Add search strategy and comments

Author: Tavernari

Sources/StringContainsOperators/Extensions/String+removeDiacriticsAndCase.swift

@@ -0,0 +1,21 @@
+//
+//  String+removeDiacriticsAndCase.swift
+//  
+//
+//  Created by Victor C Tavernari on 23/03/2023.
+//
+
+import Foundation
+
+/// An extension of String that removes diacritics and lowercase the string.
+extension String {
+
+    /// Removes diacritics and lowercase the string.
+    ///
+    /// - Returns: The string with removed diacritics and lowercase.
+    func removeDiacriticsAndCase() -> String {
+
+        return folding(options: .diacriticInsensitive,
+                       locale: Locale.current)
+    }
+}

Sources/StringContainsOperators/SearchStrategies/AndOnlyPredicateSearchStrategy.swift

@@ -0,0 +1,32 @@
+//
+//  AndOnlyPredicateSearchStrategy.swift
+//
+//
+//  Created by Victor C Tavernari on 23/03/2023.
+//
+
+import Foundation
+
+/// `AndOnlyPredicateSearchStrategy` is a type of `SearchStrategy` that searches for multiple `StringPredicate`s with an "AND" condition.
+final class AndOnlyPredicateSearchStrategy: SearchStrategy {
+
+    /// The list of `StringPredicate`s to be searched.
+    let predicates: [StringPredicate]
+
+    /// Initializes a new instance of `AndOnlyPredicateSearchStrategy`.
+    ///
+    /// - Parameter predicates: The list of `StringPredicate`s to be searched.
+    init(predicates: [StringPredicate]) {
+
+        self.predicates = predicates
+    }
+
+    /// Evaluates if a given string contains all of the `StringPredicate`s in the `predicates` array.
+    ///
+    /// - Parameter string: The string to be evaluated.
+    /// - Returns: `true` if the string contains all of the `StringPredicate`s in the `predicates` array, `false` otherwise.
+    func evaluate(string: String) -> Bool {
+
+        return predicates.allSatisfy(string.contains)
+    }
+}

Sources/StringContainsOperators/SearchStrategies/AndPredicateSearchStrategy.swift

@@ -0,0 +1,38 @@
+//
+//  AndPredicateSearchStrategy.swift
+//  
+//
+//  Created by Victor C Tavernari on 23/03/2023.
+//
+
+import Foundation
+
+/// `AndPredicateSearchStrategy` is a type of `SearchStrategy` that searches for a `String` and a `StringPredicate` with an "AND" condition.
+final class AndPredicateSearchStrategy: SearchStrategy {
+
+    /// The string to be searched.
+    let value: String
+
+    /// The `StringPredicate` to be searched.
+    let predicate: StringPredicate
+
+    /// Initializes a new instance of `AndPredicateSearchStrategy`.
+    ///
+    /// - Parameters:
+    ///   - value: The string to be searched.
+    ///   - predicate: The `StringPredicate` to be searched.
+    init(value: String, predicate: StringPredicate) {
+
+        self.value = value
+        self.predicate = predicate
+    }
+
+    /// Evaluates if a given string contains both the string `value` and the `StringPredicate` `predicate`.
+    ///
+    /// - Parameter string: The string to be evaluated.
+    /// - Returns: `true` if the string contains both the string `value` and the `StringPredicate` `predicate`, `false` otherwise.
+    func evaluate(string: String) -> Bool {
+
+        return string.contains(self.predicate) && string.contains(self.value)
+    }
+}

Sources/StringContainsOperators/SearchStrategies/AndSearchStrategy.swift

