build.gradle

apply plugin: 'groovy'
apply plugin: 'java'
apply plugin: 'maven'
apply plugin: 'java-library'
apply plugin: 'maven-publish'

sourceCompatibility = 8

def mainClass='de.lisaplus.atlas.DoCodeGen'

project.group = 'de.lisaplus.tools'
project.version = '0.13.2'


task sourcesJar(type: Jar) {
    classifier = 'sources'
    from sourceSets.main.allJava
}

task javadocJar(type: Jar) {
    classifier = 'javadoc'
    from javadoc.destinationDir
}

repositories {
    mavenCentral()
}

artifacts {
    archives jar
}

dependencies {
    compile group: 'org.slf4j', name: 'slf4j-api', version: '1.7.25'
    compile group: 'ch.qos.logback', name: 'logback-classic', version: '1.2.3'
    compile group: 'com.beust', name: 'jcommander', version: '1.69'
    compile 'org.apache.commons:commons-lang3:3.3'
    compile 'org.codehaus.groovy:groovy-all:2.5.7'
    compile group: 'org.apache.xmlbeans', name: 'xmlbeans', version: '3.0.0'
    testCompile group: 'junit', name: 'junit', version: '4.12'
}

clean {
    delete "${buildDir}/release"
}

task dependenciesToLibDir(type: Copy) {
    into "$buildDir/release/lib"
    from configurations.runtime
}

task buildRelease (type: Copy) {
        println 'buildRelease start ...'
        outputs.upToDateWhen { false }

        copy {
            from "${project.rootDir}/src/main/resources/bin"
            into "${buildDir}/release"
        }
        copy {
            from "${project.rootDir}/src/main/resources/conf"
            into "${buildDir}/release/conf"
        }


        into "${buildDir}/release/lib"
        from "${buildDir}/libs"

        println 'buildRelease end ...'
}

task zipRelease (type: Zip) {
    doLast {
        println 'zipRelease'
        from "${buildDir}/release"
        include '*'
        include '*/*'
        archiveName "$releaseArchiveName"
        destinationDir(file("${buildDir}"))
    }
}

task myRun (type: JavaExec, dependsOn: classes){
    if(project.hasProperty('myArgs')){
        args(myArgs.split(','))
    }
    if (project.hasProperty('DEBUG')) {
        jvmArgs '-Xdebug',
                '-Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=9009'
    }
    main = mainClass
    classpath = sourceSets.main.runtimeClasspath
}

dependenciesToLibDir.dependsOn jar
buildRelease.dependsOn dependenciesToLibDir

configurations {
    integrationTestCompile.extendsFrom testCompile
    integrationTestRuntime.extendsFrom testRuntime
}

sourceSets {
    integrationTest {
        java {
            compileClasspath += main.output + test.output
            runtimeClasspath += main.output + test.output
            srcDir file('src/integration_test/java')
        }
        /* not needed this time
        resources.srcDir file('src/integration-test/resources')
        */
    }
}

task integrationTest(type: Test) {
    doFirst {
        // that's the place to init integration tests
    }

    doLast {
        // that's the place to tidy up test integration environment
    }
    testClassesDirs = sourceSets.integrationTest.output.classesDirs
    classpath = sourceSets.integrationTest.runtimeClasspath
    outputs.upToDateWhen { false }
}

task buildDockerImage {
    outputs.upToDateWhen { false }
    doLast {
        def imageName=['bash','docker/bin/image_conf.sh'].execute().text.trim()
        println "create image: $imageName ..."
        def cmd = ['docker', 'build', '-t', imageName,'.']
        def sout = new StringBuilder(), serr = new StringBuilder()
        def proc = cmd.execute()
        proc.consumeProcessOutput(sout, serr)
        proc.waitForOrKill(20000)
        if (serr.size()>0) {
            println "err> $serr"
        }
        else {
            println "... created"
        }
    }
}

buildRelease.dependsOn assemble
buildDockerImage.dependsOn buildRelease

check.dependsOn integrationTest
integrationTest.mustRunAfter test
buildRelease.dependsOn test
zipRelease.dependsOn buildRelease