Aggregate raw coverage data, not XML reports

scalac-scoverage-plugin/src/main/scala/scoverage/IOUtils.scala

@@ -54,10 +54,13 @@ object IOUtils {
     override def accept(pathname: File): Boolean = pathname.getName.startsWith(Constants.MeasurementsPrefix)
   })
 
-  def reportFileSearch(baseDir: File, condition: File => Boolean): Seq[File] = {
+  def scoverageDataDirsSearch(baseDir: File): Seq[File] = {
+    def directoryFilter = new FileFilter {
+      override def accept(pathname: File): Boolean = pathname.isDirectory
+    }
     def search(file: File): Seq[File] = file match {
-      case dir if dir.isDirectory => dir.listFiles().toSeq.map(search).flatten
-      case f if isReportFile(f) => Seq(f)
+      case dir if dir.isDirectory && dir.getName == Constants.DataDir => Seq(dir)
+      case dir if dir.isDirectory => dir.listFiles(directoryFilter).toSeq.flatMap(search)
       case _ => Nil
     }
     search(baseDir)

scalac-scoverage-plugin/src/main/scala/scoverage/report/CoverageAggregator.scala

@@ -2,35 +2,39 @@ package scoverage.report
 
 import java.io.File
 
-import scoverage.{Coverage, IOUtils}
+import scoverage.{Coverage, IOUtils, Serializer}
 
 object CoverageAggregator {
 
+  @deprecated("1.4.0", "Used only by gradle-scoverage plugin")
   def aggregate(baseDir: File, clean: Boolean): Option[Coverage] = {
-    val files = IOUtils.reportFileSearch(baseDir, IOUtils.isReportFile)
-    aggregate(files, clean)
+    aggregate(IOUtils.scoverageDataDirsSearch(baseDir))
   }
 
-  def aggregate(files: Seq[File], clean: Boolean): Option[Coverage] = {
-    println(s"[info] Found ${files.size} subproject report files [${files.mkString(",")}]")
-    if (files.size > 0) {
-      val coverage = aggregatedCoverage(files)
-      if (clean) files foreach (_.delete)
-      Some(coverage)
+  def aggregate(dataDirs: Seq[File]): Option[Coverage] = {
+    println(s"[info] Found ${dataDirs.size} subproject scoverage data directories [${dataDirs.mkString(",")}]")
+    if (dataDirs.size > 0) {
+      Some(aggregatedCoverage(dataDirs))
     } else {
       None
     }
   }
 
-  def aggregatedCoverage(files: Seq[File]): Coverage = {
+  def aggregatedCoverage(dataDirs: Seq[File]): Coverage = {
     var id = 0
     val coverage = Coverage()
-    files foreach { file =>
-      val subcoverage = ScoverageXmlReader.read(file)
-      subcoverage.statements foreach { stmt =>
-        // need to ensure all the ids are unique otherwise the coverage object will have stmt collisions
-        id = id + 1
-        coverage add stmt.copy(id = id)
+    dataDirs foreach { dataDir =>
+      val coverageFile: File = Serializer.coverageFile(dataDir)
+      if (coverageFile.exists) {
+        val subcoverage: Coverage = Serializer.deserialize(coverageFile)
+        val measurementFiles: Array[File] = IOUtils.findMeasurementFiles(dataDir)
+        val measurements = IOUtils.invoked(measurementFiles)
+        subcoverage.apply(measurements)
+        subcoverage.statements foreach { stmt =>
+          // need to ensure all the ids are unique otherwise the coverage object will have stmt collisions
+          id = id + 1
+          coverage add stmt.copy(id = id)
+        }
       }
     }
     coverage

scalac-scoverage-plugin/src/test/scala/scoverage/CoverageAggregatorTest.scala

@@ -1,10 +1,10 @@
 package scoverage
 
-import java.io.File
+import java.io.{File, FileWriter}
 import java.util.UUID
 
 import org.scalatest.{FreeSpec, Matchers}
-import scoverage.report.{CoverageAggregator, ScoverageXmlWriter}
+import scoverage.report.CoverageAggregator
 
 class CoverageAggregatorTest extends FreeSpec with Matchers {
 
@@ -23,33 +23,41 @@ class CoverageAggregatorTest extends FreeSpec with Matchers {
         "methlab",
         source)
 
+      val cov1Stmt1 = Statement(location, 1, 155, 176, 4, "", "", "", true, 1)
+      val cov1Stmt2 = Statement(location, 2, 200, 300, 5, "", "", "", false, 1)
       val coverage1 = Coverage()
-      coverage1.add(Statement(location, 1, 155, 176, 4, "", "", "", true, 1))
-      coverage1.add(Statement(location, 2, 200, 300, 5, "", "", "", false, 2))
+      coverage1.add(cov1Stmt1.copy(count = 0))
+      coverage1.add(cov1Stmt2.copy(count = 0))
       val dir1 = new File(IOUtils.getTempPath, UUID.randomUUID.toString)
       dir1.mkdir()
-      new ScoverageXmlWriter(sourceRoot, dir1, false).write(coverage1)
+      Serializer.serialize(coverage1, Serializer.coverageFile(dir1))
+      val measurementsFile1 = new File(dir1, s"${Constants.MeasurementsPrefix}1")
+      val measurementsFile1Writer = new FileWriter(measurementsFile1)
+      measurementsFile1Writer.write("1\n2\n")
+      measurementsFile1Writer.close()
 
+      val cov2Stmt1 = Statement(location, 1, 95, 105, 19, "", "", "", false, 0)
       val coverage2 = Coverage()
-      coverage2.add(Statement(location, 1, 95, 105, 19, "", "", "", false, 0))
+      coverage2.add(cov2Stmt1)
       val dir2 = new File(IOUtils.getTempPath, UUID.randomUUID.toString)
       dir2.mkdir()
-      new ScoverageXmlWriter(sourceRoot, dir2, false).write(coverage2)
+      Serializer.serialize(coverage2, Serializer.coverageFile(dir2))
 
+      val cov3Stmt1 = Statement(location, 2, 14, 1515, 544, "", "", "", false, 1)
       val coverage3 = Coverage()
-      coverage3.add(Statement(location, 2, 14, 1515, 544, "", "", "", false, 1))
+      coverage3.add(cov3Stmt1.copy(count = 0))
       val dir3 = new File(IOUtils.getTempPath, UUID.randomUUID.toString)
       dir3.mkdir()
-      new ScoverageXmlWriter(sourceRoot, dir3, false).write(coverage3)
+      Serializer.serialize(coverage3, Serializer.coverageFile(dir3))
+      val measurementsFile3 = new File(dir3, s"${Constants.MeasurementsPrefix}1")
+      val measurementsFile3Writer = new FileWriter(measurementsFile3)
+      measurementsFile3Writer.write("2\n")
+      measurementsFile3Writer.close()
 
-      val aggregated = CoverageAggregator.aggregatedCoverage(
-        Seq(IOUtils.reportFile(dir1, debug = false),
-          IOUtils.reportFile(dir2, debug = false),
-          IOUtils.reportFile(dir3, debug = false))
-      )
+      val aggregated = CoverageAggregator.aggregatedCoverage(Seq(dir1, dir2, dir3))
       aggregated.statements.toSet.size shouldBe 4
       aggregated.statements.map(_.copy(id = 0)).toSet shouldBe
-        (coverage1.statements ++ coverage2.statements ++ coverage3.statements).map(_.copy(id = 0)).toSet
+        Set(cov1Stmt1, cov1Stmt2, cov2Stmt1, cov3Stmt1).map(_.copy(id = 0))
     }
   }
 }

scalac-scoverage-plugin/src/test/scala/scoverage/IOUtilsTest.scala

@@ -42,34 +42,23 @@ class IOUtilsTest extends FreeSpec with MockitoSugar with OneInstancePerTest wit
       file1.delete()
       file2.delete()
     }
-    "should deep search for report files" in {
+    "should deep search for scoverage-data directories" in {
       // create new folder to hold all our data
       val base = new File(IOUtils.getTempDirectory, UUID.randomUUID.toString)
-      base.mkdir() shouldBe true
 
-      val file1 = new File(base, Constants.XMLReportFilename)
-      val writer1 = new FileWriter(file1)
-      writer1.write("1\n3\n5\n\n\n7\n")
-      writer1.close()
+      val dataDir1 = new File(base, Constants.DataDir)
+      dataDir1.mkdirs() shouldBe true
 
-      val file2 = new File(base, UUID.randomUUID.toString + "/" + Constants.XMLReportFilename)
-      file2.getParentFile.mkdir()
-      val writer2 = new FileWriter(file2)
-      writer2.write("2\n4\n6\n\n8\n")
-      writer2.close()
+      val subDir = new File(base, UUID.randomUUID.toString)
+      val dataDir2 = new File(subDir, Constants.DataDir)
+      dataDir2.mkdirs() shouldBe true
 
-      val file3 = new File(file2.getParentFile, UUID.randomUUID.toString + "/" + Constants.XMLReportFilename)
-      file3.getParentFile.mkdir()
-      val writer3 = new FileWriter(file3)
-      writer3.write("11\n20\n30\n\n44\n")
-      writer3.close()
+      val subSubDir = new File(subDir, UUID.randomUUID.toString)
+      val dataDir3 = new File(subSubDir, Constants.DataDir)
+      dataDir3.mkdirs() shouldBe true
 
-      val files = IOUtils.reportFileSearch(base, IOUtils.isReportFile)
-      val invoked = IOUtils.invoked(files)
-      assert(invoked === Set(1, 2, 3, 4, 5, 6, 7, 8, 11, 20, 30, 44))
-
-      file1.delete()
-      file2.delete()
+      val dataDirs = IOUtils.scoverageDataDirsSearch(base)
+      dataDirs should contain only (dataDir1, dataDir2, dataDir3)
     }
   }
 }