build.gradle

plugins {
    id 'java-library'
    id 'maven-publish'
    id "com.diffplug.spotless" version "5.12.5"
    id 'org.ajoberstar.grgit' version '4.1.0'
}

group = "tech.pegasys.tools.epchecks"
rootProject.version = calculatePublishVersion()
def projectSpecificVersion = calculateVersion()

// used by maven publish
def cloudsmithUser = project.hasProperty('cloudsmithUser') ? project.property('cloudsmithUser') : System.getenv('CLOUDSMITH_USER')
def cloudsmithKey = project.hasProperty('cloudsmithApiKey') ? project.property('cloudsmithApiKey') : System.getenv('CLOUDSMITH_API_KEY')

repositories {
    mavenCentral()
}

dependencies {

    implementation 'com.google.auto.service:auto-service-annotations:1.0'
    annotationProcessor 'com.google.auto.service:auto-service:1.0'
    implementation 'com.google.errorprone:error_prone_check_api:2.7.1'

    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.1'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'

    testImplementation 'com.google.errorprone:error_prone_test_helpers:2.7.1'
    testRuntimeOnly 'info.picocli:picocli:4.6.1'
    testRuntimeOnly 'org.apache.logging.log4j:log4j-api:2.17.1'
    testRuntimeOnly 'it.unimi.dsi:fastutil:8.5.6'
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(11)
    }
    withSourcesJar()
}

spotless {
    java {
        removeUnusedImports()
        googleJavaFormat('1.10.0')
        importOrder 'tech.pegasys', 'java', ''
        trimTrailingWhitespace()
        endWithNewline()
        licenseHeaderFile "${rootDir}/gradle/spotless.java.license"
    }
}

tasks.named('test') {
    // Use junit platform (aka JUnit 5) for unit tests.
    useJUnitPlatform()
    testLogging.showStandardStreams = true
}

publishing {
    publications {
        library(MavenPublication) {
            from components.java
            versionMapping {
                usage('java-api') {
                    fromResolutionOf('runtimeClasspath')
                }
                usage('java-runtime') {
                    fromResolutionResult()
                }
            }
            pom {
                name = 'errorprone-checks'
                description = 'A collection of custom error prone checks'
                url = 'https://github.com/ConsenSys/errorprone-checks'
                licenses {
                    license {
                        name = 'The Apache License, Version 2.0'
                        url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                    }
                }
                scm {
                    connection = 'scm:git:git://github.com/ConsenSys/errorprone-checks.git'
                    developerConnection = 'scm:git:ssh://github.com/ConsenSys/errorprone-checks.git'
                    url = 'https://github.com/ConsenSys/errorprone-checks'
                }
            }
        }
    }
    repositories {
        maven {
            name = "cloudsmith"
            url = "https://api-g.cloudsmith.io/maven/consensys/maven/"
            credentials {
                username = cloudsmithUser
                password = cloudsmithKey
            }
        }
    }
}

// Calculate the version that this build would be published under (if it is published)
// If this exact commit is tagged, use the tag
// If this is on a release-* branch, use the most recent tag appended with +develop (e.g. 0.1.1-RC1+develop)
// Otherwise, use develop
def calculatePublishVersion() {
    if (!grgit) {
        return 'UNKNOWN'
    }
    def specificVersion = calculateVersion()
    def isReleaseBranch = grgit.branch.current().name.startsWith('release-')
    if (specificVersion.contains('+')) {
        return isReleaseBranch ? "${specificVersion.substring(0, specificVersion.indexOf('+'))}+develop" : "develop"
    }
    return specificVersion
}

// Calculate specific version of this project.
// If this exact commit is tagged, use the tag
// Otherwise use git describe --tags and replace the - after the tag with a +
def calculateVersion() {
    if (!grgit) {
        return 'UNKNOWN'
    }
    String version = grgit.describe(tags: true)
    if (version == null) {
        return "UNKNOWN+g${grgit.head().abbreviatedId}"
    }
    def versionPattern = ~/^(?<lastVersion>.*)-(?<devVersion>[0-9]+-g[a-z0-9]+)$/
    def matcher = version =~ versionPattern
    if (matcher.find()) {
        return "${matcher.group("lastVersion")}+${matcher.group("devVersion")}"
    }
    return version
}

task printVersion() {
    doFirst {
        print "Specific version: ${projectSpecificVersion}  Publish version: ${project.version}"
    }
}