build.gradle

// tag::versions[]
buildscript {
    dependencies {
        apply from: "versions.gradle"

        def depMgmtVersion = versions['dependency.management.plugin.version']

        classpath "io.spring.gradle:dependency-management-plugin:${depMgmtVersion}"
        classpath 'org.asciidoctor:asciidoctor-gradle-plugin:1.5.9.2'
        classpath 'org.asciidoctor:asciidoctorj-pdf:1.5.0-alpha.16'
        classpath 'com.moowork.gradle:gradle-node-plugin:1.1.1'
        classpath 'org.ajoberstar:gradle-git-publish:0.4.1'
        classpath 'org.sonarsource.scanner.gradle:sonarqube-gradle-plugin:2.5-rc1'
        classpath "org.kt3k.gradle.plugin:coveralls-gradle-plugin:2.8.1"

        classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8.4'

        classpath 'com.bmuschko:gradle-docker-plugin:3.2.8'
    }
}

wrapper {
    gradleVersion = '5.2.1'
}

// note that a production build creates javadoc, sources jars and signatures undesired during development
// for performance reasons
def isProductionBuild = System.env.NEXUS_DEPLOY_USER != null
ext {
    timestampedVersion = isProductionBuild
}

apply plugin: 'org.ajoberstar.grgit'

if (ext.timestampedVersion) {
    def gitCommitTimestamp = grgit.head().date.format("yyyyMMddHHmmss", TimeZone.getTimeZone('GMT'))
    version = BUILD_VERSION_PREFIX + "." + gitCommitTimestamp
} else {
    version = '10.0.0-SNAPSHOT'
}
group = GROUP_ID

if (JavaVersion.current().isJava8Compatible()) {
    allprojects {
        tasks.withType(Javadoc) {
            options.addStringOption('Xdoclint:none', '-quiet')
        }
    }
}

