ScoverageSbtPlugin.scala

package scoverage

import sbt.Keys._
import sbt._
import sbt.internal.util.Util.isWindows
import sbt.plugins.JvmPlugin
import scoverage.reporter.CoberturaXmlWriter
import scoverage.domain.Constants
import scoverage.domain.Coverage
import scoverage.domain.Statement
import scoverage.reporter.CoverageAggregator
import scoverage.reporter.IOUtils
import scoverage.reporter.ScoverageHtmlWriter
import scoverage.reporter.ScoverageXmlWriter
import scoverage.serialize.Serializer

import java.time.Instant
import scala.util.Try
import scala.util.matching.Regex

object ScoverageSbtPlugin extends AutoPlugin {

  val orgScoverage = "org.scoverage"
  val scalacRuntimeArtifact = "scalac-scoverage-runtime"
  val scalacPluginArtifact = "scalac-scoverage-plugin"
  val scalacDomainArtifact = "scalac-scoverage-domain"
  val scalacReporterArtifact = "scalac-scoverage-reporter"
  val scalacSerializerArtifact = "scalac-scoverage-serializer"
  val defaultScoverageVersion = BuildInfo.scoverageVersion
  val autoImport = ScoverageKeys
  lazy val ScoveragePluginConfig = config("scoveragePlugin").hide

  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: JvmPlugin.type = plugins.JvmPlugin
  override def trigger: PluginTrigger = allRequirements

  override def globalSettings: Seq[Def.Setting[_]] =
    super.globalSettings ++ Seq(
      coverageEnabled := false,
      coverageExcludedPackages := "",
      coverageExcludedFiles := "",
      coverageMinimumStmtTotal := 0,
      coverageMinimumBranchTotal := 0,
      coverageMinimumStmtPerPackage := 0,
      coverageMinimumBranchPerPackage := 0,
      coverageMinimumStmtPerFile := 0,
      coverageMinimumBranchPerFile := 0,
      coverageFailOnMinimum := false,
      coverageHighlighting := true,
      coverageOutputXML := true,
      coverageOutputHTML := true,
      coverageOutputCobertura := true,
      coverageOutputDebug := false,
      coverageOutputTeamCity := false,
      coverageScalacPluginVersion := defaultScoverageVersion,
      coverageSourceRoot := (ThisBuild / baseDirectory).value
    )

  override def buildSettings: Seq[Setting[_]] = super.buildSettings ++
    addCommandAlias("coverage", ";set ThisBuild / coverageEnabled := true") ++
    addCommandAlias("coverageOn", ";set ThisBuild / coverageEnabled := true") ++
    addCommandAlias("coverageOff", ";set ThisBuild / coverageEnabled := false")

  override def projectSettings: Seq[Setting[_]] = Seq(
    ivyConfigurations += ScoveragePluginConfig,
    coverageReport := coverageReport0.value,
    coverageAggregate := coverageAggregate0.value,
    coverageAggregate / aggregate := false,
    coverageDataDir := crossTarget.value
  ) ++ coverageSettings ++ scalacSettings

  private def isScala2(scalaVersion: String) =
    CrossVersion
      .partialVersion(scalaVersion)
      .collect { case (2, _) =>
        true
      }
      .getOrElse(false)

  private def isScala3SupportingScoverage(scalaVersion: String) =
    CrossVersion
      .partialVersion(scalaVersion)
      .collect {
        case (3, minor) if minor >= 2 => true
      }
      .getOrElse(false)

