build.gradle

buildscript {
    repositories {
        mavenLocal()
        jcenter()
        maven { url "https://plugins.gradle.org/m2/" } //for sonarqube plugin
    }
    dependencies {
        classpath "org.springframework.boot:spring-boot-gradle-plugin:1.4.0.RELEASE"
        classpath 'com.ofg:uptodate-gradle-plugin:+'
        classpath "com.ofg:micro-common-release:0.1.18"
        classpath "io.spring.gradle:dependency-management-plugin:0.5.6.RELEASE"
        classpath "com.jfrog.bintray.gradle:gradle-bintray-plugin:+"
        if (project.hasProperty("coverage")) {
            classpath 'org.kt3k.gradle.plugin:coveralls-gradle-plugin:+'
            classpath "org.sonarqube.gradle:gradle-sonarqube-plugin:1.0"
        }
    }
    dependencies {
        ant.unjar src: configurations.classpath.find { it.name.startsWith("micro-common-release") }, dest: 'build/release'
    }
}

apply from: "${rootProject.buildDir}/release/gradle/version.gradle"

scmVersion {
    tag {
        prefix = 'release'
        versionSeparator = '/'
    }
}

allprojects {
    group = 'com.ofg'
    project.version = scmVersion.version
}

Set emptySubprojects = [project(':swagger'), project(':micro-deps-root'), project(':stub-runner-root')]
Set srcSubprojects = subprojects - emptySubprojects

configure(srcSubprojects) {
    apply plugin: 'groovy'
    apply from: "${rootProject.buildDir}/release/gradle/publish.gradle"

    bintray {
        pkg {
            repo = project.name.startsWith("micro-deps") ? 'micro-deps' : 'micro'
            vcsUrl = 'https://github.com/4finance/micro-infra-spring.git'
        }
    }
}

apply from: "${rootProject.buildDir}/release/gradle/release.gradle"

//NOTE: All release and publishing modifications (including further scmVersion closure) should be put AFTER the apply of publish.gradle and/or release.gradle
//      (to be not overridden by the default values applied in those files)


allprojects {
    repositories {
        mavenLocal()
        mavenCentral()
        jcenter()
    }

    configurations {
        all {
            resolutionStrategy {
                exclude group: 'log4j', module: 'log4j'
                force 'org.apache.httpcomponents:httpclient:4.5.2+'
                force 'org.jboss.logging:jboss-logging:3.3.0.Final'

                eachDependency { DependencyResolveDetails details ->
                    if (details.requested.group == 'org.slf4j') { details.useVersion '1.7.21' }
                    if (details.requested.group == 'com.fasterxml.jackson.core') { details.useVersion '2.8.1' }

                    // To prevent an accidental usage of groovy-all.jar and groovy.jar in different versions
                    // all modularized Groovy jars are replaced with groovy-all.jar by default.
                    if (details.requested.group == 'org.codehaus.groovy' && details.requested.name != "groovy-all") {
                        details.useTarget("org.codehaus.groovy:groovy-all:${details.requested.version}")
                    }
                    if (details.requested.group == 'org.aspectj') { details.useVersion '1.8.9' }
                }
            }
        }
    }
}

task addHashFile << {
    String gitCmd = "git log --pretty=format:'%H' -n 1"
    def proc = gitCmd.execute()
    proc.waitFor()
    project.buildDir.mkdirs()
    new File(project.buildDir, "commitHash.txt").withWriter { it << proc.in.text }
}

configure(emptySubprojects + rootProject) {
    apply plugin: 'base'
}

