Recursive diff: attempt to recursively diff any State object

Author: melle

Sources/LoggerMiddleware/LoggerMiddleware.swift

@@ -125,6 +125,7 @@ extension LoggerMiddleware {
     public enum StateDiffTransform {
         case diff(linesOfContext: Int = 2, prefixLines: String = "🏛 ")
         case newStateOnly
+        case recursive(prefixLines: String = "🏛 ", stateName: String)
         case custom((StateType?, StateType) -> String?)
 
         func transform(oldState: StateType?, newState: StateType) -> String? {
@@ -136,11 +137,86 @@ extension LoggerMiddleware {
                 ?? "\(prefixLines) No state mutation"
             case .newStateOnly:
                 return dumpToString(newState)
+            case let .recursive(prefixLines, stateName):
+                return recursiveDiff(prefixLines: prefixLines, stateName: stateName, before: oldState, after: newState)
             case let .custom(closure):
                 return closure(oldState, newState)
             }
         }
     }
+
+    public static func recursiveDiff(prefixLines: String, stateName: String, before: StateType?, after: StateType) -> String? {
+        // cuts the redundant newline character from the output
+        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)
+
+        // special handling for Dictionaries
+        if let left = lhs as? Dictionary<AnyHashable, Any>, let right = rhs as? Dictionary<AnyHashable, Any> {
+
+            let leftSorted = left.sorted { a, b in "\(a.key)" < "\(b.key)" }
+            let rightSorted = right.sorted { a, b in "\(a.key)" < "\(b.key)" }
+
+            let leftPrintable = leftSorted.map { key, value in "\(key): \(value)" }.joined(separator: ", ")
+            let rightPrintable = rightSorted.map { key, value in "\(key): \(value)" }.joined(separator: ", ")
+
+            // .difference(from:) gives unpleasant results
+            if leftPrintable == rightPrintable {
+                return nil
+            }
+
+            return "\(prefix).\(name): 📦 [\(leftPrintable)] → [\(rightPrintable)]"
+        }
+
+        // special handling for sets as well: order the contents, compare as strings
+        if let left = lhs as? Set<AnyHashable>, let right = rhs as? Set<AnyHashable> {
+            let leftSorted = left.map { "\($0)" }.sorted { a, b in a < b }
+            let rightSorted = right.map { "\($0)" }.sorted { a, b in a < b }
+
+            let leftPrintable = leftSorted.joined(separator: ", ")
+            let rightPrintable = rightSorted.joined(separator: ", ")
+
+            // .difference(from:) gives unpleasant results
+            if leftPrintable == rightPrintable {
+                return nil
+            }
+            return "\(prefix).\(name): 📦 <\(leftPrintable)> → <\(rightPrintable)>"
+        }
+
+        // if there are no children, compare lhs and rhs directly
+        if 0 == leftMirror.children.count {
+            if "\(lhs)" == "\(rhs)" {
+                return nil
+            } else {
+                return "\(prefix).\(name): \(lhs) → \(rhs)"
+            }
+        }
+
+        // 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 ?? "",
+                             level: level + 1,
+                             lhs: leftValue,
+                             rhs: rightValue)
+        }).compactMap { $0 }
+
+        if strings.count > 0 {
+            return strings.joined(separator: "\n")
+        }
+        return nil
+    }
 }
 
 // MARK: - Action

Tests/LoggerMiddlewareTests/LoggerMiddlewareTests.swift

@@ -1,11 +1,61 @@
 import XCTest
+import SwiftRex
 @testable import LoggerMiddleware
 
+struct TestState: Equatable {
+    public let a: Substate
+    public let b: [Int]
+    public let c: String
+}
+
+struct Substate: Equatable {
+    public let x: Set<String>
+    public let y: [String: Int]
+    public let z: Bool
+}
+
+struct TestMiddleware: Middleware {
+    func receiveContext(getState: @escaping GetState<TestState>, output: AnyActionHandler<Int>) {
+    }
+
+    func handle(action: Int, from dispatcher: ActionSource, afterReducer: inout AfterReducer) {
+    }
+
+    typealias InputActionType = Int
+    typealias OutputActionType = Int
+    typealias StateType = TestState
+}
+
 final class LoggerMiddlewareTests: XCTestCase {
-    func testExample() {
+
+    func testStateDiff() {
+        // given
+        let beforeState: LoggerMiddleware<TestMiddleware>.StateType = TestState(a: Substate(x: ["SetB", "SetA"],
+                                                                                            y: ["one": 1, "eleven": 11],
+                                                                                            z: true),
+                                                                                b: [0, 1],
+                                                                                c: "Foo")
+        let afterState: LoggerMiddleware<TestMiddleware>.StateType = TestState(a: Substate(x: ["SetB", "SetC"],
+                                                                                           y: ["one": 1, "twelve": 12],
+                                                                                           z: false),
+                                                                                b: [0],
+                                                                                c: "Bar")
+
+        // 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
+                       """
+        XCTAssertEqual(result, expected)
     }
 
     static var allTests = [
-        ("testExample", testExample),
+        ("testStateDiff", testStateDiff),
     ]
 }