build.gradle

buildscript {
    repositories {
        maven { url "https://repo.grails.org/grails/core" }
        maven { url "https://plugins.gradle.org/m2/" }
    }
    dependencies {
        classpath "org.grails:grails-gradle-plugin:$grailsGradlePluginVersion"
        classpath "org.grails:grails-docs:${project.ext.properties.grailsDocsVersion ?: grailsVersion}"
        classpath "org.grails.plugins:views-gradle:$jsonViewsVersion"
        classpath "io.github.gradle-nexus:publish-plugin:$gradleNexusPublishPluginVersion"
        classpath "org.asciidoctor:asciidoctor-gradle-jvm:$asciidoctorJvmVersion"
    }
}

group = "org.grails"
version project.projectVersion

apply plugin: 'java-library'
apply plugin: 'groovy'

ext {

    isSnapshot = project.projectVersion.endsWith('-SNAPSHOT')
    isReleaseVersion = !isSnapshot
}

ext."signing.keyId" = project.findProperty("signing.keyId") ?: System.getenv('SIGNING_KEY')
ext."signing.secretKeyRingFile" = project.findProperty("signing.secretKeyRingFile") ?: "${System.properties['user.home']}${File.separator}.gnupg${File.separator}secring.gpg"
ext."signing.password" = project.findProperty("signing.password") ?: System.getenv('SIGNING_PASSPHRASE')

allprojects {
    configurations.configureEach {

        // FORCE UPGRADE OF GROOVY IN DEPENDENCIES TO GROOVY 4
        resolutionStrategy.eachDependency { DependencyResolveDetails details ->
            if (details.requested.group == 'org.codehaus.groovy') {
                details.useTarget(group: 'org.apache.groovy', name: details.requested.name, version: groovyVersion)
            }
        }
    }

    repositories {
        maven { url "https://repo.grails.org/grails/core" }
        mavenCentral()
        if (groovyVersion && groovyVersion.endsWith('-SNAPSHOT')) {
            maven {
                name = 'ASF Snapshot repo'
                url = 'https://repository.apache.org/content/repositories/snapshots'
            }
        }
    }
}