@@ -0,0 +1,32 @@
+//
+//  AndSearchStrategy.swift
+//  
+//
+//  Created by Victor C Tavernari on 23/03/2023.
+//
+
+import Foundation
+
+/// `AndSearchStrategy` is a type of `SearchStrategy` that searches for multiple `String`s with an "AND" condition.
+final class AndSearchStrategy: SearchStrategy {
+
+    /// The list of strings to be searched.
+    let strings: [String]
+
+    /// Initializes a new instance of `AndSearchStrategy`.
+    ///
+    /// - Parameter strings: The list of strings to be searched.
+    init(strings: [String]) {
+
+        self.strings = strings
+    }
+
+    /// Evaluates if a given string contains all of the `String`s in the `strings` array.
+    ///
+    /// - Parameter string: The string to be evaluated.
+    /// - Returns: `true` if the string contains all of the `String`s in the `strings` array, `false` otherwise.
+    func evaluate(string: String) -> Bool {
+
+        return strings.allSatisfy(string.contains)
+    }
+}

Sources/StringContainsOperators/SearchStrategies/DiacriticAndCaseInsensitiveSearchStrategy.swift

@@ -0,0 +1,35 @@
+//
+//  DiacriticAndCaseInsensitiveSearchStrategy.swift
+//  
+//
+//  Created by Victor C Tavernari on 23/03/2023.
+//
+
+import Foundation
+
+/// `DiacriticAndCaseInsensitiveSearchStrategy` is a type of `SearchStrategy` that searches for a `String` case-insensitively and without diacritics.
+final class DiacriticAndCaseInsensitiveSearchStrategy: SearchStrategy {
+
+    /// The string to be searched without diacritics and case-insensitively.
+    let value: String
+
+    /// Initializes a new instance of `DiacriticAndCaseInsensitiveSearchStrategy`.
+    ///
+    /// - Parameter value: The string to be searched.
+    init(value: String) {
+
+        self.value = value.removeDiacriticsAndCase().lowercased()
+    }
+
+    /// Evaluates if a given string contains the `value` string without diacritics and case-insensitively.
+    ///
+    /// - Parameter string: The string to be evaluated.
+    /// - Returns: `true` if the string contains the `value` string without diacritics and case-insensitively, `false` otherwise.
+    func evaluate(string: String) -> Bool {
+
+        return string
+            .removeDiacriticsAndCase()
+            .lowercased()
+            .contains(self.value)
+    }
+}

Sources/StringContainsOperators/SearchStrategies/OrOnlyPredicateSearchStrategy.swift

@@ -0,0 +1,32 @@
+//
+//  OrOnlyPredicateSearchStrategy.swift
+//  
+//
+//  Created by Victor C Tavernari on 23/03/2023.
+//
+
+import Foundation
+
+/// `OrOnlyPredicateSearchStrategy` is a type of `SearchStrategy` that searches for multiple `StringPredicate`s with an "OR" condition.
+final class OrOnlyPredicateSearchStrategy: SearchStrategy {
+
+    /// The list of `StringPredicate`s to be searched.
+    let predicates: [StringPredicate]
+
+    /// Initializes a new instance of `OrOnlyPredicateSearchStrategy`.
+    ///
+    /// - Parameter predicates: The list of `StringPredicate`s to be searched.
+    init(predicates: [StringPredicate]) {
+
+        self.predicates = predicates
+    }
+
+    /// Evaluates if a given string contains at least one of the `StringPredicate`s in the `predicates` array.
+    ///
+    /// - Parameter string: The string to be evaluated.
+    /// - Returns: `true` if the string contains at least one of the `StringPredicate`s in the `predicates` array, `false` otherwise.
+    func evaluate(string: String) -> Bool {
+
+        self.predicates.contains(where: string.contains)
+    }
+}

Sources/StringContainsOperators/SearchStrategies/OrPredicateSearchStrategy.swift

