Rewrote plugin to remove all 0.12.x era idioms

Author: sksamuel

src/main/scala/scoverage/ScoverageSbtPlugin.scala

@@ -1,8 +1,7 @@
 package scoverage
 
-import sbt._
 import sbt.Keys._
-import scoverage.report._
+import sbt._
 
 object ScoverageSbtPlugin extends ScoverageSbtPlugin
 
@@ -21,96 +20,69 @@ class ScoverageSbtPlugin extends sbt.Plugin {
 
   import ScoverageKeys._
 
-  lazy val Scoverage: Configuration = config("scoverage") extend Test
+  lazy val Scoverage: Configuration = config("scoverage") extend Compile
+  lazy val ScoverageTest: Configuration = config("scoverage-test") extend Scoverage
 
   lazy val instrumentSettings: Seq[Setting[_]] = {
     inConfig(Scoverage)(Defaults.compileSettings) ++
-      inConfig(Scoverage)(Defaults.testSettings) ++
+      inConfig(ScoverageTest)(Defaults.testSettings) ++
       Seq(
-        //ivyConfigurations ++= Seq(Scoverage.hide, Scoverage.hide),
-        libraryDependencies in(Scoverage, compile) += {
-          OrgScoverage % (ArtifactId + "_" + scalaBinaryVersion.value) % ScoverageVersion
+        ivyConfigurations ++= Seq(Scoverage.hide, ScoverageTest.hide),
+        libraryDependencies += {
+          OrgScoverage % (ArtifactId + "_" + scalaBinaryVersion.value) % ScoverageVersion % Scoverage.name
         },
-
+        sources in Scoverage := (sources in Compile).value,
+        sourceDirectory in Scoverage := (sourceDirectory in Compile).value,
+        resourceDirectory in Scoverage := (resourceDirectory in Compile).value,
+        resourceGenerators in Scoverage := (resourceGenerators in Compile).value,
+        javacOptions in Scoverage := (javacOptions in Compile).value,
+        javaOptions in Scoverage := (javaOptions in Compile).value,
+
+        minimumCoverage := 0, // default is no minimum
+        failOnMinimumCoverage := false,
+        highlighting := false,
         excludedPackages in Scoverage := "",
-        minimumCoverage in Scoverage := 0, // default is no minimum
-        failOnMinimumCoverage in Scoverage := false,
-        highlighting in Scoverage := false,
 
-        scalacOptions in(Scoverage, compile) ++= {
+        scalacOptions in Scoverage := {
             val target = crossTarget.value
-            val scoverageDeps = (update in(Scoverage, compile)).value matching configurationFilter(Scoverage.name)
+            val scoverageDeps = update.value matching configurationFilter(Scoverage.name)
             scoverageDeps.find(_.getAbsolutePath.contains(ArtifactId)) match {
               case None => throw new Exception(s"Fatal: $ArtifactId not in libraryDependencies")
               case Some(classpath) =>
                 Seq(
                   "-Xplugin:" + classpath.getAbsolutePath,
-                  "-P:scoverage:excludedPackages:" + Option((excludedPackages in Scoverage).value).getOrElse(""),
+                  "-P:scoverage:excludedPackages:" + Option(excludedPackages.value).getOrElse(""),
                   "-P:scoverage:dataDir:" + target.getAbsolutePath + "/scoverage-data"
                 )
             }
         },
 
-        scalacOptions in(Scoverage, compile) ++= (if ((highlighting in Scoverage).value) List("-Yrangepos") else Nil),
-
-        test in Scoverage := {
-          (test in Scoverage).value
-          streams.value.log.info(s"[scoverage] Waiting for measurement data to sync...")
-          Thread.sleep(2000) // have noticed some delay in writing, hacky but works
-
-          val targetPath = crossTarget.value
-
-          val dataDir = targetPath / "/scoverage-data"
-          val coberturaDir = targetPath / "coverage-report"
-          val reportDir = targetPath / "scoverage-report"
-          coberturaDir.mkdirs()
-          reportDir.mkdirs()
-
-          val coverageFile = IOUtils.coverageFile(dataDir)
-          val measurementFiles = IOUtils.findMeasurementFiles(dataDir)
-
-          streams.value.log.info(s"[scoverage] Reading scoverage instrumentation [$coverageFile]")
-          streams.value.log.info(s"[scoverage] Reading scoverage measurements...")
-
-          val coverage = IOUtils.deserialize(coverageFile)
-          val measurements = IOUtils.invoked(measurementFiles)
-          coverage.apply(measurements)
-
-          streams.value.log
-            .info(s"[scoverage] Generating Cobertura report [${coberturaDir.getAbsolutePath}/cobertura.xml]")
-          new CoberturaXmlWriter(baseDirectory.value, coberturaDir).write(coverage)
-
-          streams.value.log.info(s"[scoverage] Generating XML report [${reportDir.getAbsolutePath}/scoverage.xml]")
-          new ScoverageXmlWriter((scalaSource in Compile).value, reportDir, false).write(coverage)
-          new ScoverageXmlWriter((scalaSource in Compile).value, reportDir, true).write(coverage)
-
-          streams.value.log.info(s"[scoverage] Generating HTML report [${reportDir.getAbsolutePath}/index.html]")
-          new ScoverageHtmlWriter((scalaSource in Compile).value, reportDir).write(coverage)
-
-          streams.value.log.info("[scoverage] Reports completed")
-
-          // check for default minimum
-          val min = (minimumCoverage in Scoverage).value
-          val failOnMin = (failOnMinimumCoverage in Scoverage).value
-          if (min > 0) {
-            def is100(d: Double) = Math.abs(100 - d) <= 0.00001
+        scalacOptions in Scoverage ++= (if (highlighting.value) List("-Yrangepos") else Nil),
+
+        sources in ScoverageTest <<= (sources in Test),
+        sourceDirectory in ScoverageTest <<= (sourceDirectory in Test),
+        resourceDirectory in ScoverageTest <<= (resourceDirectory in Test),
+        resourceGenerators in ScoverageTest <<= (resourceGenerators in Test),
+        unmanagedResources in ScoverageTest <<= (unmanagedResources in Test),
+        javacOptions in ScoverageTest <<= (javacOptions in Test),
+        javaOptions in ScoverageTest <<= (javaOptions in Test),
+        fork in ScoverageTest <<= (fork in Test),
+
+        externalDependencyClasspath in Scoverage <<= Classpaths
+          .concat(externalDependencyClasspath in Scoverage, externalDependencyClasspath in Compile),
+        externalDependencyClasspath in ScoverageTest <<= Classpaths
+          .concat(externalDependencyClasspath in ScoverageTest, externalDependencyClasspath in Test),
+
+        internalDependencyClasspath in Scoverage <<= (internalDependencyClasspath in Compile),
+        internalDependencyClasspath in ScoverageTest <<= (internalDependencyClasspath in Test, internalDependencyClasspath in ScoverageTest, classDirectory in Compile) map {
+          (testDeps, scoverageDeps, oldClassDir) =>
+            scoverageDeps ++ testDeps.filter(_.data != oldClassDir)
+        },
 
-            if (is100(coverage.statementCoveragePercent)) {
-              streams.value.log.info(s"[scoverage] 100% Coverage")
-            } else if (min > coverage.statementCoveragePercent) {
-              streams.value.log
-                .error(s"[scoverage] Coverage is below minimum [${coverage.statementCoverageFormatted}% < $min%]")
-              if (failOnMin)
-                throw new RuntimeException("Coverage minimum was not reached")
-            } else {
-              streams.value.log
-                .info(s"[scoverage] Coverage is above minimum [${coverage.statementCoverageFormatted}% > $min%]")
-            }
-          }
+        testOptions in ScoverageTest <<= (testOptions in Test),
 
-          streams.value.log.info(s"[scoverage] All done. Coverage was [${coverage.statementCoverageFormatted}%]")
-          ()
-        }
+        // copy the test task into compile so we can do scoverage:test instead of scoverage-test:test
+        test in Scoverage <<= (test in ScoverageTest)
       )
   }
 }