Make the plugin delete non-instrumented classes from the output directory

Author: eyalroth

build.gradle

@@ -49,6 +49,7 @@ targetCompatibility = '1.6'
 
 dependencies {
     compileOnly "org.scoverage:scalac-scoverage-plugin_2.12:1.3.1"
+    compile group: 'commons-io', name: 'commons-io', version: '2.6'
     testCompile 'junit:junit:4.12'
     testCompile 'org.hamcrest:hamcrest-library:1.3'
 }

src/functionalTest/java/org.scoverage/ScalaSingleModuleTest.java

@@ -79,6 +79,24 @@ public void checkScoverageFails() throws Exception {
         assertCoverage(0.0);
     }
 
+    @Test
+    public void reportScoverageWithExcludedClasses() throws Exception {
+
+        AssertableBuildResult result = run("clean", ScoveragePlugin.getREPORT_NAME(),
+                "-PexcludedFile=.*");
+
+        result.assertTaskSucceeded(ScoveragePlugin.getCOMPILE_NAME());
+        result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME());
+        result.assertTaskDoesntExist(ScoveragePlugin.getCHECK_NAME());
+        result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME());
+
+        Assert.assertTrue(resolve(reportDir(), "index.html").exists());
+        Assert.assertFalse(resolve(reportDir(), "src/main/scala/org/hello/World.scala.html").exists());
+        assertCoverage(100.0); // coverage is 100 since no classes are covered
+
+        Assert.assertFalse(resolve(buildDir(), "classes/scala/scoverage/org/hello/World.class").exists());
+    }
+
     private void assertReportFilesExist() {
 
         Assert.assertTrue(resolve(reportDir(), "index.html").exists());

src/functionalTest/java/org.scoverage/ScoverageFunctionalTest.java

@@ -49,14 +49,24 @@ protected File projectDir() {
         return new File("src/functionalTest/resources/projects/" + projectName);
     }
 
+    protected File buildDir() {
+
+        return buildDir(projectDir());
+    }
+
+    protected File buildDir(File projectDir) {
+
+        return projectDir.toPath().resolve("build").toFile();
+    }
+
     protected File reportDir() {
 
         return reportDir(projectDir());
     }
 
     protected File reportDir(File projectDir) {
 
-        return projectDir.toPath().resolve("build").resolve(ScoveragePlugin.getDEFAULT_REPORT_DIR()).toFile();
+        return buildDir(projectDir).toPath().resolve(ScoveragePlugin.getDEFAULT_REPORT_DIR()).toFile();
     }
 
     protected AssertableBuildResult run(String... arguments) {

src/functionalTest/resources/projects/scala-single-module/build.gradle

@@ -26,4 +26,10 @@ test {
 
 checkScoverage {
     minimumRate = 0.5
+}
+
+if (hasProperty("excludedFile")) {
+    scoverage {
+        excludedFiles = [excludedFile]
+    }
 }

src/main/groovy/org/scoverage/ScoveragePlugin.groovy

@@ -1,12 +1,16 @@
 package org.scoverage
 
+import org.apache.commons.io.FileUtils
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.invocation.Gradle
 import org.gradle.api.plugins.PluginAware
 import org.gradle.api.tasks.SourceSet
 import org.gradle.api.tasks.bundling.Jar
-import org.gradle.util.GFileUtils
+
+import java.nio.file.Files
+
+import static groovy.io.FileType.FILES
 
 class ScoveragePlugin implements Plugin<PluginAware> {
 
@@ -82,18 +86,19 @@ class ScoveragePlugin implements Plugin<PluginAware> {
 
         ScoverageRunner scoverageRunner = new ScoverageRunner(project.configurations.scoverage)
 
+        def originalSourceSet = project.sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME)
         def instrumentedSourceSet = project.sourceSets.create('scoverage') {
-            def original = project.sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME)
 
-            resources.source(original.resources)
-            scala.source(original.java)
-            scala.source(original.scala)
+            resources.source(originalSourceSet.resources)
+            scala.source(originalSourceSet.java)
+            scala.source(originalSourceSet.scala)
 
-            compileClasspath += original.compileClasspath + project.configurations.scoverage
-            runtimeClasspath = it.output + project.configurations.scoverage + original.runtimeClasspath
+            compileClasspath += originalSourceSet.compileClasspath + project.configurations.scoverage
+            runtimeClasspath = it.output + project.configurations.scoverage + originalSourceSet.runtimeClasspath
         }
 
         def compileTask = project.tasks[instrumentedSourceSet.getCompileTaskName("scala")]
+        compileTask.mustRunAfter(originalSourceSet.getCompileTaskName("scala"))
         project.test.mustRunAfter(compileTask)
 
         def scoverageJar = project.tasks.create('jarScoverage', Jar.class) {
@@ -127,7 +132,6 @@ class ScoveragePlugin implements Plugin<PluginAware> {
 
         project.gradle.taskGraph.whenReady { graph ->
             if (graph.hasTask(reportTask)) {
-
                 project.test.configure {
                     project.logger.debug("Adding instrumented classes to '${path}' classpath")
 
@@ -164,6 +168,10 @@ class ScoveragePlugin implements Plugin<PluginAware> {
             }
 
             compileTask.configure {
+                doFirst {
+                    destinationDir.deleteDir()
+                }
+
                 File pluginFile = project.configurations[CONFIGURATION_NAME].find {
                     it.name.startsWith("scalac-scoverage-plugin")
                 }
@@ -184,13 +192,49 @@ class ScoveragePlugin implements Plugin<PluginAware> {
                 if (extension.highlighting.get()) {
                     parameters.add('-Yrangepos')
                 }
-                doFirst {
-                    GFileUtils.deleteDirectory(destinationDir)
-                }
                 scalaCompileOptions.additionalParameters = parameters
                 // the compile task creates a store of measured statements
                 outputs.file(new File(extension.dataDir.get(), 'scoverage.coverage.xml'))
+
+                doLast {
+                    def originalCompileTaskName = project.sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME)
+                            .getCompileTaskName("scala")
+                    def originalDestinationDir = project.tasks[originalCompileTaskName].destinationDir
+
+                    def findFiles = { File dir, Closure<Boolean> condition = null ->
+                        def files = []
+
+                        if (dir.exists()) {
+                            dir.eachFileRecurse(FILES) { f ->
+                                if (condition == null || condition(f)) {
+                                    def relativePath = dir.relativePath(f)
+                                    files << relativePath
+                                }
+                            }
+                        }
+
+                        return files
+                    }
+
+                    def isSameFile = { String relativePath ->
+                        def fileA = new File(originalDestinationDir, relativePath)
+                        def fileB = new File(destinationDir, relativePath)
+                        return FileUtils.contentEquals(fileA, fileB)
+                    }
+
+                    def originalClasses = findFiles(originalDestinationDir)
+                    def identicalInstrumentedClasses = findFiles(destinationDir, { f ->
+                        def relativePath = destinationDir.relativePath(f)
+                        return originalClasses.contains(relativePath) && isSameFile(relativePath)
+                    })
+
+                    identicalInstrumentedClasses.each { f ->
+                        Files.deleteIfExists(destinationDir.toPath().resolve(f))
+                    }
+                }
             }
         }
     }
+
+
 }