Remove dispatcher (WIP)

src/Redux.js

@@ -1,46 +1,29 @@
-import createDispatcher from './createDispatcher';
-import composeStores from './utils/composeStores';
-import thunkMiddleware from './middleware/thunk';
-
 export default class Redux {
-  constructor(dispatcherOrStores, initialState) {
-    let finalDispatcher = dispatcherOrStores;
-    if (typeof dispatcherOrStores === 'object') {
-      // A shortcut notation to use the default dispatcher
-      finalDispatcher = createDispatcher(
-        composeStores(dispatcherOrStores),
-        (getState) => [thunkMiddleware(getState)]
-      );
-    }
-
+  constructor(reducer, initialState) {
     this.state = initialState;
     this.listeners = [];
-    this.replaceDispatcher(finalDispatcher);
+    this.replaceReducer(reducer);
   }
 
-  getDispatcher() {
-    return this.dispatcher;
+  getReducer() {
+    return this.reducer;
   }
 
-  replaceDispatcher(nextDispatcher) {
-    this.dispatcher = nextDispatcher;
-    this.dispatchFn = nextDispatcher(this.state, ::this.setState);
+  replaceReducer(nextReducer) {
+    this.reducer = nextReducer;
+    this.dispatch({ type: '@@INIT' });
   }
 
   dispatch(action) {
-    return this.dispatchFn(action);
+    const { reducer } = this;
+    this.state = reducer(this.state, action);
+    this.listeners.forEach(listener => listener());
   }
 
   getState() {
     return this.state;
   }
 
-  setState(nextState) {
-    this.state = nextState;
-    this.listeners.forEach(listener => listener());
-    return nextState;
-  }
-
   subscribe(listener) {
     const { listeners } = this;
     listeners.push(listener);

src/components/createProvider.js

@@ -31,8 +31,8 @@ export default function createProvider(React) {
       const { redux: nextRedux } = nextProps;
 
       if (redux !== nextRedux) {
-        const nextDispatcher = nextRedux.getDispatcher();
-        redux.replaceDispatcher(nextDispatcher);
+        const nextReducer = nextRedux.getReducer();
+        redux.replaceReducer(nextReducer);
       }
     }
 

src/createRedux.js

@@ -1,13 +1,18 @@
 import Redux from './Redux';
+import composeReducers from './utils/composeReducers';
 
-export default function createRedux(...args) {
-  const redux = new Redux(...args);
+export default function createRedux(reducer, initialState) {
+  const finalReducer = typeof reducer === 'function' ?
+    reducer :
+    composeReducers(reducer);
+
+  const redux = new Redux(finalReducer, initialState);
 
   return {
     subscribe: ::redux.subscribe,
     dispatch: ::redux.dispatch,
     getState: ::redux.getState,
-    getDispatcher: ::redux.getDispatcher,
-    replaceDispatcher: ::redux.replaceDispatcher
+    getReducer: ::redux.getReducer,
+    replaceReducer: ::redux.replaceReducer
   };
 }

src/index.js

@@ -1,16 +1,14 @@
 // Core
 import createRedux from './createRedux';
-import createDispatcher from './createDispatcher';
 
 // Utilities
 import composeMiddleware from './utils/composeMiddleware';
-import composeStores from './utils/composeStores';
+import composeReducers from './utils/composeReducers';
 import bindActionCreators from './utils/bindActionCreators';
 
 export {
   createRedux,
-  createDispatcher,
   composeMiddleware,
-  composeStores,
+  composeReducers,
   bindActionCreators
 };

src/middleware/thunk.js

@@ -1,10 +1,6 @@
-export default function thunkMiddleware(getState) {
-  return (next) => {
-    const recurse = (action) =>
-      typeof action === 'function' ?
-        action(recurse, getState) :
-        next(action);
-
-    return recurse;
-  };
+export default function thunkMiddleware({ getState, dispatch }) {
+  return (next) => (action) =>
+    typeof action === 'function' ?
+      action(dispatch, getState) :
+      next(action);
 }

src/utils/composeReducers.js

@@ -0,0 +1,12 @@
+import mapValues from '../utils/mapValues';
+import pick from '../utils/pick';
+
+export default function composeReducers(reducers) {
+  const finalReducers = pick(reducers, (val) => typeof val === 'function');
+
+  return function Composition(atom = {}, action) {
+    return mapValues(finalReducers, (store, key) =>
+      store(atom[key], action)
+    );
+  };
+}

test/components/connect.spec.js

@@ -1,7 +1,7 @@
 import expect from 'expect';
 import jsdomReact from './jsdomReact';
 import React, { PropTypes, Component } from 'react/addons';
-import { createRedux } from '../../src';
+import { createRedux, composeReducers } from '../../src';
 import { connect, Connector } from '../../src/react';
 
 const { TestUtils } = React.addons;

test/composeStores.spec.js → test/composeReducers.spec.js

@@ -1,31 +1,31 @@
 import expect from 'expect';
-import { composeStores } from '../src';
+import { composeReducers } from '../src';
 
 describe('Utils', () => {
-  describe('composeStores', () => {
-    it('should return a store that maps state keys to reducer functions', () => {
-      const store = composeStores({
+  describe('composeReducers', () => {
+    it('should return a reducer that maps state keys to reducer functions', () => {
+      const reducer = composeReducers({
         counter: (state = 0, action) =>
           action.type === 'increment' ? state + 1 : state,
         stack: (state = [], action) =>
           action.type === 'push' ? [...state, action.value] : state
       });
 
-      const s1 = store({}, { type: 'increment' });
+      const s1 = reducer({}, { type: 'increment' });
       expect(s1).toEqual({ counter: 1, stack: [] });
-      const s2 = store(s1, { type: 'push', value: 'a' });
+      const s2 = reducer(s1, { type: 'push', value: 'a' });
       expect(s2).toEqual({ counter: 1, stack: ['a'] });
     });
 
     it('should ignore all props which are not a function', () => {
-      const store = composeStores({
+      const reducer = composeReducers({
         fake: true,
         broken: 'string',
         another: {nested: 'object'},
         stack: (state = []) => state
       });
 
-      expect(Object.keys(store({}, {type: 'push'}))).toEqual(['stack']);
+      expect(Object.keys(reducer({}, {type: 'push'}))).toEqual(['stack']);
     });
   });
 });

test/createDispatcher.spec.js

@@ -7,7 +7,7 @@ const { constants, defaultText, todoActions, todoStore } = helpers;
 const { addTodo, addTodoAsync } = todoActions;
 const { ADD_TODO } = constants;
 
-describe('createDispatcher', () => {
+describe.skip('createDispatcher', () => {
 
   it('should handle sync and async dispatches', done => {
     const spy = expect.createSpy(

test/createRedux.spec.js

@@ -20,8 +20,8 @@ describe('createRedux', () => {
     expect(methods).toContain('subscribe');
     expect(methods).toContain('dispatch');
     expect(methods).toContain('getState');
-    expect(methods).toContain('getDispatcher');
-    expect(methods).toContain('replaceDispatcher');
+    expect(methods).toContain('getReducer');
+    expect(methods).toContain('replaceReducer');
   });
 
   it('should subscribe to changes', done => {
@@ -54,11 +54,11 @@ describe('createRedux', () => {
     expect(changeListenerSpy.calls.length).toBe(1);
   });
 
-  it('should use existing state when replacing the dispatcher', () => {
+  it('should use existing state when replacing the reducer', () => {
     redux.dispatch(addTodo('Hello'));
 
     let nextRedux = createRedux({ todoStore });
-    redux.replaceDispatcher(nextRedux.getDispatcher());
+    redux.replaceReducer(nextRedux.getReducer());
 
     let state;
     let action = (_, getState) => {