From eaa094e38b11090e4c10530a1491c54b1f7cd65e Mon Sep 17 00:00:00 2001 From: xuwei-k <6b656e6a69@gmail.com> Date: Wed, 9 Oct 2024 08:35:30 +0900 Subject: [PATCH] replace deprecated unicode arrow --- .../spray/boilerplate/BoilerplatePlugin.scala | 8 ++++---- .../scala/spray/boilerplate/Generator.scala | 8 ++++---- .../spray/boilerplate/TemplateParser.scala | 20 +++++++++---------- 3 files changed, 18 insertions(+), 18 deletions(-) diff --git a/src/main/scala/spray/boilerplate/BoilerplatePlugin.scala b/src/main/scala/spray/boilerplate/BoilerplatePlugin.scala index 50bcfd5..9692ee9 100644 --- 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 index db2feb9..0ef4316 100644 --- 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 index 99784d9..dd1dbbe 100644 --- 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") } }