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
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2021-2022 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
import XCTest
@_spi(LiteralPattern)
import _StringProcessing
import RegexBuilder
@available(SwiftStdlib 6.0, *)
fileprivate func _literalTest<T>(
_ regex: Regex<T>,
expected: String?,
file: StaticString = #filePath,
line: UInt = #line
) {
XCTAssertEqual(regex._literalPattern, expected, file: file, line: line)
if let expected {
let remadeRegex = try? Regex(expected)
XCTAssertEqual(expected, remadeRegex?._literalPattern, file: file, line: line)
}
}
@available(SwiftStdlib 6.0, *)
extension RegexTests {
func testPrintableRegex() throws {
let regexString = #"([a-fGH1-9[^\D]]+)?b*cd(e.+)\2\w\S+?"#
let regex = try Regex(regexString)
// Note: This is true for this particular regex, but not all regexes
_literalTest(regex, expected: regexString)
let printableRegex = try XCTUnwrap(PrintableRegex(regex))
XCTAssertEqual("\(printableRegex)", regexString)
}
func testUnicodeEscapes() throws {
let regex = #/\r\n\t cafe\u{301} \u{1D11E}/#
_literalTest(regex, expected: #"\r\n\t cafe\u0301 \U0001D11E"#)
}
func testPrintableDSLRegex() throws {
let regex = Regex {
OneOrMore("aaa", .reluctant)
Regex {
ChoiceOf {
ZeroOrMore("bbb")
OneOrMore("d")
Repeat("e", 3...)
}
}.dotMatchesNewlines()
Optionally("c")
}.ignoresCase()
_literalTest(regex, expected: "(?i:(?:aaa)+?(?s:(?:bbb)*|d+|e{3,})c?)")
let nonPrintableRegex = Regex {
OneOrMore("a")
Capture {
OneOrMore(.digit)
} transform: { Int($0)! }
Optionally("b")
}
_literalTest(nonPrintableRegex, expected: nil)
}
}
// MARK: - PrintableRegex
// Demonstration of a guaranteed Codable/Sendable regex type.
@available(SwiftStdlib 6.0, *)
struct PrintableRegex: RegexComponent, @unchecked Sendable {
var pattern: String
var regex: Regex<AnyRegexOutput>
init?(_ re: some RegexComponent) {
guard let pattern = re.regex._literalPattern
else { return nil }
self.pattern = pattern
self.regex = Regex(re.regex)
}
func matches(in string: String) -> Bool {
string.contains(regex)
}
func wholeMatches(in string: String) -> Bool {
string.wholeMatch(of: regex) != nil
}
}
@available(SwiftStdlib 6.0, *)
extension PrintableRegex: Codable {
init(from decoder: Decoder) throws {
let container = try decoder.singleValueContainer()
self.pattern = try container.decode(String.self)
self.regex = try Regex(self.pattern)
}
func encode(to encoder: Encoder) throws {
var container = encoder.singleValueContainer()
try container.encode(pattern)
}
}
@available(SwiftStdlib 6.0, *)
extension PrintableRegex: CustomStringConvertible {
var description: String {
pattern
}
}
|
