Add a negatable predicate with the operator !

Author: Tavernari

README.md

@@ -36,6 +36,18 @@ print(result4) // true
 // Check if text contains "fox" AND ("Jumps" OR "swift") case insensitively and without diacritics
 let result5 = text.contains(~"fox" && (~"Jumps" || ~"swift"))
 print(result5) // true
+
+// Check if text does NOT contain "cat" AND "bird"
+let result6 = text.contains(!"cat" && !"bird")
+print(result6) // true
+
+// Check if text does NOT contain "brown"
+let result7 = text.contains(!"brown")
+print(result7) // false
+
+// Check if text does NOT contain "cat" case insensitively and without diacritics
+let result8 = text.contains(!~"cat")
+print(result8) // true
 ```
 
 ## How to Install

Sources/StringContainsOperators/SearchStrategies/NegatablePredicateSearchStrategy.swift

@@ -0,0 +1,29 @@
+//
+//  NegatablePredicateSearchStrategy.swift
+//  
+//
+//  Created by Victor C Tavernari on 24/03/2023.
+//
+
+import Foundation
+
+/// A search strategy that negates the result of another search strategy.
+final class NegatablePredicateSearchStrategy: SearchStrategy {
+
+    let searchStrategy: SearchStrategy
+
+    init(searchStrategy: SearchStrategy) {
+
+        self.searchStrategy = searchStrategy
+    }
+
+    /// Evaluates the given string with the negated search strategy.
+    ///
+    /// - Parameter string: The string to be evaluated.
+    /// - Returns: `true` if the given string does not match the original search strategy, `false` otherwise.
+    func evaluate(string: String) -> Bool {
+
+        return !self.searchStrategy.evaluate(string: string)
+    }
+}
+

Sources/StringContainsOperators/SearchStrategies/NegatableValueSearchStrategy.swift

@@ -0,0 +1,29 @@
+//
+//  NegatableValueSearchStrategy.swift
+//  
+//
+//  Created by Victor C Tavernari on 24/03/2023.
+//
+
+import Foundation
+
+/// A search strategy that negates the presence of a given value in a string.
+final class NegatableValueSearchStrategy: SearchStrategy {
+
+    let value: String
+
+    init(value: String) {
+
+        self.value = value
+    }
+
+    /// Evaluates the given string with the negated value search strategy.
+    ///
+    /// - Parameter string: The string to be evaluated.
+    /// - Returns: `true` if the given string does not contain the value, `false` otherwise.
+    func evaluate(string: String) -> Bool {
+
+        return !string.contains(self.value)
+    }
+}
+

Sources/StringContainsOperators/SearchStrategyMaker.swift

@@ -41,6 +41,12 @@ enum SearchStrategyMaker {
 
         case let .regexp(pattern):
             return RegexSearchStrategy(pattern: pattern)
+
+        case let .negatable(value):
+            return NegatableValueSearchStrategy(value: value)
+
+        case let .negatablePredicate(predicate):
+            return NegatablePredicateSearchStrategy(searchStrategy: self.make(predicate: predicate))
         }
     }
 }

Sources/StringContainsOperators/StringContainsOperators.swift

@@ -10,6 +10,7 @@ infix operator || : LogicalDisjunctionPrecedence
 infix operator && : LogicalConjunctionPrecedence
 prefix operator ~
 prefix operator =~
+prefix operator !
 
 /// An enum representing a string search predicate.
 public indirect enum StringPredicate {
@@ -38,67 +39,131 @@ public indirect enum StringPredicate {
     /// 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)
 }
 
 /// Returns a `StringPredicate` that performs a logical OR operation between two strings.
+/// - Parameters:
+///   - lhs: The first string to be evaluated.
+///   - rhs: The second string to be evaluated.
+/// - Returns: A `StringPredicate` that performs a logical OR operation between two strings.
 public func || (lhs: String, rhs: String) -> StringPredicate {
 
     return .or([lhs, rhs])
 }
 
 /// Returns a `StringPredicate` that performs a logical OR operation between a string and a `StringPredicate`.
+/// - Parameters:
+///   - lhs: The string to be evaluated.
+///   - rhs: The `StringPredicate` to be evaluated.
+/// - Returns: A `StringPredicate` that performs a logical OR operation between a string and a `StringPredicate`.
 public func || (lhs: String, rhs: StringPredicate) -> StringPredicate {
 
     return .orPredicates(lhs, rhs)
 }
 
 /// Returns a `StringPredicate` that performs a logical OR operation between a `StringPredicate` and a string.
+/// - Parameters:
+///   - lhs: The `StringPredicate` to be evaluated.
+///   - rhs: The string to be evaluated.
+/// - Returns: A `StringPredicate` that performs a logical OR operation between a `StringPredicate` and a string.
 public func || (lhs: StringPredicate, rhs: String) -> StringPredicate {
 
     return .orPredicates(rhs, lhs)
 }
 
 /// Returns a `StringPredicate` that performs a logical OR operation between two `StringPredicate`s.
+/// - Parameters:
+///   - lhs: The first `StringPredicate` to be evaluated.
+///   - rhs: The second `StringPredicate` to be evaluated.
+/// - Returns: A `StringPredicate` that performs a logical OR operation between two `StringPredicate`s.
 public func || (lhs: StringPredicate, rhs: StringPredicate) -> StringPredicate {
 
     return .orOnlyPredicates([rhs, lhs])
 }
 
 /// Returns a `StringPredicate` that performs a logical AND operation between two strings.
+/// - Parameters:
+///   - lhs: The first string to be evaluated.
+///   - rhs: The second string to be evaluated.
+/// - Returns: A `StringPredicate` that performs a logical AND operation between two strings.
 public func && (lhs: String, rhs: String) -> StringPredicate {
 
     return .and([lhs, rhs])
 }
 
 /// Returns a `StringPredicate` that performs a logical AND operation between a string and a `StringPredicate`.
+/// - Parameters:
+///   - lhs: The string to be evaluated.
+///   - rhs: The `StringPredicate` to be evaluated.
+/// - Returns: A `StringPredicate` that performs a logical AND operation between a string and a `StringPredicate`.
 public func && (lhs: String, rhs: StringPredicate) -> StringPredicate {
 
     return .andPredicates(lhs, rhs)
 }
 
 /// Returns a `StringPredicate` that performs a logical AND operation between a `StringPredicate` and a string.
+/// - Parameters:
+///   - lhs: The `StringPredicate` to be evaluated.
+///   - rhs: The string to be evaluated.
+/// - Returns: A `StringPredicate` that performs a logical AND operation between a `StringPredicate` and a string.
 public func && (lhs: StringPredicate, rhs: String) -> StringPredicate {
 
     return .andPredicates(rhs, lhs)
 }
 
 /// Returns a `StringPredicate` that performs a logical AND operation between two `StringPredicate`s.
+/// - Parameters:
+///   - lhs: The first `StringPredicate` to be evaluated.
+///   - rhs: The second `StringPredicate` to be evaluated.
+/// - Returns: A `StringPredicate
 public func && (lhs: StringPredicate, rhs: StringPredicate) -> StringPredicate {
 
     return .andOnlyPredicates([rhs, lhs])
 }
 
 /// Returns a `StringPredicate` that performs a case-insensitive and diacritic-insensitive search for a given string.
