Merge pull request #91 from mfulgo/issue-88

Adds NestedMiddlewareBuilder

Author: davidmarne

Diff for: lib/src/middleware.dart

@@ -10,14 +10,19 @@ class MiddlewareApi<
     State extends Built<State, StateBuilder>,
     StateBuilder extends Builder<State, StateBuilder>,
     Actions extends ReduxActions> {
-  Store<State, StateBuilder, Actions> _store;
-  MiddlewareApi(this._store);
+  final State Function() _state;
+  final Actions Function() _actions;
+
+  MiddlewareApi._(this._state, this._actions);
+
+  factory MiddlewareApi(Store<State, StateBuilder, Actions> _store) =>
+      MiddlewareApi._(() => _store.state, () => _store.actions);
 
   /// [state] returns the current state
-  State get state => _store.state;
+  State get state => _state();
 
   /// [actions] returns the actions synced with this redux store
-  Actions get actions => _store.actions;
+  Actions get actions => _actions();
 }
 
 /// [MiddlewareBuilder] allows you to build a reducer that handles many different actions
@@ -44,6 +49,16 @@ class MiddlewareBuilder<
     _map.addAll(other._map);
   }
 
+  void combineNested<
+          NestedState extends Built<NestedState, NestedStateBuilder>,
+          NestedStateBuilder extends Builder<NestedState, NestedStateBuilder>,
+          NestedActions extends ReduxActions>(
+      NestedMiddlewareBuilder<State, StateBuilder, Actions, NestedState,
+              NestedStateBuilder, NestedActions>
+          other) {
+    _map.addAll(other._map);
+  }
+
   /// [build] returns a [Middleware] function that handles all actions added with [add]
   Middleware<State, StateBuilder, Actions> build() =>
       (MiddlewareApi<State, StateBuilder, Actions> api) =>
@@ -58,9 +73,52 @@ class MiddlewareBuilder<
               };
 }
 
+class NestedMiddlewareBuilder<
+    State extends Built<State, StateBuilder>,
+    StateBuilder extends Builder<State, StateBuilder>,
+    Actions extends ReduxActions,
+    NestedState extends Built<NestedState, NestedStateBuilder>,
+    NestedStateBuilder extends Builder<NestedState, NestedStateBuilder>,
+    NestedActions extends ReduxActions> {
+  final _map =
+      Map<String, MiddlewareHandler<State, StateBuilder, Actions, dynamic>>();
+
+  final NestedState Function(State) _stateMapper;
+  final NestedActions Function(Actions) _actionsMapper;
+
+  NestedMiddlewareBuilder(this._stateMapper, this._actionsMapper);
+
+  void add<Payload>(
+      ActionName<Payload> aMgr,
+      MiddlewareHandler<NestedState, NestedStateBuilder, NestedActions, Payload>
+          handler) {
+    _map[aMgr.name] = (api, next, action) {
+      handler(
+          MiddlewareApi._(
+              () => _stateMapper(api.state), () => _actionsMapper(api.actions)),
+          next,
+          action as Action<Payload>);
+    };
+  }
+
+  void addAll(
+      MiddlewareBuilder<NestedState, NestedStateBuilder, NestedActions> other) {
+    var adapted = other._map.map((name, handler) => MapEntry(
+        name,
+        (MiddlewareApi<State, StateBuilder, Actions> api, ActionHandler next,
+                Action action) =>
+            handler(
+                MiddlewareApi._(() => _stateMapper(api.state),
+                    () => _actionsMapper(api.actions)),
+                next,
+                action)));
+    _map.addAll(adapted);
+  }
+}
+
 /// [MiddlewareHandler] is a function that handles an action in a middleware. Its is only for
 /// use with [MiddlewareBuilder]. If you are not using [MiddlewareBuilder] middleware must be
-/// decalred as a [Middleware] function.
+/// declared as a [Middleware] function.
 typedef void MiddlewareHandler<
     State extends Built<State, StateBuilder>,
     StateBuilder extends Builder<State, StateBuilder>,

Diff for: test/unit/middleware_test.dart

@@ -67,5 +67,12 @@ void main() {
       store.actions.middlewareActions.tripleIt(0);
       expect(store.state.count, 4);
     });
