Merge pull request #5 from Tavernari/add-regexp-predicate

Add regex string predicate with prefix =~

Author: Tavernari

README.md

@@ -48,6 +48,15 @@ print(result7) // false
 // Check if text does NOT contain "cat" case insensitively and without diacritics
 let result8 = text.contains(!~"cat")
 print(result8) // true
+
+// Check if text contains "quick" OR "jumps" AND "fox" using a regular expression
+let result9 = text.contains(=~"(quick|jumps).*fox")
+print(result9) // true
+
+// Check if text contains "jumps" OR "swift" AND "fox" using a regular expression
+let result10 = text.contains(=~"(jumps|swift).*fox")
+print(result10) // true
+
 ```
 
 ## How to Install

Sources/StringContainsOperators/SearchStrategies/RegexSearchStrategy.swift

@@ -0,0 +1,33 @@
+//
+//  RegexSearchStrategy.swift
+//  
+//
+//  Created by Victor C Tavernari on 24/03/2023.
+//
+
+import Foundation
+
+/// A search strategy that evaluates whether a string matches a given regular expression pattern.
+final class RegexSearchStrategy: SearchStrategy {
+
+    /// The regular expression pattern to match.
+    let regex: NSRegularExpression?
+
+    /// Creates a new instance of `RegexSearchStrategy` with the given regular expression pattern.
+    /// - Parameter pattern: The regular expression pattern to match.
+    init(pattern: String) {
+
+        self.regex = try? NSRegularExpression(pattern: pattern,
+                                             options: [])
+    }
+
+    /// Evaluates whether a string matches the regular expression pattern.
+    /// - Parameter string: The string to evaluate.
+    /// - Returns: `true` if the string matches the regular expression pattern, `false` otherwise.
+    func evaluate(string: String) -> Bool {
+
+        let range = NSRange(location: 0, length: string.utf16.count)
+        return self.regex?.firstMatch(in: string, options: [], range: range) != nil
+    }
+}
+

Sources/StringContainsOperators/SearchStrategyMaker.swift

@@ -39,6 +39,9 @@ enum SearchStrategyMaker {
         case let .diacriticAndCaseInsensitive(value):
             return DiacriticAndCaseInsensitiveSearchStrategy(value: value)
 
+        case let .regexp(pattern):
+            return RegexSearchStrategy(pattern: pattern)
+
         case let .negatable(value):
             return NegatableValueSearchStrategy(value: value)
 

Sources/StringContainsOperators/StringContainsOperators.swift

@@ -9,6 +9,7 @@ import Foundation
 infix operator || : LogicalDisjunctionPrecedence
 infix operator && : LogicalConjunctionPrecedence
 prefix operator ~
+prefix operator =~
 prefix operator !
 
 /// An enum representing a string search predicate.
@@ -35,8 +36,14 @@ public indirect enum StringPredicate {
     /// Represents a case-insensitive and diacritic-insensitive search for a given string.
     case diacriticAndCaseInsensitive(String)
 
+    /// Represents a regular expression pattern that can be used to match a string using NSRegularExpression.
+    /// - Note: The String value should be a valid regular expression pattern.
+    case regexp(String)
+    
+    /// Represents a negatable search predicate for a given string.
     case negatable(String)
 
+    /// Represents a negatable search predicate for a given `StringPredicate`.
     case negatablePredicate(StringPredicate)
 }
 
@@ -129,6 +136,15 @@ public prefix func ~ (value: String) -> StringPredicate {
     return .diacriticAndCaseInsensitive(value)
 }
 
+/// Returns a `StringPredicate` that performs a regular expression pattern that can be used to match a string using NSRegularExpression.
+///
+/// - Parameter value: The regular expression pattern as a string value.
+/// - Returns: A `StringPredicate` that can be used to perform regular expression pattern matching.
+public prefix func =~ (value: String) -> StringPredicate {
+
+    return .regexp(value)
+}
+
 /// Returns a `StringPredicate` that negates another `StringPredicate`.
 ///
 /// - Parameter predicate: The predicate to be negated.

Tests/StringContainsOperatorsTests/StringContainsOperatorsTests.swift

@@ -103,6 +103,25 @@ final class StringContainsOperatorsTests: XCTestCase {
         XCTAssertFalse("Goodbye".contains(predicate))
     }
 
+    func testContainsWithRegexp() {
+
+        let string = "This is a test string"
+
+        let predicate = "test" && "string" && =~"is.a"
+
+        XCTAssertTrue(string.contains(predicate))
+
+        let invalidString = "This is not a valid string"
+        XCTAssertFalse(invalidString.contains(predicate))
+    }
+
+    func testWithInvalidRegexp() {
+
+        let string = "This is a test string"
+
+        XCTAssertFalse(string.contains(=~"^*$(dis.a"))
+    }
+
     func testNegatablePredicate() {
         let text = "Hello my little friend"