Differentiate unset mimaPreviousArtifacts from empty mimaPreviou… (#334)

Differentiate unset mimaPreviousArtifacts from empty mimaPreviousArtifacts

Author: dwijnand

README.md

@@ -83,33 +83,3 @@ mimaBinaryIssueFilters ++= Seq(
   ProblemFilters.exclude[Problem]("com.example.mylibrary.internal.*"),
 )
 ```
-
-## Make mimaReportBinaryIssues not fail
-
-The setting `mimaFailOnNoPrevious` (introduced in v0.4.0) defaults to `true` and will make
-`mimaReportBinaryIssues` fail if `mimaPreviousArtifacts` is empty.
-
-To make `mimaReportBinaryIssues` not fail you may want to do one of the following:
-
-* set `mimaPreviousArtifacts` on all the projects that should be checking their binary compatibility
-* set `mimaFailOnNoPrevious := false` on specific projects that want to opt-out (alternatively `disablePlugins(MimaPlugin)`)
-* set `mimaFailOnNoPrevious in ThisBuild := false`, which disables it build-wide, effectively reverting back to the previous behaviour
-
-You may want to redefine `mimaFailOnNoPrevious` in your build to be conditional on something else.  For
-instance, if you have already ported your project to Scala 2.13 and set it up for cross-building to Scala 2.13,
-but still haven't cut a release, you may want to redefine `mimaFailOnNoPrevious` according to the Scala version,
-with something like:
-
-```scala
-// fail MiMa if no mimaPreviousArtifacts is set and NOT on Scala 2.13
-mimaFailOnNoPrevious in ThisBuild := CrossVersion.partialVersion(scalaVersion.scala) != Some((2, 13))
-```
-
-or perhaps using some of sbt 1.2's new API:
-
-```scala
-import sbt.librarymanagement.{ SemanticSelector, VersionNumber }
-
-// fail MiMa if no mimaPreviousArtifacts is set and on Scala <2.13
-mimaFailOnNoPrevious in ThisBuild := VersionNumber(scalaVersion.value).matchesSemVer(SemanticSelector("<2.13"))
-```

sbtplugin/src/main/scala/com/typesafe/tools/mima/plugin/MimaKeys.scala

@@ -8,7 +8,6 @@ object MimaKeys extends MimaKeys
 class MimaKeys {
 
   final val mimaFailOnProblem      = settingKey[Boolean]("if true, fail the build on binary incompatibility detection.")
-  final val mimaFailOnNoPrevious   = settingKey[Boolean]("if true, fail the build if no previous artifacts are set.")
   final val mimaPreviousArtifacts  = settingKey[Set[ModuleID]]("Previous released artifacts used to test binary compatibility.")
   final val mimaPreviousClassfiles = taskKey[Map[ModuleID, File]]("Directories or jars containing the previous class files used to test compatibility with a given module.")
   final val mimaCurrentClassfiles  = taskKey[File]("Directory or jar containing the current class files used to test compatibility.")
@@ -23,4 +22,7 @@ class MimaKeys {
 
   final val mimaCheckDirection = settingKey[String]("Compatibility checking direction; default is \"backward\", but can also be \"forward\" or \"both\".")
 
+  @deprecated("No longer used", "0.5.0")
+  final val mimaFailOnNoPrevious = MimaPlugin.mimaFailOnNoPrevious
+
 }

sbtplugin/src/main/scala/com/typesafe/tools/mima/plugin/MimaPlugin.scala

@@ -52,45 +52,82 @@ object MimaPlugin extends AutoPlugin {
   /** Setup mima with default settings, applicable for most projects. */
   def mimaDefaultSettings: Seq[Setting[_]] = Seq(
     mimaFailOnProblem := true,
-    mimaPreviousArtifacts := Set.empty,
+    mimaPreviousArtifacts := NoPreviousArtifacts,
     mimaCurrentClassfiles := (classDirectory in Compile).value,
     mimaPreviousClassfiles := {
       val scalaModuleInfoV = scalaModuleInfo.value
       val ivy = ivySbt.value
       val taskStreams = streams.value
-
-      mimaPreviousArtifacts.value.iterator.map { m =>
-        val id = CrossVersion(m, scalaModuleInfoV) match {
-          case Some(f) => m.withName(f(Project.normalizeModuleID(m.name)))
-          case None    => m // no module id normalization if it's fully declaring it (using "%")
-        }
-        id -> SbtMima.getPreviousArtifact(id, ivy, taskStreams)
-      }.toMap
+      mimaPreviousArtifacts.value match {
+        case _: NoPreviousArtifacts.type => NoPreviousClassfiles
+        case previousArtifacts =>
+          previousArtifacts.iterator.map { m =>
+            val id = CrossVersion(m, scalaModuleInfoV) match {
+              case Some(f) => m.withName(f(Project.normalizeModuleID(m.name)))
+              case None    => m // no module id normalization if it's fully declaring it (using "%")
+            }
+            id -> SbtMima.getPreviousArtifact(id, ivy, taskStreams)
+          }.toMap
+      }
     },
     fullClasspath in mimaFindBinaryIssues := (fullClasspath in Compile).value
   ) ++ mimaReportSettings
 
   // Allows reuse between mimaFindBinaryIssues and mimaReportBinaryIssues
   // without blowing up the Akka build's heap
   private def binaryIssuesIterator = Def.task {
-    val log = new SbtLogger(streams.value)
+    val s = streams.value
+    val log = new SbtLogger(s)
     val projectName = name.value
-    val previousClassfiles = mimaPreviousClassfiles.value
-    val failOnNoPrevious = mimaFailOnNoPrevious.value
     val currentClassfiles = mimaCurrentClassfiles.value
     val cp = (fullClasspath in mimaFindBinaryIssues).value
     val checkDirection = mimaCheckDirection.value
-    if (previousClassfiles.isEmpty) {
-      val msg = s"$projectName: mimaPreviousArtifacts not set, not analyzing binary compatibility. See https://github.com/lightbend/mima#make-mimareportbinaryissues-not-fail"
-      if (failOnNoPrevious) sys.error(msg)
-      log.info(msg)
-      Iterator.empty
-    }
-    else {
-      previousClassfiles.iterator.map { case (moduleId, file) =>
-        val problems = SbtMima.runMima(file, currentClassfiles, cp, checkDirection, log)
-        (moduleId, (problems._1, problems._2))
-      }
+    mimaPreviousClassfiles.value match {
+      case _: NoPreviousClassfiles.type =>
+        sys.error(s"$projectName: mimaPreviousArtifacts not set, not analyzing binary compatibility.")
+      case previousClassfiles if previousClassfiles.isEmpty =>
+        s.log.info(s"$projectName: mimaPreviousArtifacts is empty, not analyzing binary compatibility.")
+        Iterator.empty
+      case previousClassfiles =>
+        previousClassfiles.iterator.map { case (moduleId, file) =>
+          val problems = SbtMima.runMima(file, currentClassfiles, cp, checkDirection, log)
+          (moduleId, (problems._1, problems._2))
+        }
     }
   }
+
+  // Used to differentiate unset mimaPreviousArtifacts from empty mimaPreviousArtifacts
+  private object NoPreviousArtifacts extends EmptySet[ModuleID]
+  private object NoPreviousClassfiles extends EmptyMap[ModuleID, File]
+
+  private sealed class EmptySet[A] extends Set[A] {
+    def iterator          = Iterator.empty
+    def contains(elem: A) = false
+    def + (elem: A)       = Set(elem)
+    def - (elem: A)       = this
+
+    override def size                  = 0
+    override def foreach[U](f: A => U) = ()
+    override def toSet[B >: A]: Set[B] = this.asInstanceOf[Set[B]]
+  }
+
+  private sealed class EmptyMap[K, V] extends Map[K, V] {
+    def get(key: K)              = None
+    def iterator                 = Iterator.empty
+    def + [V1 >: V](kv: (K, V1)) = updated(kv._1, kv._2)
+    def - (key: K)               = this
+
+
+    override def size                                       = 0
+    override def contains(key: K)                           = false
+    override def getOrElse[V1 >: V](key: K, default: => V1) = default
+    override def updated[V1 >: V](key: K, value: V1)        = Map(key -> value)
+
+    override def apply(key: K) = throw new NoSuchElementException(s"key not found: $key")
+  }
+
+  // internal un-deprecated version
+  private[mima] final val mimaFailOnNoPrevious =
+    settingKey[Boolean]("if true, fail the build if no previous artifacts are set.")
+
 }

sbtplugin/src/sbt-test/sbt-mima-plugin/ensure-mimaPreviousArtifacts-is-set/build.sbt

@@ -0,0 +1,3 @@
+import com.typesafe.tools.mima.core._
+
+mimaBinaryIssueFilters := Seq(ProblemFilters.exclude[MissingMethodProblem]("A.bar"))

sbtplugin/src/sbt-test/sbt-mima-plugin/ensure-mimaPreviousArtifacts-is-set/project/plugins.sbt

@@ -0,0 +1 @@
+addSbtPlugin("com.typesafe" % "sbt-mima-plugin" % System.getProperty("plugin.version"))

sbtplugin/src/sbt-test/sbt-mima-plugin/ensure-mimaPreviousArtifacts-is-set/test

@@ -0,0 +1,23 @@
+# Setup: v2 has a breaking change from v1
+> set scalaSource in Compile := baseDirectory.value /"v1"
+> set version := s"0.0.1-SNAPSHOT"
+> publishLocal
+> set scalaSource in Compile := baseDirectory.value /"v2"
+> set version := s"0.0.2-SNAPSHOT"
+
+# fail, due to unset mimaPreviousArtifacts
+-> mimaReportBinaryIssues
+
+# pass, because mimaPreviousArtifacts was set to the empty set
+> set mimaPreviousArtifacts := Set.empty
+> mimaReportBinaryIssues
+> set mimaPreviousArtifacts := Set()
+> mimaReportBinaryIssues
+> set mimaPreviousArtifacts := scala.collection.immutable.HashSet()
+> mimaReportBinaryIssues
+> set mimaPreviousArtifacts := scala.collection.immutable.HashSet.empty
+> mimaReportBinaryIssues
+
+# pass, because mimaPreviousArtifacts was set and filters are set in the build file
+> set mimaPreviousArtifacts := Set(organization.value %% name.value % s"0.0.1-SNAPSHOT")
+> mimaReportBinaryIssues

sbtplugin/src/sbt-test/sbt-mima-plugin/ensure-mimaPreviousArtifacts-is-set/v1/A.scala

@@ -0,0 +1,4 @@
+class A {
+  def foo = 1
+  def bar = foo
+}

sbtplugin/src/sbt-test/sbt-mima-plugin/ensure-mimaPreviousArtifacts-is-set/v2/A.scala

@@ -0,0 +1,3 @@
+class A {
+  def foo = 1
+}