feat(default): support path function in subpathReducer

Author: jedwards1211

README.md

@@ -85,7 +85,7 @@ import {subpathReducer} from 'mindfront-redux-utils-immutable'
 
 ```es6
 function subpathReducer(
-  path: Array<any>,
+  path: Array<any> | (action: Action) => Array<any>,
   initialState?: Immutable.Collection.Keyed | Record
 ): Reducer => Reducer
 ```
@@ -94,4 +94,7 @@ Creates a reducer that applies the decorated reducer at the given `path` within
 equivalent to `(state = initialState, action) => state.updateIn(path, reducer)` except that if the decorated reducer
 has `actionHandlers`, the created reducer will have corresponding `actionHandlers` so that other utils can optimize it.
 
+If you pass a function for `path`, `subpathReducer` will get the actual path by calling `path(action)` for each
+`action`.
+
 

src/subpathReducer.js

@@ -2,16 +2,20 @@ import {createReducer} from 'mindfront-redux-utils'
 import mapValues from 'lodash.mapvalues'
 
 export default function subpathReducer(subpath, initialState) {
+  if (typeof subpath !== 'function') {
+    const fixedSubpath = subpath
+    subpath = () => fixedSubpath
+  }
   return reducer => {
     const {actionHandlers} = reducer
     if (actionHandlers instanceof Object) {
       const initialSubState = reducer.initialState
       return createReducer(initialState, mapValues(actionHandlers, reducer => (state, action) =>
-        state.updateIn(subpath, (substate = initialSubState) => reducer(substate, action))
+        state.updateIn(subpath(action), (substate = initialSubState) => reducer(substate, action))
       ))
     }
     return (state = initialState, action) =>
-      state.updateIn(subpath, substate => reducer(substate, action))
+      state.updateIn(subpath(action), substate => reducer(substate, action))
   }
 }
 

test/subpathReducerTest.js

@@ -27,5 +27,16 @@ describe('subpathReducer', () => {
     expect(reducer(undefined, {type: 'INCREMENT'})).to.equal(fromJS({a: {b: 1}}))
     expect(reducer(fromJS({a: {b: 2}}), {type: 'INCREMENT'})).to.equal(fromJS({a: {b: 3}}))
   })
+  it("calls subpath with action if it's a function", () => {
+    const reducer = subpathReducer(action => action.meta.reduxPath, Map())(createReducer(0, {
+      INCREMENT: state => state + 1
+    }))
+
+    expect(reducer.actionHandlers.INCREMENT).to.be.an.instanceof(Function)
+
+    expect(reducer(undefined, {})).to.equal(fromJS({}))
+    expect(reducer(undefined, {type: 'INCREMENT', meta: {reduxPath: ['a', 'b']}})).to.equal(fromJS({a: {b: 1}}))
+    expect(reducer(fromJS({a: 2}), {type: 'INCREMENT', meta: {reduxPath: ['a']}})).to.equal(fromJS({a: 3}))
+  })
 })