Build: Introduce new software component for publishing

Some of our published modules don't have javaComponent

buildSrc/src/main/kotlin/artifacts.kt

@@ -10,11 +10,13 @@ import org.gradle.api.artifacts.PublishArtifact
 import org.gradle.api.artifacts.component.ProjectComponentIdentifier
 import org.gradle.api.attributes.Bundling
 import org.gradle.api.attributes.Category
+import org.gradle.api.attributes.LibraryElements
 import org.gradle.api.attributes.Usage
 import org.gradle.api.component.AdhocComponentWithVariants
 import org.gradle.api.file.DuplicatesStrategy
 import org.gradle.api.plugins.BasePluginConvention
 import org.gradle.api.plugins.JavaPlugin
+import org.gradle.api.plugins.JavaPlugin.*
 import org.gradle.api.plugins.JavaPluginExtension
 import org.gradle.api.publish.PublishingExtension
 import org.gradle.api.publish.maven.MavenPublication
@@ -109,12 +111,14 @@ fun <T : Jar> Project.runtimeJar(task: TaskProvider<T>, body: T.() -> Unit = {})
             attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.LIBRARY))
             attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_RUNTIME))
             attribute(Bundling.BUNDLING_ATTRIBUTE, objects.named(Bundling.EXTERNAL))
+            attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements.JAR))
         }
     }
 
-    val javaComponent = components.findByName("java") as AdhocComponentWithVariants
+    configurePublishedComponent {
-    javaComponent.withVariantsFromConfiguration(configurations["runtimeElements"]) { skip() }
+        withVariantsFromConfiguration(configurations[RUNTIME_ELEMENTS_CONFIGURATION_NAME]) { skip() }
-    javaComponent.addVariantsFromConfiguration(runtimeJar) { }
+        addVariantsFromConfiguration(runtimeJar) { }
+    }
 
     return task
 }
@@ -151,6 +155,10 @@ fun Project.sourcesJar(body: Jar.() -> Unit = {}): TaskProvider<Jar> {
     addArtifact("archives", sourcesJar)
     addArtifact("sources", sourcesJar)
 
+    configurePublishedComponent {
+        addVariantsFromConfiguration(configurations[SOURCES_ELEMENTS_CONFIGURATION_NAME]) { }
+    }
+
     return sourcesJar
 }
 
@@ -170,13 +178,21 @@ fun Project.javadocJar(body: Jar.() -> Unit = {}): TaskProvider<Jar> {
     }
 
     addArtifact("archives", javadocTask)
+
+    configurePublishedComponent {
+        addVariantsFromConfiguration(configurations[JAVADOC_ELEMENTS_CONFIGURATION_NAME]) { }
+    }
+
     return javadocTask
 }
 
 fun Project.modularJar(body: Jar.() -> Unit): TaskProvider<Jar> {
     val modularJar = configurations.maybeCreate("modularJar").apply {
+        isCanBeConsumed = true
+        isCanBeResolved = false
         attributes {
             attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_RUNTIME))
+            attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named("modular-jar"))
         }
     }
 
@@ -189,8 +205,9 @@ fun Project.modularJar(body: Jar.() -> Unit): TaskProvider<Jar> {
     addArtifact("modularJar", modularJarTask)
     addArtifact("archives", modularJarTask)
 
-    val javaComponent = components.findByName("java") as AdhocComponentWithVariants
+    configurePublishedComponent {
-    javaComponent.addVariantsFromConfiguration(modularJar) { }
+        addVariantsFromConfiguration(modularJar) { mapToMavenScope("runtime") }
+    }
 
     return modularJarTask
 }
@@ -362,3 +379,6 @@ fun Project.cleanArtifacts() {
         }
     }
 }
+
+fun Project.configurePublishedComponent(configure: AdhocComponentWithVariants.() -> Unit) =
+    (components.findByName(KotlinBuildPublishingPlugin.ADHOC_COMPONENT_NAME) as AdhocComponentWithVariants?)?.apply(configure)

buildSrc/src/main/kotlin/plugins/KotlinBuildPublishingPlugin.kt

@@ -9,6 +9,8 @@ import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.attributes.Usage
 import org.gradle.api.component.AdhocComponentWithVariants
+import org.gradle.api.component.SoftwareComponentFactory
+import org.gradle.api.plugins.JavaBasePlugin
 import org.gradle.api.publish.PublishingExtension
 import org.gradle.api.publish.maven.MavenPublication
 import org.gradle.api.publish.maven.plugins.MavenPublishPlugin
