JAL-3210 updated jmol jar in j8lib, j11lib
[jalview.git] / 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 }