Updates Project

Author: juanpedromoreno

.scalafmt.conf

@@ -1,3 +1,4 @@
+version=2.4.2
 style = defaultWithAlign
 maxColumn = 100
 
@@ -19,5 +20,4 @@ docstrings = JavaDoc
 rewrite {
   rules = [SortImports, RedundantBraces]
   redundantBraces.maxLines = 1
-}
-        
+}

.travis.yml

@@ -1,25 +1,16 @@
-import ProjectPlugin.autoImport._
-val scalaExercisesV = "0.6.0-SNAPSHOT"
+addCommandAlias("ci-test", "scalafmtCheckAll; scalafmtSbtCheck; test")
+addCommandAlias("ci-docs", "github; project-docs/mdoc; headerCreateAll")
 
-def dep(artifactId: String) = "org.scala-exercises" %% artifactId % scalaExercisesV
-
-lazy val fpinscala = (project in file("."))
+lazy val exercises = (project in file("."))
+  .settings(moduleName := "exercises-fpinscala")
+  .settings(exercisesSettings)
   .enablePlugins(ExerciseCompilerPlugin)
-  .settings(
-    name         := "exercises-fpinscala",
-    libraryDependencies ++= Seq(
-      dep("exercise-compiler"),
-      dep("definitions"),
-      %%("shapeless", V.shapeless),
-      %%("scalatest", V.scalatest),
-      %%("scalacheck", V.scalacheck),
-      "com.github.alexarchambault" %% "scalacheck-shapeless_1.14" % V.scalacheckShapeless,
-      "org.scalatestplus"          %% "scalatestplus-scalacheck"  % V.scalatestplusScheck
-    )
-  )
-
-// Distribution
 
-pgpPassphrase := Some(getEnvVar("PGP_PASSPHRASE").getOrElse("").toCharArray)
-pgpPublicRing := file(s"$gpgFolder/pubring.gpg")
-pgpSecretRing := file(s"$gpgFolder/secring.gpg")
+lazy val `project-docs` = (project in file(".docs"))
+  .aggregate(exercises)
+  .dependsOn(exercises)
+  .settings(moduleName := "exercises-project-docs")
+  .settings(mdocIn := file(".docs"))
+  .settings(mdocOut := file("."))
+  .settings(skip in publish := true)
+  .enablePlugins(MdocPlugin)

build.sbt

@@ -1,55 +1,49 @@
-import de.heikoseeberger.sbtheader.License._
-import de.heikoseeberger.sbtheader.HeaderPlugin.autoImport._
 import sbt.Keys._
 import sbt._