@@ -0,0 +1,39 @@
+//
+//  OrPredicateSearchStrategy.swift
+//  
+//
+//  Created by Victor C Tavernari on 23/03/2023.
+//
+
+import Foundation
+
+
+/// An OrPredicateSearchStrategy is a SearchStrategy that searches for the occurrence of a given string or a given StringPredicate.
+final class OrPredicateSearchStrategy: SearchStrategy {
+
+    /// The string to search for.
+    let value: String
+
+    /// The predicate to search for.
+    let predicate: StringPredicate
+
+    /// Creates a new `OrPredicateSearchStrategy` instance with the given string and predicate.
+    ///
+    /// - Parameters:
+    ///   - value: The string to search for.
+    ///   - predicate: The predicate to search for.
+    init(value: String, predicate: StringPredicate) {
+
+        self.value = value
+        self.predicate = predicate
+    }
+
+    /// Evaluates whether the given string contains either the string or the predicate that this strategy is looking for.
+    ///
+    /// - Parameter string: The string to evaluate.
+    /// - Returns: `true` if the string contains either the string or the predicate that this strategy is looking for, `false` otherwise.
+    func evaluate(string: String) -> Bool {
+
+        return string.contains(self.predicate) || string.contains(self.value)
+    }
+}

Sources/StringContainsOperators/SearchStrategies/OrSearchStrategy.swift

@@ -0,0 +1,30 @@
+//
+//  OrSearchStrategy.swift
+//  
+//
+//  Created by Victor C Tavernari on 23/03/2023.
+//
+
+import Foundation
+
+/// OrSearchStrategy is a concrete class that represents a strategy to search for a string that contains at least one of a given array of strings.
+final class OrSearchStrategy: SearchStrategy {
+
+    /// An array of strings to search.
+    let strings: [String]
+
+    /// Initializes an instance of `OrSearchStrategy`.
+    /// - Parameter strings: An array of strings to search.
+    init(strings: [String]) {
+
+        self.strings = strings
+    }
+
+    /// Evaluates if a given string contains at least one of the strings in `strings`.
+    /// - Parameter string: The string to search.
+    /// - Returns: `true` if the string contains at least one of the strings in `strings`, `false` otherwise.
+    func evaluate(string: String) -> Bool {
+
+        self.strings.contains(where: string.contains)
+    }
+}

Sources/StringContainsOperators/SearchStrategy.swift

@@ -0,0 +1,18 @@
+//
+//  SearchStrategy.swift
+//  
+//
+//  Created by Victor C Tavernari on 23/03/2023.
+//
+
+import Foundation
+
+/// A protocol that defines the behavior of a search strategy.
+protocol SearchStrategy {
+
+    /// Evaluates if a given string matches the search strategy.
+    ///
+    /// - Parameter string: The string to evaluate.
+    /// - Returns: `true` if the string matches the search strategy, otherwise `false`.
+    func evaluate(string: String) -> Bool
+}

Sources/StringContainsOperators/SearchStrategyMaker.swift

@@ -0,0 +1,43 @@
+//
+//  File.swift
+//  
+//
+//  Created by Victor C Tavernari on 23/03/2023.
+//
+
+import Foundation
+
+/// `SearchStrategyMaker` is a factory that produces `SearchStrategy` objects based on a given `StringPredicate`.
+enum SearchStrategyMaker {
+
+    /// Creates an appropriate `SearchStrategy` based on the given `StringPredicate`.
+    ///
+    /// - Parameter predicate: The `StringPredicate` to base the `SearchStrategy` on.
+    /// - Returns: The appropriate `SearchStrategy`.
+    static func make(predicate: StringPredicate) -> SearchStrategy {
+
+        switch predicate {
+
+        case let .or(strings):
+            return OrSearchStrategy(strings: strings)
+
+        case let .orPredicates(value, predicate):
+            return OrPredicateSearchStrategy(value: value, predicate: predicate)
+
+        case let .orOnlyPredicates(predicates):
+            return OrOnlyPredicateSearchStrategy(predicates: predicates)
+
+        case let .and(strings):
+            return AndSearchStrategy(strings: strings)
+
+        case let .andPredicates(value, predicate):
+            return AndPredicateSearchStrategy(value: value, predicate: predicate)
+
+        case let .andOnlyPredicates(predicates):
+            return AndOnlyPredicateSearchStrategy(predicates: predicates)
+
+        case let .diacriticAndCaseInsensitive(value):
+            return DiacriticAndCaseInsensitiveSearchStrategy(value: value)
+        }
+    }
+}