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 java.security.MessageDigest import groovy.transform.ExternalizeMethods buildscript { dependencies { 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' id 'com.dorongold.task-tree' version '1.4' // only needed to display task dependency tree with gradle task1 [task2 ...] taskTree } repositories { jcenter() mavenCentral() mavenLocal() flatDir { dirs gradlePluginsDir } } dependencies { compile 'org.apache.commons:commons-compress:1.18' } // in ext the values are cast to Object. Ensure string values are cast as String (and not GStringImpl) for later use def string(Object o) { return o.toString() } ext { jalviewDirAbsolutePath = file(jalviewDir).getAbsolutePath() jalviewDirRelativePath = jalviewDir // local build environment properties def localProps = "${jalviewDirAbsolutePath}/local.properties" if (file(localProps).exists()) { try { def p = new Properties() def localPropsFIS = new FileInputStream(localProps) p.load(localPropsFIS) localPropsFIS.close() p.each { key, val -> def over = getProperty(key) != null setProperty(key, val) if (over) { println("Overriding property '${key}' with local.properties value '${val}'") } } } catch (Exception e) { System.out.println("Exception reading local.properties") } } // this property set when running Eclipse headlessly j2sHeadlessBuildProperty = string("net.sf.j2s.core.headlessbuild") // this property set by Eclipse eclipseApplicationProperty = string("eclipse.application") // CHECK IF RUNNING FROM WITHIN ECLIPSE def eclipseApplicationPropertyVal = System.properties[eclipseApplicationProperty] IN_ECLIPSE = eclipseApplicationPropertyVal != null && eclipseApplicationPropertyVal.startsWith("org.eclipse.ui.") // BUT WITHOUT THE HEADLESS BUILD PROPERTY SET if (System.properties[j2sHeadlessBuildProperty].equals("true")) { println("Setting IN_ECLIPSE to ${IN_ECLIPSE} as System.properties['${j2sHeadlessBuildProperty}'] == '${System.properties[j2sHeadlessBuildProperty]}'") IN_ECLIPSE = false } if (IN_ECLIPSE) { println("WITHIN ECLIPSE IDE") } else { println("HEADLESS BUILD") } /* *-/ System.properties.sort { it.key }.each { key, val -> println("SYSTEM PROPERTY ${key}='${val}'") } /-* *-/ if (false && IN_ECLIPSE) { jalviewDir = jalviewDirAbsolutePath } */ // essentials bareSourceDir = string(source_dir) sourceDir = string("${jalviewDir}/${bareSourceDir}") resourceDir = string("${jalviewDir}/${resource_dir}") bareTestSourceDir = string(test_source_dir) testSourceDir = string("${jalviewDir}/${bareTestSourceDir}") // clover cloverInstrDir = file("${buildDir}/${cloverSourcesInstrDir}") classesDir = string("${jalviewDir}/${classes_dir}") if (clover.equals("true")) { use_clover = true classesDir = string("${buildDir}/${cloverClassesDir}") } else { use_clover = false classesDir = string("${jalviewDir}/${classes_dir}") } classes = classesDir getdownWebsiteDir = string("${jalviewDir}/${getdown_website_dir}/${JAVA_VERSION}") getdownDir = string("") reportRsyncCmd = false buildDist = true buildProperties = build_properties_file getdownLauncher = string("${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 = string("${bamboo_planKey}/${JAVA_VERSION}") getdown_app_base = string("${bamboo_channelbase}/${bamboo_planKey}${bamboo_getdown_channel_suffix}/${JAVA_VERSION}") getdown_app_dir = getdown_app_dir_alt buildProperties = string("${classesDir}/${build_properties_file}") break case "RELEASE": getdown_channel_name = CHANNEL.toLowerCase() getdownDir = string("${getdown_channel_name}/${JAVA_VERSION}") getdown_app_base = string("${getdown_channel_base}/${getdownDir}") getdown_app_dir = getdown_app_dir_release buildProperties = string("${classesDir}/${build_properties_file}") reportRsyncCommand = true break case "ARCHIVE": getdown_channel_name = CHANNEL.toLowerCase()+"/${JALVIEW_VERSION}" getdownDir = string("${getdown_channel_name}/${JAVA_VERSION}") getdown_app_base = string("${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 = string("${ARCHIVEDIR}/${packageDir}") buildProperties = string("${ARCHIVEDIR}/${classes_dir}/${build_properties_file}") buildDist = false } reportRsyncCommand = true break case "ARCHIVELOCAL": getdown_channel_name = string("archive/${JALVIEW_VERSION}") getdownDir = string("${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 = string("${ARCHIVEDIR}/${packageDir}") buildProperties = string("${ARCHIVEDIR}/${classes_dir}/${build_properties_file}") buildDist = false } reportRsyncCommand = true getdownLauncher = string("${jalviewDir}/${getdown_lib_dir}/${getdown_launcher_local}") break case "DEVELOP": getdown_channel_name = CHANNEL.toLowerCase() getdownDir = string("${getdown_channel_name}/${JAVA_VERSION}") getdown_app_base = string("${getdown_channel_base}/${getdownDir}") getdown_app_dir = getdown_app_dir_alt buildProperties = string("${classesDir}/${build_properties_file}") reportRsyncCommand = true break case "TEST-RELEASE": getdown_channel_name = CHANNEL.toLowerCase() getdownDir = string("${getdown_channel_name}/${JAVA_VERSION}") getdown_app_base = string("${getdown_channel_base}/${getdownDir}") getdown_app_dir = getdown_app_dir_alt buildProperties = string("${classesDir}/${build_properties_file}") reportRsyncCommand = true break case ~/^SCRATCH(|-[-\w]*)$/: getdown_channel_name = CHANNEL getdownDir = string("${getdown_channel_name}/${JAVA_VERSION}") getdown_app_base = string("${getdown_channel_base}/${getdownDir}") getdown_app_dir = getdown_app_dir_alt buildProperties = string("${classesDir}/${build_properties_file}") reportRsyncCommand = true break case "LOCAL": getdown_app_base = file(getdownWebsiteDir).toURI().toString() getdown_app_dir = getdown_app_dir_alt buildProperties = string("${classesDir}/${build_properties_file}") getdownLauncher = string("${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 } getdownAppDir = string("${getdownWebsiteDir}/${getdown_app_dir}") //getdownJ11libDir = "${getdownWebsiteDir}/${getdown_j11lib_dir}" getdownResourceDir = string("${getdownWebsiteDir}/${getdown_resource_dir}") getdownInstallDir = string("${getdownWebsiteDir}/${getdown_install_dir}") getdownFilesDir = string("${jalviewDir}/${getdown_files_dir}/${JAVA_VERSION}/") getdownFilesInstallDir = string("${getdownFilesDir}/${getdown_install_dir}") /* compile without modules -- using classpath libraries modules_compileClasspath = fileTree(dir: "${jalviewDir}/${j11modDir}", include: ["*.jar"]) modules_runtimeClasspath = modules_compileClasspath */ gitHash = string("") gitBranch = string("") println("Using a ${CHANNEL} profile.") additional_compiler_args = [] // configure classpath/args for j8/j11 compilation if (JAVA_VERSION.equals("1.8")) { JAVA_INTEGER_VERSION = string("8") //libDir = j8libDir libDir = j11libDir libDistDir = j8libDir compile_source_compatibility = 1.8 compile_target_compatibility = 1.8 // these are getdown.txt properties defined dependent on the JAVA_VERSION getdown_alt_java_min_version = getdown_alt_java8_min_version getdown_alt_java_max_version = getdown_alt_java8_max_version // this property is assigned below and expanded to multiple lines in the getdown task getdown_alt_multi_java_location = getdown_alt_java8_txt_multi_java_location // this property is for the Java library used in eclipse eclipse_java_runtime_name = string("JavaSE-1.8") } else if (JAVA_VERSION.equals("11")) { JAVA_INTEGER_VERSION = string("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 = string("JavaSE-11") /* compile without modules -- using classpath libraries additional_compiler_args += [ '--module-path', 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 = string("JavaSE-11") /* compile without modules -- using classpath libraries additional_compiler_args += [ '--module-path', modules_compileClasspath.asPath, '--add-modules', j11modules ] */ } else { throw new GradleException("JAVA_VERSION=${JAVA_VERSION} not currently supported by Jalview") } // for install4j JAVA_MIN_VERSION = JAVA_VERSION JAVA_MAX_VERSION = JAVA_VERSION macosJavaVMDir = string("${System.env.HOME}/buildtools/jre/openjdk-java_vm/getdown/macos-jre${JAVA_VERSION}/jre") macosJavaVMTgz = string("${System.env.HOME}/buildtools/jre/openjdk-java_vm/install4j/tgz/macos-jre${JAVA_VERSION}.tar.gz") windowsJavaVMDir = string("${System.env.HOME}/buildtools/jre/openjdk-java_vm/getdown/windows-jre${JAVA_VERSION}/jre") windowsJavaVMTgz = string("${System.env.HOME}/buildtools/jre/openjdk-java_vm/install4j/tgz/windows-jre${JAVA_VERSION}.tar.gz") install4jDir = string("${jalviewDir}/${install4j_utils_dir}") install4jConfFileName = string("jalview-installers-java${JAVA_VERSION}.install4j") install4jConfFile = string("${install4jDir}/${install4jConfFileName}") install4jHomeDir = install4j_home_dir if (install4jHomeDir.startsWith("~/")) { install4jHomeDir = System.getProperty("user.home") + install4jHomeDir.substring(1) } buildingHTML = string("${jalviewDir}/${docDir}/building.html") helpFile = string("${classesDir}/${help_dir}/help.jhm") helpParentDir = string("${jalviewDir}/${help_parent_dir}") helpDir = string("${help_dir}") helpSourceDir = string("${helpParentDir}/${helpDir}") relativeBuildDir = file(jalviewDirAbsolutePath).toPath().relativize(buildDir.toPath()) jalviewjsBuildDir = string("${relativeBuildDir}/jalviewjs") jalviewjsSiteDir = string("${jalviewjsBuildDir}/${jalviewjs_site_dir}") if (IN_ECLIPSE) { jalviewjsTransferSiteJsDir = string(jalviewjsSiteDir) } else { jalviewjsTransferSiteJsDir = string("${jalviewjsBuildDir}/tmp/${jalviewjs_site_dir}_js") } jalviewjsTransferSiteLibDir = string("${jalviewjsBuildDir}/tmp/${jalviewjs_site_dir}_lib") jalviewjsTransferSiteSwingJsDir = string("${jalviewjsBuildDir}/tmp/${jalviewjs_site_dir}_swingjs") jalviewjsTransferSiteCoreDir = string("${jalviewjsBuildDir}/tmp/${jalviewjs_site_dir}_core") jalviewjsJalviewCoreHtmlFile = string("") jalviewjsJalviewCoreName = string(jalviewjs_core_name) jalviewjsCoreClasslists = [] jalviewjsJalviewTemplateName = string(jalviewjs_name) jalviewjsJ2sSettingsFileName = string("${jalviewDir}/${jalviewjs_j2s_settings}") jalviewjsJ2sProps = null eclipseWorkspace = null eclipseBinary = string("") eclipseVersion = string("") eclipseDebug = false // ENDEXT } sourceSets { main { java { srcDirs sourceDir outputDir = file(classesDir) } resources { srcDirs resourceDir } jar.destinationDir = file("${jalviewDir}/${packageDir}") compileClasspath = files(sourceSets.main.java.outputDir) compileClasspath += fileTree(dir: "${jalviewDir}/${libDir}", include: ["*.jar"]) runtimeClasspath = compileClasspath } clover { java { 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 testSourceDir outputDir = file("${jalviewDir}/${testOutputDir}") } resources { srcDirs = sourceSets.main.resources.srcDirs } compileClasspath = files( sourceSets.test.java.outputDir ) if (use_clover) { compileClasspath += sourceSets.clover.compileClasspath } else { compileClasspath += files(sourceSets.main.java.outputDir) } 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 } } // clover bits dependencies { if (use_clover) { cloverCompile 'org.openclover:clover:4.3.1' testCompile 'org.openclover:clover:4.3.1' } } configurations { 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 -> // This conditional removes all src classpathentries that a) have already been added or b) aren't "src" or "test". // e.g. this removes the resources dir being copied into bin/main, bin/test AND bin/clover // we add the resources and help/help dirs in as libs afterwards (see below) if (entry.kind == 'src') { if (alreadyAddedSrcPath.getAt(entry.path) || !(entry.path == bareSourceDir || entry.path == bareTestSourceDir)) { removeTheseToo += entry } else { alreadyAddedSrcPath.putAt(entry.path, true) } } } cp.entries.removeAll(removeTheseToo) //cp.entries += new Output("${eclipse_bin_dir}/main") if (file(helpSourceDir).isDirectory()) { cp.entries += new Library(fileReference(helpSourceDir)) } 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, especially if they don't exist return false // groovy "continue" in .any closure } 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") }.any { //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 "continue" in .any 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)) lib.entryAttributes["test"] = "true" cp.entries += lib alreadyAddedLibPath.put(itPath, true) } } } // whenMerged } // 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 if (IN_ECLIPSE) { // Don't want these to be activated if in headless build synchronizationTasks "eclipseSynchronizationTask" autoBuildTasks "eclipseAutoBuildTask" } } task cloverInstr() { // only instrument source, we build test classes as normal inputs.files files (sourceSets.main.allJava) // , fileTree(dir: 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) } } 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) } } // end clover bits compileJava { doFirst { sourceCompatibility = compile_source_compatibility targetCompatibility = compile_target_compatibility options.compilerArgs = additional_compiler_args print ("Setting target compatibility to "+targetCompatibility+"\n") } } compileTestJava { if (use_clover) { dependsOn compileCloverJava classpath += configurations.cloverRuntime } else { classpath += sourceSets.main.runtimeClasspath } doFirst { sourceCompatibility = compile_source_compatibility targetCompatibility = compile_target_compatibility options.compilerArgs = additional_compiler_args print ("Setting target compatibility to "+targetCompatibility+"\n") } } compileCloverJava { doFirst { sourceCompatibility = compile_source_compatibility targetCompatibility = compile_target_compatibility options.compilerArgs += additional_compiler_args print ("Setting target compatibility to "+targetCompatibility+"\n") } classpath += configurations.cloverRuntime } clean { doFirst { delete sourceSets.main.java.outputDir } } cleanTest { doFirst { delete sourceSets.test.java.outputDir delete cloverInstrDir } } // format is a string like date.format("dd MMMM yyyy") def getDate(format) { def date = new Date() return date.format(format) } task setGitVals { def hashStdOut = new ByteArrayOutputStream() exec { commandLine "git", "rev-parse", "--short", "HEAD" standardOutput = hashStdOut ignoreExitValue true } def branchStdOut = new ByteArrayOutputStream() exec { commandLine "git", "rev-parse", "--abbrev-ref", "HEAD" standardOutput = branchStdOut ignoreExitValue true } gitHash = hashStdOut.toString().trim() gitBranch = branchStdOut.toString().trim() outputs.upToDateWhen { false } } task createBuildProperties(type: WriteProperties) { dependsOn setGitVals inputs.dir(sourceDir) inputs.dir(resourceDir) file(buildProperties).getParentFile().mkdirs() 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:"+gitHash+" ["+gitBranch+"]" outputs.file(outputFile) } task cleanBuildingHTML(type: Delete) { doFirst { delete buildingHTML } } task convertBuildingMD(type: Exec) { dependsOn cleanBuildingHTML 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("Cannot find pandoc. Skipping convert building.md to HTML") } } ignoreExitValue true inputs.file(buildingMD) inputs.file(css) outputs.file(buildingHTML) } clean { doFirst { delete buildingHTML } } task syncDocs(type: Sync) { dependsOn convertBuildingMD def syncDir = "${classesDir}/${docDir}" from fileTree("${jalviewDir}/${docDir}") into syncDir } task copyHelp(type: Copy) { def inputDir = helpSourceDir def outputDir = "${classesDir}/${helpDir}" 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 inputs.dir(inputDir) outputs.files(helpFile) outputs.dir(outputDir) } task syncLib(type: Sync) { def syncDir = "${classesDir}/${libDistDir}" from fileTree("${jalviewDir}/${libDistDir}") into syncDir } task syncResources(type: Sync) { from resourceDir include "**/*.*" into "${classesDir}" preserve { include "**" } } task prepare { dependsOn syncResources dependsOn syncDocs dependsOn copyHelp } //testReportDirName = "test-reports" // note that test workingDir will be $jalviewDir test { dependsOn prepare dependsOn compileJava if (use_clover) { dependsOn cloverInstr } 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 targetCompatibility = compile_target_compatibility jvmArgs += additional_compiler_args } task buildIndices(type: JavaExec) { dependsOn copyHelp classpath = sourceSets.main.compileClasspath main = "com.sun.java.help.search.Indexer" workingDir = "${classesDir}/${helpDir}" def argDir = "html" args = [ argDir ] inputs.dir("${workingDir}/${argDir}") outputs.dir("${classesDir}/doc") outputs.dir("${classesDir}/help") outputs.file("${workingDir}/JavaHelpSearch/DOCS") outputs.file("${workingDir}/JavaHelpSearch/DOCS.TAB") outputs.file("${workingDir}/JavaHelpSearch/OFFSETS") outputs.file("${workingDir}/JavaHelpSearch/POSITIONS") outputs.file("${workingDir}/JavaHelpSearch/SCHEMA") outputs.file("${workingDir}/JavaHelpSearch/TMAP") } task compileLinkCheck(type: JavaCompile) { options.fork = true classpath = files("${jalviewDir}/${utilsDir}") 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") } task linkCheck(type: JavaExec) { dependsOn prepare, compileLinkCheck def helpLinksCheckerOutFile = file("${jalviewDir}/${utilsDir}/HelpLinksChecker.out") classpath = files("${jalviewDir}/${utilsDir}") main = "HelpLinksChecker" workingDir = jalviewDir def help = "${classesDir}/${helpDir}" args = [ "${classesDir}/${helpDir}", "-nointernet" ] def outFOS = new FileOutputStream(helpLinksCheckerOutFile, false) // false == don't append def errFOS = outFOS standardOutput = new org.apache.tools.ant.util.TeeOutputStream( outFOS, standardOutput) errorOutput = new org.apache.tools.ant.util.TeeOutputStream( outFOS, errorOutput) inputs.dir("${classesDir}/${helpDir}") outputs.file(helpLinksCheckerOutFile) } // import the pubhtmlhelp target ant.properties.basedir = "${jalviewDir}" ant.properties.helpBuildDir = "${jalviewDirAbsolutePath}/${classes_dir}/${helpDir}" ant.importBuild "${utilsDir}/publishHelp.xml" task cleanPackageDir(type: Delete) { doFirst { delete fileTree(dir: "${jalviewDir}/${packageDir}", include: "*.jar") } } jar { dependsOn linkCheck dependsOn buildIndices dependsOn createBuildProperties manifest { attributes "Main-Class": mainClass, "Permissions": "all-permissions", "Application-Name": "Jalview Desktop", "Codebase": application_codebase } destinationDir = file("${jalviewDir}/${packageDir}") archiveName = rootProject.name+".jar" exclude "cache*/**" exclude "*.jar" exclude "*.jar.*" exclude "**/*.jar" exclude "**/*.jar.*" inputs.dir(classesDir) outputs.file("${jalviewDir}/${packageDir}/${archiveName}") } task copyJars(type: Copy) { from fileTree(dir: classesDir, include: "**/*.jar").files into "${jalviewDir}/${packageDir}" } // doing a Sync instead of Copy as Copy doesn't deal with "outputs" very well task syncJars(type: Sync) { from fileTree(dir: "${jalviewDir}/${libDistDir}", include: "**/*.jar").files into "${jalviewDir}/${packageDir}" preserve { include jar.archiveName } } task makeDist { group = "build" description = "Put all required libraries in dist" // order of "cleanPackageDir", "copyJars", "jar" important! jar.mustRunAfter cleanPackageDir syncJars.mustRunAfter cleanPackageDir dependsOn cleanPackageDir dependsOn syncJars dependsOn jar outputs.dir("${jalviewDir}/${packageDir}") } task cleanDist { dependsOn cleanPackageDir dependsOn cleanTest dependsOn clean } shadowJar { group = "distribution" if (buildDist) { dependsOn makeDist } from ("${jalviewDir}/${libDistDir}") { include("*.jar") } manifest { attributes 'Implementation-Version': JALVIEW_VERSION } mainClassName = shadowJarMainClass mergeServiceFiles() classifier = "all-"+JALVIEW_VERSION+"-j"+JAVA_VERSION minimize() } 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 } def getdownWebsiteResourceFilenames = [] def getdownTextString = "" def getdownResourceDir = getdownResourceDir def getdownAppDir = getdownAppDir def getdownResourceFilenames = [] doFirst { // clean the getdown website and files dir before creating getdown folders delete getdownWebsiteDir delete getdownFilesDir copy { from buildProperties rename(build_properties_file, getdown_build_properties) into getdownAppDir } getdownWebsiteResourceFilenames += "${getdown_app_dir}/${getdown_build_properties}" // go through properties looking for getdown_txt_... def props = project.properties.sort { it.key } 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) { if (prop.startsWith("getdown_txt_multi_")) { def key = prop.substring(18) val.split(",").each{ v -> def line = "${key} = ${v}\n" getdownTextString += line } } else { // file values rationalised if (val.indexOf('/') > -1 || prop.startsWith("getdown_txt_resource")) { def r = null if (val.indexOf('/') == 0) { // absolute path r = file(val) } else if (val.indexOf('/') > 0) { // relative path (relative to jalviewDir) r = file( "${jalviewDir}/${val}" ) } if (r.exists()) { val = "${getdown_resource_dir}/" + r.getName() getdownWebsiteResourceFilenames += val getdownResourceFilenames += r.getPath() } } if (! prop.startsWith("getdown_txt_resource")) { def line = prop.substring(12) + " = ${val}\n" getdownTextString += line } } } } getdownWebsiteResourceFilenames.each{ filename -> getdownTextString += "resource = ${filename}\n" } getdownResourceFilenames.each{ filename -> copy { from filename into getdownResourceDir } } def codeFiles = [] fileTree(file(packageDir)).each{ f -> if (f.isDirectory()) { def files = fileTree(dir: f, include: ["*"]).getFiles() codeFiles += files } else if (f.exists()) { codeFiles += f } } codeFiles.sort().each{f -> def name = f.getName() def line = "code = ${getdown_app_dir}/${name}\n" getdownTextString += line copy { from f.getPath() into getdownAppDir } } // 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 name = f.getName() def line = "code = ${getdown_j11lib_dir}/${name}\n" getdownTextString += line copy { from f.getPath() into getdownJ11libDir } } } */ // 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("${getdownWebsiteDir}/getdown.txt") getdown_txt.write(getdownTextString) def launch_jvl = file("${getdownWebsiteDir}/${getdown_launch_jvl}") launch_jvl.write("appbase="+props.get("getdown_txt_appbase")) copy { from getdownLauncher rename(file(getdownLauncher).getName(), getdown_launcher_new) into getdownWebsiteDir } copy { from getdownLauncher if (file(getdownLauncher).getName() != getdown_launcher) { rename(file(getdownLauncher).getName(), getdown_launcher) } into getdownWebsiteDir } 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 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 getdownResourceDir into "${getdownFilesDir}/${getdown_resource_dir}" } } if (buildDist) { inputs.dir("${jalviewDir}/${packageDir}") } outputs.dir(getdownWebsiteDir) outputs.dir(getdownFilesDir) } task getdownDigest(type: JavaExec) { group = "distribution" description = "Digest the getdown website folder" dependsOn getdownWebsite doFirst { classpath = files("${getdownWebsiteDir}/${getdown_launcher}") } main = "com.threerings.getdown.tools.Digester" args getdownWebsiteDir inputs.dir(getdownWebsiteDir) outputs.file("${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 { doFirst { delete getdownWebsiteDir delete getdownFilesDir } } install4j { if (file(install4jHomeDir).exists()) { // good to go! } else if (file(System.getProperty("user.home")+"/buildtools/install4j").exists()) { install4jHomeDir = System.getProperty("user.home")+"/buildtools/install4j" } else if (file("/Applications/install4j.app/Contents/Resources/app").exists()) { install4jHomeDir = "/Applications/install4j.app/Contents/Resources/app" } installDir(file(install4jHomeDir)) mediaTypes = Arrays.asList(install4j_media_types.split(",")) if (install4j_faster.equals("true")) { faster = true } } task copyInstall4jTemplate(type: Copy) { dependsOn setGitVals def install4jTemplateMd5 = "" def digest = MessageDigest.getInstance("MD5") digest.update( (file("${install4jDir}/${install4j_template}").text + file("${install4jDir}/${install4j_info_plist_file_associations}").text + file("${install4jDir}/${install4j_installer_file_associations}").text).bytes) def filesMd5 = new BigInteger(1, digest.digest()).toString(16) if (filesMd5.length() >= 8) { filesMd5 = filesMd5.substring(0,8) } install4jTemplateMd5 += filesMd5 install4jTemplateMd5 += "_${gitHash}" inputs.file("${install4jDir}/${install4j_template}") inputs.file("${install4jDir}/${install4j_info_plist_file_associations}") inputs.file("${install4jDir}/${install4j_installer_file_associations}") outputs.files(install4jConfFile) from (install4jDir) { include install4j_template rename (install4j_template, install4jConfFileName) filter(ReplaceTokens, beginToken: '', endToken: '', tokens: [ '0000000000': JAVA_MIN_VERSION, '9999999999': JAVA_MAX_VERSION ] ) 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': install4j_info_plist_file_associations, 'INSTALLER_TEMPLATE_MD5': install4jTemplateMd5, 'COPYRIGHT_MESSAGE': install4j_copyright_message, 'MACOS_BUNDLE_ID': install4j_macOS_bundle_id, '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 doLast { // include file associations in installer def installerFileAssociationsXml = file("${install4jDir}/${install4j_installer_file_associations}").text ant.replaceregexp( byline: false, flags: "s", match: '', replace: installerFileAssociationsXml, file: install4jConfFile ) /* // include uninstaller applescript app files in dmg def installerDMGUninstallerXml = file("$install4jDir/$install4j_DMG_uninstaller_app_files").text ant.replaceregexp( byline: false, flags: "s", match: '', replace: installerDMGUninstallerXml, file: install4jConfFile ) */ } } clean { doFirst { delete install4jConfFile } } task installers(type: com.install4j.gradle.Install4jTask) { group = "distribution" description = "Create the install4j installers" dependsOn getdown dependsOn copyInstall4jTemplate projectFile = file(install4jConfFile) variables = [majorVersion: version.substring(2, 11), build: 001, OSX_KEYSTORE: OSX_KEYSTORE, JSIGN_SH: JSIGN_SH] destination = "${jalviewDir}/${install4j_build_dir}/${JAVA_VERSION}" buildSelected = true if (OSX_KEYPASS) { macKeystorePassword=OSX_KEYPASS } doFirst { println("Using projectFile "+projectFile) } inputs.dir(getdownWebsiteDir) inputs.file(install4jConfFile) inputs.dir(macosJavaVMDir) inputs.dir(windowsJavaVMDir) outputs.dir("${jalviewDir}/${install4j_build_dir}/${JAVA_VERSION}") } 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("${classesDir}/${helpDir}") outputs.dir("${buildDir}/distributions/${helpDir}") } // LARGE AMOUNT OF JALVIEWJS STUFF DELETED HERE task eclipseAutoBuildTask {} task eclipseSynchronizationTask {}