Setup publications with MPP Gradle metadata for kotlin-test library

Move publication configuration from individual platform specific
kotlin-test- modules to the root module.

KT-40225

libraries/kotlin.test/annotations-common/build.gradle

@@ -2,8 +2,6 @@ description = 'Kotlin Test Annotations Common'
 
 apply plugin: 'kotlin-platform-common'
 
-configurePublishing(project)
-
 jvmTarget = "1.6"
 
 dependencies {

libraries/kotlin.test/build.gradle.kts

@@ -0,0 +1,289 @@
+import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
+
+plugins {
+    `kotlin-multiplatform` apply false
+    base
+    `maven-publish`
+}
+
+open class ComponentsFactoryAccess
+@javax.inject.Inject
+constructor(val factory: SoftwareComponentFactory)
+
+val componentFactory = objects.newInstance<ComponentsFactoryAccess>().factory
+
+
+val jvmApi by configurations.creating {
+    isCanBeConsumed = true
+    isCanBeResolved = false
+    attributes {
+        attribute(Usage.USAGE_ATTRIBUTE, objects.named("java-api"))
+        attribute(KotlinPlatformType.attribute, KotlinPlatformType.jvm)
+    }
+}
+
+val jvmRuntime by configurations.creating {
+    isCanBeConsumed = true
+    isCanBeResolved = false
+    attributes {
+        attribute(Usage.USAGE_ATTRIBUTE, objects.named("java-runtime"))
+        attribute(KotlinPlatformType.attribute, KotlinPlatformType.jvm)
+    }
+    extendsFrom(jvmApi)
+}
+
+val jsApiVariant by configurations.creating {
+    isCanBeConsumed = true
+    isCanBeResolved = false
+    attributes {
+        attribute(Usage.USAGE_ATTRIBUTE, objects.named("kotlin-api"))
+        attribute(KotlinPlatformType.attribute, KotlinPlatformType.js)
+    }
+}
+val jsRuntimeVariant by configurations.creating {
+    isCanBeConsumed = true
+    isCanBeResolved = false
+    attributes {
+        attribute(Usage.USAGE_ATTRIBUTE, objects.named("kotlin-runtime"))
+        attribute(KotlinPlatformType.attribute, KotlinPlatformType.js)
+    }
+    extendsFrom(jsApiVariant)
+}
+
+val nativeApiVariant by configurations.creating {
+    isCanBeConsumed = true
+    isCanBeResolved = false
+    attributes {
+        attribute(Usage.USAGE_ATTRIBUTE, objects.named("kotlin-api"))
+        attribute(KotlinPlatformType.attribute, KotlinPlatformType.native)
+    }
+}
+
+val commonVariant by configurations.creating {
+    isCanBeConsumed = true
+    isCanBeResolved = false
+    attributes {
+        attribute(Usage.USAGE_ATTRIBUTE, objects.named("kotlin-api"))
+        attribute(KotlinPlatformType.attribute, KotlinPlatformType.common)
+    }
+}
+
+dependencies {
+    jvmApi(project(":kotlin-stdlib"))
+    jsApiVariant("$group:kotlin-test-js:$version")
+    commonVariant("$group:kotlin-test-common:$version")
+    commonVariant("$group:kotlin-test-annotations-common:$version")
+}
+
+artifacts {
+    val jvmJar = tasks.getByPath(":kotlin-test:kotlin-test-jvm:jar")
+    add(jvmApi.name, jvmJar)
+    add(jvmRuntime.name, jvmJar)
+}
+
+val kotlinTestCommonSourcesJar = tasks.getByPath(":kotlin-test:kotlin-test-common:sourcesJar") as Jar
+val kotlinTestJvmSourcesJar = tasks.getByPath(":kotlin-test:kotlin-test-jvm:sourcesJar") as Jar
+
+val combinedSourcesJar by tasks.registering(Jar::class) {
+    dependsOn(kotlinTestCommonSourcesJar, kotlinTestJvmSourcesJar)
+    archiveClassifier.set("sources")
+    into("common") {
+        from(zipTree(kotlinTestCommonSourcesJar.archiveFile)) {
+            exclude("META-INF/**")
+        }
+    }
+    into("jvm") {
+        from(zipTree(kotlinTestJvmSourcesJar.archiveFile)) {
+            exclude("META-INF/**")
+        }
+    }
+}
+
+
+val rootComponent = componentFactory.adhoc("root").apply {
+    addVariantsFromConfiguration(jvmApi) {
+        mapToMavenScope("compile")
+    }
+    addVariantsFromConfiguration(jvmRuntime) {
+        mapToMavenScope("runtime")
+    }
+    addVariantsFromConfiguration(jsApiVariant) { mapToOptional() }
+    addVariantsFromConfiguration(jsRuntimeVariant) { mapToOptional() }
+    addVariantsFromConfiguration(nativeApiVariant) { mapToOptional() }
+    addVariantsFromConfiguration(commonVariant) { mapToOptional() }
+}
+
+
+val baseCapability = "$group:kotlin-test-framework:$version"
+val implCapability = "$group:kotlin-test-framework-impl:$version"
+
+val jvmTestFrameworks = listOf("junit", "junit5", "testng")
+
+jvmTestFrameworks.forEach { framework ->
+    val (apiVariant, runtimeVariant) = listOf("api", "runtime").map { usage ->
+        configurations.create("${framework}${usage.capitalize()}Variant") {
+            isCanBeConsumed = true
+            isCanBeResolved = false
+            attributes {
+                attribute(Usage.USAGE_ATTRIBUTE, objects.named("java-$usage"))
+                attribute(KotlinPlatformType.attribute, KotlinPlatformType.jvm)
+            }
+            outgoing.capability(baseCapability)  // C0
+            outgoing.capability("$group:kotlin-test-framework-$framework:$version") // C0
+        }
+    }
+    runtimeVariant.extendsFrom(apiVariant)
+    dependencies {
+        apiVariant("$group:kotlin-test-$framework:$version")
+    }
+    rootComponent.addVariantsFromConfiguration(apiVariant) { mapToOptional() }
+    rootComponent.addVariantsFromConfiguration(runtimeVariant) { mapToOptional() }
+
+    val (apiElements, runtimeElements) = listOf("api", "runtime").map { usage ->
+        configurations.create("${framework}${usage.capitalize()}") {
+            isCanBeConsumed = true
+            isCanBeResolved = false
+            attributes {
+                attribute(Usage.USAGE_ATTRIBUTE, objects.named("java-$usage"))
+            }
+            outgoing.capability(implCapability) // CC
+            outgoing.capability("$group:kotlin-test-$framework:$version")  // CC
+        }
+    }
+    runtimeElements.extendsFrom(apiElements)
+    dependencies {
+        apiElements("$group:kotlin-test:$version")
+        when(framework) {
+            "junit" -> {
+                apiElements("junit:junit:4.12")
+            }
+            "junit5" -> {
+                apiElements("org.junit.jupiter:junit-jupiter-api:5.0.0")
+            }
+            "testng" -> {
+                apiElements("org.testng:testng:6.13.1")
+            }
+        }
+    }
+
+    artifacts {
+        val jar = tasks.getByPath(":kotlin-test:kotlin-test-$framework:jar")
+        add(apiElements.name, jar)
+        add(runtimeElements.name, jar)
+    }
+
+    componentFactory.adhoc(framework).apply {
+        addVariantsFromConfiguration(apiElements) {
+            mapToMavenScope("compile")
+        }
+        addVariantsFromConfiguration(runtimeElements) {
+            mapToMavenScope("runtime")
+        }
+    }.let { components.add(it) }
+}
+
+val (jsApi, jsRuntime) = listOf("api", "runtime").map { usage ->
+    configurations.create("js${usage.capitalize()}") {
+        isCanBeConsumed = true
+        isCanBeResolved = false
+        attributes {
+            attribute(Usage.USAGE_ATTRIBUTE, objects.named("kotlin-$usage"))
+            attribute(KotlinPlatformType.attribute, KotlinPlatformType.js)
+        }
+    }
+}
+jsRuntime.extendsFrom(jsApi)
+
+dependencies {
+    jsApi(project(":kotlin-stdlib-js"))
+}
+
+artifacts {
+    val jsJar = tasks.getByPath(":kotlin-test:kotlin-test-js:libraryJarWithIr")
+    add(jsApi.name, jsJar)
+    add(jsRuntime.name, jsJar)
+}
+
+val jsComponent = componentFactory.adhoc("js").apply {
+    addVariantsFromConfiguration(jsApi) {
+        mapToMavenScope("compile")
+    }
+    addVariantsFromConfiguration(jsRuntime) {
+        mapToMavenScope("runtime")
+    }
+}
+
+val commonMetadata by configurations.creating {
+    isCanBeConsumed = true
+    isCanBeResolved = false
+    attributes {
+        attribute(Usage.USAGE_ATTRIBUTE, objects.named("kotlin-api"))
+        attribute(KotlinPlatformType.attribute, KotlinPlatformType.common)
+    }
+}
+val annotationsMetadata by configurations.creating {
+    isCanBeConsumed = true
+    isCanBeResolved = false
+    attributes {
+        attribute(Usage.USAGE_ATTRIBUTE, objects.named("kotlin-api"))
+        attribute(KotlinPlatformType.attribute, KotlinPlatformType.common)
+    }
+}
+dependencies {
+    commonMetadata(project(":kotlin-stdlib-common"))
+    annotationsMetadata(project(":kotlin-stdlib-common"))
+}
+artifacts {
+    add(commonMetadata.name, tasks.getByPath(":kotlin-test:kotlin-test-common:jar"))
+    add(annotationsMetadata.name, tasks.getByPath(":kotlin-test:kotlin-test-annotations-common:jar"))
+}
+val commonMetadataComponent = componentFactory.adhoc("common").apply {
+    addVariantsFromConfiguration(commonMetadata) {
+        mapToMavenScope("compile")
+    }
+}
+val annotationsMetadataComponent = componentFactory.adhoc("annotations-common").apply {
+    addVariantsFromConfiguration(annotationsMetadata) {
+        mapToMavenScope("compile")
+    }
+}
+
+
+
+publishing {
+    publications {
+        create("main", MavenPublication::class) {
+            from(rootComponent)
+            artifact(combinedSourcesJar)
+            // TODO: Remove all optional dependencies from root pom
+        }
+        jvmTestFrameworks.forEach { framework ->
+            create(framework, MavenPublication::class) {
+                artifactId = "kotlin-test-$framework"
+                from(components[framework])
+                artifact(tasks.getByPath(":kotlin-test:kotlin-test-$framework:sourcesJar") as Jar)
+            }
+        }
+        create("js", MavenPublication::class) {
+            artifactId = "kotlin-test-js"
+            from(jsComponent)
+            artifact(tasks.getByPath(":kotlin-test:kotlin-test-js:sourcesJar") as Jar)
+        }
+        create("common", MavenPublication::class) {
+            artifactId = "kotlin-test-common"
+            from(commonMetadataComponent)
+            artifact(tasks.getByPath(":kotlin-test:kotlin-test-common:sourcesJar") as Jar)
+        }
+        create("annotationsCommon", MavenPublication::class) {
+            artifactId = "kotlin-test-annotations-common"
+            from(annotationsMetadataComponent)
+            artifact(tasks.getByPath(":kotlin-test:kotlin-test-annotations-common:sourcesJar") as Jar)
+        }
+    }
+}
+
+tasks {
+    val install by creating {
+        dependsOn(publishToMavenLocal)
+    }
+}

libraries/kotlin.test/common/build.gradle

@@ -2,8 +2,6 @@ description = 'Kotlin Test Common'
 
 apply plugin: 'kotlin-platform-common'
 
-configurePublishing(project)
-
 jvmTarget = "1.6"
 
 dependencies {

libraries/kotlin.test/js/build.gradle

@@ -2,8 +2,6 @@ description = 'Kotlin Test for JS'
 
 apply plugin: 'kotlin-platform-js'
 
-configurePublishing(project)
-
 configurations {
     distJs
     distLibrary
@@ -76,7 +74,6 @@ task sourcesJar(type: Jar, dependsOn: classes) {
 artifacts {
     runtime libraryJarWithIr
     archives libraryJarWithIr
-    publishedRuntime libraryJarWithIr
     distLibrary libraryJarWithIr
     archives sourcesJar
     distJs(file(compileKotlin2Js.kotlinOptions.outputFile)) {

libraries/kotlin.test/junit/build.gradle

@@ -3,7 +3,6 @@ description = 'Kotlin Test JUnit'
 apply plugin: 'kotlin-platform-jvm'
 
 configureJvm6Project(project)
-configurePublishing(project)
 
 def includeJava9 = BuildPropertiesExtKt.getIncludeJava9(project.kotlinBuildProperties)
 

libraries/kotlin.test/junit5/build.gradle

@@ -3,7 +3,6 @@ description = 'Kotlin Test JUnit 5'
 apply plugin: 'kotlin-platform-jvm'
 
 configureJvm6Project(project)
-configurePublishing(project)
 ext.javaHome = JDK_18
 ext.jvmTarget = "1.8"
 

libraries/kotlin.test/jvm/build.gradle

@@ -6,9 +6,6 @@ archivesBaseName = 'kotlin-test'
 
 configureJvm6Project(project)
 
-configurePublishing(project) {
-    artifactId = archivesBaseName
-}
 
 def includeJava9 = BuildPropertiesExtKt.getIncludeJava9(project.kotlinBuildProperties)
 

libraries/kotlin.test/testng/build.gradle

@@ -3,7 +3,6 @@ description = 'Kotlin Test TestNG'
 apply plugin: 'kotlin-platform-jvm'
 
 configureJvm6Project(project)
-configurePublishing(project)
 ext.javaHome = JDK_17
 
 def includeJava9 = BuildPropertiesExtKt.getIncludeJava9(project.kotlinBuildProperties)