build: style-gate build-logic with ktlint, pin its toolchain, and guard the publication on the kotlin-jvm plugin

Author: OmarAlJarrah

build-logic/build.gradle.kts

@@ -12,9 +12,37 @@
 // classpath.
 plugins {
     `kotlin-dsl`
+    // Style-gate this included build's own scripts. `build-logic` is a separate build with its
+    // own settings, so the root build's `subprojects { ktlint }` block does not reach it; without
+    // this the convention-plugin `.kts` files would escape the repository's Kotlin style checks.
+    // The version is pinned literally (not via the version catalog) to keep this build catalog-free
+    // — see the rationale in `settings.gradle.kts`; it must match `ktlint-plugin` in
+    // `gradle/libs.versions.toml`.
+    id("org.jlleitschuh.gradle.ktlint") version "12.1.1"
 }
 
 repositories {
     mavenCentral()
     gradlePluginPortal()
 }
+
+// Pin the toolchain so this included build compiles reproducibly regardless of the JDK running
+// the Gradle daemon. This is plugin code for the build JVM, not shipped bytecode, so the version
+// only needs to be recent enough for `kotlin-dsl`.
+kotlin {
+    jvmToolchain(21)
+}
+
+ktlint {
+    ignoreFailures.set(false)
+}
+
+// `kotlin-dsl` adds its plugin wrappers and DSL accessors (under build/generated-sources) to the
+// `main` Kotlin source set, so the source-set ktlint tasks would otherwise lint tool-generated
+// code. Drop the generated tree from those tasks' inputs; the hand-written convention scripts under
+// src/ — and the build script via `runKtlintCheckOverKotlinScripts` — are still checked.
+val generatedSourcesDir = layout.buildDirectory.dir("generated-sources").get().asFile
+tasks.withType<org.jlleitschuh.gradle.ktlint.tasks.BaseKtLintCheckTask>().configureEach {
+    val handWritten = source.filter { file -> !file.startsWith(generatedSourcesDir) }.files
+    setSource(handWritten)
+}

build-logic/src/main/kotlin/dexpace.published-module.gradle.kts

@@ -23,54 +23,65 @@ plugins {
 
 // Coordinates. The group and version are the same for every published module and match the
 // values declared on the root project; keeping the single literal here makes a coordinate
-// change a one-file edit instead of a nine-file edit.
+// change a one-file edit instead of a nine-file edit. The root `build.gradle.kts` still declares
+// its own `group`/`version`, so a version bump must update both literals until they are sourced
+// from one place (e.g. a `gradle.properties` entry read by both).
 group = "org.dexpace"
 version = "0.0.1-alpha.1"
 
-publishing {
-    publications {
-        create<MavenPublication>("library") {
-            from(components["java"])
-            pom {
-                name.set(project.name)
-                description.set("Dexpace Java SDK — ${project.name}")
-                url.set("https://github.com/dexpace/java-sdk")
-                licenses {
-                    license {
-                        name.set("MIT License")
-                        url.set("https://github.com/dexpace/java-sdk/blob/main/LICENSE")
-                        distribution.set("repo")
+// The `library` publication is built from the `java` software component, which only exists once a
+// `java`/`java-library`/`kotlin("jvm")` plugin is applied. Every current consumer applies
+// `kotlin("jvm")`, but this plugin neither applies nor requires one, so the whole publication +
+// signing setup is guarded on the Kotlin JVM plugin. Without the guard, a module that opted in
+// without a Java/Kotlin plugin would fail with an opaque "SoftwareComponent with name java not
+// found".
+pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
+    publishing {
+        publications {
+            create<MavenPublication>("library") {
+                from(components["java"])
+                pom {
+                    name.set(project.name)
+                    description.set("Dexpace Java SDK — ${project.name}")
+                    url.set("https://github.com/dexpace/java-sdk")
+                    licenses {
+                        license {
+                            name.set("MIT License")
+                            url.set("https://github.com/dexpace/java-sdk/blob/main/LICENSE")
+                            distribution.set("repo")
+                        }
                     }
-                }
-                developers {
-                    developer {
-                        id.set("dexpace")
-                        name.set("Dexpace SDK Team")
+                    developers {
+                        developer {
+                            id.set("dexpace")
+                            name.set("Dexpace SDK Team")
+                        }
+                    }
+                    scm {
+                        connection.set("scm:git:https://github.com/dexpace/java-sdk.git")
+                        developerConnection.set("scm:git:ssh://github.com/dexpace/java-sdk.git")
+                        url.set("https://github.com/dexpace/java-sdk")
                     }
-                }
-                scm {
-                    connection.set("scm:git:https://github.com/dexpace/java-sdk.git")
-                    developerConnection.set("scm:git:ssh://github.com/dexpace/java-sdk.git")
-                    url.set("https://github.com/dexpace/java-sdk")
                 }
             }
         }
-    }
-    repositories {
-        // Local staging repository. CI must override this to publish to a real remote.
-        maven {
-            name = "local"
-            url = uri(rootProject.layout.buildDirectory.dir("staging-repo"))
+        repositories {
+            // Local staging repository. CI must override this to publish to a real remote.
+            maven {
+                name = "local"
+                url = uri(rootProject.layout.buildDirectory.dir("staging-repo"))
+            }
         }
     }
-}
 
-signing {
-    isRequired = (System.getenv("CI") == "true")
-    val signingKey = project.findProperty("signing.key") as String? ?: System.getenv("SIGNING_KEY")
-    val signingPassword = project.findProperty("signing.password") as String? ?: System.getenv("SIGNING_PASSWORD")
-    if (!signingKey.isNullOrBlank() && !signingPassword.isNullOrBlank()) {
-        useInMemoryPgpKeys(signingKey, signingPassword)
+    signing {
+        isRequired = (System.getenv("CI") == "true")
+        val signingKey = project.findProperty("signing.key") as String? ?: System.getenv("SIGNING_KEY")
+        val signingPassword =
+            project.findProperty("signing.password") as String? ?: System.getenv("SIGNING_PASSWORD")
+        if (!signingKey.isNullOrBlank() && !signingPassword.isNullOrBlank()) {
+            useInMemoryPgpKeys(signingKey, signingPassword)
+        }
+        sign(publishing.publications["library"])
     }
-    sign(publishing.publications["library"])
 }