subprojects { project ->

    version rootProject.projectVersion

    ext['groovyVersion'] = System.getenv('CI_GROOVY_VERSION') ?: project.groovyVersion

    ext {
        userOrg = "grails"
        isGrailsPlugin = name.startsWith('grails-plugin')
        isBuildSnapshot = version.toString().endsWith("-SNAPSHOT")
    }

    if (isGrailsPlugin) {
        group "org.grails.plugins"
    } else {
        group "org.grails"
    }

    apply plugin: "groovy"
    if (project.name.startsWith("examples")) {
        apply plugin: "org.grails.grails-web"
        apply plugin: "org.grails.plugins.views-json"
    } else {
        apply plugin: "java-library"
        if (isGrailsPlugin) {
            apply plugin: "org.grails.grails-plugin"
        } else {
            repositories {
                maven { url "https://repo.grails.org/grails/core" }
            }

            configurations {
                documentation
            }

            dependencies {
                api "org.apache.groovy:groovy:$groovyVersion"
                api "org.slf4j:slf4j-api:$slf4jVersion"

                testImplementation "org.spockframework:spock-core:${spockVersion}", {
                    exclude module: 'groovy-all'
                }
                testRuntimeOnly "net.bytebuddy:byte-buddy:$bytebuddyVersion"
                testRuntimeOnly "org.objenesis:objenesis:$objenesisVersion"

                documentation "org.fusesource.jansi:jansi:$jansiVersion"

            }

            test {
                testLogging {
                    events "passed", "skipped", "failed", "standardOut", "standardError"
                }
            }

            groovydoc.classpath += (configurations.documentation + configurations.compileClasspath)
        }
    }

    java {
        toolchain {
            languageVersion = JavaLanguageVersion.of(17)
        }
    }

    dependencies {
        implementation "com.github.javaparser:javaparser-core:$javaParserVersion"
        compileOnly "jakarta.servlet:jakarta.servlet-api:$servletApiVersion"

        testImplementation "jakarta.servlet:jakarta.servlet-api:$servletApiVersion"
        testImplementation "org.apache.groovy:groovy-test-junit5:$groovyVersion"
        testImplementation "org.junit.jupiter:junit-jupiter-api:$junitJupiterVersion"
        testImplementation "org.junit.platform:junit-platform-runner:$junitPlatformVersion"
        testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:$junitJupiterVersion"
    }

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

subprojects { subproject ->
    ext {
        isExample = subproject.name.startsWith('example')
        isGrailsPlugin = subproject.name.startsWith('grails-plugin')
        pomInfo = {
            delegate.name subproject.title
            delegate.description subproject.projectDesc
            delegate.url projectUrl

            delegate.licenses {
                delegate.license {
                    delegate.name 'The Apache Software License, Version 2.0'
                    delegate.url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                    delegate.distribution 'repo'
                }
            }

            delegate.scm {
                delegate.url "scm:git@github.com:${githubSlug}.git"
                delegate.connection "scm:git@github.com:${githubSlug}.git"
                delegate.developerConnection "scm:git@github.com:${githubSlug}.git"
            }

            if (developers) {
                delegate.developers {
                    for (dev in developers.split(',')) {
                        delegate.developer {
                            delegate.id dev.toLowerCase().replace(' ', '')
                            delegate.name dev
                        }
                    }
                }
            }
        }
    }

    if (!isExample) {

        apply plugin: 'maven-publish'
        apply plugin: 'signing'

        Task sourcesJar = subproject.tasks.findByName("sourcesJar")
        if (!sourcesJar) {
            sourcesJar = tasks.create("sourcesJar", Jar) {
                archiveClassifier = 'sources'
                group = BasePlugin.BUILD_GROUP
                description = 'Assembles a jar archive containing the main sources of this project.'
                from subproject.sourceSets.main.allSource
            }
        }

        Task javadocJar = subproject.tasks.findByName("javadocJar")
        if (!javadocJar) {
            javadocJar = tasks.create("javadocJar", Jar) {
                archiveClassifier = 'javadoc'
                group = BasePlugin.BUILD_GROUP
                description = 'Assembles a jar archive containing the generated Javadoc API documentation of this project.'
                from subproject.plugins.hasPlugin(GroovyPlugin) ? subproject.tasks.getByName(GroovyPlugin.GROOVYDOC_TASK_NAME) : subproject.tasks.getByName(JavaPlugin.JAVADOC_TASK_NAME)
            }
        }
        tasks.findByName("assemble").finalizedBy(sourcesJar, javadocJar)

        publishing {
            if (isSnapshot) {
                repositories {
                    maven {
                        credentials {
                            def u = System.getenv("ARTIFACTORY_USERNAME") ?: project.findProperty("artifactoryPublishUsername") ?: ''
                            def p = System.getenv("ARTIFACTORY_PASSWORD") ?: project.findProperty("artifactoryPublishPassword") ?: ''
                            username = u
                            password = p
                        }
                        if (isGrailsPlugin) {
                            url "https://repo.grails.org/grails/plugins3-snapshots-local"
                        } else {
                            url "https://repo.grails.org/grails/libs-snapshots-local"
                        }
                    }
                }
            }

            publications {
                maven(MavenPublication) {
                    if (isGrailsPlugin) {
                        artifactId(subproject.name - 'grails-plugin-')
                    } else if (subproject.name.contains('/')) {
                        artifactId(subproject.name.substring(subproject.name.indexOf('/') + 1))
                    }

                    from components.java

                    artifact sourcesJar
                    artifact javadocJar

                    if (isGrailsPlugin) {
                        artifact source: "${subproject.buildDir}/classes/groovy/main/META-INF/grails-plugin.xml",
                                classifier: "plugin",
                                extension: 'xml'
                    }
                    pom.withXml {
                        def xml = asNode()

                        xml.children().last() + pomInfo
                        // dependency management shouldn't be included
                        def n = xml.get("dependencyManagement")
                        if (n) xml.remove(n)
                    }

                }
            }
        }

        subproject.afterEvaluate {
            signing {
                required { isReleaseVersion }
                sign publishing.publications.maven
            }
        }

        tasks.withType(Sign) {
            onlyIf { isReleaseVersion }
        }

        //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))
        }
    }
    apply plugin: "org.asciidoctor.jvm.convert"

    configurations {
        documentation.extendsFrom compileClasspath
    }

    dependencies {
        if (configurations.find { it.name == 'documentation' }) {
            documentation "org.fusesource.jansi:jansi:$jansiVersion"
            documentation "jline:jline:$jlineVersion"
            documentation "com.github.javaparser:javaparser-core:$javaParserVersion"
            documentation "org.apache.groovy:groovy:${groovyVersion}"
            documentation "org.apache.groovy:groovy-templates:${groovyVersion}"
            documentation "org.apache.groovy:groovy-ant:$groovyVersion"
            documentation "org.apache.groovy:groovy-dateutil:$groovyVersion"
            documentation "org.apache.groovy:groovy-cli-picocli:$groovyVersion"
        }
    }

    groovydoc.classpath += configurations.documentation
}

if (isReleaseVersion) {
    apply plugin: 'maven-publish'
    apply plugin: "io.github.gradle-nexus.publish-plugin"

    nexusPublishing {
        repositories {
            sonatype {
                def ossUser = System.getenv("SONATYPE_USERNAME") ?: project.findProperty("sonatypeOssUsername") ?: ''
                def ossPass = System.getenv("SONATYPE_PASSWORD") ?: project.findProperty("sonatypeOssPassword") ?: ''
                def ossStagingProfileId = System.getenv("SONATYPE_STAGING_PROFILE_ID") ?: project.findProperty("sonatypeOssStagingProfileId") ?: ''
                nexusUrl = uri("https://s01.oss.sonatype.org/service/local/")
                username = ossUser
                password = ossPass
                stagingProfileId = ossStagingProfileId
            }
        }
        transitionCheckOptions {
            maxRetries.set(40)
            delayBetween.set(java.time.Duration.ofMillis(2000))
        }
    }
}

def DOCUMENTATION_GROUP = 'Documentation'

