Prototype migration of dependencies to a published Version Catalog

.github/workflows/build-on-ubuntu.yml

@@ -18,6 +18,10 @@ jobs:
       - name: Pull config
         run: git submodule update --init --recursive
 
+      - name: Prepare a version catalog in Maven local
+        shell: bash
+        run: cd version-catalog && ./gradlew publishToMavenLocal
+
       - name: Build project and run tests
         shell: bash
         run: ./gradlew build --stacktrace

.github/workflows/build-on-windows.yml

@@ -18,6 +18,10 @@ jobs:
       - name: Pull config
         run: git submodule update --init --recursive
 
+      - name: Prepare a version catalog in Maven local
+        shell: bash
+        run: cd version-catalog && ./gradlew publishToMavenLocal
+
       - name: Build project and run tests
         shell: cmd
         # For the reason on `--no-daemon` see https://github.com/actions/cache/issues/454

.github/workflows/increment-guard.yml

@@ -24,6 +24,10 @@ jobs:
       - name: Pull config
         run: git submodule update --init --recursive
 
+      - name: Prepare a version catalog in Maven local
+        shell: bash
+        run: cd version-catalog && ./gradlew publishToMavenLocal
+
       - name: Check version is not yet published
         shell: bash
         run: ./gradlew checkVersionIncrement --stacktrace

build.gradle.kts

@@ -31,9 +31,6 @@ import com.google.protobuf.gradle.generateProtoTasks
 import com.google.protobuf.gradle.id
 import com.google.protobuf.gradle.protobuf
 import com.google.protobuf.gradle.protoc
-import io.spine.internal.dependency.ErrorProne
-import io.spine.internal.dependency.JUnit
-import io.spine.internal.dependency.Protobuf
 import io.spine.internal.gradle.publish.PublishingRepos
 import io.spine.internal.gradle.applyGitHubPackages
 import io.spine.internal.gradle.applyStandard
