build.gradle

buildscript {
    repositories {
        gradlePluginPortal()
        mavenCentral()
    }
    dependencies {
        classpath "gradle.plugin.com.github.jengelman.gradle.plugins:shadow:7.0.0"
        classpath "org.aim42:htmlSanityCheck:${libs.versions.htmlSanityCheck.get()}"
        classpath 'javax.xml.bind:jaxb-api:2.3.1'
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${libs.versions.managed.kotlin.asProvider().get()}"
    }
}

apply plugin: 'org.aim42.htmlSanityCheck'

repositories {
    mavenCentral()
}

tasks.register("testReportsAggregate") {
    group 'verification'
    doLast() {
        int totalFailures = 0
        int totalErrors = 0
        int totalSkipped = 0
        int totalTests = 0
        int itemPad = 13
        int titlePad = 35
        String separator = " | "
        subprojects.each { subproject ->
            if (subproject.tasks.find { Task task -> task.name == 'test' }) {
                if (new File("${subproject.buildDir}/test-results/test").exists()) {
                    int failures = 0
                    int errors = 0
                    int skipped = 0
                    int tests = 0
                    new File("${subproject.buildDir}/test-results/test").eachFile() { file ->
                        if (file.name.endsWith('.xml')) {
                            def testsuite = new XmlSlurper().parseText(file.text)
                            failures += "${testsuite['@failures']}" as int
                            errors += "${testsuite['@errors']}" as int
                            skipped += "${testsuite['@skipped']}" as int
                            tests += "${testsuite['@tests']}" as int
                        }
                    }
                    totalFailures += failures
                    totalErrors += errors
                    totalSkipped += skipped
                    totalTests += tests
                    String subprojectStr = "${subproject.name}".padRight(titlePad)
                    String testStr = "tests: $tests".padRight(itemPad)
                    String skippedStr = "skipped: $skipped".padRight(itemPad)
                    String errorsStr = "errors: $errors".padRight(itemPad)
                    String failuresStr = "failures: $failures".padRight(itemPad)
                    logger.quiet("${subprojectStr}${separator}${testStr}${separator}${skippedStr}${separator}${errorsStr}${separator}${failuresStr}")
                }
            }
        }
        String title = "All Tests".padRight(titlePad)
        String testStr = "tests: $totalTests".padRight(itemPad)
        String skippedStr = "skipped: $totalSkipped".padRight(itemPad)
        String errorsStr = "errors: $totalErrors".padRight(itemPad)
        String failuresStr = "failures: $totalFailures".padRight(itemPad)
        int itemsSize = [totalTests, totalSkipped, totalErrors, totalFailures].size()
        logger.quiet("=" * ((itemPad * itemsSize) + titlePad + (separator.length() * itemsSize)))
        logger.quiet("${title}${separator}${testStr}${separator}${skippedStr}${separator}${errorsStr}${separator}${failuresStr}")
    }
}

