Merge pull request #120 from pdalpra/code-cleanup

sksamuel · sksamuel · commit 7b4f88dcc874 · 2015-07-20T22:40:19.000+01:00
Code cleanup
diff --git a/build.sbt b/build.sbt
@@ -2,43 +2,32 @@ name := "sbt-scoverage"
 
 organization := "org.scoverage"
 
-scalaVersion := "2.10.5"
-
 scalacOptions := Seq("-unchecked", "-deprecation", "-feature", "-encoding", "utf8")
 
 sbtPlugin := true
 
-resolvers <++= isSnapshot(
-  if (_)
-    Seq(Resolver.mavenLocal, Resolver.sonatypeRepo("snapshots"))
-  else
-    Seq()
-)
-
-libraryDependencies ++= Seq(
-  "org.scoverage" %% "scalac-scoverage-plugin" % "1.1.0"
-)
-
-publishTo := {
-  if (isSnapshot.value) {
-    Some(Resolver.sbtPluginRepo("snapshots"))
-  } else {
-    Some(Resolver.sbtPluginRepo("releases"))
-  }
+resolvers ++= {
+  if(isSnapshot.value) Seq(Resolver.mavenLocal, Resolver.sonatypeRepo("snapshots"))
+  else Seq.empty
 }
 
-publishMavenStyle := false
+libraryDependencies += "org.scoverage" %% "scalac-scoverage-plugin" % "1.1.0"
+
+publishTo := Some(
+  if (isSnapshot.value) Resolver.sbtPluginRepo("snapshots")
+  else Resolver.sbtPluginRepo("releases")
+)
 
 publishArtifact in Test := false
 
 licenses +=("Apache-2.0", url("http://www.apache.org/licenses/LICENSE-2.0.html"))
 
 ScriptedPlugin.scriptedSettings
 
-scriptedLaunchOpts := {
-  scriptedLaunchOpts.value ++
-    Seq("-Xmx1024M", "-XX:MaxPermSize=256M", "-Dplugin.version=" + version.value)
-}
+scriptedLaunchOpts ++= Seq(
+  "-Xmx1024M", "-XX:MaxPermSize=256M",
+  "-Dplugin.version=" + version.value
+)
 
 releaseSettings
 
diff --git a/project/plugins.sbt b/project/plugins.sbt
@@ -1,6 +1,4 @@
-resolvers += "sonatype-releases" at "https://oss.sonatype.org/content/repositories/releases/"
-
-libraryDependencies <+= sbtVersion(v => "org.scala-sbt" % "scripted-plugin" % v)
+libraryDependencies += "org.scala-sbt" % "scripted-plugin" % sbtVersion.value
 
 addSbtPlugin("com.typesafe.sbt" % "sbt-pgp" % "0.8.3")
 
diff --git a/src/main/scala/scoverage/ScoverageKeys.scala b/src/main/scala/scoverage/ScoverageKeys.scala
@@ -0,0 +1,20 @@
+package scoverage
+
+import sbt._
+
+object ScoverageKeys {
+  lazy val coverage = taskKey[Unit]("enable compiled code with instrumentation")
+  lazy val coverageOff = taskKey[Unit]("disable compiled code with instrumentation")
+  lazy val coverageReport = taskKey[Unit]("run report generation")
+  lazy val coverageAggregate = taskKey[Unit]("aggregate reports from subprojects")
+  lazy val coverageExcludedPackages = settingKey[String]("regex for excluded packages")
+  lazy val coverageExcludedFiles = settingKey[String]("regex for excluded file paths")
+  lazy val coverageMinimum = settingKey[Double]("scoverage-minimum-coverage")
+  lazy val coverageFailOnMinimum = settingKey[Boolean]("if coverage is less than this value then fail build")
+  lazy val coverageHighlighting = settingKey[Boolean]("enables range positioning for highlighting")
+  lazy val coverageOutputCobertura = settingKey[Boolean]("enables cobertura XML report generation")
+  lazy val coverageOutputXML = settingKey[Boolean]("enables xml report generation")
+  lazy val coverageOutputHTML = settingKey[Boolean]("enables html report generation")
+  lazy val coverageOutputDebug = settingKey[Boolean]("turn on the debug report")
+  lazy val coverageCleanSubprojectFiles = settingKey[Boolean]("removes subproject data after an aggregation")
+}
diff --git a/src/main/scala/scoverage/ScoverageSbtPlugin.scala b/src/main/scala/scoverage/ScoverageSbtPlugin.scala
@@ -4,39 +4,22 @@ import sbt.Keys._
 import sbt._
 import scoverage.report.{CoverageAggregator, CoberturaXmlWriter, ScoverageHtmlWriter, ScoverageXmlWriter}
 
-object ScoverageSbtPlugin extends ScoverageSbtPlugin
-
-class ScoverageSbtPlugin extends sbt.AutoPlugin {
+object ScoverageSbtPlugin extends AutoPlugin {
 
   val OrgScoverage = "org.scoverage"
   val ScalacRuntimeArtifact = "scalac-scoverage-runtime"
   val ScalacPluginArtifact = "scalac-scoverage-plugin"
   val ScoverageVersion = "1.1.0"
-
-  object ScoverageKeys {
-    lazy val coverage = taskKey[Unit]("enable compiled code with instrumentation")
-    lazy val coverageOff = taskKey[Unit]("disable compiled code with instrumentation")
-    lazy val coverageReport = taskKey[Unit]("run report generation")
-    lazy val coverageAggregate = taskKey[Unit]("aggregate reports from subprojects")
-    val coverageExcludedPackages = settingKey[String]("regex for excluded packages")
-    val coverageExcludedFiles = settingKey[String]("regex for excluded file paths")
-    val coverageMinimum = settingKey[Double]("scoverage-minimum-coverage")
-    val coverageFailOnMinimum = settingKey[Boolean]("if coverage is less than this value then fail build")
-    val coverageHighlighting = settingKey[Boolean]("enables range positioning for highlighting")
-    val coverageOutputCobertura = settingKey[Boolean]("enables cobertura XML report generation")
-    val coverageOutputXML = settingKey[Boolean]("enables xml report generation")
-    val coverageOutputHTML = settingKey[Boolean]("enables html report generation")
-    val coverageOutputDebug = settingKey[Boolean]("turn on the debug report")
-    val coverageCleanSubprojectFiles = settingKey[Boolean]("removes subproject data after an aggregation")
-  }
-
+  val autoImport = ScoverageKeys
   var enabled = false
 
-  import ScoverageKeys._
+  import autoImport._
 
   val aggregateFilter = ScopeFilter( inAggregates(ThisProject), inConfigurations(Compile) ) // must be outside of the 'coverageAggregate' task (see: https://github.com/sbt/sbt/issues/1095 or https://github.com/sbt/sbt/issues/780)
 
+  override def requires = plugins.JvmPlugin
   override def trigger = allRequirements
+
   override lazy val projectSettings = Seq(
 
     coverage := {
@@ -49,31 +32,31 @@ class ScoverageSbtPlugin extends sbt.AutoPlugin {
 
     coverageReport := {
       val target = crossTarget.value
-      val s = (streams in Global).value
+      val log = streams.value.log
 
-      streams.value.log.info(s"Waiting for measurement data to sync...")
+      log.info(s"Waiting for measurement data to sync...")
       Thread.sleep(1000) // have noticed some delay in writing on windows, hacky but works
 
-      loadCoverage(target, s) match {
+      loadCoverage(target, log) match {
         case Some(cov) => writeReports(target,
           (sourceDirectories in Compile).value,
           cov,
           coverageOutputCobertura.value,
           coverageOutputXML.value,
           coverageOutputHTML.value,
           coverageOutputDebug.value,
-          s)
-        case None => s.log.warn("No coverage data, skipping reports")
+          log)
+        case None => log.warn("No coverage data, skipping reports")
       }
     },
 
-    testOptions in Test <+= postTestReport,
+    testOptions in Test += postTestReport.value,
 
-    testOptions in IntegrationTest <+= postTestReport,
+    testOptions in IntegrationTest += postTestReport.value,
 
     coverageAggregate := {
-      val s = (streams in Global).value
-      s.log.info(s"Aggregating coverage from subprojects...")
+      val log = streams.value.log
+      log.info(s"Aggregating coverage from subprojects...")
 
       val xmlReportFiles = crossTarget.all(aggregateFilter).value map (_ / "scoverage-report" / Constants.XMLReportFilename) filter (_.isFile())
       CoverageAggregator.aggregate(xmlReportFiles, coverageCleanSubprojectFiles.value) match {
@@ -85,11 +68,11 @@ class ScoverageSbtPlugin extends sbt.AutoPlugin {
             coverageOutputXML.value,
             coverageOutputHTML.value,
             coverageOutputDebug.value,
-            s)
+            log)
           val cfmt = cov.statementCoverageFormatted
-          s.log.info(s"Aggregation complete. Coverage was [$cfmt]")
+          log.info(s"Aggregation complete. Coverage was [$cfmt]")
         case None =>
-          s.log.info("No subproject data to aggregate, skipping reports")
+          log.info("No subproject data to aggregate, skipping reports")
       }
     },
 
@@ -125,26 +108,26 @@ class ScoverageSbtPlugin extends sbt.AutoPlugin {
     coverageCleanSubprojectFiles := true
   )
 
-  private def postTestReport = {
-    (crossTarget, sourceDirectories in Compile, coverageMinimum, coverageFailOnMinimum, coverageOutputCobertura, coverageOutputXML, coverageOutputHTML, coverageOutputDebug, streams in Global) map {
-      (target, compileSources, min, failOnMin, outputCobertura, outputXML, outputHTML, coverageDebug, streams) =>
-        Tests.Cleanup {
-          () => if (enabled) {
-            loadCoverage(target, streams) foreach {
-              c =>
-                writeReports(target,
-                  compileSources,
-                  c,
-                  outputCobertura,
-                  outputXML,
-                  outputHTML,
-                  coverageDebug,
-                  streams)
-                checkCoverage(c, streams, min, failOnMin)
-            }
-            ()
-          }
+  private def postTestReport = Def.task {
+    val log = streams.value.log
+    val target = crossTarget.value
+    Tests.Cleanup {
+      () => if (enabled) {
+        loadCoverage(target, log) foreach { c =>
+          writeReports(
+            target,
+            (sourceDirectories in Compile).value,
+            c,
+            coverageOutputCobertura.value,
+            coverageOutputXML.value,
+            coverageOutputHTML.value,
+            coverageOutputDebug.value,
+            log
+          )
+          checkCoverage(c, log, coverageMinimum.value, coverageFailOnMinimum.value)
         }
+        ()
+      }
     }
   }
 
@@ -174,47 +157,47 @@ class ScoverageSbtPlugin extends sbt.AutoPlugin {
                            coverageOutputXML: Boolean,
                            coverageOutputHTML: Boolean,
                            coverageDebug: Boolean,
-                           s: TaskStreams): Unit = {
-    s.log.info(s"Generating scoverage reports...")
+                           log: Logger): Unit = {
+    log.info(s"Generating scoverage reports...")
 
     val coberturaDir = crossTarget / "coverage-report"
     val reportDir = crossTarget / "scoverage-report"
     coberturaDir.mkdirs()
     reportDir.mkdirs()
 
     if (coverageOutputCobertura) {
-      s.log.info(s"Written Cobertura report [${coberturaDir.getAbsolutePath}/cobertura.xml]")
+      log.info(s"Written Cobertura report [${coberturaDir.getAbsolutePath}/cobertura.xml]")
       new CoberturaXmlWriter(compileSourceDirectories, coberturaDir).write(coverage)
     }
 
     if (coverageOutputXML) {
-      s.log.info(s"Written XML coverage report [${reportDir.getAbsolutePath}/scoverage.xml]")
+      log.info(s"Written XML coverage report [${reportDir.getAbsolutePath}/scoverage.xml]")
       new ScoverageXmlWriter(compileSourceDirectories, reportDir, false).write(coverage)
       if (coverageDebug) {
         new ScoverageXmlWriter(compileSourceDirectories, reportDir, true).write(coverage)
       }
     }
 
     if (coverageOutputHTML) {
-      s.log.info(s"Written HTML coverage report [${reportDir.getAbsolutePath}/index.html]")
+      log.info(s"Written HTML coverage report [${reportDir.getAbsolutePath}/index.html]")
       new ScoverageHtmlWriter(compileSourceDirectories, reportDir).write(coverage)
     }
 
-    s.log.info("Coverage reports completed")
+    log.info("Coverage reports completed")
   }
 
-  private def loadCoverage(crossTarget: File, s: TaskStreams): Option[Coverage] = {
+  private def loadCoverage(crossTarget: File, log: Logger): Option[Coverage] = {
 
     val dataDir = crossTarget / "/scoverage-data"
     val coverageFile = Serializer.coverageFile(dataDir)
 
-    s.log.info(s"Reading scoverage instrumentation [$coverageFile]")
+    log.info(s"Reading scoverage instrumentation [$coverageFile]")
 
     if (coverageFile.exists) {
 
       val coverage = Serializer.deserialize(coverageFile)
 
-      s.log.info(s"Reading scoverage measurements...")
+      log.info(s"Reading scoverage measurements...")
       val measurementFiles = IOUtils.findMeasurementFiles(dataDir)
       val measurements = IOUtils.invoked(measurementFiles)
       coverage.apply(measurements)
@@ -226,7 +209,7 @@ class ScoverageSbtPlugin extends sbt.AutoPlugin {
   }
 
   private def checkCoverage(coverage: Coverage,
-                            s: TaskStreams,
+                            log: Logger,
                             min: Double,
                             failOnMin: Boolean): Unit = {
 
@@ -238,16 +221,16 @@ class ScoverageSbtPlugin extends sbt.AutoPlugin {
       def is100(d: Double) = Math.abs(100 - d) <= 0.00001
 
       if (is100(min) && is100(cper)) {
-        s.log.info(s"100% Coverage !")
+        log.info(s"100% Coverage !")
       } else if (min > cper) {
-        s.log.error(s"Coverage is below minimum [$cfmt% < $min%]")
+        log.error(s"Coverage is below minimum [$cfmt% < $min%]")
         if (failOnMin)
           throw new RuntimeException("Coverage minimum was not reached")
       } else {
-        s.log.info(s"Coverage is above minimum [$cfmt% > $min%]")
+        log.info(s"Coverage is above minimum [$cfmt% > $min%]")
       }
     }
 
-    s.log.info(s"All done. Coverage was [$cfmt%]")
+    log.info(s"All done. Coverage was [$cfmt%]")
   }
 }
diff --git a/src/sbt-test/scoverage/bad-coverage/build.sbt b/src/sbt-test/scoverage/bad-coverage/build.sbt
@@ -4,6 +4,6 @@ scalaVersion := "2.10.4"
 
 libraryDependencies += "org.specs2" %% "specs2" % "2.3.13" % "test"
 
-ScoverageSbtPlugin.ScoverageKeys.coverageMinimum := 80
+coverageMinimum := 80
 
-ScoverageSbtPlugin.ScoverageKeys.coverageFailOnMinimum := true
+coverageFailOnMinimum := true
diff --git a/src/sbt-test/scoverage/coverage-off/build.sbt b/src/sbt-test/scoverage/coverage-off/build.sbt
@@ -4,6 +4,6 @@ scalaVersion := "2.10.4"
 
 libraryDependencies += "org.specs2" %% "specs2" % "2.3.13" % "test"
 
-ScoverageSbtPlugin.ScoverageKeys.coverageMinimum := 80
+coverageMinimum := 80
 
-ScoverageSbtPlugin.ScoverageKeys.coverageFailOnMinimum := true
+coverageFailOnMinimum := true
diff --git a/src/sbt-test/scoverage/good-coverage/build.sbt b/src/sbt-test/scoverage/good-coverage/build.sbt
@@ -4,6 +4,6 @@ scalaVersion := "2.10.4"
 
 libraryDependencies += "org.specs2" %% "specs2" % "2.3.13" % "test"
 
-ScoverageSbtPlugin.ScoverageKeys.coverageMinimum := 80
+coverageMinimum := 80
 
-ScoverageSbtPlugin.ScoverageKeys.coverageFailOnMinimum := true
+coverageFailOnMinimum := true
