build.gradle

/*
 * Copyright 2018 NEM
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'com.netflix.nebula:gradle-aggregate-javadocs-plugin:3.0.1'
    }
}

plugins {
    id "org.sonarqube" version "2.7"
    id 'com.github.kt3k.coveralls' version '2.8.4'
    id 'ch.netzwerg.release' version '1.2.5'
    id 'org.ajoberstar.git-publish' version '3.0.0-rc.1'
    id "de.marcphilipp.nexus-publish" version "0.4.0"
    id 'io.codearte.nexus-staging' version '0.21.1'
    id "com.diffplug.spotless" version "5.4.0"
    id 'jacoco'
    id 'signing'
    id 'java-library'
    id 'java'
}

apply plugin: 'nebula-aggregate-javadocs'



ext {
    vertxVersion = "3.5.0"
    rxjavaVersion = "2.1.7"
    junitVersion = "5.9.0"
    catbufferVersion = "0.1.5"
    restApiVersion = "1.0.3"
    jackson_version = "2.9.9"
    jackson_databind_version = "2.9.9"
}
def encoding = "UTF-8"

repositories {
    mavenLocal()
    mavenCentral()
}

def getPropertyValue(key, defaultValue = null) {
    def value = project.hasProperty(key) ? project[key] : System.getenv(key)
    return value == null || value.trim() == '' ? defaultValue : value
}

def ossrhUsername = getPropertyValue('ossrhUsername');
def ossrhPassword = getPropertyValue('ossrhPassword');

def sonarProjectKey = getPropertyValue('sonarProjectKey');
def sonarLogin = getPropertyValue('sonarLogin');
def sonarOrganization = getPropertyValue('sonarOrganization');
def sonarHostUrl = getPropertyValue('sonarHostUrl');
def sonarBranchName = getPropertyValue('sonarBranchName');

def signingSecretKeyRingFile = getPropertyValue('signingSecretKeyRingFile')
def signingKeyId = getPropertyValue('signingKeyId')
def signingPassword = getPropertyValue('signingPassword')

def githubToken = getPropertyValue('GITHUB_TOKEN')
def repoPath = getPropertyValue('TRAVIS_REPO_SLUG', "nemtech/symbol-sdk-java")

def artifactVersion =  getPropertyValue('VERSION', rootProject.file('version.txt').text.trim() + '-SNAPSHOT')
def isReleaseVersion = !artifactVersion.contains("SNAPSHOT")

System.out.println("Current Version: " + artifactVersion)

allprojects {
    ext."signing.keyId" = signingKeyId
    ext."signing.secretKeyRingFile" = signingSecretKeyRingFile
    ext."signing.password" = signingPassword

}

subprojects {
    apply plugin: 'java'
    apply plugin: 'maven'
    apply plugin: 'jacoco'
    apply plugin: 'signing'
    apply plugin: 'org.sonarqube'
    apply plugin: 'de.marcphilipp.nexus-publish'
    apply plugin: 'project-report'
    apply plugin: 'com.diffplug.spotless'

    group 'io.nem'

    spotless {
        java {
            importOrder()
            removeUnusedImports()
            googleJavaFormat('1.7')
            licenseHeaderFile '../LICENSE_HEADER'
        }
    }

    java {
        sourceCompatibility = JavaVersion.VERSION_1_8
        targetCompatibility = JavaVersion.VERSION_1_8
    }

    version = artifactVersion

    compileJava.options.encoding = encoding
    compileTestJava.options.encoding = encoding
    javadoc.options.encoding = encoding

    signing {
        required { signingKeyId }
        sign publishing.publications
    }

    task checkForSnapshotDependencies {
        onlyIf { isReleaseVersion }
        doLast {
            allprojects { project ->
                project.configurations.runtime.each {
                    if (it.toString().contains("-SNAPSHOT"))
                        throw new Exception("Release build contains snapshot dependencies: " + it)
                }
            }
        }
    }
    jar.dependsOn checkForSnapshotDependencies

    repositories {
        mavenLocal()
        mavenCentral()
        maven {
            url 'https://oss.sonatype.org/content/repositories/snapshots'
        }
    }

    javadoc {
        // options.addBooleanOption('html5', true)
        failOnError = true
        source = sourceSets.main.allJava
        classpath = configurations.compile
    }

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

    task javadocJar(type: Jar) {
        classifier = 'javadoc'
        from javadoc
    }

    artifacts {
        archives javadocJar, sourcesJar
    }

    test {
        exclude '**/**IntegrationTest.class'
        useJUnitPlatform {
            includeEngines 'junit-jupiter'
        }
        testLogging {
            events "skipped", "failed"
        }
    }

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

    dependencies {
        // Tests
        testCompile 'org.hamcrest:hamcrest-core:1.3'
        testCompile 'org.hamcrest:hamcrest-library:1.3'
        testCompile 'org.mockito:mockito-all:1.9.5'

        testImplementation(platform("org.junit:junit-bom:$junitVersion"))
        testImplementation("org.junit.jupiter:junit-jupiter:$junitVersion")
    }


    if (project.name != "integration-tests") {
        publishing {
            publications {
                mavenJava(MavenPublication) {
                    from components.java
                    artifact sourcesJar
                    artifact javadocJar
                    pom {
                        packaging = 'jar'
                        url = "https://github.com/${repoPath}"
                        name = "${project.name}"
                        description = "${project.name} lib for Sybol SDK Java"

                        scm {
                            connection = "scm:git:https://github.com/${repoPath}.git"
                            developerConnection = "scm:svn:https://github.com/${repoPath}"
                            url = "https://github.com/${repoPath}"
                        }

                        licenses {
                            license {
                                name = 'The Apache License, Version 2.0'
                                url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                            }
                        }
                        developers {
                            developer {
                                id = 'fullcircle23'
                                name = 'Ravi Shanker'
                            }
                            developer {
                                id = 'rg911'
                                name = 'Steven Liu'
                            }
                            developer {
                                id = 'fboucquez'
                                name = 'Fernando Boucquez'
                            }
                        }
                    }
                }
            }
        }
    }

    nexusPublishing {
        repositories {
            sonatype {
                username = ossrhUsername
                password = ossrhPassword
            }
        }
        connectTimeout = Duration.ofSeconds(360)
        clientTimeout = Duration.ofSeconds(360)
    }
}


