Merge pull request #31 from k-kohey/refactor/mutation

Refactor mutation

Author: k-kohey

Sources/Parchment/LoggerBundler.swift

@@ -11,7 +11,7 @@ public final actor LoggerBundler {
     private let buffer: LogBuffer
     private let bufferFlowController: BufferFlowController
 
-    private(set) var transform: Transform
+    private var mutations: [any Mutation] = []
 
     public init(
         components: [any LoggerComponent],
@@ -22,17 +22,15 @@ public final actor LoggerBundler {
         self.components = components
         self.buffer = buffer
         self.bufferFlowController = bufferFlowController
-        transform = mutations.composed()
+        self.mutations = mutations
     }
 
     public func add(component: LoggerComponent) {
         components.append(component)
     }
 
     public func add(mutations: [Mutation]) {
-        transform = [
-            transform, mutations.composed()
-        ].composed()
+        self.mutations += mutations
     }
 
     /// Sends a Log to the retained LoggerComponents.
@@ -53,7 +51,7 @@ public final actor LoggerBundler {
             for logger in await loggers() {
                 let payload = await Payload(
                     destination: logger.id.value,
-                    event: transform(event, logger.id),
+                    event: mutations.transform(event, id: logger.id),
                     timestamp: .init()
                 )
 

Sources/Parchment/Mutation.swift

@@ -31,27 +31,13 @@ public protocol Mutation: Sendable {
     func transform(_: any Loggable, id: LoggerComponentID) -> AnyLoggable
 }
 
-private extension Mutation {
-    var _transform: Transform {
-        {
-            self.transform($0, id: $1)
+extension Array: Mutation where Element == Mutation {
+    public func transform(_ base: Loggable, id: LoggerComponentID) -> AnyLoggable {
+        var result = AnyLoggable(base)
+        for mutation in self {
+            result = mutation.transform(result, id: id)
         }
+        return result
     }
 }
 
-extension Sequence where Element == Mutation {
-    func composed() -> Transform {
-        return map { $0._transform }.composed()
-    }
-}
-
-extension Sequence where Element == Transform {
-    func composed() -> Transform {
-        let base: Transform = { log, _ in AnyLoggable(log) }
-        return reduce(base) { partialResult, transform in
-            {
-                transform(partialResult($0, $1), $1)
-            }
-        }
-    }
-}

Tests/ParchmentDefaultTests/MutationTest.swift Tests/ParchmentDefaultTests/DeviceDataMutationTests.swift

@@ -1,5 +1,5 @@
 //
-//  RegularlyPollingSchedulerTests.swift
+//  DeviceDataMutationTests.swift
 //
 //
 //  Created by k-kohey on 2021/12/06.
@@ -27,16 +27,16 @@ private enum Event: Loggable {
     }
 }
 
-class MutationTests: XCTestCase {
 #if canImport(UIKit)
+class DeviceDataMutationTests: XCTestCase {
     // 的確なテストに直す
     @MainActor func testTransform() async throws {
         let event = Event.hoge
         let mutation: [Mutation] = [DeviceDataMutation(device: .current)]
 
-        let newEvent = await mutation.composed()(event, .init("hoge"))
+        let newEvent = await mutation.transform(event, id: .init("hoge"))
 
         XCTAssertTrue(newEvent.parameters.count > 1)
     }
-#endif
 }
+#endif

Tests/ParchmentTests/MutationTests.swift

@@ -0,0 +1,77 @@
+//
+//  MutationTests.swift
+//
+//
+//  Created by Kohei Kawaguchi on 2023/05/18.
+//
+
+@testable import Parchment
+import XCTest
+
+private struct MutationMock: Mutation, @unchecked Sendable {
+    let _transform: ((Loggable, LoggerComponentID) -> AnyLoggable)?
+
+    func transform(_ l: Loggable, id: LoggerComponentID) -> AnyLoggable {
+        _transform!(l, id)
+    }
+}
+
+final class MutationTests: XCTestCase {
+    func testTransform() async {
+        let mutationA = MutationMock { l, id in
+            AnyLoggable(
+                eventName: l.eventName,
+                parameters: l.parameters.merging(["hoge": 0], uniquingKeysWith: { _, r in
+                    r
+                })
+            )
+        }
+        let mutationB = MutationMock { l, id in
+            AnyLoggable(
+                eventName: l.eventName,
+                parameters: l.parameters.merging(["fuga": 1], uniquingKeysWith: { _, r in
+                    r
+                })
+            )
+        }
+
+
+        let mutations: [any Mutation] = [mutationA, mutationB]
+
+        let r = await mutations.transform(AnyLoggable(eventName: "", parameters: ["foo": 2]), id: .init(""))
+
+        XCTAssertEqual(
+            r.parameters as NSDictionary,
+            ["hoge": 0, "fuga": 1, "foo": 2]
+        )
+    }
+
+    func testTransform_later_is_higher_priority() async {
+        let mutationA = MutationMock { l, id in
+            AnyLoggable(
+                eventName: l.eventName,
+                parameters: l.parameters.merging(["hoge": 0], uniquingKeysWith: { _, r in
+                    r
+                })
+            )
+        }
+        let mutationB = MutationMock { l, id in
+            AnyLoggable(
+                eventName: l.eventName,
+                parameters: l.parameters.merging(["hoge": 1], uniquingKeysWith: { _, r in
+                    r
+                })
+            )
+        }
+
+
+        let mutations: [any Mutation] = [mutationA, mutationB]
+
+        let r = await mutations.transform(AnyLoggable(eventName: "", parameters: ["hoge": ""]), id: .init(""))
+
+        XCTAssertEqual(
+            r.parameters as NSDictionary,
+            ["hoge": 1]
+        )
+    }
+}