Support Grapheme Clusters 👨‍👩‍👧 (rebased)

README.md

@@ -35,6 +35,7 @@ Still we hope it will be useful for everybody else.
 	- [x] Simple
 	- [x] With groups
 - [x] String extensions
+- [x] Supports grapheme clusters 👨‍👩‍👧
 
 ## Extra
 

Sources/Regex/GroupRangeUtils.swift

@@ -22,13 +22,13 @@ enum InvalidRangeError : Error {
 
 extension GroupRange {
     func asRange(ofString source:String) throws -> StringRange {
-        let len = source.count
+        let len = source.utf16.count
         if self.location < 0 || self.location >= len || self.location + self.length > len {
             throw InvalidRangeError.Error
         }
 
-        let start = source.index(source.startIndex, offsetBy: self.location)
-        let end = source.index(start, offsetBy: self.length)
+        let start = source.utf16.index(source.startIndex, offsetBy: self.location)
+        let end = source.utf16.index(start, offsetBy: self.length)
 
         return start ..< end
     }

Sources/Regex/Regex.swift

@@ -232,7 +232,7 @@ public class Regex : RegexProtocol {
      */
     public func findAll(in source:String) -> MatchSequence {
         let options = NSRegularExpression.MatchingOptions(rawValue: 0)
-        let range = GroupRange(location: 0, length: source.count)
+        let range = GroupRange(location: 0, length: source.utf16.count)
         let context = compiled?.matches(in: source, options: options, range: range)
         //hard unwrap of context, because the instance would not exist without it
         return MatchSequence(source: source, context: context!, groupNames: groupNames)
@@ -247,7 +247,7 @@ public class Regex : RegexProtocol {
      */
     public func findFirst(in source:String) -> Match? {
         let options = NSRegularExpression.MatchingOptions(rawValue: 0)
-        let range = GroupRange(location: 0, length: source.count)
+        let range = GroupRange(location: 0, length: source.utf16.count)
         let match = compiled?.firstMatch(in: source, options: options, range: range)
         return match.map { match in
             Match(source: source, match: match, groupNames: groupNames)
@@ -264,7 +264,7 @@ public class Regex : RegexProtocol {
      */
     public func replaceAll(in source:String, with replacement:String) -> String {
         let options = NSRegularExpression.MatchingOptions(rawValue: 0)
-        let range = GroupRange(location: 0, length: source.count)
+        let range = GroupRange(location: 0, length: source.utf16.count)
 
         return compiled!.stringByReplacingMatches(in: source, options: options, range: range, withTemplate: replacement)
     }

Tests/RegexTests/RegexTests.swift

@@ -15,7 +15,7 @@
 //===----------------------------------------------------------------------===//
 
 import XCTest
-import Regex
+@testable import Regex
 
 class RegexTests: XCTestCase {
     static let pattern:String = "(.+?)([1,2,3]*)(.*)"
@@ -134,6 +134,67 @@ class RegexTests: XCTestCase {
         }
         XCTAssertEqual("l321321la321a", replaced2)
     }
+
+    func testGraphemeClusters() {
+        let testString = """
+            👍👍 Find me. 👌👨‍👩‍👧👨\u{200D}👩\u{200D}👧👌
+            """
+        let regex = try! Regex(pattern: "^(👍+) *([^👌]+?) *([👌👨‍👩‍👧]+)$",
+                               options: [.anchorsMatchLines],
+                               groupNames: [])
+
+        guard let firstMatch = regex.findFirst(in: testString) else {
+            return XCTFail("Failed to find first match using anchored regex.")
+        }
+
+        XCTAssert(firstMatch.group(at: 1) == "👍👍",
+                  "Incorrect first capture group for anchored regex.")
+        XCTAssert(firstMatch.group(at: 2) == "Find me.",
+                  "Incorrect second capture group for anchored regex.")
+        XCTAssert(firstMatch.group(at: 3) == "👌👨‍👩‍👧👨‍👩‍👧👌",
+                  "Incorrect third capture group for anchored regex.")
+
+        let englishMatchSequence = regex.findAll(in: testString)
+        XCTAssert(englishMatchSequence.context.count == 1,
+                  "Failed to find match using anchored regex.")
+
+        let englishFirstMatch = englishMatchSequence.makeIterator().next()!
+        XCTAssert(englishFirstMatch.group(at: 1) == "👍👍",
+                  "Incorrect first capture group for anchored regex.")
+        XCTAssert(englishFirstMatch.group(at: 2) == "Find me.",
+                  "Incorrect second capture group for anchored regex.")
+        XCTAssert(englishFirstMatch.group(at: 3) == "👌👨‍👩‍👧👨‍👩‍👧👌",
+                  "Incorrect third capture group for anchored regex.")
+
+
+        let familyEmojiRegex = try! Regex(pattern: "👌([👨‍👩‍👧]+)",
+                                          groupNames: [])
+        guard let familyFirstMatch = familyEmojiRegex.findFirst(in: testString) else {
+            return XCTFail("Failed to find first match using family regex.")
+        }
+        XCTAssert(familyFirstMatch.matched == "👌👨‍👩‍👧👨‍👩‍👧",
+                  "Incorrect matched string for family emoji regex.")
+        XCTAssert(familyFirstMatch.group(at: 1) == "👨‍👩‍👧👨‍👩‍👧",
+                  "Incorrect first capture group for family emoji regex.")
+
+
+        let testInArabic = "اختبار"
+        let arabicTestString = "🇦🇪 مرحبًا ، هذا اختبار"
+        let arabicRegex = try! Regex(pattern: testInArabic, groupNames: [])
+        let arabicMatchSequence = arabicRegex.findAll(in: arabicTestString)
+        XCTAssert(arabicMatchSequence.context.count == 1, "Failed to find match in Arabic test string.")
+        let arabicFirstMatch = arabicMatchSequence.makeIterator().next()!
+        XCTAssert(arabicFirstMatch.matched == testInArabic, "Failed to match Arabic.")
+
+
+        let testInThai = "ทดสอบ"
+        let thaiTestString = "🇹🇭 สวัสดีนี่เป็นแบบทดสอบ"
+        let thaiRegex = try! Regex(pattern: testInThai, groupNames: [])
+        let thaiMatchSequence = thaiRegex.findAll(in: thaiTestString)
+        XCTAssert(thaiMatchSequence.context.count == 1, "Failed to find match in Thai test string.")
+        let thaiFirstMatch = thaiMatchSequence.makeIterator().next()!
+        XCTAssert(thaiFirstMatch.matched == testInThai, "Failed to match Thai.")
+    }
 
     func testSplit() {
         let re = namesSplitPattern.r!
@@ -208,6 +269,7 @@ extension RegexTests {
 			("testReplaceAllWithReplacer", testReplaceAllWithReplacer),
 			("testReplaceFirst", testReplaceFirst),
 			("testReplaceFirstWithReplacer", testReplaceFirstWithReplacer),
+            ("testGraphemeClusters", testGraphemeClusters),
 			("testSplit", testSplit),
 			("testSplitOnString", testSplitOnString),
 			("testSplitWithSubgroups", testSplitWithSubgroups),