@@ -52,12 +49,19 @@ import io.spine.internal.gradle.test.registerTestTasks
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 buildscript {
-    apply(from = "$rootDir/version.gradle.kts")
-
     io.spine.internal.gradle.doApplyStandard(repositories)
-    io.spine.internal.gradle.doForceVersions(configurations)
+    io.spine.internal.gradle.doForceVersions(configurations, libs)
+
+    /*
+     Due to a bug, we can't apply scripts.
+
+     `version.gradle.kts` file is not applied, thus the version of mcJava is
+     declared right here.
 
-    val mcJavaVersion: String by extra
+     See issue: https://github.com/gradle/gradle/issues/20717
+     */
+
+    val mcJavaVersion = "2.0.0-SNAPSHOT.83"
     dependencies {
         classpath("io.spine.tools:spine-mc-java:$mcJavaVersion")
     }
@@ -75,8 +79,20 @@ plugins {
     idea
     `project-report`
 
-    id(io.spine.internal.dependency.Protobuf.GradlePlugin.id)
-    id(io.spine.internal.dependency.ErrorProne.GradlePlugin.id)
+    /*
+     As for now, Gradle doesn't provide API for applying plugins without version.
+     This is why we resolve a provider by `get()`.
+
+     See a feature request: https://github.com/gradle/gradle/issues/17968
+
+     Also, for these two lines below, IDEA reports a false-positive error.
+
+     See issue in Gradle: https://github.com/gradle/gradle/issues/20839
+     See issue in IDEA: https://youtrack.jetbrains.com/issue/KTIJ-19369/False-positive-can-t-be-called-in-this-context-by-implicit-recei
+     */
+
+    id(libs.plugins.protobuf.get().pluginId)
+    id(libs.plugins.errorProne.get().pluginId)
 }
 
 spinePublishing {
@@ -91,27 +107,39 @@ spinePublishing {
             cloudArtifactRegistry
         )
     }
-
     dokkaJar {
         enabled = true
     }
 }
 
 allprojects {
-    apply(from = "$rootDir/version.gradle.kts")
+
+    /*
+     Due to a bug, we can't apply scripts.
+
+     `version.gradle.kts` file is not applied, thus the versions of spine libs
+     are declared right here.
+
+     See issue: https://github.com/gradle/gradle/issues/20717
+     */
+
+    /** Versions of the Spine libraries that `time` depends on. */
+    extra["spineBaseVersion"] = "2.0.0-SNAPSHOT.91"
+    extra["javadocToolsVersion"] = "2.0.0-SNAPSHOT.75"
+
+    /** The version of this library. */
+    val versionToPublish by extra("2.0.0-SNAPSHOT.93")
 
     group = "io.spine"
-    version = extra["versionToPublish"]!!
+    version = versionToPublish
 }
 
 subprojects {
-
     apply {
         plugin("java-library")
         plugin("kotlin")
         plugin("com.google.protobuf")
         plugin("net.ltgt.errorprone")
-        plugin("pmd")
         plugin("checkstyle")
         plugin("idea")
         plugin("pmd-settings")
@@ -126,19 +154,28 @@ subprojects {
 
     val spineBaseVersion: String by extra
     dependencies {
-        errorprone(ErrorProne.core)
+
+        /*
+         Gradle discourages cross-configuration of projects.
+         Thus, the direct access to `libs` in `allprojects` and `subprojects`
+         blocks is unavailable. But we still can use it from `rootProject`.
+
+         See the closed issue: https://github.com/gradle/gradle/issues/16634
+         */
+
+        errorprone(rootProject.libs.errorProne.core)
         api(kotlin("stdlib-jdk8"))
 
         testImplementation("io.spine.tools:spine-testlib:$spineBaseVersion")
-        testImplementation(JUnit.runner)
+        testImplementation(rootProject.libs.jUnit.runner)
     }
 
     /**
      * Force Error Prone dependencies to `2.10.0`, because in `2.11.0` an empty constructor in
      * [com.google.errorprone.bugpatterns.CheckReturnValue] was removed leading to breaking the API.
      */
     configurations {
-        forceVersions()
+        forceVersions(rootProject.libs)
         all {
             resolutionStrategy {
                 force(
@@ -199,7 +236,7 @@ subprojects {
     protobuf {
         generatedFilesBaseDir = generatedRootDir
         protoc {
-            artifact = Protobuf.compiler
+            artifact = rootProject.libs.protobuf.compiler.get().toString()
         }
         generateProtoTasks {
             all().forEach { task ->
@@ -218,7 +255,7 @@ subprojects {
         rootFolder.set(rootDir)
     }
 
-    // Apply the same IDEA module configuration for each of sub-projects.
+    // Apply the same IDEA module configuration for each of subprojects.
     idea {
         module {
             with(generatedSourceDirs) {

buildSrc/build.gradle.kts

@@ -24,19 +24,11 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/**
- * This script uses two declarations of the constant [licenseReportVersion] because
- * currently there is no way to define a constant _before_ a build script of `buildSrc`.
- * We cannot use imports or do something else before the `buildscript` or `plugin` clauses.
- */
-
 plugins {
     java
     groovy
     `kotlin-dsl`
     pmd
-    val licenseReportVersion = "2.1"
-    id("com.github.jk1.dependency-license-report").version(licenseReportVersion)
 }
 
 repositories {
@@ -45,105 +37,70 @@ repositories {
     mavenCentral()
 }
 
-/**
- * The version of Jackson used by `buildSrc`.
- *
- * Please keep this value in sync. with `io.spine.internal.dependency.Jackson.version`.
- * It's not a requirement, but would be good in terms of consistency.
- */
-val jacksonVersion = "2.13.0"
-
-val googleAuthToolVersion = "2.1.2"
-val licenseReportVersion = "2.1"
-val grGitVersion = "3.1.1"
-
-/**
- * The version of the Kotlin Gradle plugin.
- *
- * Please check that this value matches one defined in
- *  [io.spine.internal.dependency.Kotlin.version].
- */
-val kotlinVersion = "1.6.21"
-
-/**
- * The version of Guava used in `buildSrc`.
- *
- * Always use the same version as the one specified in [io.spine.internal.dependency.Guava].
- * Otherwise, when testing Gradle plugins, clashes may occur.
- */
-val guavaVersion = "31.1-jre"
-
-/**
- * The version of ErrorProne Gradle plugin.
- *
- * Please keep in sync. with [io.spine.internal.dependency.ErrorProne.GradlePlugin.version].
- *
- * @see <a href="https://github.com/tbroyer/gradle-errorprone-plugin/releases">
- *     Error Prone Gradle Plugin Releases</a>
- */
-val errorProneVersion = "2.0.2"
-
-/**
- * The version of Protobuf Gradle Plugin.
- *
- * Please keep in sync. with [io.spine.internal.dependency.Protobuf.GradlePlugin.version].
- *
- * @see <a href="https://github.com/google/protobuf-gradle-plugin/releases">
- *     Protobuf Gradle Plugins Releases</a>
- */
-val protobufPluginVersion = "0.8.18"
-
-/**
- * The version of Dokka Gradle Plugins.
- *
- * Please keep in sync with [io.spine.internal.dependency.Dokka.version].
- *
- * @see <a href="https://github.com/Kotlin/dokka/releases">
- *     Dokka Releases</a>
- */
-val dokkaVersion = "1.6.20"
+// Let's get rid of warnings about different Kotlin version on the classpath.
+// Also, builds are more reproducible when dynamic version resolution is suppressed.
 
 configurations.all {
     resolutionStrategy {
-        // Force Kotlin lib versions avoiding using those bundled with Gradle.
+        failOnVersionConflict()
         force(
-            "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion",
-            "org.jetbrains.kotlin:kotlin-stdlib-common:$kotlinVersion",
-            "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlinVersion",
-            "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlinVersion",
-            "org.jetbrains.kotlin:kotlin-reflect:$kotlinVersion"
+            libs.apacheHttp.core,
+            libs.guava,
+            libs.httpClient.google,
+            libs.jackson.core,
+            libs.jackson.databind,
+            libs.jackson.dataformatXml,
+            libs.jackson.moduleKotlin,
+            libs.kotlin.reflect,
+            libs.kotlin.stdLib,
+            libs.kotlin.stdLib.common,
+            libs.kotlin.stdLib.jdk8,
+            libs.kotlinX.coroutines.core,
+            libs.kotlinX.coroutines.core.jvm,
+            libs.slf4J.api,
         )
     }
 }
 
-val jvmVersion = JavaLanguageVersion.of(11)
-
-java {
-    toolchain.languageVersion.set(jvmVersion)
-}
-
-tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
-    kotlinOptions {
-        jvmTarget = jvmVersion.toString()
-    }
-}
-
 dependencies {
-    implementation("com.fasterxml.jackson.core:jackson-databind:$jacksonVersion")
-    implementation("com.fasterxml.jackson.dataformat:jackson-dataformat-xml:$jacksonVersion")
-    implementation("com.google.cloud.artifactregistry:artifactregistry-auth-common:$googleAuthToolVersion") {
-        exclude(group = "com.google.guava")
-    }
-    implementation("com.google.guava:guava:$guavaVersion")
-    api("com.github.jk1:gradle-license-report:$licenseReportVersion")
-    implementation("org.ajoberstar.grgit:grgit-core:${grGitVersion}")
-    implementation("net.ltgt.gradle:gradle-errorprone-plugin:${errorProneVersion}")
 
-    // Add explicit dependency to avoid warning on different Kotlin runtime versions.
-    implementation("org.jetbrains.kotlin:kotlin-reflect:$kotlinVersion")
-    implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion")
-
-    implementation("gradle.plugin.com.google.protobuf:protobuf-gradle-plugin:$protobufPluginVersion")
-    implementation("org.jetbrains.dokka:dokka-gradle-plugin:${dokkaVersion}")
-    implementation("org.jetbrains.dokka:dokka-base:${dokkaVersion}")
+    /*
+     We add the implementation dependency on the class of `libs` extension
+     in order to make the generated `LibrariesForLibs` available in `main`
+     source set.
+
+     It does not mean our dependencies will be available in `main` sources.
+     It means we can fetch them in a type-safe manner from a `Project` instance,
+     in which this extension is registered.
+
+     For example:
+     val libs = project.extensions.getByType<LibrariesForLibs>()
+     */
+
+    implementation(files(libs.javaClass.superclass.protectionDomain.codeSource.location))
+
+    implementation(libs.errorProne.gradlePlugin)
+    implementation(libs.googleCloud.artifactRegistry.authCommon)
+    implementation(libs.grGit.core)
+    implementation(libs.guava)
+    implementation(libs.jackson.databind)
+    implementation(libs.jackson.dataformatXml)
+    implementation(libs.kotlin.gradlePlugin)
+    implementation(libs.licenseReport.gradlePlugin)
+    implementation(libs.protobuf.gradlePlugin)
+
+    /*
+     These guys below use a fat jar with Kotlin runtime inside. One more
+     Kotlin version. This is a reason for two warnings.
+
+     I'm not sure if we can just exclude those jars. It should be checked on
+     a repo where Dokka is used. And if not, leave a comment here, describing
+     why it is so.
+     */
+
+    implementation(libs.dokka.gradlePlugin)
+    implementation(libs.dokka.basePlugin) {
+        exclude("org.jetbrains.dokka", "kotlin-analysis-compiler")
+        exclude("org.jetbrains.dokka", "kotlin-analysis-intellij")
+    }
 }