using compile only

build.gradle.kts

@@ -6,7 +6,7 @@ plugins {
 }
 
 group = "io.github.cdsap"
-version = "0.2.0"
+version = "0.3.0-SNAPSHOT"
 
 java {
     toolchain {
@@ -18,7 +18,7 @@ dependencies {
     implementation("io.github.cdsap:jdk-tools-parser:0.1.1")
     implementation("io.github.cdsap:commandline-value-source:0.1.0")
     implementation("com.jakewharton.picnic:picnic:0.7.0")
-    implementation("com.gradle:develocity-gradle-plugin:4.2.2")
+    compileOnly("com.gradle:develocity-gradle-plugin:4.2.2")
     testImplementation("junit:junit:4.13.2")
 }
 tasks.withType<Test>().configureEach {

src/main/kotlin/io/github/cdsap/gradleprocess/Constants.kt

@@ -0,0 +1,7 @@
+package io.github.cdsap.gradleprocess
+
+class Constants {
+    companion object {
+        const val GRADLE_PROCESS_NAME = "GradleDaemon"
+    }
+}

src/main/kotlin/io/github/cdsap/gradleprocess/DevelocityWrapperConfiguration.kt

@@ -0,0 +1,47 @@
+package io.github.cdsap.gradleprocess
+
+import com.gradle.develocity.agent.gradle.DevelocityConfiguration
+import io.github.cdsap.gradleprocess.output.DevelocityValues
+import io.github.cdsap.jdk.tools.parser.ConsolidateProcesses
+import io.github.cdsap.jdk.tools.parser.model.Process
+import io.github.cdsap.jdk.tools.parser.model.TypeProcess
+import io.github.cdsap.valuesourceprocess.jInfo
+import io.github.cdsap.valuesourceprocess.jStat
+import org.gradle.api.Project
+import org.gradle.api.provider.Provider
+
+class DevelocityWrapperConfiguration {
+
+    fun configureProjectWithDevelocity(target: Project) {
+        val extension = target.extensions.findByType(DevelocityConfiguration::class.java) != null
+        if (extension) {
+            buildScanDevelocityReporting(target, target.extensions.findByType(DevelocityConfiguration::class.java)!!)
+        }
+    }
+
+    private fun buildScanDevelocityReporting(
+        project: Project,
+        buildScanExtension: DevelocityConfiguration
+    ) {
+        val (jStat, jInfo) = providerPair(project)
+
+        buildScanExtension.buildScan.buildFinished {
+            val processes = processes(jStat, jInfo)
+            DevelocityValues(buildScanExtension, processes).addProcessesInfoToBuildScan()
+        }
+    }
+
+    private fun processes(
+        jStat: Provider<String>,
+        jInfo: Provider<String>
+    ): List<Process> {
+        val processes = ConsolidateProcesses().consolidate(jStat.get(), jInfo.get(), TypeProcess.Kotlin)
+        return processes
+    }
+
+    private fun providerPair(project: Project): Pair<Provider<String>, Provider<String>> {
+        val jStat = project.jStat(Constants.GRADLE_PROCESS_NAME)
+        val jInfo = project.jInfo(Constants.GRADLE_PROCESS_NAME)
+        return Pair(jStat, jInfo)
+    }
+}

src/main/kotlin/io/github/cdsap/gradleprocess/InfoGradleProcessPlugin.kt

@@ -1,28 +1,26 @@
 package io.github.cdsap.gradleprocess
 
-import com.gradle.develocity.agent.gradle.DevelocityConfiguration
-import io.github.cdsap.gradleprocess.output.DevelocityValues
-import io.github.cdsap.jdk.tools.parser.ConsolidateProcesses
-import io.github.cdsap.jdk.tools.parser.model.Process
-import io.github.cdsap.jdk.tools.parser.model.TypeProcess
+import io.github.cdsap.gradleprocess.Constants.Companion.GRADLE_PROCESS_NAME
 import io.github.cdsap.valuesourceprocess.jInfo
 import io.github.cdsap.valuesourceprocess.jStat
 import org.gradle.api.Plugin
 import org.gradle.api.Project
-import org.gradle.api.provider.Provider
 import org.gradle.build.event.BuildEventsListenerRegistry
 import org.gradle.kotlin.dsl.support.serviceOf
 
 class InfoGradleProcessPlugin : Plugin<Project> {
-
-    private val nameProcess = "GradleDaemon"
     override fun apply(target: Project) {
-        target.gradle.rootProject {
 
-            val develocityConfiguration = extensions.findByType(DevelocityConfiguration::class.java)
+        target.rootProject.gradle.rootProject {
+            val hasDevelocity = try {
+                Class.forName("com.gradle.develocity.agent.gradle.DevelocityConfiguration")
+                true
+            } catch (_: ClassNotFoundException) {
+                false
+            }
 
-            if (develocityConfiguration != null) {
-                buildScanDevelocityReporting(project, develocityConfiguration)
+            if (hasDevelocity) {
+                DevelocityWrapperConfiguration().configureProjectWithDevelocity(target)
             } else {
                 consoleReporting(target)
             }
@@ -34,35 +32,10 @@ class InfoGradleProcessPlugin : Plugin<Project> {
         val service = project.gradle.sharedServices.registerIfAbsent(
             "gradleProcessService", InfoGradleProcessBuildService::class.java
         ) {
-            parameters.jInfoProvider = project.jInfo(nameProcess)
-            parameters.jStatProvider = project.jStat(nameProcess)
+            parameters.jInfoProvider = project.jInfo(GRADLE_PROCESS_NAME)
+            parameters.jStatProvider = project.jStat(GRADLE_PROCESS_NAME)
         }
         project.serviceOf<BuildEventsListenerRegistry>().onTaskCompletion(service)
     }
 
-    private fun buildScanDevelocityReporting(
-        project: Project,
-        buildScanExtension: DevelocityConfiguration
-    ) {
-        val (jStat, jInfo) = providerPair(project)
-
-        buildScanExtension.buildScan.buildFinished {
-            val processes = processes(jStat, jInfo)
-            DevelocityValues(buildScanExtension, processes).addProcessesInfoToBuildScan()
-        }
-    }
-
-    private fun processes(
-        jStat: Provider<String>,
-        jInfo: Provider<String>
-    ): List<Process> {
-        val processes = ConsolidateProcesses().consolidate(jStat.get(), jInfo.get(), TypeProcess.Kotlin)
-        return processes
-    }
-
-    private fun providerPair(project: Project): Pair<Provider<String>, Provider<String>> {
-        val jStat = project.jStat(nameProcess)
-        val jInfo = project.jInfo(nameProcess)
-        return Pair(jStat, jInfo)
-    }
 }

src/test/kotlin/io/github/cdsap/gradleprocess/InfoGradleProcessNoDVTest.kt

@@ -0,0 +1,94 @@
+package io.github.cdsap.gradleprocess
+
+import junit.framework.TestCase
+import org.gradle.testkit.runner.GradleRunner
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import kotlin.collections.forEach
+import kotlin.io.appendText
+import kotlin.text.contains
+import kotlin.text.trimIndent
+
+class InfoGradleProcessNoDVTest {
+
+    @Rule
+    @JvmField
+    val testProjectDir = TemporaryFolder()
+
+    @Test
+    fun testPluginIsCompatibleWithConfigurationCacheWithDevelocity() {
+
+        testProjectDir.newFile("settings.gradle").appendText(
+            """
+            """.trimIndent()
+        )
+        testProjectDir.newFile("build.gradle").appendText(
+            """
+                plugins {
+                    id 'org.jetbrains.kotlin.jvm' version '2.0.20'
+                    id 'application'
+                    id 'io.github.cdsap.gradleprocess'
+                }
+                repositories {
+                    mavenCentral()
+                }
+
+            """.trimIndent()
+        )
+        listOf("8.14.2", "9.1.0").forEach {
+            val firstBuild = GradleRunner.create()
+                .withProjectDir(testProjectDir.root)
+                .withArguments("compileKotlin", "--configuration-cache")
+                .withPluginClasspath()
+                .withGradleVersion(it)
+                .build()
+            val secondBuild = GradleRunner.create()
+                .withProjectDir(testProjectDir.root)
+                .withArguments("compileKotlin", "--configuration-cache")
+                .withPluginClasspath()
+                .withGradleVersion(it)
+                .build()
+            TestCase.assertTrue(firstBuild.output.contains("Configuration cache entry stored"))
+            TestCase.assertTrue(secondBuild.output.contains("Configuration cache entry reused."))
+        }
+    }
+
+    @Test
+    fun testPluginIsCompatibleWithProjectIsolation() {
+
+        testProjectDir.newFile("settings.gradle").appendText(
+            """
+            """.trimIndent()
+        )
+        testProjectDir.newFile("build.gradle").appendText(
+            """
+                plugins {
+                    id 'org.jetbrains.kotlin.jvm' version '2.0.20'
+                    id 'application'
+                    id 'io.github.cdsap.gradleprocess'
+                }
+                repositories {
+                    mavenCentral()
+                }
+
+            """.trimIndent()
+        )
+        listOf("8.14.3", "9.1.0").forEach {
+            val firstBuild = GradleRunner.create()
+                .withProjectDir(testProjectDir.root)
+                .withArguments("compileKotlin", "-Dorg.gradle.unsafe.isolated-projects=true")
+                .withPluginClasspath()
+                .withGradleVersion(it)
+                .build()
+            val secondBuild = GradleRunner.create()
+                .withProjectDir(testProjectDir.root)
+                .withArguments("compileKotlin", "-Dorg.gradle.unsafe.isolated-projects=true")
+                .withPluginClasspath()
+                .withGradleVersion(it)
+                .build()
+            TestCase.assertTrue(firstBuild.output.contains("Configuration cache entry stored"))
+            TestCase.assertTrue(secondBuild.output.contains("Configuration cache entry reused."))
+        }
+    }
+}

src/test/kotlin/io/github/cdsap/gradleprocess/InfoGradleProcessPluginTest.kt

@@ -10,14 +10,15 @@ import org.junit.rules.TemporaryFolder
 
 class InfoGradleProcessPluginTest {
 
-    private val gradleVersions = listOf("8.6", "8.7","8.12.1","8.14.2")
+    private val gradleVersions = listOf("8.14.2", "9.1.0")
 
     @Rule
     @JvmField
     val testProjectDir = TemporaryFolder()
 
     @Test
     fun testOutputIsGeneratedWhenPluginIsApplied() {
+        createSettingsGradle()
         createBuildGradle()
 
         gradleVersions.forEach {
@@ -29,6 +30,7 @@ class InfoGradleProcessPluginTest {
 
     @Test
     fun testPluginIsCompatibleWithConfigurationCacheWithoutGradleEnterprise() {
+        createSettingsGradle()
         createBuildGradle()
 
         gradleVersions.forEach {
@@ -60,7 +62,7 @@ class InfoGradleProcessPluginTest {
             org.gradle.jvmargs=-Xmx256m -Dfile.encoding=UTF-8
         """.trimIndent()
         )
-
+        createSettingsGradle()
         createBuildGradle()
 
         gradleVersions.forEach {
@@ -77,6 +79,7 @@ class InfoGradleProcessPluginTest {
             org.gradle.jvmargs=-Xmx600m
         """.trimIndent()
         )
+        createSettingsGradle()
         createBuildGradle()
 
         gradleVersions.forEach {
@@ -93,6 +96,7 @@ class InfoGradleProcessPluginTest {
             org.gradle.jvmargs=-Xmx750m -Dfile.encoding=UTF-8 -XX:+UseParallelGC
         """.trimIndent()
         )
+        createSettingsGradle()
         createBuildGradle()
 
         gradleVersions.forEach {
@@ -109,6 +113,7 @@ class InfoGradleProcessPluginTest {
             org.gradle.jvmargs=-Xmx512m -XX:+UseParallelGC -Dfile.encoding=UTF-8
         """.trimIndent()
         )
+        createSettingsGradle()
         createBuildGradle()
 
         gradleVersions.forEach {
@@ -126,6 +131,7 @@ class InfoGradleProcessPluginTest {
             org.gradle.jvmargs=-Xmx400m -XX:+UseParallelGC
         """.trimIndent()
         )
+        createSettingsGradle()
         createBuildGradle()
 
         gradleVersions.forEach {
@@ -157,7 +163,7 @@ class InfoGradleProcessPluginTest {
         testProjectDir.newFile("build.gradle").appendText(
             """
                     plugins {
-                        id 'org.jetbrains.kotlin.jvm' version '1.7.21'
+                        id 'org.jetbrains.kotlin.jvm' version '2.0.20'
                         id 'application'
                         id 'io.github.cdsap.gradleprocess'
                     }
@@ -168,4 +174,11 @@ class InfoGradleProcessPluginTest {
                 """.trimIndent()
         )
     }
+
+    private fun createSettingsGradle() {
+        testProjectDir.newFile("settings.gradle").appendText(
+            """
+            """.trimIndent()
+        )
+    }
 }

src/test/kotlin/io/github/cdsap/gradleprocess/InfoGradleProcessPluginWtihBuildScanTest.kt

@@ -21,13 +21,13 @@ class InfoGradleProcessPluginWtihBuildScanTest {
             System.getenv("GE_URL") != null && System.getenv("GE_API_KEY") != null
         )
 
-        testProjectDir.newFile("settings.gradle").appendText(
+        testProjectDir.newFile("settings.gradle.kts").appendText(
             """
                 plugins {
-                    id 'com.gradle.develocity' version '4.0.2'
+                    id("com.gradle.develocity") version("4.0.2")
                 }
                 develocity {
-                    server = "${System.getenv("GE_URL")}"
+                    server = "https://ge.solutions-team.gradle.com/"
                     accessKey="${System.getenv("GE_API_KEY")}"
                     buildScan {
                         publishing { true }
@@ -38,19 +38,20 @@ class InfoGradleProcessPluginWtihBuildScanTest {
         testProjectDir.newFile("build.gradle").appendText(
             """
                 plugins {
-                    id 'org.jetbrains.kotlin.jvm' version '1.7.21'
+                    id 'org.jetbrains.kotlin.jvm' version '2.0.20'
                     id 'application'
                     id 'io.github.cdsap.gradleprocess'
+
                 }
                 repositories {
                     mavenCentral()
                 }
             """.trimIndent()
         )
-        listOf("8.14.1").forEach {
+        listOf("8.14.1", "9.1.0").forEach {
             val firstBuild = GradleRunner.create()
                 .withProjectDir(testProjectDir.root)
-                .withArguments("compileKotlin", "--configuration-cache")
+                .withArguments("compileKotlin", "--configuration-cache","--info")
                 .withPluginClasspath()
                 .withGradleVersion(it)
                 .build()