Update scalafmt-core to 2.6.0

.scalafmt.conf

@@ -1,4 +1,4 @@
-version = 2.5.3
+version = 2.6.0
 
 style = defaultWithAlign
 maxColumn = 100

fetch-debug/src/main/scala/document.scala

@@ -108,13 +108,16 @@ abstract class Document {
 
 object Document {
 
-  /** The empty document */
+  /**
+   * The empty document */
   def empty = DocNil
 
-  /** A break, which will either be turned into a space or a line break */
+  /**
+   * A break, which will either be turned into a space or a line break */
   def break = DocBreak
 
-  /** A document consisting of some text literal */
+  /**
+   * A document consisting of some text literal */
   def text(s: String): Document = DocText(s)
 
   /**
@@ -123,6 +126,7 @@ object Document {
    */
   def group(d: Document): Document = DocGroup(d)
 
-  /** A nested document, which will be indented as specified. */
+  /**
+   * A nested document, which will be indented as specified. */
   def nest(i: Int, d: Document): Document = DocNest(i, d)
 }

fetch/src/main/scala/datasource.scala

@@ -26,7 +26,7 @@ import cats.kernel.{Hash => H}
 
 /**
  * `Data` is a trait used to identify and optimize access to a `DataSource`.
- **/
+ */
 trait Data[I, A] { self =>
   def name: String
 
@@ -47,11 +47,13 @@ trait DataSource[F[_], I, A] {
 
   implicit def CF: Concurrent[F]
 
-  /** Fetch one identity, returning a None if it wasn't found.
+  /**
+   * Fetch one identity, returning a None if it wasn't found.
    */
   def fetch(id: I): F[Option[A]]
 
-  /** Fetch many identities, returning a mapping from identities to results. If an
+  /**
+   * Fetch many identities, returning a mapping from identities to results. If an
    * identity wasn't found, it won't appear in the keys.
    */
   def batch(ids: NonEmptyList[I]): F[Map[I, A]] =

fetch/src/main/scala/syntax.scala

@@ -21,14 +21,16 @@ import cats.effect._
 
 object syntax {
 
-  /** Implicit syntax to lift any value to the context of Fetch via pure */
+  /**
+   * Implicit syntax to lift any value to the context of Fetch via pure */
   implicit class FetchIdSyntax[A](val a: A) extends AnyVal {
 
     def fetch[F[_]: Concurrent]: Fetch[F, A] =
       Fetch.pure[F, A](a)
   }
 
-  /** Implicit syntax to lift exception to Fetch errors */
+  /**
+   * Implicit syntax to lift exception to Fetch errors */
   implicit class FetchExceptionSyntax[B](val a: Throwable) extends AnyVal {
 
     def fetch[F[_]: Concurrent]: Fetch[F, B] =

fetch/src/test/scala/FetchAsyncQueryTests.scala

@@ -53,13 +53,12 @@ class FetchAsyncQueryTests extends FetchSpec {
     val io = Fetch.run[IO](fetch)
 
     io.map(
-        _ shouldEqual List(
-          Article(1, "An article with id 1"),
-          Article(1, "An article with id 1"),
-          Article(2, "An article with id 2")
-        )
+      _ shouldEqual List(
+        Article(1, "An article with id 1"),
+        Article(1, "An article with id 1"),
+        Article(2, "An article with id 2")
       )
-      .unsafeToFuture
+    ).unsafeToFuture
   }
 
   "We can use combinators and multiple sources in a for comprehension and interpret a fetch from async sources into an IO" in {
@@ -72,20 +71,19 @@ class FetchAsyncQueryTests extends FetchSpec {
     val io = Fetch.run[IO](fetch)
 
     io.map(
-        _ shouldEqual (
-          List(
-            Article(1, "An article with id 1"),
-            Article(1, "An article with id 1"),
-            Article(2, "An article with id 2")
-          ),
-          List(
-            Author(2, "@egg2"),
-            Author(2, "@egg2"),
-            Author(3, "@egg3")
-          )
+      _ shouldEqual (
+        List(
+          Article(1, "An article with id 1"),
+          Article(1, "An article with id 1"),
+          Article(2, "An article with id 2")
+        ),
+        List(
+          Author(2, "@egg2"),
+          Author(2, "@egg2"),
+          Author(3, "@egg3")
         )
       )
-      .unsafeToFuture
+    ).unsafeToFuture
   }
 }
 

fetch/src/test/scala/FetchBatchingTests.scala

@@ -110,13 +110,12 @@ class FetchBatchingTests extends FetchSpec {
     val io = Fetch.runLog[IO](fetch)
 
     io.map({
-        case (log, result) =>
-          result shouldEqual List(1, 2, 3, 4, 5)
-          log.rounds.size shouldEqual 1
-          totalFetched(log.rounds) shouldEqual 5
-          totalBatches(log.rounds) shouldEqual 3
-      })
-      .unsafeToFuture
+      case (log, result) =>
+        result shouldEqual List(1, 2, 3, 4, 5)
+        log.rounds.size shouldEqual 1
+        totalFetched(log.rounds) shouldEqual 5
+        totalBatches(log.rounds) shouldEqual 3
+    }).unsafeToFuture
   }
 
   "A large fetch to a datasource with a maximum batch size is split and executed in parallel" in {
@@ -126,13 +125,12 @@ class FetchBatchingTests extends FetchSpec {
     val io = Fetch.runLog[IO](fetch)
 
     io.map({
-        case (log, result) =>
-          result shouldEqual List(1, 2, 3, 4, 5)
-          log.rounds.size shouldEqual 1
-          totalFetched(log.rounds) shouldEqual 5
-          totalBatches(log.rounds) shouldEqual 3
-      })
-      .unsafeToFuture
+      case (log, result) =>
+        result shouldEqual List(1, 2, 3, 4, 5)
+        log.rounds.size shouldEqual 1
+        totalFetched(log.rounds) shouldEqual 5
+        totalBatches(log.rounds) shouldEqual 3
+    }).unsafeToFuture
   }
 
   "Fetches to datasources with a maximum batch size should be split and executed in parallel and sequentially when using productR" in {
@@ -143,13 +141,12 @@ class FetchBatchingTests extends FetchSpec {
     val io = Fetch.runLog[IO](fetch)
 
     io.map({
-        case (log, result) =>
-          result shouldEqual List(1, 2, 3, 4, 5)
-          log.rounds.size shouldEqual 1
-          totalFetched(log.rounds) shouldEqual 5 + 5
-          totalBatches(log.rounds) shouldEqual 3 + 3
-      })
-      .unsafeToFuture
+      case (log, result) =>
+        result shouldEqual List(1, 2, 3, 4, 5)
+        log.rounds.size shouldEqual 1
+        totalFetched(log.rounds) shouldEqual 5 + 5
+        totalBatches(log.rounds) shouldEqual 3 + 3
+    }).unsafeToFuture
   }
 
   "Fetches to datasources with a maximum batch size should be split and executed in parallel and sequentially when using productL" in {
@@ -160,13 +157,12 @@ class FetchBatchingTests extends FetchSpec {
     val io = Fetch.runLog[IO](fetch)
 
     io.map({
-        case (log, result) =>
-          result shouldEqual List(1, 2, 3, 4, 5)
-          log.rounds.size shouldEqual 1
-          totalFetched(log.rounds) shouldEqual 5 + 5
-          totalBatches(log.rounds) shouldEqual 3 + 3
-      })
-      .unsafeToFuture
+      case (log, result) =>
+        result shouldEqual List(1, 2, 3, 4, 5)
+        log.rounds.size shouldEqual 1
+        totalFetched(log.rounds) shouldEqual 5 + 5
+        totalBatches(log.rounds) shouldEqual 3 + 3
+    }).unsafeToFuture
   }
 
   "A large (many) fetch to a datasource with a maximum batch size is split and executed in sequence" in {
@@ -176,13 +172,12 @@ class FetchBatchingTests extends FetchSpec {
     val io = Fetch.runLog[IO](fetch)
 
     io.map({
-        case (log, result) =>
-          result shouldEqual List(1, 2, 3)
-          log.rounds.size shouldEqual 1
-          totalFetched(log.rounds) shouldEqual 3
-          totalBatches(log.rounds) shouldEqual 2
-      })
-      .unsafeToFuture
+      case (log, result) =>
+        result shouldEqual List(1, 2, 3)
+        log.rounds.size shouldEqual 1
+        totalFetched(log.rounds) shouldEqual 3
+        totalBatches(log.rounds) shouldEqual 2
+    }).unsafeToFuture
   }
 
   "A large (many) fetch to a datasource with a maximum batch size is split and executed in parallel" in {
@@ -192,13 +187,12 @@ class FetchBatchingTests extends FetchSpec {
     val io = Fetch.runLog[IO](fetch)
 
     io.map({
-        case (log, result) =>
-          result shouldEqual List(1, 2, 3)
-          log.rounds.size shouldEqual 1
-          totalFetched(log.rounds) shouldEqual 3
-          totalBatches(log.rounds) shouldEqual 2
-      })
-      .unsafeToFuture
+      case (log, result) =>
+        result shouldEqual List(1, 2, 3)
+        log.rounds.size shouldEqual 1
+        totalFetched(log.rounds) shouldEqual 3
+        totalBatches(log.rounds) shouldEqual 2
+    }).unsafeToFuture
   }
 
   "Very deep fetches don't overflow stack or heap" in {
@@ -216,9 +210,8 @@ class FetchBatchingTests extends FetchSpec {
     )
 
     io.map({
-        case (log, result) =>
-          result shouldEqual ids.map(_.toString)
-      })
-      .unsafeToFuture
+      case (log, result) =>
+        result shouldEqual ids.map(_.toString)
+    }).unsafeToFuture
   }
 }

