Revert Store to use MutableProperty, revert to previous

implementation of `send` to avoid problem with nested sending
in ReactiveSwift Signal.
Disabled `testPublisherOwnsViewStore` test.

Author: mluisbrown

Sources/ComposableArchitecture/Store.swift

@@ -114,18 +114,15 @@ import ReactiveSwift
 /// See also: ``ViewStore`` to understand how one observes changes to the state in a ``Store`` and
 /// sends user actions.
 public final class Store<State, Action> {
-  private(set) var state: State {
-    didSet {
-      statePipe.input.send(value: state)
-    }
-  }
-  private let statePipe = Signal<State, Never>.pipe()
+  @MutableProperty
+  private(set) var state: State
   internal var producer: Effect<State, Never> {
-    Property<State>(initial: self.state, then: self.statePipe.output.producer).producer
+    self.$state.producer
   }
 
   private var isSending = false
   private let reducer: (inout State, Action) -> Effect<Action, Never>
+  private var synchronousActionsToSend: [Action] = []
   private var bufferedActions: [Action] = []
   internal var effectDisposables: [UUID: Disposable] = [:]
   internal var parentDisposable: Disposable?
@@ -373,41 +370,50 @@ public final class Store<State, Action> {
   }
 
   func send(_ action: Action) {
-    self.bufferedActions.append(action)
-    guard !self.isSending else { return }
-
-    self.isSending = true
-    var currentState = self.state
-    defer {
-      self.isSending = false
-      self.state = currentState
+    if !self.isSending {
+      self.synchronousActionsToSend.append(action)
+    } else {
+      self.bufferedActions.append(action)
+      return
     }
 
-    while !self.bufferedActions.isEmpty {
-      let action = self.bufferedActions.removeFirst()
-      let effect = self.reducer(&currentState, action)
+    while !self.synchronousActionsToSend.isEmpty || !self.bufferedActions.isEmpty {
+      let action =
+        !self.synchronousActionsToSend.isEmpty
+        ? self.synchronousActionsToSend.removeFirst()
+        : self.bufferedActions.removeFirst()
+
+      self.isSending = true
+      let effect = self.reducer(&self.state, action)
+      self.isSending = false
 
       var didComplete = false
-      let uuid = UUID()
+      let effectID = UUID()
 
+      var isProcessingEffects = true
       let observer = Signal<Action, Never>.Observer(
         value: { [weak self] action in
-          self?.send(action)
+          if isProcessingEffects {
+            self?.synchronousActionsToSend.append(action)
+          } else {
+            self?.send(action)
+          }
         },
+        failed: .none,
         completed: { [weak self] in
           didComplete = true
-          self?.effectDisposables.removeValue(forKey: uuid)?.dispose()
+          self?.effectDisposables.removeValue(forKey: effectID)?.dispose()
         },
         interrupted: { [weak self] in
           didComplete = true
-          self?.effectDisposables.removeValue(forKey: uuid)?.dispose()
+          self?.effectDisposables.removeValue(forKey: effectID)?.dispose()
         }
       )
-
       let effectDisposable = effect.start(observer)
+      isProcessingEffects = false
 
       if !didComplete {
-        self.effectDisposables[uuid] = effectDisposable
+        self.effectDisposables[effectID] = effectDisposable
       } else {
         effectDisposable.dispose()
       }

Sources/ComposableArchitecture/ViewStore.swift

@@ -298,9 +298,6 @@ public struct StoreProducer<State>: SignalProducerConvertible {
   fileprivate init<Action>(viewStore: ViewStore<State, Action>) {
     self.viewStore = viewStore
     self.upstream = Property<State>(initial: viewStore.state, then: viewStore.statePipe.output).producer
-//      .on(completed: { [viewStore = self.viewStore] in
-//        _ = viewStore
-//      })
   }
 
   private init(

Tests/ComposableArchitectureTests/StoreTests.swift

@@ -447,12 +447,11 @@ final class StoreTests: XCTestCase {
 
     viewStore.send(0)
 
-    XCTAssertEqual(emissions, [0, 3])
+    XCTAssertEqual(emissions, [0, 1, 2, 3])
   }
 
-// This test commented out as it falls foul of ReactiveSwift's
-// `Signal` not allowing nested sends 😢
-
+  // This test commented out as it falls foul of ReactiveSwift's
+  // `Signal` not allowing nested sends 😢
   func disabled_testBufferedActionProcessing() {
     struct ChildState: Equatable {
       var count: Int?

Tests/ComposableArchitectureTests/ViewStoreTests.swift

@@ -125,21 +125,24 @@ final class ViewStoreTests: XCTestCase {
     }
   #endif
 
-//  func testPublisherOwnsViewStore() {
-//    let reducer = Reducer<Int, Void, Void> { count, _, _ in
-//      count += 1
-//      return .none
-//    }
-//    let store = Store(initialState: 0, reducer: reducer, environment: ())
-//
-//    var results: [Int] = []
-//    ViewStore(store)
-//      .produced.producer.logEvents(identifier: "test")
-//      .startWithValues { results.append($0) }
-//
-//    ViewStore(store).send(())
-//    XCTAssertEqual(results, [0, 1])
-//  }
+  // disabled as the fix for this would be onerous with
+  // ReactiveSwift, forcing explicit disposable of any use of
+  // `ViewStore.produced.producer`
+  func disabled_testPublisherOwnsViewStore() {
+    let reducer = Reducer<Int, Void, Void> { count, _, _ in
+      count += 1
+      return .none
+    }
+    let store = Store(initialState: 0, reducer: reducer, environment: ())
+
+    var results: [Int] = []
+    ViewStore(store)
+      .produced.producer
+      .startWithValues { results.append($0) }
+
+    ViewStore(store).send(())
+    XCTAssertEqual(results, [0, 1])
+  }
 }
 
 private struct State: Equatable {