build.gradle

buildscript {
    ext {
        springBootVersion = '1.2.5.RELEASE'
    }
    repositories {
        mavenLocal()
        jcenter()
        maven { url "https://plugins.gradle.org/m2/" }  //for sonarqube plugin
    }
    dependencies {
        classpath "org.springframework.boot:spring-boot-gradle-plugin:$springBootVersion"
        classpath 'com.ofg:uptodate-gradle-plugin:+'
        classpath "com.ofg:micro-common-release:0.1.18"
        classpath "io.spring.gradle:dependency-management-plugin:0.2.1.RELEASE"
        if (project.hasProperty("coverage")) {
            classpath 'org.kt3k.gradle.plugin:coveralls-gradle-plugin:+'
            classpath "org.sonarqube.gradle:gradle-sonarqube-plugin:1.0"
        }
        if (project.hasProperty("compatibility")) { classpath "be.insaneprogramming.gradle:animalsniffer-gradle-plugin:+" }
    }
    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'
        }
    }
}

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.3.+'
                force 'org.jboss.logging:jboss-logging:3.1.4.GA'

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

                    // 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.springframework.boot') { details.useVersion springBootVersion }
                    if (details.requested.group == 'org.springframework') { details.useVersion '4.1.7.RELEASE' }
                    if (details.requested.group == 'org.aspectj') { details.useVersion '1.8.6' }
                }
            }
        }
    }
}

task addHashFile << {
    String gitCmd = "git log --pretty=format:'%H' -n 1"
    def proc = gitCmd.execute()
    proc.waitFor()
    new File("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.7

    dependencyManagement {
        dependencies {
            "org.codehaus.groovy:groovy-all" "2.4.3"
            "com.google.guava:guava" "18.0"
            "commons-io:commons-io" "2.4"

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

            //test
            "ch.qos.logback:logback-classic" "1.1.3"
            "com.jayway.restassured:rest-assured" "2.4.1"
            "com.github.tomakehurst:wiremock" "1.56"
            "cglib:cglib-nodep" "3.1"
            "org.objenesis:objenesis" "2.1"

            dependencySet(group:'org.spockframework', version: '1.0-groovy-2.4') {
                entry "spock-core"
                entry "spock-spring"
            }
            dependencySet(group:'com.jayway.awaitility', version: '1.6.3') {
                entry "awaitility"
                entry "awaitility-groovy"
            }
        }
    }

    test {
        jvmArgs project.gradle.startParameter.systemPropertiesArgs.entrySet().collect{"-D${it.key}=${it.value}"}
        testLogging {
            exceptionFormat = 'full'
        }
    }

    if (project.hasProperty("compatibility")) {
        apply plugin: 'be.insaneprogramming.gradle.animalsniffer'

        animalsniffer {
            signature = "org.codehaus.mojo.signature:java17:+@signature"
        }

        afterEvaluate {
            animalSniffer.mustRunAfter 'compileGroovy'
        }
    }

    jar {
        dependsOn addHashFile
        from "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.11'
    }
}

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

        jacoco {
            toolVersion = '0.7.4.201502262128'
        }
    }

    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']
            }
        }

        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
    }
}

wrapper {
    gradleVersion '2.2.1'
}