build.gradle

// Add to classpath dependencies for building the script
buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath 'com.bmuschko:gradle-docker-plugin:2.6.5'
        classpath 'org.asciidoctor:asciidoctor-gradle-plugin:1.5.3'
        classpath 'org.asciidoctor:asciidoctorj-screenshot:0.1.0'
    }
}

plugins {
    id 'net.nemerosa.versioning' version '1.5.0'
    id "de.undercouch.download" version "2.1.0"
}

apply plugin: 'war'
apply plugin: 'pmd'
apply plugin: 'maven-publish'


// all projects need JaCoCo integration, compiling in Java 8 and similar group and version strategy
allprojects {
    sourceCompatibility = 1.8
    targetCompatibility = 1.8

    group = 'org.starwars'
    version = '1.0-SNAPSHOT'

    repositories {
        mavenCentral()
    }

}

apply plugin: 'jacoco'
jacoco {
    toolVersion = "0.7.5.201505241946"
}

// there are dependencies that are common on core project (this) and all other subprojects like testing libraries
dependencies {
    providedCompile 'javax:javaee-api:7.0'

    testCompile 'junit:junit:4.12'
    testCompile 'org.hamcrest:hamcrest-library:1.3'
    testCompile 'org.apache.cxf:cxf-rt-rs-client:3.1.4'
    testCompile 'org.apache.johnzon:johnzon-jaxrs:0.9.2-incubating'
    testCompile 'com.github.tomakehurst:wiremock:2.0.8-beta'
    testCompile('org.mockito:mockito-all:1.10.19') {
        exclude group: 'org.hamcrest'
    }

}


tasks.withType(JavaCompile) {
     options.encoding = 'UTF-8'
}

// aggregates jacoco results from all subprojects and core project and generate a report
task jacocoRootTestReport(type: JacocoReport) {

    sourceSets sourceSets.main

    def jacocoTestFiles = ["$buildDir/jacoco/test.exec"]
    subprojects.each { p ->
        def coverageFileLocation = "$p.buildDir/jacoco/test.exec"
        if (new File(coverageFileLocation).exists()) {
            jacocoTestFiles << coverageFileLocation
        }
    }

    logger.info('Aggregating next JaCoCo Coverage Files: {}', jacocoTestFiles)
    executionData files(jacocoTestFiles)

    reports {
        xml.enabled false
        csv.enabled false
    }
}


// add pmd static code analysis
pmd {
    ignoreFailures = true
    ruleSets = [
            "basic"
    ]
}

// initialize ext.config object with configuration parameters
apply from: "$rootDir/gradle/configuring.gradle"

// change version of all projects to version + (jenkinsBuild?)
allprojects {
    apply from: "$rootDir/gradle/versioning.gradle"
    ext.config = rootProject.ext.parsedConfig
    apply from: "$rootDir/gradle/dockercompose.gradle"
}

// TODO https://plugins.gradle.org/plugin/com.github.ksoichiro.build.info
// adds a build-info file inside war file
task createBuildInfoFile << {

    def buildInfoFile = new File("$buildDir/build-info.properties")
    Properties props = new Properties()
    props.setProperty('version', project.version.toString())
    props.setProperty('timestamp', project.buildTimestamp)
    props.setProperty('git_commit', versioning.info.build)
    props.store(buildInfoFile.newWriter(), null)
}

// creates war with Manifest and build file information
war {
    dependsOn createBuildInfoFile
    from(buildDir) {
        include 'build-info.properties'
        into('WEB-INF/classes')
    }
    manifest {
        attributes "Implementation-Version": project.version.toString()
    }
}

// creates Docker image for developers
// IMPORTANT: this task is not intend to be used by Jenkins
// Now to work with Docker-Machine

apply plugin: 'com.bmuschko.docker-remote-api'
import com.bmuschko.gradle.docker.tasks.image.DockerBuildImage

docker {
    if (System.env.containsKey('DOCKER_HOST') && System.env.containsKey('DOCKER_CERT_PATH')) {
        url = System.env.DOCKER_HOST.replace("tcp", "https")
        certPath = new File(System.env.DOCKER_CERT_PATH)
    }
}

task buildImage(type: DockerBuildImage) {
    dependsOn assemble
    inputDir = project.rootDir
    tag = "${config.common.docker.organization}/${config.common.docker.image}:latest"
}
buildImage.onlyIf {project.hasProperty('env') && project.getProperty('env') == 'dev'}

// to publish artifact (war) we need to create sourceJar (jar with sources) and javadocJar (jar with javadoc) tasks
// so those are called and attached to the publish
task sourceJar(type: Jar) {
    from sourceSets.main.allJava
}

task javadocJar (type: Jar, dependsOn: javadoc) {
    from javadoc.destinationDir
}

// gets from config variable the location where artifacts are published
ext.repoUrl = "$config.binaryRepository.url/$config.binaryRepository.name"

// publish artifact to
publishing {
    publications {
        webApp(MavenPublication){
            from components.web
            // sourceJar task created previously
            artifact sourceJar {
                classifier "sources"
            }
            // javadocJar task created previously
            artifact javadocJar {
                classifier "javadoc"
            }
        }
    }

    // Local directory is used for simplification

    repositories {
        maven {
            url repoUrl
        }
    }
}

apply plugin: 'org.asciidoctor.gradle.asciidoctor'

asciidoctor {
    sourceDir = file('src/asciidoc')
    attributes = [
            'screenshot-dir-name': "../screens",
            'rootdir': "${rootDir}"
    ]
}

task downloadFile(type: de.undercouch.gradle.tasks.download.Download) {
    src 'https://github.com/sdaschner/jaxrs-analyzer/releases/download/v0.9/jaxrs-analyzer.jar'
    dest buildDir
}

task runJaxRsAnalyzer(type:Exec) {
    if (!new File("${buildDir}/jaxrs-analyzer.jar").exists()) {
        dependsOn downloadFile
    }
    workingDir "${buildDir}"

    def args = [
            "-b",
            "asciidoc",
            "-o",
            "${buildDir}/starwarsendpoints.adoc",
            "${buildDir}/classes/main"
    ]

    commandLine "java -jar ${buildDir}/jaxrs-analyzer.jar -b asciidoc -o ${buildDir}/starwarsendpoints.adoc ${buildDir}/classes/main"

}