Maven publishing fixes (#39)

* rm unused maven pom config

* * fix Javadoc jar + Javadoc jar signing
* fix JavaPlugin + KMPP plugin clash
* only publish to Sonatype when credentials are present

* old code clean up, and use Gradle lazy task config for KotlinCompile config

Author: aSemy

buildSrc/src/main/kotlin/buildsrc/config/publishing.kt

@@ -2,43 +2,27 @@ package buildsrc.config
 
 import org.gradle.api.Project
 import org.gradle.api.publish.PublishingExtension
-import org.gradle.api.publish.maven.MavenPublication
 import org.gradle.kotlin.dsl.configure
 import org.gradle.kotlin.dsl.getByType
 import org.gradle.plugins.signing.SigningExtension
 
 
-fun MavenPublication.kxsTsGenPom() = pom {
-  url.set("https://github.com/adamko-dev/kotlinx-serialization-typescript-generator")
-  packaging = "jar"
-  licenses {
-    license {
-      name.set("The Apache License, Version 2.0")
-      url.set("http://www.apache.org/licenses/LICENSE-2.0.txt")
-    }
-  }
-  scm {
-    connection.set("scm:git:git://github.com/adamko-dev/kotlinx-serialization-typescript-generator.git")
-    url.set("https://github.com/adamko-dev/kotlinx-serialization-typescript-generator")
-  }
-}
-
-
-
-
-
 // hacks because IntelliJ still doesn't properly load DSL accessors for buildSrc
 
+
 /** Configure [PublishingExtension] */
 fun Project.publishing(action: PublishingExtension.() -> Unit): Unit =
   extensions.configure(action)
 
+
 val Project.publishing: PublishingExtension
   get() = extensions.getByType<PublishingExtension>()
 
+
 /** Configure [SigningExtension] */
 fun Project.signing(action: SigningExtension.() -> Unit): Unit =
   extensions.configure(action)
 
+
 val Project.signing: SigningExtension
   get() = extensions.getByType<SigningExtension>()

buildSrc/src/main/kotlin/buildsrc/convention/maven-publish.gradle.kts

@@ -2,6 +2,10 @@ package buildsrc.convention
 
 import buildsrc.config.publishing
 import buildsrc.config.signing
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinMultiplatformPlugin
+import org.jetbrains.kotlin.gradle.targets.jvm.KotlinJvmTarget
+
 
 plugins {
   `maven-publish`
@@ -28,92 +32,91 @@ val sonatypeRepositoryReleaseUrl: Provider<String> = provider {
 
 val signingKeyId: Provider<String> =
   providers.gradleProperty("signing.keyId")
+val signingKey: Provider<String> =
+  providers.gradleProperty("signing.key")
 val signingPassword: Provider<String> =
   providers.gradleProperty("signing.password")
 val signingSecretKeyRingFile: Provider<String> =
   providers.gradleProperty("signing.secretKeyRingFile")
 
 
+val javadocJarStub by tasks.registering(Jar::class) {
+  group = JavaBasePlugin.DOCUMENTATION_GROUP
+  description = "Stub javadoc.jar artifact (required by Maven Central)"
+  archiveClassifier.set("javadoc")
+}
+
+
 tasks.matching {
   it.name.startsWith(PublishingPlugin.PUBLISH_LIFECYCLE_TASK_NAME)
     && it.group == PublishingPlugin.PUBLISH_TASK_GROUP
 }.configureEach {
+  if (sonatypeRepositoryCredentials.isPresent()) {
+    dependsOn(javadocJarStub)
+  }
   doLast {
     logger.lifecycle("[${this.name}] ${project.group}:${project.name}:${project.version}")
   }
 }
 
 
 publishing {
-  repositories {
-    maven(sonatypeRepositoryReleaseUrl) {
-      name = "sonatype"
-      credentials(sonatypeRepositoryCredentials.get())
+  if (sonatypeRepositoryCredentials.isPresent()) {
+    repositories {
+      maven(sonatypeRepositoryReleaseUrl) {
+        name = "sonatype"
+        credentials(sonatypeRepositoryCredentials.get())
+      }
+    }
+    publications.withType<MavenPublication>().configureEach {
+      createKxTsGenPom()
+      artifact(javadocJarStub)
     }
-  }
-  publications.withType<MavenPublication>().configureEach {
-    createKxTsGenPom()
   }
 }
 
 
 signing {
+  if (sonatypeRepositoryCredentials.isPresent()) {
+    if (signingKeyId.isPresent() && signingKey.isPresent() && signingPassword.isPresent()) {
+      useInMemoryPgpKeys(signingKeyId.get(), signingKey.get(), signingPassword.get())
+    } else {
+      useGpgCmd()
+    }
 
-//  if (
-//    signingKeyId.isPresent() &&
-//    signingPassword.isPresent() &&
-//    signingSecretKeyRingFile.isPresent()
-//  ) {
-//  useInMemoryPgpKeys(signingKeyId, signingKey, signingPassword)
-//  } else {
-//    useGpgCmd()
-//  }
+    // sign all publications
+    sign(publishing.publications)
+    sign(javadocJarStub.get())
+  }
+}
 
-  useGpgCmd()
 
-  // sign all publications
-  sign(publishing.publications)
+plugins.withType(KotlinMultiplatformPlugin::class).configureEach {
+  publishing.publications.withType<MavenPublication>().configureEach {
+    artifact(javadocJarStub)
+  }
 }
 
 
-plugins.configureEach {
-  when (this) {
-    // not necessary? It looks like the plugin creates publications correctly?
-//    is KotlinMultiplatformPlugin -> {
-//
-//      // Stub javadoc.jar artifact (required by Maven Central?)
-//      val javadocJar by tasks.registering(Jar::class) {
-//        archiveClassifier.set("javadoc")
-//      }
-//
-//      publishing.publications.create<MavenPublication>("mavenKotlinMpp") {
-//        from(components["kotlin"])
-//        artifact(javadocJar)
-//        artifact(tasks["sourcesJar"])
-//      }
-//    }
-
-    // JavaPlugin clashes with KotlinMultiplatformPlugin?
-    // causes error
-    // Artifact kxs-ts-gen-core-jvm-maven-publish-SNAPSHOT.jar wasn't produced by this build
-//    is JavaPlugin                -> afterEvaluate {
-//      if (!plugins.hasPlugin(KotlinMultiplatformPlugin::class)) {
-//        publishing.publications.create<MavenPublication>("mavenJava") {
-//          from(components["java"])
-//          artifact(tasks["sourcesJar"])
-//        }
-//      }
-//    }
-
-    is JavaPlatformPlugin -> {
-      publishing.publications.create<MavenPublication>("mavenJavaPlatform") {
-        from(components["javaPlatform"])
+plugins.withType(JavaPlugin::class).configureEach {
+  afterEvaluate {
+    if (!isKotlinMultiplatformJavaEnabled()) {
+      publishing.publications.create<MavenPublication>("mavenJava") {
+        from(components["java"])
+        artifact(tasks["sourcesJar"])
       }
     }
   }
 }
 
 
+plugins.withType(JavaPlatformPlugin::class).configureEach {
+  publishing.publications.create<MavenPublication>("mavenJavaPlatform") {
+    from(components["javaPlatform"])
+  }
+}
+
+
 fun MavenPublication.createKxTsGenPom(): Unit = pom {
   name.set("Kotlinx Serialization Typescript Generator")
   description.set("KxTsGen creates TypeScript interfaces from Kotlinx Serialization @Serializable classes")
@@ -122,7 +125,7 @@ fun MavenPublication.createKxTsGenPom(): Unit = pom {
   licenses {
     license {
       name.set("The Apache License, Version 2.0")
-      url.set("http://www.apache.org/licenses/LICENSE-2.0.txt")
+      url.set("https://www.apache.org/licenses/LICENSE-2.0.txt")
     }
   }
 
@@ -138,3 +141,14 @@ fun MavenPublication.createKxTsGenPom(): Unit = pom {
     url.set("https://github.com/adamko-dev/kotlinx-serialization-typescript-generator")
   }
 }
+
+
+/** Logic from [KotlinJvmTarget.withJava] */
+fun Project.isKotlinMultiplatformJavaEnabled(): Boolean {
+  val multiplatformExtension: KotlinMultiplatformExtension? =
+    extensions.findByType(KotlinMultiplatformExtension::class)
+
+  return multiplatformExtension?.targets
+    ?.any { it is KotlinJvmTarget && it.withJavaEnabled }
+    ?: false
+}

modules/kxs-ts-gen-core/build.gradle.kts

@@ -9,11 +9,6 @@ kotlin {
 
   js(IR) {
     binaries.executable()
-//    browser {
-//      commonWebpackConfig {
-//        cssSupport.enabled = true
-//      }
-//    }
     nodejs()
   }
 
@@ -72,10 +67,13 @@ kotlin {
         implementation(libs.okio.core)
       }
     }
+
 //    val nativeMain by getting
 //    val nativeTest by getting
+
     val jsMain by getting
     val jsTest by getting
+
     val jvmMain by getting {
       dependencies {
         implementation(project.dependencies.platform(projects.modules.versionsPlatform))
@@ -91,18 +89,3 @@ kotlin {
     }
   }
 }
-
-//
-//val javadocJar by tasks.creating(Jar::class) {
-//  group = JavaBasePlugin.DOCUMENTATION_GROUP
-//  description = "Assembles java doc to jar"
-//  archiveClassifier.set("javadoc")
-//  from(tasks.javadoc)
-//}
-//
-
-//publishing {
-//  publications.withType<MavenPublication>().configureEach {
-////    artifact(javadocJar)
-//  }
-//}

modules/kxs-ts-gen-processor/build.gradle.kts

@@ -23,7 +23,8 @@ dependencies {
   testImplementation(kotlin("test"))
 }
 
-tasks.withType<KotlinCompile> {
+
+tasks.withType<KotlinCompile>().configureEach {
   kotlinOptions.freeCompilerArgs += listOf(
     "-opt-in=kotlinx.serialization.ExperimentalSerializationApi",
   )