build.gradle

/*
 * Copyright (C) 2015-2016 KeepSafe Software
 *
 * 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.
 */

plugins {
    id "groovy"
    id "java-gradle-plugin"

    alias libs.plugins.gradlePluginPublish
    alias libs.plugins.mavenPublish
    alias libs.plugins.thrifty
    alias libs.plugins.versions
}

group = GROUP
version = VERSION_NAME
description = POM_DESCRIPTION

java {
    sourceCompatibility = JavaVersion.VERSION_17
    targetCompatibility = JavaVersion.VERSION_11
}

sourceSets {
    integrationTest
}

configurations {
    // Runtime dependencies provided by consuming Android projects - if you're
    // building an Android project, you've already got these on the build classpath
    // and we can't bundle our own copies.
    androidBuildTool

    // Runtime dependencies that are run only in Gradle Workers
    // and must be restricted to an isolated classpath
    workerImplementation

    testImplementation {
        extendsFrom androidBuildTool
        extendsFrom workerImplementation
    }

    integrationTestImplementation {
        extendsFrom testImplementation
    }

    compileOnly {
        extendsFrom androidBuildTool
        extendsFrom workerImplementation
    }
}

jar {
    manifest {
        attributes(
                "Implementation-Title": POM_ARTIFACT_ID,
                "Implementation-Version": VERSION_NAME)
    }
}

repositories {
    mavenLocal {
        content {
            includeGroup "com.getkeepsafe.dexcount"
        }
    }
    gradlePluginPortal()
    google()
}

dependencies {
    compileOnlyApi libs.autoValue.annotations
    annotationProcessor libs.autoValue.processor

    implementation libs.commons.io

    androidBuildTool libs.androidTools.agp
    androidBuildTool libs.androidTools.r8
    androidBuildTool libs.androidTools.repository

    workerImplementation libs.gson
    workerImplementation libs.javassist
    workerImplementation libs.thriftyRuntime

    testImplementation dependencies.create(libs.spock.get()) {
        exclude module: "groovy-all"
    }
    testImplementation libs.thriftyRuntime
}

thrifty {
    java {}
}

def generateDependencyResource = tasks.register("generateDependencyResource") { t ->
    // This task generates a text file containing versions of our worker-specific
    // dependencies.  At runtime, we'll stuff these into a custom configuration
    // and hand that to Gradle Worker tasks.

    def generatedResourcesDir = project.layout.buildDirectory.dir(["generated", "sources", "dexcount", "src", "main", "resources"].join(File.separator))
    def outputFile = generatedResourcesDir.map { it -> it.file("dependencies.list") }
    def dependencies = configurations.workerImplementation.getDependencies()

    dependencies.forEach { dep ->
        t.inputs.property(dep.name, dep.version)
    }

    t.outputs.dir(generatedResourcesDir)

    t.doFirst {
        File file = outputFile.get().getAsFile()
        file.getParentFile().mkdirs()
        file.delete()

        dependencies
            .collect { "${it.group}:${it.name}:${it.version}" }
            .forEach { file << "$it\n" }
    }
}

sourceSets {
    main {
        resources {
            srcDirs += generateDependencyResource
        }
    }
}

def installForTesting = tasks.register("installForIntegrationTests") { t ->
    t.dependsOn "publishToMavenLocal"
}

def integrationTest = tasks.register("integrationTest", Test) { t ->
    t.dependsOn installForTesting
    t.mustRunAfter tasks.named("test")

    t.outputs.cacheIf { false }
    t.outputs.upToDateWhen { false }

    t.group "verification"
    t.description "Runs integration tests."

    t.testClassesDirs = sourceSets.integrationTest.output.classesDirs
    t.classpath = sourceSets.integrationTest.runtimeClasspath

    // Workaround for https://github.com/gradle/gradle/issues/4506#issuecomment-570815277
    t.systemProperty("org.gradle.testkit.dir", file("build/tmp/.test-kit"))

    t.jvmArgs(
        "-XX:+HeapDumpOnOutOfMemoryError", "-XX:GCTimeLimit=20", "-XX:GCHeapFreeLimit=10",
        "-XX:MaxMetaspaceSize=2g"
    )

    t.beforeTest { testCase ->
        logger.lifecycle("Running test: $testCase")
    }
}

