Merge pull request #264 from Sciss/sciss_work

code clean-up, latest dependencies

build.sbt

@@ -11,8 +11,8 @@ lazy val commonSettings = inConfig(Test)(Defaults.testSettings) ++
     scalaVersion := crossScalaVersions.value.head,
     crossScalaVersions := Seq(
       "2.12.4",
-      "2.11.11",
-      "2.10.6"
+      "2.11.12",
+      "2.10.7"
     ),
     scalacOptions ++= (CrossVersion.partialVersion(scalaVersion.value) match {
       case Some((2, 12)) => Seq(
@@ -68,7 +68,7 @@ def getPublishToRepo = Def.setting {
     Some(Opts.resolver.sonatypeStaging)
 }
 
-lazy val subprojectSettings = commonSettings :+ (
+def subprojectSettings(projectName: String) = commonSettings ++ Seq(
   ScalariformKeys.preferences := PreferencesImporterExporter.loadPreferences(
     (baseDirectory.value / ".." / "formatterPreferences.properties").getPath)
 )
@@ -85,11 +85,11 @@ def scala2_11Dependencies = Def.setting {
 
 lazy val scalariform = (project
   enablePlugins(BuildInfoPlugin)
-  settings(subprojectSettings)
+  settings(subprojectSettings("scalariform"))
   settings(publishSettings("scalariform"))
   settings(
     libraryDependencies ++= scala2_11Dependencies.value,
-    libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.1" % "test",
+    libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.4" % "test",
     // sbt doesn't automatically load the content of the MANIFST.MF file, therefore
     // we have to do it here by ourselves. Furthermore, the version format in the
     // MANIFEST.MF is `version.qualifier`, which means that we have to replace
@@ -118,13 +118,14 @@ lazy val scalariform = (project
       }
       Package.JarManifest(m)
     },
-    testOptions in Test += Tests.Argument("-oI")
+    testOptions in Test += Tests.Argument("-oI"),
+    mimaPreviousArtifacts := Set(organization.value %% "scalariform" % "0.2.6")
   )
 )
 
 lazy val cli = (project
   enablePlugins(BuildInfoPlugin)
-  settings(subprojectSettings)
+  settings(subprojectSettings("cli"))
   settings(publishSettings("cli"))
   settings(
     libraryDependencies += "commons-io" % "commons-io" % "1.4",

cli/src/main/scala/scalariform/Utils.scala

@@ -1,8 +1,8 @@
 package scalariform
 
 object Utils {
-  def writeText(file: java.io.File, text: String, encodingOpt: Option[String] = None) {
-    import java.io.{OutputStreamWriter, FileOutputStream}
+  def writeText(file: java.io.File, text: String, encodingOpt: Option[String] = None): Unit = {
+    import java.io.{ OutputStreamWriter, FileOutputStream }
     val encoding = encodingOpt getOrElse (System getProperty "file.encoding")
     val writer = new OutputStreamWriter(new FileOutputStream(file), encoding)
     try

cli/src/main/scala/scalariform/commandline/CommandLineOptionParser.scala

@@ -3,49 +3,50 @@ package scalariform.commandline
 import scala.util.parsing.combinator._
 
 class CommandLineOptionParser extends RegexParsers {
+  type Arg = Parser[CommandLineArgument]
 
-  lazy val option: Parser[CommandLineArgument] =
+  lazy val option: Arg =
     phrase(help) | phrase(version) | phrase(scalaVersion) | phrase(stdin) | phrase(stdout) | phrase(recurse) |
       phrase(test) | phrase(forceOutput) | phrase(quiet) | phrase(fileList) | phrase(encoding) | phrase(toggle) |
       phrase(preferenceFile) | phrase(preferenceOption) | phrase(badOption)
 
-  lazy val test = ("--test" | "-t") ^^^ Test
+  lazy val test: Parser[Test.type] = ("--test" | "-t") ^^^ Test
 
-  lazy val forceOutput = ("--forceOutput" | "-f") ^^^ ForceOutput
+  lazy val forceOutput: Arg = ("--forceOutput" | "-f") ^^^ ForceOutput
 
-  lazy val stdout = "--stdout" ^^^ Stdout
+  lazy val stdout: Arg = "--stdout" ^^^ Stdout
 
-  lazy val stdin = "--stdin" ^^^ Stdin
+  lazy val stdin: Arg = "--stdin" ^^^ Stdin
 
-  lazy val quiet = ("--quiet" | "-q") ^^^ Quiet
+  lazy val quiet: Arg = ("--quiet" | "-q") ^^^ Quiet
 
-  lazy val recurse = ("--recurse" | "-r") ^^^ Recurse
+  lazy val recurse: Arg = ("--recurse" | "-r") ^^^ Recurse
 
-  lazy val help = ("--help" | "-help" | "-h") ^^^ Help
+  lazy val help: Arg = ("--help" | "-help" | "-h") ^^^ Help
 
-  lazy val version = ("--version" | "-version") ^^^ Version
+  lazy val version: Arg = ("--version" | "-version") ^^^ Version
 
-  lazy val scalaVersion = ("--scalaVersion=" | "-s=") ~> """(\d|\.)+""".r ^^ ScalaVersion
+  lazy val scalaVersion: Arg = ("--scalaVersion=" | "-s=") ~> """(\d|\.)+""".r ^^ ScalaVersion
 
-  lazy val fileList = ("--fileList=" | "-l=") ~> ".+".r ^^ FileList
+  lazy val fileList: Arg = ("--fileList=" | "-l=") ~> ".+".r ^^ FileList
 
-  lazy val encoding = "--encoding=" ~> ".+".r ^^ Encoding
+  lazy val encoding: Arg = "--encoding=" ~> ".+".r ^^ Encoding
 
-  lazy val toggle = plusOrMinus ~ preferenceKey ^^ { case onOrOff ~ key ⇒ PreferenceOption(key, onOrOff.toString) }
+  lazy val toggle: Arg = plusOrMinus ~ preferenceKey ^^ { case onOrOff ~ key ⇒ PreferenceOption(key, onOrOff.toString) }
 
-  lazy val plusOrMinus = "+" ^^^ true | "-" ^^^ false
+  lazy val plusOrMinus: Parser[Boolean] = "+" ^^^ true | "-" ^^^ false
 
-  lazy val preferenceFile = ("--preferenceFile=" | "-p=") ~> ".+".r ^^ PreferenceFile
+  lazy val preferenceFile: Arg = ("--preferenceFile=" | "-p=") ~> ".+".r ^^ PreferenceFile
 
-  lazy val preferenceOption = ("-" ~> preferenceKey <~ "=") ~ """(\w|\.)+""".r ^^ {
+  lazy val preferenceOption: Arg = ("-" ~> preferenceKey <~ "=") ~ """(\w|\.)+""".r ^^ {
     case (key ~ value) ⇒ PreferenceOption(key, value)
   }
 
   lazy val preferenceKey: Parser[String] = """[a-zA-Z.]+""".r
 
-  lazy val badOption = guard(plusOrMinus) ~> ".*".r ^^ BadOption
+  lazy val badOption: Arg = guard(plusOrMinus) ~> ".*".r ^^ BadOption
 
-  def getArgument(s: String) = parse(option, s) getOrElse FileName(s)
+  def getArgument(s: String): CommandLineArgument = parse(option, s) getOrElse FileName(s)
 }
 
 sealed trait CommandLineArgument

cli/src/main/scala/scalariform/commandline/Main.scala

@@ -12,7 +12,7 @@ import scalariform.Utils._
 
 object Main {
 
-  def main(args: Array[String]) {
+  def main(args: Array[String]): Unit = {
     sys.exit(if (process(args)) 1 else 0)
   }
 
@@ -39,16 +39,16 @@ object Main {
       showUsage = true
     }
 
-    val encoding: String = arguments.collect {
-      case Encoding(encoding) ⇒ encoding
-    }.headOption.getOrElse(System getProperty "file.encoding")
+    val encoding: String = arguments.collectFirst {
+      case Encoding(e) ⇒ e
+    }.getOrElse(System getProperty "file.encoding")
 
     try
       Charset.forName(encoding)
     catch {
-      case e: UnsupportedCharsetException ⇒
+      case _: UnsupportedCharsetException ⇒
         errors ::= "Unsupported encoding " + encoding
-      case e: IllegalCharsetNameException ⇒
+      case _: IllegalCharsetNameException ⇒
         errors ::= "Illegal encoding " + encoding
     }
 
@@ -64,7 +64,7 @@ object Main {
         }
     }
 
-    val preferenceOptions = (for (p @ PreferenceOption(_, _) ← arguments) yield p)
+    val preferenceOptions = for (p @ PreferenceOption(_, _) ← arguments) yield p
 
     for (PreferenceOption(key, _) ← preferenceOptions if !(AllPreferences.preferencesByKey contains key)) {
       errors ::= "Unrecognised preference: " + key
@@ -74,14 +74,14 @@ object Main {
     if (errors.isEmpty) {
 
       preferences = preferenceOptions.foldLeft(preferences) {
-        case (preferences, PreferenceOption(key, valueString)) ⇒
+        case (p, PreferenceOption(key, valueString)) ⇒
           val descriptor = AllPreferences.preferencesByKey(key)
           def processDescriptor[T](descriptor: PreferenceDescriptor[T]) = {
             descriptor.preferenceType.parseValue(valueString) match {
-              case Right(value) ⇒ preferences.setPreference(descriptor, value)
+              case Right(value) ⇒ p.setPreference(descriptor, value)
               case Left(error) ⇒
                 errors ::= "Could not parse value for preference " + key + ", " + error
-                preferences
+                p
             }
           }
           processDescriptor(descriptor)
@@ -92,7 +92,7 @@ object Main {
 
     def getFiles(): List[File] = {
       var files: List[File] = Nil
-      def addFile(fileName: String) {
+      def addFile(fileName: String): Unit = {
         val file = new File(fileName)
         if (!file.exists)
           errors ::= "No such file " + file
@@ -140,19 +140,19 @@ object Main {
     if (forceOutput && files.size > 1)
       errors ::= "Cannot use --forceOutput with multiple files"
 
-    if (!errors.isEmpty) {
+    if (errors.nonEmpty) {
       for (error ← errors.reverse)
         System.err.println("Error: " + error)
       if (showUsage)
         printUsage()
       return true
     }
 
-    def log(s: String) = if (!quiet && !stdout && !stdin) println(s)
+    def log(s: String): Unit = if (!quiet && !stdout && !stdin) println(s)
 
-    val scalaVersion = arguments.collect {
-      case ScalaVersion(scalaVersion) ⇒ scalaVersion
-    }.headOption.getOrElse(ScalaVersions.DEFAULT_VERSION)
+    val scalaVersion = arguments.collectFirst {
+      case ScalaVersion(sv) ⇒ sv
+    }.getOrElse(ScalaVersions.DEFAULT_VERSION)
 
     log("Assuming source is Scala " + scalaVersion)
 
@@ -166,7 +166,7 @@ object Main {
       try
         Some(ScalaFormatter.format(s, preferences, scalaVersion = scalaVersion))
       catch {
-        case e: ScalaParserException ⇒ None
+        case _: ScalaParserException ⇒ None
       }
 
     if (test)
@@ -293,7 +293,7 @@ object Main {
   private case object NotFormattedCorrectly extends FormatResult
   private case object DidNotParse extends FormatResult
 
-  private def printUsage() {
+  private def printUsage(): Unit = {
     println("Usage: scalariform [options] [files...]")
     println()
     println("Options:")

cli/src/main/scala/scalariform/commandline/ScalaFileWalker.scala

@@ -1,7 +1,7 @@
 package scalariform.commandline
 
 import java.io.File
-import java.util.{ArrayList, Collection}
+import java.util.{ ArrayList, Collection }
 import scala.collection.JavaConverters._
 
 import org.apache.commons.io._

project/build.properties

@@ -1 +1 @@
-sbt.version=1.0.2
+sbt.version=1.0.4

project/build.sbt

@@ -1 +1 @@
-scalacOptions := Seq("-feature", "-deprecation", "-Xlint")
+scalacOptions := Seq("-feature", "-deprecation", "-Xlint:-unused,_")

project/plugins.sbt

@@ -1,5 +1,6 @@
-addSbtPlugin("org.scalariform" % "sbt-scalariform" % "1.8.1")
-addSbtPlugin("com.jsuereth" % "sbt-pgp" % "1.1.0")
-addSbtPlugin("com.eed3si9n" % "sbt-buildinfo" % "0.7.0")
-addSbtPlugin("org.xerial.sbt" % "sbt-sonatype" % "2.0")
-addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "0.14.5")
+addSbtPlugin("org.scalariform" % "sbt-scalariform"  % "1.8.2")
+addSbtPlugin("com.jsuereth"    % "sbt-pgp"          % "1.1.0")
+addSbtPlugin("com.eed3si9n"    % "sbt-buildinfo"    % "0.7.0")
+addSbtPlugin("org.xerial.sbt"  % "sbt-sonatype"     % "2.0")
+addSbtPlugin("com.eed3si9n"    % "sbt-assembly"     % "0.14.6")
+addSbtPlugin("com.typesafe"    % "sbt-mima-plugin"  % "0.1.18")

scalariform/src/main/scala/scalariform/ScalaVersions.scala

@@ -1,8 +1,8 @@
 package scalariform
 
+import scala.math.Ordering
 import scala.util.Properties
 import scalariform.utils.Utils._
-import scala.math.Ordering
 
 object ScalaVersion {
 
@@ -27,21 +27,21 @@ case class ScalaVersion(major: Int, minor: Int, extra: String = "") extends Orde
 
   private def majorMinor = (major, minor)
 
-  def compare(that: ScalaVersion) = Ordering[(Int, Int)].compare(this.majorMinor, that.majorMinor)
+  def compare(that: ScalaVersion): Int = Ordering[(Int, Int)].compare(this.majorMinor, that.majorMinor)
 
-  override def toString = major + "." + minor + "." + extra
+  override def toString: String = major + "." + minor + "." + extra
 
 }
 
 object ScalaVersions {
 
-  val Scala_2_11 = ScalaVersion.parse("2.11.0").get
-  val Scala_2_10 = ScalaVersion.parse("2.10.0").get
-  val Scala_2_9 = ScalaVersion.parse("2.9.2").get
-  val Scala_2_8 = ScalaVersion.parse("2.8.1").get
+  val Scala_2_11: ScalaVersion = ScalaVersion.parse("2.11.0").get
+  val Scala_2_10: ScalaVersion = ScalaVersion.parse("2.10.0").get
+  val Scala_2_9: ScalaVersion = ScalaVersion.parse("2.9.2").get
+  val Scala_2_8: ScalaVersion = ScalaVersion.parse("2.8.1").get
 
-  lazy val DEFAULT_VERSION = Properties.scalaPropOrElse("version.number", "2.9.2")
+  lazy val DEFAULT_VERSION: String = Properties.scalaPropOrElse("version.number", "2.9.2")
 
-  lazy val DEFAULT = ScalaVersion.parse(DEFAULT_VERSION).get
+  lazy val DEFAULT: ScalaVersion = ScalaVersion.parse(DEFAULT_VERSION).get
 
 }

scalariform/src/main/scala/scalariform/astselect/AstSelector.scala

@@ -1,10 +1,10 @@
 package scalariform.astselect
 
+import scala.util.control.Exception._
+import scalariform.ScalaVersions
 import scalariform.lexer._
 import scalariform.parser._
 import scalariform.utils.Range
-import scala.util.control.Exception._
-import scalariform.ScalaVersions
 
 object AstSelector {
 
@@ -58,7 +58,7 @@ class AstSelector(source: String, scalaVersion: String = ScalaVersions.DEFAULT_V
 
   private val compilationUnitOpt: Option[CompilationUnit] = {
     val parser = new ScalaParser(tokens.toArray)
-    parser.safeParse(parser.compilationUnitOrScript)
+    parser.safeParse(parser.compilationUnitOrScript())
   }
 
   private val allTokens: List[Token] = tokens.flatMap { token ⇒
@@ -183,7 +183,7 @@ class AstSelector(source: String, scalaVersion: String = ScalaVersions.DEFAULT_V
     nodeStack match {
       case List(_: BlockExpr, _: MatchExpr, _*)   ⇒ false
       case List(_: BlockExpr, _: ProcFunBody, _*) ⇒ false
-      case List(node, _*)                         ⇒ !(nonSelectableAstNodes contains node.getClass.asInstanceOf[Class[_ <: AstNode]])
+      case List(node, _*)                         ⇒ !(nonSelectableAstNodes contains node.getClass)
       case Nil                                    ⇒ false
     }
 

scalariform/src/main/scala/scalariform/formatter/Alignment.scala

@@ -1,7 +1,8 @@
 package scalariform.formatter
 
+import java.lang.Math._
+
 import scalariform.parser._
-import Math._
 
 // For now, this is just a place to store alignment related functionality.
 // TOOD: refactor duplicate behavior in here
@@ -30,9 +31,8 @@ object Alignment {
     largestIdLength: Int
   ) {
 
-    def prepend(equalsExpr: EqualsExpr, length: Int) = {
+    def prepend(equalsExpr: EqualsExpr, length: Int) =
       ConsecutiveSingleLineEqualsExprs(equalsExpr :: equalsExprs, max(length, largestIdLength))
-    }
   }
 
   case class ConsecutiveSingleLineCaseClauses(
@@ -43,7 +43,7 @@ object Alignment {
     def prepend(clause: CaseClause, length: Int) =
       ConsecutiveSingleLineCaseClauses(clause :: clauses, max(length, largestCasePatternLength), min(length, smallestCasePatternLength))
 
-    def patternLengthRange = largestCasePatternLength - smallestCasePatternLength
+    def patternLengthRange: Int = largestCasePatternLength - smallestCasePatternLength
 
   }
 

scalariform/src/main/scala/scalariform/formatter/AnnotationFormatter.scala

@@ -1,7 +1,7 @@
 package scalariform.formatter
 
-import scalariform.parser._
 import scalariform.formatter.preferences._
+import scalariform.parser._
 
 trait AnnotationFormatter { self: HasFormattingPreferences with TypeFormatter with ExprFormatter ⇒