+
+    test('combineNested works with SubCounter doubleIt', () async {
+      setup();
+      expect(store.state.subCounter.subCount, 1);
+      store.actions.subCounterActions.doubleIt(0);
+      expect(store.state.subCounter.subCount, 3);
+    });
   });
 }

Diff for: test/unit/test_counter.dart

@@ -15,20 +15,34 @@ abstract class CounterActions extends ReduxActions {
 
   ActionDispatcher<int> increment;
   ActionDispatcher<int> incrementOther;
+  SubCounterActions subCounterActions;
   MiddlewareActions middlewareActions;
 }
 
+abstract class SubCounterActions extends ReduxActions {
+  SubCounterActions._();
+  factory SubCounterActions() => new _$SubCounterActions();
+
+  ActionDispatcher<int> increment;
+  ActionDispatcher<int> doubleIt;
+}
+
 void _increment(Counter state, Action<int> action, CounterBuilder builder) =>
     builder.count = state.count + action.payload;
 
 void _incrementOther(
         Counter state, Action<int> action, CounterBuilder builder) =>
     builder.otherCount = state.otherCount + action.payload;
 
+void _incrementSubCount(
+        Counter state, Action<int> action, CounterBuilder builder) =>
+    builder.subCounter.subCount = state.subCounter.subCount + action.payload;
+
 final reducer = (new ReducerBuilder<Counter, CounterBuilder>()
       ..add(CounterActionsNames.increment, _increment)
-      ..combine(_otherReducer))
-    .build();
+      ..combine(_otherReducer)
+      ..add(SubCounterActionsNames.increment, _incrementSubCount)
+    ).build();
 
 final _otherReducer = (new ReducerBuilder<Counter, CounterBuilder>()
   ..add(CounterActionsNames.incrementOther, _incrementOther));
@@ -38,9 +52,21 @@ abstract class Counter implements Built<Counter, CounterBuilder> {
 
   int get otherCount;
 
+  SubCounter get subCounter;
+
   // Built value constructor
   Counter._();
-  factory Counter() => new _$Counter._(count: 1, otherCount: 1);
+
+  factory Counter() =>
+      new _$Counter._(count: 1, otherCount: 1, subCounter: SubCounter());
+}
+
+abstract class SubCounter implements Built<SubCounter, SubCounterBuilder> {
+  int get subCount;
+
+  SubCounter._();
+
+  factory SubCounter() => new _$SubCounter._(subCount: 1);
 }
 
 // Middleware
@@ -54,10 +80,11 @@ abstract class MiddlewareActions extends ReduxActions {
 }
 
 var counterMiddleware =
-    (new MiddlewareBuilder<Counter, CounterBuilder, CounterActions>()
-          ..add(MiddlewareActionsNames.doubleIt, _doubleIt)
-          ..combine(tripleItMiddlewareBuilder))
-        .build();
+(new MiddlewareBuilder<Counter, CounterBuilder, CounterActions>()
+  ..add(MiddlewareActionsNames.doubleIt, _doubleIt)
+  ..combine(tripleItMiddlewareBuilder)
+  ..combineNested(subCountNested)
+).build();
 
 void _doubleIt(MiddlewareApi<Counter, CounterBuilder, CounterActions> api,
     ActionHandler next, Action<int> action) {
@@ -75,6 +102,20 @@ void _tripleIt(MiddlewareApi<Counter, CounterBuilder, CounterActions> api,
   next(action);
 }
 
+var subCountNested = NestedMiddlewareBuilder<Counter, CounterBuilder,
+    CounterActions, SubCounter, SubCounterBuilder, SubCounterActions>(
+    (c) => c.subCounter, (a) => a.subCounterActions)
+  ..addAll(subCountMiddlewareBuilder);
+
+var subCountMiddlewareBuilder = new MiddlewareBuilder<SubCounter, SubCounterBuilder, SubCounterActions>()
+  ..add(SubCounterActionsNames.doubleIt, _subCounterDoubleIt);
+
+void _subCounterDoubleIt(MiddlewareApi<SubCounter, SubCounterBuilder, SubCounterActions> api,
+    ActionHandler next, Action<int> action) {
+  api.actions.increment(api.state.subCount * 2);
+  next(action);
+}
+
 // Change handler
 
 StoreChangeHandlerBuilder<Counter, CounterBuilder,