Changed mechanism for detecting obsolete class files.

Relying only on the source namespace name doesn't work for class files
generated e.g. from defprotocol.

Instead all files are compiled to a temporary directory and then copied
to the destination directory. During next compilation first all files
found in temporary destination directory are deleted from the proper
destination directory.

Author: pbzdyl

src/main/kotlin/cursive/ClojurePlugin.kt

@@ -34,13 +34,13 @@ import org.gradle.api.tasks.SourceSet
 import org.gradle.api.tasks.TaskAction
 import org.gradle.api.tasks.compile.AbstractCompile
 import org.gradle.api.tasks.incremental.IncrementalTaskInputs
-import org.gradle.api.tasks.incremental.InputFileDetails
 import org.gradle.process.JavaForkOptions
 import org.gradle.process.internal.DefaultJavaForkOptions
 import org.gradle.process.internal.ExecException
 import org.gradle.process.internal.JavaExecHandleBuilder
 import org.gradle.util.ConfigureUtil
 import java.io.File
+import java.io.IOException
 import java.io.OutputStream
 import java.util.*
 import java.util.regex.Pattern
@@ -49,6 +49,7 @@ import javax.inject.Inject
 /**
  * @author Colin Fleming
  */
+@Suppress("unused")
 class ClojurePlugin : Plugin<Project> {
   val logger = Logging.getLogger(this.javaClass)
 
@@ -163,6 +164,12 @@ open class ClojureSourceSetImpl(displayName: String?, resolver: FileResolver?) :
 
 class ReflectionWarnings(var enabled: Boolean, var projectOnly: Boolean, var asErrors: Boolean)
 
+object FileCopyErrorHandler : (File, IOException) -> OnErrorAction {
+  override fun invoke(file: File, exception: IOException): OnErrorAction {
+    throw ExecException("Could not copy ${file} to output directory", exception)
+  }
+}
+
 open class ClojureCompile @Inject constructor(val fileResolver: FileResolver) :
     AbstractCompile(),
     JavaForkOptions by DefaultJavaForkOptions(fileResolver) {
@@ -175,30 +182,38 @@ open class ClojureCompile @Inject constructor(val fileResolver: FileResolver) :
   var elideMeta: Collection<String> = emptyList()
   var directLinking: Boolean = false
 
+  @Suppress("unused")
   var namespaces: Collection<String> = emptyList()
 
+  @Suppress("unused")
   fun reflectionWarnings(configureClosure: Closure<Any?>?): ReflectionWarnings {
     ConfigureUtil.configure(configureClosure, reflectionWarnings)
     return reflectionWarnings
   }
 
-  override fun compile() {
-    throw UnsupportedOperationException()
-  }
-
+  @Suppress("UNUSED_PARAMETER")
   @TaskAction
   fun compile(inputs: IncrementalTaskInputs) {
+    compile()
+  }
+
+  override fun compile() {
     logger.info("Starting ClojureCompile task")
 
-    destinationDir.mkdirs()
+    val tmpDestinationDir = temporaryDir.resolve("classes")
+    removeObsoleteClassFiles(destinationDir, tmpDestinationDir)
 
-    inputs.outOfDate { removeOutputFilesDerivedFromInputFile(it, destinationDir) }
-    inputs.removed { removeOutputFilesDerivedFromInputFile(it, destinationDir) }
+    if (!tmpDestinationDir.deleteRecursively()) {
+      throw ExecException("Could not delete ${tmpDestinationDir}")
+    }
+    tmpDestinationDir.mkdirs()
+    destinationDir.mkdirs()
 
     if (copySourceToOutput ?: !aotCompile) {
       project.copy {
-        it.from(getSource()).into(destinationDir)
+        it.from(getSource()).into(tmpDestinationDir)
       }
+      copyToDestination(tmpDestinationDir)
       return
     }
 
@@ -215,7 +230,7 @@ open class ClojureCompile @Inject constructor(val fileResolver: FileResolver) :
       logger.info("Compiling " + namespaces.joinToString(", "))
 
       val script = listOf("(try",
-                          "  (binding [*compile-path* \"${destinationDir.canonicalPath}\"",
+                          "  (binding [*compile-path* \"${tmpDestinationDir.canonicalPath}\"",
                           "            *warn-on-reflection* ${reflectionWarnings.enabled}",
                           "            *compiler-options* {:disable-locals-clearing $disableLocalsClearing",
                           "                                :elide-meta [${elideMeta.map { ":$it" }.joinToString(" ")}]",
@@ -263,6 +278,8 @@ open class ClojureCompile @Inject constructor(val fileResolver: FileResolver) :
 
       executeScript(script, stdout, stderr)
 
+      copyToDestination(tmpDestinationDir)
+
       if (libraryReflectionWarningCount > 0) {
         System.err.println("$libraryReflectionWarningCount reflection warnings from dependencies")
       }
@@ -272,28 +289,22 @@ open class ClojureCompile @Inject constructor(val fileResolver: FileResolver) :
     }
   }
 
-  private fun removeOutputFilesDerivedFromInputFile(inputFileDetails: InputFileDetails, destinationDir: File) {
-    val sourceAbsoluteFile = inputFileDetails.file
-    if (isClojureSource(sourceAbsoluteFile)) {
-      logger.debug("Removing class files for {}", inputFileDetails.file)
-      val sourceCanonicalFileName = sourceAbsoluteFile.canonicalPath
-      val sourceFileRoot = getSourceRootsFiles()
-          .find { sourceCanonicalFileName.startsWith(it.canonicalPath) }
-          ?: throw IllegalStateException("No source root found for source file ${sourceAbsoluteFile}")
-      val sourceRelativeFile = sourceAbsoluteFile.relativeTo(sourceFileRoot)
-      val sourceRelativeDirectory = sourceRelativeFile.parentFile
-      val sourceFileName = sourceAbsoluteFile.nameWithoutExtension
-      destinationDir.resolve(sourceRelativeDirectory)
-          .listFiles { file -> file.name.startsWith(sourceFileName) }
-          ?.forEach {
-            logger.debug("Deleting derived file {}", it)
-            it.delete()
-          }
-    }
+  private fun copyToDestination(tmpDestinationDir: File) {
+    tmpDestinationDir.copyRecursively(target = destinationDir, overwrite = true, onError = FileCopyErrorHandler)
   }
 
-  private fun  isClojureSource(file: File): Boolean {
-    return CLJ_EXTENSION_REGEX.matches(file.extension) && getSourceRoots().any { file.canonicalPath.startsWith(it) }
+  private fun  removeObsoleteClassFiles(destinationDir: File, tmpDestinationDir: File) {
+    tmpDestinationDir.walkBottomUp().forEach {
+      val relativeFile = it.relativeTo(tmpDestinationDir)
+      val fileInDestination = destinationDir.resolve(relativeFile)
+      if (fileInDestination.exists()) {
+        if (fileInDestination.delete()) {
+          logger.debug("Deleted obsolete output file {}", fileInDestination)
+        } else {
+          logger.warn("Couldn't delete obsolete output file {}", fileInDestination)
+        }
+      }
+    }
   }
 
   private fun executeScript(script: String, stdout: OutputStream, stderr: OutputStream) {
@@ -385,7 +396,6 @@ open class ClojureCompile @Inject constructor(val fileResolver: FileResolver) :
                          '\\' to "_BSLASH_",
                          '?' to "_QMARK_")
 
-    val CLJ_EXTENSION_REGEX = "cljc?".toRegex()
     val DEMUNGE_MAP = CHAR_MAP.map { it.value to it.key }.toMap()
     val DEMUNGE_PATTERN = Pattern.compile(DEMUNGE_MAP.keys
                                               .sortedByDescending { it.length }
@@ -394,6 +404,7 @@ open class ClojureCompile @Inject constructor(val fileResolver: FileResolver) :
 
     val REFLECTION_WARNING_PREFIX = "Reflection warning, "
 
+    @Suppress("unused")
     fun munge(name: String): String {
       val sb = StringBuilder()
       for (c in name) {
@@ -431,7 +442,9 @@ open class ClojureTestRunner @Inject constructor(val fileResolver: FileResolver)
     ConventionTask(),
     JavaForkOptions by DefaultJavaForkOptions(fileResolver) {
 
+  @Suppress("unused")
   var classpath: FileCollection = SimpleFileCollection()
+  @Suppress("unused")
   var namespaces: Collection<String> = emptyList()
   var junitReport: File? = null
 

src/test/int-tests-projects/cursive/BasicClojureProjectTest/src/main/clojure/basic_project/core.clj

@@ -16,6 +16,8 @@
 
 (ns basic-project.core)
 
+(defprotocol ITest)
+
 (defn hello [name]
   (println "Generating message for" name)
   (str "Hello " name))

src/test/int-tests-projects/cursive/IncrementalCompilationTest/src/main/clojure/basic_project/core.clj

@@ -16,5 +16,7 @@
 
 (ns basic-project.core)
 
+(defprotocol ITest)
+
 (defn hello [name]
   (str "Hello " name))

src/test/int-tests-projects/cursive/MixedJavaClojureTest/src/cljSS/clojure/cljSS/core.clj

@@ -15,7 +15,8 @@
 ;
 
 (ns cljSS.core
-  (:import javaSS.Example))
+  (:import (javaSS Example1 Example2)))
 
 (defn test []
-  (.test (Example.)))
+  (.test (Example1.))
+  (.test (Example2.)))

src/test/int-tests-projects/cursive/MixedJavaClojureTest/src/javaSS/java/javaSS/Example.java renamed to src/test/int-tests-projects/cursive/MixedJavaClojureTest/src/javaSS/java/javaSS/Example1.java

@@ -16,7 +16,7 @@
 
 package javaSS;
 
-public class Example {
+public class Example1 {
     public void test() {
     }
 }

src/test/int-tests-projects/cursive/MixedJavaClojureTest/src/javaSS/java/javaSS/Example2.java

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2017 Colin Fleming
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package javaSS;
+
+public class Example2 {
+    public void test() {
+    }
+}

src/test/kotlin/cursive/BasicClojureProjectTest.kt

@@ -18,6 +18,7 @@ package cursive
 
 import org.assertj.core.api.KotlinAssertions.assertThat
 import org.gradle.testkit.runner.TaskOutcome
+import org.junit.Assert.assertTrue
 import org.junit.Test
 
 class BasicClojureProjectTest : IntegrationTestBase() {
@@ -52,6 +53,7 @@ class BasicClojureProjectTest : IntegrationTestBase() {
     assertThat(result.task(":testClojure").outcome).isEqualTo(TaskOutcome.SUCCESS)
 
     assertSourceFileIsOnlyCompiledToOutputDir(coreNsSourceFile)
+    assertTrue("Protocol class file exists", testProjectDir.resolve("build/classes/main/basic_project/core/ITest.class").exists())
 
     assertThat(result.output).contains("Generating message for World")
   }

src/test/kotlin/cursive/IncrementalCompilationTest.kt

@@ -18,6 +18,7 @@ package cursive
 
 import org.assertj.core.api.KotlinAssertions.assertThat
 import org.gradle.testkit.runner.TaskOutcome
+import org.junit.Assert.assertFalse
 import org.junit.Test
 
 class IncrementalCompilationTest : IntegrationTestBase() {
@@ -113,5 +114,6 @@ class IncrementalCompilationTest : IntegrationTestBase() {
     assertSourceFileNotCopiedToOutputDir(coreNsSourceFile)
     assertSourceFileNotCompiledToOutputDir(coreNsSourceFile)
     assertSourceFileIsOnlyCompiledToOutputDir(utilsNsSourceFile)
+    assertFalse("Protocol class file doesn't exists", testProjectDir.resolve("build/classes/main/basic_project/core/ITest.class").exists())
   }
 }

src/test/kotlin/cursive/MixedJavaClojureTest.kt

@@ -21,24 +21,76 @@ import org.gradle.testkit.runner.TaskOutcome
 import org.junit.Test
 
 class MixedJavaClojureTest : IntegrationTestBase() {
-  @Test
-  fun `Compilation with Clojure code depending on Java code`() {
-    // given
-    val javaOutputDir = testProjectDir.resolve("build/classes/javaSS")
-    val javaClassFile = javaOutputDir.resolve("javaSS/Example.class")
+  val javaOutputDir = testProjectDir.resolve("build/classes/javaSS")
+  val javaExample1SourceFile = testProjectDir.resolve("src/javaSS/java/javaSS/Example1.java")
+  val javaExample1ClassFile = javaOutputDir.resolve("javaSS/Example1.class")
+  val javaExample2ClassFile = javaOutputDir.resolve("javaSS/Example2.class")
 
-    val cljSourceDir = testProjectDir.resolve("src/cljSS/clojure")
-    val cljCoreNsFile = cljSourceDir.resolve("cljSS/core.clj")
-    val cljOutputDir = testProjectDir.resolve("build/classes/cljSS")
+  val cljSourceDir = testProjectDir.resolve("src/cljSS/clojure")
+  val cljCoreNsFile = cljSourceDir.resolve("cljSS/core.clj")
+  val cljOutputDir = testProjectDir.resolve("build/classes/cljSS")
 
+  @Test
+  fun `Compilation with Clojure code depending on Java code`() {
     // when
     val result = projectBuildRunner().withArguments("compileCljSSClojure").build()
 
     // then
     assertThat(result.task(":compileJavaSSJava").outcome).isEqualTo(TaskOutcome.SUCCESS)
     assertThat(result.task(":compileCljSSClojure").outcome).isEqualTo(TaskOutcome.SUCCESS)
 
-    assertThat(javaClassFile.exists()).isTrue()
+    assertThat(javaExample1ClassFile.exists()).isTrue()
+    assertThat(javaExample2ClassFile.exists()).isTrue()
+    assertSourceFileIsOnlyCompiledToOutputDir(cljCoreNsFile, cljSourceDir, cljOutputDir)
+  }
+
+  @Test
+  fun `Incremental compilation with Clojure code depending on Java code when Java source unchanged`() {
+    // when
+    val firstResult = projectBuildRunner().withArguments("compileCljSSClojure").build()
+
+    // then
+    assertThat(firstResult.task(":compileJavaSSJava").outcome).isEqualTo(TaskOutcome.SUCCESS)
+    assertThat(firstResult.task(":compileCljSSClojure").outcome).isEqualTo(TaskOutcome.SUCCESS)
+
+    assertThat(javaExample1ClassFile.exists()).isTrue()
+    assertThat(javaExample2ClassFile.exists()).isTrue()
     assertSourceFileIsOnlyCompiledToOutputDir(cljCoreNsFile, cljSourceDir, cljOutputDir)
+
+    // when
+    val secondResult = projectBuildRunner().withArguments("compileCljSSClojure").build()
+
+    // then
+    println(secondResult.output)
+    assertThat(secondResult.task(":compileJavaSSJava").outcome).isEqualTo(TaskOutcome.UP_TO_DATE)
+    assertThat(secondResult.task(":compileCljSSClojure").outcome).isEqualTo(TaskOutcome.UP_TO_DATE)
+
+    assertThat(javaExample1ClassFile.exists()).isTrue()
+    assertThat(javaExample2ClassFile.exists()).isTrue()
+    assertSourceFileIsOnlyCompiledToOutputDir(cljCoreNsFile, cljSourceDir, cljOutputDir)
+  }
+
+  @Test
+  fun `Incremental compilation with Clojure code depending on Java code when Java source changes`() {
+    // when
+    val firstResult = projectBuildRunner().withArguments("compileCljSSClojure").build()
+
+    // then
+    assertThat(firstResult.task(":compileJavaSSJava").outcome).isEqualTo(TaskOutcome.SUCCESS)
+    assertThat(firstResult.task(":compileCljSSClojure").outcome).isEqualTo(TaskOutcome.SUCCESS)
+
+    assertThat(javaExample1ClassFile.exists()).isTrue()
+    assertThat(javaExample2ClassFile.exists()).isTrue()
+    assertSourceFileIsOnlyCompiledToOutputDir(cljCoreNsFile, cljSourceDir, cljOutputDir)
+
+    // when
+    javaExample1SourceFile.delete()
+    val secondResult = projectBuildRunner().withArguments("compileCljSSClojure").buildAndFail()
+
+    // then
+    assertThat(secondResult.task(":compileJavaSSJava").outcome).isEqualTo(TaskOutcome.SUCCESS)
+    assertThat(secondResult.task(":compileCljSSClojure").outcome).isEqualTo(TaskOutcome.FAILED)
+
+    assertThat(secondResult.output).contains("java.lang.ClassNotFoundException: javaSS.Example1")
   }
 }