feat: added separate default value options for missing value and other errors (#81)

Author: soumyamahunt

README.md

@@ -22,15 +22,14 @@ Supercharge `Swift`'s `Codable` implementations with macros.
 - Allows to create flattened model for nested `CodingKey` values with ``CodedAt(_:)`` and ``CodedIn(_:)``.
 - Allows to create composition of multiple `Codable` types with ``CodedAt(_:)`` passing no arguments.
 - Allows to read data from additional fallback `CodingKey`s provided with ``CodedAs(_:_:)``.
-- Allows to provide default value in case of decoding failures with ``Default(_:)``.
+- Allows to provide default value in case of decoding failures with ``Default(_:)``, or only in case of failures when missing value with ``Default(ifMissing:)``. Different default values can also be used for value missing and other errors respectively with ``Default(ifMissing:forErrors:)``.
 - Allows to create custom decoding/encoding strategies with ``HelperCoder`` and using them with ``CodedBy(_:)``. i.e. ``LossySequenceCoder`` etc.
 - Allows specifying different case values with ``CodedAs(_:_:)`` and case value/protocol type identifier type different from `String` with ``CodedAs()``.
 - Allows specifying enum-case/protocol type identifier path with ``CodedAt(_:)`` and case content path with ``ContentAt(_:_:)``.
 - Allows decoding/encoding enums that lack distinct identifiers for each case data with ``UnTagged()``.
 - Allows to ignore specific properties/cases from decoding/encoding with ``IgnoreCoding()``, ``IgnoreDecoding()`` and ``IgnoreEncoding()``.
 - Allows to use camel-case names for variables according to [Swift API Design Guidelines](https://www.swift.org/documentation/api-design-guidelines/#general-conventions), while enabling a type/case to work with different case style keys with ``CodingKeys(_:)``.
-- Allows to ignore all initialized properties of a type/case from decoding/encoding with ``IgnoreCodingInitialized()`` unless explicitly asked to decode/encode by attaching any coding attributes, i.e. ``CodedIn(_:)``, ``CodedAt(_:)``,
-``CodedBy(_:)``, ``Default(_:)`` etc.
+- Allows to ignore all initialized properties of a type/case from decoding/encoding with ``IgnoreCodingInitialized()`` unless explicitly asked to decode/encode by attaching any coding attributes, i.e. ``CodedIn(_:)``, ``CodedAt(_:)``, ``CodedBy(_:)``, ``Default(_:)`` etc.
 - Allows to generate protocol decoding/encoding ``HelperCoder``s with `MetaProtocolCodable` build tool plugin from ``DynamicCodable`` types.
 
 [**See the limitations for this macro**](<doc:Limitations>).

Sources/MetaCodable/Default.swift

@@ -27,3 +27,65 @@
 @available(swift 5.9)
 public macro Default<T>(_ default: T) =
     #externalMacro(module: "MacroPlugin", type: "Default")
+
+/// Provides a `default` value to be used when value is missing
+/// and when not initialized explicitly in memberwise initializer(s).
+///
+/// If the value is missing , the default value will be used instead of
+/// throwing error and terminating decoding. i.e. for a field declared as:
+/// ```swift
+/// @Default(ifMissing: "some")
+/// let field: String
+/// ```
+/// if empty json provided
+/// ```json
+/// {}
+/// ```
+/// the default value provided in this case `some` will be used as
+/// `field`'s value.
+///
+/// - Parameter default: The default value to use.
+///
+/// - Note: This macro on its own only validates if attached declaration
+///   is a variable declaration. ``Codable()`` macro uses this macro
+///   when generating final implementations.
+///
+/// - Important: The field type must confirm to `Codable` and
+///   default value type `T` must be the same as field type.
+@attached(peer)
+@available(swift 5.9)
+public macro Default<T>(ifMissing default: T) =
+    #externalMacro(module: "MacroPlugin", type: "Default")
+
+/// Provides different `default` values to be used for missing value
+/// and decoding errors..
+///
+/// If the value is missing, the `missingDefault` value will be used,
+/// while for incorrect data type, `errorDefault` value will be used,
+/// instead of throwing error and terminating decoding.
+/// i.e. for a field declared as:
+/// ```swift
+/// @Default(ifMissing: "some", forErrors: "another")
+/// let field: String
+/// ```
+/// if type at `CodingKey` is different or empty json provided
+/// ```json
+/// { "field": 5 } // or {}
+/// ```
+/// the default value `some` and `another` will be used as
+/// `field`'s value respectively.
+///
+/// - Parameters:
+///   - missingDefault: The default value to use when value is missing.
+///   - errorDefault: The default value to use for other errors.
+///
+/// - Note: This macro on its own only validates if attached declaration
+///   is a variable declaration. ``Codable()`` macro uses this macro
+///   when generating final implementations.
+///
+/// - Important: The field type must confirm to `Codable` and
+///   default value type `T` must be the same as field type.
+@attached(peer)
+@available(swift 5.9)
+public macro Default<T>(ifMissing missingDefault: T, forErrors errorDefault: T) =
+    #externalMacro(module: "MacroPlugin", type: "Default")

Sources/MetaCodable/MetaCodable.docc/MetaCodable.md

@@ -17,15 +17,14 @@ Supercharge `Swift`'s `Codable` implementations with macros.
 - Allows to create flattened model for nested `CodingKey` values with ``CodedAt(_:)`` and ``CodedIn(_:)``.
 - Allows to create composition of multiple `Codable` types with ``CodedAt(_:)`` passing no arguments.
 - Allows to read data from additional fallback `CodingKey`s provided with ``CodedAs(_:_:)``.
-- Allows to provide default value in case of decoding failures with ``Default(_:)``.
+- Allows to provide default value in case of decoding failures with ``Default(_:)``, or only in case of failures when missing value with ``Default(ifMissing:)``. Different default values can also be used for value missing and other errors respectively with ``Default(ifMissing:forErrors:)``.
 - Allows to create custom decoding/encoding strategies with ``HelperCoder`` and using them with ``CodedBy(_:)``. i.e. ``LossySequenceCoder`` etc.
 - Allows specifying different case values with ``CodedAs(_:_:)`` and case value/protocol type identifier type different from `String` with ``CodedAs()``.
 - Allows specifying enum-case/protocol type identifier path with ``CodedAt(_:)`` and case content path with ``ContentAt(_:_:)``.
 - Allows decoding/encoding enums that lack distinct identifiers for each case data with ``UnTagged()``.
 - Allows to ignore specific properties/cases from decoding/encoding with ``IgnoreCoding()``, ``IgnoreDecoding()`` and ``IgnoreEncoding()``.
 - Allows to use camel-case names for variables according to [Swift API Design Guidelines](https://www.swift.org/documentation/api-design-guidelines/#general-conventions), while enabling a type/case to work with different case style keys with ``CodingKeys(_:)``.
-- Allows to ignore all initialized properties of a type/case from decoding/encoding with ``IgnoreCodingInitialized()`` unless explicitly asked to decode/encode by attaching any coding attributes, i.e. ``CodedIn(_:)``, ``CodedAt(_:)``,
-``CodedBy(_:)``, ``Default(_:)`` etc.
+- Allows to ignore all initialized properties of a type/case from decoding/encoding with ``IgnoreCodingInitialized()`` unless explicitly asked to decode/encode by attaching any coding attributes, i.e. ``CodedIn(_:)``, ``CodedAt(_:)``, ``CodedBy(_:)``, ``Default(_:)`` etc.
 - Allows to generate protocol decoding/encoding ``HelperCoder``s with `MetaProtocolCodable` build tool plugin from ``DynamicCodable`` types.
 
 [**See the limitations for this macro**](<doc:Limitations>).
@@ -77,6 +76,8 @@ Supercharge `Swift`'s `Codable` implementations with macros.
 - ``CodedAt(_:)``
 - ``CodedIn(_:)``
 - ``Default(_:)``
+- ``Default(ifMissing:)``
+- ``Default(ifMissing:forErrors:)``
 - ``CodedBy(_:)``
 - ``CodedAs()``
 - ``CodedAs(_:_:)``

Sources/PluginCore/Attributes/Default.swift

@@ -10,12 +10,34 @@ package struct Default: PropertyAttribute {
     /// during initialization.
     let node: AttributeSyntax
 
-    /// The default value expression provided.
-    var expr: ExprSyntax {
-        return node.arguments!
+    /// The default value expression provided for value missing case.
+    ///
+    /// This expression should be used only when value is missing
+    /// in the decoding syntax.
+    var onMissingExpr: ExprSyntax {
+        return node.arguments?.as(LabeledExprListSyntax.self)?.first { expr in
+            expr.label?.tokenKind == .identifier("ifMissing")
+        }?.expression ?? node.arguments!
             .as(LabeledExprListSyntax.self)!.first!.expression
     }
 
+    /// The default value expression provided for errors.
+    ///
+    /// This expression should be used for errors other than
+    /// value is missing in the decoding syntax.
+    var onErrorExpr: ExprSyntax? {
+        guard
+            let exprs = node.arguments?.as(LabeledExprListSyntax.self),
+            !exprs.isEmpty
+        else { return nil }
+        guard
+            exprs.count > 1 || exprs.first?.label != nil
+        else { return exprs.first!.expression }
+        return node.arguments?.as(LabeledExprListSyntax.self)?.first { expr in
+            expr.label?.tokenKind == .identifier("forErrors")
+        }?.expression
+    }
+
     /// Creates a new instance with the provided node.
     ///
     /// The initializer fails to create new instance if the name
@@ -72,7 +94,9 @@ where
     func addDefaultValueIfExists() -> Registration<Decl, Key, DefOutput> {
         guard let attr = Default(from: self.decl)
         else { return self.updating(with: self.variable.any) }
-        let newVar = self.variable.with(default: attr.expr)
+        let newVar = self.variable.with(
+            onMissingExpr: attr.onMissingExpr, onErrorExpr: attr.onErrorExpr
+        )
         return self.updating(with: newVar.any)
     }
 }
@@ -84,9 +108,16 @@ where Initialization == RequiredInitialization {
     /// `DefaultValueVariable` is created with this variable as base
     /// and default expression provided.
     ///
-    /// - Parameter expr: The default expression to add.
+    /// - Parameters:
+    ///   - mExpr: The missing value default expression to add.
+    ///   - eExpr: The other errors default expression to add.
+    ///
     /// - Returns: Created variable data with default expression.
-    func with(default expr: ExprSyntax) -> DefaultValueVariable<Self> {
-        return .init(base: self, options: .init(expr: expr))
+    func with(
+        onMissingExpr mExpr: ExprSyntax, onErrorExpr eExpr: ExprSyntax?
+    ) -> DefaultValueVariable<Self> {
+        return .init(
+            base: self, options: .init(onMissingExpr: mExpr, onErrorExpr: eExpr)
+        )
     }
 }

Sources/PluginCore/Variables/Enum/Switcher/UnTaggedEnumSwitcher.swift

@@ -62,7 +62,8 @@ struct UnTaggedEnumSwitcher: EnumSwitcherVariable {
     func transform(
         variable: BasicAssociatedVariable
     ) -> BasicAssociatedVariable {
-        let fallback = DecodingFallback.ifError("throw \(error)")
+        let `throw`: CodeBlockItemListSyntax = "throw \(error)"
+        let fallback = DecodingFallback.ifMissing(`throw`, ifError: `throw`)
         return .init(
             base: variable.base, label: variable.label,
             fallback: fallback

Sources/PluginCore/Variables/Property/BasicPropertyVariable.swift

@@ -74,7 +74,7 @@ struct BasicPropertyVariable: DefaultPropertyVariable, DeclaredVariable {
     /// `nil` value only when missing or `null`.
     var decodingFallback: DecodingFallback {
         guard hasOptionalType else { return .throw }
-        return .ifMissing("\(decodePrefix)\(name) = nil")
+        return .onlyIfMissing("\(decodePrefix)\(name) = nil")
     }
 
     /// Creates a new variable with provided data.

Sources/PluginCore/Variables/Property/Data/DecodingFallback.swift

@@ -16,13 +16,16 @@ package enum DecodingFallback {
     ///
     /// Indicates if variable data is missing or `null`,
     /// provided fallback syntax will be used for initialization.
-    case ifMissing(CodeBlockItemListSyntax)
+    case onlyIfMissing(CodeBlockItemListSyntax)
     /// Represents fallback option handling
     /// decoding failure completely.
     ///
     /// Indicates for any type of failure error in decoding,
-    /// provided fallback syntax will be used for initialization.
-    case ifError(CodeBlockItemListSyntax)
+    /// provided fallback syntaxes will be used for initialization.
+    ///
+    /// First syntax will be used for errors due to missing or `null`
+    /// value while second syntax will be used for all the other errors.
+    case ifMissing(CodeBlockItemListSyntax, ifError: CodeBlockItemListSyntax)
 
     /// Represents container for decoding/encoding properties.
     typealias Container = PropertyVariableTreeNode.CodingLocation.Container
@@ -76,7 +79,7 @@ package enum DecodingFallback {
         let isOptional: Bool
         let fallbacks: CodeBlockItemListSyntax
         switch self {
-        case .ifError(let eFallbacks):
+        case .ifMissing(_, ifError: let eFallbacks):
             isOptional = true
             fallbacks = eFallbacks
         default:
@@ -146,7 +149,7 @@ package enum DecodingFallback {
                 generated.syntax
             }
             conditionalSyntax = generated.conditionalSyntax
-        case .ifMissing(let fallbacks):
+        case .onlyIfMissing(let fallbacks):
             let generated = decoding(.init(name: nContainer, isOptional: true))
             syntax = CodeBlockItemListSyntax {
                 if nestedContainer == nil {
@@ -167,26 +170,40 @@ package enum DecodingFallback {
                     fallbacks
                 }
             }
-        case .ifError(let fallbacks):
+        case let .ifMissing(fallbacks, ifError: eFallbacks):
             let generated = decoding(.init(name: nContainer, isOptional: true))
+            let containerMissing: TokenSyntax = "\(nContainer)Missing"
             syntax = CodeBlockItemListSyntax {
                 if nestedContainer == nil {
-                    """
-                    let \(nContainer) = try? \(container.syntax).nestedContainer(keyedBy: \(key.type), forKey: \(key.expr))
-                    """
+                    "let \(nContainer): KeyedDecodingContainer<\(key.typeName)>?"
+                    "let \(containerMissing): Bool"
+                    try! IfExprSyntax(
+                        """
+                        if (try? \(container.syntax).decodeNil(forKey: \(key.expr))) == false
+                        """
+                    ) {
+                        """
+                        \(nContainer) = try? \(container.syntax).nestedContainer(keyedBy: \(key.type), forKey: \(key.expr))
+                        """
+                        "\(containerMissing) = false"
+                    } else: {
+                        "\(nContainer) = nil"
+                        "\(containerMissing) = true"
+                    }
                 }
                 generated.syntax
             }
             conditionalSyntax = CodeBlockItemListSyntax {
                 try! IfExprSyntax(
-                    """
-                    if let \(nContainer) = \(nContainer)
-                    """
-                ) {
-                    generated.conditionalSyntax
-                } else: {
-                    fallbacks
-                }
+                    "if let \(nContainer) = \(nContainer)",
+                    bodyBuilder: {
+                        generated.conditionalSyntax
+                    }, elseIf: IfExprSyntax("if \(containerMissing)") {
+                        fallbacks
+                    } else: {
+                        eFallbacks
+                    }
+                )
             }
         }
         return .init(syntax: syntax, conditionalSyntax: conditionalSyntax)
@@ -210,36 +227,37 @@ extension DecodingFallback {
             false
         }
     }
-
-    /// The combined fallback option for all variable elements.
+    
+    /// Adds two decoding fallbacks into a single fallback.
     ///
-    /// Represents the fallback to use when decoding container
-    /// of all the element variables fails.
+    /// The generated single fallback represents both
+    /// the fallback syntaxes added.
     ///
-    /// - Parameter fallbacks: The fallback values to combine.
-    /// - Returns: The aggregated fallback value.
-    static func aggregate<C: Collection>(
-        fallbacks: C
-    ) -> Self where C.Element == Self {
-        var aggregated = C.Element.ifError(.init())
-        for fallback in fallbacks {
-            switch (aggregated, fallback) {
-            case (_, .throw), (.throw, _):
-                return .throw
-            case (.ifMissing(var a), .ifMissing(let f)),
-                (.ifMissing(var a), .ifError(let f)),
-                (.ifError(var a), .ifMissing(let f)):
-                if !hasEarlyExit(in: a) {
-                    a.append(contentsOf: f)
-                }
-                aggregated = .ifMissing(a)
-            case (.ifError(var a), .ifError(let f)):
-                if !hasEarlyExit(in: a) {
-                    a.append(contentsOf: f)
-                }
-                aggregated = .ifError(a)
+    /// - Parameters:
+    ///   - lhs: The first value to add.
+    ///   - rhs: The second value to add.
+    ///
+    /// - Returns: The generated fallback value.
+    static func + (lhs: Self, rhs: Self) -> Self {
+        switch (lhs, rhs) {
+        case (.throw, _), (_, .throw):
+            return .throw
+        case (.onlyIfMissing(let lf), .onlyIfMissing(let rf)), (.onlyIfMissing(let lf), .ifMissing(let rf, ifError: _)), (.ifMissing(let lf, ifError: _), .onlyIfMissing(let rf)):
+            var fallbacks = lf
+            if !hasEarlyExit(in: fallbacks) {
+                fallbacks.append(contentsOf: rf)
+            }
+            return .onlyIfMissing(fallbacks)
+        case let (.ifMissing(lf, ifError: lef), .ifMissing(rf, ifError: ref)):
+            var fallbacks = lf
+            if !hasEarlyExit(in: fallbacks) {
+                fallbacks.append(contentsOf: rf)
+            }
+            var eFallbacks = lef
+            if !hasEarlyExit(in: eFallbacks) {
+                eFallbacks.append(contentsOf: ref)
             }
+            return .ifMissing(fallbacks, ifError: eFallbacks)
         }
-        return aggregated
     }
 }