tasks.named("check").configure { t ->
    t.dependsOn integrationTest
}

tasks.register("publishEverywhere") { t ->
    t.group "publishing"
    t.description "Publish to Maven Central and the Gradle Plugin Portal"

    t.dependsOn("publish", "publishPlugins")
}

// Compiler settings

tasks.withType(JavaCompile).configureEach {
    sourceCompatibility = JavaVersion.VERSION_11
    targetCompatibility = JavaVersion.VERSION_11

    // Show all warnings except boot classpath
    configure(options) {
        compilerArgs << "-Xlint:all"            // Turn on all warnings
        compilerArgs << "-Xlint:-options"       // Turn off "missing" bootclasspath warning
        compilerArgs << "-Xlint:-processing"    // Turn off "no processor claimed these annotations" warning
        compilerArgs << "-Werror"               // Turn warnings into errors
        encoding = "utf-8"
        fork = true
    }
}

tasks.withType(GroovyCompile).configureEach {
    sourceCompatibility = JavaVersion.VERSION_11
    targetCompatibility = JavaVersion.VERSION_11

    // Show all warnings except boot classpath
    configure(options) {
        compilerArgs << "-Xlint:all"            // Turn on all warnings
        compilerArgs << "-Xlint:-options"       // Turn off "missing" bootclasspath warning
        compilerArgs << "-Werror"               // Turn warnings into errors
        incremental = true
        encoding = "utf-8"
        fork = true
    }

    configure(groovyOptions) {
        encoding = "utf-8"
        fork = true
    }
}

// Don't fork too much on CI - it tends to run out of metaspace memory.
def isCi = providers.environmentVariable("CI").isPresent()

tasks.withType(Test).configureEach {
    // Turn on logging for all tests, filter to show failures/skips only
    testLogging {
        exceptionFormat "full"
        showCauses true
        showExceptions true
        showStackTraces true
        events "failed", "skipped"
    }

    useJUnitPlatform()

    failFast = true
    maxParallelForks = isCi ? 1 : Runtime.runtime.availableProcessors().intdiv(2) ?: 1
}

tasks.withType(Javadoc).configureEach {
    title = "${project.name} ${project.version}"
    configure(options) {
        source = JavaVersion.VERSION_11
        header = project.name
        encoding "UTF-8"
        docEncoding "UTF-8"
        charSet "UTF-8"
        linkSource true
        author = true
        links "https://docs.oracle.com/en/java/javase/11/docs/api/"
        exclude "**/*Test.java"
        if (JavaVersion.current().java8Compatible) addStringOption("Xdoclint:none", "-quiet")
    }
}

tasks.withType(Groovydoc).configureEach {
    docTitle = "${project.name} ${project.version}"
    header = project.name
    link("http://docs.oracle.com/javase/8/docs/api/",
        "http://docs.oracle.com/javaee/7/api/",
        "http://groovy.codehaus.org/gapi/")
    exclude "**/*Spec.java"
}

signing {
    useGpgCmd()
}

// Plugin Portal publishing

gradlePlugin {
    website = POM_URL
    vcsUrl = POM_SCM_URL

    plugins {
        dexcount {
            id = "com.getkeepsafe.dexcount"
            implementationClass = "com.getkeepsafe.dexcount.DexMethodCountPlugin"
            displayName = POM_NAME
            description = POM_DESCRIPTION
            tags.set(["android", "dex", "method count"])
        }
    }
}

// Convenient entrypoint for the "upload snapshot" CI action.
// It's easier to do the version check here than in a Github action.
def isSnapshot = providers.gradleProperty("VERSION_NAME").map { it.endsWith("-SNAPSHOT") }
tasks.register("uploadSnapshot") {
    if (isSnapshot.get()) {
        dependsOn tasks.named("publish")
    } else {
        doFirst {
            logger.lifecycle("Skipping upload of non-snapshot version '{}'", VERSION_NAME)
        }
    }
}

wrapper {
    gradleVersion = "8.4"
    distributionType = Wrapper.DistributionType.ALL
}