Modularize build with convention plugins and per-project files

Author: jupblb

build-logic/build.gradle.kts

@@ -0,0 +1,16 @@
+import org.gradle.plugin.use.PluginDependency
+
+plugins {
+    `kotlin-dsl`
+}
+
+dependencies {
+    implementation(plugin(libs.plugins.kotlin.jvm))
+    implementation(plugin(libs.plugins.shadow))
+    implementation(plugin(libs.plugins.vanniktech.maven.publish))
+}
+
+// Maps a version-catalog plugin alias to its plugin-marker dependency so the
+// external plugin can be applied by id from the precompiled convention plugins.
+fun plugin(dependency: Provider<PluginDependency>): Provider<String> =
+    dependency.map { "${it.pluginId}:${it.pluginId}.gradle.plugin:${it.version}" }

build-logic/settings.gradle.kts

@@ -0,0 +1,13 @@
+dependencyResolutionManagement {
+    repositories {
+        gradlePluginPortal()
+        mavenCentral()
+    }
+    versionCatalogs {
+        create("libs") {
+            from(files("../gradle/libs.versions.toml"))
+        }
+    }
+}
+
+rootProject.name = "build-logic"

build-logic/src/main/kotlin/com/sourcegraph/buildlogic/JavacInternals.kt

@@ -0,0 +1,22 @@
+package com.sourcegraph.buildlogic
+
+import java.io.File
+import java.util.Properties
+
+/**
+ * Reads the JVM flags scip-javac needs to access internal javac APIs on Java 9+,
+ * keeping gradle/javac-internals.properties the single source of truth.
+ */
+object JavacInternals {
+    fun propertiesFile(rootDir: File): File = rootDir.resolve("gradle/javac-internals.properties")
+
+    fun jvmOptions(rootDir: File): List<String> {
+        val file = propertiesFile(rootDir)
+        val raw =
+            Properties()
+                .apply { file.inputStream().use { load(it) } }
+                .getProperty("javac.jvmOptions")
+                ?: error("Missing javac.jvmOptions in $file")
+        return raw.split(',').map { it.trim() }.filter { it.isNotEmpty() }
+    }
+}

build-logic/src/main/kotlin/com/sourcegraph/buildlogic/SharedArtifacts.kt

@@ -0,0 +1,23 @@
+package com.sourcegraph.buildlogic
+
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration
+
+/**
+ * Declares a resolvable view of another project's shaded jar, published by its
+ * `shadowJarElements` consumable configuration (the `scip.shadow-producer`
+ * convention plugin).
+ *
+ * Returns a [Configuration] (a `FileCollection`) that resolves to the single
+ * shaded jar and carries the task dependency on the producing `shadowJar`.
+ * Sharing the artifact this way, instead of referencing the task across
+ * projects, keeps project evaluation order and the configuration cache intact.
+ */
+fun Project.shadowJarArtifact(producerPath: String, name: String): Configuration {
+    val bucket = configurations.dependencyScope("${name}Classpath")
+    dependencies.add(
+        bucket.name,
+        dependencies.project(mapOf("path" to producerPath, "configuration" to "shadowJarElements")),
+    )
+    return configurations.resolvable(name) { extendsFrom(bucket.get()) }.get()
+}

build-logic/src/main/kotlin/scip.java-base.gradle.kts

@@ -0,0 +1,32 @@
+import org.gradle.api.artifacts.VersionCatalogsExtension
+
+plugins {
+    id("scip.project-base")
+    java
+}
+
+val libs = extensions.getByType<VersionCatalogsExtension>().named("libs")
+
+tasks.withType<JavaCompile>().configureEach {
+    options.encoding = "UTF-8"
+    options.release.set(17)
+}
+
+tasks.withType<Javadoc>().configureEach {
+    options.encoding = "UTF-8"
+    (options as StandardJavadocDocletOptions).addStringOption("Xdoclint:none", "-quiet")
+}
+
+testing {
+    suites {
+        named<JvmTestSuite>("test") {
+            useJUnitJupiter(libs.findVersion("junit-jupiter").get().requiredVersion)
+        }
+    }
+}
+
+tasks.withType<Test>().configureEach {
+    testLogging {
+        events("failed", "skipped")
+    }
+}

build-logic/src/main/kotlin/scip.java-library.gradle.kts

@@ -0,0 +1,4 @@
+plugins {
+    id("scip.java-base")
+    `java-library`
+}

build-logic/src/main/kotlin/scip.kotlin-jvm.gradle.kts

@@ -0,0 +1,10 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+    id("org.jetbrains.kotlin.jvm")
+}
+
+tasks.withType<KotlinCompile>().configureEach {
+    compilerOptions.jvmTarget.set(JvmTarget.JVM_17)
+}

build-logic/src/main/kotlin/scip.maven-publish.gradle.kts

@@ -0,0 +1,34 @@
+import com.vanniktech.maven.publish.MavenPublishBaseExtension
+
+plugins {
+    id("com.vanniktech.maven.publish")
+}
+
+extensions.configure<MavenPublishBaseExtension>("mavenPublishing") {
+    val repositoryUrl = "https://github.com/sourcegraph/scip-java"
+    publishToMavenCentral()
+    signAllPublications()
+
+    pom {
+        name.set(project.name)
+        description.set(provider { project.description ?: project.name })
+        url.set(repositoryUrl)
+        licenses {
+            license {
+                name.set("Apache-2.0")
+                url.set("http://www.apache.org/licenses/LICENSE-2.0")
+            }
+        }
+        developers {
+            developer {
+                id.set("sourcegraph")
+                name.set("Sourcegraph")
+            }
+        }
+        scm {
+            connection.set("scm:git:$repositoryUrl.git")
+            developerConnection.set("scm:git:ssh://git@github.com/sourcegraph/scip-java.git")
+            url.set(repositoryUrl)
+        }
+    }
+}

build-logic/src/main/kotlin/scip.project-base.gradle.kts

@@ -0,0 +1,9 @@
+group = "com.sourcegraph"
+version = providers.gradleProperty("releaseVersion").orElse("0.0.0-SNAPSHOT").get()
+
+// Several modules also have Bazel `BUILD` files. On the default macOS
+// case-insensitive filesystem, Gradle's default `build/` directory collides
+// with those files, so keep Gradle outputs under the already-ignored target/.
+if (layout.projectDirectory.file("BUILD").asFile.isFile) {
+    layout.buildDirectory.set(layout.projectDirectory.dir("target/gradle"))
+}

build-logic/src/main/kotlin/scip.shadow-producer.gradle.kts

@@ -0,0 +1,10 @@
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+
+plugins {
+    id("com.gradleup.shadow")
+}
+
+// Publish the shaded jar as a consumable artifact, resolved by consumers via
+// `shadowJarArtifact` (see SharedArtifacts.kt).
+val shadowJarElements = configurations.consumable("shadowJarElements").get()
+artifacts.add(shadowJarElements.name, tasks.named<ShadowJar>("shadowJar"))