build.gradle

   1 /* Convention for properties.  Read from gradle.properties, use lower_case_underlines for property names.
   2  * For properties set within build.gradle, use camelCaseNoSpace.
   3  */
   4 import org.apache.tools.ant.filters.ReplaceTokens
   5 import org.gradle.internal.os.OperatingSystem
   6 import org.gradle.plugins.ide.internal.generator.PropertiesPersistableConfigurationObject
   7 import org.gradle.api.internal.PropertiesTransformer
   8 import org.gradle.util.ConfigureUtil
   9 import org.gradle.plugins.ide.eclipse.model.Output
  10 import org.gradle.plugins.ide.eclipse.model.Library
  11 import java.security.MessageDigest
  12 import java.util.regex.Matcher
  13 import groovy.transform.ExternalizeMethods
  14 import groovy.util.XmlParser
  15 import groovy.xml.XmlUtil
  16 import groovy.json.JsonBuilder
  17 import com.vladsch.flexmark.util.ast.Node
  18 import com.vladsch.flexmark.html.HtmlRenderer
  19 import com.vladsch.flexmark.parser.Parser
  20 import com.vladsch.flexmark.util.data.MutableDataSet
  21 import com.vladsch.flexmark.ext.gfm.tasklist.TaskListExtension
  22 import com.vladsch.flexmark.ext.tables.TablesExtension
  23 import com.vladsch.flexmark.ext.gfm.strikethrough.StrikethroughExtension
  24 import com.vladsch.flexmark.ext.autolink.AutolinkExtension
  25 import com.vladsch.flexmark.ext.anchorlink.AnchorLinkExtension
  26 import com.vladsch.flexmark.ext.toc.TocExtension
  27 import com.google.common.hash.HashCode
  28 import com.google.common.hash.Hashing
  29 import com.google.common.io.Files
  30 import org.jsoup.Jsoup
  31 import org.jsoup.nodes.Element
  32
  33 buildscript {
  34   repositories {
  35     mavenCentral()
  36     mavenLocal()
  37   }
  38   dependencies {
  39     classpath "com.vladsch.flexmark:flexmark-all:0.62.0"
  40     classpath "org.jsoup:jsoup:1.14.3"
  41     classpath "com.eowise:gradle-imagemagick:0.5.1"
  42   }
  43 }
  44
  45
  46 plugins {
  47   id 'java'
  48   id 'application'
  49   id 'eclipse'
  50   id "com.diffplug.gradle.spotless" version "3.28.0"
  51   id 'com.github.johnrengelman.shadow' version '4.0.3'
  52   id 'com.install4j.gradle' version '10.0.3'
  53   id 'com.dorongold.task-tree' version '2.1.1' // only needed to display task dependency tree with  gradle task1 [task2 ...] taskTree
  54   id 'com.palantir.git-version' version '0.13.0' apply false
  55 }
  56
  57 repositories {
  58   jcenter()
  59   mavenCentral()
  60   mavenLocal()
  61 }
  62
  63
  64
  65 // in ext the values are cast to Object. Ensure string values are cast as String (and not GStringImpl) for later use
  66 def string(Object o) {
  67   return o == null ? "" : o.toString()
  68 }
  69
  70 def overrideProperties(String propsFileName, boolean output = false) {
  71   if (propsFileName == null) {
  72     return
  73   }
  74   def propsFile = file(propsFileName)
  75   if (propsFile != null && propsFile.exists()) {
  76     println("Using properties from file '${propsFileName}'")
  77     try {
  78       def p = new Properties()
  79       def localPropsFIS = new FileInputStream(propsFile)
  80       p.load(localPropsFIS)
  81       localPropsFIS.close()
  82       p.each {
  83         key, val ->
  84           def oldval
  85           if (project.hasProperty(key)) {
  86             oldval = project.findProperty(key)
  87             project.setProperty(key, val)
  88             if (output) {
  89               println("Overriding property '${key}' ('${oldval}') with ${file(propsFile).getName()} value '${val}'")
  90             }
  91           } else {
  92             ext.setProperty(key, val)
  93             if (output) {
  94               println("Setting ext property '${key}' with ${file(propsFile).getName()}s value '${val}'")
  95             }
  96           }
  97       }
  98     } catch (Exception e) {
  99       println("Exception reading local.properties")
 100       e.printStackTrace()
 101     }
 102   }
 103 }
 104
 105 ext {
 106   jalviewDirAbsolutePath = file(jalviewDir).getAbsolutePath()
 107   jalviewDirRelativePath = jalviewDir
 108   date = new Date()
 109
 110   getdownChannelName = CHANNEL.toLowerCase()
 111   // default to "default". Currently only has different cosmetics for "develop", "release", "default"
 112   propertiesChannelName = ["develop", "release", "test-release", "jalviewjs", "jalviewjs-release" ].contains(getdownChannelName) ? getdownChannelName : "default"
 113   channelDirName = propertiesChannelName
 114   // Import channel_properties
 115   if (getdownChannelName.startsWith("develop-")) {
 116     channelDirName = "develop-SUFFIX"
 117   }
 118   channelDir = string("${jalviewDir}/${channel_properties_dir}/${channelDirName}")
 119   channelGradleProperties = string("${channelDir}/channel_gradle.properties")
 120   channelPropsFile = string("${channelDir}/${resource_dir}/${channel_props}")
 121   overrideProperties(channelGradleProperties, false)
 122   // local build environment properties
 123   // can be "projectDir/local.properties"
 124   overrideProperties("${projectDir}/local.properties", true)
 125   // or "../projectDir_local.properties"
 126   overrideProperties(projectDir.getParent() + "/" + projectDir.getName() + "_local.properties", true)
 127
 128   ////
 129   // Import releaseProps from the RELEASE file
 130   // or a file specified via JALVIEW_RELEASE_FILE if defined
 131   // Expect jalview.version and target release branch in jalview.release
 132   releaseProps = new Properties();
 133   def releasePropFile = findProperty("JALVIEW_RELEASE_FILE");
 134   def defaultReleasePropFile = "${jalviewDirAbsolutePath}/RELEASE";
 135   try {
 136     (new File(releasePropFile!=null ? releasePropFile : defaultReleasePropFile)).withInputStream {
 137      releaseProps.load(it)
 138     }
 139   } catch (Exception fileLoadError) {
 140     throw new Error("Couldn't load release properties file "+(releasePropFile==null ? defaultReleasePropFile : "from custom location: releasePropFile"),fileLoadError);
 141   }
 142   ////
 143   // Set JALVIEW_VERSION if it is not already set
 144   if (findProperty("JALVIEW_VERSION")==null || "".equals(JALVIEW_VERSION)) {
 145     JALVIEW_VERSION = releaseProps.get("jalview.version")
 146   }
 147   println("JALVIEW_VERSION is set to '${JALVIEW_VERSION}'")
 148
 149   // this property set when running Eclipse headlessly
 150   j2sHeadlessBuildProperty = string("net.sf.j2s.core.headlessbuild")
 151   // this property set by Eclipse
 152   eclipseApplicationProperty = string("eclipse.application")
 153   // CHECK IF RUNNING FROM WITHIN ECLIPSE
 154   def eclipseApplicationPropertyVal = System.properties[eclipseApplicationProperty]
 155   IN_ECLIPSE = eclipseApplicationPropertyVal != null && eclipseApplicationPropertyVal.startsWith("org.eclipse.ui.")
 156   // BUT WITHOUT THE HEADLESS BUILD PROPERTY SET
 157   if (System.properties[j2sHeadlessBuildProperty].equals("true")) {
 158     println("Setting IN_ECLIPSE to ${IN_ECLIPSE} as System.properties['${j2sHeadlessBuildProperty}'] == '${System.properties[j2sHeadlessBuildProperty]}'")
 159     IN_ECLIPSE = false
 160   }
 161   if (IN_ECLIPSE) {
 162     println("WITHIN ECLIPSE IDE")
 163   } else {
 164     println("HEADLESS BUILD")
 165   }
 166
 167   J2S_ENABLED = (project.hasProperty('j2s.compiler.status') && project['j2s.compiler.status'] != null && project['j2s.compiler.status'] == "enable")
 168   if (J2S_ENABLED) {
 169     println("J2S ENABLED")
 170   }
 171   /* *-/
 172   System.properties.sort { it.key }.each {
 173     key, val -> println("SYSTEM PROPERTY ${key}='${val}'")
 174   }
 175   /-* *-/
 176   if (false && IN_ECLIPSE) {
 177     jalviewDir = jalviewDirAbsolutePath
 178   }
 179   */
 180
 181   // datestamp
 182   buildDate = new Date().format("yyyyMMdd")
 183
 184   // essentials
 185   bareSourceDir = string(source_dir)
 186   sourceDir = string("${jalviewDir}/${bareSourceDir}")
 187   resourceDir = string("${jalviewDir}/${resource_dir}")
 188   bareTestSourceDir = string(test_source_dir)
 189   testDir = string("${jalviewDir}/${bareTestSourceDir}")
 190
 191   classesDir = string("${jalviewDir}/${classes_dir}")
 192
 193   // clover
 194   useClover = clover.equals("true")
 195   cloverBuildDir = "${buildDir}/clover"
 196   cloverInstrDir = file("${cloverBuildDir}/clover-instr")
 197   cloverClassesDir = file("${cloverBuildDir}/clover-classes")
 198   cloverReportDir = file("${buildDir}/reports/clover")
 199   cloverTestInstrDir = file("${cloverBuildDir}/clover-test-instr")
 200   cloverTestClassesDir = file("${cloverBuildDir}/clover-test-classes")
 201   //cloverTestClassesDir = cloverClassesDir
 202   cloverDb = string("${cloverBuildDir}/clover.db")
 203
 204   testSourceDir = useClover ? cloverTestInstrDir : testDir
 205   testClassesDir = useClover ? cloverTestClassesDir : "${jalviewDir}/${test_output_dir}"
 206
 207   channelSuffix = ""
 208   backgroundImageText = BACKGROUNDIMAGETEXT
 209   getdownChannelDir = string("${getdown_website_dir}/${propertiesChannelName}")
 210   getdownAppBaseDir = string("${jalviewDir}/${getdownChannelDir}/${JAVA_VERSION}")
 211   getdownArchiveDir = string("${jalviewDir}/${getdown_archive_dir}")
 212   getdownFullArchiveDir = null
 213   getdownTextLines = []
 214   getdownLaunchJvl = null
 215   getdownVersionLaunchJvl = null
 216   buildDist = true
 217   buildProperties = null
 218
 219   // the following values might be overridden by the CHANNEL switch
 220   getdownDir = string("${getdownChannelName}/${JAVA_VERSION}")
 221   getdownAppBase = string("${getdown_channel_base}/${getdownDir}")
 222   getdownArchiveAppBase = getdown_archive_base
 223   getdownLauncher = string("${jalviewDir}/${getdown_lib_dir}/${getdown_launcher}")
 224   getdownAppDistDir = getdown_app_dir_alt
 225   getdownImagesDir = string("${jalviewDir}/${getdown_images_dir}")
 226   getdownImagesBuildDir = string("${buildDir}/imagemagick/getdown")
 227   getdownSetAppBaseProperty = false // whether to pass the appbase and appdistdir to the application
 228   reportRsyncCommand = false
 229   jvlChannelName = CHANNEL.toLowerCase()
 230   install4jSuffix = CHANNEL.substring(0, 1).toUpperCase() + CHANNEL.substring(1).toLowerCase(); // BUILD -> Build
 231   install4jDMGDSStore = "${install4j_images_dir}/${install4j_dmg_ds_store}"
 232   install4jDMGBackgroundImageDir = "${install4j_images_dir}"
 233   install4jDMGBackgroundImageBuildDir = "build/imagemagick/install4j"
 234   install4jDMGBackgroundImageFile = "${install4j_dmg_background}"
 235   install4jInstallerName = "${jalview_name} Non-Release Installer"
 236   install4jExecutableName = install4j_executable_name
 237   install4jExtraScheme = "jalviewx"
 238   install4jMacIconsFile = string("${install4j_images_dir}/${install4j_mac_icons_file}")
 239   install4jWindowsIconsFile = string("${install4j_images_dir}/${install4j_windows_icons_file}")
 240   install4jPngIconFile = string("${install4j_images_dir}/${install4j_png_icon_file}")
 241   install4jBackground = string("${install4j_images_dir}/${install4j_background}")
 242   install4jBuildDir = "${install4j_build_dir}/${JAVA_VERSION}"
 243   install4jCheckSums = true
 244
 245   applicationName = "${jalview_name}"
 246   switch (CHANNEL) {
 247
 248     case "BUILD":
 249     // TODO: get bamboo build artifact URL for getdown artifacts
 250     getdown_channel_base = bamboo_channelbase
 251     getdownChannelName = string("${bamboo_planKey}/${JAVA_VERSION}")
 252     getdownAppBase = string("${bamboo_channelbase}/${bamboo_planKey}${bamboo_getdown_channel_suffix}/${JAVA_VERSION}")
 253     jvlChannelName += "_${getdownChannelName}"
 254     // automatically add the test group Not-bamboo for exclusion
 255     if ("".equals(testng_excluded_groups)) {
 256       testng_excluded_groups = "Not-bamboo"
 257     }
 258     install4jExtraScheme = "jalviewb"
 259     backgroundImageText = true
 260     break
 261
 262     case [ "RELEASE", "JALVIEWJS-RELEASE" ]:
 263     getdownAppDistDir = getdown_app_dir_release
 264     getdownSetAppBaseProperty = true
 265     reportRsyncCommand = true
 266     install4jSuffix = ""
 267     install4jInstallerName = "${jalview_name} Installer"
 268     break
 269
 270     case "ARCHIVE":
 271     getdownChannelName = CHANNEL.toLowerCase()+"/${JALVIEW_VERSION}"
 272     getdownDir = string("${getdownChannelName}/${JAVA_VERSION}")
 273     getdownAppBase = string("${getdown_channel_base}/${getdownDir}")
 274     if (!file("${ARCHIVEDIR}/${package_dir}").exists()) {
 275       throw new GradleException("Must provide an ARCHIVEDIR value to produce an archive distribution")
 276     } else {
 277       package_dir = string("${ARCHIVEDIR}/${package_dir}")
 278       buildProperties = string("${ARCHIVEDIR}/${classes_dir}/${build_properties_file}")
 279       buildDist = false
 280     }
 281     reportRsyncCommand = true
 282     install4jExtraScheme = "jalviewa"
 283     break
 284
 285     case "ARCHIVELOCAL":
 286     getdownChannelName = string("archive/${JALVIEW_VERSION}")
 287     getdownDir = string("${getdownChannelName}/${JAVA_VERSION}")
 288     getdownAppBase = file(getdownAppBaseDir).toURI().toString()
 289     if (!file("${ARCHIVEDIR}/${package_dir}").exists()) {
 290       throw new GradleException("Must provide an ARCHIVEDIR value to produce an archive distribution [did not find '${ARCHIVEDIR}/${package_dir}']")
 291     } else {
 292       package_dir = string("${ARCHIVEDIR}/${package_dir}")
 293       buildProperties = string("${ARCHIVEDIR}/${classes_dir}/${build_properties_file}")
 294       buildDist = false
 295     }
 296     reportRsyncCommand = true
 297     getdownLauncher = string("${jalviewDir}/${getdown_lib_dir}/${getdown_launcher_local}")
 298     install4jSuffix = "Archive"
 299     install4jExtraScheme = "jalviewa"
 300     break
 301
 302     case ~/^DEVELOP-([\.\-\w]*)$/:
 303     def suffix = Matcher.lastMatcher[0][1]
 304     reportRsyncCommand = true
 305     getdownSetAppBaseProperty = true
 306     JALVIEW_VERSION=JALVIEW_VERSION+"-d${suffix}-${buildDate}"
 307     install4jSuffix = "Develop ${suffix}"
 308     install4jExtraScheme = "jalviewd"
 309     install4jInstallerName = "${jalview_name} Develop ${suffix} Installer"
 310     getdownChannelName = string("develop-${suffix}")
 311     getdownChannelDir = string("${getdown_website_dir}/${getdownChannelName}")
 312     getdownAppBaseDir = string("${jalviewDir}/${getdownChannelDir}/${JAVA_VERSION}")
 313     getdownDir = string("${getdownChannelName}/${JAVA_VERSION}")
 314     getdownAppBase = string("${getdown_channel_base}/${getdownDir}")
 315     channelSuffix = string(suffix)
 316     backgroundImageText = true
 317     break
 318
 319     case "DEVELOP":
 320     reportRsyncCommand = true
 321     getdownSetAppBaseProperty = true
 322     // DEVELOP-RELEASE is usually associated with a Jalview release series so set the version
 323     JALVIEW_VERSION=JALVIEW_VERSION+"-d${buildDate}"
 324
 325     install4jSuffix = "Develop"
 326     install4jExtraScheme = "jalviewd"
 327     install4jInstallerName = "${jalview_name} Develop Installer"
 328     backgroundImageText = true
 329     break
 330
 331     case "TEST-RELEASE":
 332     reportRsyncCommand = true
 333     getdownSetAppBaseProperty = true
 334     // Don't ignore transpile errors for release build
 335     if (jalviewjs_ignore_transpile_errors.equals("true")) {
 336       jalviewjs_ignore_transpile_errors = "false"
 337       println("Setting jalviewjs_ignore_transpile_errors to 'false'")
 338     }
 339     JALVIEW_VERSION = JALVIEW_VERSION+"-test"
 340     install4jSuffix = "Test"
 341     install4jExtraScheme = "jalviewt"
 342     install4jInstallerName = "${jalview_name} Test Installer"
 343     backgroundImageText = true
 344     break
 345
 346     case ~/^SCRATCH(|-[-\w]*)$/:
 347     getdownChannelName = CHANNEL
 348     JALVIEW_VERSION = JALVIEW_VERSION+"-"+CHANNEL
 349
 350     getdownDir = string("${getdownChannelName}/${JAVA_VERSION}")
 351     getdownAppBase = string("${getdown_channel_base}/${getdownDir}")
 352     reportRsyncCommand = true
 353     install4jSuffix = "Scratch"
 354     break
 355
 356     case "TEST-LOCAL":
 357     if (!file("${LOCALDIR}").exists()) {
 358       throw new GradleException("Must provide a LOCALDIR value to produce a local distribution")
 359     } else {
 360       getdownAppBase = file(file("${LOCALDIR}").getAbsolutePath()).toURI().toString()
 361       getdownLauncher = string("${jalviewDir}/${getdown_lib_dir}/${getdown_launcher_local}")
 362     }
 363     JALVIEW_VERSION = "TEST"
 364     install4jSuffix = "Test-Local"
 365     install4jExtraScheme = "jalviewt"
 366     install4jInstallerName = "${jalview_name} Test Installer"
 367     backgroundImageText = true
 368     break
 369
 370     case [ "LOCAL", "JALVIEWJS" ]:
 371     JALVIEW_VERSION = "TEST"
 372     getdownAppBase = file(getdownAppBaseDir).toURI().toString()
 373     getdownArchiveAppBase = file("${jalviewDir}/${getdown_archive_dir}").toURI().toString()
 374     getdownLauncher = string("${jalviewDir}/${getdown_lib_dir}/${getdown_launcher_local}")
 375     install4jExtraScheme = "jalviewl"
 376     install4jCheckSums = false
 377     break
 378
 379     default: // something wrong specified
 380     throw new GradleException("CHANNEL must be one of BUILD, RELEASE, ARCHIVE, DEVELOP, TEST-RELEASE, SCRATCH-..., LOCAL [default]")
 381     break
 382
 383   }
 384   JALVIEW_VERSION_UNDERSCORES = JALVIEW_VERSION.replaceAll("\\.", "_")
 385   hugoDataJsonFile = file("${jalviewDir}/${hugo_build_dir}/${hugo_data_installers_dir}/installers-${JALVIEW_VERSION_UNDERSCORES}.json")
 386   hugoArchiveMdFile = file("${jalviewDir}/${hugo_build_dir}/${hugo_version_archive_dir}/Version-${JALVIEW_VERSION_UNDERSCORES}/_index.md")
 387   // override getdownAppBase if requested
 388   if (findProperty("getdown_appbase_override") != null) {
 389     // revert to LOCAL if empty string
 390     if (string(getdown_appbase_override) == "") {
 391       getdownAppBase = file(getdownAppBaseDir).toURI().toString()
 392       getdownLauncher = string("${jalviewDir}/${getdown_lib_dir}/${getdown_launcher_local}")
 393     } else if (string(getdown_appbase_override).startsWith("file://")) {
 394       getdownAppBase = string(getdown_appbase_override)
 395       getdownLauncher = string("${jalviewDir}/${getdown_lib_dir}/${getdown_launcher_local}")
 396     } else {
 397       getdownAppBase = string(getdown_appbase_override)
 398     }
 399     println("Overriding getdown appbase with '${getdownAppBase}'")
 400   }
 401   // sanitise file name for jalview launcher file for this channel
 402   jvlChannelName = jvlChannelName.replaceAll("[^\\w\\-]+", "_")
 403   // install4j application and folder names
 404   if (install4jSuffix == "") {
 405     install4jBundleId = "${install4j_bundle_id}"
 406     install4jWinApplicationId = install4j_release_win_application_id
 407   } else {
 408     applicationName = "${jalview_name} ${install4jSuffix}"
 409     install4jBundleId = "${install4j_bundle_id}-" + install4jSuffix.toLowerCase()
 410     // add int hash of install4jSuffix to the last part of the application_id
 411     def id = install4j_release_win_application_id
 412     def idsplitreverse = id.split("-").reverse()
 413     idsplitreverse[0] = idsplitreverse[0].toInteger() + install4jSuffix.hashCode()
 414     install4jWinApplicationId = idsplitreverse.reverse().join("-")
 415   }
 416   // sanitise folder and id names
 417   // install4jApplicationFolder = e.g. "Jalview Build"
 418   install4jApplicationFolder = applicationName
 419                                     .replaceAll("[\"'~:/\\\\\\s]", "_") // replace all awkward filename chars " ' ~ : / \
 420                                     .replaceAll("_+", "_") // collapse __
 421   install4jInternalId = applicationName
 422                                     .replaceAll(" ","_")
 423                                     .replaceAll("[^\\w\\-\\.]", "_") // replace other non [alphanumeric,_,-,.]
 424                                     .replaceAll("_+", "") // collapse __
 425                                     //.replaceAll("_*-_*", "-") // collapse _-_
 426   install4jUnixApplicationFolder = applicationName
 427                                     .replaceAll(" ","_")
 428                                     .replaceAll("[^\\w\\-\\.]", "_") // replace other non [alphanumeric,_,-,.]
 429                                     .replaceAll("_+", "_") // collapse __
 430                                     .replaceAll("_*-_*", "-") // collapse _-_
 431                                     .toLowerCase()
 432
 433   getdownWrapperLink = install4jUnixApplicationFolder // e.g. "jalview_local"
 434   getdownAppDir = string("${getdownAppBaseDir}/${getdownAppDistDir}")
 435   //getdownJ11libDir = "${getdownAppBaseDir}/${getdown_j11lib_dir}"
 436   getdownResourceDir = string("${getdownAppBaseDir}/${getdown_resource_dir}")
 437   getdownInstallDir = string("${getdownAppBaseDir}/${getdown_install_dir}")
 438   getdownFilesDir = string("${jalviewDir}/${getdown_files_dir}/${JAVA_VERSION}/")
 439   getdownFilesInstallDir = string("${getdownFilesDir}/${getdown_install_dir}")
 440   /* compile without modules -- using classpath libraries
 441   modules_compileClasspath = fileTree(dir: "${jalviewDir}/${j11modDir}", include: ["*.jar"])
 442   modules_runtimeClasspath = modules_compileClasspath
 443   */
 444
 445   gitHash = "SOURCE"
 446   gitBranch = "Source"
 447   try {
 448     apply plugin: "com.palantir.git-version"
 449     def details = versionDetails()
 450     gitHash = details.gitHash
 451     gitBranch = details.branchName
 452   } catch(org.gradle.api.internal.plugins.PluginApplicationException e) {
 453     println("Not in a git repository. Using git values from RELEASE properties file.")
 454     gitHash = releaseProps.getProperty("git.hash")
 455     gitBranch = releaseProps.getProperty("git.branch")
 456   } catch(java.lang.RuntimeException e1) {
 457     throw new GradleException("Error with git-version plugin.  Directory '.git' exists but versionDetails() cannot be found.")
 458   }
 459
 460   println("Using a ${CHANNEL} profile.")
 461
 462   additional_compiler_args = []
 463   // configure classpath/args for j8/j11 compilation
 464   if (JAVA_VERSION.equals("1.8")) {
 465     JAVA_INTEGER_VERSION = string("8")
 466     //libDir = j8libDir
 467     libDir = j11libDir
 468     libDistDir = j8libDir
 469     compile_source_compatibility = 1.8
 470     compile_target_compatibility = 1.8
 471     // these are getdown.txt properties defined dependent on the JAVA_VERSION
 472     getdownAltJavaMinVersion = string(findProperty("getdown_alt_java8_min_version"))
 473     getdownAltJavaMaxVersion = string(findProperty("getdown_alt_java8_max_version"))
 474     // this property is assigned below and expanded to multiple lines in the getdown task
 475     getdownAltMultiJavaLocation = string(findProperty("getdown_alt_java8_txt_multi_java_location"))
 476     // this property is for the Java library used in eclipse
 477     eclipseJavaRuntimeName = string("JavaSE-1.8")
 478   } else if (JAVA_VERSION.equals("11")) {
 479     JAVA_INTEGER_VERSION = string("11")
 480     libDir = j11libDir
 481     libDistDir = j11libDir
 482     compile_source_compatibility = 11
 483     compile_target_compatibility = 11
 484     getdownAltJavaMinVersion = string(findProperty("getdown_alt_java11_min_version"))
 485     getdownAltJavaMaxVersion = string(findProperty("getdown_alt_java11_max_version"))
 486     getdownAltMultiJavaLocation = string(findProperty("getdown_alt_java11_txt_multi_java_location"))
 487     eclipseJavaRuntimeName = string("JavaSE-11")
 488     /* compile without modules -- using classpath libraries
 489     additional_compiler_args += [
 490     '--module-path', modules_compileClasspath.asPath,
 491     '--add-modules', j11modules
 492     ]
 493      */
 494   } else if (JAVA_VERSION.equals("17")) {
 495     JAVA_INTEGER_VERSION = string("17")
 496     libDir = j17libDir
 497     libDistDir = j17libDir
 498     compile_source_compatibility = 17
 499     compile_target_compatibility = 17
 500     getdownAltJavaMinVersion = string(findProperty("getdown_alt_java11_min_version"))
 501     getdownAltJavaMaxVersion = string(findProperty("getdown_alt_java11_max_version"))
 502     getdownAltMultiJavaLocation = string(findProperty("getdown_alt_java11_txt_multi_java_location"))
 503     eclipseJavaRuntimeName = string("JavaSE-17")
 504     /* compile without modules -- using classpath libraries
 505     additional_compiler_args += [
 506     '--module-path', modules_compileClasspath.asPath,
 507     '--add-modules', j11modules
 508     ]
 509      */
 510   } else {
 511     throw new GradleException("JAVA_VERSION=${JAVA_VERSION} not currently supported by Jalview")
 512   }
 513
 514
 515   // for install4j
 516   JAVA_MIN_VERSION = JAVA_VERSION
 517   JAVA_MAX_VERSION = JAVA_VERSION
 518   jreInstallsDir = string(jre_installs_dir)
 519   if (jreInstallsDir.startsWith("~/")) {
 520     jreInstallsDir = System.getProperty("user.home") + jreInstallsDir.substring(1)
 521   }
 522   install4jDir = string("${jalviewDir}/${install4j_utils_dir}")
 523   install4jConfFileName = string("jalview-install4j-conf.install4j")
 524   install4jConfFile = file("${install4jDir}/${install4jConfFileName}")
 525   install4jHomeDir = install4j_home_dir
 526   if (install4jHomeDir.startsWith("~/")) {
 527     install4jHomeDir = System.getProperty("user.home") + install4jHomeDir.substring(1)
 528   }
 529
 530   resourceBuildDir = string("${buildDir}/resources")
 531   resourcesBuildDir = string("${resourceBuildDir}/resources_build")
 532   helpBuildDir = string("${resourceBuildDir}/help_build")
 533   docBuildDir = string("${resourceBuildDir}/doc_build")
 534
 535   if (buildProperties == null) {
 536     buildProperties = string("${resourcesBuildDir}/${build_properties_file}")
 537   }
 538   buildingHTML = string("${jalviewDir}/${doc_dir}/building.html")
 539   helpParentDir = string("${jalviewDir}/${help_parent_dir}")
 540   helpSourceDir = string("${helpParentDir}/${help_dir}")
 541   helpFile = string("${helpBuildDir}/${help_dir}/help.jhm")
 542
 543   convertBinary = null
 544   convertBinaryExpectedLocation = imagemagick_convert
 545   if (convertBinaryExpectedLocation.startsWith("~/")) {
 546     convertBinaryExpectedLocation = System.getProperty("user.home") + convertBinaryExpectedLocation.substring(1)
 547   }
 548   if (file(convertBinaryExpectedLocation).exists()) {
 549     convertBinary = convertBinaryExpectedLocation
 550   }
 551
 552   relativeBuildDir = file(jalviewDirAbsolutePath).toPath().relativize(buildDir.toPath())
 553   jalviewjsBuildDir = string("${relativeBuildDir}/jalviewjs")
 554   jalviewjsSiteDir = string("${jalviewjsBuildDir}/${jalviewjs_site_dir}")
 555   if (IN_ECLIPSE) {
 556     jalviewjsTransferSiteJsDir = string(jalviewjsSiteDir)
 557   } else {
 558     jalviewjsTransferSiteJsDir = string("${jalviewjsBuildDir}/tmp/${jalviewjs_site_dir}_js")
 559   }
 560   jalviewjsTransferSiteLibDir = string("${jalviewjsBuildDir}/tmp/${jalviewjs_site_dir}_lib")
 561   jalviewjsTransferSiteSwingJsDir = string("${jalviewjsBuildDir}/tmp/${jalviewjs_site_dir}_swingjs")
 562   jalviewjsTransferSiteCoreDir = string("${jalviewjsBuildDir}/tmp/${jalviewjs_site_dir}_core")
 563   jalviewjsJalviewCoreHtmlFile = string("")
 564   jalviewjsJalviewCoreName = string(jalviewjs_core_name)
 565   jalviewjsCoreClasslists = []
 566   jalviewjsJalviewTemplateName = string(jalviewjs_name)
 567   jalviewjsJ2sSettingsFileName = string("${jalviewDir}/${jalviewjs_j2s_settings}")
 568   jalviewjsJ2sAltSettingsFileName = string("${jalviewDir}/${jalviewjs_j2s_alt_settings}")
 569   jalviewjsJ2sProps = null
 570   jalviewjsJ2sPlugin = jalviewjs_j2s_plugin
 571
 572   eclipseWorkspace = null
 573   eclipseBinary = string("")
 574   eclipseVersion = string("")
 575   eclipseDebug = false
 576   // ENDEXT
 577 }
 578
 579
 580 sourceSets {
 581   main {
 582     java {
 583       srcDirs sourceDir
 584       outputDir = file(classesDir)
 585     }
 586
 587     resources {
 588       srcDirs = [ resourcesBuildDir, docBuildDir, helpBuildDir ]
 589     }
 590
 591     compileClasspath = files(sourceSets.main.java.outputDir)
 592     compileClasspath += fileTree(dir: "${jalviewDir}/${libDir}", include: ["*.jar"])
 593
 594     runtimeClasspath = compileClasspath
 595     runtimeClasspath += files(sourceSets.main.resources.srcDirs)
 596   }
 597
 598   clover {
 599     java {
 600       srcDirs cloverInstrDir
 601       outputDir = cloverClassesDir
 602     }
 603
 604     resources {
 605       srcDirs = sourceSets.main.resources.srcDirs
 606     }
 607
 608     compileClasspath = files( sourceSets.clover.java.outputDir )
 609     //compileClasspath += files( testClassesDir )
 610     compileClasspath += fileTree(dir: "${jalviewDir}/${libDir}", include: ["*.jar"])
 611     compileClasspath += fileTree(dir: "${jalviewDir}/${clover_lib_dir}", include: ["*.jar"])
 612     compileClasspath += fileTree(dir: "${jalviewDir}/${utils_dir}/testnglibs", include: ["**/*.jar"])
 613
 614     runtimeClasspath = compileClasspath
 615   }
 616
 617   test {
 618     java {
 619       srcDirs testSourceDir
 620       outputDir = file(testClassesDir)
 621     }
 622
 623     resources {
 624       srcDirs = useClover ? sourceSets.clover.resources.srcDirs : sourceSets.main.resources.srcDirs
 625     }
 626
 627     compileClasspath = files( sourceSets.test.java.outputDir )
 628     compileClasspath += useClover ? sourceSets.clover.compileClasspath : sourceSets.main.compileClasspath
 629     compileClasspath += fileTree(dir: "${jalviewDir}/${utils_dir}/testnglibs", include: ["**/*.jar"])
 630
 631     runtimeClasspath = compileClasspath
 632     runtimeClasspath += files(sourceSets.test.resources.srcDirs)
 633   }
 634
 635 }
 636
 637
 638 // eclipse project and settings files creation, also used by buildship
 639 eclipse {
 640   project {
 641     name = eclipse_project_name
 642
 643     natures 'org.eclipse.jdt.core.javanature',
 644     'org.eclipse.jdt.groovy.core.groovyNature',
 645     'org.eclipse.buildship.core.gradleprojectnature'
 646
 647     buildCommand 'org.eclipse.jdt.core.javabuilder'
 648     buildCommand 'org.eclipse.buildship.core.gradleprojectbuilder'
 649   }
 650
 651   classpath {
 652     //defaultOutputDir = sourceSets.main.java.outputDir
 653     configurations.each{ c->
 654       if (c.isCanBeResolved()) {
 655         minusConfigurations += [c]
 656       }
 657     }
 658
 659     plusConfigurations = [ ]
 660     file {
 661
 662       whenMerged { cp ->
 663         def removeTheseToo = []
 664         HashMap<String, Boolean> alreadyAddedSrcPath = new HashMap<>();
 665         cp.entries.each { entry ->
 666           // This conditional removes all src classpathentries that a) have already been added or b) aren't "src" or "test".
 667           // e.g. this removes the resources dir being copied into bin/main, bin/test AND bin/clover
 668           // we add the resources and help/help dirs in as libs afterwards (see below)
 669           if (entry.kind == 'src') {
 670             if (alreadyAddedSrcPath.getAt(entry.path) || !(entry.path == bareSourceDir || entry.path == bareTestSourceDir)) {
 671               removeTheseToo += entry
 672             } else {
 673               alreadyAddedSrcPath.putAt(entry.path, true)
 674             }
 675           }
 676
 677         }
 678         cp.entries.removeAll(removeTheseToo)
 679
 680         //cp.entries += new Output("${eclipse_bin_dir}/main")
 681         if (file(helpParentDir).isDirectory()) {
 682           cp.entries += new Library(fileReference(helpParentDir))
 683         }
 684         if (file(resourceDir).isDirectory()) {
 685           cp.entries += new Library(fileReference(resourceDir))
 686         }
 687
 688         HashMap<String, Boolean> alreadyAddedLibPath = new HashMap<>();
 689
 690         sourceSets.main.compileClasspath.findAll { it.name.endsWith(".jar") }.any {
 691           //don't want to add outputDir as eclipse is using its own output dir in bin/main
 692           if (it.isDirectory() || ! it.exists()) {
 693             // don't add dirs to classpath, especially if they don't exist
 694             return false // groovy "continue" in .any closure
 695           }
 696           def itPath = it.toString()
 697           if (itPath.startsWith("${jalviewDirAbsolutePath}/")) {
 698             // make relative path
 699             itPath = itPath.substring(jalviewDirAbsolutePath.length()+1)
 700           }
 701           if (alreadyAddedLibPath.get(itPath)) {
 702             //println("Not adding duplicate entry "+itPath)
 703           } else {
 704             //println("Adding entry "+itPath)
 705             cp.entries += new Library(fileReference(itPath))
 706             alreadyAddedLibPath.put(itPath, true)
 707           }
 708         }
 709
 710         sourceSets.test.compileClasspath.findAll { it.name.endsWith(".jar") }.any {
 711           //no longer want to add outputDir as eclipse is using its own output dir in bin/main
 712           if (it.isDirectory() || ! it.exists()) {
 713             // don't add dirs to classpath
 714             return false // groovy "continue" in .any closure
 715           }
 716
 717           def itPath = it.toString()
 718           if (itPath.startsWith("${jalviewDirAbsolutePath}/")) {
 719             itPath = itPath.substring(jalviewDirAbsolutePath.length()+1)
 720           }
 721           if (alreadyAddedLibPath.get(itPath)) {
 722             // don't duplicate
 723           } else {
 724             def lib = new Library(fileReference(itPath))
 725             lib.entryAttributes["test"] = "true"
 726             cp.entries += lib
 727             alreadyAddedLibPath.put(itPath, true)
 728           }
 729         }
 730
 731       } // whenMerged
 732
 733     } // file
 734
 735     containers 'org.eclipse.buildship.core.gradleclasspathcontainer'
 736
 737   } // classpath
 738
 739   jdt {
 740     // for the IDE, use java 11 compatibility
 741     sourceCompatibility = compile_source_compatibility
 742     targetCompatibility = compile_target_compatibility
 743     javaRuntimeName = eclipseJavaRuntimeName
 744
 745     // add in jalview project specific properties/preferences into eclipse core preferences
 746     file {
 747       withProperties { props ->
 748         def jalview_prefs = new Properties()
 749         def ins = new FileInputStream("${jalviewDirAbsolutePath}/${eclipse_extra_jdt_prefs_file}")
 750         jalview_prefs.load(ins)
 751         ins.close()
 752         jalview_prefs.forEach { t, v ->
 753           if (props.getAt(t) == null) {
 754             props.putAt(t, v)
 755           }
 756         }
 757         // codestyle file -- overrides previous formatter prefs
 758         def csFile = file("${jalviewDirAbsolutePath}/${eclipse_codestyle_file}")
 759         if (csFile.exists()) {
 760           XmlParser parser = new XmlParser()
 761           def profiles = parser.parse(csFile)
 762           def profile = profiles.'profile'.find { p -> (p.'@kind' == "CodeFormatterProfile" && p.'@name' == "Jalview") }
 763           if (profile != null) {
 764             profile.'setting'.each { s ->
 765               def id = s.'@id'
 766               def value = s.'@value'
 767               if (id != null && value != null) {
 768                 props.putAt(id, value)
 769               }
 770             }
 771           }
 772         }
 773       }
 774     }
 775
 776   } // jdt
 777
 778   if (IN_ECLIPSE) {
 779     // Don't want these to be activated if in headless build
 780     synchronizationTasks "eclipseSynchronizationTask"
 781     //autoBuildTasks "eclipseAutoBuildTask"
 782
 783   }
 784 }
 785
 786
 787 /* hack to change eclipse prefs in .settings files other than org.eclipse.jdt.core.prefs */
 788 // Class to allow updating arbitrary properties files
 789 class PropertiesFile extends PropertiesPersistableConfigurationObject {
 790   public PropertiesFile(PropertiesTransformer t) { super(t); }
 791   @Override protected void load(Properties properties) { }
 792   @Override protected void store(Properties properties) { }
 793   @Override protected String getDefaultResourceName() { return ""; }
 794   // This is necessary, because PropertiesPersistableConfigurationObject fails
 795   // if no default properties file exists.
 796   @Override public void loadDefaults() { load(new StringBufferInputStream("")); }
 797 }
 798
 799 // Task to update arbitrary properties files (set outputFile)
 800 class PropertiesFileTask extends PropertiesGeneratorTask<PropertiesFile> {
 801   private final PropertiesFileContentMerger file;
 802   public PropertiesFileTask() { file = new PropertiesFileContentMerger(getTransformer()); }
 803   protected PropertiesFile create() { return new PropertiesFile(getTransformer()); }
 804   protected void configure(PropertiesFile props) {
 805     file.getBeforeMerged().execute(props); file.getWhenMerged().execute(props);
 806   }
 807   public void file(Closure closure) { ConfigureUtil.configure(closure, file); }
 808 }
 809
 810 task eclipseUIPreferences(type: PropertiesFileTask) {
 811   description = "Generate Eclipse additional settings"
 812   def filename = "org.eclipse.jdt.ui.prefs"
 813   outputFile = "$projectDir/.settings/${filename}" as File
 814   file {
 815     withProperties {
 816       it.load new FileInputStream("$projectDir/utils/eclipse/${filename}" as String)
 817     }
 818   }
 819 }
 820
 821 task eclipseGroovyCorePreferences(type: PropertiesFileTask) {
 822   description = "Generate Eclipse additional settings"
 823   def filename = "org.eclipse.jdt.groovy.core.prefs"
 824   outputFile = "$projectDir/.settings/${filename}" as File
 825   file {
 826     withProperties {
 827       it.load new FileInputStream("$projectDir/utils/eclipse/${filename}" as String)
 828     }
 829   }
 830 }
 831
 832 task eclipseAllPreferences {
 833   dependsOn eclipseJdt
 834   dependsOn eclipseUIPreferences
 835   dependsOn eclipseGroovyCorePreferences
 836 }
 837
 838 eclipseUIPreferences.mustRunAfter eclipseJdt
 839 eclipseGroovyCorePreferences.mustRunAfter eclipseJdt
 840
 841 /* end of eclipse preferences hack */
 842
 843
 844 // clover bits
 845
 846
 847 task cleanClover {
 848   doFirst {
 849     delete cloverBuildDir
 850     delete cloverReportDir
 851   }
 852 }
 853
 854
 855 task cloverInstrJava(type: JavaExec) {
 856   group = "Verification"
 857   description = "Create clover instrumented source java files"
 858
 859   dependsOn cleanClover
 860
 861   inputs.files(sourceSets.main.allJava)
 862   outputs.dir(cloverInstrDir)
 863
 864   //classpath = fileTree(dir: "${jalviewDir}/${clover_lib_dir}", include: ["*.jar"])
 865   classpath = sourceSets.clover.compileClasspath
 866   main = "com.atlassian.clover.CloverInstr"
 867
 868   def argsList = [
 869     "--encoding",
 870     "UTF-8",
 871     "--initstring",
 872     cloverDb,
 873     "--destdir",
 874     cloverInstrDir.getPath(),
 875   ]
 876   def srcFiles = sourceSets.main.allJava.files
 877   argsList.addAll(
 878     srcFiles.collect(
 879       { file -> file.absolutePath }
 880     )
 881   )
 882   args argsList.toArray()
 883
 884   doFirst {
 885     delete cloverInstrDir
 886     println("Clover: About to instrument "+srcFiles.size() +" files")
 887   }
 888 }
 889
 890
 891 task cloverInstrTests(type: JavaExec) {
 892   group = "Verification"
 893   description = "Create clover instrumented source test files"
 894
 895   dependsOn cleanClover
 896
 897   inputs.files(testDir)
 898   outputs.dir(cloverTestInstrDir)
 899
 900   classpath = sourceSets.clover.compileClasspath
 901   main = "com.atlassian.clover.CloverInstr"
 902
 903   def argsList = [
 904     "--encoding",
 905     "UTF-8",
 906     "--initstring",
 907     cloverDb,
 908     "--srcdir",
 909     testDir,
 910     "--destdir",
 911     cloverTestInstrDir.getPath(),
 912   ]
 913   args argsList.toArray()
 914
 915   doFirst {
 916     delete cloverTestInstrDir
 917     println("Clover: About to instrument test files")
 918   }
 919 }
 920
 921
 922 task cloverInstr {
 923   group = "Verification"
 924   description = "Create clover instrumented all source files"
 925
 926   dependsOn cloverInstrJava
 927   dependsOn cloverInstrTests
 928 }
 929
 930
 931 cloverClasses.dependsOn cloverInstr
 932
 933
 934 task cloverConsoleReport(type: JavaExec) {
 935   group = "Verification"
 936   description = "Creates clover console report"
 937
 938   onlyIf {
 939     file(cloverDb).exists()
 940   }
 941
 942   inputs.dir cloverClassesDir
 943
 944   classpath = sourceSets.clover.runtimeClasspath
 945   main = "com.atlassian.clover.reporters.console.ConsoleReporter"
 946
 947   if (cloverreport_mem.length() > 0) {
 948     maxHeapSize = cloverreport_mem
 949   }
 950   if (cloverreport_jvmargs.length() > 0) {
 951     jvmArgs Arrays.asList(cloverreport_jvmargs.split(" "))
 952   }
 953
 954   def argsList = [
 955     "--alwaysreport",
 956     "--initstring",
 957     cloverDb,
 958     "--unittests"
 959   ]
 960
 961   args argsList.toArray()
 962 }
 963
 964
 965 task cloverHtmlReport(type: JavaExec) {
 966   group = "Verification"
 967   description = "Creates clover HTML report"
 968
 969   onlyIf {
 970     file(cloverDb).exists()
 971   }
 972
 973   def cloverHtmlDir = cloverReportDir
 974   inputs.dir cloverClassesDir
 975   outputs.dir cloverHtmlDir
 976
 977   classpath = sourceSets.clover.runtimeClasspath
 978   main = "com.atlassian.clover.reporters.html.HtmlReporter"
 979
 980   if (cloverreport_mem.length() > 0) {
 981     maxHeapSize = cloverreport_mem
 982   }
 983   if (cloverreport_jvmargs.length() > 0) {
 984     jvmArgs Arrays.asList(cloverreport_jvmargs.split(" "))
 985   }
 986
 987   def argsList = [
 988     "--alwaysreport",
 989     "--initstring",
 990     cloverDb,
 991     "--outputdir",
 992     cloverHtmlDir
 993   ]
 994
 995   if (cloverreport_html_options.length() > 0) {
 996     argsList += cloverreport_html_options.split(" ")
 997   }
 998
 999   args argsList.toArray()
1000 }
1001
1002
1003 task cloverXmlReport(type: JavaExec) {
1004   group = "Verification"
1005   description = "Creates clover XML report"
1006
1007   onlyIf {
1008     file(cloverDb).exists()
1009   }
1010
1011   def cloverXmlFile = "${cloverReportDir}/clover.xml"
1012   inputs.dir cloverClassesDir
1013   outputs.file cloverXmlFile
1014
1015   classpath = sourceSets.clover.runtimeClasspath
1016   main = "com.atlassian.clover.reporters.xml.XMLReporter"
1017
1018   if (cloverreport_mem.length() > 0) {
1019     maxHeapSize = cloverreport_mem
1020   }
1021   if (cloverreport_jvmargs.length() > 0) {
1022     jvmArgs Arrays.asList(cloverreport_jvmargs.split(" "))
1023   }
1024
1025   def argsList = [
1026     "--alwaysreport",
1027     "--initstring",
1028     cloverDb,
1029     "--outfile",
1030     cloverXmlFile
1031   ]
1032
1033   if (cloverreport_xml_options.length() > 0) {
1034     argsList += cloverreport_xml_options.split(" ")
1035   }
1036
1037   args argsList.toArray()
1038 }
1039
1040
1041 task cloverReport {
1042   group = "Verification"
1043   description = "Creates clover reports"
1044
1045   dependsOn cloverXmlReport
1046   dependsOn cloverHtmlReport
1047 }
1048
1049
1050 compileCloverJava {
1051
1052   doFirst {
1053     sourceCompatibility = compile_source_compatibility
1054     targetCompatibility = compile_target_compatibility
1055     options.compilerArgs += additional_compiler_args
1056     print ("Setting target compatibility to "+targetCompatibility+"\n")
1057   }
1058   //classpath += configurations.cloverRuntime
1059 }
1060 // end clover bits
1061
1062
1063 compileJava {
1064   // JBP->BS should the print statement in doFirst refer to compile_target_compatibility ?
1065   sourceCompatibility = compile_source_compatibility
1066   targetCompatibility = compile_target_compatibility
1067   options.compilerArgs += additional_compiler_args
1068   options.encoding = "UTF-8"
1069   doFirst {
1070     print ("Setting target compatibility to "+compile_target_compatibility+"\n")
1071   }
1072
1073 }
1074
1075
1076 compileTestJava {
1077   sourceCompatibility = compile_source_compatibility
1078   targetCompatibility = compile_target_compatibility
1079   options.compilerArgs += additional_compiler_args
1080   doFirst {
1081     print ("Setting target compatibility to "+targetCompatibility+"\n")
1082   }
1083 }
1084
1085
1086 clean {
1087   doFirst {
1088     delete sourceSets.main.java.outputDir
1089   }
1090 }
1091
1092
1093 cleanTest {
1094   dependsOn cleanClover
1095   doFirst {
1096     delete sourceSets.test.java.outputDir
1097   }
1098 }
1099
1100
1101 // format is a string like date.format("dd MMMM yyyy")
1102 def getDate(format) {
1103   return date.format(format)
1104 }
1105
1106
1107 def convertMdToHtml (FileTree mdFiles, File cssFile) {
1108   MutableDataSet options = new MutableDataSet()
1109
1110   def extensions = new ArrayList<>()
1111   extensions.add(AnchorLinkExtension.create())
1112   extensions.add(AutolinkExtension.create())
1113   extensions.add(StrikethroughExtension.create())
1114   extensions.add(TaskListExtension.create())
1115   extensions.add(TablesExtension.create())
1116   extensions.add(TocExtension.create())
1117
1118   options.set(Parser.EXTENSIONS, extensions)
1119
1120   // set GFM table parsing options
1121   options.set(TablesExtension.WITH_CAPTION, false)
1122   options.set(TablesExtension.COLUMN_SPANS, false)
1123   options.set(TablesExtension.MIN_HEADER_ROWS, 1)
1124   options.set(TablesExtension.MAX_HEADER_ROWS, 1)
1125   options.set(TablesExtension.APPEND_MISSING_COLUMNS, true)
1126   options.set(TablesExtension.DISCARD_EXTRA_COLUMNS, true)
1127   options.set(TablesExtension.HEADER_SEPARATOR_COLUMN_MATCH, true)
1128   // GFM anchor links
1129   options.set(AnchorLinkExtension.ANCHORLINKS_SET_ID, false)
1130   options.set(AnchorLinkExtension.ANCHORLINKS_ANCHOR_CLASS, "anchor")
1131   options.set(AnchorLinkExtension.ANCHORLINKS_SET_NAME, true)
1132   options.set(AnchorLinkExtension.ANCHORLINKS_TEXT_PREFIX, "<span class=\"octicon octicon-link\"></span>")
1133
1134   Parser parser = Parser.builder(options).build()
1135   HtmlRenderer renderer = HtmlRenderer.builder(options).build()
1136
1137   mdFiles.each { mdFile ->
1138     // add table of contents
1139     def mdText = "[TOC]\n"+mdFile.text
1140
1141     // grab the first top-level title
1142     def title = null
1143     def titleRegex = /(?m)^#(\s+|([^#]))(.*)/
1144     def matcher = mdText =~ titleRegex
1145     if (matcher.size() > 0) {
1146       // matcher[0][2] is the first character of the title if there wasn't any whitespace after the #
1147       title = (matcher[0][2] != null ? matcher[0][2] : "")+matcher[0][3]
1148     }
1149     // or use the filename if none found
1150     if (title == null) {
1151       title = mdFile.getName()
1152     }
1153
1154     Node document = parser.parse(mdText)
1155     String htmlBody = renderer.render(document)
1156     def htmlText = '''<html>
1157 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
1158 <html xmlns="http://www.w3.org/1999/xhtml">
1159   <head>
1160     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
1161     <meta http-equiv="Content-Style-Type" content="text/css" />
1162     <meta name="generator" content="flexmark" />
1163 '''
1164     htmlText += ((title != null) ? "  <title>${title}</title>" : '' )
1165     htmlText += '''
1166     <style type="text/css">code{white-space: pre;}</style>
1167 '''
1168     htmlText += ((cssFile != null) ? cssFile.text : '')
1169     htmlText += '''</head>
1170   <body>
1171 '''
1172     htmlText += htmlBody
1173     htmlText += '''
1174   </body>
1175 </html>
1176 '''
1177
1178     def htmlFilePath = mdFile.getPath().replaceAll(/\..*?$/, ".html")
1179     def htmlFile = file(htmlFilePath)
1180     println("Creating ${htmlFilePath}")
1181     htmlFile.text = htmlText
1182   }
1183 }
1184
1185
1186 task copyDocs(type: Copy) {
1187   def inputDir = "${jalviewDir}/${doc_dir}"
1188   def outputDir = "${docBuildDir}/${doc_dir}"
1189   from(inputDir) {
1190     include('**/*.txt')
1191     include('**/*.md')
1192     include('**/*.html')
1193     include('**/*.xml')
1194     filter(ReplaceTokens,
1195       beginToken: '$$',
1196       endToken: '$$',
1197       tokens: [
1198         'Version-Rel': JALVIEW_VERSION,
1199         'Year-Rel': getDate("yyyy")
1200       ]
1201     )
1202   }
1203   from(inputDir) {
1204     exclude('**/*.txt')
1205     exclude('**/*.md')
1206     exclude('**/*.html')
1207     exclude('**/*.xml')
1208   }
1209   into outputDir
1210
1211   inputs.dir(inputDir)
1212   outputs.dir(outputDir)
1213 }
1214
1215
1216 task convertMdFiles {
1217   dependsOn copyDocs
1218   def mdFiles = fileTree(dir: docBuildDir, include: "**/*.md")
1219   def cssFile = file("${jalviewDir}/${flexmark_css}")
1220
1221   doLast {
1222     convertMdToHtml(mdFiles, cssFile)
1223   }
1224
1225   inputs.files(mdFiles)
1226   inputs.file(cssFile)
1227
1228   def htmlFiles = []
1229   mdFiles.each { mdFile ->
1230     def htmlFilePath = mdFile.getPath().replaceAll(/\..*?$/, ".html")
1231     htmlFiles.add(file(htmlFilePath))
1232   }
1233   outputs.files(htmlFiles)
1234 }
1235
1236
1237 def hugoTemplateSubstitutions(String input, Map extras=null) {
1238   def replacements = [
1239     DATE: getDate("yyyy-MM-dd"),
1240     CHANNEL: propertiesChannelName,
1241     APPLICATION_NAME: applicationName,
1242     GIT_HASH: gitHash,
1243     GIT_BRANCH: gitBranch,
1244     VERSION: JALVIEW_VERSION,
1245     JAVA_VERSION: JAVA_VERSION,
1246     VERSION_UNDERSCORES: JALVIEW_VERSION_UNDERSCORES,
1247     DRAFT: "false",
1248     JVL_HEADER: ""
1249   ]
1250   def output = input
1251   if (extras != null) {
1252     extras.each{ k, v ->
1253       output = output.replaceAll("__${k}__", ((v == null)?"":v))
1254     }
1255   }
1256   replacements.each{ k, v ->
1257     output = output.replaceAll("__${k}__", ((v == null)?"":v))
1258   }
1259   return output
1260 }
1261
1262 def mdFileComponents(File mdFile, def dateOnly=false) {
1263   def map = [:]
1264   def content = ""
1265   if (mdFile.exists()) {
1266     def inFrontMatter = false
1267     def firstLine = true
1268     mdFile.eachLine { line ->
1269       if (line.matches("---")) {
1270         def prev = inFrontMatter
1271         inFrontMatter = firstLine
1272         if (inFrontMatter != prev)
1273           return false
1274       }
1275       if (inFrontMatter) {
1276         def m = null
1277         if (m = line =~ /^date:\s*(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})/) {
1278           map["date"] = new Date().parse("yyyy-MM-dd HH:mm:ss", m[0][1])
1279         } else if (m = line =~ /^date:\s*(\d{4}-\d{2}-\d{2})/) {
1280           map["date"] = new Date().parse("yyyy-MM-dd", m[0][1])
1281         } else if (m = line =~ /^channel:\s*(\S+)/) {
1282           map["channel"] = m[0][1]
1283         } else if (m = line =~ /^version:\s*(\S+)/) {
1284           map["version"] = m[0][1]
1285         } else if (m = line =~ /^\s*([^:]+)\s*:\s*(\S.*)/) {
1286           map[ m[0][1] ] = m[0][2]
1287         }
1288         if (dateOnly && map["date"] != null) {
1289           return false
1290         }
1291       } else {
1292         if (dateOnly)
1293           return false
1294         content += line+"\n"
1295       }
1296       firstLine = false
1297     }
1298   }
1299   return dateOnly ? map["date"] : [map, content]
1300 }
1301
1302 task hugoTemplates {
1303   group "website"
1304   description "Create partially populated md pages for hugo website build"
1305
1306   def hugoTemplatesDir = file("${jalviewDir}/${hugo_templates_dir}")
1307   def hugoBuildDir = "${jalviewDir}/${hugo_build_dir}"
1308   def templateFiles = fileTree(dir: hugoTemplatesDir)
1309   def releaseMdFile = file("${jalviewDir}/${releases_dir}/release-${JALVIEW_VERSION_UNDERSCORES}.md")
1310   def whatsnewMdFile = file("${jalviewDir}/${whatsnew_dir}/whatsnew-${JALVIEW_VERSION_UNDERSCORES}.md")
1311   def oldJvlFile = file("${jalviewDir}/${hugo_old_jvl}")
1312   def jalviewjsFile = file("${jalviewDir}/${hugo_jalviewjs}")
1313
1314   doFirst {
1315     // specific release template for version archive
1316     def changes = ""
1317     def whatsnew = null
1318     def givenDate = null
1319     def givenChannel = null
1320     def givenVersion = null
1321     if (CHANNEL == "RELEASE") {
1322       def (map, content) = mdFileComponents(releaseMdFile)
1323       givenDate = map.date
1324       givenChannel = map.channel
1325       givenVersion = map.version
1326       changes = content
1327       if (givenVersion != null && givenVersion != JALVIEW_VERSION) {
1328         throw new GradleException("'version' header (${givenVersion}) found in ${releaseMdFile} does not match JALVIEW_VERSION (${JALVIEW_VERSION})")
1329       }
1330
1331       if (whatsnewMdFile.exists())
1332         whatsnew = whatsnewMdFile.text
1333     }
1334
1335     def oldJvl = oldJvlFile.exists() ? oldJvlFile.collect{it} : []
1336     def jalviewjsLink = jalviewjsFile.exists() ? jalviewjsFile.collect{it} : []
1337
1338     def changesHugo = null
1339     if (changes != null) {
1340       changesHugo = '<div class="release_notes">\n\n'
1341       def inSection = false
1342       changes.eachLine { line ->
1343         def m = null
1344         if (m = line =~ /^##([^#].*)$/) {
1345           if (inSection) {
1346             changesHugo += "</div>\n\n"
1347           }
1348           def section = m[0][1].trim()
1349           section = section.toLowerCase()
1350           section = section.replaceAll(/ +/, "_")
1351           section = section.replaceAll(/[^a-z0-9_\-]/, "")
1352           changesHugo += "<div class=\"${section}\">\n\n"
1353           inSection = true
1354         } else if (m = line =~ /^(\s*-\s*)<!--([^>]+)-->(.*?)(<br\/?>)?\s*$/) {
1355           def comment = m[0][2].trim()
1356           if (comment != "") {
1357             comment = comment.replaceAll('"', "&quot;")
1358             def issuekeys = []
1359             comment.eachMatch(/JAL-\d+/) { jal -> issuekeys += jal }
1360             def newline = m[0][1]
1361             if (comment.trim() != "")
1362               newline += "{{<comment>}}${comment}{{</comment>}}  "
1363             newline += m[0][3].trim()
1364             if (issuekeys.size() > 0)
1365               newline += "  {{< jal issue=\"${issuekeys.join(",")}\" alt=\"${comment}\" >}}"
1366             if (m[0][4] != null)
1367               newline += m[0][4]
1368             line = newline
1369           }
1370         }
1371         changesHugo += line+"\n"
1372       }
1373       if (inSection) {
1374         changesHugo += "\n</div>\n\n"
1375       }
1376       changesHugo += '</div>'
1377     }
1378
1379     templateFiles.each{ templateFile ->
1380       def newFileName = string(hugoTemplateSubstitutions(templateFile.getName()))
1381       def relPath = hugoTemplatesDir.toPath().relativize(templateFile.toPath()).getParent()
1382       def newRelPathName = hugoTemplateSubstitutions( relPath.toString() )
1383
1384       def outPathName = string("${hugoBuildDir}/$newRelPathName")
1385
1386       copy {
1387         from templateFile
1388         rename(templateFile.getName(), newFileName)
1389         into outPathName
1390       }
1391
1392       def newFile = file("${outPathName}/${newFileName}".toString())
1393       def content = newFile.text
1394       newFile.text = hugoTemplateSubstitutions(content,
1395         [
1396           WHATSNEW: whatsnew,
1397           CHANGES: changesHugo,
1398           DATE: givenDate == null ? "" : givenDate.format("yyyy-MM-dd"),
1399           DRAFT: givenDate == null ? "true" : "false",
1400           JALVIEWJSLINK: jalviewjsLink.contains(JALVIEW_VERSION) ? "true" : "false",
1401           JVL_HEADER: oldJvl.contains(JALVIEW_VERSION) ? "jvl: true" : ""
1402         ]
1403       )
1404     }
1405
1406   }
1407
1408   inputs.file(oldJvlFile)
1409   inputs.dir(hugoTemplatesDir)
1410   inputs.property("JALVIEW_VERSION", { JALVIEW_VERSION })
1411   inputs.property("CHANNEL", { CHANNEL })
1412 }
1413
1414 def getMdDate(File mdFile) {
1415   return mdFileComponents(mdFile, true)
1416 }
1417
1418 def getMdSections(String content) {
1419   def sections = [:]
1420   def sectionContent = ""
1421   def sectionName = null
1422   content.eachLine { line ->
1423     def m = null
1424     if (m = line =~ /^##([^#].*)$/) {
1425       if (sectionName != null) {
1426         sections[sectionName] = sectionContent
1427         sectionName = null
1428         sectionContent = ""
1429       }
1430       sectionName = m[0][1].trim()
1431       sectionName = sectionName.toLowerCase()
1432       sectionName = sectionName.replaceAll(/ +/, "_")
1433       sectionName = sectionName.replaceAll(/[^a-z0-9_\-]/, "")
1434     } else if (sectionName != null) {
1435       sectionContent += line+"\n"
1436     }
1437   }
1438   if (sectionContent != null) {
1439     sections[sectionName] = sectionContent
1440   }
1441   return sections
1442 }
1443
1444
1445 task copyHelp(type: Copy) {
1446   def inputDir = helpSourceDir
1447   def outputDir = "${helpBuildDir}/${help_dir}"
1448   from(inputDir) {
1449     include('**/*.txt')
1450     include('**/*.md')
1451     include('**/*.html')
1452     include('**/*.hs')
1453     include('**/*.xml')
1454     include('**/*.jhm')
1455     filter(ReplaceTokens,
1456       beginToken: '$$',
1457       endToken: '$$',
1458       tokens: [
1459         'Version-Rel': JALVIEW_VERSION,
1460         'Year-Rel': getDate("yyyy")
1461       ]
1462     )
1463   }
1464   from(inputDir) {
1465     exclude('**/*.txt')
1466     exclude('**/*.md')
1467     exclude('**/*.html')
1468     exclude('**/*.hs')
1469     exclude('**/*.xml')
1470     exclude('**/*.jhm')
1471   }
1472   into outputDir
1473
1474   inputs.dir(inputDir)
1475   outputs.files(helpFile)
1476   outputs.dir(outputDir)
1477 }
1478
1479
1480 task releasesTemplates {
1481   group "help"
1482   description "Recreate whatsNew.html and releases.html from markdown files and templates in help"
1483
1484   dependsOn copyHelp
1485
1486   def releasesTemplateFile = file("${jalviewDir}/${releases_template}")
1487   def whatsnewTemplateFile = file("${jalviewDir}/${whatsnew_template}")
1488   def releasesHtmlFile = file("${helpBuildDir}/${help_dir}/${releases_html}")
1489   def whatsnewHtmlFile = file("${helpBuildDir}/${help_dir}/${whatsnew_html}")
1490   def releasesMdDir = "${jalviewDir}/${releases_dir}"
1491   def whatsnewMdDir = "${jalviewDir}/${whatsnew_dir}"
1492
1493   doFirst {
1494     def releaseMdFile = file("${releasesMdDir}/release-${JALVIEW_VERSION_UNDERSCORES}.md")
1495     def whatsnewMdFile = file("${whatsnewMdDir}/whatsnew-${JALVIEW_VERSION_UNDERSCORES}.md")
1496
1497     if (CHANNEL == "RELEASE") {
1498       if (!releaseMdFile.exists()) {
1499         throw new GradleException("File ${releaseMdFile} must be created for RELEASE")
1500       }
1501       if (!whatsnewMdFile.exists()) {
1502         throw new GradleException("File ${whatsnewMdFile} must be created for RELEASE")
1503       }
1504     }
1505
1506     def releaseFiles = fileTree(dir: releasesMdDir, include: "release-*.md")
1507     def releaseFilesDates = releaseFiles.collectEntries {
1508       [(it): getMdDate(it)]
1509     }
1510     releaseFiles = releaseFiles.sort { a,b -> releaseFilesDates[a].compareTo(releaseFilesDates[b]) }
1511
1512     def releasesTemplate = releasesTemplateFile.text
1513     def m = releasesTemplate =~ /(?s)__VERSION_LOOP_START__(.*)__VERSION_LOOP_END__/
1514     def versionTemplate = m[0][1]
1515
1516     MutableDataSet options = new MutableDataSet()
1517
1518     def extensions = new ArrayList<>()
1519     options.set(Parser.EXTENSIONS, extensions)
1520     options.set(Parser.HTML_BLOCK_COMMENT_ONLY_FULL_LINE, true)
1521
1522     Parser parser = Parser.builder(options).build()
1523     HtmlRenderer renderer = HtmlRenderer.builder(options).build()
1524
1525     def actualVersions = releaseFiles.collect { rf ->
1526       def (rfMap, rfContent) = mdFileComponents(rf)
1527       return rfMap.version
1528     }
1529     def versionsHtml = ""
1530     def linkedVersions = []
1531     releaseFiles.reverse().each { rFile ->
1532       def (rMap, rContent) = mdFileComponents(rFile)
1533
1534       def versionLink = ""
1535       def partialVersion = ""
1536       def firstPart = true
1537       rMap.version.split("\\.").each { part ->
1538         def displayPart = ( firstPart ? "" : "." ) + part
1539         partialVersion += displayPart
1540         if (
1541             linkedVersions.contains(partialVersion)
1542             || ( actualVersions.contains(partialVersion) && partialVersion != rMap.version )
1543             ) {
1544           versionLink += displayPart
1545         } else {
1546           versionLink += "<a id=\"Jalview.${partialVersion}\">${displayPart}</a>"
1547           linkedVersions += partialVersion
1548         }
1549         firstPart = false
1550       }
1551       def displayDate = releaseFilesDates[rFile].format("dd/MM/yyyy")
1552
1553       def lm = null
1554       def rContentProcessed = ""
1555       rContent.eachLine { line ->
1556         if (lm = line =~ /^(\s*-)(\s*<!--[^>]*?-->)(.*)$/) {
1557           line = "${lm[0][1]}${lm[0][3]}${lm[0][2]}"
1558       } else if (lm = line =~ /^###([^#]+.*)$/) {
1559           line = "_${lm[0][1].trim()}_"
1560         }
1561         rContentProcessed += line + "\n"
1562       }
1563
1564       def rContentSections = getMdSections(rContentProcessed)
1565       def rVersion = versionTemplate
1566       if (rVersion != "") {
1567         def rNewFeatures = rContentSections["new_features"]
1568         def rIssuesResolved = rContentSections["issues_resolved"]
1569         Node newFeaturesNode = parser.parse(rNewFeatures)
1570         String newFeaturesHtml = renderer.render(newFeaturesNode)
1571         Node issuesResolvedNode = parser.parse(rIssuesResolved)
1572         String issuesResolvedHtml = renderer.render(issuesResolvedNode)
1573         rVersion = hugoTemplateSubstitutions(rVersion,
1574           [
1575             VERSION: rMap.version,
1576             VERSION_LINK: versionLink,
1577             DISPLAY_DATE: displayDate,
1578             NEW_FEATURES: newFeaturesHtml,
1579             ISSUES_RESOLVED: issuesResolvedHtml
1580           ]
1581         )
1582         versionsHtml += rVersion
1583       }
1584     }
1585
1586     releasesTemplate = releasesTemplate.replaceAll("(?s)__VERSION_LOOP_START__.*__VERSION_LOOP_END__", versionsHtml)
1587     releasesTemplate = hugoTemplateSubstitutions(releasesTemplate)
1588     releasesHtmlFile.text = releasesTemplate
1589
1590     if (whatsnewMdFile.exists()) {
1591       def wnDisplayDate = releaseFilesDates[releaseMdFile] != null ? releaseFilesDates[releaseMdFile].format("dd MMMM yyyy") : ""
1592       def whatsnewMd = hugoTemplateSubstitutions(whatsnewMdFile.text)
1593       Node whatsnewNode = parser.parse(whatsnewMd)
1594       String whatsnewHtml = renderer.render(whatsnewNode)
1595       whatsnewHtml = whatsnewTemplateFile.text.replaceAll("__WHATS_NEW__", whatsnewHtml)
1596       whatsnewHtmlFile.text = hugoTemplateSubstitutions(whatsnewHtml,
1597         [
1598             VERSION: JALVIEW_VERSION,
1599           DISPLAY_DATE: wnDisplayDate
1600         ]
1601       )
1602     } else if (gradle.taskGraph.hasTask(":linkCheck")) {
1603       whatsnewHtmlFile.text = "Development build " + getDate("yyyy-MM-dd HH:mm:ss")
1604     }
1605
1606   }
1607
1608   inputs.file(releasesTemplateFile)
1609   inputs.file(whatsnewTemplateFile)
1610   inputs.dir(releasesMdDir)
1611   inputs.dir(whatsnewMdDir)
1612   outputs.file(releasesHtmlFile)
1613   outputs.file(whatsnewHtmlFile)
1614 }
1615
1616
1617 task copyResources(type: Copy) {
1618   group = "build"
1619   description = "Copy (and make text substitutions in) the resources dir to the build area"
1620
1621   def inputDir = resourceDir
1622   def outputDir = resourcesBuildDir
1623   from(inputDir) {
1624     include('**/*.txt')
1625     include('**/*.md')
1626     include('**/*.html')
1627     include('**/*.xml')
1628     filter(ReplaceTokens,
1629       beginToken: '$$',
1630       endToken: '$$',
1631       tokens: [
1632         'Version-Rel': JALVIEW_VERSION,
1633         'Year-Rel': getDate("yyyy")
1634       ]
1635     )
1636   }
1637   from(inputDir) {
1638     exclude('**/*.txt')
1639     exclude('**/*.md')
1640     exclude('**/*.html')
1641     exclude('**/*.xml')
1642   }
1643   into outputDir
1644
1645   inputs.dir(inputDir)
1646   outputs.dir(outputDir)
1647 }
1648
1649 task copyChannelResources(type: Copy) {
1650   dependsOn copyResources
1651   group = "build"
1652   description = "Copy the channel resources dir to the build resources area"
1653
1654   def inputDir = "${channelDir}/${resource_dir}"
1655   def outputDir = resourcesBuildDir
1656   from(inputDir) {
1657     include(channel_props)
1658     filter(ReplaceTokens,
1659       beginToken: '__',
1660       endToken: '__',
1661       tokens: [
1662         'SUFFIX': channelSuffix
1663       ]
1664     )
1665   }
1666   from(inputDir) {
1667     exclude(channel_props)
1668   }
1669   into outputDir
1670
1671   inputs.dir(inputDir)
1672   outputs.dir(outputDir)
1673 }
1674
1675 task createBuildProperties(type: WriteProperties) {
1676   dependsOn copyResources
1677   group = "build"
1678   description = "Create the ${buildProperties} file"
1679
1680   inputs.dir(sourceDir)
1681   inputs.dir(resourcesBuildDir)
1682   outputFile (buildProperties)
1683   // taking time specific comment out to allow better incremental builds
1684   comment "--Jalview Build Details--\n"+getDate("yyyy-MM-dd HH:mm:ss")
1685   //comment "--Jalview Build Details--\n"+getDate("yyyy-MM-dd")
1686   property "BUILD_DATE", getDate("HH:mm:ss dd MMMM yyyy")
1687   property "VERSION", JALVIEW_VERSION
1688   property "INSTALLATION", INSTALLATION+" git-commit:"+gitHash+" ["+gitBranch+"]"
1689   property "JAVA_COMPILE_VERSION", JAVA_INTEGER_VERSION
1690   if (getdownSetAppBaseProperty) {
1691     property "GETDOWNAPPBASE", getdownAppBase
1692     property "GETDOWNAPPDISTDIR", getdownAppDistDir
1693   }
1694   outputs.file(outputFile)
1695 }
1696
1697
1698 task buildIndices(type: JavaExec) {
1699   dependsOn copyHelp
1700   classpath = sourceSets.main.compileClasspath
1701   main = "com.sun.java.help.search.Indexer"
1702   workingDir = "${helpBuildDir}/${help_dir}"
1703   def argDir = "html"
1704   args = [ argDir ]
1705   inputs.dir("${workingDir}/${argDir}")
1706
1707   outputs.dir("${classesDir}/doc")
1708   outputs.dir("${classesDir}/help")
1709   outputs.file("${workingDir}/JavaHelpSearch/DOCS")
1710   outputs.file("${workingDir}/JavaHelpSearch/DOCS.TAB")
1711   outputs.file("${workingDir}/JavaHelpSearch/OFFSETS")
1712   outputs.file("${workingDir}/JavaHelpSearch/POSITIONS")
1713   outputs.file("${workingDir}/JavaHelpSearch/SCHEMA")
1714   outputs.file("${workingDir}/JavaHelpSearch/TMAP")
1715 }
1716
1717 task buildResources {
1718   dependsOn copyResources
1719   dependsOn copyChannelResources
1720   dependsOn createBuildProperties
1721 }
1722
1723 task prepare {
1724   dependsOn buildResources
1725   dependsOn copyDocs
1726   dependsOn copyHelp
1727   dependsOn releasesTemplates
1728   dependsOn convertMdFiles
1729   dependsOn buildIndices
1730 }
1731
1732
1733 compileJava.dependsOn prepare
1734 run.dependsOn compileJava
1735 compileTestJava.dependsOn compileJava
1736
1737
1738
1739 test {
1740   group = "Verification"
1741   description = "Runs all testTaskN tasks)"
1742
1743   if (useClover) {
1744     dependsOn cloverClasses
1745   } else { //?
1746     dependsOn testClasses
1747   }
1748
1749   // not running tests in this task
1750   exclude "**/*"
1751 }
1752 /* testTask0 is the main test task */
1753 task testTask0(type: Test) {
1754   group = "Verification"
1755   description = "The main test task. Runs all non-testTaskN-labelled tests (unless excluded)"
1756   useTestNG() {
1757     includeGroups testng_groups.split(",")
1758     excludeGroups testng_excluded_groups.split(",")
1759     tasks.withType(Test).matching {it.name.startsWith("testTask") && it.name != name}.all {t -> excludeGroups t.name}
1760     preserveOrder true
1761     useDefaultListeners=true
1762   }
1763 }
1764
1765 /* separated tests */
1766 task testTask1(type: Test) {
1767   group = "Verification"
1768   description = "Tests that need to be isolated from the main test run"
1769   useTestNG() {
1770     includeGroups name
1771     excludeGroups testng_excluded_groups.split(",")
1772     preserveOrder true
1773     useDefaultListeners=true
1774   }
1775 }
1776
1777 /* insert more testTaskNs here -- change N to next digit or other string */
1778 /*
1779 task testTaskN(type: Test) {
1780   group = "Verification"
1781   description = "Tests that need to be isolated from the main test run"
1782   useTestNG() {
1783     includeGroups name
1784     excludeGroups testng_excluded_groups.split(",")
1785     preserveOrder true
1786     useDefaultListeners=true
1787   }
1788 }
1789 */
1790
1791 /*
1792  * adapted from https://medium.com/@wasyl/pretty-tests-summary-in-gradle-744804dd676c
1793  * to summarise test results from all Test tasks
1794  */
1795 /* START of test tasks results summary */
1796 import groovy.time.TimeCategory
1797 import org.gradle.api.tasks.testing.logging.TestExceptionFormat
1798 import org.gradle.api.tasks.testing.logging.TestLogEvent
1799 rootProject.ext.testsResults = [] // Container for tests summaries
1800
1801 tasks.withType(Test).matching {t -> t.getName().startsWith("testTask")}.all { testTask ->
1802
1803   // from original test task
1804   if (useClover) {
1805     dependsOn cloverClasses
1806   } else { //?
1807     dependsOn testClasses //?
1808   }
1809
1810   // run main tests first
1811   if (!testTask.name.equals("testTask0"))
1812     testTask.mustRunAfter "testTask0"
1813
1814   testTask.testLogging { logging ->
1815     events TestLogEvent.FAILED
1816 //      TestLogEvent.SKIPPED,
1817 //      TestLogEvent.STANDARD_OUT,
1818 //      TestLogEvent.STANDARD_ERROR
1819
1820     exceptionFormat TestExceptionFormat.FULL
1821     showExceptions true
1822     showCauses true
1823     showStackTraces true
1824
1825     info.events = [ TestLogEvent.FAILED ]
1826   }
1827
1828
1829
1830   ignoreFailures = true // Always try to run all tests for all modules
1831
1832   afterSuite { desc, result ->
1833     if (desc.parent)
1834       return // Only summarize results for whole modules
1835
1836     def resultsInfo = [testTask.project.name, testTask.name, result, TimeCategory.minus(new Date(result.endTime), new Date(result.startTime)), testTask.reports.html.entryPoint]
1837
1838     rootProject.ext.testsResults.add(resultsInfo)
1839   }
1840
1841   // from original test task
1842   maxHeapSize = "1024m"
1843
1844   workingDir = jalviewDir
1845   def testLaf = project.findProperty("test_laf")
1846   if (testLaf != null) {
1847     println("Setting Test LaF to '${testLaf}'")
1848     systemProperty "laf", testLaf
1849   }
1850   def testHiDPIScale = project.findProperty("test_HiDPIScale")
1851   if (testHiDPIScale != null) {
1852     println("Setting Test HiDPI Scale to '${testHiDPIScale}'")
1853     systemProperty "sun.java2d.uiScale", testHiDPIScale
1854   }
1855   sourceCompatibility = compile_source_compatibility
1856   targetCompatibility = compile_target_compatibility
1857   jvmArgs += additional_compiler_args
1858
1859   doFirst {
1860     // this is not perfect yet -- we should only add the commandLineIncludePatterns to the
1861     // testTasks that include the tests, and exclude all from the others.
1862     // get --test argument
1863     filter.commandLineIncludePatterns = test.filter.commandLineIncludePatterns
1864     // do something with testTask.getCandidateClassFiles() to see if the test should silently finish because of the
1865     // commandLineIncludePatterns not matching anything.  Instead we are doing setFailOnNoMatchingTests(false) below
1866
1867
1868     if (useClover) {
1869       println("Running tests " + (useClover?"WITH":"WITHOUT") + " clover")
1870     }
1871   }
1872
1873
1874   /* don't fail on no matching tests (so --tests will run across all testTasks) */
1875   testTask.filter.setFailOnNoMatchingTests(false)
1876
1877   /* ensure the "test" task dependsOn all the testTasks */
1878   test.dependsOn testTask
1879 }
1880
1881 gradle.buildFinished {
1882     def allResults = rootProject.ext.testsResults
1883
1884     if (!allResults.isEmpty()) {
1885         printResults allResults
1886         allResults.each {r ->
1887           if (r[2].resultType == TestResult.ResultType.FAILURE)
1888             throw new GradleException("Failed tests!")
1889         }
1890     }
1891 }
1892
1893 private static String colString(styler, col, colour, text) {
1894   return col?"${styler[colour](text)}":text
1895 }
1896
1897 private static String getSummaryLine(s, pn, tn, rt, rc, rs, rf, rsk, t, col) {
1898   def colour = 'black'
1899   def text = rt
1900   def nocol = false
1901   if (rc == 0) {
1902     text = "-----"
1903     nocol = true
1904   } else {
1905     switch(rt) {
1906       case TestResult.ResultType.SUCCESS:
1907         colour = 'green'
1908         break;
1909       case TestResult.ResultType.FAILURE:
1910         colour = 'red'
1911         break;
1912       default:
1913         nocol = true
1914         break;
1915     }
1916   }
1917   StringBuilder sb = new StringBuilder()
1918   sb.append("${pn}")
1919   if (tn != null)
1920     sb.append(":${tn}")
1921   sb.append(" results: ")
1922   sb.append(colString(s, col && !nocol, colour, text))
1923   sb.append(" (")
1924   sb.append("${rc} tests, ")
1925   sb.append(colString(s, col && rs > 0, 'green', rs))
1926   sb.append(" successes, ")
1927   sb.append(colString(s, col && rf > 0, 'red', rf))
1928   sb.append(" failures, ")
1929   sb.append("${rsk} skipped) in ${t}")
1930   return sb.toString()
1931 }
1932
1933 private static void printResults(allResults) {
1934
1935     // styler from https://stackoverflow.com/a/56139852
1936     def styler = 'black red green yellow blue magenta cyan white'.split().toList().withIndex(30).collectEntries { key, val -> [(key) : { "\033[${val}m${it}\033[0m" }] }
1937
1938     def maxLength = 0
1939     def failedTests = false
1940     def summaryLines = []
1941     def totalcount = 0
1942     def totalsuccess = 0
1943     def totalfail = 0
1944     def totalskip = 0
1945     def totaltime = TimeCategory.getSeconds(0)
1946     // sort on project name then task name
1947     allResults.sort {a, b -> a[0] == b[0]? a[1]<=>b[1]:a[0] <=> b[0]}.each {
1948       def projectName = it[0]
1949       def taskName = it[1]
1950       def result = it[2]
1951       def time = it[3]
1952       def report = it[4]
1953       def summaryCol = getSummaryLine(styler, projectName, taskName, result.resultType, result.testCount, result.successfulTestCount, result.failedTestCount, result.skippedTestCount, time, true)
1954       def summaryPlain = getSummaryLine(styler, projectName, taskName, result.resultType, result.testCount, result.successfulTestCount, result.failedTestCount, result.skippedTestCount, time, false)
1955       def reportLine = "Report file: ${report}"
1956       def ls = summaryPlain.length()
1957       def lr = reportLine.length()
1958       def m = [ls, lr].max()
1959       if (m > maxLength)
1960         maxLength = m
1961       def info = [ls, summaryCol, reportLine]
1962       summaryLines.add(info)
1963       failedTests |= result.resultType == TestResult.ResultType.FAILURE
1964       totalcount += result.testCount
1965       totalsuccess += result.successfulTestCount
1966       totalfail += result.failedTestCount
1967       totalskip += result.skippedTestCount
1968       totaltime += time
1969     }
1970     def totalSummaryCol = getSummaryLine(styler, "OVERALL", "", failedTests?TestResult.ResultType.FAILURE:TestResult.ResultType.SUCCESS, totalcount, totalsuccess, totalfail, totalskip, totaltime, true)
1971     def totalSummaryPlain = getSummaryLine(styler, "OVERALL", "", failedTests?TestResult.ResultType.FAILURE:TestResult.ResultType.SUCCESS, totalcount, totalsuccess, totalfail, totalskip, totaltime, false)
1972     def tls = totalSummaryPlain.length()
1973     if (tls > maxLength)
1974       maxLength = tls
1975     def info = [tls, totalSummaryCol, null]
1976     summaryLines.add(info)
1977
1978     def allSummaries = []
1979     for(sInfo : summaryLines) {
1980       def ls = sInfo[0]
1981       def summary = sInfo[1]
1982       def report = sInfo[2]
1983
1984       StringBuilder sb = new StringBuilder()
1985       sb.append("│" + summary + " " * (maxLength - ls) + "│")
1986       if (report != null) {
1987         sb.append("\n│" + report + " " * (maxLength - report.length()) + "│")
1988       }
1989       allSummaries += sb.toString()
1990     }
1991
1992     println "┌${"${"─" * maxLength}"}┐"
1993     println allSummaries.join("\n├${"${"─" * maxLength}"}┤\n")
1994     println "└${"${"─" * maxLength}"}┘"
1995 }
1996 /* END of test tasks results summary */
1997
1998
1999 task compileLinkCheck(type: JavaCompile) {
2000   options.fork = true
2001   classpath = files("${jalviewDir}/${utils_dir}")
2002   destinationDir = file("${jalviewDir}/${utils_dir}")
2003   source = fileTree(dir: "${jalviewDir}/${utils_dir}", include: ["HelpLinksChecker.java", "BufferedLineReader.java"])
2004
2005   inputs.file("${jalviewDir}/${utils_dir}/HelpLinksChecker.java")
2006   inputs.file("${jalviewDir}/${utils_dir}/HelpLinksChecker.java")
2007   outputs.file("${jalviewDir}/${utils_dir}/HelpLinksChecker.class")
2008   outputs.file("${jalviewDir}/${utils_dir}/BufferedLineReader.class")
2009 }
2010
2011
2012 task linkCheck(type: JavaExec) {
2013   dependsOn prepare
2014   dependsOn compileLinkCheck
2015
2016   def helpLinksCheckerOutFile = file("${jalviewDir}/${utils_dir}/HelpLinksChecker.out")
2017   classpath = files("${jalviewDir}/${utils_dir}")
2018   main = "HelpLinksChecker"
2019   workingDir = "${helpBuildDir}"
2020   args = [ "${helpBuildDir}/${help_dir}", "-nointernet" ]
2021
2022   def outFOS = new FileOutputStream(helpLinksCheckerOutFile, false) // false == don't append
2023   standardOutput = new org.apache.tools.ant.util.TeeOutputStream(
2024     outFOS,
2025     System.out)
2026   errorOutput = new org.apache.tools.ant.util.TeeOutputStream(
2027     outFOS,
2028     System.err)
2029
2030   inputs.dir(helpBuildDir)
2031   outputs.file(helpLinksCheckerOutFile)
2032 }
2033
2034
2035 // import the pubhtmlhelp target
2036 ant.properties.basedir = "${jalviewDir}"
2037 ant.properties.helpBuildDir = "${helpBuildDir}/${help_dir}"
2038 ant.importBuild "${utils_dir}/publishHelp.xml"
2039
2040
2041 task cleanPackageDir(type: Delete) {
2042   doFirst {
2043     delete fileTree(dir: "${jalviewDir}/${package_dir}", include: "*.jar")
2044   }
2045 }
2046
2047
2048 jar {
2049   dependsOn prepare
2050   dependsOn linkCheck
2051
2052   manifest {
2053     attributes "Main-Class": main_class,
2054     "Permissions": "all-permissions",
2055     "Application-Name": applicationName,
2056     "Codebase": application_codebase,
2057     "Implementation-Version": JALVIEW_VERSION
2058   }
2059
2060   def outputDir = "${jalviewDir}/${package_dir}"
2061   destinationDirectory = file(outputDir)
2062   archiveFileName = rootProject.name+".jar"
2063   duplicatesStrategy "EXCLUDE"
2064
2065
2066   exclude "cache*/**"
2067   exclude "*.jar"
2068   exclude "*.jar.*"
2069   exclude "**/*.jar"
2070   exclude "**/*.jar.*"
2071
2072   inputs.dir(sourceSets.main.java.outputDir)
2073   sourceSets.main.resources.srcDirs.each{ dir ->
2074     inputs.dir(dir)
2075   }
2076   outputs.file("${outputDir}/${archiveFileName}")
2077 }
2078
2079
2080 task copyJars(type: Copy) {
2081   from fileTree(dir: classesDir, include: "**/*.jar").files
2082   into "${jalviewDir}/${package_dir}"
2083 }
2084
2085
2086 // doing a Sync instead of Copy as Copy doesn't deal with "outputs" very well
2087 task syncJars(type: Sync) {
2088   dependsOn jar
2089   from fileTree(dir: "${jalviewDir}/${libDistDir}", include: "**/*.jar").files
2090   into "${jalviewDir}/${package_dir}"
2091   preserve {
2092     include jar.archiveFileName.getOrNull()
2093   }
2094 }
2095
2096
2097 task makeDist {
2098   group = "build"
2099   description = "Put all required libraries in dist"
2100   // order of "cleanPackageDir", "copyJars", "jar" important!
2101   jar.mustRunAfter cleanPackageDir
2102   syncJars.mustRunAfter cleanPackageDir
2103   dependsOn cleanPackageDir
2104   dependsOn syncJars
2105   dependsOn jar
2106   outputs.dir("${jalviewDir}/${package_dir}")
2107 }
2108
2109
2110 task cleanDist {
2111   dependsOn cleanPackageDir
2112   dependsOn cleanTest
2113   dependsOn clean
2114 }
2115
2116
2117 shadowJar {
2118   group = "distribution"
2119   description = "Create a single jar file with all dependency libraries merged. Can be run with java -jar"
2120   if (buildDist) {
2121     dependsOn makeDist
2122   }
2123   from ("${jalviewDir}/${libDistDir}") {
2124     include("*.jar")
2125   }
2126   manifest {
2127     attributes "Implementation-Version": JALVIEW_VERSION,
2128     "Application-Name": applicationName
2129   }
2130
2131   duplicatesStrategy "INCLUDE"
2132
2133   mainClassName = shadow_jar_main_class
2134   mergeServiceFiles()
2135   classifier = "all-"+JALVIEW_VERSION+"-j"+JAVA_VERSION
2136   minimize()
2137 }
2138
2139 task getdownImagesCopy() {
2140   inputs.dir getdownImagesDir
2141   outputs.dir getdownImagesBuildDir
2142
2143   doFirst {
2144     copy {
2145       from(getdownImagesDir) {
2146         include("*getdown*.png")
2147       }
2148       into getdownImagesBuildDir
2149     }
2150   }
2151 }
2152
2153 task getdownImagesProcess() {
2154   dependsOn getdownImagesCopy
2155
2156   doFirst {
2157     if (backgroundImageText) {
2158       if (convertBinary == null) {
2159         throw new StopExecutionException("No ImageMagick convert binary installed at '${convertBinaryExpectedLocation}'")
2160       }
2161       if (!project.hasProperty("getdown_background_image_text_suffix_cmd")) {
2162         throw new StopExecutionException("No property 'getdown_background_image_text_suffix_cmd' defined. See channel_gradle.properties for channel ${CHANNEL}")
2163       }
2164       fileTree(dir: getdownImagesBuildDir, include: "*background*.png").getFiles().each { file ->
2165         exec {
2166           executable convertBinary
2167           args = [
2168             file.getPath(),
2169             '-font', getdown_background_image_text_font,
2170             '-fill', getdown_background_image_text_colour,
2171             '-draw', sprintf(getdown_background_image_text_suffix_cmd, channelSuffix),
2172             '-draw', sprintf(getdown_background_image_text_commit_cmd, "git-commit: ${gitHash}"),
2173             '-draw', sprintf(getdown_background_image_text_date_cmd, getDate("yyyy-MM-dd HH:mm:ss")),
2174             file.getPath()
2175           ]
2176         }
2177       }
2178     }
2179   }
2180 }
2181
2182 task getdownImages() {
2183   dependsOn getdownImagesProcess
2184 }
2185
2186 task getdownWebsite() {
2187   group = "distribution"
2188   description = "Create the getdown minimal app folder, and website folder for this version of jalview. Website folder also used for offline app installer"
2189
2190   dependsOn getdownImages
2191   if (buildDist) {
2192     dependsOn makeDist
2193   }
2194
2195   def getdownWebsiteResourceFilenames = []
2196   def getdownResourceDir = getdownResourceDir
2197   def getdownResourceFilenames = []
2198
2199   doFirst {
2200     // clean the getdown website and files dir before creating getdown folders
2201     delete getdownAppBaseDir
2202     delete getdownFilesDir
2203
2204     copy {
2205       from buildProperties
2206       rename(file(buildProperties).getName(), getdown_build_properties)
2207       into getdownAppDir
2208     }
2209     getdownWebsiteResourceFilenames += "${getdownAppDistDir}/${getdown_build_properties}"
2210
2211     copy {
2212       from channelPropsFile
2213       filter(ReplaceTokens,
2214         beginToken: '__',
2215         endToken: '__',
2216         tokens: [
2217           'SUFFIX': channelSuffix
2218         ]
2219       )
2220       into getdownAppBaseDir
2221     }
2222     getdownWebsiteResourceFilenames += file(channelPropsFile).getName()
2223
2224     // set some getdownTxt_ properties then go through all properties looking for getdownTxt_...
2225     def props = project.properties.sort { it.key }
2226     if (getdownAltJavaMinVersion != null && getdownAltJavaMinVersion.length() > 0) {
2227       props.put("getdown_txt_java_min_version", getdownAltJavaMinVersion)
2228     }
2229     if (getdownAltJavaMaxVersion != null && getdownAltJavaMaxVersion.length() > 0) {
2230       props.put("getdown_txt_java_max_version", getdownAltJavaMaxVersion)
2231     }
2232     if (getdownAltMultiJavaLocation != null && getdownAltMultiJavaLocation.length() > 0) {
2233       props.put("getdown_txt_multi_java_location", getdownAltMultiJavaLocation)
2234     }
2235     if (getdownImagesBuildDir != null && file(getdownImagesBuildDir).exists()) {
2236       props.put("getdown_txt_ui.background_image", "${getdownImagesBuildDir}/${getdown_background_image}")
2237       props.put("getdown_txt_ui.instant_background_image", "${getdownImagesBuildDir}/${getdown_instant_background_image}")
2238       props.put("getdown_txt_ui.error_background", "${getdownImagesBuildDir}/${getdown_error_background}")
2239       props.put("getdown_txt_ui.progress_image", "${getdownImagesBuildDir}/${getdown_progress_image}")
2240       props.put("getdown_txt_ui.icon", "${getdownImagesDir}/${getdown_icon}")
2241       props.put("getdown_txt_ui.mac_dock_icon", "${getdownImagesDir}/${getdown_mac_dock_icon}")
2242     }
2243
2244     props.put("getdown_txt_title", jalview_name)
2245     props.put("getdown_txt_ui.name", applicationName)
2246
2247     // start with appbase
2248     getdownTextLines += "appbase = ${getdownAppBase}"
2249     props.each{ prop, val ->
2250       if (prop.startsWith("getdown_txt_") && val != null) {
2251         if (prop.startsWith("getdown_txt_multi_")) {
2252           def key = prop.substring(18)
2253           val.split(",").each{ v ->
2254             def line = "${key} = ${v}"
2255             getdownTextLines += line
2256           }
2257         } else {
2258           // file values rationalised
2259           if (val.indexOf('/') > -1 || prop.startsWith("getdown_txt_resource")) {
2260             def r = null
2261             if (val.indexOf('/') == 0) {
2262               // absolute path
2263               r = file(val)
2264             } else if (val.indexOf('/') > 0) {
2265               // relative path (relative to jalviewDir)
2266               r = file( "${jalviewDir}/${val}" )
2267             }
2268             if (r.exists()) {
2269               val = "${getdown_resource_dir}/" + r.getName()
2270               getdownWebsiteResourceFilenames += val
2271               getdownResourceFilenames += r.getPath()
2272             }
2273           }
2274           if (! prop.startsWith("getdown_txt_resource")) {
2275             def line = prop.substring(12) + " = ${val}"
2276             getdownTextLines += line
2277           }
2278         }
2279       }
2280     }
2281
2282     getdownWebsiteResourceFilenames.each{ filename ->
2283       getdownTextLines += "resource = ${filename}"
2284     }
2285     getdownResourceFilenames.each{ filename ->
2286       copy {
2287         from filename
2288         into getdownResourceDir
2289       }
2290     }
2291
2292     def getdownWrapperScripts = [ getdown_bash_wrapper_script, getdown_powershell_wrapper_script, getdown_batch_wrapper_script ]
2293     getdownWrapperScripts.each{ script ->
2294       def s = file( "${jalviewDir}/utils/getdown/${getdown_wrapper_script_dir}/${script}" )
2295       if (s.exists()) {
2296         copy {
2297           from s
2298           into "${getdownAppBaseDir}/${getdown_wrapper_script_dir}"
2299         }
2300         getdownTextLines += "resource = ${getdown_wrapper_script_dir}/${script}"
2301       }
2302     }
2303
2304     def codeFiles = []
2305     fileTree(file(package_dir)).each{ f ->
2306       if (f.isDirectory()) {
2307         def files = fileTree(dir: f, include: ["*"]).getFiles()
2308         codeFiles += files
2309       } else if (f.exists()) {
2310         codeFiles += f
2311       }
2312     }
2313     def jalviewJar = jar.archiveFileName.getOrNull()
2314     // put jalview.jar first for CLASSPATH and .properties files reasons
2315     codeFiles.sort{a, b -> ( a.getName() == jalviewJar ? -1 : ( b.getName() == jalviewJar ? 1 : a <=> b ) ) }.each{f ->
2316       def name = f.getName()
2317       def line = "code = ${getdownAppDistDir}/${name}"
2318       getdownTextLines += line
2319       copy {
2320         from f.getPath()
2321         into getdownAppDir
2322       }
2323     }
2324
2325     // NOT USING MODULES YET, EVERYTHING SHOULD BE IN dist
2326     /*
2327     if (JAVA_VERSION.equals("11")) {
2328     def j11libFiles = fileTree(dir: "${jalviewDir}/${j11libDir}", include: ["*.jar"]).getFiles()
2329     j11libFiles.sort().each{f ->
2330     def name = f.getName()
2331     def line = "code = ${getdown_j11lib_dir}/${name}"
2332     getdownTextLines += line
2333     copy {
2334     from f.getPath()
2335     into getdownJ11libDir
2336     }
2337     }
2338     }
2339      */
2340
2341     // getdown-launcher.jar should not be in main application class path so the main application can move it when updated.  Listed as a resource so it gets updated.
2342     //getdownTextLines += "class = " + file(getdownLauncher).getName()
2343     getdownTextLines += "resource = ${getdown_launcher_new}"
2344     getdownTextLines += "class = ${main_class}"
2345     // Not setting these properties in general so that getdownappbase and getdowndistdir will default to release version in jalview.bin.Cache
2346     if (getdownSetAppBaseProperty) {
2347       getdownTextLines += "jvmarg = -Dgetdowndistdir=${getdownAppDistDir}"
2348       getdownTextLines += "jvmarg = -Dgetdownappbase=${getdownAppBase}"
2349     }
2350
2351     def getdownTxt = file("${getdownAppBaseDir}/getdown.txt")
2352     getdownTxt.write(getdownTextLines.join("\n"))
2353
2354     getdownLaunchJvl = getdown_launch_jvl_name + ( (jvlChannelName != null && jvlChannelName.length() > 0)?"-${jvlChannelName}":"" ) + ".jvl"
2355     def launchJvl = file("${getdownAppBaseDir}/${getdownLaunchJvl}")
2356     launchJvl.write("appbase=${getdownAppBase}")
2357
2358     // files going into the getdown website dir: getdown-launcher.jar
2359     copy {
2360       from getdownLauncher
2361       rename(file(getdownLauncher).getName(), getdown_launcher_new)
2362       into getdownAppBaseDir
2363     }
2364
2365     // files going into the getdown website dir: getdown-launcher(-local).jar
2366     copy {
2367       from getdownLauncher
2368       if (file(getdownLauncher).getName() != getdown_launcher) {
2369         rename(file(getdownLauncher).getName(), getdown_launcher)
2370       }
2371       into getdownAppBaseDir
2372     }
2373
2374     // files going into the getdown website dir: ./install dir and files
2375     if (! (CHANNEL.startsWith("ARCHIVE") || CHANNEL.startsWith("DEVELOP"))) {
2376       copy {
2377         from getdownTxt
2378         from getdownLauncher
2379         from "${getdownAppDir}/${getdown_build_properties}"
2380         if (file(getdownLauncher).getName() != getdown_launcher) {
2381           rename(file(getdownLauncher).getName(), getdown_launcher)
2382         }
2383         into getdownInstallDir
2384       }
2385
2386       // and make a copy in the getdown files dir (these are not downloaded by getdown)
2387       copy {
2388         from getdownInstallDir
2389         into getdownFilesInstallDir
2390       }
2391     }
2392
2393     // files going into the getdown files dir: getdown.txt, getdown-launcher.jar, channel-launch.jvl, build_properties
2394     copy {
2395       from getdownTxt
2396       from launchJvl
2397       from getdownLauncher
2398       from "${getdownAppBaseDir}/${getdown_build_properties}"
2399       from "${getdownAppBaseDir}/${channel_props}"
2400       if (file(getdownLauncher).getName() != getdown_launcher) {
2401         rename(file(getdownLauncher).getName(), getdown_launcher)
2402       }
2403       into getdownFilesDir
2404     }
2405
2406     // and ./resource (not all downloaded by getdown)
2407     copy {
2408       from getdownResourceDir
2409       into "${getdownFilesDir}/${getdown_resource_dir}"
2410     }
2411   }
2412
2413   if (buildDist) {
2414     inputs.dir("${jalviewDir}/${package_dir}")
2415   }
2416   outputs.dir(getdownAppBaseDir)
2417   outputs.dir(getdownFilesDir)
2418 }
2419
2420
2421 // a helper task to allow getdown digest of any dir: `gradle getdownDigestDir -PDIGESTDIR=/path/to/my/random/getdown/dir
2422 task getdownDigestDir(type: JavaExec) {
2423   group "Help"
2424   description "A task to run a getdown Digest on a dir with getdown.txt. Provide a DIGESTDIR property via -PDIGESTDIR=..."
2425
2426   def digestDirPropertyName = "DIGESTDIR"
2427   doFirst {
2428     classpath = files(getdownLauncher)
2429     def digestDir = findProperty(digestDirPropertyName)
2430     if (digestDir == null) {
2431       throw new GradleException("Must provide a DIGESTDIR value to produce an alternative getdown digest")
2432     }
2433     args digestDir
2434   }
2435   main = "com.threerings.getdown.tools.Digester"
2436 }
2437
2438
2439 task getdownDigest(type: JavaExec) {
2440   group = "distribution"
2441   description = "Digest the getdown website folder"
2442   dependsOn getdownWebsite
2443   doFirst {
2444     classpath = files(getdownLauncher)
2445   }
2446   main = "com.threerings.getdown.tools.Digester"
2447   args getdownAppBaseDir
2448   inputs.dir(getdownAppBaseDir)
2449   outputs.file("${getdownAppBaseDir}/digest2.txt")
2450 }
2451
2452
2453 task getdown() {
2454   group = "distribution"
2455   description = "Create the minimal and full getdown app folder for installers and website and create digest file"
2456   dependsOn getdownDigest
2457   doLast {
2458     if (reportRsyncCommand) {
2459       def fromDir = getdownAppBaseDir + (getdownAppBaseDir.endsWith('/')?'':'/')
2460       def toDir = "${getdown_rsync_dest}/${getdownDir}" + (getdownDir.endsWith('/')?'':'/')
2461       println "LIKELY RSYNC COMMAND:"
2462       println "mkdir -p '$toDir'\nrsync -avh --delete '$fromDir' '$toDir'"
2463       if (RUNRSYNC == "true") {
2464         exec {
2465           commandLine "mkdir", "-p", toDir
2466         }
2467         exec {
2468           commandLine "rsync", "-avh", "--delete", fromDir, toDir
2469         }
2470       }
2471     }
2472   }
2473 }
2474
2475
2476 task getdownArchiveBuild() {
2477   group = "distribution"
2478   description = "Put files in the archive dir to go on the website"
2479
2480   dependsOn getdownWebsite
2481
2482   def v = "v${JALVIEW_VERSION_UNDERSCORES}"
2483   def vDir = "${getdownArchiveDir}/${v}"
2484   getdownFullArchiveDir = "${vDir}/getdown"
2485   getdownVersionLaunchJvl = "${vDir}/jalview-${v}.jvl"
2486
2487   def vAltDir = "alt_${v}"
2488   def archiveImagesDir = "${jalviewDir}/${channel_properties_dir}/old/images"
2489
2490   doFirst {
2491     // cleanup old "old" dir
2492     delete getdownArchiveDir
2493
2494     def getdownArchiveTxt = file("${getdownFullArchiveDir}/getdown.txt")
2495     getdownArchiveTxt.getParentFile().mkdirs()
2496     def getdownArchiveTextLines = []
2497     def getdownFullArchiveAppBase = "${getdownArchiveAppBase}${getdownArchiveAppBase.endsWith("/")?"":"/"}${v}/getdown/"
2498
2499     // the libdir
2500     copy {
2501       from "${getdownAppBaseDir}/${getdownAppDistDir}"
2502       into "${getdownFullArchiveDir}/${vAltDir}"
2503     }
2504
2505     getdownTextLines.each { line ->
2506       line = line.replaceAll("^(?<s>appbase\\s*=\\s*).*", '${s}'+getdownFullArchiveAppBase)
2507       line = line.replaceAll("^(?<s>(resource|code)\\s*=\\s*)${getdownAppDistDir}/", '${s}'+vAltDir+"/")
2508       line = line.replaceAll("^(?<s>ui.background_image\\s*=\\s*).*\\.png", '${s}'+"${getdown_resource_dir}/jalview_archive_getdown_background.png")
2509       line = line.replaceAll("^(?<s>ui.instant_background_image\\s*=\\s*).*\\.png", '${s}'+"${getdown_resource_dir}/jalview_archive_getdown_background_initialising.png")
2510       line = line.replaceAll("^(?<s>ui.error_background\\s*=\\s*).*\\.png", '${s}'+"${getdown_resource_dir}/jalview_archive_getdown_background_error.png")
2511       line = line.replaceAll("^(?<s>ui.progress_image\\s*=\\s*).*\\.png", '${s}'+"${getdown_resource_dir}/jalview_archive_getdown_progress_bar.png")
2512       // remove the existing resource = resource/ or bin/ lines
2513       if (! line.matches("resource\\s*=\\s*(resource|bin)/.*")) {
2514         getdownArchiveTextLines += line
2515       }
2516     }
2517
2518     // the resource dir -- add these files as resource lines in getdown.txt
2519     copy {
2520       from "${archiveImagesDir}"
2521       into "${getdownFullArchiveDir}/${getdown_resource_dir}"
2522       eachFile { file ->
2523         getdownArchiveTextLines += "resource = ${getdown_resource_dir}/${file.getName()}"
2524       }
2525     }
2526
2527     getdownArchiveTxt.write(getdownArchiveTextLines.join("\n"))
2528
2529     def vLaunchJvl = file(getdownVersionLaunchJvl)
2530     vLaunchJvl.getParentFile().mkdirs()
2531     vLaunchJvl.write("appbase=${getdownFullArchiveAppBase}\n")
2532     def vLaunchJvlPath = vLaunchJvl.toPath().toAbsolutePath()
2533     def jvlLinkPath = file("${vDir}/jalview.jvl").toPath().toAbsolutePath()
2534     // for some reason filepath.relativize(fileInSameDirPath) gives a path to "../" which is wrong
2535     //java.nio.file.Files.createSymbolicLink(jvlLinkPath, jvlLinkPath.relativize(vLaunchJvlPath));
2536     java.nio.file.Files.createSymbolicLink(jvlLinkPath, java.nio.file.Paths.get(".",vLaunchJvl.getName()));
2537
2538     // files going into the getdown files dir: getdown.txt, getdown-launcher.jar, channel-launch.jvl, build_properties
2539     copy {
2540       from getdownLauncher
2541       from "${getdownAppBaseDir}/${getdownLaunchJvl}"
2542       from "${getdownAppBaseDir}/${getdown_launcher_new}"
2543       from "${getdownAppBaseDir}/${channel_props}"
2544       if (file(getdownLauncher).getName() != getdown_launcher) {
2545         rename(file(getdownLauncher).getName(), getdown_launcher)
2546       }
2547       into getdownFullArchiveDir
2548     }
2549
2550   }
2551 }
2552
2553 task getdownArchiveDigest(type: JavaExec) {
2554   group = "distribution"
2555   description = "Digest the getdown archive folder"
2556
2557   dependsOn getdownArchiveBuild
2558
2559   doFirst {
2560     classpath = files(getdownLauncher)
2561     args getdownFullArchiveDir
2562   }
2563   main = "com.threerings.getdown.tools.Digester"
2564   inputs.dir(getdownFullArchiveDir)
2565   outputs.file("${getdownFullArchiveDir}/digest2.txt")
2566 }
2567
2568 task getdownArchive() {
2569   group = "distribution"
2570   description = "Build the website archive dir with getdown digest"
2571
2572   dependsOn getdownArchiveBuild
2573   dependsOn getdownArchiveDigest
2574 }
2575
2576 tasks.withType(JavaCompile) {
2577         options.encoding = 'UTF-8'
2578 }
2579
2580
2581 clean {
2582   doFirst {
2583     delete getdownAppBaseDir
2584     delete getdownFilesDir
2585     delete getdownArchiveDir
2586   }
2587 }
2588
2589
2590 install4j {
2591   if (file(install4jHomeDir).exists()) {
2592     // good to go!
2593   } else if (file(System.getProperty("user.home")+"/buildtools/install4j").exists()) {
2594     install4jHomeDir = System.getProperty("user.home")+"/buildtools/install4j"
2595   } else if (file("/Applications/install4j.app/Contents/Resources/app").exists()) {
2596     install4jHomeDir = "/Applications/install4j.app/Contents/Resources/app"
2597   }
2598   installDir(file(install4jHomeDir))
2599
2600   mediaTypes = Arrays.asList(install4j_media_types.split(","))
2601 }
2602
2603
2604 task copyInstall4jTemplate {
2605   def install4jTemplateFile = file("${install4jDir}/${install4j_template}")
2606   def install4jFileAssociationsFile = file("${install4jDir}/${install4j_installer_file_associations}")
2607   inputs.file(install4jTemplateFile)
2608   inputs.file(install4jFileAssociationsFile)
2609   inputs.property("CHANNEL", { CHANNEL })
2610   outputs.file(install4jConfFile)
2611
2612   doLast {
2613     def install4jConfigXml = new XmlParser().parse(install4jTemplateFile)
2614
2615     // turn off code signing if no OSX_KEYPASS
2616     if (OSX_KEYPASS == "") {
2617       install4jConfigXml.'**'.codeSigning.each { codeSigning ->
2618         codeSigning.'@macEnabled' = "false"
2619       }
2620       install4jConfigXml.'**'.windows.each { windows ->
2621         windows.'@runPostProcessor' = "false"
2622       }
2623     }
2624
2625     // disable install screen for OSX dmg (for 2.11.2.0)
2626     install4jConfigXml.'**'.macosArchive.each { macosArchive ->
2627       macosArchive.attributes().remove('executeSetupApp')
2628       macosArchive.attributes().remove('setupAppId')
2629     }
2630
2631     // turn off checksum creation for LOCAL channel
2632     def e = install4jConfigXml.application[0]
2633     e.'@createChecksums' = string(install4jCheckSums)
2634
2635     // put file association actions where placeholder action is
2636     def install4jFileAssociationsText = install4jFileAssociationsFile.text
2637     def fileAssociationActions = new XmlParser().parseText("<actions>${install4jFileAssociationsText}</actions>")
2638     install4jConfigXml.'**'.action.any { a -> // .any{} stops after the first one that returns true
2639       if (a.'@name' == 'EXTENSIONS_REPLACED_BY_GRADLE') {
2640         def parent = a.parent()
2641         parent.remove(a)
2642         fileAssociationActions.each { faa ->
2643             parent.append(faa)
2644         }
2645         // don't need to continue in .any loop once replacements have been made
2646         return true
2647       }
2648     }
2649
2650     // use Windows Program Group with Examples folder for RELEASE, and Program Group without Examples for everything else
2651     // NB we're deleting the /other/ one!
2652     // Also remove the examples subdir from non-release versions
2653     def customizedIdToDelete = "PROGRAM_GROUP_RELEASE"
2654     // 2.11.1.0 NOT releasing with the Examples folder in the Program Group
2655     if (false && CHANNEL=="RELEASE") { // remove 'false && ' to include Examples folder in RELEASE channel
2656       customizedIdToDelete = "PROGRAM_GROUP_NON_RELEASE"
2657     } else {
2658       // remove the examples subdir from Full File Set
2659       def files = install4jConfigXml.files[0]
2660       def fileset = files.filesets.fileset.find { fs -> fs.'@customizedId' == "FULL_FILE_SET" }
2661       def root = files.roots.root.find { r -> r.'@fileset' == fileset.'@id' }
2662       def mountPoint = files.mountPoints.mountPoint.find { mp -> mp.'@root' == root.'@id' }
2663       def dirEntry = files.entries.dirEntry.find { de -> de.'@mountPoint' == mountPoint.'@id' && de.'@subDirectory' == "examples" }
2664       dirEntry.parent().remove(dirEntry)
2665     }
2666     install4jConfigXml.'**'.action.any { a ->
2667       if (a.'@customizedId' == customizedIdToDelete) {
2668         def parent = a.parent()
2669         parent.remove(a)
2670         return true
2671       }
2672     }
2673
2674     // write install4j file
2675     install4jConfFile.text = XmlUtil.serialize(install4jConfigXml)
2676   }
2677 }
2678
2679
2680 clean {
2681   doFirst {
2682     delete install4jConfFile
2683   }
2684 }
2685
2686 task cleanInstallersDataFiles {
2687   def installersOutputTxt = file("${jalviewDir}/${install4jBuildDir}/output.txt")
2688   def installersSha256 = file("${jalviewDir}/${install4jBuildDir}/sha256sums")
2689   def hugoDataJsonFile = file("${jalviewDir}/${install4jBuildDir}/installers-${JALVIEW_VERSION_UNDERSCORES}.json")
2690   doFirst {
2691     delete installersOutputTxt
2692     delete installersSha256
2693     delete hugoDataJsonFile
2694   }
2695 }
2696
2697 task install4jDMGBackgroundImageCopy {
2698   inputs.file "${install4jDMGBackgroundImageDir}/${install4jDMGBackgroundImageFile}"
2699   outputs.dir "${install4jDMGBackgroundImageBuildDir}"
2700   doFirst {
2701     copy {
2702       from(install4jDMGBackgroundImageDir) {
2703         include(install4jDMGBackgroundImageFile)
2704       }
2705       into install4jDMGBackgroundImageBuildDir
2706     }
2707   }
2708 }
2709
2710 task install4jDMGBackgroundImageProcess {
2711   dependsOn install4jDMGBackgroundImageCopy
2712
2713   doFirst {
2714     if (backgroundImageText) {
2715       if (convertBinary == null) {
2716         throw new StopExecutionException("No ImageMagick convert binary installed at '${convertBinaryExpectedLocation}'")
2717       }
2718       if (!project.hasProperty("install4j_background_image_text_suffix_cmd")) {
2719         throw new StopExecutionException("No property 'install4j_background_image_text_suffix_cmd' defined. See channel_gradle.properties for channel ${CHANNEL}")
2720       }
2721       fileTree(dir: install4jDMGBackgroundImageBuildDir, include: "*.png").getFiles().each { file ->
2722         exec {
2723           executable convertBinary
2724           args = [
2725             file.getPath(),
2726             '-font', install4j_background_image_text_font,
2727             '-fill', install4j_background_image_text_colour,
2728             '-draw', sprintf(install4j_background_image_text_suffix_cmd, channelSuffix),
2729             '-draw', sprintf(install4j_background_image_text_commit_cmd, "git-commit: ${gitHash}"),
2730             '-draw', sprintf(install4j_background_image_text_date_cmd, getDate("yyyy-MM-dd HH:mm:ss")),
2731             file.getPath()
2732           ]
2733         }
2734       }
2735     }
2736   }
2737 }
2738
2739 task install4jDMGBackgroundImage {
2740   dependsOn install4jDMGBackgroundImageProcess
2741 }
2742
2743 task installerFiles(type: com.install4j.gradle.Install4jTask) {
2744   group = "distribution"
2745   description = "Create the install4j installers"
2746   dependsOn getdown
2747   dependsOn copyInstall4jTemplate
2748   dependsOn cleanInstallersDataFiles
2749   dependsOn install4jDMGBackgroundImage
2750
2751   projectFile = install4jConfFile
2752
2753   // create an md5 for the input files to use as version for install4j conf file
2754   def digest = MessageDigest.getInstance("MD5")
2755   digest.update(
2756     (file("${install4jDir}/${install4j_template}").text +
2757     file("${install4jDir}/${install4j_info_plist_file_associations}").text +
2758     file("${install4jDir}/${install4j_installer_file_associations}").text).bytes)
2759   def filesMd5 = new BigInteger(1, digest.digest()).toString(16)
2760   if (filesMd5.length() >= 8) {
2761     filesMd5 = filesMd5.substring(0,8)
2762   }
2763   def install4jTemplateVersion = "${JALVIEW_VERSION}_F${filesMd5}_C${gitHash}"
2764
2765   variables = [
2766     'JALVIEW_NAME': jalview_name,
2767     'JALVIEW_APPLICATION_NAME': applicationName,
2768     'JALVIEW_DIR': "../..",
2769     'OSX_KEYSTORE': OSX_KEYSTORE,
2770     'OSX_APPLEID': OSX_APPLEID,
2771     'OSX_ALTOOLPASS': OSX_ALTOOLPASS,
2772     'JSIGN_SH': JSIGN_SH,
2773     'JRE_DIR': getdown_app_dir_java,
2774     'INSTALLER_TEMPLATE_VERSION': install4jTemplateVersion,
2775     'JALVIEW_VERSION': JALVIEW_VERSION,
2776     'JAVA_MIN_VERSION': JAVA_MIN_VERSION,
2777     'JAVA_MAX_VERSION': JAVA_MAX_VERSION,
2778     'JAVA_VERSION': JAVA_VERSION,
2779     'JAVA_INTEGER_VERSION': JAVA_INTEGER_VERSION,
2780     'VERSION': JALVIEW_VERSION,
2781     'COPYRIGHT_MESSAGE': install4j_copyright_message,
2782     'BUNDLE_ID': install4jBundleId,
2783     'INTERNAL_ID': install4jInternalId,
2784     'WINDOWS_APPLICATION_ID': install4jWinApplicationId,
2785     'MACOS_DMG_DS_STORE': install4jDMGDSStore,
2786     'MACOS_DMG_BG_IMAGE': "${install4jDMGBackgroundImageBuildDir}/${install4jDMGBackgroundImageFile}",
2787     'WRAPPER_LINK': getdownWrapperLink,
2788     'BASH_WRAPPER_SCRIPT': getdown_bash_wrapper_script,
2789     'POWERSHELL_WRAPPER_SCRIPT': getdown_powershell_wrapper_script,
2790     'WRAPPER_SCRIPT_BIN_DIR': getdown_wrapper_script_dir,
2791     'INSTALLER_NAME': install4jInstallerName,
2792     'INSTALL4J_UTILS_DIR': install4j_utils_dir,
2793     'GETDOWN_CHANNEL_DIR': getdownChannelDir,
2794     'GETDOWN_FILES_DIR': getdown_files_dir,
2795     'GETDOWN_RESOURCE_DIR': getdown_resource_dir,
2796     'GETDOWN_DIST_DIR': getdownAppDistDir,
2797     'GETDOWN_ALT_DIR': getdown_app_dir_alt,
2798     'GETDOWN_INSTALL_DIR': getdown_install_dir,
2799     'INFO_PLIST_FILE_ASSOCIATIONS_FILE': install4j_info_plist_file_associations,
2800     'BUILD_DIR': install4jBuildDir,
2801     'APPLICATION_CATEGORIES': install4j_application_categories,
2802     'APPLICATION_FOLDER': install4jApplicationFolder,
2803     'UNIX_APPLICATION_FOLDER': install4jUnixApplicationFolder,
2804     'EXECUTABLE_NAME': install4jExecutableName,
2805     'EXTRA_SCHEME': install4jExtraScheme,
2806     'MAC_ICONS_FILE': install4jMacIconsFile,
2807     'WINDOWS_ICONS_FILE': install4jWindowsIconsFile,
2808     'PNG_ICON_FILE': install4jPngIconFile,
2809     'BACKGROUND': install4jBackground,
2810   ]
2811
2812   def varNameMap = [
2813     'mac': 'MACOS',
2814     'windows': 'WINDOWS',
2815     'linux': 'LINUX'
2816   ]
2817
2818   // these are the bundled OS/architecture VMs needed by install4j
2819   def osArch = [
2820     [ "mac", "x64" ],
2821     [ "mac", "aarch64" ],
2822     [ "windows", "x64" ],
2823     [ "linux", "x64" ],
2824     [ "linux", "aarch64" ]
2825   ]
2826   osArch.forEach { os, arch ->
2827     variables[ sprintf("%s_%s_JAVA_VM_DIR", varNameMap[os], arch.toUpperCase(Locale.ROOT)) ] = sprintf("%s/jre-%s-%s-%s/jre", jreInstallsDir, JAVA_INTEGER_VERSION, os, arch)
2828     // N.B. For some reason install4j requires the below filename to have underscores and not hyphens
2829     // otherwise running `gradle installers` generates a non-useful error:
2830     // `install4j: compilation failed. Reason: java.lang.NumberFormatException: For input string: "windows"`
2831     variables[ sprintf("%s_%s_JAVA_VM_TGZ", varNameMap[os], arch.toUpperCase(Locale.ROOT)) ] = sprintf("%s/tgz/jre_%s_%s_%s.tar.gz", jreInstallsDir, JAVA_INTEGER_VERSION, os, arch)
2832   }
2833
2834   //println("INSTALL4J VARIABLES:")
2835   //variables.each{k,v->println("${k}=${v}")}
2836
2837   destination = "${jalviewDir}/${install4jBuildDir}"
2838   buildSelected = true
2839
2840   if (install4j_faster.equals("true") || CHANNEL.startsWith("LOCAL")) {
2841     faster = true
2842     disableSigning = true
2843     disableNotarization = true
2844   }
2845
2846   if (OSX_KEYPASS) {
2847     macKeystorePassword = OSX_KEYPASS
2848   }
2849
2850   if (OSX_ALTOOLPASS) {
2851     appleIdPassword = OSX_ALTOOLPASS
2852     disableNotarization = false
2853   } else {
2854     disableNotarization = true
2855   }
2856
2857   doFirst {
2858     println("Using projectFile "+projectFile)
2859     if (!disableNotarization) { println("Will notarize OSX App DMG") }
2860   }
2861   //verbose=true
2862
2863   inputs.dir(getdownAppBaseDir)
2864   inputs.file(install4jConfFile)
2865   inputs.file("${install4jDir}/${install4j_info_plist_file_associations}")
2866   outputs.dir("${jalviewDir}/${install4j_build_dir}/${JAVA_VERSION}")
2867 }
2868
2869 def getDataHash(File myFile) {
2870   HashCode hash = Files.asByteSource(myFile).hash(Hashing.sha256())
2871   return myFile.exists()
2872   ? [
2873       "file" : myFile.getName(),
2874       "filesize" : myFile.length(),
2875       "sha256" : hash.toString()
2876     ]
2877   : null
2878 }
2879
2880 def writeDataJsonFile(File installersOutputTxt, File installersSha256, File dataJsonFile) {
2881   def hash = [
2882     "channel" : getdownChannelName,
2883     "date" : getDate("yyyy-MM-dd HH:mm:ss"),
2884     "git-commit" : "${gitHash} [${gitBranch}]",
2885     "version" : JALVIEW_VERSION
2886   ]
2887   // install4j installer files
2888   if (installersOutputTxt.exists()) {
2889     def idHash = [:]
2890     installersOutputTxt.readLines().each { def line ->
2891       if (line.startsWith("#")) {
2892         return;
2893       }
2894       line.replaceAll("\n","")
2895       def vals = line.split("\t")
2896       def filename = vals[3]
2897       def filesize = file(filename).length()
2898       filename = filename.replaceAll(/^.*\//, "")
2899       hash[vals[0]] = [ "id" : vals[0], "os" : vals[1], "name" : vals[2], "file" : filename, "filesize" : filesize ]
2900       idHash."${filename}" = vals[0]
2901     }
2902     if (install4jCheckSums && installersSha256.exists()) {
2903       installersSha256.readLines().each { def line ->
2904         if (line.startsWith("#")) {
2905           return;
2906         }
2907         line.replaceAll("\n","")
2908         def vals = line.split(/\s+\*?/)
2909         def filename = vals[1]
2910         def innerHash = (hash.(idHash."${filename}"))."sha256" = vals[0]
2911       }
2912     }
2913   }
2914
2915   [
2916     "JAR": shadowJar.archiveFile, // executable JAR
2917     "JVL": getdownVersionLaunchJvl, // version JVL
2918     "SOURCE": sourceDist.archiveFile // source TGZ
2919   ].each { key, value ->
2920     def file = file(value)
2921     if (file.exists()) {
2922       def fileHash = getDataHash(file)
2923       if (fileHash != null) {
2924         hash."${key}" = fileHash;
2925       }
2926     }
2927   }
2928   return dataJsonFile.write(new JsonBuilder(hash).toPrettyString())
2929 }
2930
2931 task staticMakeInstallersJsonFile {
2932   doFirst {
2933     def output = findProperty("i4j_output")
2934     def sha256 = findProperty("i4j_sha256")
2935     def json = findProperty("i4j_json")
2936     if (output == null || sha256 == null || json == null) {
2937       throw new GradleException("Must provide paths to all of output.txt, sha256sums, and output.json with '-Pi4j_output=... -Pi4j_sha256=... -Pi4j_json=...")
2938     }
2939     writeDataJsonFile(file(output), file(sha256), file(json))
2940   }
2941 }
2942
2943 task installers {
2944   dependsOn installerFiles
2945 }
2946
2947
2948 spotless {
2949   java {
2950     eclipse().configFile(eclipse_codestyle_file)
2951   }
2952 }
2953
2954 task createSourceReleaseProperties(type: WriteProperties) {
2955   group = "distribution"
2956   description = "Create the source RELEASE properties file"
2957
2958   def sourceTarBuildDir = "${buildDir}/sourceTar"
2959   def sourceReleasePropertiesFile = "${sourceTarBuildDir}/RELEASE"
2960   outputFile (sourceReleasePropertiesFile)
2961
2962   doFirst {
2963     releaseProps.each{ key, val -> property key, val }
2964     property "git.branch", gitBranch
2965     property "git.hash", gitHash
2966   }
2967
2968   outputs.file(outputFile)
2969 }
2970
2971 task sourceDist(type: Tar) {
2972   group "distribution"
2973   description "Create a source .tar.gz file for distribution"
2974
2975   dependsOn createBuildProperties
2976   dependsOn convertMdFiles
2977   dependsOn eclipseAllPreferences
2978   dependsOn createSourceReleaseProperties
2979
2980
2981   def outputFileName = "${project.name}_${JALVIEW_VERSION_UNDERSCORES}.tar.gz"
2982   archiveFileName = outputFileName
2983
2984   compression Compression.GZIP
2985
2986   into project.name
2987
2988   def EXCLUDE_FILES=[
2989     "build/*",
2990     "bin/*",
2991     "test-output/",
2992     "test-reports",
2993     "tests",
2994     "clover*/*",
2995     ".*",
2996     "benchmarking/*",
2997     "**/.*",
2998     "*.class",
2999     "**/*.class","$j11modDir/**/*.jar","appletlib","**/*locales",
3000     "*locales/**",
3001     "utils/InstallAnywhere",
3002     "**/*.log",
3003     "RELEASE",
3004   ]
3005   def PROCESS_FILES=[
3006     "AUTHORS",
3007     "CITATION",
3008     "FEATURETODO",
3009     "JAVA-11-README",
3010     "FEATURETODO",
3011     "LICENSE",
3012     "**/README",
3013     "THIRDPARTYLIBS",
3014     "TESTNG",
3015     "build.gradle",
3016     "gradle.properties",
3017     "**/*.java",
3018     "**/*.html",
3019     "**/*.xml",
3020     "**/*.gradle",
3021     "**/*.groovy",
3022     "**/*.properties",
3023     "**/*.perl",
3024     "**/*.sh",
3025   ]
3026   def INCLUDE_FILES=[
3027     ".classpath",
3028     ".settings/org.eclipse.buildship.core.prefs",
3029     ".settings/org.eclipse.jdt.core.prefs"
3030   ]
3031
3032   from(jalviewDir) {
3033     exclude (EXCLUDE_FILES)
3034     include (PROCESS_FILES)
3035     filter(ReplaceTokens,
3036       beginToken: '$$',
3037       endToken: '$$',
3038       tokens: [
3039         'Version-Rel': JALVIEW_VERSION,
3040         'Year-Rel': getDate("yyyy")
3041       ]
3042     )
3043   }
3044   from(jalviewDir) {
3045     exclude (EXCLUDE_FILES)
3046     exclude (PROCESS_FILES)
3047     exclude ("appletlib")
3048     exclude ("**/*locales")
3049     exclude ("*locales/**")
3050     exclude ("utils/InstallAnywhere")
3051
3052     exclude (getdown_files_dir)
3053     // getdown_website_dir and getdown_archive_dir moved to build/website/docroot/getdown
3054     //exclude (getdown_website_dir)
3055     //exclude (getdown_archive_dir)
3056
3057     // exluding these as not using jars as modules yet
3058     exclude ("${j11modDir}/**/*.jar")
3059   }
3060   from(jalviewDir) {
3061     include(INCLUDE_FILES)
3062   }
3063 //  from (jalviewDir) {
3064 //    // explicit includes for stuff that seemed to not get included
3065 //    include(fileTree("test/**/*."))
3066 //    exclude(EXCLUDE_FILES)
3067 //    exclude(PROCESS_FILES)
3068 //  }
3069
3070   from(file(buildProperties).getParent()) {
3071     include(file(buildProperties).getName())
3072     rename(file(buildProperties).getName(), "build_properties")
3073     filter({ line ->
3074       line.replaceAll("^INSTALLATION=.*\$","INSTALLATION=Source Release"+" git-commit\\\\:"+gitHash+" ["+gitBranch+"]")
3075     })
3076   }
3077
3078   def sourceTarBuildDir = "${buildDir}/sourceTar"
3079   from(sourceTarBuildDir) {
3080     // this includes the appended RELEASE properties file
3081   }
3082 }
3083
3084 task dataInstallersJson {
3085   group "website"
3086   description "Create the installers-VERSION.json data file for installer files created"
3087
3088   mustRunAfter installers
3089   mustRunAfter shadowJar
3090   mustRunAfter sourceDist
3091   mustRunAfter getdownArchive
3092
3093   def installersOutputTxt = file("${jalviewDir}/${install4jBuildDir}/output.txt")
3094   def installersSha256 = file("${jalviewDir}/${install4jBuildDir}/sha256sums")
3095
3096   if (installersOutputTxt.exists()) {
3097     inputs.file(installersOutputTxt)
3098   }
3099   if (install4jCheckSums && installersSha256.exists()) {
3100     inputs.file(installersSha256)
3101   }
3102   [
3103     shadowJar.archiveFile, // executable JAR
3104     getdownVersionLaunchJvl, // version JVL
3105     sourceDist.archiveFile // source TGZ
3106   ].each { fileName ->
3107     if (file(fileName).exists()) {
3108       inputs.file(fileName)
3109     }
3110   }
3111
3112   outputs.file(hugoDataJsonFile)
3113
3114   doFirst {
3115     writeDataJsonFile(installersOutputTxt, installersSha256, hugoDataJsonFile)
3116   }
3117 }
3118
3119 task helppages {
3120   group "help"
3121   description "Copies all help pages to build dir. Runs ant task 'pubhtmlhelp'."
3122
3123   dependsOn copyHelp
3124   dependsOn pubhtmlhelp
3125
3126   inputs.dir("${helpBuildDir}/${help_dir}")
3127   outputs.dir("${buildDir}/distributions/${help_dir}")
3128 }
3129
3130
3131 task j2sSetHeadlessBuild {
3132   doFirst {
3133     IN_ECLIPSE = false
3134   }
3135 }
3136
3137
3138 task jalviewjsEnableAltFileProperty(type: WriteProperties) {
3139   group "jalviewjs"
3140   description "Enable the alternative J2S Config file for headless build"
3141
3142   outputFile = jalviewjsJ2sSettingsFileName
3143   def j2sPropsFile = file(jalviewjsJ2sSettingsFileName)
3144   def j2sProps = new Properties()
3145   if (j2sPropsFile.exists()) {
3146     try {
3147       def j2sPropsFileFIS = new FileInputStream(j2sPropsFile)
3148       j2sProps.load(j2sPropsFileFIS)
3149       j2sPropsFileFIS.close()
3150
3151       j2sProps.each { prop, val ->
3152         property(prop, val)
3153       }
3154     } catch (Exception e) {
3155       println("Exception reading ${jalviewjsJ2sSettingsFileName}")
3156       e.printStackTrace()
3157     }
3158   }
3159   if (! j2sProps.stringPropertyNames().contains(jalviewjs_j2s_alt_file_property_config)) {
3160     property(jalviewjs_j2s_alt_file_property_config, jalviewjs_j2s_alt_file_property)
3161   }
3162 }
3163
3164
3165 task jalviewjsSetEclipseWorkspace {
3166   def propKey = "jalviewjs_eclipse_workspace"
3167   def propVal = null
3168   if (project.hasProperty(propKey)) {
3169     propVal = project.getProperty(propKey)
3170     if (propVal.startsWith("~/")) {
3171       propVal = System.getProperty("user.home") + propVal.substring(1)
3172     }
3173   }
3174   def propsFileName = "${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_eclipse_workspace_location_file}"
3175   def propsFile = file(propsFileName)
3176   def eclipseWsDir = propVal
3177   def props = new Properties()
3178
3179   def writeProps = true
3180   if (( eclipseWsDir == null || !file(eclipseWsDir).exists() ) && propsFile.exists()) {
3181     def ins = new FileInputStream(propsFileName)
3182     props.load(ins)
3183     ins.close()
3184     if (props.getProperty(propKey, null) != null) {
3185       eclipseWsDir = props.getProperty(propKey)
3186       writeProps = false
3187     }
3188   }
3189
3190   if (eclipseWsDir == null || !file(eclipseWsDir).exists()) {
3191     def tempDir = File.createTempDir()
3192     eclipseWsDir = tempDir.getAbsolutePath()
3193     writeProps = true
3194   }
3195   eclipseWorkspace = file(eclipseWsDir)
3196
3197   doFirst {
3198     // do not run a headless transpile when we claim to be in Eclipse
3199     if (IN_ECLIPSE) {
3200       println("Skipping task ${name} as IN_ECLIPSE=${IN_ECLIPSE}")
3201       throw new StopExecutionException("Not running headless transpile whilst IN_ECLIPSE is '${IN_ECLIPSE}'")
3202     } else {
3203       println("Running task ${name} as IN_ECLIPSE=${IN_ECLIPSE}")
3204     }
3205
3206     if (writeProps) {
3207       props.setProperty(propKey, eclipseWsDir)
3208       propsFile.parentFile.mkdirs()
3209       def bytes = new ByteArrayOutputStream()
3210       props.store(bytes, null)
3211       def propertiesString = bytes.toString()
3212       propsFile.text = propertiesString
3213       print("NEW ")
3214     } else {
3215       print("EXISTING ")
3216     }
3217
3218     println("ECLIPSE WORKSPACE: "+eclipseWorkspace.getPath())
3219   }
3220
3221   //inputs.property(propKey, eclipseWsDir) // eclipseWsDir only gets set once this task runs, so will be out-of-date
3222   outputs.file(propsFileName)
3223   outputs.upToDateWhen { eclipseWorkspace.exists() && propsFile.exists() }
3224 }
3225
3226
3227 task jalviewjsEclipsePaths {
3228   def eclipseProduct
3229
3230   def eclipseRoot = jalviewjs_eclipse_root
3231   if (eclipseRoot.startsWith("~/")) {
3232     eclipseRoot = System.getProperty("user.home") + eclipseRoot.substring(1)
3233   }
3234   if (OperatingSystem.current().isMacOsX()) {
3235     eclipseRoot += "/Eclipse.app"
3236     eclipseBinary = "${eclipseRoot}/Contents/MacOS/eclipse"
3237     eclipseProduct = "${eclipseRoot}/Contents/Eclipse/.eclipseproduct"
3238   } else if (OperatingSystem.current().isWindows()) { // check these paths!!
3239     if (file("${eclipseRoot}/eclipse").isDirectory() && file("${eclipseRoot}/eclipse/.eclipseproduct").exists()) {
3240       eclipseRoot += "/eclipse"
3241     }
3242     eclipseBinary = "${eclipseRoot}/eclipse.exe"
3243     eclipseProduct = "${eclipseRoot}/.eclipseproduct"
3244   } else { // linux or unix
3245     if (file("${eclipseRoot}/eclipse").isDirectory() && file("${eclipseRoot}/eclipse/.eclipseproduct").exists()) {
3246       eclipseRoot += "/eclipse"
3247 println("eclipseDir exists")
3248     }
3249     eclipseBinary = "${eclipseRoot}/eclipse"
3250     eclipseProduct = "${eclipseRoot}/.eclipseproduct"
3251   }
3252
3253   eclipseVersion = "4.13" // default
3254   def assumedVersion = true
3255   if (file(eclipseProduct).exists()) {
3256     def fis = new FileInputStream(eclipseProduct)
3257     def props = new Properties()
3258     props.load(fis)
3259     eclipseVersion = props.getProperty("version")
3260     fis.close()
3261     assumedVersion = false
3262   }
3263
3264   def propKey = "eclipse_debug"
3265   eclipseDebug = (project.hasProperty(propKey) && project.getProperty(propKey).equals("true"))
3266
3267   doFirst {
3268     // do not run a headless transpile when we claim to be in Eclipse
3269     if (IN_ECLIPSE) {
3270       println("Skipping task ${name} as IN_ECLIPSE=${IN_ECLIPSE}")
3271       throw new StopExecutionException("Not running headless transpile whilst IN_ECLIPSE is '${IN_ECLIPSE}'")
3272     } else {
3273       println("Running task ${name} as IN_ECLIPSE=${IN_ECLIPSE}")
3274     }
3275
3276     if (!assumedVersion) {
3277       println("ECLIPSE VERSION=${eclipseVersion}")
3278     }
3279   }
3280 }
3281
3282
3283 task printProperties {
3284   group "Debug"
3285   description "Output to console all System.properties"
3286   doFirst {
3287     System.properties.each { key, val -> System.out.println("Property: ${key}=${val}") }
3288   }
3289 }
3290
3291
3292 task eclipseSetup {
3293   dependsOn eclipseProject
3294   dependsOn eclipseClasspath
3295   dependsOn eclipseJdt
3296 }
3297
3298
3299 // this version (type: Copy) will delete anything in the eclipse dropins folder that isn't in fromDropinsDir
3300 task jalviewjsEclipseCopyDropins(type: Copy) {
3301   dependsOn jalviewjsEclipsePaths
3302
3303   def inputFiles = fileTree(dir: "${jalviewDir}/${jalviewjs_eclipse_dropins_dir}", include: "*.jar")
3304   inputFiles += file("${jalviewDir}/${jalviewjsJ2sPlugin}")
3305   def outputDir = "${jalviewDir}/${jalviewjsBuildDir}/${jalviewjs_eclipse_tmp_dropins_dir}"
3306
3307   from inputFiles
3308   into outputDir
3309 }
3310
3311
3312 // this eclipse -clean doesn't actually work
3313 task jalviewjsCleanEclipse(type: Exec) {
3314   dependsOn eclipseSetup
3315   dependsOn jalviewjsEclipsePaths
3316   dependsOn jalviewjsEclipseCopyDropins
3317
3318   executable(eclipseBinary)
3319   args(["-nosplash", "--launcher.suppressErrors", "-data", eclipseWorkspace.getPath(), "-clean", "-console", "-consoleLog"])
3320   if (eclipseDebug) {
3321     args += "-debug"
3322   }
3323   args += "-l"
3324
3325   def inputString = """exit
3326 y
3327 """
3328   def inputByteStream = new ByteArrayInputStream(inputString.getBytes())
3329   standardInput = inputByteStream
3330 }
3331
3332 /* not really working yet
3333 jalviewjsEclipseCopyDropins.finalizedBy jalviewjsCleanEclipse
3334 */
3335
3336
3337 task jalviewjsTransferUnzipSwingJs {
3338   def file_zip = "${jalviewDir}/${jalviewjs_swingjs_zip}"
3339
3340   doLast {
3341     copy {
3342       from zipTree(file_zip)
3343       into "${jalviewDir}/${jalviewjsTransferSiteSwingJsDir}"
3344     }
3345   }
3346
3347   inputs.file file_zip
3348   outputs.dir "${jalviewDir}/${jalviewjsTransferSiteSwingJsDir}"
3349 }
3350
3351
3352 task jalviewjsTransferUnzipLib {
3353   def zipFiles = fileTree(dir: "${jalviewDir}/${jalviewjs_libjs_dir}", include: "*.zip")
3354
3355   doLast {
3356     zipFiles.each { file_zip ->
3357       copy {
3358         from zipTree(file_zip)
3359         into "${jalviewDir}/${jalviewjsTransferSiteLibDir}"
3360       }
3361     }
3362   }
3363
3364   inputs.files zipFiles
3365   outputs.dir "${jalviewDir}/${jalviewjsTransferSiteLibDir}"
3366 }
3367
3368
3369 task jalviewjsTransferUnzipAllLibs {
3370   dependsOn jalviewjsTransferUnzipSwingJs
3371   dependsOn jalviewjsTransferUnzipLib
3372 }
3373
3374
3375 task jalviewjsCreateJ2sSettings(type: WriteProperties) {
3376   group "JalviewJS"
3377   description "Create the alternative j2s file from the j2s.* properties"
3378
3379   jalviewjsJ2sProps = project.properties.findAll { it.key.startsWith("j2s.") }.sort { it.key }
3380   def siteDirProperty = "j2s.site.directory"
3381   def setSiteDir = false
3382   jalviewjsJ2sProps.each { prop, val ->
3383     if (val != null) {
3384       if (prop == siteDirProperty) {
3385         if (!(val.startsWith('/') || val.startsWith("file://") )) {
3386           val = "${jalviewDir}/${jalviewjsTransferSiteJsDir}/${val}"
3387         }
3388         setSiteDir = true
3389       }
3390       property(prop,val)
3391     }
3392     if (!setSiteDir) { // default site location, don't override specifically set property
3393       property(siteDirProperty,"${jalviewDirRelativePath}/${jalviewjsTransferSiteJsDir}")
3394     }
3395   }
3396   outputFile = jalviewjsJ2sAltSettingsFileName
3397
3398   if (! IN_ECLIPSE) {
3399     inputs.properties(jalviewjsJ2sProps)
3400     outputs.file(jalviewjsJ2sAltSettingsFileName)
3401   }
3402 }
3403
3404
3405 task jalviewjsEclipseSetup {
3406   dependsOn jalviewjsEclipseCopyDropins
3407   dependsOn jalviewjsSetEclipseWorkspace
3408   dependsOn jalviewjsCreateJ2sSettings
3409 }
3410
3411
3412 task jalviewjsSyncAllLibs (type: Sync) {
3413   dependsOn jalviewjsTransferUnzipAllLibs
3414   def inputFiles = fileTree(dir: "${jalviewDir}/${jalviewjsTransferSiteLibDir}")
3415   inputFiles += fileTree(dir: "${jalviewDir}/${jalviewjsTransferSiteSwingJsDir}")
3416   def outputDir = "${jalviewDir}/${jalviewjsSiteDir}"
3417
3418   from inputFiles
3419   into outputDir
3420   def outputFiles = []
3421   rename { filename ->
3422     outputFiles += "${outputDir}/${filename}"
3423     null
3424   }
3425   preserve {
3426     include "**"
3427   }
3428
3429   // should this be exclude really ?
3430   duplicatesStrategy "INCLUDE"
3431
3432   outputs.files outputFiles
3433   inputs.files inputFiles
3434 }
3435
3436
3437 task jalviewjsSyncResources (type: Sync) {
3438   dependsOn buildResources
3439
3440   def inputFiles = fileTree(dir: resourcesBuildDir)
3441   def outputDir = "${jalviewDir}/${jalviewjsSiteDir}/${jalviewjs_j2s_subdir}"
3442
3443   from inputFiles
3444   into outputDir
3445   def outputFiles = []
3446   rename { filename ->
3447     outputFiles += "${outputDir}/${filename}"
3448     null
3449   }
3450   preserve {
3451     include "**"
3452   }
3453   outputs.files outputFiles
3454   inputs.files inputFiles
3455 }
3456
3457
3458 task jalviewjsSyncSiteResources (type: Sync) {
3459   def inputFiles = fileTree(dir: "${jalviewDir}/${jalviewjs_site_resource_dir}")
3460   def outputDir = "${jalviewDir}/${jalviewjsSiteDir}"
3461
3462   from inputFiles
3463   into outputDir
3464   def outputFiles = []
3465   rename { filename ->
3466     outputFiles += "${outputDir}/${filename}"
3467     null
3468   }
3469   preserve {
3470     include "**"
3471   }
3472   outputs.files outputFiles
3473   inputs.files inputFiles
3474 }
3475
3476
3477 task jalviewjsSyncBuildProperties (type: Sync) {
3478   dependsOn createBuildProperties
3479   def inputFiles = [file(buildProperties)]
3480   def outputDir = "${jalviewDir}/${jalviewjsSiteDir}/${jalviewjs_j2s_subdir}"
3481
3482   from inputFiles
3483   into outputDir
3484   def outputFiles = []
3485   rename { filename ->
3486     outputFiles += "${outputDir}/${filename}"
3487     null
3488   }
3489   preserve {
3490     include "**"
3491   }
3492   outputs.files outputFiles
3493   inputs.files inputFiles
3494 }
3495
3496
3497 task jalviewjsProjectImport(type: Exec) {
3498   dependsOn eclipseSetup
3499   dependsOn jalviewjsEclipsePaths
3500   dependsOn jalviewjsEclipseSetup
3501
3502   doFirst {
3503     // do not run a headless import when we claim to be in Eclipse
3504     if (IN_ECLIPSE) {
3505       println("Skipping task ${name} as IN_ECLIPSE=${IN_ECLIPSE}")
3506       throw new StopExecutionException("Not running headless import whilst IN_ECLIPSE is '${IN_ECLIPSE}'")
3507     } else {
3508       println("Running task ${name} as IN_ECLIPSE=${IN_ECLIPSE}")
3509     }
3510   }
3511
3512   //def projdir = eclipseWorkspace.getPath()+"/.metadata/.plugins/org.eclipse.core.resources/.projects/jalview/org.eclipse.jdt.core"
3513   def projdir = eclipseWorkspace.getPath()+"/.metadata/.plugins/org.eclipse.core.resources/.projects/jalview"
3514   executable(eclipseBinary)
3515   args(["-nosplash", "--launcher.suppressErrors", "-application", "com.seeq.eclipse.importprojects.headlessimport", "-data", eclipseWorkspace.getPath(), "-import", jalviewDirAbsolutePath])
3516   if (eclipseDebug) {
3517     args += "-debug"
3518   }
3519   args += [ "--launcher.appendVmargs", "-vmargs", "-Dorg.eclipse.equinox.p2.reconciler.dropins.directory=${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_eclipse_tmp_dropins_dir}" ]
3520   if (!IN_ECLIPSE) {
3521     args += [ "-D${j2sHeadlessBuildProperty}=true" ]
3522     args += [ "-D${jalviewjs_j2s_alt_file_property}=${jalviewjsJ2sAltSettingsFileName}" ]
3523   }
3524
3525   inputs.file("${jalviewDir}/.project")
3526   outputs.upToDateWhen {
3527     file(projdir).exists()
3528   }
3529 }
3530
3531
3532 task jalviewjsTranspile(type: Exec) {
3533   dependsOn jalviewjsEclipseSetup
3534   dependsOn jalviewjsProjectImport
3535   dependsOn jalviewjsEclipsePaths
3536   if (!IN_ECLIPSE) {
3537     dependsOn jalviewjsEnableAltFileProperty
3538   }
3539
3540   doFirst {
3541     // do not run a headless transpile when we claim to be in Eclipse
3542     if (IN_ECLIPSE) {
3543       println("Skipping task ${name} as IN_ECLIPSE=${IN_ECLIPSE}")
3544       throw new StopExecutionException("Not running headless transpile whilst IN_ECLIPSE is '${IN_ECLIPSE}'")
3545     } else {
3546       println("Running task ${name} as IN_ECLIPSE=${IN_ECLIPSE}")
3547     }
3548   }
3549
3550   executable(eclipseBinary)
3551   args(["-nosplash", "--launcher.suppressErrors", "-application", "org.eclipse.jdt.apt.core.aptBuild", "-data", eclipseWorkspace, "-${jalviewjs_eclipse_build_arg}", eclipse_project_name ])
3552   if (eclipseDebug) {
3553     args += "-debug"
3554   }
3555   args += [ "--launcher.appendVmargs", "-vmargs", "-Dorg.eclipse.equinox.p2.reconciler.dropins.directory=${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_eclipse_tmp_dropins_dir}" ]
3556   if (!IN_ECLIPSE) {
3557     args += [ "-D${j2sHeadlessBuildProperty}=true" ]
3558     args += [ "-D${jalviewjs_j2s_alt_file_property}=${jalviewjsJ2sAltSettingsFileName}" ]
3559   }
3560
3561   def stdout
3562   def stderr
3563   doFirst {
3564     stdout = new ByteArrayOutputStream()
3565     stderr = new ByteArrayOutputStream()
3566
3567     def logOutFileName = "${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_j2s_transpile_stdout}"
3568     def logOutFile = file(logOutFileName)
3569     logOutFile.createNewFile()
3570     logOutFile.text = """ROOT: ${jalviewjs_eclipse_root}
3571 BINARY: ${eclipseBinary}
3572 VERSION: ${eclipseVersion}
3573 WORKSPACE: ${eclipseWorkspace}
3574 DEBUG: ${eclipseDebug}
3575 ----
3576 """
3577     def logOutFOS = new FileOutputStream(logOutFile, true) // true == append
3578     // combine stdout and stderr
3579     def logErrFOS = logOutFOS
3580
3581     if (jalviewjs_j2s_to_console.equals("true")) {
3582       standardOutput = new org.apache.tools.ant.util.TeeOutputStream(
3583         new org.apache.tools.ant.util.TeeOutputStream(
3584           logOutFOS,
3585           stdout),
3586         System.out)
3587       errorOutput = new org.apache.tools.ant.util.TeeOutputStream(
3588         new org.apache.tools.ant.util.TeeOutputStream(
3589           logErrFOS,
3590           stderr),
3591         System.err)
3592     } else {
3593       standardOutput = new org.apache.tools.ant.util.TeeOutputStream(
3594         logOutFOS,
3595         stdout)
3596       errorOutput = new org.apache.tools.ant.util.TeeOutputStream(
3597         logErrFOS,
3598         stderr)
3599     }
3600   }
3601
3602   doLast {
3603     if (stdout.toString().contains("Error processing ")) {
3604       // j2s did not complete transpile
3605       //throw new TaskExecutionException("Error during transpilation:\n${stderr}\nSee eclipse transpile log file '${jalviewDir}/${jalviewjsBuildDir}/${jalviewjs_j2s_transpile_stdout}'")
3606       if (jalviewjs_ignore_transpile_errors.equals("true")) {
3607         println("IGNORING TRANSPILE ERRORS")
3608         println("See eclipse transpile log file '${jalviewDir}/${jalviewjsBuildDir}/${jalviewjs_j2s_transpile_stdout}'")
3609       } else {
3610         throw new GradleException("Error during transpilation:\n${stderr}\nSee eclipse transpile log file '${jalviewDir}/${jalviewjsBuildDir}/${jalviewjs_j2s_transpile_stdout}'")
3611       }
3612     }
3613   }
3614
3615   inputs.dir("${jalviewDir}/${sourceDir}")
3616   outputs.dir("${jalviewDir}/${jalviewjsTransferSiteJsDir}")
3617   outputs.upToDateWhen( { file("${jalviewDir}/${jalviewjsTransferSiteJsDir}${jalviewjs_server_resource}").exists() } )
3618 }
3619
3620
3621 def jalviewjsCallCore(String name, FileCollection list, String prefixFile, String suffixFile, String jsfile, String zjsfile, File logOutFile, Boolean logOutConsole) {
3622
3623   def stdout = new ByteArrayOutputStream()
3624   def stderr = new ByteArrayOutputStream()
3625
3626   def coreFile = file(jsfile)
3627   def msg = ""
3628   msg = "Creating core for ${name}...\nGenerating ${jsfile}"
3629   println(msg)
3630   logOutFile.createNewFile()
3631   logOutFile.append(msg+"\n")
3632
3633   def coreTop = file(prefixFile)
3634   def coreBottom = file(suffixFile)
3635   coreFile.getParentFile().mkdirs()
3636   coreFile.createNewFile()
3637   coreFile.write( coreTop.getText("UTF-8") )
3638   list.each {
3639     f ->
3640     if (f.exists()) {
3641       def t = f.getText("UTF-8")
3642       t.replaceAll("Clazz\\.([^_])","Clazz_${1}")
3643       coreFile.append( t )
3644     } else {
3645       msg = "...file '"+f.getPath()+"' does not exist, skipping"
3646       println(msg)
3647       logOutFile.append(msg+"\n")
3648     }
3649   }
3650   coreFile.append( coreBottom.getText("UTF-8") )
3651
3652   msg = "Generating ${zjsfile}"
3653   println(msg)
3654   logOutFile.append(msg+"\n")
3655   def logOutFOS = new FileOutputStream(logOutFile, true) // true == append
3656   def logErrFOS = logOutFOS
3657
3658   javaexec {
3659     classpath = files(["${jalviewDir}/${jalviewjs_closure_compiler}"])
3660     main = "com.google.javascript.jscomp.CommandLineRunner"
3661     jvmArgs = [ "-Dfile.encoding=UTF-8" ]
3662     args = [ "--compilation_level", "SIMPLE_OPTIMIZATIONS", "--warning_level", "QUIET", "--charset", "UTF-8", "--js", jsfile, "--js_output_file", zjsfile ]
3663     maxHeapSize = "2g"
3664
3665     msg = "\nRunning '"+commandLine.join(' ')+"'\n"
3666     println(msg)
3667     logOutFile.append(msg+"\n")
3668
3669     if (logOutConsole) {
3670       standardOutput = new org.apache.tools.ant.util.TeeOutputStream(
3671         new org.apache.tools.ant.util.TeeOutputStream(
3672           logOutFOS,
3673           stdout),
3674         standardOutput)
3675         errorOutput = new org.apache.tools.ant.util.TeeOutputStream(
3676           new org.apache.tools.ant.util.TeeOutputStream(
3677             logErrFOS,
3678             stderr),
3679           System.err)
3680     } else {
3681       standardOutput = new org.apache.tools.ant.util.TeeOutputStream(
3682         logOutFOS,
3683         stdout)
3684         errorOutput = new org.apache.tools.ant.util.TeeOutputStream(
3685           logErrFOS,
3686           stderr)
3687     }
3688   }
3689   msg = "--"
3690   println(msg)
3691   logOutFile.append(msg+"\n")
3692 }
3693
3694
3695 task jalviewjsBuildAllCores {
3696   group "JalviewJS"
3697   description "Build the core js lib closures listed in the classlists dir"
3698   dependsOn jalviewjsTranspile
3699   dependsOn jalviewjsTransferUnzipSwingJs
3700
3701   def j2sDir = "${jalviewDir}/${jalviewjsTransferSiteJsDir}/${jalviewjs_j2s_subdir}"
3702   def swingJ2sDir = "${jalviewDir}/${jalviewjsTransferSiteSwingJsDir}/${jalviewjs_j2s_subdir}"
3703   def libJ2sDir = "${jalviewDir}/${jalviewjsTransferSiteLibDir}/${jalviewjs_j2s_subdir}"
3704   def jsDir = "${jalviewDir}/${jalviewjsTransferSiteSwingJsDir}/${jalviewjs_js_subdir}"
3705   def outputDir = "${jalviewDir}/${jalviewjsTransferSiteCoreDir}/${jalviewjs_j2s_subdir}/core"
3706   def prefixFile = "${jsDir}/core/coretop2.js"
3707   def suffixFile = "${jsDir}/core/corebottom2.js"
3708
3709   inputs.file prefixFile
3710   inputs.file suffixFile
3711
3712   def classlistFiles = []
3713   // add the classlists found int the jalviewjs_classlists_dir
3714   fileTree(dir: "${jalviewDir}/${jalviewjs_classlists_dir}", include: "*.txt").each {
3715     file ->
3716     def name = file.getName() - ".txt"
3717     classlistFiles += [
3718       'file': file,
3719       'name': name
3720     ]
3721   }
3722
3723   // _jmol and _jalview cores. Add any other peculiar classlist.txt files here
3724   //classlistFiles += [ 'file': file("${jalviewDir}/${jalviewjs_classlist_jmol}"), 'name': "_jvjmol" ]
3725   classlistFiles += [ 'file': file("${jalviewDir}/${jalviewjs_classlist_jalview}"), 'name': jalviewjsJalviewCoreName ]
3726
3727   jalviewjsCoreClasslists = []
3728
3729   classlistFiles.each {
3730     hash ->
3731
3732     def file = hash['file']
3733     if (! file.exists()) {
3734       //println("...classlist file '"+file.getPath()+"' does not exist, skipping")
3735       return false // this is a "continue" in groovy .each closure
3736     }
3737     def name = hash['name']
3738     if (name == null) {
3739       name = file.getName() - ".txt"
3740     }
3741
3742     def filelist = []
3743     file.eachLine {
3744       line ->
3745         filelist += line
3746     }
3747     def list = fileTree(dir: j2sDir, includes: filelist)
3748
3749     def jsfile = "${outputDir}/core${name}.js"
3750     def zjsfile = "${outputDir}/core${name}.z.js"
3751
3752     jalviewjsCoreClasslists += [
3753       'jsfile': jsfile,
3754       'zjsfile': zjsfile,
3755       'list': list,
3756       'name': name
3757     ]
3758
3759     inputs.file(file)
3760     inputs.files(list)
3761     outputs.file(jsfile)
3762     outputs.file(zjsfile)
3763   }
3764
3765   // _stevesoft core. add any cores without a classlist here (and the inputs and outputs)
3766   def stevesoftClasslistName = "_stevesoft"
3767   def stevesoftClasslist = [
3768     'jsfile': "${outputDir}/core${stevesoftClasslistName}.js",
3769     'zjsfile': "${outputDir}/core${stevesoftClasslistName}.z.js",
3770     'list': fileTree(dir: j2sDir, include: "com/stevesoft/pat/**/*.js"),
3771     'name': stevesoftClasslistName
3772   ]
3773   jalviewjsCoreClasslists += stevesoftClasslist
3774   inputs.files(stevesoftClasslist['list'])
3775   outputs.file(stevesoftClasslist['jsfile'])
3776   outputs.file(stevesoftClasslist['zjsfile'])
3777
3778   // _all core
3779   def allClasslistName = "_all"
3780   def allJsFiles = fileTree(dir: j2sDir, include: "**/*.js")
3781   allJsFiles += fileTree(
3782     dir: libJ2sDir,
3783     include: "**/*.js",
3784     excludes: [
3785       // these exlusions are files that the closure-compiler produces errors for. Should fix them
3786       "**/org/jmol/jvxl/readers/IsoIntersectFileReader.js",
3787       "**/org/jmol/export/JSExporter.js"
3788     ]
3789   )
3790   allJsFiles += fileTree(
3791     dir: swingJ2sDir,
3792     include: "**/*.js",
3793     excludes: [
3794       // these exlusions are files that the closure-compiler produces errors for. Should fix them
3795       "**/sun/misc/Unsafe.js",
3796       "**/swingjs/jquery/jquery-editable-select.js",
3797       "**/swingjs/jquery/j2sComboBox.js",
3798       "**/sun/misc/FloatingDecimal.js"
3799     ]
3800   )
3801   def allClasslist = [
3802     'jsfile': "${outputDir}/core${allClasslistName}.js",
3803     'zjsfile': "${outputDir}/core${allClasslistName}.z.js",
3804     'list': allJsFiles,
3805     'name': allClasslistName
3806   ]
3807   // not including this version of "all" core at the moment
3808   //jalviewjsCoreClasslists += allClasslist
3809   inputs.files(allClasslist['list'])
3810   outputs.file(allClasslist['jsfile'])
3811   outputs.file(allClasslist['zjsfile'])
3812
3813   doFirst {
3814     def logOutFile = file("${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_j2s_closure_stdout}")
3815     logOutFile.getParentFile().mkdirs()
3816     logOutFile.createNewFile()
3817     logOutFile.write(getDate("yyyy-MM-dd HH:mm:ss")+" jalviewjsBuildAllCores\n----\n")
3818
3819     jalviewjsCoreClasslists.each {
3820       jalviewjsCallCore(it.name, it.list, prefixFile, suffixFile, it.jsfile, it.zjsfile, logOutFile, jalviewjs_j2s_to_console.equals("true"))
3821     }
3822   }
3823
3824 }
3825
3826
3827 def jalviewjsPublishCoreTemplate(String coreName, String templateName, File inputFile, String outputFile) {
3828   copy {
3829     from inputFile
3830     into file(outputFile).getParentFile()
3831     rename { filename ->
3832       if (filename.equals(inputFile.getName())) {
3833         return file(outputFile).getName()
3834       }
3835       return null
3836     }
3837     filter(ReplaceTokens,
3838       beginToken: '_',
3839       endToken: '_',
3840       tokens: [
3841         'MAIN': '"'+main_class+'"',
3842         'CODE': "null",
3843         'NAME': jalviewjsJalviewTemplateName+" [core ${coreName}]",
3844         'COREKEY': jalviewjs_core_key,
3845         'CORENAME': coreName
3846       ]
3847     )
3848   }
3849 }
3850
3851
3852 task jalviewjsPublishCoreTemplates {
3853   dependsOn jalviewjsBuildAllCores
3854   def inputFileName = "${jalviewDir}/${j2s_coretemplate_html}"
3855   def inputFile = file(inputFileName)
3856   def outputDir = "${jalviewDir}/${jalviewjsTransferSiteCoreDir}"
3857
3858   def outputFiles = []
3859   jalviewjsCoreClasslists.each { cl ->
3860     def outputFile = "${outputDir}/${jalviewjsJalviewTemplateName}_${cl.name}.html"
3861     cl['outputfile'] = outputFile
3862     outputFiles += outputFile
3863   }
3864
3865   doFirst {
3866     jalviewjsCoreClasslists.each { cl ->
3867       jalviewjsPublishCoreTemplate(cl.name, jalviewjsJalviewTemplateName, inputFile, cl.outputfile)
3868     }
3869   }
3870   inputs.file(inputFile)
3871   outputs.files(outputFiles)
3872 }
3873
3874
3875 task jalviewjsSyncCore (type: Sync) {
3876   dependsOn jalviewjsBuildAllCores
3877   dependsOn jalviewjsPublishCoreTemplates
3878   def inputFiles = fileTree(dir: "${jalviewDir}/${jalviewjsTransferSiteCoreDir}")
3879   def outputDir = "${jalviewDir}/${jalviewjsSiteDir}"
3880
3881   from inputFiles
3882   into outputDir
3883   def outputFiles = []
3884   rename { filename ->
3885     outputFiles += "${outputDir}/${filename}"
3886     null
3887   }
3888   preserve {
3889     include "**"
3890   }
3891   outputs.files outputFiles
3892   inputs.files inputFiles
3893 }
3894
3895
3896 // this Copy version of TransferSiteJs will delete anything else in the target dir
3897 task jalviewjsCopyTransferSiteJs(type: Copy) {
3898   dependsOn jalviewjsTranspile
3899   from "${jalviewDir}/${jalviewjsTransferSiteJsDir}"
3900   into "${jalviewDir}/${jalviewjsSiteDir}"
3901 }
3902
3903
3904 // this Sync version of TransferSite is used by buildship to keep the website automatically up to date when a file changes
3905 task jalviewjsSyncTransferSiteJs(type: Sync) {
3906   from "${jalviewDir}/${jalviewjsTransferSiteJsDir}"
3907   include "**/*.*"
3908   into "${jalviewDir}/${jalviewjsSiteDir}"
3909   preserve {
3910     include "**"
3911   }
3912 }
3913
3914
3915 jalviewjsSyncAllLibs.mustRunAfter jalviewjsCopyTransferSiteJs
3916 jalviewjsSyncResources.mustRunAfter jalviewjsCopyTransferSiteJs
3917 jalviewjsSyncSiteResources.mustRunAfter jalviewjsCopyTransferSiteJs
3918 jalviewjsSyncBuildProperties.mustRunAfter jalviewjsCopyTransferSiteJs
3919
3920 jalviewjsSyncAllLibs.mustRunAfter jalviewjsSyncTransferSiteJs
3921 jalviewjsSyncResources.mustRunAfter jalviewjsSyncTransferSiteJs
3922 jalviewjsSyncSiteResources.mustRunAfter jalviewjsSyncTransferSiteJs
3923 jalviewjsSyncBuildProperties.mustRunAfter jalviewjsSyncTransferSiteJs
3924
3925
3926 task jalviewjsPrepareSite {
3927   group "JalviewJS"
3928   description "Prepares the website folder including unzipping files and copying resources"
3929   dependsOn jalviewjsSyncAllLibs
3930   dependsOn jalviewjsSyncResources
3931   dependsOn jalviewjsSyncSiteResources
3932   dependsOn jalviewjsSyncBuildProperties
3933   dependsOn jalviewjsSyncCore
3934 }
3935
3936
3937 task jalviewjsBuildSite {
3938   group "JalviewJS"
3939   description "Builds the whole website including transpiled code"
3940   dependsOn jalviewjsCopyTransferSiteJs
3941   dependsOn jalviewjsPrepareSite
3942 }
3943
3944
3945 task cleanJalviewjsTransferSite {
3946   doFirst {
3947     delete "${jalviewDir}/${jalviewjsTransferSiteJsDir}"
3948     delete "${jalviewDir}/${jalviewjsTransferSiteLibDir}"
3949     delete "${jalviewDir}/${jalviewjsTransferSiteSwingJsDir}"
3950     delete "${jalviewDir}/${jalviewjsTransferSiteCoreDir}"
3951   }
3952 }
3953
3954
3955 task cleanJalviewjsSite {
3956   dependsOn cleanJalviewjsTransferSite
3957   doFirst {
3958     delete "${jalviewDir}/${jalviewjsSiteDir}"
3959   }
3960 }
3961
3962
3963 task jalviewjsSiteTar(type: Tar) {
3964   group "JalviewJS"
3965   description "Creates a tar.gz file for the website"
3966   dependsOn jalviewjsBuildSite
3967   def outputFilename = "jalviewjs-site-${JALVIEW_VERSION}.tar.gz"
3968   archiveFileName = outputFilename
3969
3970   compression Compression.GZIP
3971
3972   from "${jalviewDir}/${jalviewjsSiteDir}"
3973   into jalviewjs_site_dir // this is inside the tar file
3974
3975   inputs.dir("${jalviewDir}/${jalviewjsSiteDir}")
3976 }
3977
3978
3979 task jalviewjsServer {
3980   group "JalviewJS"
3981   def filename = "jalviewjsTest.html"
3982   description "Starts a webserver on localhost to test the website. See ${filename} to access local site on most recently used port."
3983   def htmlFile = "${jalviewDirAbsolutePath}/${filename}"
3984   doLast {
3985
3986     def factory
3987     try {
3988       def f = Class.forName("org.gradle.plugins.javascript.envjs.http.simple.SimpleHttpFileServerFactory")
3989       factory = f.newInstance()
3990     } catch (ClassNotFoundException e) {
3991       throw new GradleException("Unable to create SimpleHttpFileServerFactory")
3992     }
3993     def port = Integer.valueOf(jalviewjs_server_port)
3994     def start = port
3995     def running = false
3996     def url
3997     def jalviewjsServer
3998     while(port < start+1000 && !running) {
3999       try {
4000         def doc_root = new File("${jalviewDirAbsolutePath}/${jalviewjsSiteDir}")
4001         jalviewjsServer = factory.start(doc_root, port)
4002         running = true
4003         url = jalviewjsServer.getResourceUrl(jalviewjs_server_resource)
4004         println("SERVER STARTED with document root ${doc_root}.")
4005         println("Go to "+url+" . Run  gradle --stop  to stop (kills all gradle daemons).")
4006         println("For debug: "+url+"?j2sdebug")
4007         println("For verbose: "+url+"?j2sverbose")
4008       } catch (Exception e) {
4009         port++;
4010       }
4011     }
4012     def htmlText = """
4013       <p><a href="${url}">JalviewJS Test. &lt;${url}&gt;</a></p>
4014       <p><a href="${url}?j2sdebug">JalviewJS Test with debug. &lt;${url}?j2sdebug&gt;</a></p>
4015       <p><a href="${url}?j2sverbose">JalviewJS Test with verbose. &lt;${url}?j2sdebug&gt;</a></p>
4016       """
4017     jalviewjsCoreClasslists.each { cl ->
4018       def urlcore = jalviewjsServer.getResourceUrl(file(cl.outputfile).getName())
4019       htmlText += """
4020       <p><a href="${urlcore}">${jalviewjsJalviewTemplateName} [core ${cl.name}]. &lt;${urlcore}&gt;</a></p>
4021       """
4022       println("For core ${cl.name}: "+urlcore)
4023     }
4024
4025     file(htmlFile).text = htmlText
4026   }
4027
4028   outputs.file(htmlFile)
4029   outputs.upToDateWhen({false})
4030 }
4031
4032
4033 task cleanJalviewjsAll {
4034   group "JalviewJS"
4035   description "Delete all configuration and build artifacts to do with JalviewJS build"
4036   dependsOn cleanJalviewjsSite
4037   dependsOn jalviewjsEclipsePaths
4038
4039   doFirst {
4040     delete "${jalviewDir}/${jalviewjsBuildDir}"
4041     delete "${jalviewDir}/${eclipse_bin_dir}"
4042     if (eclipseWorkspace != null && file(eclipseWorkspace.getAbsolutePath()+"/.metadata").exists()) {
4043       delete file(eclipseWorkspace.getAbsolutePath()+"/.metadata")
4044     }
4045     delete jalviewjsJ2sAltSettingsFileName
4046   }
4047
4048   outputs.upToDateWhen( { false } )
4049 }
4050
4051
4052 task jalviewjsIDE_checkJ2sPlugin {
4053   group "00 JalviewJS in Eclipse"
4054   description "Compare the swingjs/net.sf.j2s.core(-j11)?.jar file with the Eclipse IDE's plugin version (found in the 'dropins' dir)"
4055
4056   doFirst {
4057     def j2sPlugin = string("${jalviewDir}/${jalviewjsJ2sPlugin}")
4058     def j2sPluginFile = file(j2sPlugin)
4059     def eclipseHome = System.properties["eclipse.home.location"]
4060     if (eclipseHome == null || ! IN_ECLIPSE) {
4061       throw new StopExecutionException("Cannot find running Eclipse home from System.properties['eclipse.home.location']. Skipping J2S Plugin Check.")
4062     }
4063     def eclipseJ2sPluginDirs = [ "${eclipseHome}/dropins" ]
4064     def altPluginsDir = System.properties["org.eclipse.equinox.p2.reconciler.dropins.directory"]
4065     if (altPluginsDir != null && file(altPluginsDir).exists()) {
4066       eclipseJ2sPluginDirs += altPluginsDir
4067     }
4068     def foundPlugin = false
4069     def j2sPluginFileName = j2sPluginFile.getName()
4070     def eclipseJ2sPlugin
4071     def eclipseJ2sPluginFile
4072     eclipseJ2sPluginDirs.any { dir ->
4073       eclipseJ2sPlugin = "${dir}/${j2sPluginFileName}"
4074       eclipseJ2sPluginFile = file(eclipseJ2sPlugin)
4075       if (eclipseJ2sPluginFile.exists()) {
4076         foundPlugin = true
4077         return true
4078       }
4079     }
4080     if (!foundPlugin) {
4081       def msg = "Eclipse J2S Plugin is not installed (could not find '${j2sPluginFileName}' in\n"+eclipseJ2sPluginDirs.join("\n")+"\n)\nTry running task jalviewjsIDE_copyJ2sPlugin"
4082       System.err.println(msg)
4083       throw new StopExecutionException(msg)
4084     }
4085
4086     def digest = MessageDigest.getInstance("MD5")
4087
4088     digest.update(j2sPluginFile.text.bytes)
4089     def j2sPluginMd5 = new BigInteger(1, digest.digest()).toString(16).padLeft(32, '0')
4090
4091     digest.update(eclipseJ2sPluginFile.text.bytes)
4092     def eclipseJ2sPluginMd5 = new BigInteger(1, digest.digest()).toString(16).padLeft(32, '0')
4093
4094     if (j2sPluginMd5 != eclipseJ2sPluginMd5) {
4095       def msg = "WARNING! Eclipse J2S Plugin '${eclipseJ2sPlugin}' is different to this commit's version '${j2sPlugin}'"
4096       System.err.println(msg)
4097       throw new StopExecutionException(msg)
4098     } else {
4099       def msg = "Eclipse J2S Plugin '${eclipseJ2sPlugin}' is the same as '${j2sPlugin}' (this is good)"
4100       println(msg)
4101     }
4102   }
4103 }
4104
4105 task jalviewjsIDE_copyJ2sPlugin {
4106   group "00 JalviewJS in Eclipse"
4107   description "Copy the swingjs/net.sf.j2s.core(-j11)?.jar file into the Eclipse IDE's 'dropins' dir"
4108
4109   doFirst {
4110     def j2sPlugin = string("${jalviewDir}/${jalviewjsJ2sPlugin}")
4111     def j2sPluginFile = file(j2sPlugin)
4112     def eclipseHome = System.properties["eclipse.home.location"]
4113     if (eclipseHome == null || ! IN_ECLIPSE) {
4114       throw new StopExecutionException("Cannot find running Eclipse home from System.properties['eclipse.home.location']. NOT copying J2S Plugin.")
4115     }
4116     def eclipseJ2sPlugin = "${eclipseHome}/dropins/${j2sPluginFile.getName()}"
4117     def eclipseJ2sPluginFile = file(eclipseJ2sPlugin)
4118     def msg = "WARNING! Copying this commit's j2s plugin '${j2sPlugin}' to Eclipse J2S Plugin '${eclipseJ2sPlugin}'\n* May require an Eclipse restart"
4119     System.err.println(msg)
4120     copy {
4121       from j2sPlugin
4122       eclipseJ2sPluginFile.getParentFile().mkdirs()
4123       into eclipseJ2sPluginFile.getParent()
4124     }
4125   }
4126 }
4127
4128
4129 task jalviewjsIDE_j2sFile {
4130   group "00 JalviewJS in Eclipse"
4131   description "Creates the .j2s file"
4132   dependsOn jalviewjsCreateJ2sSettings
4133 }
4134
4135
4136 task jalviewjsIDE_SyncCore {
4137   group "00 JalviewJS in Eclipse"
4138   description "Build the core js lib closures listed in the classlists dir and publish core html from template"
4139   dependsOn jalviewjsSyncCore
4140 }
4141
4142
4143 task jalviewjsIDE_SyncSiteAll {
4144   dependsOn jalviewjsSyncAllLibs
4145   dependsOn jalviewjsSyncResources
4146   dependsOn jalviewjsSyncSiteResources
4147   dependsOn jalviewjsSyncBuildProperties
4148 }
4149
4150
4151 cleanJalviewjsTransferSite.mustRunAfter jalviewjsIDE_SyncSiteAll
4152
4153
4154 task jalviewjsIDE_PrepareSite {
4155   group "00 JalviewJS in Eclipse"
4156   description "Sync libs and resources to site dir, but not closure cores"
4157
4158   dependsOn jalviewjsIDE_SyncSiteAll
4159   //dependsOn cleanJalviewjsTransferSite // not sure why this clean is here -- will slow down a re-run of this task
4160 }
4161
4162
4163 task jalviewjsIDE_AssembleSite {
4164   group "00 JalviewJS in Eclipse"
4165   description "Assembles unzipped supporting zipfiles, resources, site resources and closure cores into the Eclipse transpiled site"
4166   dependsOn jalviewjsPrepareSite
4167 }
4168
4169
4170 task jalviewjsIDE_SiteClean {
4171   group "00 JalviewJS in Eclipse"
4172   description "Deletes the Eclipse transpiled site"
4173   dependsOn cleanJalviewjsSite
4174 }
4175
4176
4177 task jalviewjsIDE_Server {
4178   group "00 JalviewJS in Eclipse"
4179   description "Starts a webserver on localhost to test the website"
4180   dependsOn jalviewjsServer
4181 }
4182
4183
4184 // buildship runs this at import or gradle refresh
4185 task eclipseSynchronizationTask {
4186   //dependsOn eclipseSetup
4187   dependsOn createBuildProperties
4188   if (J2S_ENABLED) {
4189     dependsOn jalviewjsIDE_j2sFile
4190     dependsOn jalviewjsIDE_checkJ2sPlugin
4191     dependsOn jalviewjsIDE_PrepareSite
4192   }
4193 }
4194
4195
4196 // buildship runs this at build time or project refresh
4197 task eclipseAutoBuildTask {
4198   //dependsOn jalviewjsIDE_checkJ2sPlugin
4199   //dependsOn jalviewjsIDE_PrepareSite
4200 }
4201
4202
4203 task jalviewjs {
4204   group "JalviewJS"
4205   description "Build the site"
4206   dependsOn jalviewjsBuildSite
4207 }
4208