subprojects { Project subproject ->

    ext {
        isBuildSnapshot = version.toString().endsWith("-SNAPSHOT")
        shadowJarEnabled = false
    }

    group projectGroupId

    if (subproject.name.contains("bom") || subproject.name.contains("parent")) {
        return
    }

    apply plugin: "io.micronaut.build.internal.common"
    if (!subproject.name.startsWith('test-') &&
            !subproject.name.startsWith('inject-test-') &&
            !subproject.toString().contains('benchmarks')) {
        apply plugin: "io.micronaut.build.internal.publishing"
    }

    micronautBuild {
        enableBom = false
        enableProcessing = false
    }

    tasks.withType(Test).configureEach {
        useJUnitPlatform()
        jvmArgs '-Xmx2048m'
        systemProperty "micronaut.cloud.platform", "OTHER"
        if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_15)) {
            jvmArgs "--enable-preview"
        }
    }

    tasks.withType(JavaCompile).configureEach {
       options.compilerArgs.add("-Amicronaut.processing.group=$project.group")
       options.compilerArgs.add("-Amicronaut.processing.module=micronaut-$project.name")
       options.compilerArgs.add("-Amicronaut.processing.omit.confprop.injectpoints=true")
       options.forkOptions.memoryMaximumSize = "2g"
    }
    tasks.withType(GroovyCompile).configureEach {
        options.compilerArgs.add("-Amicronaut.processing.group=$project.group")
        options.compilerArgs.add("-Amicronaut.processing.module=micronaut-$project.name")
        groovyOptions.forkOptions.memoryMaximumSize = "2g"
    }

    configurations {
        shadowCompile
        all {
            resolutionStrategy.eachDependency { DependencyResolveDetails details ->
                String group = details.requested.group
                if (group == 'org.ow2.asm') {
                    details.useVersion(libs.versions.asm.get())
                }
            }
        }
    }

    apply plugin: 'com.github.johnrengelman.shadow'

    tasks.named("shadowJar") {
        configurations = [project.configurations.shadowCompile]
        relocate "com.github.benmanes.caffeine", "io.micronaut.caffeine"
        relocate "org.objectweb.asm", "io.micronaut.asm"
    }

    def isDocumented = subproject.name != 'inject' && subproject.name != 'core' && subproject.name != 'aop' && !subproject.name.contains('asciidoc-config-props')

    dependencies {
        if (subproject.name != "bom") {
            api libs.managed.slf4j
        }

        if (isDocumented) {
            annotationProcessor(libs.micronaut.docs) {
                transitive = false
            }
        }
        compileOnly libs.caffeine
        testAnnotationProcessor project(":http-validation")
        testImplementation libs.caffeine
        testImplementation libs.managed.groovy
        testImplementation(libs.managed.spock) {
            exclude module: 'groovy-all'
        }

        testImplementation libs.groovy.test.junit5
        compileOnly libs.bundles.asm
        annotationProcessor libs.bundles.asm

        testImplementation libs.bundles.asm
        testAnnotationProcessor libs.bundles.asm
    }
    spotless {
        java {
            targetExclude '**/io/micronaut/core/io/scan/AnnotationClassReader.java'
            targetExclude '**/io/micronaut/core/io/scan/Attribute.java'
            targetExclude '**/io/micronaut/core/io/scan/Context.java'
            targetExclude '**/io/micronaut/core/util/clhm/**'
            targetExclude '**/io/micronaut/core/util/AntPathMatcher.java'
            targetExclude '**/io/micronaut/discovery/eureka/client/v2/AmazonInfo.java'
            targetExclude '**/io/micronaut/discovery/eureka/client/v2/DataCenterInfo.java'
            targetExclude '**/io/micronaut/discovery/eureka/client/v2/LeaseInfo.java'
            targetExclude '**/io/micronaut/support/InMemoryJavaFileManager.java'
            targetExclude '**/io/micronaut/scheduling/cron/CronExpression.java'
            targetExclude '**/org/atinject/tck/auto/Tck.kt'
            targetExclude '**/io/micronaut/http/uri/QueryStringDecoder.java'
        }
        format 'javaMisc', {
            targetExclude '**/io/micronaut/core/util/clhm/**'
            targetExclude '**/io/micronaut/http/netty/stream/package-info.java'
        }
    }
}
apply plugin: "io.micronaut.build.internal.docs"
apply plugin: "io.micronaut.build.internal.version-catalog-updates"

allprojects {

    version project.projectVersion

    apply plugin: 'idea'

    idea {
        module {
            outputDir file('build/classes/java/main')
            testOutputDir file('build/classes/groovy/test')
        }
    }
}

htmlSanityCheck {
    sourceDir = new File("${rootProject.buildDir}/docs/guide/")
    sourceDocuments = fileTree(sourceDir) {
        include "index.html"
    }
}

tasks.named("docs") {
    finalizedBy(htmlSanityCheck)
}

tasks.named("updateVersionCatalogs") {
    // we set the list to empty because we accept upgrades which improve the status
    rejectedQualifiers = []
    // Invalid POM files
    ignoredModules.add("io.micronaut.ignite:micronaut-ignite-core")
    ignoredModules.add("io.micronaut.ignite:micronaut-ignite-cache")
    // workaround Gradle variant selection problem
    ignoredModules.add("com.github.ben-manes.caffeine:caffeine")
}

allprojects {
    tasks.withType(JavaCompile).configureEach {
        options.fork = true
        options.forkOptions.memoryMaximumSize = "1048m"
    }
}