X-Git-Url: http://source.jalview.org/gitweb/?p=jalview.git;a=blobdiff_plain;f=build.gradle;h=d575f182bd246a6df7c28a47c48f1c20fb4247fc;hp=38d35f4a385f9d21db2ef1d062c953f094bf7329;hb=5f3301530feeaddcbc90d85af438880e41a69d04;hpb=3729618c7df9803178a79112efe65bd4f08779ea diff --git a/build.gradle b/build.gradle index 38d35f4..d575f18 100644 --- a/build.gradle +++ b/build.gradle @@ -1,16 +1,20 @@ import org.apache.tools.ant.filters.ReplaceTokens import org.gradle.internal.os.OperatingSystem +import org.gradle.plugins.ide.eclipse.model.Output +import org.gradle.plugins.ide.eclipse.model.Library + +import groovy.transform.ExternalizeMethods buildscript { dependencies { - classpath 'org.openclover:clover:4.3.1' - classpath 'org.apache.commons:commons-compress:1.18' + classpath 'org.openclover:clover:4.3.1' } } plugins { id 'java' id 'application' + id 'eclipse' id 'com.github.johnrengelman.shadow' version '4.0.3' id 'com.install4j.gradle' version '7.0.9' } @@ -24,9 +28,14 @@ repositories { } } +dependencies { + compile 'org.apache.commons:commons-compress:1.18' +} + mainClassName = launcherClass def cloverInstrDir = file("$buildDir/$cloverSourcesInstrDir") def classes = "$jalviewDir/$classesDir" + if (clover.equals("true")) { use_clover = true classes = "$buildDir/$cloverClassesDir" @@ -37,28 +46,182 @@ if (clover.equals("true")) { // configure classpath/args for j8/j11 compilation +def jalviewDirAbsolutePath = file(jalviewDir).getAbsolutePath() def libDir def libDistDir def compile_source_compatibility def compile_target_compatibility + +ext { + getdownWebsiteDir = jalviewDir + '/' + getdown_website_dir + '/' + JAVA_VERSION + getdownDir = "" + reportRsyncCmd = false + buildDist = true + buildProperties = buildPropertiesFile + getdownLauncher = jalviewDir + '/' + getdown_lib_dir + '/' + getdown_launcher + switch (CHANNEL) { + + case "BUILD": + // TODO: get bamboo build artifact URL for getdown artifacts + getdown_channel_base = bamboo_channelbase + getdown_channel_name = bamboo_planKey + '/'+JAVA_VERSION + getdown_app_base = bamboo_channelbase + '/'+ bamboo_planKey + bamboo_getdown_channel_suffix + '/'+JAVA_VERSION + getdown_app_dir = getdown_app_dir_alt + buildProperties = jalviewDir + "/" + classesDir +"/" + buildPropertiesFile + break + + case "RELEASE": + getdown_channel_name = CHANNEL.toLowerCase() + getdownDir = getdown_channel_name + "/" + JAVA_VERSION + getdown_app_base = getdown_channel_base + "/" + getdownDir + getdown_app_dir = getdown_app_dir_release + buildProperties = jalviewDir + "/" + classesDir +"/" + buildPropertiesFile + reportRsyncCommand = true + break + + case "ARCHIVE": + getdown_channel_name = CHANNEL.toLowerCase()+"/"+JALVIEW_VERSION + getdownDir = getdown_channel_name + "/" + JAVA_VERSION + getdown_app_base = getdown_channel_base + "/" + getdownDir + getdown_app_dir = getdown_app_dir_alt + if (!file(ARCHIVEDIR+"/"+packageDir).exists()) { + print "Must provide an ARCHIVEDIR value to produce an archive distribution" + exit + } else { + packageDir = ARCHIVEDIR + "/" + packageDir + buildProperties = ARCHIVEDIR +"/" + classesDir + "/" + buildPropertiesFile + buildDist = false + } + reportRsyncCommand = true + break + + case "ARCHIVELOCAL": + getdown_channel_name = "archive" + "/" + JALVIEW_VERSION + getdownDir = getdown_channel_name + "/" + JAVA_VERSION + getdown_app_base = file(getdownWebsiteDir).toURI().toString() + getdown_app_dir = getdown_app_dir_alt + if (!file(ARCHIVEDIR+"/"+packageDir).exists()) { + print "Must provide an ARCHIVEDIR value to produce an archive distribution" + exit + } else { + packageDir = ARCHIVEDIR + "/" + packageDir + buildProperties = ARCHIVEDIR +"/" + classesDir + "/" + buildPropertiesFile + buildDist = false + } + reportRsyncCommand = true + getdownLauncher = jalviewDir + '/' + getdown_lib_dir + '/' + getdown_launcher_local + break + + case "DEVELOP": + getdown_channel_name = CHANNEL.toLowerCase() + getdownDir = getdown_channel_name + "/" + JAVA_VERSION + getdown_app_base = getdown_channel_base + "/" + getdownDir + getdown_app_dir = getdown_app_dir_alt + buildProperties = jalviewDir + "/" + classesDir +"/" + buildPropertiesFile + reportRsyncCommand = true + break + + case "TEST-RELEASE": + getdown_channel_name = CHANNEL.toLowerCase() + getdownDir = getdown_channel_name + "/" + JAVA_VERSION + getdown_app_base = getdown_channel_base + "/" + getdownDir + getdown_app_dir = getdown_app_dir_alt + buildProperties = jalviewDir + "/" + classesDir +"/" + buildPropertiesFile + reportRsyncCommand = true + break + + case ~/^SCRATCH(|-[-\w]*)$/: + getdown_channel_name = CHANNEL + getdownDir = getdown_channel_name + "/" + JAVA_VERSION + getdown_app_base = getdown_channel_base + "/" + getdownDir + getdown_app_dir = getdown_app_dir_alt + buildProperties = jalviewDir + "/" + classesDir +"/" + buildPropertiesFile + reportRsyncCommand = true + break + + case "LOCAL": + getdown_app_base = file(getdownWebsiteDir).toURI().toString() + getdown_app_dir = getdown_app_dir_alt + buildProperties = jalviewDir + "/" + classesDir +"/" + buildPropertiesFile + getdownLauncher = jalviewDir + '/' + getdown_lib_dir + '/' + getdown_launcher_local + break + + default: // something wrong specified + print("CHANNEL must be one of BUILD, RELEASE, ARCHIVE, DEVELOP, TEST-RELEASE, SCRATCH-..., LOCAL [default]") + exit + break + + } + + println("Using a "+CHANNEL+" profile. appbase="+getdown_app_base) + getdownAppDir = getdownWebsiteDir + '/' + getdown_app_dir + //getdownJ11libDir = getdownWebsiteDir + '/' + getdown_j11lib_dir + getdownResourceDir = getdownWebsiteDir + '/' + getdown_resource_dir + getdownInstallDir = getdownWebsiteDir + '/' + getdown_install_dir + getdownFilesDir = jalviewDir + '/' + getdown_files_dir + '/' + JAVA_VERSION + '/' + getdownFilesInstallDir = getdownFilesDir+"/"+getdown_install_dir + /* compile without modules -- using classpath libraries + modules_compileClasspath = fileTree(dir: "$jalviewDir/$j11modDir", include: ["*.jar"]) + modules_runtimeClasspath = modules_compileClasspath + */ + gitHash = "" + gitBranch = "" + + jalviewjsServer = "" +} + +def JAVA_INTEGER_VERSION def additional_compiler_args = [] +// these are getdown.txt properties defined dependent on the JAVA_VERSION def getdown_alt_java_min_version +def getdown_alt_java_max_version +// this property is assigned below and expanded to multiple lines in the getdown task +def getdown_alt_multi_java_location +// this property is for the Java library used in eclipse +def eclipse_java_runtime_name if (JAVA_VERSION.equals("1.8")) { + JAVA_INTEGER_VERSION = "8" + //libDir = j8libDir libDir = j11libDir libDistDir = j8libDir compile_source_compatibility = 1.8 compile_target_compatibility = 1.8 getdown_alt_java_min_version = getdown_alt_java8_min_version + getdown_alt_java_max_version = getdown_alt_java8_max_version + getdown_alt_multi_java_location = getdown_alt_java8_txt_multi_java_location + eclipse_java_runtime_name = "JavaSE-1.8" } else if (JAVA_VERSION.equals("11")) { + JAVA_INTEGER_VERSION = "11" libDir = j11libDir libDistDir = j11libDir compile_source_compatibility = 11 compile_target_compatibility = 11 getdown_alt_java_min_version = getdown_alt_java11_min_version + getdown_alt_java_max_version = getdown_alt_java11_max_version + getdown_alt_multi_java_location = getdown_alt_java11_txt_multi_java_location + eclipse_java_runtime_name = "JavaSE-11" + /* compile without modules -- using classpath libraries + additional_compiler_args += [ + '--module-path', ext.modules_compileClasspath.asPath, + '--add-modules', j11modules + ] + */ +} else if (JAVA_VERSION.equals("12") || JAVA_VERSION.equals("13")) { + JAVA_INTEGER_VERSION = JAVA_VERSION + libDir = j11libDir + libDistDir = j11libDir + compile_source_compatibility = JAVA_VERSION + compile_target_compatibility = JAVA_VERSION + getdown_alt_java_min_version = getdown_alt_java11_min_version + getdown_alt_java_max_version = getdown_alt_java11_max_version + getdown_alt_multi_java_location = getdown_alt_java11_txt_multi_java_location + eclipse_java_runtime_name = "JavaSE-11" + /* compile without modules -- using classpath libraries additional_compiler_args += [ - '--module-path', file("$jalviewDir/$j11modDir").getAbsolutePath(), - '--add-modules', j11modules + '--module-path', ext.modules_compileClasspath.asPath, + '--add-modules', j11modules ] + */ } else { throw new GradleException("JAVA_VERSION=$JAVA_VERSION not currently supported by Jalview") } @@ -73,7 +236,6 @@ sourceSets { resources { srcDirs "$jalviewDir/$resourceDir" - srcDirs "$jalviewDir/$libDir" } jar.destinationDir = file("$jalviewDir/$packageDir") @@ -83,23 +245,25 @@ sourceSets { runtimeClasspath = compileClasspath } - + clover { java { - srcDirs = [ cloverInstrDir ] - outputDir = file("${buildDir}/${cloverClassesDir}") + srcDirs = [ cloverInstrDir ] + outputDir = file("${buildDir}/${cloverClassesDir}") } - + resources { srcDirs = sourceSets.main.resources.srcDirs } compileClasspath = configurations.cloverRuntime + files( sourceSets.clover.java.outputDir ) + compileClasspath += files(sourceSets.main.java.outputDir) + compileClasspath += sourceSets.main.compileClasspath compileClasspath += fileTree(dir: "$jalviewDir/$utilsDir", include: ["**/*.jar"]) compileClasspath += fileTree(dir: "$jalviewDir/$libDir", include: ["*.jar"]) runtimeClasspath = compileClasspath } - + test { java { srcDirs "$jalviewDir/$testSourceDir" @@ -110,16 +274,17 @@ sourceSets { srcDirs = sourceSets.main.resources.srcDirs } - compileClasspath = files( sourceSets.test.java.outputDir ) + compileClasspath = files( sourceSets.test.java.outputDir ) + if (use_clover) { compileClasspath += sourceSets.clover.compileClasspath } else { - compileClasspath += sourceSets.main.compileClasspath compileClasspath += files(sourceSets.main.java.outputDir) } - compileClasspath += files( sourceSets.main.resources.srcDirs) - compileClasspath += fileTree(dir: "$jalviewDir/$utilsDir", include: ["**/*.jar"]) + compileClasspath += fileTree(dir: "$jalviewDir/$libDir", include: ["*.jar"]) + compileClasspath += fileTree(dir: "$jalviewDir/$utilsDir/testnglibs", include: ["**/*.jar"]) + compileClasspath += fileTree(dir: "$jalviewDir/$utilsDir/testlibs", include: ["**/*.jar"]) runtimeClasspath = compileClasspath } @@ -134,46 +299,209 @@ dependencies { } configurations { - cloverRuntime - cloverRuntime.extendsFrom cloverCompile + cloverRuntime + cloverRuntime.extendsFrom cloverCompile } - + +eclipse { + project { + name = eclipse_project_name + + natures 'org.eclipse.jdt.core.javanature', + 'org.eclipse.jdt.groovy.core.groovyNature', + 'org.eclipse.buildship.core.gradleprojectnature' + + buildCommand 'org.eclipse.jdt.core.javabuilder' + buildCommand 'org.eclipse.buildship.core.gradleprojectbuilder' + } + + classpath { + //defaultOutputDir = sourceSets.main.java.outputDir + def removeThese = [] + configurations.each{ + if (it.isCanBeResolved()) { + removeThese += it + } + } + + minusConfigurations += removeThese + plusConfigurations = [ ] + file { + + whenMerged { cp -> + def removeTheseToo = [] + HashMap alreadyAddedSrcPath = new HashMap<>(); + cp.entries.each { entry -> + if (entry.kind == 'src') { + if (alreadyAddedSrcPath.getAt(entry.path) || !(entry.path == "src" || entry.path == "test")) { + removeTheseToo += entry + } else { + alreadyAddedSrcPath.putAt(entry.path, true) + } + } + } + cp.entries.removeAll(removeTheseToo) + + if (file(eclipse_bin_dir+"/main").isDirectory()) { + cp.entries += new Output(eclipse_bin_dir+"/main") + } + if (file(helpParentDir).isDirectory()) { + cp.entries += new Library(fileReference(helpParentDir)) + } + if (file(resourceDir).isDirectory()) { + cp.entries += new Library(fileReference(resourceDir)) + } + + HashMap alreadyAddedLibPath = new HashMap<>(); + + sourceSets.main.compileClasspath.findAll { it.name.endsWith(".jar") }.each { + //don't want to add outputDir as eclipse is using its own output dir in bin/main + if (it.isDirectory() || ! it.exists()) { + // don't add dirs to classpath + return + } + def itPath = it.toString() + if (itPath.startsWith(jalviewDirAbsolutePath+"/")) { + // make relative path + itPath = itPath.substring(jalviewDirAbsolutePath.length()+1) + } + if (alreadyAddedLibPath.get(itPath)) { + //println("Not adding duplicate entry "+itPath) + } else { + //println("Adding entry "+itPath) + cp.entries += new Library(fileReference(itPath)) + alreadyAddedLibPath.put(itPath, true) + } + } + + //fileTree(dir: "$jalviewDir/$utilsDir", include: ["test*/*.jar"]).each { + sourceSets.test.compileClasspath.findAll { it.name.endsWith(".jar") }.each { + //no longer want to add outputDir as eclipse is using its own output dir in bin/main + if (it.isDirectory() || ! it.exists()) { + // don't add dirs to classpath + return false // groovy "break" in .each closure + } + def itPath = it.toString() + if (itPath.startsWith(jalviewDirAbsolutePath+"/")) { + itPath = itPath.substring(jalviewDirAbsolutePath.length()+1) + } + if (alreadyAddedLibPath.get(itPath)) { + // don't duplicate + } else { + def lib = new Library(fileReference(itPath)) + /* this doesn't work... yet. Adding test=true attribute using withXml below + def attrs = new Node(null, 'attributes') + attrs.appendNode('attribute', ["name":"test","value":"true"]) + lib.appendNode(attrs) + /**/ + cp.entries += lib + alreadyAddedLibPath.put(itPath, true) + } + } + + } // whenMerged + + // withXml changes ignored by buildship, these add the "test=true" attribute + withXml { + def node = it.asNode() + + def srcTestAttributes + node.children().each{ cpe -> + def attributes = cpe.attributes() + if (attributes.get("kind") == "src" && attributes.get("path") == "test") { + srcTestAttributes = cpe.find { a -> a.name() == "attributes" } + return + } + } + def addTestAttribute = true + srcTestAttributes.each{a -> + if (a.name() == "attribute" && a.attributes().getAt("name") == "test") { + addTestAttribute = false + } + } + if (addTestAttribute) { + srcTestAttributes.append(new Node(null, "attribute", [name:"test", value:"true"])) + } + + node.children().each{ cpe -> + def attributes = cpe.attributes() + if (attributes.get("kind") == "lib" && attributes.get("path").startsWith("utils/")) { + cpe.appendNode('attributes') + .appendNode('attribute', [name:"test", value:"true"]) + } + } + } // withXML + + + } // file + + containers 'org.eclipse.buildship.core.gradleclasspathcontainer' + + } // classpath + + jdt { + // for the IDE, use java 11 compatibility + sourceCompatibility = compile_source_compatibility + targetCompatibility = compile_target_compatibility + javaRuntimeName = eclipse_java_runtime_name + + // add in jalview project specific properties/preferences into eclipse core preferences + file { + withProperties { props -> + def jalview_prefs = new Properties() + def ins = new FileInputStream(jalviewDirAbsolutePath+"/"+eclipse_extra_jdt_prefs_file) + jalview_prefs.load(ins) + ins.close() + jalview_prefs.forEach { t, v -> + if (props.getAt(t) == null) { + props.putAt(t, v) + } + } + } + } + + } // jdt + +} + task cloverInstr() { // only instrument source, we build test classes as normal - inputs.files files (sourceSets.main.allJava) // , fileTree(dir:"$jalviewDir/$testSourceDir", include: ["**/*.java"])) - outputs.dir cloverInstrDir + inputs.files files (sourceSets.main.allJava) // , fileTree(dir:"$jalviewDir/$testSourceDir", include: ["**/*.java"])) + outputs.dir cloverInstrDir - doFirst { - delete cloverInstrDir - def argsList = ["--initstring", "${buildDir}/clover/clover.db", - "-d", "${buildDir}/${cloverSourcesInstrDir}"] - argsList.addAll(inputs.files.files.collect({ file -> - file.absolutePath - })) - String[] args = argsList.toArray() - println("About to instrument "+args.length +" files") - com.atlassian.clover.CloverInstr.mainImpl(args) - } + doFirst { + delete cloverInstrDir + def argsList = ["--initstring", "${buildDir}/clover/clover.db", + "-d", "${buildDir}/${cloverSourcesInstrDir}"] + argsList.addAll(inputs.files.files.collect({ file -> + file.absolutePath + })) + String[] args = argsList.toArray() + println("About to instrument "+args.length +" files") + com.atlassian.clover.CloverInstr.mainImpl(args) + } } - + task cloverReport { + group = "Verification" + description = "Createst the Clover report" inputs.dir "${buildDir}/clover" outputs.dir "${reportsDir}/clover" onlyIf { - file("${buildDir}/clover/clover.db").exists() - } - doFirst { - def argsList = ["--initstring", "${buildDir}/clover/clover.db", - "-o", "${reportsDir}/clover"] - String[] args = argsList.toArray() - com.atlassian.clover.reporters.html.HtmlReporter.runReport(args) - - // and generate ${reportsDir}/clover/clover.xml - args = ["--initstring", "${buildDir}/clover/clover.db", - "-o", "${reportsDir}/clover/clover.xml"].toArray() - com.atlassian.clover.reporters.xml.XMLReporter.runReport(args) + file("${buildDir}/clover/clover.db").exists() } + doFirst { + def argsList = ["--initstring", "${buildDir}/clover/clover.db", + "-o", "${reportsDir}/clover"] + String[] args = argsList.toArray() + com.atlassian.clover.reporters.html.HtmlReporter.runReport(args) + + // and generate ${reportsDir}/clover/clover.xml + args = ["--initstring", "${buildDir}/clover/clover.db", + "-o", "${reportsDir}/clover/clover.xml"].toArray() + com.atlassian.clover.reporters.xml.XMLReporter.runReport(args) + } } // end clover bits @@ -191,7 +519,6 @@ compileJava { } compileTestJava { - if (use_clover) { dependsOn compileCloverJava classpath += configurations.cloverRuntime @@ -227,47 +554,92 @@ cleanTest { delete cloverInstrDir } +// format is a string like date.format("dd MMMM yyyy") def getDate(format) { def date = new Date() - //return date.format("dd MMMM yyyy") return date.format(format) } -def getGitHash() { - def stdout = new ByteArrayOutputStream() +task setGitVals { + def hashStdOut = new ByteArrayOutputStream() exec { commandLine "git", "rev-parse", "--short", "HEAD" - standardOutput = stdout - workingDir = jalviewDir + standardOutput = hashStdOut + ignoreExitValue true } - return stdout.toString().trim() -} -def getGitBranch() { - def stdout = new ByteArrayOutputStream() + def branchStdOut = new ByteArrayOutputStream() exec { commandLine "git", "rev-parse", "--abbrev-ref", "HEAD" - standardOutput = stdout - workingDir = jalviewDir + standardOutput = branchStdOut + ignoreExitValue true } - return stdout.toString().trim() + + project.ext.gitHash = hashStdOut.toString().trim() + project.ext.gitBranch = branchStdOut.toString().trim() + + outputs.upToDateWhen { false } } task createBuildProperties(type: WriteProperties) { + dependsOn setGitVals inputs.dir("$jalviewDir/$sourceDir") + inputs.dir("$classes") inputs.dir("$jalviewDir/$resourceDir") - outputFile "$classes/$buildPropertiesFile" - /* taking time/date specific comment out to allow better incremental builds */ - //comment "--Jalview Build Details--\n"+getDate("yyyy-MM-dd HH:mm:ss") - comment "--Jalview Build Details--\n"+getDate("yyyy-MM-dd") - property "BUILD_DATE", getDate("dd MMMM yyyy") + outputFile (buildProperties) + // taking time specific comment out to allow better incremental builds + comment "--Jalview Build Details--\n"+getDate("yyyy-MM-dd HH:mm:ss") + //comment "--Jalview Build Details--\n"+getDate("yyyy-MM-dd") + property "BUILD_DATE", getDate("HH:mm:ss dd MMMM yyyy") property "VERSION", JALVIEW_VERSION - property "INSTALLATION", INSTALLATION+" git-commit:"+getGitHash()+" ["+getGitBranch()+"]" + property "INSTALLATION", INSTALLATION+" git-commit:"+project.ext.gitHash+" ["+project.ext.gitBranch+"]" outputs.file(outputFile) - outputs.dir("$classes") +} + +def buildingHTML = "$jalviewDir/$docDir/building.html" +task deleteBuildingHTML(type: Delete) { + delete buildingHTML +} + +task convertBuildingMD(type: Exec) { + dependsOn deleteBuildingHTML + def buildingMD = "$jalviewDir/$docDir/building.md" + def css = "$jalviewDir/$docDir/github.css" + + def pandoc = null + pandoc_exec.split(",").each { + if (file(it.trim()).exists()) { + pandoc = it.trim() + return true + } + } + + def hostname = "hostname".execute().text.trim() + if ((pandoc == null || ! file(pandoc).exists()) && hostname.equals("jv-bamboo")) { + pandoc = System.getProperty("user.home")+"/buildtools/pandoc/bin/pandoc" + } + + doFirst { + if (pandoc != null && file(pandoc).exists()) { + commandLine pandoc, '-s', '-o', buildingHTML, '--metadata', 'pagetitle="Building Jalview from Source"', '--toc', '-H', css, buildingMD + } else { + println("Cannot find pandoc. Skipping convert building.md to HTML") + throw new StopExecutionException() + } + } + + ignoreExitValue true + + inputs.file(buildingMD) + inputs.file(css) + outputs.file(buildingHTML) +} +clean { + delete buildingHTML } task syncDocs(type: Sync) { + dependsOn convertBuildingMD def syncDir = "$classes/$docDir" from fileTree("$jalviewDir/$docDir") into syncDir @@ -275,29 +647,31 @@ task syncDocs(type: Sync) { } def helpFile = "$classes/$helpDir/help.jhm" -task syncHelp(type: Sync) { - inputs.files("$jalviewDir/$helpDir") - outputs.files(helpFile) - - def syncDir = "$classes/$helpDir" - from fileTree("$jalviewDir/$helpDir") - into syncDir -} task copyHelp(type: Copy) { - def inputDir = "$jalviewDir/$helpDir" + def inputDir = "$jalviewDir/$helpParentDir/$helpDir" def outputDir = "$classes/$helpDir" - from inputDir + from(inputDir) { + exclude '**/*.gif' + exclude '**/*.jpg' + exclude '**/*.png' + filter(ReplaceTokens, beginToken: '$$', endToken: '$$', tokens: ['Version-Rel': JALVIEW_VERSION,'Year-Rel': getDate("yyyy")]) + } + from(inputDir) { + include '**/*.gif' + include '**/*.jpg' + include '**/*.png' + } into outputDir - filter(ReplaceTokens, beginToken: '$$', endToken: '$$', tokens: ['Version-Rel': "USING_FILTER"]) + inputs.dir(inputDir) outputs.files(helpFile) outputs.dir(outputDir) } task syncLib(type: Sync) { - def syncDir = "$classes/$libDir" - from fileTree("$jalviewDir/$libDir") + def syncDir = "$classes/$libDistDir" + from fileTree("$jalviewDir/$libDistDir") into syncDir } @@ -325,14 +699,17 @@ test { if (use_clover) { dependsOn cloverInstr } - print("Running tests " + (use_clover?"WITH":"WITHOUT") + " clover [clover="+use_clover+"]\n") - + + if (use_clover) { + print("Running tests " + (use_clover?"WITH":"WITHOUT") + " clover [clover="+use_clover+"]\n") + } + useTestNG() { includeGroups testngGroups preserveOrder true useDefaultListeners=true } - + workingDir = jalviewDir //systemProperties 'clover.jar' System.properties.clover.jar sourceCompatibility = compile_source_compatibility @@ -366,10 +743,13 @@ task compileLinkCheck(type: JavaCompile) { destinationDir = file("$jalviewDir/$utilsDir") source = fileTree(dir: "$jalviewDir/$utilsDir", include: ["HelpLinksChecker.java", "BufferedLineReader.java"]) + inputs.file("$jalviewDir/$utilsDir/HelpLinksChecker.java") + inputs.file("$jalviewDir/$utilsDir/HelpLinksChecker.java") outputs.file("$jalviewDir/$utilsDir/HelpLinksChecker.class") outputs.file("$jalviewDir/$utilsDir/BufferedLineReader.class") } +def helplinkscheckertouchfile = file("$jalviewDir/$utilsDir/HelpLinksChecker.touch") task linkCheck(type: JavaExec) { dependsOn prepare, compileLinkCheck classpath = files("$jalviewDir/$utilsDir") @@ -377,15 +757,21 @@ task linkCheck(type: JavaExec) { workingDir = jalviewDir def help = "$classes/$helpDir" args = [ "$classes/$helpDir", "-nointernet" ] - //args = [ "$classesDir/$helpDir", "-nointernet" ] - doFirst { - standardOutput new FileOutputStream("$jalviewDir/$utilsDir/HelpLinksChecker.out") + doLast { + helplinkscheckertouchfile.createNewFile() } - outputs.file("$jalviewDir/$utilsDir/HelpLinksChecker.out") + inputs.dir("$classes/$helpDir") + outputs.file(helplinkscheckertouchfile) } +// import the pubhtmlhelp target +ant.properties.basedir = "$jalviewDir" +ant.properties.helpBuildDir = jalviewDirAbsolutePath+"/$classes/$helpDir" +ant.importBuild "$utilsDir/publishHelp.xml" + + task cleanPackageDir(type: Delete) { delete fileTree("$jalviewDir/$packageDir").include("*.jar") } @@ -422,7 +808,7 @@ task copyJars(type: Copy) { // doing a Sync instead of Copy as Copy doesn't deal with "outputs" very well task syncJars(type: Sync) { - from fileTree("$jalviewDir/$libDir").include("**/*.jar").include("*.jar").files + from fileTree("$jalviewDir/$libDistDir").include("**/*.jar").include("*.jar").files into "$jalviewDir/$packageDir" preserve { include jar.archiveName @@ -430,6 +816,8 @@ task syncJars(type: Sync) { } task makeDist { + group = "build" + description = "Put all required libraries in dist" // order of "cleanPackageDir", "copyJars", "jar" important! jar.mustRunAfter cleanPackageDir syncJars.mustRunAfter cleanPackageDir @@ -446,44 +834,57 @@ task cleanDist { } shadowJar { - dependsOn makeDist - if (JAVA_VERSION.equals("11")) { - from ("$jalviewDir/$j11libDir") { - include("*.jar") - } + group = "distribution" + if (buildDist) { + dependsOn makeDist + } + from ("$jalviewDir/$libDistDir") { + include("*.jar") + } + manifest { + attributes 'Implementation-Version': JALVIEW_VERSION } mainClassName = shadowJarMainClass mergeServiceFiles() - classifier = "all" + classifier = "all-"+JALVIEW_VERSION+"-j"+JAVA_VERSION minimize() } -ext { - getdownWebsiteDir = jalviewDir + '/' + getdown_website_dir - getdownAppDir = getdownWebsiteDir + '/' + getdown_app_dir - getdownJ11libDir = getdownWebsiteDir + '/' + getdown_j11lib_dir - getdownResourceDir = getdownWebsiteDir + '/' + getdown_resource_dir - getdownLauncher = jalviewDir + '/' + getdown_launcher - getdownFilesDir = jalviewDir + '/' + getdown_files_dir - getdownLib1 = jalviewDir + '/' + getdown_lib1 - def getdownChannel = getdown_channel_name - if (getdown_channel_name.equals("COMMIT")) { - getdownChannel = getGitHash() +task getdownWebsite() { + group = "distribution" + description = "Create the getdown minimal app folder, and website folder for this version of jalview. Website folder also used for offline app installer" + if (buildDist) { + dependsOn makeDist } - getdown_app_base = getdown_channel_base+"/"+JAVA_VERSION+"/"+getdownChannel+"/" -} -task getdownWebsite() { - dependsOn makeDist + // clean the getdown website and files dir before creating getdown folders + delete project.ext.getdownWebsiteDir + delete project.ext.getdownFilesDir + def getdownWebsiteResourceFilenames = [] def getdownTextString = "" def getdownResourceDir = project.ext.getdownResourceDir def getdownAppDir = project.ext.getdownAppDir def getdownResourceFilenames = [] + doFirst { + copy { + from buildProperties + rename(buildPropertiesFile, getdown_build_properties) + into project.ext.getdownAppDir + } + getdownWebsiteResourceFilenames += getdown_app_dir+"/"+getdown_build_properties + // go through properties looking for getdown_txt_... def props = project.properties.sort { it.key } - props.put("getdown_txt_java_min_version", getdown_alt_java_min_version) + if (getdown_alt_java_min_version.length() > 0) { + props.put("getdown_txt_java_min_version", getdown_alt_java_min_version) + } + if (getdown_alt_java_max_version.length() > 0) { + props.put("getdown_txt_java_max_version", getdown_alt_java_max_version) + } + props.put("getdown_txt_multi_java_location", getdown_alt_multi_java_location) + props.put("getdown_txt_appbase", getdown_app_base) props.each{ prop, val -> if (prop.startsWith("getdown_txt_") && val != null) { @@ -495,7 +896,7 @@ task getdownWebsite() { } } else { // file values rationalised - if (val.indexOf('/') > -1) { + if (val.indexOf('/') > -1 || prop.startsWith("getdown_txt_resource")) { def r = null if (val.indexOf('/') == 0) { // absolute path @@ -510,8 +911,10 @@ task getdownWebsite() { getdownResourceFilenames += r.getPath() } } - def line = prop.substring(12) + " = " + val + "\n" - getdownTextString += line + if (! prop.startsWith("getdown_txt_resource")) { + def line = prop.substring(12) + " = " + val + "\n" + getdownTextString += line + } } } } @@ -527,7 +930,7 @@ task getdownWebsite() { } def codeFiles = [] - makeDist.outputs.files.each{ f -> + fileTree(file(packageDir)).each{ f -> if (f.isDirectory()) { def files = fileTree(dir: f, include: ["*"]).getFiles() codeFiles += files @@ -544,75 +947,120 @@ task getdownWebsite() { } } + // NOT USING MODULES YET, EVERYTHING SHOULD BE IN dist + /* if (JAVA_VERSION.equals("11")) { - def j11libFiles = fileTree(dir: "$jalviewDir/$j11libDir", include: ["*.jar"]).getFiles() - j11libFiles.sort().each{f -> - def line = "code = " + getdown_j11lib_dir + '/' + f.getName() + "\n" - getdownTextString += line - copy { - from f.getPath() - into project.ext.getdownJ11libDir - } - } + def j11libFiles = fileTree(dir: "$jalviewDir/$j11libDir", include: ["*.jar"]).getFiles() + j11libFiles.sort().each{f -> + def line = "code = " + getdown_j11lib_dir + '/' + f.getName() + "\n" + getdownTextString += line + copy { + from f.getPath() + into project.ext.getdownJ11libDir + } } + } + */ - getdownTextString += "code = " + file(getdownLauncher).getName() + "\n" + // 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. + //getdownTextString += "class = " + file(getdownLauncher).getName() + "\n" + getdownTextString += "resource = " + getdown_launcher_new + "\n" getdownTextString += "class = " + mainClass + "\n" def getdown_txt = file(project.ext.getdownWebsiteDir + "/getdown.txt") getdown_txt.write(getdownTextString) - copy { - from getdown_txt - into project.ext.getdownFilesDir - } + def launch_jvl = file(project.ext.getdownWebsiteDir + "/" + getdown_launch_jvl) + launch_jvl.write("appbase="+props.get("getdown_txt_appbase")) copy { from getdownLauncher + rename(file(getdownLauncher).getName(), getdown_launcher_new) into project.ext.getdownWebsiteDir } copy { from getdownLauncher - into project.ext.getdownFilesDir + if (file(getdownLauncher).getName() != getdown_launcher) { + rename(file(getdownLauncher).getName(), getdown_launcher) + } + into project.ext.getdownWebsiteDir } - copy { - from getdownLib1 - into project.ext.getdownFilesDir + if (! (CHANNEL.startsWith("ARCHIVE") || CHANNEL.startsWith("DEVELOP"))) { + copy { + from getdown_txt + from getdownLauncher + from getdownWebsiteDir+"/"+getdown_build_properties + if (file(getdownLauncher).getName() != getdown_launcher) { + rename(file(getdownLauncher).getName(), getdown_launcher) + } + into getdownInstallDir + } + + copy { + from getdownInstallDir + into getdownFilesInstallDir + } } copy { - from getdownLib1 - into project.ext.getdownWebsiteDir + from getdown_txt + from launch_jvl + from getdownLauncher + from getdownWebsiteDir+"/"+getdown_build_properties + if (file(getdownLauncher).getName() != getdown_launcher) { + rename(file(getdownLauncher).getName(), getdown_launcher) + } + into getdownFilesDir } copy { - from jalviewDir + '/' + project.getProperty('getdown_txt_ui.background_image') - from jalviewDir + '/' + project.getProperty('getdown_txt_ui.error_background') - from jalviewDir + '/' + project.getProperty('getdown_txt_ui.progress_image') - from jalviewDir + '/' + project.getProperty('getdown_txt_ui.icon') - from jalviewDir + '/' + project.getProperty('getdown_txt_ui.mac_dock_icon') - into project.ext.getdownFilesDir + '/' + getdown_resource_dir + from getdownResourceDir + into project.ext.getdownFilesDir + '/' + getdown_resource_dir } } - inputs.dir(jalviewDir + '/' + packageDir) + if (buildDist) { + inputs.dir(jalviewDir + '/' + packageDir) + } outputs.dir(project.ext.getdownWebsiteDir) outputs.dir(project.ext.getdownFilesDir) } task getdownDigest(type: JavaExec) { + group = "distribution" + description = "Digest the getdown website folder" dependsOn getdownWebsite - classpath = files(jalviewDir + '/' + getdown_core) - classpath file(jalviewDir + '/' + getdown_lib1) + doFirst { + classpath = files(getdownWebsiteDir + '/' + getdown_launcher) + } main = "com.threerings.getdown.tools.Digester" args project.ext.getdownWebsiteDir + inputs.dir(project.ext.getdownWebsiteDir) outputs.file(project.ext.getdownWebsiteDir + '/' + "digest2.txt") } task getdown() { + group = "distribution" + description = "Create the minimal and full getdown app folder for installers and website and create digest file" dependsOn getdownDigest + doLast { + if (reportRsyncCommand) { + def fromDir = getdownWebsiteDir + (getdownWebsiteDir.endsWith("/")?"":"/") + def toDir = getdown_rsync_dest + "/" + getdownDir + (getdownDir.endsWith("/")?"":"/") + println "LIKELY RSYNC COMMAND:" + println "mkdir -p '$toDir'\nrsync -avh --delete '$fromDir' '$toDir'" + if (RUNRSYNC == "true") { + exec { + commandLine "mkdir", "-p", toDir + } + exec { + commandLine "rsync", "-avh", "--delete", fromDir, toDir + } + } + } + } } clean { @@ -635,42 +1083,544 @@ install4j { } installDir = file(install4jHomeDir) mediaTypes = Arrays.asList(install4jMediaTypes.split(",")) + if (install4jFaster.equals("true")) { + faster = true + } } def install4jConf def macosJavaVMDir +def macosJavaVMTgz def windowsJavaVMDir +def windowsJavaVMTgz +def install4jDir = "$jalviewDir/$install4jResourceDir" +def install4jConfFile = "jalview-installers-java"+JAVA_VERSION+".install4j" +install4jConf = "$install4jDir/$install4jConfFile" + task copyInstall4jTemplate(type: Copy) { - def install4jDir = "$jalviewDir/$install4jResourceDir" - def install4jConfFile = "jalview-installers-java"+JAVA_VERSION+".install4j" - macosJavaVMDir = System.env.HOME+"/buildtools/jre/openjdk-java_vm/macos-jre"+JAVA_VERSION+"/java_vm" - windowsJavaVMDir = System.env.HOME+"/buildtools/jre/openjdk-java_vm/windows-jre"+JAVA_VERSION+"/java_vm" + macosJavaVMDir = System.env.HOME+"/buildtools/jre/openjdk-java_vm/getdown/macos-jre"+JAVA_VERSION+"/jre" + macosJavaVMTgz = System.env.HOME+"/buildtools/jre/openjdk-java_vm/install4j/tgz/macos-jre"+JAVA_VERSION+".tar.gz" + windowsJavaVMDir = System.env.HOME+"/buildtools/jre/openjdk-java_vm/getdown/windows-jre"+JAVA_VERSION+"/jre" + windowsJavaVMTgz = System.env.HOME+"/buildtools/jre/openjdk-java_vm/install4j/tgz/windows-jre"+JAVA_VERSION+".tar.gz" from (install4jDir) { include install4jTemplate rename (install4jTemplate, install4jConfFile) filter(ReplaceTokens, beginToken: '', endToken: '', tokens: ['9999999999': JAVA_VERSION]) - filter(ReplaceTokens, beginToken: '$$', endToken: '$$', tokens: ['VERSION': JALVIEW_VERSION, 'MACOS_JAVA_VM_DIR': macosJavaVMDir, 'WINDOWS_JAVA_VM_DIR': windowsJavaVMDir]) + filter(ReplaceTokens, beginToken: '$$', endToken: '$$', + tokens: [ + 'JAVA_VERSION': JAVA_VERSION, + 'JAVA_INTEGER_VERSION': JAVA_INTEGER_VERSION, + 'VERSION': JALVIEW_VERSION, + 'MACOS_JAVA_VM_DIR': macosJavaVMDir, + 'MACOS_JAVA_VM_TGZ': macosJavaVMTgz, + 'WINDOWS_JAVA_VM_DIR': windowsJavaVMDir, + 'WINDOWS_JAVA_VM_TGZ': windowsJavaVMTgz, + 'INSTALL4JINFOPLISTFILEASSOCIATIONS': install4jInfoPlistFileAssociations, + 'COPYRIGHT_MESSAGE': install4jCopyrightMessage, + 'MACOS_BUNDLE_ID': install4jMacOSBundleId, + 'GETDOWN_RESOURCE_DIR': getdown_resource_dir, + 'GETDOWN_DIST_DIR': getdown_app_dir, + 'GETDOWN_ALT_DIR': getdown_app_dir_alt, + 'GETDOWN_INSTALL_DIR': getdown_install_dir + ] + ) + if (OSX_KEYPASS=="") { + filter(ReplaceTokens, beginToken: 'codeSigning macEnabled="', endToken: '"', tokens: ['true':'codeSigning macEnabled="false"']) + filter(ReplaceTokens, beginToken: 'runPostProcessor="true" ',endToken: 'Processor', tokens: ['post':'runPostProcessor="false" postProcessor']) + } } into install4jDir - install4jConf = "$install4jDir/$install4jConfFile" - inputs.files("$install4jDir/$install4jTemplate") outputs.files(install4jConf) + + doLast { + // include file associations in installer + def installerFileAssociationsXml = file("$install4jDir/$install4jInstallerFileAssociations").text + ant.replaceregexp( + byline: false, + flags: "s", + match: '', + replace: installerFileAssociationsXml, + file: install4jConf + ) + /* + // include uninstaller applescript app files in dmg + def installerDMGUninstallerXml = file("$install4jDir/$install4jDMGUninstallerAppFiles").text + ant.replaceregexp( + byline: false, + flags: "s", + match: '', + replace: installerDMGUninstallerXml, + file: install4jConf + ) + */ + } } task installers(type: com.install4j.gradle.Install4jTask) { + group = "distribution" + description = "Create the install4j installers" dependsOn getdown dependsOn copyInstall4jTemplate - projectFile = install4jConf - variables = [majorVersion: version.substring(2, 11), build: 001] - destination = "$jalviewDir/$install4jBuildDir" + projectFile = file(install4jConf) + println("Using projectFile "+projectFile) + variables = [majorVersion: version.substring(2, 11), build: 001, OSX_KEYSTORE: OSX_KEYSTORE, JSIGN_SH: JSIGN_SH] + destination = "$jalviewDir/$install4jBuildDir/$JAVA_VERSION" buildSelected = true + + if (OSX_KEYPASS) { + macKeystorePassword=OSX_KEYPASS + + } + inputs.dir(project.ext.getdownWebsiteDir) inputs.file(install4jConf) inputs.dir(macosJavaVMDir) inputs.dir(windowsJavaVMDir) - outputs.dir("$jalviewDir/$install4jBuildDir") + outputs.dir("$jalviewDir/$install4jBuildDir/$JAVA_VERSION") + } clean { delete install4jConf } + +task sourceDist (type: Tar) { + + def VERSION_UNDERSCORES = JALVIEW_VERSION.replaceAll("\\.", "_") + def outputFileName = project.name + "_" + VERSION_UNDERSCORES + ".tar.gz" + // cater for buildship < 3.1 [3.0.1 is max version in eclipse 2018-09] + try { + archiveFileName = outputFileName + } catch (Exception e) { + archiveName = outputFileName + } + + compression Compression.GZIP + + into project.name + + def EXCLUDE_FILES=["build/*","bin/*","test-output/","test-reports","tests","clover*/*" + ,".*" + ,"benchmarking/*" + ,"**/.*" + ,"*.class" + ,"**/*.class","$j11modDir/**/*.jar","appletlib","**/*locales" + ,"*locales/**", + ,"utils/InstallAnywhere"] + def PROCESS_FILES=[ "AUTHORS", + "CITATION", + "FEATURETODO", + "JAVA-11-README", + "FEATURETODO", + "LICENSE", + "**/README", + "RELEASE", + "THIRDPARTYLIBS","TESTNG", + "build.gradle", + "gradle.properties", + "**/*.java", + "**/*.html", + "**/*.xml", + "**/*.gradle", + "**/*.groovy", + "**/*.properties", + "**/*.perl", + "**/*.sh"] + + from(jalviewDir) { + exclude (EXCLUDE_FILES) + include (PROCESS_FILES) + filter(ReplaceTokens, beginToken: '$$', endToken: '$$', tokens: ['Version-Rel': JALVIEW_VERSION,'Year-Rel': getDate("yyyy")]) + } + from(jalviewDir) { + exclude (EXCLUDE_FILES) + exclude (PROCESS_FILES) + exclude ("appletlib") + exclude ("**/*locales") + exclude ("*locales/**") + exclude ("utils/InstallAnywhere") + + exclude (getdown_files_dir) + exclude (getdown_website_dir) + + // exluding these as not using jars as modules yet + exclude ("$j11modDir/**/*.jar") +} +// from (jalviewDir) { +// // explicit includes for stuff that seemed to not get included +// include(fileTree("test/**/*.")) +// exclude(EXCLUDE_FILES) +// exclude(PROCESS_FILES) +// } +} + +task helppages { + dependsOn copyHelp + dependsOn pubhtmlhelp + + inputs.dir("$classes/$helpDir") + outputs.dir("$helpOutputDir") +} + +def jalviewjsBuildDir +def jalviewjsSiteDir +def jalviewjsTransferSiteDir +task jalviewjsSitePath { + if (jalviewjs_site_dir.startsWith("/")) { + jalviewjsSiteDir = jalviewjs_site_dir + } else { + def relativeBuildDir = file(jalviewDirAbsolutePath).toPath().relativize(buildDir.toPath()) + jalviewjsBuildDir = "${relativeBuildDir}/jalviewjs" + jalviewjsSiteDir = jalviewjsBuildDir + "/" + jalviewjs_site_dir + } + jalviewjsTransferSiteDir = jalviewjsBuildDir + "/tmp/site" +} + +def eclipseWorkspace +task jalviewjsSetEclipseWorkspace { + def propKey = "jalviewjs_eclipse_workspace" + def propsFileName = "${jalviewjsBuildDir}/${jalviewjs_eclipse_workspace_location_file}" + def props = new Properties() + def eclipseWsDir + def propVal = null + if (project.hasProperty(propKey)) { + propVal = project.getProperty(propKey) + eclipseWsDir = propVal + } + if (( eclipseWsDir == null || !file(eclipseWsDir).exists() ) && file(propsFileName).exists()) { + def ins = new FileInputStream(propsFileName) + props.load(ins) + ins.close() + if (props.getProperty(propKey, null) != null) { + eclipseWsDir = props.getProperty(propKey) + } + } + + if (eclipseWsDir == null || !file(eclipseWsDir).exists()) { + def tempDir = File.createTempDir() + eclipseWsDir = tempDir.getAbsolutePath() + props.setProperty(propKey, eclipseWsDir) + def propsFile = file(propsFileName) + propsFile.parentFile.mkdirs() + propsFile.createNewFile() // doesn't affect existing file + def outs = new FileOutputStream(propsFile, false) + props.store(outs, null) + outs.close() + } + + eclipseWorkspace = file(eclipseWsDir) + + println("ECLIPSE WORKSPACE: "+eclipseWorkspace.getPath()) + + inputs.property(propKey, propVal) + outputs.file(propsFileName) +} + + +task jalviewjsUnzipFiles { + dependsOn jalviewjsSitePath + + def zipFiles = fileTree(dir: jalviewjs_utils_dir+"/"+jalviewjs_libjs_dir).include("*.zip") + zipFiles += jalviewjs_utils_dir+"/"+jalviewjs_swingjs_zip + + doLast { + zipFiles.each { file_zip -> + copy { + from zipTree(file_zip) + into jalviewjsSiteDir + } + } + } + + inputs.files zipFiles + outputs.dir jalviewjsSiteDir +} + +def eclipseDropinsDir +def eclipseBinary +def eclipseVersion +def fromDropinsDir +task jalviewjsEclipsePaths { + def eclipseRoot + def eclipseProduct + eclipseRoot = jalviewjs_eclipse_root + if (eclipseRoot.startsWith("~")) { + eclipseRoot = System.getProperty("user.home") + eclipseRoot.substring(1) + } + if (OperatingSystem.current().isMacOsX()) { + eclipseRoot += "/Eclipse.app" + eclipseDropinsDir = eclipseRoot+"/Contents/Eclipse/dropins" + eclipseBinary = eclipseRoot+"/Contents/MacOS/eclipse" + eclipseProduct = eclipseRoot+"/Contents/Eclipse/.eclipseproduct" + } else if (OperatingSystem.current().isWindows()) { // check these paths!! + if (file(eclipseRoot+"/eclipse").isDirectory() && file(eclipseRoot+"/eclipse/.eclipseproduct").exists()) { + eclipseRoot += "/eclipse" + } + eclipseDropinsDir = eclipseRoot+"/dropins" + eclipseBinary = eclipseRoot+"/eclipse" + eclipseProduct = eclipseRoot+"/.eclipseproduct" + } else { // linux or unix + if (file(eclipseRoot+"/eclipse").isDirectory() && file(eclipseRoot+"/eclipse/.eclipseproduct").exists()) { + eclipseRoot += "/eclipse" + } + eclipseDropinsDir = eclipseRoot+"/dropins" + eclipseBinary = eclipseRoot+"/eclipse" + eclipseProduct = eclipseRoot+"/.eclipseproduct" + } + + def fis = new FileInputStream(eclipseProduct) + def props = new Properties() + props.load(fis) + eclipseVersion = props.getProperty("version") + fis.close() + println("ECLIPSE_VERSION=${eclipseVersion}") + String[] v = eclipseVersion.split("\\.") + def v0 = Integer.valueOf(v[0]) + def v1 = Integer.valueOf(v[1]) + if (v0 < 4 || ( v0 == 4 && v1 < 13 )) { + fromDropinsDir = "eclipse/dropins_4.12" + } else { + fromDropinsDir = "eclipse/dropins_4.13" + } +} + +task jalviewjsEclipseCopyDropins { + dependsOn jalviewjsEclipsePaths + def inputFiles = fileTree(dir: jalviewjs_utils_dir+"/"+fromDropinsDir, include: "*.jar") + def outputDir = eclipseDropinsDir + + inputs.files inputFiles + inputFiles.each { file -> + outputs.file(outputDir+"/"+file.name) + } + + doLast { + def outputFiles = [] + inputFiles.each { file -> + copy { + from file + into outputDir + } + } + } +} + +task jalviewjsCreateJ2sSettings(type: WriteProperties) { + dependsOn jalviewjsSitePath + outputFile (jalviewDir+"/"+jalviewjs_j2s_settings) + def props = project.properties.sort { it.key } + def siteDirProperty = "j2s.site.directory" + def setSiteDir = false + props.each { prop, val -> + if (prop.startsWith("j2s.") && val != null) { + if (prop == siteDirProperty) { + if (!(val.startsWith("/") || val.startsWith("file://") )) { + val = jalviewjsTransferSiteDir+"/"+val + } + setSiteDir = true + } + property(prop,val) + } + if (!setSiteDir) { + property(siteDirProperty,jalviewjsTransferSiteDir) + } + } + outputs.file(outputFile) +} + +task jalviewjsEclipseSetup { + dependsOn jalviewjsEclipseCopyDropins + dependsOn jalviewjsSetEclipseWorkspace + dependsOn jalviewjsCreateJ2sSettings +} + +task jalviewjsCopyResources (type: Copy) { + dependsOn jalviewjsSitePath + def inputFiles = fileTree(dir: jalviewjs_resource_dir) + def outputDir = jalviewjsSiteDir+"/"+jalviewjs_j2s_subdir + + from inputFiles + into outputDir + def outputFiles = [] + rename { filename -> + outputFiles += outputDir+"/"+filename + null + } + outputs.files outputFiles + inputs.files inputFiles +} + +task jalviewjsCopySiteResources (type: Copy) { + dependsOn jalviewjsSitePath + def inputFiles = fileTree(dir: jalviewjs_utils_dir+"/"+jalviewjs_site_resource_dir) + def outputDir = jalviewjsSiteDir + + from inputFiles + into outputDir + def outputFiles = [] + rename { filename -> + outputFiles += outputDir+"/"+filename + null + } + outputs.files outputFiles + inputs.files inputFiles +} + +task cleanJalviewjs { + //delete jalviewjsBuildDir + //delete jalviewDir+"/"+eclipse_bin_dir + //delete file(eclipseWorkspace.getAbsolutePath()+"/.metadata") + //delete jalviewDir+"/"+jalviewjs_j2s_settings +} + +task jalviewjsProjectImport(type: Exec) { + // work out how to do this! + dependsOn eclipseProject + dependsOn eclipseClasspath + dependsOn eclipseJdt + dependsOn jalviewjsEclipsePaths + dependsOn jalviewjsEclipseSetup + executable(eclipseBinary) + args(["-nosplash", "--launcher.suppressErrors", "-application", "com.seeq.eclipse.importprojects.headlessimport", "-data", eclipseWorkspace.getPath(), "-import", jalviewDirAbsolutePath]) + + def projdir = eclipseWorkspace.getPath()+"/.metadata/.plugins/org.eclipse.core.resources/.projects/jalview/org.eclipse.jdt.core" + inputs.file(jalviewDir+"/.project") + outputs.dir(projdir) + outputs.upToDateWhen { file(projdir).exists() } +} + +task jalviewjsTranspile(type: Exec) { + dependsOn jalviewjsEclipseSetup + dependsOn jalviewjsProjectImport + dependsOn jalviewjsEclipsePaths + executable(eclipseBinary) + args(["-nosplash", "--launcher.suppressErrors", "-application", "org.eclipse.jdt.apt.core.aptBuild", "-data", eclipseWorkspace, "-"+jalviewjs_eclipseBuildArg, eclipse_project_name ]) + + def stdout + def stderr + doFirst { + stdout = new ByteArrayOutputStream() + stderr = new ByteArrayOutputStream() + + def logOutFileName = "${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_j2s_stdout}" + def logOutFile = file(logOutFileName) + logOutFile.createNewFile() + def logOutFOS = new FileOutputStream(logOutFile, false) + //def logErrFileName = "${jalviewjsBuildDir}/${jalviewjs_j2s_stderr}" + //def logErrFile = file(logFileName) + //logErrFile.createNewFile() + //def logErrFOS = new FileErrputStream(logErrFile, false) + // combine stdout and stderr + def logErrFOS = logOutFOS + if (jalviewjs_j2s_to_console.equals("true")) { + standardOutput = new org.apache.tools.ant.util.TeeOutputStream( + new org.apache.tools.ant.util.TeeOutputStream( + logOutFOS, + stdout), + standardOutput) + errorOutput = new org.apache.tools.ant.util.TeeOutputStream( + new org.apache.tools.ant.util.TeeOutputStream( + logErrFOS, + stderr), + errorOutput) + } else { + standardOutput = new org.apache.tools.ant.util.TeeOutputStream( + logOutFOS, + stdout) + errorOutput = new org.apache.tools.ant.util.TeeOutputStream( + logErrFOS, + stderr) + } + } + doLast { + if (stdout.toString().contains("Error processing ")) { + // j2s did not complete transpile + throw new GradleException("Error during transpilation:\n${stderr}\nSee eclipse transpile log file '${jalviewjsBuildDir}/${jalviewjs_j2s_stdout}'") + } + } + + inputs.dir(sourceDir) + outputs.dir(eclipse_bin_dir+"/main") + outputs.dir(jalviewjsTransferSiteDir) + +} + +task jalviewjsCopyTransferSite(type: Copy) { + dependsOn jalviewjsTranspile + from jalviewjsTransferSiteDir + into jalviewjsSiteDir +} + +jalviewjsUnzipFiles.mustRunAfter jalviewjsCopyTransferSite +jalviewjsCopyResources.mustRunAfter jalviewjsCopyTransferSite +jalviewjsCopySiteResources.mustRunAfter jalviewjsCopyTransferSite + +task jalviewjsPrepareSite { + group "JalviewJS" + description "Prepares the website folder including unzipping files and copying resources" + dependsOn jalviewjsSitePath + dependsOn jalviewjsUnzipFiles + dependsOn jalviewjsCopyResources + dependsOn jalviewjsCopySiteResources +} + +task jalviewjsBuildSite { + group "JalviewJS" + description "Builds the whole website including transpiled code" + dependsOn jalviewjsCopyTransferSite + dependsOn jalviewjsPrepareSite +} + +task jalviewjsSiteTar(type: Tar) { + group "JalviewJS" + description "Creates a tar.gz file for the website" + dependsOn jalviewjsBuildSite + def outputFilename = "jalviewjs-site-${JALVIEW_VERSION}.tar.gz" + try { + archiveFileName = outputFilename + } catch (Exception e) { + archiveName = outputFilename + } + + compression Compression.GZIP + + from jalviewjsSiteDir + into jalviewjs_site_dir // this is inside the tar file + + inputs.dir(jalviewjsSiteDir) +} + +task jalviewjsServer { + group "JalviewJS" + description "Starts a webserver on localhost to test the website" + dependsOn jalviewjsSitePath + doLast { + + SimpleHttpFileServerFactory factory = new SimpleHttpFileServerFactory() + def port = Integer.valueOf(jalviewjs_server_port) + def start = port + def running = false + while(port < start+1000 && !running) { + try { + def doc_root = new File(jalviewDirAbsolutePath +"/"+ jalviewjsSiteDir) + jalviewjsServer = factory.start(doc_root, port) + running = true + println("SERVER STARTED with document root ${doc_root}.") + println("Go to "+jalviewjsServer.getResourceUrl(jalviewjs_server_resource)+" . Run gradle --stop to stop (kills all gradle daemons).") + println("For debug: "+jalviewjsServer.getResourceUrl(jalviewjs_server_resource)+"?j2sdebug") + } catch (Exception e) { + port++; + } + } + + } + +} + +task jalviewjs { + group "JalviewJS" + description "Build the site" + dependsOn jalviewjsBuildSite +} + +