1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
|
/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2007-2013, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
/**
* This package is concerned with regular expression (regex) matching against strings,
* with the main goal of pulling out information from those matches, or replacing
* them with something else.
*
* There are four classes and three objects, with most of them being members of
* Regex companion object. [[scala.util.matching.Regex]] is the class users instantiate
* to do regular expression matching.
*
* The remaining classes and objects in the package are used in the following way:
*
* * The companion object to [[scala.util.matching.Regex]] just contains the other members.
* * [[scala.util.matching.Regex.Match]] makes more information about a match available.
* * [[scala.util.matching.Regex.MatchIterator]] is used to iterate over multiple matches.
* * [[scala.util.matching.Regex.MatchData]] is just a base trait for the above classes.
* * [[scala.util.matching.Regex.Groups]] extracts group from a [[scala.util.matching.Regex.Match]]
* without recomputing the match.
* * [[scala.util.matching.Regex.Match]] converts a [[scala.util.matching.Regex.Match]]
* into a [[java.lang.String]].
*
*/
package scala
package util.matching
import scala.collection.AbstractIterator
import java.util.regex.{ Pattern, Matcher }
/** This class provides methods for creating and using regular expressions.
* It is based on the regular expressions of the JDK since 1.4.
*
* Its main goal is to extract strings that match a pattern, or the subgroups
* that make it up. For that reason, it is usually used with for comprehensions
* and matching (see methods for examples).
*
* A Regex is created from a [[java.lang.String]] representation of the
* regular expression pattern^1^. That pattern is compiled
* during construction, so frequently used patterns should be declared outside
* loops if performance is of concern. Possibly, they might be declared on a
* companion object, so that they need only to be initialized once.
*
* The canonical way of creating regex patterns is by using the method `r`, provided
* on [[java.lang.String]] through an implicit conversion into
* [[scala.collection.immutable.WrappedString]]. Using triple quotes to write these
* strings avoids having to quote the backslash character (`\`).
*
* Using the constructor directly, on the other hand, makes
* it possible to declare names for subgroups in the pattern.
*
* For example, both declarations below generate the same regex, but the second
* one associate names with the subgroups.
*
* {{{
* val dateP1 = """(\d\d\d\d)-(\d\d)-(\d\d)""".r
* val dateP2 = new scala.util.matching.Regex("""(\d\d\d\d)-(\d\d)-(\d\d)""", "year", "month", "day")
* }}}
*
* There are two ways of using a `Regex` to find a pattern: calling methods on
* Regex, such as `findFirstIn` or `findAllIn`, or using it as an extractor in a
* pattern match.
*
* Note, however, that when Regex is used as an extractor in a pattern match, it
* only succeeds if the whole text can be matched. For this reason, one usually
* calls a method to find the matching substrings, and then use it as an extractor
* to break match into subgroups.
*
* As an example, the above patterns can be used like this:
*
* {{{
* val dateP1(year, month, day) = "2011-07-15"
*
* // val dateP1(year, month, day) = "Date 2011-07-15" // throws an exception at runtime
*
* val copyright: String = dateP1 findFirstIn "Date of this document: 2011-07-15" match {
* case Some(dateP1(year, month, day)) => "Copyright "+year
* case None => "No copyright"
* }
*
* val copyright: Option[String] = for {
* dateP1(year, month, day) <- dateP1 findFirstIn "Last modified 2011-07-15"
* } yield year
* def getYears(text: String): Iterator[String] = for (dateP1(year, _, _) <- dateP1 findAllIn text) yield year
* def getFirstDay(text: String): Option[String] = for (m <- dateP2 findFirstMatchIn text) yield m group "day"
* }}}
*
* Regex does not provide a method that returns a [[scala.Boolean]]. One can
* use [[java.lang.String]] `matches` method, or, if `Regex` is preferred,
* either ignore the return value or test the `Option` for emptyness. For example:
*
* {{{
* def hasDate(text: String): Boolean = (dateP1 findFirstIn text).nonEmpty
* def printLinesWithDates(lines: Traversable[String]) {
* lines foreach { line =>
* dateP1 findFirstIn line foreach { _ => println(line) }
* }
* }
* }}}
*
* There are also methods that can be used to replace the patterns
* on a text. The substitutions can be simple replacements, or more
* complex functions. For example:
*
* {{{
* val months = Map( 1 -> "Jan", 2 -> "Feb", 3 -> "Mar",
* 4 -> "Apr", 5 -> "May", 6 -> "Jun",
* 7 -> "Jul", 8 -> "Aug", 9 -> "Sep",
* 10 -> "Oct", 11 -> "Nov", 12 -> "Dec")
*
* import scala.util.matching.Regex.Match
* def reformatDate(text: String) = dateP2 replaceAllIn ( text, (m: Match) =>
* "%s %s, %s" format (months(m group "month" toInt), m group "day", m group "year")
* )
* }}}
*
* You can use special pattern syntax constructs like `(?idmsux-idmsux)`¹ to switch
* various regex compilation options like `CASE_INSENSITIVE` or `UNICODE_CASE`.
*
* @note ¹ A detailed description is available in [[java.util.regex.Pattern]].
* @see [[java.util.regex.Pattern]]
*
* @author Thibaud Hottelier
* @author Philipp Haller
* @author Martin Odersky
* @version 1.1, 29/01/2008
*
* @param pattern The compiled pattern
* @param groupNames A mapping from names to indices in capture groups
*
* @define replacementString
* In the replacement String, a dollar sign (`$`) followed by a number will be
* interpreted as a reference to a group in the matched pattern, with numbers
* 1 through 9 corresponding to the first nine groups, and 0 standing for the
* whole match. Any other character is an error. The backslash (`\`) character
* will be interpreted as an escape character, and can be used to escape the
* dollar sign. One can use [[scala.util.matching.Regex]]'s `quoteReplacement`
* to automatically escape these characters.
*/
@SerialVersionUID(-2094783597747625537L)
class Regex private[matching](val pattern: Pattern, groupNames: String*) extends Serializable {
outer =>
import Regex._
/**
* @param regex A string representing a regular expression
* @param groupNames A mapping from names to indices in capture groups
*/
def this(regex: String, groupNames: String*) = this(Pattern.compile(regex), groupNames: _*)
/** Tries to match a [[java.lang.CharSequence]].
* If the match succeeds, the result is a list of the matching
* groups (or a `null` element if a group did not match any input).
* If the pattern specifies no groups, then the result will be an empty list
* on a successful match.
*
* This method attempts to match the entire input by default; to find the next
* matching subsequence, use an unanchored Regex.
* For example:
*
* {{{
* val p1 = "ab*c".r
* val p1Matches = "abbbc" match {
* case p1() => true
* case _ => false
* }
* val p2 = "a(b*)c".r
* val numberOfB = "abbbc" match {
* case p2(b) => Some(b.length)
* case _ => None
* }
* val p3 = "b*".r.unanchored
* val p3Matches = "abbbc" match {
* case p3() => true
* case _ => false
* }
* }}}
*
* @param s The string to match
* @return The matches
*/
def unapplySeq(s: CharSequence): Option[Seq[String]] = {
val m = pattern matcher s
if (runMatcher(m)) Some(1 to m.groupCount map m.group)
else None
}
/** Tries to match on a [[scala.util.matching.Regex.Match]].
* A previously failed match results in None.
* If a successful match was made against the current pattern, then that result is used.
* Otherwise, this Regex is applied to the previously matched input,
* and the result of that match is used.
*/
def unapplySeq(m: Match): Option[Seq[String]] =
if (m.matched == null) None
else if (m.matcher.pattern == this.pattern) Some(1 to m.groupCount map m.group)
else unapplySeq(m.matched)
/** Tries to match target.
* @param target The string to match
* @return The matches
*/
@deprecated("Extracting a match result from anything but a CharSequence or Match is deprecated", "2.11.0")
def unapplySeq(target: Any): Option[List[String]] = target match {
case s: CharSequence =>
val m = pattern matcher s
if (runMatcher(m)) Some((1 to m.groupCount).toList map m.group)
else None
case m: Match => unapplySeq(m.matched)
case _ => None
}
// @see UnanchoredRegex
protected def runMatcher(m: Matcher) = m.matches()
/** Return all matches of this regexp in given character sequence as a [[scala.util.matching.Regex.MatchIterator]],
* which is a special [[scala.collection.Iterator]] that returns the
* matched strings, but can also be converted into a normal iterator
* that returns objects of type [[scala.util.matching.Regex.Match]]
* that can be queried for data such as the text that precedes the
* match, subgroups, etc.
*
* @param source The text to match against.
* @return A [[scala.util.matching.Regex.MatchIterator]] of all matches.
* @example {{{for (words <- """\w+""".r findAllIn "A simple example.") yield words}}}
*/
def findAllIn(source: CharSequence) = new Regex.MatchIterator(source, this, groupNames)
/** Return all matches of this regexp in given character sequence as a
* [[scala.collection.Iterator]] of [[scala.util.matching.Regex.Match]].
*
* @param source The text to match against.
* @return A [[scala.collection.Iterator]] of [[scala.util.matching.Regex.Match]] for all matches.
* @example {{{for (words <- """\w+""".r findAllMatchIn "A simple example.") yield words.start}}}
*/
def findAllMatchIn(source: CharSequence): Iterator[Match] = {
val matchIterator = findAllIn(source)
new Iterator[Match] {
def hasNext = matchIterator.hasNext
def next: Match = {
matchIterator.next()
new Match(matchIterator.source, matchIterator.matcher, matchIterator.groupNames).force
}
}
}
/** Return optionally first matching string of this regexp in given character sequence,
* or None if it does not exist.
*
* @param source The text to match against.
* @return An [[scala.Option]] of the first matching string in the text.
* @example {{{"""\w+""".r findFirstIn "A simple example." foreach println // prints "A"}}}
*/
def findFirstIn(source: CharSequence): Option[String] = {
val m = pattern.matcher(source)
if (m.find) Some(m.group) else None
}
/** Return optionally first match of this regexp in given character sequence,
* or None if it does not exist.
*
* The main difference between this method and `findFirstIn` is that the (optional) return
* type for this is [[scala.util.matching.Regex.Match]], through which more
* data can be obtained about the match, such as the strings that precede and follow it,
* or subgroups.
*
* @param source The text to match against.
* @return A [[scala.Option]] of [[scala.util.matching.Regex.Match]] of the first matching string in the text.
* @example {{{("""[a-z]""".r findFirstMatchIn "A simple example.") map (_.start) // returns Some(2), the index of the first match in the text}}}
*/
def findFirstMatchIn(source: CharSequence): Option[Match] = {
val m = pattern.matcher(source)
if (m.find) Some(new Match(source, m, groupNames)) else None
}
/** Return optionally match of this regexp at the beginning of the
* given character sequence, or None if regexp matches no prefix
* of the character sequence.
*
* The main difference from this method to `findFirstIn` is that this
* method will not return any matches that do not begin at the start
* of the text being matched against.
*
* @param source The text to match against.
* @return A [[scala.Option]] of the matched prefix.
* @example {{{"""[a-z]""".r findPrefixOf "A simple example." // returns None, since the text does not begin with a lowercase letter}}}
*/
def findPrefixOf(source: CharSequence): Option[String] = {
val m = pattern.matcher(source)
if (m.lookingAt) Some(m.group) else None
}
/** Return optionally match of this regexp at the beginning of the
* given character sequence, or None if regexp matches no prefix
* of the character sequence.
*
* The main difference from this method to `findFirstMatchIn` is that
* this method will not return any matches that do not begin at the
* start of the text being matched against.
*
* @param source The text to match against.
* @return A [[scala.Option]] of the [[scala.util.matching.Regex.Match]] of the matched string.
* @example {{{"""\w+""".r findPrefixMatchOf "A simple example." map (_.after) // returns Some(" simple example.")}}}
*/
def findPrefixMatchOf(source: CharSequence): Option[Match] = {
val m = pattern.matcher(source)
if (m.lookingAt) Some(new Match(source, m, groupNames)) else None
}
/** Replaces all matches by a string.
*
* $replacementString
*
* @param target The string to match
* @param replacement The string that will replace each match
* @return The resulting string
* @example {{{"""\d+""".r replaceAllIn ("July 15", "<NUMBER>") // returns "July <NUMBER>"}}}
*/
def replaceAllIn(target: CharSequence, replacement: String): String = {
val m = pattern.matcher(target)
m.replaceAll(replacement)
}
/**
* Replaces all matches using a replacer function. The replacer function takes a
* [[scala.util.matching.Regex.Match]] so that extra information can be obtained
* from the match. For example:
*
* {{{
* import scala.util.matching.Regex
* val datePattern = new Regex("""(\d\d\d\d)-(\d\d)-(\d\d)""", "year", "month", "day")
* val text = "From 2011-07-15 to 2011-07-17"
* val repl = datePattern replaceAllIn (text, m => m.group("month")+"/"+m.group("day"))
* }}}
*
* $replacementString
*
* @param target The string to match.
* @param replacer The function which maps a match to another string.
* @return The target string after replacements.
*/
def replaceAllIn(target: CharSequence, replacer: Match => String): String = {
val it = new Regex.MatchIterator(target, this, groupNames).replacementData
it foreach (md => it replace replacer(md))
it.replaced
}
/**
* Replaces some of the matches using a replacer function that returns an [[scala.Option]].
* The replacer function takes a [[scala.util.matching.Regex.Match]] so that extra
* information can be btained from the match. For example:
*
* {{{
* import scala.util.matching.Regex._
*
* val map = Map("x" -> "a var", "y" -> """some $ and \ signs""")
* val text = "A text with variables %x, %y and %z."
* val varPattern = """%(\w+)""".r
* val mapper = (m: Match) => map get (m group 1) map (quoteReplacement(_))
* val repl = varPattern replaceSomeIn (text, mapper)
* }}}
*
* $replacementString
*
* @param target The string to match.
* @param replacer The function which optionally maps a match to another string.
* @return The target string after replacements.
*/
def replaceSomeIn(target: CharSequence, replacer: Match => Option[String]): String = {
val it = new Regex.MatchIterator(target, this, groupNames).replacementData
for (matchdata <- it ; replacement <- replacer(matchdata))
it replace replacement
it.replaced
}
/** Replaces the first match by a string.
*
* $replacementString
*
* @param target The string to match
* @param replacement The string that will replace the match
* @return The resulting string
*/
def replaceFirstIn(target: CharSequence, replacement: String): String = {
val m = pattern.matcher(target)
m.replaceFirst(replacement)
}
/** Splits the provided character sequence around matches of this regexp.
*
* @param toSplit The character sequence to split
* @return The array of strings computed by splitting the
* input around matches of this regexp
*/
def split(toSplit: CharSequence): Array[String] =
pattern.split(toSplit)
/** Create a new Regex with the same pattern, but no requirement that
* the entire String matches in extractor patterns. For instance, the strings
* shown below lead to successful matches, where they would not otherwise.
*
* {{{
* val dateP1 = """(\d\d\d\d)-(\d\d)-(\d\d)""".r.unanchored
*
* val dateP1(year, month, day) = "Date 2011-07-15"
*
* val copyright: String = "Date of this document: 2011-07-15" match {
* case dateP1(year, month, day) => "Copyright "+year
* case _ => "No copyright"
* }
* }}}
*
* @return The new unanchored regex
*/
def unanchored: UnanchoredRegex = new Regex(pattern, groupNames: _*) with UnanchoredRegex { override def anchored = outer }
def anchored: Regex = this
def regex: String = pattern.pattern
/** The string defining the regular expression */
override def toString = regex
}
trait UnanchoredRegex extends Regex {
override protected def runMatcher(m: Matcher) = m.find()
override def unanchored = this
}
/** This object defines inner classes that describe
* regex matches and helper objects. The class hierarchy
* is as follows:
*
* {{{
* MatchData
* / \
* MatchIterator Match
* }}}
*
*/
object Regex {
/** This class provides methods to access
* the details of a match.
*/
trait MatchData {
/** The source from where the match originated */
val source: CharSequence
/** The names of the groups, or some empty sequence if one defined */
val groupNames: Seq[String]
/** The number of subgroups in the pattern (not all of these need to match!) */
def groupCount: Int
/** The index of the first matched character, or -1 if nothing was matched */
def start: Int
/** The index of the first matched character in group `i`,
* or -1 if nothing was matched for that group */
def start(i: Int): Int
/** The index of the last matched character, or -1 if nothing was matched */
def end: Int
/** The index following the last matched character in group `i`,
* or -1 if nothing was matched for that group */
def end(i: Int): Int
/** The matched string, or `null` if nothing was matched */
def matched: String =
if (start >= 0) source.subSequence(start, end).toString
else null
/** The matched string in group `i`,
* or `null` if nothing was matched */
def group(i: Int): String =
if (start(i) >= 0) source.subSequence(start(i), end(i)).toString
else null
/** All matched subgroups, i.e. not including group(0) */
def subgroups: List[String] = (1 to groupCount).toList map group
/** The char sequence before first character of match,
* or `null` if nothing was matched */
def before: CharSequence =
if (start >= 0) source.subSequence(0, start)
else null
/** The char sequence before first character of match in group `i`,
* or `null` if nothing was matched for that group */
def before(i: Int): CharSequence =
if (start(i) >= 0) source.subSequence(0, start(i))
else null
/** Returns char sequence after last character of match,
* or `null` if nothing was matched */
def after: CharSequence =
if (end >= 0) source.subSequence(end, source.length)
else null
/** The char sequence after last character of match in group `i`,
* or `null` if nothing was matched for that group */
def after(i: Int): CharSequence =
if (end(i) >= 0) source.subSequence(end(i), source.length)
else null
private lazy val nameToIndex: Map[String, Int] = Map[String, Int]() ++ ("" :: groupNames.toList).zipWithIndex
/** Returns the group with given name
*
* @param id The group name
* @return The requested group
* @throws NoSuchElementException if the requested group name is not defined
*/
def group(id: String): String = nameToIndex.get(id) match {
case None => throw new NoSuchElementException("group name "+id+" not defined")
case Some(index) => group(index)
}
/** The matched string; equivalent to `matched.toString` */
override def toString = matched
}
/** Provides information about a succesful match.
*/
class Match(val source: CharSequence,
private[matching] val matcher: Matcher,
val groupNames: Seq[String]) extends MatchData {
/** The index of the first matched character */
val start = matcher.start
/** The index following the last matched character */
val end = matcher.end
/** The number of subgroups */
def groupCount = matcher.groupCount
private lazy val starts: Array[Int] =
((0 to groupCount) map matcher.start).toArray
private lazy val ends: Array[Int] =
((0 to groupCount) map matcher.end).toArray
/** The index of the first matched character in group `i` */
def start(i: Int) = starts(i)
/** The index following the last matched character in group `i` */
def end(i: Int) = ends(i)
/** The match itself with matcher-dependent lazy vals forced,
* so that match is valid even once matcher is advanced
*/
def force: this.type = { starts; ends; this }
}
/** An extractor object for Matches, yielding the matched string
*
* This can be used to help writing replacer functions when you
* are not interested in match data. For example:
*
* {{{
* import scala.util.matching.Regex.Match
* """\w+""".r replaceAllIn ("A simple example.", _ match { case Match(s) => s.toUpperCase })
* }}}
*
*/
object Match {
def unapply(m: Match): Some[String] = Some(m.matched)
}
/** An extractor object that yields the groups in the match. Using an extractor
* rather than the original regex avoids recomputing the match.
*
* {{{
* import scala.util.matching.Regex.Groups
*
* val datePattern = """(\d\d\d\d)-(\d\d)-(\d\d)""".r
* val text = "The doc spree happened on 2011-07-15."
* val day = datePattern replaceAllIn(text, _ match { case Groups(year, month, day) => month+"/"+day })
* }}}
*/
object Groups {
def unapplySeq(m: Match): Option[Seq[String]] = if (m.groupCount > 0) Some(1 to m.groupCount map m.group) else None
}
/** A class to step through a sequence of regex matches
*/
class MatchIterator(val source: CharSequence, val regex: Regex, val groupNames: Seq[String])
extends AbstractIterator[String] with Iterator[String] with MatchData { self =>
protected[Regex] val matcher = regex.pattern.matcher(source)
private var nextSeen = false
/** Is there another match? */
def hasNext: Boolean = {
if (!nextSeen) nextSeen = matcher.find()
nextSeen
}
/** The next matched substring of `source` */
def next(): String = {
if (!hasNext) throw new NoSuchElementException
nextSeen = false
matcher.group
}
override def toString = super[AbstractIterator].toString
/** The index of the first matched character */
def start: Int = matcher.start
/** The index of the first matched character in group `i` */
def start(i: Int): Int = matcher.start(i)
/** The index of the last matched character */
def end: Int = matcher.end
/** The index following the last matched character in group `i` */
def end(i: Int): Int = matcher.end(i)
/** The number of subgroups */
def groupCount = matcher.groupCount
/** Convert to an iterator that yields MatchData elements instead of Strings */
def matchData: Iterator[Match] = new AbstractIterator[Match] {
def hasNext = self.hasNext
def next = { self.next(); new Match(source, matcher, groupNames).force }
}
/** Convert to an iterator that yields MatchData elements instead of Strings and has replacement support */
private[matching] def replacementData = new AbstractIterator[Match] with Replacement {
def matcher = self.matcher
def hasNext = self.hasNext
def next = { self.next(); new Match(source, matcher, groupNames).force }
}
}
/**
* A trait able to build a string with replacements assuming it has a matcher.
* Meant to be mixed in with iterators.
*/
private[matching] trait Replacement {
protected def matcher: Matcher
private val sb = new java.lang.StringBuffer
def replaced = {
val newsb = new java.lang.StringBuffer(sb)
matcher.appendTail(newsb)
newsb.toString
}
def replace(rs: String) = matcher.appendReplacement(sb, rs)
}
/** Quotes replacement strings to be used in replacement methods.
*
* Replacement methods give special meaning to backslashes (`\`) and
* dollar signs (`$`) in replacement strings, so they are not treated
* as literals. This method escapes these characters so the resulting
* string can be used as a literal replacement representing the input
* string.
*
* @param text The string one wishes to use as literal replacement.
* @return A string that can be used to replace matches with `text`.
* @example {{{"CURRENCY".r.replaceAllIn(input, Regex quoteReplacement "US$")}}}
*/
def quoteReplacement(text: String): String = Matcher quoteReplacement text
}
|