+/* Convention for properties. Read from gradle.properties, use lower_case_underlines for property names.
+ * For properties set within build.gradle, use camelCaseNoSpace.
+ */
import org.apache.tools.ant.filters.ReplaceTokens
import org.gradle.internal.os.OperatingSystem
import org.gradle.plugins.ide.internal.generator.PropertiesPersistableConfigurationObject
mavenCentral()
mavenLocal()
}
- dependencies {
- classpath 'org.openclover:clover:4.4.1'
- }
}
}
}
+ ////
+ // Import releaseProps from the RELEASE file
+ // or a file specified via JALVIEW_RELEASE_FILE if defined
+ // Expect jalview.version and target release branch in jalview.release
+ def releaseProps = new Properties();
+ def releasePropFile = findProperty("JALVIEW_RELEASE_FILE");
+ def defaultReleasePropFile = "${jalviewDirAbsolutePath}/RELEASE";
+ try {
+ (new File(releasePropFile!=null ? releasePropFile : defaultReleasePropFile)).withInputStream {
+ releaseProps.load(it)
+ }
+ } catch (Exception fileLoadError) {
+ throw new Error("Couldn't load release properties file "+(releasePropFile==null ? defaultReleasePropFile : "from custom location: releasePropFile"),fileLoadError);
+ }
+ ////
+ // Set JALVIEW_VERSION if it is not already set
+ if (findProperty(JALVIEW_VERSION)==null || "".equals(JALVIEW_VERSION)) {
+ JALVIEW_VERSION = releaseProps.get("jalview.version")
+ }
+
// this property set when running Eclipse headlessly
j2sHeadlessBuildProperty = string("net.sf.j2s.core.headlessbuild")
// this property set by Eclipse
J2S_ENABLED = (project.hasProperty('j2s.compiler.status') && project['j2s.compiler.status'] != null && project['j2s.compiler.status'] == "enable")
if (J2S_ENABLED) {
println("J2S ENABLED")
- }
-
+ }
/* *-/
System.properties.sort { it.key }.each {
key, val -> println("SYSTEM PROPERTY ${key}='${val}'")
sourceDir = string("${jalviewDir}/${bareSourceDir}")
resourceDir = string("${jalviewDir}/${resource_dir}")
bareTestSourceDir = string(test_source_dir)
- testSourceDir = string("${jalviewDir}/${bareTestSourceDir}")
+ testDir = string("${jalviewDir}/${bareTestSourceDir}")
- // clover
- cloverInstrDir = file("${buildDir}/${cloverSourcesInstrDir}")
- cloverDb = string("${buildDir}/clover/clover.db")
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
+ // clover
+ useClover = clover.equals("true")
+ cloverBuildDir = "${buildDir}/clover"
+ cloverInstrDir = file("${cloverBuildDir}/clover-instr")
+ cloverClassesDir = file("${cloverBuildDir}/clover-classes")
+ cloverReportDir = file("${buildDir}/reports/clover")
+ cloverTestInstrDir = file("${cloverBuildDir}/clover-test-instr")
+ cloverTestClassesDir = file("${cloverBuildDir}/clover-test-classes")
+ //cloverTestClassesDir = cloverClassesDir
+ cloverDb = string("${cloverBuildDir}/clover.db")
+
+ resourceClassesDir = useClover ? cloverClassesDir : classesDir
+
+ testSourceDir = useClover ? cloverTestInstrDir : testDir
+ testClassesDir = useClover ? cloverTestClassesDir : "${jalviewDir}/${test_output_dir}"
getdownWebsiteDir = string("${jalviewDir}/${getdown_website_dir}/${JAVA_VERSION}")
buildDist = true
getdownAppBase = string("${bamboo_channelbase}/${bamboo_planKey}${bamboo_getdown_channel_suffix}/${JAVA_VERSION}")
jvlChannelName += "_${getdownChannelName}"
// automatically add the test group Not-bamboo for exclusion
- if ("".equals(testngExcludedGroups)) {
- testngExcludedGroups = "Not-bamboo"
+ if ("".equals(testng_excluded_groups)) {
+ testng_excluded_groups = "Not-bamboo"
}
install4jExtraScheme = "jalviewb"
break
case "RELEASE":
getdownAppDistDir = getdown_app_dir_release
reportRsyncCommand = true
- // Don't ignore transpile errors for release build
- if (jalviewjs_ignore_transpile_errors.equals("true")) {
- jalviewjs_ignore_transpile_errors = "false"
- println("Setting jalviewjs_ignore_transpile_errors to 'false'")
- }
install4jSuffix = ""
install4jDSStore = "DS_Store"
install4jDMGBackgroundImage = "jalview_dmg_background.png"
getdownChannelName = CHANNEL.toLowerCase()+"/${JALVIEW_VERSION}"
getdownDir = string("${getdownChannelName}/${JAVA_VERSION}")
getdownAppBase = string("${getdown_channel_base}/${getdownDir}")
- if (!file("${ARCHIVEDIR}/${packageDir}").exists()) {
+ if (!file("${ARCHIVEDIR}/${package_dir}").exists()) {
throw new GradleException("Must provide an ARCHIVEDIR value to produce an archive distribution")
} else {
- packageDir = string("${ARCHIVEDIR}/${packageDir}")
- buildProperties = string("${buildDir}/archive/${build_properties_file}")
+ package_dir = string("${ARCHIVEDIR}/${package_dir}")
+ buildProperties = string("${ARCHIVEDIR}/${classes_dir}/${build_properties_file}")
buildDist = false
}
reportRsyncCommand = true
getdownChannelName = string("archive/${JALVIEW_VERSION}")
getdownDir = string("${getdownChannelName}/${JAVA_VERSION}")
getdownAppBase = file(getdownWebsiteDir).toURI().toString()
- if (!file("${ARCHIVEDIR}/${packageDir}").exists()) {
+ if (!file("${ARCHIVEDIR}/${package_dir}").exists()) {
throw new GradleException("Must provide an ARCHIVEDIR value to produce an archive distribution")
} else {
- packageDir = string("${ARCHIVEDIR}/${packageDir}")
- buildProperties = string("${buildDir}/archive/${build_properties_file}")
+ package_dir = string("${ARCHIVEDIR}/${package_dir}")
+ buildProperties = string("${ARCHIVEDIR}/${classes_dir}/${build_properties_file}")
buildDist = false
}
reportRsyncCommand = true
case "DEVELOP":
reportRsyncCommand = true
+
+ // DEVELOP-RELEASE is usually associated with a Jalview release series so set the version
+ JALVIEW_VERSION=JALVIEW_VERSION+"-develop"
+
+ install4jSuffix = "Develop"
install4jDSStore = "DS_Store-DEVELOP"
install4jDMGBackgroundImage = "jalview_dmg_background-DEVELOP.png"
install4jExtraScheme = "jalviewd"
jalviewjs_ignore_transpile_errors = "false"
println("Setting jalviewjs_ignore_transpile_errors to 'false'")
}
- JALVIEW_VERSION = "TEST"
+ JALVIEW_VERSION = JALVIEW_VERSION+"-test"
install4jSuffix = "Test"
install4jDSStore = "DS_Store-TEST-RELEASE"
install4jDMGBackgroundImage = "jalview_dmg_background-TEST.png"
case ~/^SCRATCH(|-[-\w]*)$/:
getdownChannelName = CHANNEL
+ JALVIEW_VERSION = JALVIEW_VERSION+"-"+CHANNEL
+
getdownDir = string("${getdownChannelName}/${JAVA_VERSION}")
getdownAppBase = string("${getdown_channel_base}/${getdownDir}")
reportRsyncCommand = true
break
case "LOCAL":
+ JALVIEW_VERSION = "TEST"
getdownAppBase = file(getdownWebsiteDir).toURI().toString()
getdownLauncher = string("${jalviewDir}/${getdown_lib_dir}/${getdown_launcher_local}")
install4jExtraScheme = "jalviewl"
- buildingHTML = string("${jalviewDir}/${docDir}/building.html")
- helpFile = string("${classesDir}/${help_dir}/help.jhm")
+ buildingHTML = string("${jalviewDir}/${doc_dir}/building.html")
+ helpFile = string("${resourceClassesDir}/${help_dir}/help.jhm")
helpParentDir = string("${jalviewDir}/${help_parent_dir}")
helpSourceDir = string("${helpParentDir}/${help_dir}")
srcDirs += helpParentDir
}
- jar.destinationDir = file("${jalviewDir}/${packageDir}")
+ jar.destinationDir = file("${jalviewDir}/${package_dir}")
compileClasspath = files(sourceSets.main.java.outputDir)
- //compileClasspath += files(sourceSets.main.resources.srcDirs)
compileClasspath += fileTree(dir: "${jalviewDir}/${libDir}", include: ["*.jar"])
runtimeClasspath = compileClasspath
clover {
java {
- srcDirs = [ cloverInstrDir ]
- outputDir = file("${buildDir}/${cloverClassesDir}")
+ srcDirs cloverInstrDir
+ outputDir = 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 = files( sourceSets.clover.java.outputDir )
+ //compileClasspath += files( testClassesDir )
compileClasspath += fileTree(dir: "${jalviewDir}/${libDir}", include: ["*.jar"])
+ compileClasspath += fileTree(dir: "${jalviewDir}/${clover_lib_dir}", include: ["*.jar"])
+ compileClasspath += fileTree(dir: "${jalviewDir}/${utils_dir}/testnglibs", include: ["**/*.jar"])
runtimeClasspath = compileClasspath
}
test {
java {
srcDirs testSourceDir
- outputDir = file("${jalviewDir}/${testOutputDir}")
+ outputDir = file(testClassesDir)
}
resources {
- srcDirs = sourceSets.main.resources.srcDirs
+ srcDirs = useClover ? sourceSets.clover.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"])
+ compileClasspath += useClover ? sourceSets.clover.compileClasspath : sourceSets.main.compileClasspath
+ compileClasspath += fileTree(dir: "${jalviewDir}/${utils_dir}/testnglibs", include: ["**/*.jar"])
runtimeClasspath = compileClasspath
}
-}
-
-// clover bits
-dependencies {
- if (use_clover) {
- cloverCompile 'org.openclover:clover:4.4.1'
- testCompile 'org.openclover:clover:4.4.1'
- }
-}
-
-
-configurations {
- cloverRuntime
- cloverRuntime.extendsFrom cloverCompile
}
javaRuntimeName = eclipseJavaRuntimeName
// add in jalview project specific properties/preferences into eclipse core preferences
- // and also the codestyle XML file
file {
withProperties { props ->
def jalview_prefs = new Properties()
/* end of eclipse preferences hack */
-task cloverInstr {
- // only instrument source, we build test classes as normal
- inputs.files files (sourceSets.main.allJava,sourceSets.test.allJava) // , fileTree(dir:"$jalviewDir/$testSourceDir", include: ["**/*.java"]))
- outputs.dir cloverInstrDir
+// clover bits
+
+task cleanClover {
doFirst {
- delete cloverInstrDir
- def argsList = [
- "--initstring",
- cloverDb,
- "-d",
- cloverInstrDir.getPath(),
- ]
- argsList.addAll(
- inputs.files.files.collect(
- { file -> file.absolutePath }
- )
+ delete cloverBuildDir
+ delete cloverReportDir
+ }
+}
+
+
+task cloverInstrJava(type: JavaExec) {
+ group = "Verification"
+ description = "Create clover instrumented source java files"
+
+ dependsOn cleanClover
+
+ inputs.files(sourceSets.main.allJava)
+ outputs.dir(cloverInstrDir)
+
+ //classpath = fileTree(dir: "${jalviewDir}/${clover_lib_dir}", include: ["*.jar"])
+ classpath = sourceSets.clover.compileClasspath
+ main = "com.atlassian.clover.CloverInstr"
+
+ def argsList = [
+ "--encoding",
+ "UTF-8",
+ "--initstring",
+ cloverDb,
+ "--destdir",
+ cloverInstrDir.getPath(),
+ ]
+ def srcFiles = sourceSets.main.allJava.files
+ argsList.addAll(
+ srcFiles.collect(
+ { file -> file.absolutePath }
)
- String[] args = argsList.toArray()
- println("About to instrument "+args.length +" files")
- com.atlassian.clover.CloverInstr.mainImpl(args)
+ )
+ args argsList.toArray()
+
+ doFirst {
+ delete cloverInstrDir
+ println("Clover: About to instrument "+srcFiles.size() +" files")
+ }
+}
+
+
+task cloverInstrTests(type: JavaExec) {
+ group = "Verification"
+ description = "Create clover instrumented source test files"
+
+ dependsOn cleanClover
+
+ inputs.files(testDir)
+ outputs.dir(cloverTestInstrDir)
+
+ classpath = sourceSets.clover.compileClasspath
+ main = "com.atlassian.clover.CloverInstr"
+
+ def argsList = [
+ "--encoding",
+ "UTF-8",
+ "--initstring",
+ cloverDb,
+ "--srcdir",
+ testDir,
+ "--destdir",
+ cloverTestInstrDir.getPath(),
+ ]
+ args argsList.toArray()
+
+ doFirst {
+ delete cloverTestInstrDir
+ println("Clover: About to instrument test files")
}
}
+task cloverInstr {
+ group = "Verification"
+ description = "Create clover instrumented all source files"
+
+ dependsOn cloverInstrJava
+ dependsOn cloverInstrTests
+}
+
+
cloverClasses.dependsOn cloverInstr
-task cloverReport {
+task cloverConsoleReport(type: JavaExec) {
group = "Verification"
- description = "Creates the Clover report"
- inputs.dir "${buildDir}/clover"
- outputs.dir "${reportsDir}/clover"
+ description = "Creates clover console report"
+
onlyIf {
file(cloverDb).exists()
}
- doFirst {
- def argsList = [
- "--initstring",
- cloverDb,
- "-o",
- "${reportsDir}/clover"
- ]
- String[] args = argsList.toArray()
- com.atlassian.clover.reporters.html.HtmlReporter.runReport(args)
- // and generate ${reportsDir}/clover/clover.xml
- args = [
- "--initstring",
- cloverDb,
- "-o",
- "${reportsDir}/clover/clover.xml"
- ].toArray()
- com.atlassian.clover.reporters.xml.XMLReporter.runReport(args)
+ inputs.dir cloverClassesDir
+
+ classpath = sourceSets.clover.runtimeClasspath
+ main = "com.atlassian.clover.reporters.console.ConsoleReporter"
+
+ if (cloverreport_mem.length() > 0) {
+ maxHeapSize = cloverreport_mem
+ }
+ if (cloverreport_jvmargs.length() > 0) {
+ jvmArgs Arrays.asList(cloverreport_jvmargs.split(" "))
}
+
+ def argsList = [
+ "--alwaysreport",
+ "--initstring",
+ cloverDb,
+ "--unittests"
+ ]
+
+ args argsList.toArray()
}
-compileCloverJava {
+task cloverHtmlReport(type: JavaExec) {
+ group = "Verification"
+ description = "Creates clover HTML report"
- doFirst {
- sourceCompatibility = compile_source_compatibility
- targetCompatibility = compile_target_compatibility
- options.compilerArgs += additional_compiler_args
- print ("Setting target compatibility to "+targetCompatibility+"\n")
+ onlyIf {
+ file(cloverDb).exists()
+ }
+
+ def cloverHtmlDir = cloverReportDir
+ inputs.dir cloverClassesDir
+ outputs.dir cloverHtmlDir
+
+ classpath = sourceSets.clover.runtimeClasspath
+ main = "com.atlassian.clover.reporters.html.HtmlReporter"
+
+ if (cloverreport_mem.length() > 0) {
+ maxHeapSize = cloverreport_mem
+ }
+ if (cloverreport_jvmargs.length() > 0) {
+ jvmArgs Arrays.asList(cloverreport_jvmargs.split(" "))
}
- classpath += configurations.cloverRuntime
+
+ def argsList = [
+ "--alwaysreport",
+ "--initstring",
+ cloverDb,
+ "--outputdir",
+ cloverHtmlDir
+ ]
+
+ if (cloverreport_html_options.length() > 0) {
+ argsList += cloverreport_html_options.split(" ")
+ }
+
+ args argsList.toArray()
}
-task cleanClover {
- doFirst {
- delete cloverInstrDir
- delete cloverDb
+task cloverXmlReport(type: JavaExec) {
+ group = "Verification"
+ description = "Creates clover XML report"
+
+ onlyIf {
+ file(cloverDb).exists()
}
+
+ def cloverXmlFile = "${cloverReportDir}/clover.xml"
+ inputs.dir cloverClassesDir
+ outputs.file cloverXmlFile
+
+ classpath = sourceSets.clover.runtimeClasspath
+ main = "com.atlassian.clover.reporters.xml.XMLReporter"
+
+ if (cloverreport_mem.length() > 0) {
+ maxHeapSize = cloverreport_mem
+ }
+ if (cloverreport_jvmargs.length() > 0) {
+ jvmArgs Arrays.asList(cloverreport_jvmargs.split(" "))
+ }
+
+ def argsList = [
+ "--alwaysreport",
+ "--initstring",
+ cloverDb,
+ "--outfile",
+ cloverXmlFile
+ ]
+
+ if (cloverreport_xml_options.length() > 0) {
+ argsList += cloverreport_xml_options.split(" ")
+ }
+
+ args argsList.toArray()
}
-// end clover bits
-compileJava {
+task cloverReport {
+ group = "Verification"
+ description = "Creates clover reports"
+
+ dependsOn cloverXmlReport
+ dependsOn cloverHtmlReport
+}
+
+
+compileCloverJava {
doFirst {
sourceCompatibility = compile_source_compatibility
targetCompatibility = compile_target_compatibility
- options.compilerArgs = additional_compiler_args
+ options.compilerArgs += additional_compiler_args
print ("Setting target compatibility to "+targetCompatibility+"\n")
}
+ //classpath += configurations.cloverRuntime
+}
+// end clover bits
+
+
+compileJava {
+ // JBP->BS should the print statement in doFirst refer to compile_target_compatibility ?
+ sourceCompatibility = compile_source_compatibility
+ targetCompatibility = compile_target_compatibility
+ options.compilerArgs = additional_compiler_args
+ options.encoding = "UTF-8"
+ doFirst {
+ print ("Setting target compatibility to "+compile_target_compatibility+"\n")
+ }
}
compileTestJava {
- if (use_clover) {
- dependsOn compileCloverJava
- classpath += configurations.cloverRuntime
- } else {
- classpath += sourceSets.main.runtimeClasspath
- }
+ sourceCompatibility = compile_source_compatibility
+ targetCompatibility = compile_target_compatibility
+ options.compilerArgs = additional_compiler_args
doFirst {
- sourceCompatibility = compile_source_compatibility
- targetCompatibility = compile_target_compatibility
- options.compilerArgs = additional_compiler_args
print ("Setting target compatibility to "+targetCompatibility+"\n")
}
}
task convertBuildingMD(type: Exec) {
dependsOn cleanBuildingHTML
- def buildingMD = "${jalviewDir}/${docDir}/building.md"
- def css = "${jalviewDir}/${docDir}/github.css"
+ def buildingMD = "${jalviewDir}/${doc_dir}/building.md"
+ def css = "${jalviewDir}/${doc_dir}/github.css"
def pandoc = null
pandoc_exec.split(",").each {
task syncDocs(type: Sync) {
dependsOn convertBuildingMD
- def syncDir = "${classesDir}/${docDir}"
- from fileTree("${jalviewDir}/${docDir}")
+ def syncDir = "${classesDir}/${doc_dir}"
+ from fileTree("${jalviewDir}/${doc_dir}")
into syncDir
}
task copyHelp(type: Copy) {
def inputDir = helpSourceDir
- def outputDir = "${classesDir}/${help_dir}"
+ def outputDir = "${resourceClassesDir}/${help_dir}"
from(inputDir) {
exclude '**/*.gif'
exclude '**/*.jpg'
task syncLib(type: Sync) {
- def syncDir = "${classesDir}/${libDistDir}"
+ def syncDir = "${resourceClassesDir}/${libDistDir}"
from fileTree("${jalviewDir}/${libDistDir}")
into syncDir
}
dependsOn createBuildProperties
from resourceDir
include "**/*.*"
- into "${classesDir}"
+ into "${resourceClassesDir}"
preserve {
include "**"
}
//testReportDirName = "test-reports" // note that test workingDir will be $jalviewDir
test {
dependsOn prepare
- dependsOn compileJava
- if (use_clover) {
- dependsOn cloverInstr
- }
+ //dependsOn compileJava ////? DELETE
- if (use_clover) {
- print("Running tests " + (use_clover?"WITH":"WITHOUT") + " clover [clover="+use_clover+"]\n")
+ if (useClover) {
+ dependsOn cloverClasses
+ } else { //?
+ dependsOn compileJava //?
}
useTestNG() {
- includeGroups testngGroups
- excludeGroups testngExcludedGroups
+ includeGroups testng_groups
+ excludeGroups testng_excluded_groups
preserveOrder true
useDefaultListeners=true
}
targetCompatibility = compile_target_compatibility
jvmArgs += additional_compiler_args
+ doFirst {
+ if (useClover) {
+ println("Running tests " + (useClover?"WITH":"WITHOUT") + " clover")
+ }
+ }
}
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"])
+ classpath = files("${jalviewDir}/${utils_dir}")
+ destinationDir = file("${jalviewDir}/${utils_dir}")
+ source = fileTree(dir: "${jalviewDir}/${utils_dir}", 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")
+ inputs.file("${jalviewDir}/${utils_dir}/HelpLinksChecker.java")
+ inputs.file("${jalviewDir}/${utils_dir}/HelpLinksChecker.java")
+ outputs.file("${jalviewDir}/${utils_dir}/HelpLinksChecker.class")
+ outputs.file("${jalviewDir}/${utils_dir}/BufferedLineReader.class")
}
task linkCheck(type: JavaExec) {
dependsOn prepare, compileLinkCheck
- def helpLinksCheckerOutFile = file("${jalviewDir}/${utilsDir}/HelpLinksChecker.out")
- classpath = files("${jalviewDir}/${utilsDir}")
+ def helpLinksCheckerOutFile = file("${jalviewDir}/${utils_dir}/HelpLinksChecker.out")
+ classpath = files("${jalviewDir}/${utils_dir}")
main = "HelpLinksChecker"
workingDir = jalviewDir
args = [ "${classesDir}/${help_dir}", "-nointernet" ]
// import the pubhtmlhelp target
ant.properties.basedir = "${jalviewDir}"
ant.properties.helpBuildDir = "${jalviewDirAbsolutePath}/${classes_dir}/${help_dir}"
-ant.importBuild "${utilsDir}/publishHelp.xml"
+ant.importBuild "${utils_dir}/publishHelp.xml"
task cleanPackageDir(type: Delete) {
doFirst {
- delete fileTree(dir: "${jalviewDir}/${packageDir}", include: "*.jar")
+ delete fileTree(dir: "${jalviewDir}/${package_dir}", include: "*.jar")
}
}
dependsOn createBuildProperties
manifest {
- attributes "Main-Class": mainClass,
+ attributes "Main-Class": main_class,
"Permissions": "all-permissions",
"Application-Name": "Jalview Desktop",
"Codebase": application_codebase
}
- destinationDir = file("${jalviewDir}/${packageDir}")
+ destinationDir = file("${jalviewDir}/${package_dir}")
archiveName = rootProject.name+".jar"
exclude "cache*/**"
exclude "**/*.jar.*"
inputs.dir(classesDir)
- outputs.file("${jalviewDir}/${packageDir}/${archiveName}")
+ outputs.file("${jalviewDir}/${package_dir}/${archiveName}")
}
task copyJars(type: Copy) {
from fileTree(dir: classesDir, include: "**/*.jar").files
- into "${jalviewDir}/${packageDir}"
+ into "${jalviewDir}/${package_dir}"
}
// 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}"
+ into "${jalviewDir}/${package_dir}"
preserve {
include jar.archiveName
}
dependsOn cleanPackageDir
dependsOn syncJars
dependsOn jar
- outputs.dir("${jalviewDir}/${packageDir}")
+ outputs.dir("${jalviewDir}/${package_dir}")
}
manifest {
attributes 'Implementation-Version': JALVIEW_VERSION
}
- mainClassName = shadowJarMainClass
+ mainClassName = shadow_jar_main_class
mergeServiceFiles()
classifier = "all-"+JALVIEW_VERSION+"-j"+JAVA_VERSION
minimize()
}
def codeFiles = []
- fileTree(file(packageDir)).each{ f ->
+ fileTree(file(package_dir)).each{ f ->
if (f.isDirectory()) {
def files = fileTree(dir: f, include: ["*"]).getFiles()
codeFiles += files
// 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"
+ getdownTextString += "class = ${main_class}\n"
def getdown_txt = file("${getdownWebsiteDir}/getdown.txt")
getdown_txt.write(getdownTextString)
}
if (buildDist) {
- inputs.dir("${jalviewDir}/${packageDir}")
+ inputs.dir("${jalviewDir}/${package_dir}")
}
outputs.dir(getdownWebsiteDir)
outputs.dir(getdownFilesDir)
// a helper task to allow getdown digest of any dir: `gradle getdownDigestDir -PDIGESTDIR=/path/to/my/random/getdown/dir
task getdownDigestDir(type: JavaExec) {
+ group "Help"
+ description "A task to run a getdown Digest on a dir with getdown.txt. Provide a DIGESTDIR property via -PDIGESTDIR=..."
+
def digestDirPropertyName = "DIGESTDIR"
- description = "Digest a local dir (-P${digestDirPropertyName}=...) for getdown"
doFirst {
classpath = files(getdownLauncher)
def digestDir = findProperty(digestDirPropertyName)
}
+tasks.withType(JavaCompile) {
+ options.encoding = 'UTF-8'
+}
+
+
clean {
doFirst {
delete getdownWebsiteDir
// NB we're deleting the /other/ one!
// Also remove the examples subdir from non-release versions
def customizedIdToDelete = "PROGRAM_GROUP_RELEASE"
- if (CHANNEL=="RELEASE") {
+ // 2.11.1.0 NOT releasing with the Examples folder in the Program Group
+ if (false && CHANNEL=="RELEASE") { // remove 'false && ' to include Examples folder in RELEASE channel
customizedIdToDelete = "PROGRAM_GROUP_NON_RELEASE"
} else {
// remove the examples subdir from Full File Set
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.exe"
+ eclipseRoot += "/eclipse"
}
- eclipseBinary = "${eclipseRoot}/eclipse"
+ eclipseBinary = "${eclipseRoot}/eclipse.exe"
eclipseProduct = "${eclipseRoot}/.eclipseproduct"
} else { // linux or unix
if (file("${eclipseRoot}/eclipse").isDirectory() && file("${eclipseRoot}/eclipse/.eclipseproduct").exists()) {
eclipseRoot += "/eclipse"
+println("eclipseDir exists")
}
eclipseBinary = "${eclipseRoot}/eclipse"
eclipseProduct = "${eclipseRoot}/.eclipseproduct"
def coreBottom = file(suffixFile)
coreFile.getParentFile().mkdirs()
coreFile.createNewFile()
- coreFile.write( coreTop.text )
+ coreFile.write( coreTop.getText("UTF-8") )
list.each {
f ->
if (f.exists()) {
- def t = f.text
+ def t = f.getText("UTF-8")
t.replaceAll("Clazz\\.([^_])","Clazz_${1}")
coreFile.append( t )
} else {
logOutFile.append(msg+"\n")
}
}
- coreFile.append( coreBottom.text )
+ coreFile.append( coreBottom.getText("UTF-8") )
msg = "Generating ${zjsfile}"
println(msg)
def logErrFOS = logOutFOS
javaexec {
- classpath = files(["${jalviewDir}/tools/closure_compiler.jar"])
- args = [ "--js", jsfile, "--js_output_file", zjsfile ]
+ classpath = files(["${jalviewDir}/${jalviewjs_closure_compiler}"])
+ main = "com.google.javascript.jscomp.CommandLineRunner"
+ jvmArgs = [ "-Dfile.encoding=UTF-8" ]
+ args = [ "--compilation_level", "SIMPLE_OPTIMIZATIONS", "--warning_level", "QUIET", "--charset", "UTF-8", "--js", jsfile, "--js_output_file", zjsfile ]
maxHeapSize = "2g"
msg = "\nRunning '"+commandLine.join(' ')+"'\n"
beginToken: '_',
endToken: '_',
tokens: [
- 'MAIN': '"'+mainClass+'"',
+ 'MAIN': '"'+main_class+'"',
'CODE': "null",
'NAME': jalviewjsJalviewTemplateName+" [core ${coreName}]",
'COREKEY': jalviewjs_core_key,