build.gradle

import io.micronaut.internal.VersionsWriterTask

plugins {
    id 'groovy-gradle-plugin'
    id 'groovy'
    id 'maven-publish'
    id("io.github.gradle-nexus.publish-plugin") version "2.0.0"
    id 'signing'
}

version project.projectVersion
group "io.micronaut.build.internal"

repositories {
    mavenCentral()
    gradlePluginPortal()
}

sourceSets {
    functionalTest {
    }
}

gradlePlugin.testSourceSets(sourceSets.functionalTest)
configurations {
    functionalTestImplementation {
        extendsFrom(testImplementation)
    }
    functionalTestRuntimeClasspath {
        resolutionStrategy {
            exclude group: 'org.codehaus.groovy'
        }
    }
}

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

tasks.register('functionalTest', Test) {
    inputs.dir(file("src/functionalTest/gradle-projects"))
    testClassesDirs = sourceSets.functionalTest.output.classesDirs
    classpath = sourceSets.functionalTest.runtimeClasspath
    systemProperty "CURRENT_JDK", JavaVersion.current().majorVersion
    environment("GH_USERNAME", System.getenv("GH_USERNAME"))
    environment("GH_TOKEN_PUBLIC_REPOS_READONLY", System.getenv("GH_TOKEN_PUBLIC_REPOS_READONLY"))
    if (System.getenv("CI") != null) {
        environment("CI", System.getenv("CI"))
    }
}

tasks.named('check') {
    dependsOn(tasks.functionalTest)
}

dependencies {
    implementation libs.commons.lang3
    implementation libs.snakeyaml
    implementation libs.grails.gdoc
    implementation libs.asciidoctorj
    implementation libs.spotless.plugin
    implementation libs.testlogger.plugin
    implementation libs.nexus.publish.plugin
    implementation libs.sonar.plugin

    implementation libs.develocity.plugin
    implementation libs.gradle.github.actions.plugin
    implementation libs.gradle.custom.userdata.plugin
    implementation libs.japicmp.plugin

    implementation libs.tomlj

    testImplementation platform(libs.spock.bom)
    testImplementation(libs.spock.core)

    testImplementation(libs.typesafe.config)

    testImplementation(libs.mockserver.netty)
    testImplementation(libs.mockserver.client)

}

configurations.all {
    resolutionStrategy {
        componentSelection {
            withModule("xerces:xercesImpl") { ComponentSelection selection ->
                selection.reject("No xerces")
            }
        }

        eachDependency { details ->
            if (details.requested.group == 'org.codehaus.groovy') {
                details.useVersion groovyVersion
                details.because 'Groovy 2.5.x not supported by Gradle 7.0+'
            }
        }
    }
}

tasks.register('docFilesJar', Jar) {
    description = 'Package up files used for generating documentation.'
    archiveVersion = null
    archiveFileName = "grails-doc-files.jar"
    from "src/main/template"
}

tasks.named('jar', Jar) {
    from docFilesJar
}

def generateVersions = tasks.register("generateVersions", VersionsWriterTask) {
    versions.put("bytebuddy", libs.versions.bytebuddy)
    versions.put("objenesis", libs.versions.objenesis)
    className = "io.micronaut.build.utils.DefaultVersions"
    outputDirectory = layout.buildDirectory.dir("generated/versions")
}

sourceSets.main.java.srcDir(generateVersions)

