1 /* Convention for properties. Read from gradle.properties, use lower_case_underlines for property names.
2 * For properties set within build.gradle, use camelCaseNoSpace.
4 import org.apache.tools.ant.filters.ReplaceTokens
5 import org.gradle.internal.os.OperatingSystem
6 import org.gradle.plugins.ide.internal.generator.PropertiesPersistableConfigurationObject
7 import org.gradle.api.internal.PropertiesTransformer
8 import org.gradle.util.ConfigureUtil
9 import org.gradle.plugins.ide.eclipse.model.Output
10 import org.gradle.plugins.ide.eclipse.model.Library
11 import java.security.MessageDigest
12 import groovy.transform.ExternalizeMethods
13 import groovy.util.XmlParser
14 import groovy.xml.XmlUtil
15 import com.vladsch.flexmark.util.ast.Node
16 import com.vladsch.flexmark.html.HtmlRenderer
17 import com.vladsch.flexmark.parser.Parser
18 import com.vladsch.flexmark.util.data.MutableDataSet
19 import com.vladsch.flexmark.ext.gfm.tasklist.TaskListExtension
20 import com.vladsch.flexmark.ext.tables.TablesExtension
21 import com.vladsch.flexmark.ext.gfm.strikethrough.StrikethroughExtension
22 import com.vladsch.flexmark.ext.autolink.AutolinkExtension
23 import com.vladsch.flexmark.ext.anchorlink.AnchorLinkExtension
24 import com.vladsch.flexmark.ext.toc.TocExtension
32 classpath "com.vladsch.flexmark:flexmark-all:0.62.0"
41 id "com.diffplug.gradle.spotless" version "3.28.0"
42 id 'com.github.johnrengelman.shadow' version '4.0.3'
43 id 'com.install4j.gradle' version '8.0.4'
44 id 'com.dorongold.task-tree' version '1.5' // only needed to display task dependency tree with gradle task1 [task2 ...] taskTree
45 id 'com.palantir.git-version' version '0.12.3'
55 // in ext the values are cast to Object. Ensure string values are cast as String (and not GStringImpl) for later use
56 def string(Object o) {
57 return o == null ? "" : o.toString()
62 jalviewDirAbsolutePath = file(jalviewDir).getAbsolutePath()
63 jalviewDirRelativePath = jalviewDir
65 // local build environment properties
66 // can be "projectDir/local.properties"
67 def localProps = "${projectDir}/local.properties"
69 if (file(localProps).exists()) {
70 propsFile = localProps
72 // or "../projectDir_local.properties"
73 def dirLocalProps = projectDir.getParent() + "/" + projectDir.getName() + "_local.properties"
74 if (file(dirLocalProps).exists()) {
75 propsFile = dirLocalProps
77 if (propsFile != null) {
79 def p = new Properties()
80 def localPropsFIS = new FileInputStream(propsFile)
85 def oldval = findProperty(key)
88 println("Overriding property '${key}' ('${oldval}') with ${file(propsFile).getName()} value '${val}'")
90 println("Setting unknown property '${key}' with ${file(propsFile).getName()}s value '${val}'")
93 } catch (Exception e) {
94 System.out.println("Exception reading local.properties")
99 // Import releaseProps from the RELEASE file
100 // or a file specified via JALVIEW_RELEASE_FILE if defined
101 // Expect jalview.version and target release branch in jalview.release
102 def releaseProps = new Properties();
103 def releasePropFile = findProperty("JALVIEW_RELEASE_FILE");
104 def defaultReleasePropFile = "${jalviewDirAbsolutePath}/RELEASE";
106 (new File(releasePropFile!=null ? releasePropFile : defaultReleasePropFile)).withInputStream {
107 releaseProps.load(it)
109 } catch (Exception fileLoadError) {
110 throw new Error("Couldn't load release properties file "+(releasePropFile==null ? defaultReleasePropFile : "from custom location: releasePropFile"),fileLoadError);
113 // Set JALVIEW_VERSION if it is not already set
114 if (findProperty(JALVIEW_VERSION)==null || "".equals(JALVIEW_VERSION)) {
115 JALVIEW_VERSION = releaseProps.get("jalview.version")
118 // this property set when running Eclipse headlessly
119 j2sHeadlessBuildProperty = string("net.sf.j2s.core.headlessbuild")
120 // this property set by Eclipse
121 eclipseApplicationProperty = string("eclipse.application")
122 // CHECK IF RUNNING FROM WITHIN ECLIPSE
123 def eclipseApplicationPropertyVal = System.properties[eclipseApplicationProperty]
124 IN_ECLIPSE = eclipseApplicationPropertyVal != null && eclipseApplicationPropertyVal.startsWith("org.eclipse.ui.")
125 // BUT WITHOUT THE HEADLESS BUILD PROPERTY SET
126 if (System.properties[j2sHeadlessBuildProperty].equals("true")) {
127 println("Setting IN_ECLIPSE to ${IN_ECLIPSE} as System.properties['${j2sHeadlessBuildProperty}'] == '${System.properties[j2sHeadlessBuildProperty]}'")
131 println("WITHIN ECLIPSE IDE")
133 println("HEADLESS BUILD")
136 J2S_ENABLED = (project.hasProperty('j2s.compiler.status') && project['j2s.compiler.status'] != null && project['j2s.compiler.status'] == "enable")
138 println("J2S ENABLED")
141 System.properties.sort { it.key }.each {
142 key, val -> println("SYSTEM PROPERTY ${key}='${val}'")
145 if (false && IN_ECLIPSE) {
146 jalviewDir = jalviewDirAbsolutePath
151 bareSourceDir = string(source_dir)
152 sourceDir = string("${jalviewDir}/${bareSourceDir}")
153 resourceDir = string("${jalviewDir}/${resource_dir}")
154 bareTestSourceDir = string(test_source_dir)
155 testDir = string("${jalviewDir}/${bareTestSourceDir}")
157 classesDir = string("${jalviewDir}/${classes_dir}")
160 useClover = clover.equals("true")
161 cloverBuildDir = "${buildDir}/clover"
162 cloverInstrDir = file("${cloverBuildDir}/clover-instr")
163 cloverClassesDir = file("${cloverBuildDir}/clover-classes")
164 cloverReportDir = file("${buildDir}/reports/clover")
165 cloverTestInstrDir = file("${cloverBuildDir}/clover-test-instr")
166 cloverTestClassesDir = file("${cloverBuildDir}/clover-test-classes")
167 //cloverTestClassesDir = cloverClassesDir
168 cloverDb = string("${cloverBuildDir}/clover.db")
170 testSourceDir = useClover ? cloverTestInstrDir : testDir
171 testClassesDir = useClover ? cloverTestClassesDir : "${jalviewDir}/${test_output_dir}"
173 getdownWebsiteDir = string("${jalviewDir}/${getdown_website_dir}/${JAVA_VERSION}")
176 // the following values might be overridden by the CHANNEL switch
177 getdownChannelName = CHANNEL.toLowerCase()
178 getdownDir = string("${getdownChannelName}/${JAVA_VERSION}")
179 getdownAppBase = string("${getdown_channel_base}/${getdownDir}")
180 getdownLauncher = string("${jalviewDir}/${getdown_lib_dir}/${getdown_launcher}")
181 getdownAppDistDir = getdown_app_dir_alt
182 reportRsyncCommand = false
183 jvlChannelName = CHANNEL.toLowerCase()
184 install4jSuffix = CHANNEL.substring(0, 1).toUpperCase() + CHANNEL.substring(1).toLowerCase(); // BUILD -> Build
185 install4jDSStore = "DS_Store-NON-RELEASE"
186 install4jDMGBackgroundImage = "jalview_dmg_background-NON-RELEASE.png"
187 install4jInstallerName = "${jalview_name} Non-Release Installer"
188 install4jExecutableName = jalview_name.replaceAll("[^\\w]+", "_").toLowerCase()
189 install4jExtraScheme = "jalviewx"
193 // TODO: get bamboo build artifact URL for getdown artifacts
194 getdown_channel_base = bamboo_channelbase
195 getdownChannelName = string("${bamboo_planKey}/${JAVA_VERSION}")
196 getdownAppBase = string("${bamboo_channelbase}/${bamboo_planKey}${bamboo_getdown_channel_suffix}/${JAVA_VERSION}")
197 jvlChannelName += "_${getdownChannelName}"
198 // automatically add the test group Not-bamboo for exclusion
199 if ("".equals(testng_excluded_groups)) {
200 testng_excluded_groups = "Not-bamboo"
202 install4jExtraScheme = "jalviewb"
206 getdownAppDistDir = getdown_app_dir_release
207 reportRsyncCommand = true
209 install4jDSStore = "DS_Store"
210 install4jDMGBackgroundImage = "jalview_dmg_background.png"
211 install4jInstallerName = "${jalview_name} Installer"
215 getdownChannelName = CHANNEL.toLowerCase()+"/${JALVIEW_VERSION}"
216 getdownDir = string("${getdownChannelName}/${JAVA_VERSION}")
217 getdownAppBase = string("${getdown_channel_base}/${getdownDir}")
218 if (!file("${ARCHIVEDIR}/${package_dir}").exists()) {
219 throw new GradleException("Must provide an ARCHIVEDIR value to produce an archive distribution")
221 package_dir = string("${ARCHIVEDIR}/${package_dir}")
222 buildProperties = string("${ARCHIVEDIR}/${classes_dir}/${build_properties_file}")
225 reportRsyncCommand = true
226 install4jExtraScheme = "jalviewa"
230 getdownChannelName = string("archive/${JALVIEW_VERSION}")
231 getdownDir = string("${getdownChannelName}/${JAVA_VERSION}")
232 getdownAppBase = file(getdownWebsiteDir).toURI().toString()
233 if (!file("${ARCHIVEDIR}/${package_dir}").exists()) {
234 throw new GradleException("Must provide an ARCHIVEDIR value to produce an archive distribution")
236 package_dir = string("${ARCHIVEDIR}/${package_dir}")
237 buildProperties = string("${ARCHIVEDIR}/${classes_dir}/${build_properties_file}")
240 reportRsyncCommand = true
241 getdownLauncher = string("${jalviewDir}/${getdown_lib_dir}/${getdown_launcher_local}")
242 install4jSuffix = "Archive"
243 install4jExtraScheme = "jalviewa"
247 reportRsyncCommand = true
249 // DEVELOP-RELEASE is usually associated with a Jalview release series so set the version
250 JALVIEW_VERSION=JALVIEW_VERSION+"-develop"
252 channelPropertiesFile = string("${channel_properties_dir}/develop_properties")
253 getdownImagesDir = "${getdown_images_dir}/develop"
254 getdownBgColour = "000000"
255 getdownFgColour = "FFFFFF"
256 getdownLightFgColour = "CCCCFF"
257 install4jSuffix = "Develop"
258 install4jDSStore = "DS_Store-DEVELOP"
259 install4jDMGBackgroundImage = "jalview_dmg_background-DEVELOP.png"
260 install4jExtraScheme = "jalviewd"
261 install4jInstallerName = "${jalview_name} Develop Installer"
262 install4jMacIconsFile = string("${install4j_utils_dir}/develop/${install4j_mac_icons_file}")
263 install4jWindowsIconsFile = string("${install4j_utils_dir}/develop/${install4j_windows_icons_file}")
264 install4jPngIconFile = string("${install4j_utils_dir}/develop/${install4j_png_icon_file}")
268 reportRsyncCommand = true
269 // Don't ignore transpile errors for release build
270 if (jalviewjs_ignore_transpile_errors.equals("true")) {
271 jalviewjs_ignore_transpile_errors = "false"
272 println("Setting jalviewjs_ignore_transpile_errors to 'false'")
274 JALVIEW_VERSION = JALVIEW_VERSION+"-test"
275 install4jSuffix = "Test"
276 install4jDSStore = "DS_Store-TEST-RELEASE"
277 install4jDMGBackgroundImage = "jalview_dmg_background-TEST.png"
278 install4jExtraScheme = "jalviewt"
279 install4jInstallerName = "${jalview_name} Test Installer"
282 case ~/^SCRATCH(|-[-\w]*)$/:
283 getdownChannelName = CHANNEL
284 JALVIEW_VERSION = JALVIEW_VERSION+"-"+CHANNEL
286 getdownDir = string("${getdownChannelName}/${JAVA_VERSION}")
287 getdownAppBase = string("${getdown_channel_base}/${getdownDir}")
288 reportRsyncCommand = true
289 install4jSuffix = "Scratch"
293 if (!file("${LOCALDIR}").exists()) {
294 throw new GradleException("Must provide a LOCALDIR value to produce a local distribution")
296 getdownAppBase = file(file("${LOCALDIR}").getAbsolutePath()).toURI().toString()
297 getdownLauncher = string("${jalviewDir}/${getdown_lib_dir}/${getdown_launcher_local}")
299 JALVIEW_VERSION = "TEST"
300 install4jSuffix = "Test-Local"
301 install4jDSStore = "DS_Store-TEST-RELEASE"
302 install4jDMGBackgroundImage = "jalview_dmg_background-TEST.png"
303 install4jExtraScheme = "jalviewt"
304 install4jInstallerName = "${jalview_name} Test Installer"
308 JALVIEW_VERSION = "TEST"
309 getdownAppBase = file(getdownWebsiteDir).toURI().toString()
310 getdownLauncher = string("${jalviewDir}/${getdown_lib_dir}/${getdown_launcher_local}")
311 install4jExtraScheme = "jalviewl"
314 default: // something wrong specified
315 throw new GradleException("CHANNEL must be one of BUILD, RELEASE, ARCHIVE, DEVELOP, TEST-RELEASE, SCRATCH-..., LOCAL [default]")
319 // override getdownAppBase if requested
320 if (findProperty("getdown_appbase_override") != null) {
321 getdownAppBase = string(getProperty("getdown_appbase_override"))
322 println("Overriding getdown appbase with '${getdownAppBase}'")
324 // sanitise file name for jalview launcher file for this channel
325 jvlChannelName = jvlChannelName.replaceAll("[^\\w\\-]+", "_")
326 // install4j application and folder names
327 if (install4jSuffix == "") {
328 install4jApplicationName = "${jalview_name}"
329 install4jBundleId = "${install4j_bundle_id}"
330 install4jWinApplicationId = install4j_release_win_application_id
332 install4jApplicationName = "${jalview_name} ${install4jSuffix}"
333 install4jBundleId = "${install4j_bundle_id}-" + install4jSuffix.toLowerCase()
334 // add int hash of install4jSuffix to the last part of the application_id
335 def id = install4j_release_win_application_id
336 def idsplitreverse = id.split("-").reverse()
337 idsplitreverse[0] = idsplitreverse[0].toInteger() + install4jSuffix.hashCode()
338 install4jWinApplicationId = idsplitreverse.reverse().join("-")
340 // sanitise folder and id names
341 // install4jApplicationFolder = e.g. "Jalview Build"
342 install4jApplicationFolder = install4jApplicationName
343 .replaceAll("[\"'~:/\\\\\\s]", "_") // replace all awkward filename chars " ' ~ : / \
344 .replaceAll("_+", "_") // collapse __
345 install4jInternalId = install4jApplicationName
347 .replaceAll("[^\\w\\-\\.]", "_") // replace other non [alphanumeric,_,-,.]
348 .replaceAll("_+", "") // collapse __
349 //.replaceAll("_*-_*", "-") // collapse _-_
350 install4jUnixApplicationFolder = install4jApplicationName
352 .replaceAll("[^\\w\\-\\.]", "_") // replace other non [alphanumeric,_,-,.]
353 .replaceAll("_+", "_") // collapse __
354 .replaceAll("_*-_*", "-") // collapse _-_
357 getdownAppDir = string("${getdownWebsiteDir}/${getdownAppDistDir}")
358 //getdownJ11libDir = "${getdownWebsiteDir}/${getdown_j11lib_dir}"
359 getdownResourceDir = string("${getdownWebsiteDir}/${getdown_resource_dir}")
360 getdownInstallDir = string("${getdownWebsiteDir}/${getdown_install_dir}")
361 getdownFilesDir = string("${jalviewDir}/${getdown_files_dir}/${JAVA_VERSION}/")
362 getdownFilesInstallDir = string("${getdownFilesDir}/${getdown_install_dir}")
363 /* compile without modules -- using classpath libraries
364 modules_compileClasspath = fileTree(dir: "${jalviewDir}/${j11modDir}", include: ["*.jar"])
365 modules_runtimeClasspath = modules_compileClasspath
367 def details = versionDetails()
368 gitHash = details.gitHash
369 gitBranch = details.branchName
371 println("Using a ${CHANNEL} profile.")
373 additional_compiler_args = []
374 // configure classpath/args for j8/j11 compilation
375 if (JAVA_VERSION.equals("1.8")) {
376 JAVA_INTEGER_VERSION = string("8")
379 libDistDir = j8libDir
380 compile_source_compatibility = 1.8
381 compile_target_compatibility = 1.8
382 // these are getdown.txt properties defined dependent on the JAVA_VERSION
383 getdownAltJavaMinVersion = string(findProperty("getdown_alt_java8_min_version"))
384 getdownAltJavaMaxVersion = string(findProperty("getdown_alt_java8_max_version"))
385 // this property is assigned below and expanded to multiple lines in the getdown task
386 getdownAltMultiJavaLocation = string(findProperty("getdown_alt_java8_txt_multi_java_location"))
387 // this property is for the Java library used in eclipse
388 eclipseJavaRuntimeName = string("JavaSE-1.8")
389 } else if (JAVA_VERSION.equals("11")) {
390 JAVA_INTEGER_VERSION = string("11")
392 libDistDir = j11libDir
393 compile_source_compatibility = 11
394 compile_target_compatibility = 11
395 getdownAltJavaMinVersion = string(findProperty("getdown_alt_java11_min_version"))
396 getdownAltJavaMaxVersion = string(findProperty("getdown_alt_java11_max_version"))
397 getdownAltMultiJavaLocation = string(findProperty("getdown_alt_java11_txt_multi_java_location"))
398 eclipseJavaRuntimeName = string("JavaSE-11")
399 /* compile without modules -- using classpath libraries
400 additional_compiler_args += [
401 '--module-path', modules_compileClasspath.asPath,
402 '--add-modules', j11modules
405 } else if (JAVA_VERSION.equals("12") || JAVA_VERSION.equals("13")) {
406 JAVA_INTEGER_VERSION = JAVA_VERSION
408 libDistDir = j11libDir
409 compile_source_compatibility = JAVA_VERSION
410 compile_target_compatibility = JAVA_VERSION
411 getdownAltJavaMinVersion = string(findProperty("getdown_alt_java11_min_version"))
412 getdownAltJavaMaxVersion = string(findProperty("getdown_alt_java11_max_version"))
413 getdownAltMultiJavaLocation = string(findProperty("getdown_alt_java11_txt_multi_java_location"))
414 eclipseJavaRuntimeName = string("JavaSE-11")
415 /* compile without modules -- using classpath libraries
416 additional_compiler_args += [
417 '--module-path', modules_compileClasspath.asPath,
418 '--add-modules', j11modules
422 throw new GradleException("JAVA_VERSION=${JAVA_VERSION} not currently supported by Jalview")
427 JAVA_MIN_VERSION = JAVA_VERSION
428 JAVA_MAX_VERSION = JAVA_VERSION
429 def jreInstallsDir = string(jre_installs_dir)
430 if (jreInstallsDir.startsWith("~/")) {
431 jreInstallsDir = System.getProperty("user.home") + jreInstallsDir.substring(1)
433 macosJavaVMDir = string("${jreInstallsDir}/jre-${JAVA_INTEGER_VERSION}-mac-x64/jre")
434 macosJavaVMTgz = string("${jreInstallsDir}/tgz/jre-${JAVA_INTEGER_VERSION}-mac-x64.tar.gz")
435 windowsJavaVMDir = string("${jreInstallsDir}/jre-${JAVA_INTEGER_VERSION}-windows-x64/jre")
436 windowsJavaVMTgz = string("${jreInstallsDir}/tgz/jre-${JAVA_INTEGER_VERSION}-windows-x64.tar.gz")
437 linuxJavaVMDir = string("${jreInstallsDir}/jre-${JAVA_INTEGER_VERSION}-linux-x64/jre")
438 linuxJavaVMTgz = string("${jreInstallsDir}/tgz/jre-${JAVA_INTEGER_VERSION}-linux-x64.tar.gz")
439 install4jDir = string("${jalviewDir}/${install4j_utils_dir}")
440 install4jConfFileName = string("jalview-install4j-conf.install4j")
441 install4jConfFile = file("${install4jDir}/${install4jConfFileName}")
442 install4jHomeDir = install4j_home_dir
443 if (install4jHomeDir.startsWith("~/")) {
444 install4jHomeDir = System.getProperty("user.home") + install4jHomeDir.substring(1)
447 resourceBuildDir = string("${buildDir}/resources")
448 resourcesBuildDir = string("${resourceBuildDir}/resources_build")
449 helpBuildDir = string("${resourceBuildDir}/help_build")
450 docBuildDir = string("${resourceBuildDir}/doc_build")
452 buildProperties = string("${resourcesBuildDir}/${build_properties_file}")
453 buildingHTML = string("${jalviewDir}/${doc_dir}/building.html")
454 helpParentDir = string("${jalviewDir}/${help_parent_dir}")
455 helpSourceDir = string("${helpParentDir}/${help_dir}")
456 helpFile = string("${helpBuildDir}/${help_dir}/help.jhm")
459 relativeBuildDir = file(jalviewDirAbsolutePath).toPath().relativize(buildDir.toPath())
460 jalviewjsBuildDir = string("${relativeBuildDir}/jalviewjs")
461 jalviewjsSiteDir = string("${jalviewjsBuildDir}/${jalviewjs_site_dir}")
463 jalviewjsTransferSiteJsDir = string(jalviewjsSiteDir)
465 jalviewjsTransferSiteJsDir = string("${jalviewjsBuildDir}/tmp/${jalviewjs_site_dir}_js")
467 jalviewjsTransferSiteLibDir = string("${jalviewjsBuildDir}/tmp/${jalviewjs_site_dir}_lib")
468 jalviewjsTransferSiteSwingJsDir = string("${jalviewjsBuildDir}/tmp/${jalviewjs_site_dir}_swingjs")
469 jalviewjsTransferSiteCoreDir = string("${jalviewjsBuildDir}/tmp/${jalviewjs_site_dir}_core")
470 jalviewjsJalviewCoreHtmlFile = string("")
471 jalviewjsJalviewCoreName = string(jalviewjs_core_name)
472 jalviewjsCoreClasslists = []
473 jalviewjsJalviewTemplateName = string(jalviewjs_name)
474 jalviewjsJ2sSettingsFileName = string("${jalviewDir}/${jalviewjs_j2s_settings}")
475 jalviewjsJ2sProps = null
476 jalviewjsJ2sPlugin = jalviewjs_j2s_plugin
478 eclipseWorkspace = null
479 eclipseBinary = string("")
480 eclipseVersion = string("")
490 outputDir = file(classesDir)
494 srcDirs = [ resourcesBuildDir, docBuildDir, helpBuildDir ]
497 compileClasspath = files(sourceSets.main.java.outputDir)
498 compileClasspath += fileTree(dir: "${jalviewDir}/${libDir}", include: ["*.jar"])
500 runtimeClasspath = compileClasspath
501 runtimeClasspath += files(sourceSets.main.resources.srcDirs)
506 srcDirs cloverInstrDir
507 outputDir = cloverClassesDir
511 srcDirs = sourceSets.main.resources.srcDirs
514 compileClasspath = files( sourceSets.clover.java.outputDir )
515 //compileClasspath += files( testClassesDir )
516 compileClasspath += fileTree(dir: "${jalviewDir}/${libDir}", include: ["*.jar"])
517 compileClasspath += fileTree(dir: "${jalviewDir}/${clover_lib_dir}", include: ["*.jar"])
518 compileClasspath += fileTree(dir: "${jalviewDir}/${utils_dir}/testnglibs", include: ["**/*.jar"])
520 runtimeClasspath = compileClasspath
525 srcDirs testSourceDir
526 outputDir = file(testClassesDir)
530 srcDirs = useClover ? sourceSets.clover.resources.srcDirs : sourceSets.main.resources.srcDirs
533 compileClasspath = files( sourceSets.test.java.outputDir )
534 compileClasspath += useClover ? sourceSets.clover.compileClasspath : sourceSets.main.compileClasspath
535 compileClasspath += fileTree(dir: "${jalviewDir}/${utils_dir}/testnglibs", include: ["**/*.jar"])
537 runtimeClasspath = compileClasspath
538 runtimeClasspath += files(sourceSets.test.resources.srcDirs)
544 // eclipse project and settings files creation, also used by buildship
547 name = eclipse_project_name
549 natures 'org.eclipse.jdt.core.javanature',
550 'org.eclipse.jdt.groovy.core.groovyNature',
551 'org.eclipse.buildship.core.gradleprojectnature'
553 buildCommand 'org.eclipse.jdt.core.javabuilder'
554 buildCommand 'org.eclipse.buildship.core.gradleprojectbuilder'
558 //defaultOutputDir = sourceSets.main.java.outputDir
559 configurations.each{ c->
560 if (c.isCanBeResolved()) {
561 minusConfigurations += [c]
565 plusConfigurations = [ ]
569 def removeTheseToo = []
570 HashMap<String, Boolean> alreadyAddedSrcPath = new HashMap<>();
571 cp.entries.each { entry ->
572 // This conditional removes all src classpathentries that a) have already been added or b) aren't "src" or "test".
573 // e.g. this removes the resources dir being copied into bin/main, bin/test AND bin/clover
574 // we add the resources and help/help dirs in as libs afterwards (see below)
575 if (entry.kind == 'src') {
576 if (alreadyAddedSrcPath.getAt(entry.path) || !(entry.path == bareSourceDir || entry.path == bareTestSourceDir)) {
577 removeTheseToo += entry
579 alreadyAddedSrcPath.putAt(entry.path, true)
584 cp.entries.removeAll(removeTheseToo)
586 //cp.entries += new Output("${eclipse_bin_dir}/main")
587 if (file(helpParentDir).isDirectory()) {
588 cp.entries += new Library(fileReference(helpParentDir))
590 if (file(resourceDir).isDirectory()) {
591 cp.entries += new Library(fileReference(resourceDir))
594 HashMap<String, Boolean> alreadyAddedLibPath = new HashMap<>();
596 sourceSets.main.compileClasspath.findAll { it.name.endsWith(".jar") }.any {
597 //don't want to add outputDir as eclipse is using its own output dir in bin/main
598 if (it.isDirectory() || ! it.exists()) {
599 // don't add dirs to classpath, especially if they don't exist
600 return false // groovy "continue" in .any closure
602 def itPath = it.toString()
603 if (itPath.startsWith("${jalviewDirAbsolutePath}/")) {
604 // make relative path
605 itPath = itPath.substring(jalviewDirAbsolutePath.length()+1)
607 if (alreadyAddedLibPath.get(itPath)) {
608 //println("Not adding duplicate entry "+itPath)
610 //println("Adding entry "+itPath)
611 cp.entries += new Library(fileReference(itPath))
612 alreadyAddedLibPath.put(itPath, true)
616 sourceSets.test.compileClasspath.findAll { it.name.endsWith(".jar") }.any {
617 //no longer want to add outputDir as eclipse is using its own output dir in bin/main
618 if (it.isDirectory() || ! it.exists()) {
619 // don't add dirs to classpath
620 return false // groovy "continue" in .any closure
623 def itPath = it.toString()
624 if (itPath.startsWith("${jalviewDirAbsolutePath}/")) {
625 itPath = itPath.substring(jalviewDirAbsolutePath.length()+1)
627 if (alreadyAddedLibPath.get(itPath)) {
630 def lib = new Library(fileReference(itPath))
631 lib.entryAttributes["test"] = "true"
633 alreadyAddedLibPath.put(itPath, true)
641 containers 'org.eclipse.buildship.core.gradleclasspathcontainer'
646 // for the IDE, use java 11 compatibility
647 sourceCompatibility = compile_source_compatibility
648 targetCompatibility = compile_target_compatibility
649 javaRuntimeName = eclipseJavaRuntimeName
651 // add in jalview project specific properties/preferences into eclipse core preferences
653 withProperties { props ->
654 def jalview_prefs = new Properties()
655 def ins = new FileInputStream("${jalviewDirAbsolutePath}/${eclipse_extra_jdt_prefs_file}")
656 jalview_prefs.load(ins)
658 jalview_prefs.forEach { t, v ->
659 if (props.getAt(t) == null) {
663 // codestyle file -- overrides previous formatter prefs
664 def csFile = file("${jalviewDirAbsolutePath}/${eclipse_codestyle_file}")
665 if (csFile.exists()) {
666 XmlParser parser = new XmlParser()
667 def profiles = parser.parse(csFile)
668 def profile = profiles.'profile'.find { p -> (p.'@kind' == "CodeFormatterProfile" && p.'@name' == "Jalview") }
669 if (profile != null) {
670 profile.'setting'.each { s ->
672 def value = s.'@value'
673 if (id != null && value != null) {
674 props.putAt(id, value)
685 // Don't want these to be activated if in headless build
686 synchronizationTasks "eclipseSynchronizationTask"
687 //autoBuildTasks "eclipseAutoBuildTask"
693 /* hack to change eclipse prefs in .settings files other than org.eclipse.jdt.core.prefs */
694 // Class to allow updating arbitrary properties files
695 class PropertiesFile extends PropertiesPersistableConfigurationObject {
696 public PropertiesFile(PropertiesTransformer t) { super(t); }
697 @Override protected void load(Properties properties) { }
698 @Override protected void store(Properties properties) { }
699 @Override protected String getDefaultResourceName() { return ""; }
700 // This is necessary, because PropertiesPersistableConfigurationObject fails
701 // if no default properties file exists.
702 @Override public void loadDefaults() { load(new StringBufferInputStream("")); }
705 // Task to update arbitrary properties files (set outputFile)
706 class PropertiesFileTask extends PropertiesGeneratorTask<PropertiesFile> {
707 private final PropertiesFileContentMerger file;
708 public PropertiesFileTask() { file = new PropertiesFileContentMerger(getTransformer()); }
709 protected PropertiesFile create() { return new PropertiesFile(getTransformer()); }
710 protected void configure(PropertiesFile props) {
711 file.getBeforeMerged().execute(props); file.getWhenMerged().execute(props);
713 public void file(Closure closure) { ConfigureUtil.configure(closure, file); }
716 task eclipseUIPreferences(type: PropertiesFileTask) {
717 description = "Generate Eclipse additional settings"
718 def filename = "org.eclipse.jdt.ui.prefs"
719 outputFile = "$projectDir/.settings/${filename}" as File
722 it.load new FileInputStream("$projectDir/utils/eclipse/${filename}" as String)
727 task eclipseGroovyCorePreferences(type: PropertiesFileTask) {
728 description = "Generate Eclipse additional settings"
729 def filename = "org.eclipse.jdt.groovy.core.prefs"
730 outputFile = "$projectDir/.settings/${filename}" as File
733 it.load new FileInputStream("$projectDir/utils/eclipse/${filename}" as String)
738 task eclipseAllPreferences {
740 dependsOn eclipseUIPreferences
741 dependsOn eclipseGroovyCorePreferences
744 eclipseUIPreferences.mustRunAfter eclipseJdt
745 eclipseGroovyCorePreferences.mustRunAfter eclipseJdt
747 /* end of eclipse preferences hack */
755 delete cloverBuildDir
756 delete cloverReportDir
761 task cloverInstrJava(type: JavaExec) {
762 group = "Verification"
763 description = "Create clover instrumented source java files"
765 dependsOn cleanClover
767 inputs.files(sourceSets.main.allJava)
768 outputs.dir(cloverInstrDir)
770 //classpath = fileTree(dir: "${jalviewDir}/${clover_lib_dir}", include: ["*.jar"])
771 classpath = sourceSets.clover.compileClasspath
772 main = "com.atlassian.clover.CloverInstr"
780 cloverInstrDir.getPath(),
782 def srcFiles = sourceSets.main.allJava.files
785 { file -> file.absolutePath }
788 args argsList.toArray()
791 delete cloverInstrDir
792 println("Clover: About to instrument "+srcFiles.size() +" files")
797 task cloverInstrTests(type: JavaExec) {
798 group = "Verification"
799 description = "Create clover instrumented source test files"
801 dependsOn cleanClover
803 inputs.files(testDir)
804 outputs.dir(cloverTestInstrDir)
806 classpath = sourceSets.clover.compileClasspath
807 main = "com.atlassian.clover.CloverInstr"
817 cloverTestInstrDir.getPath(),
819 args argsList.toArray()
822 delete cloverTestInstrDir
823 println("Clover: About to instrument test files")
829 group = "Verification"
830 description = "Create clover instrumented all source files"
832 dependsOn cloverInstrJava
833 dependsOn cloverInstrTests
837 cloverClasses.dependsOn cloverInstr
840 task cloverConsoleReport(type: JavaExec) {
841 group = "Verification"
842 description = "Creates clover console report"
845 file(cloverDb).exists()
848 inputs.dir cloverClassesDir
850 classpath = sourceSets.clover.runtimeClasspath
851 main = "com.atlassian.clover.reporters.console.ConsoleReporter"
853 if (cloverreport_mem.length() > 0) {
854 maxHeapSize = cloverreport_mem
856 if (cloverreport_jvmargs.length() > 0) {
857 jvmArgs Arrays.asList(cloverreport_jvmargs.split(" "))
867 args argsList.toArray()
871 task cloverHtmlReport(type: JavaExec) {
872 group = "Verification"
873 description = "Creates clover HTML report"
876 file(cloverDb).exists()
879 def cloverHtmlDir = cloverReportDir
880 inputs.dir cloverClassesDir
881 outputs.dir cloverHtmlDir
883 classpath = sourceSets.clover.runtimeClasspath
884 main = "com.atlassian.clover.reporters.html.HtmlReporter"
886 if (cloverreport_mem.length() > 0) {
887 maxHeapSize = cloverreport_mem
889 if (cloverreport_jvmargs.length() > 0) {
890 jvmArgs Arrays.asList(cloverreport_jvmargs.split(" "))
901 if (cloverreport_html_options.length() > 0) {
902 argsList += cloverreport_html_options.split(" ")
905 args argsList.toArray()
909 task cloverXmlReport(type: JavaExec) {
910 group = "Verification"
911 description = "Creates clover XML report"
914 file(cloverDb).exists()
917 def cloverXmlFile = "${cloverReportDir}/clover.xml"
918 inputs.dir cloverClassesDir
919 outputs.file cloverXmlFile
921 classpath = sourceSets.clover.runtimeClasspath
922 main = "com.atlassian.clover.reporters.xml.XMLReporter"
924 if (cloverreport_mem.length() > 0) {
925 maxHeapSize = cloverreport_mem
927 if (cloverreport_jvmargs.length() > 0) {
928 jvmArgs Arrays.asList(cloverreport_jvmargs.split(" "))
939 if (cloverreport_xml_options.length() > 0) {
940 argsList += cloverreport_xml_options.split(" ")
943 args argsList.toArray()
948 group = "Verification"
949 description = "Creates clover reports"
951 dependsOn cloverXmlReport
952 dependsOn cloverHtmlReport
959 sourceCompatibility = compile_source_compatibility
960 targetCompatibility = compile_target_compatibility
961 options.compilerArgs += additional_compiler_args
962 print ("Setting target compatibility to "+targetCompatibility+"\n")
964 //classpath += configurations.cloverRuntime
970 // JBP->BS should the print statement in doFirst refer to compile_target_compatibility ?
971 sourceCompatibility = compile_source_compatibility
972 targetCompatibility = compile_target_compatibility
973 options.compilerArgs = additional_compiler_args
974 options.encoding = "UTF-8"
976 print ("Setting target compatibility to "+compile_target_compatibility+"\n")
983 sourceCompatibility = compile_source_compatibility
984 targetCompatibility = compile_target_compatibility
985 options.compilerArgs = additional_compiler_args
987 print ("Setting target compatibility to "+targetCompatibility+"\n")
994 delete sourceSets.main.java.outputDir
1000 dependsOn cleanClover
1002 delete sourceSets.test.java.outputDir
1007 // format is a string like date.format("dd MMMM yyyy")
1008 def getDate(format) {
1009 def date = new Date()
1010 return date.format(format)
1014 def convertMdToHtml (FileTree mdFiles, File cssFile) {
1015 MutableDataSet options = new MutableDataSet()
1017 def extensions = new ArrayList<>()
1018 extensions.add(AnchorLinkExtension.create())
1019 extensions.add(AutolinkExtension.create())
1020 extensions.add(StrikethroughExtension.create())
1021 extensions.add(TaskListExtension.create())
1022 extensions.add(TablesExtension.create())
1023 extensions.add(TocExtension.create())
1025 options.set(Parser.EXTENSIONS, extensions)
1027 // set GFM table parsing options
1028 options.set(TablesExtension.WITH_CAPTION, false)
1029 options.set(TablesExtension.COLUMN_SPANS, false)
1030 options.set(TablesExtension.MIN_HEADER_ROWS, 1)
1031 options.set(TablesExtension.MAX_HEADER_ROWS, 1)
1032 options.set(TablesExtension.APPEND_MISSING_COLUMNS, true)
1033 options.set(TablesExtension.DISCARD_EXTRA_COLUMNS, true)
1034 options.set(TablesExtension.HEADER_SEPARATOR_COLUMN_MATCH, true)
1036 options.set(AnchorLinkExtension.ANCHORLINKS_SET_ID, false)
1037 options.set(AnchorLinkExtension.ANCHORLINKS_ANCHOR_CLASS, "anchor")
1038 options.set(AnchorLinkExtension.ANCHORLINKS_SET_NAME, true)
1039 options.set(AnchorLinkExtension.ANCHORLINKS_TEXT_PREFIX, "<span class=\"octicon octicon-link\"></span>")
1041 Parser parser = Parser.builder(options).build()
1042 HtmlRenderer renderer = HtmlRenderer.builder(options).build()
1044 mdFiles.each { mdFile ->
1045 // add table of contents
1046 def mdText = "[TOC]\n"+mdFile.text
1048 // grab the first top-level title
1050 def titleRegex = /(?m)^#(\s+|([^#]))(.*)/
1051 def matcher = mdText =~ titleRegex
1052 if (matcher.size() > 0) {
1053 // matcher[0][2] is the first character of the title if there wasn't any whitespace after the #
1054 title = (matcher[0][2] != null ? matcher[0][2] : "")+matcher[0][3]
1056 // or use the filename if none found
1057 if (title == null) {
1058 title = mdFile.getName()
1061 Node document = parser.parse(mdText)
1062 String htmlBody = renderer.render(document)
1063 def htmlText = '''<html>
1064 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
1065 <html xmlns="http://www.w3.org/1999/xhtml">
1067 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
1068 <meta http-equiv="Content-Style-Type" content="text/css" />
1069 <meta name="generator" content="flexmark" />
1071 htmlText += ((title != null) ? " <title>${title}</title>" : '' )
1073 <style type="text/css">code{white-space: pre;}</style>
1075 htmlText += ((cssFile != null) ? cssFile.text : '')
1076 htmlText += '''</head>
1079 htmlText += htmlBody
1085 def htmlFilePath = mdFile.getPath().replaceAll(/\..*?$/, ".html")
1086 def htmlFile = file(htmlFilePath)
1087 htmlFile.text = htmlText
1092 task copyDocs(type: Copy) {
1093 def inputDir = "${jalviewDir}/${doc_dir}"
1094 def outputDir = "${docBuildDir}/${doc_dir}"
1098 include('**/*.html')
1100 filter(ReplaceTokens,
1104 'Version-Rel': JALVIEW_VERSION,
1105 'Year-Rel': getDate("yyyy")
1112 exclude('**/*.html')
1117 inputs.dir(inputDir)
1118 outputs.dir(outputDir)
1122 task convertMdFiles {
1124 def mdFiles = fileTree(dir: docBuildDir, include: "*.md")
1125 def cssFile = file("${jalviewDir}/${flexmark_css}")
1128 convertMdToHtml(mdFiles, cssFile)
1131 inputs.files(mdFiles)
1132 inputs.file(cssFile)
1135 mdFiles.each { mdFile ->
1136 def htmlFilePath = mdFile.getPath().replaceAll(/\..*?$/, ".html")
1137 htmlFiles.add(file(htmlFilePath))
1139 outputs.files(htmlFiles)
1143 task copyHelp(type: Copy) {
1144 def inputDir = helpSourceDir
1145 def outputDir = "${helpBuildDir}/${help_dir}"
1149 include('**/*.html')
1153 filter(ReplaceTokens,
1157 'Version-Rel': JALVIEW_VERSION,
1158 'Year-Rel': getDate("yyyy")
1165 exclude('**/*.html')
1172 inputs.dir(inputDir)
1173 outputs.files(helpFile)
1174 outputs.dir(outputDir)
1178 task copyResources(type: Copy) {
1179 def inputDir = resourceDir
1180 def outputDir = resourcesBuildDir
1184 include('**/*.html')
1186 filter(ReplaceTokens,
1190 'Version-Rel': JALVIEW_VERSION,
1191 'Year-Rel': getDate("yyyy")
1198 exclude('**/*.html')
1203 inputs.dir(inputDir)
1204 outputs.dir(outputDir)
1208 task createBuildProperties(type: WriteProperties) {
1209 dependsOn copyResources
1211 description = "Create the ${buildProperties} file"
1213 inputs.dir(sourceDir)
1214 inputs.dir(resourcesBuildDir)
1215 outputFile (buildProperties)
1216 // taking time specific comment out to allow better incremental builds
1217 comment "--Jalview Build Details--\n"+getDate("yyyy-MM-dd HH:mm:ss")
1218 //comment "--Jalview Build Details--\n"+getDate("yyyy-MM-dd")
1219 property "BUILD_DATE", getDate("HH:mm:ss dd MMMM yyyy")
1220 property "VERSION", JALVIEW_VERSION
1221 property "INSTALLATION", INSTALLATION+" git-commit:"+gitHash+" ["+gitBranch+"]"
1222 outputs.file(outputFile)
1227 dependsOn copyResources
1230 dependsOn createBuildProperties
1231 dependsOn convertMdFiles
1235 compileJava.dependsOn prepare
1236 run.dependsOn compileJava
1237 //run.dependsOn prepare
1240 //testReportDirName = "test-reports" // note that test workingDir will be $jalviewDir
1245 dependsOn cloverClasses
1247 dependsOn compileJava //?
1251 includeGroups testng_groups
1252 excludeGroups testng_excluded_groups
1254 useDefaultListeners=true
1257 maxHeapSize = "1024m"
1259 workingDir = jalviewDir
1260 def testLaf = project.findProperty("test_laf")
1261 if (testLaf != null) {
1262 println("Setting Test LaF to '${testLaf}'")
1263 systemProperty "laf", testLaf
1265 sourceCompatibility = compile_source_compatibility
1266 targetCompatibility = compile_target_compatibility
1267 jvmArgs += additional_compiler_args
1271 println("Running tests " + (useClover?"WITH":"WITHOUT") + " clover")
1277 task buildIndices(type: JavaExec) {
1279 classpath = sourceSets.main.compileClasspath
1280 main = "com.sun.java.help.search.Indexer"
1281 workingDir = "${helpBuildDir}/${help_dir}"
1284 inputs.dir("${workingDir}/${argDir}")
1286 outputs.dir("${classesDir}/doc")
1287 outputs.dir("${classesDir}/help")
1288 outputs.file("${workingDir}/JavaHelpSearch/DOCS")
1289 outputs.file("${workingDir}/JavaHelpSearch/DOCS.TAB")
1290 outputs.file("${workingDir}/JavaHelpSearch/OFFSETS")
1291 outputs.file("${workingDir}/JavaHelpSearch/POSITIONS")
1292 outputs.file("${workingDir}/JavaHelpSearch/SCHEMA")
1293 outputs.file("${workingDir}/JavaHelpSearch/TMAP")
1297 task compileLinkCheck(type: JavaCompile) {
1299 classpath = files("${jalviewDir}/${utils_dir}")
1300 destinationDir = file("${jalviewDir}/${utils_dir}")
1301 source = fileTree(dir: "${jalviewDir}/${utils_dir}", include: ["HelpLinksChecker.java", "BufferedLineReader.java"])
1303 inputs.file("${jalviewDir}/${utils_dir}/HelpLinksChecker.java")
1304 inputs.file("${jalviewDir}/${utils_dir}/HelpLinksChecker.java")
1305 outputs.file("${jalviewDir}/${utils_dir}/HelpLinksChecker.class")
1306 outputs.file("${jalviewDir}/${utils_dir}/BufferedLineReader.class")
1310 task linkCheck(type: JavaExec) {
1311 dependsOn prepare, compileLinkCheck
1313 def helpLinksCheckerOutFile = file("${jalviewDir}/${utils_dir}/HelpLinksChecker.out")
1314 classpath = files("${jalviewDir}/${utils_dir}")
1315 main = "HelpLinksChecker"
1316 workingDir = jalviewDir
1317 args = [ "${helpBuildDir}/${help_dir}", "-nointernet" ]
1319 def outFOS = new FileOutputStream(helpLinksCheckerOutFile, false) // false == don't append
1321 standardOutput = new org.apache.tools.ant.util.TeeOutputStream(
1324 errorOutput = new org.apache.tools.ant.util.TeeOutputStream(
1328 inputs.dir(helpBuildDir)
1329 outputs.file(helpLinksCheckerOutFile)
1333 // import the pubhtmlhelp target
1334 ant.properties.basedir = "${jalviewDir}"
1335 ant.properties.helpBuildDir = "${helpBuildDir}/${help_dir}"
1336 ant.importBuild "${utils_dir}/publishHelp.xml"
1339 task cleanPackageDir(type: Delete) {
1341 delete fileTree(dir: "${jalviewDir}/${package_dir}", include: "*.jar")
1348 dependsOn buildIndices
1349 dependsOn createBuildProperties
1353 attributes "Main-Class": main_class,
1354 "Permissions": "all-permissions",
1355 "Application-Name": install4jApplicationName,
1356 "Codebase": application_codebase,
1357 "Implementation-Version": JALVIEW_VERSION
1360 destinationDirectory = file("${jalviewDir}/${package_dir}")
1361 archiveFileName = rootProject.name+".jar"
1367 exclude "**/*.jar.*"
1369 inputs.dir(sourceSets.main.java.outputDir)
1370 sourceSets.main.resources.srcDirs.each{ dir ->
1373 outputs.file("${destinationDirectory}/${archiveFileName}")
1377 task copyJars(type: Copy) {
1378 from fileTree(dir: classesDir, include: "**/*.jar").files
1379 into "${jalviewDir}/${package_dir}"
1383 // doing a Sync instead of Copy as Copy doesn't deal with "outputs" very well
1384 task syncJars(type: Sync) {
1386 from fileTree(dir: "${jalviewDir}/${libDistDir}", include: "**/*.jar").files
1387 into "${jalviewDir}/${package_dir}"
1389 include jar.archiveFileName.getOrNull()
1396 description = "Put all required libraries in dist"
1397 // order of "cleanPackageDir", "copyJars", "jar" important!
1398 jar.mustRunAfter cleanPackageDir
1399 syncJars.mustRunAfter cleanPackageDir
1400 dependsOn cleanPackageDir
1403 outputs.dir("${jalviewDir}/${package_dir}")
1408 dependsOn cleanPackageDir
1415 group = "distribution"
1416 description = "Create a single jar file with all dependency libraries merged. Can be run with java -jar"
1420 from ("${jalviewDir}/${libDistDir}") {
1424 attributes "Implementation-Version": JALVIEW_VERSION,
1425 "Application-Name": install4jApplicationName
1427 mainClassName = shadow_jar_main_class
1429 classifier = "all-"+JALVIEW_VERSION+"-j"+JAVA_VERSION
1434 task getdownWebsite() {
1435 group = "distribution"
1436 description = "Create the getdown minimal app folder, and website folder for this version of jalview. Website folder also used for offline app installer"
1441 def getdownWebsiteResourceFilenames = []
1442 def getdownTextString = ""
1443 def getdownResourceDir = getdownResourceDir
1444 def getdownResourceFilenames = []
1447 // clean the getdown website and files dir before creating getdown folders
1448 delete getdownWebsiteDir
1449 delete getdownFilesDir
1452 from buildProperties
1453 rename(build_properties_file, getdown_build_properties)
1456 getdownWebsiteResourceFilenames += "${getdownAppDistDir}/${getdown_build_properties}"
1458 // set some getdown_txt_ properties then go through all properties looking for getdown_txt_...
1459 def props = project.properties.sort { it.key }
1460 if (getdownAltJavaMinVersion != null && getdownAltJavaMinVersion.length() > 0) {
1461 props.put("getdown_txt_java_min_version", getdownAltJavaMinVersion)
1463 if (getdownAltJavaMaxVersion != null && getdownAltJavaMaxVersion.length() > 0) {
1464 props.put("getdown_txt_java_max_version", getdownAltJavaMaxVersion)
1466 if (getdownAltMultiJavaLocation != null && getdownAltMultiJavaLocation.length() > 0) {
1467 props.put("getdown_txt_multi_java_location", getdownAltMultiJavaLocation)
1470 props.put("getdown_txt_title", jalview_name)
1471 props.put("getdown_txt_ui.name", install4jApplicationName)
1473 // start with appbase
1474 getdownTextString += "appbase = ${getdownAppBase}\n"
1475 props.each{ prop, val ->
1476 if (prop.startsWith("getdown_txt_") && val != null) {
1477 if (prop.startsWith("getdown_txt_multi_")) {
1478 def key = prop.substring(18)
1479 val.split(",").each{ v ->
1480 def line = "${key} = ${v}\n"
1481 getdownTextString += line
1484 // file values rationalised
1485 if (val.indexOf('/') > -1 || prop.startsWith("getdown_txt_resource")) {
1487 if (val.indexOf('/') == 0) {
1490 } else if (val.indexOf('/') > 0) {
1491 // relative path (relative to jalviewDir)
1492 r = file( "${jalviewDir}/${val}" )
1495 val = "${getdown_resource_dir}/" + r.getName()
1496 getdownWebsiteResourceFilenames += val
1497 getdownResourceFilenames += r.getPath()
1500 if (! prop.startsWith("getdown_txt_resource")) {
1501 def line = prop.substring(12) + " = ${val}\n"
1502 getdownTextString += line
1508 getdownWebsiteResourceFilenames.each{ filename ->
1509 getdownTextString += "resource = ${filename}\n"
1511 getdownResourceFilenames.each{ filename ->
1514 into getdownResourceDir
1519 fileTree(file(package_dir)).each{ f ->
1520 if (f.isDirectory()) {
1521 def files = fileTree(dir: f, include: ["*"]).getFiles()
1523 } else if (f.exists()) {
1527 codeFiles.sort().each{f ->
1528 def name = f.getName()
1529 def line = "code = ${getdownAppDistDir}/${name}\n"
1530 getdownTextString += line
1537 // NOT USING MODULES YET, EVERYTHING SHOULD BE IN dist
1539 if (JAVA_VERSION.equals("11")) {
1540 def j11libFiles = fileTree(dir: "${jalviewDir}/${j11libDir}", include: ["*.jar"]).getFiles()
1541 j11libFiles.sort().each{f ->
1542 def name = f.getName()
1543 def line = "code = ${getdown_j11lib_dir}/${name}\n"
1544 getdownTextString += line
1547 into getdownJ11libDir
1553 // 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.
1554 //getdownTextString += "class = " + file(getdownLauncher).getName() + "\n"
1555 getdownTextString += "resource = ${getdown_launcher_new}\n"
1556 getdownTextString += "class = ${main_class}\n"
1558 def getdown_txt = file("${getdownWebsiteDir}/getdown.txt")
1559 getdown_txt.write(getdownTextString)
1561 def getdownLaunchJvl = getdown_launch_jvl_name + ( (jvlChannelName != null && jvlChannelName.length() > 0)?"-${jvlChannelName}":"" ) + ".jvl"
1562 def launchJvl = file("${getdownWebsiteDir}/${getdownLaunchJvl}")
1563 launchJvl.write("appbase=${getdownAppBase}")
1566 from getdownLauncher
1567 rename(file(getdownLauncher).getName(), getdown_launcher_new)
1568 into getdownWebsiteDir
1572 from getdownLauncher
1573 if (file(getdownLauncher).getName() != getdown_launcher) {
1574 rename(file(getdownLauncher).getName(), getdown_launcher)
1576 into getdownWebsiteDir
1579 if (! (CHANNEL.startsWith("ARCHIVE") || CHANNEL.startsWith("DEVELOP"))) {
1582 from getdownLauncher
1583 from "${getdownWebsiteDir}/${getdown_build_properties}"
1584 if (file(getdownLauncher).getName() != getdown_launcher) {
1585 rename(file(getdownLauncher).getName(), getdown_launcher)
1587 into getdownInstallDir
1591 from getdownInstallDir
1592 into getdownFilesInstallDir
1599 from getdownLauncher
1600 from "${getdownWebsiteDir}/${getdown_build_properties}"
1601 if (file(getdownLauncher).getName() != getdown_launcher) {
1602 rename(file(getdownLauncher).getName(), getdown_launcher)
1604 into getdownFilesDir
1608 from getdownResourceDir
1609 into "${getdownFilesDir}/${getdown_resource_dir}"
1614 inputs.dir("${jalviewDir}/${package_dir}")
1616 outputs.dir(getdownWebsiteDir)
1617 outputs.dir(getdownFilesDir)
1621 // a helper task to allow getdown digest of any dir: `gradle getdownDigestDir -PDIGESTDIR=/path/to/my/random/getdown/dir
1622 task getdownDigestDir(type: JavaExec) {
1624 description "A task to run a getdown Digest on a dir with getdown.txt. Provide a DIGESTDIR property via -PDIGESTDIR=..."
1626 def digestDirPropertyName = "DIGESTDIR"
1628 classpath = files(getdownLauncher)
1629 def digestDir = findProperty(digestDirPropertyName)
1630 if (digestDir == null) {
1631 throw new GradleException("Must provide a DIGESTDIR value to produce an alternative getdown digest")
1635 main = "com.threerings.getdown.tools.Digester"
1639 task getdownDigest(type: JavaExec) {
1640 group = "distribution"
1641 description = "Digest the getdown website folder"
1642 dependsOn getdownWebsite
1644 classpath = files(getdownLauncher)
1646 main = "com.threerings.getdown.tools.Digester"
1647 args getdownWebsiteDir
1648 inputs.dir(getdownWebsiteDir)
1649 outputs.file("${getdownWebsiteDir}/digest2.txt")
1654 group = "distribution"
1655 description = "Create the minimal and full getdown app folder for installers and website and create digest file"
1656 dependsOn getdownDigest
1658 if (reportRsyncCommand) {
1659 def fromDir = getdownWebsiteDir + (getdownWebsiteDir.endsWith('/')?'':'/')
1660 def toDir = "${getdown_rsync_dest}/${getdownDir}" + (getdownDir.endsWith('/')?'':'/')
1661 println "LIKELY RSYNC COMMAND:"
1662 println "mkdir -p '$toDir'\nrsync -avh --delete '$fromDir' '$toDir'"
1663 if (RUNRSYNC == "true") {
1665 commandLine "mkdir", "-p", toDir
1668 commandLine "rsync", "-avh", "--delete", fromDir, toDir
1676 tasks.withType(JavaCompile) {
1677 options.encoding = 'UTF-8'
1683 delete getdownWebsiteDir
1684 delete getdownFilesDir
1690 if (file(install4jHomeDir).exists()) {
1692 } else if (file(System.getProperty("user.home")+"/buildtools/install4j").exists()) {
1693 install4jHomeDir = System.getProperty("user.home")+"/buildtools/install4j"
1694 } else if (file("/Applications/install4j.app/Contents/Resources/app").exists()) {
1695 install4jHomeDir = "/Applications/install4j.app/Contents/Resources/app"
1697 installDir(file(install4jHomeDir))
1699 mediaTypes = Arrays.asList(install4j_media_types.split(","))
1703 task copyInstall4jTemplate {
1704 def install4jTemplateFile = file("${install4jDir}/${install4j_template}")
1705 def install4jFileAssociationsFile = file("${install4jDir}/${install4j_installer_file_associations}")
1706 inputs.file(install4jTemplateFile)
1707 inputs.file(install4jFileAssociationsFile)
1708 inputs.property("CHANNEL", { CHANNEL })
1709 outputs.file(install4jConfFile)
1712 def install4jConfigXml = new XmlParser().parse(install4jTemplateFile)
1714 // turn off code signing if no OSX_KEYPASS
1715 if (OSX_KEYPASS == "") {
1716 install4jConfigXml.'**'.codeSigning.each { codeSigning ->
1717 codeSigning.'@macEnabled' = "false"
1719 install4jConfigXml.'**'.windows.each { windows ->
1720 windows.'@runPostProcessor' = "false"
1724 // turn off checksum creation for LOCAL channel
1725 def e = install4jConfigXml.application[0]
1726 if (CHANNEL == "LOCAL") {
1727 e.'@createChecksums' = "false"
1729 e.'@createChecksums' = "true"
1732 // put file association actions where placeholder action is
1733 def install4jFileAssociationsText = install4jFileAssociationsFile.text
1734 def fileAssociationActions = new XmlParser().parseText("<actions>${install4jFileAssociationsText}</actions>")
1735 install4jConfigXml.'**'.action.any { a -> // .any{} stops after the first one that returns true
1736 if (a.'@name' == 'EXTENSIONS_REPLACED_BY_GRADLE') {
1737 def parent = a.parent()
1739 fileAssociationActions.each { faa ->
1742 // don't need to continue in .any loop once replacements have been made
1747 // use Windows Program Group with Examples folder for RELEASE, and Program Group without Examples for everything else
1748 // NB we're deleting the /other/ one!
1749 // Also remove the examples subdir from non-release versions
1750 def customizedIdToDelete = "PROGRAM_GROUP_RELEASE"
1751 // 2.11.1.0 NOT releasing with the Examples folder in the Program Group
1752 if (false && CHANNEL=="RELEASE") { // remove 'false && ' to include Examples folder in RELEASE channel
1753 customizedIdToDelete = "PROGRAM_GROUP_NON_RELEASE"
1755 // remove the examples subdir from Full File Set
1756 def files = install4jConfigXml.files[0]
1757 def fileset = files.filesets.fileset.find { fs -> fs.'@customizedId' == "FULL_FILE_SET" }
1758 def root = files.roots.root.find { r -> r.'@fileset' == fileset.'@id' }
1759 def mountPoint = files.mountPoints.mountPoint.find { mp -> mp.'@root' == root.'@id' }
1760 def dirEntry = files.entries.dirEntry.find { de -> de.'@mountPoint' == mountPoint.'@id' && de.'@subDirectory' == "examples" }
1761 dirEntry.parent().remove(dirEntry)
1763 install4jConfigXml.'**'.action.any { a ->
1764 if (a.'@customizedId' == customizedIdToDelete) {
1765 def parent = a.parent()
1771 // remove the "Uninstall Old Jalview (optional)" symlink from DMG for non-release DS_Stores
1772 if (! (CHANNEL == "RELEASE" || CHANNEL == "TEST-RELEASE" ) ) {
1773 def symlink = install4jConfigXml.'**'.topLevelFiles.symlink.find { sl -> sl.'@name' == "Uninstall Old Jalview (optional).app" }
1774 symlink.parent().remove(symlink)
1777 // write install4j file
1778 install4jConfFile.text = XmlUtil.serialize(install4jConfigXml)
1785 delete install4jConfFile
1790 task installers(type: com.install4j.gradle.Install4jTask) {
1791 group = "distribution"
1792 description = "Create the install4j installers"
1794 dependsOn copyInstall4jTemplate
1796 projectFile = install4jConfFile
1798 // create an md5 for the input files to use as version for install4j conf file
1799 def digest = MessageDigest.getInstance("MD5")
1801 (file("${install4jDir}/${install4j_template}").text +
1802 file("${install4jDir}/${install4j_info_plist_file_associations}").text +
1803 file("${install4jDir}/${install4j_installer_file_associations}").text).bytes)
1804 def filesMd5 = new BigInteger(1, digest.digest()).toString(16)
1805 if (filesMd5.length() >= 8) {
1806 filesMd5 = filesMd5.substring(0,8)
1808 def install4jTemplateVersion = "${JALVIEW_VERSION}_F${filesMd5}_C${gitHash}"
1809 // make install4jBuildDir relative to jalviewDir
1810 def install4jBuildDir = "${install4j_build_dir}/${JAVA_VERSION}"
1813 'JALVIEW_NAME': jalview_name,
1814 'JALVIEW_APPLICATION_NAME': install4jApplicationName,
1815 'JALVIEW_DIR': "../..",
1816 'OSX_KEYSTORE': OSX_KEYSTORE,
1817 'JSIGN_SH': JSIGN_SH,
1818 'JRE_DIR': getdown_app_dir_java,
1819 'INSTALLER_TEMPLATE_VERSION': install4jTemplateVersion,
1820 'JALVIEW_VERSION': JALVIEW_VERSION,
1821 'JAVA_MIN_VERSION': JAVA_MIN_VERSION,
1822 'JAVA_MAX_VERSION': JAVA_MAX_VERSION,
1823 'JAVA_VERSION': JAVA_VERSION,
1824 'JAVA_INTEGER_VERSION': JAVA_INTEGER_VERSION,
1825 'VERSION': JALVIEW_VERSION,
1826 'MACOS_JAVA_VM_DIR': macosJavaVMDir,
1827 'WINDOWS_JAVA_VM_DIR': windowsJavaVMDir,
1828 'LINUX_JAVA_VM_DIR': linuxJavaVMDir,
1829 'MACOS_JAVA_VM_TGZ': macosJavaVMTgz,
1830 'WINDOWS_JAVA_VM_TGZ': windowsJavaVMTgz,
1831 'LINUX_JAVA_VM_TGZ': linuxJavaVMTgz,
1832 'COPYRIGHT_MESSAGE': install4j_copyright_message,
1833 'BUNDLE_ID': install4jBundleId,
1834 'INTERNAL_ID': install4jInternalId,
1835 'WINDOWS_APPLICATION_ID': install4jWinApplicationId,
1836 'MACOS_DS_STORE': install4jDSStore,
1837 'MACOS_DMG_BG_IMAGE': install4jDMGBackgroundImage,
1838 'INSTALLER_NAME': install4jInstallerName,
1839 'INSTALL4J_UTILS_DIR': install4j_utils_dir,
1840 'GETDOWN_WEBSITE_DIR': getdown_website_dir,
1841 'GETDOWN_FILES_DIR': getdown_files_dir,
1842 'GETDOWN_RESOURCE_DIR': getdown_resource_dir,
1843 'GETDOWN_DIST_DIR': getdownAppDistDir,
1844 'GETDOWN_ALT_DIR': getdown_app_dir_alt,
1845 'GETDOWN_INSTALL_DIR': getdown_install_dir,
1846 'INFO_PLIST_FILE_ASSOCIATIONS_FILE': install4j_info_plist_file_associations,
1847 'BUILD_DIR': install4jBuildDir,
1848 'APPLICATION_CATEGORIES': install4j_application_categories,
1849 'APPLICATION_FOLDER': install4jApplicationFolder,
1850 'UNIX_APPLICATION_FOLDER': install4jUnixApplicationFolder,
1851 'EXECUTABLE_NAME': install4jExecutableName,
1852 'EXTRA_SCHEME': install4jExtraScheme,
1855 //println("INSTALL4J VARIABLES:")
1856 //variables.each{k,v->println("${k}=${v}")}
1858 destination = "${jalviewDir}/${install4jBuildDir}"
1859 buildSelected = true
1861 if (install4j_faster.equals("true") || CHANNEL.startsWith("LOCAL")) {
1863 disableSigning = true
1867 macKeystorePassword = OSX_KEYPASS
1871 println("Using projectFile "+projectFile)
1874 inputs.dir(getdownWebsiteDir)
1875 inputs.file(install4jConfFile)
1876 inputs.file("${install4jDir}/${install4j_info_plist_file_associations}")
1877 inputs.dir(macosJavaVMDir)
1878 inputs.dir(windowsJavaVMDir)
1879 outputs.dir("${jalviewDir}/${install4j_build_dir}/${JAVA_VERSION}")
1885 eclipse().configFile(eclipse_codestyle_file)
1890 task sourceDist(type: Tar) {
1891 group "distribution"
1892 description "Create a source .tar.gz file for distribution"
1894 dependsOn convertMdFiles
1896 def VERSION_UNDERSCORES = JALVIEW_VERSION.replaceAll("\\.", "_")
1897 def outputFileName = "${project.name}_${VERSION_UNDERSCORES}.tar.gz"
1898 archiveFileName = outputFileName
1900 compression Compression.GZIP
1915 "**/*.class","$j11modDir/**/*.jar","appletlib","**/*locales",
1917 "utils/InstallAnywhere",
1932 "gradle.properties",
1943 ".settings/org.eclipse.jdt.core.jalview.prefs",
1947 exclude (EXCLUDE_FILES)
1948 include (PROCESS_FILES)
1949 filter(ReplaceTokens,
1953 'Version-Rel': JALVIEW_VERSION,
1954 'Year-Rel': getDate("yyyy")
1959 exclude (EXCLUDE_FILES)
1960 exclude (PROCESS_FILES)
1961 exclude ("appletlib")
1962 exclude ("**/*locales")
1963 exclude ("*locales/**")
1964 exclude ("utils/InstallAnywhere")
1966 exclude (getdown_files_dir)
1967 exclude (getdown_website_dir)
1969 // exluding these as not using jars as modules yet
1970 exclude ("${j11modDir}/**/*.jar")
1973 include(INCLUDE_FILES)
1975 // from (jalviewDir) {
1976 // // explicit includes for stuff that seemed to not get included
1977 // include(fileTree("test/**/*."))
1978 // exclude(EXCLUDE_FILES)
1979 // exclude(PROCESS_FILES)
1986 dependsOn pubhtmlhelp
1988 inputs.dir("${helpBuildDir}/${help_dir}")
1989 outputs.dir("${buildDir}/distributions/${help_dir}")
1993 task j2sSetHeadlessBuild {
2000 task jalviewjsSetEclipseWorkspace {
2001 def propKey = "jalviewjs_eclipse_workspace"
2003 if (project.hasProperty(propKey)) {
2004 propVal = project.getProperty(propKey)
2005 if (propVal.startsWith("~/")) {
2006 propVal = System.getProperty("user.home") + propVal.substring(1)
2009 def propsFileName = "${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_eclipse_workspace_location_file}"
2010 def propsFile = file(propsFileName)
2011 def eclipseWsDir = propVal
2012 def props = new Properties()
2014 def writeProps = true
2015 if (( eclipseWsDir == null || !file(eclipseWsDir).exists() ) && propsFile.exists()) {
2016 def ins = new FileInputStream(propsFileName)
2019 if (props.getProperty(propKey, null) != null) {
2020 eclipseWsDir = props.getProperty(propKey)
2025 if (eclipseWsDir == null || !file(eclipseWsDir).exists()) {
2026 def tempDir = File.createTempDir()
2027 eclipseWsDir = tempDir.getAbsolutePath()
2030 eclipseWorkspace = file(eclipseWsDir)
2033 // do not run a headless transpile when we claim to be in Eclipse
2035 println("Skipping task ${name} as IN_ECLIPSE=${IN_ECLIPSE}")
2036 throw new StopExecutionException("Not running headless transpile whilst IN_ECLIPSE is '${IN_ECLIPSE}'")
2038 println("Running task ${name} as IN_ECLIPSE=${IN_ECLIPSE}")
2042 props.setProperty(propKey, eclipseWsDir)
2043 propsFile.parentFile.mkdirs()
2044 def bytes = new ByteArrayOutputStream()
2045 props.store(bytes, null)
2046 def propertiesString = bytes.toString()
2047 propsFile.text = propertiesString
2053 println("ECLIPSE WORKSPACE: "+eclipseWorkspace.getPath())
2056 //inputs.property(propKey, eclipseWsDir) // eclipseWsDir only gets set once this task runs, so will be out-of-date
2057 outputs.file(propsFileName)
2058 outputs.upToDateWhen { eclipseWorkspace.exists() && propsFile.exists() }
2062 task jalviewjsEclipsePaths {
2065 def eclipseRoot = jalviewjs_eclipse_root
2066 if (eclipseRoot.startsWith("~/")) {
2067 eclipseRoot = System.getProperty("user.home") + eclipseRoot.substring(1)
2069 if (OperatingSystem.current().isMacOsX()) {
2070 eclipseRoot += "/Eclipse.app"
2071 eclipseBinary = "${eclipseRoot}/Contents/MacOS/eclipse"
2072 eclipseProduct = "${eclipseRoot}/Contents/Eclipse/.eclipseproduct"
2073 } else if (OperatingSystem.current().isWindows()) { // check these paths!!
2074 if (file("${eclipseRoot}/eclipse").isDirectory() && file("${eclipseRoot}/eclipse/.eclipseproduct").exists()) {
2075 eclipseRoot += "/eclipse"
2077 eclipseBinary = "${eclipseRoot}/eclipse.exe"
2078 eclipseProduct = "${eclipseRoot}/.eclipseproduct"
2079 } else { // linux or unix
2080 if (file("${eclipseRoot}/eclipse").isDirectory() && file("${eclipseRoot}/eclipse/.eclipseproduct").exists()) {
2081 eclipseRoot += "/eclipse"
2082 println("eclipseDir exists")
2084 eclipseBinary = "${eclipseRoot}/eclipse"
2085 eclipseProduct = "${eclipseRoot}/.eclipseproduct"
2088 eclipseVersion = "4.13" // default
2089 def assumedVersion = true
2090 if (file(eclipseProduct).exists()) {
2091 def fis = new FileInputStream(eclipseProduct)
2092 def props = new Properties()
2094 eclipseVersion = props.getProperty("version")
2096 assumedVersion = false
2099 def propKey = "eclipse_debug"
2100 eclipseDebug = (project.hasProperty(propKey) && project.getProperty(propKey).equals("true"))
2103 // do not run a headless transpile when we claim to be in Eclipse
2105 println("Skipping task ${name} as IN_ECLIPSE=${IN_ECLIPSE}")
2106 throw new StopExecutionException("Not running headless transpile whilst IN_ECLIPSE is '${IN_ECLIPSE}'")
2108 println("Running task ${name} as IN_ECLIPSE=${IN_ECLIPSE}")
2111 if (!assumedVersion) {
2112 println("ECLIPSE VERSION=${eclipseVersion}")
2118 task printProperties {
2120 description "Output to console all System.properties"
2122 System.properties.each { key, val -> System.out.println("Property: ${key}=${val}") }
2128 dependsOn eclipseProject
2129 dependsOn eclipseClasspath
2130 dependsOn eclipseJdt
2134 // this version (type: Copy) will delete anything in the eclipse dropins folder that isn't in fromDropinsDir
2135 task jalviewjsEclipseCopyDropins(type: Copy) {
2136 dependsOn jalviewjsEclipsePaths
2138 def inputFiles = fileTree(dir: "${jalviewDir}/${jalviewjs_eclipse_dropins_dir}", include: "*.jar")
2139 inputFiles += file("${jalviewDir}/${jalviewjsJ2sPlugin}")
2140 def outputDir = "${jalviewDir}/${jalviewjsBuildDir}/${jalviewjs_eclipse_tmp_dropins_dir}"
2147 // this eclipse -clean doesn't actually work
2148 task jalviewjsCleanEclipse(type: Exec) {
2149 dependsOn eclipseSetup
2150 dependsOn jalviewjsEclipsePaths
2151 dependsOn jalviewjsEclipseCopyDropins
2153 executable(eclipseBinary)
2154 args(["-nosplash", "--launcher.suppressErrors", "-data", eclipseWorkspace.getPath(), "-clean", "-console", "-consoleLog"])
2160 def inputString = """exit
2163 def inputByteStream = new ByteArrayInputStream(inputString.getBytes())
2164 standardInput = inputByteStream
2167 /* not really working yet
2168 jalviewjsEclipseCopyDropins.finalizedBy jalviewjsCleanEclipse
2172 task jalviewjsTransferUnzipSwingJs {
2173 def file_zip = "${jalviewDir}/${jalviewjs_swingjs_zip}"
2177 from zipTree(file_zip)
2178 into "${jalviewDir}/${jalviewjsTransferSiteSwingJsDir}"
2182 inputs.file file_zip
2183 outputs.dir "${jalviewDir}/${jalviewjsTransferSiteSwingJsDir}"
2187 task jalviewjsTransferUnzipLib {
2188 def zipFiles = fileTree(dir: "${jalviewDir}/${jalviewjs_libjs_dir}", include: "*.zip")
2191 zipFiles.each { file_zip ->
2193 from zipTree(file_zip)
2194 into "${jalviewDir}/${jalviewjsTransferSiteLibDir}"
2199 inputs.files zipFiles
2200 outputs.dir "${jalviewDir}/${jalviewjsTransferSiteLibDir}"
2204 task jalviewjsTransferUnzipAllLibs {
2205 dependsOn jalviewjsTransferUnzipSwingJs
2206 dependsOn jalviewjsTransferUnzipLib
2210 task jalviewjsCreateJ2sSettings(type: WriteProperties) {
2212 description "Create the .j2s file from the j2s.* properties"
2214 jalviewjsJ2sProps = project.properties.findAll { it.key.startsWith("j2s.") }.sort { it.key }
2215 def siteDirProperty = "j2s.site.directory"
2216 def setSiteDir = false
2217 jalviewjsJ2sProps.each { prop, val ->
2219 if (prop == siteDirProperty) {
2220 if (!(val.startsWith('/') || val.startsWith("file://") )) {
2221 val = "${jalviewDir}/${jalviewjsTransferSiteJsDir}/${val}"
2227 if (!setSiteDir) { // default site location, don't override specifically set property
2228 property(siteDirProperty,"${jalviewDirRelativePath}/${jalviewjsTransferSiteJsDir}")
2231 outputFile = jalviewjsJ2sSettingsFileName
2234 inputs.properties(jalviewjsJ2sProps)
2235 outputs.file(jalviewjsJ2sSettingsFileName)
2240 task jalviewjsEclipseSetup {
2241 dependsOn jalviewjsEclipseCopyDropins
2242 dependsOn jalviewjsSetEclipseWorkspace
2243 dependsOn jalviewjsCreateJ2sSettings
2247 task jalviewjsSyncAllLibs (type: Sync) {
2248 dependsOn jalviewjsTransferUnzipAllLibs
2249 def inputFiles = fileTree(dir: "${jalviewDir}/${jalviewjsTransferSiteLibDir}")
2250 inputFiles += fileTree(dir: "${jalviewDir}/${jalviewjsTransferSiteSwingJsDir}")
2251 def outputDir = "${jalviewDir}/${jalviewjsSiteDir}"
2255 def outputFiles = []
2256 rename { filename ->
2257 outputFiles += "${outputDir}/${filename}"
2263 outputs.files outputFiles
2264 inputs.files inputFiles
2268 task jalviewjsSyncResources (type: Sync) {
2269 def inputFiles = fileTree(dir: resourceDir)
2270 def outputDir = "${jalviewDir}/${jalviewjsSiteDir}/${jalviewjs_j2s_subdir}"
2274 def outputFiles = []
2275 rename { filename ->
2276 outputFiles += "${outputDir}/${filename}"
2282 outputs.files outputFiles
2283 inputs.files inputFiles
2287 task jalviewjsSyncSiteResources (type: Sync) {
2288 def inputFiles = fileTree(dir: "${jalviewDir}/${jalviewjs_site_resource_dir}")
2289 def outputDir = "${jalviewDir}/${jalviewjsSiteDir}"
2293 def outputFiles = []
2294 rename { filename ->
2295 outputFiles += "${outputDir}/${filename}"
2301 outputs.files outputFiles
2302 inputs.files inputFiles
2306 task jalviewjsSyncBuildProperties (type: Sync) {
2307 dependsOn createBuildProperties
2308 def inputFiles = [file(buildProperties)]
2309 def outputDir = "${jalviewDir}/${jalviewjsSiteDir}/${jalviewjs_j2s_subdir}"
2313 def outputFiles = []
2314 rename { filename ->
2315 outputFiles += "${outputDir}/${filename}"
2321 outputs.files outputFiles
2322 inputs.files inputFiles
2326 task jalviewjsProjectImport(type: Exec) {
2327 dependsOn eclipseSetup
2328 dependsOn jalviewjsEclipsePaths
2329 dependsOn jalviewjsEclipseSetup
2332 // do not run a headless import when we claim to be in Eclipse
2334 println("Skipping task ${name} as IN_ECLIPSE=${IN_ECLIPSE}")
2335 throw new StopExecutionException("Not running headless import whilst IN_ECLIPSE is '${IN_ECLIPSE}'")
2337 println("Running task ${name} as IN_ECLIPSE=${IN_ECLIPSE}")
2341 //def projdir = eclipseWorkspace.getPath()+"/.metadata/.plugins/org.eclipse.core.resources/.projects/jalview/org.eclipse.jdt.core"
2342 def projdir = eclipseWorkspace.getPath()+"/.metadata/.plugins/org.eclipse.core.resources/.projects/jalview"
2343 executable(eclipseBinary)
2344 args(["-nosplash", "--launcher.suppressErrors", "-application", "com.seeq.eclipse.importprojects.headlessimport", "-data", eclipseWorkspace.getPath(), "-import", jalviewDirAbsolutePath])
2348 args += [ "--launcher.appendVmargs", "-vmargs", "-Dorg.eclipse.equinox.p2.reconciler.dropins.directory=${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_eclipse_tmp_dropins_dir}" ]
2350 args += [ "-D${j2sHeadlessBuildProperty}=true" ]
2353 inputs.file("${jalviewDir}/.project")
2354 outputs.upToDateWhen {
2355 file(projdir).exists()
2360 task jalviewjsTranspile(type: Exec) {
2361 dependsOn jalviewjsEclipseSetup
2362 dependsOn jalviewjsProjectImport
2363 dependsOn jalviewjsEclipsePaths
2366 // do not run a headless transpile when we claim to be in Eclipse
2368 println("Skipping task ${name} as IN_ECLIPSE=${IN_ECLIPSE}")
2369 throw new StopExecutionException("Not running headless transpile whilst IN_ECLIPSE is '${IN_ECLIPSE}'")
2371 println("Running task ${name} as IN_ECLIPSE=${IN_ECLIPSE}")
2375 executable(eclipseBinary)
2376 args(["-nosplash", "--launcher.suppressErrors", "-application", "org.eclipse.jdt.apt.core.aptBuild", "-data", eclipseWorkspace, "-${jalviewjs_eclipse_build_arg}", eclipse_project_name ])
2380 args += [ "--launcher.appendVmargs", "-vmargs", "-Dorg.eclipse.equinox.p2.reconciler.dropins.directory=${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_eclipse_tmp_dropins_dir}" ]
2382 args += [ "-D${j2sHeadlessBuildProperty}=true" ]
2388 stdout = new ByteArrayOutputStream()
2389 stderr = new ByteArrayOutputStream()
2391 def logOutFileName = "${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_j2s_transpile_stdout}"
2392 def logOutFile = file(logOutFileName)
2393 logOutFile.createNewFile()
2394 logOutFile.text = """ROOT: ${jalviewjs_eclipse_root}
2395 BINARY: ${eclipseBinary}
2396 VERSION: ${eclipseVersion}
2397 WORKSPACE: ${eclipseWorkspace}
2398 DEBUG: ${eclipseDebug}
2401 def logOutFOS = new FileOutputStream(logOutFile, true) // true == append
2402 // combine stdout and stderr
2403 def logErrFOS = logOutFOS
2405 if (jalviewjs_j2s_to_console.equals("true")) {
2406 standardOutput = new org.apache.tools.ant.util.TeeOutputStream(
2407 new org.apache.tools.ant.util.TeeOutputStream(
2411 errorOutput = new org.apache.tools.ant.util.TeeOutputStream(
2412 new org.apache.tools.ant.util.TeeOutputStream(
2417 standardOutput = new org.apache.tools.ant.util.TeeOutputStream(
2420 errorOutput = new org.apache.tools.ant.util.TeeOutputStream(
2427 if (stdout.toString().contains("Error processing ")) {
2428 // j2s did not complete transpile
2429 //throw new TaskExecutionException("Error during transpilation:\n${stderr}\nSee eclipse transpile log file '${jalviewDir}/${jalviewjsBuildDir}/${jalviewjs_j2s_transpile_stdout}'")
2430 if (jalviewjs_ignore_transpile_errors.equals("true")) {
2431 println("IGNORING TRANSPILE ERRORS")
2432 println("See eclipse transpile log file '${jalviewDir}/${jalviewjsBuildDir}/${jalviewjs_j2s_transpile_stdout}'")
2434 throw new GradleException("Error during transpilation:\n${stderr}\nSee eclipse transpile log file '${jalviewDir}/${jalviewjsBuildDir}/${jalviewjs_j2s_transpile_stdout}'")
2439 inputs.dir("${jalviewDir}/${sourceDir}")
2440 outputs.dir("${jalviewDir}/${jalviewjsTransferSiteJsDir}")
2441 outputs.upToDateWhen( { file("${jalviewDir}/${jalviewjsTransferSiteJsDir}${jalviewjs_server_resource}").exists() } )
2445 def jalviewjsCallCore(String name, FileCollection list, String prefixFile, String suffixFile, String jsfile, String zjsfile, File logOutFile, Boolean logOutConsole) {
2447 def stdout = new ByteArrayOutputStream()
2448 def stderr = new ByteArrayOutputStream()
2450 def coreFile = file(jsfile)
2452 msg = "Creating core for ${name}...\nGenerating ${jsfile}"
2454 logOutFile.createNewFile()
2455 logOutFile.append(msg+"\n")
2457 def coreTop = file(prefixFile)
2458 def coreBottom = file(suffixFile)
2459 coreFile.getParentFile().mkdirs()
2460 coreFile.createNewFile()
2461 coreFile.write( coreTop.getText("UTF-8") )
2465 def t = f.getText("UTF-8")
2466 t.replaceAll("Clazz\\.([^_])","Clazz_${1}")
2467 coreFile.append( t )
2469 msg = "...file '"+f.getPath()+"' does not exist, skipping"
2471 logOutFile.append(msg+"\n")
2474 coreFile.append( coreBottom.getText("UTF-8") )
2476 msg = "Generating ${zjsfile}"
2478 logOutFile.append(msg+"\n")
2479 def logOutFOS = new FileOutputStream(logOutFile, true) // true == append
2480 def logErrFOS = logOutFOS
2483 classpath = files(["${jalviewDir}/${jalviewjs_closure_compiler}"])
2484 main = "com.google.javascript.jscomp.CommandLineRunner"
2485 jvmArgs = [ "-Dfile.encoding=UTF-8" ]
2486 args = [ "--compilation_level", "SIMPLE_OPTIMIZATIONS", "--warning_level", "QUIET", "--charset", "UTF-8", "--js", jsfile, "--js_output_file", zjsfile ]
2489 msg = "\nRunning '"+commandLine.join(' ')+"'\n"
2491 logOutFile.append(msg+"\n")
2493 if (logOutConsole) {
2494 standardOutput = new org.apache.tools.ant.util.TeeOutputStream(
2495 new org.apache.tools.ant.util.TeeOutputStream(
2499 errorOutput = new org.apache.tools.ant.util.TeeOutputStream(
2500 new org.apache.tools.ant.util.TeeOutputStream(
2505 standardOutput = new org.apache.tools.ant.util.TeeOutputStream(
2508 errorOutput = new org.apache.tools.ant.util.TeeOutputStream(
2515 logOutFile.append(msg+"\n")
2519 task jalviewjsBuildAllCores {
2521 description "Build the core js lib closures listed in the classlists dir"
2522 dependsOn jalviewjsTranspile
2523 dependsOn jalviewjsTransferUnzipSwingJs
2525 def j2sDir = "${jalviewDir}/${jalviewjsTransferSiteJsDir}/${jalviewjs_j2s_subdir}"
2526 def swingJ2sDir = "${jalviewDir}/${jalviewjsTransferSiteSwingJsDir}/${jalviewjs_j2s_subdir}"
2527 def libJ2sDir = "${jalviewDir}/${jalviewjsTransferSiteLibDir}/${jalviewjs_j2s_subdir}"
2528 def jsDir = "${jalviewDir}/${jalviewjsTransferSiteSwingJsDir}/${jalviewjs_js_subdir}"
2529 def outputDir = "${jalviewDir}/${jalviewjsTransferSiteCoreDir}/${jalviewjs_j2s_subdir}/core"
2530 def prefixFile = "${jsDir}/core/coretop2.js"
2531 def suffixFile = "${jsDir}/core/corebottom2.js"
2533 inputs.file prefixFile
2534 inputs.file suffixFile
2536 def classlistFiles = []
2537 // add the classlists found int the jalviewjs_classlists_dir
2538 fileTree(dir: "${jalviewDir}/${jalviewjs_classlists_dir}", include: "*.txt").each {
2540 def name = file.getName() - ".txt"
2547 // _jmol and _jalview cores. Add any other peculiar classlist.txt files here
2548 //classlistFiles += [ 'file': file("${jalviewDir}/${jalviewjs_classlist_jmol}"), 'name': "_jvjmol" ]
2549 classlistFiles += [ 'file': file("${jalviewDir}/${jalviewjs_classlist_jalview}"), 'name': jalviewjsJalviewCoreName ]
2551 jalviewjsCoreClasslists = []
2553 classlistFiles.each {
2556 def file = hash['file']
2557 if (! file.exists()) {
2558 //println("...classlist file '"+file.getPath()+"' does not exist, skipping")
2559 return false // this is a "continue" in groovy .each closure
2561 def name = hash['name']
2563 name = file.getName() - ".txt"
2571 def list = fileTree(dir: j2sDir, includes: filelist)
2573 def jsfile = "${outputDir}/core${name}.js"
2574 def zjsfile = "${outputDir}/core${name}.z.js"
2576 jalviewjsCoreClasslists += [
2585 outputs.file(jsfile)
2586 outputs.file(zjsfile)
2589 // _stevesoft core. add any cores without a classlist here (and the inputs and outputs)
2590 def stevesoftClasslistName = "_stevesoft"
2591 def stevesoftClasslist = [
2592 'jsfile': "${outputDir}/core${stevesoftClasslistName}.js",
2593 'zjsfile': "${outputDir}/core${stevesoftClasslistName}.z.js",
2594 'list': fileTree(dir: j2sDir, include: "com/stevesoft/pat/**/*.js"),
2595 'name': stevesoftClasslistName
2597 jalviewjsCoreClasslists += stevesoftClasslist
2598 inputs.files(stevesoftClasslist['list'])
2599 outputs.file(stevesoftClasslist['jsfile'])
2600 outputs.file(stevesoftClasslist['zjsfile'])
2603 def allClasslistName = "_all"
2604 def allJsFiles = fileTree(dir: j2sDir, include: "**/*.js")
2605 allJsFiles += fileTree(
2609 // these exlusions are files that the closure-compiler produces errors for. Should fix them
2610 "**/org/jmol/jvxl/readers/IsoIntersectFileReader.js",
2611 "**/org/jmol/export/JSExporter.js"
2614 allJsFiles += fileTree(
2618 // these exlusions are files that the closure-compiler produces errors for. Should fix them
2619 "**/sun/misc/Unsafe.js",
2620 "**/swingjs/jquery/jquery-editable-select.js",
2621 "**/swingjs/jquery/j2sComboBox.js",
2622 "**/sun/misc/FloatingDecimal.js"
2625 def allClasslist = [
2626 'jsfile': "${outputDir}/core${allClasslistName}.js",
2627 'zjsfile': "${outputDir}/core${allClasslistName}.z.js",
2629 'name': allClasslistName
2631 // not including this version of "all" core at the moment
2632 //jalviewjsCoreClasslists += allClasslist
2633 inputs.files(allClasslist['list'])
2634 outputs.file(allClasslist['jsfile'])
2635 outputs.file(allClasslist['zjsfile'])
2638 def logOutFile = file("${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_j2s_closure_stdout}")
2639 logOutFile.getParentFile().mkdirs()
2640 logOutFile.createNewFile()
2641 logOutFile.write(getDate("yyyy-MM-dd HH:mm:ss")+" jalviewjsBuildAllCores\n----\n")
2643 jalviewjsCoreClasslists.each {
2644 jalviewjsCallCore(it.name, it.list, prefixFile, suffixFile, it.jsfile, it.zjsfile, logOutFile, jalviewjs_j2s_to_console.equals("true"))
2651 def jalviewjsPublishCoreTemplate(String coreName, String templateName, File inputFile, String outputFile) {
2654 into file(outputFile).getParentFile()
2655 rename { filename ->
2656 if (filename.equals(inputFile.getName())) {
2657 return file(outputFile).getName()
2661 filter(ReplaceTokens,
2665 'MAIN': '"'+main_class+'"',
2667 'NAME': jalviewjsJalviewTemplateName+" [core ${coreName}]",
2668 'COREKEY': jalviewjs_core_key,
2669 'CORENAME': coreName
2676 task jalviewjsPublishCoreTemplates {
2677 dependsOn jalviewjsBuildAllCores
2678 def inputFileName = "${jalviewDir}/${j2s_coretemplate_html}"
2679 def inputFile = file(inputFileName)
2680 def outputDir = "${jalviewDir}/${jalviewjsTransferSiteCoreDir}"
2682 def outputFiles = []
2683 jalviewjsCoreClasslists.each { cl ->
2684 def outputFile = "${outputDir}/${jalviewjsJalviewTemplateName}_${cl.name}.html"
2685 cl['outputfile'] = outputFile
2686 outputFiles += outputFile
2690 jalviewjsCoreClasslists.each { cl ->
2691 jalviewjsPublishCoreTemplate(cl.name, jalviewjsJalviewTemplateName, inputFile, cl.outputfile)
2694 inputs.file(inputFile)
2695 outputs.files(outputFiles)
2699 task jalviewjsSyncCore (type: Sync) {
2700 dependsOn jalviewjsBuildAllCores
2701 dependsOn jalviewjsPublishCoreTemplates
2702 def inputFiles = fileTree(dir: "${jalviewDir}/${jalviewjsTransferSiteCoreDir}")
2703 def outputDir = "${jalviewDir}/${jalviewjsSiteDir}"
2707 def outputFiles = []
2708 rename { filename ->
2709 outputFiles += "${outputDir}/${filename}"
2715 outputs.files outputFiles
2716 inputs.files inputFiles
2720 // this Copy version of TransferSiteJs will delete anything else in the target dir
2721 task jalviewjsCopyTransferSiteJs(type: Copy) {
2722 dependsOn jalviewjsTranspile
2723 from "${jalviewDir}/${jalviewjsTransferSiteJsDir}"
2724 into "${jalviewDir}/${jalviewjsSiteDir}"
2728 // this Sync version of TransferSite is used by buildship to keep the website automatically up to date when a file changes
2729 task jalviewjsSyncTransferSiteJs(type: Sync) {
2730 from "${jalviewDir}/${jalviewjsTransferSiteJsDir}"
2732 into "${jalviewDir}/${jalviewjsSiteDir}"
2739 jalviewjsSyncAllLibs.mustRunAfter jalviewjsCopyTransferSiteJs
2740 jalviewjsSyncResources.mustRunAfter jalviewjsCopyTransferSiteJs
2741 jalviewjsSyncSiteResources.mustRunAfter jalviewjsCopyTransferSiteJs
2742 jalviewjsSyncBuildProperties.mustRunAfter jalviewjsCopyTransferSiteJs
2744 jalviewjsSyncAllLibs.mustRunAfter jalviewjsSyncTransferSiteJs
2745 jalviewjsSyncResources.mustRunAfter jalviewjsSyncTransferSiteJs
2746 jalviewjsSyncSiteResources.mustRunAfter jalviewjsSyncTransferSiteJs
2747 jalviewjsSyncBuildProperties.mustRunAfter jalviewjsSyncTransferSiteJs
2750 task jalviewjsPrepareSite {
2752 description "Prepares the website folder including unzipping files and copying resources"
2753 dependsOn jalviewjsSyncAllLibs
2754 dependsOn jalviewjsSyncResources
2755 dependsOn jalviewjsSyncSiteResources
2756 dependsOn jalviewjsSyncBuildProperties
2757 dependsOn jalviewjsSyncCore
2761 task jalviewjsBuildSite {
2763 description "Builds the whole website including transpiled code"
2764 dependsOn jalviewjsCopyTransferSiteJs
2765 dependsOn jalviewjsPrepareSite
2769 task cleanJalviewjsTransferSite {
2771 delete "${jalviewDir}/${jalviewjsTransferSiteJsDir}"
2772 delete "${jalviewDir}/${jalviewjsTransferSiteLibDir}"
2773 delete "${jalviewDir}/${jalviewjsTransferSiteSwingJsDir}"
2774 delete "${jalviewDir}/${jalviewjsTransferSiteCoreDir}"
2779 task cleanJalviewjsSite {
2780 dependsOn cleanJalviewjsTransferSite
2782 delete "${jalviewDir}/${jalviewjsSiteDir}"
2787 task jalviewjsSiteTar(type: Tar) {
2789 description "Creates a tar.gz file for the website"
2790 dependsOn jalviewjsBuildSite
2791 def outputFilename = "jalviewjs-site-${JALVIEW_VERSION}.tar.gz"
2792 archiveFileName = outputFilename
2794 compression Compression.GZIP
2796 from "${jalviewDir}/${jalviewjsSiteDir}"
2797 into jalviewjs_site_dir // this is inside the tar file
2799 inputs.dir("${jalviewDir}/${jalviewjsSiteDir}")
2803 task jalviewjsServer {
2805 def filename = "jalviewjsTest.html"
2806 description "Starts a webserver on localhost to test the website. See ${filename} to access local site on most recently used port."
2807 def htmlFile = "${jalviewDirAbsolutePath}/${filename}"
2810 SimpleHttpFileServerFactory factory = new SimpleHttpFileServerFactory()
2811 def port = Integer.valueOf(jalviewjs_server_port)
2816 while(port < start+1000 && !running) {
2818 def doc_root = new File("${jalviewDirAbsolutePath}/${jalviewjsSiteDir}")
2819 jalviewjsServer = factory.start(doc_root, port)
2821 url = jalviewjsServer.getResourceUrl(jalviewjs_server_resource)
2822 println("SERVER STARTED with document root ${doc_root}.")
2823 println("Go to "+url+" . Run gradle --stop to stop (kills all gradle daemons).")
2824 println("For debug: "+url+"?j2sdebug")
2825 println("For verbose: "+url+"?j2sverbose")
2826 } catch (Exception e) {
2831 <p><a href="${url}">JalviewJS Test. <${url}></a></p>
2832 <p><a href="${url}?j2sdebug">JalviewJS Test with debug. <${url}?j2sdebug></a></p>
2833 <p><a href="${url}?j2sverbose">JalviewJS Test with verbose. <${url}?j2sdebug></a></p>
2835 jalviewjsCoreClasslists.each { cl ->
2836 def urlcore = jalviewjsServer.getResourceUrl(file(cl.outputfile).getName())
2838 <p><a href="${urlcore}">${jalviewjsJalviewTemplateName} [core ${cl.name}]. <${urlcore}></a></p>
2840 println("For core ${cl.name}: "+urlcore)
2843 file(htmlFile).text = htmlText
2846 outputs.file(htmlFile)
2847 outputs.upToDateWhen({false})
2851 task cleanJalviewjsAll {
2853 description "Delete all configuration and build artifacts to do with JalviewJS build"
2854 dependsOn cleanJalviewjsSite
2855 dependsOn jalviewjsEclipsePaths
2858 delete "${jalviewDir}/${jalviewjsBuildDir}"
2859 delete "${jalviewDir}/${eclipse_bin_dir}"
2860 if (eclipseWorkspace != null && file(eclipseWorkspace.getAbsolutePath()+"/.metadata").exists()) {
2861 delete file(eclipseWorkspace.getAbsolutePath()+"/.metadata")
2863 delete "${jalviewDir}/${jalviewjs_j2s_settings}"
2866 outputs.upToDateWhen( { false } )
2870 task jalviewjsIDE_checkJ2sPlugin {
2871 group "00 JalviewJS in Eclipse"
2872 description "Compare the swingjs/net.sf.j2s.core(-j11)?.jar file with the Eclipse IDE's plugin version (found in the 'dropins' dir)"
2875 def j2sPlugin = string("${jalviewDir}/${jalviewjsJ2sPlugin}")
2876 def j2sPluginFile = file(j2sPlugin)
2877 def eclipseHome = System.properties["eclipse.home.location"]
2878 if (eclipseHome == null || ! IN_ECLIPSE) {
2879 throw new StopExecutionException("Cannot find running Eclipse home from System.properties['eclipse.home.location']. Skipping J2S Plugin Check.")
2881 def eclipseJ2sPluginDirs = [ "${eclipseHome}/dropins" ]
2882 def altPluginsDir = System.properties["org.eclipse.equinox.p2.reconciler.dropins.directory"]
2883 if (altPluginsDir != null && file(altPluginsDir).exists()) {
2884 eclipseJ2sPluginDirs += altPluginsDir
2886 def foundPlugin = false
2887 def j2sPluginFileName = j2sPluginFile.getName()
2888 def eclipseJ2sPlugin
2889 def eclipseJ2sPluginFile
2890 eclipseJ2sPluginDirs.any { dir ->
2891 eclipseJ2sPlugin = "${dir}/${j2sPluginFileName}"
2892 eclipseJ2sPluginFile = file(eclipseJ2sPlugin)
2893 if (eclipseJ2sPluginFile.exists()) {
2899 def msg = "Eclipse J2S Plugin is not installed (could not find '${j2sPluginFileName}' in\n"+eclipseJ2sPluginDirs.join("\n")+"\n)\nTry running task jalviewjsIDE_copyJ2sPlugin"
2900 System.err.println(msg)
2901 throw new StopExecutionException(msg)
2904 def digest = MessageDigest.getInstance("MD5")
2906 digest.update(j2sPluginFile.text.bytes)
2907 def j2sPluginMd5 = new BigInteger(1, digest.digest()).toString(16).padLeft(32, '0')
2909 digest.update(eclipseJ2sPluginFile.text.bytes)
2910 def eclipseJ2sPluginMd5 = new BigInteger(1, digest.digest()).toString(16).padLeft(32, '0')
2912 if (j2sPluginMd5 != eclipseJ2sPluginMd5) {
2913 def msg = "WARNING! Eclipse J2S Plugin '${eclipseJ2sPlugin}' is different to this commit's version '${j2sPlugin}'"
2914 System.err.println(msg)
2915 throw new StopExecutionException(msg)
2917 def msg = "Eclipse J2S Plugin '${eclipseJ2sPlugin}' is the same as '${j2sPlugin}' (this is good)"
2923 task jalviewjsIDE_copyJ2sPlugin {
2924 group "00 JalviewJS in Eclipse"
2925 description "Copy the swingjs/net.sf.j2s.core(-j11)?.jar file into the Eclipse IDE's 'dropins' dir"
2928 def j2sPlugin = string("${jalviewDir}/${jalviewjsJ2sPlugin}")
2929 def j2sPluginFile = file(j2sPlugin)
2930 def eclipseHome = System.properties["eclipse.home.location"]
2931 if (eclipseHome == null || ! IN_ECLIPSE) {
2932 throw new StopExecutionException("Cannot find running Eclipse home from System.properties['eclipse.home.location']. NOT copying J2S Plugin.")
2934 def eclipseJ2sPlugin = "${eclipseHome}/dropins/${j2sPluginFile.getName()}"
2935 def eclipseJ2sPluginFile = file(eclipseJ2sPlugin)
2936 def msg = "WARNING! Copying this commit's j2s plugin '${j2sPlugin}' to Eclipse J2S Plugin '${eclipseJ2sPlugin}'\n* May require an Eclipse restart"
2937 System.err.println(msg)
2940 eclipseJ2sPluginFile.getParentFile().mkdirs()
2941 into eclipseJ2sPluginFile.getParent()
2947 task jalviewjsIDE_j2sFile {
2948 group "00 JalviewJS in Eclipse"
2949 description "Creates the .j2s file"
2950 dependsOn jalviewjsCreateJ2sSettings
2954 task jalviewjsIDE_SyncCore {
2955 group "00 JalviewJS in Eclipse"
2956 description "Build the core js lib closures listed in the classlists dir and publish core html from template"
2957 dependsOn jalviewjsSyncCore
2961 task jalviewjsIDE_SyncSiteAll {
2962 dependsOn jalviewjsSyncAllLibs
2963 dependsOn jalviewjsSyncResources
2964 dependsOn jalviewjsSyncSiteResources
2965 dependsOn jalviewjsSyncBuildProperties
2969 cleanJalviewjsTransferSite.mustRunAfter jalviewjsIDE_SyncSiteAll
2972 task jalviewjsIDE_PrepareSite {
2973 group "00 JalviewJS in Eclipse"
2974 description "Sync libs and resources to site dir, but not closure cores"
2976 dependsOn jalviewjsIDE_SyncSiteAll
2977 //dependsOn cleanJalviewjsTransferSite // not sure why this clean is here -- will slow down a re-run of this task
2981 task jalviewjsIDE_AssembleSite {
2982 group "00 JalviewJS in Eclipse"
2983 description "Assembles unzipped supporting zipfiles, resources, site resources and closure cores into the Eclipse transpiled site"
2984 dependsOn jalviewjsPrepareSite
2988 task jalviewjsIDE_SiteClean {
2989 group "00 JalviewJS in Eclipse"
2990 description "Deletes the Eclipse transpiled site"
2991 dependsOn cleanJalviewjsSite
2995 task jalviewjsIDE_Server {
2996 group "00 JalviewJS in Eclipse"
2997 description "Starts a webserver on localhost to test the website"
2998 dependsOn jalviewjsServer
3002 // buildship runs this at import or gradle refresh
3003 task eclipseSynchronizationTask {
3004 //dependsOn eclipseSetup
3005 dependsOn createBuildProperties
3007 dependsOn jalviewjsIDE_j2sFile
3008 dependsOn jalviewjsIDE_checkJ2sPlugin
3009 dependsOn jalviewjsIDE_PrepareSite
3014 // buildship runs this at build time or project refresh
3015 task eclipseAutoBuildTask {
3016 //dependsOn jalviewjsIDE_checkJ2sPlugin
3017 //dependsOn jalviewjsIDE_PrepareSite
3023 description "Build the site"
3024 dependsOn jalviewjsBuildSite