Merge pull request #13 from ABridoux/develop

Added support for single boolean key path and string key paths

Author: ABridoux

Sources/SafeFetching/Predicate/Declarations/BooleanKeyPathPredicate+Comparison.swift

@@ -28,3 +28,7 @@ public func < <E: NSManagedObject, V: Comparable & DatabaseValue & DatabaseTestV
 public func <= <E: NSManagedObject, V: Comparable & DatabaseValue & DatabaseTestValue>(lhs: KeyPath<E, V>, rhs: V) -> Builders.Predicate<E> {
     .init(keyPath: lhs, operatorString: "<=", value: rhs)
 }
+
+public prefix func ! <E: NSManagedObject>(rhs: KeyPath<E, Bool>) -> Builders.Predicate<E> {
+    .init(keyPath: rhs, isInverted: true)
+}

Sources/SafeFetching/Predicate/Declarations/BooleanStringKeyPathPredicate+Comparison.swift

@@ -48,3 +48,9 @@ public func <= <E: NSManagedObject, V: Comparable & DatabaseTestValue>(
 ) -> Builders.Predicate<E> {
     .init(keyPathString: lhs.key, operatorString: "<=", value: rhs)
 }
+
+public prefix func ! <E: NSManagedObject>(
+    rhs: StringKeyPath<E, Bool>
+) -> Builders.Predicate<E> {
+    .init(keyPathString: rhs.key, isInverted: true)
+}

Sources/SafeFetching/Predicate/Declarations/StringKeyPredicateRightValue+RawRepresentable.swift

@@ -31,6 +31,8 @@ extension Builders {
     }
 }
 
+// MARK: - Predicate <-> Predicate
+
 public func && <E: NSManagedObject>(
     lhs: Builders.Predicate<E>,
     rhs: Builders.Predicate<E>
@@ -52,3 +54,99 @@ public func || <E: NSManagedObject>(
         rightPredicate: rhs
     )
 }
+
+// MARK: - KeyPath <-> Predicate
+
+public func && <E: NSManagedObject>(
+    lhs: KeyPath<E, Bool>,
+    rhs: Builders.Predicate<E>
+) -> Builders.CompoundPredicate<E> {
+    Builders.CompoundPredicate(
+        joinOperator: .and,
+        leftPredicate: .init(keyPath: lhs),
+        rightPredicate: rhs
+    )
+}
+
+public func || <E: NSManagedObject>(
+    lhs: KeyPath<E, Bool>,
+    rhs: Builders.Predicate<E>
+) -> Builders.CompoundPredicate<E> {
+    Builders.CompoundPredicate(
+        joinOperator: .or,
+        leftPredicate: .init(keyPath: lhs),
+        rightPredicate: rhs
+    )
+}
+
+// MARK: - Predicate <-> KeyPath
+
+public func && <E: NSManagedObject>(
+    lhs: Builders.Predicate<E>,
+    rhs: KeyPath<E, Bool>
+) -> Builders.CompoundPredicate<E> {
+    Builders.CompoundPredicate(
+        joinOperator: .and,
+        leftPredicate: lhs,
+        rightPredicate: .init(keyPath: rhs)
+    )
+}
+
+public func || <E: NSManagedObject>(
+    lhs: Builders.Predicate<E>,
+    rhs: KeyPath<E, Bool>
+) -> Builders.CompoundPredicate<E> {
+    Builders.CompoundPredicate(
+        joinOperator: .or,
+        leftPredicate: lhs,
+        rightPredicate: .init(keyPath: rhs)
+    )
+}
+
+// MARK: - StringKeyPath <-> Predicate
+
+public func && <E: NSManagedObject>(
+    lhs: StringKeyPath<E, Bool>,
+    rhs: Builders.Predicate<E>
+) -> Builders.CompoundPredicate<E> {
+    Builders.CompoundPredicate(
+        joinOperator: .and,
+        leftPredicate: .init(keyPathString: lhs.key),
+        rightPredicate: rhs
+    )
+}
+
+public func || <E: NSManagedObject>(
+    lhs: StringKeyPath<E, Bool>,
+    rhs: Builders.Predicate<E>
+) -> Builders.CompoundPredicate<E> {
+    Builders.CompoundPredicate(
+        joinOperator: .or,
+        leftPredicate: .init(keyPathString: lhs.key),
+        rightPredicate: rhs
+    )
+}
+
+// MARK: - Predicate <-> StringKeyPath
+
+public func && <E: NSManagedObject>(
+    lhs: Builders.Predicate<E>,
+    rhs: StringKeyPath<E, Bool>
+) -> Builders.CompoundPredicate<E> {
+    Builders.CompoundPredicate(
+        joinOperator: .and,
+        leftPredicate: lhs,
+        rightPredicate: .init(keyPathString: rhs.key)
+    )
+}
+
+public func || <E: NSManagedObject>(
+    lhs: Builders.Predicate<E>,
+    rhs: StringKeyPath<E, Bool>
+) -> Builders.CompoundPredicate<E> {
+    Builders.CompoundPredicate(
+        joinOperator: .or,
+        leftPredicate: lhs,
+        rightPredicate: .init(keyPathString: rhs.key)
+    )
+}

