build.gradle

buildscript {
    repositories {
        maven { url "https://plugins.gradle.org/m2/" }
        maven { url "https://repo.grails.org/grails/core" }
    }
    dependencies {
        classpath "commons-io:commons-io:$commonsIOVersion"
        classpath "io.github.gradle-nexus:publish-plugin:$gradleNexusPublishPluginVersion"
        classpath "com.netflix.nebula:gradle-extra-configurations-plugin:$gradleExtraConfigurationsPluginVersion"
        classpath "com.bmuschko:gradle-nexus-plugin:$gradleNexusPluginVersion"
        classpath "jakarta.xml.bind:jakarta.xml.bind-api:$jakartaXmlBindVersion"
        classpath "gradle.plugin.com.hierynomus.gradle.plugins:license-gradle-plugin:$gradleLicensePluginVersion"
    }
}

apply plugin: 'idea'

ext {
    isJava8Compatible = org.gradle.api.JavaVersion.current().isJava8Compatible()
    grailsVersion = project.projectVersion
    isBuildSnapshot = grailsVersion.endsWith("-SNAPSHOT")
    isReleaseVersion = !isBuildSnapshot
    isCiBuild = System.getenv().get("CI") as Boolean
    springLoadedCommonOptions = "-Xverify:none -Dspringloaded.synchronize=true -Djdk.reflect.allowGetCallerClass=true"

    // When making changes in the dependencyVersions, remember to also update the Grails BOM Documentation:
    // https://docs.grails.org/snapshot/ref/Dependency%20Versions/Grails%20BOM.html
    dependencyVersions = [
            'fieldsPlugin'           : [version: fieldsPluginVersion,
                                        group  : 'org.grails.plugins',
                                        names  : ['fields'],
                                        modules: ['']
            ],
            'jakarta-annotation'     : [version: jakartaAnnotationApiVersion,
                                        group  : 'jakarta.annotation',
                                        names  : ['jakarta.annotation-api'],
                                        modules: ['']
            ],
            'mongodb'                : [version: mongodbJavaDriverVersion,
                                        group  : 'org.mongodb',
                                        names  : ['mongodb-driver'],
                                        modules: ['core', 'sync']
            ],
            'mongodb.bson'           : [version: mongodbJavaDriverVersion,
                                        group  : 'org.mongodb',
                                        names  : ['bson'],
                                        modules: ['', 'record-codec']
            ],
            'gorm'                   : [version: datastoreVersion,
                                        group  : 'org.grails',
                                        names  : ['grails-datastore'],
                                        modules: ['async', 'core', 'web', 'gorm', 'gorm-async', 'gorm-support', 'gorm-rx', 'gorm-test', 'gorm-validation']
            ],
            'gorm.hibernate'         : [version: hibernateDatastoreVersion,
                                        group  : 'org.grails',
                                        names  : ['grails-datastore-gorm-hibernate5'],
                                        modules: ['']
            ],
            'groovy'                 : [version: groovyVersion,
                                        group  : 'org.apache.groovy',
                                        names  : ['groovy'],
                                        modules: ['', 'xml', 'swing', 'console', 'json', 'ant', 'sql', 'templates', 'nio', 'dateutil', 'macro']
            ],
            'spring'                 : [version: springVersion,
                                        group  : 'org.springframework',
                                        names  : ['spring'],
                                        modules: ['aop', 'aspects', 'beans', 'context-support', 'context', 'core', 'expression', 'instrument', 'jdbc', 'jms', 'messaging', 'orm', 'oxm', 'test', 'tx', 'web', 'webmvc', 'websocket']
            ],
            'directoryWatcher'       : [version: directoryWatcherVersion,
                                        group  : 'io.methvin',
                                        names  : ['directory-watcher'],
                                        modules: ['']
            ],
            'springLoaded'           : [version: springLoadedVersion,
                                        group  : 'org.springframework',
                                        names  : ['springloaded'],
                                        modules: ['']
            ],
            'async'                  : [version: asyncVersion,
                                        group  : 'org.grails.plugins',
                                        names  : ['async', 'events'],
                                        modules: ['']
            ],
            'asyncImpls'             : [version: asyncVersion,
                                        group  : 'org.grails',
                                        names  : ['grails-async', 'grails-events'],
                                        modules: ['gpars', 'rxjava', 'rxjava2']
            ],
            'snakeyaml'              : [version: snakeyamlVersion,
                                        group  : 'org.yaml',
                                        names  : ['snakeyaml'],
                                        modules: ['']
            ],
            'spock'                  : [version: spockVersion,
                                        group  : 'org.spockframework',
                                        names  : ['spock-core', 'spock-spring'],
                                        modules: ['']
            ],
            'gsp'                    : [version: gspVersion,
                                        group  : 'org.grails.plugins',
                                        names  : ['gsp'],
                                        modules: ['']
            ],
            'testingSupport'         : [version: testingSupportVersion,
                                        group  : 'org.grails',
                                        names  : ['grails-testing-support', 'grails-gorm-testing-support', 'grails-web-testing-support'],
                                        modules: ['']
            ],
            'viewsJsonTestingSupport': [version: viewsVersion,
                                        group  : 'org.grails',
                                        names  : ['views-json-testing-support'],
                                        modules: ['']
            ],
            'h2'                     : [version: h2Version,
                                        group  : 'com.h2database',
                                        names  : ['h2'],
                                        modules: ['']
            ],
    ]

    nexusUsername = System.getenv("SONATYPE_USERNAME") ?: project.hasProperty("sonatypeOssUsername") ? project.sonatypeOssUsername : ''
    nexusPassword = System.getenv("SONATYPE_PASSWORD") ?: project.hasProperty("sonatypeOssPassword") ? project.sonatypeOssPassword : ''


}

