From c2e26785cc58cd30e04954e18c8df99813348a85 Mon Sep 17 00:00:00 2001 From: Luiz Rodrigo Martins Barbosa Date: Tue, 23 Nov 2021 14:52:33 +0100 Subject: [PATCH] Update SwiftRex to use Middleware IO --- Package.resolved | 4 +- Package.swift | 2 +- .../LoggerMiddleware/LoggerMiddleware.swift | 52 ++++------ .../LoggerMiddlewareTests.swift | 95 +++++++++---------- 4 files changed, 70 insertions(+), 83 deletions(-) diff --git a/Package.resolved b/Package.resolved index be425c3..d0cf8a4 100644 --- a/Package.resolved +++ b/Package.resolved @@ -24,8 +24,8 @@ "repositoryURL": "https://github.com/SwiftRex/SwiftRex.git", "state": { "branch": null, - "revision": "660ba8ec5a79bc30f152955f9d8ea0b69ba6b466", - "version": "0.8.6" + "revision": "c51328031f943d8f055dbcb738bc66915825b8cc", + "version": "0.8.8" } } ] diff --git a/Package.swift b/Package.swift index 0a9a446..e2a3f9e 100644 --- a/Package.swift +++ b/Package.swift @@ -12,7 +12,7 @@ let package = Package( .library(name: "LoggerMiddleware", targets: ["LoggerMiddleware"]) ], dependencies: [ - .package(url: "https://github.com/SwiftRex/SwiftRex.git", .upToNextMajor(from: "0.8.6")) + .package(url: "https://github.com/SwiftRex/SwiftRex.git", .upToNextMajor(from: "0.8.8")) ], targets: [ .target( diff --git a/Sources/LoggerMiddleware/LoggerMiddleware.swift b/Sources/LoggerMiddleware/LoggerMiddleware.swift index 1640bd6..38f2f95 100644 --- a/Sources/LoggerMiddleware/LoggerMiddleware.swift +++ b/Sources/LoggerMiddleware/LoggerMiddleware.swift @@ -2,32 +2,31 @@ import Foundation import os.log import SwiftRex -extension Middleware where StateType: Equatable { +extension MiddlewareProtocol where StateType: Equatable { public func logger( - actionTransform: LoggerMiddleware.ActionTransform = .default(), - actionPrinter: LoggerMiddleware.ActionLogger = .osLog, + actionTransform: LoggerMiddleware.ActionTransform = .default(), + actionPrinter: LoggerMiddleware.ActionLogger = .osLog, actionFilter: @escaping (InputActionType) -> Bool = { _ in true }, - stateDiffTransform: LoggerMiddleware.StateDiffTransform = .diff(), - stateDiffPrinter: LoggerMiddleware.StateLogger = .osLog, + stateDiffTransform: LoggerMiddleware.StateDiffTransform = .diff(), + stateDiffPrinter: LoggerMiddleware.StateLogger = .osLog, queue: DispatchQueue = .main - ) -> LoggerMiddleware { + ) -> ComposedMiddleware { LoggerMiddleware( - self, actionTransform: actionTransform, actionPrinter: actionPrinter, actionFilter: actionFilter, stateDiffTransform: stateDiffTransform, stateDiffPrinter: stateDiffPrinter, queue: queue - ) + ).lift(outputAction: { (_: Never) -> OutputActionType in }) <> self } } -public final class LoggerMiddleware: Middleware where M.StateType: Equatable { - public typealias InputActionType = M.InputActionType - public typealias OutputActionType = M.OutputActionType - public typealias StateType = M.StateType - private let middleware: M +public final class LoggerMiddleware: MiddlewareProtocol { + public typealias InputActionType = Action + public typealias OutputActionType = Never + public typealias StateType = State + private let queue: DispatchQueue private var getState: GetState? private let actionTransform: ActionTransform @@ -37,7 +36,6 @@ public final class LoggerMiddleware: Middleware where M.StateType private let stateDiffPrinter: StateLogger init( - _ middleware: M, actionTransform: ActionTransform, actionPrinter: ActionLogger, actionFilter: @escaping (InputActionType) -> Bool = { _ in true }, @@ -45,7 +43,6 @@ public final class LoggerMiddleware: Middleware where M.StateType stateDiffPrinter: StateLogger, queue: DispatchQueue ) { - self.middleware = middleware self.actionTransform = actionTransform self.actionPrinter = actionPrinter self.actionFilter = actionFilter @@ -54,19 +51,11 @@ public final class LoggerMiddleware: Middleware where M.StateType self.queue = queue } - public func receiveContext(getState: @escaping GetState, output: AnyActionHandler) { - self.getState = getState - middleware.receiveContext(getState: getState, output: output) - } - - public func handle(action: InputActionType, from dispatcher: ActionSource, afterReducer: inout AfterReducer) { - guard actionFilter(action) else { return } + public func handle(action: Action, from dispatcher: ActionSource, state: @escaping GetState) -> IO { + guard actionFilter(action) else { return .pure() } let stateBefore = getState?() - var innerAfterReducer = AfterReducer.doNothing() - - middleware.handle(action: action, from: dispatcher, afterReducer: &innerAfterReducer) - afterReducer = innerAfterReducer <> .do { [weak self] in + return IO { [weak self] _ in guard let self = self, let stateAfter = self.getState?() else { return } @@ -83,15 +72,14 @@ public final class LoggerMiddleware: Middleware where M.StateType extension LoggerMiddleware { public static func `default`( - actionTransform: LoggerMiddleware>.ActionTransform = .default(), - actionPrinter: LoggerMiddleware>.ActionLogger = .osLog, + actionTransform: LoggerMiddleware.ActionTransform = .default(), + actionPrinter: LoggerMiddleware.ActionLogger = .osLog, actionFilter: @escaping (InputActionType) -> Bool = { _ in true }, - stateDiffTransform: LoggerMiddleware>.StateDiffTransform = .diff(), - stateDiffPrinter: LoggerMiddleware>.StateLogger = .osLog, + stateDiffTransform: LoggerMiddleware.StateDiffTransform = .diff(), + stateDiffPrinter: LoggerMiddleware.StateLogger = .osLog, queue: DispatchQueue = .main - ) -> LoggerMiddleware> { + ) -> LoggerMiddleware { .init( - IdentityMiddleware(), actionTransform: actionTransform, actionPrinter: actionPrinter, actionFilter: actionFilter, diff --git a/Tests/LoggerMiddlewareTests/LoggerMiddlewareTests.swift b/Tests/LoggerMiddlewareTests/LoggerMiddlewareTests.swift index 575aa59..843f402 100644 --- a/Tests/LoggerMiddlewareTests/LoggerMiddlewareTests.swift +++ b/Tests/LoggerMiddlewareTests/LoggerMiddlewareTests.swift @@ -17,42 +17,41 @@ struct Substate: Equatable { public let z: Bool } -struct TestMiddleware: Middleware { - func receiveContext(getState: @escaping GetState, output: AnyActionHandler) { +struct TestMiddleware: MiddlewareProtocol { + + func handle(action: Int, from dispatcher: ActionSource, state: @escaping GetState) -> IO { + .pure() } - - func handle(action: Int, from dispatcher: ActionSource, afterReducer: inout AfterReducer) { - } - + typealias InputActionType = Int typealias OutputActionType = Int typealias StateType = TestState } final class LoggerMiddlewareTests: XCTestCase { - + func testStateDiff() { // given - let beforeState: LoggerMiddleware.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.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: "🥚") - + let beforeState = 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 = 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.recursiveDiff(prefixLines: "🏛", stateName: "TestState", before: beforeState, after: afterState) - + let result: String? = LoggerMiddleware.recursiveDiff(prefixLines: "🏛", stateName: "TestState", before: beforeState, after: afterState) + // then let expected = """ 🏛 TestState.a.x: 📦 → @@ -66,29 +65,29 @@ final class LoggerMiddlewareTests: XCTestCase { """ XCTAssertEqual(result, expected) } - - + + func testStateDiffWithFilters() { // given - let beforeState: LoggerMiddleware.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.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: "🥚") - + let beforeState = 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 = 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.recursiveDiff(prefixLines: "🏛", + let result: String? = LoggerMiddleware.recursiveDiff(prefixLines: "🏛", stateName: "TestState", filters: [ " TestState.a.y2", @@ -96,7 +95,7 @@ final class LoggerMiddlewareTests: XCTestCase { ], before: beforeState, after: afterState) - + // then let expected = """ 🏛 TestState.a.x: 📦 → @@ -108,7 +107,7 @@ final class LoggerMiddlewareTests: XCTestCase { """ XCTAssertEqual(result, expected) } - + static var allTests = [ ("testStateDiff", testStateDiff), ]