build.gradle

   1 import org.apache.tools.ant.filters.ReplaceTokens
   2 //import org.apache.tools.ant.filters.ReplaceRegexp
   3 import org.gradle.internal.os.OperatingSystem
   4 import org.gradle.plugins.ide.eclipse.model.*
   5
   6
   7 import groovy.transform.ExternalizeMethods
   8
   9 buildscript {
  10   dependencies {
  11     classpath 'org.openclover:clover:4.4.1'
  12     classpath 'org.apache.commons:commons-compress:1.18'
  13   }
  14 }
  15
  16 plugins {
  17   id 'java'
  18   id 'application'
  19   id 'eclipse'
  20   id 'com.github.johnrengelman.shadow' version '4.0.3'
  21   id 'com.install4j.gradle' version '7.0.9'
  22 }
  23
  24 repositories {
  25   jcenter()
  26   mavenCentral()
  27   mavenLocal()
  28   flatDir {
  29     dirs gradlePluginsDir
  30   }
  31 }
  32
  33 mainClassName = launcherClass
  34 def cloverInstrDir = file("$buildDir/$cloverSourcesInstrDir")
  35 def classes = "$jalviewDir/$classesDir"
  36
  37 if (clover.equals("true")) {
  38   use_clover = true
  39   classes = "$buildDir/$cloverClassesDir"
  40 } else {
  41   use_clover = false
  42   classes = "$jalviewDir/$classesDir"
  43 }
  44
  45 // configure classpath/args for j8/j11 compilation
  46
  47 def jalviewDirAbsolutePath = file(jalviewDir).getAbsolutePath()
  48 def libDir
  49 def libDistDir
  50 def compile_source_compatibility
  51 def compile_target_compatibility
  52
  53 ext {
  54   getdownWebsiteDir = jalviewDir + '/' + getdown_website_dir + '/' + JAVA_VERSION
  55   getdownDir = ""
  56   reportRsyncCmd = false
  57   buildDist = true
  58   buildProperties = buildPropertiesFile
  59   getdownLauncher = jalviewDir + '/' + getdown_lib_dir + '/' + getdown_launcher
  60   switch (CHANNEL) {
  61
  62     case "BUILD":
  63     // TODO: get bamboo build artifact URL for getdown artifacts
  64     getdown_channel_base = bamboo_channelbase
  65     getdown_channel_name = bamboo_planKey + '/'+JAVA_VERSION
  66     getdown_app_base = bamboo_channelbase + '/'+ bamboo_planKey + bamboo_getdown_channel_suffix + '/'+JAVA_VERSION
  67     getdown_app_dir = getdown_app_dir_alt
  68     buildProperties = jalviewDir + "/" + classesDir +"/" + buildPropertiesFile
  69     break
  70
  71     case "RELEASE":
  72     getdown_channel_name = CHANNEL.toLowerCase()
  73     getdownDir = getdown_channel_name + "/" + JAVA_VERSION
  74     getdown_app_base = getdown_channel_base + "/" + getdownDir
  75     getdown_app_dir = getdown_app_dir_release
  76     buildProperties = jalviewDir + "/" + classesDir +"/" + buildPropertiesFile
  77     reportRsyncCommand = true
  78     break
  79
  80     case "ARCHIVE":
  81     getdown_channel_name = CHANNEL.toLowerCase()+"/"+JALVIEW_VERSION
  82     getdownDir = getdown_channel_name + "/" + JAVA_VERSION
  83     getdown_app_base = getdown_channel_base + "/" + getdownDir
  84     getdown_app_dir = getdown_app_dir_alt
  85     if (!file(ARCHIVEDIR+"/"+packageDir).exists()) {
  86       print "Must provide an ARCHIVEDIR value to produce an archive distribution"
  87       exit
  88     } else {
  89       packageDir = ARCHIVEDIR + "/" + packageDir
  90       buildProperties = ARCHIVEDIR +"/" + classesDir + "/" + buildPropertiesFile
  91       buildDist = false
  92     }
  93     reportRsyncCommand = true
  94     break
  95
  96     case "ARCHIVELOCAL":
  97     getdown_channel_name = "archive" + "/" + JALVIEW_VERSION
  98     getdownDir = getdown_channel_name + "/" + JAVA_VERSION
  99     getdown_app_base = file(getdownWebsiteDir).toURI().toString()
 100     getdown_app_dir = getdown_app_dir_alt
 101     if (!file(ARCHIVEDIR+"/"+packageDir).exists()) {
 102       print "Must provide an ARCHIVEDIR value to produce an archive distribution"
 103       exit
 104     } else {
 105       packageDir = ARCHIVEDIR + "/" + packageDir
 106       buildProperties = ARCHIVEDIR +"/" + classesDir + "/" + buildPropertiesFile
 107       buildDist = false
 108     }
 109     reportRsyncCommand = true
 110     getdownLauncher = jalviewDir + '/' + getdown_lib_dir + '/' + getdown_launcher_local
 111     break
 112
 113     case "DEVELOP":
 114     getdown_channel_name = CHANNEL.toLowerCase()
 115     getdownDir = getdown_channel_name + "/" + JAVA_VERSION
 116     getdown_app_base = getdown_channel_base + "/" + getdownDir
 117     getdown_app_dir = getdown_app_dir_alt
 118     buildProperties = jalviewDir + "/" + classesDir +"/" + buildPropertiesFile
 119     reportRsyncCommand = true
 120     break
 121
 122     case "TEST-RELEASE":
 123     getdown_channel_name = CHANNEL.toLowerCase()
 124     getdownDir = getdown_channel_name + "/" + JAVA_VERSION
 125     getdown_app_base = getdown_channel_base + "/" + getdownDir
 126     getdown_app_dir = getdown_app_dir_alt
 127     buildProperties = jalviewDir + "/" + classesDir +"/" + buildPropertiesFile
 128     reportRsyncCommand = true
 129     break
 130
 131     case ~/^SCRATCH(|-[-\w]*)$/:
 132     getdown_channel_name = CHANNEL
 133     getdownDir = getdown_channel_name + "/" + JAVA_VERSION
 134     getdown_app_base = getdown_channel_base + "/" + getdownDir
 135     getdown_app_dir = getdown_app_dir_alt
 136     buildProperties = jalviewDir + "/" + classesDir +"/" + buildPropertiesFile
 137     reportRsyncCommand = true
 138     break
 139
 140     case "LOCAL":
 141     getdown_app_base = file(getdownWebsiteDir).toURI().toString()
 142     getdown_app_dir = getdown_app_dir_alt
 143     buildProperties = jalviewDir + "/" + classesDir +"/" + buildPropertiesFile
 144     getdownLauncher = jalviewDir + '/' + getdown_lib_dir + '/' + getdown_launcher_local
 145     break
 146
 147     default: // something wrong specified
 148     print("CHANNEL must be one of BUILD, RELEASE, ARCHIVE, DEVELOP, TEST-RELEASE, SCRATCH-..., LOCAL [default]")
 149     exit
 150     break
 151
 152   }
 153
 154   println("Using a "+CHANNEL+" profile. appbase="+getdown_app_base)
 155   getdownAppDir = getdownWebsiteDir + '/' + getdown_app_dir
 156   //getdownJ11libDir = getdownWebsiteDir + '/' + getdown_j11lib_dir
 157   getdownResourceDir = getdownWebsiteDir + '/' + getdown_resource_dir
 158   getdownInstallDir = getdownWebsiteDir + '/' + getdown_install_dir
 159   getdownFilesDir = jalviewDir + '/' + getdown_files_dir + '/' + JAVA_VERSION + '/'
 160   getdownFilesInstallDir = getdownFilesDir+"/"+getdown_install_dir
 161   /* compile without modules -- using classpath libraries
 162   modules_compileClasspath = fileTree(dir: "$jalviewDir/$j11modDir", include: ["*.jar"])
 163   modules_runtimeClasspath = modules_compileClasspath
 164   */
 165   gitHash = ""
 166   gitBranch = ""
 167 }
 168
 169 def JAVA_INTEGER_VERSION
 170 def additional_compiler_args = []
 171 // these are getdown.txt properties defined dependent on the JAVA_VERSION
 172 def getdown_alt_java_min_version
 173 def getdown_alt_java_max_version
 174 // this property is assigned below and expanded to multiple lines in the getdown task
 175 def getdown_alt_multi_java_location
 176 // this property is for the Java library used in eclipse
 177 def eclipse_java_runtime_name
 178 if (JAVA_VERSION.equals("1.8")) {
 179   JAVA_INTEGER_VERSION = "8"
 180   //libDir = j8libDir
 181   libDir = j11libDir
 182   libDistDir = j8libDir
 183   compile_source_compatibility = 1.8
 184   compile_target_compatibility = 1.8
 185   getdown_alt_java_min_version = getdown_alt_java8_min_version
 186   getdown_alt_java_max_version = getdown_alt_java8_max_version
 187   getdown_alt_multi_java_location = getdown_alt_java8_txt_multi_java_location
 188   eclipse_java_runtime_name = "JavaSE-1.8"
 189 } else if (JAVA_VERSION.equals("11")) {
 190   JAVA_INTEGER_VERSION = "11"
 191   libDir = j11libDir
 192   libDistDir = j11libDir
 193   compile_source_compatibility = 11
 194   compile_target_compatibility = 11
 195   getdown_alt_java_min_version = getdown_alt_java11_min_version
 196   getdown_alt_java_max_version = getdown_alt_java11_max_version
 197   getdown_alt_multi_java_location = getdown_alt_java11_txt_multi_java_location
 198   eclipse_java_runtime_name = "JavaSE-11"
 199   /* compile without modules -- using classpath libraries
 200   additional_compiler_args += [
 201   '--module-path', ext.modules_compileClasspath.asPath,
 202   '--add-modules', j11modules
 203   ]
 204   */
 205 } else if (JAVA_VERSION.equals("12") || JAVA_VERSION.equals("13")) {
 206   JAVA_INTEGER_VERSION = JAVA_VERSION
 207   libDir = j11libDir
 208   libDistDir = j11libDir
 209   compile_source_compatibility = JAVA_VERSION
 210   compile_target_compatibility = JAVA_VERSION
 211   getdown_alt_java_min_version = getdown_alt_java11_min_version
 212   getdown_alt_java_max_version = getdown_alt_java11_max_version
 213   getdown_alt_multi_java_location = getdown_alt_java11_txt_multi_java_location
 214   eclipse_java_runtime_name = "JavaSE-11"
 215   /* compile without modules -- using classpath libraries
 216   additional_compiler_args += [
 217   '--module-path', ext.modules_compileClasspath.asPath,
 218   '--add-modules', j11modules
 219   ]
 220   */
 221 } else {
 222   throw new GradleException("JAVA_VERSION=$JAVA_VERSION not currently supported by Jalview")
 223 }
 224
 225 sourceSets {
 226
 227   main {
 228     java {
 229       srcDirs "$jalviewDir/$sourceDir"
 230       outputDir = file("$classes")
 231     }
 232
 233     resources {
 234       srcDirs "$jalviewDir/$resourceDir"
 235     }
 236
 237     jar.destinationDir = file("$jalviewDir/$packageDir")
 238
 239     compileClasspath = files(sourceSets.main.java.outputDir)
 240     compileClasspath += fileTree(dir: "$jalviewDir/$libDir", include: ["*.jar"])
 241
 242     runtimeClasspath = compileClasspath
 243   }
 244   clover {
 245     java {
 246       srcDirs = [ cloverInstrDir ]
 247       outputDir = file("${buildDir}/${cloverClassesDir}")
 248     }
 249
 250     resources {
 251       srcDirs = sourceSets.main.resources.srcDirs
 252     }
 253     compileClasspath = configurations.cloverRuntime + files( sourceSets.clover.java.outputDir )
 254     compileClasspath += files(sourceSets.main.java.outputDir)
 255     compileClasspath += sourceSets.main.compileClasspath
 256     compileClasspath += fileTree(dir: "$jalviewDir/$utilsDir", include: ["**/*.jar"])
 257     compileClasspath += fileTree(dir: "$jalviewDir/$libDir", include: ["*.jar"])
 258
 259     runtimeClasspath = compileClasspath
 260   }
 261
 262   test {
 263     java {
 264       srcDirs "$jalviewDir/$testSourceDir"
 265       outputDir = file("$jalviewDir/$testOutputDir")
 266     }
 267
 268     resources {
 269       srcDirs = sourceSets.main.resources.srcDirs
 270     }
 271
 272     compileClasspath = files( sourceSets.test.java.outputDir )
 273
 274     if (use_clover) {
 275       compileClasspath = sourceSets.clover.compileClasspath
 276     } else {
 277       compileClasspath += files(sourceSets.main.java.outputDir)
 278     }
 279
 280     compileClasspath += fileTree(dir: "$jalviewDir/$utilsDir", include: ["**/*.jar"])
 281     compileClasspath += fileTree(dir: "$jalviewDir/$libDir", include: ["*.jar"])
 282
 283     runtimeClasspath = compileClasspath
 284   }
 285 }
 286
 287 // clover bits
 288 dependencies {
 289   if (use_clover) {
 290     cloverCompile 'org.openclover:clover:4.4.1'
 291     testCompile 'org.openclover:clover:4.4.1'
 292   }
 293 }
 294
 295 configurations {
 296   cloverRuntime
 297   cloverRuntime.extendsFrom cloverCompile
 298 }
 299
 300 eclipse {
 301   project {
 302     name = "Jalview with gradle build"
 303
 304     natures 'org.eclipse.jdt.core.javanature',
 305     'org.eclipse.jdt.groovy.core.groovyNature',
 306     'org.eclipse.buildship.core.gradleprojectnature'
 307
 308     buildCommand 'org.eclipse.jdt.core.javabuilder'
 309     buildCommand 'org.eclipse.buildship.core.gradleprojectbuilder'
 310   }
 311
 312   classpath {
 313     //defaultOutputDir = sourceSets.main.java.outputDir
 314     def removeThese = []
 315     configurations.each{ if (it.isCanBeResolved()) {
 316       removeThese += it
 317     }
 318   }
 319
 320   minusConfigurations += removeThese
 321   plusConfigurations = [ ]
 322   file {
 323
 324     whenMerged { cp ->
 325       def removeTheseToo = []
 326       HashMap<String, Boolean> addedSrcPath = new HashMap<>();
 327       cp.entries.each { entry ->
 328         if (entry.kind == 'src') {
 329           if (addedSrcPath.getAt(entry.path) || !(entry.path == "src" || entry.path == "test")) {
 330             removeTheseToo += entry
 331           } else {
 332             addedSrcPath.putAt(entry.path, true)
 333           }
 334         }
 335       }
 336       cp.entries.removeAll(removeTheseToo)
 337
 338       print ("CP="+cp.inspect())
 339
 340       cp.entries += new Output("bin/main")
 341       cp.entries += new Library(fileReference(helpParentDir))
 342       cp.entries += new Library(fileReference(resourceDir))
 343
 344       HashMap<String, Boolean> addedLibPath = new HashMap<>();
 345
 346       // changing from sourcesets.main.classpath to specific Java version lib
 347       //sourceSets.main.compileClasspath.each{
 348       fileTree("$jalviewDir/$libDistDir").include("**/*.jar").include("*.jar").each {
 349         //don't want to add outputDir as eclipse is using its own output dir in bin/main
 350         if (it.isDirectory() || ! it.exists()) {
 351           // don't add dirs to classpath
 352           return
 353         }
 354         def itPath = it.toString()
 355         if (itPath.startsWith(jalviewDirAbsolutePath+"/")) {
 356           itPath = itPath.substring(jalviewDirAbsolutePath.length()+1)
 357         }
 358         if (addedLibPath.get(itPath)) {
 359           //println("Not adding duplicate entry "+itPath)
 360         } else {
 361           //println("Adding entry "+itPath)
 362           cp.entries += new Library(fileReference(itPath))
 363           addedLibPath.put(itPath, true)
 364         }
 365       }
 366
 367       // changing from sourcesets.main.classpath to specific Java version lib
 368       //sourceSets.test.compileClasspath.each{
 369       fileTree(dir: "$jalviewDir/$utilsDir", include: ["**/*.jar"]).each {
 370         //if ((it.isDirectory() || ! it.exists()) && ! (it.equals(sourceSets.main.java.outputDir))) {
 371         //no longer want to add outputDir as eclipse is using its own output dir in bin/main
 372         if (it.isDirectory() || ! it.exists()) {
 373           // don't add dirs to classpath
 374           return false // groovy "break" in .each loop
 375         }
 376         def itPath = it.toString()
 377         if (itPath.startsWith(jalviewDirAbsolutePath+"/")) {
 378           itPath = itPath.substring(jalviewDirAbsolutePath.length()+1)
 379         }
 380         if (addedLibPath.get(itPath)) {
 381           // don't duplicate
 382         } else {
 383           def lib = new Library(fileReference(itPath))
 384           // this doesn't work... yet.  Adding test=true attribute using withXml below
 385           //def attrs = new Node(null, 'attributes', ["test":"true"])
 386           //lib.appendNode(attrs) //
 387           cp.entries += lib
 388           addedLibPath.put(itPath, true)
 389         }
 390         }
 391       }
 392
 393       // withXml changes ignored by buildship, these add the "test=true" attribute
 394       withXml {
 395         def node = it.asNode()
 396
 397         def srcTestAttributes
 398         node.children().each{ cpe ->
 399           def attributes = cpe.attributes()
 400           if (attributes.get("kind") == "src" && attributes.get("path") == "test") {
 401             srcTestAttributes = cpe.find { a -> a.name() == "attributes" }
 402             return
 403           }
 404         }
 405         def addTestAttribute = true
 406         srcTestAttributes.each{a ->
 407           if (a.name() == "attribute" && a.attributes().getAt("name") == "test") {
 408             addTestAttribute = false
 409           }
 410         }
 411         if (addTestAttribute) {
 412           srcTestAttributes.append(new Node(null, "attribute", [name:"test", value:"true"]))
 413         }
 414
 415         node.children().each{ cpe ->
 416           def attributes = cpe.attributes()
 417           if (attributes.get("kind") == "lib" && attributes.get("path").startsWith("utils/")) {
 418             cpe.appendNode('attributes')
 419             .appendNode('attribute', [name:"test", value:"true"])
 420           }
 421         }
 422       } // withXML
 423     } // file
 424
 425     containers 'org.eclipse.buildship.core.gradleclasspathcontainer'
 426   } // classpath
 427
 428   jdt {
 429     // for the IDE, use java 11 compatibility
 430     sourceCompatibility = compile_source_compatibility
 431     targetCompatibility = compile_target_compatibility
 432     javaRuntimeName = eclipse_java_runtime_name
 433
 434     file {
 435       withProperties { props ->
 436         def jalview_prefs = new Properties()
 437         def ins = new FileInputStream(jalviewDirAbsolutePath+"/"+eclipse_extra_jdt_prefs_file)
 438         jalview_prefs.load(ins)
 439         ins.close()
 440         jalview_prefs.forEach { t, v ->
 441           if (props.getAt(t) == null) {
 442             props.putAt(t, v)
 443           }
 444         }
 445       }
 446     }
 447   }
 448
 449   //synchronizationTasks eclipseClasspath
 450   //autoBuildTasks eclipseClasspath
 451 }
 452
 453 task cloverInstr() {
 454   // only instrument source, we build test classes as normal
 455   inputs.files files (sourceSets.main.allJava,sourceSets.test.allJava) // , fileTree(dir:"$jalviewDir/$testSourceDir", include: ["**/*.java"]))
 456   outputs.dir cloverInstrDir
 457
 458   doFirst {
 459     delete cloverInstrDir
 460     def argsList = ["--initstring", "${buildDir}/clover/clover.db",
 461     "-d", "${buildDir}/${cloverSourcesInstrDir}"]
 462     argsList.addAll(inputs.files.files.collect({ file ->
 463       file.absolutePath
 464     }))
 465     String[] args = argsList.toArray()
 466     println("About to instrument "+args.length +" files")
 467     com.atlassian.clover.CloverInstr.mainImpl(args)
 468   }
 469 }
 470
 471
 472 task cloverReportHTML (type: JavaExec) {
 473     inputs.dir "${buildDir}/clover"
 474     outputs.dir "${reportsDir}/clover"
 475
 476     classpath configurations.cloverRuntime
 477     maxHeapSize "${cloverReportJVMHeap}"
 478     jvmArgs += "${cloverReportJVMArgs}"
 479     main = "com.atlassian.clover.reporters.html.HtmlReporter"
 480     args  "--initstring", "${buildDir}/clover/clover.db", "-o", "${reportsDir}/clover"
 481     "${cloverReportHTMLOptions}".split(",").each {
 482       args+= it.trim()
 483       }
 484 }
 485
 486 task cloverReportXML (type: JavaExec) {
 487     inputs.dir "${buildDir}/clover"
 488     outputs.dir "${reportsDir}/clover"
 489     maxHeapSize "${cloverReportJVMHeap}"
 490     jvmArgs "${cloverReportJVMArgs}"
 491     classpath configurations.cloverRuntime
 492     main = "com.atlassian.clover.reporters.xml.XMLReporter"
 493     args  "--initstring", "${buildDir}/clover/clover.db", "-o", "${reportsDir}/clover/clover.xml"
 494
 495     "${cloverReportXMLOptions}".split(",").each {
 496       args+= it.trim()
 497       }
 498 }
 499 task cloverReport {
 500   group = "Verification"
 501     description = "Creates the Clover report"
 502     inputs.dir "${buildDir}/clover"
 503     outputs.dir "${reportsDir}/clover"
 504     onlyIf {
 505       file("${buildDir}/clover/clover.db").exists()
 506     }
 507     dependsOn cloverReportXML
 508     dependsOn cloverReportHTML
 509 }
 510
 511 // end clover bits
 512
 513
 514 compileJava {
 515
 516   doFirst {
 517     sourceCompatibility = compile_source_compatibility
 518     targetCompatibility = compile_target_compatibility
 519     options.compilerArgs = additional_compiler_args
 520     print ("Setting target compatibility to "+targetCompatibility+"\n")
 521   }
 522
 523 }
 524
 525 compileTestJava {
 526   if (use_clover) {
 527     dependsOn compileCloverJava
 528     classpath += configurations.cloverRuntime
 529   } else {
 530     classpath += sourceSets.main.runtimeClasspath
 531   }
 532   doFirst {
 533     sourceCompatibility = compile_source_compatibility
 534     targetCompatibility = compile_target_compatibility
 535     options.compilerArgs = additional_compiler_args
 536     print ("Setting target compatibility to "+targetCompatibility+"\n")
 537   }
 538 }
 539
 540
 541 compileCloverJava {
 542
 543   doFirst {
 544     sourceCompatibility = compile_source_compatibility
 545     targetCompatibility = compile_target_compatibility
 546     options.compilerArgs += additional_compiler_args
 547     print ("Setting target compatibility to "+targetCompatibility+"\n")
 548   }
 549   classpath += configurations.cloverRuntime
 550 }
 551
 552 clean {
 553   delete sourceSets.main.java.outputDir
 554 }
 555
 556 cleanTest {
 557   delete sourceSets.test.java.outputDir
 558   delete cloverInstrDir
 559 }
 560
 561 // format is a string like date.format("dd MMMM yyyy")
 562 def getDate(format) {
 563   def date = new Date()
 564   return date.format(format)
 565 }
 566
 567 task setGitVals {
 568   def hashStdOut = new ByteArrayOutputStream()
 569   exec {
 570     commandLine "git", "rev-parse", "--short", "HEAD"
 571     standardOutput = hashStdOut
 572     ignoreExitValue true
 573   }
 574
 575   def branchStdOut = new ByteArrayOutputStream()
 576   exec {
 577     commandLine "git", "rev-parse", "--abbrev-ref", "HEAD"
 578     standardOutput = branchStdOut
 579     ignoreExitValue true
 580   }
 581
 582   project.ext.gitHash = hashStdOut.toString().trim()
 583   project.ext.gitBranch = branchStdOut.toString().trim()
 584
 585   outputs.upToDateWhen { false }
 586 }
 587
 588 task createBuildProperties(type: WriteProperties) {
 589   dependsOn setGitVals
 590   inputs.dir("$jalviewDir/$sourceDir")
 591   inputs.dir("$classes")
 592   inputs.dir("$jalviewDir/$resourceDir")
 593   outputFile (buildProperties)
 594   // taking time specific comment out to allow better incremental builds
 595   comment "--Jalview Build Details--\n"+getDate("yyyy-MM-dd HH:mm:ss")
 596   //comment "--Jalview Build Details--\n"+getDate("yyyy-MM-dd")
 597   property "BUILD_DATE", getDate("HH:mm:ss dd MMMM yyyy")
 598   property "VERSION", JALVIEW_VERSION
 599   property "INSTALLATION", INSTALLATION+" git-commit:"+project.ext.gitHash+" ["+project.ext.gitBranch+"]"
 600   outputs.file(outputFile)
 601 }
 602
 603 def buildingHTML = "$jalviewDir/$docDir/building.html"
 604 task deleteBuildingHTML(type: Delete) {
 605   delete buildingHTML
 606 }
 607
 608 task convertBuildingMD(type: Exec) {
 609   dependsOn deleteBuildingHTML
 610   def buildingMD = "$jalviewDir/$docDir/building.md"
 611   def css = "$jalviewDir/$docDir/github.css"
 612
 613   def pandoc = null
 614   pandoc_exec.split(",").each {
 615     if (file(it.trim()).exists()) {
 616       pandoc = it.trim()
 617       return true
 618     }
 619   }
 620
 621   def hostname = "hostname".execute().text.trim()
 622   if ((pandoc == null || ! file(pandoc).exists()) && hostname.equals("jv-bamboo")) {
 623     pandoc = System.getProperty("user.home")+"/buildtools/pandoc/bin/pandoc"
 624   }
 625
 626   doFirst {
 627     if (pandoc != null && file(pandoc).exists()) {
 628         commandLine pandoc, '-s', '-o', buildingHTML, '--metadata', 'pagetitle="Building Jalview from Source"', '--toc', '-H', css, buildingMD
 629     } else {
 630         println("Cannot find pandoc. Skipping convert building.md to HTML")
 631         throw new StopExecutionException()
 632     }
 633   }
 634
 635   ignoreExitValue true
 636
 637   inputs.file(buildingMD)
 638   inputs.file(css)
 639   outputs.file(buildingHTML)
 640 }
 641 clean {
 642   delete buildingHTML
 643 }
 644
 645 task syncDocs(type: Sync) {
 646   dependsOn convertBuildingMD
 647   def syncDir = "$classes/$docDir"
 648   from fileTree("$jalviewDir/$docDir")
 649   into syncDir
 650
 651 }
 652
 653 def helpFile = "$classes/$helpDir/help.jhm"
 654
 655 task copyHelp(type: Copy) {
 656   def inputDir = "$jalviewDir/$helpParentDir/$helpDir"
 657   def outputDir = "$classes/$helpDir"
 658   from(inputDir) {
 659     exclude '**/*.gif'
 660       exclude '**/*.jpg'
 661       exclude '**/*.png'
 662       filter(ReplaceTokens, beginToken: '$$', endToken: '$$', tokens: ['Version-Rel': JALVIEW_VERSION,'Year-Rel': getDate("yyyy")])
 663   }
 664   from(inputDir) {
 665     include '**/*.gif'
 666       include '**/*.jpg'
 667       include '**/*.png'
 668   }
 669   into outputDir
 670
 671   inputs.dir(inputDir)
 672   outputs.files(helpFile)
 673   outputs.dir(outputDir)
 674 }
 675
 676 task syncLib(type: Sync) {
 677   def syncDir = "$classes/$libDistDir"
 678   from fileTree("$jalviewDir/$libDistDir")
 679   into syncDir
 680 }
 681
 682 task syncResources(type: Sync) {
 683   from "$jalviewDir/$resourceDir"
 684   include "**/*.*"
 685   exclude "install4j"
 686   into "$classes"
 687   preserve {
 688     include "**"
 689   }
 690 }
 691
 692 task prepare {
 693   dependsOn syncResources
 694   dependsOn syncDocs
 695   dependsOn copyHelp
 696 }
 697
 698
 699 //testReportDirName = "test-reports" // note that test workingDir will be $jalviewDir
 700 test {
 701   dependsOn prepare
 702   dependsOn compileJava
 703   if (use_clover) {
 704     dependsOn cloverInstr
 705   }
 706
 707   if (use_clover) {
 708     print("Running tests " + (use_clover?"WITH":"WITHOUT") + " clover [clover="+use_clover+"]\n")
 709   }
 710
 711   useTestNG() {
 712     includeGroups testngGroups
 713     preserveOrder true
 714     useDefaultListeners=true
 715   }
 716
 717   workingDir = jalviewDir
 718   //systemProperties 'clover.jar' System.properties.clover.jar
 719   sourceCompatibility = compile_source_compatibility
 720   targetCompatibility = compile_target_compatibility
 721   jvmArgs += additional_compiler_args
 722   print ("Setting target compatibility to "+targetCompatibility+"\n")
 723 }
 724
 725 task buildIndices(type: JavaExec) {
 726   dependsOn copyHelp
 727   classpath = sourceSets.main.compileClasspath
 728   main = "com.sun.java.help.search.Indexer"
 729   workingDir = "$classes/$helpDir"
 730   def argDir = "html"
 731   args = [ argDir ]
 732   inputs.dir("$workingDir/$argDir")
 733
 734   outputs.dir("$classes/doc")
 735   outputs.dir("$classes/help")
 736   outputs.file("$workingDir/JavaHelpSearch/DOCS")
 737   outputs.file("$workingDir/JavaHelpSearch/DOCS.TAB")
 738   outputs.file("$workingDir/JavaHelpSearch/OFFSETS")
 739   outputs.file("$workingDir/JavaHelpSearch/POSITIONS")
 740   outputs.file("$workingDir/JavaHelpSearch/SCHEMA")
 741   outputs.file("$workingDir/JavaHelpSearch/TMAP")
 742 }
 743
 744 task compileLinkCheck(type: JavaCompile) {
 745   options.fork = true
 746   classpath = files("$jalviewDir/$utilsDir")
 747   destinationDir = file("$jalviewDir/$utilsDir")
 748   source = fileTree(dir: "$jalviewDir/$utilsDir", include: ["HelpLinksChecker.java", "BufferedLineReader.java"])
 749
 750   inputs.file("$jalviewDir/$utilsDir/HelpLinksChecker.java")
 751   inputs.file("$jalviewDir/$utilsDir/HelpLinksChecker.java")
 752   outputs.file("$jalviewDir/$utilsDir/HelpLinksChecker.class")
 753   outputs.file("$jalviewDir/$utilsDir/BufferedLineReader.class")
 754 }
 755
 756 def helplinkscheckertouchfile = file("$jalviewDir/$utilsDir/HelpLinksChecker.touch")
 757 task linkCheck(type: JavaExec) {
 758   dependsOn prepare, compileLinkCheck
 759   classpath = files("$jalviewDir/$utilsDir")
 760   main = "HelpLinksChecker"
 761   workingDir = jalviewDir
 762   def help = "$classes/$helpDir"
 763   args = [ "$classes/$helpDir", "-nointernet" ]
 764
 765   doLast {
 766     helplinkscheckertouchfile.createNewFile()
 767   }
 768
 769   inputs.dir("$classes/$helpDir")
 770   outputs.file(helplinkscheckertouchfile)
 771 }
 772
 773 // import the pubhtmlhelp target
 774 ant.properties.basedir = "$jalviewDir"
 775 ant.properties.helpBuildDir = jalviewDirAbsolutePath+"/$classes/$helpDir"
 776 ant.importBuild "$utilsDir/publishHelp.xml"
 777
 778
 779 task cleanPackageDir(type: Delete) {
 780   delete fileTree("$jalviewDir/$packageDir").include("*.jar")
 781 }
 782
 783 jar {
 784   dependsOn linkCheck
 785   dependsOn buildIndices
 786   dependsOn createBuildProperties
 787
 788   manifest {
 789     attributes "Main-Class": mainClass,
 790     "Permissions": "all-permissions",
 791     "Application-Name": "Jalview Desktop",
 792     "Codebase": application_codebase
 793   }
 794
 795   destinationDir = file("$jalviewDir/$packageDir")
 796   archiveName = rootProject.name+".jar"
 797
 798   exclude "cache*/**"
 799   exclude "*.jar"
 800   exclude "*.jar.*"
 801   exclude "**/*.jar"
 802   exclude "**/*.jar.*"
 803
 804   inputs.dir("$classes")
 805   outputs.file("$jalviewDir/$packageDir/$archiveName")
 806 }
 807
 808 task copyJars(type: Copy) {
 809   from fileTree("$classes").include("**/*.jar").include("*.jar").files
 810   into "$jalviewDir/$packageDir"
 811 }
 812
 813 // doing a Sync instead of Copy as Copy doesn't deal with "outputs" very well
 814 task syncJars(type: Sync) {
 815   from fileTree("$jalviewDir/$libDistDir").include("**/*.jar").include("*.jar").files
 816   into "$jalviewDir/$packageDir"
 817   preserve {
 818     include jar.archiveName
 819   }
 820 }
 821
 822 task makeDist {
 823   group = "build"
 824   description = "Put all required libraries in dist"
 825   // order of "cleanPackageDir", "copyJars", "jar" important!
 826   jar.mustRunAfter cleanPackageDir
 827   syncJars.mustRunAfter cleanPackageDir
 828   dependsOn cleanPackageDir
 829   dependsOn syncJars
 830   dependsOn jar
 831   outputs.dir("$jalviewDir/$packageDir")
 832 }
 833
 834 task cleanDist {
 835   dependsOn cleanPackageDir
 836   dependsOn cleanTest
 837   dependsOn clean
 838 }
 839
 840 shadowJar {
 841   group = "distribution"
 842   if (buildDist) {
 843     dependsOn makeDist
 844   }
 845   from ("$jalviewDir/$libDistDir") {
 846     include("*.jar")
 847   }
 848   manifest {
 849     attributes 'Implementation-Version': JALVIEW_VERSION
 850   }
 851   mainClassName = shadowJarMainClass
 852   mergeServiceFiles()
 853   classifier = "all-"+JALVIEW_VERSION+"-j"+JAVA_VERSION
 854   minimize()
 855 }
 856
 857 task getdownWebsite() {
 858   group = "distribution"
 859   description = "Create the getdown minimal app folder, and website folder for this version of jalview. Website folder also used for offline app installer"
 860   if (buildDist) {
 861     dependsOn makeDist
 862   }
 863
 864         // clean the getdown website and files dir before creating getdown folders
 865         delete project.ext.getdownWebsiteDir
 866         delete project.ext.getdownFilesDir
 867
 868   def getdownWebsiteResourceFilenames = []
 869   def getdownTextString = ""
 870   def getdownResourceDir = project.ext.getdownResourceDir
 871   def getdownAppDir = project.ext.getdownAppDir
 872   def getdownResourceFilenames = []
 873
 874   doFirst {
 875     copy {
 876       from buildProperties
 877       rename(buildPropertiesFile, getdown_build_properties)
 878       into project.ext.getdownAppDir
 879     }
 880     getdownWebsiteResourceFilenames += getdown_app_dir+"/"+getdown_build_properties
 881
 882     // go through properties looking for getdown_txt_...
 883     def props = project.properties.sort { it.key }
 884         if (getdown_alt_java_min_version.length() > 0) {
 885                 props.put("getdown_txt_java_min_version", getdown_alt_java_min_version)
 886         }
 887         if (getdown_alt_java_max_version.length() > 0) {
 888                 props.put("getdown_txt_java_max_version", getdown_alt_java_max_version)
 889         }
 890         props.put("getdown_txt_multi_java_location", getdown_alt_multi_java_location)
 891
 892     props.put("getdown_txt_appbase", getdown_app_base)
 893     props.each{ prop, val ->
 894       if (prop.startsWith("getdown_txt_") && val != null) {
 895         if (prop.startsWith("getdown_txt_multi_")) {
 896           def key = prop.substring(18)
 897           val.split(",").each{ v ->
 898             def line = key + " = " + v + "\n"
 899             getdownTextString += line
 900           }
 901         } else {
 902           // file values rationalised
 903           if (val.indexOf('/') > -1 || prop.startsWith("getdown_txt_resource")) {
 904             def r = null
 905             if (val.indexOf('/') == 0) {
 906               // absolute path
 907               r = file(val)
 908             } else if (val.indexOf('/') > 0) {
 909               // relative path (relative to jalviewDir)
 910               r = file( jalviewDir + '/' + val )
 911             }
 912             if (r.exists()) {
 913               val = getdown_resource_dir + '/' + r.getName()
 914               getdownWebsiteResourceFilenames += val
 915               getdownResourceFilenames += r.getPath()
 916             }
 917           }
 918           if (! prop.startsWith("getdown_txt_resource")) {
 919             def line = prop.substring(12) + " = " + val + "\n"
 920             getdownTextString += line
 921           }
 922         }
 923       }
 924     }
 925
 926     getdownWebsiteResourceFilenames.each{ filename ->
 927       getdownTextString += "resource = "+filename+"\n"
 928     }
 929     getdownResourceFilenames.each{ filename ->
 930       copy {
 931         from filename
 932         into project.ext.getdownResourceDir
 933       }
 934     }
 935
 936     def codeFiles = []
 937     fileTree(file(packageDir)).each{ f ->
 938       if (f.isDirectory()) {
 939         def files = fileTree(dir: f, include: ["*"]).getFiles()
 940         codeFiles += files
 941       } else if (f.exists()) {
 942         codeFiles += f
 943       }
 944     }
 945     codeFiles.sort().each{f ->
 946       def line = "code = " + getdown_app_dir + '/' + f.getName() + "\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 line = "code = " + getdown_j11lib_dir + '/' + f.getName() + "\n"
 960     getdownTextString += line
 961     copy {
 962     from f.getPath()
 963     into project.ext.getdownJ11libDir
 964     }
 965     }
 966     }
 967      */
 968
 969     // 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.
 970     //getdownTextString += "class = " + file(getdownLauncher).getName() + "\n"
 971     getdownTextString += "resource = " + getdown_launcher_new + "\n"
 972     getdownTextString += "class = " + mainClass + "\n"
 973
 974     def getdown_txt = file(project.ext.getdownWebsiteDir + "/getdown.txt")
 975     getdown_txt.write(getdownTextString)
 976
 977     def launch_jvl = file(project.ext.getdownWebsiteDir + "/" + getdown_launch_jvl)
 978     launch_jvl.write("appbase="+props.get("getdown_txt_appbase"))
 979
 980     copy {
 981       from getdownLauncher
 982       rename(file(getdownLauncher).getName(), getdown_launcher_new)
 983       into project.ext.getdownWebsiteDir
 984     }
 985
 986     copy {
 987       from getdownLauncher
 988       if (file(getdownLauncher).getName() != getdown_launcher) {
 989         rename(file(getdownLauncher).getName(), getdown_launcher)
 990       }
 991       into project.ext.getdownWebsiteDir
 992     }
 993
 994     if (! (CHANNEL.startsWith("ARCHIVE") || CHANNEL.startsWith("DEVELOP"))) {
 995       copy {
 996         from getdown_txt
 997         from getdownLauncher
 998         from getdownWebsiteDir+"/"+getdown_build_properties
 999         if (file(getdownLauncher).getName() != getdown_launcher) {
1000           rename(file(getdownLauncher).getName(), getdown_launcher)
1001         }
1002         into getdownInstallDir
1003       }
1004
1005       copy {
1006         from getdownInstallDir
1007         into getdownFilesInstallDir
1008       }
1009     }
1010
1011     copy {
1012       from getdown_txt
1013       from launch_jvl
1014       from getdownLauncher
1015       from getdownWebsiteDir+"/"+getdown_build_properties
1016       if (file(getdownLauncher).getName() != getdown_launcher) {
1017         rename(file(getdownLauncher).getName(), getdown_launcher)
1018       }
1019       into getdownFilesDir
1020     }
1021
1022     copy {
1023           from getdownResourceDir
1024       into project.ext.getdownFilesDir + '/' + getdown_resource_dir
1025     }
1026   }
1027
1028   if (buildDist) {
1029     inputs.dir(jalviewDir + '/' + packageDir)
1030   }
1031   outputs.dir(project.ext.getdownWebsiteDir)
1032   outputs.dir(project.ext.getdownFilesDir)
1033 }
1034
1035 task getdownDigest(type: JavaExec) {
1036   group = "distribution"
1037   description = "Digest the getdown website folder"
1038   dependsOn getdownWebsite
1039   doFirst {
1040     classpath = files(getdownWebsiteDir + '/' + getdown_launcher)
1041   }
1042   main = "com.threerings.getdown.tools.Digester"
1043   args project.ext.getdownWebsiteDir
1044   inputs.dir(project.ext.getdownWebsiteDir)
1045   outputs.file(project.ext.getdownWebsiteDir + '/' + "digest2.txt")
1046 }
1047
1048 task getdown() {
1049   group = "distribution"
1050   description = "Create the minimal and full getdown app folder for installers and website and create digest file"
1051   dependsOn getdownDigest
1052   doLast {
1053     if (reportRsyncCommand) {
1054       def fromDir = getdownWebsiteDir + (getdownWebsiteDir.endsWith("/")?"":"/")
1055       def toDir = getdown_rsync_dest + "/" + getdownDir + (getdownDir.endsWith("/")?"":"/")
1056       println "LIKELY RSYNC COMMAND:"
1057       println "mkdir -p '$toDir'\nrsync -avh --delete '$fromDir' '$toDir'"
1058       if (RUNRSYNC == "true") {
1059         exec {
1060           commandLine "mkdir", "-p", toDir
1061         }
1062         exec {
1063           commandLine "rsync", "-avh", "--delete", fromDir, toDir
1064         }
1065       }
1066     }
1067   }
1068 }
1069
1070 clean {
1071   delete project.ext.getdownWebsiteDir
1072   delete project.ext.getdownFilesDir
1073 }
1074
1075 install4j {
1076   def install4jHomeDir = "/opt/install4j"
1077   def hostname = "hostname".execute().text.trim()
1078   if (hostname.equals("jv-bamboo")) {
1079     install4jHomeDir = System.getProperty("user.home")+"/buildtools/install4j"
1080   } else if (OperatingSystem.current().isMacOsX()) {
1081     install4jHomeDir = '/Applications/install4j.app/Contents/Resources/app'
1082     if (! file(install4jHomeDir).exists()) {
1083       install4jHomeDir = System.getProperty("user.home")+install4jHomeDir
1084     }
1085   } else if (OperatingSystem.current().isLinux()) {
1086     install4jHomeDir = System.getProperty("user.home")+"/buildtools/install4j"
1087   }
1088   installDir = file(install4jHomeDir)
1089   mediaTypes = Arrays.asList(install4jMediaTypes.split(","))
1090   if (install4jFaster.equals("true")) {
1091     faster = true
1092   }
1093 }
1094
1095 def install4jConf
1096 def macosJavaVMDir
1097 def macosJavaVMTgz
1098 def windowsJavaVMDir
1099 def windowsJavaVMTgz
1100 def install4jDir = "$jalviewDir/$install4jResourceDir"
1101 def install4jConfFile = "jalview-installers-java"+JAVA_VERSION+".install4j"
1102 install4jConf = "$install4jDir/$install4jConfFile"
1103
1104 task copyInstall4jTemplate(type: Copy) {
1105   macosJavaVMDir = System.env.HOME+"/buildtools/jre/openjdk-java_vm/getdown/macos-jre"+JAVA_VERSION+"/jre"
1106   macosJavaVMTgz = System.env.HOME+"/buildtools/jre/openjdk-java_vm/install4j/tgz/macos-jre"+JAVA_VERSION+".tar.gz"
1107   windowsJavaVMDir = System.env.HOME+"/buildtools/jre/openjdk-java_vm/getdown/windows-jre"+JAVA_VERSION+"/jre"
1108   windowsJavaVMTgz = System.env.HOME+"/buildtools/jre/openjdk-java_vm/install4j/tgz/windows-jre"+JAVA_VERSION+".tar.gz"
1109   from (install4jDir) {
1110     include install4jTemplate
1111     rename (install4jTemplate, install4jConfFile)
1112     filter(ReplaceTokens, beginToken: '', endToken: '', tokens: ['9999999999': JAVA_VERSION])
1113     filter(ReplaceTokens, beginToken: '$$', endToken: '$$',
1114     tokens: [
1115     'JAVA_VERSION': JAVA_VERSION,
1116     'JAVA_INTEGER_VERSION': JAVA_INTEGER_VERSION,
1117     'VERSION': JALVIEW_VERSION,
1118     'MACOS_JAVA_VM_DIR': macosJavaVMDir,
1119     'MACOS_JAVA_VM_TGZ': macosJavaVMTgz,
1120     'WINDOWS_JAVA_VM_DIR': windowsJavaVMDir,
1121     'WINDOWS_JAVA_VM_TGZ': windowsJavaVMTgz,
1122     'INSTALL4JINFOPLISTFILEASSOCIATIONS': install4jInfoPlistFileAssociations,
1123     'COPYRIGHT_MESSAGE': install4jCopyrightMessage,
1124     'MACOS_BUNDLE_ID': install4jMacOSBundleId,
1125     'GETDOWN_RESOURCE_DIR': getdown_resource_dir,
1126     'GETDOWN_DIST_DIR': getdown_app_dir,
1127     'GETDOWN_ALT_DIR': getdown_app_dir_alt,
1128     'GETDOWN_INSTALL_DIR': getdown_install_dir
1129     ]
1130     )
1131     if (OSX_KEYPASS=="") {
1132       filter(ReplaceTokens, beginToken: 'codeSigning macEnabled="', endToken: '"', tokens: ['true':'codeSigning macEnabled="false"'])
1133       filter(ReplaceTokens, beginToken: 'runPostProcessor="true" ',endToken: 'Processor', tokens: ['post':'runPostProcessor="false" postProcessor'])
1134     }
1135   }
1136   into install4jDir
1137   outputs.files(install4jConf)
1138
1139   doLast {
1140     // include file associations in installer
1141     def installerFileAssociationsXml = file("$install4jDir/$install4jInstallerFileAssociations").text
1142     ant.replaceregexp(
1143       byline: false,
1144       flags: "s",
1145       match: '<action name="EXTENSIONS_REPLACED_BY_GRADLE".*?</action>',
1146       replace: installerFileAssociationsXml,
1147       file: install4jConf
1148     )
1149     /*
1150     // include uninstaller applescript app files in dmg
1151     def installerDMGUninstallerXml = file("$install4jDir/$install4jDMGUninstallerAppFiles").text
1152     ant.replaceregexp(
1153     byline: false,
1154     flags: "s",
1155     match: '<file name="UNINSTALL_OLD_JALVIEW_APP_REPLACED_IN_GRADLE" file=.*?>',
1156     replace: installerDMGUninstallerXml,
1157     file: install4jConf
1158     )
1159      */
1160   }
1161 }
1162
1163 task installers(type: com.install4j.gradle.Install4jTask) {
1164   group = "distribution"
1165   description = "Create the install4j installers"
1166   dependsOn getdown
1167   dependsOn copyInstall4jTemplate
1168   projectFile = file(install4jConf)
1169   println("Using projectFile "+projectFile)
1170   variables = [majorVersion: version.substring(2, 11), build: 001, OSX_KEYSTORE: OSX_KEYSTORE, JSIGN_SH: JSIGN_SH]
1171   destination = "$jalviewDir/$install4jBuildDir/$JAVA_VERSION"
1172   buildSelected = true
1173
1174   if (OSX_KEYPASS) {
1175     macKeystorePassword=OSX_KEYPASS
1176
1177   }
1178
1179   inputs.dir(project.ext.getdownWebsiteDir)
1180   inputs.file(install4jConf)
1181   inputs.dir(macosJavaVMDir)
1182   inputs.dir(windowsJavaVMDir)
1183   outputs.dir("$jalviewDir/$install4jBuildDir/$JAVA_VERSION")
1184
1185 }
1186
1187 clean {
1188   delete install4jConf
1189 }
1190
1191 task sourceDist (type: Tar) {
1192
1193   def VERSION_UNDERSCORES = JALVIEW_VERSION.replaceAll("\\.", "_")
1194   def outputFileName = project.name + "_" + VERSION_UNDERSCORES + ".tar.gz"
1195   // cater for buildship < 3.1 [3.0.1 is max version in eclipse 2018-09]
1196   try {
1197     archiveFileName = outputFileName
1198   } catch (Exception e) {
1199     archiveName = outputFileName
1200   }
1201
1202   compression Compression.GZIP
1203
1204   into project.name
1205
1206   def EXCLUDE_FILES=[
1207     "build/*",
1208     "bin/*",
1209     "test-output/",
1210     "test-reports",
1211     "tests",
1212     "clover*/*",
1213     ".*",
1214     "benchmarking/*",
1215     "**/.*",
1216     "*.class",
1217     "**/*.class","$j11modDir/**/*.jar","appletlib","**/*locales",
1218     "*locales/**",
1219     "utils/InstallAnywhere",
1220     "**/*.log",
1221   ]
1222   def PROCESS_FILES=[
1223     "AUTHORS",
1224     "CITATION",
1225     "FEATURETODO",
1226     "JAVA-11-README",
1227     "FEATURETODO",
1228     "LICENSE",
1229     "**/README",
1230     "RELEASE",
1231     "THIRDPARTYLIBS",
1232     "TESTNG",
1233     "build.gradle",
1234     "gradle.properties",
1235     "**/*.java",
1236     "**/*.html",
1237     "**/*.xml",
1238     "**/*.gradle",
1239     "**/*.groovy",
1240     "**/*.properties",
1241     "**/*.perl",
1242     "**/*.sh",
1243   ]
1244   def INCLUDE_FILES=[
1245     ".settings/org.eclipse.jdt.core.jalview.prefs",
1246   ]
1247
1248   from(jalviewDir) {
1249     exclude (EXCLUDE_FILES)
1250     include (PROCESS_FILES)
1251     filter(ReplaceTokens, beginToken: '$$', endToken: '$$', tokens: ['Version-Rel': JALVIEW_VERSION,'Year-Rel': getDate("yyyy")])
1252   }
1253   from(jalviewDir) {
1254     exclude (EXCLUDE_FILES)
1255     exclude (PROCESS_FILES)
1256     exclude ("appletlib")
1257     exclude ("**/*locales")
1258     exclude ("*locales/**")
1259     exclude ("utils/InstallAnywhere")
1260
1261     exclude (getdown_files_dir)
1262     exclude (getdown_website_dir)
1263
1264     // exluding these as not using jars as modules yet
1265     exclude ("$j11modDir/**/*.jar")
1266   }
1267   from(jalviewDir) {
1268     include(INCLUDE_FILES)
1269   }
1270 //  from (jalviewDir) {
1271 //    // explicit includes for stuff that seemed to not get included
1272 //    include(fileTree("test/**/*."))
1273 //    exclude(EXCLUDE_FILES)
1274 //    exclude(PROCESS_FILES)
1275 //  }
1276 }
1277
1278 task helppages  {
1279   dependsOn copyHelp
1280   dependsOn pubhtmlhelp
1281
1282   inputs.dir("$classes/$helpDir")
1283   outputs.dir("$helpOutputDir")
1284 }