configure(srcSubprojects) {

    apply plugin: 'com.ofg.uptodate'
    apply plugin: "io.spring.dependency-management"

    sourceCompatibility = 1.8

    dependencyManagement {
        imports {
            mavenBom 'org.springframework.cloud:spring-cloud-starter-parent:Brixton.SR4'
        }

        dependencies {
            dependency "org.codehaus.groovy:groovy-all:2.4.7"
            dependency "com.google.guava:guava:19.0"
            dependency "commons-io:commons-io:2.4"

            dependencySet(group:"org.apache.curator", version: "2.8.0") {
                entry "curator-x-discovery"
                entry "curator-test"
            }

            //test
            dependency "ch.qos.logback:logback-classic:1.1.7"
            dependency "com.jayway.restassured:rest-assured:2.9.0"
            dependency "com.github.tomakehurst:wiremock:2.0.10-beta"
            dependency "cglib:cglib-nodep:3.2.0"
            dependency "org.objenesis:objenesis:2.1"

            dependencySet(group:'org.spockframework', version: '1.0-groovy-2.4') {
                entry "spock-core"
                entry "spock-spring"
            }
            dependency "info.solidsoft.spock:spock-global-unroll:0.5.0"
            dependencySet(group:'com.jayway.awaitility', version: '1.7.0') {
                entry "awaitility"
                entry "awaitility-groovy"
            }
        }
    }

    test {
        jvmArgs project.gradle.startParameter.systemPropertiesArgs.entrySet().collect{"-D${it.key}=${it.value}"}
        jvmArgs '-XX:MaxPermSize=256m', '-Xmx512m'
        testLogging {
            exceptionFormat = 'full'
        }
        maxHeapSize = "2g"
        maxParallelForks = project.hasProperty('parallel') ? Runtime.runtime.availableProcessors() : 1
    }

    jar {
        dependsOn addHashFile
        from new File(project.buildDir, "commitHash.txt")
    }

    //Dependencies in all subprojects - http://solidsoft.wordpress.com/2014/11/13/gradle-tricks-display-dependencies-for-all-subprojects-in-multi-project-build/
    task allDeps(type: DependencyReportTask) {}
    task allInsight(type: DependencyInsightReportTask) {}

    configurations {
        jansi.extendsFrom(runtime)
    }
    groovydoc {
        def title = "IPDS ${version}"
        groovyClasspath = project.configurations.jansi
    }
    dependencies {
        jansi 'org.fusesource.jansi:jansi:1.12'
    }
}

if (project.hasProperty("coverage")) {
    configure(srcSubprojects + rootProject) {
        apply plugin: 'jacoco'
    }

    apply plugin: 'com.github.kt3k.coveralls'
    apply plugin: 'org.sonarqube'

    sonarqube {
        properties {
            property "sonar.projectName", "micro-infra-spring"
        }
    }

    configure(srcSubprojects) {
        jacocoTestReport {
            reports {
                xml.enabled = true // coveralls plugin depends on xml format report
            }
        }

        test {
            jacoco {
                excludes = ['*Configuration', 'repackaged.*']
            }
        }

        sonarqube {
            properties {
                property "sonar.groovy.jacoco.reportPath", "$buildDir/jacoco/test.exec"     //TODO: Could be taken from JaCoCo extension directly
                property "sonar.exclusions", "**/src/main/resources/static/swagger/**"
            }
        }
    }

    coveralls {
        sourceDirs = files(srcSubprojects.sourceSets.main.allSource.srcDirs).files.absolutePath
    }

    task jacocoRootReport(type: JacocoReport) {
        // Gather execution data from all subprojects
        // (change this if you e.g. want to calculate unit test/integration test coverage separately)
        executionData fileTree(project.rootDir.absolutePath).include("**/build/jacoco/*.exec")

        // Add all relevant sourcesets from the subprojects
        srcSubprojects.each {
            sourceSets it.sourceSets.main
        }

        reports {
            xml.enabled true
            xml.destination "${buildDir}/reports/jacoco/test/jacocoTestReport.xml"
        }
    }

    // always run the tests before generating the report
    jacocoRootReport.dependsOn {
        srcSubprojects*.test
        srcSubprojects*.jacocoTestReport
    }
}

//Individual HTML test reports could be disabled to speed up build a little bit if testReport was the only one used - http://stackoverflow.com/a/16921750
task testReport(type: TestReport) {
    destinationDir = file("$buildDir/reports/allTests")
    reportOn srcSubprojects*.test
}