Initial commit

Author: Tavernari

.gitignore

@@ -0,0 +1,9 @@
+.DS_Store
+/.build
+/Packages
+/*.xcodeproj
+xcuserdata/
+DerivedData/
+.swiftpm/config/registries.json
+.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
+.netrc

.vscode/settings.json

@@ -0,0 +1 @@
+{}

Package.swift

@@ -0,0 +1,28 @@
+// swift-tools-version: 5.7
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "StringContainsOperators",
+    products: [
+        // Products define the executables and libraries a package produces, and make them visible to other packages.
+        .library(
+            name: "StringContainsOperators",
+            targets: ["StringContainsOperators"]),
+    ],
+    dependencies: [
+        // Dependencies declare other packages that this package depends on.
+        // .package(url: /* package url */, from: "1.0.0"),
+    ],
+    targets: [
+        // Targets are the basic building blocks of a package. A target can define a module or a test suite.
+        // Targets can depend on other targets in this package, and on products in packages this package depends on.
+        .target(
+            name: "StringContainsOperators",
+            dependencies: []),
+        .testTarget(
+            name: "StringContainsOperatorsTests",
+            dependencies: ["StringContainsOperators"]),
+    ]
+)

README.md

@@ -0,0 +1,60 @@
+# StringContainsOperators
+
+StringContainsOperators is a Swift library for creating and evaluating complex string predicates using custom operators. This library provides an easy-to-use and flexible solution for matching strings against complex patterns.
+
+## How to Use
+
+The library provides three main components: custom operators, an enum type, and an extension to the String class.
+
+## Custom Operators
+
+StringContainsOperators provides two custom operators: || and &&. These operators are used to create OR and AND predicates, respectively, between two strings or between a string and another predicate.
+
+For example, you can create an OR predicate between two strings as follows:
+
+```swift
+let predicate = "hello" || "world"
+```
+This creates a predicate that matches any string that contains either "hello" or "world". Similarly, you can create an AND predicate between two strings like this:
+
+```swift
+let predicate = "hello" && "world"
+```
+This creates a predicate that matches any string that contains both "hello" and "world".
+
+## Enum Type
+
+The resulting predicate is represented by an enum type called StringPredicate. This enum type can be either a base predicate, an OR predicate, or an AND predicate.
+
+## Extension to String
+
+The contains() function, which is an extension of the String class, is used to evaluate whether a given string satisfies a particular predicate. The function takes a StringPredicate as input and returns a boolean value indicating whether the predicate is true or false.
+
+```swift
+let result = "hello world".contains("hello" || "world")
+print(result) // true
+```
+
+## How to Install
+
+### SPM
+
+You can install StringContainsOperators using Swift Package Manager (SPM). Simply add the following line to your dependencies in your Package.swift file:
+
+```swift
+.package(url: "https://github.com/Tavernari/StringContainsOperators.git", from: "1.0.0")
+```
+
+### Cocoapods
+
+You can also install StringContainsOperators using CocoaPods. Simply add the following line to your Podfile:
+
+```ruby
+pod 'StringContainsOperators', '~> 1.0'
+```
+
+## Contributions
+
+Contributions to StringContainsOperators are welcome! Before making a pull request, please open an issue to discuss your proposed changes. We follow the GitHub Flow for our development process.
+
+Please note that this project is released with a Contributor Code of Conduct. By participating in this project you agree to abide by its terms.

Sources/StringContainsOperators/StringContainsOperators.swift

@@ -0,0 +1,67 @@
+import Foundation
+
+infix operator || : LogicalDisjunctionPrecedence
+infix operator && : LogicalConjunctionPrecedence
+
+public indirect enum StringPredicate {
+    case base(StringPredicate)
+    case or([String])
+    case orPredicates(String, StringPredicate)
+    case and([String])
+    case andPredicates(String, StringPredicate)
+}
+
+public func || (lhs: String, rhs: String) -> StringPredicate {
+
+    return .base(.or([lhs, rhs]))
+}
+
+public func || (lhs: String, rhs: StringPredicate) -> StringPredicate {
+
+    return .orPredicates(lhs, rhs)
+}
+
+public func || (lhs: StringPredicate, rhs: String) -> StringPredicate {
+
+    return .orPredicates(rhs, lhs)
+}
+
+public func && (lhs: String, rhs: String) -> StringPredicate {
+
+    return .base(.and([lhs, rhs]))
+}
+
+public func && (lhs: String, rhs: StringPredicate) -> StringPredicate {
+
+    return .andPredicates(lhs, rhs)
+}
+
+public func && (lhs: StringPredicate, rhs: String) -> StringPredicate {
+
+    return .andPredicates(rhs, lhs)
+}
+
+public extension String {
+    func contains(_ predicate: StringPredicate) -> Bool {
+
+        switch predicate {
+
+        case let .base(predicate):
+            return self.contains(predicate)
+
+        case let .or(strings):
+            return strings.contains(where: self.contains)
+
+        case let .orPredicates(value, predicate):
+            return self.contains(predicate) || self.contains(.or([value]))
+
+        case let .and(strings):
+            return strings.allSatisfy(self.contains)
+
+        case let .andPredicates(value, predicate):
+            return self.contains(predicate) && self.contains(.and([value]))
+        }
+    }
+}
+
+