  private lazy val coverageSettings = Seq(
    libraryDependencies ++= {
      if (coverageEnabled.value && isScala2(scalaVersion.value)) {
        Seq(
          orgScoverage %% scalacDomainArtifact % coverageScalacPluginVersion.value,
          orgScoverage %% scalacReporterArtifact % coverageScalacPluginVersion.value,
          orgScoverage %% scalacSerializerArtifact % coverageScalacPluginVersion.value,
          // 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
          )) % coverageScalacPluginVersion.value,
          // We don't want to instrument the test code itself, nor add to a pom when published with coverage enabled.
          (orgScoverage %% scalacPluginArtifact % coverageScalacPluginVersion.value % ScoveragePluginConfig.name)
            .cross(CrossVersion.full)
        )
      } else
        Nil
    }
  )

  private lazy val scalacSettings = Seq(
    Compile / compile / scalacOptions ++= {

      implicit val log = streams.value.log

      val updateReport = update.value
      if (coverageEnabled.value && isScala2(scalaVersion.value)) {
        val scoverageDeps: Seq[File] =
          updateReport.matching(configurationFilter(ScoveragePluginConfig.name))

        // Since everything isn't contained in a single plugin jar since we
        // want to share reporter/domain code between the plugin and the
        // reporter which can be used for Scala3 we need to essentially put
        // together the little classpath to pass in to the compiler which
        // includes everything it needs for the compiler plugin phase:
        //  1. the plugin jar
        //  2. the domain jar
        //  3. the serializer jar
        //  NOTE: Even though you'd think that since plugin relies on domain
        //  it'd just auto include it... it doesn't.
        //  https://github.com/sbt/sbt/issues/2255
        val pluginPaths = scoverageDeps.collect {
          case path
              if path.getAbsolutePath().contains(scalacPluginArtifact) || path
                .getAbsolutePath()
                .contains(scalacDomainArtifact) ||
                path.getAbsolutePath().contains(scalacSerializerArtifact) =>
            path.getAbsolutePath()
        }

        // NOTE: A little hacky, but make sure we are matching on the exact
        // number of deps that we expect to collect up above.
        if (pluginPaths.size != 3)
          throw new Exception(
            s"Fatal: Not finding either $scalacDomainArtifact or $scalacPluginArtifact or $scalacSerializerArtifact in libraryDependencies."
          )

        Seq(
          Some(
            s"-Xplugin:${pluginPaths.mkString(java.io.File.pathSeparator)}"
          ),
          Some(
            s"-P:scoverage:dataDir:${coverageDataDir.value.getAbsolutePath}/scoverage-data"
          ),
          Some(
            s"-P:scoverage:sourceRoot:${coverageSourceRoot.value.getAbsolutePath}"
          ),
          Option(coverageExcludedPackages.value.trim)
            .filter(_.nonEmpty)
            .map(v => s"-P:scoverage:excludedPackages:$v"),
          Option(coverageExcludedFiles.value.trim)
            .filter(_.nonEmpty)
            .map(v =>
              // On windows, replace unix file separators with windows file
              // separators. Note that we need to replace / with \\ because
              // the plugin treats this string as a regular expression and
              // backslashes must be escaped in regular expressions.
              if (isWindows) v.replace("/", """\\""") else v
            )
            .map(v => s"-P:scoverage:excludedFiles:$v"),
          Some("-P:scoverage:reportTestName"),
          // rangepos is broken in some releases of scala so option to turn it off
          if (coverageHighlighting.value) Some("-Yrangepos") else None
        ).flatten
      } else if (
        coverageEnabled.value && isScala3SupportingScoverage(scalaVersion.value)
      ) {
        Seq(
          s"-coverage-out:${coverageDataDir.value.getAbsolutePath()}/scoverage-data"
        )
      } else if (coverageEnabled.value && !isScala2(scalaVersion.value)) {
        log.warn(
          "coverage in Scala 3 needs at least 3.2.x. Please update your Scala version and try again."
        )
        Nil
      } else {
        Nil
      }
    }
  )

  private def scalacRuntime(deps: Seq[ModuleID]): String = {
    scalacRuntimeArtifact + optionalScalaJsSuffix(deps)
  }

  // returns "_sjs$sjsVersion" for Scala.js projects or "" otherwise
  private def optionalScalaJsSuffix(deps: Seq[ModuleID]): String = {
    val sjsClassifier = deps
      .collectFirst {
        case moduleId
            if moduleId.organization == "org.scala-js" && moduleId.name == "scalajs-library" =>
          moduleId.revision
      }
      .map(_.take(1))
      .map(sjsVersion => "_sjs" + sjsVersion)

    sjsClassifier getOrElse ""
  }

  private lazy val coverageReport0 = Def.task {
    val target = coverageDataDir.value
    implicit val log = streams.value.log

    log.info(s"Waiting for measurement data to sync...")
    if (System.getProperty("os.name").toLowerCase.contains("windows")) {
      Thread.sleep(
        1000
      ) // have noticed some delay in writing on windows, hacky but works
    }

    loadCoverage(
      target,
      log,
      coverageSourceRoot.value.getAbsoluteFile()
    ) match {
      case Some(cov) =>
        val coverage = if (isScala3SupportingScoverage(scalaVersion.value)) {
          filterCoverage(
            cov,
            coverageExcludedFiles.value,
            coverageExcludedPackages.value,
            log
          )
        } else cov

        writeReports(
          target,
          (Compile / sourceDirectories).value,
          coverage,
          coverageOutputCobertura.value,
          coverageOutputXML.value,
          coverageOutputHTML.value,
          coverageOutputDebug.value,
          coverageOutputTeamCity.value,
          sourceEncoding((Compile / scalacOptions).value),
          log
        )

        CoverageMinimum.all.value
          .checkCoverage(coverage, coverageFailOnMinimum.value)
      case None => log.warn("No coverage data, skipping reports")
    }
  }

  private lazy val coverageAggregate0 = Def.task {
    implicit val log = streams.value.log
    log.info(s"Aggregating coverage from subprojects...")

    val dataDirs = coverageDataDir.?.all(aggregateFilter).value
      .collect {
        case Some(file) if (file / Constants.DataDir).isDirectory =>
          file / Constants.DataDir
      }

    CoverageAggregator.aggregate(dataDirs, coverageSourceRoot.value) match {
      case Some(cov) =>
        val coverage = if (isScala3SupportingScoverage(scalaVersion.value)) {
          filterCoverage(
            cov,
            coverageExcludedFiles.value,
            coverageExcludedPackages.value,
            log
          )
        } else cov

        writeReports(
          coverageDataDir.value,
          sourceDirectories.all(aggregateFilter).value.flatten,
          coverage,
          coverageOutputCobertura.value,
          coverageOutputXML.value,
          coverageOutputHTML.value,
          coverageOutputDebug.value,
          coverageOutputTeamCity.value,
          sourceEncoding((Compile / scalacOptions).value),
          log
        )
        val cfmt = coverage.statementCoverageFormatted
        log.info(s"Aggregation complete. Coverage was [$cfmt]")

        CoverageMinimum.all.value
          .checkCoverage(coverage, coverageFailOnMinimum.value)
      case None =>
        log.info("No subproject data to aggregate, skipping reports")
    }
  }

  private def compileRegex(regexString: String): Option[Regex] =
    Try(regexString.r).toOption

  private def asRegexList(strSetting: String) = strSetting
    .split(';')
    .map(_.trim)
    .filter(_.nonEmpty)
    .flatMap(compileRegex)

  private def filterStatements(
      statements: Iterable[Statement],
      excludedFiles: Array[Regex],
      excludedPackages: Array[Regex],
      log: Logger
  ) = statements
    .groupBy { statement =>
      (statement.location.sourcePath, statement.location.fullClassName)
    }
    .filterKeys { case t @ (sourcePath, fullClassName) =>
      val preserveSource = excludedFiles.isEmpty || excludedFiles.forall(
        _.findFirstMatchIn(sourcePath).isEmpty
      )
      val preservePackage = excludedPackages.isEmpty || excludedPackages
        .forall(_.findFirstMatchIn(fullClassName).isEmpty)
      if (!preserveSource) log.info(s"Excluded file from report: $sourcePath")
      if (!preservePackage)
        log.info(s"Excluded package from report: $fullClassName")
      preserveSource && preservePackage
    }
    .values
    .flatten

  private def filterCoverage(
      originalCoverage: Coverage,
      excludedFilesSetting: String,
      excludedPackagesSetting: String,
      log: Logger
  ): Coverage = {

    val excludedFiles: Array[Regex] = asRegexList(excludedFilesSetting)
    val excludedPackages: Array[Regex] = asRegexList(excludedPackagesSetting)

    if (excludedFiles.isEmpty && excludedPackages.isEmpty) {
      log.debug("Skipping filter")
      originalCoverage
    } else {
      log.debug("Applying filter")
      val updatedCoverage = Coverage()

      filterStatements(
        originalCoverage.statements,
        excludedFiles,
        excludedPackages,
        log
      ).foreach(updatedCoverage.add)

      filterStatements(
        originalCoverage.ignoredStatements,
        excludedFiles,
        excludedPackages,
        log
      ).foreach(updatedCoverage.addIgnoredStatement)

      updatedCoverage
    }
  }

  private def writeReports(
      crossTarget: File,
      compileSourceDirectories: Seq[File],
      coverage: Coverage,
      coverageOutputCobertura: Boolean,
      coverageOutputXML: Boolean,
      coverageOutputHTML: Boolean,
      coverageDebug: Boolean,
      coverageOutputTeamCity: Boolean,
      coverageSourceEncoding: Option[String],
      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) {
      new CoberturaXmlWriter(
        compileSourceDirectories,
        coberturaDir,
        coverageSourceEncoding
      ).write(
        coverage
      )
      log.info(
        s"Written Cobertura report [${coberturaDir.getAbsolutePath}/cobertura.xml]"
      )
    }

    if (coverageOutputXML) {
      new ScoverageXmlWriter(
        compileSourceDirectories,
        reportDir,
        false,
        coverageSourceEncoding
      ).write(
        coverage
      )
      if (coverageDebug) {
        new ScoverageXmlWriter(
          compileSourceDirectories,
          reportDir,
          true,
          coverageSourceEncoding
        ).write(
          coverage
        )
      }
      log.info(
        s"Written XML coverage report [${reportDir.getAbsolutePath}/scoverage.xml]"
      )
    }

    if (coverageOutputHTML) {
      new ScoverageHtmlWriter(
        compileSourceDirectories,
        reportDir,
        coverageSourceEncoding
      ).write(coverage)
      log.info(
        s"Written HTML coverage report [${reportDir.getAbsolutePath}/index.html]"
      )
    }
    if (coverageOutputTeamCity) {
      reportToTeamcity(
        coverage,
        coverageOutputHTML,
        reportDir,
        crossTarget,
        log
      )
      log.info("Written coverage report to TeamCity")
    }

    log.info(s"Statement coverage.: ${coverage.statementCoverageFormatted}%")
    log.info(s"Branch coverage....: ${coverage.branchCoverageFormatted}%")
    log.info("Coverage reports completed")
  }

  private def reportToTeamcity(
      coverage: Coverage,
      createCoverageZip: Boolean,
      reportDir: File,
      crossTarget: File,
      log: Logger
  ) {

    def statsKeyValue(key: String, value: Int): String =
      s"##teamcity[buildStatisticValue key='$key' value='$value']"

    // Log statement coverage as per: https://devnet.jetbrains.com/message/5467985
    log.info(
      statsKeyValue("CodeCoverageAbsSCovered", coverage.invokedStatementCount)
    )
    log.info(statsKeyValue("CodeCoverageAbsSTotal", coverage.statementCount))
    log.info(
      statsKeyValue("CodeCoverageAbsRCovered", coverage.invokedBranchesCount)
    )
    log.info(statsKeyValue("CodeCoverageAbsRTotal", coverage.branchCount))

    // Log branch coverage as a custom metrics (in percent)
    log.info(
      statsKeyValue(
        "CodeCoverageBranch",
        "%.0f".format(coverage.branchCoveragePercent).toInt
      )
    )

    // Create the coverage report for teamcity (HTML files)
    if (createCoverageZip)
      IO.zip(
        Path.allSubpaths(reportDir),
        crossTarget / "coverage.zip",
        Some(Instant.now().toEpochMilli())
      )
  }

  private def loadCoverage(
      crossTarget: File,
      log: Logger,
      sourceRoot: File
  ): Option[Coverage] = {

    val dataDir = crossTarget / "/scoverage-data"
    val coverageFile = Serializer.coverageFile(dataDir)

    log.info(s"Reading scoverage instrumentation [$coverageFile]")

    if (coverageFile.exists) {

      val coverage = Serializer.deserialize(
        coverageFile,
        sourceRoot
      )

      log.info(s"Reading scoverage measurements...")
      val measurementFiles = IOUtils.findMeasurementFiles(dataDir)
      val measurements = IOUtils.invoked(measurementFiles)
      coverage.apply(measurements)
      Some(coverage)

    } else {
      None
    }
  }

  private def sourceEncoding(scalacOptions: Seq[String]): Option[String] = {
    val i = scalacOptions.indexOf("-encoding") + 1
    if (i > 0 && i < scalacOptions.length) Some(scalacOptions(i)) else None
  }

}