Allow running scoverage without running the normal compilation (only scoverage compilation)

Author: eyalroth

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

@@ -61,7 +61,7 @@ public void checkScoverage() throws Exception {
         result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME());
 
         assertReportFilesExist();
-        assertCoverage(100.0);
+        assertCoverage(50.0);
     }
 
     @Test
@@ -94,6 +94,42 @@ public void reportScoverageWithExcludedClasses() throws Exception {
         Assert.assertFalse(resolve(reportDir(), "src/main/scala/org/hello/World.scala.html").exists());
         assertCoverage(100.0); // coverage is 100 since no classes are covered
 
+        // compiled class should exist in the default classes directory, but not in scoverage
+        Assert.assertTrue(resolve(buildDir(), "classes/scala/main/org/hello/World.class").exists());
+        Assert.assertFalse(resolve(buildDir(), "classes/scala/scoverage/org/hello/World.class").exists());
+    }
+
+    @Test
+    public void reportScoverageWithoutNormalCompilation() throws Exception {
+
+        AssertableBuildResult result = run("clean", ScoveragePlugin.getREPORT_NAME(),
+                "-PrunNormalCompilation=false");
+
+        result.assertTaskSkipped("compileScala");
+        result.assertTaskSucceeded(ScoveragePlugin.getCOMPILE_NAME());
+        result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME());
+        result.assertTaskDoesntExist(ScoveragePlugin.getCHECK_NAME());
+        result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME());
+
+        assertReportFilesExist();
+        assertCoverage(50.0);
+
+        Assert.assertTrue(resolve(buildDir(), "classes/scala/main/org/hello/World.class").exists());
+        Assert.assertFalse(resolve(buildDir(), "classes/scala/scoverage/org/hello/World.class").exists());
+    }
+
+    @Test
+    public void reportScoverageWithoutNormalCompilationAndWithExcludedClasses() throws Exception {
+
+        AssertableBuildResult result = run("clean", ScoveragePlugin.getREPORT_NAME(),
+                "-PrunNormalCompilation=false", "-PexcludedFile=.*");
+
+        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
+
+        // compiled class should exist in the default classes directory, but not in scoverage
+        Assert.assertTrue(resolve(buildDir(), "classes/scala/main/org/hello/World.class").exists());
         Assert.assertFalse(resolve(buildDir(), "classes/scala/scoverage/org/hello/World.class").exists());
     }
 

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

@@ -25,11 +25,13 @@ test {
 }
 
 checkScoverage {
-    minimumRate = 0.5
+    minimumRate = 0.3
 }
 
 if (hasProperty("excludedFile")) {
-    scoverage {
-        excludedFiles = [excludedFile]
-    }
-}
+    scoverage.excludedFiles = [excludedFile]
+}
+if (hasProperty("runNormalCompilation")) {
+    scoverage.runNormalCompilation = Boolean.valueOf(runNormalCompilation)
+}
+

src/functionalTest/resources/projects/scala-single-module/src/main/scala/org/hello/World.scala

@@ -6,4 +6,7 @@ class World {
     val s = "a" + "b"
     s
   }
+
+  // not covered by tests
+  def bar(): String = "y"
 }

src/main/groovy/org/scoverage/ScoverageExtension.groovy

@@ -40,6 +40,8 @@ class ScoverageExtension {
 
     final Property<Boolean> deleteReportsOnAggregation
 
+    final Property<Boolean> runNormalCompilation
+
     ScoverageExtension(Project project) {
 
         project.plugins.apply(JavaPlugin.class)
@@ -83,5 +85,8 @@ class ScoverageExtension {
 
         deleteReportsOnAggregation = project.objects.property(Boolean)
         deleteReportsOnAggregation.set(false)
+
+        runNormalCompilation = project.objects.property(Boolean)
+        runNormalCompilation.set(true)
     }
 }

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

@@ -6,7 +6,6 @@ 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 java.nio.file.Files
 
@@ -97,19 +96,13 @@ class ScoveragePlugin implements Plugin<PluginAware> {
             runtimeClasspath = it.output + project.configurations.scoverage + originalSourceSet.runtimeClasspath
         }
 
+        def originalCompileTask = project.tasks[originalSourceSet.getCompileTaskName("scala")]
+        originalCompileTask.onlyIf { extension.runNormalCompilation.get() }
+
         def compileTask = project.tasks[instrumentedSourceSet.getCompileTaskName("scala")]
-        compileTask.mustRunAfter(originalSourceSet.getCompileTaskName("scala"))
+        compileTask.mustRunAfter(originalCompileTask)
         project.test.mustRunAfter(compileTask)
 
-        def scoverageJar = project.tasks.create('jarScoverage', Jar.class) {
-            dependsOn(instrumentedSourceSet.classesTaskName)
-            classifier = CONFIGURATION_NAME
-            from instrumentedSourceSet.output
-        }
-        project.artifacts {
-            scoverage scoverageJar
-        }
-
         def reportTask = project.tasks.create(REPORT_NAME, ScoverageReport.class) {
             dependsOn compileTask, project.test
             onlyIf { extension.dataDir.get().list() }
@@ -146,6 +139,12 @@ class ScoveragePlugin implements Plugin<PluginAware> {
                         })
                     }
                 }
+
+                if (!extension.runNormalCompilation.get()) {
+                    project.sourceSets.getByName(SourceSet.TEST_SOURCE_SET_NAME) {
+                        compileClasspath = instrumentedSourceSet.output + compileClasspath
+                    }
+                }
             }
         }
 
@@ -168,8 +167,12 @@ class ScoveragePlugin implements Plugin<PluginAware> {
             }
 
             compileTask.configure {
-                doFirst {
-                    destinationDir.deleteDir()
+                if (extension.runNormalCompilation.get()) {
+                    doFirst {
+                        destinationDir.deleteDir()
+                    }
+                } else {
+                    destinationDir = originalCompileTask.destinationDir
                 }
 
                 File pluginFile = project.configurations[CONFIGURATION_NAME].find {
@@ -196,40 +199,43 @@ class ScoveragePlugin implements Plugin<PluginAware> {
                 // 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
+                if (extension.runNormalCompilation.get()) {
+                    // delete non-instrumented classes by comparing normally compiled classes to those compiled with scoverage
+                    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
-                    }
+                            return files
+                        }
 
-                    def isSameFile = { String relativePath ->
-                        def fileA = new File(originalDestinationDir, relativePath)
-                        def fileB = new File(destinationDir, relativePath)
-                        return FileUtils.contentEquals(fileA, fileB)
-                    }
+                        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)
-                    })
+                        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))
+                        identicalInstrumentedClasses.each { f ->
+                            Files.deleteIfExists(destinationDir.toPath().resolve(f))
+                        }
                     }
                 }
             }