added support for param grouping by blank lines

Author: Daniel Trinh

scalariform/src/main/scala/scalariform/formatter/ExprFormatter.scala

@@ -859,16 +859,26 @@ trait ExprFormatter { self: HasFormattingPreferences with AnnotationFormatter wi
    *         Right stores an unalignable param.
    */
   private def groupParams(paramClause: ParamClause, alignParameters: Boolean)(implicit formatterState: FormatterState): List[EitherAlignableParam] = {
-    val ParamClause(_, implicitOption, firstParamOption, otherParams, _) = paramClause
+    val ParamClause(_, implicitOption, firstParamOption, otherParamsWithComma, _) = paramClause
 
-    val paramsList: List[Param] = otherParams.map { case (comma, param) ⇒ param }.reverse
+    val otherParams = otherParamsWithComma.map { case (comma, param) ⇒ param }
 
-    def appendParamToGroup(paramToAppend: Param,
-                           groupedParams: List[EitherAlignableParam],
-                           isFirstParam: Boolean): List[EitherAlignableParam] = {
+    // This is reversed because "appendParamToGroup" works on lists, and will
+    // create the list in the reverse order of the list it is given.
+    val allParams = (firstParamOption.toList ++ otherParams).reverse
+
+    def appendParamToGroup(previousParam: Option[Param],
+                           paramToAppend: Param,
+                           nextParam: Option[Param],
+                           groupedParams: List[EitherAlignableParam]
+                          ): List[EitherAlignableParam] = {
+
+      // This unintuitive line is dependent on the ordering of groupedParams being passed
+      // in. It's in reverse.
+      val isFirstParam = !nextParam.isDefined
 
       val firstParamAlignable = !implicitOption.isDefined ||
-        (newlineBefore(implicitOption.get) && otherParams != Nil && newlineBefore(otherParams.head._2))
+        (newlineBefore(implicitOption.get) && otherParams != Nil && newlineBefore(otherParams.head))
 
       val paramIsAlignable = alignParameters && (!isFirstParam || firstParamAlignable)
 
@@ -879,7 +889,22 @@ trait ExprFormatter { self: HasFormattingPreferences with AnnotationFormatter wi
               case Right(param) :: tail ⇒
                 Left(ConsecutiveSingleLineParams(List(paramToAppend), sectionLengths, sectionLengths)) :: groupedParams
               case Left(existingParams) :: tail ⇒
-                Left(existingParams.prepend(paramToAppend, sectionLengths)) :: tail
+                if (previousParam.isDefined) {
+                  /* Group params separately if a blank line between two params:
+                   * case class Spacing(a:   Int = 1,
+                   *                    bee: Int = 2,
+                   *
+                   *                    ceee:  String = "",
+                   *                    deeee: Any    = Nothing)
+                   */
+                  val numNewlinesBeforeParam = hiddenPredecessors(previousParam.get.firstToken).text.count(_ == '\n')
+                  if (numNewlinesBeforeParam >= 2)
+                    Left(ConsecutiveSingleLineParams(List(paramToAppend), sectionLengths, sectionLengths)) :: groupedParams
+                  else
+                    Left(existingParams.prepend(paramToAppend, sectionLengths)) :: tail
+                } else {
+                  Left(existingParams.prepend(paramToAppend, sectionLengths)) :: tail
+                }
               case Nil ⇒
                 Left(ConsecutiveSingleLineParams(List(paramToAppend), sectionLengths, sectionLengths)) :: Nil
             }
@@ -891,11 +916,11 @@ trait ExprFormatter { self: HasFormattingPreferences with AnnotationFormatter wi
       }
     }
 
-    var paramsGroup = paramsList.foldLeft(List[EitherAlignableParam]()) { (groupedParams, nextParam) ⇒
-      appendParamToGroup(nextParam, groupedParams, isFirstParam = false)
-    }
-    for (firstParam ← firstParamOption) {
-      paramsGroup = appendParamToGroup(firstParam, paramsGroup, isFirstParam = true)
+    val staggeredParams = Utils.withPreviousAndNext(allParams)
+
+    val paramsGroup = staggeredParams.foldLeft(List[EitherAlignableParam]()) { (groupedParams, prevAndNext) ⇒
+      val (prevParam, param, nextParam) = prevAndNext
+      appendParamToGroup(prevParam, param, nextParam, groupedParams)
     }
 
     paramsGroup

scalariform/src/test/scala/scalariform/formatter/TemplateFormatterTest.scala

@@ -431,7 +431,7 @@ implicit val formattingPreferences = FormattingPreferences.setPreference(SpacesW
     """def a(
       |  p1: => (SomeLongByNameParam => SomeShorterParam) = Null,
       |  param2: SomeShorterParam = Null): A""" ==>
-   """def a(
+    """def a(
       |  p1:     => (SomeLongByNameParam => SomeShorterParam) = Null,
       |  param2: SomeShorterParam                             = Null): A"""
 
@@ -450,7 +450,7 @@ implicit val formattingPreferences = FormattingPreferences.setPreference(SpacesW
       |                   paramTwo:   Int    = 2,
       |                   paramThree: String = "3")"""
 
-    // Groups and formats consecutive single line parameters
+    // Groups and formats consecutive single line parameters (multi line params)
     """case class Spacing(param: Int = 1,
       |paramTwo: Int = 2,
       |paramThree: {
@@ -466,6 +466,20 @@ implicit val formattingPreferences = FormattingPreferences.setPreference(SpacesW
       |                   paramFour: Option[String] = Some("One"),
       |                   paramFive: Any            = Nothing)"""
 
+    // Groups and formats consecutive single line parameters (newlines)
+    """case class Spacing(
+      |param: Int = 1,
+      |paramTwo: Int = 2,
+      |
+      |paramFour: Option[String] = Some("One"),
+      |paramFive: Any = Nothing)""" ==>
+    """case class Spacing(
+      |  param:    Int = 1,
+      |  paramTwo: Int = 2,
+      |
+      |  paramFour: Option[String] = Some("One"),
+      |  paramFive: Any            = Nothing)"""
+
     // Aligns implicits and curried parameters properly
     """class SomeClass(
       |parameterOne: Int = 1,
@@ -486,7 +500,7 @@ implicit val formattingPreferences = FormattingPreferences.setPreference(SpacesW
       |      five:     String,
       |      six:      Boolean)"""
 
-    // Handles annotations, modifiers, and comments
+   // Handles annotations, modifiers, and comments
    """def extraStuff(
      |// comment 1
      |@Annotated paramOne: Int = 1, // comment 2