build.gradle

import org.apache.tools.ant.taskdefs.condition.Os

//defaultTasks 'bower'

/*
 * This build file was auto generated by running the Gradle 'init' task
 * by 'nathandunn' at '3/14/16 12:08 PM' with Gradle 2.11
 *
 * This generated file contains a commented-out sample Java project to get you started.
 * For more details take a look at the Java Quickstart chapter in the Gradle
 * user guide available at https://docs.gradle.org/2.11/userguide/tutorial_java_projects.html
 */

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
    }
}

plugins {
//    id "com.eriwen.gradle.js" version "1.12.1"
//    id "com.moowork.node" version "0.12"
}

// In this section you declare where to find the dependencies of your project
repositories {
    // Use 'jcenter' for resolving your dependencies.
    // You can declare any Maven/Ivy/file repository here.
    jcenter()
}


ext {
    npmCommand = Os.isFamily(Os.FAMILY_WINDOWS) ? 'npm.cmd' : 'npm'
    bowerCommand = Os.isFamily(Os.FAMILY_WINDOWS) ? 'bower.cmd' : 'bower'
    githubURL = "https://github.com/"
}


ant.importBuild 'build.xml'

// Apply the java plugin to add support for Java
apply plugin: 'java'
apply plugin: 'groovy'
apply plugin: 'eclipse'
apply plugin: 'idea'
//apply plugin: "de.qaware.seu.as.code.git"

// In this section you declare the dependencies for your production and test code
dependencies {
    // The production code uses the SLF4J logging API at compile time
//    compile 'org.slf4j:slf4j-api:1.7.14'

    // Declare the dependency for your favourite test framework you want to use in your tests.
    // TestNG is also supported by the Gradle Test task. Just change the
    // testCompile dependency to testCompile 'org.testng:testng:6.8.1' and add
    // 'test.useTestNG()' to your build script.
//    testCompile 'junit:junit:4.12'
}


def jbrowseConfig
def jbrowsePlugins
def jbrowseDirectory = "jbrowse-download"
def pluginsDirectory = "${jbrowseDirectory}/plugins"



task evaluateJBrowseConfigs {
    // gradle read in Config.groovy
    def config = new ConfigSlurper().parse(new File("grails-app/conf/Config.groovy").toURI().toURL())
    jbrowseConfig = config.jbrowse
    jbrowsePlugins = jbrowseConfig.plugins
    // if apollo-config.groovy exists, read THAT in and apply it as well
    File testFile = new File("./apollo-config.groovy")
    def revisedConfig
    if (testFile.exists()) {
        revisedConfig = new ConfigSlurper().parse(new File("apollo-config.groovy").toURI().toURL())
    } else {
        try {
            Class scriptClass = getClass().classLoader.loadClass('apollo-config.groovy')
            revisedConfig = new ConfigSlurper().parse(scriptClass)
        } catch (e) {
            println "No log file found in classpath."
        }
    }

    if (revisedConfig) {
        jbrowseConfig = revisedConfig.jbrowse ?: jbrowseConfig
        jbrowsePlugins << revisedConfig.jbrowse.plugins
    }

    println "final JBrowse settings ${jbrowseConfig}"
    println "final plugins ${jbrowsePlugins}"
}


task installJBrowse(dependsOn: evaluateJBrowseConfigs) << {
    println "installing jbrowse ${jbrowseConfig}"

    File jbrowseFile = new File(jbrowseDirectory)
    if (jbrowseConfig.git) {
        def git = jbrowseConfig.git
        if (jbrowseFile.exists()) {
            if ( (git.alwaysRecheck || git.alwaysPull)) {
                if(hasBower()) {
                    refreshBowerRepo(jbrowseDirectory)
                }
                else{
                    if (git.tag) {
                        fetchTags(jbrowseFile)
                        checkoutBranch(jbrowseFile, "tags/" + git.tag)
                    } else if (git.branch) {
                        checkoutBranch(jbrowseFile, git.branch)
                    }
                    if (git.alwaysPull && git.branch) {
                        println "Pulling ${git.url}"
                        gitPull(jbrowseFile)
                    }
                }
            }
        } else {
            println "Cloning: ${git.url} into ${jbrowseDirectory}."
            def branch = git.branch ?: (git.tag ? "tags/${git.tag}" : null)
            cloneRepo(git.url, jbrowseDirectory, branch, 1)
            if(!hasBower()){
                checkoutBranch(jbrowseFile, branch)
            }
        }
    } else if (jbrowseConfig.url && !jbrowseFile.exists()) {

        if (jbrowseConfig.url.type == "zip") {
            // assume its a zip
            def f = new File(jbrowseDirectory + ".zip")
            new URL(jbrowseConfig.url.url).withInputStream { i -> f.withOutputStream { it << i } }
            File tempFile = File.createTempDir()
            ant.unzip(src: f.absolutePath, dest: tempFile, overwrite: false)
            org.gradle.util.GFileUtils.moveDirectory(new File(tempFile.absolutePath + "/" + jbrowseConfig.url.fileName), jbrowseFile)
            org.gradle.util.GFileUtils.deleteDirectory(new File(jbrowseFile.absolutePath + "/sample_data"))
            tempFile.deleteDir()
            f.delete()
        } else {
//            new URL(jbrowseConfig.url.url).withInputStream { i -> f.withOutputStream { it << i } }
            println "Must specify type"
            throw new GradleException("Unable to specify jbrowse download type")
        }
    }
}


