Merge pull request #70 from SpineEventEngine/fix-dependency-on-compiler-gradle-api

alexander-yevsyukov · web-flow · commit ee0934727cfe · 2026-02-12T21:27:49.000Z
Fix dependencies of the `plugin-bundle` module
diff --git a/dependencies.md b/dependencies.md
diff --git a/gradle-plugins/build.gradle.kts b/gradle-plugins/build.gradle.kts
@@ -61,6 +61,7 @@ artifactMeta {
 }
 
 dependencies {
+    compileOnly(gradleKotlinDsl())
     implementation(Compiler.pluginLib)
     implementation(Compiler.params)
     implementation(ToolBase.jvmTools)
diff --git a/gradle-plugins/src/main/kotlin/io/spine/tools/core/jvm/gradle/plugins/CompilerConfigPlugin.kt b/gradle-plugins/src/main/kotlin/io/spine/tools/core/jvm/gradle/plugins/CompilerConfigPlugin.kt
@@ -29,7 +29,6 @@
 package io.spine.tools.core.jvm.gradle.plugins
 
 import io.spine.tools.compiler.gradle.api.CompilerSettings
-import io.spine.tools.compiler.gradle.api.Names.GRADLE_PLUGIN_ID
 import io.spine.tools.compiler.gradle.api.addUserClasspathDependency
 import io.spine.tools.compiler.gradle.api.compilerSettings
 import io.spine.tools.compiler.gradle.api.compilerWorkingDir
@@ -59,6 +58,8 @@ import org.gradle.api.provider.Provider
 import org.gradle.kotlin.dsl.register
 import org.gradle.kotlin.dsl.withType
 import io.spine.tools.compiler.plugin.Plugin as CompilerPlugin
+import io.spine.tools.compiler.gradle.plugin.Plugin as CompilerGradlePlugin
+import org.gradle.kotlin.dsl.apply
 
 /**
  * The plugin that configures the Spine Compiler for the associated project.
@@ -86,7 +87,9 @@ internal class CompilerConfigPlugin : Plugin<Project> {
         project.afterEvaluate {
             it.configureCompiler()
         }
-        project.pluginManager.apply(GRADLE_PLUGIN_ID)
+        // Apply the Compiler Gradle Plugin so that we can manipulate the compiler settings.
+        // We do not want the user to add it manually.
+        project.apply<CompilerGradlePlugin>()
     }
 
     companion object {
diff --git a/gradle-plugins/src/main/kotlin/io/spine/tools/core/jvm/gradle/plugins/CoreJvmPlugin.kt b/gradle-plugins/src/main/kotlin/io/spine/tools/core/jvm/gradle/plugins/CoreJvmPlugin.kt
@@ -26,6 +26,7 @@
 
 package io.spine.tools.core.jvm.gradle.plugins
 
+import com.google.protobuf.gradle.ProtobufPlugin
 import io.spine.string.simply
 import io.spine.tools.core.jvm.VersionHolder
 import io.spine.tools.core.jvm.gradle.CoreJvmOptions
@@ -39,6 +40,7 @@ import io.spine.tools.gradle.DslSpec
 import io.spine.tools.gradle.lib.LibraryPlugin
 import org.gradle.api.Plugin
 import org.gradle.api.Project
+import org.gradle.kotlin.dsl.apply
 
 /**
  * Spine Model Compiler for Java Gradle plugin.
@@ -76,8 +78,7 @@ public class CoreJvmPlugin : LibraryPlugin<CoreJvmOptions>(
 private fun Project.applyProtobufPlugin() {
     if (!pluginManager.hasPlugin(ProtobufGradlePlugin.id)) {
         // We carry the plugin as a runtime dependency of the fat JAR.
-        // So it will be available in the build classpath and found by the ID.
-        pluginManager.apply(ProtobufGradlePlugin.id)
+        project.apply<ProtobufPlugin>()
     }
 }
 
@@ -105,11 +106,11 @@ private fun Project.createAndApplyPlugins() {
         RoutingPlugin()
     )
     plugins.forEach {
-        apply(it)
+        doApply(it)
     }
 }
 
-private fun Project.apply(plugin: Plugin<Project>) {
+private fun Project.doApply(plugin: Plugin<Project>) {
     logger.debug { "Applying `${plugin.javaClass.name}` plugin." }
     plugin.apply(project)
 }
diff --git a/plugin-bundle/build.gradle.kts b/plugin-bundle/build.gradle.kts
@@ -204,6 +204,57 @@ publishing {
                     excludeGroup(it, "io.spine.tools")
                 }
 
+                /*
+                 * Add the dependency onto `io.spine.tools:compiler-gradle-plugin`,
+                 * so that CoreJvm Gradle Plugin can add it to a project.
+                 */
+                val compilerGradlePlugin = Node(dependencies, "dependency")
+                compilerGradlePlugin.let {
+                    Node(it, "groupId", "io.spine.tools")
+                    Node(it, "artifactId", "compiler-gradle-plugin")
+                    Node(it, "version", Compiler.version)
+                    Node(it, "scope", "runtime")
+                }
+                Node(compilerGradlePlugin, "exclusions").let {
+                    excludeGroup(it, "org.jetbrains.kotlin")
+                    excludeGroup(it, "com.google.protobuf")
+                    excludeGroup(it, "io.spine.tools")
+                }
+
+                /*
+                 * Add the dependency onto `io.spine.tools:compiler-gradle-api`,
+                 * so that CoreJvm Gradle Plugin can add it to a project.
+                 */
+                val compilerGradleApi = Node(dependencies, "dependency")
+                compilerGradleApi.let {
+                    Node(it, "groupId", "io.spine.tools")
+                    Node(it, "artifactId", "compiler-gradle-api")
+                    Node(it, "version", Compiler.version)
+                    Node(it, "scope", "runtime")
+                }
+                Node(compilerGradleApi, "exclusions").let {
+                    excludeGroup(it, "org.jetbrains.kotlin")
+                    excludeGroup(it, "com.google.protobuf")
+                    excludeGroup(it, "io.spine.tools")
+                }
+
+                /*
+                 * Add the dependency onto `io.spine.tools:compiler-params`,
+                 * so that it is available in the classpath.
+                 */
+                val compilerParams = Node(dependencies, "dependency")
+                compilerParams.let {
+                    Node(it, "groupId", "io.spine.tools")
+                    Node(it, "artifactId", "compiler-params")
+                    Node(it, "version", Compiler.version)
+                    Node(it, "scope", "runtime")
+                }
+                Node(compilerParams, "exclusions").let {
+                    excludeGroup(it, "org.jetbrains.kotlin")
+                    excludeGroup(it, "com.google.protobuf")
+                    excludeGroup(it, "io.spine.tools")
+                }
+
                 /*
                  * Add the dependency on Protobuf Gradle Plugin so that we can add it
                  * from our code. The code in `pom.xml` would look like this:
@@ -224,7 +275,7 @@ publishing {
                 }
 
                 /*
-                 * Add the dependency on Protobuf Java library so that we can add it
+                 * Add the dependency on the Protobuf Java library so that we can add it
                  * from our code. The code in `pom.xml` would look like this:
                  * ```
                  * <dependency>
@@ -242,6 +293,27 @@ publishing {
                     Node(it, "scope", "runtime")
                 }
 
+                /*
+                 * Add the dependency on the Protobuf Java Util library because it is
+                 * used from the `compiler-params` module. Since we exclude the dependencies
+                 * on Protobuf, we need to add the Util library manually.
+                 *  The code in `pom.xml` would look like this:
+                 * ```
+                 * <dependency>
+                 *     <groupId>com.google.protobuf</groupId>
+                 *     <artifactId>protobuf-java-util</artifactId>
+                 *     <version>${Protobuf.version}</version>
+                 *     <scope>runtime</scope>
+                 * </dependency>
+                 * ```
+                 */
+                Node(dependencies, "dependency").let {
+                    Node(it, "groupId", "com.google.protobuf")
+                    Node(it, "artifactId", "protobuf-java-util")
+                    Node(it, "version", Protobuf.version)
+                    Node(it, "scope", "runtime")
+                }
+
                 /*
                  * Add the dependency on Protobuf Kotlin library so that we can add it
                  * from our code. The code in `pom.xml` would look like this:
diff --git a/pom.xml b/pom.xml
@@ -10,7 +10,7 @@ all modules and does not describe the project structure per-subproject.
  -->
 <groupId>io.spine.tools</groupId>
 <artifactId>core-jvm-compiler</artifactId>
-<version>2.0.0-SNAPSHOT.051</version>
+<version>2.0.0-SNAPSHOT.052</version>
 
 <inceptionYear>2015</inceptionYear>
 
diff --git a/tests/build.gradle.kts b/tests/build.gradle.kts
@@ -65,8 +65,6 @@ buildscript {
         classpath(io.spine.dependency.build.ErrorProne.GradlePlugin.lib) {
             exclude(group = "com.google.guava")
         }
-        classpath(compiler.pluginLib)
-        classpath(io.spine.dependency.local.Compiler.pluginLib)
         classpath(io.spine.dependency.local.CoreJvmCompiler.pluginLibNew(coreJvmCompilerVersion))
         classpath(enforcedPlatform(io.spine.dependency.kotlinx.Coroutines.bom))
         classpath(enforcedPlatform(io.spine.dependency.lib.Grpc.bom))
diff --git a/version.gradle.kts b/version.gradle.kts
@@ -29,5 +29,5 @@
  *
  * Do not rename this property, as it is also used in the integration tests via its name.
  */
-val coreJvmCompilerVersion by extra("2.0.0-SNAPSHOT.051")
+val coreJvmCompilerVersion by extra("2.0.0-SNAPSHOT.052")
 val versionToPublish by extra(coreJvmCompilerVersion)

Original file line number	Diff line number	Diff line change
`@@ -61,6 +61,7 @@ artifactMeta {`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`dependencies {`
	`64`	`+ compileOnly(gradleKotlinDsl())`
`64`	`65`	`implementation(Compiler.pluginLib)`
`65`	`66`	`implementation(Compiler.params)`
`66`	`67`	`implementation(ToolBase.jvmTools)`
Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,7 @@`
`26`	`26`
`27`	`27`	`package io.spine.tools.core.jvm.gradle.plugins`
`28`	`28`
	`29`	`+import com.google.protobuf.gradle.ProtobufPlugin`
`29`	`30`	`import io.spine.string.simply`
`30`	`31`	`import io.spine.tools.core.jvm.VersionHolder`
`31`	`32`	`import io.spine.tools.core.jvm.gradle.CoreJvmOptions`
`@@ -39,6 +40,7 @@ import io.spine.tools.gradle.DslSpec`
`39`	`40`	`import io.spine.tools.gradle.lib.LibraryPlugin`
`40`	`41`	`import org.gradle.api.Plugin`
`41`	`42`	`import org.gradle.api.Project`
	`43`	`+import org.gradle.kotlin.dsl.apply`
`42`	`44`
`43`	`45`	`/**`
`44`	`46`	`* Spine Model Compiler for Java Gradle plugin.`
`@@ -76,8 +78,7 @@ public class CoreJvmPlugin : LibraryPlugin<CoreJvmOptions>(`
`76`	`78`	`private fun Project.applyProtobufPlugin() {`
`77`	`79`	`if (!pluginManager.hasPlugin(ProtobufGradlePlugin.id)) {`
`78`	`80`	`// We carry the plugin as a runtime dependency of the fat JAR.`
`79`		`- // So it will be available in the build classpath and found by the ID.`
`80`		`- pluginManager.apply(ProtobufGradlePlugin.id)`
	`81`	`+ project.apply<ProtobufPlugin>()`
`81`	`82`	`}`
`82`	`83`	`}`
`83`	`84`
`@@ -105,11 +106,11 @@ private fun Project.createAndApplyPlugins() {`
`105`	`106`	`RoutingPlugin()`
`106`	`107`	`)`
`107`	`108`	`plugins.forEach {`
`108`		`- apply(it)`
	`109`	`+ doApply(it)`
`109`	`110`	`}`
`110`	`111`	`}`
`111`	`112`
`112`		`-private fun Project.apply(plugin: Plugin<Project>) {`
	`113`	`+private fun Project.doApply(plugin: Plugin<Project>) {`
`113`	`114`	logger.debug { "Applying `${plugin.javaClass.name}` plugin." }
`114`	`115`	`plugin.apply(project)`
`115`	`116`	`}`
Original file line number	Diff line number	Diff line change
`@@ -65,8 +65,6 @@ buildscript {`
`65`	`65`	`classpath(io.spine.dependency.build.ErrorProne.GradlePlugin.lib) {`
`66`	`66`	`exclude(group = "com.google.guava")`
`67`	`67`	`}`
`68`		`- classpath(compiler.pluginLib)`
`69`		`- classpath(io.spine.dependency.local.Compiler.pluginLib)`
`70`	`68`	`classpath(io.spine.dependency.local.CoreJvmCompiler.pluginLibNew(coreJvmCompilerVersion))`
`71`	`69`	`classpath(enforcedPlatform(io.spine.dependency.kotlinx.Coroutines.bom))`
`72`	`70`	`classpath(enforcedPlatform(io.spine.dependency.lib.Grpc.bom))`
Original file line number	Diff line number	Diff line change
`@@ -29,5 +29,5 @@`
`29`	`29`	`*`
`30`	`30`	`* Do not rename this property, as it is also used in the integration tests via its name.`
`31`	`31`	`*/`
`32`		`-val coreJvmCompilerVersion by extra("2.0.0-SNAPSHOT.051")`
	`32`	`+val coreJvmCompilerVersion by extra("2.0.0-SNAPSHOT.052")`
`33`	`33`	`val versionToPublish by extra(coreJvmCompilerVersion)`