jpos-app.gradle

def archiveJarName="${project.name}-${project.version}.jar"
def archiveWarName="${project.name}-${project.version}.war"
def installDir=file("${project.buildDir}/install/${project.name}")
project.ext {
    targetConfiguration = new Properties()
    def target = project.hasProperty('target') ? target : 'devel'
    targetConfiguration.put('jarname', archiveJarName.toString())
    targetConfiguration.put('warname', archiveWarName.toString())
    targetConfiguration.put('target', target.toString())
    targetConfiguration.put("buildTimestamp", new Date().format("yyyy-MM-dd HH:mm:ss z"));
    File cfgFile = file("${target}.properties")
    if (cfgFile.exists()) {
        cfgFile.withInputStream{
            targetConfiguration.load(it);
        }
    }
}

def jposCopySpec = copySpec {
    from(file("src/dist")) {
        exclude 'cfg/*.jks'
        exclude '**/*.jpg'
        exclude '**/*.gif'
        exclude '**/*.png'
        exclude '**/*.pdf'
        filter(
            org.apache.tools.ant.filters.ReplaceTokens, 
            tokens: targetConfiguration
        )
    }
    from(file("src/dist")) {
        include 'cfg/*.ks'
        include 'cfg/*.jks'
        include '**/*.jpg'
        include '**/*.gif'
        include '**/*.png'
        include '**/*.pdf'
    }
    from(jar) {
        rename archiveJarName, "${targetConfiguration.jarname}"
    }
    into("lib") {
        from(configurations.runtime)
    }
    into("webapps") {
        from(file("build/libs")) {
            include '*.war'
        }
    }
}

// Create the jar's manifest
jar.manifest {
    attributes \
        'Implementation-Title': project.name,
        'Implementation-Version': project.version,
        'Main-Class': 'org.jpos.q2.Q2',
        'Class-Path': configurations.runtime.collect { "lib/" + it.getName() }.join(' ')
}

task sourceJar( type: Jar ) {
    classifier = "sources"
    from sourceSets.main.allSource
}

task javadocJar (type: Jar, dependsOn: javadoc) {
    classifier = 'javadoc'
    from new File(project.buildDir, 'docs/javadoc')
}

artifacts {
    archives sourceJar, javadocJar
}

processResources {
    from(sourceSets.main.resources.srcDirs) {
        include '**/*.properties'
        include '**/*.xml'
        include '**/*.cfg'
        include '**/*.asc'
        filter(
            org.apache.tools.ant.filters.ReplaceTokens, 
            tokens: targetConfiguration
        )
    }
}
//--------------------------------------------------
// TASKS
//--------------------------------------------------

task version (type: JavaExec, dependsOn: classes) {
    description = "Shows jPOS Version"
    main = 'org.jpos.q2.Q2'
    args = ['--version']
    classpath configurations.runtime 
}

task dist(type: Tar) {
    dependsOn 'assemble', 'sourceJar'
    description 'Creates tar distribution'
    compression = Compression.GZIP
    includeEmptyDirs true
    into "$project.name-$version"
    with jposCopySpec
    extension "tar.gz"
}

task zip(type: Zip) {
    dependsOn 'assemble', 'sourceJar'
    description 'Creates zip distribution'
    includeEmptyDirs true
    into "$project.name-$version"
    with jposCopySpec
    extension "zip"
}

task installApp(type: Sync) {
    description 'Installs jPOS based application'
    into { installDir }
    with jposCopySpec
}

task wrapper( type: Wrapper ) {
    description = "Generate gradlew[.bat]"
    gradleVersion = '2.4'
}

task installResources(dependsOn: 'classes', type: JavaExec) {
    classpath = sourceSets.main.runtimeClasspath
    main = 'org.jpos.q2.install.Install'
    args = ["--outputDir=src/dist"]
}

task run( dependsOn: 'installApp', type: Exec ) {
    workingDir installDir
    commandLine 'java','-jar', archiveJarName
}

task genDocker(type: Docker, dependsOn: 'jar') {
    def projectName = project.name
    applicationName = "${projectName}"
    workingDir "/app"
    addFile {
        into('/app') {
            with(jposCopySpec)
        }
    }
    defaultCommand = ["/app/bin/q2"]
}

class GitRevisionTask extends DefaultTask
{
    @InputFile @Optional
    File gitHead
    boolean gotHead

    File getRefFile()
    {
        return new File(gitHead.parent,gitHead.text.replace('ref: ', '').trim())
    }

    @OutputFile
    File outputFile

    @TaskAction
    public void writeFile()
    {
        Properties props=new Properties()
        if (gotHead) {
            File ref=getRefFile()
            if (ref.exists()) {
                props.put("branch",ref.getName())
                props.put("revision",ref.text.substring(0,7))
            } else {
                props.put("branch", "detached");
                props.put("revision", gitHead.text.substring(0,7))
            }
        } else {
            props.put("branch", "unknown");
            props.put("revision", "unknown");
        }
        props.store(new FileOutputStream(outputFile),"Revision Properties")
    }
}

class BuildTimestampTask extends DefaultTask {
    // We don't want to declare @OutputFile, 
    // we need a fresh timestamp on every run
    File outputFile

    @TaskAction
    public void writeFile() {
        new File(outputFile.parent).mkdirs()
        Properties props=new Properties()
        props.put("projectName", project.name);
        props.put("version", project.version);
        props.put("buildTimestamp", new Date().format("yyyy-MM-dd HH:mm:ss z"));
        props.store(new FileOutputStream(outputFile),"Revision Properties")
    }
}


task createBuildTimestampPropertyFile(type: BuildTimestampTask) {
    outputFile = "$sourceSets.main.output.resourcesDir/buildinfo.properties" as File
}

task createRevisionPropertyFile(type: GitRevisionTask) {
    gitHead = "$rootDir/.git/HEAD" as File
    gotHead = gitHead.exists()
    if (!gotHead)
        gitHead = null;
    outputFile = "$sourceSets.main.output.resourcesDir/revision.properties" as File
}

processResources.dependsOn createBuildTimestampPropertyFile, createRevisionPropertyFile

task viewTests (description: 'Open Test Reports') << {
    Class.forName("java.awt.Desktop").newInstance().browse(
        new File("${buildDir}/reports/tests", 'index.html').toURI())
}