scalameta#916 Add option to space context bounds only when multiple. …

…ReaderUtil.oneOf always lowercases

scalafmt-core/shared/src/main/scala/org/scalafmt/config/ReaderUtil.scala

@@ -8,14 +8,14 @@ import metaconfig.Configured._
 object ReaderUtil {
   // Poor mans coproduct reader
   def oneOf[T: ClassTag](options: sourcecode.Text[T]*): ConfDecoder[T] = {
-    val m = options.map(x => x.source -> x.value).toMap
+    val m = options.map(x => x.source.toLowerCase() -> x.value).toMap
     ConfDecoder.instance[T] {
       case Conf.Str(x) =>
-        m.get(x) match {
+        m.get(x.toLowerCase()) match {
           case Some(y) =>
             Ok(y)
           case None =>
-            val available = m.keys.mkString(", ")
+            val available = options.map(_.source).mkString(", ")
             val msg = s"Unknown input '$x'. Expected one of $available"
             ConfError.msg(msg).notOk
         }

scalafmt-core/shared/src/main/scala/org/scalafmt/config/SpaceBeforeContextBound.scala

@@ -0,0 +1,25 @@
+package org.scalafmt.config
+
+import metaconfig.Configured.Ok
+import metaconfig.{Conf, ConfDecoder}
+import org.scalafmt.config.SpaceBeforeContextBound.{Always, IfMultipleBounds}
+
+object SpaceBeforeContextBound {
+
+  implicit val reader = ConfDecoder.instance[SpaceBeforeContextBound] {
+    case Conf.Bool(true) => Ok(Always)
+    case Conf.Bool(false) => Ok(Never)
+    case x =>
+      ReaderUtil
+        .oneOf[SpaceBeforeContextBound](Always, Never, IfMultipleBounds)
+        .read(x)
+  }
+
+  case object Always extends SpaceBeforeContextBound
+  case object Never extends SpaceBeforeContextBound
+  case object IfMultipleBounds extends SpaceBeforeContextBound
+}
+sealed trait SpaceBeforeContextBound {
+  def isIfMultipleBounds = this == IfMultipleBounds
+  def isAlways = this == Always
+}

scalafmt-core/shared/src/main/scala/org/scalafmt/config/Spaces.scala

@@ -1,6 +1,7 @@
 package org.scalafmt.config
 
 import metaconfig._
+import org.scalafmt.config.SpaceBeforeContextBound.Never
 
 /**
   *
@@ -16,9 +17,9 @@ import metaconfig._
   */
 @DeriveConfDecoder
 case class Spaces(
-    beforeContextBoundColon: Boolean = false,
-    afterTripleEquals: Boolean = false,
-    inImportCurlyBraces: Boolean = false,
-    inParentheses: Boolean = false,
-    neverAroundInfixTypes: Seq[String] = Nil
+                   beforeContextBoundColon: SpaceBeforeContextBound = Never,
+                   afterTripleEquals: Boolean = false,
+                   inImportCurlyBraces: Boolean = false,
+                   inParentheses: Boolean = false,
+                   neverAroundInfixTypes: Seq[String] = Nil
 )

scalafmt-core/shared/src/main/scala/org/scalafmt/internal/Router.scala

@@ -772,8 +772,10 @@ class Router(formatOps: FormatOps) {
         )
       case FormatToken(left, Colon(), _) =>
         val mod: Modification = rightOwner match {
-          case _: Type.Param =>
-            if (style.spaces.beforeContextBoundColon) Space else NoSplit
+          case tp: Type.Param =>
+            val contextOption = style.spaces.beforeContextBoundColon
+            if (contextOption.isIfMultipleBounds && tp.cbounds.size > 1 || contextOption.isAlways) Space else NoSplit
+
           case _ =>
             left match {
               case ident: Ident => identModification(ident)

scalafmt-tests/src/test/resources/spaces/BeforeContextBoundColonIfMultipleBounds.stat

@@ -0,0 +1,13 @@
+spaces.beforeContextBoundColon = ifMultipleBounds
+<<< space before colon #180
+def map[T: Class](f: N => T): S[T]
+>>>
+def map[T: Class](f: N => T): S[T]
+<<< space before colon 2 #180
+def orderLaws[A:Eq:Arbitrary] = O
+>>>
+def orderLaws[A : Eq : Arbitrary] = O
+<<< non-ident before colon
+def myMethod[F[_]:Functor](): Foo
+>>>
+def myMethod[F[_]: Functor](): Foo

scalafmt-tests/src/test/resources/spaces/BeforeContextBoundColon.stat → scalafmt-tests/src/test/resources/spaces/BeforeContextBoundColonTrue.stat

@@ -1,5 +1,5 @@
 spaces.beforeContextBoundColon = true
-<<<  space before colon #180
+<<< space before colon #180
 def map[T: Class](f: N => T): S[T]
 >>>
 def map[T : Class](f: N => T): S[T]