Add collect argument to dispatch

Qata · Qata · commit 215c0f20a655 · 2021-07-23T13:10:32.000+10:00
diff --git a/Sources/RecombinePackage/Store/BaseStore.swift b/Sources/RecombinePackage/Store/BaseStore.swift
@@ -123,11 +123,15 @@ public class BaseStore<State: Equatable, RawAction, RefinedAction>: StoreProtoco
         _actionsPairedWithState.eraseToAnyPublisher()
     }
 
-    open func dispatch<S: Sequence>(serially: Bool = false, actions: S) where S.Element == Action {
+    open func dispatch<S: Sequence>(
+        serially: Bool = false,
+        collect: Bool = false,
+        actions: S
+    ) where S.Element == Action {
         let maxPublishers: Subscribers.Demand = serially ? .max(1) : .unlimited
         weak var `self` = self
 
-        func reduce(actions: Action) -> AnyPublisher<[RefinedAction], Never> {
+        func recurse(actions: Action) -> AnyPublisher<[RefinedAction], Never> {
             switch actions {
             case let .raw(actions):
                 self?._rawActions.send(actions)
@@ -137,20 +141,33 @@ public class BaseStore<State: Equatable, RawAction, RefinedAction>: StoreProtoco
                             $0.thunk.transform($0.$state.first(), action)
                         }
                     }
-                    .flatMap(maxPublishers: maxPublishers, reduce(actions:))
+                    .flatMap(maxPublishers: maxPublishers, recurse(actions:))
                     .eraseToAnyPublisher()
             case let .refined(actions):
                 return Just(actions).eraseToAnyPublisher()
             }
         }
 
-        actions
-            .publisher
-            .flatMap(maxPublishers: maxPublishers, reduce(actions:))
-            .sink {
-                self?._preMiddlewareRefinedActions.send($0)
-            }
-            .store(in: &cancellables)
+        let recursed = actions.publisher.flatMap(
+            maxPublishers: maxPublishers,
+            recurse(actions:)
+        )
+
+        if collect {
+            recursed
+                .collect()
+                .map { $0.flatMap { $0 } }
+                .sink {
+                    self?._preMiddlewareRefinedActions.send($0)
+                }
+                .store(in: &cancellables)
+        } else {
+            recursed
+                .sink {
+                    self?._preMiddlewareRefinedActions.send($0)
+                }
+                .store(in: &cancellables)
+        }
     }
 
     open func injectBypassingMiddleware<S: Sequence>(actions: S) where S.Element == RefinedAction {
diff --git a/Sources/RecombinePackage/Store/StoreProtocol.swift b/Sources/RecombinePackage/Store/StoreProtocol.swift
@@ -14,7 +14,7 @@ public protocol StoreProtocol: ObservableObject, Subscriber {
     var underlying: Underlying { get }
     var stateLens: (BaseState) -> SubState { get }
     var actionPromotion: (SubRefinedAction) -> BaseRefinedAction { get }
-    func dispatch<S: Sequence>(serially: Bool, actions: S) where S.Element == Action
+    func dispatch<S: Sequence>(serially: Bool, collect: Bool, actions: S) where S.Element == Action
     func eraseToAnyStore() -> AnyStore<BaseState, SubState, RawAction, BaseRefinedAction, SubRefinedAction>
 }
 
@@ -173,9 +173,14 @@ public extension StoreProtocol {
 }
 
 public extension StoreProtocol {
-    func dispatch<S: Sequence>(serially: Bool = false, actions: S) where S.Element == Action {
+    func dispatch<S: Sequence>(
+        serially: Bool = false,
+        collect: Bool = false,
+        actions: S
+    ) where S.Element == Action {
         underlying.dispatch(
             serially: serially,
+            collect: collect,
             actions: actions.map {
                 switch $0 {
                 case let .refined(actions):
@@ -187,16 +192,28 @@ public extension StoreProtocol {
         )
     }
 
-    func dispatch(serially: Bool = false, actions: Action...) {
-        dispatch(serially: serially, actions: actions)
+    func dispatch(
+        serially: Bool = false,
+        collect: Bool = false,
+        actions: Action...
+    ) {
+        dispatch(serially: serially, collect: collect, actions: actions)
     }
 
-    func dispatch<S: Sequence>(serially: Bool = false, raw actions: S) where S.Element == RawAction {
-        dispatch(serially: serially, actions: .raw(.init(actions)))
+    func dispatch<S: Sequence>(
+        serially: Bool = false,
+        collect: Bool = false,
+        raw actions: S
+    ) where S.Element == RawAction {
+        dispatch(serially: serially, collect: collect, actions: .raw(.init(actions)))
     }
 
-    func dispatch(serially: Bool = false, raw actions: RawAction...) {
-        dispatch(serially: serially, actions: .raw(actions))
+    func dispatch(
+        serially: Bool = false,
+        collect: Bool = false,
+        raw actions: RawAction...
+    ) {
+        dispatch(serially: serially, collect: collect, actions: .raw(actions))
     }
 
     func dispatch<S: Sequence>(refined actions: S) where S.Element == SubRefinedAction {
diff --git a/Tests/RecombineTests/Extensions.swift b/Tests/RecombineTests/Extensions.swift
@@ -25,8 +25,7 @@ extension XCTestCase {
         _ store: Store,
         dropFirst: Int = 0,
         timeout: TimeInterval = 1,
-        serially: Bool = false,
-        actions: [ActionStrata<[Store.RawAction], [Store.SubRefinedAction]>],
+        access: (Store) -> Void,
         keyPath: KeyPath<Store.SubState, State>,
         value: State
     ) throws {
@@ -35,12 +34,32 @@ extension XCTestCase {
                 store,
                 dropFirst: dropFirst,
                 timeout: timeout,
-                access: { $0.dispatch(serially: serially, actions: actions) }
+                access: access
             )?[keyPath: keyPath],
             value
         )
     }
 
+    func nextEquals<Store: StoreProtocol, State: Equatable>(
+        _ store: Store,
+        dropFirst: Int = 0,
+        timeout: TimeInterval = 1,
+        serially: Bool = false,
+        collect: Bool = false,
+        actions: [ActionStrata<[Store.RawAction], [Store.SubRefinedAction]>],
+        keyPath: KeyPath<Store.SubState, State>,
+        value: State
+    ) throws {
+        try nextEquals(
+            store,
+            dropFirst: dropFirst,
+            timeout: timeout,
+            access: { $0.dispatch(serially: serially, collect: collect, actions: actions) },
+            keyPath: keyPath,
+            value: value
+        )
+    }
+
     func prefix<Store: StoreProtocol>(
         _ store: Store,
         count: Int,
@@ -57,6 +76,7 @@ extension XCTestCase {
         count: Int,
         timeout: TimeInterval = 1,
         serially: Bool = false,
+        collect: Bool = false,
         actions: [ActionStrata<[Store.RawAction], [Store.SubRefinedAction]>],
         keyPath: KeyPath<Store.SubState, State>,
         values: [State]
@@ -66,7 +86,7 @@ extension XCTestCase {
                 store,
                 count: count,
                 timeout: timeout,
-                access: { $0.dispatch(serially: serially, actions: actions) }
+                access: { $0.dispatch(serially: serially, collect: collect, actions: actions) }
             ).map { $0[keyPath: keyPath] },
             values
         )
diff --git a/Tests/RecombineTests/StoreDispatchTests.swift b/Tests/RecombineTests/StoreDispatchTests.swift
@@ -6,60 +6,75 @@ import XCTest
 private typealias StoreTestType = BaseStore<TestFakes.IntTest.State, TestFakes.SetAction, TestFakes.SetAction>
 
 class ObservableStoreDispatchTests: XCTestCase {
-    fileprivate var store: StoreTestType!
-    var reducer: MutatingReducer<TestFakes.IntTest.State, TestFakes.SetAction>!
+    enum RawAction: Equatable {
+        case addTwice(String)
+        case addThrice(String)
+    }
+
+    let thunk = Thunk<String, RawAction, String> { _, action -> AnyPublisher
+        <ActionStrata<[RawAction], [String]>, Never> in
+        switch action {
+        case let .addTwice(value):
+            return Just(value)
+                .append(
+                    Just(value)
+                        .delay(for: .seconds(0.1), scheduler: DispatchQueue.main)
+                )
+                .map { .refined($0) }
+                .eraseToAnyPublisher()
+        case let .addThrice(value):
+            return Just(.raw(.addTwice(value)))
+                .append(
+                    Just(.refined(value))
+                        .delay(for: .seconds(0.1), scheduler: DispatchQueue.main)
+                )
+                .eraseToAnyPublisher()
+        }
+    }
 
-    override func setUp() {
-        super.setUp()
-        reducer = TestFakes.IntTest.reducer
+    let reducer: MutatingReducer<String, String> = .init { state, action in
+        state += action
     }
 
     /**
      it subscribes to the property we pass in and dispatches any new values
      */
-    func testLiftingWorksAsExpected() {
-        let subject = PassthroughSubject<StoreTestType.Action, Never>()
-        store = BaseStore(state: TestFakes.IntTest.State(), reducer: reducer, middleware: .init(), publishOn: ImmediateScheduler.shared)
-        let recorder = store.recorder
+    func testLiftingWorksAsExpected() throws {
+        let store = BaseStore(
+            state: "",
+            reducer: reducer,
+            thunk: thunk,
+            publishOn: ImmediateScheduler.shared
+        )
 
-        subject.subscribe(store)
-        subject.send(.refined(.int(20)))
+        let subject = PassthroughSubject<ActionStrata<[RawAction], [String]>, Never>()
+        let rawActionsRecorder = store.rawActions.record()
+        let refinedActionsRecorder = store.postMiddlewareRefinedActions.record()
+
+        try nextEquals(
+            store,
+            dropFirst: 2,
+            access: {
+                subject.subscribe($0)
+                subject.send(.raw(.addThrice("1")))
+            },
+            keyPath: \.self,
+            value: "111"
+        )
+
+        let rawExpectation: [RawAction] = [.addThrice("1"), .addTwice("1")]
+        XCTAssertEqual(
+            try wait(for: rawActionsRecorder.prefix(2), timeout: 10),
+            rawExpectation.map { [$0] }
+        )
 
         XCTAssertEqual(
-            try wait(for: recorder.next(), timeout: 1).value,
-            20
+            try wait(for: refinedActionsRecorder.prefix(3), timeout: 10),
+            "111".map { [String($0)] }
         )
     }
 
     func testSerialDispatch() throws {
-        enum RawAction: Equatable {
-            case addTwice(String)
-            case addThrice(String)
-        }
-
-        let thunk = Thunk<String, RawAction, String> { _, action -> AnyPublisher
-            <ActionStrata<[RawAction], [String]>, Never> in
-            switch action {
-            case let .addTwice(value):
-                return Just(value)
-                    .append(
-                        Just(value)
-                            .delay(for: .seconds(0.1), scheduler: DispatchQueue.main)
-                    )
-                    .map { .refined($0) }
-                    .eraseToAnyPublisher()
-            case let .addThrice(value):
-                return Just(.raw(.addTwice(value)))
-                    .append(
-                        Just(.refined(value))
-                            .delay(for: .seconds(0.1), scheduler: DispatchQueue.main)
-                    )
-                    .eraseToAnyPublisher()
-            }
-        }
-        let reducer: MutatingReducer<String, String> = .init { state, action in
-            state += action
-        }
         let store = BaseStore(
             state: "",
             reducer: reducer,
@@ -108,4 +123,45 @@ class ObservableStoreDispatchTests: XCTestCase {
             refinedExpectation
         )
     }
+
+    func testSerialDispatchWithCollect() throws {
+        let store = BaseStore(
+            state: "",
+            reducer: reducer,
+            thunk: thunk,
+            publishOn: ImmediateScheduler.shared
+        )
+
+        let rawActionsRecorder = store.rawActions.record()
+        let refinedActionsRecorder = store.postMiddlewareRefinedActions.record()
+
+        let value = "5500666221"
+
+        try nextEquals(
+            store,
+            timeout: 10,
+            serially: true,
+            collect: true,
+            actions: [
+                .raw(.addTwice("5")),
+                .refined(["0", "0"]),
+                .raw(.addThrice("6")),
+                .raw(.addTwice("2")),
+                .refined("1"),
+            ],
+            keyPath: \.self,
+            value: "5500666221"
+        )
+
+        let rawExpectation: [RawAction] = [.addTwice("5"), .addThrice("6"), .addTwice("6"), .addTwice("2")]
+        XCTAssertEqual(
+            try wait(for: rawActionsRecorder.prefix(rawExpectation.count), timeout: 10).flatMap { $0 },
+            rawExpectation
+        )
+
+        XCTAssertEqual(
+            try wait(for: refinedActionsRecorder.next(), timeout: 10),
+            value.map { String($0) }
+        )
+    }
 }
