RecursiveDiff: better nil-Handling, deal with components of collections (#)

Author: melle

Sources/LoggerMiddleware/LoggerMiddleware.swift

@@ -150,9 +150,23 @@ extension LoggerMiddleware {
         diff(prefix: prefixLines, name: stateName, lhs: before, rhs: after)?.trimmingCharacters(in: .whitespacesAndNewlines)
     }
 
-    private static func diff<A>(prefix: String, name: String, level: Int = 0, lhs: A, rhs: A) -> String? {
-        let leftMirror = Mirror(reflecting: lhs)
-        let rightMirror = Mirror(reflecting: rhs)
+    private static func diff<A>(prefix: String, name: String, level: Int = 0, lhs: A?, rhs: A?) -> String? {
+
+        guard let rightHandSide = rhs, let leftHandSide = lhs else {
+            if let rightHandSide = rhs {
+                return "\(prefix).\(name): nil → \(rightHandSide)"
+            }
+
+            if let leftHandSide = lhs {
+                return "\(prefix).\(name): \(leftHandSide) → nil"
+            }
+
+            // nil == lhs == rhs
+            return nil
+        }
+
+        let leftMirror = Mirror(reflecting: leftHandSide)
+        let rightMirror = Mirror(reflecting: rightHandSide)
 
         // special handling for Dictionaries
         if let left = lhs as? Dictionary<AnyHashable, Any>, let right = rhs as? Dictionary<AnyHashable, Any> {
@@ -188,28 +202,21 @@ extension LoggerMiddleware {
 
         // if there are no children, compare lhs and rhs directly
         if 0 == leftMirror.children.count {
-            if "\(lhs)" == "\(rhs)" {
+            if "\(leftHandSide)" == "\(rightHandSide)" {
                 return nil
             } else {
-                return "\(prefix).\(name): \(lhs) → \(rhs)"
+                return "\(prefix).\(name): \(leftHandSide) → \(rightHandSide)"
             }
         }
 
         // there are children -> diff the object graph recursively
         let strings: [String] = leftMirror.children.map({ leftChild  in
-            guard let rightChild = rightMirror.children.first(where: { $0.label == leftChild.label }) else {
-                return nil
-            }
-
-            let leftValue = leftChild.value
-            let rightValue = rightChild.value
-
-            let dot = (level > 0) ? "." : " "
-            return Self.diff(prefix: "\(prefix)\(dot)\(name)",
-                             name: leftChild.label ?? "",
+            let toDotOrNotToDot = (level > 0) ? "." : " "
+            return Self.diff(prefix: "\(prefix)\(toDotOrNotToDot)\(name)",
+                             name: leftChild.label ?? "#", // label might be missing for items in collections
                              level: level + 1,
-                             lhs: leftValue,
-                             rhs: rightValue)
+                             lhs: leftChild.value,
+                             rhs: rightMirror.children.first(where: { $0.label == leftChild.label })?.value)
         }).compactMap { $0 }
 
         if strings.count > 0 {

Tests/LoggerMiddlewareTests/LoggerMiddlewareTests.swift

@@ -6,11 +6,14 @@ struct TestState: Equatable {
     public let a: Substate
     public let b: [Int]
     public let c: String
+    public let d: String?
+    public let e: String?
 }
 
 struct Substate: Equatable {
     public let x: Set<String>
-    public let y: [String: Int]
+    public let y1: [String: Int]
+    public let y2: [String: Int?]
     public let z: Bool
 }
 
@@ -31,26 +34,35 @@ final class LoggerMiddlewareTests: XCTestCase {
     func testStateDiff() {
         // given
         let beforeState: LoggerMiddleware<TestMiddleware>.StateType = TestState(a: Substate(x: ["SetB", "SetA"],
-                                                                                            y: ["one": 1, "eleven": 11],
+                                                                                            y1: ["one": 1, "eleven": 11],
+                                                                                            y2: ["one": 1, "eleven": 11, "zapp": 42],
                                                                                             z: true),
                                                                                 b: [0, 1],
-                                                                                c: "Foo")
+                                                                                c: "Foo",
+                                                                                d: "✨",
+                                                                                e: nil)
         let afterState: LoggerMiddleware<TestMiddleware>.StateType = TestState(a: Substate(x: ["SetB", "SetC"],
-                                                                                           y: ["one": 1, "twelve": 12],
+                                                                                           y1: ["one": 1, "twelve": 12],
+                                                                                           y2: ["one": 1, "twelve": 12, "zapp": nil],
                                                                                            z: false),
                                                                                 b: [0],
-                                                                                c: "Bar")
+                                                                                c: "Bar",
+                                                                                d: nil,
+                                                                                e: "🥚")
 
         // when
         let result: String? = LoggerMiddleware<TestMiddleware>.recursiveDiff(prefixLines: "🏛", stateName: "TestState", before: beforeState, after: afterState)
 
         // then
         let expected = """
-                       🏛 TestState.some.a.x: 📦 <SetA, SetB> → <SetB, SetC>
-                       🏛 TestState.some.a.y: 📦 [eleven: 11, one: 1] → [one: 1, twelve: 12]
-                       🏛 TestState.some.a.z: true → false
-                       🏛 TestState.some.b: 📦 [0, 1] → [0]
-                       🏛 TestState.some.c: Foo → Bar
+                       🏛 TestState.a.x: 📦 <SetA, SetB> → <SetB, SetC>
+                       🏛 TestState.a.y1: 📦 [eleven: 11, one: 1] → [one: 1, twelve: 12]
+                       🏛 TestState.a.y2: 📦 [eleven: Optional(11), one: Optional(1), zapp: Optional(42)] → [one: Optional(1), twelve: Optional(12), zapp: nil]
+                       🏛 TestState.a.z: true → false
+                       🏛 TestState.b.#: 1 → 0
+                       🏛 TestState.c: Foo → Bar
+                       🏛 TestState.d.some: ✨ → nil
+                       🏛 TestState.e: nil → Optional("🥚")
                        """
         XCTAssertEqual(result, expected)
     }