id 'com.install4j.gradle' version '7.0.9'
}
-// local build environment properties
-def localProps = "${jalviewDir}/local.properties"
-if (file(localProps).exists()) {
- try {
- def p = new Properties()
- def localPropsFIS = new FileInputStream(localProps)
- p.load(localPropsFIS)
- localPropsFIS.close()
- p.each {
- key, val ->
- def over = getProperty(key) != null
- setProperty(key, val)
- if (over) {
- println("Overriding property '${key}' with local.properties value '${val}'")
- }
- }
- } catch (Exception e) {
- System.out.println("Exception reading local.properties")
- }
-}
-
repositories {
jcenter()
mavenCentral()
def compile_target_compatibility
ext {
+ // local build environment properties
+ def localProps = "${jalviewDirAbsolutePath}/local.properties"
+ if (file(localProps).exists()) {
+ try {
+ def p = new Properties()
+ def localPropsFIS = new FileInputStream(localProps)
+ p.load(localPropsFIS)
+ localPropsFIS.close()
+ p.each {
+ key, val ->
+ def over = getProperty(key) != null
+ setProperty(key, val)
+ if (over) {
+ println("Overriding property '${key}' with local.properties value '${val}'")
+ }
+ }
+ } catch (Exception e) {
+ System.out.println("Exception reading local.properties")
+ }
+ }
+
getdownWebsiteDir = "${jalviewDir}/${getdown_website_dir}/${JAVA_VERSION}"
getdownDir = ""
reportRsyncCmd = false
throw new GradleException("JAVA_VERSION=${JAVA_VERSION} not currently supported by Jalview")
}
+
sourceSets {
main {
}
}
+
// clover bits
dependencies {
if (use_clover) {
}
}
+
configurations {
cloverRuntime
cloverRuntime.extendsFrom cloverCompile
}
+
eclipse {
project {
name = eclipse_project_name
}
//fileTree(dir: "$jalviewDir/$utilsDir", include: ["test*/*.jar"]).each {
- sourceSets.test.compileClasspath.findAll { it.name.endsWith(".jar") }.each {
+ sourceSets.test.compileClasspath.findAll { it.name.endsWith(".jar") }.any {
//no longer want to add outputDir as eclipse is using its own output dir in bin/main
if (it.isDirectory() || ! it.exists()) {
// don't add dirs to classpath
- return false // groovy "break" in .each closure
+ return false // groovy "continue" in .any closure
}
+
def itPath = it.toString()
if (itPath.startsWith("${jalviewDirAbsolutePath}/")) {
itPath = itPath.substring(jalviewDirAbsolutePath.length()+1)
}
+
task cloverInstr() {
// only instrument source, we build test classes as normal
inputs.files files (sourceSets.main.allJava) // , fileTree(dir:"$jalviewDir/$testSourceDir", include: ["**/*.java"]))
com.atlassian.clover.reporters.xml.XMLReporter.runReport(args)
}
}
-
// end clover bits
}
+
compileTestJava {
if (use_clover) {
dependsOn compileCloverJava
classpath += configurations.cloverRuntime
}
+
clean {
doFirst {
delete sourceSets.main.java.outputDir
}
}
+
cleanTest {
doFirst {
delete sourceSets.test.java.outputDir
}
}
+
// format is a string like date.format("dd MMMM yyyy")
def getDate(format) {
def date = new Date()
return date.format(format)
}
+
task setGitVals {
def hashStdOut = new ByteArrayOutputStream()
exec {
outputs.upToDateWhen { false }
}
+
task createBuildProperties(type: WriteProperties) {
dependsOn setGitVals
inputs.dir("${jalviewDir}/${sourceDir}")
outputs.file(outputFile)
}
+
def buildingHTML = "${jalviewDir}/${docDir}/building.html"
task cleanBuildingHTML(type: Delete) {
doFirst {
}
}
+
task convertBuildingMD(type: Exec) {
dependsOn cleanBuildingHTML
def buildingMD = "${jalviewDir}/${docDir}/building.md"
outputs.file(buildingHTML)
}
+
clean {
doFirst {
delete buildingHTML
}
}
+
task syncDocs(type: Sync) {
dependsOn convertBuildingMD
def syncDir = "${classes}/${docDir}"
}
-def helpFile = "${classes}/${helpDir}/help.jhm"
+def helpFile = "${classes}/${helpDir}/help.jhm"
task copyHelp(type: Copy) {
def inputDir = "${jalviewDir}/${helpParentDir}/${helpDir}"
def outputDir = "${classes}/${helpDir}"
outputs.dir(outputDir)
}
+
task syncLib(type: Sync) {
def syncDir = "${classes}/${libDistDir}"
from fileTree("${jalviewDir}/${libDistDir}")
into syncDir
}
+
task syncResources(type: Sync) {
from "${jalviewDir}/${resourceDir}"
include "**/*.*"
}
}
+
task prepare {
dependsOn syncResources
dependsOn syncDocs
}
+
task buildIndices(type: JavaExec) {
dependsOn copyHelp
classpath = sourceSets.main.compileClasspath
outputs.file("${workingDir}/JavaHelpSearch/TMAP")
}
+
task compileLinkCheck(type: JavaCompile) {
options.fork = true
classpath = files("${jalviewDir}/${utilsDir}")
outputs.file("${jalviewDir}/${utilsDir}/BufferedLineReader.class")
}
+
task linkCheck(type: JavaExec) {
dependsOn prepare, compileLinkCheck
outputs.file("${jalviewDir}/${packageDir}/${archiveName}")
}
+
task copyJars(type: Copy) {
from fileTree(dir: "${classes}", include: "**/*.jar").files
into "${jalviewDir}/${packageDir}"
}
+
// doing a Sync instead of Copy as Copy doesn't deal with "outputs" very well
task syncJars(type: Sync) {
from fileTree(dir: "${jalviewDir}/${libDistDir}", include: "**/*.jar").files
}
}
+
task makeDist {
group = "build"
description = "Put all required libraries in dist"
outputs.dir("${jalviewDir}/${packageDir}")
}
+
task cleanDist {
dependsOn cleanPackageDir
dependsOn cleanTest
minimize()
}
+
task getdownWebsite() {
group = "distribution"
description = "Create the getdown minimal app folder, and website folder for this version of jalview. Website folder also used for offline app installer"
outputs.dir(project.ext.getdownFilesDir)
}
+
task getdownDigest(type: JavaExec) {
group = "distribution"
description = "Digest the getdown website folder"
outputs.file("${project.ext.getdownWebsiteDir}/digest2.txt")
}
+
task getdown() {
group = "distribution"
description = "Create the minimal and full getdown app folder for installers and website and create digest file"
}
}
+
clean {
doFirst {
delete project.ext.getdownWebsiteDir
}
}
+
install4j {
def install4jHomeDir = "/opt/install4j"
def hostname = "hostname".execute().text.trim()
}
}
+
def install4jConf
def macosJavaVMDir
def macosJavaVMTgz
}
}
+
task installers(type: com.install4j.gradle.Install4jTask) {
group = "distribution"
description = "Create the install4j installers"
outputs.dir("${jalviewDir}/${install4jBuildDir}/${JAVA_VERSION}")
}
+
clean {
doFirst {
delete install4jConf
}
}
+
task sourceDist (type: Tar) {
def VERSION_UNDERSCORES = JALVIEW_VERSION.replaceAll("\\.", "_")
// }
}
+
task helppages {
dependsOn copyHelp
dependsOn pubhtmlhelp
outputs.dir("${helpOutputDir}")
}
+
def jalviewjsBuildDir
def jalviewjsSiteDir
def jalviewjsTransferSiteJsDir
def jalviewjsTransferSiteLibDir
+def jalviewjsTransferSiteSwingJsDir
def jalviewjsTransferSiteCoreDir
task jalviewjsSitePath {
def relativeBuildDir = file(jalviewDirAbsolutePath).toPath().relativize(buildDir.toPath())
jalviewjsSiteDir = "${jalviewjsBuildDir}/${jalviewjs_site_dir}"
jalviewjsTransferSiteJsDir = "${jalviewjsBuildDir}/tmp/${jalviewjs_site_dir}_js"
jalviewjsTransferSiteLibDir = "${jalviewjsBuildDir}/tmp/${jalviewjs_site_dir}_lib"
+ jalviewjsTransferSiteSwingJsDir = "${jalviewjsBuildDir}/tmp/${jalviewjs_site_dir}_swingjs"
jalviewjsTransferSiteCoreDir = "${jalviewjsBuildDir}/tmp/${jalviewjs_site_dir}_core"
}
+
def eclipseWorkspace
task jalviewjsSetEclipseWorkspace {
def propKey = "jalviewjs_eclipse_workspace"
println("ECLIPSE WORKSPACE: "+eclipseWorkspace.getPath())
}
- inputs.property(propKey, eclipseWsDir)
+ //inputs.property(propKey, eclipseWsDir) // eclipseWsDir only gets set once this task runs, so will be out-of-date
outputs.file(propsFileName)
+ outputs.upToDateWhen { eclipseWorkspace.exists() }
}
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"
+ eclipseRoot += "/eclipse.exe"
}
eclipseBinary = "${eclipseRoot}/eclipse"
eclipseProduct = "${eclipseRoot}/.eclipseproduct"
eclipseProduct = "${eclipseRoot}/.eclipseproduct"
}
- eclipseVersion = "4.12" // default
+ eclipseVersion = "4.13" // default
def assumedVersion = true
if (file(eclipseProduct).exists()) {
def fis = new FileInputStream(eclipseProduct)
fis.close()
assumedVersion = false
}
- /*
- String[] v = eclipseVersion.split("\\.")
- def v0 = Integer.valueOf(v[0])
- def v1 = Integer.valueOf(v[1])
- if (v0 < 4 || ( v0 == 4 && v1 < 13 )) {
- eclipseVersionSuffix = "_4.12"
- } else {
- eclipseVersionSuffix = "_4.13"
- }
- */
-
def propKey = "eclipse_debug"
eclipseDebug = (project.hasProperty(propKey) && project.getProperty(propKey).equals("true"))
}
}
+
task eclipseSetup {
dependsOn eclipseProject
dependsOn eclipseClasspath
dependsOn eclipseJdt
}
-/* using the Copy task below
-task OLDjalviewjsEclipseCopyDropins {
- dependsOn jalviewjsEclipsePaths
- dependsOn jalviewjsCleanEclipse
- def inputFiles = fileTree(dir: "${jalviewDir}/${jalviewjs_eclipse_dropins_dir}", include: "*.jar")
- inputFiles += file(jalviewjs_j2s_plugin)
- def outputDir = "${buildDir}/jalviewjs
-
- inputs.files inputFiles
- inputFiles.each { file ->
- outputs.file("${outputDir}/${file.name}")
- }
-
- doLast {
- inputFiles.each { file ->
- copy {
- from file
- into outputDir
- }
- }
- }
-}
-*/
// this version (type: Copy) will delete anything in the eclipse dropins folder that isn't in fromDropinsDir
task jalviewjsEclipseCopyDropins(type: Copy) {
into outputDir
}
+
// this eclipse -clean doesn't actually work
task jalviewjsCleanEclipse(type: Exec) {
dependsOn eclipseSetup
def inputByteStream = new ByteArrayInputStream(inputString.getBytes())
standardInput = inputByteStream
}
+
/* not really working yet
jalviewjsEclipseCopyDropins.finalizedBy jalviewjsCleanEclipse
*/
-def jalviewjsTransferSiteUnzipDir
+
+task jalviewjsTransferUnzipSwingJs {
+ dependsOn jalviewjsSitePath
+
+ def file_zip = "${jalviewDir}/${jalviewjs_swingjs_zip}"
+
+ doLast {
+ copy {
+ from zipTree(file_zip)
+ into "${jalviewDir}/${jalviewjsTransferSiteSwingJsDir}"
+ }
+ }
+
+ inputs.file file_zip
+ outputs.dir "${jalviewDir}/${jalviewjsTransferSiteSwingJsDir}"
+}
+
+
task jalviewjsTransferUnzipLib {
dependsOn jalviewjsSitePath
def zipFiles = fileTree(dir: "${jalviewDir}/${jalviewjs_libjs_dir}", include: "*.zip")
- zipFiles += "${jalviewDir}/${jalviewjs_swingjs_zip}"
doLast {
zipFiles.each { file_zip ->
outputs.dir "${jalviewDir}/${jalviewjsTransferSiteLibDir}"
}
+
+task jalviewjsTransferUnzipAllLibs {
+ dependsOn jalviewjsTransferUnzipSwingJs
+ dependsOn jalviewjsTransferUnzipLib
+}
+
+
task jalviewjsCreateJ2sSettings(type: WriteProperties) {
group "JalviewJS"
description "Create the .j2s file from the j2s.* properties"
outputs.file(outputFile)
}
+
task jalviewjsEclipseSetup {
dependsOn jalviewjsEclipseCopyDropins
dependsOn jalviewjsSetEclipseWorkspace
dependsOn jalviewjsCreateJ2sSettings
}
-task jalviewjsSyncLib (type: Sync) {
+
+task jalviewjsSyncAllLibs (type: Sync) {
dependsOn jalviewjsSitePath
- dependsOn jalviewjsTransferUnzipLib
+ dependsOn jalviewjsTransferUnzipAllLibs
def inputFiles = fileTree(dir: "${jalviewDir}/${jalviewjsTransferSiteLibDir}")
+ inputFiles += fileTree(dir: "${jalviewDir}/${jalviewjsTransferSiteSwingJsDir}")
def outputDir = "${jalviewDir}/${jalviewjsSiteDir}"
from inputFiles
inputs.files inputFiles
}
-task jalviewjsSyncCore (type: Sync) {
- dependsOn jalviewjsSitePath
- dependsOn "jalviewjsBuildAllCores"
- def inputFiles = fileTree(dir: "${jalviewDir}/${jalviewjsTransferSiteCoreDir}")
- def outputDir = "${jalviewDir}/${jalviewjsSiteDir}"
-
- from inputFiles
- into outputDir
- def outputFiles = []
- rename { filename ->
- outputFiles += "${outputDir}/${filename}"
- null
- }
- preserve {
- include "**"
- }
- outputs.files outputFiles
- inputs.files inputFiles
-}
task jalviewjsSyncResources (type: Sync) {
dependsOn jalviewjsSitePath
inputs.files inputFiles
}
+
task jalviewjsSyncSiteResources (type: Sync) {
dependsOn jalviewjsSitePath
def inputFiles = fileTree(dir: "${jalviewDir}/${jalviewjs_site_resource_dir}")
inputs.files inputFiles
}
+
task jalviewjsSyncBuildProperties (type: Sync) {
dependsOn jalviewjsSitePath
dependsOn createBuildProperties
inputs.files inputFiles
}
+
task jalviewjsProjectImport(type: Exec) {
dependsOn eclipseSetup
dependsOn jalviewjsEclipsePaths
dependsOn jalviewjsEclipseSetup
- def projdir = eclipseWorkspace.getPath()+"/.metadata/.plugins/org.eclipse.core.resources/.projects/jalview/org.eclipse.jdt.core"
+ doFirst {
+ // do not run a headless import when we claim to be in Eclipse
+ if (ECLIPSE_IDE_DEVELOPER.equals("true")) {
+ throw new StopExecutionException("Not running headless import whilst ECLIPSE_IDE_DEVELOPER is '"+ECLIPSE_IDE_DEVELOPER+"'")
+ }
+ }
+
+ //def projdir = eclipseWorkspace.getPath()+"/.metadata/.plugins/org.eclipse.core.resources/.projects/jalview/org.eclipse.jdt.core"
+ def projdir = eclipseWorkspace.getPath()+"/.metadata/.plugins/org.eclipse.core.resources/.projects/jalview"
executable(eclipseBinary)
args(["-nosplash", "--launcher.suppressErrors", "-application", "com.seeq.eclipse.importprojects.headlessimport", "-data", eclipseWorkspace.getPath(), "-import", jalviewDirAbsolutePath])
if (eclipseDebug) {
args += [ "--launcher.appendVmargs", "-vmargs", "-Dorg.eclipse.equinox.p2.reconciler.dropins.directory=${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_eclipse_tmp_dropins_dir}" ]
inputs.file("${jalviewDir}/.project")
- outputs.upToDateWhen { file(projdir).exists() }
+ outputs.upToDateWhen {
+ file(projdir).exists()
+ }
}
+
task jalviewjsTranspile(type: Exec) {
dependsOn jalviewjsEclipseSetup
dependsOn jalviewjsProjectImport
dependsOn jalviewjsEclipsePaths
+ doFirst {
+ // do not run a headless transpile when we claim to be in Eclipse
+ if (ECLIPSE_IDE_DEVELOPER.equals("true")) {
+ throw new StopExecutionException("Not running headless transpile whilst ECLIPSE_IDE_DEVELOPER is '"+ECLIPSE_IDE_DEVELOPER+"'")
+ }
+ }
+
executable(eclipseBinary)
args(["-nosplash", "--launcher.suppressErrors", "-application", "org.eclipse.jdt.apt.core.aptBuild", "-data", eclipseWorkspace, "-${jalviewjs_eclipse_build_arg}", eclipse_project_name ])
if (eclipseDebug) {
stdout = new ByteArrayOutputStream()
stderr = new ByteArrayOutputStream()
- def logOutFileName = "${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_j2s_stdout}"
+ def logOutFileName = "${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_j2s_transpile_stdout}"
def logOutFile = file(logOutFileName)
logOutFile.createNewFile()
logOutFile.text = """ROOT: ${jalviewjs_eclipse_root}
----
"""
def logOutFOS = new FileOutputStream(logOutFile, true) // true == append
- //def logErrFileName = "${jalviewDir}/${jalviewjsBuildDir}/${jalviewjs_j2s_stderr}"
- //def logErrFile = file(logFileName)
- //logErrFile.createNewFile()
- //def logErrFOS = new FileErrputStream(logErrFile, false)
// combine stdout and stderr
def logErrFOS = logOutFOS
doLast {
if (stdout.toString().contains("Error processing ")) {
// j2s did not complete transpile
- throw new GradleException("Error during transpilation:\n${stderr}\nSee eclipse transpile log file '${jalviewDir}/${jalviewjsBuildDir}/${jalviewjs_j2s_stdout}'")
+ //throw new TaskExecutionException("Error during transpilation:\n${stderr}\nSee eclipse transpile log file '${jalviewDir}/${jalviewjsBuildDir}/${jalviewjs_j2s_transpile_stdout}'")
+ throw new GradleException("Error during transpilation:\n${stderr}\nSee eclipse transpile log file '${jalviewDir}/${jalviewjsBuildDir}/${jalviewjs_j2s_transpile_stdout}'")
}
}
outputs.upToDateWhen( { file("${jalviewDir}/${jalviewjsTransferSiteJsDir}${jalviewjs_server_resource}").exists() } )
}
-// this Copy version of TransferSite will delete anything else in the target dir
-task jalviewjsCopyTransferSite(type: Copy) {
+
+def jalviewjsCallCore(FileCollection list, String prefixFile, String suffixFile, String jsfile, String zjsfile, File logOutFile, Boolean logOutConsole) {
+
+ def stdout = new ByteArrayOutputStream()
+ def stderr = new ByteArrayOutputStream()
+
+ def coreFile = file(jsfile)
+ def msg = ""
+ msg = "Generating ${jsfile}"
+ println(msg)
+ logOutFile.createNewFile()
+ logOutFile.append(msg+"\n")
+
+ def coreTop = file(prefixFile)
+ def coreBottom = file(suffixFile)
+ coreFile.getParentFile().mkdirs()
+ coreFile.createNewFile()
+ coreFile.write( coreTop.text )
+ list.each {
+ f ->
+ if (f.exists()) {
+ def t = f.text
+ t.replaceAll("Clazz\\.","Clazz_")
+ t.replaceAll("Class__","Clazz._")
+ coreFile.append( t )
+ } else {
+ msg = "...file '"+f.getPath()+"' does not exist, skipping"
+ println(msg)
+ logOutFile.append(msg+"\n")
+ }
+ }
+ coreFile.append( coreBottom.text )
+
+ msg = "Generating ${zjsfile}"
+ println(msg)
+ logOutFile.append(msg+"\n")
+ def logOutFOS = new FileOutputStream(logOutFile, true) // true == append
+ def logErrFOS = logOutFOS
+
+ javaexec {
+ classpath = files(["${jalviewDir}/tools/closure_compiler.jar"])
+ args = [ "--js", jsfile, "--js_output_file", zjsfile ]
+
+ msg = "\nRunning '"+commandLine.join(' ')+"'\n"
+ println(msg)
+ logOutFile.append(msg+"\n")
+
+ if (logOutConsole) {
+ standardOutput = new org.apache.tools.ant.util.TeeOutputStream(
+ new org.apache.tools.ant.util.TeeOutputStream(
+ logOutFOS,
+ stdout),
+ standardOutput)
+ errorOutput = new org.apache.tools.ant.util.TeeOutputStream(
+ new org.apache.tools.ant.util.TeeOutputStream(
+ logErrFOS,
+ stderr),
+ errorOutput)
+ } else {
+ standardOutput = new org.apache.tools.ant.util.TeeOutputStream(
+ logOutFOS,
+ stdout)
+ errorOutput = new org.apache.tools.ant.util.TeeOutputStream(
+ logErrFOS,
+ stderr)
+ }
+ }
+ msg = "--"
+ println(msg)
+ logOutFile.append(msg+"\n")
+}
+
+
+def jalviewjsJalviewTemplateName = "JalviewJS"
+def jalviewjsJalviewCoreName = "_jalview"
+task jalviewjsNoTranspileBuildAllCores {
+ dependsOn jalviewjsSitePath
+ dependsOn jalviewjsTransferUnzipSwingJs
+
+ def j2sDir = "${jalviewDir}/${jalviewjsTransferSiteJsDir}/${jalviewjs_j2s_subdir}"
+ def jsDir = "${jalviewDir}/${jalviewjsTransferSiteSwingJsDir}/${jalviewjs_js_subdir}"
+ def outputDir = "${jalviewDir}/${jalviewjsTransferSiteCoreDir}/${jalviewjs_j2s_subdir}/core"
+ def prefixFile = "${jsDir}/core/coretop2.js"
+ def suffixFile = "${jsDir}/core/corebottom2.js"
+
+ inputs.file prefixFile
+ inputs.file suffixFile
+
+ def classlistFiles = []
+ // add the classlists found int the jalviewjs_classlists_dir
+ fileTree(dir: "${jalviewDir}/${jalviewjs_classlists_dir}", include: "*.txt").each {
+ file ->
+ def name = file.getName() - ".txt"
+ classlistFiles += [
+ 'file': file,
+ 'name': name
+ ]
+ }
+
+ // _jmol and _jalview cores. Add any other peculiar classlist.txt files here
+ classlistFiles += [ 'file': file("${jalviewDir}/${jalviewjs_classlist_jmol}"), 'name': "_jvjmol" ]
+ classlistFiles += [ 'file': file("${jalviewDir}/${jalviewjs_classlist_jalview}"), 'name': jalviewjsJalviewCoreName ]
+
+ def classlists = []
+
+ classlistFiles.each {
+ hash ->
+
+ def file = hash['file']
+ if (! file.exists()) {
+ println("...classlist file '"+file.getPath()+"' does not exist, skipping")
+ return false // this is a "continue" in groovy .each closure
+ }
+ def name = hash['name']
+ if (name == null) {
+ name = file.getName() - ".txt"
+ }
+
+ def filelist = []
+ file.eachLine {
+ line ->
+ filelist += line
+ }
+ def list = fileTree(dir: j2sDir, includes: filelist)
+
+ def jsfile = "${outputDir}/core${name}.js"
+ def zjsfile = "${outputDir}/core${name}.z.js"
+
+ classlists += [
+ 'jsfile': jsfile,
+ 'zjsfile': zjsfile,
+ 'list': list
+ ]
+
+ inputs.file(file)
+ inputs.files(list)
+ outputs.file(jsfile)
+ outputs.file(zjsfile)
+ }
+
+ // _stevesoft core. add any cores without a classlist here (and the inputs and outputs)
+ def stevesoftClasslist = [
+ 'jsfile': "${outputDir}/core_stevesoft.js",
+ 'zjsfile': "${outputDir}/core_stevesoft.z.js",
+ 'list': fileTree(dir: j2sDir, include: "com/stevesoft/pat/**/*.js")
+ ]
+ classlists += stevesoftClasslist
+ inputs.files(stevesoftClasslist['list'])
+ outputs.file(stevesoftClasslist['jsfile'])
+ outputs.file(stevesoftClasslist['zjsfile'])
+
+ doFirst {
+ def logOutFile = file("${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_j2s_closure_stdout}")
+ logOutFile.getParentFile().mkdirs()
+ logOutFile.createNewFile()
+ logOutFile.write(getDate("yyyy-MM-dd HH:mm:ss")+" jalviewjsNoTranspileBuildAllCores\n----\n")
+
+ classlists.each {
+ jalviewjsCallCore(it.list, prefixFile, suffixFile, it.jsfile, it.zjsfile, logOutFile, jalviewjs_j2s_to_console.equals("true"))
+ }
+ }
+
+}
+
+
+jalviewjsNoTranspileBuildAllCores.mustRunAfter jalviewjsTranspile
+
+
+task jalviewjsBuildAllCores {
+ group "JalviewJS"
+ description "Build the core js lib closures listed in the classlists dir"
+ dependsOn jalviewjsTranspile
+ dependsOn jalviewjsNoTranspileBuildAllCores
+}
+
+
+def jalviewjsJalviewCoreHtmlFile
+task jalviewjsPublishCoreTemplate(type: Sync) {
+ dependsOn jalviewjsSitePath
+ dependsOn jalviewjsBuildAllCores
+
+ def inputFile = file("${jalviewDir}/${j2s_template_html}")
+ def outputDir = "${jalviewDir}/${jalviewjsTransferSiteCoreDir}"
+
+ from inputFile
+ into outputDir
+ def outputFiles = []
+ jalviewjsJalviewCoreHtmlFile = "${jalviewjsJalviewTemplateName}_${jalviewjsJalviewCoreName}.html"
+ rename { filename ->
+ outputFiles += "${outputDir}/${filename}"
+ if (filename.equals(inputFile.getName())) {
+ return jalviewjsJalviewCoreHtmlFile
+ }
+ return null
+ }
+ filter(ReplaceTokens, beginToken: '_', endToken: '_', tokens: ['MAIN': '"'+mainClass+'"', 'CODE': "null", 'NAME': jalviewjsJalviewTemplateName])
+ filter(ReplaceTokens, beginToken: '', endToken: '', tokens: ['NONE': jalviewjsJalviewCoreName])
+ preserve {
+ include "**"
+ }
+ outputs.files outputFiles
+ inputs.files inputFile
+}
+
+
+task jalviewjsNoTranspileSyncCore (type: Sync) {
+ dependsOn jalviewjsSitePath
+ dependsOn jalviewjsNoTranspileBuildAllCores
+ dependsOn jalviewjsPublishCoreTemplate
+ def inputFiles = fileTree(dir: "${jalviewDir}/${jalviewjsTransferSiteCoreDir}")
+ def outputDir = "${jalviewDir}/${jalviewjsSiteDir}"
+
+ from inputFiles
+ into outputDir
+ def outputFiles = []
+ rename { filename ->
+ outputFiles += "${outputDir}/${filename}"
+ null
+ }
+ preserve {
+ include "**"
+ }
+ outputs.files outputFiles
+ inputs.files inputFiles
+}
+
+
+task jalviewjsSyncCore (type: Sync) {
+ dependsOn jalviewjsTranspile
+ dependsOn jalviewjsNoTranspileSyncCore
+ dependsOn "jalviewjsBuildAllCores"
+}
+
+
+// this Copy version of TransferSiteJs will delete anything else in the target dir
+task jalviewjsCopyTransferSiteJs(type: Copy) {
dependsOn jalviewjsTranspile
from "${jalviewDir}/${jalviewjsTransferSiteJsDir}"
into "${jalviewDir}/${jalviewjsSiteDir}"
}
+
// this Sync version of TransferSite is used by buildship to keep the website automatically up to date when a file changes
-task jalviewjsSyncTransferSite(type: Sync) {
+task jalviewjsNoTranspileSyncTransferSiteJs(type: Sync) {
from "${jalviewDir}/${jalviewjsTransferSiteJsDir}"
include "**/*.*"
into "${jalviewDir}/${jalviewjsSiteDir}"
}
}
-jalviewjsSyncLib.mustRunAfter jalviewjsCopyTransferSite
-jalviewjsSyncResources.mustRunAfter jalviewjsCopyTransferSite
-jalviewjsSyncSiteResources.mustRunAfter jalviewjsCopyTransferSite
-jalviewjsSyncBuildProperties.mustRunAfter jalviewjsCopyTransferSite
+jalviewjsSyncAllLibs.mustRunAfter jalviewjsCopyTransferSiteJs
+jalviewjsSyncResources.mustRunAfter jalviewjsCopyTransferSiteJs
+jalviewjsSyncSiteResources.mustRunAfter jalviewjsCopyTransferSiteJs
+jalviewjsSyncBuildProperties.mustRunAfter jalviewjsCopyTransferSiteJs
+
+jalviewjsSyncAllLibs.mustRunAfter jalviewjsNoTranspileSyncTransferSiteJs
+jalviewjsSyncResources.mustRunAfter jalviewjsNoTranspileSyncTransferSiteJs
+jalviewjsSyncSiteResources.mustRunAfter jalviewjsNoTranspileSyncTransferSiteJs
+jalviewjsSyncBuildProperties.mustRunAfter jalviewjsNoTranspileSyncTransferSiteJs
+
+
+task jalviewjsNoTranspilePrepareSite {
+ dependsOn jalviewjsSyncAllLibs
+ dependsOn jalviewjsSyncResources
+ dependsOn jalviewjsSyncSiteResources
+ dependsOn jalviewjsSyncBuildProperties
+ dependsOn jalviewjsNoTranspileSyncCore
+}
-jalviewjsSyncLib.mustRunAfter jalviewjsSyncTransferSite
-jalviewjsSyncResources.mustRunAfter jalviewjsSyncTransferSite
-jalviewjsSyncSiteResources.mustRunAfter jalviewjsSyncTransferSite
-jalviewjsSyncBuildProperties.mustRunAfter jalviewjsSyncTransferSite
task jalviewjsPrepareSite {
group "JalviewJS"
description "Prepares the website folder including unzipping files and copying resources"
- dependsOn jalviewjsSyncLib
+ dependsOn jalviewjsSyncAllLibs
dependsOn jalviewjsSyncResources
dependsOn jalviewjsSyncSiteResources
dependsOn jalviewjsSyncBuildProperties
+ dependsOn jalviewjsSyncCore
}
+
task jalviewjsBuildSite {
group "JalviewJS"
description "Builds the whole website including transpiled code"
- dependsOn jalviewjsCopyTransferSite
+ dependsOn jalviewjsCopyTransferSiteJs
dependsOn jalviewjsPrepareSite
}
+
task cleanJalviewjsSite {
doFirst {
delete "${jalviewDir}/${jalviewjsTransferSiteJsDir}"
+ delete "${jalviewDir}/${jalviewjsTransferSiteLibDir}"
+ delete "${jalviewDir}/${jalviewjsTransferSiteSwingJsDir}"
+ delete "${jalviewDir}/${jalviewjsTransferSiteCoreDir}"
delete "${jalviewDir}/${jalviewjsSiteDir}"
}
}
+
task jalviewjsSiteTar(type: Tar) {
group "JalviewJS"
description "Creates a tar.gz file for the website"
inputs.dir("${jalviewDir}/${jalviewjsSiteDir}")
}
+
task jalviewjsServer {
group "JalviewJS"
def filename = "jalviewjsTest.html"
def start = port
def running = false
def url
+ def urlcore
while(port < start+1000 && !running) {
try {
def doc_root = new File("${jalviewDirAbsolutePath}/${jalviewjsSiteDir}")
def jalviewjsServer = factory.start(doc_root, port)
running = true
url = jalviewjsServer.getResourceUrl(jalviewjs_server_resource)
+ urlcore = jalviewjsServer.getResourceUrl(jalviewjsJalviewCoreHtmlFile)
println("SERVER STARTED with document root ${doc_root}.")
println("Go to "+url+" . Run gradle --stop to stop (kills all gradle daemons).")
println("For debug: "+url+"?j2sdebug")
+ println("For core: "+urlcore)
file(htmlFile).text = """
- <p><a href="${url}">Jalview JS Test. <${url}></a></p>
- <p><a href="${url}?j2sdebug">Jalview JS Test with debug. <${url}?j2sdebug<</a></p>
+ <p><a href="${url}">JalviewJS Test. <${url}></a></p>
+ <p><a href="${url}?j2sdebug">JalviewJS Test with debug. <${url}?j2sdebug<</a></p>
+ <p><a href="${urlcore}">${jalviewjsJalviewTemplateName} Core Test. <${urlcore}></a></p>
"""
} catch (Exception e) {
outputs.upToDateWhen({false})
}
+
task cleanJalviewjsAll {
group "JalviewJS"
description "Delete all configuration and build artifacts to do with JalviewJS build"
outputs.upToDateWhen( { false } )
}
-task jalviewjs {
- group "JalviewJS"
- description "Build the site"
- dependsOn jalviewjsBuildSite
-}
-task jalviewjsIDE_CopyTransferSite(type: Copy) {
+task jalviewjsIDE_CopyTransferSiteJs(type: Copy) {
from "${jalviewDir}/${jalviewjsTransferSiteJsDir}"
into "${jalviewDir}/${jalviewjsSiteDir}"
}
-task jalviewjsIDE_j2s {
+
+task jalviewjsIDE_j2sFile {
group "00 JalviewJS in Eclipse"
description "Creates the .j2s file"
dependsOn jalviewjsCreateJ2sSettings
}
+
+task jalviewjsIDE_BuildAllCores {
+ group "00 JalviewJS in Eclipse"
+ description "Build the core js lib closures listed in the classlists dir"
+ dependsOn jalviewjsNoTranspileBuildAllCores
+}
+
+
task jalviewjsIDE_AssembleSite {
group "00 JalviewJS in Eclipse"
description "Assembles the Eclipse transpiled site and unzips supporting zipfiles"
- dependsOn jalviewjsIDE_CopyTransferSite
- dependsOn jalviewjsPrepareSite
+ dependsOn jalviewjsIDE_CopyTransferSiteJs
+ dependsOn jalviewjsNoTranspilePrepareSite
}
+
task jalviewjsIDE_SiteClean {
group "00 JalviewJS in Eclipse"
description "Deletes the Eclipse transpiled site"
dependsOn cleanJalviewjsSite
}
+
task jalviewjsIDE_Server {
group "00 JalviewJS in Eclipse"
description "Starts a webserver on localhost to test the website"
dependsOn jalviewjsServer
}
+
// buildship runs this at import
task eclipseSynchronizationTask {
dependsOn eclipseSetup
- dependsOn jalviewjsIDE_j2s
+ dependsOn jalviewjsIDE_j2sFile
}
+
// buildship runs this at build time
task eclipseAutoBuildTask {
- dependsOn jalviewjsSyncTransferSite
- dependsOn jalviewjsPrepareSite
+ dependsOn jalviewjsNoTranspileSyncTransferSiteJs
+ dependsOn jalviewjsNoTranspilePrepareSite
}
-// closure
-def jalviewjsCallCore(String name, FileCollection list, String jsDir, String outputDir) {
- def coreFileName = "core${name}.js"
- def coreFilePath = "${outputDir}/${coreFileName}"
- def coreFile = file(coreFilePath)
- println("...Generating ${coreFilePath}")
-
- def coreTop = file("${jsDir}/core/coretop2.js")
- def coreBottom = file("${jsDir}/core/corebottom2.js")
- coreFile.getParentFile().mkdirs()
- coreFile.createNewFile()
- coreFile.write( coreTop.text )
- list.each {
- f ->
- if (f.exists()) {
- def t = f.text
- t.replaceAll("Clazz\\.","Clazz_")
- t.replaceAll("Class__","Clazz._")
- coreFile.append( t )
- } else {
- println("...file ${line} does not exist, skipping")
- }
- }
- coreFile.append( coreBottom.text )
-
- def coreZFileName = "core${name}.z.js"
- def coreZFilePath = "${outputDir}/${coreZFileName}"
- def coreZFile = file(coreZFilePath)
- println("...Generating ${coreZFilePath}")
-
- javaexec {
- classpath = files(["${jalviewDir}/tools/closure_compiler.jar"])
- args = [ "--js", coreFileName, "--js_output_file", coreZFileName ]
- workingDir = outputDir
- }
-
- return [ coreFile, coreZFile ]
-}
-
-def jalviewjsToJs(String name, String classlist, String jsDir, String j2sDir, String outputDir) {
- def filelist = []
- file(classlist).eachLine {
- line ->
- filelist += line
- }
- def list = fileTree(dir: j2sDir, includes: filelist)
- /*
- def list = files()
- file(classlist).eachLine {
- line ->
- list += file("${j2sDir}/${line}")
- }
- */
-
- return jalviewjsCallCore(name, list, jsDir, outputDir)
-// publish-core-template ... here?
-}
-
-task jalviewjsBuildAllCores {
+task jalviewjs {
group "JalviewJS"
- description "Build the core js lib closures"
-
- dependsOn jalviewjsSitePath
- dependsOn jalviewjsTransferUnzipLib
- dependsOn jalviewjsTranspile
-
- fileTree(dir: "${jalviewDir}/${jalviewjs_classlists_dir}", include: "*.txt").each {
- file ->
- def name = file.getName() - ".txt"
-
- jalviewjsToJs(name, file.getAbsolutePath(), "${jalviewDir}/${jalviewjsTransferSiteLibDir}/${jalviewjs_js_subdir}", "${jalviewDir}/${jalviewjsTransferSiteJsDir}/${jalviewjs_j2s_subdir}", "${jalviewDir}/${jalviewjsTransferSiteCoreDir}/${jalviewjs_j2s_subdir}/core")
- }
+ description "Build the site"
+ dependsOn jalviewjsBuildSite
}
git://source.jalview.org / jalview.git / blobdiff