build.gradle

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