apply scalariform

6 files changed, 43 insertions, 21 deletions

diff --git a/build.sbt b/build.sbt
index 2c1efcc..f1a2bf6 100644
--- a/build.sbt
+++ b/build.sbt
@@ -41,3 +41,5 @@ seq(lsSettings :_*)
 crossBuildingSettings
 
 libraryDependencies += "org.specs2" %% "specs2" % "2.3.13" % "test"
+
+ScalariformSupport.formatSettings
\ No newline at end of file
diff --git a/project/ScalariformSupport.scala b/project/ScalariformSupport.scala
new file mode 100644
index 0000000..665a9e6
--- /dev/null
+++ b/project/ScalariformSupport.scala
@@ -0,0 +1,20 @@
+import sbt._
+
+import com.typesafe.sbt.SbtScalariform
+import com.typesafe.sbt.SbtScalariform.ScalariformKeys
+
+object ScalariformSupport {
+  lazy val formatSettings = SbtScalariform.scalariformSettings ++ Seq(
+    ScalariformKeys.preferences in Compile := formattingPreferences,
+    ScalariformKeys.preferences in Test    := formattingPreferences
+  )
+
+  import scalariform.formatter.preferences._
+  def formattingPreferences =
+    FormattingPreferences()
+      .setPreference(RewriteArrowSymbols, true)
+      .setPreference(AlignParameters, true)
+      .setPreference(AlignSingleLineCaseStatements, true)
+      .setPreference(DoubleIndentClassDeclaration, true)
+
+}
diff --git a/project/plugins.sbt b/project/plugins.sbt
index 23e54f6..ebae536 100644
--- a/project/plugins.sbt
+++ b/project/plugins.sbt
@@ -6,3 +6,5 @@ resolvers ++= Seq(
 addSbtPlugin("me.lessis" % "ls-sbt" % "0.1.2")
 
 addSbtPlugin("net.virtual-void" % "sbt-cross-building" % "0.8.1")
+
+addSbtPlugin("com.typesafe.sbt" % "sbt-scalariform" % "1.2.0")
\ No newline at end of file
diff --git a/src/main/scala/spray/boilerplate/BoilerplatePlugin.scala b/src/main/scala/spray/boilerplate/BoilerplatePlugin.scala
index 149192c..993a800 100644
--- a/src/main/scala/spray/boilerplate/BoilerplatePlugin.scala
+++ b/src/main/scala/spray/boilerplate/BoilerplatePlugin.scala
@@ -30,10 +30,9 @@ object BoilerplatePlugin extends Plugin {
 
       // add managed sources to the packaged sources
       mappings in (Compile, packageSrc) <++=
-        (sourceManaged in Compile, managedSources in Compile) map { (base, srcs) =>
+        (sourceManaged in Compile, managedSources in Compile) map { (base, srcs) ⇒
           (srcs x (Path.relativeTo(base) | Path.flat))
-        }
-    )
+        })
 
     def watch(sourceDirKey: SettingKey[File], filterKey: SettingKey[FileFilter], excludeKey: SettingKey[FileFilter]) =
       watchSources <++= (sourceDirKey, filterKey, excludeKey) map descendents
