Fix scalafmt errors (#200)

Author: mwz

.scalafmt.conf

@@ -5,7 +5,7 @@ align {
   ifWhileOpenParen = false
   openParenCallSite = false
   openParenDefnSite = false
-  tokens.add = [
+  tokens."+" = [
     "%",
     "%%",
     "<-",
@@ -16,7 +16,7 @@ align {
 assumeStandardLibraryStripMargin = true
 continuationIndent.defnSite = 2
 continuationIndent.callSite = 2
-docstrings = JavaDoc
+docstrings.style = Asterisk
 maxColumn = 110
 newlines.implicitParamListModifierPrefer = before
 project {

src/main/scala/org/scalastyle/Checker.scala

@@ -147,8 +147,8 @@ class CheckerUtils(classLoader: Option[ClassLoader] = None) {
           c match {
             case c: FileChecker        => c.verify(file, c.level, lines, lines)
             case c: ScalariformChecker => c.verify(file, c.level, scalariformAst.ast, lines)
-            case c: CombinedChecker    => c.verify(file, c.level, CombinedAst(scalariformAst.ast, lines), lines)
-            case _                     => Nil
+            case c: CombinedChecker => c.verify(file, c.level, CombinedAst(scalariformAst.ast, lines), lines)
+            case _                  => Nil
           }
         )
         .filter(m => CommentFilter.filterApplies(m, commentFilters))
@@ -180,8 +180,8 @@ class CheckerUtils(classLoader: Option[ClassLoader] = None) {
   }
 
   /**
-   * if we pass an encoding in, then we only try that encoding.
-   * If there is no encoding passed, we try the default, then UTF-8, then UTF-16, then ISO-8859-1
+   * if we pass an encoding in, then we only try that encoding. If there is no encoding passed, we try the
+   * default, then UTF-8, then UTF-16, then ISO-8859-1
    */
   def readFile(file: String, encoding: Option[String])(implicit codec: Codec): String = {
     @tailrec

src/main/scala/org/scalastyle/scalariform/CaseBraceChecker.scala

@@ -33,8 +33,10 @@ class CaseBraceChecker extends CombinedChecker {
 
   /**
    * Checks, if given case clause contains just block expression, without anything else.
-   * @param clause case clause to check
-   * @return position of block's left brace, if block found; None otherwise.
+   * @param clause
+   *   case clause to check
+   * @return
+   *   position of block's left brace, if block found; None otherwise.
    */
   private def justBlockPosition(clause: CaseClause) = {
     import clause.statSeq._

src/main/scala/org/scalastyle/scalariform/ClassNamesChecker.scala

@@ -91,7 +91,7 @@ class PackageNamesChecker extends ScalariformChecker {
       tokens match {
         case Nil                                   => (Nil, Nil)
         case hd :: tail if hd.tokenType == PACKAGE => tail.span(isPartOfPackageName)
-        case l: Any                                => getNextPackageName(l.dropWhile(tok => tok.tokenType != PACKAGE))
+        case l: Any => getNextPackageName(l.dropWhile(tok => tok.tokenType != PACKAGE))
       }
 
     @annotation.tailrec

src/main/scala/org/scalastyle/scalariform/ImportsChecker.scala

@@ -157,30 +157,27 @@ class ImportGroupingChecker extends ScalariformChecker {
 }
 
 /**
- * Style checker that enforces import ordering. The following configuration parameters are
- * available:
+ * Style checker that enforces import ordering. The following configuration parameters are available:
  *
- *  - groups: a comma-separated list of group names to consider.
- *  - maxBlankLines: maximum number of blank lines to allow between groups. The default is "1".
- *                   A value less than 1 disables the blank line limit.
- *  - group.[groupName]: a regular expression that matches imports that should be in the given
- *                       group.
- *  - lexicographic: if true, imports are ordered lexicographically (classes, wildcards, then
- *                   packages; case-sensitive ordering within); if false, apply the original
- *                   case-insensitive ordering (with wildcards coming first, before classes).
+ *   - groups: a comma-separated list of group names to consider.
+ *   - maxBlankLines: maximum number of blank lines to allow between groups. The default is "1". A value less
+ *     than 1 disables the blank line limit.
+ *   - group.[groupName]: a regular expression that matches imports that should be in the given group.
+ *   - lexicographic: if true, imports are ordered lexicographically (classes, wildcards, then packages;
+ *     case-sensitive ordering within); if false, apply the original case-insensitive ordering (with wildcards
+ *     coming first, before classes).
  *
- * For example, to check that "java" and "javax" imports are in a separate group at the top of the
- * import list, you'd use this config:
+ * For example, to check that "java" and "javax" imports are in a separate group at the top of the import
+ * list, you'd use this config:
  *
- *  <parameter name="groups">java,others</parameter>
- *  <parameter name="group.java">javax?\..+</parameter>
- *  <parameter name="group.other">.+</parameter>
+ * <parameter name="groups">java,others</parameter> <parameter name="group.java">javax?\..+</parameter>
+ * <parameter name="group.other">.+</parameter>
  *
  * Other non-configurable rules:
- * - Within each group, import clauses are ordered alphabetically if 'lexicographic' is
- *   specified; else puts wildcards, then classes and packages, with case-insensitive sort.
- * - In multi-import statements, entries are ordered alphabetically, with method / packages
- *   (assumed to be any string starting with a lower case letter) coming before classes.
+ *   - Within each group, import clauses are ordered alphabetically if 'lexicographic' is specified; else puts
+ *     wildcards, then classes and packages, with case-insensitive sort.
+ *   - In multi-import statements, entries are ordered alphabetically, with method / packages (assumed to be
+ *     any string starting with a lower case letter) coming before classes.
  *
  * Currently, this checker only looks at the top-level list of imports.
  */
@@ -201,7 +198,7 @@ class ImportOrderChecker extends ScalariformChecker {
     // Note that any exceptions thrown here are swallowed by CheckerUtils and ignored...
     require(parameters.contains("groups"))
     groups = parameters("groups").split(",").toSeq.map { name =>
-      name -> Pattern.compile(parameters(s"group.${name}"))
+      name -> Pattern.compile(parameters(s"group.$name"))
     }
     maxBlankLines = parameters.getOrElse("maxBlankLines", "1").toInt
     lexicographic = parameters.get("lexicographic").map(_.toBoolean).getOrElse(false)
@@ -295,8 +292,8 @@ class ImportOrderChecker extends ScalariformChecker {
   }
 
   /**
-   * When the current import group changes, checks that there is a single empty line between
-   * the last import statement in the previous group and the first statement in the new one.
+   * When the current import group changes, checks that there is a single empty line between the last import
+   * statement in the previous group and the first statement in the new one.
    */
   private def checkGroupSeparation(
     lastGroup: Int,
@@ -360,8 +357,7 @@ class ImportOrderChecker extends ScalariformChecker {
   /**
    * Compares two import statements, comparing each component of the import separately.
    *
-   * The import statements can end with a dangling `.`, meaning they're the start of a
-   * multi-import block.
+   * The import statements can end with a dangling `.`, meaning they're the start of a multi-import block.
    */
   private[scalariform] def compareImports(imp1: String, imp2: String): Int = {
     val imp1Components = imp1.split("[.]")
@@ -388,15 +384,17 @@ class ImportOrderChecker extends ScalariformChecker {
   }
 
   /**
-   * Compares two strings that represent a single imported artifact; this considers lower-case
-   * names as being "lower" than upper case ones.
+   * Compares two strings that represent a single imported artifact; this considers lower-case names as being
+   * "lower" than upper case ones.
    *
-   * @param name1 First name.
-   * @param name2 Second name.
-   * @param isImport If true, orders names according to the import statement rules:
-   *                 "_" should come before other names, and capital letters should come
-   *                 before lower case ones. Otherwise, do the opposite, which are the ordering
-   *                 rules for names within a selector.
+   * @param name1
+   *   First name.
+   * @param name2
+   *   Second name.
+   * @param isImport
+   *   If true, orders names according to the import statement rules: "_" should come before other names, and
+   *   capital letters should come before lower case ones. Otherwise, do the opposite, which are the ordering
+   *   rules for names within a selector.
    */
   private[scalariform] def compareNames(name1: String, name2: String, isImport: Boolean): Int = {
     if (lexicographic && isImport)

src/main/scala/org/scalastyle/scalariform/ScalaDocChecker.scala

@@ -42,14 +42,13 @@ import org.scalastyle.scalariform.VisitorHelper.visit
 
 /**
  * Checks that the ScalaDoc exists for all accessible members:
- * - classes, traits, case classes and objects
- * - methods
- * - vals, vars and types
+ *   - classes, traits, case classes and objects
+ *   - methods
+ *   - vals, vars and types
  *
- * The ScalaDoc's structure must satisfy the parameter of the constructor in case of
- * case classes and classes, or the parameter of the methods. The ScalaDoc must include
- * the type parameters. Finally, the ScalaDoc must include return description for non-Unit
- * returning methods.
+ * The ScalaDoc's structure must satisfy the parameter of the constructor in case of case classes and classes,
+ * or the parameter of the methods. The ScalaDoc must include the type parameters. Finally, the ScalaDoc must
+ * include return description for non-Unit returning methods.
  */
 class ScalaDocChecker extends CombinedChecker {
   protected val errorKey: String = "scaladoc"
@@ -253,7 +252,7 @@ class ScalaDocChecker extends CombinedChecker {
         val skip = t.modifiers.exists {
           case AccessModifier(pop, Some(_)) =>
             if (pop.text == "private") skipQualifiedPrivate else skipQualifiedProtected
-          case AccessModifier(pop, None)                                     => if (pop.text == "private") skipPrivate else skipProtected
+          case AccessModifier(pop, None) => if (pop.text == "private") skipPrivate else skipProtected
           case SimpleModifier(tk) if ignoreOverride && tk.text == "override" => true
           case _                                                             => false
         }
@@ -436,9 +435,12 @@ object ScalaDocChecker {
 
     /**
      * Take the ``raw`` and parse an instance of ``ScalaDoc``
-     * @param raw the token containing the ScalaDoc
-     * @param offset column number of scaladoc's first string
-     * @return the parsed instance
+     * @param raw
+     *   the token containing the ScalaDoc
+     * @param offset
+     *   column number of scaladoc's first string
+     * @return
+     *   the parsed instance
      */
     // scalastyle:off cyclomatic.complexity
     def apply(raw: Token, offset: Int): ScalaDoc = {
@@ -498,19 +500,27 @@ object ScalaDocChecker {
 
   /**
    * Models a parameter: either plain or type
-   * @param name the parameter name
-   * @param text the parameter text
+   * @param name
+   *   the parameter name
+   * @param text
+   *   the parameter text
    */
   private case class ScalaDocParameter(name: String, text: String)
 
   /**
    * Models the parsed ScalaDoc
-   * @param text arbitrary text
-   * @param params the parameters
-   * @param typeParams the type parameters
-   * @param returns the returns clause, if present
-   * @param throws the throws clause, if present
-   * @param indentStyle doc indent style
+   * @param text
+   *   arbitrary text
+   * @param params
+   *   the parameters
+   * @param typeParams
+   *   the type parameters
+   * @param returns
+   *   the returns clause, if present
+   * @param throws
+   *   the throws clause, if present
+   * @param indentStyle
+   *   doc indent style
    */
   private case class ScalaDoc(
     text: String,

src/main/scala/org/scalastyle/scalariform/SimplifyBooleanExpressionChecker.scala

@@ -36,12 +36,12 @@ class SimplifyBooleanExpressionChecker extends ScalariformChecker {
 
   def verify(ast: CompilationUnit): List[ScalastyleError] = {
     val it1 = for {
-      List(left, right) <- ast.tokens.sliding(2);
+      List(left, right) <- ast.tokens.sliding(2)
       if (left.text == "!" && isBoolean(right))
     } yield PositionError(left.offset)
 
     val it2 = for {
-      t <- localvisit(ast);
+      t <- localvisit(ast)
       if (matches(t))
     } yield PositionError(t.position.get)
 

src/main/scala/org/scalastyle/util/CreateRulesMarkdown.scala

@@ -87,7 +87,7 @@ object CreateRulesMarkdown {
     val header = List(
       s"""<a name="${id(c.className)}"></a>""",
       "",
-      s"""### ${c.className} - ${desc}""",
+      s"""### ${c.className} - $desc""",
       "",
       " * id - " + c.id,
       " * description - " + desc,

src/test/scala/org/scalastyle/file/IndentationCheckerTest.scala

@@ -171,8 +171,8 @@ class A {
   }
 
   /**
-   * Check that we don't accidentally think that val defintions are method defintions just because
-   * it includes the word def, and complain about subsequent method argument indentation
+   * Check that we don't accidentally think that val defintions are method defintions just because it includes
+   * the word def, and complain about subsequent method argument indentation
    */
   @Test def testValNotConsideredMethod(): Unit = {
     val source =

src/test/scala/org/scalastyle/scalariform/ReturnCheckerTest.scala

@@ -25,7 +25,8 @@ import org.scalatestplus.junit.AssertionsForJUnit
 /**
  * Test that checks that return keyword should not be used
  *
- * @author Galder Zamarreño
+ * @author
+ *   Galder Zamarreño
  */
 class ReturnCheckerTest extends AssertionsForJUnit with CheckerTest {
 

src/test/scala/org/scalastyle/scalariform/ScalaDocCheckerTest.scala

@@ -166,7 +166,7 @@ class ScalaDocCheckerTest extends AssertionsForJUnit with CheckerTest {
            | * XXX
            | */
            |trait X {
-           |  %s${access} def foo[A, B, U](a: A, b: B): U = ???
+           |  %s$access def foo[A, B, U](a: A, b: B): U = ???
            |}
         """.stripMargin
       val annotatedFun =
@@ -175,7 +175,7 @@ class ScalaDocCheckerTest extends AssertionsForJUnit with CheckerTest {
            | * XXX
            | */
            |trait X {
-           |  %s${access} def foo[@unchecked A, @annotated B, U](@Field() a: A, @Field("b") b: B): U = ???
+           |  %s$access def foo[@unchecked A, @annotated B, U](@Field() a: A, @Field("b") b: B): U = ???
            |}
         """.stripMargin
       val proc1 =
@@ -184,7 +184,7 @@ class ScalaDocCheckerTest extends AssertionsForJUnit with CheckerTest {
            | * XXX
            | */
            |trait X {
-           |  %s${access} def foo[A, B, U](a: A, b: B): Unit = ()
+           |  %s$access def foo[A, B, U](a: A, b: B): Unit = ()
            |}
         """.stripMargin
       val proc2 =
@@ -193,7 +193,7 @@ class ScalaDocCheckerTest extends AssertionsForJUnit with CheckerTest {
            | * XXX
            | */
            |trait X {
-           |  %s${access} def foo[A, B, U](a: A, b: B) {}
+           |  %s$access def foo[A, B, U](a: A, b: B) {}
            |}
         """.stripMargin
       def doc(proc: Boolean) =
@@ -332,7 +332,7 @@ class ScalaDocCheckerTest extends AssertionsForJUnit with CheckerTest {
         s"""
            |$tlDoc
            |$container Foo {
-           |  %s${what}
+           |  %s$what
            |}
         """.stripMargin
       val doc =