Rewrote plugin to remove all 0.12.x era idioms

Author: sksamuel

Diff for: src/main/scala/scoverage/ScoverageSbtPlugin.scala

@@ -1,27 +1,27 @@
 package scoverage
 
-import sbt.Keys._
 import sbt._
-import scoverage.report.{ScoverageHtmlWriter, ScoverageXmlWriter, CoberturaXmlWriter}
+import sbt.Keys._
+import scoverage.report._
 
 object ScoverageSbtPlugin extends ScoverageSbtPlugin
 
 class ScoverageSbtPlugin extends sbt.Plugin {
 
   val OrgScoverage = "org.scoverage"
-  val ArtifactId = "scalac-scoverage-plugin"
+  val ScalacArtifact = "scalac-scoverage-plugin"
   val ScoverageVersion = "0.99.7"
 
   object ScoverageKeys {
     val excludedPackages = SettingKey[String]("scoverage-excluded-packages")
     val minimumCoverage = SettingKey[Double]("scoverage-minimum-coverage")
     val failOnMinimumCoverage = SettingKey[Boolean]("scoverage-fail-on-minimum-coverage")
-    val highlighting = settingKey[Boolean]("enables range positioning for highlighting")
+    val highlighting = SettingKey[Boolean]("scoverage-highlighting", "enables range positioning for highlighting")
   }
 
   import ScoverageKeys._
 
-  lazy val Scoverage: Configuration = config("scoverage") extend Compile
+  lazy val Scoverage: Configuration = config("scoverage")
   lazy val ScoverageTest: Configuration = config("scoverage-test") extend Scoverage
 
   lazy val instrumentSettings: Seq[Setting[_]] = {
@@ -30,7 +30,7 @@ class ScoverageSbtPlugin extends sbt.Plugin {
       Seq(
         ivyConfigurations ++= Seq(Scoverage.hide, ScoverageTest.hide),
         libraryDependencies += {
-          OrgScoverage % (ArtifactId + "_" + scalaBinaryVersion.value) % ScoverageVersion % Scoverage.name
+          OrgScoverage % (ScalacArtifact + "_" + scalaBinaryVersion.value) % ScoverageVersion % Scoverage.name
         },
         sources in Scoverage := (sources in Compile).value,
         sourceDirectory in Scoverage := (sourceDirectory in Compile).value,
@@ -44,15 +44,15 @@ class ScoverageSbtPlugin extends sbt.Plugin {
         highlighting := false,
         excludedPackages in Scoverage := "",
 
-        scalacOptions in Scoverage := {
-            val target = crossTarget.value
-            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")
+        scalacOptions in Scoverage <++= (crossTarget in Compile, update, excludedPackages in Scoverage) map {
+          (target, report, excluded) =>
+            val scoverageDeps = report matching configurationFilter(Scoverage.name)
+            scoverageDeps.find(_.getAbsolutePath.contains(ScalacArtifact)) match {
+              case None => throw new Exception(s"Fatal: $ScalacArtifact not in libraryDependencies")
               case Some(classpath) =>
                 Seq(
                   "-Xplugin:" + classpath.getAbsolutePath,
-                  "-P:scoverage:excludedPackages:" + Option((excludedPackages in Scoverage).value).getOrElse(""),
+                  "-P:scoverage:excludedPackages:" + Option(excluded).getOrElse(""),
                   "-P:scoverage:dataDir:" + target.getAbsolutePath + "/scoverage-data"
                 )
             }
@@ -74,20 +74,16 @@ class ScoverageSbtPlugin extends sbt.Plugin {
         externalDependencyClasspath in ScoverageTest <<= Classpaths
           .concat(externalDependencyClasspath in ScoverageTest, externalDependencyClasspath in Test),
 
-        internalDependencyClasspath in Scoverage <<= (internalDependencyClasspath in Compile),
+        internalDependencyClasspath in Scoverage := (internalDependencyClasspath in Compile).value,
         internalDependencyClasspath in ScoverageTest <<= (internalDependencyClasspath in Test, internalDependencyClasspath in ScoverageTest, classDirectory in Compile) map {
           (testDeps, scoverageDeps, oldClassDir) =>
             scoverageDeps ++ testDeps.filter(_.data != oldClassDir)
         },
 
-        testOptions in ScoverageTest <<= (testOptions in Test),
-
-        // copy the test task into compile so we can do scoverage:test instead of scoverage-test:test
-        test in Scoverage <<= (test in ScoverageTest),
-
-        test in Scoverage := {
-          (test in Scoverage).value
+        testOptions in ScoverageTest := (testOptions in Test).value,
 
+        test in ScoverageTest := {
+          (test in ScoverageTest).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
 
@@ -107,15 +103,16 @@ class ScoverageSbtPlugin extends sbt.Plugin {
           val measurements = IOUtils.invoked(measurementFiles)
           coverage.apply(measurements)
 
-          streams.value.log.info(s"[scoverage] Generating Cobertura report [${coberturaDir.getAbsolutePath}/cobertura.xml]")
-          new CoberturaXmlWriter(baseDirectory in Compile value, coberturaDir).write(coverage)
+          streams.value.log
+            .info(s"[scoverage] Generating Cobertura report [${coberturaDir.getAbsolutePath}/cobertura.xml]")
+          new CoberturaXmlWriter((baseDirectory in Compile).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)
+          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)
+          new ScoverageHtmlWriter((scalaSource in Compile).value, reportDir).write(coverage)
 
           streams.value.log.info("[scoverage] Reports completed")
 
@@ -129,17 +126,22 @@ class ScoverageSbtPlugin extends sbt.Plugin {
             if (is100(min) && 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%]")
+              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%]")
+              streams.value.log
+                .info(s"[scoverage] Coverage is above minimum [${coverage.statementCoverageFormatted}% > $min%]")
             }
           }
 
           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).value
       )
   }
 }