def publishedProjects = subprojects

task jacocoMerge(type: JacocoMerge) {
    publishedProjects.each { subproject ->
        executionData subproject.tasks.withType(Test)
    }
    doFirst {
        executionData = files(executionData.findAll { it.exists() })
    }
}


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

    additionalSourceDirs.from = files(publishedProjects.sourceSets.main.allSource.srcDirs)
    sourceDirectories.from = files(publishedProjects.sourceSets.main.allSource.srcDirs)
    classDirectories.from = files(publishedProjects.sourceSets.main.output)
    executionData jacocoMerge.destinationFile

    reports {
        html.enabled = true // human readable
        xml.enabled = true // required by coveralls
    }
    afterEvaluate {
        classDirectories.from = files(classDirectories.files.collect {
            fileTree(dir: it)
        })
    }
}

coveralls {
    sourceDirs = publishedProjects.sourceSets.main.allSource.srcDirs.flatten()
    jacocoReportPath = "${buildDir}/reports/jacoco/jacocoRootReport/jacocoRootReport.xml"
}

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


gitPublish {
    if (githubToken) {
        repoUri = "https://github.com/${repoPath}.git".toString()
    } else {
        repoUri = "git@github.com:${repoPath}.git".toString()
    }
    branch = 'gh-pages'
    preserve { include '**/*' }
    commitMessage = "Publishing SDK Javadocs for version ${artifactVersion}".toString()
    contents {
        from(file("$buildDir/docs/javadoc")) {
            into "javadoc/${artifactVersion}".toString()
        }
    }
}

gitPublishPush.dependsOn("aggregateJavadocs")


def gitBranch() {
    def branch = ""
    def proc = "git rev-parse --abbrev-ref HEAD".execute()
    proc.in.eachLine { line -> branch = line }
    proc.err.eachLine { line -> println line }
    proc.waitFor()
    branch
}

release {
    push = false
}

nexusStaging {
    packageGroup = "io.nem"
    stagingProfileId = "365f7aa90b3b13"
    username = ossrhUsername
    password = ossrhPassword
    numberOfRetries = 40
    delayBetweenRetriesInMillis = 10000
}


release.dependsOn subprojects.install

sonarqube {
    properties {
        //       property "sonar.branch.name", sonarBranchName == null ? gitBranch() : sonarBranchName
        property "sonar.projectKey", sonarProjectKey
        property "sonar.projectName", sonarProjectKey
        property "sonar.organization", sonarOrganization
        property "sonar.login", sonarLogin
        property "sonar.host.url", sonarHostUrl
    }
}