feat: added IgnoreEncoding(basedOn:) macro to ignore encoding based on other properties (#139)

Author: soumyamahunt

Sources/MetaCodable/IgnoreCoding.swift

@@ -176,3 +176,32 @@ public macro IgnoreEncoding<each T>(if condition: (repeat each T) -> Bool) =
 @available(swift 5.9)
 public macro IgnoreEncoding<T>(if condition: (T) -> Bool) =
     #externalMacro(module: "MacroPlugin", type: "IgnoreEncoding")
+
+/// Indicates the field needs to be encoded only if provided condition
+/// is not satisfied, based on the containing object.
+///
+/// This macro evaluates the condition using the containing object itself,
+/// rather than just the property value. This is useful when the encoding
+/// decision depends on other properties or the overall state of the object.
+/// ```swift
+/// let shouldNotEncodeField: Bool
+/// @IgnoreEncoding(basedOn: \Self.shouldNotEncodeField)
+/// let field: String
+/// ```
+///
+/// The decoding data needs to have applicable data in `field` key.
+/// But the encoded data might not have any `field` key depending on
+/// the value of `shouldNotEncodeField` property of the containing object.
+///
+/// - Parameter condition: The condition to be checked using the containing object.
+///
+/// - Note: This macro on its own only validates if attached declaration
+///   is a variable declaration. ``Codable(commonStrategies:)`` macro uses this macro
+///   when generating final implementations.
+///
+/// - Important: The condition takes the containing object as its parameter
+///   which must conform to `Encodable`.
+@attached(peer)
+@available(swift 5.9)
+public macro IgnoreEncoding<T>(basedOn condition: (T) -> Bool) =
+    #externalMacro(module: "MacroPlugin", type: "IgnoreEncoding")

Sources/MetaCodable/MetaCodable.docc/MetaCodable.md

@@ -112,6 +112,7 @@ Supercharge `Swift`'s `Codable` implementations with macros.
 - ``IgnoreEncoding()``
 - ``IgnoreEncoding(if:)-1iuvv``
 - ``IgnoreEncoding(if:)-7toka``
+- ``IgnoreEncoding(basedOn:)``
 - ``IgnoreCodingInitialized()``
 
 ### Dynamic Coding

Sources/PluginCore/Attributes/Codable/IgnoreCodingInitialized.swift

@@ -69,7 +69,7 @@ extension Registration where Var: ValuedVariable {
         let attr = IgnoreCodingInitialized(from: decl)
         let code = attr != nil ? self.variable.value == nil : nil
         let options = Output.Options(
-            decode: code, encode: code, encodingConditionExpr: nil
+            decode: code, encode: code, encodingCondition: nil
         )
         let newVariable = Output(base: self.variable, options: options)
         return self.updating(with: newVariable)

Sources/PluginCore/Attributes/IgnoreCoding/IgnoreCoding.swift

@@ -106,8 +106,23 @@ where
         let ignoreEncoding = ignoreEncodingAttr != nil && conditionExpr == nil
         let decode = !ignoreCoding && !ignoreDecoding
         let encode = !ignoreCoding && !ignoreEncoding
+
+        let encodingCondition: Output.Options.Condition?
+        if let conditionExpr = conditionExpr {
+            switch conditionExpr.label?.tokenKind {
+            case .identifier("if"):
+                encodingCondition = .if(conditionExpr.expression)
+            case .identifier("basedOn"):
+                encodingCondition = .basedOn(conditionExpr.expression)
+            default:
+                encodingCondition = nil
+            }
+        } else {
+            encodingCondition = nil
+        }
+
         let options = Output.Options(
-            decode: decode, encode: encode, encodingConditionExpr: conditionExpr
+            decode: decode, encode: encode, encodingCondition: encodingCondition
         )
         let newVariable = Output(base: self.variable, options: options)
         return self.updating(with: newVariable)

Sources/PluginCore/Attributes/IgnoreCoding/IgnoreEncoding.swift

@@ -12,17 +12,20 @@ package struct IgnoreEncoding: PropertyAttribute {
     /// during initialization.
     let node: AttributeSyntax
 
-    /// Optional encoding condition closure specified.
+    /// Optional encoding condition closure expression with label specified.
     ///
     /// This closure may take one or multiple arguments depending on
-    /// whether attached to property or enum case.
-    ///
-    /// The return type of closure in `Bool`, based on this value encoding
-    /// is decided to be performed or ignored.
-    var conditionExpr: ExprSyntax? {
-        return node.arguments?.as(LabeledExprListSyntax.self)?.first { expr in
-            expr.label?.tokenKind == .identifier("if")
-        }?.expression
+    /// whether attached to property or enum case, and includes information
+    /// about whether it's an 'if' or 'basedOn' condition.
+    var conditionExpr: LabeledExprSyntax? {
+        guard let args = node.arguments?.as(LabeledExprListSyntax.self) else {
+            return nil
+        }
+
+        return args.first { expr in
+            expr.label?.tokenKind == .identifier("if") ||
+            expr.label?.tokenKind == .identifier("basedOn")
+        }
     }
 
     /// Creates a new instance with the provided node.

Sources/PluginCore/Variables/ConditionalCodingVariable.swift

@@ -24,11 +24,28 @@ where Var: ConditionalVariable, Var.Generated: ConditionalVariableSyntax {
         /// False for variables with `@IgnoreCoding`
         /// and `@IgnoreEncoding` attributes.
         let encode: Bool?
-        /// The condition expression based on which encoding is decided.
+
+        /// The condition based on which encoding is decided.
         ///
-        /// This expression accepts arguments from this variable and resolves
+        /// This condition accepts arguments from this variable and resolves
         /// to either `true` or `false` based on which encoding is ignored.
-        let encodingConditionExpr: ExprSyntax?
+        let encodingCondition: Condition?
+
+        /// Condition for determining when encoding should not be performed.
+        enum Condition {
+            /// Encoding is performed only if the provided expression evaluates
+            /// to false.
+            ///
+            /// The expression accepts arguments from this variable and resolves
+            /// to either `true` or `false` based on which encoding is decided.
+            case `if`(ExprSyntax)
+            /// Encoding is performed only if the provided expression evaluates
+            /// to false.
+            ///
+            /// The expression accepts argument as the value that contains
+            /// this property.
+            case basedOn(ExprSyntax)
+        }
     }
 
     /// The value wrapped by this instance.
@@ -59,17 +76,27 @@ where Var: ConditionalVariable, Var.Generated: ConditionalVariableSyntax {
         to location: Var.CodingLocation
     ) -> Var.Generated {
         let syntax = base.encoding(in: context, to: location)
-        guard
-            let conditionExpr = options.encodingConditionExpr
-        else { return syntax }
-        let args = self.conditionArguments
+        guard let condition = options.encodingCondition else { return syntax }
+
+        let conditionExpr: ExprSyntax
+        let args: LabeledExprListSyntax
+        switch condition {
+        case .if(let expr):
+            conditionExpr = expr
+            args = self.conditionArguments
+        case .basedOn(let expr):
+            conditionExpr = expr
+            args = LabeledExprListSyntax {
+                LabeledExprSyntax(expression: "self" as ExprSyntax)
+            }
+        }
+
         let returnList = TupleTypeElementListSyntax {
             for _ in args {
                 TupleTypeElementSyntax(type: "_" as TypeSyntax)
             }
         }
-        let expr: ExprSyntax =
-            "!{ () -> (\(returnList)) -> Bool in \(conditionExpr) }()(\(args))"
+        let expr: ExprSyntax = "!{ () -> (\(returnList)) -> Bool in \(conditionExpr) }()(\(args))"
         return syntax.adding(condition: [.init(expression: expr)])
     }
 }