Use standardized project names (#11354)

* Use standardized project names

This will make it easier to use Micronaut Core as an included build.
This also simplifies some dependency substitution rules which were
a bit awkward.

* Convert all build scripts to Kotlin DSL

For consistency and better IDE support.

Author: melix

aop/build.gradle

@@ -0,0 +1,25 @@
+plugins {
+    id("io.micronaut.build.internal.convention-core-library")
+    alias(libs.plugins.managed.kotlin.jvm)
+}
+
+micronautBuild {
+    core {
+        documented = false
+    }
+}
+
+dependencies {
+    api(projects.micronautInject)
+    api(projects.micronautCore)
+    compileOnly(projects.micronautCoreReactive)
+    compileOnly(libs.managed.kotlinx.coroutines.core)
+    compileOnly(libs.managed.reactor)
+}
+
+tasks {
+    compileKotlin {
+        kotlinOptions.jvmTarget = "17"
+        kotlinOptions.languageVersion = "1.7"
+    }
+}

aop/build.gradle.kts

@@ -0,0 +1,87 @@
+plugins {
+    id("io.micronaut.build.internal.convention-base")
+    id("me.champeau.jmh") version "0.7.2"
+}
+
+val typeCheckTestSourceSet = sourceSets.create("typeCheckTest") {
+    compileClasspath += sourceSets.get("jmh").output
+    runtimeClasspath += sourceSets.get("jmh").output
+}
+
+dependencies {
+    annotationProcessor(projects.micronautInjectJava)
+    jmhAnnotationProcessor(projects.micronautInjectJava)
+    jmhAnnotationProcessor(libs.bundles.asm)
+    jmhAnnotationProcessor(libs.jmh.generator.annprocess)
+
+    annotationProcessor(platform(libs.test.boms.micronaut.validation))
+    annotationProcessor(libs.micronaut.validation.processor) {
+        exclude(group = "io.micronaut")
+    }
+
+    compileOnly(platform(libs.test.boms.micronaut.validation))
+    compileOnly(libs.micronaut.validation) {
+        exclude(group = "io.micronaut")
+    }
+
+    api(projects.micronautInject)
+    api(projects.micronautInjectJavaTest)
+    api(projects.micronautHttpServer)
+    api(projects.micronautHttpServerNetty)
+    api(projects.micronautHttpClient)
+    api(projects.micronautJacksonDatabind)
+    api(projects.micronautRouter)
+    api(projects.micronautRuntime)
+
+    api(platform(libs.test.boms.micronaut.validation))
+    api(libs.managed.reactor)
+    api(libs.micronaut.validation) {
+        exclude(group = "io.micronaut")
+    }
+
+    jmh(libs.jmh.core)
+
+    "typeCheckTestImplementation"(libs.junit.jupiter)
+    "typeCheckTestImplementation"(libs.micronaut.test.type.pollution)
+    "typeCheckTestImplementation"(libs.bytebuddy.agent)
+    "typeCheckTestImplementation"(libs.bytebuddy)
+    "typeCheckTestRuntimeOnly"(libs.junit.platform.engine)
+}
+
+configurations {
+    get("typeCheckTestImplementation").extendsFrom(jmhImplementation.get(), implementation.get())
+    get("typeCheckTestRuntimeOnly").extendsFrom(jmhRuntimeOnly.get(), runtimeOnly.get())
+}
+
+jmh {
+    includes = listOf("io.micronaut.http.server.StartupBenchmark")
+    duplicateClassesStrategy = DuplicatesStrategy.WARN
+}
+
+tasks {
+    processJmhResources {
+        duplicatesStrategy = DuplicatesStrategy.WARN
+    }
+}
+
+val typeCheckTest = tasks.register<Test>("typeCheckTest") {
+    description = "Runs type check tests."
+    group = "verification"
+
+    testClassesDirs = typeCheckTestSourceSet.output.classesDirs
+    classpath = typeCheckTestSourceSet.runtimeClasspath
+
+    useJUnitPlatform()
+}
+
+tasks {
+    check {
+        dependsOn(typeCheckTest)
+    }
+}
+
+listOf("spotlessJavaCheck", "checkstyleMain", "checkstyleJmh").forEach {
+    tasks.named(it) {
+        enabled = false
+    }
+}

benchmarks/build.gradle

@@ -0,0 +1,12 @@
+plugins {
+    id("io.micronaut.build.internal.convention-library")
+}
+
+dependencies {
+    api(projects.micronautCore)
+    api(projects.micronautInject)
+    api(libs.managed.netty.buffer)
+    compileOnly(libs.graal)
+
+    annotationProcessor(projects.micronautInjectJava)
+}

benchmarks/build.gradle.kts

@@ -5,3 +5,5 @@ dependencyResolutionManagement {
         }
     }
 }
