修复SmartFlat的层级问题

Author: iAmMccc

Example/SmartCodable/Test2ViewController.swift

@@ -19,28 +19,25 @@ class Test2ViewController: BaseViewController {
 
     }
 
+    
     override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
         let dict: [String: Any] = [
             "my_name": "Tom",
             "student": [
-                "my_age": "18"
+                "my_age": "18",
+                "my_name": "Tom",
             ]
         ]
-        let person = Person.deserialize(from: dict,options: [.key(.fromSnakeCase)])
-        print("1111")
+        
+        let student = StudentModel.deserialize(from: dict)
+        print("1111 \(String(describing: student))")
     }
 
-
-}
-
-
-class Person11: SmartCodable {
-    var myName: String?
-    var student: Student?
-    required init() {}
-}
-
-@SmartSubclass
-class Student11: Person11 {
-    var myAge: String?
+    
+    struct FlatModel: SmartCodable {
+        var _cover: String = "123"
+    }
+    struct StudentModel: SmartCodable {
+        var student: FlatModel?
+    }
 }

Example/SmartCodable/TestViewController.swift

@@ -28,39 +28,34 @@ class TestViewController: BaseViewController {
 
     override func viewDidLoad() {
         super.viewDidLoad()
-        let testData: [String: Any] = [
-            "data": [
-                "friend:apply": [
-                    "popup": 124_124_124_124,
-                    "msg_code": "123"
-                ]
-            ]
-        ]
-        let data = NoAuthButtonResponse.deserialize(from: testData)
-        print(data?.data["friend:apply"] as Any)
-    }
-}
-
-class AuthApi {
-
-}
-struct NoAuthButtonResponse: SmartCodable {
-    var data: [String: NoAuthButtonItem] = [:]
-}
-
 
-struct NoAuthButtonItem: SmartCodable {
-    var popup: PopupType = .unsupported
-    var msg: String = ""
+    }
 
-    static func mappingForKey() -> [SmartKeyTransformer]? {
-        return [
-            CodingKeys.msg <--- "msg_code"
+    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
+        let dict: [String: Any] = [
+            "my_name": "Tom",
+//            "nick_name": "XiaoMing",
+//            "student": [
+//                "my_age": "18"
+//            ]
         ]
+        
+        guard let student = StudentModel.deserialize(from: dict) else { return }
+        print("⭐️解析结果: my_name = \(student.flatModel.my_name), nick_name = \(student.flatModel.nick_name)")
+    }
+    
+    
+    struct StudentModel: SmartCodable {
+        @SmartFlat
+        var flatModel: FlatModel = FlatModel()
+    }
+    
+    struct FlatModel: SmartCodable {
+        @SmartIgnored
+        var image: UIImage?
+        var nick_name: String = "Mccc"
+        var my_name: String = "default"
     }
-}
 
-enum PopupType: Int, SmartCaseDefaultable {
-    case banned = 4
-    case unsupported = -1
 }
+

Sources/SmartCodable/Core/Cache/Cachable.swift

