From bbaeb150734853a5a18af26d3ca050eb11238aa4 Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 17 May 2021 16:12:53 +0700
Subject: [PATCH] Fix Unicode handling (#5)

---
 Sources/Regex/Regex.swift         |  21 ++++--
 Sources/Regex/Utilities.swift     |  14 ++++
 Tests/RegexTests/RegexTests.swift | 120 +++++++++++++++++++++++++++++-
 3 files changed, 146 insertions(+), 9 deletions(-)

diff --git a/Sources/Regex/Regex.swift b/Sources/Regex/Regex.swift
index f186cab..0d8d23d 100644
--- a/Sources/Regex/Regex.swift
+++ b/Sources/Regex/Regex.swift
@@ -157,7 +157,7 @@ extension Regex {
 			public let range: Range<String.Index>
 
 			fileprivate init(originalString: String, range: NSRange) {
-				self.range = Range(range, in: originalString)!
+				self.range = originalString.range(fromNSRange: range)
 				self.value = String(originalString[self.range])
 			}
 		}
@@ -193,7 +193,10 @@ extension Regex {
 		public func group(named name: String) -> Group? {
 			let range = checkingResult.range(withName: name)
 
-			guard range.length > 0 else {
+			guard
+				range.location != NSNotFound,
+				range.length > 0
+			else {
 				return nil
 			}
 
@@ -203,12 +206,20 @@ extension Regex {
 		fileprivate init(checkingResult: NSTextCheckingResult, string: String) {
 			self.checkingResult = checkingResult
 			self.originalString = string
-			self.value = string[nsRange: checkingResult.range]!.string
-			self.range = Range(checkingResult.range, in: string)!
+			self.range = string.range(fromNSRange: checkingResult.range)
+			self.value = String(string[self.range])
 
 			// The first range is the full range, so we ignore that.
-			self.groups = (1..<checkingResult.numberOfRanges).map {
+			self.groups = (1..<checkingResult.numberOfRanges).compactMap {
 				let range = checkingResult.range(at: $0)
+
+				guard
+					range.location != NSNotFound,
+					range.length > 0
+				else {
+					return nil
+				}
+
 				return Group(originalString: string, range: range)
 			}
 		}
diff --git a/Sources/Regex/Utilities.swift b/Sources/Regex/Utilities.swift
index 71ca65b..5199927 100644
--- a/Sources/Regex/Utilities.swift
+++ b/Sources/Regex/Utilities.swift
@@ -25,6 +25,20 @@ extension String {
 }
 
 
+extension String {
+	/**
+	Get a string range from a `NSRange`.
+
+	This works better than the built-in `Range(nsRange, in: string)`, which doesn't correctly handle some Unicode compositions.
+	*/
+	func range(fromNSRange nsRange: NSRange) -> Range<Index> {
+		let startIndex = utf16.index(utf16.startIndex, offsetBy: nsRange.lowerBound)
+		let endIndex = utf16.index(startIndex, offsetBy: nsRange.length)
+		return rangeOfComposedCharacterSequences(for: startIndex..<endIndex)
+	}
+}
+
+
 /// Convenience wrappers that make the `range` parameter optional and type-safe.
 extension NSRegularExpression {
 	/// Returns an array containing all the matches of the regular expression in the string.
diff --git a/Tests/RegexTests/RegexTests.swift b/Tests/RegexTests/RegexTests.swift
index 9d9b18b..80e0532 100644
--- a/Tests/RegexTests/RegexTests.swift
+++ b/Tests/RegexTests/RegexTests.swift
@@ -58,18 +58,47 @@ final class RegexTests: XCTestCase {
 	}
 
 	func testMatchGroupRange() {
-		let string = "foo-456"
-		let groups = Regex(#"([a-z]+)-(\d+)"#).firstMatch(in: string)!.groups
+		let fixture = "foo-456"
+		let groups = Regex(#"([a-z]+)-(\d+)"#).firstMatch(in: fixture)!.groups
 
 		XCTAssertEqual(
-			string[groups[0].range],
+			fixture[groups[0].range],
 			"foo"
 		)
 
 		XCTAssertEqual(
-			string[groups[1].range],
+			fixture[groups[1].range],
 			"456"
 		)
+
+		XCTAssertEqual(
+			String(fixture[groups[0].range]),
+			groups[0].value
+		)
+
+		XCTAssertEqual(
+			String(fixture[groups[1].range]),
+			groups[1].value
+		)
+	}
+
+	func testMatchGroupUnicode() {
+		let fixture = "foo ഫെയ്‌ bar"
+
+		// The `fixture` without `ZERO WIDTH NON-JOINER`.
+		let expected = "ഫെയ്"
+
+		let groups = Regex(#"foo (\p{malayalam}+)"#).firstMatch(in: fixture)!.groups
+
+		XCTAssertEqual(
+			groups[0].value,
+			expected
+		)
+
+		XCTAssertEqual(
+			String(fixture[groups[0].range]),
+			groups[0].value
+		)
 	}
 
 	func testPatternMatching() {
@@ -90,4 +119,87 @@ final class RegexTests: XCTestCase {
 
 		XCTAssertTrue(regex.isMatched(by: "foo123"))
 	}
+
+	func testUnicode() {
+		/*
+		UTF16 representation:
+		0d2b MALAYALAM LETTER PHA (U+0D2B)
+		0d46 MALAYALAM VOWEL SIGN E (U+0D46)
+		0d2f MALAYALAM LETTER YA (U+0D2F)
+		0d4d MALAYALAM SIGN VIRAMA (U+0D4D)
+		200c ZERO WIDTH NON-JOINER (U+200C)
+		*/
+		let fixture = "ഫെയ്‌"
+
+		/*
+		UTF16 representation:
+		0d2b MALAYALAM LETTER PHA (U+0D2B)
+		0d46 MALAYALAM VOWEL SIGN E (U+0D46)
+		0d2f MALAYALAM LETTER YA (U+0D2F)
+		0d4d MALAYALAM SIGN VIRAMA (U+0D4D)
+		*/
+		let expected = "ഫെയ്"
+
+		let match = Regex(#"\p{malayalam}+"#).firstMatch(in: fixture)!
+
+		XCTAssertEqual(
+			match.value,
+			expected
+		)
+
+		XCTAssertEqual(
+			String(fixture[match.range]),
+			match.value
+		)
+	}
+
+	func testUnicode2() {
+		let fixture = "foo ഫെയ്‌ bar"
+
+		// The `fixture` without `ZERO WIDTH NON-JOINER`.
+		let expected = "ഫെയ്"
+
+		let match = Regex(#"\p{malayalam}+"#).firstMatch(in: fixture)!
+
+		XCTAssertEqual(
+			match.value,
+			expected
+		)
+
+		XCTAssertEqual(
+			String(fixture[match.range]),
+			match.value
+		)
+	}
+
+	func testUnicode3() {
+		let fixture = "foo ഫെയ്‌ bar"
+		let match = Regex(#"\p{malayalam}"#).firstMatch(in: fixture)!
+
+		XCTAssertEqual(
+			match.value,
+			"ഫെ"
+		)
+
+		XCTAssertEqual(
+			String(fixture[match.range]),
+			match.value
+		)
+	}
+
+	func testUnicode4() {
+		let fixture = "foo 👩‍👩‍👧‍👦​🇳🇴 bar"
+		let expected = "👩‍👩‍👧‍👦​🇳🇴"
+		let match = Regex(#"[^foo ]+"#).firstMatch(in: fixture)!
+
+		XCTAssertEqual(
+			match.value,
+			expected
+		)
+
+		XCTAssertEqual(
+			String(fixture[match.range]),
+			match.value
+		)
+	}
 }