build.gradle

import org.gradle.api.internal.classpath.ModuleRegistry

import java.util.regex.Pattern

buildscript {
    repositories {
        maven { url "https://plugins.gradle.org/m2/" }
        mavenCentral()
    }
    dependencies { classpath "com.diffplug.spotless:spotless-plugin-gradle:6.25.0" }
}

class VersionString implements Comparable<VersionString> {
    static VersionString parse(String value) {
        def parts = value.split("-", 2)

        def versions = parts[0].split("\\.")

        int major = Integer.parseInt(versions[0])
        int minor = Integer.parseInt(versions[1])
        int patch = versions.length > 2 ? Integer.parseInt(versions[2]) : 0
        String channel = null
        String channelVersion = null

        if (parts.length > 1) {
            def pattern = Pattern.compile("([a-zA-Z]+)(\\d+)");
            def m = pattern.matcher(parts[1])

            if (m.matches()) {
                channel = m.group(1)
                channelVersion = m.group(2)
            }
        }

        return new VersionString(major, minor, patch, channel, channelVersion)
    }

    private final int major
    private final int minor
    private final int patch
    private final String channel
    private final String channelVersion

    VersionString(int major, int minor, int patch, String channel, String channelVersion) {
        this.major = major
        this.minor = minor
        this.patch = patch
        this.channel = channel
        this.channelVersion = channelVersion
    }

    @Override
    int compareTo(VersionString o) {
        return versionInt() <=> o.versionInt()
    }

    int versionInt() {
        def base = 100 * 100 * 100 * major + 100 * 100 * minor + 100 * patch // padding is 1-99

        // 3.0.0 vs 3.0.0-alpha10 -> 3.0.0 is greater
        switch (channel) {
            case "alpha":
                base -= 33
            case "beta":
                base -= 33
            case "rc":
                base -= 34
                base += Integer.parseInt(channelVersion)
                break
        }

        return base
    }

    @Override
    String toString() {
        if (channel) {
            return "${major}.${minor}.${patch}-${channel}${channelVersion}"
        } else {
            return "${major}.${minor}.${patch}"
        }
    }
}

apply plugin: 'groovy'
apply plugin: 'maven-publish'
apply plugin: 'signing'
apply plugin: "com.diffplug.spotless"

group = 'com.deploygate'
version = new File(rootProject.projectDir, 'src/main/resources/VERSION').text.trim()

def archivesBaseName = 'gradle'

repositories {
    google()
    mavenCentral()
    maven { url 'https://jitpack.io' }
}

ext {
    releaseVersion = version
    // Be careful to set androidGradleVersion's default. Bytecode compatibility needs to drop backward compatibility.
    androidGradleVersion = VersionString.parse(System.getenv("TEST_AGP_VERSION") ?: "4.2.0")
    gradleVersion = VersionString.parse(gradle.gradleVersion)

    requireJava11 = VersionString.parse("7.4.0") <= androidGradleVersion
    requireGroovy3 = VersionString.parse("7.0") <= gradleVersion
}

sourceSets {
    unrollAcceptanceTest {
        groovy.srcDirs += ["src/test/unrollAcceptance"]
        resources.srcDirs += test.resources.srcDirs
    }
    pluginAcceptanceTest {
        groovy.srcDirs += ["src/test/acceptance"]
        resources.srcDirs += test.resources.srcDirs
    }
}

configurations {
    unrollAcceptanceTestCompileOnly.extendsFrom testCompileOnly
    unrollAcceptanceTestRuntime.extendsFrom testRuntime
    unrollAcceptanceTestRuntimeOnly.extendsFrom testRuntimeOnly
    unrollAcceptanceTestImplementation.extendsFrom testImplementation
    unrollAcceptanceTestApi.extendsFrom testApi

    pluginAcceptanceTestCompileOnly.extendsFrom testCompileOnly
    pluginAcceptanceTestRuntime.extendsFrom testRuntime
    pluginAcceptanceTestRuntimeOnly.extendsFrom testRuntimeOnly
    pluginAcceptanceTestImplementation.extendsFrom testImplementation
    pluginAcceptanceTestApi.extendsFrom testApi
}

// For testing. The classpaths of this plugin must be specified

task createClasspathManifest {
    def outputDir = file("$buildDir/$name")

    inputs.files sourceSets.main.runtimeClasspath
    outputs.dir outputDir

    doLast {
        outputDir.mkdirs()
        file("$outputDir/plugin-classpath.txt").text = sourceSets.main.runtimeClasspath.join("\n")
    }
}

if (requireJava11) {
    // since this version, android gradle plugin artifact is targeting Java 11 and we are using it in testing dependencies.
    // We need to change target compatibility only for testing.
    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_11
} else {
    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8
}

