build.gradle

import org.ajoberstar.gradle.git.release.opinion.Strategies
import org.ajoberstar.grgit.Grgit

group = 'net.serenity-bdd'
buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.5'
        classpath 'org.ajoberstar:gradle-git:1.6.0'
        classpath 'org.pegdown:pegdown:1.4.1'
    }
}

apply plugin: 'org.ajoberstar.release-opinion'

task wrapper(type: Wrapper) {
    gradleVersion = "${gradleVersion}"
}

subprojects {
    task allDeps(type: DependencyReportTask) {}
}

ext {
    seleniumVersion = '2.53.1'
    htmlunitVersion = '2.21'

    groovyVersion = '2.4.4'
    gradleVersion = '2.10'

    junitVersion = '4.12'
    hamcrestVersion = '1.3'
    springVersion = '4.3.5.RELEASE'
    springBootVersion = '1.4.3.RELEASE'
    guavaVersion = '20.0'
    restAssuredVersion = '2.4.1'
    mockitoCoreVersion = '1.10.19'
    jbehaveCoreVersion = '4.1'
    commonsIoVersion = '2.5'
    commonsCollectionsVersion = '3.2.2'
    commonsLang3Version = '3.4'
    commonsCodecVersion = '1.10'
    xstreamVersion = '1.4.9'
    jodaTimeVersion = '2.7'
    lambdajVersion = '2.3.3'
    gsonVersion = '2.6.1'
    typesafeConfigVersion = '1.2.1'
    freemarkerVersion = '2.3.23'
    wiremockCoreVersion = '1.58'
    // Bintray configuration
    bintrayBaseUrl = 'https://api.bintray.com/maven'
    bintrayRepository = 'maven'
    bintrayPackage = 'serenity-core'
    projectDescription = 'Serenity Core'

    if (!project.hasProperty("bintrayUsername")) {
        bintrayUsername = 'wakaleo'
    }
    if (!project.hasProperty("bintrayApiKey")) {
        bintrayApiKey = ''
    }

}

allprojects {
    apply plugin: 'project-report'

    configurations.all {
        resolutionStrategy {
            // fail fast on dependency convergence problems
           failOnVersionConflict()

            // force versions to fix dependency convergence problems
            // when updating this list, update Serenity's declared deps if exists
            // TODO make work for generated Maven POM...
            // it's working for gradle build, but also had to exclude old transitives for geio.appiumnerated POM
            force  "com.thoughtworks.xstream:xstream:${xstreamVersion}",
                   "commons-collections:commons-collections:${commonsCollectionsVersion}",
                   'commons-logging:commons-logging:1.2',
                   'xml-apis:xml-apis:1.4.01',
                    'org.springframework:spring-context:4.3.5.RELEASE'

        }
    }
}

release {
    grgit = Grgit.open()
    defaultVersionStrategy Strategies.SNAPSHOT
    versionStrategy Strategies.SNAPSHOT
}

