Merge branch 'master' of https://github.com/typelevel/cats

Author: denisrosca

build.sbt

@@ -1,5 +1,9 @@
+import java.time.LocalDateTime
+
 import microsites._
 import ReleaseTransformations._
+import sbt.io.Using
+
 import scala.xml.transform.{RewriteRule, RuleTransformer}
 import sbtcrossproject.CrossProject
 import sbtcrossproject.CrossPlugin.autoImport.{crossProject, CrossType}
@@ -18,7 +22,24 @@ lazy val scoverageSettings = Seq(
 
 organization in ThisBuild := "org.typelevel"
 
+val isTravisBuild = settingKey[Boolean]("Flag indicating whether the current build is running under Travis")
+val crossScalaVersionsFromTravis = settingKey[Seq[String]]("Scala versions set in .travis.yml as scala_version_XXX")
+isTravisBuild in Global := sys.env.get("TRAVIS").isDefined
+
+crossScalaVersionsFromTravis in Global := {
+  val manifest = (baseDirectory in ThisBuild).value / ".travis.yml"
+  import collection.JavaConverters._
+  Using.fileInputStream(manifest) { fis =>
+    List(new org.yaml.snakeyaml.Yaml().load(fis))
+      .collect { case map: java.util.Map[_, _] => map.asScala.toList }
+      .flatMap(_.collect {
+        case (k: String, v: String) if k.contains("scala_version_") => v
+      })
+  }
+}
+
 lazy val commonSettings = Seq(
+  crossScalaVersions := (crossScalaVersionsFromTravis in Global).value,
   scalacOptions ++= commonScalacOptions(scalaVersion.value),
   Compile / unmanagedSourceDirectories ++= {
     val bd = baseDirectory.value
@@ -610,6 +631,7 @@ lazy val binCompatTest = project
   .disablePlugins(CoursierPlugin)
   .settings(noPublishSettings)
   .settings(
+    crossScalaVersions := (crossScalaVersionsFromTravis in Global).value,
     addCompilerPlugin("org.spire-math" %% "kind-projector" % "0.9.9"),
     libraryDependencies ++= List(
       {
@@ -743,7 +765,7 @@ addCommandAlias("validateKernelJS", "kernelLawsJS/test")
 addCommandAlias("validateFreeJS", "freeJS/test") //separated due to memory constraint on travis
 addCommandAlias("validate", ";clean;validateJS;validateKernelJS;validateFreeJS;validateJVM")
 
-addCommandAlias("prePR", ";fmt;++2.11.12;validateBC")
+addCommandAlias("prePR", ";fmt;++2.11.12 mimaReportBinaryIssues")
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Base Build Settings - Should not need to edit below this line.

free/src/test/scala/cats/free/FreeInvariantMonoidalSuite.scala

@@ -3,10 +3,11 @@ package tests
 
 import cats.arrow.FunctionK
 import cats.free.FreeInvariantMonoidal
-import cats.laws.discipline.{InvariantMonoidalTests, SerializableTests}
+import cats.laws.discipline.{InvariantMonoidalTests, MiniInt, SerializableTests}
+import cats.laws.discipline.arbitrary._
 import cats.laws.discipline.SemigroupalTests.Isomorphisms
 import org.scalacheck.{Arbitrary, Gen}
-import cats.tests.CsvCodecInvariantMonoidalSuite._
+import cats.tests.BinCodecInvariantMonoidalSuite._
 
 class FreeInvariantMonoidalSuite extends CatsSuite {
   implicit def freeInvariantMonoidalArbitrary[F[_], A](implicit F: Arbitrary[F[A]],
@@ -25,24 +26,25 @@ class FreeInvariantMonoidalSuite extends CatsSuite {
       }
     }
 
-  implicit val isoFreeCsvCodec = Isomorphisms.invariant[FreeInvariantMonoidal[CsvCodec, ?]]
+  implicit val isoFreeBinCodec = Isomorphisms.invariant[FreeInvariantMonoidal[BinCodec, ?]]
 
-  checkAll("FreeInvariantMonoidal[CsvCodec, ?]",
-           InvariantMonoidalTests[FreeInvariantMonoidal[CsvCodec, ?]].invariantMonoidal[Int, Int, Int])
-  checkAll("InvariantMonoidal[FreeInvariantMonoidal[CsvCodec, ?]]",
-           SerializableTests.serializable(InvariantMonoidal[FreeInvariantMonoidal[CsvCodec, ?]]))
+  checkAll("FreeInvariantMonoidal[BinCodec, ?]",
+           InvariantMonoidalTests[FreeInvariantMonoidal[BinCodec, ?]].invariantMonoidal[MiniInt, Boolean, Boolean])
+  checkAll("InvariantMonoidal[FreeInvariantMonoidal[BinCodec, ?]]",
+           SerializableTests.serializable(InvariantMonoidal[FreeInvariantMonoidal[BinCodec, ?]]))
 
   test("FreeInvariantMonoidal#fold") {
-    val n = 2
-    val i1 = numericSystemCodec(8)
-    val i2 = InvariantMonoidal[CsvCodec].point(n)
-    val iExpr = i1.product(i2.imap(_ * 2)(_ / 2))
+    forAll { i1: BinCodec[MiniInt] =>
+      val n = MiniInt.unsafeFromInt(2)
+      val i2 = InvariantMonoidal[BinCodec].point(n)
+      val iExpr = i1.product(i2.imap(_ * n)(_ / n))
 
-    val f1 = FreeInvariantMonoidal.lift[CsvCodec, Int](i1)
-    val f2 = FreeInvariantMonoidal.pure[CsvCodec, Int](n)
-    val fExpr = f1.product(f2.imap(_ * 2)(_ / 2))
+      val f1 = FreeInvariantMonoidal.lift[BinCodec, MiniInt](i1)
+      val f2 = FreeInvariantMonoidal.pure[BinCodec, MiniInt](n)
+      val fExpr = f1.product(f2.imap(_ * n)(_ / n))
 
-    fExpr.fold should ===(iExpr)
+      fExpr.fold should ===(iExpr)
+    }
   }
 
   implicit val idIsInvariantMonoidal: InvariantMonoidal[Id] = new InvariantMonoidal[Id] {

free/src/test/scala/cats/free/FreeTSuite.scala

@@ -5,7 +5,6 @@ import cats._
 import cats.arrow.FunctionK
 import cats.data._
 import cats.laws.discipline._
-import cats.laws.discipline.arbitrary._
 import cats.tests.CatsSuite
 import cats.instances.option._
 import org.scalacheck.{Arbitrary, Cogen, Gen}
@@ -247,7 +246,7 @@ trait FreeTSuiteInstances {
   import cats.tests.IndexedStateTSuite._
   import SemigroupalTests._
 
-  type IntState[A] = State[Int, A]
+  type IntState[A] = State[MiniInt, A]
   type FreeTOption[A] = FreeT[Option, Option, A]
   type FreeTState[A] = FreeT[IntState, IntState, A]
 
@@ -261,16 +260,6 @@ trait FreeTSuiteInstances {
     override def map[A, B](fa: JustFunctor[A])(f: A => B): JustFunctor[B] = JustFunctor(f(fa.a))
   }
 
-  implicit val intEq: Eq[Int] = new Eq[Int] {
-    def eqv(a: Int, b: Int) = a == b
-  }
-
-  implicit def evalEq[A: Eq]: Eq[Eval[A]] = Eval.catsEqForEval[A]
-
-  implicit def intStateEq[A: Eq]: Eq[IntState[A]] = stateEq[Int, A]
-
-  implicit def intStateArb[A: Arbitrary]: Arbitrary[IntState[A]] = catsLawArbitraryForState[Int, A]
-
   implicit def freeTOptionEq[A](implicit A: Eq[A], OM: Monad[Option]): Eq[FreeTOption[A]] = new Eq[FreeTOption[A]] {
     def eqv(a: FreeTOption[A], b: FreeTOption[A]) = Eq[Option[A]].eqv(a.runM(identity), b.runM(identity))
   }

laws/src/main/scala/cats/laws/discipline/Arbitrary.scala

@@ -349,6 +349,11 @@ object arbitrary extends ArbitraryInstances0 {
   implicit def catsLawsCogenForChain[A](implicit A: Cogen[A]): Cogen[Chain[A]] =
     Cogen[List[A]].contramap(_.toList)
 
+  implicit val catsLawsCogenForMiniInt: Cogen[MiniInt] =
+    Cogen[Int].contramap(_.toInt)
+
+  implicit val catsLawsArbitraryForMiniInt: Arbitrary[MiniInt] =
+    Arbitrary(Gen.oneOf(MiniInt.allValues))
 }
 
 sealed private[discipline] trait ArbitraryInstances0 {