+
+rootProject.name = "buildSrc"

buffer-netty/build.gradle

@@ -19,13 +19,6 @@ configurations.all {
     resolutionStrategy.cacheDynamicVersionsFor 0, 'seconds'
 }
 
-configurations {
-    testRuntimeClasspath {
-        // Use AOP from here, not from maven
-        exclude group: 'io.micronaut', module: 'micronaut-aop'
-    }
-}
-
 group = projectGroupId
 
 def micronautBuild = (ExtensionAware) project.extensions.getByName("micronautBuild")
@@ -63,11 +56,12 @@ tasks.withType(Jar).configureEach {
 configurations.all {
     resolutionStrategy.dependencySubstitution {
         rootProject.subprojects.each {
-            if (!it.name.startsWith('test-')) {
+            String targetName = ":${it.name}"
+            if (it.name.startsWith('micronaut-')) {
                 if (it.name.contains('bom')) {
-                    substitute platform(module("io.micronaut:micronaut-${it.name}")) using platform(project(":${it.name}")) because "we want to test with what we're building"
+                    substitute platform(module("io.micronaut:micronaut-${it.name}")) using platform(project(targetName)) because "we want to test with what we're building"
                 } else {
-                    substitute module("io.micronaut:micronaut-${it.name}") using project(":${it.name}") because "we want to test with what we're building"
+                    substitute module("io.micronaut:${it.name}") using project(targetName) because "we want to test with what we're building"
                 }
             }
         }
@@ -90,7 +84,7 @@ dependencies {
     compileOnly libs.caffeine
     compileOnly libs.bundles.asm
 
-    testAnnotationProcessor project(":http-validation")
+    testAnnotationProcessor projects.micronautHttpValidation
     testAnnotationProcessor libs.bundles.asm
 
     testImplementation libs.caffeine

buffer-netty/build.gradle.kts

@@ -1,3 +1,3 @@
 plugins {
-    id "io.micronaut.build.internal.convention-library"
+    id("io.micronaut.build.internal.convention-library")
 }

buildSrc/settings.gradle

@@ -10,12 +10,12 @@ import groovy.transform.CompileStatic
 class RemovedPackages implements ViolationTransformer {
     private final List<String> excludedPackagesPrefixes
     private final List<String> excludedPackages
-    
-    public RemovedPackages(Map<String, List<String>> params) {
-        this.excludedPackagesPrefixes = params.prefixes as List<String>
-        this.excludedPackages = params.exact as List<String>
+
+    public RemovedPackages(Map<String, String> params) {
+        this.excludedPackagesPrefixes = params.prefixes.split(',') as List<String>
+        this.excludedPackages = params.exact.split(',') as List<String>
     }
-    
+
     Optional<Violation> transform(String type, Violation v) {
         String pkg = type.substring(0, type.lastIndexOf('.'))
 
@@ -27,4 +27,3 @@ class RemovedPackages implements ViolationTransformer {
         return Optional.of(v)
     }
 }
-