Add collision report as output

Having at least one output also ensures that task is considered up-to-date on second run.

Author: REPLicated

src/main/kotlin/io/fuchs/gradle/collisiondetector/DetectCollisionsTask.kt

@@ -5,10 +5,12 @@ import org.gradle.api.DefaultTask
 import org.gradle.api.GradleException
 import org.gradle.api.file.ArchiveOperations
 import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.file.RegularFileProperty
 import org.gradle.api.tasks.CacheableTask
 import org.gradle.api.tasks.Classpath
-import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.InputFiles
+import org.gradle.api.tasks.Internal
+import org.gradle.api.tasks.OutputFile
 import org.gradle.api.tasks.TaskAction
 import org.gradle.api.tasks.TaskExecutionException
 import org.gradle.api.tasks.util.PatternSet
@@ -25,11 +27,18 @@ abstract class DetectCollisionsTask : DefaultTask() {
     @get:Classpath
     abstract val configurations: ConfigurableFileCollection
 
-    @get:Input
+    @get:Inject
+    abstract val archiveOperations: ArchiveOperations
+
+    @get:OutputFile
+    abstract val reportFile: RegularFileProperty
+
+    @get:Internal
     val collisionFilter: PatternSet = PatternSet()
 
-    @get:Inject
-    protected abstract val archiveOperations: ArchiveOperations
+    init {
+        reportFile.convention(project.layout.buildDirectory.file("reports/classpath-collisions.txt"))
+    }
 
     fun collisionFilter(filterConfig: Action<PatternSet>) {
         filterConfig.execute(collisionFilter)
@@ -38,31 +47,33 @@ abstract class DetectCollisionsTask : DefaultTask() {
     @TaskAction
     fun detectCollisions() {
         val collisionDetector = CollisionDetector(findClasspathArtifacts())
-
         val collisions = collisionDetector.detectCollisions()
 
+        val resolvedReportFile = reportFile.get().asFile
         if (collisions.isNotEmpty()) {
-            collisions.forEach { logCollisionMessage(it) }
+            val collisionMessages = collisions.map { toCollisionMessage(it) }
+            collisionMessages.forEach { logger.error(it) }
+            resolvedReportFile.writeText(collisionMessages.joinToString("\n"))
             throw TaskExecutionException(this, GradleException("Detected unexpected collisions!"))
+        } else {
+            resolvedReportFile.writeText("No collisions detected")
         }
     }
 
-    private fun logCollisionMessage(collision: ClasspathCollision) {
+    private fun toCollisionMessage(collision: ClasspathCollision): String {
         val name = collision.classpathEntry
         val collisionJars = collision.containingArtifacts
-                .map { it.artifact }
-                .sorted()
-                .joinToString("\n")
-                .prependIndent("   ")
-
-        val message = "Collision detected! Entry $name present in following JARs:\n${collisionJars}"
-        logger.error(message)
+            .map { it.artifact }
+            .sorted()
+            .joinToString("\n")
+            .prependIndent("   ")
+        return "Collision detected! Entry $name present in following JARs:\n${collisionJars}"
     }
 
     private fun findClasspathArtifacts(): List<ClasspathArtifact> {
         return configurations.files
-                .filter { it.name.endsWith(".jar") }
-                .map { toClassPathArtifact(it) }
+            .filter { it.name.endsWith(".jar") }
+            .map { toClassPathArtifact(it) }
     }
 
     private fun toClassPathArtifact(file: File): ClasspathArtifact {
@@ -72,4 +83,4 @@ abstract class DetectCollisionsTask : DefaultTask() {
     }
 
 
-}
+}

src/test/kotlin/io/fuchs/gradle/collisiondetector/testkit/CollisionDetectorPluginTest.kt

@@ -55,6 +55,26 @@ class CollisionDetectorPluginTest {
         assertEquals(TaskOutcome.SUCCESS, detectCollisionsTask?.outcome)
     }
 
+    fun `task is up-to-date in second execution`(@TempDir tempDir: Path) {
+        copyBuildFileToTempDir("apply_plugin_only.gradle", tempDir)
+
+        val buildResult1 = GradleRunner.create()
+            .withProjectDir(tempDir.toFile())
+            .withPluginClasspath()
+            .withArguments(":detectCollisions")
+            .build()
+        val buildResult2 = GradleRunner.create()
+            .withProjectDir(tempDir.toFile())
+            .withPluginClasspath()
+            .withArguments(":detectCollisions")
+            .build()
+
+        val detectCollisionsTask1 = buildResult1.task(":detectCollisions")
+        assertEquals(TaskOutcome.SUCCESS, detectCollisionsTask1?.outcome)
+        val detectCollisionsTask2 = buildResult2.task(":detectCollisions")
+        assertEquals(TaskOutcome.UP_TO_DATE, detectCollisionsTask2?.outcome)
+    }
+
     @Test
     fun `detects collisions and fails`(@TempDir tempDir: Path) {
         copyBuildFileToTempDir("found_collisions.gradle", tempDir)