dependencies {
    compileOnly gradleApi()
    compileOnly localGroovy()
    // Don't enable this on the repository because this artifact may include bytecode incompatibility.
    //    compileOnly "com.android.tools.build:gradle:$androidGradleVersion"
    implementation 'org.jetbrains:annotations:26.0.1'
    implementation 'com.google.guava:guava-annotations:r03'

    implementation 'org.apache.httpcomponents.client5:httpclient5:5.4.1'
    implementation 'com.google.code.gson:gson:2.11.0'
    implementation 'javax.annotation:javax.annotation-api:1.3.2' // for jdk 11 or over

    testImplementation gradleTestKit()
    testImplementation 'junit:junit:4.13.2'

    testImplementation 'org.objenesis:objenesis:3.4'
    implementation 'net.bytebuddy:byte-buddy:1.15.10'

    if (requireGroovy3) {
        testImplementation 'org.spockframework:spock-core:2.3-groovy-3.0'
        testImplementation 'org.spockframework:spock-junit4:2.3-groovy-3.0'
    } else {
        testImplementation 'org.spockframework:spock-core:2.3-groovy-2.5'
        testImplementation 'org.spockframework:spock-junit4:2.3-groovy-2.5'
    }

    // for ApplyPluginSpec
    testRuntimeOnly "com.android.tools.build:gradle:$androidGradleVersion"
    testRuntimeOnly files(createClasspathManifest)

    // We can remove this workaround when upgrading Gradle to 7.5
    // https://github.com/gradle/gradle/issues/16774#issuecomment-853407822
    testRuntimeOnly(files(services.get(ModuleRegistry).getModule("gradle-tooling-api-builders").classpath.asFiles.first()))
}

tasks.create("testUnrollAcceptanceTest", Test) {
    testClassesDirs = sourceSets.unrollAcceptanceTest.output.classesDirs
    classpath = sourceSets.unrollAcceptanceTest.runtimeClasspath
    dependsOn("createClasspathManifest")
}

tasks.create("testPluginAcceptanceTest", Test) {
    testClassesDirs = sourceSets.pluginAcceptanceTest.output.classesDirs
    classpath = sourceSets.pluginAcceptanceTest.runtimeClasspath
    dependsOn("createClasspathManifest")
}

project.tasks.withType(Test).configureEach {
    useJUnitPlatform()

    testLogging {
        events "passed", "skipped", "failed"
        exceptionFormat "full"
    }

    environment([
        "ANDROID_HOME": System.getenv("ANDROID_HOME"),
        "TEST_AGP_VERSION": System.getenv("TEST_AGP_VERSION"),
        "TEST_GRADLE_VERSION": System.getenv("TEST_GRADLE_VERSION"),
        "TEST_SERVER_URL": System.getenv("TEST_SERVER_URL") ?: "http://localhost:3000",
    ])
}

task javadocJar(type: Jar, dependsOn: groovydoc) {
    archiveClassifier.set('javadoc')
    from "${buildDir}/javadoc"
}

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

def getRepositoryUsername() {
    return hasProperty('nexusUsername') ? nexusUsername : ""
}

def getRepositoryPassword() {
    return hasProperty('nexusPassword') ? nexusPassword : ""
}

def isRelease() {
    return rootProject.ext.releaseVersion =~ /^\d+\.\d+\.\d+$/
}

allprojects {
    // spotless requires Java11 so please comment out all spotless configurations if you wanna run on JRE 8
    spotless {
        ratchetFrom 'origin/master'

        encoding 'UTF-8'

        java {
            importOrder()
            removeUnusedImports()
            googleJavaFormat('1.16.0').aosp().reflowLongStrings()
            formatAnnotations()
            indentWithSpaces(4)
        }
        groovy {
            importOrder()
            excludeJava()
            greclipse('4.26')
            indentWithSpaces(4)
        }
        groovyGradle {
            target '*.gradle'
            greclipse('4.26')
            indentWithSpaces(4)
        }
        format 'misc', {
            target '*.md', '.gitignore', '*.properties'

            trimTrailingWhitespace()
            indentWithSpaces(4)
            endWithNewline()
        }

        // TODO detect violations automatically
        // DO: Use org.jetbrains.annotations.{NotNull,Nullable,VisibleForTesting}
        // DON'T: Use javax.annotations.{Nonnull,Nullable}, Guavas VisibleForTesting
    }
}

afterEvaluate {
    publishing {
        repositories {
            maven {
                url = isRelease() ? "https://oss.sonatype.org/service/local/staging/deploy/maven2/" : "https://oss.sonatype.org/content/repositories/snapshots/"

                credentials(PasswordCredentials) {
                    username = getRepositoryUsername()
                    password = getRepositoryPassword()
                }
            }
        }

        publications {
            release(MavenPublication) {
                from components.java
                artifact sourcesJar
                artifact javadocJar
                groupId = project.group
                artifactId = archivesBaseName
                version = project.version
                pom {
                    name = "Gradle DeployGate Plugin"
                    description = "This is the DeployGate plugin for the Gradle. You can build and deploy your apps to DeployGate by running a single task."
                    url = 'https://github.com/DeployGate/gradle-deploygate-plugin'
                    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 = "deploygate"
                            name = "DeployGate"
                        }
                    }
                    scm { url = 'https://github.com/DeployGate/gradle-deploygate-plugin' }
                }
            }
        }

        signing {
            required { (isRelease() || System.getenv("RELEASE_SCRIPT_TEST") == "true") && gradle.taskGraph.hasTask("publishReleasePublicationToMavenRepository") }

            def signingKey = findProperty("signingKey")
            def signingPassword = findProperty("signingPassword")
            useInMemoryPgpKeys(signingKey, signingPassword)
            publishing.publications.configureEach { publication -> sign publication }
        }
    }
}

project.afterEvaluate {
    def process = "git rev-parse HEAD".execute([], rootDir)
    def version_name

    if (process.waitFor() == 0) {
        version_name = process.text.trim()
    } else {
        version_name = "unavailable"
    }

    if (System.getenv("CI") != "true") {
        version_name += "(local)"
    }

    def file = rootProject.file("src/main/resources/VERSION_NAME")

    if (file.exists()) {
        if (file.text.trim() != version_name) {
            file.write(version_name, "UTF-8")
        }
    } else {
        file.write(version_name, "UTF-8")
    }
}