-import sbtorgpolicies._
-import sbtorgpolicies.model._
-import sbtorgpolicies.OrgPoliciesPlugin.autoImport._
+import com.alejandrohdezma.sbt.github.SbtGithubPlugin
 
 object ProjectPlugin extends AutoPlugin {
 
   override def trigger: PluginTrigger = allRequirements
 
-  override def requires: Plugins = plugins.JvmPlugin && OrgPoliciesPlugin
+  override def requires: Plugins = plugins.JvmPlugin && SbtGithubPlugin
 
   object autoImport {
 
     lazy val V = new {
-      val scala213: String            = "2.13.1"
       val shapeless: String           = "2.3.3"
-      val scalatest: String           = "3.1.1"
-      val scalatestplusScheck: String = "3.1.0.0-RC2"
+      val scala: String               = "2.13.2"
+      val scalaExercises: String      = "0.6.0-SNAPSHOT"
       val scalacheck: String          = "1.14.3"
       val scalacheckShapeless: String = "1.2.5"
+      val scalatest: String           = "3.1.1"
+      val scalatestplusScheck: String = "3.1.1.1"
     }
-  }
 
-  import autoImport._
+    def dep(artifactId: String) = "org.scala-exercises" %% artifactId % V.scalaExercises
+
+    lazy val exercisesSettings = Seq(
+      libraryDependencies ++= Seq(
+        dep("exercise-compiler"),
+        dep("definitions"),
+        "com.chuusai"                %% "shapeless"                 % V.shapeless,
+        "org.scalatest"              %% "scalatest"                 % V.scalatest,
+        "org.scalacheck"             %% "scalacheck"                % V.scalacheck,
+        "org.scalatestplus"          %% "scalacheck-1-14"           % V.scalatestplusScheck,
+        "com.github.alexarchambault" %% "scalacheck-shapeless_1.14" % V.scalacheckShapeless
+      )
+    )
+  }
 
   override def projectSettings: Seq[Def.Setting[_]] =
     Seq(
-      description := "Scala Exercises: The path to enlightenment",
-      startYear := Option(2016),
-      orgGithubSetting := GitHubSettings(
-        organization = "scala-exercises",
-        project = name.value,
-        organizationName = "Scala Exercises",
-        groupId = "org.scala-exercises",
-        organizationHomePage = url("https://www.scala-exercises.org"),
-        organizationEmail = "[email protected]"
-      ),
-      orgLicenseSetting := ApacheLicense,
-      scalaVersion := V.scala213,
-      scalaOrganization := "org.scala-lang",
+      organization := "org.scala-exercises",
+      organizationName := "47 Degrees",
+      organizationHomepage := Some(url("https://47deg.com")),
+      scalaVersion := autoImport.V.scala,
       resolvers ++= Seq(
-        Resolver.mavenLocal,
         Resolver.sonatypeRepo("snapshots"),
         Resolver.sonatypeRepo("releases")
-      ),
-      scalacOptions := scalacCommonOptions ++ scalacLanguageOptions,
-      headerLicense := Some(Custom(s"""| scala-exercises - ${name.value}
-                                       | Copyright (C) 2015-2019 47 Degrees, LLC. <http://www.47deg.com>
-                                       |
-                                       |""".stripMargin))
+      )
     )
 }

project/ProjectPlugin.scala

@@ -1,6 +1,10 @@
-resolvers ++= Seq(
-  Resolver.sonatypeRepo("snapshots")
-)
-
-addSbtPlugin("org.scala-exercises" % "sbt-exercise" % "0.6.0-SNAPSHOT")
-addSbtPlugin("com.47deg"         % "sbt-org-policies" % "0.12.0-M3")
+resolvers += Resolver.sonatypeRepo("snapshots")
+addSbtPlugin("org.scala-exercises" % "sbt-exercise"      % "0.6.0-SNAPSHOT")
+addSbtPlugin("com.geirsson"        % "sbt-ci-release"    % "1.5.3")
+addSbtPlugin("org.scalameta"       % "sbt-mdoc"          % "2.1.5")
+addSbtPlugin("org.scalameta"       % "sbt-scalafmt"      % "2.3.4")
+addSbtPlugin("de.heikoseeberger"   % "sbt-header"        % "5.6.0")
+addSbtPlugin("com.alejandrohdezma" %% "sbt-github"       % "0.8.0")
+addSbtPlugin("com.alejandrohdezma" % "sbt-github-header" % "0.8.0")
+addSbtPlugin("com.alejandrohdezma" % "sbt-github-mdoc"   % "0.8.0")
+addSbtPlugin("com.alejandrohdezma" % "sbt-mdoc-toc"      % "0.2")

project/plugins.sbt

@@ -135,7 +135,8 @@ object ErrorHandlingSection
   def optionFilterAssert(
       res0: Some[Employee],
       res1: Option[Employee],
-      res2: Option[Employee]): Unit = {
+      res2: Option[Employee]
+  ): Unit = {
     lookupByName("Joe").filter(_.department != "IT") shouldBe res0
     lookupByName("Mary").filter(_.department != "IT") shouldBe res1
     lookupByName("Foo").filter(_.department != "IT") shouldBe res2
@@ -271,7 +272,8 @@ object ErrorHandlingSection
         e.manager match {
           case Some(e) => Right(e)
           case _       => Left("Manager not found")
-      })
+        }
+      )
 
     getManager(lookupByNameViaEither("Joe")) shouldBe res0
     getManager(lookupByNameViaEither("Mary")) shouldBe res1
