build.gradle

buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:0.6'
        classpath 'org.ajoberstar:gradle-git:0.12.0'
        classpath 'org.pegdown:pegdown:1.4.1'
        classpath 'com.github.ben-manes:gradle-versions-plugin:0.7'
    }
}

import org.ajoberstar.grgit.*
import org.ajoberstar.gradle.git.release.opinion.Strategies
import org.pegdown.PegDownProcessor
import groovy.text.SimpleTemplateEngine

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

allprojects {
    apply plugin: 'project-report'
    apply plugin: 'com.github.ben-manes.versions'

    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 generated POM
            force 'asm:asm:3.3.1',
                'com.fasterxml.jackson.core:jackson-annotations:2.4.3',
                'com.google.code.gson:gson:2.3',
                'com.google.guava:guava:18.0',
                'com.google.inject.extensions:guice-multibindings:3.0',
                'com.google.inject.extensions:guice-servlet:3.0',
                'com.google.inject:guice:3.0',
                'com.thoughtworks.xstream:xstream:1.4.1',
                'commons-codec:commons-codec:1.9',
                'commons-collections:commons-collections:3.2.1',
                'commons-io:commons-io:2.4',
                'commons-logging:commons-logging:1.1.3',
                'joda-time:joda-time:2.2',
                'org.apache.commons:commons-lang3:3.3.2',
                'org.apache.httpcomponents:httpclient:4.3.4',
                'org.apache.httpcomponents:httpmime:4.3.3',
                'org.bouncycastle:bcprov-jdk15on:1.48',
                'org.codehaus.groovy:groovy-all:2.3.6',
                'org.codehaus.jackson:jackson-core-asl:1.7.1',
                'org.codehaus.jackson:jackson-mapper-asl:1.7.1',
                'org.eclipse.jetty:jetty-http:8.1.15.v20140411',
                'org.freemarker:freemarker:2.3.21',
                'org.objenesis:objenesis:2.1',
                'org.seleniumhq.selenium:selenium-api:2.44.0',
                'org.slf4j:slf4j-api:1.7.5',
                'xalan:xalan:2.7.1',
                'xml-apis:xml-apis:1.4.01'
        }
    }
}

release {
    grgit = Grgit.open(project.file('.'))
    versionStrategy Strategies.FINAL
    versionStrategy Strategies.PRE_RELEASE
    defaultVersionStrategy 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

    task wrapper(type: Wrapper) {
        gradleVersion = '2.2.1'
    }

    test {
        exclude '**/*$*'
        exclude '**/integration/**'
        exclude '**/samples/**'
        exclude '**/*Sample*'
        minHeapSize = "128m"
        maxHeapSize = "512m"
        jvmArgs '-XX:MaxPermSize=256m'
    }

    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 = "2048m"
        jvmArgs '-XX:MaxPermSize=256m'
    }

    test {
        testLogging {
            exceptionFormat = 'full'
        }
    }

    integrationTests {
        testLogging {
            exceptionFormat = 'full'
        }
    }

    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:18.0"
        compile "com.google.inject:guice:3.0"
        compile "commons-codec:commons-codec:1.9"
        compile "org.objenesis:objenesis:2.1"
        compile "org.slf4j:slf4j-api:1.6.4"
        compile "xml-apis:xml-apis:1.4.01"
        testCompile "ch.qos.logback:logback-classic:1.0.13"
        testCompile "junit:junit:4.11"
        testCompile "org.hamcrest:hamcrest-integration:1.3"
        testCompile "org.hamcrest:hamcrest-library:1.3"
        testCompile "org.hamcrest:hamcrest-core:1.3"
        testCompile('org.mockito:mockito-all:1.10.8') {
            exclude group: "org.hamcrest"
        }
        testCompile("org.spockframework:spock-core:0.7-groovy-2.0") {
            exclude group: "junit"
        }
        testCompile("com.github.goldin:spock-extensions:0.1.4") {
            exclude module: "spock-core"
        }
        testCompile("org.codehaus.groovy:groovy-all:2.3.6")
        testCompile("org.easytesting:fest-assert:1.4")
    }

    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(JavaCompile) {
        options.compilerArgs << "-Xlint:-options"
    }
    if (JavaVersion.current().isJava8Compatible()) {
        allprojects {
            tasks.withType(Javadoc) {
                options.addStringOption('Xdoclint:none', '-quiet')
            }
        }
    }
}

// Supporting methods to generate the release notes from the Git commits
// TODO: Make this into a plugin

