Breakup debug option into individual option flags

TODO: add tests

Author: jordangarcia

src/logging.js

@@ -1,8 +1,17 @@
+import { getOption } from './reactor/fns'
+
 /* eslint-disable no-console */
 /**
  * Wraps a Reactor.react invocation in a console.group
+ * @param {ReactorState} reactorState
+ * @param {String} type
+ * @param {*} payload
 */
-exports.dispatchStart = function(type, payload) {
+exports.dispatchStart = function(reactorState, type, payload) {
+  if (!getOption(reactorState, 'logDispatches')) {
+    return
+  }
+
   if (console.group) {
     console.groupCollapsed('Dispatch: %s', type)
     console.group('payload')
@@ -11,24 +20,31 @@ exports.dispatchStart = function(type, payload) {
   }
 }
 
-exports.dispatchError = function(error) {
+exports.dispatchError = function(reactorState, error) {
+  console.log('dispatchError, shoud do', getOption(reactorState, 'logDispatches'))
+  if (!getOption(reactorState, 'logDispatches')) {
+    return
+  }
+
   if (console.group) {
     console.debug('Dispatch error: ' + error)
     console.groupEnd()
   }
 }
 
-exports.storeHandled = function(id, before, after) {
-  if (console.group) {
-    if (before !== after) {
-      console.debug('Store ' + id + ' handled action')
-    }
+exports.dispatchEnd = function(reactorState, state, dirtyStores) {
+  if (!getOption(reactorState, 'logDispatches')) {
+    return
   }
-}
 
-exports.dispatchEnd = function(state) {
   if (console.group) {
-    console.debug('Dispatch done, new state: ', state.toJS())
+    if (getOption(reactorState, 'logDirtyStores')) {
+      console.log('Stores updated:', dirtyStores.toList().toJS())
+    }
+
+    if (getOption(reactorState, 'logAppState')) {
+      console.debug('Dispatch done, new state: ', state.toJS())
+    }
     console.groupEnd()
   }
 }

src/reactor.js

@@ -1,11 +1,16 @@
 import Immutable from 'immutable'
 import createReactMixin from './create-react-mixin'
-import fns from './reactor/fns'
+import * as fns from './reactor/fns'
 import { isKeyPath } from './key-path'
 import { isGetter } from './getter'
 import { toJS } from './immutable-helpers'
 import { toFactory } from './utils'
-import { ReactorState, ObserverState } from './reactor/records'
+import {
+  ReactorState,
+  ObserverState,
+  DEBUG_OPTIONS,
+  PROD_OPTIONS,
+} from './reactor/records'
 
 /**
  * State is stored in NuclearJS Reactors.  Reactors
@@ -18,8 +23,11 @@ import { ReactorState, ObserverState } from './reactor/records'
  */
 class Reactor {
   constructor(config = {}) {
+    const baseOptions = config.debug ? DEBUG_OPTIONS : PROD_OPTIONS
     const initialReactorState = new ReactorState({
       debug: config.debug,
+      // merge config options with the defaults
+      options: baseOptions.merge(config.options || {}),
     })
 
     this.prevReactorState = initialReactorState
@@ -101,9 +109,11 @@ class Reactor {
    */
   dispatch(actionType, payload) {
     if (this.__batchDepth === 0) {
-      if (this.__isDispatching) {
-        this.__isDispatching = false
-        throw new Error('Dispatch may not be called while a dispatch is in progress')
+      if (!fns.getOption(this.reactorState, 'allowDispatchInDispatch')) {
+        if (this.__isDispatching) {
+          this.__isDispatching = false
+          throw new Error('Dispatch may not be called while a dispatch is in progress')
+        }
       }
       this.__isDispatching = true
     }

src/reactor/fns.js

@@ -23,9 +23,7 @@ function evaluateResult(result, reactorState) {
  * @param {Object<String, Store>} stores
  * @return {ReactorState}
  */
-exports.registerStores = function(reactorState, stores) {
-  const debug = reactorState.get('debug')
-
+export function registerStores(reactorState, stores) {
   return reactorState.withMutations((reactorState) => {
     each(stores, (store, id) => {
       if (reactorState.getIn(['stores', id])) {
@@ -36,7 +34,7 @@ exports.registerStores = function(reactorState, stores) {
 
       const initialState = store.getInitialState()
 
-      if (debug && !isImmutableValue(initialState)) {
+      if (!getOption(reactorState, 'allowNonImmutableStores') && !isImmutableValue(initialState)) {
         throw new Error('Store getInitialState() must return an immutable value, did you forget to call toImmutable')
       }
 
@@ -56,15 +54,12 @@ exports.registerStores = function(reactorState, stores) {
  * @param {*} payload
  * @return {ReactorState}
  */
-exports.dispatch = function(reactorState, actionType, payload) {
+export function dispatch(reactorState, actionType, payload) {
   const currState = reactorState.get('state')
-  const debug = reactorState.get('debug')
   let dirtyStores = reactorState.get('dirtyStores')
 
   const nextState = currState.withMutations(state => {
-    if (debug) {
-      logging.dispatchStart(actionType, payload)
-    }
+    logging.dispatchStart(reactorState, actionType, payload)
 
     // let each store handle the message
     reactorState.get('stores').forEach((store, id) => {
@@ -75,13 +70,13 @@ exports.dispatch = function(reactorState, actionType, payload) {
         newState = store.handle(currState, actionType, payload)
       } catch(e) {
         // ensure console.group is properly closed
-        logging.dispatchError(e.message)
+        logging.dispatchError(reactorState, e.message)
         throw e
       }
 
-      if (debug && newState === undefined) {
+      if (!getOption(reactorState, 'allowUndefinedDispatch') && newState === undefined) {
         const errorMsg = 'Store handler must return a value, did you forget a return statement'
-        logging.dispatchError(errorMsg)
+        logging.dispatchError(reactorState, errorMsg)
         throw new Error(errorMsg)
       }
 
@@ -91,15 +86,9 @@ exports.dispatch = function(reactorState, actionType, payload) {
         // if the store state changed add store to list of dirty stores
         dirtyStores = dirtyStores.add(id)
       }
-
-      if (debug) {
-        logging.storeHandled(id, currState, newState)
-      }
     })
 
-    if (debug) {
-      logging.dispatchEnd(state)
-    }
+    logging.dispatchEnd(reactorState, state, dirtyStores)
   })
 
   const nextReactorState = reactorState
@@ -115,7 +104,7 @@ exports.dispatch = function(reactorState, actionType, payload) {
  * @param {Immutable.Map} state
  * @return {ReactorState}
  */
-exports.loadState = function(reactorState, state) {
+export function loadState(reactorState, state) {
   let dirtyStores = []
   const stateToLoad = toImmutable({}).withMutations(stateToLoad => {
     each(state, (serializedStoreState, storeId) => {
@@ -154,7 +143,7 @@ exports.loadState = function(reactorState, state) {
  * @param {function} handler
  * @return {ObserveResult}
  */
-exports.addObserver = function(observerState, getter, handler) {
+export function addObserver(observerState, getter, handler) {
   // use the passed in getter as the key so we can rely on a byreference call for unobserve
   const getterKey = getter
   if (isKeyPath(getter)) {
@@ -180,7 +169,7 @@ exports.addObserver = function(observerState, getter, handler) {
       storeDeps.forEach(storeId => {
         let path = ['stores', storeId]
         if (!map.hasIn(path)) {
-          map.setIn(path, Immutable.Set([]))
+          map.setIn(path, Immutable.Set())
         }
         map.updateIn(['stores', storeId], observerIds => observerIds.add(currId))
       })
@@ -197,6 +186,15 @@ exports.addObserver = function(observerState, getter, handler) {
   }
 }
 
+/**
+ * @param {ReactorState} reactorState
+ * @param {String} option
+ * @return {Boolean}
+ */
+export function getOption(reactorState, option) {
+  return reactorState.getIn(['options', option], false)
+}
+
 /**
  * Use cases
  * removeObserver(observerState, [])
@@ -210,7 +208,7 @@ exports.addObserver = function(observerState, getter, handler) {
  * @param {Function} handler
  * @return {ObserverState}
  */
-exports.removeObserver = function(observerState, getter, handler) {
+export function removeObserver(observerState, getter, handler) {
   const entriesToRemove = observerState.get('observersMap').filter(entry => {
     // use the getterKey in the case of a keyPath is transformed to a getter in addObserver
     let entryGetter = entry.get('getterKey')
@@ -227,7 +225,7 @@ exports.removeObserver = function(observerState, getter, handler) {
   })
 
   return observerState.withMutations(map => {
-    entriesToRemove.forEach(entry => exports.removeObserverByEntry(map, entry))
+    entriesToRemove.forEach(entry => removeObserverByEntry(map, entry))
   })
 }
 
@@ -237,7 +235,7 @@ exports.removeObserver = function(observerState, getter, handler) {
  * @param {Immutable.Map} entry
  * @return {ObserverState}
  */
-exports.removeObserverByEntry = function(observerState, entry) {
+export function removeObserverByEntry(observerState, entry) {
   return observerState.withMutations(map => {
     const id = entry.get('id')
     const storeDeps = entry.get('storeDeps')
@@ -264,8 +262,7 @@ exports.removeObserverByEntry = function(observerState, entry) {
  * @param {ReactorState} reactorState
  * @return {ReactorState}
  */
-exports.reset = function(reactorState) {
-  const debug = reactorState.get('debug')
+export function reset(reactorState) {
   const prevState = reactorState.get('state')
 
   return reactorState.withMutations(reactorState => {
@@ -274,17 +271,17 @@ exports.reset = function(reactorState) {
     storeMap.forEach((store, id) => {
       const storeState = prevState.get(id)
       const resetStoreState = store.handleReset(storeState)
-      if (debug && resetStoreState === undefined) {
+      if (!getOption(reactorState, 'allowUndefinedDispatch') && resetStoreState === undefined) {
         throw new Error('Store handleReset() must return a value, did you forget a return statement')
       }
-      if (debug && !isImmutableValue(resetStoreState)) {
+      if (!getOption(reactorState, 'allowNonImmutableStores') && !isImmutableValue(resetStoreState)) {
         throw new Error('Store reset state must be an immutable value, did you forget to call toImmutable')
       }
       reactorState.setIn(['state', id], resetStoreState)
     })
 
     reactorState.update('storeStates', storeStates => incrementStoreStates(storeStates, storeIds))
-    exports.resetDirtyStores(reactorState)
+    resetDirtyStores(reactorState)
   })
 }
 
@@ -293,7 +290,7 @@ exports.reset = function(reactorState) {
  * @param {KeyPath|Gettter} keyPathOrGetter
  * @return {EvaluateResult}
  */
-exports.evaluate = function evaluate(reactorState, keyPathOrGetter) {
+export function evaluate(reactorState, keyPathOrGetter) {
   const state = reactorState.get('state')
 
   if (isKeyPath(keyPathOrGetter)) {
@@ -331,7 +328,7 @@ exports.evaluate = function evaluate(reactorState, keyPathOrGetter) {
  * @param {ReactorState} reactorState
  * @return {Object}
  */
-exports.serialize = function(reactorState) {
+export function serialize(reactorState) {
   let serialized = {}
   reactorState.get('stores').forEach((store, id) => {
     let storeState = reactorState.getIn(['state', id])
@@ -348,7 +345,7 @@ exports.serialize = function(reactorState) {
  * @param {ReactorState} reactorState
  * @return {ReactorState}
  */
-exports.resetDirtyStores = function(reactorState) {
+export function resetDirtyStores(reactorState) {
   return reactorState.set('dirtyStores', Immutable.Set())
 }
 

src/reactor/records.js

@@ -1,28 +1,55 @@
-import Immutable from 'immutable'
+import { Map, Set, Record } from 'immutable'
 
-const ReactorState = Immutable.Record({
+export const ReactorState = Record({
   dispatchId: 0,
-  state: Immutable.Map(),
-  stores: Immutable.Map(),
-  cache: Immutable.Map(),
+  state: Map(),
+  stores: Map(),
+  cache: Map(),
   // maintains a mapping of storeId => state id (monotomically increasing integer whenever store state changes)
-  storeStates: Immutable.Map(),
-  dirtyStores: Immutable.Set(),
+  storeStates: Map(),
+  dirtyStores: Set(),
   debug: false,
+  // production defaults
+  options: Map({}),
 })
 
-const ObserverState = Immutable.Record({
+export const ObserverState = Record({
   // observers registered to any store change
-  any: Immutable.Set([]),
+  any: Set(),
   // observers registered to specific store changes
-  stores: Immutable.Map({}),
+  stores: Map({}),
 
-  observersMap: Immutable.Map({}),
+  observersMap: Map({}),
 
   nextId: 1,
 })
 
-export default {
-  ReactorState,
-  ObserverState,
-}
+export const DEBUG_OPTIONS = Map({
+  // logs information for each dispatch
+  logDispatches: true,
+  // log the entire app state after each dispatch
+  logAppState: true,
+  // logs what stores changed after a dispatch
+  logDirtyStores: true,
+  // if false, throw an error if a store returns undefined
+  allowUndefinedDispatch: false,
+  // if false, throw an error if a store returns undefined
+  allowNonImmutableStores: false,
+  // if false throw when dispatching in dispatch
+  allowDispatchInDispatch: false,
+})
+
+export const PROD_OPTIONS = Map({
+  // logs information for each dispatch
+  logDispatches: false,
+  // log the entire app state after each dispatch
+  logAppState: false,
+  // logs what stores changed after a dispatch
+  logDirtyStores: false,
+  // if false, throw an error if a store returns undefined
+  allowUndefinedDispatch: true,
+  // if false, throw an error if a store returns undefined
+  allowNonImmutableStores: true,
+  // if false throw when dispatching in dispatch
+  allowDispatchInDispatch: true,
+})

tests/reactor-fns-tests.js

@@ -1,7 +1,7 @@
 /*eslint-disable one-var, comma-dangle*/
 import { Map, Set, is } from 'immutable'
 import { Store } from '../src/main'
-import fns from '../src/reactor/fns'
+import * as fns from '../src/reactor/fns'
 import { ReactorState, ObserverState } from '../src/reactor/records'
 import { toImmutable } from '../src/immutable-helpers'
 

tests/reactor-tests.js

@@ -764,7 +764,7 @@ describe('Reactor', () => {
       expect(function() {
         reactor.dispatch('set', 'foo')
       }).toThrow(new Error('Error during action handling'))
-      expect(logging.dispatchError).toHaveBeenCalledWith('Error during action handling')
+      expect(logging.dispatchError).toHaveBeenCalledWith(reactor.reactorState, 'Error during action handling')
     })
   })