Sources/SafeFetching/Predicate/Types/CompoundPredicate.swift

@@ -38,10 +38,18 @@ extension Builders.Predicate {
         isInverted: Bool = false,
         formatter: @escaping Formatter
     ) {
-
         let format = formatter(keyPath.label)
         self.init(nsValue: NSPredicate(format: format))
     }
+
+    public convenience init(
+        keyPath: KeyPath<Entity, Bool>,
+        isInverted: Bool = false
+    ) {
+        let testValue = isInverted ? "0" : "1"
+        let format = "\(keyPath.label) == \(testValue)"
+        self.init(nsValue: NSPredicate(format: format))
+    }
 }
 
 // MARK: - KeyPath string init
@@ -67,4 +75,13 @@ extension Builders.Predicate {
         let format = formatter(keyPathString)
         self.init(nsValue: NSPredicate(format: format))
     }
+
+    public convenience init(
+        keyPathString: String,
+        isInverted: Bool = false
+    ) {
+        let testValue = isInverted ? "0" : "1"
+        let format = "\(keyPathString) == \(testValue)"
+        self.init(nsValue: NSPredicate(format: format))
+    }
 }

Sources/SafeFetching/Predicate/Types/Predicate.swift

@@ -59,11 +59,30 @@ public extension Builders.Request where Step == TargetStep {
     /// ### Examples
     ///  - `.where(\.name == "Endo")`
     ///  - `.where(\.age >= 20 && \.score * .isIn(10...20))`
-    func `where`(_ predicate: Builders.Predicate<Entity>)
-    -> Builders.Request<Entity, PredicateStep, Output> {
+    func `where`(_ predicate: Builders.Predicate<Entity>) -> Builders.Request<Entity, PredicateStep, Output> {
         request.predicate = predicate.nsValue
         return .init(request: request)
     }
+
+    /// Pass a boolean key path
+    ///
+    /// ### Examples
+    ///  - `.where(\.isDownloaded)`
+    ///  - `.where(!\.isDownloaded)`
+    func `where`(_ keyPath: KeyPath<Entity, Bool>) -> Builders.Request<Entity, PredicateStep, Output> {
+        request.predicate = Builders.Predicate<Entity>(keyPath: keyPath).nsValue
+        return .init(request: request)
+    }
+
+    /// Pass a boolean string key path
+    ///
+    /// ### Examples
+    ///  - `.where(.isDownloaded)`
+    ///  - `.where(!.isDownloaded)`
+    func `where`(_ keyPath: StringKeyPath<Entity, Bool>) -> Builders.Request<Entity, PredicateStep, Output> {
+        request.predicate = Builders.Predicate<Entity>(keyPathString: keyPath.key).nsValue
+        return .init(request: request)
+    }
 }
 
 

Sources/SafeFetching/Request/RequestBuilder+BuildingSteps.swift

@@ -12,7 +12,7 @@ final class StubEntity: NSManagedObject {
 }
 ```
 
-When building a request, the ``Builders/Request/where(_:)`` operation allows to specify a predicate. For a demonstration purpose in this article, predicates are specified after their implicit declaration.
+When building a request, the ``Builders/Request/where(_:)-6r3wg`` operation allows to specify a predicate. For a demonstration purpose in this article, predicates are specified after their implicit declaration.
 
 ```swift
 let predicate: Builders.Predicate<StubEntity>
@@ -53,6 +53,22 @@ predicate = \.score < 20
 predicate = \.score <= 20
 ```
 
+##### Boolean
+
+```swift
+predicate = \.isAdmin == true
+```
+
+```swift
+predicate = !\.isAdmin
+```
+
+The `where(_:)` function has convenient variations to take a single boolean like ``Builders/Request/where(_:)-5ar9o``.
+
+```swift
+.where(\.isAdmin)
+```
+
 ## Advanced operations
 It's possible to use the advanced operators offered by `NSPredicate` safely by specifying a key path followed by the junction operator `*` then the custom operator.
 
@@ -101,10 +117,22 @@ predicate = \.name == "Bruce"
     || \.score * .isIn(20..<40)
 ```
 
-Composing predicates with compound predicates is done naturally
+##### Single booleans
+
+Compound predicates work with single booleans.
+
+```swift
+predicate = \.isAdmin && \.score * .isIn(20..<40)
+```
+
+```swift
+predicate = !\.isAdmin || \.score * .isIn(20..<40)
+```
 
 ### And - And
 
+Composing predicates with compound predicates is done naturally
+
 ```swift
 predicate = \.score * .isIn(20..<40)
     && \.name * .hasPrefix("Do")

Sources/SafeFetching/SafeFetching.docc/Articles/build-predicates.md

@@ -27,6 +27,7 @@ Key paths predicate work with key paths that target a property exposed to Object
 - ``_=(_:_:)-3bumn``
 - ``_(_:_:)-2o0zw``
 - ``_=(_:_:)-7tt3x``
+- ``!(_:)-k9g0``
 
 ### Key path advanced predicates
 
@@ -46,6 +47,7 @@ Advanced predicates like string comparison ``Builders/KeyPathPredicateRightValue
 - ``_=(_:_:)-7schv``
 - ``_(_:_:)-756zh``
 - ``_=(_:_:)-627jw``
+- ``!(_:)-84xed``
 
 
 ### String key paths advanced predicates
@@ -56,9 +58,19 @@ Advanced predicates like membership ``Builders/StringKeyPathPredicateRightValue/
 
 ### Compound predicate
 
+Use and `&&` and or `||` operators between predicates or with a single boolean key path or string key path..
+
 - ``Builders/CompoundPredicate``
-- ``&&(_:_:)``
-- ``__(_:_:)``
+- ``&&(_:_:)-9k2h3``
+- ``__(_:_:)-7vb5w``
+- ``&&(_:_:)-5awsl``
+- ``__(_:_:)-2bklc``
+- ``&&(_:_:)-1r2e1``
+- ``__(_:_:)-91dq6``
+- ``&&(_:_:)-26dgm``
+- ``__(_:_:)-k20``
+- ``&&(_:_:)-1vytf``
+- ``__(_:_:)-6zf3v``
 
 ### Build requests
 

Sources/SafeFetching/SafeFetching.docc/SafeFetching.md

@@ -17,7 +17,9 @@ final class BooleanPredicateTests: XCTestCase {
         testNSFormat(predicate: \.score <= 10, expecting: "score <= 10")
         testNSFormat(predicate: \.isAdmin == true, expecting: "isAdmin == 1")
         testNSFormat(predicate: \.isAdmin == false, expecting: "isAdmin == 0")
+        testNSFormat(predicate: !\.isAdmin, expecting: "isAdmin == 0")
         testNSFormat(predicate: \.property == nil, expecting: "property == nil")
+
         testNSFormat(predicate: \.stubRelationship == nil, expecting: "stubRelationship == nil")
     }