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 def jalviewjsTransferSiteCoreDir
1280 task jalviewjsSitePath {
1281   def relativeBuildDir = file(jalviewDirAbsolutePath).toPath().relativize(buildDir.toPath())
1282   jalviewjsBuildDir = "${relativeBuildDir}/jalviewjs"
1283   jalviewjsSiteDir = "${jalviewjsBuildDir}/${jalviewjs_site_dir}"
1284   jalviewjsTransferSiteJsDir = "${jalviewjsBuildDir}/tmp/${jalviewjs_site_dir}_js"
1285   jalviewjsTransferSiteLibDir = "${jalviewjsBuildDir}/tmp/${jalviewjs_site_dir}_lib"
1286   jalviewjsTransferSiteCoreDir = "${jalviewjsBuildDir}/tmp/${jalviewjs_site_dir}_core"
1287 }
1288
1289 def eclipseWorkspace
1290 task jalviewjsSetEclipseWorkspace {
1291   def propKey = "jalviewjs_eclipse_workspace"
1292   def propVal = null
1293   if (project.hasProperty(propKey)) {
1294     propVal = project.getProperty(propKey)
1295     if (propVal.startsWith("~/")) {
1296       propVal = System.getProperty("user.home") + propVal.substring(1)
1297     }
1298   }
1299   def propsFileName = "${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_eclipse_workspace_location_file}"
1300   def propsFile = file(propsFileName)
1301   def eclipseWsDir = propVal
1302   def props = new Properties()
1303
1304   if (( eclipseWsDir == null || !file(eclipseWsDir).exists() ) && propsFile.exists()) {
1305     def ins = new FileInputStream(propsFileName)
1306     props.load(ins)
1307     ins.close()
1308     if (props.getProperty(propKey, null) != null) {
1309       eclipseWsDir = props.getProperty(propKey)
1310     }
1311   }
1312
1313   def writeProps = false
1314   if (eclipseWsDir == null || !file(eclipseWsDir).exists()) {
1315     def tempDir = File.createTempDir()
1316     eclipseWsDir = tempDir.getAbsolutePath()
1317     writeProps = true
1318   }
1319   eclipseWorkspace = file(eclipseWsDir)
1320
1321   doFirst {
1322     if (writeProps) {
1323       props.setProperty(propKey, eclipseWsDir)
1324       propsFile.parentFile.mkdirs()
1325       def bytes = new ByteArrayOutputStream()
1326       props.store(bytes, null)
1327       def propertiesString = bytes.toString()
1328       propsFile.text = propertiesString
1329     }
1330
1331     println("ECLIPSE WORKSPACE: "+eclipseWorkspace.getPath())
1332   }
1333
1334   inputs.property(propKey, eclipseWsDir)
1335   outputs.file(propsFileName)
1336 }
1337
1338
1339 def eclipseBinary
1340 def eclipseVersion
1341 def eclipseDebug = false
1342 def eclipseVersionSuffix = ""
1343 task jalviewjsEclipsePaths {
1344   def eclipseProduct
1345
1346   def eclipseRoot = jalviewjs_eclipse_root
1347   if (eclipseRoot.startsWith("~/")) {
1348     eclipseRoot = System.getProperty("user.home") + eclipseRoot.substring(1)
1349   }
1350   if (OperatingSystem.current().isMacOsX()) {
1351     eclipseRoot += "/Eclipse.app"
1352     eclipseBinary = "${eclipseRoot}/Contents/MacOS/eclipse"
1353     eclipseProduct = "${eclipseRoot}/Contents/Eclipse/.eclipseproduct"
1354   } else if (OperatingSystem.current().isWindows()) { // check these paths!!
1355     if (file("${eclipseRoot}/eclipse").isDirectory() && file("${eclipseRoot}/eclipse/.eclipseproduct").exists()) {
1356       eclipseRoot += "/eclipse"
1357     }
1358     eclipseBinary = "${eclipseRoot}/eclipse"
1359     eclipseProduct = "${eclipseRoot}/.eclipseproduct"
1360   } else { // linux or unix
1361     if (file("${eclipseRoot}/eclipse").isDirectory() && file("${eclipseRoot}/eclipse/.eclipseproduct").exists()) {
1362       eclipseRoot += "/eclipse"
1363     }
1364     eclipseBinary = "${eclipseRoot}/eclipse"
1365     eclipseProduct = "${eclipseRoot}/.eclipseproduct"
1366   }
1367
1368   eclipseVersion = "4.12" // default
1369   def assumedVersion = true
1370   if (file(eclipseProduct).exists()) {
1371     def fis = new FileInputStream(eclipseProduct)
1372     def props = new Properties()
1373     props.load(fis)
1374     eclipseVersion = props.getProperty("version")
1375     fis.close()
1376     assumedVersion = false
1377   }
1378   /*
1379   String[] v = eclipseVersion.split("\\.")
1380   def v0 = Integer.valueOf(v[0])
1381   def v1 = Integer.valueOf(v[1])
1382   if (v0 < 4 || ( v0 == 4 && v1 < 13 )) {
1383     eclipseVersionSuffix = "_4.12"
1384   } else {
1385     eclipseVersionSuffix = "_4.13"
1386   }
1387   */
1388
1389
1390   def propKey = "eclipse_debug"
1391   eclipseDebug = (project.hasProperty(propKey) && project.getProperty(propKey).equals("true"))
1392
1393   doFirst {
1394     if (!assumedVersion) {
1395       println("ECLIPSE VERSION=${eclipseVersion}")
1396     }
1397   }
1398 }
1399
1400 task eclipseSetup {
1401   dependsOn eclipseProject
1402   dependsOn eclipseClasspath
1403   dependsOn eclipseJdt
1404 }
1405
1406 /* using the Copy task below
1407 task OLDjalviewjsEclipseCopyDropins {
1408   dependsOn jalviewjsEclipsePaths
1409   dependsOn jalviewjsCleanEclipse
1410   def inputFiles = fileTree(dir: "${jalviewDir}/${jalviewjs_eclipse_dropins_dir}", include: "*.jar")
1411   inputFiles += file(jalviewjs_j2s_plugin)
1412   def outputDir = "${buildDir}/jalviewjs
1413
1414   inputs.files inputFiles
1415   inputFiles.each { file ->
1416     outputs.file("${outputDir}/${file.name}")
1417   }
1418
1419   doLast {
1420     inputFiles.each { file ->
1421       copy {
1422         from file
1423         into outputDir
1424       }
1425     }
1426   }
1427 }
1428 */
1429
1430 // this version (type: Copy) will delete anything in the eclipse dropins folder that isn't in fromDropinsDir
1431 task jalviewjsEclipseCopyDropins(type: Copy) {
1432   dependsOn jalviewjsEclipsePaths
1433
1434   def inputFiles = fileTree(dir: "${jalviewDir}/${jalviewjs_eclipse_dropins_dir}", include: "*.jar")
1435   inputFiles += file("${jalviewDir}/${jalviewjs_j2s_plugin}")
1436   def outputDir = "${jalviewDir}/${jalviewjsBuildDir}/${jalviewjs_eclipse_tmp_dropins_dir}"
1437
1438   from inputFiles
1439   into outputDir
1440 }
1441
1442 // this eclipse -clean doesn't actually work
1443 task jalviewjsCleanEclipse(type: Exec) {
1444   dependsOn eclipseSetup
1445   dependsOn jalviewjsEclipsePaths
1446   dependsOn jalviewjsEclipseCopyDropins
1447
1448   executable(eclipseBinary)
1449   args(["-nosplash", "--launcher.suppressErrors", "-data", eclipseWorkspace.getPath(), "-clean", "-console", "-consoleLog"])
1450   if (eclipseDebug) {
1451     args += "-debug"
1452   }
1453   args += "-l"
1454
1455   def inputString = """exit
1456 y
1457 """
1458   def inputByteStream = new ByteArrayInputStream(inputString.getBytes())
1459   standardInput = inputByteStream
1460 }
1461 /* not really working yet
1462 jalviewjsEclipseCopyDropins.finalizedBy jalviewjsCleanEclipse
1463 */
1464
1465 def jalviewjsTransferSiteUnzipDir
1466 task jalviewjsTransferUnzipLib {
1467   dependsOn jalviewjsSitePath
1468
1469   def zipFiles = fileTree(dir: "${jalviewDir}/${jalviewjs_libjs_dir}", include: "*.zip")
1470   zipFiles += "${jalviewDir}/${jalviewjs_swingjs_zip}"
1471
1472   doLast {
1473     zipFiles.each { file_zip ->
1474       copy {
1475         from zipTree(file_zip)
1476         into "${jalviewDir}/${jalviewjsTransferSiteLibDir}"
1477       }
1478     }
1479   }
1480
1481   inputs.files zipFiles
1482   outputs.dir "${jalviewDir}/${jalviewjsTransferSiteLibDir}"
1483 }
1484
1485 task jalviewjsCreateJ2sSettings(type: WriteProperties) {
1486   group "JalviewJS"
1487   description "Create the .j2s file from the j2s.* properties"
1488
1489   dependsOn jalviewjsSitePath
1490
1491   outputFile ("${jalviewDir}/${jalviewjs_j2s_settings}")
1492   def j2s_props = project.properties.findAll { it.key.startsWith("j2s.") }.sort { it.key }
1493   def siteDirProperty = "j2s.site.directory"
1494   def setSiteDir = false
1495   j2s_props.each { prop, val ->
1496     if (val != null) {
1497       if (prop == siteDirProperty) {
1498         if (!(val.startsWith('/') || val.startsWith("file://") )) {
1499           val = "${jalviewDir}/${jalviewjsTransferSiteJsDir}/${val}"
1500         }
1501         setSiteDir = true
1502       }
1503       property(prop,val)
1504     }
1505     if (!setSiteDir) { // default site location, don't override specifically set property
1506       property(siteDirProperty,"${jalviewDir}/${jalviewjsTransferSiteJsDir}")
1507     }
1508   }
1509   inputs.properties(j2s_props)
1510   outputs.file(outputFile)
1511 }
1512
1513 task jalviewjsEclipseSetup {
1514   dependsOn jalviewjsEclipseCopyDropins
1515   dependsOn jalviewjsSetEclipseWorkspace
1516   dependsOn jalviewjsCreateJ2sSettings
1517 }
1518
1519 task jalviewjsSyncLib (type: Sync) {
1520   dependsOn jalviewjsSitePath
1521   dependsOn jalviewjsTransferUnzipLib
1522   def inputFiles = fileTree(dir: "${jalviewDir}/${jalviewjsTransferSiteLibDir}")
1523   def outputDir = "${jalviewDir}/${jalviewjsSiteDir}"
1524
1525   from inputFiles
1526   into outputDir
1527   def outputFiles = []
1528   rename { filename ->
1529     outputFiles += "${outputDir}/${filename}"
1530     null
1531   }
1532   preserve {
1533     include "**"
1534   }
1535   outputs.files outputFiles
1536   inputs.files inputFiles
1537 }
1538
1539 task jalviewjsSyncCore (type: Sync) {
1540   dependsOn jalviewjsSitePath
1541   dependsOn "jalviewjsBuildAllCores"
1542   def inputFiles = fileTree(dir: "${jalviewDir}/${jalviewjsTransferSiteCoreDir}")
1543   def outputDir = "${jalviewDir}/${jalviewjsSiteDir}"
1544
1545   from inputFiles
1546   into outputDir
1547   def outputFiles = []
1548   rename { filename ->
1549     outputFiles += "${outputDir}/${filename}"
1550     null
1551   }
1552   preserve {
1553     include "**"
1554   }
1555   outputs.files outputFiles
1556   inputs.files inputFiles
1557 }
1558
1559 task jalviewjsSyncResources (type: Sync) {
1560   dependsOn jalviewjsSitePath
1561   def inputFiles = fileTree(dir: "${jalviewDir}/${resourceDir}")
1562   def outputDir = "${jalviewDir}/${jalviewjsSiteDir}/${jalviewjs_j2s_subdir}"
1563
1564   from inputFiles
1565   into outputDir
1566   def outputFiles = []
1567   rename { filename ->
1568     outputFiles += "${outputDir}/${filename}"
1569     null
1570   }
1571   preserve {
1572     include "**"
1573   }
1574   outputs.files outputFiles
1575   inputs.files inputFiles
1576 }
1577
1578 task jalviewjsSyncSiteResources (type: Sync) {
1579   dependsOn jalviewjsSitePath
1580   def inputFiles = fileTree(dir: "${jalviewDir}/${jalviewjs_site_resource_dir}")
1581   def outputDir = "${jalviewDir}/${jalviewjsSiteDir}"
1582
1583   from inputFiles
1584   into outputDir
1585   def outputFiles = []
1586   rename { filename ->
1587     outputFiles += "${outputDir}/${filename}"
1588     null
1589   }
1590   preserve {
1591     include "**"
1592   }
1593   outputs.files outputFiles
1594   inputs.files inputFiles
1595 }
1596
1597 task jalviewjsSyncBuildProperties (type: Sync) {
1598   dependsOn jalviewjsSitePath
1599   dependsOn createBuildProperties
1600   def inputFiles = [file(buildProperties)]
1601   def outputDir = "${jalviewDir}/${jalviewjsSiteDir}/${jalviewjs_j2s_subdir}"
1602
1603   from inputFiles
1604   into outputDir
1605   def outputFiles = []
1606   rename { filename ->
1607     outputFiles += "${outputDir}/${filename}"
1608     null
1609   }
1610   preserve {
1611     include "**"
1612   }
1613   outputs.files outputFiles
1614   inputs.files inputFiles
1615 }
1616
1617 task jalviewjsProjectImport(type: Exec) {
1618   dependsOn eclipseSetup
1619   dependsOn jalviewjsEclipsePaths
1620   dependsOn jalviewjsEclipseSetup
1621
1622   def projdir = eclipseWorkspace.getPath()+"/.metadata/.plugins/org.eclipse.core.resources/.projects/jalview/org.eclipse.jdt.core"
1623   executable(eclipseBinary)
1624   args(["-nosplash", "--launcher.suppressErrors", "-application", "com.seeq.eclipse.importprojects.headlessimport", "-data", eclipseWorkspace.getPath(), "-import", jalviewDirAbsolutePath])
1625   if (eclipseDebug) {
1626     args += "-debug"
1627   }
1628   args += [ "--launcher.appendVmargs", "-vmargs", "-Dorg.eclipse.equinox.p2.reconciler.dropins.directory=${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_eclipse_tmp_dropins_dir}" ]
1629
1630   inputs.file("${jalviewDir}/.project")
1631   outputs.upToDateWhen { file(projdir).exists() }
1632 }
1633
1634 task jalviewjsTranspile(type: Exec) {
1635   dependsOn jalviewjsEclipseSetup
1636   dependsOn jalviewjsProjectImport
1637   dependsOn jalviewjsEclipsePaths
1638
1639   executable(eclipseBinary)
1640   args(["-nosplash", "--launcher.suppressErrors", "-application", "org.eclipse.jdt.apt.core.aptBuild", "-data", eclipseWorkspace, "-${jalviewjs_eclipse_build_arg}", eclipse_project_name ])
1641   if (eclipseDebug) {
1642     args += "-debug"
1643   }
1644   args += [ "--launcher.appendVmargs", "-vmargs", "-Dorg.eclipse.equinox.p2.reconciler.dropins.directory=${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_eclipse_tmp_dropins_dir}" ]
1645
1646   def stdout
1647   def stderr
1648   doFirst {
1649     stdout = new ByteArrayOutputStream()
1650     stderr = new ByteArrayOutputStream()
1651
1652     def logOutFileName = "${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_j2s_stdout}"
1653     def logOutFile = file(logOutFileName)
1654     logOutFile.createNewFile()
1655     logOutFile.text = """ROOT: ${jalviewjs_eclipse_root}
1656 BINARY: ${eclipseBinary}
1657 VERSION: ${eclipseVersion}
1658 WORKSPACE: ${eclipseWorkspace}
1659 DEBUG: ${eclipseDebug}
1660 ----
1661 """
1662     def logOutFOS = new FileOutputStream(logOutFile, true) // true == append
1663     //def logErrFileName = "${jalviewDir}/${jalviewjsBuildDir}/${jalviewjs_j2s_stderr}"
1664     //def logErrFile = file(logFileName)
1665     //logErrFile.createNewFile()
1666     //def logErrFOS = new FileErrputStream(logErrFile, false)
1667     // combine stdout and stderr
1668     def logErrFOS = logOutFOS
1669
1670     if (jalviewjs_j2s_to_console.equals("true")) {
1671       standardOutput = new org.apache.tools.ant.util.TeeOutputStream(
1672         new org.apache.tools.ant.util.TeeOutputStream(
1673           logOutFOS,
1674           stdout),
1675         standardOutput)
1676       errorOutput = new org.apache.tools.ant.util.TeeOutputStream(
1677         new org.apache.tools.ant.util.TeeOutputStream(
1678           logErrFOS,
1679           stderr),
1680         errorOutput)
1681     } else {
1682       standardOutput = new org.apache.tools.ant.util.TeeOutputStream(
1683         logOutFOS,
1684         stdout)
1685       errorOutput = new org.apache.tools.ant.util.TeeOutputStream(
1686         logErrFOS,
1687         stderr)
1688     }
1689   }
1690
1691   doLast {
1692     if (stdout.toString().contains("Error processing ")) {
1693       // j2s did not complete transpile
1694       throw new GradleException("Error during transpilation:\n${stderr}\nSee eclipse transpile log file '${jalviewDir}/${jalviewjsBuildDir}/${jalviewjs_j2s_stdout}'")
1695     }
1696   }
1697
1698   inputs.dir("${jalviewDir}/${sourceDir}")
1699   outputs.dir("${jalviewDir}/${jalviewjsTransferSiteJsDir}")
1700   outputs.upToDateWhen( { file("${jalviewDir}/${jalviewjsTransferSiteJsDir}${jalviewjs_server_resource}").exists() } )
1701 }
1702
1703 // this Copy version of TransferSite will delete anything else in the target dir
1704 task jalviewjsCopyTransferSite(type: Copy) {
1705   dependsOn jalviewjsTranspile
1706   from "${jalviewDir}/${jalviewjsTransferSiteJsDir}"
1707   into "${jalviewDir}/${jalviewjsSiteDir}"
1708 }
1709
1710 // this Sync version of TransferSite is used by buildship to keep the website automatically up to date when a file changes
1711 task jalviewjsSyncTransferSite(type: Sync) {
1712   from "${jalviewDir}/${jalviewjsTransferSiteJsDir}"
1713   include "**/*.*"
1714   into "${jalviewDir}/${jalviewjsSiteDir}"
1715   preserve {
1716     include "**"
1717   }
1718 }
1719
1720 jalviewjsSyncLib.mustRunAfter jalviewjsCopyTransferSite
1721 jalviewjsSyncResources.mustRunAfter jalviewjsCopyTransferSite
1722 jalviewjsSyncSiteResources.mustRunAfter jalviewjsCopyTransferSite
1723 jalviewjsSyncBuildProperties.mustRunAfter jalviewjsCopyTransferSite
1724
1725 jalviewjsSyncLib.mustRunAfter jalviewjsSyncTransferSite
1726 jalviewjsSyncResources.mustRunAfter jalviewjsSyncTransferSite
1727 jalviewjsSyncSiteResources.mustRunAfter jalviewjsSyncTransferSite
1728 jalviewjsSyncBuildProperties.mustRunAfter jalviewjsSyncTransferSite
1729
1730 task jalviewjsPrepareSite {
1731   group "JalviewJS"
1732   description "Prepares the website folder including unzipping files and copying resources"
1733   dependsOn jalviewjsSyncLib
1734   dependsOn jalviewjsSyncResources
1735   dependsOn jalviewjsSyncSiteResources
1736   dependsOn jalviewjsSyncBuildProperties
1737 }
1738
1739 task jalviewjsBuildSite {
1740   group "JalviewJS"
1741   description "Builds the whole website including transpiled code"
1742   dependsOn jalviewjsCopyTransferSite
1743   dependsOn jalviewjsPrepareSite
1744 }
1745
1746 task cleanJalviewjsSite {
1747   doFirst {
1748     delete "${jalviewDir}/${jalviewjsTransferSiteJsDir}"
1749     delete "${jalviewDir}/${jalviewjsSiteDir}"
1750   }
1751 }
1752
1753 task jalviewjsSiteTar(type: Tar) {
1754   group "JalviewJS"
1755   description "Creates a tar.gz file for the website"
1756   dependsOn jalviewjsBuildSite
1757   def outputFilename = "jalviewjs-site-${JALVIEW_VERSION}.tar.gz"
1758   try {
1759     archiveFileName = outputFilename
1760   } catch (Exception e) {
1761     archiveName = outputFilename
1762   }
1763
1764   compression Compression.GZIP
1765
1766   from "${jalviewDir}/${jalviewjsSiteDir}"
1767   into jalviewjs_site_dir // this is inside the tar file
1768
1769   inputs.dir("${jalviewDir}/${jalviewjsSiteDir}")
1770 }
1771
1772 task jalviewjsServer {
1773   group "JalviewJS"
1774   def filename = "jalviewjsTest.html"
1775   description "Starts a webserver on localhost to test the website. See ${filename} to access local site on most recently used port."
1776   dependsOn jalviewjsSitePath
1777   def htmlFile = "${jalviewDirAbsolutePath}/${filename}"
1778   doLast {
1779
1780     SimpleHttpFileServerFactory factory = new SimpleHttpFileServerFactory()
1781     def port = Integer.valueOf(jalviewjs_server_port)
1782     def start = port
1783     def running = false
1784     def url
1785     while(port < start+1000 && !running) {
1786       try {
1787         def doc_root = new File("${jalviewDirAbsolutePath}/${jalviewjsSiteDir}")
1788         def jalviewjsServer = factory.start(doc_root, port)
1789         running = true
1790         url = jalviewjsServer.getResourceUrl(jalviewjs_server_resource)
1791         println("SERVER STARTED with document root ${doc_root}.")
1792         println("Go to "+url+" . Run  gradle --stop  to stop (kills all gradle daemons).")
1793         println("For debug: "+url+"?j2sdebug")
1794
1795         file(htmlFile).text = """
1796         <p><a href="${url}">Jalview JS Test. &lt;${url}&gt;</a></p>
1797         <p><a href="${url}?j2sdebug">Jalview JS Test with debug. &lt;${url}?j2sdebug&lt;</a></p>
1798         """
1799
1800       } catch (Exception e) {
1801         port++;
1802       }
1803     }
1804
1805   }
1806
1807   outputs.file(htmlFile)
1808   outputs.upToDateWhen({false})
1809 }
1810
1811 task cleanJalviewjsAll {
1812   group "JalviewJS"
1813   description "Delete all configuration and build artifacts to do with JalviewJS build"
1814   dependsOn cleanJalviewjsSite
1815   dependsOn jalviewjsEclipsePaths
1816
1817   doFirst {
1818     delete "${jalviewDir}/${jalviewjsBuildDir}"
1819     delete "${jalviewDir}/${eclipse_bin_dir}"
1820     if (eclipseWorkspace != null && file(eclipseWorkspace.getAbsolutePath()+"/.metadata").exists()) {
1821       delete file(eclipseWorkspace.getAbsolutePath()+"/.metadata")
1822     }
1823     delete "${jalviewDir}/${jalviewjs_j2s_settings}"
1824   }
1825
1826   outputs.upToDateWhen( { false } )
1827 }
1828
1829 task jalviewjs {
1830   group "JalviewJS"
1831   description "Build the site"
1832   dependsOn jalviewjsBuildSite
1833 }
1834
1835
1836 task jalviewjsIDE_CopyTransferSite(type: Copy) {
1837   from "${jalviewDir}/${jalviewjsTransferSiteJsDir}"
1838   into "${jalviewDir}/${jalviewjsSiteDir}"
1839 }
1840
1841 task jalviewjsIDE_j2s {
1842   group "00 JalviewJS in Eclipse"
1843   description "Creates the .j2s file"
1844   dependsOn jalviewjsCreateJ2sSettings
1845 }
1846
1847 task jalviewjsIDE_AssembleSite {
1848   group "00 JalviewJS in Eclipse"
1849   description "Assembles the Eclipse transpiled site and unzips supporting zipfiles"
1850   dependsOn jalviewjsIDE_CopyTransferSite
1851   dependsOn jalviewjsPrepareSite
1852 }
1853
1854 task jalviewjsIDE_SiteClean {
1855   group "00 JalviewJS in Eclipse"
1856   description "Deletes the Eclipse transpiled site"
1857   dependsOn cleanJalviewjsSite
1858 }
1859
1860 task jalviewjsIDE_Server {
1861   group "00 JalviewJS in Eclipse"
1862   description "Starts a webserver on localhost to test the website"
1863   dependsOn jalviewjsServer
1864 }
1865
1866 // buildship runs this at import
1867 task eclipseSynchronizationTask {
1868   dependsOn eclipseSetup
1869   dependsOn jalviewjsIDE_j2s
1870 }
1871
1872 // buildship runs this at build time
1873 task eclipseAutoBuildTask {
1874   dependsOn jalviewjsSyncTransferSite
1875   dependsOn jalviewjsPrepareSite
1876 }
1877
1878
1879
1880
1881
1882
1883
1884
1885 // closure
1886 def jalviewjsCallCore(String name, FileCollection list, String jsDir, String outputDir) {
1887   def coreFileName = "core${name}.js"
1888   def coreFilePath = "${outputDir}/${coreFileName}"
1889   def coreFile = file(coreFilePath)
1890   println("...Generating ${coreFilePath}")
1891
1892   def coreTop = file("${jsDir}/core/coretop2.js")
1893   def coreBottom = file("${jsDir}/core/corebottom2.js")
1894   coreFile.getParentFile().mkdirs()
1895   coreFile.createNewFile()
1896   coreFile.write( coreTop.text )
1897   list.each {
1898     f ->
1899     if (f.exists()) {
1900       def t = f.text
1901       t.replaceAll("Clazz\\.","Clazz_")
1902       t.replaceAll("Class__","Clazz._")
1903       coreFile.append( t )
1904     } else {
1905       println("...file ${line} does not exist, skipping")
1906     }
1907   }
1908   coreFile.append( coreBottom.text )
1909
1910   def coreZFileName = "core${name}.z.js"
1911   def coreZFilePath = "${outputDir}/${coreZFileName}"
1912   def coreZFile = file(coreZFilePath)
1913   println("...Generating ${coreZFilePath}")
1914
1915   javaexec {
1916     classpath = files(["${jalviewDir}/tools/closure_compiler.jar"])
1917     args = [ "--js", coreFileName, "--js_output_file", coreZFileName ]
1918     workingDir = outputDir
1919   }
1920
1921   return [ coreFile, coreZFile ]
1922 }
1923
1924 def jalviewjsToJs(String name, String classlist, String jsDir, String j2sDir, String outputDir) {
1925   def filelist = []
1926   file(classlist).eachLine {
1927     line ->
1928     filelist += line
1929   }
1930   def list = fileTree(dir: j2sDir, includes: filelist)
1931   /*
1932   def list = files()
1933   file(classlist).eachLine {
1934     line ->
1935     list += file("${j2sDir}/${line}")
1936   }
1937   */
1938
1939   return jalviewjsCallCore(name, list, jsDir, outputDir)
1940 // publish-core-template ... here?
1941 }
1942
1943 task jalviewjsBuildAllCores {
1944   group "JalviewJS"
1945   description "Build the core js lib closures"
1946
1947   dependsOn jalviewjsSitePath
1948   dependsOn jalviewjsTransferUnzipLib
1949   dependsOn jalviewjsTranspile
1950
1951   fileTree(dir: "${jalviewDir}/${jalviewjs_classlists_dir}", include: "*.txt").each {
1952     file ->
1953     def name = file.getName() - ".txt"
1954
1955     jalviewjsToJs(name, file.getAbsolutePath(), "${jalviewDir}/${jalviewjsTransferSiteLibDir}/${jalviewjs_js_subdir}", "${jalviewDir}/${jalviewjsTransferSiteJsDir}/${jalviewjs_j2s_subdir}", "${jalviewDir}/${jalviewjsTransferSiteCoreDir}/${jalviewjs_j2s_subdir}/core")
1956   }
1957 }