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   // where the getdown channel will be built.
  55   // TODO: consider allowing this expression to  be overridden by -P arg
  56   getdownWebsiteDir = jalviewDir + '/' + getdown_website_dir + '/' + JAVA_VERSION
  57   getdownAppDir = getdownWebsiteDir + '/' + getdown_app_dir
  58   //getdownJ11libDir = getdownWebsiteDir + '/' + getdown_j11lib_dir
  59   getdownResourceDir = getdownWebsiteDir + '/' + getdown_resource_dir
  60   getdownLauncher = jalviewDir + '/' + getdown_launcher
  61   getdownFilesDir = jalviewDir + '/' + getdown_files_dir + '/' + JAVA_VERSION + '/'
  62   getdown_app_base = getdown_channel_base+"/"+getdown_channel_name+"/"+JAVA_VERSION+"/"
  63   modules_compileClasspath = fileTree(dir: "$jalviewDir/$j11modDir", include: ["*.jar"])
  64   modules_runtimeClasspath = modules_compileClasspath
  65   gitHash = ""
  66   gitBranch = ""
  67 }
  68
  69 def JAVA_INTEGER_VERSION
  70 def additional_compiler_args = []
  71 // these are getdown.txt properties defined dependent on the JAVA_VERSION
  72 def getdown_alt_java_min_version
  73 // this property is assigned below and expanded to multiple lines in the getdown task
  74 def getdown_alt_multi_java_location
  75 // this property is for the Java library used in eclipse
  76 def eclipse_java_runtime_name
  77 if (JAVA_VERSION.equals("1.8")) {
  78   JAVA_INTEGER_VERSION = "8"
  79   //libDir = j8libDir
  80   libDir = j11libDir
  81   libDistDir = j8libDir
  82   compile_source_compatibility = 1.8
  83   compile_target_compatibility = 1.8
  84   getdown_alt_java_min_version = getdown_alt_java8_min_version
  85   getdown_alt_multi_java_location = getdown_alt_java8_txt_multi_java_location
  86   eclipse_java_runtime_name = "JavaSE-1.8"
  87 } else if (JAVA_VERSION.equals("11")) {
  88   JAVA_INTEGER_VERSION = "11"
  89   libDir = j11libDir
  90   libDistDir = j11libDir
  91   compile_source_compatibility = 11
  92   compile_target_compatibility = 11
  93   getdown_alt_java_min_version = getdown_alt_java11_min_version
  94   getdown_alt_multi_java_location = getdown_alt_java11_txt_multi_java_location
  95   eclipse_java_runtime_name = "JavaSE-11"
  96   additional_compiler_args += [
  97     '--module-path', ext.modules_compileClasspath.asPath,
  98     '--add-modules', j11modules
  99   ]
 100 } else {
 101   throw new GradleException("JAVA_VERSION=$JAVA_VERSION not currently supported by Jalview")
 102 }
 103
 104 sourceSets {
 105
 106   main {
 107     java {
 108       srcDirs "$jalviewDir/$sourceDir"
 109       outputDir = file("$classes")
 110     }
 111
 112     resources {
 113       srcDirs "$jalviewDir/$resourceDir"
 114     }
 115
 116     jar.destinationDir = file("$jalviewDir/$packageDir")
 117
 118     compileClasspath = files(sourceSets.main.java.outputDir)
 119     compileClasspath += fileTree(dir: "$jalviewDir/$libDir", include: ["*.jar"])
 120
 121     runtimeClasspath = compileClasspath
 122   }
 123   clover {
 124     java {
 125       srcDirs = [ cloverInstrDir ]
 126       outputDir = file("${buildDir}/${cloverClassesDir}")
 127     }
 128
 129     resources {
 130       srcDirs = sourceSets.main.resources.srcDirs
 131     }
 132     compileClasspath = configurations.cloverRuntime + files( sourceSets.clover.java.outputDir )
 133     compileClasspath += files(sourceSets.main.java.outputDir)
 134     compileClasspath += sourceSets.main.compileClasspath
 135     compileClasspath += fileTree(dir: "$jalviewDir/$utilsDir", include: ["**/*.jar"])
 136     compileClasspath += fileTree(dir: "$jalviewDir/$libDir", include: ["*.jar"])
 137
 138     runtimeClasspath = compileClasspath
 139   }
 140
 141   test {
 142     java {
 143       srcDirs "$jalviewDir/$testSourceDir"
 144       outputDir = file("$jalviewDir/$testOutputDir")
 145     }
 146
 147     resources {
 148       srcDirs = sourceSets.main.resources.srcDirs
 149     }
 150
 151     compileClasspath = files( sourceSets.test.java.outputDir )
 152
 153     if (use_clover) {
 154       compileClasspath += sourceSets.clover.compileClasspath
 155     } else {
 156       compileClasspath += files(sourceSets.main.java.outputDir)
 157     }
 158
 159     compileClasspath += fileTree(dir: "$jalviewDir/$utilsDir", include: ["**/*.jar"])
 160     compileClasspath += fileTree(dir: "$jalviewDir/$libDir", include: ["*.jar"])
 161
 162     runtimeClasspath = compileClasspath
 163   }
 164 }
 165
 166 // clover bits
 167 dependencies {
 168   if (use_clover) {
 169     cloverCompile 'org.openclover:clover:4.3.1'
 170     testCompile 'org.openclover:clover:4.3.1'
 171   }
 172 }
 173
 174 configurations {
 175   cloverRuntime
 176   cloverRuntime.extendsFrom cloverCompile
 177 }
 178
 179 eclipse {
 180   project {
 181     name = "Jalview with gradle build"
 182
 183     natures 'org.eclipse.jdt.core.javanature',
 184         'org.eclipse.jdt.groovy.core.groovyNature',
 185         'org.eclipse.buildship.core.gradleprojectnature'
 186
 187     buildCommand 'org.eclipse.jdt.core.javabuilder'
 188     buildCommand 'org.eclipse.buildship.core.gradleprojectbuilder'
 189   }
 190
 191   classpath {
 192     //defaultOutputDir = sourceSets.main.java.outputDir
 193     def removeThese = []
 194     configurations.each{ if (it.isCanBeResolved()) {
 195         removeThese += it
 196       }
 197     }
 198
 199     minusConfigurations += removeThese
 200     plusConfigurations = [ ]
 201     file {
 202
 203       whenMerged { cp ->
 204         def removeTheseToo = []
 205         HashMap<String, Boolean> addedSrcPath = new HashMap<>();
 206         cp.entries.each { entry ->
 207           if (entry.kind == 'src') {
 208             if (addedSrcPath.getAt(entry.path) || !(entry.path == "src" || entry.path == "test")) {
 209               removeTheseToo += entry
 210             } else {
 211               addedSrcPath.putAt(entry.path, true)
 212             }
 213           }
 214         }
 215         cp.entries.removeAll(removeTheseToo)
 216
 217         print ("CP="+cp.inspect())
 218
 219         cp.entries += new Output("bin/main")
 220         cp.entries += new Library(fileReference(helpParentDir))
 221         cp.entries += new Library(fileReference(resourceDir))
 222
 223         HashMap<String, Boolean> addedLibPath = new HashMap<>();
 224
 225         // changing from sourcesets.main.classpath to specific Java version lib
 226         //sourceSets.main.compileClasspath.each{
 227         fileTree("$jalviewDir/$libDistDir").include("**/*.jar").include("*.jar").each {
 228           //don't want to add outputDir as eclipse is using its own output dir in bin/main
 229           if (it.isDirectory() || ! it.exists()) {
 230             // don't add dirs to classpath
 231             return
 232           }
 233           def itPath = it.toString()
 234           if (itPath.startsWith(jalviewDirAbsolutePath+"/")) {
 235             itPath = itPath.substring(jalviewDirAbsolutePath.length()+1)
 236           }
 237           if (addedLibPath.get(itPath)) {
 238             //println("Not adding duplicate entry "+itPath)
 239           } else {
 240             //println("Adding entry "+itPath)
 241             cp.entries += new Library(fileReference(itPath))
 242             addedLibPath.put(itPath, true)
 243           }
 244         }
 245
 246         // changing from sourcesets.main.classpath to specific Java version lib
 247         //sourceSets.test.compileClasspath.each{
 248         fileTree(dir: "$jalviewDir/$utilsDir", include: ["**/*.jar"]).each {
 249           //if ((it.isDirectory() || ! it.exists()) && ! (it.equals(sourceSets.main.java.outputDir))) {
 250           //no longer want to add outputDir as eclipse is using its own output dir in bin/main
 251           if (it.isDirectory() || ! it.exists()) {
 252             // don't add dirs to classpath
 253             return false // groovy "break" in .each loop
 254           }
 255           def itPath = it.toString()
 256           if (itPath.startsWith(jalviewDirAbsolutePath+"/")) {
 257             itPath = itPath.substring(jalviewDirAbsolutePath.length()+1)
 258           }
 259           if (addedLibPath.get(itPath)) {
 260             // don't duplicate
 261           } else {
 262             def lib = new Library(fileReference(itPath))
 263             // this doesn't work... yet.  Adding test=true attribute using withXml below
 264             //def attrs = new Node(null, 'attributes', ["test":"true"])
 265             //lib.appendNode(attrs) //
 266             cp.entries += lib
 267             addedLibPath.put(itPath, true)
 268           }
 269         }
 270       }
 271
 272       // withXml changes ignored by buildship, these add the "test=true" attribute
 273       withXml {
 274         def node = it.asNode()
 275
 276         def srcTestAttributes
 277         node.children().each{ cpe ->
 278           def attributes = cpe.attributes()
 279           if (attributes.get("kind") == "src" && attributes.get("path") == "test") {
 280             srcTestAttributes = cpe.find { a -> a.name() == "attributes" }
 281             return
 282           }
 283         }
 284         def addTestAttribute = true
 285         srcTestAttributes.each{a ->
 286           if (a.name() == "attribute" && a.attributes().getAt("name") == "test") {
 287             addTestAttribute = false
 288           }
 289         }
 290         if (addTestAttribute) {
 291           srcTestAttributes.append(new Node(null, "attribute", [name:"test", value:"true"]))
 292         }
 293
 294         node.children().each{ cpe ->
 295           def attributes = cpe.attributes()
 296           if (attributes.get("kind") == "lib" && attributes.get("path").startsWith("utils/")) {
 297             cpe.appendNode('attributes')
 298                 .appendNode('attribute', [name:"test", value:"true"])
 299           }
 300         }
 301       } // withXML
 302     } // file
 303
 304     containers 'org.eclipse.buildship.core.gradleclasspathcontainer'
 305   } // classpath
 306
 307   jdt {
 308     // for the IDE, use java 11 compatibility
 309     sourceCompatibility = compile_source_compatibility
 310     targetCompatibility = compile_target_compatibility
 311     javaRuntimeName = eclipse_java_runtime_name
 312
 313     file {
 314       withProperties { props ->
 315         def jalview_prefs = new Properties()
 316         def ins = new FileInputStream(jalviewDirAbsolutePath+"/"+eclipse_extra_jdt_prefs_file)
 317         jalview_prefs.load(ins)
 318         ins.close()
 319         jalview_prefs.forEach { t, v ->
 320           if (props.getAt(t) == null) {
 321             props.putAt(t, v)
 322           }
 323         }
 324       }
 325     }
 326   }
 327
 328   //synchronizationTasks eclipseClasspath
 329   //autoBuildTasks eclipseClasspath
 330 }
 331
 332 task cloverInstr() {
 333   // only instrument source, we build test classes as normal
 334   inputs.files files (sourceSets.main.allJava) // , fileTree(dir:"$jalviewDir/$testSourceDir", include: ["**/*.java"]))
 335   outputs.dir cloverInstrDir
 336
 337   doFirst {
 338     delete cloverInstrDir
 339     def argsList = ["--initstring", "${buildDir}/clover/clover.db",
 340       "-d", "${buildDir}/${cloverSourcesInstrDir}"]
 341     argsList.addAll(inputs.files.files.collect({ file ->
 342       file.absolutePath
 343     }))
 344     String[] args = argsList.toArray()
 345     println("About to instrument "+args.length +" files")
 346     com.atlassian.clover.CloverInstr.mainImpl(args)
 347   }
 348 }
 349
 350
 351 task cloverReport {
 352   group = "Verification"
 353   description = "Createst the Clover report"
 354   inputs.dir "${buildDir}/clover"
 355   outputs.dir "${reportsDir}/clover"
 356   onlyIf {
 357     file("${buildDir}/clover/clover.db").exists()
 358   }
 359   doFirst {
 360     def argsList = ["--initstring", "${buildDir}/clover/clover.db",
 361       "-o", "${reportsDir}/clover"]
 362     String[] args = argsList.toArray()
 363     com.atlassian.clover.reporters.html.HtmlReporter.runReport(args)
 364
 365     // and generate ${reportsDir}/clover/clover.xml
 366     args = ["--initstring", "${buildDir}/clover/clover.db",
 367       "-o", "${reportsDir}/clover/clover.xml"].toArray()
 368     com.atlassian.clover.reporters.xml.XMLReporter.runReport(args)
 369   }
 370 }
 371
 372 // end clover bits
 373
 374
 375 compileJava {
 376
 377   doFirst {
 378     sourceCompatibility = compile_source_compatibility
 379     targetCompatibility = compile_target_compatibility
 380     options.compilerArgs = additional_compiler_args
 381     print ("Setting target compatibility to "+targetCompatibility+"\n")
 382   }
 383
 384 }
 385
 386 compileTestJava {
 387   if (use_clover) {
 388     dependsOn compileCloverJava
 389     classpath += configurations.cloverRuntime
 390   } else {
 391     classpath += sourceSets.main.runtimeClasspath
 392   }
 393   doFirst {
 394     sourceCompatibility = compile_source_compatibility
 395     targetCompatibility = compile_target_compatibility
 396     options.compilerArgs = additional_compiler_args
 397     print ("Setting target compatibility to "+targetCompatibility+"\n")
 398   }
 399 }
 400
 401
 402 compileCloverJava {
 403
 404   doFirst {
 405     sourceCompatibility = compile_source_compatibility
 406     targetCompatibility = compile_target_compatibility
 407     options.compilerArgs += additional_compiler_args
 408     print ("Setting target compatibility to "+targetCompatibility+"\n")
 409   }
 410   classpath += configurations.cloverRuntime
 411 }
 412
 413 clean {
 414   delete sourceSets.main.java.outputDir
 415 }
 416
 417 cleanTest {
 418   delete sourceSets.test.java.outputDir
 419   delete cloverInstrDir
 420 }
 421
 422 // format is a string like date.format("dd MMMM yyyy")
 423 def getDate(format) {
 424   def date = new Date()
 425   return date.format(format)
 426 }
 427
 428 task setGitVals {
 429   def hashStdOut = new ByteArrayOutputStream()
 430   exec {
 431     commandLine "git", "rev-parse", "--short", "HEAD"
 432     standardOutput = hashStdOut
 433     ignoreExitValue true
 434   }
 435
 436   def branchStdOut = new ByteArrayOutputStream()
 437   exec {
 438     commandLine "git", "rev-parse", "--abbrev-ref", "HEAD"
 439     standardOutput = branchStdOut
 440     ignoreExitValue true
 441   }
 442
 443   project.ext.gitHash = hashStdOut.toString().trim()
 444   project.ext.gitBranch = branchStdOut.toString().trim()
 445
 446   outputs.upToDateWhen { false }
 447 }
 448
 449 task createBuildProperties(type: WriteProperties) {
 450   dependsOn setGitVals
 451   inputs.dir("$jalviewDir/$sourceDir")
 452   inputs.dir("$classes")
 453   inputs.dir("$jalviewDir/$resourceDir")
 454   outputFile "$classes/$buildPropertiesFile"
 455   // taking time specific comment out to allow better incremental builds
 456   comment "--Jalview Build Details--\n"+getDate("yyyy-MM-dd HH:mm:ss")
 457   //comment "--Jalview Build Details--\n"+getDate("yyyy-MM-dd")
 458   property "BUILD_DATE", getDate("HH:mm:ss dd MMMM yyyy")
 459   property "VERSION", JALVIEW_VERSION
 460   property "INSTALLATION", INSTALLATION+" git-commit:"+project.ext.gitHash+" ["+project.ext.gitBranch+"]"
 461   outputs.file(outputFile)
 462 }
 463
 464 def buildingHTML = "$jalviewDir/$docDir/building.html"
 465 task deleteBuildingHTML(type: Delete) {
 466   delete buildingHTML
 467 }
 468
 469 task convertBuildingMD(type: Exec) {
 470   dependsOn deleteBuildingHTML
 471   def buildingMD = "$jalviewDir/$docDir/building.md"
 472   def css = "$jalviewDir/$docDir/github.css"
 473
 474   def pandoc = null
 475   pandoc_exec.split(",").each {
 476     if (file(it.trim()).exists()) {
 477       pandoc = it.trim()
 478       return true
 479     }
 480   }
 481
 482   def hostname = "hostname".execute().text.trim()
 483   if ((pandoc == null || ! file(pandoc).exists()) && hostname.equals("jv-bamboo")) {
 484     pandoc = System.getProperty("user.home")+"/buildtools/pandoc/bin/pandoc"
 485   }
 486
 487   if (pandoc != null && file(pandoc).exists()) {
 488     commandLine pandoc, '-s', '-o', buildingHTML, '--metadata', 'pagetitle="Building Jalview from Source"', '--toc', '-H', css, buildingMD
 489   } else {
 490     commandLine "true"
 491   }
 492
 493   ignoreExitValue true
 494
 495   inputs.file(buildingMD)
 496   inputs.file(css)
 497   outputs.file(buildingHTML)
 498 }
 499 clean {
 500   delete buildingHTML
 501 }
 502
 503 task syncDocs(type: Sync) {
 504   dependsOn convertBuildingMD
 505   def syncDir = "$classes/$docDir"
 506   from fileTree("$jalviewDir/$docDir")
 507   into syncDir
 508
 509 }
 510
 511 def helpFile = "$classes/$helpDir/help.jhm"
 512
 513 task copyHelp(type: Copy) {
 514   def inputDir = "$jalviewDir/$helpParentDir/$helpDir"
 515   def outputDir = "$classes/$helpDir"
 516   from(inputDir) {
 517     exclude '**/*.gif'
 518     exclude '**/*.jpg'
 519     exclude '**/*.png'
 520     filter(ReplaceTokens, beginToken: '$$', endToken: '$$', tokens: ['Version-Rel': JALVIEW_VERSION])
 521   }
 522   from(inputDir) {
 523     include '**/*.gif'
 524     include '**/*.jpg'
 525     include '**/*.png'
 526   }
 527   into outputDir
 528
 529   inputs.dir(inputDir)
 530   outputs.files(helpFile)
 531   outputs.dir(outputDir)
 532 }
 533
 534 task syncLib(type: Sync) {
 535   def syncDir = "$classes/$libDistDir"
 536   from fileTree("$jalviewDir/$libDistDir")
 537   into syncDir
 538 }
 539
 540 task syncResources(type: Sync) {
 541   from "$jalviewDir/$resourceDir"
 542   include "**/*.*"
 543   exclude "install4j"
 544   into "$classes"
 545   preserve {
 546     include "**"
 547   }
 548 }
 549
 550 task prepare {
 551   dependsOn syncResources
 552   dependsOn syncDocs
 553   dependsOn copyHelp
 554 }
 555
 556
 557 //testReportDirName = "test-reports" // note that test workingDir will be $jalviewDir
 558 test {
 559   dependsOn prepare
 560   dependsOn compileJava
 561   if (use_clover) {
 562     dependsOn cloverInstr
 563   }
 564
 565   print("Running tests " + (use_clover?"WITH":"WITHOUT") + " clover [clover="+use_clover+"]\n")
 566
 567   useTestNG() {
 568     includeGroups testngGroups
 569     preserveOrder true
 570     useDefaultListeners=true
 571   }
 572
 573   workingDir = jalviewDir
 574   //systemProperties 'clover.jar' System.properties.clover.jar
 575   sourceCompatibility = compile_source_compatibility
 576   targetCompatibility = compile_target_compatibility
 577   jvmArgs += additional_compiler_args
 578   print ("Setting target compatibility to "+targetCompatibility+"\n")
 579 }
 580
 581 task buildIndices(type: JavaExec) {
 582   dependsOn copyHelp
 583   classpath = sourceSets.main.compileClasspath
 584   main = "com.sun.java.help.search.Indexer"
 585   workingDir = "$classes/$helpDir"
 586   def argDir = "html"
 587   args = [ argDir ]
 588   inputs.dir("$workingDir/$argDir")
 589
 590   outputs.dir("$classes/doc")
 591   outputs.dir("$classes/help")
 592   outputs.file("$workingDir/JavaHelpSearch/DOCS")
 593   outputs.file("$workingDir/JavaHelpSearch/DOCS.TAB")
 594   outputs.file("$workingDir/JavaHelpSearch/OFFSETS")
 595   outputs.file("$workingDir/JavaHelpSearch/POSITIONS")
 596   outputs.file("$workingDir/JavaHelpSearch/SCHEMA")
 597   outputs.file("$workingDir/JavaHelpSearch/TMAP")
 598 }
 599
 600 task compileLinkCheck(type: JavaCompile) {
 601   options.fork = true
 602   classpath = files("$jalviewDir/$utilsDir")
 603   destinationDir = file("$jalviewDir/$utilsDir")
 604   source = fileTree(dir: "$jalviewDir/$utilsDir", include: ["HelpLinksChecker.java", "BufferedLineReader.java"])
 605
 606   inputs.file("$jalviewDir/$utilsDir/HelpLinksChecker.java")
 607   inputs.file("$jalviewDir/$utilsDir/HelpLinksChecker.java")
 608   outputs.file("$jalviewDir/$utilsDir/HelpLinksChecker.class")
 609   outputs.file("$jalviewDir/$utilsDir/BufferedLineReader.class")
 610 }
 611
 612 def helplinkscheckeroutputfile = file("$jalviewDir/$utilsDir/HelpLinksChecker.out")
 613 task linkCheck(type: JavaExec) {
 614   dependsOn prepare, compileLinkCheck
 615   classpath = files("$jalviewDir/$utilsDir")
 616   main = "HelpLinksChecker"
 617   workingDir = jalviewDir
 618   def help = "$classes/$helpDir"
 619   args = [ "$classes/$helpDir", "-nointernet" ]
 620
 621   doFirst {
 622     helplinkscheckeroutputfile.createNewFile()
 623     standardOutput new FileOutputStream(helplinkscheckeroutputfile, false)
 624   }
 625
 626   outputs.file(helplinkscheckeroutputfile)
 627 }
 628
 629 task cleanPackageDir(type: Delete) {
 630   delete fileTree("$jalviewDir/$packageDir").include("*.jar")
 631 }
 632
 633 jar {
 634   dependsOn linkCheck
 635   dependsOn buildIndices
 636   dependsOn createBuildProperties
 637
 638   manifest {
 639     attributes "Main-Class": mainClass,
 640     "Permissions": "all-permissions",
 641     "Application-Name": "Jalview Desktop",
 642     "Codebase": application_codebase
 643   }
 644
 645   destinationDir = file("$jalviewDir/$packageDir")
 646   archiveName = rootProject.name+".jar"
 647
 648   exclude "cache*/**"
 649   exclude "*.jar"
 650   exclude "*.jar.*"
 651   exclude "**/*.jar"
 652   exclude "**/*.jar.*"
 653
 654   inputs.dir("$classes")
 655   outputs.file("$jalviewDir/$packageDir/$archiveName")
 656 }
 657
 658 task copyJars(type: Copy) {
 659   from fileTree("$classes").include("**/*.jar").include("*.jar").files
 660   into "$jalviewDir/$packageDir"
 661 }
 662
 663 // doing a Sync instead of Copy as Copy doesn't deal with "outputs" very well
 664 task syncJars(type: Sync) {
 665   from fileTree("$jalviewDir/$libDistDir").include("**/*.jar").include("*.jar").files
 666   into "$jalviewDir/$packageDir"
 667   preserve {
 668     include jar.archiveName
 669   }
 670 }
 671
 672 task makeDist {
 673   group = "build"
 674   description = "Put all required libraries in dist"
 675   // order of "cleanPackageDir", "copyJars", "jar" important!
 676   jar.mustRunAfter cleanPackageDir
 677   syncJars.mustRunAfter cleanPackageDir
 678   dependsOn cleanPackageDir
 679   dependsOn syncJars
 680   dependsOn jar
 681   outputs.dir("$jalviewDir/$packageDir")
 682 }
 683
 684 task cleanDist {
 685   dependsOn cleanPackageDir
 686   dependsOn cleanTest
 687   dependsOn clean
 688 }
 689
 690 shadowJar {
 691   group = "distribution"
 692   dependsOn makeDist
 693   from ("$jalviewDir/$libDistDir") {
 694     include("*.jar")
 695   }
 696   mainClassName = shadowJarMainClass
 697   mergeServiceFiles()
 698   classifier = "all-"+JAVA_VERSION
 699   minimize()
 700 }
 701
 702 task getdownWebsite() {
 703   group = "distribution"
 704   description = "Create the getdown minimal app folder, and website folder for this version of jalview. Website folder also used for offline app installer"
 705   dependsOn makeDist
 706   def getdownWebsiteResourceFilenames = []
 707   def getdownTextString = ""
 708   def getdownResourceDir = project.ext.getdownResourceDir
 709   def getdownAppDir = project.ext.getdownAppDir
 710   def getdownResourceFilenames = []
 711   doFirst {
 712     // go through properties looking for getdown_txt_...
 713     def props = project.properties.sort { it.key }
 714     props.put("getdown_txt_java_min_version", getdown_alt_java_min_version)
 715     props.put("getdown_txt_multi_java_location", getdown_alt_multi_java_location)
 716
 717     if (getdown_local == "true") {
 718       getdown_app_base = file(getdownWebsiteDir).toURI().toString()
 719     }
 720     props.put("getdown_txt_appbase", getdown_app_base)
 721     props.each{ prop, val ->
 722       if (prop.startsWith("getdown_txt_") && val != null) {
 723         if (prop.startsWith("getdown_txt_multi_")) {
 724           def key = prop.substring(18)
 725           val.split(",").each{ v ->
 726             def line = key + " = " + v + "\n"
 727             getdownTextString += line
 728           }
 729         } else {
 730           // file values rationalised
 731           if (val.indexOf('/') > -1) {
 732             def r = null
 733             if (val.indexOf('/') == 0) {
 734               // absolute path
 735               r = file(val)
 736             } else if (val.indexOf('/') > 0) {
 737               // relative path (relative to jalviewDir)
 738               r = file( jalviewDir + '/' + val )
 739             }
 740             if (r.exists()) {
 741               val = getdown_resource_dir + '/' + r.getName()
 742               getdownWebsiteResourceFilenames += val
 743               getdownResourceFilenames += r.getPath()
 744             }
 745           }
 746           def line = prop.substring(12) + " = " + val + "\n"
 747           getdownTextString += line
 748         }
 749       }
 750     }
 751
 752     getdownWebsiteResourceFilenames.each{ filename ->
 753       getdownTextString += "resource = "+filename+"\n"
 754     }
 755     getdownResourceFilenames.each{ filename ->
 756       copy {
 757         from filename
 758         into project.ext.getdownResourceDir
 759       }
 760     }
 761
 762     def codeFiles = []
 763     makeDist.outputs.files.each{ f ->
 764       if (f.isDirectory()) {
 765         def files = fileTree(dir: f, include: ["*"]).getFiles()
 766         codeFiles += files
 767       } else if (f.exists()) {
 768         codeFiles += f
 769       }
 770     }
 771     codeFiles.sort().each{f ->
 772       def line = "code = " + getdown_app_dir + '/' + f.getName() + "\n"
 773       getdownTextString += line
 774       copy {
 775         from f.getPath()
 776         into project.ext.getdownAppDir
 777       }
 778     }
 779
 780     // NOT USING MODULES YET, EVERYTHING SHOULD BE IN dist
 781     /*
 782      if (JAVA_VERSION.equals("11")) {
 783      def j11libFiles = fileTree(dir: "$jalviewDir/$j11libDir", include: ["*.jar"]).getFiles()
 784      j11libFiles.sort().each{f ->
 785      def line = "code = " + getdown_j11lib_dir + '/' + f.getName() + "\n"
 786      getdownTextString += line
 787      copy {
 788      from f.getPath()
 789      into project.ext.getdownJ11libDir
 790      }
 791      }
 792      }
 793      */
 794
 795     // 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.
 796     //getdownTextString += "class = " + file(getdownLauncher).getName() + "\n"
 797     getdownTextString += "resource = " + file(getdownLauncher).getName() + "\n"
 798     getdownTextString += "class = " + mainClass + "\n"
 799
 800     def getdown_txt = file(project.ext.getdownWebsiteDir + "/getdown.txt")
 801     getdown_txt.write(getdownTextString)
 802
 803     copy {
 804       from getdown_txt
 805       into project.ext.getdownFilesDir
 806     }
 807
 808     copy {
 809       from getdownLauncher
 810       into project.ext.getdownFilesDir
 811     }
 812
 813     copy {
 814       from getdownLauncher
 815       into project.ext.getdownWebsiteDir
 816     }
 817
 818     copy {
 819       from jalviewDir + '/' + project.getProperty('getdown_txt_ui.background_image')
 820       from jalviewDir + '/' + project.getProperty('getdown_txt_ui.error_background')
 821       from jalviewDir + '/' + project.getProperty('getdown_txt_ui.progress_image')
 822       from jalviewDir + '/' + project.getProperty('getdown_txt_ui.icon')
 823       from jalviewDir + '/' + project.getProperty('getdown_txt_ui.mac_dock_icon')
 824       into project.ext.getdownFilesDir + '/' + getdown_resource_dir
 825     }
 826   }
 827
 828   inputs.dir(jalviewDir + '/' + packageDir)
 829   outputs.dir(project.ext.getdownWebsiteDir)
 830   outputs.dir(project.ext.getdownFilesDir)
 831 }
 832
 833 task getdownDigest(type: JavaExec) {
 834   group = "distribution"
 835   description = "Digest the getdown website folder"
 836   dependsOn getdownWebsite
 837   classpath = files(jalviewDir + '/' + getdown_core, jalviewDir+'/'+getdown_launcher)
 838   main = "com.threerings.getdown.tools.Digester"
 839   args project.ext.getdownWebsiteDir
 840   inputs.dir(project.ext.getdownWebsiteDir)
 841   outputs.file(project.ext.getdownWebsiteDir + '/' + "digest2.txt")
 842 }
 843
 844 task getdown() {
 845   group = "distribution"
 846   description = "Create the minimal and full getdown app folder for installers and website and create digest file"
 847   dependsOn getdownDigest
 848 }
 849
 850 clean {
 851   delete project.ext.getdownWebsiteDir
 852   delete project.ext.getdownFilesDir
 853 }
 854
 855 install4j {
 856   def install4jHomeDir = "/opt/install4j"
 857   def hostname = "hostname".execute().text.trim()
 858   if (hostname.equals("jv-bamboo")) {
 859     install4jHomeDir = System.getProperty("user.home")+"/buildtools/install4j"
 860   } else if (OperatingSystem.current().isMacOsX()) {
 861     install4jHomeDir = '/Applications/install4j.app/Contents/Resources/app'
 862     if (! file(install4jHomeDir).exists()) {
 863       install4jHomeDir = System.getProperty("user.home")+install4jHomeDir
 864     }
 865   } else if (OperatingSystem.current().isLinux()) {
 866     install4jHomeDir = System.getProperty("user.home")+"/buildtools/install4j"
 867   }
 868   installDir = file(install4jHomeDir)
 869   mediaTypes = Arrays.asList(install4jMediaTypes.split(","))
 870   if (install4jFaster.equals("true")) {
 871     faster = true
 872   }
 873 }
 874
 875 def install4jConf
 876 def macosJavaVMDir
 877 def macosJavaVMTgz
 878 def windowsJavaVMDir
 879 def windowsJavaVMTgz
 880 def install4jDir = "$jalviewDir/$install4jResourceDir"
 881 def install4jConfFile = "jalview-installers-java"+JAVA_VERSION+".install4j"
 882 install4jConf = "$install4jDir/$install4jConfFile"
 883
 884 task copyInstall4jTemplate(type: Copy) {
 885   macosJavaVMDir = System.env.HOME+"/buildtools/jre/openjdk-java_vm/getdown/macos-jre"+JAVA_VERSION+"/jre"
 886   macosJavaVMTgz = System.env.HOME+"/buildtools/jre/openjdk-java_vm/install4j/tgz/macos-jre"+JAVA_VERSION+".tar.gz"
 887   windowsJavaVMDir = System.env.HOME+"/buildtools/jre/openjdk-java_vm/getdown/windows-jre"+JAVA_VERSION+"/jre"
 888   windowsJavaVMTgz = System.env.HOME+"/buildtools/jre/openjdk-java_vm/install4j/tgz/windows-jre"+JAVA_VERSION+".tar.gz"
 889   from (install4jDir) {
 890     include install4jTemplate
 891     rename (install4jTemplate, install4jConfFile)
 892     filter(ReplaceTokens, beginToken: '', endToken: '', tokens: ['9999999999': JAVA_VERSION])
 893     filter(ReplaceTokens, beginToken: '$$', endToken: '$$',
 894       tokens: [
 895         'JAVA_VERSION': JAVA_VERSION,
 896         'JAVA_INTEGER_VERSION': JAVA_INTEGER_VERSION,
 897         'VERSION': JALVIEW_VERSION,
 898         'MACOS_JAVA_VM_DIR': macosJavaVMDir,
 899         'MACOS_JAVA_VM_TGZ': macosJavaVMTgz,
 900         'WINDOWS_JAVA_VM_DIR': windowsJavaVMDir,
 901         'WINDOWS_JAVA_VM_TGZ': windowsJavaVMTgz,
 902         'INSTALL4JINFOPLISTFILEASSOCIATIONS': install4jInfoPlistFileAssociations,
 903         'COPYRIGHT_MESSAGE': install4jCopyrightMessage,
 904         'MACOS_BUNDLE_ID': install4jMacOSBundleId
 905       ]
 906     )
 907     if (OSX_KEYPASS=="") {
 908       filter(ReplaceTokens, beginToken: 'codeSigning macEnabled="', endToken: '"', tokens: ['true':'codeSigning macEnabled="false"'])
 909       filter(ReplaceTokens, beginToken: 'runPostProcessor="true" ',endToken: 'Processor', tokens: ['post':'runPostProcessor="false" postProcessor'])
 910     }
 911   }
 912   into install4jDir
 913   outputs.files(install4jConf)
 914
 915   doLast {
 916     // include file associations in installer
 917     def installerFileAssociationsXml = file("$install4jDir/$install4jInstallerFileAssociations").text
 918     ant.replaceregexp(
 919       byline: false,
 920       flags: "s",
 921       match: '<action name="EXTENSIONS_REPLACED_BY_GRADLE".*?</action>',
 922       replace: installerFileAssociationsXml,
 923       file: install4jConf
 924     )
 925     /*
 926     // include uninstaller applescript app files in dmg
 927     def installerDMGUninstallerXml = file("$install4jDir/$install4jDMGUninstallerAppFiles").text
 928     ant.replaceregexp(
 929       byline: false,
 930       flags: "s",
 931       match: '<file name="UNINSTALL_OLD_JALVIEW_APP_REPLACED_IN_GRADLE" file=.*?>',
 932       replace: installerDMGUninstallerXml,
 933       file: install4jConf
 934     )
 935     */
 936   }
 937 }
 938
 939 task installers(type: com.install4j.gradle.Install4jTask) {
 940   group = "distribution"
 941   description = "Create the install4j installers"
 942   dependsOn getdown
 943   dependsOn copyInstall4jTemplate
 944   projectFile = file(install4jConf)
 945   println("Using projectFile "+projectFile)
 946   variables = [majorVersion: version.substring(2, 11), build: 001, OSX_KEYSTORE: OSX_KEYSTORE, JSIGN_SH: JSIGN_SH]
 947   destination = "$jalviewDir/$install4jBuildDir/$JAVA_VERSION"
 948   buildSelected = true
 949
 950   if (OSX_KEYPASS) {
 951     macKeystorePassword=OSX_KEYPASS
 952
 953   }
 954
 955   inputs.dir(project.ext.getdownWebsiteDir)
 956   inputs.file(install4jConf)
 957   inputs.dir(macosJavaVMDir)
 958   inputs.dir(windowsJavaVMDir)
 959   outputs.dir("$jalviewDir/$install4jBuildDir/$JAVA_VERSION")
 960 }
 961
 962 clean {
 963   delete install4jConf
 964 }