subprojects {
    apply plugin: 'java'
    apply plugin: 'groovy'
    apply plugin: 'eclipse'
    apply plugin: 'idea'
    apply plugin: 'maven'
    apply plugin: 'maven-publish'
    apply plugin: 'com.jfrog.bintray'

    sourceCompatibility = 1.7
    targetCompatibility = 1.7

    repositories {
        mavenLocal()
        jcenter()
    }

    ext {
        bintrayBaseUrl = 'https://api.bintray.com/maven'
        bintrayRepository = 'maven'
        bintrayPackage = 'serenity-core'
        projectDescription = 'Serenity core libraries'
        if (!project.hasProperty("bintrayUsername")) {
            bintrayUsername = 'wakaleo'
        }
        if (!project.hasProperty("bintrayApiKey")) {
            bintrayApiKey = ''
        }
    }
    group = 'net.serenity-bdd'
    version = rootProject.version

    test {
        exclude '**/*$*'
        exclude '**/integration/**'
        exclude '**/samples/**'
        exclude '**/*Sample*'
        minHeapSize = "128m"
        maxHeapSize = "1536m"
        if (!JavaVersion.current().isJava8Compatible()) {
            jvmArgs += ["-XX:MaxPermSize=256m"]
        }
//        testLogging {
//            events "passed", "skipped", "failed", "standardOut", "standardError"
//        }
        maxParallelForks = Integer.parseInt(System.getProperty("forks","1"))
    }

    task integrationTests(type: Test) {
        exclude '**/*$*'
        exclude '**/samples/**'
        exclude '**/*Sample*'
        exclude '**/integration/browsers**'
        include '**/integration/**'
        reports.junitXml.destination = "${buildDir}/reports/integration-tests"
        reports.html.destination = "${buildDir}/reports/integration-tests"
        minHeapSize = "128m"
        maxHeapSize = "1536m"
        if (!JavaVersion.current().isJava8Compatible()) {
            jvmArgs '-XX:MaxPermSize=256m'
        }
    }

    test {
        testLogging {
            events "failed"//, "passed", "skipped"
            exceptionFormat = 'full'
        }
//        beforeTest { desc ->
//            println "Executing test ${desc.name} [${desc.className}]"
//        }
//        afterTest { desc ->
//            println "Finished test ${desc.name} [${desc.className}]"
//        }
    }

    integrationTests {
        testLogging {
            events "failed"//, "passed", "skipped"
            exceptionFormat = 'full'
        }
//        beforeTest { desc ->
//            println "Executing test ${desc.name} [${desc.className}]"
//        }
//        afterTest { desc ->
//            println "Finished test ${desc.name} [${desc.className}]"
//        }
    }

    task browserTests(type: Test) {
        exclude '**/*$*'
        exclude '**/samples/**'
        exclude '**/*Sample*'
        exclude '**/*Base'
        include '**/integration/browsers/**'
    }

    task javadoc(type: Javadoc, overwrite: true) {
        source = sourceSets.main.allJava
        options.memberLevel = JavadocMemberLevel.PUBLIC
        options.addStringOption('views')
        options.addStringOption('all')
        options.addStringOption('quiet')
        options.addStringOption('qualify')
        options.addStringOption('Xdoclint:none')
        options.encoding = 'UTF-8'
        classpath = configurations.compile
    }

//    integrationTests.dependsOn test
    check.dependsOn -= integrationTests


    dependencies {
        compile "com.google.guava:guava:${guavaVersion}"
        compile "com.google.code.findbugs:jsr305:3.0.1"
        compile("com.google.inject:guice:3.0") {
            exclude group:"org.ow2.asm", module:"asm"
            exclude group:"asm", module:"asm"
            exclude group:"org.sonatype.sisu.inject", module:"cglib"
        }

        compile ('cglib:cglib:3.1') {
            exclude group:"org.ow2.asm", module:"asm"
        }
        compile ('org.ow2.asm:asm:5.0.3')

        compile "commons-codec:commons-codec:${commonsCodecVersion}"
        compile "org.objenesis:objenesis:2.1"
        compile "org.slf4j:slf4j-api:1.7.21"
        compile "xml-apis:xml-apis:1.4.01"
        compile 'info.cukes:cucumber-core:1.2.5'

        compile 'commons-logging:commons-logging:1.2'
        compile "junit:junit:${junitVersion}"
        compile("org.mockito:mockito-core:${mockitoCoreVersion}") {
            exclude group: "org.hamcrest", module:"hamcrest-core"
            exclude group: "org.objenesis", module:"objenesis"
        }

        testCompile ("ch.qos.logback:logback-classic:1.1.7") {
            exclude group: "org.slf4j", module: 'slf4j-api'
        }
        testCompile "org.hamcrest:hamcrest-integration:${hamcrestVersion}"
        testCompile "org.hamcrest:hamcrest-library:${hamcrestVersion}"
        testCompile "org.hamcrest:hamcrest-core:${hamcrestVersion}"
        testCompile('org.spockframework:spock-core:1.0-groovy-2.4') {
            exclude group: "junit"
            exclude group:"org.codehaus.groovy", module: "groovy-all"

        }
        testCompile("com.github.goldin:spock-extensions:0.1.4") {
            exclude group:"org.spockframework", module: "spock-core"
            exclude group:"org.slf4j", module: "slf4j-api"
            exclude group:"asm", module: "asm"
        }
        testCompile("org.codehaus.groovy:groovy-all:${groovyVersion}")
        testCompile 'org.assertj:assertj-core:1.7.1'
    }

    configurations.all {
        resolutionStrategy.eachDependency { DependencyResolveDetails details ->
            if (details.requested.name == 'mockito-all') {
                details.useTarget group: 'org.mockito', name: 'mockito-core', version: '1.9.5'
            }
            if (details.requested.name == 'hamcrest-core') {
                details.useTarget group: 'org.hamcrest', name: 'hamcrest-core', version: "${hamcrestVersion}"
            }
            if (details.requested.name == 'hamcrest-all') {
                details.useTarget group: 'org.hamcrest', name: 'hamcrest-all', version: "${hamcrestVersion}"
            }
            if (details.requested.name == 'hamcrest-library') {
                details.useTarget group: 'org.hamcrest', name: 'hamcrest-library', version: "${hamcrestVersion}"
            }
        }
    }

    jar {
        manifest.attributes["Created-By"] =
                "${System.getProperty("java.version")} (${System.getProperty("java.specification.vendor")})"
        manifest.attributes["Implementation-Title"] = project.name
        manifest.attributes["Implementation-Version"] = project.version

        from("${rootProject.projectDir}/src/dist") {
            include "license.txt"
            include "notice.txt"
            into "META-INF"
            expand(copyright: new Date().format("yyyy"), version: project.version)
        }
    }

    bintray {
        user = bintrayUsername //this usually comes form gradle.properties file in ~/.gradle
        key = bintrayApiKey //this usually comes form gradle.properties file in ~/.gradle
        publications = ['mavenJava'] // see publications closure
        pkg {
            repo = 'maven'
            userOrg = 'serenity'
            name = 'serenity-core'
            desc = 'Serenity core libraries'
            licenses = ['Apache-2.0']
            labels = ['serenity', 'bdd']
        }
    }

    task sourcesJar(type: Jar, dependsOn: classes) {
        classifier = 'sources'
        from sourceSets.main.allSource
    }

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

    artifacts {
        archives sourcesJar, javadocJar
    }

    publishing {
        publications {
            mavenJava(MavenPublication) {

                println "Publishing $project.name:$project.group:$project.version"

                from components.java

                artifact sourcesJar {
                    classifier "sources"
                }

                artifact javadocJar {
                    classifier "javadoc"
                }

                pom.withXml {
                    asNode().children().last() + {
                        resolveStrategy = Closure.DELEGATE_FIRST
                        name "$project.name"
                        description "$projectDescription"

                        url 'https://github.com/serenity-bdd/serenity-core'
                        scm {
                            url 'scm:git:git@github.com:serenity-bdd/serenity-core.git'
                            connection 'scm:git:git@github.com:serenity-bdd/serenity-core.git'
                            developerConnection 'scm:git:git@github.com:serenity-bdd/serenity-core.git'
                        }
                        licenses {
                            license {
                                name 'The Apache Software License, Version 2.0'
                                url 'http://www.apache.org/license/LICENSE-2.0.txt'
                                distribution 'repo'
                            }
                        }
                        developers {
                            developer {
                                id 'johnsmart'
                                name 'John Ferguson Smart'
                                email 'john.smart@wakaleo.com'
                            }
                        }
                    }
                    // Preserve compile-scope dependencies
                    asNode().dependencies.'*'.findAll() {
                        it.scope.text() == 'runtime' && project.configurations.compile.allDependencies.find { dep ->
                            dep.name == it.artifactId.text()
                        }
                    }.each() {
                        it.scope*.value = 'compile'
                    }
                }
            }
        }
    }

    tasks.withType(GroovyCompile) {
        options.encoding = "UTF-8" // for Java compilation
        groovyOptions.encoding = "UTF-8" // for Groovy compilation
    }

    tasks.withType(JavaCompile) {
        options.compilerArgs << "-Xlint:-options"
        options.encoding = 'UTF-8'
    }
    if (JavaVersion.current().isJava8Compatible()) {
        allprojects {
            tasks.withType(Javadoc) {
                options.addStringOption('Xdoclint:none', '-quiet')
            }
        }
    }

    task wrapper(type: Wrapper) {
        gradleVersion = "${gradleVersion}"
    }

    task copyDeps(type: Copy) {
        from configurations.runtime + configurations.testCompile
        into project.projectDir.path + "/lib"
    }
}