Unify commands by removing toggleCoverage

Author: Alistair-Johnson

src/main/scala/scoverage/ScoverageSbtPlugin.scala

@@ -24,55 +24,70 @@ object ScoverageSbtPlugin extends AutoPlugin {
   override def requires: JvmPlugin.type = plugins.JvmPlugin
   override def trigger: PluginTrigger = allRequirements
 
-  override lazy val projectSettings = {
-    if (cmdlineScoverageEnabled == "true") {
-      Seq(
-        coverageEnabled := true,
-        libraryDependencies ++= Seq(
-          OrgScoverage %% ScalacPluginArtifact % DefaultScoverageVersion % "provided" intransitive(),
-          OrgScoverage % (ScalacRuntimeArtifact + runtimeClassifier(libraryDependencies.value, scalaBinaryVersion.value)) % DefaultScoverageVersion % "provided" intransitive()
-        ),
-        coverageReport <<= coverageReport0,
-        coverageAggregate <<= coverageAggregate0,
-        scalacOptions in(Compile, compile) ++= scoverageScalacOptions.value,
-        aggregate in coverageAggregate := false,
-        coverageExcludedPackages := "",
-        coverageExcludedFiles := "",
-        coverageMinimum := 0, // default is no minimum
-        coverageFailOnMinimum := false,
-        coverageHighlighting := true,
-        coverageOutputXML := true,
-        coverageOutputHTML := true,
-        coverageOutputCobertura := true,
-        coverageOutputDebug := false,
-        coverageCleanSubprojectFiles := true,
-        coverageOutputTeamCity := false
-      )
-    } else if (cmdlineScoverageEnabled == "false") {
-      Seq()
-    } else {
-      // keep it as before, warts'n all
-      Seq(
-        coverageEnabled := false,
-        commands += Command.command("coverage", "enable compiled code with instrumentation", "")(toggleCoverage(true)),
-        commands += Command.command("coverageOff", "disable compiled code with instrumentation", "")(toggleCoverage(false)),
-        coverageReport <<= coverageReport0,
-        coverageAggregate <<= coverageAggregate0,
-        scalacOptions in(Compile, compile) ++= scoverageScalacOptions.value,
-        aggregate in coverageAggregate := false,
-        coverageExcludedPackages := "",
-        coverageExcludedFiles := "",
-        coverageMinimum := 0, // default is no minimum
-        coverageFailOnMinimum := false,
-        coverageHighlighting := true,
-        coverageOutputXML := true,
-        coverageOutputHTML := true,
-        coverageOutputCobertura := true,
-        coverageOutputDebug := false,
-        coverageCleanSubprojectFiles := true,
-        coverageOutputTeamCity := false
-      )
+  override def globalSettings: Seq[Def.Setting[_]] = super.globalSettings ++ Seq(
+    coverageEnabled := false,
+    coverageExcludedPackages := "",
+    coverageExcludedFiles := "",
+    coverageMinimum := 0, // default is no minimum
+    coverageFailOnMinimum := false,
+    coverageHighlighting := true,
+    coverageOutputXML := true,
+    coverageOutputHTML := true,
+    coverageOutputCobertura := true,
+    coverageOutputDebug := false,
+    coverageCleanSubprojectFiles := true,
+    coverageOutputTeamCity := false
+  )
+
+  override def buildSettings: Seq[Setting[_]] = super.buildSettings ++
+    addCommandAlias("coverage", ";set coverageEnabled in ThisBuild := true") ++
+    addCommandAlias("coverageOn", ";set coverageEnabled in ThisBuild := true") ++
+    addCommandAlias("coverageOff", ";set coverageEnabled in ThisBuild := false")
+
+  override def projectSettings: Seq[Setting[_]] = Seq(
+    coverageReport <<= coverageReport0,
+    coverageAggregate <<= coverageAggregate0
+  ) ++ coverageSettings ++ scalacSettings
+
+  private lazy val coverageSettings = Seq(
+    libraryDependencies  ++= {
+      if (coverageEnabled.value)
+        Seq(
+          // We only add for "compile"" because of macros. This setting could be optimed to just "test" if the handling
+          // of macro coverage was improved.
+          OrgScoverage % (scalacRuntime(libraryDependencies.value, scalaBinaryVersion.value)) % DefaultScoverageVersion,
+          // We don't want to instrument the test code itself
+          OrgScoverage %% ScalacPluginArtifact % DefaultScoverageVersion  % "compile"
+        )
+      else
+        Nil
+    }
+  )
+
+  private lazy val scalacSettings = Seq(
+    scalacOptions in(Compile, compile) ++= {
+      if (coverageEnabled.value) {
+        val scoverageDeps: Seq[File] = update.value matching configurationFilter("compile")
+        val pluginPath: File =  scoverageDeps.find(_.getAbsolutePath.contains(ScalacPluginArtifact)) match {
+          case None => throw new Exception(s"Fatal: $ScalacPluginArtifact not in libraryDependencies")
+          case Some(pluginPath) => pluginPath
+        }
+        Seq(
+          Some(s"-Xplugin:${pluginPath.getAbsolutePath}"),
+          Some(s"-P:scoverage:dataDir:${crossTarget.value.getAbsolutePath}/scoverage-data"),
+          Option(coverageExcludedPackages.value.trim).filter(_.nonEmpty).map(v => s"-P:scoverage:excludedPackages:$v"),
+          Option(coverageExcludedFiles.value.trim).filter(_.nonEmpty).map(v => s"-P:scoverage:excludedFiles:$v"),
+          // rangepos is broken in some releases of scala so option to turn it off
+          if (coverageHighlighting.value) Some("-Yrangepos") else None
+        ).flatten
+      } else {
+        Nil
+      }
     }
+  )
+
+  private def scalacRuntime(deps: Seq[ModuleID], binaryVersion:String): String = {
+    ScalacRuntimeArtifact + runtimeClassifier(deps, binaryVersion)
   }
 
   private def runtimeClassifier(deps: Seq[ModuleID], binaryVersion:String): String = {
@@ -83,26 +98,6 @@ object ScoverageSbtPlugin extends AutoPlugin {
     sjsClassifier getOrElse "_" + binaryVersion
   }
 
-  /**
-    * The "coverage" command enables or disables instrumentation for all projects
-    * in the build.
-    */
-  private def toggleCoverage(status: Boolean): State => State = { state =>
-    val extracted = Project.extract(state)
-    val newSettings = extracted.structure.allProjectRefs flatMap { proj =>
-      Seq(
-        coverageEnabled in proj := status,
-        libraryDependencies in proj ++= {
-          if (status) Seq(
-            OrgScoverage % (ScalacRuntimeArtifact + "_" + scalaBinaryVersion.value) % DefaultScoverageVersion % "provided" intransitive(),
-            OrgScoverage % (ScalacPluginArtifact + "_" + scalaBinaryVersion.value) % DefaultScoverageVersion % "provided" intransitive()
-          ) else Nil
-        }
-      )
-    }
-    extracted.append(newSettings, state)
-  }
-
   private lazy val coverageReport0 = Def.task {
     val target = crossTarget.value
     val log = streams.value.log
@@ -157,40 +152,6 @@ object ScoverageSbtPlugin extends AutoPlugin {
     }
   }
 
-  private lazy val scoverageScalacOptions = Def.task {
-    val scoverageDeps: Seq[File] = update.value matching configurationFilter("provided")
-    scoverageDeps.find(_.getAbsolutePath.contains(ScalacPluginArtifact)) match {
-      case None => throw new Exception(s"Fatal: $ScalacPluginArtifact not in libraryDependencies")
-      case Some(pluginPath) =>
-        scalaArgs(coverageEnabled.value,
-          pluginPath,
-          crossTarget.value,
-          coverageExcludedPackages.value,
-          coverageExcludedFiles.value,
-          coverageHighlighting.value)
-    }
-  }
-
-  private def scalaArgs(coverageEnabled: Boolean,
-                        pluginPath: File,
-                        target: File,
-                        excludedPackages: String,
-                        excludedFiles: String,
-                        coverageHighlighting: Boolean) = {
-    if (coverageEnabled) {
-      Seq(
-        Some(s"-Xplugin:${pluginPath.getAbsolutePath}"),
-        Some(s"-P:scoverage:dataDir:${target.getAbsolutePath}/scoverage-data"),
-        Option(excludedPackages.trim).filter(_.nonEmpty).map(v => s"-P:scoverage:excludedPackages:$v"),
-        Option(excludedFiles.trim).filter(_.nonEmpty).map(v => s"-P:scoverage:excludedFiles:$v"),
-        // rangepos is broken in some releases of scala so option to turn it off
-        if (coverageHighlighting) Some("-Yrangepos") else None
-      ).flatten
-    } else {
-      Nil
-    }
-  }
-
   private def writeReports(crossTarget: File,
                            compileSourceDirectories: Seq[File],
                            coverage: Coverage,