@@ -16,44 +18,57 @@ import org.gradle.api.publish.maven.tasks.PublishToMavenRepository
 import org.gradle.kotlin.dsl.*
 import org.gradle.plugins.signing.SigningExtension
 import org.gradle.plugins.signing.SigningPlugin
+import javax.inject.Inject
 
 
-class KotlinBuildPublishingPlugin : Plugin<Project> {
+class KotlinBuildPublishingPlugin @Inject constructor(
+    private val componentFactory: SoftwareComponentFactory
+) : Plugin<Project> {
     override fun apply(target: Project): Unit = with(target) {
         apply<MavenPublishPlugin>()
         apply<SigningPlugin>()
 
-        val javaComponent = components.findByName("java") as AdhocComponentWithVariants?
+        val publishedRuntime = configurations.maybeCreate(RUNTIME_CONFIGURATION).apply {
-        if (javaComponent != null) {
+            isCanBeConsumed = false
+            isCanBeResolved = false
+            attributes {
+                attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_RUNTIME))
+            }
+        }
+
+        val publishedCompile = configurations.maybeCreate(COMPILE_CONFIGURATION).apply {
+            isCanBeConsumed = false
+            isCanBeResolved = false
+            attributes {
+                attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_API))
+            }
+        }
+
+        val kotlinLibraryComponent = componentFactory.adhoc(ADHOC_COMPONENT_NAME) as AdhocComponentWithVariants
+        components.add(kotlinLibraryComponent)
+        kotlinLibraryComponent.addVariantsFromConfiguration(publishedCompile) { mapToMavenScope("compile") }
+        kotlinLibraryComponent.addVariantsFromConfiguration(publishedRuntime) { mapToMavenScope("runtime") }
+
+        pluginManager.withPlugin("java-base") {
             val runtimeElements by configurations
             val apiElements by configurations
 
-            val publishedRuntime = configurations.maybeCreate("publishedRuntime").apply {
+            publishedRuntime.extendsFrom(runtimeElements)
-                attributes {
+            publishedCompile.extendsFrom(apiElements)
-                    attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_RUNTIME))
+
+            kotlinLibraryComponent.addVariantsFromConfiguration(runtimeElements) {
+                mapToMavenScope("runtime")
+
+                if (configurationVariant.artifacts.any { JavaBasePlugin.UNPUBLISHABLE_VARIANT_ARTIFACTS.contains(it.type) }) {
+                    skip()
                 }
-                extendsFrom(runtimeElements)
             }
-
-            val publishedCompile = configurations.maybeCreate("publishedCompile").apply {
-                attributes {
-                    attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_API))
-                }
-                extendsFrom(apiElements)
-            }
-
-            javaComponent.withVariantsFromConfiguration(apiElements) { skip() }
-
-            javaComponent.addVariantsFromConfiguration(publishedCompile) { mapToMavenScope("compile") }
-            javaComponent.addVariantsFromConfiguration(publishedRuntime) { mapToMavenScope("runtime") }
         }
 
         configure<PublishingExtension> {
             publications {
                 create<MavenPublication>(PUBLICATION_NAME) {
-                    if (javaComponent != null) {
+                    from(kotlinLibraryComponent)
-                        from(javaComponent)
-                    }
 
                     pom {
                         packaging = "jar"
@@ -126,5 +141,9 @@ class KotlinBuildPublishingPlugin : Plugin<Project> {
     companion object {
         const val PUBLICATION_NAME = "Main"
         const val REPOSITORY_NAME = "Maven"
+        const val ADHOC_COMPONENT_NAME = "kotlinLibrary"
+
+        const val COMPILE_CONFIGURATION = "publishedCompile"
+        const val RUNTIME_CONFIGURATION = "publishedRuntime"
     }
 }

libraries/reflect/build.gradle.kts

@@ -4,7 +4,6 @@ import com.github.jengelman.gradle.plugins.shadow.transformers.Transformer
 import com.github.jengelman.gradle.plugins.shadow.transformers.TransformerContext
 import kotlinx.metadata.jvm.KmModuleVisitor
 import kotlinx.metadata.jvm.KotlinModuleMetadata
-import org.gradle.api.tasks.PathSensitivity.RELATIVE
 import shadow.org.apache.tools.zip.ZipEntry
 import shadow.org.apache.tools.zip.ZipOutputStream
 
@@ -186,6 +185,10 @@ java {
     withSourcesJar()
 }
 
+configurePublishedComponent {
+    addVariantsFromConfiguration(configurations[JavaPlugin.SOURCES_ELEMENTS_CONFIGURATION_NAME]) { }
+}
+
 val sourcesJar = tasks.named<Jar>("sourcesJar") {
     archiveClassifier.set("sources")