@@ -298,7 +300,8 @@ object ErrorHandlingSection
         e.manager match {
           case Some(e) => Right(e)
           case _       => Left("Manager not found")
-      })
+        }
+      )
 
     getManager(lookupByNameViaEither("Joe")).orElse(Right("Mr. CEO")) shouldBe res0
     getManager(lookupByNameViaEither("Mary")).orElse(Right("Mr. CEO")) shouldBe res1

pubring.gpg

@@ -91,7 +91,8 @@ object FunctionalDataStructuresSection
       res1: List[Int],
       res2: List[Int],
       res3: List[Int],
-      res4: List[Int]) = {
+      res4: List[Int]
+  ) = {
     def drop[A](l: List[A], n: Int): List[A] =
       if (n <= 0) l
       else
@@ -161,7 +162,8 @@ object FunctionalDataStructuresSection
       res7: Int,
       res8: Int,
       res9: Int,
-      res10: Int) = {
+      res10: Int
+  ) = {
     foldRight(Cons(1, Cons(2, Cons(3, Nil))), 0)((x, y) => x + y) shouldBe 6
     res0 + foldRight(Cons(2, Cons(3, Nil)), 0)((x, y) => x + y) shouldBe 6
     res1 + res2 + foldRight(Cons(3, Nil), 0)((x, y) => x + y) shouldBe 6

secring.gpg.enc

@@ -293,7 +293,7 @@ object FunctionalStateSection
                 Machine(false, candy, coin + res0)
               case (Turn, Machine(false, candy, coin)) =>
                 Machine(true, candy - res1, coin)
-        }
+            }
 
       def simulateMachine(inputs: List[Input]): State[Machine, (Int, Int)] =
         for {

src/main/scala/fpinscalalib/ErrorHandlingSection.scala

@@ -108,7 +108,8 @@ object ParserCombinatorsSection
    */
   def parserManyAssert(
       res0: Either[ParseError, List[Char]],
-      res1: Either[ParseError, List[Char]]): Unit = {
+      res1: Either[ParseError, List[Char]]
+  ): Unit = {
     def many[A](p: Parser[A]): Parser[List[A]] =
       map2(p, many(p))(_ :: _) or fpinscalalib.customlib.parsing.Reference.succeed(List())
 
@@ -276,14 +277,13 @@ object ParserCombinatorsSection
   def parserStringAssert(res0: String): Unit = {
     def string(w: String): Parser[String] = {
       val msg = "'" + w + "'"
-      s =>
-        {
-          val i = firstNonmatchingIndex(s.loc.input, w, s.loc.offset)
-          if (i == -1) // they matched
-            Success(w, w.length)
-          else
-            Failure(s.loc.advanceBy(i).toError(msg), i != 0)
-        }
+      s => {
+        val i = firstNonmatchingIndex(s.loc.input, w, s.loc.offset)
+        if (i == -1) // they matched
+          Success(w, w.length)
+        else
+          Failure(s.loc.advanceBy(i).toError(msg), i != 0)
+      }
     }
 
     val parseFunction = run(
@@ -329,7 +329,7 @@ object ParserCombinatorsSection
         p(s) match {
           case Success(_, n)     => Success(s.slice(n), n)
           case f @ Failure(_, _) => f
-      }
+        }
 
     val parserFunction = run(
       slice(many1(string("a")))

src/main/scala/fpinscalalib/FunctionalDataStructuresSection.scala

@@ -357,10 +357,10 @@ object PropertyBasedTestingSection
    * Let's show how we can test higher-order functions with `takeWhile` and `dropWhile` from `List`:
    */
   def propTakeWhileDropWhile(res0: Result): Unit = {
-    val prop = forAll(listOf(Gen.choose(0, 20)))(l => {
+    val prop = forAll(listOf(Gen.choose(0, 20))) { l =>
       val index = Gen.choose(0, 20).sample.run(RNG.Simple(47))._1
       l.takeWhile(_ < index) ++ l.dropWhile(_ < index) == l
-    })
+    }
     prop.run(100, 100, RNG.Simple(System.currentTimeMillis)) shouldBe res0
   }
 }

src/main/scala/fpinscalalib/FunctionalStateSection.scala

@@ -185,7 +185,8 @@ object StrictnessAndLazinessSection
       res2: Stream[Int],
       res3: Int,
       res4: Stream[Int],
-      res5: Int): Unit = {
+      res5: Int
+  ): Unit = {
     val startingPoint = Stream(1, 2, 3, 4).map(_ + 10).filter(_ % 2 == 0).toList
 
     // Apply map to the first element:

src/main/scala/fpinscalalib/ParserCombinatorsSection.scala

@@ -24,7 +24,9 @@ object List { // `List` companion object. Contains functions for creating and wo
     ints match { // A function that uses pattern matching to add up a list of integers
       case Nil => 0 // The sum of the empty list is 0.
       case Cons(x, xs) =>
-        x + sum(xs) // The sum of a list starting with `x` is `x` plus the sum of the rest of the list.
+        x + sum(
+          xs
+        ) // The sum of a list starting with `x` is `x` plus the sum of the rest of the list.
     }
 
   def product(ds: List[Double]): Double = ds match {

src/main/scala/fpinscalalib/PropertyBasedTestingSection.scala

@@ -21,7 +21,9 @@ object Par {
 
   def unit[A](a: A): Par[A] =
     (es: ExecutorService) =>
-      UnitFuture(a) // `unit` is represented as a function that returns a `UnitFuture`, which is a simple implementation of `Future` that just wraps a constant value. It doesn't use the `ExecutorService` at all. It's always done and can't be cancelled. Its `get` method simply returns the value that we gave it.
+      UnitFuture(
+        a
+      ) // `unit` is represented as a function that returns a `UnitFuture`, which is a simple implementation of `Future` that just wraps a constant value. It doesn't use the `ExecutorService` at all. It's always done and can't be cancelled. Its `get` method simply returns the value that we gave it.
 
   private case class UnitFuture[A](get: A) extends Future[A] {
     def isDone                                  = true
@@ -34,7 +36,9 @@ object Par {
     (es: ExecutorService) => {
       val af = a(es)
       val bf = b(es)
-      UnitFuture(f(af.get, bf.get)) // This implementation of `map2` does _not_ respect timeouts. It simply passes the `ExecutorService` on to both `Par` values, waits for the results of the Futures `af` and `bf`, applies `f` to them, and wraps them in a `UnitFuture`. In order to respect timeouts, we'd need a new `Future` implementation that records the amount of time spent evaluating `af`, then subtracts that time from the available time allocated for evaluating `bf`.
+      UnitFuture(
+        f(af.get, bf.get)
+      ) // This implementation of `map2` does _not_ respect timeouts. It simply passes the `ExecutorService` on to both `Par` values, waits for the results of the Futures `af` and `bf`, applies `f` to them, and wraps them in a `UnitFuture`. In order to respect timeouts, we'd need a new `Future` implementation that records the amount of time spent evaluating `af`, then subtracts that time from the available time allocated for evaluating `bf`.
     }
 
   def fork[A](a: => Par[A]): Par[A] = // This is the simplest and most natural implementation of `fork`, but there are some problems with it--for one, the outer `Callable` will block waiting for the "inner" task to complete. Since this blocking occupies a thread in our thread pool, or whatever resource backs the `ExecutorService`, this implies that we're losing out on some potential parallelism. Essentially, we're using two threads when one should suffice. This is a symptom of a more serious problem with the implementation, and we will discuss this later in the chapter.