Initial support for decoding predicates

Author: philptr

Example/PredicateViewExample/SwiftDataDemoView.swift

@@ -41,7 +41,11 @@ struct SwiftDataDemoView: View {
     }
 
     @Environment(\.modelContext) private var modelContext
-    @State var predicate: Predicate<Item> = .true
+    @State var predicate: Predicate<Item> = #Predicate<Item> {
+        $0.title.localizedStandardContains("Item")
+    }
+    
+    @State private var savedPredicates: [Predicate<Item>] = []
 
     var body: some View {
         VStack(alignment: .leading) {
@@ -52,6 +56,21 @@ struct SwiftDataDemoView: View {
                 ])
             }
 
+            GroupBox("Cloned Predicates") {
+                ForEach(Array($savedPredicates.enumerated()), id: \.offset) { index, $predicate in
+                    ScrollView(.horizontal) {
+                        PredicateView(predicate: $predicate, rowTemplates: [
+                            .init(keyPath: \.title, title: "Title"),
+                            .init(StatusExpressionView.self),
+                        ])
+                    }
+                }
+                
+                Button("Clone") {
+                    savedPredicates.append(predicate)
+                }
+            }
+            
             Table(items) {
                 TableColumn("Title", value: \.title)
                 TableColumn("Status", value: \.status.rawValue)

Sources/PredicateView/Attributes/ExpressionAttribute.swift

@@ -7,17 +7,17 @@
 
 import Foundation
 
-public protocol ExpressionAttribute<Expr>: OperatorContainer, Hashable where Expr: SimpleExpression {
+public protocol ExpressionAttribute<Expr>: OperatorContainer, Hashable where Expr: PredicateExpressionConvertible {
     var `operator`: Expr.Operator { get set }
     var value: Expr.AttributeValue { get set }
 }
 
-public struct StandardAttribute<Expr>: ExpressionAttribute where Expr: SimpleExpression {
+public struct StandardAttribute<Expr>: ExpressionAttribute where Expr: PredicateExpressionConvertible {
     public var `operator`: Expr.Operator
     public var value: Expr.AttributeValue
 }
 
-public struct MetadataAttribute<Expr, Metadata>: ExpressionAttribute where Expr: SimpleExpression {
+public struct MetadataAttribute<Expr, Metadata>: ExpressionAttribute where Expr: PredicateExpressionConvertible {
     public var `operator`: Expr.Operator
     public var value: Expr.AttributeValue
     public var metadata: Metadata

Sources/PredicateView/Expressions/Abstract/ContentExpression.swift

@@ -9,7 +9,7 @@ import SwiftUI
 
 // MARK: - ContentExpression
 
-public protocol ContentExpression<Root>: SimpleExpression {
+public protocol ContentExpression<Root>: PredicateExpressionConvertible & TitledExpression {
     associatedtype ExprView = ContentExpressionView<Root, Self>
     associatedtype Result: View
 

Sources/PredicateView/Expressions/Abstract/ExpressionWrapper.swift

@@ -0,0 +1,40 @@
+//
+//  ExpressionWrapper.swift
+//  PredicateView
+//
+//  Created by Phil Zakharchenko on 9/22/24.
+//
+
+import Foundation
+
+public protocol ExpressionWrapper<Root, WrappedExpression>: KeyPathExpression {
+    associatedtype WrappedExpression: PredicateExpressionConvertible<Root>
+    associatedtype Attribute: ExpressionAttribute<WrappedExpression>
+    
+    var attribute: Attribute? { get set }
+    var `operator`: Operator { get }
+    
+    static func buildPredicate<V>(
+        for variable: V,
+        using wrappedExpression: Attribute?,
+        operator: Operator
+    ) -> (any StandardPredicateExpression<Bool>)? where V: StandardPredicateExpression<Value>
+}
+
+extension ExpressionWrapper {
+    public var currentValue: AnyHashable {
+        ExpressionWrapperValue(op: self.operator, attribute: self.attribute)
+    }
+    
+    public func buildPredicate(
+        using input: PredicateExpressions.Variable<Root>
+    ) -> (any StandardPredicateExpression<Bool>)? {
+        let keyPath = PredicateExpressions.KeyPath(root: input, keyPath: keyPath)
+        return Self.buildPredicate(for: keyPath, using: attribute, operator: `operator`)
+    }
+}
+
+private struct ExpressionWrapperValue: Hashable {
+    var op: AnyHashable
+    var attribute: AnyHashable?
+}

Sources/PredicateView/Expressions/Abstract/KeyPathExpression.swift

@@ -0,0 +1,22 @@
+//
+//  ValueExpression.swift
+//
+//
+//  Created by Phil Zakharchenko on 4/20/24.
+//
+
+import Foundation
+
+// MARK: - KeyPathExpression
+
+public protocol KeyPathExpression<Root>: TitledExpression {
+    associatedtype Root
+    associatedtype Value: Hashable
+    
+    var keyPath: KeyPath<Root, Value> { get }
+}
+
+extension KeyPathExpression {
+    typealias KeyPathPredicateExpression = PredicateExpressions.KeyPath<PredicateExpressions.Variable<Root>, Value>
+    typealias ValuePredicateExpression = PredicateExpressions.Value<Value>
+}

Sources/PredicateView/Expressions/Abstract/PredicateExpressionConvertible.swift

@@ -0,0 +1,28 @@
+//
+//  PredicateExpressionConvertible.swift
+//  PredicateView
+//
+//  Created by Phil Zakharchenko on 9/22/24.
+//
+
+import Foundation
+
+/// Describes an ``Expression`` capable of both building a ``StandardPredicateExpression`` from
+/// itself and decoding a provided ``PredicateExpression``.
+public protocol PredicateExpressionConvertible<Root>: LeafPredicateExpressionDecoding {
+    associatedtype Attribute: ExpressionAttribute<Self>
+    associatedtype AttributeValue: Hashable
+    
+    static var defaultAttribute: Attribute { get }
+    var attribute: Attribute { get set }
+    
+    func buildPredicate(
+        using input: PredicateExpressions.Variable<Root>
+    ) -> (any StandardPredicateExpression<Bool>)?
+}
+
+extension PredicateExpressionConvertible {
+    public var currentValue: AnyHashable {
+        attribute
+    }
+}

Sources/PredicateView/Expressions/Abstract/PredicateExpressionDecoding.swift

@@ -0,0 +1,37 @@
+//
+//  PredicateExpressionDecoding.swift
+//  PredicateView
+//
+//  Created by Phil Zakharchenko on 9/22/24.
+//
+
+import Foundation
+
+/// Describes an ``Expression`` that is able to decode from a provided ``PredicateExpression``.
+///
+/// Typically, a given type should only be concerned with decoding predicates that map to itself.
+/// As such, the return type in most cases should be `Self`.
+///
+/// However, in some cases, such as expressions containing other subexpressions, notably
+/// ``LogicalExpression``, the returned ``Expression`` may be of a type different than `Self`.
+public protocol PredicateExpressionDecoding<Root>: Expression {
+    func decode<PredicateExpressionType: PredicateExpression<Bool>>(
+        _ expression: PredicateExpressionType,
+        using decoders: [any PredicateExpressionDecoding<Root>]
+    ) -> (any Expression<Root>)?
+}
+
+public protocol LeafPredicateExpressionDecoding<Root>: PredicateExpressionDecoding {
+    func decode<PredicateExpressionType: PredicateExpression<Bool>>(
+        _ expression: PredicateExpressionType
+    ) -> (any Expression<Root>)?
+}
+
+extension LeafPredicateExpressionDecoding {
+    public func decode<PredicateExpressionType: PredicateExpression<Bool>>(
+        _ expression: PredicateExpressionType,
+        using decoders: [any PredicateExpressionDecoding<Root>]
+    ) -> (any Expression<Root>)? {
+        self.decode(expression)
+    }
+}

Sources/PredicateView/Expressions/Abstract/TitledExpression.swift

@@ -0,0 +1,13 @@
+//
+//  TitledExpression.swift
+//  PredicateView
+//
+//  Created by Phil Zakharchenko on 9/22/24.
+//
+
+import Foundation
+
+/// A specialized expression that has a read-only title shown to the user.
+public protocol TitledExpression<Root>: Expression {
+    var title: String { get }
+}

Sources/PredicateView/Expressions/Abstract/ValueExpression.swift

@@ -0,0 +1,25 @@
+//
+//  WrappablePredicateExpression.swift
+//  PredicateView
+//
+//  Created by Phil Zakharchenko on 9/22/24.
+//
+
+import Foundation
+
+/// Describes an ``Expression`` that can be wrapped by an ``ExpressionWrapper``, such as ``OptionalExpression``.
+public protocol WrappablePredicateExpression: PredicateExpressionConvertible & KeyPathExpression {
+    static func buildPredicate<V: StandardPredicateExpression<Value>>(
+        for variable: V,
+        using attribute: Attribute
+    ) -> (any StandardPredicateExpression<Bool>)?
+}
+
+extension PredicateExpressionConvertible where Self: WrappablePredicateExpression {
+    public func buildPredicate(
+        using input: PredicateExpressions.Variable<Root>
+    ) -> (any StandardPredicateExpression<Bool>)? {
+        let keyPath = PredicateExpressions.KeyPath(root: input, keyPath: keyPath)
+        return Self.buildPredicate(for: keyPath, using: attribute)
+    }
+}