Add exhaustivity for substate reducers

Author: Thibault Wittemberg

RxReduce/Store.swift

@@ -20,23 +20,45 @@ import RxCocoa
 /// A Store is dedicated to a State Type
 public final class Store<State: Equatable> {
 
-    public typealias ReducerFunction = (State, Action) -> State
+    private typealias ReducerFunction = (State, Action) -> State
 
     private var state: State
-    private var reducers = [ReducerFunction]()
-//    private let reducers: ContiguousArray<Reducer<StateType>>
+    private var reducers = [String: ReducerFunction]()
+
+    private var subStateTypes = [String]()
 //    private let middlewares: ContiguousArray<Middleware<StateType>>?
 
     public init(withState state: State) {
         self.state = state
+
+        let stateMirror = Mirror(reflecting: self.state)
+        for child in stateMirror.children {
+            let childMirror = Mirror(reflecting: child.value)
+            subStateTypes.append("\(type(of: childMirror.subjectType))")
+        }
+
 //        self.middlewares = middlewares
     }
 
-    public func register<SubState: Equatable> (reducer: Reducer<State, SubState>) {
-        self.reducers.append(reducer.apply)
+    public func register<SubState: Equatable> (reducer: Reducer<State, SubState>) throws {
+        let key = "\(type(of: SubState.self))"
+
+        if let index = self.subStateTypes.index(of: key) {
+            self.subStateTypes.remove(at: index)
+        }
+
+        guard self.reducers[key] == nil else {
+            throw NSError(domain: "ReducerAlreadyExists", code: -1)
+        }
+        self.reducers[key] = reducer.apply
     }
 
     public func dispatch(action: Action) -> Observable<State> {
+
+        guard self.subStateTypes.isEmpty else {
+            fatalError("All substate must be handled")
+        }
+
         // every received action is converted to an async action
         return action
             .toAsync()
@@ -47,7 +69,7 @@ public final class Store<State: Equatable> {
 //            })
             .map { (action) -> State in
 
-                return self.reducers.reduce(self.state, { (currentState, reducer) -> State in
+                return self.reducers.values.reduce(self.state, { (currentState, reducer) -> State in
                     return reducer(currentState, action)
                 })
             }.do(onNext: { [unowned self] (newState) in

RxReduceTests/StoreTests.swift

@@ -32,8 +32,12 @@ class StoreTests: XCTestCase {
         let counterReducer = Reducer<TestState, CounterState>(lens: counterLens, reducer: counterReduce)
         let userReducer = Reducer<TestState, UserState>(lens: userLens, reducer: userReduce)
 
-        store.register(reducer: counterReducer)
-        store.register(reducer: userReducer)
+        do {
+            try store.register(reducer: counterReducer)
+            try store.register(reducer: userReducer)
+        } catch {
+            XCTFail("Reducer registering failure")
+        }
 
         return store
     }()
@@ -146,6 +150,17 @@ class StoreTests: XCTestCase {
         }
     }
 
+    func testStoreRegistering () {
+        do {
+            let counterReducer = Reducer<TestState, CounterState>(lens: counterLens, reducer: counterReduce)
+            try self.store.register(reducer: counterReducer)
+            XCTFail("Counter Reducer has already been registered, it should not be possible to register a new one")
+        } catch {
+            let error = error as NSError
+            XCTAssertEqual("ReducerAlreadyExists", error.domain)
+        }
+    }
+
 //    func testMiddleware () {
 //
 //        let exp = expectation(description: "Middleware subscription")