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.3.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.3.1'
 291     testCompile 'org.openclover:clover:4.3.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) // , 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 cloverReport {
 473   group = "Verification"
 474     description = "Createst the Clover report"
 475     inputs.dir "${buildDir}/clover"
 476     outputs.dir "${reportsDir}/clover"
 477     onlyIf {
 478       file("${buildDir}/clover/clover.db").exists()
 479     }
 480   doFirst {
 481     def argsList = ["--initstring", "${buildDir}/clover/clover.db",
 482     "-o", "${reportsDir}/clover"]
 483     String[] args = argsList.toArray()
 484     com.atlassian.clover.reporters.html.HtmlReporter.runReport(args)
 485
 486     // and generate ${reportsDir}/clover/clover.xml
 487     args = ["--initstring", "${buildDir}/clover/clover.db",
 488     "-o", "${reportsDir}/clover/clover.xml"].toArray()
 489     com.atlassian.clover.reporters.xml.XMLReporter.runReport(args)
 490   }
 491 }
 492
 493 // end clover bits
 494
 495
 496 compileJava {
 497
 498   doFirst {
 499     sourceCompatibility = compile_source_compatibility
 500     targetCompatibility = compile_target_compatibility
 501     options.compilerArgs = additional_compiler_args
 502     print ("Setting target compatibility to "+targetCompatibility+"\n")
 503   }
 504
 505 }
 506
 507 compileTestJava {
 508   if (use_clover) {
 509     dependsOn compileCloverJava
 510     classpath += configurations.cloverRuntime
 511   } else {
 512     classpath += sourceSets.main.runtimeClasspath
 513   }
 514   doFirst {
 515     sourceCompatibility = compile_source_compatibility
 516     targetCompatibility = compile_target_compatibility
 517     options.compilerArgs = additional_compiler_args
 518     print ("Setting target compatibility to "+targetCompatibility+"\n")
 519   }
 520 }
 521
 522
 523 compileCloverJava {
 524
 525   doFirst {
 526     sourceCompatibility = compile_source_compatibility
 527     targetCompatibility = compile_target_compatibility
 528     options.compilerArgs += additional_compiler_args
 529     print ("Setting target compatibility to "+targetCompatibility+"\n")
 530   }
 531   classpath += configurations.cloverRuntime
 532 }
 533
 534 clean {
 535   delete sourceSets.main.java.outputDir
 536 }
 537
 538 cleanTest {
 539   delete sourceSets.test.java.outputDir
 540   delete cloverInstrDir
 541 }
 542
 543 // format is a string like date.format("dd MMMM yyyy")
 544 def getDate(format) {
 545   def date = new Date()
 546   return date.format(format)
 547 }
 548
 549 task setGitVals {
 550   def hashStdOut = new ByteArrayOutputStream()
 551   exec {
 552     commandLine "git", "rev-parse", "--short", "HEAD"
 553     standardOutput = hashStdOut
 554     ignoreExitValue true
 555   }
 556
 557   def branchStdOut = new ByteArrayOutputStream()
 558   exec {
 559     commandLine "git", "rev-parse", "--abbrev-ref", "HEAD"
 560     standardOutput = branchStdOut
 561     ignoreExitValue true
 562   }
 563
 564   project.ext.gitHash = hashStdOut.toString().trim()
 565   project.ext.gitBranch = branchStdOut.toString().trim()
 566
 567   outputs.upToDateWhen { false }
 568 }
 569
 570 task createBuildProperties(type: WriteProperties) {
 571   dependsOn setGitVals
 572   inputs.dir("$jalviewDir/$sourceDir")
 573   inputs.dir("$classes")
 574   inputs.dir("$jalviewDir/$resourceDir")
 575   outputFile (buildProperties)
 576   // taking time specific comment out to allow better incremental builds
 577   comment "--Jalview Build Details--\n"+getDate("yyyy-MM-dd HH:mm:ss")
 578   //comment "--Jalview Build Details--\n"+getDate("yyyy-MM-dd")
 579   property "BUILD_DATE", getDate("HH:mm:ss dd MMMM yyyy")
 580   property "VERSION", JALVIEW_VERSION
 581   property "INSTALLATION", INSTALLATION+" git-commit:"+project.ext.gitHash+" ["+project.ext.gitBranch+"]"
 582   outputs.file(outputFile)
 583 }
 584
 585 def buildingHTML = "$jalviewDir/$docDir/building.html"
 586 task deleteBuildingHTML(type: Delete) {
 587   delete buildingHTML
 588 }
 589
 590 task convertBuildingMD(type: Exec) {
 591   dependsOn deleteBuildingHTML
 592   def buildingMD = "$jalviewDir/$docDir/building.md"
 593   def css = "$jalviewDir/$docDir/github.css"
 594
 595   def pandoc = null
 596   pandoc_exec.split(",").each {
 597     if (file(it.trim()).exists()) {
 598       pandoc = it.trim()
 599       return true
 600     }
 601   }
 602
 603   def hostname = "hostname".execute().text.trim()
 604   if ((pandoc == null || ! file(pandoc).exists()) && hostname.equals("jv-bamboo")) {
 605     pandoc = System.getProperty("user.home")+"/buildtools/pandoc/bin/pandoc"
 606   }
 607
 608   doFirst {
 609     if (pandoc != null && file(pandoc).exists()) {
 610         commandLine pandoc, '-s', '-o', buildingHTML, '--metadata', 'pagetitle="Building Jalview from Source"', '--toc', '-H', css, buildingMD
 611     } else {
 612         println("Cannot find pandoc. Skipping convert building.md to HTML")
 613         throw new StopExecutionException()
 614     }
 615   }
 616
 617   ignoreExitValue true
 618
 619   inputs.file(buildingMD)
 620   inputs.file(css)
 621   outputs.file(buildingHTML)
 622 }
 623 clean {
 624   delete buildingHTML
 625 }
 626
 627 task syncDocs(type: Sync) {
 628   dependsOn convertBuildingMD
 629   def syncDir = "$classes/$docDir"
 630   from fileTree("$jalviewDir/$docDir")
 631   into syncDir
 632
 633 }
 634
 635 def helpFile = "$classes/$helpDir/help.jhm"
 636
 637 task copyHelp(type: Copy) {
 638   def inputDir = "$jalviewDir/$helpParentDir/$helpDir"
 639   def outputDir = "$classes/$helpDir"
 640   from(inputDir) {
 641     exclude '**/*.gif'
 642       exclude '**/*.jpg'
 643       exclude '**/*.png'
 644       filter(ReplaceTokens, beginToken: '$$', endToken: '$$', tokens: ['Version-Rel': JALVIEW_VERSION,'Year-Rel': getDate("yyyy")])
 645   }
 646   from(inputDir) {
 647     include '**/*.gif'
 648       include '**/*.jpg'
 649       include '**/*.png'
 650   }
 651   into outputDir
 652
 653   inputs.dir(inputDir)
 654   outputs.files(helpFile)
 655   outputs.dir(outputDir)
 656 }
 657
 658 task syncLib(type: Sync) {
 659   def syncDir = "$classes/$libDistDir"
 660   from fileTree("$jalviewDir/$libDistDir")
 661   into syncDir
 662 }
 663
 664 task syncResources(type: Sync) {
 665   from "$jalviewDir/$resourceDir"
 666   include "**/*.*"
 667   exclude "install4j"
 668   into "$classes"
 669   preserve {
 670     include "**"
 671   }
 672 }
 673
 674 task prepare {
 675   dependsOn syncResources
 676   dependsOn syncDocs
 677   dependsOn copyHelp
 678 }
 679
 680
 681 //testReportDirName = "test-reports" // note that test workingDir will be $jalviewDir
 682 test {
 683   dependsOn prepare
 684   dependsOn compileJava
 685   if (use_clover) {
 686     dependsOn cloverInstr
 687   }
 688
 689   if (use_clover) {
 690     print("Running tests " + (use_clover?"WITH":"WITHOUT") + " clover [clover="+use_clover+"]\n")
 691   }
 692
 693   useTestNG() {
 694     includeGroups testngGroups
 695     preserveOrder true
 696     useDefaultListeners=true
 697   }
 698
 699   workingDir = jalviewDir
 700   //systemProperties 'clover.jar' System.properties.clover.jar
 701   sourceCompatibility = compile_source_compatibility
 702   targetCompatibility = compile_target_compatibility
 703   jvmArgs += additional_compiler_args
 704   print ("Setting target compatibility to "+targetCompatibility+"\n")
 705 }
 706
 707 task buildIndices(type: JavaExec) {
 708   dependsOn copyHelp
 709   classpath = sourceSets.main.compileClasspath
 710   main = "com.sun.java.help.search.Indexer"
 711   workingDir = "$classes/$helpDir"
 712   def argDir = "html"
 713   args = [ argDir ]
 714   inputs.dir("$workingDir/$argDir")
 715
 716   outputs.dir("$classes/doc")
 717   outputs.dir("$classes/help")
 718   outputs.file("$workingDir/JavaHelpSearch/DOCS")
 719   outputs.file("$workingDir/JavaHelpSearch/DOCS.TAB")
 720   outputs.file("$workingDir/JavaHelpSearch/OFFSETS")
 721   outputs.file("$workingDir/JavaHelpSearch/POSITIONS")
 722   outputs.file("$workingDir/JavaHelpSearch/SCHEMA")
 723   outputs.file("$workingDir/JavaHelpSearch/TMAP")
 724 }
 725
 726 task compileLinkCheck(type: JavaCompile) {
 727   options.fork = true
 728   classpath = files("$jalviewDir/$utilsDir")
 729   destinationDir = file("$jalviewDir/$utilsDir")
 730   source = fileTree(dir: "$jalviewDir/$utilsDir", include: ["HelpLinksChecker.java", "BufferedLineReader.java"])
 731
 732   inputs.file("$jalviewDir/$utilsDir/HelpLinksChecker.java")
 733   inputs.file("$jalviewDir/$utilsDir/HelpLinksChecker.java")
 734   outputs.file("$jalviewDir/$utilsDir/HelpLinksChecker.class")
 735   outputs.file("$jalviewDir/$utilsDir/BufferedLineReader.class")
 736 }
 737
 738 def helplinkscheckertouchfile = file("$jalviewDir/$utilsDir/HelpLinksChecker.touch")
 739 task linkCheck(type: JavaExec) {
 740   dependsOn prepare, compileLinkCheck
 741   classpath = files("$jalviewDir/$utilsDir")
 742   main = "HelpLinksChecker"
 743   workingDir = jalviewDir
 744   def help = "$classes/$helpDir"
 745   args = [ "$classes/$helpDir", "-nointernet" ]
 746
 747   doLast {
 748     helplinkscheckertouchfile.createNewFile()
 749   }
 750
 751   inputs.dir("$classes/$helpDir")
 752   outputs.file(helplinkscheckertouchfile)
 753 }
 754
 755 // import the pubhtmlhelp target
 756 ant.properties.basedir = "$jalviewDir"
 757 ant.properties.helpBuildDir = jalviewDirAbsolutePath+"/$classes/$helpDir"
 758 ant.importBuild "$utilsDir/publishHelp.xml"
 759
 760
 761 task cleanPackageDir(type: Delete) {
 762   delete fileTree("$jalviewDir/$packageDir").include("*.jar")
 763 }
 764
 765 jar {
 766   dependsOn linkCheck
 767   dependsOn buildIndices
 768   dependsOn createBuildProperties
 769
 770   manifest {
 771     attributes "Main-Class": mainClass,
 772     "Permissions": "all-permissions",
 773     "Application-Name": "Jalview Desktop",
 774     "Codebase": application_codebase
 775   }
 776
 777   destinationDir = file("$jalviewDir/$packageDir")
 778   archiveName = rootProject.name+".jar"
 779
 780   exclude "cache*/**"
 781   exclude "*.jar"
 782   exclude "*.jar.*"
 783   exclude "**/*.jar"
 784   exclude "**/*.jar.*"
 785
 786   inputs.dir("$classes")
 787   outputs.file("$jalviewDir/$packageDir/$archiveName")
 788 }
 789
 790 task copyJars(type: Copy) {
 791   from fileTree("$classes").include("**/*.jar").include("*.jar").files
 792   into "$jalviewDir/$packageDir"
 793 }
 794
 795 // doing a Sync instead of Copy as Copy doesn't deal with "outputs" very well
 796 task syncJars(type: Sync) {
 797   from fileTree("$jalviewDir/$libDistDir").include("**/*.jar").include("*.jar").files
 798   into "$jalviewDir/$packageDir"
 799   preserve {
 800     include jar.archiveName
 801   }
 802 }
 803
 804 task makeDist {
 805   group = "build"
 806   description = "Put all required libraries in dist"
 807   // order of "cleanPackageDir", "copyJars", "jar" important!
 808   jar.mustRunAfter cleanPackageDir
 809   syncJars.mustRunAfter cleanPackageDir
 810   dependsOn cleanPackageDir
 811   dependsOn syncJars
 812   dependsOn jar
 813   outputs.dir("$jalviewDir/$packageDir")
 814 }
 815
 816 task cleanDist {
 817   dependsOn cleanPackageDir
 818   dependsOn cleanTest
 819   dependsOn clean
 820 }
 821
 822 shadowJar {
 823   group = "distribution"
 824   if (buildDist) {
 825     dependsOn makeDist
 826   }
 827   from ("$jalviewDir/$libDistDir") {
 828     include("*.jar")
 829   }
 830   manifest {
 831     attributes 'Implementation-Version': JALVIEW_VERSION
 832   }
 833   mainClassName = shadowJarMainClass
 834   mergeServiceFiles()
 835   classifier = "all-"+JALVIEW_VERSION+"-j"+JAVA_VERSION
 836   minimize()
 837 }
 838
 839 task getdownWebsite() {
 840   group = "distribution"
 841   description = "Create the getdown minimal app folder, and website folder for this version of jalview. Website folder also used for offline app installer"
 842   if (buildDist) {
 843     dependsOn makeDist
 844   }
 845
 846         // clean the getdown website and files dir before creating getdown folders
 847         delete project.ext.getdownWebsiteDir
 848         delete project.ext.getdownFilesDir
 849
 850   def getdownWebsiteResourceFilenames = []
 851   def getdownTextString = ""
 852   def getdownResourceDir = project.ext.getdownResourceDir
 853   def getdownAppDir = project.ext.getdownAppDir
 854   def getdownResourceFilenames = []
 855
 856   doFirst {
 857     copy {
 858       from buildProperties
 859       rename(buildPropertiesFile, getdown_build_properties)
 860       into project.ext.getdownAppDir
 861     }
 862     getdownWebsiteResourceFilenames += getdown_app_dir+"/"+getdown_build_properties
 863
 864     // go through properties looking for getdown_txt_...
 865     def props = project.properties.sort { it.key }
 866         if (getdown_alt_java_min_version.length() > 0) {
 867                 props.put("getdown_txt_java_min_version", getdown_alt_java_min_version)
 868         }
 869         if (getdown_alt_java_max_version.length() > 0) {
 870                 props.put("getdown_txt_java_max_version", getdown_alt_java_max_version)
 871         }
 872         props.put("getdown_txt_multi_java_location", getdown_alt_multi_java_location)
 873
 874     props.put("getdown_txt_appbase", getdown_app_base)
 875     props.each{ prop, val ->
 876       if (prop.startsWith("getdown_txt_") && val != null) {
 877         if (prop.startsWith("getdown_txt_multi_")) {
 878           def key = prop.substring(18)
 879           val.split(",").each{ v ->
 880             def line = key + " = " + v + "\n"
 881             getdownTextString += line
 882           }
 883         } else {
 884           // file values rationalised
 885           if (val.indexOf('/') > -1 || prop.startsWith("getdown_txt_resource")) {
 886             def r = null
 887             if (val.indexOf('/') == 0) {
 888               // absolute path
 889               r = file(val)
 890             } else if (val.indexOf('/') > 0) {
 891               // relative path (relative to jalviewDir)
 892               r = file( jalviewDir + '/' + val )
 893             }
 894             if (r.exists()) {
 895               val = getdown_resource_dir + '/' + r.getName()
 896               getdownWebsiteResourceFilenames += val
 897               getdownResourceFilenames += r.getPath()
 898             }
 899           }
 900           if (! prop.startsWith("getdown_txt_resource")) {
 901             def line = prop.substring(12) + " = " + val + "\n"
 902             getdownTextString += line
 903           }
 904         }
 905       }
 906     }
 907
 908     getdownWebsiteResourceFilenames.each{ filename ->
 909       getdownTextString += "resource = "+filename+"\n"
 910     }
 911     getdownResourceFilenames.each{ filename ->
 912       copy {
 913         from filename
 914         into project.ext.getdownResourceDir
 915       }
 916     }
 917
 918     def codeFiles = []
 919     fileTree(file(packageDir)).each{ f ->
 920       if (f.isDirectory()) {
 921         def files = fileTree(dir: f, include: ["*"]).getFiles()
 922         codeFiles += files
 923       } else if (f.exists()) {
 924         codeFiles += f
 925       }
 926     }
 927     codeFiles.sort().each{f ->
 928       def line = "code = " + getdown_app_dir + '/' + f.getName() + "\n"
 929       getdownTextString += line
 930       copy {
 931         from f.getPath()
 932         into project.ext.getdownAppDir
 933       }
 934     }
 935
 936     // NOT USING MODULES YET, EVERYTHING SHOULD BE IN dist
 937     /*
 938     if (JAVA_VERSION.equals("11")) {
 939     def j11libFiles = fileTree(dir: "$jalviewDir/$j11libDir", include: ["*.jar"]).getFiles()
 940     j11libFiles.sort().each{f ->
 941     def line = "code = " + getdown_j11lib_dir + '/' + f.getName() + "\n"
 942     getdownTextString += line
 943     copy {
 944     from f.getPath()
 945     into project.ext.getdownJ11libDir
 946     }
 947     }
 948     }
 949      */
 950
 951     // 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.
 952     //getdownTextString += "class = " + file(getdownLauncher).getName() + "\n"
 953     getdownTextString += "resource = " + getdown_launcher_new + "\n"
 954     getdownTextString += "class = " + mainClass + "\n"
 955
 956     def getdown_txt = file(project.ext.getdownWebsiteDir + "/getdown.txt")
 957     getdown_txt.write(getdownTextString)
 958
 959     def launch_jvl = file(project.ext.getdownWebsiteDir + "/" + getdown_launch_jvl)
 960     launch_jvl.write("appbase="+props.get("getdown_txt_appbase"))
 961
 962     copy {
 963       from getdownLauncher
 964       rename(file(getdownLauncher).getName(), getdown_launcher_new)
 965       into project.ext.getdownWebsiteDir
 966     }
 967
 968     copy {
 969       from getdownLauncher
 970       if (file(getdownLauncher).getName() != getdown_launcher) {
 971         rename(file(getdownLauncher).getName(), getdown_launcher)
 972       }
 973       into project.ext.getdownWebsiteDir
 974     }
 975
 976     if (! (CHANNEL.startsWith("ARCHIVE") || CHANNEL.startsWith("DEVELOP"))) {
 977       copy {
 978         from getdown_txt
 979         from getdownLauncher
 980         from getdownWebsiteDir+"/"+getdown_build_properties
 981         if (file(getdownLauncher).getName() != getdown_launcher) {
 982           rename(file(getdownLauncher).getName(), getdown_launcher)
 983         }
 984         into getdownInstallDir
 985       }
 986
 987       copy {
 988         from getdownInstallDir
 989         into getdownFilesInstallDir
 990       }
 991     }
 992
 993     copy {
 994       from getdown_txt
 995       from launch_jvl
 996       from getdownLauncher
 997       from getdownWebsiteDir+"/"+getdown_build_properties
 998       if (file(getdownLauncher).getName() != getdown_launcher) {
 999         rename(file(getdownLauncher).getName(), getdown_launcher)
1000       }
1001       into getdownFilesDir
1002     }
1003
1004     copy {
1005           from getdownResourceDir
1006       into project.ext.getdownFilesDir + '/' + getdown_resource_dir
1007     }
1008   }
1009
1010   if (buildDist) {
1011     inputs.dir(jalviewDir + '/' + packageDir)
1012   }
1013   outputs.dir(project.ext.getdownWebsiteDir)
1014   outputs.dir(project.ext.getdownFilesDir)
1015 }
1016
1017 task getdownDigest(type: JavaExec) {
1018   group = "distribution"
1019   description = "Digest the getdown website folder"
1020   dependsOn getdownWebsite
1021   doFirst {
1022     classpath = files(getdownWebsiteDir + '/' + getdown_launcher)
1023   }
1024   main = "com.threerings.getdown.tools.Digester"
1025   args project.ext.getdownWebsiteDir
1026   inputs.dir(project.ext.getdownWebsiteDir)
1027   outputs.file(project.ext.getdownWebsiteDir + '/' + "digest2.txt")
1028 }
1029
1030 task getdown() {
1031   group = "distribution"
1032   description = "Create the minimal and full getdown app folder for installers and website and create digest file"
1033   dependsOn getdownDigest
1034   doLast {
1035     if (reportRsyncCommand) {
1036       def fromDir = getdownWebsiteDir + (getdownWebsiteDir.endsWith("/")?"":"/")
1037       def toDir = getdown_rsync_dest + "/" + getdownDir + (getdownDir.endsWith("/")?"":"/")
1038       println "LIKELY RSYNC COMMAND:"
1039       println "mkdir -p '$toDir'\nrsync -avh --delete '$fromDir' '$toDir'"
1040       if (RUNRSYNC == "true") {
1041         exec {
1042           commandLine "mkdir", "-p", toDir
1043         }
1044         exec {
1045           commandLine "rsync", "-avh", "--delete", fromDir, toDir
1046         }
1047       }
1048     }
1049   }
1050 }
1051
1052 clean {
1053   delete project.ext.getdownWebsiteDir
1054   delete project.ext.getdownFilesDir
1055 }
1056
1057 install4j {
1058   def install4jHomeDir = "/opt/install4j"
1059   def hostname = "hostname".execute().text.trim()
1060   if (hostname.equals("jv-bamboo")) {
1061     install4jHomeDir = System.getProperty("user.home")+"/buildtools/install4j"
1062   } else if (OperatingSystem.current().isMacOsX()) {
1063     install4jHomeDir = '/Applications/install4j.app/Contents/Resources/app'
1064     if (! file(install4jHomeDir).exists()) {
1065       install4jHomeDir = System.getProperty("user.home")+install4jHomeDir
1066     }
1067   } else if (OperatingSystem.current().isLinux()) {
1068     install4jHomeDir = System.getProperty("user.home")+"/buildtools/install4j"
1069   }
1070   installDir = file(install4jHomeDir)
1071   mediaTypes = Arrays.asList(install4jMediaTypes.split(","))
1072   if (install4jFaster.equals("true")) {
1073     faster = true
1074   }
1075 }
1076
1077 def install4jConf
1078 def macosJavaVMDir
1079 def macosJavaVMTgz
1080 def windowsJavaVMDir
1081 def windowsJavaVMTgz
1082 def install4jDir = "$jalviewDir/$install4jResourceDir"
1083 def install4jConfFile = "jalview-installers-java"+JAVA_VERSION+".install4j"
1084 install4jConf = "$install4jDir/$install4jConfFile"
1085
1086 task copyInstall4jTemplate(type: Copy) {
1087   macosJavaVMDir = System.env.HOME+"/buildtools/jre/openjdk-java_vm/getdown/macos-jre"+JAVA_VERSION+"/jre"
1088   macosJavaVMTgz = System.env.HOME+"/buildtools/jre/openjdk-java_vm/install4j/tgz/macos-jre"+JAVA_VERSION+".tar.gz"
1089   windowsJavaVMDir = System.env.HOME+"/buildtools/jre/openjdk-java_vm/getdown/windows-jre"+JAVA_VERSION+"/jre"
1090   windowsJavaVMTgz = System.env.HOME+"/buildtools/jre/openjdk-java_vm/install4j/tgz/windows-jre"+JAVA_VERSION+".tar.gz"
1091   from (install4jDir) {
1092     include install4jTemplate
1093     rename (install4jTemplate, install4jConfFile)
1094     filter(ReplaceTokens, beginToken: '', endToken: '', tokens: ['9999999999': JAVA_VERSION])
1095     filter(ReplaceTokens, beginToken: '$$', endToken: '$$',
1096     tokens: [
1097     'JAVA_VERSION': JAVA_VERSION,
1098     'JAVA_INTEGER_VERSION': JAVA_INTEGER_VERSION,
1099     'VERSION': JALVIEW_VERSION,
1100     'MACOS_JAVA_VM_DIR': macosJavaVMDir,
1101     'MACOS_JAVA_VM_TGZ': macosJavaVMTgz,
1102     'WINDOWS_JAVA_VM_DIR': windowsJavaVMDir,
1103     'WINDOWS_JAVA_VM_TGZ': windowsJavaVMTgz,
1104     'INSTALL4JINFOPLISTFILEASSOCIATIONS': install4jInfoPlistFileAssociations,
1105     'COPYRIGHT_MESSAGE': install4jCopyrightMessage,
1106     'MACOS_BUNDLE_ID': install4jMacOSBundleId,
1107     'GETDOWN_RESOURCE_DIR': getdown_resource_dir,
1108     'GETDOWN_DIST_DIR': getdown_app_dir,
1109     'GETDOWN_ALT_DIR': getdown_app_dir_alt,
1110     'GETDOWN_INSTALL_DIR': getdown_install_dir
1111     ]
1112     )
1113     if (OSX_KEYPASS=="") {
1114       filter(ReplaceTokens, beginToken: 'codeSigning macEnabled="', endToken: '"', tokens: ['true':'codeSigning macEnabled="false"'])
1115       filter(ReplaceTokens, beginToken: 'runPostProcessor="true" ',endToken: 'Processor', tokens: ['post':'runPostProcessor="false" postProcessor'])
1116     }
1117   }
1118   into install4jDir
1119   outputs.files(install4jConf)
1120
1121   doLast {
1122     // include file associations in installer
1123     def installerFileAssociationsXml = file("$install4jDir/$install4jInstallerFileAssociations").text
1124     ant.replaceregexp(
1125       byline: false,
1126       flags: "s",
1127       match: '<action name="EXTENSIONS_REPLACED_BY_GRADLE".*?</action>',
1128       replace: installerFileAssociationsXml,
1129       file: install4jConf
1130     )
1131     /*
1132     // include uninstaller applescript app files in dmg
1133     def installerDMGUninstallerXml = file("$install4jDir/$install4jDMGUninstallerAppFiles").text
1134     ant.replaceregexp(
1135     byline: false,
1136     flags: "s",
1137     match: '<file name="UNINSTALL_OLD_JALVIEW_APP_REPLACED_IN_GRADLE" file=.*?>',
1138     replace: installerDMGUninstallerXml,
1139     file: install4jConf
1140     )
1141      */
1142   }
1143 }
1144
1145 task installers(type: com.install4j.gradle.Install4jTask) {
1146   group = "distribution"
1147   description = "Create the install4j installers"
1148   dependsOn getdown
1149   dependsOn copyInstall4jTemplate
1150   projectFile = file(install4jConf)
1151   println("Using projectFile "+projectFile)
1152   variables = [majorVersion: version.substring(2, 11), build: 001, OSX_KEYSTORE: OSX_KEYSTORE, JSIGN_SH: JSIGN_SH]
1153   destination = "$jalviewDir/$install4jBuildDir/$JAVA_VERSION"
1154   buildSelected = true
1155
1156   if (OSX_KEYPASS) {
1157     macKeystorePassword=OSX_KEYPASS
1158
1159   }
1160
1161   inputs.dir(project.ext.getdownWebsiteDir)
1162   inputs.file(install4jConf)
1163   inputs.dir(macosJavaVMDir)
1164   inputs.dir(windowsJavaVMDir)
1165   outputs.dir("$jalviewDir/$install4jBuildDir/$JAVA_VERSION")
1166
1167 }
1168
1169 clean {
1170   delete install4jConf
1171 }
1172
1173 task sourceDist (type: Tar) {
1174
1175   def VERSION_UNDERSCORES = JALVIEW_VERSION.replaceAll("\\.", "_")
1176   def outputFileName = project.name + "_" + VERSION_UNDERSCORES + ".tar.gz"
1177   // cater for buildship < 3.1 [3.0.1 is max version in eclipse 2018-09]
1178   try {
1179     archiveFileName = outputFileName
1180   } catch (Exception e) {
1181     archiveName = outputFileName
1182   }
1183
1184   compression Compression.GZIP
1185
1186   into project.name
1187
1188   def EXCLUDE_FILES=["build/*","bin/*","test-output/","test-reports","tests","clover*/*"
1189   ,".*"
1190   ,"benchmarking/*"
1191   ,"**/.*"
1192   ,"*.class"
1193   ,"**/*.class","$j11modDir/**/*.jar","appletlib","**/*locales"
1194   ,"*locales/**",
1195   ,"utils/InstallAnywhere"]
1196   def PROCESS_FILES=[   "AUTHORS",
1197   "CITATION",
1198   "FEATURETODO",
1199   "JAVA-11-README",
1200   "FEATURETODO",
1201   "LICENSE",
1202   "**/README",
1203   "RELEASE",
1204   "THIRDPARTYLIBS","TESTNG",
1205   "build.gradle",
1206   "gradle.properties",
1207   "**/*.java",
1208   "**/*.html",
1209   "**/*.xml",
1210   "**/*.gradle",
1211   "**/*.groovy",
1212   "**/*.properties",
1213   "**/*.perl",
1214   "**/*.sh"]
1215
1216   from(jalviewDir) {
1217     exclude (EXCLUDE_FILES)
1218     include (PROCESS_FILES)
1219     filter(ReplaceTokens, beginToken: '$$', endToken: '$$', tokens: ['Version-Rel': JALVIEW_VERSION,'Year-Rel': getDate("yyyy")])
1220   }
1221   from(jalviewDir) {
1222     exclude (EXCLUDE_FILES)
1223     exclude (PROCESS_FILES)
1224   exclude ("appletlib")
1225   exclude ("**/*locales")
1226   exclude ("*locales/**")
1227   exclude ("utils/InstallAnywhere")
1228
1229     exclude (getdown_files_dir)
1230   exclude (getdown_website_dir)
1231
1232   // exluding these as not using jars as modules yet
1233   exclude ("$j11modDir/**/*.jar")
1234 }
1235 //  from (jalviewDir) {
1236 //    // explicit includes for stuff that seemed to not get included
1237 //    include(fileTree("test/**/*."))
1238 //    exclude(EXCLUDE_FILES)
1239 //    exclude(PROCESS_FILES)
1240 //  }
1241 }
1242
1243 task helppages  {
1244   dependsOn copyHelp
1245   dependsOn pubhtmlhelp
1246
1247   inputs.dir("$classes/$helpDir")
1248   outputs.dir("$helpOutputDir")
1249 }