def commonGithubOrg = 'grails'
def commonGithubSlug = 'grails-common-build'
def commonBranch = 'master'
def docResourcesDir = "${buildDir}/resources/${commonGithubSlug}-${commonBranch}/src/main/resources"

task prepareDocResources {
    group = DOCUMENTATION_GROUP
    description = 'Downloads common documentation resoruces and unzips them to build folder'
    doLast {
        ant.mkdir(dir: buildDir)
        ant.get(src: "https://github.com/${commonGithubOrg}/${commonGithubSlug}/archive/${commonBranch}.zip", dest: "${buildDir}/resources.zip")
        ant.unzip(src: "${buildDir}/resources.zip", dest: "${buildDir}/resources")
    }
}

task copyLocalDocResources(type: Copy, dependsOn: prepareDocResources) {
    group = DOCUMENTATION_GROUP
    description = 'Copy local resources to build folder'
    mustRunAfter prepareDocResources
    from('src/main/docs/resources')
    into docResourcesDir
}

configurations {
    documentation
}

dependencies {
    if (configurations.find { it.name == 'documentation' }) {
        documentation "info.picocli:picocli:$picocliVersion"
        documentation "org.fusesource.jansi:jansi:$jansiVersion"
        documentation "jline:jline:$jlineVersion"
        documentation "com.github.javaparser:javaparser-core:$javaParserVersion"
        documentation "org.apache.groovy:groovy:$groovyVersion"
        documentation "org.apache.groovy:groovy-templates:$groovyVersion"
        documentation "org.apache.groovy:groovy-ant:$groovyVersion"
        documentation "org.apache.groovy:groovy-cli-picocli:$groovyVersion"
    }
}

def cleanTask = project.tasks.findByName("clean")
if (cleanTask == null) {
    task clean(type: Delete) {
        delete(buildDir)
    }
} else {
    cleanTask.doLast {
        ant.delete(dir: "build/docs")
    }
}

tasks.withType(Groovydoc) {
    group = DOCUMENTATION_GROUP
    docTitle = "${project.title} - ${project.version}"
    destinationDir = project.file("build/docs/api")
    def files = []
    project.rootProject.subprojects
            .findAll { it.name != 'docs' && !it.name.startsWith('examples') }
            .each { subproject ->
                if (subproject.file('src/main/groovy').exists()) {
                    files += subproject.files("src/main/groovy")
                }
            }
    if (project.file('src/main/groovy').exists()) {
        files += project.files("src/main/groovy")
    }
    source = files
    classpath += configurations.documentation
}

tasks.withType(org.gradle.api.tasks.javadoc.Groovydoc) {
    configure {
        access = GroovydocAccess.PRIVATE
        processScripts = false
        includeMainForScripts = false
        includeAuthor = true
        groovyClasspath = configurations.documentation
    }
}

task publishGuide(type: grails.doc.gradle.PublishGuide) {
    group = DOCUMENTATION_GROUP
    description = 'Generate Guide'
    dependsOn copyLocalDocResources, compileGroovy, compileJava, groovydoc, processResources

    targetDir = project.file("${buildDir}/docs")
    sourceRepo = "https://github.com/${githubSlug}/edit/${githubBranch}/src/main/docs"
    sourceDir = new File(projectDir, "src/main/docs")
    propertiesFiles = [new File(rootProject.projectDir, "gradle.properties")]
    asciidoc = true
    resourcesDir = project.file(docResourcesDir)
    properties = ['safe'     : 'UNSAFE',
                  'version'  : project.version,
                  'subtitle' : project.projectDesc,
                  'api'      : '../api',
                  'sourceDir': rootProject.projectDir.absolutePath,
                  'sourcedir': rootProject.projectDir.absolutePath,
                  'javaee'   : 'https://docs.oracle.com/javaee/7/api/',
                  'jakartaee': 'https://jakarta.ee/specifications/platform/10/apidocs/',
                  'javase'   : 'https://docs.oracle.com/en/java/javase/17/docs/api/index.html',
                  'groovyapi': 'http://docs.groovy-lang.org/latest/html/gapi/',
                  'grailsapi': 'http://docs.grails.org/latest/api/',
                  'gormapi'  : 'http://gorm.grails.org/latest/api/',
                  'springapi': 'https://docs.spring.io/spring/docs/current/javadoc-api/']
    doLast {
        ant.move(file: "${project.buildDir}/docs/guide/single.html",
                tofile: "${project.buildDir}/docs/guide/index.html", overwrite: true)
        new File(project.buildDir, "docs/index.html").text = '''
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html lang="en">
<head>
<meta http-equiv="refresh" content="0; url=guide/index.html" />
</head>

</body>
</html>
'''
    }
}

task docs(dependsOn: [groovydoc, publishGuide]) {
    group = DOCUMENTATION_GROUP
}

def assembleTask = project.tasks.findByName("assemble")
if (assembleTask == null) {
    task assemble(dependsOn: docs, type: Zip) {
        archiveFileName = "${project.name}-${project.version}.zip"
        destinationDirectory = new File(project.buildDir, "distributions")
        from project.files("${buildDir}/docs")
    }
}