Fix #112 - report on specific module in a multi-module project without normal compilation fails

Author: eyalroth

src/functionalTest/java/org.scoverage/ScalaMultiModuleTest.java

@@ -36,12 +36,38 @@ public void reportScoverageOnlyRoot() {
     @Test
     public void reportScoverageOnlyA() {
 
-        AssertableBuildResult result = dryRun("clean", ":a:" + ScoveragePlugin.getREPORT_NAME());
+        AssertableBuildResult result = run("clean", ":a:" + ScoveragePlugin.getREPORT_NAME());
 
         result.assertTaskDoesntExist(ScoveragePlugin.getREPORT_NAME());
-        result.assertTaskExists("a:" + ScoveragePlugin.getREPORT_NAME());
         result.assertTaskDoesntExist("b:" + ScoveragePlugin.getREPORT_NAME());
         result.assertTaskDoesntExist("common:" + ScoveragePlugin.getREPORT_NAME());
+
+        result.assertTaskSucceeded("a:" + ScoveragePlugin.getCOMPILE_NAME());
+        result.assertTaskSucceeded("a:" + ScoveragePlugin.getREPORT_NAME());
+
+        assertAReportFilesExist();
+    }
+
+    @Test
+    public void reportScoverageOnlyAWithoutNormalCompilation() {
+
+        AssertableBuildResult result = run("clean", ":a:" + ScoveragePlugin.getREPORT_NAME(),
+                "-x", "compileScala");
+
+        result.assertTaskSkipped("compileScala");
+        result.assertTaskSkipped("a:compileScala");
+        result.assertTaskSkipped("common:compileScala");
+        result.assertTaskSucceeded("common:" + ScoveragePlugin.getCOMPILE_NAME());
+        result.assertTaskSucceeded("a:" + ScoveragePlugin.getCOMPILE_NAME());
+        result.assertTaskSucceeded("a:" + ScoveragePlugin.getREPORT_NAME());
+
+        assertAReportFilesExist();
+
+        Assert.assertTrue(resolve(buildDir(resolve(projectDir(), "a")), "classes/scala/main/org/hello/a/WorldA.class").exists());
+        Assert.assertFalse(resolve(buildDir(resolve(projectDir(), "a")), "classes/scala/scoverage/org/hello/a/WorldA.class").exists());
+
+        Assert.assertTrue(resolve(buildDir(resolve(projectDir(), "common")), "classes/scala/main/org/hello/common/WorldCommon.class").exists());
+        Assert.assertFalse(resolve(buildDir(resolve(projectDir(), "common")), "classes/scala/scoverage/org/hello/common/WorldCommon.class").exists());
     }
 
     @Test

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

@@ -266,51 +266,53 @@ class ScoveragePlugin implements Plugin<PluginAware> {
                             }
                         }
                     }
+                }
 
-                    compileTask.configure {
-                        if (!graph.hasTask(originalCompileTask)) {
-                            destinationDir = originalCompileTask.destinationDir
-                        } else {
-                            doFirst {
-                                destinationDir.deleteDir()
-                            }
+                compileTask.configure {
+                    if (!graph.hasTask(originalCompileTask)) {
+                        project.logger.info("Making scoverage compilation the primary compilation task (instead of compileScala)")
+                        destinationDir = originalCompileTask.destinationDir
+                    } else {
+                        doFirst {
+                            destinationDir.deleteDir()
+                        }
 
-                            // 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
-                                            }
+                        // delete non-instrumented classes by comparing normally compiled classes to those compiled with scoverage
+                        doLast {
+                            project.logger.info("Deleting classes compiled by scoverage but non-instrumented (identical to normal compilation)")
+                            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
                                         }
                                     }
-
-                                    files
                                 }
 
-                                def isSameFile = { String relativePath ->
-                                    def fileA = new File(originalDestinationDir, relativePath)
-                                    def fileB = new File(destinationDir, relativePath)
-                                    FileUtils.contentEquals(fileA, fileB)
-                                }
+                                files
+                            }
 
-                                def originalClasses = findFiles(originalDestinationDir)
-                                def identicalInstrumentedClasses = findFiles(destinationDir, { f ->
-                                    def relativePath = destinationDir.relativePath(f)
-                                    originalClasses.contains(relativePath) && isSameFile(relativePath)
-                                })
+                            def isSameFile = { String relativePath ->
+                                def fileA = new File(originalDestinationDir, relativePath)
+                                def fileB = new File(destinationDir, relativePath)
+                                FileUtils.contentEquals(fileA, fileB)
+                            }
 
-                                identicalInstrumentedClasses.each { f ->
-                                    Files.deleteIfExists(destinationDir.toPath().resolve(f))
-                                }
+                            def originalClasses = findFiles(originalDestinationDir)
+                            def identicalInstrumentedClasses = findFiles(destinationDir, { f ->
+                                def relativePath = destinationDir.relativePath(f)
+                                originalClasses.contains(relativePath) && isSameFile(relativePath)
+                            })
+
+                            identicalInstrumentedClasses.each { f ->
+                                Files.deleteIfExists(destinationDir.toPath().resolve(f))
                             }
                         }
                     }