Merge pull request #13 from trading-point/michael/iflet

Fix issues with ifLet sending "else" values too often.

Author: mluisbrown

Sources/ComposableArchitecture/UIKit/IfLetUIKit.swift

@@ -1,4 +1,3 @@
-import Combine
 import ReactiveSwift
 
 extension Store {
@@ -43,16 +42,28 @@ extension Store {
     then unwrap: @escaping (Store<Wrapped, Action>) -> Void,
     else: @escaping () -> Void
   ) -> Disposable where State == Wrapped? {
-    self
+    let elseDisposable = self
+      .scope(
+        state: { state -> Effect<Wrapped?, Never> in
+          state
+            .skipRepeats { ($0 != nil) == ($1 != nil) }
+        }
+      )
+      .startWithValues { store in
+        if store.$state.value == nil { `else`() }
+      }
+
+    let unwrapDisposable = self
       .scope(
         state: { state -> Effect<Wrapped, Never> in
           state
             .skipRepeats { ($0 != nil) == ($1 != nil) }
-            .on(value: { if $0 == nil { `else`() } })
             .compactMap { $0 }
         }
       )
       .startWithValues(unwrap)
+
+    return CompositeDisposable([elseDisposable, unwrapDisposable])
   }
 
   /// An overload of `ifLet(then:else:)` for the times that you do not want to handle the `else`

Tests/ComposableArchitectureTests/StoreTests.swift

@@ -188,4 +188,112 @@ final class StoreTests: XCTestCase {
     store.send(.incr)
     XCTAssertEqual(ViewStore(store).state, 100_000)
   }
+
+  func testPublisherScope() {
+    let appReducer = Reducer<Int, Bool, Void> { state, action, _ in
+      state += action ? 1 : 0
+      return .none
+    }
+
+    let parentStore = Store(initialState: 0, reducer: appReducer, environment: ())
+
+    var outputs: [Int] = []
+
+    parentStore
+      .scope { $0.skipRepeats() }
+      .startWithValues { outputs.append($0.$state.value) }
+
+    XCTAssertEqual(outputs, [0])
+
+    parentStore.send(true)
+    XCTAssertEqual(outputs, [0, 1])
+
+    parentStore.send(false)
+    XCTAssertEqual(outputs, [0, 1])
+    parentStore.send(false)
+    XCTAssertEqual(outputs, [0, 1])
+    parentStore.send(false)
+    XCTAssertEqual(outputs, [0, 1])
+    parentStore.send(false)
+    XCTAssertEqual(outputs, [0, 1])
+  }
+
+  func testIfLetAfterScope() {
+    struct AppState {
+      var count: Int?
+    }
+
+    let appReducer = Reducer<AppState, Int?, Void> { state, action, _ in
+      state.count = action
+      return .none
+    }
+
+    let parentStore = Store(initialState: AppState(), reducer: appReducer, environment: ())
+
+    // NB: This test needs to hold a strong reference to the emitted stores
+    var outputs: [Int?] = []
+    var stores: [Any] = []
+
+    parentStore
+      .scope(state: \.count)
+      .ifLet(
+        then: { store in
+          stores.append(store)
+          outputs.append(store.$state.value)
+      },
+        else: {
+          outputs.append(nil)
+      })
+
+    XCTAssertEqual(outputs, [nil])
+
+    parentStore.send(1)
+    XCTAssertEqual(outputs, [nil, 1])
+
+    parentStore.send(nil)
+    XCTAssertEqual(outputs, [nil, 1, nil])
+
+    parentStore.send(1)
+    XCTAssertEqual(outputs, [nil, 1, nil, 1])
+
+    parentStore.send(nil)
+    XCTAssertEqual(outputs, [nil, 1, nil, 1, nil])
+
+    parentStore.send(1)
+    XCTAssertEqual(outputs, [nil, 1, nil, 1, nil, 1])
+
+    parentStore.send(nil)
+    XCTAssertEqual(outputs, [nil, 1, nil, 1, nil, 1, nil])
+  }
+
+  func testIfLetTwo() {
+    let parentStore = Store(
+      initialState: 0,
+      reducer: Reducer<Int?, Bool, Void> { state, action, _ in
+        if action {
+          state? += 1
+          return .none
+        } else {
+          return Effect(value: true).observe(on: QueueScheduler.main)
+        }
+      },
+      environment: ()
+    )
+
+    parentStore.ifLet { childStore in
+      let vs = ViewStore(childStore)
+
+      vs
+        .publisher.producer
+        .startWithValues { _ in }
+
+      vs.send(false)
+      _ = XCTWaiter.wait(for: [.init()], timeout: 0.1)
+      vs.send(false)
+      _ = XCTWaiter.wait(for: [.init()], timeout: 0.1)
+      vs.send(false)
+      _ = XCTWaiter.wait(for: [.init()], timeout: 0.1)
+      XCTAssertEqual(vs.state, 3)
+    }
+  }
 }