build.gradle

import net.serenitybdd.builds.ProjectVersionCounter

buildscript {
    repositories {
        mavenLocal()
        jcenter()
        maven {
            url 'https://geonet.artifactoryonline.com/geonet/public-releases'
        }
    }
    dependencies {
        classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8.4'
    }
}

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.8
targetCompatibility = 1.8

repositories {
    mavenLocal()
    jcenter()
    maven() {
        url "http://dl.bintray.com/serenity/maven/"
    }
}

ext {
    bintrayBaseUrl = 'https://api.bintray.com/maven'
    bintrayRepository = 'maven'
    bintrayPackage = 'serenity-cucumber'
    projectDescription = 'Serenity Cucumber 2.x integration'

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

    versionCounter = new ProjectVersionCounter(isRelease: project.hasProperty("releaseBuild"))
}

group = 'net.serenity-bdd'
version = versionCounter.nextVersion


task createNewVersionTag(type: Exec) {
    executable "sh"
    args "-c", "git tag -f -a v$version -m'release tag'"
}

task pushVersionTag(type: Exec, dependsOn: 'createNewVersionTag') {
    executable "sh"
    args "-c", "git push -f origin v$version"
}

task tagNewVersion() {
    dependsOn pushVersionTag
}

wrapper {
    gradleVersion = '5.3.1'
}

test {
    include '**/When*'
    exclude '**/*$*'
    exclude '**/integration/**'
    exclude '**/samples/**'
    exclude '**/*Sample*'
    maxParallelForks = Runtime.runtime.availableProcessors()
}


configurations.all {
    resolutionStrategy {
        // fail fast on dependency convergence problems
        //failOnVersionConflict()
        force  "commons-collections:commons-collections:${commonsCollectionsVersion}",
        "xml-apis:xml-apis:${xmlApiVersion}",
                "commons-codec:commons-codec:${commonsCodecVersion}",
        "com.google.code.gson:gson:${gsonVersion}"
    }
}

dependencies {
    compile ("net.serenity-bdd:serenity-core:${serenityCoreVersion}")
    compile ("net.serenity-bdd:serenity-screenplay:${serenityCoreVersion}")
    compile ("net.serenity-bdd:serenity-screenplay-webdriver:${serenityCoreVersion}")
    compile "io.cucumber:cucumber-java:${cucumberJVMVersion}"
    compile("io.cucumber:cucumber-junit:${cucumberJVMVersion}") {
            exclude group: "junit"
    }
    compile("commons-logging:commons-logging:${commonsLoggingVersion}")
    compile("org.apache.commons:commons-csv:${commonsCsvVersion}")
    compile "junit:junit:${junitVersion}"
    compile "com.google.code.gson:gson:${gsonVersion}"

    testCompile ("ch.qos.logback:logback-classic:${logbackVersion}") {
        exclude module: "slf4j-api"
    }
    testCompile "org.assertj:assertj-core:${assertjVersion}"
    testCompile "org.codehaus.groovy:groovy-all:${groovyVersion}"
    testCompile("org.spockframework:spock-core:${spockVersion}") {
        exclude group: "junit"
        exclude module: "groovy-all"
    }
    testCompile("com.github.goldin:spock-extensions:${spockExtensionsVersion}") {
        exclude module: "spock-core"
        exclude module: "slf4j-api"
    }
}

jar {
    manifest {
        attributes("Implementation-Title": "Serenity Cucumber Plugin",
                   "Implementation-Version": project.version.toString())
    }
}

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 'serenity-cucumber'
                    description 'Serenity Cucumber Integration'

                    url 'https://github.com/serenity-bdd/serenity-cucumber'
                    scm {
                        url 'scm:git:git@github.com:serenity-bdd/serenity-cucumber.git'
                        connection 'scm:git:git@github.com:serenity-bdd/serenity-cucumber.git'
                        developerConnection 'scm:git:git@github.com:serenity-bdd/serenity-cucumber.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 'cliviu'
                            name 'Liviu Carausu'
                            email 'liviu.carausu@gmail.com'
                        }
                        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"
}

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
    publish = true
    pkg {
        repo = 'maven'
        userOrg = 'serenity'
        name = 'serenity-cucumber'
        desc = 'Serenity Cucumber integration'
        licenses = ['Apache-2.0']
        labels = ['serenity','bdd','cucumber']
    }
}

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