version = grailsVersion
group = "org.grails"

// directories created during the build which are related
// to turning the workspace root into a GRAILS_HOME
ext {
    distInstallDir = layout.buildDirectory.dir("dist-tmp").get()
    homeDistDir = layout.buildDirectory.dir("install/dist").get()
    homeBinDir = layout.buildDirectory.dir("install/bin").get()
    homeConfDir = layout.buildDirectory.dir("install/conf").get()
    homeLibDir = layout.buildDirectory.dir("install/lib").get()
    homeSrcDir = layout.buildDirectory.dir("install/src").get()
}

// Groovy is added as a dependency to both the 'groovy' and 'compile'
// configurations, so place the dependency in a shared variable. The
// 'compile' is required so that Groovy appears as a dependency in the
// artifacts' POMs.
ext.jointBuildGroovyJarProperty = System.getProperty('groovy.jar')
ext.groovyDependency = null

ext."signing.keyId" = System.getenv("SIGNING_KEY") ?: project.hasProperty("signing.keyId") ? project.getProperty('signing.keyId') : null
ext."signing.password" = System.getenv("SIGNING_PASSPHRASE") ?: project.hasProperty("signing.password") ? project.getProperty('signing.password') : null
ext."signing.secretKeyRingFile" = project.hasProperty("signing.secretKeyRingFile") ? project.getProperty('signing.secretKeyRingFile') : null

if (jointBuildGroovyJarProperty) {
    def jointBuildGroovyJar = file(jointBuildGroovyJarProperty)
    if (jointBuildGroovyJar.exists()) {
        groovyDependency = dependencies.create(files(jointBuildGroovyJar))
    } else {
        throw new GradleException("The groovy.jar system property points to ${jointBuildGroovyJar.absolutePath} which does not exist.")
    }
} else {
    groovyDependency = dependencies.create("org.apache.groovy:groovy:${groovyVersion}") {
        exclude module:"commons-cli"
        exclude module:"ant"
    }
}

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

    nexusPublishing {
        repositories {
            sonatype {
                def ossUser = System.getenv("SONATYPE_USERNAME") ?: project.hasProperty("sonatypeOssUsername") ? project.sonatypeOssUsername : ''
                def ossPass = System.getenv("SONATYPE_PASSWORD") ?: project.hasProperty("sonatypeOssPassword") ? project.sonatypeOssPassword : ''
                def ossStagingProfileId = System.getenv("SONATYPE_STAGING_PROFILE_ID") ?: project.hasProperty("sonatypeOssStagingProfileId") ? project.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(5000))
        }
    }
}

