Merge pull request #57 from xuwei-k/unicode

replace deprecated unicode arrow
sbt · Nov 15, 2024 · 30fa89d · 30fa89d
2 parents c1c09ea + eaa094e
commit 30fa89d
Show file tree

Hide file tree

Showing 3 changed files with 18 additions and 18 deletions.
diff --git a/src/main/scala/spray/boilerplate/BoilerplatePlugin.scala b/src/main/scala/spray/boilerplate/BoilerplatePlugin.scala
@@ -53,13 +53,13 @@ object BoilerplatePlugin extends AutoPlugin {
     }
 
     val mapping = (files pair Path.rebase(sourceDir, targetDir)).map {
-      case (orig, target) ⇒ (orig, changeExtension(target))
+      case (orig, target) => (orig, changeExtension(target))
     }
 
     val newFiles = mapping.map(_._2)
     clearTargetDir(streams, targetDir, signature, newFiles)
     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)
@@ -88,13 +88,13 @@ object BoilerplatePlugin extends AutoPlugin {
     val toRemove =
       Compat.allPaths(targetDir)
         // apply filters with increasing effort
-        .filter(f ⇒ f.exists && f.isFile)
+        .filter(f => f.exists && f.isFile)
         .filter(_.length >= signature.length)
         .filter(!fileSet(_))
         .filter(containsSignature _)
         .get
 
-    toRemove.foreach { f ⇒
+    toRemove.foreach { f =>
       streams.log.debug(s"Removing $f that was formerly created by sbt-boilerplate (but won't be created anew).")
       f.delete
     }

diff --git a/src/main/scala/spray/boilerplate/Generator.scala b/src/main/scala/spray/boilerplate/Generator.scala
@@ -11,9 +11,9 @@ object Generator {
     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, range) ⇒ (range.start.getOrElse(1) to range.end.getOrElse(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, range) => (range.start.getOrElse(1) to range.end.getOrElse(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
@@ -40,27 +40,27 @@ object TemplateParser extends RegexParsers {
   lazy val elements: Parser[TemplateElement] = rep1(element) ^^ maybeSequence
   lazy val element: Parser[TemplateElement] = offset | literalString | expand
 
-  lazy val offset: Parser[Offset] = offsetChars ^^ (s ⇒ Offset(s - '0'))
-  lazy val literalString: Parser[LiteralString] = rep1(escapedSharp | escapedLiteralNumber | literalChar) ^^ (chs ⇒ LiteralString(chs.mkString))
+  lazy val offset: Parser[Offset] = offsetChars ^^ (s => Offset(s - '0'))
+  lazy val literalString: Parser[LiteralString] = rep1(escapedSharp | escapedLiteralNumber | literalChar) ^^ (chs => LiteralString(chs.mkString))
   lazy val literalChar: Parser[Char] =
     not(expandStart | """#[^\]]*\]""".r | offsetChars) ~> elem("Any character", _ != EOI)
 
   lazy val offsetChars: Parser[Char] = "[012]".r ^^ (_.head) | failure("'##' is used to quote '0', '1', or '2', use '\\#\\#' to output double hashes")
 
   lazy val escapedSharp: Parser[Char] = "\\#" ~> success('#')
-  lazy val escapedLiteralNumber: Parser[Char] = "##" ~! offsetChars ^^ { case _ ~ x ⇒ x }
+  lazy val escapedLiteralNumber: Parser[Char] = "##" ~! offsetChars ^^ { case _ ~ x => x }
 
-  lazy val outsideLiteralString: Parser[LiteralString] = rep1(escapedSharp | outsideLiteralChar) ^^ (chs ⇒ LiteralString(chs.mkString))
+  lazy val outsideLiteralString: Parser[LiteralString] = rep1(escapedSharp | outsideLiteralChar) ^^ (chs => LiteralString(chs.mkString))
   lazy val outsideLiteralChar: Parser[Char] = not(expandStart) ~> elem("Any character", _ != EOI)
 
   lazy val expand: Parser[Expand] = expandStart ~ elements ~ "#" ~ separatorChars <~ "]" ^^ {
-    case range ~ els ~ x ~ sep ⇒ Expand(els, sep.getOrElse(Expand.defaultSeparator), range)
+    case range ~ els ~ x ~ sep => Expand(els, sep.getOrElse(Expand.defaultSeparator), range)
   }
   lazy val expandStart: Parser[Range] = "[" ~> range <~ "#"
 
   lazy val range: Parser[Range] =
     (opt("""\d{1,2}""".r) ~ """\s*\.\.\s*""".r ~ opt("""\d{1,2}""".r) ^^ {
-      case start ~ sep ~ end ⇒ Range(start.map(_.toInt), end.map(_.toInt))
+      case start ~ sep ~ end => Range(start.map(_.toInt), end.map(_.toInt))
     }) | success(Range())
 
   lazy val outsideElements: Parser[TemplateElement] =
@@ -69,13 +69,13 @@ object TemplateParser extends RegexParsers {
   lazy val 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 =
     phrase(outsideElements)(new scala.util.parsing.input.CharArrayReader(input.toCharArray)) match {
-      case Success(res, _) ⇒ res
-      case x: NoSuccess    ⇒ throw new RuntimeException(s"Parsing failed: $x")
+      case Success(res, _) => res
+      case x: NoSuccess    => throw new RuntimeException(s"Parsing failed: $x")
     }
 }