Update scalafmt-core to 3.7.14

.git-blame-ignore-revs

@@ -4,3 +4,6 @@ f6bdd1574b34dd2f7eb6737863bff6dbb876bbb2
 
 # Scala Steward: Reformat with scalafmt 3.7.2
 306a9a501c20a74348d8640da8f2b1cb89172706
+
+# Scala Steward: Reformat with scalafmt 3.7.14
+f2b7b1bf2fe61078845671fd610467a68cd9fb91

.scalafmt.conf

@@ -1,4 +1,4 @@
-version = "3.7.3"
+version = "3.7.14"
 
 align.preset = none
 align.openParenCallSite = false

build.sc

@@ -16,7 +16,7 @@ val acyclic = "0.3.8"
 val scalaVersions = List(scala212, scala213, scala3)
 
 trait MainArgsPublishModule
-  extends PublishModule
+    extends PublishModule
     with CrossScalaModule
     with Mima
     with PlatformScalaModule {
@@ -25,7 +25,6 @@ trait MainArgsPublishModule
 
   override def mimaPreviousVersions = Seq("0.5.0")
 
-
   override def versionScheme: T[Option[VersionScheme]] = T(Some(VersionScheme.EarlySemVer))
 
   def pomSettings = PomSettings(
@@ -41,18 +40,18 @@ trait MainArgsPublishModule
 
   def scalacOptions =
     super.scalacOptions() ++
-    Option.when(!isScala3(scalaVersion()))("-P:acyclic:force")
+      Option.when(!isScala3(scalaVersion()))("-P:acyclic:force")
 
   def scalacPluginIvyDeps =
     super.scalacPluginIvyDeps() ++
-    Option.when(!isScala3(scalaVersion()))(ivy"com.lihaoyi:::acyclic:${acyclic}")
+      Option.when(!isScala3(scalaVersion()))(ivy"com.lihaoyi:::acyclic:${acyclic}")
 
   def compileIvyDeps =
     super.compileIvyDeps() ++
-    Agg.when(!isScala3(crossScalaVersion))(
-      ivy"com.lihaoyi:::acyclic:${acyclic}",
-      ivy"org.scala-lang:scala-reflect:$crossScalaVersion"
-    )
+      Agg.when(!isScala3(crossScalaVersion))(
+        ivy"com.lihaoyi:::acyclic:${acyclic}",
+        ivy"org.scala-lang:scala-reflect:$crossScalaVersion"
+      )
 
   def ivyDeps = Agg(
     ivy"org.scala-lang.modules::scala-collection-compat::2.8.1",

mainargs/src/Invoker.scala

@@ -31,9 +31,9 @@ object Invoker {
             Right(ParamResult.Success(Flag(kvs.contains(a)).asInstanceOf[T]))
           case r: TokensReader.Simple[T] => Right(makeReadCall(kvs, base, a, r))
           case r: TokensReader.Constant[T] => Right(r.read() match {
-            case Left(s) => ParamResult.Failure(Seq(Result.ParamError.Failed(a, Nil, s)))
-            case Right(v) => ParamResult.Success(v)
-          })
+              case Left(s) => ParamResult.Failure(Seq(Result.ParamError.Failed(a, Nil, s)))
+              case Right(v) => ParamResult.Success(v)
+            })
           case r: TokensReader.Leftover[T, _] => Right(makeReadVarargsCall(a, extras, r))
           case r: TokensReader.Class[T] =>
             Left(

mainargs/src/TokenGrouping.scala

@@ -76,10 +76,10 @@ object TokenGrouping {
 
       val missing = argSigs.collect {
         case (a, r: TokensReader.Simple[_])
-          if !r.allowEmpty
-          && a.default.isEmpty
-          && !current.contains(a) =>
-            a
+            if !r.allowEmpty
+              && a.default.isEmpty
+              && !current.contains(a) =>
+          a
       }
 
       val unknown = if (allowLeftover) Nil else remaining

mainargs/src/TokensReader.scala

@@ -22,6 +22,7 @@ object TokensReader {
   sealed trait Terminal[T] extends TokensReader[T]
 
   sealed trait ShortNamed[T] extends Terminal[T] {
+
     /**
      * The label that shows up in the CLI help message, e.g. the `bar` in
      * `--foo <bar>`
@@ -34,6 +35,7 @@ object TokensReader {
    * e.g. `--foo bar`
    */
   trait Simple[T] extends ShortNamed[T] {
+
     /**
      * Converts the given input tokens to a [[T]] or an error `String`.
      * The input is a `Seq` because input tokens can be passed more than once,
@@ -132,15 +134,16 @@ object TokensReader {
     def read(strs: Seq[String]) = tryEither(strs.last.toDouble)
   }
 
-  implicit def LeftoverRead[T: TokensReader.Simple]: TokensReader.Leftover[mainargs.Leftover[T], T] =
+  implicit def LeftoverRead[T: TokensReader.Simple]
+      : TokensReader.Leftover[mainargs.Leftover[T], T] =
     new LeftoverRead[T]()(implicitly[TokensReader.Simple[T]])
 
   class LeftoverRead[T](implicit wrapped: TokensReader.Simple[T])
       extends Leftover[mainargs.Leftover[T], T] {
     def read(strs: Seq[String]) = {
       val (failures, successes) = strs
         .map(s =>
-          implicitly[TokensReader[T]] match{
+          implicitly[TokensReader[T]] match {
             case r: TokensReader.Simple[T] => r.read(Seq(s))
             case r: TokensReader.Leftover[T, _] => r.read(Seq(s))
           }
@@ -221,8 +224,9 @@ object TokensReader {
 }
 
 object ArgSig {
-  def create[T, B](name0: String, arg: mainargs.arg, defaultOpt: Option[B => T])
-                  (implicit tokensReader: TokensReader[T]): ArgSig = {
+  def create[T, B](name0: String, arg: mainargs.arg, defaultOpt: Option[B => T])(implicit
+      tokensReader: TokensReader[T]
+  ): ArgSig = {
     val nameOpt = scala.Option(arg.name).orElse(if (name0.length == 1 || arg.noDefaultName) None
     else Some(name0))
     val shortOpt = arg.short match {
@@ -285,7 +289,7 @@ case class MainData[T, B](
     argSigs0.iterator.flatMap[(ArgSig, TokensReader.Terminal[_])](ArgSig.flatten(_)).toVector
 
   val renderedArgSigs: Seq[ArgSig] =
-    flattenedArgSigs.collect{case (a, r) if !a.hidden && !r.isConstant => a}
+    flattenedArgSigs.collect { case (a, r) if !a.hidden && !r.isConstant => a }
 }
 
 object MainData {

mainargs/test/src-jvm-2/AmmoniteTests.scala

@@ -31,8 +31,8 @@ object AmmoniteConfig {
   case class InjectedConstant()
 
   implicit object InjectedTokensReader extends TokensReader.Constant[InjectedConstant] {
-      def read() = Right(new InjectedConstant())
-    }
+    def read() = Right(new InjectedConstant())
+  }
   @main
   case class Core(
       injectedConstant: InjectedConstant,

mainargs/test/src/ClassWithDefaultTests.scala

@@ -46,13 +46,13 @@ object ClassWithDefaultTests extends TestSuite {
     }
 
     test("nested") {
-      test("success"){
+      test("success") {
         mainParser.runOrThrow(Seq("-x", "1", "-y", "2", "--bool", "true")) ==> "1 2 true"
       }
-      test("default"){
+      test("default") {
         mainParser.runOrThrow(Seq("-x", "1", "-y", "2")) ==> "1 2 false"
       }
-      test("default2"){
+      test("default2") {
         mainParser.runOrThrow(Seq("-x", "0")) ==> "0 1 false"
       }
     }

mainargs/test/src/ConstantTests.scala

@@ -5,7 +5,7 @@ object ConstantTests extends TestSuite {
 
   case class Injected()
   implicit def InjectedTokensReader: TokensReader.Constant[Injected] =
-    new TokensReader.Constant[Injected]{
+    new TokensReader.Constant[Injected] {
       def read() = Right(new Injected())
     }
   object Base {

mainargs/test/src/CoreTests.scala

@@ -219,7 +219,15 @@ object CorePositionalDisabledOnlyTests extends TestSuite {
     test("redundantParams") - check(
       List("qux", "1", "-i", "2"),
       MismatchedArguments(
-        missing = List(ArgSig(None, Some('i'), None, None, TokensReader.IntRead, positional = false, hidden = false)),
+        missing = List(ArgSig(
+          None,
+          Some('i'),
+          None,
+          None,
+          TokensReader.IntRead,
+          positional = false,
+          hidden = false
+        )),
         unknown = List("1", "-i", "2")
       )
     )

mainargs/test/src/IssueTests.scala

@@ -5,9 +5,11 @@ object IssueTests extends TestSuite {
 
   object Main {
     @main
-    def mycmd(@arg(name = "the-flag") f: mainargs.Flag = mainargs.Flag(false),
-              @arg str: String = "s",
-              args: Leftover[String]) = {
+    def mycmd(
+        @arg(name = "the-flag") f: mainargs.Flag = mainargs.Flag(false),
+        @arg str: String = "s",
+        args: Leftover[String]
+    ) = {
       (f.value, str, args.value)
     }
   }