feat: added common strategies applicable to all properties (#129)

Author: soumyamahunt

Examples/App/Sources/ContentView.swift

@@ -1,6 +1,6 @@
-import SwiftUI
-import MetaCodable
 import HelperCoders
+import MetaCodable
+import SwiftUI
 
 public struct ContentView: View {
     public init() {}

Package.swift

@@ -1,8 +1,9 @@
 // swift-tools-version: 6.0
+// swift-format-ignore-file
 
+import CompilerPluginSupport
 import Foundation
 import PackageDescription
-import CompilerPluginSupport
 
 let package = Package(
     name: "MetaCodable",

Package@swift-5.swift

@@ -1,8 +1,9 @@
 // swift-tools-version: 5.9
+// swift-format-ignore-file
 
+import CompilerPluginSupport
 import Foundation
 import PackageDescription
-import CompilerPluginSupport
 
 let package = Package(
     name: "MetaCodable",

README.md

@@ -14,7 +14,7 @@ Supercharge `Swift`'s `Codable` implementations with macros.
 
 ## Overview
 
-`MetaCodable` framework exposes custom macros which can be used to generate dynamic `Codable` implementations. The core of the framework is ``Codable()`` macro which generates the implementation aided by data provided with using other macros.
+`MetaCodable` framework exposes custom macros which can be used to generate dynamic `Codable` implementations. The core of the framework is ``Codable(commonStrategies:)`` macro which generates the implementation aided by data provided with using other macros.
 
 `MetaCodable` aims to supercharge your `Codable` implementations by providing these inbox features:
 
@@ -24,6 +24,7 @@ Supercharge `Swift`'s `Codable` implementations with macros.
 - Allows to read data from additional fallback `CodingKey`s provided with ``CodedAs(_:_:)``.
 - 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(_:)``, ``CodedBy(_:properties:)`` or others. i.e. ``LossySequenceCoder`` etc.
+- Allows applying common strategies like `ValueCoder` to all properties of a type through the ``Codable(commonStrategies:)`` parameter, reducing the need for repetitive property annotations.
 - 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()``.

Sources/HelperCoders/HelperCoders.docc/HelperCoders.md

@@ -75,3 +75,7 @@ Level up `MetaCodable`'s generated implementations with helpers assisting common
 ### Sequence
 
 - ``SequenceCoder``
+
+### Strategies
+
+- ``HelperCoderStrategy``

Sources/HelperCoders/Strategies/HelperCoderStrategy.swift

@@ -0,0 +1,21 @@
+import MetaCodable
+
+/// An enumeration of supported helper coder strategies for use with the `@Codable` macro's `commonStrategies` parameter.
+///
+/// Use cases such as `.valueCoder()` allow you to specify that all properties should use a particular value coding strategy
+/// (e.g., `ValueCoder`) for encoding and decoding, without annotating each property individually.
+public enum HelperCoderStrategy {
+    /// Applies the `ValueCoder` strategy to all properties, optionally specifying additional types.
+    case valueCoder(_ additionalTypes: [any ValueCodingStrategy.Type] = [])
+    // Future cases can be added here
+}
+
+public extension CodableCommonStrategy {
+    /// Returns a `CodableCommonStrategy` representing the use of a helper coder strategy for all properties.
+    ///
+    /// - Parameter helperCoderStrategy: The helper coder strategy to apply (e.g., `.valueCoder()`).
+    /// - Returns: A `CodableCommonStrategy` value for use in the `commonStrategies` parameter of `@Codable`.
+    static func codedBy(_ helperCoderStrategy: HelperCoderStrategy) -> Self {
+        return .init()
+    }
+}

Sources/MetaCodable/Codable/Codable.swift

@@ -46,6 +46,10 @@
 ///   * If attached declaration already conforms to `Codable` this macro expansion
 ///     is skipped.
 ///
+/// - Parameters:
+///   - commonStrategies: An array of CodableCommonStrategy values specifying
+///   type conversion strategies to be automatically applied to all properties of the type.
+///
 /// - Important: The attached declaration must be of a `struct`, `class`, `enum`
 ///   or `actor` type. [See the limitations for this macro](<doc:Limitations>).
 @attached(
@@ -58,17 +62,17 @@
     names: named(CodingKeys), named(init(from:)), named(encode(to:))
 )
 @available(swift 5.9)
-public macro Codable() =
+public macro Codable(commonStrategies: [CodableCommonStrategy] = []) =
     #externalMacro(module: "MacroPlugin", type: "Codable")
 
 /// Indicates whether super class conforms to `Codable` or not.
 ///
-/// By default, ``Codable()`` assumes class inherits `Decodable`
+/// By default, ``Codable(commonStrategies:)`` assumes class inherits `Decodable`
 /// or `Encodable` conformance if it doesn't receive protocol needs
 /// to be conformed from the compiler. Using this macro, it can be explicitly
 /// indicated that the class doesn't inherit conformance in such cases.
 ///
-/// Following code indicates ``Codable()`` that `Item` class doesn't
+/// Following code indicates ``Codable(commonStrategies:)`` that `Item` class doesn't
 /// inherit conformance:
 /// ```swift
 /// @Codable
@@ -87,7 +91,7 @@ public macro Codable() =
 ///   - encodable: Whether super class conforms to `Encodable`.
 ///
 /// - Note: This macro on its own only validates if attached declaration
-///   is a class declaration. ``Codable()`` macro uses this macro
+///   is a class declaration. ``Codable(commonStrategies:)`` macro uses this macro
 ///   when generating final implementations.
 @attached(peer)
 @available(swift 5.9)

Sources/MetaCodable/Codable/CodableCommonStrategy.swift

@@ -0,0 +1,23 @@
+// CodableCommonStrategy.swift
+// Defines the CodableCommonStrategy struct for commonStrategies parameter in @Codable macro.
+
+/// A marker type used to represent a common type conversion strategy for the `@Codable` macro.
+///
+/// `CodableCommonStrategy` is used as the element type for the `commonStrategies` parameter in the
+/// `@Codable` macro. It allows users to specify strategies (such as value coding) that should be
+/// automatically applied to all properties of a type, so that users do not have to annotate each property
+/// individually. The macro system interprets these strategies and injects the appropriate coding logic
+/// during macro expansion.
+///
+/// Example usage:
+/// ```swift
+/// @Codable(commonStrategies: [.codedBy(.valueCoder())])
+/// struct MyModel {
+///     let int: Int
+///     let string: String
+/// }
+/// ```
+public struct CodableCommonStrategy {
+    // Only allow MetaCodable to construct
+    package init() {}
+}

Sources/MetaCodable/Codable/CodingKeys.swift

@@ -25,7 +25,7 @@
 ///     let description: String
 /// }
 /// ```
-/// The ``Codable()`` macro generated code will transform field names
+/// The ``Codable(commonStrategies:)`` macro generated code will transform field names
 /// to snake-case in the `Codable` implementation.
 ///
 /// Similarly, for enums associated value label can be kept camel-cased while
@@ -88,10 +88,10 @@
 ///   ``CodedAt(_:)`` will remain unchanged.
 ///
 /// - Note: This macro on its own only validates if attached declaration
-///   is a variable declaration. ``Codable()`` macro uses this macro
+///   is a variable declaration. ``Codable(commonStrategies:)`` macro uses this macro
 ///   when generating final implementations.
 ///
-/// - Important: This attribute must be used combined with ``Codable()``.
+/// - Important: This attribute must be used combined with ``Codable(commonStrategies:)``.
 ///
 /// [Swift API Design Guidelines]:
 /// https://www.swift.org/documentation/api-design-guidelines/#general-conventions

Sources/MetaCodable/Codable/IgnoreCodingInitialized.swift

@@ -57,10 +57,10 @@
 /// while `notIgnored` is decoded and encoded.
 ///
 /// - Note: This macro on its own only validates if attached declaration
-///   is a variable declaration. ``Codable()`` macro uses this macro
+///   is a variable declaration. ``Codable(commonStrategies:)`` macro uses this macro
 ///   when generating final implementations.
 ///
-/// - Important: This attribute must be used combined with ``Codable()``.
+/// - Important: This attribute must be used combined with ``Codable(commonStrategies:)``.
 @attached(peer)
 @available(swift 5.9)
 public macro IgnoreCodingInitialized() =