build.gradle

   1 import org.apache.tools.ant.filters.ReplaceTokens
   2 import org.gradle.internal.os.OperatingSystem
   3 import org.gradle.plugins.ide.eclipse.model.Output
   4 import org.gradle.plugins.ide.eclipse.model.Library
   5
   6 import groovy.transform.ExternalizeMethods
   7
   8 buildscript {
   9   dependencies {
  10     classpath 'org.openclover:clover:4.3.1'
  11   }
  12 }
  13
  14 plugins {
  15   id 'java'
  16   id 'application'
  17   id 'eclipse'
  18   id 'com.github.johnrengelman.shadow' version '4.0.3'
  19   id 'com.install4j.gradle' version '7.0.9'
  20 }
  21
  22 // local build environment properties
  23 def localProps = "${jalviewDir}/local.properties"
  24 if (file(localProps).exists()) {
  25   try {
  26     def p = new Properties()
  27     def localPropsFIS = new FileInputStream(localProps)
  28     p.load(localPropsFIS)
  29     localPropsFIS.close()
  30     p.each {
  31       key, val ->
  32         def over = getProperty(key) != null
  33         setProperty(key, val)
  34         if (over) {
  35           println("Overriding property '${key}' with local.properties value '${val}'")
  36         }
  37     }
  38   } catch (Exception e) {
  39     System.out.println("Exception reading local.properties")
  40   }
  41 }
  42
  43 repositories {
  44   jcenter()
  45   mavenCentral()
  46   mavenLocal()
  47   flatDir {
  48     dirs gradlePluginsDir
  49   }
  50 }
  51
  52 dependencies {
  53   compile 'org.apache.commons:commons-compress:1.18'
  54 }
  55
  56 mainClassName = launcherClass
  57 def cloverInstrDir = file("${buildDir}/${cloverSourcesInstrDir}")
  58 def classes = "${jalviewDir}/${classesDir}"
  59
  60 if (clover.equals("true")) {
  61   use_clover = true
  62   classes = "${buildDir}/${cloverClassesDir}"
  63 } else {
  64   use_clover = false
  65   classes = "${jalviewDir}/${classesDir}"
  66 }
  67
  68 // configure classpath/args for j8/j11 compilation
  69
  70 def jalviewDirAbsolutePath = file(jalviewDir).getAbsolutePath()
  71 def libDir
  72 def libDistDir
  73 def compile_source_compatibility
  74 def compile_target_compatibility
  75
  76 ext {
  77   getdownWebsiteDir = "${jalviewDir}/${getdown_website_dir}/${JAVA_VERSION}"
  78   getdownDir = ""
  79   reportRsyncCmd = false
  80   buildDist = true
  81   buildProperties = build_properties_file
  82   getdownLauncher = "${jalviewDir}/${getdown_lib_dir}/${getdown_launcher}"
  83   switch (CHANNEL) {
  84
  85     case "BUILD":
  86     // TODO: get bamboo build artifact URL for getdown artifacts
  87     getdown_channel_base = bamboo_channelbase
  88     getdown_channel_name = "${bamboo_planKey}/${JAVA_VERSION}"
  89     getdown_app_base = "${bamboo_channelbase}/${bamboo_planKey}${bamboo_getdown_channel_suffix}/${JAVA_VERSION}"
  90     getdown_app_dir = getdown_app_dir_alt
  91     buildProperties = "${jalviewDir}/${classesDir}/${build_properties_file}"
  92     break
  93
  94     case "RELEASE":
  95     getdown_channel_name = CHANNEL.toLowerCase()
  96     getdownDir = "${getdown_channel_name}/${JAVA_VERSION}"
  97     getdown_app_base = "${getdown_channel_base}/${getdownDir}"
  98     getdown_app_dir = getdown_app_dir_release
  99     buildProperties = "${jalviewDir}/${classesDir}/${build_properties_file}"
 100     reportRsyncCommand = true
 101     break
 102
 103     case "ARCHIVE":
 104     getdown_channel_name = CHANNEL.toLowerCase()+"/${JALVIEW_VERSION}"
 105     getdownDir = "${getdown_channel_name}/${JAVA_VERSION}"
 106     getdown_app_base = "${getdown_channel_base}/${getdownDir}"
 107     getdown_app_dir = getdown_app_dir_alt
 108     if (!file("${ARCHIVEDIR}/${packageDir}").exists()) {
 109       print "Must provide an ARCHIVEDIR value to produce an archive distribution"
 110       exit
 111     } else {
 112       packageDir = "${ARCHIVEDIR}/${packageDir}"
 113       buildProperties = "${ARCHIVEDIR}/${classesDir}/${build_properties_file}"
 114       buildDist = false
 115     }
 116     reportRsyncCommand = true
 117     break
 118
 119     case "ARCHIVELOCAL":
 120     getdown_channel_name = "archive/${JALVIEW_VERSION}"
 121     getdownDir = "${getdown_channel_name}/${JAVA_VERSION}"
 122     getdown_app_base = file(getdownWebsiteDir).toURI().toString()
 123     getdown_app_dir = getdown_app_dir_alt
 124     if (!file("${ARCHIVEDIR}/${packageDir}").exists()) {
 125       print "Must provide an ARCHIVEDIR value to produce an archive distribution"
 126       exit
 127     } else {
 128       packageDir = "${ARCHIVEDIR}/${packageDir}"
 129       buildProperties = "${ARCHIVEDIR}/${classesDir}/${build_properties_file}"
 130       buildDist = false
 131     }
 132     reportRsyncCommand = true
 133     getdownLauncher = "${jalviewDir}/${getdown_lib_dir}/${getdown_launcher_local}"
 134     break
 135
 136     case "DEVELOP":
 137     getdown_channel_name = CHANNEL.toLowerCase()
 138     getdownDir = "${getdown_channel_name}/${JAVA_VERSION}"
 139     getdown_app_base = "${getdown_channel_base}/${getdownDir}"
 140     getdown_app_dir = getdown_app_dir_alt
 141     buildProperties = "${jalviewDir}/${classesDir}/${build_properties_file}"
 142     reportRsyncCommand = true
 143     break
 144
 145     case "TEST-RELEASE":
 146     getdown_channel_name = CHANNEL.toLowerCase()
 147     getdownDir = "${getdown_channel_name}/${JAVA_VERSION}"
 148     getdown_app_base = "${getdown_channel_base}/${getdownDir}"
 149     getdown_app_dir = getdown_app_dir_alt
 150     buildProperties = "${jalviewDir}/${classesDir}/${build_properties_file}"
 151     reportRsyncCommand = true
 152     break
 153
 154     case ~/^SCRATCH(|-[-\w]*)$/:
 155     getdown_channel_name = CHANNEL
 156     getdownDir = "${getdown_channel_name}/${JAVA_VERSION}"
 157     getdown_app_base = "${getdown_channel_base}/${getdownDir}"
 158     getdown_app_dir = getdown_app_dir_alt
 159     buildProperties = "${jalviewDir}/${classesDir}/${build_properties_file}"
 160     reportRsyncCommand = true
 161     break
 162
 163     case "LOCAL":
 164     getdown_app_base = file(getdownWebsiteDir).toURI().toString()
 165     getdown_app_dir = getdown_app_dir_alt
 166     buildProperties = "${jalviewDir}/${classesDir}/${build_properties_file}"
 167     getdownLauncher = "${jalviewDir}/${getdown_lib_dir}/${getdown_launcher_local}"
 168     break
 169
 170     default: // something wrong specified
 171     print("CHANNEL must be one of BUILD, RELEASE, ARCHIVE, DEVELOP, TEST-RELEASE, SCRATCH-..., LOCAL [default]")
 172     exit
 173     break
 174
 175   }
 176
 177   getdownAppDir = "${getdownWebsiteDir}/${getdown_app_dir}"
 178   //getdownJ11libDir = "${getdownWebsiteDir}/${getdown_j11lib_dir}"
 179   getdownResourceDir = "${getdownWebsiteDir}/${getdown_resource_dir}"
 180   getdownInstallDir = "${getdownWebsiteDir}/${getdown_install_dir}"
 181   getdownFilesDir = "${jalviewDir}/${getdown_files_dir}/${JAVA_VERSION}/"
 182   getdownFilesInstallDir = "${getdownFilesDir}/${getdown_install_dir}"
 183   /* compile without modules -- using classpath libraries
 184   modules_compileClasspath = fileTree(dir: "${jalviewDir}/${j11modDir}", include: ["*.jar"])
 185   modules_runtimeClasspath = modules_compileClasspath
 186   */
 187   gitHash = ""
 188   gitBranch = ""
 189
 190   println("Using a ${CHANNEL} profile.")
 191 }
 192
 193 def JAVA_INTEGER_VERSION
 194 def additional_compiler_args = []
 195 // these are getdown.txt properties defined dependent on the JAVA_VERSION
 196 def getdown_alt_java_min_version
 197 def getdown_alt_java_max_version
 198 // this property is assigned below and expanded to multiple lines in the getdown task
 199 def getdown_alt_multi_java_location
 200 // this property is for the Java library used in eclipse
 201 def eclipse_java_runtime_name
 202 if (JAVA_VERSION.equals("1.8")) {
 203   JAVA_INTEGER_VERSION = "8"
 204   //libDir = j8libDir
 205   libDir = j11libDir
 206   libDistDir = j8libDir
 207   compile_source_compatibility = 1.8
 208   compile_target_compatibility = 1.8
 209   getdown_alt_java_min_version = getdown_alt_java8_min_version
 210   getdown_alt_java_max_version = getdown_alt_java8_max_version
 211   getdown_alt_multi_java_location = getdown_alt_java8_txt_multi_java_location
 212   eclipse_java_runtime_name = "JavaSE-1.8"
 213 } else if (JAVA_VERSION.equals("11")) {
 214   JAVA_INTEGER_VERSION = "11"
 215   libDir = j11libDir
 216   libDistDir = j11libDir
 217   compile_source_compatibility = 11
 218   compile_target_compatibility = 11
 219   getdown_alt_java_min_version = getdown_alt_java11_min_version
 220   getdown_alt_java_max_version = getdown_alt_java11_max_version
 221   getdown_alt_multi_java_location = getdown_alt_java11_txt_multi_java_location
 222   eclipse_java_runtime_name = "JavaSE-11"
 223   /* compile without modules -- using classpath libraries
 224   additional_compiler_args += [
 225   '--module-path', ext.modules_compileClasspath.asPath,
 226   '--add-modules', j11modules
 227   ]
 228   */
 229 } else if (JAVA_VERSION.equals("12") || JAVA_VERSION.equals("13")) {
 230   JAVA_INTEGER_VERSION = JAVA_VERSION
 231   libDir = j11libDir
 232   libDistDir = j11libDir
 233   compile_source_compatibility = JAVA_VERSION
 234   compile_target_compatibility = JAVA_VERSION
 235   getdown_alt_java_min_version = getdown_alt_java11_min_version
 236   getdown_alt_java_max_version = getdown_alt_java11_max_version
 237   getdown_alt_multi_java_location = getdown_alt_java11_txt_multi_java_location
 238   eclipse_java_runtime_name = "JavaSE-11"
 239   /* compile without modules -- using classpath libraries
 240   additional_compiler_args += [
 241   '--module-path', ext.modules_compileClasspath.asPath,
 242   '--add-modules', j11modules
 243   ]
 244   */
 245 } else {
 246   throw new GradleException("JAVA_VERSION=${JAVA_VERSION} not currently supported by Jalview")
 247 }
 248
 249 sourceSets {
 250
 251   main {
 252     java {
 253       srcDirs "${jalviewDir}/${sourceDir}"
 254       outputDir = file("${classes}")
 255     }
 256
 257     resources {
 258       srcDirs "${jalviewDir}/${resourceDir}"
 259     }
 260
 261     jar.destinationDir = file("${jalviewDir}/${packageDir}")
 262
 263     compileClasspath = files(sourceSets.main.java.outputDir)
 264     compileClasspath += fileTree(dir: "${jalviewDir}/${libDir}", include: ["*.jar"])
 265
 266     runtimeClasspath = compileClasspath
 267   }
 268
 269   clover {
 270     java {
 271       srcDirs = [ cloverInstrDir ]
 272       outputDir = file("${buildDir}/${cloverClassesDir}")
 273     }
 274
 275     resources {
 276       srcDirs = sourceSets.main.resources.srcDirs
 277     }
 278     compileClasspath = configurations.cloverRuntime + files( sourceSets.clover.java.outputDir )
 279     compileClasspath += files(sourceSets.main.java.outputDir)
 280     compileClasspath += sourceSets.main.compileClasspath
 281     compileClasspath += fileTree(dir: "${jalviewDir}/${utilsDir}", include: ["**/*.jar"])
 282     compileClasspath += fileTree(dir: "${jalviewDir}/${libDir}", include: ["*.jar"])
 283
 284     runtimeClasspath = compileClasspath
 285   }
 286
 287   test {
 288     java {
 289       srcDirs "${jalviewDir}/${testSourceDir}"
 290       outputDir = file("${jalviewDir}/${testOutputDir}")
 291     }
 292
 293     resources {
 294       srcDirs = sourceSets.main.resources.srcDirs
 295     }
 296
 297     compileClasspath = files( sourceSets.test.java.outputDir )
 298
 299     if (use_clover) {
 300       compileClasspath += sourceSets.clover.compileClasspath
 301     } else {
 302       compileClasspath += files(sourceSets.main.java.outputDir)
 303     }
 304
 305     compileClasspath += fileTree(dir: "${jalviewDir}/${libDir}", include: ["*.jar"])
 306     compileClasspath += fileTree(dir: "${jalviewDir}/${utilsDir}/testnglibs", include: ["**/*.jar"])
 307     compileClasspath += fileTree(dir: "${jalviewDir}/${utilsDir}/testlibs", include: ["**/*.jar"])
 308
 309     runtimeClasspath = compileClasspath
 310   }
 311 }
 312
 313 // clover bits
 314 dependencies {
 315   if (use_clover) {
 316     cloverCompile 'org.openclover:clover:4.3.1'
 317     testCompile 'org.openclover:clover:4.3.1'
 318   }
 319 }
 320
 321 configurations {
 322   cloverRuntime
 323   cloverRuntime.extendsFrom cloverCompile
 324 }
 325
 326 eclipse {
 327   project {
 328     name = eclipse_project_name
 329
 330     natures 'org.eclipse.jdt.core.javanature',
 331     'org.eclipse.jdt.groovy.core.groovyNature',
 332     'org.eclipse.buildship.core.gradleprojectnature'
 333
 334     buildCommand 'org.eclipse.jdt.core.javabuilder'
 335     buildCommand 'org.eclipse.buildship.core.gradleprojectbuilder'
 336   }
 337
 338   classpath {
 339     //defaultOutputDir = sourceSets.main.java.outputDir
 340     def removeThese = []
 341     configurations.each{
 342       if (it.isCanBeResolved()) {
 343         removeThese += it
 344       }
 345     }
 346
 347     minusConfigurations += removeThese
 348     plusConfigurations = [ ]
 349     file {
 350
 351       whenMerged { cp ->
 352         def removeTheseToo = []
 353         HashMap<String, Boolean> alreadyAddedSrcPath = new HashMap<>();
 354         cp.entries.each { entry ->
 355           if (entry.kind == 'src') {
 356             if (alreadyAddedSrcPath.getAt(entry.path) || !(entry.path == sourceDir || entry.path == testSourceDir)) {
 357               removeTheseToo += entry
 358             } else {
 359               alreadyAddedSrcPath.putAt(entry.path, true)
 360             }
 361           }
 362         }
 363         cp.entries.removeAll(removeTheseToo)
 364
 365         if (file("${jalviewDir}/${eclipse_bin_dir}/main").isDirectory()) {
 366           cp.entries += new Output("${eclipse_bin_dir}/main")
 367         }
 368         if (file(helpParentDir).isDirectory()) {
 369           cp.entries += new Library(fileReference(helpParentDir))
 370         }
 371         if (file(resourceDir).isDirectory()) {
 372           cp.entries += new Library(fileReference(resourceDir))
 373         }
 374
 375         HashMap<String, Boolean> alreadyAddedLibPath = new HashMap<>();
 376
 377         sourceSets.main.compileClasspath.findAll { it.name.endsWith(".jar") }.each {
 378           //don't want to add outputDir as eclipse is using its own output dir in bin/main
 379           if (it.isDirectory() || ! it.exists()) {
 380             // don't add dirs to classpath
 381             return
 382           }
 383           def itPath = it.toString()
 384           if (itPath.startsWith("${jalviewDirAbsolutePath}/")) {
 385             // make relative path
 386             itPath = itPath.substring(jalviewDirAbsolutePath.length()+1)
 387           }
 388           if (alreadyAddedLibPath.get(itPath)) {
 389             //println("Not adding duplicate entry "+itPath)
 390           } else {
 391             //println("Adding entry "+itPath)
 392             cp.entries += new Library(fileReference(itPath))
 393             alreadyAddedLibPath.put(itPath, true)
 394           }
 395         }
 396
 397         //fileTree(dir: "$jalviewDir/$utilsDir", include: ["test*/*.jar"]).each {
 398         sourceSets.test.compileClasspath.findAll { it.name.endsWith(".jar") }.each {
 399           //no longer want to add outputDir as eclipse is using its own output dir in bin/main
 400           if (it.isDirectory() || ! it.exists()) {
 401             // don't add dirs to classpath
 402             return false // groovy "break" in .each closure
 403           }
 404           def itPath = it.toString()
 405           if (itPath.startsWith("${jalviewDirAbsolutePath}/")) {
 406             itPath = itPath.substring(jalviewDirAbsolutePath.length()+1)
 407           }
 408           if (alreadyAddedLibPath.get(itPath)) {
 409             // don't duplicate
 410           } else {
 411             def lib = new Library(fileReference(itPath))
 412             lib.entryAttributes["test"] = "true"
 413             cp.entries += lib
 414             alreadyAddedLibPath.put(itPath, true)
 415           }
 416         }
 417
 418       } // whenMerged
 419
 420     } // file
 421
 422     containers 'org.eclipse.buildship.core.gradleclasspathcontainer'
 423
 424   } // classpath
 425
 426   jdt {
 427     // for the IDE, use java 11 compatibility
 428     sourceCompatibility = compile_source_compatibility
 429     targetCompatibility = compile_target_compatibility
 430     javaRuntimeName = eclipse_java_runtime_name
 431
 432     // add in jalview project specific properties/preferences into eclipse core preferences
 433     file {
 434       withProperties { props ->
 435         def jalview_prefs = new Properties()
 436         def ins = new FileInputStream("${jalviewDirAbsolutePath}/${eclipse_extra_jdt_prefs_file}")
 437         jalview_prefs.load(ins)
 438         ins.close()
 439         jalview_prefs.forEach { t, v ->
 440           if (props.getAt(t) == null) {
 441             props.putAt(t, v)
 442           }
 443         }
 444       }
 445     }
 446
 447   } // jdt
 448
 449   synchronizationTasks "eclipseSynchronizationTask"
 450   autoBuildTasks "eclipseAutoBuildTask"
 451
 452 }
 453
 454 task cloverInstr() {
 455   // only instrument source, we build test classes as normal
 456   inputs.files files (sourceSets.main.allJava) // , fileTree(dir:"$jalviewDir/$testSourceDir", include: ["**/*.java"]))
 457   outputs.dir cloverInstrDir
 458
 459   doFirst {
 460     delete cloverInstrDir
 461     def argsList = ["--initstring", "${buildDir}/clover/clover.db",
 462     "-d", "${buildDir}/${cloverSourcesInstrDir}"]
 463     argsList.addAll(inputs.files.files.collect({ file ->
 464       file.absolutePath
 465     }))
 466     String[] args = argsList.toArray()
 467     println("About to instrument "+args.length +" files")
 468     com.atlassian.clover.CloverInstr.mainImpl(args)
 469   }
 470 }
 471
 472
 473 task cloverReport {
 474   group = "Verification"
 475     description = "Createst the Clover report"
 476     inputs.dir "${buildDir}/clover"
 477     outputs.dir "${reportsDir}/clover"
 478     onlyIf {
 479       file("${buildDir}/clover/clover.db").exists()
 480     }
 481   doFirst {
 482     def argsList = ["--initstring", "${buildDir}/clover/clover.db",
 483     "-o", "${reportsDir}/clover"]
 484     String[] args = argsList.toArray()
 485     com.atlassian.clover.reporters.html.HtmlReporter.runReport(args)
 486
 487     // and generate ${reportsDir}/clover/clover.xml
 488     args = ["--initstring", "${buildDir}/clover/clover.db",
 489     "-o", "${reportsDir}/clover/clover.xml"].toArray()
 490     com.atlassian.clover.reporters.xml.XMLReporter.runReport(args)
 491   }
 492 }
 493
 494 // end clover bits
 495
 496
 497 compileJava {
 498
 499   doFirst {
 500     sourceCompatibility = compile_source_compatibility
 501     targetCompatibility = compile_target_compatibility
 502     options.compilerArgs = additional_compiler_args
 503     print ("Setting target compatibility to "+targetCompatibility+"\n")
 504   }
 505
 506 }
 507
 508 compileTestJava {
 509   if (use_clover) {
 510     dependsOn compileCloverJava
 511     classpath += configurations.cloverRuntime
 512   } else {
 513     classpath += sourceSets.main.runtimeClasspath
 514   }
 515   doFirst {
 516     sourceCompatibility = compile_source_compatibility
 517     targetCompatibility = compile_target_compatibility
 518     options.compilerArgs = additional_compiler_args
 519     print ("Setting target compatibility to "+targetCompatibility+"\n")
 520   }
 521 }
 522
 523
 524 compileCloverJava {
 525
 526   doFirst {
 527     sourceCompatibility = compile_source_compatibility
 528     targetCompatibility = compile_target_compatibility
 529     options.compilerArgs += additional_compiler_args
 530     print ("Setting target compatibility to "+targetCompatibility+"\n")
 531   }
 532   classpath += configurations.cloverRuntime
 533 }
 534
 535 clean {
 536   doFirst {
 537     delete sourceSets.main.java.outputDir
 538   }
 539 }
 540
 541 cleanTest {
 542   doFirst {
 543     delete sourceSets.test.java.outputDir
 544     delete cloverInstrDir
 545   }
 546 }
 547
 548 // format is a string like date.format("dd MMMM yyyy")
 549 def getDate(format) {
 550   def date = new Date()
 551   return date.format(format)
 552 }
 553
 554 task setGitVals {
 555   def hashStdOut = new ByteArrayOutputStream()
 556   exec {
 557     commandLine "git", "rev-parse", "--short", "HEAD"
 558     standardOutput = hashStdOut
 559     ignoreExitValue true
 560   }
 561
 562   def branchStdOut = new ByteArrayOutputStream()
 563   exec {
 564     commandLine "git", "rev-parse", "--abbrev-ref", "HEAD"
 565     standardOutput = branchStdOut
 566     ignoreExitValue true
 567   }
 568
 569   project.ext.gitHash = hashStdOut.toString().trim()
 570   project.ext.gitBranch = branchStdOut.toString().trim()
 571
 572   outputs.upToDateWhen { false }
 573 }
 574
 575 task createBuildProperties(type: WriteProperties) {
 576   dependsOn setGitVals
 577   inputs.dir("${jalviewDir}/${sourceDir}")
 578   inputs.dir("${jalviewDir}/${resourceDir}")
 579   file(buildProperties).getParentFile().mkdirs()
 580   outputFile (buildProperties)
 581   // taking time specific comment out to allow better incremental builds
 582   comment "--Jalview Build Details--\n"+getDate("yyyy-MM-dd HH:mm:ss")
 583   //comment "--Jalview Build Details--\n"+getDate("yyyy-MM-dd")
 584   property "BUILD_DATE", getDate("HH:mm:ss dd MMMM yyyy")
 585   property "VERSION", JALVIEW_VERSION
 586   property "INSTALLATION", INSTALLATION+" git-commit:"+project.ext.gitHash+" ["+project.ext.gitBranch+"]"
 587   outputs.file(outputFile)
 588 }
 589
 590 def buildingHTML = "${jalviewDir}/${docDir}/building.html"
 591 task cleanBuildingHTML(type: Delete) {
 592   doFirst {
 593     delete buildingHTML
 594   }
 595 }
 596
 597 task convertBuildingMD(type: Exec) {
 598   dependsOn cleanBuildingHTML
 599   def buildingMD = "${jalviewDir}/${docDir}/building.md"
 600   def css = "${jalviewDir}/${docDir}/github.css"
 601
 602   def pandoc = null
 603   pandoc_exec.split(",").each {
 604     if (file(it.trim()).exists()) {
 605       pandoc = it.trim()
 606       return true
 607     }
 608   }
 609
 610   def hostname = "hostname".execute().text.trim()
 611   if ((pandoc == null || ! file(pandoc).exists()) && hostname.equals("jv-bamboo")) {
 612     pandoc = System.getProperty("user.home")+"/buildtools/pandoc/bin/pandoc"
 613   }
 614
 615   doFirst {
 616     if (pandoc != null && file(pandoc).exists()) {
 617         commandLine pandoc, '-s', '-o', buildingHTML, '--metadata', 'pagetitle="Building Jalview from Source"', '--toc', '-H', css, buildingMD
 618     } else {
 619         println("Cannot find pandoc. Skipping convert building.md to HTML")
 620         throw new StopExecutionException()
 621     }
 622   }
 623
 624   ignoreExitValue true
 625
 626   inputs.file(buildingMD)
 627   inputs.file(css)
 628   outputs.file(buildingHTML)
 629 }
 630
 631 clean {
 632   doFirst {
 633     delete buildingHTML
 634   }
 635 }
 636
 637 task syncDocs(type: Sync) {
 638   dependsOn convertBuildingMD
 639   def syncDir = "${classes}/${docDir}"
 640   from fileTree("${jalviewDir}/${docDir}")
 641   into syncDir
 642
 643 }
 644
 645 def helpFile = "${classes}/${helpDir}/help.jhm"
 646
 647 task copyHelp(type: Copy) {
 648   def inputDir = "${jalviewDir}/${helpParentDir}/${helpDir}"
 649   def outputDir = "${classes}/${helpDir}"
 650   from(inputDir) {
 651     exclude '**/*.gif'
 652     exclude '**/*.jpg'
 653     exclude '**/*.png'
 654     filter(ReplaceTokens, beginToken: '$$', endToken: '$$', tokens: ['Version-Rel': JALVIEW_VERSION,'Year-Rel': getDate("yyyy")])
 655   }
 656   from(inputDir) {
 657     include '**/*.gif'
 658     include '**/*.jpg'
 659     include '**/*.png'
 660   }
 661   into outputDir
 662
 663   inputs.dir(inputDir)
 664   outputs.files(helpFile)
 665   outputs.dir(outputDir)
 666 }
 667
 668 task syncLib(type: Sync) {
 669   def syncDir = "${classes}/${libDistDir}"
 670   from fileTree("${jalviewDir}/${libDistDir}")
 671   into syncDir
 672 }
 673
 674 task syncResources(type: Sync) {
 675   from "${jalviewDir}/${resourceDir}"
 676   include "**/*.*"
 677   into "${classes}"
 678   preserve {
 679     include "**"
 680   }
 681 }
 682
 683 task prepare {
 684   dependsOn syncResources
 685   dependsOn syncDocs
 686   dependsOn copyHelp
 687 }
 688
 689
 690 //testReportDirName = "test-reports" // note that test workingDir will be $jalviewDir
 691 test {
 692   dependsOn prepare
 693   dependsOn compileJava
 694   if (use_clover) {
 695     dependsOn cloverInstr
 696   }
 697
 698   if (use_clover) {
 699     print("Running tests " + (use_clover?"WITH":"WITHOUT") + " clover [clover="+use_clover+"]\n")
 700   }
 701
 702   useTestNG() {
 703     includeGroups testngGroups
 704     preserveOrder true
 705     useDefaultListeners=true
 706   }
 707
 708   workingDir = jalviewDir
 709   //systemProperties 'clover.jar' System.properties.clover.jar
 710   sourceCompatibility = compile_source_compatibility
 711   targetCompatibility = compile_target_compatibility
 712   jvmArgs += additional_compiler_args
 713
 714 }
 715
 716 task buildIndices(type: JavaExec) {
 717   dependsOn copyHelp
 718   classpath = sourceSets.main.compileClasspath
 719   main = "com.sun.java.help.search.Indexer"
 720   workingDir = "${classes}/${helpDir}"
 721   def argDir = "html"
 722   args = [ argDir ]
 723   inputs.dir("${workingDir}/${argDir}")
 724
 725   outputs.dir("${classes}/doc")
 726   outputs.dir("${classes}/help")
 727   outputs.file("${workingDir}/JavaHelpSearch/DOCS")
 728   outputs.file("${workingDir}/JavaHelpSearch/DOCS.TAB")
 729   outputs.file("${workingDir}/JavaHelpSearch/OFFSETS")
 730   outputs.file("${workingDir}/JavaHelpSearch/POSITIONS")
 731   outputs.file("${workingDir}/JavaHelpSearch/SCHEMA")
 732   outputs.file("${workingDir}/JavaHelpSearch/TMAP")
 733 }
 734
 735 task compileLinkCheck(type: JavaCompile) {
 736   options.fork = true
 737   classpath = files("${jalviewDir}/${utilsDir}")
 738   destinationDir = file("${jalviewDir}/${utilsDir}")
 739   source = fileTree(dir: "${jalviewDir}/${utilsDir}", include: ["HelpLinksChecker.java", "BufferedLineReader.java"])
 740
 741   inputs.file("${jalviewDir}/${utilsDir}/HelpLinksChecker.java")
 742   inputs.file("${jalviewDir}/${utilsDir}/HelpLinksChecker.java")
 743   outputs.file("${jalviewDir}/${utilsDir}/HelpLinksChecker.class")
 744   outputs.file("${jalviewDir}/${utilsDir}/BufferedLineReader.class")
 745 }
 746
 747 task linkCheck(type: JavaExec) {
 748   dependsOn prepare, compileLinkCheck
 749
 750   def helpLinksCheckerOutFile = file("${jalviewDir}/${utilsDir}/HelpLinksChecker.out")
 751   classpath = files("${jalviewDir}/${utilsDir}")
 752   main = "HelpLinksChecker"
 753   workingDir = jalviewDir
 754   def help = "${classes}/${helpDir}"
 755   args = [ "${classes}/${helpDir}", "-nointernet" ]
 756
 757   def outFOS = new FileOutputStream(helpLinksCheckerOutFile, false) // false == don't append
 758   def errFOS = outFOS
 759   standardOutput = new org.apache.tools.ant.util.TeeOutputStream(
 760     outFOS,
 761     standardOutput)
 762   errorOutput = new org.apache.tools.ant.util.TeeOutputStream(
 763     outFOS,
 764     errorOutput)
 765
 766   inputs.dir("${classes}/${helpDir}")
 767   outputs.file(helpLinksCheckerOutFile)
 768 }
 769
 770 // import the pubhtmlhelp target
 771 ant.properties.basedir = "${jalviewDir}"
 772 ant.properties.helpBuildDir = "${jalviewDirAbsolutePath}/${classes}/${helpDir}"
 773 ant.importBuild "${utilsDir}/publishHelp.xml"
 774
 775
 776 task cleanPackageDir(type: Delete) {
 777   doFirst {
 778     delete fileTree(dir: "${jalviewDir}/${packageDir}", include: "*.jar")
 779   }
 780 }
 781
 782 jar {
 783   dependsOn linkCheck
 784   dependsOn buildIndices
 785   dependsOn createBuildProperties
 786
 787   manifest {
 788     attributes "Main-Class": mainClass,
 789     "Permissions": "all-permissions",
 790     "Application-Name": "Jalview Desktop",
 791     "Codebase": application_codebase
 792   }
 793
 794   destinationDir = file("${jalviewDir}/${packageDir}")
 795   archiveName = rootProject.name+".jar"
 796
 797   exclude "cache*/**"
 798   exclude "*.jar"
 799   exclude "*.jar.*"
 800   exclude "**/*.jar"
 801   exclude "**/*.jar.*"
 802
 803   inputs.dir("${classes}")
 804   outputs.file("${jalviewDir}/${packageDir}/${archiveName}")
 805 }
 806
 807 task copyJars(type: Copy) {
 808   from fileTree(dir: "${classes}", include: "**/*.jar").files
 809   into "${jalviewDir}/${packageDir}"
 810 }
 811
 812 // doing a Sync instead of Copy as Copy doesn't deal with "outputs" very well
 813 task syncJars(type: Sync) {
 814   from fileTree(dir: "${jalviewDir}/${libDistDir}", include: "**/*.jar").files
 815   into "${jalviewDir}/${packageDir}"
 816   preserve {
 817     include jar.archiveName
 818   }
 819 }
 820
 821 task makeDist {
 822   group = "build"
 823   description = "Put all required libraries in dist"
 824   // order of "cleanPackageDir", "copyJars", "jar" important!
 825   jar.mustRunAfter cleanPackageDir
 826   syncJars.mustRunAfter cleanPackageDir
 827   dependsOn cleanPackageDir
 828   dependsOn syncJars
 829   dependsOn jar
 830   outputs.dir("${jalviewDir}/${packageDir}")
 831 }
 832
 833 task cleanDist {
 834   dependsOn cleanPackageDir
 835   dependsOn cleanTest
 836   dependsOn clean
 837 }
 838
 839 shadowJar {
 840   group = "distribution"
 841   if (buildDist) {
 842     dependsOn makeDist
 843   }
 844   from ("${jalviewDir}/${libDistDir}") {
 845     include("*.jar")
 846   }
 847   manifest {
 848     attributes 'Implementation-Version': JALVIEW_VERSION
 849   }
 850   mainClassName = shadowJarMainClass
 851   mergeServiceFiles()
 852   classifier = "all-"+JALVIEW_VERSION+"-j"+JAVA_VERSION
 853   minimize()
 854 }
 855
 856 task getdownWebsite() {
 857   group = "distribution"
 858   description = "Create the getdown minimal app folder, and website folder for this version of jalview. Website folder also used for offline app installer"
 859   if (buildDist) {
 860     dependsOn makeDist
 861   }
 862
 863   def getdownWebsiteResourceFilenames = []
 864   def getdownTextString = ""
 865   def getdownResourceDir = project.ext.getdownResourceDir
 866   def getdownAppDir = project.ext.getdownAppDir
 867   def getdownResourceFilenames = []
 868
 869   doFirst {
 870     // clean the getdown website and files dir before creating getdown folders
 871     delete project.ext.getdownWebsiteDir
 872     delete project.ext.getdownFilesDir
 873
 874     copy {
 875       from buildProperties
 876       rename(build_properties_file, getdown_build_properties)
 877       into project.ext.getdownAppDir
 878     }
 879     getdownWebsiteResourceFilenames += "${getdown_app_dir}/${getdown_build_properties}"
 880
 881     // go through properties looking for getdown_txt_...
 882     def props = project.properties.sort { it.key }
 883     if (getdown_alt_java_min_version.length() > 0) {
 884       props.put("getdown_txt_java_min_version", getdown_alt_java_min_version)
 885     }
 886     if (getdown_alt_java_max_version.length() > 0) {
 887       props.put("getdown_txt_java_max_version", getdown_alt_java_max_version)
 888     }
 889     props.put("getdown_txt_multi_java_location", getdown_alt_multi_java_location)
 890
 891     props.put("getdown_txt_appbase", getdown_app_base)
 892     props.each{ prop, val ->
 893       if (prop.startsWith("getdown_txt_") && val != null) {
 894         if (prop.startsWith("getdown_txt_multi_")) {
 895           def key = prop.substring(18)
 896           val.split(",").each{ v ->
 897             def line = "${key} = ${v}\n"
 898             getdownTextString += line
 899           }
 900         } else {
 901           // file values rationalised
 902           if (val.indexOf('/') > -1 || prop.startsWith("getdown_txt_resource")) {
 903             def r = null
 904             if (val.indexOf('/') == 0) {
 905               // absolute path
 906               r = file(val)
 907             } else if (val.indexOf('/') > 0) {
 908               // relative path (relative to jalviewDir)
 909               r = file( "${jalviewDir}/${val}" )
 910             }
 911             if (r.exists()) {
 912               val = "${getdown_resource_dir}/" + r.getName()
 913               getdownWebsiteResourceFilenames += val
 914               getdownResourceFilenames += r.getPath()
 915             }
 916           }
 917           if (! prop.startsWith("getdown_txt_resource")) {
 918             def line = prop.substring(12) + " = ${val}\n"
 919             getdownTextString += line
 920           }
 921         }
 922       }
 923     }
 924
 925     getdownWebsiteResourceFilenames.each{ filename ->
 926       getdownTextString += "resource = ${filename}\n"
 927     }
 928     getdownResourceFilenames.each{ filename ->
 929       copy {
 930         from filename
 931         into project.ext.getdownResourceDir
 932       }
 933     }
 934
 935     def codeFiles = []
 936     fileTree(file(packageDir)).each{ f ->
 937       if (f.isDirectory()) {
 938         def files = fileTree(dir: f, include: ["*"]).getFiles()
 939         codeFiles += files
 940       } else if (f.exists()) {
 941         codeFiles += f
 942       }
 943     }
 944     codeFiles.sort().each{f ->
 945       def name = f.getName()
 946       def line = "code = ${getdown_app_dir}/${name}\n"
 947       getdownTextString += line
 948       copy {
 949         from f.getPath()
 950         into project.ext.getdownAppDir
 951       }
 952     }
 953
 954     // NOT USING MODULES YET, EVERYTHING SHOULD BE IN dist
 955     /*
 956     if (JAVA_VERSION.equals("11")) {
 957     def j11libFiles = fileTree(dir: "${jalviewDir}/${j11libDir}", include: ["*.jar"]).getFiles()
 958     j11libFiles.sort().each{f ->
 959     def name = f.getName()
 960     def line = "code = ${getdown_j11lib_dir}/${name}\n"
 961     getdownTextString += line
 962     copy {
 963     from f.getPath()
 964     into project.ext.getdownJ11libDir
 965     }
 966     }
 967     }
 968      */
 969
 970     // 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.
 971     //getdownTextString += "class = " + file(getdownLauncher).getName() + "\n"
 972     getdownTextString += "resource = ${getdown_launcher_new}\n"
 973     getdownTextString += "class = ${mainClass}\n"
 974
 975     def getdown_txt = file("${project.ext.getdownWebsiteDir}/getdown.txt")
 976     getdown_txt.write(getdownTextString)
 977
 978     def launch_jvl = file("${project.ext.getdownWebsiteDir}/${getdown_launch_jvl}")
 979     launch_jvl.write("appbase="+props.get("getdown_txt_appbase"))
 980
 981     copy {
 982       from getdownLauncher
 983       rename(file(getdownLauncher).getName(), getdown_launcher_new)
 984       into project.ext.getdownWebsiteDir
 985     }
 986
 987     copy {
 988       from getdownLauncher
 989       if (file(getdownLauncher).getName() != getdown_launcher) {
 990         rename(file(getdownLauncher).getName(), getdown_launcher)
 991       }
 992       into project.ext.getdownWebsiteDir
 993     }
 994
 995     if (! (CHANNEL.startsWith("ARCHIVE") || CHANNEL.startsWith("DEVELOP"))) {
 996       copy {
 997         from getdown_txt
 998         from getdownLauncher
 999         from "${getdownWebsiteDir}/${getdown_build_properties}"
1000         if (file(getdownLauncher).getName() != getdown_launcher) {
1001           rename(file(getdownLauncher).getName(), getdown_launcher)
1002         }
1003         into getdownInstallDir
1004       }
1005
1006       copy {
1007         from getdownInstallDir
1008         into getdownFilesInstallDir
1009       }
1010     }
1011
1012     copy {
1013       from getdown_txt
1014       from launch_jvl
1015       from getdownLauncher
1016       from "${getdownWebsiteDir}/${getdown_build_properties}"
1017       if (file(getdownLauncher).getName() != getdown_launcher) {
1018         rename(file(getdownLauncher).getName(), getdown_launcher)
1019       }
1020       into getdownFilesDir
1021     }
1022
1023     copy {
1024       from getdownResourceDir
1025       into "${project.ext.getdownFilesDir}/${getdown_resource_dir}"
1026     }
1027   }
1028
1029   if (buildDist) {
1030     inputs.dir("${jalviewDir}/${packageDir}")
1031   }
1032   outputs.dir(project.ext.getdownWebsiteDir)
1033   outputs.dir(project.ext.getdownFilesDir)
1034 }
1035
1036 task getdownDigest(type: JavaExec) {
1037   group = "distribution"
1038   description = "Digest the getdown website folder"
1039   dependsOn getdownWebsite
1040   doFirst {
1041     classpath = files("${getdownWebsiteDir}/${getdown_launcher}")
1042   }
1043   main = "com.threerings.getdown.tools.Digester"
1044   args project.ext.getdownWebsiteDir
1045   inputs.dir(project.ext.getdownWebsiteDir)
1046   outputs.file("${project.ext.getdownWebsiteDir}/digest2.txt")
1047 }
1048
1049 task getdown() {
1050   group = "distribution"
1051   description = "Create the minimal and full getdown app folder for installers and website and create digest file"
1052   dependsOn getdownDigest
1053   doLast {
1054     if (reportRsyncCommand) {
1055       def fromDir = getdownWebsiteDir + (getdownWebsiteDir.endsWith('/')?'':'/')
1056       def toDir = "${getdown_rsync_dest}/${getdownDir}" + (getdownDir.endsWith('/')?'':'/')
1057       println "LIKELY RSYNC COMMAND:"
1058       println "mkdir -p '$toDir'\nrsync -avh --delete '$fromDir' '$toDir'"
1059       if (RUNRSYNC == "true") {
1060         exec {
1061           commandLine "mkdir", "-p", toDir
1062         }
1063         exec {
1064           commandLine "rsync", "-avh", "--delete", fromDir, toDir
1065         }
1066       }
1067     }
1068   }
1069 }
1070
1071 clean {
1072   doFirst {
1073     delete project.ext.getdownWebsiteDir
1074     delete project.ext.getdownFilesDir
1075   }
1076 }
1077
1078 install4j {
1079   def install4jHomeDir = "/opt/install4j"
1080   def hostname = "hostname".execute().text.trim()
1081   if (hostname.equals("jv-bamboo")) {
1082     install4jHomeDir = System.getProperty("user.home")+"/buildtools/install4j"
1083   } else if (OperatingSystem.current().isMacOsX()) {
1084     install4jHomeDir = '/Applications/install4j.app/Contents/Resources/app'
1085     if (! file(install4jHomeDir).exists()) {
1086       install4jHomeDir = System.getProperty("user.home")+install4jHomeDir
1087     }
1088   } else if (OperatingSystem.current().isLinux()) {
1089     install4jHomeDir = System.getProperty("user.home")+"/buildtools/install4j"
1090   }
1091   installDir = file(install4jHomeDir)
1092   mediaTypes = Arrays.asList(install4jMediaTypes.split(","))
1093   if (install4jFaster.equals("true")) {
1094     faster = true
1095   }
1096 }
1097
1098 def install4jConf
1099 def macosJavaVMDir
1100 def macosJavaVMTgz
1101 def windowsJavaVMDir
1102 def windowsJavaVMTgz
1103 def install4jDir = "${jalviewDir}/${install4jResourceDir}"
1104 def install4jConfFile = "jalview-installers-java${JAVA_VERSION}.install4j"
1105 install4jConf = "${install4jDir}/${install4jConfFile}"
1106
1107 task copyInstall4jTemplate(type: Copy) {
1108   macosJavaVMDir = "${System.env.HOME}/buildtools/jre/openjdk-java_vm/getdown/macos-jre${JAVA_VERSION}/jre"
1109   macosJavaVMTgz = "${System.env.HOME}/buildtools/jre/openjdk-java_vm/install4j/tgz/macos-jre${JAVA_VERSION}.tar.gz"
1110   windowsJavaVMDir = "${System.env.HOME}/buildtools/jre/openjdk-java_vm/getdown/windows-jre${JAVA_VERSION}/jre"
1111   windowsJavaVMTgz = "${System.env.HOME}/buildtools/jre/openjdk-java_vm/install4j/tgz/windows-jre${JAVA_VERSION}.tar.gz"
1112   from (install4jDir) {
1113     include install4jTemplate
1114     rename (install4jTemplate, install4jConfFile)
1115     filter(ReplaceTokens, beginToken: '', endToken: '', tokens: ['9999999999': JAVA_VERSION])
1116     filter(ReplaceTokens, beginToken: '$$', endToken: '$$',
1117     tokens: [
1118     'JAVA_VERSION': JAVA_VERSION,
1119     'JAVA_INTEGER_VERSION': JAVA_INTEGER_VERSION,
1120     'VERSION': JALVIEW_VERSION,
1121     'MACOS_JAVA_VM_DIR': macosJavaVMDir,
1122     'MACOS_JAVA_VM_TGZ': macosJavaVMTgz,
1123     'WINDOWS_JAVA_VM_DIR': windowsJavaVMDir,
1124     'WINDOWS_JAVA_VM_TGZ': windowsJavaVMTgz,
1125     'INSTALL4JINFOPLISTFILEASSOCIATIONS': install4jInfoPlistFileAssociations,
1126     'COPYRIGHT_MESSAGE': install4jCopyrightMessage,
1127     'MACOS_BUNDLE_ID': install4jMacOSBundleId,
1128     'GETDOWN_RESOURCE_DIR': getdown_resource_dir,
1129     'GETDOWN_DIST_DIR': getdown_app_dir,
1130     'GETDOWN_ALT_DIR': getdown_app_dir_alt,
1131     'GETDOWN_INSTALL_DIR': getdown_install_dir
1132     ]
1133     )
1134     if (OSX_KEYPASS=="") {
1135       filter(ReplaceTokens, beginToken: 'codeSigning macEnabled="', endToken: '"', tokens: ['true':'codeSigning macEnabled="false"'])
1136       filter(ReplaceTokens, beginToken: 'runPostProcessor="true" ',endToken: 'Processor', tokens: ['post':'runPostProcessor="false" postProcessor'])
1137     }
1138   }
1139   into install4jDir
1140   outputs.files(install4jConf)
1141
1142   doLast {
1143     // include file associations in installer
1144     def installerFileAssociationsXml = file("${install4jDir}/${install4jInstallerFileAssociations}").text
1145     ant.replaceregexp(
1146       byline: false,
1147       flags: "s",
1148       match: '<action name="EXTENSIONS_REPLACED_BY_GRADLE".*?</action>',
1149       replace: installerFileAssociationsXml,
1150       file: install4jConf
1151     )
1152     /*
1153     // include uninstaller applescript app files in dmg
1154     def installerDMGUninstallerXml = file("$install4jDir/$install4jDMGUninstallerAppFiles").text
1155     ant.replaceregexp(
1156     byline: false,
1157     flags: "s",
1158     match: '<file name="UNINSTALL_OLD_JALVIEW_APP_REPLACED_IN_GRADLE" file=.*?>',
1159     replace: installerDMGUninstallerXml,
1160     file: install4jConf
1161     )
1162      */
1163   }
1164 }
1165
1166 task installers(type: com.install4j.gradle.Install4jTask) {
1167   group = "distribution"
1168   description = "Create the install4j installers"
1169   dependsOn getdown
1170   dependsOn copyInstall4jTemplate
1171   projectFile = file(install4jConf)
1172   variables = [majorVersion: version.substring(2, 11), build: 001, OSX_KEYSTORE: OSX_KEYSTORE, JSIGN_SH: JSIGN_SH]
1173   destination = "${jalviewDir}/${install4jBuildDir}/${JAVA_VERSION}"
1174   buildSelected = true
1175
1176   if (OSX_KEYPASS) {
1177     macKeystorePassword=OSX_KEYPASS
1178   }
1179
1180   doFirst {
1181     println("Using projectFile "+projectFile)
1182   }
1183
1184   inputs.dir(project.ext.getdownWebsiteDir)
1185   inputs.file(install4jConf)
1186   inputs.dir(macosJavaVMDir)
1187   inputs.dir(windowsJavaVMDir)
1188   outputs.dir("${jalviewDir}/${install4jBuildDir}/${JAVA_VERSION}")
1189 }
1190
1191 clean {
1192   doFirst {
1193     delete install4jConf
1194   }
1195 }
1196
1197 task sourceDist (type: Tar) {
1198
1199   def VERSION_UNDERSCORES = JALVIEW_VERSION.replaceAll("\\.", "_")
1200   def outputFileName = "${project.name}_${VERSION_UNDERSCORES}.tar.gz"
1201   // cater for buildship < 3.1 [3.0.1 is max version in eclipse 2018-09]
1202   try {
1203     archiveFileName = outputFileName
1204   } catch (Exception e) {
1205     archiveName = outputFileName
1206   }
1207
1208   compression Compression.GZIP
1209
1210   into project.name
1211
1212   def EXCLUDE_FILES=["build/*","bin/*","test-output/","test-reports","tests","clover*/*"
1213   ,".*"
1214   ,"benchmarking/*"
1215   ,"**/.*"
1216   ,"*.class"
1217   ,"**/*.class","${j11modDir}/**/*.jar","appletlib","**/*locales"
1218   ,"*locales/**",
1219   ,"utils/InstallAnywhere"]
1220   def PROCESS_FILES=[   "AUTHORS",
1221   "CITATION",
1222   "FEATURETODO",
1223   "JAVA-11-README",
1224   "FEATURETODO",
1225   "LICENSE",
1226   "**/README",
1227   "RELEASE",
1228   "THIRDPARTYLIBS","TESTNG",
1229   "build.gradle",
1230   "gradle.properties",
1231   "**/*.java",
1232   "**/*.html",
1233   "**/*.xml",
1234   "**/*.gradle",
1235   "**/*.groovy",
1236   "**/*.properties",
1237   "**/*.perl",
1238   "**/*.sh"]
1239
1240   from(jalviewDir) {
1241     exclude (EXCLUDE_FILES)
1242     include (PROCESS_FILES)
1243     filter(ReplaceTokens, beginToken: '$$', endToken: '$$', tokens: ['Version-Rel': JALVIEW_VERSION,'Year-Rel': getDate("yyyy")])
1244   }
1245   from(jalviewDir) {
1246     exclude (EXCLUDE_FILES)
1247     exclude (PROCESS_FILES)
1248   exclude ("appletlib")
1249   exclude ("**/*locales")
1250   exclude ("*locales/**")
1251   exclude ("utils/InstallAnywhere")
1252
1253     exclude (getdown_files_dir)
1254   exclude (getdown_website_dir)
1255
1256   // exluding these as not using jars as modules yet
1257   exclude ("${j11modDir}/**/*.jar")
1258 }
1259 //  from (jalviewDir) {
1260 //    // explicit includes for stuff that seemed to not get included
1261 //    include(fileTree("test/**/*."))
1262 //    exclude(EXCLUDE_FILES)
1263 //    exclude(PROCESS_FILES)
1264 //  }
1265 }
1266
1267 task helppages  {
1268   dependsOn copyHelp
1269   dependsOn pubhtmlhelp
1270
1271   inputs.dir("${classes}/${helpDir}")
1272   outputs.dir("${helpOutputDir}")
1273 }
1274
1275 def jalviewjsBuildDir
1276 def jalviewjsSiteDir
1277 def jalviewjsTransferSiteJSDir
1278 def jalviewjsTransferSiteLibDir
1279 task jalviewjsSitePath {
1280   def relativeBuildDir = file(jalviewDirAbsolutePath).toPath().relativize(buildDir.toPath())
1281   jalviewjsBuildDir = "${relativeBuildDir}/jalviewjs"
1282   jalviewjsSiteDir = "${jalviewjsBuildDir}/${jalviewjs_site_dir}"
1283   jalviewjsTransferSiteJSDir = "${jalviewjsBuildDir}/tmp/${jalviewjs_site_dir}_js"
1284   jalviewjsTransferSiteLibDir = "${jalviewjsBuildDir}/tmp/${jalviewjs_site_dir}_lib"
1285 }
1286
1287 def eclipseWorkspace
1288 task jalviewjsSetEclipseWorkspace {
1289   def propKey = "jalviewjs_eclipse_workspace"
1290   def propVal = null
1291   if (project.hasProperty(propKey)) {
1292     propVal = project.getProperty(propKey)
1293     if (propVal.startsWith("~/")) {
1294       propVal = System.getProperty("user.home") + propVal.substring(1)
1295     }
1296   }
1297   def propsFileName = "${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_eclipse_workspace_location_file}"
1298   def propsFile = file(propsFileName)
1299   def eclipseWsDir = propVal
1300   def props = new Properties()
1301
1302   if (( eclipseWsDir == null || !file(eclipseWsDir).exists() ) && propsFile.exists()) {
1303     def ins = new FileInputStream(propsFileName)
1304     props.load(ins)
1305     ins.close()
1306     if (props.getProperty(propKey, null) != null) {
1307       eclipseWsDir = props.getProperty(propKey)
1308     }
1309   }
1310
1311   def writeProps = false
1312   if (eclipseWsDir == null || !file(eclipseWsDir).exists()) {
1313     def tempDir = File.createTempDir()
1314     eclipseWsDir = tempDir.getAbsolutePath()
1315     writeProps = true
1316   }
1317   eclipseWorkspace = file(eclipseWsDir)
1318
1319   doFirst {
1320     if (writeProps) {
1321       props.setProperty(propKey, eclipseWsDir)
1322       propsFile.parentFile.mkdirs()
1323       def bytes = new ByteArrayOutputStream()
1324       props.store(bytes, null)
1325       def propertiesString = bytes.toString()
1326       propsFile.text = propertiesString
1327     }
1328
1329     println("ECLIPSE WORKSPACE: "+eclipseWorkspace.getPath())
1330   }
1331
1332   inputs.property(propKey, eclipseWsDir)
1333   outputs.file(propsFileName)
1334 }
1335
1336
1337 def eclipseBinary
1338 def eclipseVersion
1339 def eclipseDebug = false
1340 def eclipseVersionSuffix = ""
1341 task jalviewjsEclipsePaths {
1342   def eclipseProduct
1343
1344   def eclipseRoot = jalviewjs_eclipse_root
1345   if (eclipseRoot.startsWith("~/")) {
1346     eclipseRoot = System.getProperty("user.home") + eclipseRoot.substring(1)
1347   }
1348   if (OperatingSystem.current().isMacOsX()) {
1349     eclipseRoot += "/Eclipse.app"
1350     eclipseBinary = "${eclipseRoot}/Contents/MacOS/eclipse"
1351     eclipseProduct = "${eclipseRoot}/Contents/Eclipse/.eclipseproduct"
1352   } else if (OperatingSystem.current().isWindows()) { // check these paths!!
1353     if (file("${eclipseRoot}/eclipse").isDirectory() && file("${eclipseRoot}/eclipse/.eclipseproduct").exists()) {
1354       eclipseRoot += "/eclipse"
1355     }
1356     eclipseBinary = "${eclipseRoot}/eclipse"
1357     eclipseProduct = "${eclipseRoot}/.eclipseproduct"
1358   } else { // linux or unix
1359     if (file("${eclipseRoot}/eclipse").isDirectory() && file("${eclipseRoot}/eclipse/.eclipseproduct").exists()) {
1360       eclipseRoot += "/eclipse"
1361     }
1362     eclipseBinary = "${eclipseRoot}/eclipse"
1363     eclipseProduct = "${eclipseRoot}/.eclipseproduct"
1364   }
1365
1366   eclipseVersion = "4.12" // default
1367   def assumedVersion = true
1368   if (file(eclipseProduct).exists()) {
1369     def fis = new FileInputStream(eclipseProduct)
1370     def props = new Properties()
1371     props.load(fis)
1372     eclipseVersion = props.getProperty("version")
1373     fis.close()
1374     assumedVersion = false
1375   }
1376   /*
1377   String[] v = eclipseVersion.split("\\.")
1378   def v0 = Integer.valueOf(v[0])
1379   def v1 = Integer.valueOf(v[1])
1380   if (v0 < 4 || ( v0 == 4 && v1 < 13 )) {
1381     eclipseVersionSuffix = "_4.12"
1382   } else {
1383     eclipseVersionSuffix = "_4.13"
1384   }
1385   */
1386
1387
1388   def propKey = "eclipse_debug"
1389   eclipseDebug = (project.hasProperty(propKey) && project.getProperty(propKey).equals("true"))
1390
1391   doFirst {
1392     if (!assumedVersion) {
1393       println("ECLIPSE VERSION=${eclipseVersion}")
1394     }
1395   }
1396 }
1397
1398 task eclipseSetup {
1399   dependsOn eclipseProject
1400   dependsOn eclipseClasspath
1401   dependsOn eclipseJdt
1402 }
1403
1404 /* using the Copy task below
1405 task OLDjalviewjsEclipseCopyDropins {
1406   dependsOn jalviewjsEclipsePaths
1407   dependsOn jalviewjsCleanEclipse
1408   def inputFiles = fileTree(dir: "${jalviewDir}/${jalviewjs_eclipse_dropins_dir}", include: "*.jar")
1409   inputFiles += file(jalviewjs_j2s_plugin)
1410   def outputDir = "${buildDir}/jalviewjs
1411
1412   inputs.files inputFiles
1413   inputFiles.each { file ->
1414     outputs.file("${outputDir}/${file.name}")
1415   }
1416
1417   doLast {
1418     inputFiles.each { file ->
1419       copy {
1420         from file
1421         into outputDir
1422       }
1423     }
1424   }
1425 }
1426 */
1427
1428 // this version (type: Copy) will delete anything in the eclipse dropins folder that isn't in fromDropinsDir
1429 task jalviewjsEclipseCopyDropins(type: Copy) {
1430   dependsOn jalviewjsEclipsePaths
1431
1432   def inputFiles = fileTree(dir: "${jalviewDir}/${jalviewjs_eclipse_dropins_dir}", include: "*.jar")
1433   inputFiles += file("${jalviewDir}/${jalviewjs_j2s_plugin}")
1434   def outputDir = "${jalviewDir}/${jalviewjsBuildDir}/${jalviewjs_eclipse_tmp_dropins_dir}"
1435
1436   from inputFiles
1437   into outputDir
1438 }
1439
1440 // this eclipse -clean doesn't actually work
1441 task jalviewjsCleanEclipse(type: Exec) {
1442   dependsOn eclipseSetup
1443   dependsOn jalviewjsEclipsePaths
1444   dependsOn jalviewjsEclipseCopyDropins
1445
1446   executable(eclipseBinary)
1447   args(["-nosplash", "--launcher.suppressErrors", "-data", eclipseWorkspace.getPath(), "-clean", "-console", "-consoleLog"])
1448   if (eclipseDebug) {
1449     args += "-debug"
1450   }
1451   args += "-l"
1452
1453   def inputString = """exit
1454 y
1455 """
1456   def inputByteStream = new ByteArrayInputStream(inputString.getBytes())
1457   standardInput = inputByteStream
1458 }
1459 /* not really working yet
1460 jalviewjsEclipseCopyDropins.finalizedBy jalviewjsCleanEclipse
1461 */
1462
1463 def jalviewjsTransferSiteUnzipDir
1464 task jalviewjsTransferUnzipLib {
1465   dependsOn jalviewjsSitePath
1466
1467   def zipFiles = fileTree(dir: "${jalviewDir}/${jalviewjs_libjs_dir}", include: "*.zip")
1468   zipFiles += "${jalviewDir}/${jalviewjs_swingjs_zip}"
1469
1470   doLast {
1471     zipFiles.each { file_zip ->
1472       copy {
1473         from zipTree(file_zip)
1474         into "${jalviewDir}/${jalviewjsTransferSiteLibDir}"
1475       }
1476     }
1477   }
1478
1479   inputs.files zipFiles
1480   outputs.dir "${jalviewDir}/${jalviewjsTransferSiteLibDir}"
1481 }
1482
1483 task jalviewjsCreateJ2sSettings(type: WriteProperties) {
1484   group "JalviewJS"
1485   description "Create the .j2s file from the j2s.* properties"
1486
1487   dependsOn jalviewjsSitePath
1488
1489   outputFile ("${jalviewDir}/${jalviewjs_j2s_settings}")
1490   def j2s_props = project.properties.findAll { it.key.startsWith("j2s.") }.sort { it.key }
1491   def siteDirProperty = "j2s.site.directory"
1492   def setSiteDir = false
1493   j2s_props.each { prop, val ->
1494     if (val != null) {
1495       if (prop == siteDirProperty) {
1496         if (!(val.startsWith('/') || val.startsWith("file://") )) {
1497           val = "${jalviewDir}/${jalviewjsTransferSiteJSDir}/${val}"
1498         }
1499         setSiteDir = true
1500       }
1501       property(prop,val)
1502     }
1503     if (!setSiteDir) { // default site location, don't override specifically set property
1504       property(siteDirProperty,"${jalviewDir}/${jalviewjsTransferSiteJSDir}")
1505     }
1506   }
1507   inputs.properties(j2s_props)
1508   outputs.file(outputFile)
1509 }
1510
1511 task jalviewjsEclipseSetup {
1512   dependsOn jalviewjsEclipseCopyDropins
1513   dependsOn jalviewjsSetEclipseWorkspace
1514   dependsOn jalviewjsCreateJ2sSettings
1515 }
1516
1517 task jalviewjsSyncLib (type: Sync) {
1518   dependsOn jalviewjsSitePath
1519   dependsOn jalviewjsTransferUnzipLib
1520   def inputFiles = fileTree(dir: "${jalviewDir}/${jalviewjsTransferSiteLibDir}")
1521   def outputDir = "${jalviewDir}/${jalviewjsSiteDir}"
1522
1523   from inputFiles
1524   into outputDir
1525   def outputFiles = []
1526   rename { filename ->
1527     outputFiles += "${outputDir}/${filename}"
1528     null
1529   }
1530   preserve {
1531     include "**"
1532   }
1533   outputs.files outputFiles
1534   inputs.files inputFiles
1535 }
1536
1537 task jalviewjsSyncResources (type: Sync) {
1538   dependsOn jalviewjsSitePath
1539   def inputFiles = fileTree(dir: "${jalviewDir}/${resourceDir}")
1540   def outputDir = "${jalviewDir}/${jalviewjsSiteDir}/${jalviewjs_j2s_subdir}"
1541
1542   from inputFiles
1543   into outputDir
1544   def outputFiles = []
1545   rename { filename ->
1546     outputFiles += "${outputDir}/${filename}"
1547     null
1548   }
1549   preserve {
1550     include "**"
1551   }
1552   outputs.files outputFiles
1553   inputs.files inputFiles
1554 }
1555
1556 task jalviewjsSyncSiteResources (type: Sync) {
1557   dependsOn jalviewjsSitePath
1558   def inputFiles = fileTree(dir: "${jalviewDir}/${jalviewjs_site_resource_dir}")
1559   def outputDir = "${jalviewDir}/${jalviewjsSiteDir}"
1560
1561   from inputFiles
1562   into outputDir
1563   def outputFiles = []
1564   rename { filename ->
1565     outputFiles += "${outputDir}/${filename}"
1566     null
1567   }
1568   preserve {
1569     include "**"
1570   }
1571   outputs.files outputFiles
1572   inputs.files inputFiles
1573 }
1574
1575 task jalviewjsSyncBuildProperties (type: Sync) {
1576   dependsOn jalviewjsSitePath
1577   dependsOn createBuildProperties
1578   def inputFiles = [file(buildProperties)]
1579   def outputDir = "${jalviewDir}/${jalviewjsSiteDir}/${jalviewjs_j2s_subdir}"
1580
1581   from inputFiles
1582   into outputDir
1583   def outputFiles = []
1584   rename { filename ->
1585     outputFiles += "${outputDir}/${filename}"
1586     null
1587   }
1588   preserve {
1589     include "**"
1590   }
1591   outputs.files outputFiles
1592   inputs.files inputFiles
1593 }
1594
1595 task jalviewjsProjectImport(type: Exec) {
1596   dependsOn eclipseSetup
1597   dependsOn jalviewjsEclipsePaths
1598   dependsOn jalviewjsEclipseSetup
1599
1600   def projdir = eclipseWorkspace.getPath()+"/.metadata/.plugins/org.eclipse.core.resources/.projects/jalview/org.eclipse.jdt.core"
1601   executable(eclipseBinary)
1602   args(["-nosplash", "--launcher.suppressErrors", "-application", "com.seeq.eclipse.importprojects.headlessimport", "-data", eclipseWorkspace.getPath(), "-import", jalviewDirAbsolutePath])
1603   if (eclipseDebug) {
1604     args += "-debug"
1605   }
1606   args += [ "--launcher.appendVmargs", "-vmargs", "-Dorg.eclipse.equinox.p2.reconciler.dropins.directory=${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_eclipse_tmp_dropins_dir}" ]
1607
1608   inputs.file("${jalviewDir}/.project")
1609   outputs.upToDateWhen { file(projdir).exists() }
1610 }
1611
1612 task jalviewjsTranspile(type: Exec) {
1613   dependsOn jalviewjsEclipseSetup
1614   dependsOn jalviewjsProjectImport
1615   dependsOn jalviewjsEclipsePaths
1616
1617   executable(eclipseBinary)
1618   args(["-nosplash", "--launcher.suppressErrors", "-application", "org.eclipse.jdt.apt.core.aptBuild", "-data", eclipseWorkspace, "-${jalviewjs_eclipse_build_arg}", eclipse_project_name ])
1619   if (eclipseDebug) {
1620     args += "-debug"
1621   }
1622   args += [ "--launcher.appendVmargs", "-vmargs", "-Dorg.eclipse.equinox.p2.reconciler.dropins.directory=${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_eclipse_tmp_dropins_dir}" ]
1623
1624   def stdout
1625   def stderr
1626   doFirst {
1627     stdout = new ByteArrayOutputStream()
1628     stderr = new ByteArrayOutputStream()
1629
1630     def logOutFileName = "${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_j2s_stdout}"
1631     def logOutFile = file(logOutFileName)
1632     logOutFile.createNewFile()
1633     logOutFile.text = """ROOT: ${jalviewjs_eclipse_root}
1634 BINARY: ${eclipseBinary}
1635 VERSION: ${eclipseVersion}
1636 WORKSPACE: ${eclipseWorkspace}
1637 DEBUG: ${eclipseDebug}
1638 ----
1639 """
1640     def logOutFOS = new FileOutputStream(logOutFile, true) // true == append
1641     //def logErrFileName = "${jalviewDir}/${jalviewjsBuildDir}/${jalviewjs_j2s_stderr}"
1642     //def logErrFile = file(logFileName)
1643     //logErrFile.createNewFile()
1644     //def logErrFOS = new FileErrputStream(logErrFile, false)
1645     // combine stdout and stderr
1646     def logErrFOS = logOutFOS
1647
1648     if (jalviewjs_j2s_to_console.equals("true")) {
1649       standardOutput = new org.apache.tools.ant.util.TeeOutputStream(
1650         new org.apache.tools.ant.util.TeeOutputStream(
1651           logOutFOS,
1652           stdout),
1653         standardOutput)
1654       errorOutput = new org.apache.tools.ant.util.TeeOutputStream(
1655         new org.apache.tools.ant.util.TeeOutputStream(
1656           logErrFOS,
1657           stderr),
1658         errorOutput)
1659     } else {
1660       standardOutput = new org.apache.tools.ant.util.TeeOutputStream(
1661         logOutFOS,
1662         stdout)
1663       errorOutput = new org.apache.tools.ant.util.TeeOutputStream(
1664         logErrFOS,
1665         stderr)
1666     }
1667   }
1668
1669   doLast {
1670     if (stdout.toString().contains("Error processing ")) {
1671       // j2s did not complete transpile
1672       throw new GradleException("Error during transpilation:\n${stderr}\nSee eclipse transpile log file '${jalviewDir}/${jalviewjsBuildDir}/${jalviewjs_j2s_stdout}'")
1673     }
1674   }
1675
1676   inputs.dir("${jalviewDir}/${sourceDir}")
1677   outputs.dir("${jalviewDir}/${jalviewjsTransferSiteJSDir}")
1678   outputs.upToDateWhen( { file("${jalviewDir}/${jalviewjsTransferSiteJSDir}${jalviewjs_server_resource}").exists() } )
1679 }
1680
1681 // this Copy version of TransferSite will delete anything else in the target dir
1682 task jalviewjsCopyTransferSite(type: Copy) {
1683   dependsOn jalviewjsTranspile
1684   from "${jalviewDir}/${jalviewjsTransferSiteJSDir}"
1685   into "${jalviewDir}/${jalviewjsSiteDir}"
1686 }
1687
1688 // this Sync version of TransferSite is used by buildship to keep the website automatically up to date when a file changes
1689 task jalviewjsSyncTransferSite(type: Sync) {
1690   from "${jalviewDir}/${jalviewjsTransferSiteJSDir}"
1691   include "**/*.*"
1692   into "${jalviewDir}/${jalviewjsSiteDir}"
1693   preserve {
1694     include "**"
1695   }
1696 }
1697
1698 jalviewjsSyncLib.mustRunAfter jalviewjsCopyTransferSite
1699 jalviewjsSyncResources.mustRunAfter jalviewjsCopyTransferSite
1700 jalviewjsSyncSiteResources.mustRunAfter jalviewjsCopyTransferSite
1701 jalviewjsSyncBuildProperties.mustRunAfter jalviewjsCopyTransferSite
1702
1703 jalviewjsSyncLib.mustRunAfter jalviewjsSyncTransferSite
1704 jalviewjsSyncResources.mustRunAfter jalviewjsSyncTransferSite
1705 jalviewjsSyncSiteResources.mustRunAfter jalviewjsSyncTransferSite
1706 jalviewjsSyncBuildProperties.mustRunAfter jalviewjsSyncTransferSite
1707
1708 task jalviewjsPrepareSite {
1709   group "JalviewJS"
1710   description "Prepares the website folder including unzipping files and copying resources"
1711   dependsOn jalviewjsSyncLib
1712   dependsOn jalviewjsSyncResources
1713   dependsOn jalviewjsSyncSiteResources
1714   dependsOn jalviewjsSyncBuildProperties
1715 }
1716
1717 task jalviewjsBuildSite {
1718   group "JalviewJS"
1719   description "Builds the whole website including transpiled code"
1720   dependsOn jalviewjsCopyTransferSite
1721   dependsOn jalviewjsPrepareSite
1722 }
1723
1724 task cleanJalviewjsSite {
1725   doFirst {
1726     delete "${jalviewDir}/${jalviewjsTransferSiteJSDir}"
1727     delete "${jalviewDir}/${jalviewjsSiteDir}"
1728   }
1729 }
1730
1731 task jalviewjsSiteTar(type: Tar) {
1732   group "JalviewJS"
1733   description "Creates a tar.gz file for the website"
1734   dependsOn jalviewjsBuildSite
1735   def outputFilename = "jalviewjs-site-${JALVIEW_VERSION}.tar.gz"
1736   try {
1737     archiveFileName = outputFilename
1738   } catch (Exception e) {
1739     archiveName = outputFilename
1740   }
1741
1742   compression Compression.GZIP
1743
1744   from "${jalviewDir}/${jalviewjsSiteDir}"
1745   into jalviewjs_site_dir // this is inside the tar file
1746
1747   inputs.dir("${jalviewDir}/${jalviewjsSiteDir}")
1748 }
1749
1750 task jalviewjsServer {
1751   group "JalviewJS"
1752   def filename = "jalviewjsTest.html"
1753   description "Starts a webserver on localhost to test the website. See ${filename} to access local site on most recently used port."
1754   dependsOn jalviewjsSitePath
1755   def htmlFile = "${jalviewDirAbsolutePath}/${filename}"
1756   doLast {
1757
1758     SimpleHttpFileServerFactory factory = new SimpleHttpFileServerFactory()
1759     def port = Integer.valueOf(jalviewjs_server_port)
1760     def start = port
1761     def running = false
1762     def url
1763     while(port < start+1000 && !running) {
1764       try {
1765         def doc_root = new File("${jalviewDirAbsolutePath}/${jalviewjsSiteDir}")
1766         def jalviewjsServer = factory.start(doc_root, port)
1767         running = true
1768         url = jalviewjsServer.getResourceUrl(jalviewjs_server_resource)
1769         println("SERVER STARTED with document root ${doc_root}.")
1770         println("Go to "+url+" . Run  gradle --stop  to stop (kills all gradle daemons).")
1771         println("For debug: "+url+"?j2sdebug")
1772
1773         file(htmlFile).text = """
1774         <p><a href="${url}">Jalview JS Test. &lt;${url}&gt;</a></p>
1775         <p><a href="${url}?j2sdebug">Jalview JS Test with debug. &lt;${url}?j2sdebug&lt;</a></p>
1776         """
1777
1778       } catch (Exception e) {
1779         port++;
1780       }
1781     }
1782
1783   }
1784
1785   outputs.file(htmlFile)
1786   outputs.upToDateWhen({false})
1787 }
1788
1789 task cleanJalviewjsAll {
1790   group "JalviewJS"
1791   description "Delete all configuration and build artifacts to do with JalviewJS build"
1792   dependsOn cleanJalviewjsSite
1793   dependsOn jalviewjsEclipsePaths
1794
1795   doFirst {
1796     delete "${jalviewDir}/${jalviewjsBuildDir}"
1797     delete "${jalviewDir}/${eclipse_bin_dir}"
1798     if (eclipseWorkspace != null && file(eclipseWorkspace.getAbsolutePath()+"/.metadata").exists()) {
1799       delete file(eclipseWorkspace.getAbsolutePath()+"/.metadata")
1800     }
1801     delete "${jalviewDir}/${jalviewjs_j2s_settings}"
1802   }
1803
1804   outputs.upToDateWhen( { false } )
1805 }
1806
1807 task jalviewjs {
1808   group "JalviewJS"
1809   description "Build the site"
1810   dependsOn jalviewjsBuildSite
1811 }
1812
1813
1814 task jalviewjsIDE_CopyTransferSite(type: Copy) {
1815   from "${jalviewDir}/${jalviewjsTransferSiteJSDir}"
1816   into "${jalviewDir}/${jalviewjsSiteDir}"
1817 }
1818
1819 task jalviewjsIDE_j2s {
1820   group "00 JalviewJS in Eclipse"
1821   description "Creates the .j2s file"
1822   dependsOn jalviewjsCreateJ2sSettings
1823 }
1824
1825 task jalviewjsIDE_AssembleSite {
1826   group "00 JalviewJS in Eclipse"
1827   description "Assembles the Eclipse transpiled site and unzips supporting zipfiles"
1828   dependsOn jalviewjsIDE_CopyTransferSite
1829   dependsOn jalviewjsPrepareSite
1830 }
1831
1832 task jalviewjsIDE_SiteClean {
1833   group "00 JalviewJS in Eclipse"
1834   description "Deletes the Eclipse transpiled site"
1835   dependsOn cleanJalviewjsSite
1836 }
1837
1838 task jalviewjsIDE_Server {
1839   group "00 JalviewJS in Eclipse"
1840   description "Starts a webserver on localhost to test the website"
1841   dependsOn jalviewjsServer
1842 }
1843
1844 // buildship runs this at import
1845 task eclipseSynchronizationTask {
1846   dependsOn eclipseSetup
1847   dependsOn jalviewjsIDE_j2s
1848 }
1849
1850 // buildship runs this at build time
1851 task eclipseAutoBuildTask {
1852   dependsOn jalviewjsSyncTransferSite
1853   dependsOn jalviewjsPrepareSite
1854 }