Support for collection expressions

Author: philptr

Resources/MacDemo.png

@@ -7,7 +7,27 @@
 
 import Foundation
 
-public struct ExpressionAttribute<Expr>: OperatorContainer, Hashable where Expr: SimpleExpression {
+public protocol ExpressionAttribute<Expr>: OperatorContainer, Hashable where Expr: SimpleExpression {
+    var `operator`: Expr.Operator { get set }
+    var value: Expr.AttributeValue { get set }
+}
+
+public struct StandardAttribute<Expr>: ExpressionAttribute where Expr: SimpleExpression {
+    public var `operator`: Expr.Operator
+    public var value: Expr.AttributeValue
+}
+
+public struct MetadataAttribute<Expr, Metadata>: ExpressionAttribute where Expr: SimpleExpression {
     public var `operator`: Expr.Operator
-    public var value: Expr.Value
+    public var value: Expr.AttributeValue
+    public var metadata: Metadata
+    
+    public static func == (lhs: MetadataAttribute<Expr, Metadata>, rhs: MetadataAttribute<Expr, Metadata>) -> Bool {
+        lhs.operator == rhs.operator && lhs.value == rhs.value
+    }
+    
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(self.operator)
+        hasher.combine(self.value)
+    }
 }

Sources/PredicateView/Attributes/ExpressionAttribute.swift

@@ -10,6 +10,18 @@ import Foundation
 public typealias ExpressionCompatible = Codable & Hashable
 
 public struct AnyExpression<Root>: Identifiable {
-    public var wrappedValue: any ValueExpression<Root>
+    public var wrappedValue: any TitledExpression<Root>
+    public var title: String { wrappedValue.title }
     public var id: UUID { wrappedValue.id }
+    
+    @inlinable
+    public init(wrappedValue: any TitledExpression<Root>) {
+        self.wrappedValue = wrappedValue
+    }
+    
+    public func copy() -> Self {
+        var result = wrappedValue
+        result.id = .init()
+        return AnyExpression(wrappedValue: wrappedValue)
+    }
 }

Sources/PredicateView/Expressions/Abstract/AnyExpression.swift

@@ -14,10 +14,10 @@ public protocol ContentExpression<Root>: SimpleExpression {
     associatedtype Result: View
 
     @ViewBuilder
-    static func makeContentView(_ value: Binding<Value>) -> Result
+    static func makeContentView(_ value: Binding<AttributeValue>) -> Result
 }
 
-// MARK: - StandardValueExpressionView
+// MARK: - ContentExpressionView
 
 public struct ContentExpressionView<Root, Expr: ContentExpression<Root>>: ExpressionView {
     public var expression: Binding<Expr>
@@ -34,7 +34,7 @@ public struct ContentExpressionView<Root, Expr: ContentExpression<Root>>: Expres
         }, content: {
             Expr.makeContentView($expression.attribute.value)
         }, menu: {
-            Expr.operatorPickerView(using: $expression.attribute.operator)
+            Expr.makeOperatorMenu(using: $expression.attribute.operator)
         })
     }
 }

Sources/PredicateView/Expressions/Abstract/ContentExpression.swift