allprojects {

    // FORCE UPGRADE OF GROOVY IN DEPENDENCIES TO GROOVY 4
    // except in projects that will be run by Gradle during the build
    if (!compiledByGradleGroovyVersion(project)) {
        configurations.configureEach {
            resolutionStrategy.eachDependency { DependencyResolveDetails details ->
                if (details.requested.group == 'org.codehaus.groovy' && details.requested.name != 'groovy-bom') {
                    details.useTarget(group: 'org.apache.groovy', name: details.requested.name, version: groovyVersion)
                }
            }
        }
    }

    repositories {
        mavenCentral()
        maven { url = 'https://repo.grails.org/grails/core' }
        maven { url = 'https://oss.sonatype.org/content/repositories/snapshots' }
        // mavenLocal() // Keep, this will be uncommented and used by CI (groovy-joint-workflow)
        if(groovyVersion.endsWith('-SNAPSHOT')) {
            maven {
                name = 'ASF Snapshot repo'
                url = 'https://repository.apache.org/content/repositories/snapshots'
            }
        }
    }

    configurations {
        all {
            resolutionStrategy {
                def cacheHours = isCiBuild ? 0 : 24
                cacheDynamicVersionsFor cacheHours, 'hours'
                cacheChangingModulesFor cacheHours, 'hours'
                eachDependency { DependencyResolveDetails details ->
                    //specifying a fixed version for all libraries with 'org.gradle' group
                    if (details.requested.group == 'org.apache.groovy') {
                        details.useVersion(groovyVersion)
                    }
                    if (details.requested.group == "org.spockframework") {
                        details.useVersion(spockVersion)
                    }
                }
            }
        }
    }

    [Javadoc, Groovydoc].each {
        tasks.withType(it).all {
            // exclude problematic jar file from javadoc classpath
            // https://www.adam-bien.com/roller/abien/entry/trouble_with_crippled_java_ee
            if (classpath) {
                classpath -= classpath.filter { it.name == 'javaee-web-api-6.0.jar' }
            }

            // this will apply the javadoc fix tool to all generated javadocs
            // we use it to make sure that the javadocs are not vulnerable independently of the JDK used to build
            doLast {
                def javadocFix = new JavadocFixTool()
                javadocFix.recursive = true
                javadocFix.doPatch = true
                javadocFix.searchAndPatch(destinationDir)
            }
        }

    }

    tasks.withType(Javadoc) {
        options.addStringOption('Xdoclint:none', '-quiet')
    }

    // This added to prevent remote cache miss, because project JAR include manifest file with Build-By and Created-By properties which might be different for CI vs Local.
    normalization {
        runtimeClasspath {
            metaInf {
                ignoreAttribute("Built-By")
                ignoreAttribute("Created-By")
            }
        }
    }
    apply from: rootProject.layout.projectDirectory.file('gradle/dependency-licenses.gradle')
}

apply from: "gradle/idea.gradle"