fetch/src/test/scala/FetchReportingTests.scala

@@ -30,9 +30,8 @@ class FetchReportingTests extends FetchSpec {
     val io = Fetch.runLog[IO](fetch)
 
     io.map({
-        case (log, result) => log.rounds.size shouldEqual 0
-      })
-      .unsafeToFuture
+      case (log, result) => log.rounds.size shouldEqual 0
+    }).unsafeToFuture
   }
 
   "Single fetches are executed in one round" in {
@@ -42,9 +41,8 @@ class FetchReportingTests extends FetchSpec {
     val io = Fetch.runLog[IO](fetch)
 
     io.map({
-        case (log, result) => log.rounds.size shouldEqual 1
-      })
-      .unsafeToFuture
+      case (log, result) => log.rounds.size shouldEqual 1
+    }).unsafeToFuture
   }
 
   "Single fetches are executed in one round per binding in a for comprehension" in {
@@ -57,9 +55,8 @@ class FetchReportingTests extends FetchSpec {
     val io = Fetch.runLog[IO](fetch)
 
     io.map({
-        case (log, result) => log.rounds.size shouldEqual 2
-      })
-      .unsafeToFuture
+      case (log, result) => log.rounds.size shouldEqual 2
+    }).unsafeToFuture
   }
 
   "Single fetches for different data sources are executed in multiple rounds if they are in a for comprehension" in {
@@ -72,9 +69,8 @@ class FetchReportingTests extends FetchSpec {
     val io = Fetch.runLog[IO](fetch)
 
     io.map({
-        case (log, result) => log.rounds.size shouldEqual 2
-      })
-      .unsafeToFuture
+      case (log, result) => log.rounds.size shouldEqual 2
+    }).unsafeToFuture
   }
 
   "Single fetches combined with cartesian are run in one round" in {
@@ -84,9 +80,8 @@ class FetchReportingTests extends FetchSpec {
     val io = Fetch.runLog[IO](fetch)
 
     io.map({
-        case (log, result) => log.rounds.size shouldEqual 1
-      })
-      .unsafeToFuture
+      case (log, result) => log.rounds.size shouldEqual 1
+    }).unsafeToFuture
   }
 
   "Single fetches combined with traverse are run in one round" in {
@@ -99,9 +94,8 @@ class FetchReportingTests extends FetchSpec {
     val io = Fetch.runLog[IO](fetch)
 
     io.map({
-        case (log, result) => log.rounds.size shouldEqual 2
-      })
-      .unsafeToFuture
+      case (log, result) => log.rounds.size shouldEqual 2
+    }).unsafeToFuture
   }
 
   "The product of two fetches from the same data source implies batching" in {
@@ -111,9 +105,8 @@ class FetchReportingTests extends FetchSpec {
     val io = Fetch.runLog[IO](fetch)
 
     io.map({
-        case (log, result) => log.rounds.size shouldEqual 1
-      })
-      .unsafeToFuture
+      case (log, result) => log.rounds.size shouldEqual 1
+    }).unsafeToFuture
   }
 
   "The product of concurrent fetches of the same type implies everything fetched in batches" in {
@@ -137,11 +130,10 @@ class FetchReportingTests extends FetchSpec {
     val io = Fetch.runLog[IO](fetch)
 
     io.map({
-        case (log, result) =>
-          log.rounds.size shouldEqual 2
-          totalBatches(log.rounds) shouldEqual 1
-          totalFetched(log.rounds) shouldEqual 3 + 1
-      })
-      .unsafeToFuture
+      case (log, result) =>
+        log.rounds.size shouldEqual 2
+        totalBatches(log.rounds) shouldEqual 1
+        totalFetched(log.rounds) shouldEqual 3 + 1
+    }).unsafeToFuture
   }
 }