Abstract KeyPath decoding

Author: philptr

Sources/PredicateView/Expressions/Abstract/PredicateExpressionConvertible.swift

@@ -26,3 +26,15 @@ extension PredicateExpressionConvertible {
         attribute
     }
 }
+
+extension PredicateExpressionConvertible where Self: KeyPathExpression {
+    func decoded(
+        keyPath keyPathExpression: KeyPathPredicateExpression,
+        attribute: @autoclosure () -> Attribute
+    ) -> Self? {
+        guard keyPathExpression.keyPath == keyPath else { return nil }
+        var copy = self
+        copy.attribute = attribute()
+        return copy
+    }
+}

Sources/PredicateView/Expressions/BoolExpression.swift

@@ -69,15 +69,13 @@ struct BoolExpression<Root>: ContentExpression, WrappablePredicateExpression {
     ) -> (any Expression<Root>)? {
         switch expression {
         case let expression as PredicateExpressions.Equal<KeyPathPredicateExpression, ValuePredicateExpression>:
-            BoolExpression(
-                keyPath: expression.lhs.keyPath,
-                title: title,
+            decoded(
+                keyPath: expression.lhs,
                 attribute: .init(operator: .is, value: expression.rhs.value)
             )
         case let expression as PredicateExpressions.NotEqual<KeyPathPredicateExpression, ValuePredicateExpression>:
-            BoolExpression(
-                keyPath: expression.lhs.keyPath,
-                title: title,
+            decoded(
+                keyPath: expression.lhs,
                 attribute: .init(operator: .isNot, value: expression.rhs.value)
             )
         default:

Sources/PredicateView/Expressions/DateExpression.swift

@@ -104,9 +104,8 @@ struct DateExpression<Root>: ContentExpression, WrappablePredicateExpression {
     ) -> (any Expression<Root>)? {
         switch expression {
         case let expression as PredicateExpressions.Comparison<KeyPathPredicateExpression, ValuePredicateExpression>:
-            DateExpression(
-                keyPath: expression.lhs.keyPath,
-                title: title,
+            decoded(
+                keyPath: expression.lhs,
                 attribute: .init(operator: .init(expression.op) ?? .before, value: expression.rhs.value)
             )
         case let expression as PredicateExpressions.Conjunction<Comparison, Comparison>:

Sources/PredicateView/Expressions/NumericExpression.swift

@@ -90,21 +90,18 @@ struct NumericExpression<Root, Number>: ContentExpression, WrappablePredicateExp
     ) -> (any Expression<Root>)? {
         switch expression {
         case let expression as PredicateExpressions.Equal<KeyPathPredicateExpression, ValuePredicateExpression>:
-            NumericExpression(
-                keyPath: expression.lhs.keyPath,
-                title: title,
+            decoded(
+                keyPath: expression.lhs,
                 attribute: .init(operator: .equals, value: expression.rhs.value)
             )
         case let expression as PredicateExpressions.NotEqual<KeyPathPredicateExpression, ValuePredicateExpression>:
-            NumericExpression(
-                keyPath: expression.lhs.keyPath,
-                title: title,
+            decoded(
+                keyPath: expression.lhs,
                 attribute: .init(operator: .isNotEqual, value: expression.rhs.value)
             )
         case let expression as PredicateExpressions.Comparison<KeyPathPredicateExpression, ValuePredicateExpression>:
-            NumericExpression(
-                keyPath: expression.lhs.keyPath,
-                title: title,
+            decoded(
+                keyPath: expression.lhs,
                 attribute: .init(operator: .init(expression.op) ?? .equals, value: expression.rhs.value)
             )
         default:

Sources/PredicateView/Expressions/StringExpression.swift

@@ -62,21 +62,18 @@ struct StringExpression<Root>: ContentExpression, WrappablePredicateExpression {
     ) -> (any Expression<Root>)? {
         switch expression {
         case let expression as PredicateExpressions.Equal<KeyPathPredicateExpression, ValuePredicateExpression>:
-            StringExpression(
-                keyPath: expression.lhs.keyPath,
-                title: title,
+            decoded(
+                keyPath: expression.lhs,
                 attribute: .init(operator: .equals, value: expression.rhs.value)
             )
         case let expression as PredicateExpressions.StringLocalizedStandardContains<KeyPathPredicateExpression, ValuePredicateExpression>:
-            StringExpression(
-                keyPath: expression.root.keyPath,
-                title: title,
+            decoded(
+                keyPath: expression.root,
                 attribute: .init(operator: .contains, value: expression.other.value)
             )
         case let expression as PredicateExpressions.SequenceStartsWith<KeyPathPredicateExpression, ValuePredicateExpression>:
-            StringExpression(
-                keyPath: expression.base.keyPath,
-                title: title,
+            decoded(
+                keyPath: expression.base,
                 attribute: .init(operator: .equals, value: expression.prefix.value)
             )
         default: