Merge pull request #4 from SwiftRex/recursiveDiffFilter

Recursive diff: add simple filter option

Author: luizmb

Sources/LoggerMiddleware/LoggerMiddleware.swift

@@ -125,7 +125,7 @@ extension LoggerMiddleware {
     public enum StateDiffTransform {
         case diff(linesOfContext: Int = 2, prefixLines: String = "🏛 ")
         case newStateOnly
-        case recursive(prefixLines: String = "🏛 ", stateName: String)
+        case recursive(prefixLines: String = "🏛 ", stateName: String, filters: [String]? = nil)
         case custom((StateType?, StateType) -> String?)
 
         func transform(oldState: StateType?, newState: StateType) -> String? {
@@ -137,20 +137,20 @@ 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 .recursive(prefixLines, stateName, filters):
+                return recursiveDiff(prefixLines: prefixLines, stateName: stateName, filters: filters, 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? {
+    public static func recursiveDiff(prefixLines: String, stateName: String, filters: [String]? = nil, 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)
+        diff(prefix: prefixLines, name: stateName, filters: filters, lhs: before, rhs: after)?.trimmingCharacters(in: .whitespacesAndNewlines)
     }
 
-    private static func diff<A>(prefix: String, name: String, level: Int = 0, lhs: A?, rhs: A?) -> String? {
+    private static func diff<A>(prefix: String, name: String, level: Int = 0, filters: [String]? = nil, lhs: A?, rhs: A?) -> String? {
 
         guard let rightHandSide = rhs, let leftHandSide = lhs else {
             if let rightHandSide = rhs {
@@ -215,9 +215,17 @@ extension LoggerMiddleware {
             return Self.diff(prefix: "\(prefix)\(toDotOrNotToDot)\(name)",
                              name: leftChild.label ?? "#", // label might be missing for items in collections, # represents a collection element
                              level: level + 1,
+                             filters: filters,
                              lhs: leftChild.value,
                              rhs: rightMirror.children.first(where: { $0.label == leftChild.label })?.value)
-        }).compactMap { $0 }
+        })
+        .compactMap { $0 }
+        .filter { (diffLine: String) -> Bool in
+            // filter diffLine if it contains a filterString
+            false == (filters ?? []).contains(where: { filterString in
+                diffLine.contains(filterString)
+            })
+        }
 
         if strings.count > 0 {
             return strings.joined(separator: "\n")

Tests/LoggerMiddlewareTests/LoggerMiddlewareTests.swift

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