Add new functionality to Middleware

Author: Qata

Docs/Getting Started Guide.md

@@ -201,11 +201,9 @@ Let's take a look at a quick example that shows how ReactiveReSwift supports Red
 The simplest example of a middleware, is one that prints all actions to the console. Here's how you can implement it:
 
 ```swift
-let loggingMiddleware = Middleware<State> { getState, dispatch, action in
+let loggingMiddleware = Middleware<State>().sideEffect { getState, dispatch, action in
     // perform middleware logic
     print(action)
-    // call next middleware
-    return action
 }
 ```
 You can define which middleware you would like to use when creating your store:
@@ -219,3 +217,12 @@ Store(
 )
 ```
 The actions will pass through the middleware in the order in which they are arranged in the `Middleware` initializer, however ideally middleware should not make any assumptions about when exactly it is called.
+
+`Middleware` supports multiple different operations.
+
+In no particular order, some of the more important operations are:
+
+- `sideEffect(_:)` Gives access to the `dispatch(_:)` function. Does not return, to ensure that only side effects reside inside.
+- `filter(_:)` If the predicate function passed to filter passes, keep the action, otherwise discard the action.
+- `map(_:)` Apply a transformative function to the action.
+- `flatMap(_:)` Essentially a `map` that can also filter out the action by returning `nil`

ReactiveReSwift/CoreTypes/Middleware.swift

@@ -16,12 +16,17 @@ public struct Middleware<State: StateType> {
 
     private let transform: (GetState, DispatchFunction, Action) -> Action?
 
+    /// Create a blank slate Middleware.
+    public init() {
+        self.transform = { $2 }
+    }
+
     /**
      Initialises the middleware with a transformative function.
 
      - parameter transform: The function that will be able to modify passed actions.
      */
-    public init(_ transform: @escaping (GetState, DispatchFunction, Action) -> Action?) {
+    internal init(_ transform: @escaping (GetState, DispatchFunction, Action) -> Action?) {
         self.transform = transform
     }
 
@@ -40,33 +45,41 @@ public struct Middleware<State: StateType> {
         return transform(state, dispatch, argument)
     }
 
+    /// Safe encapsulation of side effects guaranteed not to affect the action being passed through the middleware.
+    public func sideEffect(_ effect: @escaping (GetState, DispatchFunction, Action) -> Void) -> Middleware<State> {
+        return Middleware<State> {
+            guard let action = self.transform($0, $1, $2) else { return nil }
+            effect($0, $1, action)
+            return action
+        }
+    }
+
     /// Concatenates the transform function of the passed `Middleware` onto the callee's transform.
     public func concat(_ other: Middleware<State>) -> Middleware<State> {
-        return flatMap(other.transform)
+        return Middleware<State> {
+            guard let action = self.transform($0, $1, $2) else { return nil }
+            return other.transform($0, $1, action)
+        }
     }
 
     /// Concatenates the transform function onto the callee's transform.
-    public func map(_ transform: @escaping (GetState, DispatchFunction, Action) -> Action) -> Middleware<State> {
+    public func map(_ transform: @escaping (GetState, Action) -> Action) -> Middleware<State> {
         return flatMap(transform)
     }
 
     /// Concatenates the transform function onto the callee's transform.
-    public func flatMap(_ transform: @escaping (GetState, DispatchFunction, Action) -> Action?) -> Middleware<State> {
+    public func flatMap(_ transform: @escaping (GetState, Action) -> Action?) -> Middleware<State> {
         return Middleware<State> {
-            if let action = self.transform($0, $1, $2) {
-                return transform($0, $1, action)
-            }
-            return nil
+            guard let action = self.transform($0, $1, $2) else { return nil }
+            return transform($0, action)
         }
     }
 
     /// Drop the Action if `predicate(action) != true`.
-    public func filter(_ predicate: @escaping (Action) -> Bool) -> Middleware<State> {
+    public func filter(_ predicate: @escaping (GetState, Action) -> Bool) -> Middleware<State> {
         return Middleware<State> {
-            if let action = self.transform($0, $1, $2), predicate(action) {
-                return action
-            }
-            return nil
+            guard let action = self.transform($0, $1, $2), predicate($0, action) else { return nil }
+            return action
         }
     }
 }

ReactiveReSwiftTests/MiddlewareFakes.swift

@@ -8,36 +8,36 @@
 
 import ReactiveReSwift
 
-let firstMiddleware = Middleware<TestStringAppState> { state, dispatch, action in
+let firstMiddleware = Middleware<TestStringAppState>().map { state, action in
     if let action = action as? SetValueStringAction {
         return SetValueStringAction(action.value + " First Middleware")
     }
     return action
 }
 
-let secondMiddleware = Middleware<TestStringAppState> { state, dispatch, action in
+let secondMiddleware = Middleware<TestStringAppState>().map { state, action in
     if let action = action as? SetValueStringAction {
         return SetValueStringAction(action.value + " Second Middleware")
     }
     return action
 }
 
-let dispatchingMiddleware = Middleware<TestStringAppState> { state, dispatch, action in
+let dispatchingMiddleware = Middleware<TestStringAppState>().sideEffect { state, dispatch, action in
     if let action = action as? SetValueAction {
         dispatch(SetValueStringAction("\(action.value)"))
-        return nil
     }
-    return action
+}.filter { _, action in
+    !(action is SetValueAction)
 }
 
-let stateAccessingMiddleware = Middleware<TestStringAppState> { state, dispatch, action in
+let stateAccessingMiddleware = Middleware<TestStringAppState>().sideEffect { state, dispatch, action in
     if let action = action as? SetValueStringAction {
         //Avoid endless recursion by checking if we've exactly this action
         if state().testValue == "OK" && action.value != "Not OK" {
             dispatch(SetValueStringAction("Not OK"))
-            //Swallow the action
-            return nil
         }
     }
-    return action
+}.filter { state, action in
+    print("Swallowing action \(action)")
+    return (action as? SetValueStringAction)?.value == "Not OK"
 }

ReactiveReSwiftTests/Observable/StoreMiddlewareTests.swift

@@ -67,14 +67,27 @@ class StoreMiddlewareTests: XCTestCase {
      it middleware should not be executed if the previous middleware returned nil
      */
     func testMiddlewareSkipsReducersWhenPassedNil() {
-        let filteringMiddleware = Middleware<TestStringAppState> { _, _, _ in nil }.map { _, _, action in XCTFail(); return action }
+        let filteringMiddleware1 = Middleware<TestStringAppState>().filter({ _, _ in false }).sideEffect { _, _, _ in XCTFail() }
+        let filteringMiddleware2 = Middleware<TestStringAppState>().filter({ _, _ in false }).flatMap { _, _ in XCTFail(); return nil }
 
         let property = ObservableProperty(TestStringAppState(testValue: "OK"))
-        let store = Store(reducer: testValueStringReducer,
+
+        var store = Store(reducer: testValueStringReducer,
                           stateType: TestStringAppState.self,
                           observable: property,
-                          middleware: filteringMiddleware)
+                          middleware: Middleware(filteringMiddleware1, filteringMiddleware2))
+        store.dispatch(SetValueStringAction("Action That Won't Go Through"))
+
+        store = Store(reducer: testValueStringReducer,
+                           stateType: TestStringAppState.self,
+                           observable: property,
+                           middleware: filteringMiddleware1)
+        store.dispatch(SetValueStringAction("Action That Won't Go Through"))
 
+        store = Store(reducer: testValueStringReducer,
+                      stateType: TestStringAppState.self,
+                      observable: property,
+                      middleware: filteringMiddleware2)
         store.dispatch(SetValueStringAction("Action That Won't Go Through"))
     }
 }