task installJBrowseLocal(dependsOn: installJBrowse,type: Exec) {
	workingDir = '.'
    commandLine './install_jbrowse.sh'
}

task copyResourcesDev(dependsOn: installJBrowse) << {
    File jbrowse = new File("web-app/jbrowse")
    println "found jbrowse directory ${jbrowse.file}"
    if(jbrowse.exists()){
        tasks["copy-resources-dev"].execute()
    }
    else{
        tasks["copy-resources"].execute()
    }
    installJBrowseLocal.execute()
}

task copyApolloPlugin(dependsOn:installJBrowse,type:Copy){
    println "Copying apollo plugin"
    from("client/apollo")
    into("jbrowse-download/plugins/WebApollo")
}

// wrapper for ant script
task setupJBrowse(dependsOn: "setup-jbrowse") << {}

task installJBrowsePlugins(dependsOn: copyApolloPlugin) << {
    println "installing jbrowse plugins  ${jbrowsePlugins}"

    for (plugin in jbrowsePlugins) {
        def path = pluginsDirectory + "/" + plugin.key
        println "Evaluating plugin ${plugin}"
        def pluginExists = confirmPlugin(path)
        if (plugin.value.included==true) {
                if (pluginExists) {
                    println "Plugin ${path} exists and appears valid."
                } else {
                    println "ERROR: There is a problem with the plugin at ${path}!"
                    throw new GradleException("Included plugin ${path} not found in build")
                }
        }
        else if (plugin.value.included==false) {
            if (pluginExists) {
                println "Plugin ${path} exists but is not included."
            } else {
                println "Plugin ${path} does not exist but is also not included."
            }
        }
        else if (plugin.value.git) {
            println "Plugin is supplied by git"
            if (pluginExists) {
                println "Plugin ${path} exists and appears valid."
                if (plugin.value.alwaysRecheck || plugin.value.alwaysPull) {
                    println "Checking out branch ${plugin.value.branch}"
                    if (plugin.value.tag) {
                        checkoutBranch(new File(path),"tags/${plugin.value.tag}")
                    } else if (plugin.value.branch) {
                        checkoutBranch(new File(path),plugin.value.branch)
                    }

                    if (plugin.value.alwaysPull) {
                        println "Pulling ${plugin.value.git}"
                        gitPull(new File(path))
                    }
                }
            } else {
                println "Cloning '${plugin.value.git}' into '${path}'"
                cloneRepo(plugin.value.git, path, plugin.value.branch)
                println "CLONED from ${plugin.value.git} into ${path}"
            }
        } else if (plugin.value.url == true) {
            // TODO: test
            if (!pluginExists) {
                println "Plugin ${path} exists and appears valid . . . downloading."
                def f = new File(path)
                new URL(plugin.value.url).withInputStream { i -> f.withOutputStream { it << i } }
            }
        } else {
            throw new GradleException("Invalid plugin settings for path [${path}] and setting [${plugin.value}]")
        }
    }
}

// wrapper for ant script
task buildJBrowse(dependsOn: 'build.jbrowse'){}


// TODO: should inherent handleJBrowse
task handleJBrowseRelease(dependsOn: [copyApolloPlugin]) {
    println "handling jbrowse release ${jbrowseConfig}"

    doLast {
        installJBrowsePlugins
        setupJBrowse
        copyResourcesDev
		buildJBrowse
		installJBrowseLocal
    }

}

// root task
task handleJBrowse(dependsOn: [installJBrowsePlugins]) {
    println "handling jbrowse ${jbrowseConfig}"

    doLast {
        setupJBrowse
        copyResourcesDev
		installJBrowseLocal
    }

}

def confirmPlugin(String path) {
    File file = new File(path)
    return file.exists() && file.isDirectory() && file.canRead()
}

def cloneRepo(String url, String directory, String branch) {
    cloneRepo(url, directory, branch, null)
}

def cloneRepoNoBower(String url, String directory, String branch, Integer depth) {
    String depthString = depth != null && depth > 0 ? " --recursive --depth ${depth} " : ""
    def commandToExecute = "git clone ${depthString} ${url} ${directory} "
    println "command to execute [${commandToExecute}]"
    def proc = commandToExecute.execute()
    def outputStream = new StringBuffer();
    def errorStream = new StringBuffer();
    proc.waitForProcessOutput(outputStream, errorStream);
    println outputStream
    println errorStream

    if (branch.startsWith("tags")) {
        fetchTags(new File(directory))
    }
    checkoutBranch(new File(directory), branch)
}

Boolean hasBower(){
  return true
}

task removeJBrowseDownload(type:Delete){
    delete("jbrowse-download")
}