subprojects { project ->

    version = grailsVersion
    group = "org.grails"

    ext.isTestSuite = project.name.startsWith("grails-test-suite")
    ext.isCiBuild = project.hasProperty("isCiBuild") || System.getenv().get("CI") as Boolean
    ext.pomInfo = {
        delegate.name 'Grails® framework'
        delegate.description 'Grails Web Application Framework'
        delegate.url 'https://grails.org/'

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

        delegate.scm {
            delegate.url 'scm:git@github.com:grails/grails-core.git'
            delegate.connection 'scm:git@github.com:grails/grails-core.git'
            delegate.developerConnection 'scm:git@github.com:grails/grails-core.git'
        }

        delegate.developers {
            delegate.developer {
                delegate.id 'puneetbehl'
                delegate.name 'Puneet Behl'
                delegate.email 'behlp@objectcomputing.com'
            }
        }

    }

    apply plugin: 'java-library'
    apply plugin: 'groovy'
    apply plugin: 'eclipse'
    apply plugin: 'idea'
    apply plugin: 'project-report'

    if (!isTestSuite) {

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

        java {
            withJavadocJar()
            withSourcesJar()
        }

        publishing {

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

            if (project.name == 'grails-dependencies') return
            if (project.name == 'grails-bom') return

            publications {
                maven(MavenPublication) {
                    pom {
                        name = 'Grails® framework'
                        description = 'Grails Web Application Framework'
                        url = 'https://grails.org/'

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

                        scm {
                            url = 'scm:git@github.com:grails/grails-core.git'
                            connection = 'scm:git@github.com:grails/grails-core.git'
                            developerConnection = 'scm:git@github.com:grails/grails-core.git'
                        }

                        developers {
                            developer {
                                id = 'puneetbehl'
                                name = 'Puneet Behl'
                                email = 'behlp@unityfoundation.io'
                            }
                        }
                    }

                    from components.java
                }
            }
        }

        afterEvaluate {
            signing {
                required { isReleaseVersion && gradle.taskGraph.hasTask("publish") }
                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))
        }

        tasks.register("installToHomeDist", Copy) {
            dependsOn sourcesJar, javadocJar, jar
            from layout.buildDirectory.dir("libs").get()
            into distInstallDir
        }

        tasks.withType(PublishToMavenLocal).configureEach {
            dependsOn installToHomeDist
            doLast {
                ant.copy(todir: homeDistDir, flatten: true, includeEmptyDirs: false) {
                    fileset dir: distInstallDir
                }
            }
        }
    }

    if (project.name == 'grails-dependencies') return
    if (project.name == 'grails-bom') return

    if (project.name =~ /^(grails-web|grails-plugin-|grails-test-suite|grails-test)/) {
        dependencies {
            api "jakarta.servlet:jakarta.servlet-api:$servletApiVersion"
            // MockHttpServletRequest/Response/Context used in many classes
            api("org.springframework:spring-test:$springVersion") {
                exclude group: 'commons-logging', module: 'commons-logging'
            }
        }
    }

    if (project.name =~ /^(grails-plugin-datasource|grails-test-suite)/) {
        dependencies {
            testImplementation "hsqldb:hsqldb:$hsqldbVesion"
            testImplementation "com.h2database:h2:$h2Version"
        }
    }

    jar {
        manifest.mainAttributes(
                "Built-By": System.properties['user.name'],
                "Created-By": System.properties['java.vm.version'] + " (" + System.properties['java.vm.vendor'] + ")",
                "Implementation-Title": "Grails",
                "Implementation-Version": grailsVersion,
                "Implementation-Vendor": 'grails.org')
    }

    configurations {
        documentation
        meta
        published.extendsFrom archives, meta
    }

    // common-logging is a problematic dependency that is often included in the classpath
    configurations {
        all*.exclude(group: 'commons-logging', module: 'commons-logging')
    }

    dependencies {
        documentation("org.fusesource.jansi:jansi:$jansiVersion")
        documentation("jline:jline:$jlineVersion")
        documentation ("com.github.javaparser:javaparser-core:$javaParserCoreVersion")

        if (compiledByGradleGroovyVersion(project)) {
            documentation "org.codehaus.groovy:groovy:$GroovySystem.version"
            documentation "org.codehaus.groovy:groovy-ant:$GroovySystem.version"
            documentation "org.codehaus.groovy:groovy-cli-picocli:$GroovySystem.version"
        } else {
            api groovyDependency
            documentation "org.apache.groovy:groovy:$groovyVersion"
            documentation "org.apache.groovy:groovy-ant:$groovyVersion"
            documentation "org.apache.groovy:groovy-cli-picocli:$groovyVersion"
        }

        testImplementation "org.apache.groovy:groovy-test-junit5:$groovyVersion"
        testImplementation "org.junit.jupiter:junit-jupiter-api:$junitVersion"
        testImplementation "org.junit.platform:junit-platform-runner:$junitPlatformRunnerVersion"
        testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:$junitVersion"

        compileOnly "com.github.spotbugs:spotbugs-annotations:$jsr305Version"

        if (project.name != "grails-docs") {
            // Logging
            api "org.slf4j:slf4j-api:$slf4jVersion"
            api "org.slf4j:jcl-over-slf4j:$slf4jVersion"

            // Testing
            testImplementation "org.slf4j:slf4j-simple:$slf4jVersion"
            testImplementation("org.spockframework:spock-core:$spockVersion") { transitive = false }
            // Required by Spock's Mocking
            testRuntimeOnly "net.bytebuddy:byte-buddy:$bytebuddyVersion"
            testImplementation "org.objenesis:objenesis:$objenesisVersion"
        }
    }

    def debugArguments = [
            '-Xmx2g', '-Xdebug', '-Xnoagent', '-Djava.compiler=NONE',
            '-Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005'
    ]
    def java17moduleReflectionCompatibilityArguments = [
            '--add-opens=java.base/java.lang=ALL-UNNAMED',
            '--add-opens=java.base/java.util=ALL-UNNAMED'
    ]

    tasks.withType(Test).configureEach {
        useJUnitPlatform()
        jvmArgs += java17moduleReflectionCompatibilityArguments
    }

    tasks.withType(Jar) {
        duplicatesStrategy = DuplicatesStrategy.INCLUDE
    }

    // Add the Groovy compiler options
    tasks.withType(GroovyCompile).configureEach {
        groovyOptions.fork(memoryInitialSize: '128M', memoryMaximumSize: '1G')
        groovyOptions.encoding = "UTF-8"
        options.encoding = "UTF-8"
    }

    tasks.withType(Groovydoc).configureEach {
        onlyIf { !isTestSuite }
        classpath += configurations.documentation
        access = GroovydocAccess.PRIVATE
        includeAuthor = true
        includeMainForScripts = false
        processScripts = false
    }

    tasks.withType(Javadoc).configureEach {
        onlyIf { !isTestSuite }
        classpath += configurations.documentation
        // Using options.jFlags instead of closure otherwise it fails with MinimalJavadocOptions
        options.encoding "UTF-8"
        options.docEncoding "UTF-8"
        options.charSet "UTF-8"
        options.jFlags "-Xms64M", "-Xmx512M"
    }

    configure(javadoc) {
        onlyIf { !isTestSuite }
        classpath += configurations.documentation
        // Using options.jFlags instead of closure otherwise it fails with MinimalJavadocOptions
        options.encoding "UTF-8"
        options.docEncoding "UTF-8"
        options.charSet "UTF-8"
        options.jFlags "-Xms64M", "-Xmx512M"
    }

    // task for running a single test with -DsingleTest.single=TestName singleTest
    tasks.register("singleTest", Test) {
        if (System.getProperty("debug.tests")) {
            jvmArgs += debugArguments
        }
    }

    test {
        develocity {
            testRetry {
                maxRetries = 2
                maxFailures = 20
                failOnPassedAfterRetry = true
            }
        }

        testLogging {
            events "passed", "skipped", "failed"

            showExceptions true
            exceptionFormat "full"
            showCauses true
            showStackTraces true
        }
        excludes = ["**/*TestCase.class", "**/*\$*.class"]

        if (isCiBuild) {
            maxParallelForks = 2
            maxHeapSize = '768m'
            afterSuite {
                System.out.print('.')
                System.out.flush()
            }
        } else {
            maxHeapSize = '1024m'
        }

        if (System.getProperty("debug.tests")) {
            jvmArgs += debugArguments
        }
    }

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