+///
+/// - Parameter value: The value to be evaluated.
+/// - Returns: A `StringPredicate` that performs a case-insensitive and diacritic-insensitive search for a given string.
 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.
+/// - Returns: A `StringPredicate` that represents the negation of the given predicate.
+public prefix func ! (predicate: StringPredicate) -> StringPredicate {
+
+    return .negatablePredicate(predicate)
+}
+
+/// Returns a `StringPredicate` that negates a given value.
+///
+/// - Parameter value: The value to be negated.
+/// - Returns: A `StringPredicate` that represents the negation of the given value.
+public prefix func ! (value: String) -> StringPredicate {
+
+    return .negatable(value)
+}
+
 public extension String {
 
     /// Returns a Boolean value indicating whether the string contains the given `StringPredicate`.

Tests/StringContainsOperatorsTests/StringContainsOperatorsTests.swift

@@ -121,4 +121,15 @@ final class StringContainsOperatorsTests: XCTestCase {
 
         XCTAssertFalse(string.contains(=~"^*$(dis.a"))
     }
+
+    func testNegatablePredicate() {
+        let text = "Hello my little friend"
+
+        XCTAssertTrue(text.contains(!"fiance"))
+        XCTAssertFalse(text.contains(!"my"))
+        XCTAssertTrue(text.contains(!("enemy" && "little")))
+        XCTAssertFalse(text.contains(!("friend" && "little")))
+        XCTAssertTrue(text.contains(!("enemy" || "big")))
+        XCTAssertFalse(text.contains(!("friend" || "big")))
+    }
 }