@@ -49,11 +48,11 @@ object BoilerplatePlugin extends Plugin {
       }
 
       val mapping = (files x rebase(sourceDir, targetDir)).map {
-        case (orig, target) => (orig, changeExtension(target))
+        case (orig, target) ⇒ (orig, changeExtension(target))
       }
 
       mapping foreach {
-        case (templateFile, target) =>
+        case (templateFile, target) ⇒
           if (templateFile.lastModified > target.lastModified) {
             streams.log.info("Generating '%s'" format target.getName)
             val template = IO.read(templateFile)
diff --git a/src/main/scala/spray/boilerplate/Generator.scala b/src/main/scala/spray/boilerplate/Generator.scala
index 37b91eb..b115002 100644
--- a/src/main/scala/spray/boilerplate/Generator.scala
+++ b/src/main/scala/spray/boilerplate/Generator.scala
@@ -12,11 +12,10 @@ object Generator {
   def generateFromTemplate(template: String, expandTo: Int): String =
     generate(TemplateParser.parse(template))(expandTo)
 
-
   def generate(format: TemplateElement)(idx: Int): String = format match {
-    case Sequence(els@_*) => els.map(e => generate(e)(idx)).mkString
-    case Expand(inner, sep) => (1 to idx).map(generate(inner)).mkString(sep)
-    case Offset(i) => (idx + i - 1).toString
-    case LiteralString(lit) => lit
+    case Sequence(els @ _*) ⇒ els.map(e ⇒ generate(e)(idx)).mkString
+    case Expand(inner, sep) ⇒ (1 to idx).map(generate(inner)).mkString(sep)
+    case Offset(i)          ⇒ (idx + i - 1).toString
+    case LiteralString(lit) ⇒ lit
   }
 }
diff --git a/src/main/scala/spray/boilerplate/TemplateParser.scala b/src/main/scala/spray/boilerplate/TemplateParser.scala
index d718e1a..408e551 100644
--- a/src/main/scala/spray/boilerplate/TemplateParser.scala
+++ b/src/main/scala/spray/boilerplate/TemplateParser.scala
@@ -28,21 +28,21 @@ object TemplateParser extends RegexParsers {
   override val skipWhitespace = false
 
   def elements: Parser[TemplateElement] = rep1(element) ^^ maybeSequence
-  def element: Parser[TemplateElement] = offset| literalString | expand
+  def element: Parser[TemplateElement] = offset | literalString | expand
 
-  def offset: Parser[Offset] = offsetChars ^^ (s => Offset(s.toInt))
-  def literalString: Parser[LiteralString] = rep1(escapedLiteralNumber | literalChar) ^^ (chs => LiteralString(chs.mkString))
+  def offset: Parser[Offset] = offsetChars ^^ (s ⇒ Offset(s.toInt))
+  def literalString: Parser[LiteralString] = rep1(escapedLiteralNumber | literalChar) ^^ (chs ⇒ LiteralString(chs.mkString))
   def literalChar: Parser[Char] =
-    not("[#" | """#[^\]]*\]""".r | offsetChars) ~> elem("Any character", _ => true)
+    not("[#" | """#[^\]]*\]""".r | offsetChars) ~> elem("Any character", _ ⇒ true)
 
   def offsetChars = "[012]".r
 
   def escapedLiteralNumber: Parser[Char] = "##" ~> offsetChars ^^ (_.head)
 
-  def outsideTemplate: Parser[LiteralString]= """(?s).+?(?=(\[#)|(\z))""".r ^^ (LiteralString(_))
+  def outsideTemplate: Parser[LiteralString] = """(?s).+?(?=(\[#)|(\z))""".r ^^ (LiteralString(_))
 
   def expand: Parser[Expand] = "[#" ~> elements ~ "#" ~ separatorChars <~ "]" ^^ {
-    case els ~ x ~ sep => Expand(els, sep.getOrElse(", "))
+    case els ~ x ~ sep ⇒ Expand(els, sep.getOrElse(", "))
   }
   def outsideElements: Parser[TemplateElement] =
     rep1(expand | outsideTemplate) ^^ maybeSequence
@@ -50,13 +50,13 @@ object TemplateParser extends RegexParsers {
   def separatorChars: Parser[Option[String]] = rep("""[^\]]""".r) ^^ (_.reduceLeftOption(_ + _))
 
   def maybeSequence(els: Seq[TemplateElement]): TemplateElement = els match {
-    case one :: Nil => one
-    case several => Sequence(several: _*)
+    case one :: Nil ⇒ one
+    case several    ⇒ Sequence(several: _*)
   }
 
-  def parse(input:String): TemplateElement =
+  def parse(input: String): TemplateElement =
     phrase(outsideElements)(new scala.util.parsing.input.CharArrayReader(input.toCharArray)) match {
-      case Success(res,_) => res
-      case x:NoSuccess => throw new RuntimeException(x.msg)
+      case Success(res, _) ⇒ res
+      case x: NoSuccess    ⇒ throw new RuntimeException(x.msg)
     }
 }