StringContainsOperators.podspec

@@ -0,0 +1,13 @@
+Pod::Spec.new do |s|
+  s.name         = "StringContainsOperators"
+  s.version      = "1.0.0"
+  s.summary      = "A Swift library for creating and evaluating complex string predicates using custom operators."
+  s.description  = "StringContainsOperators provides custom operators and an enum type to create complex string predicates, which can be evaluated using the contains() function. This library is designed to be easy to use and flexible, allowing developers to create powerful string matching logic with minimal code."
+  s.homepage     = "https://github.com/Tavernari/StringContainsOperators"
+  s.license      = "MIT"
+  s.author       = { "Victor Carvalho Tavernari" => "victortavernari@gmail.com" }
+  s.source       = { :git => "https://github.com/Tavernari/StringContainsOperators.git", :tag => "#{s.version}" }
+  s.source_files = "Sources/**/*.swift"
+  s.ios.deployment_target     = '11.0'
+  s.osx.deployment_target     = '10.13'
+end

Tests/StringContainsOperatorsTests/StringContainsOperatorsTests.swift

@@ -0,0 +1,59 @@
+import XCTest
+@testable import StringContainsOperators
+
+final class StringContainsOperatorsTests: XCTestCase {
+
+    func testBaseStringPredicate() {
+           let predicate = "Hello" || "World"
+           XCTAssertTrue("Hello".contains(predicate))
+           XCTAssertTrue("World".contains(predicate))
+           XCTAssertFalse("Goodbye".contains(predicate))
+   }
+       
+   func testOrStringPredicate() {
+       let predicate = "Hello" || "World" || "Goodbye"
+       XCTAssertTrue("Hello".contains(predicate))
+       XCTAssertTrue("World".contains(predicate))
+       XCTAssertTrue("Goodbye".contains(predicate))
+       XCTAssertFalse("Goodnight".contains(predicate))
+   }
+   
+   func testOrPredicates() {
+       let predicate = "Hello" || ("W" && "o" && "r" && "l" && "d")
+       XCTAssertTrue("Hello".contains(predicate))
+       XCTAssertTrue("World".contains(predicate))
+       XCTAssertFalse("Goodbye".contains(predicate))
+       XCTAssertFalse("Hey".contains(predicate))
+   }
+   
+   func testAndStringPredicate() {
+       let predicate = "Hello" && "World"
+       XCTAssertTrue("HelloWorld".contains(predicate))
+       XCTAssertFalse("Hello".contains(predicate))
+       XCTAssertFalse("World".contains(predicate))
+       XCTAssertFalse("Goodbye".contains(predicate))
+   }
+   
+   func testAndPredicates() {
+       let predicate = "H" && ("e" || "i") && "llo"
+       XCTAssertTrue("Hello".contains(predicate))
+       XCTAssertTrue("Hillo".contains(predicate))
+       XCTAssertFalse("Hallo".contains(predicate))
+       XCTAssertFalse("Hiyo".contains(predicate))
+   }
+   
+   func testIndirectStringPredicate() {
+       let predicate = ("Hello" || "World") && "!"
+       XCTAssertTrue("Hello!".contains(predicate))
+       XCTAssertTrue("World!".contains(predicate))
+       XCTAssertFalse("Hello".contains(predicate))
+   }
+   
+   func testNestedStringPredicate() {
+       let predicate = "Hello" || ("W" && ("o" || "i") && "r" && "l" && "d")
+       XCTAssertTrue("Hello".contains(predicate))
+       XCTAssertTrue("World".contains(predicate))
+       XCTAssertTrue("Wirld".contains(predicate))
+       XCTAssertFalse("Goodbye".contains(predicate))
+   }
+}