gradle.beforeProject { Project project ->
    project.with {
        apply plugin: "eclipse"

        apply plugin: 'maven'

        def docs = project.name == 'crnk-documentation'
        def ui = project.name == 'crnk-ui'
        def testProject = project.name == 'crnk-test'
        def legacyBraveProject = project.name == 'crnk-brave'
        def bom = project.name == 'crnk-bom'
        def examples = project.name.contains('example')

        if (!docs) {
            apply plugin: 'java'

            sourceCompatibility = 1.8
            targetCompatibility = 1.8

            if (!bom) {
                dependencies {
                    testCompile group: 'junit', name: 'junit', version: '4.12'
                    testCompile group: 'org.mockito', name: 'mockito-core', version: '1.10.19'
                    testCompile group: 'org.assertj', name: 'assertj-core', version: '2.2.0'
                    // https://mvnrepository.com/artifact/javax.annotation/javax.annotation-api
                    compile group: 'javax.annotation', name: 'javax.annotation-api', version: '1.2'
                    // https://mvnrepository.com/artifact/javax.xml.bind/jaxb-api
                    compile group: 'javax.xml.bind', name: 'jaxb-api', version: '2.4.0-b180830.0359'
                }

                test {
                    useJUnitPlatform()
                    maxParallelForks = 1

                    testLogging {
                        exceptionFormat = 'full'
                    }
                }

                configurations.all {
                    exclude group: "org.slf4j", module: "slf4j-log4j12"
                    exclude group: "log4j", module: "log4j"
                }

                apply plugin: 'io.spring.dependency-management'
                dependencyManagement {
                    imports {
                        mavenBom 'io.projectreactor:reactor-bom:Bismuth-RELEASE'
                        mavenBom 'org.glassfish.jersey:jersey-bom:2.26'
                    }
                    dependencies {
                        dependency 'com.fasterxml.jackson.core:jackson-databind:2.9.10'
                        dependency 'com.fasterxml.jackson.core:jackson-annotations:2.9.10'
                        dependency 'com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.9.10'
                        dependency 'com.fasterxml.jackson.jaxrs:jackson-jaxrs-json-provider:2.9.10'
                        dependency 'com.fasterxml.jackson.jaxrs:jackson-jaxrs-base:2.9.10'
                        dependency 'com.fasterxml.jackson.core:jackson-core:2.9.10'
						dependency 'com.fasterxml.jackson.datatype:jackson-datatype-jdk8:2.9.10'

                        dependency 'org.reflections:reflections:0.9.11'
                    }
                }
            }
        }

        if (!docs && !examples && !testProject && !legacyBraveProject) {
            apply plugin: "jacoco"
            jacoco {
                toolVersion = "0.7.6.201602180812"
            }

            rootProject.tasks.jacocoMerge.executionData tasks.withType(Test)
            rootProject.tasks.jacocoRootReport.additionalSourceDirs files(sourceSets.main.allSource.srcDirs)

            def sourceDirs = rootProject.tasks.jacocoRootReport.sourceDirectories
            def classDirs = rootProject.tasks.jacocoRootReport.classDirectories

            def mainOutput = files(files(sourceSets.main.output).collect {
                fileTree(dir: it, exclude: '**/legacy/**')
            })

            if (sourceDirs == null) {
                rootProject.tasks.jacocoRootReport.sourceDirectories = files(sourceSets.main.allSource.srcDirs)
                rootProject.tasks.jacocoRootReport.classDirectories = mainOutput

            } else {
                rootProject.tasks.jacocoRootReport.sourceDirectories = sourceDirs.plus(files(sourceSets.main.allSource.srcDirs))
                rootProject.tasks.jacocoRootReport.classDirectories = classDirs.plus(mainOutput)
            }
            rootProject.coveralls.sourceDirs.addAll(sourceSets.main.allSource.srcDirs.flatten())

            jacocoTestReport {
                reports {
                    xml.enabled = true // coveralls plugin depends on xml format report
                    html.enabled = true
                }
            }
        }

        apply plugin: 'maven-publish'

        if (!docs && !examples) {

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

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

            apply plugin: 'com.jfrog.bintray'

            // Create the pom configuration:
            def pomConfig = {
                licenses {
                    license {
                        name "The Apache Software License, Version 2.0"
                        url "http://www.apache.org/licenses/LICENSE-2.0.txt"
                        distribution "repo"
                    }
                }
                developers {
                    developer {
                        id 'crnk.io'
                        name 'crnk.io'
                        email 'info@crnk.io'
                    }
                }

                scm {
                    url "https://github.com/crnk-project/crnk-framework"
                }
            }

            if (!bom) {
                publishing {
                    publications {
                        mavenJava(MavenPublication) {
                            from components.java

                            artifact sourcesJar {
                                classifier "sources"
                            }

                            artifact javadocJar {
                                classifier "javadoc"
                            }

                            groupId GROUP_ID
                            artifactId project.name
                            version project.version

                            pom.withXml {
                                def root = asNode()
                                root.appendNode('description', 'JSON API with Crnk')
                                root.appendNode('name', 'Crnk')
                                root.appendNode('url', 'https://www.crnk.io')
                                root.children().last() + pomConfig
                            }
                        }
                    }
                }
            }

            def releaseBuild = project.hasProperty('stable')

            bintray {
                user = System.env.BINTRAY_USER
                key = System.env.BINTRAY_TOKEN

                publications = ['mavenJava']

                pkg {
                    repo = releaseBuild ? 'maven' : 'mavenLatest'
                    name = project.name
                    userOrg = 'crnk-project'
                    licenses = ['Apache-2.0']
                    vcsUrl = 'https://github.com/crnk-project/crnk-framework.git'
                    websiteUrl = 'http://www.crnk.io'
                    desc = 'JSON API with Crnk'
                    labels = ['JSONAPI', 'rest']

                    githubRepo = 'crnk-project/crnk-framework'
                    githubReleaseNotesFile = 'README.md'

                    publish = !releaseBuild

                    version {
                        name = project.version
                        desc = 'JSON API with Crnk'
                        released = new Date()
                        vcsTag = "v$project.version"


                        mavenCentralSync {
                            sync = false //[Default: true] Determines whether to sync the version to Maven Central.
                            user = System.env.NEXUS_DEPLOY_USER
                            password = System.env.NEXUS_DEPLOY_PASS
                            close = '1'
                        }
                    }


                }
            }

            tasks.bintrayUpload.dependsOn assemble, sourcesJar, javadocJar, publishToMavenLocal

            publish.dependsOn tasks.bintrayUpload


        }

    }
}

// coveralls setup
apply plugin: "jacoco"
apply plugin: "com.github.kt3k.coveralls"

def publishedProjects = subprojects.findAll {
    it.name != 'crnk-documentation' && it.name != 'crnk-ui' && it.name != 'crnk-test' && !it.name.contains('example')
}

task jacocoMerge(type: JacocoMerge) {
    destinationFile = new File(project.buildDir, 'jacoco/test.exec')
    doFirst {
        executionData = files(executionData.findAll { it.exists() })
    }
    for (publishedProject in publishedProjects) {
        dependsOn publishedProject.path + ":check"
    }
}


task jacocoRootReport(type: JacocoReport, group: 'Coverage reports') {
    description = 'Generates an aggregate report from all subprojects'

    dependsOn tasks.jacocoMerge

    executionData tasks.jacocoMerge.destinationFile

    reports {
        html.enabled = true // human readable
        xml.enabled = true // required by coveralls
    }

}


coveralls {
    jacocoReportPath = "${buildDir}/reports/jacoco/jacocoRootReport/jacocoRootReport.xml"
}

tasks.coveralls {
    group = 'Coverage reports'
    description = 'Uploads the aggregated coverage report to Coveralls'

    dependsOn jacocoRootReport
}