@@ -9,17 +9,17 @@ import SwiftUI
 
 extension Expression {
     @ViewBuilder
-    public static func operatorPickerView<T: Hashable>(
+    public static func makeOperatorMenu<T: Hashable>(
         using operation: Binding<T>
     ) -> some View {
-        operatorPickerView(using: operation) { option in
+        makeOperatorMenu(using: operation) { option in
             Text(option.rawValue)
                 .tag(option as! T)
         }
     }
 
     @ViewBuilder
-    public static func operatorPickerView<T: Hashable>(
+    public static func makeOperatorMenu<T: Hashable>(
         using operation: Binding<T>,
         @ViewBuilder itemProvider: @escaping (Operator) -> some View
     ) -> some View {
@@ -30,6 +30,7 @@ extension Expression {
             }
         }
         .pickerStyle(.inline)
+        .labelsHidden()
     }
 
     public static func makeView(for expression: Binding<Self>) -> some ExpressionView {

Sources/PredicateView/Expressions/Abstract/Expression+View.swift

@@ -7,68 +7,75 @@
 
 import Foundation
 
+// MARK: - TitledExpression
+
+public protocol TitledExpression<Root>: Expression {
+    var title: String { get }
+}
+
 // MARK: - ValueExpression
 
-public protocol ValueExpression<Root>: Expression {
+public protocol ValueExpression<Root>: TitledExpression {
     associatedtype Root
     associatedtype Value: Hashable
 
     var keyPath: KeyPath<Root, Value> { get }
-    var title: String { get }
 }
 
 // MARK: - SimpleExpression
 
 public protocol SimpleExpression<Root>: ValueExpression {
-    static var defaultAttribute: ExpressionAttribute<Self> { get }
-    var attribute: ExpressionAttribute<Self> { get set }
+    associatedtype Attribute: ExpressionAttribute<Self>
+    associatedtype AttributeValue: Hashable
 
-    static func buildPredicate<V>(
+    static var defaultAttribute: Attribute { get }
+    var attribute: Attribute { get set }
+    
+    static func buildPredicate<V: StandardPredicateExpression<Value>>(
         for variable: V,
-        using value: Value,
-        operation: Operator
-    ) -> (any StandardPredicateExpression<Bool>)? where V: StandardPredicateExpression<Value>
+        using attribute: Attribute
+    ) -> (any StandardPredicateExpression<Bool>)?
 }
 
 extension SimpleExpression {
-    public var currentValue: AnyHashable { attribute }
-    
+    public var currentValue: AnyHashable {
+        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.value, operation: attribute.operator)
+        return Self.buildPredicate(for: keyPath, using: attribute)
     }
 }
 
 // MARK: - ExpressionWrapper
 
 public protocol ExpressionWrapper<Root, WrappedExpression>: ValueExpression {
     associatedtype WrappedExpression: SimpleExpression<Root>
+    associatedtype Attribute: ExpressionAttribute<WrappedExpression>
 
-    var attribute: ExpressionAttribute<WrappedExpression>? { get set }
+    var attribute: Attribute? { get set }
     var `operator`: Operator { get }
 
     static func buildPredicate<V>(
         for variable: V,
-        using value: WrappedExpression.Value?,
-        wrappedOperation: WrappedExpression.Operator?,
-        operation: Operator
+        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)
-        let wrappedValue = attribute?.value
-        let op = attribute?.operator
-        return Self.buildPredicate(for: keyPath, using: wrappedValue, wrappedOperation: op, operation: `operator`)
+        return Self.buildPredicate(for: keyPath, using: attribute, operator: `operator`)
     }
 }
 

Sources/PredicateView/Expressions/Abstract/ValueExpression.swift

@@ -9,15 +9,17 @@ import SwiftUI
 
 extension AnyExpression {
     public init(keyPath: KeyPath<Root, Bool>, title: String) {
-        self.wrappedValue = BoolExpression(keyPath: keyPath, title: title)
+        self.init(wrappedValue: BoolExpression(keyPath: keyPath, title: title))
     }
 
     public init(keyPath: KeyPath<Root, Bool?>, title: String) {
-        self.wrappedValue = OptionalExpression<Root, BoolExpression>(keyPath: keyPath, title: title)
+        self.init(wrappedValue: OptionalExpression<Root, BoolExpression>(keyPath: keyPath, title: title))
     }
 }
 
 struct BoolExpression<Root>: ContentExpression {
+    typealias AttributeValue = Bool
+    
     enum Operator: String, CaseIterable {
         case `is` = "is"
         case isNot = "is not"
@@ -37,28 +39,27 @@ struct BoolExpression<Root>: ContentExpression {
         }
     }
 
-    static var defaultAttribute: ExpressionAttribute<Self> { .init(operator: .is, value: true) }
+    static var defaultAttribute: StandardAttribute<Self> { .init(operator: .is, value: true) }
 
     var id = UUID()
     let keyPath: KeyPath<Root, Bool>
     let title: String
-    var attribute: ExpressionAttribute<Self> = Self.defaultAttribute
+    var attribute: StandardAttribute<Self> = Self.defaultAttribute
 
     static func buildPredicate<V>(
         for variable: V,
-        using value: Value,
-        operation: Operator
+        using attribute: StandardAttribute<Self>
     ) -> (any StandardPredicateExpression<Bool>)? where V: StandardPredicateExpression<Value> {
-        switch operation {
+        switch attribute.operator {
         case .is:
             PredicateExpressions.Equal(
                 lhs: variable,
-                rhs: PredicateExpressions.Value(value)
+                rhs: PredicateExpressions.Value(attribute.value)
             )
         case .isNot:
             PredicateExpressions.NotEqual(
                 lhs: variable,
-                rhs: PredicateExpressions.Value(value)
+                rhs: PredicateExpressions.Value(attribute.value)
             )
         }
     }