task moveBowerJBrowse(dependsOn:removeJBrowseDownload) {
    doLast {
        file("bower_components/jbrowse").renameTo(file("jbrowse-download"))
        file("bower_components").deleteDir()
    }
}

task installJBrowseBower(type:Exec) {
    workingDir 'jbrowse-download'
    commandLine './setup.sh'
}

def refreshBowerRepo(String directory){
    exec{
        println "using bower to update: ${directory}"
        workingDir directory
        commandLine "bower","update","-F","--allow-root"
    }
}

def cloneRepoBower(String url,String directory,String branch){
    String finalUrl = url + "#${branch}"
    finalUrl = finalUrl.replaceAll("tags/","")
    if(finalUrl.startsWith(githubURL)){
        finalUrl = finalUrl.substring(githubURL.length())
    }
    exec{
        println "using bower to install: ${finalUrl}"
        commandLine "bower","install","--allow-root",finalUrl
    }

    File bowerDirectory = new File('bower_components')
    if((finalUrl.contains("#")&&finalUrl.endsWith("jbrowse"))  || finalUrl.split("#")[0].endsWith("jbrowse")) {
        println "Moving JBrowse into position ${finalUrl}"
        tasks.moveBowerJBrowse.execute()
        tasks.installJBrowseBower.execute()
    }
    else{
        bowerDirectory.eachDir {
            File targetFile = new File(directory)
            println "Moving plugin into place: ${bowerDirectory.absolutePath} -> ${targetFile}"
            it.renameTo(targetFile)
        }
    }

    // delete on exit
    if(bowerDirectory.exists() && bowerDirectory.listFiles()?.length==0){
        assert bowerDirectory.delete()
    }
}


// Get the path for the locally installed binaries
task npmBin << {
    new ByteArrayOutputStream().withStream { os ->
        exec {
            executable = npmCommand
            args = ['bin']
            standardOutput = os
        }
        ext.binPath = os.toString().trim() + File.separator
    }
}


// Install packages from package.json
task npm(type: Exec) {
    description = "Grab NodeJS dependencies (from package.json)"
    commandLine = [npmCommand, "install"]
    inputs.file "package.json"
    outputs.dir "node_modules"
    tasks.npmBin.execute()
}

//<target name="clean-all" description="Cleans this project">
//<delete dir="web-app/WEB-INF/deploy" failonerror="false"/>
//<delete dir="web-app/annotator" failonerror="false"/>
//<delete dir="target" failonerror="false"/>
//</target>
task cleanAll(type:Delete){
    delete 'web-app/WEB-INF/deploy', 'web-app/annotator','target'
}

// Install the bower components for front-end library management
task bower(dependsOn: 'npm', type: Exec){
    commandLine "${npmBin.binPath}${bowerCommand}", 'install'
}


def cloneRepo(String url, String directory, String branch, Integer depth) {
    if(hasBower()){
        cloneRepoBower(url,directory,branch)
    }
    else{
        cloneRepoNoBower(url,directory,branch,depth)
    }
}

def fetchTags(File file) {
    println "fetching tags"
    if(!isValidGitDirectory(file)) return

    def processBuilder = new ProcessBuilder()
    processBuilder.redirectErrorStream(true)
    processBuilder.directory(file)
    processBuilder.command("git", "fetch", "--tags")
    def proc = processBuilder.start()
    def outputStream = new StringBuffer();
    def errorStream = new StringBuffer();
    proc.waitForProcessOutput(outputStream, errorStream);
    if(outputStream.length()>0) println "Out: " + outputStream
    if(errorStream.length()>0) println "Error: " + errorStream
}

Boolean isValidGitDirectory(File file){
    File gitFile = new File(file.absolutePath+"/.git")
    if(!gitFile.exists() || !gitFile.canRead()){
        println "Not a valid git directory so no git operations will run ${file.absolutePath}"
        return false
    }
    return true
}

def checkoutBranch(File file, String branch) {
    println "checkout out branch ${branch}"

    if(!isValidGitDirectory(file)) return

    def processBuilder = new ProcessBuilder()
    processBuilder.redirectErrorStream(true)
    processBuilder.directory(file)
    processBuilder.command("git", "checkout", branch)
    def proc = processBuilder.start()
    def outputStream = new StringBuffer();
    def errorStream = new StringBuffer();
    proc.waitForProcessOutput(outputStream, errorStream);
    if(outputStream.length()>0) println "Out: " + outputStream
    if(errorStream.length()>0) println "Error: " + errorStream

}

def gitPull(File file) {
    println "git pull ${file.absolutePath}"
    if(!isValidGitDirectory(file)) return

    def processBuilder = new ProcessBuilder()
    processBuilder.redirectErrorStream(true)
    processBuilder.directory(file)
    processBuilder.command("git", "pull")
    def proc = processBuilder.start()
    def outputStream = new StringBuffer();
    def errorStream = new StringBuffer();
    proc.waitForProcessOutput(outputStream, errorStream);
    if(outputStream.length()>0) println "Out: " + outputStream
    if(errorStream.length()>0) println "Error: " + errorStream
}