@@ -44,7 +44,7 @@ extension Cachable {
     /// - Parameter codingPath: 当前字段或容器所在的完整解码路径。
     /// - Returns: 匹配路径的快照对象，若不存在则返回 `nil`。
     func findSnapShot(with codingPath: [CodingKey]) -> SomeSnapshot? {
-        return snapshots.first { codingPathEquals($0.codingPath, codingPath) }
+        return snapshots.last { codingPathEquals($0.codingPath, codingPath) }
     }
 
     private func codingPathEquals(_ lhs: [CodingKey], _ rhs: [CodingKey]) -> Bool {

Sources/SmartCodable/Core/JSONDecoder/Decoder/DecodingCache.swift

@@ -21,18 +21,32 @@ class DecodingCache: Cachable {
     /// - Parameter type: The Decodable type to cache
     func cacheSnapshot<T>(for type: T.Type, codingPath: [CodingKey]) {
 
-        // 减少动态派发开销，is 检查是编译时静态行为，比 as? 动态转换更高效。
-        guard type is SmartDecodable.Type else { return }
 
-        if let object = type as? SmartDecodable.Type {
-            let snapshot = DecodingSnapshot()
-            snapshot.codingPath = codingPath
-            // [initialValues] Lazy initialization:
-            // Generate initial values via reflection only when first accessed,
-            // using the recorded objectType to optimize parsing performance.
-            snapshot.objectType = object
-            snapshots.append(snapshot)
+        
+        let smartType: SmartDecodable.Type?
+
+        /** 缓存条件
+         * 1. 直接是 SmartDecodable
+         * 2. 是属性包装器，且 WrappedValue 是 SmartDecodable
+         * 3. 其它情况，不关心
+        */
+        if let objectType = type as? SmartDecodable.Type {
+            smartType = objectType
+        } else if let wrapperType = type as? any PropertyWrapperable.Type {
+            smartType = wrapperType.wrappedSmartDecodableType
+        } else {
+            return
         }
+
+        guard let object = smartType else { return }
+        
+        let snapshot = DecodingSnapshot()
+        snapshot.codingPath = codingPath
+        // [initialValues] Lazy initialization:
+        // Generate initial values via reflection only when first accessed,
+        // using the recorded objectType to optimize parsing performance.
+        snapshot.objectType = object
+        snapshots.append(snapshot)
     }
 
     /// Removes the most recent snapshot for the given type
@@ -52,11 +66,6 @@ extension DecodingCache {
     /// 该方法会根据传入的 `codingPath`（代表某个解码容器的位置），
     /// 在缓存的快照中查找对应容器，并尝试获取该容器中 `key` 对应字段的初始值。
     /// 如果该容器尚未初始化初始值，则会延迟初始化一次（通过反射等方式）。
-    ///
-    /// - Parameters:
-    ///   - key: 要查找的字段对应的 `CodingKey`，若为 `nil` 则直接返回 `nil`。
-    ///   - codingPath: 当前字段所在的容器路径，用于准确定位容器上下文。
-    /// - Returns: 若存在可用的初始值且类型匹配，则返回该值；否则返回 `nil`。
     func initialValueIfPresent<T>(forKey key: CodingKey?, codingPath: [CodingKey]) -> T? {
 
         guard let key = key else { return nil }

Sources/SmartCodable/Core/JSONDecoder/Decoder/Impl/JSONDecoderImpl+KeyedContainer.swift

@@ -450,11 +450,13 @@ extension JSONDecoderImpl.KeyedContainer {
         }
 
         /// @SmartFlat的处理
+        /// 关于SmartFlat的解析，是往前一层解析，codingPath不应该增加。
         if let type = type as? FlatType.Type {
             if type.isArray {
                 return try? T(from: superDecoder(forKey: key))
             } else {
-                return try? T(from: impl)
+                // 这里需要走unwrap，需要cache。
+                return try? impl.unwrap(as: T.self)
             }
         }
 

Sources/SmartCodable/Core/PropertyWrapper/PropertyWrapperProtocol.swift

@@ -21,6 +21,8 @@ public protocol PropertyWrapperable {
 
     init(wrappedValue: WrappedValue)
 
+    static var wrappedSmartDecodableType: SmartDecodable.Type? { get }
+
     static func createInstance(with value: Any) -> Self?
 
     /**
@@ -32,7 +34,35 @@ public protocol PropertyWrapperable {
     func wrappedValueDidFinishMapping() -> Self?
 }
 
+public extension PropertyWrapperable {
+    static var wrappedSmartDecodableType: SmartDecodable.Type? {
+
+        let valueType = WrappedValue.self
+
+        // 1️⃣ WrappedValue 本身是 SmartDecodable
+        if let smart = valueType as? SmartDecodable.Type {
+            return smart
+        }
 
+        // 2️⃣ WrappedValue 是 Optional<SmartDecodable>
+        if let optionalType = valueType as? _OptionalType.Type,
+           let smart = optionalType.wrappedType as? SmartDecodable.Type {
+            return smart
+        }
+
+        return nil
+    }
+}
+
+protocol _OptionalType {
+    static var wrappedType: Any.Type { get }
+}
+
+extension Optional: _OptionalType {
+    static var wrappedType: Any.Type {
+        Wrapped.self
+    }
+}
 
 // ============================================================
 // 统一为所有 PropertyWrapperable 提供 Equatable / Hashable 支持