gradlePlugin {
    // Define the plugins
    plugins {
        base {
            id = 'io.micronaut.build.internal.base'
            implementationClass = 'io.micronaut.build.MicronautBasePlugin'
        }
        common {
            id = 'io.micronaut.build.internal.common'
            implementationClass = 'io.micronaut.build.MicronautBuildCommonPlugin'
        }
        'base-module' {
            id = 'io.micronaut.build.internal.base-module'
            implementationClass = 'io.micronaut.build.MicronautBaseModulePlugin'
        }
        module {
            id = 'io.micronaut.build.internal.module'
            implementationClass = 'io.micronaut.build.MicronautModulePlugin'
        }
        bom {
            id = 'io.micronaut.build.internal.bom'
            implementationClass = 'io.micronaut.build.MicronautBomPlugin'
        }
        publishing {
            id = 'io.micronaut.build.internal.publishing'
            implementationClass = 'io.micronaut.build.MicronautPublishingPlugin'
        }
        dependencyUpdates {
            id = 'io.micronaut.build.internal.dependency-updates'
            implementationClass = 'io.micronaut.build.MicronautDependencyUpdatesPlugin'
        }
        versionCatalogUpdates {
            id = 'io.micronaut.build.internal.version-catalog-updates'
            implementationClass = 'io.micronaut.build.catalogs.MicronautVersionCatalogUpdatePlugin'
        }
        docs {
            id = 'io.micronaut.build.internal.docs'
            implementationClass = 'io.micronaut.build.MicronautDocsPlugin'
        }
        gradleEnterprise {
            id = 'io.micronaut.build.internal.gradle-enterprise'
            implementationClass = 'io.micronaut.build.MicronautGradleEnterprisePlugin'
        }
        develocity {
            id = 'io.micronaut.build.internal.develocity'
            implementationClass = 'io.micronaut.build.MicronautDevelocityPlugin'
        }
        sharedSettings {
            id = 'io.micronaut.build.shared.settings'
            implementationClass = 'io.micronaut.build.MicronautSharedSettingsPlugin'
        }
        aotModule {
            id = 'io.micronaut.build.internal.aot-module'
            implementationClass = 'io.micronaut.build.aot.MicronautAotModulePlugin'
        }
        qualityReporting {
            id = 'io.micronaut.build.internal.quality-reporting'
            implementationClass = 'io.micronaut.build.MicronautQualityReportingAggregatorPlugin'
        }
        qualityChecks {
            id = 'io.micronaut.build.internal.quality-checks'
            implementationClass = 'io.micronaut.build.MicronautQualityChecksParticipantPlugin'
        }
        binaryCompatibilityCheck {
            id = 'io.micronaut.build.internal.binary-compatibility-check'
            implementationClass = 'io.micronaut.build.compat.MicronautBinaryCompatibilityPlugin'
        }
    }
}

java {
    withJavadocJar()
    withSourcesJar()
    sourceCompatibility = 17
    targetCompatibility = 17
}

def ossUser = System.getenv("SONATYPE_USERNAME") ?: project.hasProperty("sonatypeOssUsername") ? project.sonatypeOssUsername : ''
def ossPass = System.getenv("SONATYPE_PASSWORD") ?: project.hasProperty("sonatypeOssPassword") ? project.sonatypeOssPassword : ''
ext."signing.keyId" = System.getenv("GPG_KEY_ID") ?: project.hasProperty("signing.keyId") ? project.getProperty('signing.keyId') : null
ext."signing.password" = System.getenv("GPG_PASSWORD") ?: project.hasProperty("signing.password") ? project.getProperty('signing.password') : null
if (file("${rootDir}/secring.gpg").exists()) {
    ext."signing.secretKeyRingFile" = file("${rootDir}/secring.gpg").absolutePath
} else if (file("${System.getenv('HOME')}/.gnupg/secring.gpg").exists()){
    ext."signing.secretKeyRingFile" = file("${System.getenv('HOME')}/.gnupg/secring.gpg").absolutePath
}

nexusPublishing {
    repositories {
        sonatype {
            username = ossUser
            password = ossPass
            nexusUrl = uri("https://s01.oss.sonatype.org/service/local/")
            snapshotRepositoryUrl = uri("https://s01.oss.sonatype.org/content/repositories/snapshots/")
            stagingProfileId = "11bd7bc41716aa" //can reduce execution time by even 10 seconds
        }
    }
}

Closure pomInfo = {
    name = 'Micronaut internal build plugins'
    description = "Micronaut internal build plugins. Not intended to be used in user's projects"
    url = 'https://github.com/micronaut-projects/micronaut-build'
    inceptionYear = '2020'
    licenses {
        license {
            name = 'The Apache License, Version 2.0'
            url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
        }
    }
    developers {
        developer {
            id = 'alvarosanchez'
            name = 'Álvaro Sánchez-Mariscal Arnaiz'
        }
    }
    scm {
        connection = 'scm:https://github.com/micronaut-projects/micronaut-build.git'
        developerConnection = 'scm:git@github.com:micronaut-projects/micronaut-build.git'
        url = 'https://github.com/micronaut-projects/micronaut-build'
    }
}

publishing {
    publications {
        maven(MavenPublication) {
            groupId = project.group
            artifactId = 'micronaut-gradle-plugins'
            version = project.version

            from components.java
            pom pomInfo
        }
    }
}

afterEvaluate {
    signing {
        required { !project.version.endsWith("-SNAPSHOT") && !project.hasProperty("skipSigning") }
        publishing.publications.each {
            sign it
        }
    }

    publishing.publications.withType(MavenPublication) { MavenPublication pub ->
        pub.pom pomInfo
    }

    tasks.withType(Sign).configureEach {
        onlyIf { !project.version.endsWith("-SNAPSHOT") }
    }

    tasks.withType(PublishToMavenRepository).configureEach {
        mustRunAfter(tasks.withType(Sign))
    }
}

//do not generate extra load on Nexus with new staging repository if signing fails
tasks.withType(io.github.gradlenexus.publishplugin.InitializeNexusStagingRepository).configureEach {
    shouldRunAfter(tasks.withType(Sign))
}