Support multiple controller view connections

Author: kmcbride

MobiusCore/Source/MobiusController.swift

@@ -10,17 +10,15 @@ import Foundation
 public final class MobiusController<Model, Event, Effect> {
     typealias Loop = MobiusLoop<Model, Event, Effect>
     typealias ViewConnectable = AsyncDispatchQueueConnectable<Model, Event>
-    typealias ViewConnection = Connection<Model>
 
     private struct StoppedState {
         var modelToStartFrom: Model
-        var viewConnectable: ViewConnectable?
-
+        var viewConnectables: [UUID: ViewConnectable]
     }
 
     private struct RunningState {
         var loop: Loop
-        var viewConnectable: ViewConnectable?
+        var viewConnectables: [UUID: ViewConnectable]
         var disposables: CompositeDisposable
     }
 
@@ -78,7 +76,7 @@ public final class MobiusController<Model, Event, Effect> {
         self.viewQueue = viewQueue
 
         let state = State(
-            state: StoppedState(modelToStartFrom: initialModel, viewConnectable: nil),
+            state: StoppedState(modelToStartFrom: initialModel, viewConnectables: [:]),
             queue: loopQueue
         )
         self.state = state
@@ -130,25 +128,28 @@ public final class MobiusController<Model, Event, Effect> {
 
     /// Connect a view to this controller.
     ///
-    /// May not be called while the loop is running.
-    ///
     /// The `Connectable` will be given an event consumer, which the view should use to send events to the `MobiusLoop`.
     /// The view should also return a `Connection` that accepts models and renders them. Disposing the connection should
     /// make the view stop emitting events.
     ///
-    /// - Attention: fails via `MobiusHooks.errorHandler` if the loop is running or if the controller already is
-    ///              connected
+    /// - Returns: An identifier that can be used to disconnect the view.
+    /// - Attention: Fails via `MobiusHooks.errorHandler` if the loop is running.
+    @discardableResult
     public func connectView<ViewConnectable: Connectable>(
         _ connectable: ViewConnectable
-    ) where ViewConnectable.Input == Model, ViewConnectable.Output == Event {
+    ) -> UUID where ViewConnectable.Input == Model, ViewConnectable.Output == Event {
         do {
+            var uuid = Self.viewConnectableID
             try state.mutate { stoppedState in
-                guard stoppedState.viewConnectable == nil else {
-                    throw ErrorMessage(message: "\(Self.debugTag): only one view may be connected at a time")
+                if stoppedState.viewConnectables[uuid] != nil {
+                    // For backwards compatibility with id-less `disconnectView()` usage, we default
+                    // to the reserved connection id and generate a new one when needed.
+                    uuid = UUID()
                 }
-
-                stoppedState.viewConnectable = AsyncDispatchQueueConnectable(connectable, acceptQueue: viewQueue)
+                stoppedState.viewConnectables[uuid] = AsyncDispatchQueueConnectable(connectable, acceptQueue: viewQueue)
             }
+
+            return uuid
         } catch {
            MobiusHooks.errorHandler(
                errorMessage(error, default: "\(Self.debugTag): cannot connect a view while running"),
@@ -158,20 +159,22 @@ public final class MobiusController<Model, Event, Effect> {
        }
     }
 
-    /// Disconnect the connected view from this controller.
+    /// Disconnect a connected view from this controller.
     ///
     /// May not be called directly from an effect handler running on the controller’s loop queue.
     ///
+    /// - Parameter id: The identifier received from calling `connectView(_:)`.
     /// - Attention: fails via `MobiusHooks.errorHandler` if the loop is running or if there isn't anything to
     /// disconnect
-    public func disconnectView() {
+    public func disconnectView(id: UUID? = nil) {
         do {
+            let uuid = id ?? Self.viewConnectableID
             try state.mutate { stoppedState in
-                guard stoppedState.viewConnectable != nil else {
-                    throw ErrorMessage(message: "\(Self.debugTag): no view connected, cannot disconnect")
+                guard stoppedState.viewConnectables[uuid] != nil else {
+                    throw ErrorMessage(message: "\(Self.debugTag): invalid view connection id, cannot disconnect")
                 }
 
-                stoppedState.viewConnectable = nil
+                stoppedState.viewConnectables[uuid] = nil
             }
         } catch {
             MobiusHooks.errorHandler(
@@ -191,11 +194,8 @@ public final class MobiusController<Model, Event, Effect> {
         do {
             try state.transitionToRunning { stoppedState in
                 let loop = loopFactory(stoppedState.modelToStartFrom)
-
-                var disposables: [Disposable] = [loop]
-
-                if let viewConnectable = stoppedState.viewConnectable {
-                    let viewConnection = viewConnectable.connect { [weak loop] event in
+                let disposables: [Disposable] = [loop] + stoppedState.viewConnectables.values.map { connectable in
+                    let connection = connectable.connect { [weak loop] event in
                         guard let loop = loop else {
                             // This failure should not be reached under normal circumstances because it is handled by
                             // AsyncDispatchQueueConnectable. Stopping here means that the viewConnectable called its
@@ -205,13 +205,14 @@ public final class MobiusController<Model, Event, Effect> {
 
                         loop.unguardedDispatchEvent(event)
                     }
-                    loop.addObserver(viewConnection.accept)
-                    disposables.append(viewConnection)
+                    loop.addObserver(connection.accept)
+
+                    return connection
                 }
 
                 return RunningState(
                     loop: loop,
-                    viewConnectable: stoppedState.viewConnectable,
+                    viewConnectables: stoppedState.viewConnectables,
                     disposables: CompositeDisposable(disposables: disposables)
                 )
             }
@@ -236,11 +237,12 @@ public final class MobiusController<Model, Event, Effect> {
     public func stop() {
         do {
             try state.transitionToStopped { runningState in
-                let model = runningState.loop.latestModel
-
                 runningState.disposables.dispose()
 
-                return StoppedState(modelToStartFrom: model, viewConnectable: runningState.viewConnectable)
+                return StoppedState(
+                    modelToStartFrom: runningState.loop.latestModel,
+                    viewConnectables: runningState.viewConnectables
+                )
             }
         } catch {
             MobiusHooks.errorHandler(
@@ -287,6 +289,11 @@ public final class MobiusController<Model, Event, Effect> {
         }
     }
 
+    /// Reserves a special identifier for the primary view connectable
+    private static var viewConnectableID: UUID {
+        return UUID(uuid: (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
+    }
+
     /// Simple error that just carries an error message out of a closure for us
     private struct ErrorMessage: Error {
         let message: String

MobiusCore/Test/MobiusControllerTests.swift

@@ -78,6 +78,16 @@ class MobiusControllerTests: QuickSpec {
 
                         expect(view.recorder.items).toEventually(equal(["S", "S-hey"]))
                     }
+                    it("should allow multiple connections") {
+                        let secondaryView = RecordingTestConnectable(expectedQueue: self.viewQueue)
+
+                        controller.connectView(view)
+                        controller.connectView(secondaryView)
+                        controller.start()
+
+                        expect(view.recorder.items).toEventually(equal(["S"]))
+                        expect(secondaryView.recorder.items).toEventually(equal(["S"]))
+                    }
 
                     context("given a connected and started loop") {
                         beforeEach {
@@ -149,10 +159,6 @@ class MobiusControllerTests: QuickSpec {
                 }
 
                 describe("error handling") {
-                    it("should not allow connecting twice") {
-                        expect(controller.connectView(view)).toNot(raiseError())
-                        expect(controller.connectView(view)).to(raiseError())
-                    }
                     it("should not allow connecting after starting") {
                         controller.connectView(view)
                         controller.start()
@@ -182,6 +188,15 @@ class MobiusControllerTests: QuickSpec {
 
                         expect(view.recorder.items).toEventually(equal(["S"]))
                     }
+                    it("should allow disconnecting by id") {
+                        let secondaryView = RecordingTestConnectable(expectedQueue: self.viewQueue)
+
+                        let connectionID = controller.connectView(view)
+                        let secondaryConnectionID = controller.connectView(secondaryView)
+
+                        controller.disconnectView(id: connectionID)
+                        controller.disconnectView(id: secondaryConnectionID)
+                    }
                     it("should not send events to a disconnected view") {
                         let disconnectedView = RecordingTestConnectable(expectedQueue: self.viewQueue)
                         controller.connectView(disconnectedView)
@@ -209,8 +224,16 @@ class MobiusControllerTests: QuickSpec {
                     }
                     it("should not allow disconnecting without a connection") {
                         controller.connectView(view)
+
+                        let secondaryView = RecordingTestConnectable(expectedQueue: self.viewQueue)
+                        let secondaryConnectionID = controller.connectView(secondaryView)
+
                         controller.disconnectView()
+                        controller.disconnectView(id: secondaryConnectionID)
+
                         expect(controller.disconnectView()).to(raiseError())
+                        expect(controller.disconnectView(id: secondaryConnectionID)).to(raiseError())
+                        expect(controller.disconnectView(id: UUID())).to(raiseError())
                     }
                 }
                 #endif