/*
String LAST_LEGACY_TAG = "v1.0.23"
String RELEASE_NOTES_FILE = 'release-notes.md'

task publishReleaseNotes() {
    println "Generating Release Notes"
    def writeLegacyReleaseNotes = false

    def releaseNotes = new File(RELEASE_NOTES_FILE)
    releaseNotes.delete()

    def tags = readTags()

    writeTableOfContents(releaseNotes, tags)

    def moreRecentTag = null
    tags.findAll { !it.isEmpty() }.each {tag ->
        if (tag == LAST_LEGACY_TAG) {
            writeLegacyReleaseNotes = true
        }
        if (!moreRecentTag) {
            writeReleaseTitle(releaseNotes, 'Upcoming')
            writeToReleaseNotes(changesBetween(tag, null), releaseNotes, writeLegacyReleaseNotes)
        }
        else {
            writeReleaseTitle(releaseNotes, moreRecentTag)
            writeToReleaseNotes(changesBetween(tag, moreRecentTag), releaseNotes, writeLegacyReleaseNotes)
        }
        moreRecentTag = tag
    }
    writeReleaseTitle(releaseNotes, moreRecentTag)
    writeToReleaseNotes(changesBetween(null, moreRecentTag), releaseNotes, writeLegacyReleaseNotes)

    releaseNotes << "\n"
}

private void writeTableOfContents(releaseNotes, List<String> tags) {
    releaseNotes << '# Releases\n'
    tags.findAll { !it.isEmpty() }.each { tag ->
        releaseNotes << "- [$tag](#$tag)\n"
    }
}

private File writeReleaseTitle(releaseNotes, title) {
    releaseNotes << "# $title<a name='$title'></a>\n"
}

private File writeSubtitleitle(releaseNotes, title) {
    releaseNotes << "## $title\n"
}
private Iterable<CommitMessage> writeToReleaseNotes(List<CommitMessage> changes, releaseNotes, legacyMode) {

    boolean typesShown = false
    MessageType.values().each {
        def changesOfThisType = changesOfType(it, changes)
        if (changesOfThisType) {
            typesShown = true
            writeSubtitleitle(releaseNotes, it.label)
            changesOfThisType.each { change ->
                if (change.isIncludedInReleaseNotes()) {
                    releaseNotes << "$change\n"
                }
            }
        }
    }

    if (legacyMode) {
        def miscChanges = changesOfType(null, changes)
        if (miscChanges) {
            if (typesShown) writeSubtitleitle(releaseNotes, 'Miscellaneous')
            miscChanges.each {
                releaseNotes << "$it\n"
            }
        }
    }
}

def readTags() {
    def lines = []
    def proc = 'git for-each-ref --format=%(*committerdate:iso8601)-%(refname) refs/tags'.execute()
    proc.in.eachLine {
        line -> lines += line
    }
    lines = lines.sort().reverse();
    return lines.collect { String line -> line.length() > 36 ? line.substring(36) : ""}
}

List<CommitMessage> changesBetween(String prevTag, String tag) {
    def command = "git log $prevTag..$tag --format=%x20-%x20%s%+b"
    if (prevTag == null) {
        command = "git log $tag --format=%x20-%x20%s%+b"
    } else if (tag == null) {
        command = "git log $prevTag..HEAD --format=%x20-%x20%s%+b"
    }
    def proc = command.execute()
    def changes = []

    def subject = null
    def body = []
    proc.in.eachLine {
        if (it.startsWith(" - ")) {
            if (subject) {
                changes  += new CommitMessage(subject, body)
                body = []
            }
            subject = it.substring(3)
        } else {
            body += it
        }
    }
    if (subject) {
        changes += new CommitMessage(subject, body)
    }
    return changes
}

enum MessageType {
    feat("Features"),
    fix("Bug Fixes"),
    docs("Documentation"),
    style("Style"),
    refactor("Refactoring"),
    perf("Performance"),
    test("Tests"),
    chore("Chores")

    def label

    MessageType(label) {
        this.label = label
    }
}

class CommitMessage {
    MessageType type;
    String subject;
    List<String> body;

    CommitMessage(String subjectText, List<String> body) {
        if (declaredType(subjectText)) {
            this.type = declaredType(subjectText)
            this.subject = subjectText.replace("$type:","")
        } else {
            this.subject = subjectText
        }
        this.body = body
    }

    def declaredType(String subject) {
        return MessageType.values().find {
            String typeName = it.toString().toLowerCase()
            subject.toLowerCase().startsWith("$typeName:")
        }
    }

    def isIncludedInReleaseNotes() { type != null }

    @Override
    public String toString() {
        def rendered = "  - $subject";
        body.each {
            rendered += "\n" + it
        }
        rendered
    }
}

List<CommitMessage> changesOfType(MessageType messageType, List<CommitMessage> commitMessages) {
    commitMessages.findAll { it.type == messageType}
}
*/