// From this point on we need the subprojects to be fully configured, so force their full evaluation
subprojects.each {
    if (it.tasks.findByName('install') && it.tasks.findByName('publishToMavenLocal')) {
        it.tasks.findByName('install').finalizedBy(it.tasks.findByName('publishToMavenLocal'))
    }
    evaluationDependsOn it.path
}

apply {
    from 'gradle/docs.gradle' // tasks for building the documentation (e.g. user guide, javadocs)
    from 'gradle/assemble.gradle' // tasks for creating an installation or distribution
    from 'gradle/findbugs.gradle'
}

// Add a task to list the buildscript dependencies
tasks.register('buildscriptDependencies', org.gradle.api.tasks.diagnostics.DependencyReportTask) {
    configurations = project.buildscript.configurations
}

[Javadoc, Groovydoc].each {
    tasks.withType(it).all {
        // exclude problematic jar file from javadoc classpath
        // https://www.adam-bien.com/roller/abien/entry/trouble_with_crippled_java_ee
        if (classpath) {
            classpath -= classpath.filter { it.name == 'javaee-web-api-6.0.jar' }
        }
    }
}

// Ensure that no insecure HTTP-based Maven repositories are defined
project.afterEvaluate {
    allprojects.repositories.each { handler ->
        handler.each {
            if (it.url.toString().startsWith("http://")) {
                throw new RuntimeException("Build should not define insecure HTTP-based Maven repostories")
            }
        }
    }
}

// compile with the Groovy version provided by Gradle
// to ensure build compatibility with Gradle, currently Groovy 3.0.x
// when used by grails-gradle-plugin
// see: https://docs.gradle.org/current/userguide/compatibility.html#groovy
boolean compiledByGradleGroovyVersion(Project currentProject) {
    currentProject.name in ['grails-bootstrap', 'grails-gradle-model', 'grails-shell']
}