@peter.naydenov/fsm-hub 1.0.2 → 1.0.5

package/README.md

@@ -175,7 +175,7 @@ const
                                         return {
                                                   second : 'second'
                                                 , state
-                                                , 'answer' : resultResponseData
+                                                , 'answer' : resultResponseData.response
                                             }
                                     } 
                     }
@@ -186,17 +186,44 @@ const
 
     function showme (transitionResult) {
                 console.log ( 'ShowMe' )
-                console.log (transitionResult)
+                console.log ( transitionResult.answer )
         } // showme func.
 
     hub.addFsm ({ one, two })
     hub.addFunctions ( { showme })
 
 // Start!
-    oneFsm.update ( 'activate', 'try' )
+    oneFsm.update ( 'activate', { response:'try'} )
 
 // Result on the screen:
 // ShowMe
 // { second: 'second', state: 'active', answer: 'try' }
 
-```
+```
+
+
+
+## Release History
+
+
+
+### 1.0.4 ( 2021-04-02 )
+ - [x] Fix: Duplicated update callback if logic contain a chainAction.
+
+### 1.0.3 ( 2021-03-26 )
+ - [x] Massive code refactoring;
+ - [ ] Bug: Duplicated update callback if logic contain a chainAction.
+
+
+
+
+
+
+ ## Credits
+'@peter.naydenov/fsm-hub' was created by Peter Naydenov.
+
+
+## License
+'@peter.naydenov/fsm-hub' is released under the MIT License.
+
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peter.naydenov/fsm-hub",
-  "version": "1.0.2",
+  "version": "1.0.5",
   "description": "FSM orchestration and state-managment tool",
   "main": "src/index.js",
   "scripts": {
@@ -9,13 +9,19 @@
   },
   "author": "Peter Naydenov",
   "license": "MIT",
-  "dependencies": {},
+  "dependencies": {
+    "@peter.naydenov/stack": "1.0.0",
+    "ask-for-promise": "1.3.1"
+  },
   "devDependencies": {
-    "@peter.naydenov/fsm": "2.2.1",
-    "chai": "4.2.0",
-    "expect.js": "0.3.1",
-    "mocha": "6.1.4",
-    "nyc": "14.1.1"
+    "@peter.naydenov/fsm": "2.2.4",
+    "chai": "4.3.6",
+    "mocha": "10.0.0",
+    "nyc": "15.1.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/PeterNaydenov/fsm-hub.git"
   },
   "keywords": [
     "fsm",

package/src/index.js

@@ -1,186 +1,33 @@
-const Fsm = require ( '@peter.naydenov/fsm' );
-
-const   // Error and warnings messages
-    WRONG_REACTIVITY_RECORD  = 'Error: Wrong reactivity record on row %s.'
-  , REGISTERED_FSM_NAME      = 'Warning: FSM "%s" is already registered.'
-  , REGISTERED_FUNCTION_NAME = 'Warning: Function "%s" is already registered.'
-  , MISSING_FSM              = 'Warning: Fsm "%s" is not registered to the hub.'
-  , MISSING_FN               = 'Warning: Function "%s" is not registered to the hub.'
-  ;
-
-
-
-class FsmHub {
-
-constructor ( machine, transformerLib ) {
-        const hub = this;
-        hub.fsm = {}          // Fsm's placeholder
-        hub.fnCallbacks = {}   // Callback functions place
+const 
+      methods       = require ( './methods/index'        )
+    , msg           = require ( './msg'                  )
+    , askForPromise = require ( 'ask-for-promise'        )
+    , stack         = require ( '@peter.naydenov/stack'  )
+    ;
+
+function FsmHub ( machine, transformerLib ) {
+   const 
+          hub = this
+        , fnKeys = Object.keys ( methods )
+        ;
+        hub.fsm = {}                        // Fsm's placeholder
+        hub.fnCallbacks = {}                // Callback functions place
         hub.debug = machine.debug || false
-
-        const result = this._setTransitions ( machine, transformerLib );
-        hub.transformers  = result.transformers  // Data transformation function with format 'fsm/fsmListener' or 'fsm/function'
-        hub.subscribers   = result.subscribers   // List of fsm names that are listening for 'fsm/state' changes
-        hub.actions       = result.actions       // Fsm action that should be applied on 'fsm/state/listener' 
-        hub.callbacks     = result.callbacks     // List of functional callbacks
-    } // constructor func.
-
-
-
-
-
-_setTransitions ( {reactivity, transformers}, transformerLib={} ) {
-        let 
-              mod = {}
-            , subscribers = {}
-            , actions     = {}
-            , callbacks  = {}
-            ;
-
-        reactivity.forEach ( (ruleLine,i) => {
-                    const  hub = this;
-                    const // ruleLine elements:
-                            fsmName = 0
-                          , onState = 1
-                          , listener = 2
-                          , listenerAct = 3
-                          , isArray = ruleLine instanceof Array
-                          ;
-
-                    if ( !isArray ) {
-                            hub._debuger ( WRONG_REACTIVITY_RECORD, i+1 )
-                            return
-                        }
-
-                    const 
-                            length = ruleLine.length
-                          , hasCorrectLength = (length == 4 || length == 3 ) ? true : false
-                          ;
-
-                    if ( !hasCorrectLength ) {
-                            hub._debuger ( WRONG_REACTIVITY_RECORD, i+1 )
-                            return
-                        }
-
-                    const key = `${ruleLine[fsmName]}/${ruleLine[onState]}`;   // fsmName/state
-                    if ( length == 4 ) { // ruleLine with fsm
-                            if ( !subscribers[key] )   subscribers[key] = []
-                            subscribers [key].push ( ruleLine[listener]   ) 
-
-                            const actKey = `${key}/${ruleLine[listener]}`;   // fsmName/state/fsmSubscriberName
-                            actions [actKey] = ruleLine[listenerAct]
-                        }
-
-                    if ( length == 3 ) {   // ruleLine with function callback
-                            if ( !callbacks[key] )   callbacks[key] = []
-                            callbacks[key].push ( ruleLine[listener] )
-                        }
-            }) // forEach ruleLine
-        if ( transformers )   {
-                    Object.keys ( transformers ).forEach ( key => {
-                            const
-                                  keyFn = transformers [key]
-                                , fn    = transformerLib [ keyFn] 
-                                ;
-                            if ( fn )   mod[key] = fn
-                        })
-            }
-        return { transformers: mod, subscribers, callbacks, actions }
-    } // _setTransitions func.
-
-
-
-
-
-addFsm ( ins ) {
-        const hub = this;
-        Object.keys(ins).forEach ( name => {
-                    if ( hub.fsm[name] ) {
-                                    hub._debuger ( REGISTERED_FSM_NAME, name )
-                                    return
-                            }
-                    hub.fsm [name] = ins[name]
-                    hub.fsm [name].on ( 'update', (state, response ) => {
-                                hub._callback ( name, state, response )
-                        })
-            })
-    } // addFsm func.
-
-
-
-
-
-addFunctions ( ins ) {
-        const hub = this;
-        Object.keys(ins).forEach ( name => {
-                    if ( hub.fnCallbacks[name] ) {
-                                    hub._debuger ( REGISTERED_FUNCTION_NAME, name )
-                                    return
-                            }
-                    hub.fnCallbacks [name] = ins[name]
-            })
-    } // addFunctions func.
-
-
-
-
-
-_debuger ( str, data ) {
-    const hub = this;
-    if ( hub.debug )   console.log ( str, data )
-} // debuger func.
-
-
-
-
-_callback ( fsmName, state, response ) {
-        const 
-              hub = this
-            , itemKey        = `${fsmName}/${state}`
-            , fsmSubscriber  = hub.subscribers[itemKey] || false
-            , callbackNames  = hub.callbacks[itemKey]   || false
-            , fnCallbacks    = hub.fnCallbacks          
-            , act = hub.actions
-            ;
-        let data, wait;
-
-        if ( fsmSubscriber ) {
-                    fsmSubscriber.forEach ( subscriberName => {
-                                                    if ( !hub.fsm[ subscriberName ] )   {
-                                                            hub._debuger ( MISSING_FSM, fsmSubscriber )
-                                                            return
-                                                        }
-                                                    const 
-                                                          actionKey = `${itemKey}/${subscriberName}`
-                                                        , action = act [actionKey]
-                                                        , transformerKey = `${fsmName}/${subscriberName}`
-                                                        , transformFn = hub.transformers [transformerKey]
-                                                        ;
-                                                    if ( typeof transformFn == 'function' )   data = transformFn (state, response )
-                                                    else                                      data = response
-                                                    hub.wait = hub.fsm [ subscriberName ].update ( action, data )
-                                            })
-            } // if fsmSubscriber
-        if ( callbackNames ) {
-                    if ( hub.wait )  wait = hub.wait
-                    else             wait = Promise.resolve ()
-                    wait.then ( () => {
-                            hub.wait = false
-                            callbackNames.forEach ( cbName => {
-                                                            const 
-                                                                  fn = fnCallbacks[cbName]
-                                                                , transformerKey = `${fsmName}/${cbName}`
-                                                                , transformFn = hub.transformers [ transformerKey ]
-                                                                ;  
-                                                            if ( typeof transformFn == 'function' )   data = transformFn (state, response )
-                                                            else                                      data = response
-                                                            if ( typeof fn == 'function' )   fn(data)
-                                                            else                             hub._debuger ( MISSING_FN, cbName )
-                                                    })
-                        })
-            } // if fnCallback
-    } // _callback func.
-
+        hub.cache = stack ( 'FIFO' )
+        hub.cacheInternal = stack ( 'FIFO' )
+        hub.wait = []
+        hub.lock = false
+        hub.haveInternalRequest = false
+        hub.reactivityTask = false
+        hub.askForPromise = askForPromise
+
+        fnKeys.forEach ( k => hub[k] = methods[k](hub,msg)   )   // Attach methods to fsmHub
+
+        const { transformers, subscribers, actions, callbacks } = hub._setTransitions ( machine, transformerLib );
+        hub.transformers = transformers  // Data transformation function with format 'fsm/fsmListener' or 'fsm/function'
+        hub.subscribers  = subscribers   // List of fsm names that are listening for 'fsm/state' changes
+        hub.actions      = actions       // Fsm action that should be applied on 'fsm/state/listener' 
+        hub.callbacks    = callbacks     // List of functional callbacks
 } // FsmHub class
 
 

package/src/methods/_callback.js

@@ -0,0 +1,69 @@
+const askForPromise = require("ask-for-promise");
+
+function _callback ( hub, msg ) {
+return function _callback ( task, fsmName, state, response ) {
+    const 
+          itemKey        = `${fsmName}/${state}`
+        , fsmSubscriber  = hub.subscribers[itemKey] || false
+        , callbackNames  = hub.callbacks[itemKey]   || false
+        , fnCallbacks    = hub.fnCallbacks          
+        , act = hub.actions
+        , wait = []
+        ;
+    let data;
+
+    if ( !fsmSubscriber && !callbackNames ) {
+            task.done ()
+            return
+        }
+
+    if ( fsmSubscriber ) {
+            fsmSubscriber.forEach ( subscriberName => {
+                                  if ( !hub.fsm[ subscriberName ] )   {
+                                          hub._debugger ( msg.MISSING_FSM, fsmSubscriber )
+                                          return
+                                      }
+                                  const 
+                                        actionKey = `${itemKey}/${subscriberName}`
+                                      , action = act [actionKey]
+                                      , transformerKey = `${fsmName}/${subscriberName}`
+                                      , transformFn = hub.transformers [transformerKey]
+                                      ;
+                                  if ( typeof transformFn == 'function' )   data = transformFn (state, response )
+                                  else                                      data = response
+
+                                  if ( !data )   data = {}
+                                  data.___internalFlag = true
+                                  const updatePromise = hub.fsm [ subscriberName ].update ( action, data );
+                                  wait.push (  updatePromise   )
+                        })           
+        } // if fsmSubscriber
+
+    if ( callbackNames ) {
+              let startFunctions = askForPromise ();
+              wait.push ( startFunctions.promise  )
+
+              callbackNames.forEach ( cbName => {
+                                  const 
+                                        fn = fnCallbacks[cbName]
+                                      , transformerKey = `${fsmName}/${cbName}`
+                                      , transformFn = hub.transformers [ transformerKey ]
+                                      ;  
+                                  if ( typeof transformFn == 'function' )   data = transformFn (state, response )
+                                  else                                      data = response
+                                  if ( typeof fn == 'function' )   fn(data)
+                                  else                             hub._debugger ( msg.MISSING_FN, cbName )
+                                  
+                        })
+              startFunctions.done ()
+        } // if fnCallback
+    Promise.all ( wait ).then ( () =>  task.done ()   )
+}} // _callback func.
+
+
+
+
+
+module.exports = _callback
+
+

package/src/methods/_debugger.js

@@ -0,0 +1,10 @@
+function  _debugger ( hub ) {
+return function ( str, data ) {
+    if ( hub.debug )   console.log ( str, data )
+}} // debugger func.
+
+
+
+module.exports = _debugger
+
+

package/src/methods/_setTransitions.js

@@ -0,0 +1,59 @@
+function _setTransitions ( hub, msg ) {
+return function ( {reactivity, transformers}, transformerLib={} ) {
+    let 
+          mod = {}
+        , subscribers = {}
+        , actions     = {}
+        , callbacks  = {}
+        ;
+
+    reactivity.forEach ( (ruleLine,i) => {
+                const isArray = ruleLine instanceof Array;
+
+                if ( !isArray ) {
+                        hub._debugger ( msg.WRONG_REACTIVITY_RECORD, i+1 )
+                        return
+                    }
+
+                const 
+                        length = ruleLine.length
+                      , [ fsmName, onState, listener, listenerAct ]= ruleLine   // RuleLine elements
+                      , hasCorrectLength = (length == 4 || length == 3 ) ? true : false
+                      ;
+
+                if ( !hasCorrectLength ) {
+                        hub._debugger ( msg.WRONG_REACTIVITY_RECORD, i+1 )
+                        return
+                    }
+
+                const key = `${fsmName}/${onState}`;   // fsmName/state
+                if ( length == 4 ) { // ruleLine with fsm
+                        if ( !subscribers[key] )   subscribers[key] = []
+                        subscribers [key].push ( listener   ) 
+
+                        const actKey = `${key}/${listener}`;   // fsmName/state/fsmSubscriberName
+                        actions [actKey] = listenerAct
+                    }
+
+                if ( length == 3 ) {   // ruleLine with function callback
+                        if ( !callbacks[key] )   callbacks[key] = []
+                        callbacks[key].push ( listener )
+                    }
+        }) // forEach ruleLine
+    if ( transformers )   {
+                Object.keys ( transformers ).forEach ( key => {
+                        const
+                              keyFn = transformers [key]
+                            , fn    = transformerLib [ keyFn] 
+                            ;
+                        if ( fn )   mod[key] = fn
+                    })
+        }
+    return { transformers: mod, subscribers, callbacks, actions }
+}} // _setTransitions func.
+
+
+
+module.exports = _setTransitions
+
+

package/src/methods/addFsm.js

@@ -0,0 +1,68 @@
+const askForPromise = require("ask-for-promise")
+
+function addFsm ( hub, msg ) {
+return function ( ins ) {
+            Object.keys(ins).forEach ( name => {
+                        if ( hub.fsm[name] ) {
+                                        hub._debugger ( msg.REGISTERED_FSM_NAME, name )
+                                        return
+                            }
+
+                        function reactivityComplete ( isInternalRequest ) {
+                                
+                                        if ( isInternalRequest       )   hub.haveInternalRequest = false
+                                        if ( hub.haveInternalRequest )   return
+
+                                        let  
+                                             emptyInternalCache = hub.cacheInternal.isEmpty ()
+                                           , emptyCache         = hub.cache.isEmpty ()
+                                           , emptyBoth          = emptyCache && emptyInternalCache
+                                           ;
+                                        if ( emptyBoth ) {  
+                                                hub.lock = false
+                                                return
+                                            }
+                                        let [ name, state, response ] = ( !emptyInternalCache ) ? hub.cacheInternal.pull () : hub.cache.pull ()                                        
+                                        if ( hub.cache.isEmpty ()         )   hub.lock = false
+                                        if ( hub.cacheInternal.isEmpty () )   hub.haveInternalRequest = false
+                                        hubUpdateWatcher ( name, state, response )
+                            } // reactivityComplete func.
+
+
+
+                        function hubUpdateWatcher (name,state,response) {
+                                    let executeReactivity;
+                                    if ( !hub.lock ) {
+                                                hub.lock = true
+                                                executeReactivity = askForPromise ()
+                                                executeReactivity.onComplete ( z =>  reactivityComplete ( false ) )   // complete of external reaction
+                                                hub._callback ( executeReactivity, name, state, response )
+                                                return
+                                        }
+
+                                    if ( response && response.___internalFlag ) {
+                                                if ( hub.haveInternalRequest ) {
+                                                                hub.cacheInternal.push ( [[ name, state, response ]])
+                                                                return
+                                                        }
+                                                let reactivityTask = askForPromise ();
+                                                reactivityTask.onComplete ( z => reactivityComplete ( true )  )   // complete of internal reaction
+                                                hub.haveInternalRequest = true;
+                                                hub._callback ( reactivityTask, name, state, response )
+                                                return
+                                       }
+                                    hub.cache.push ( [[ name, state, response ]])
+                            } // hubUpdateWatcher func.
+
+
+
+                        hub.fsm [name] = ins[name]
+                        hub.fsm [name].on ( 'update', (state,response) => hubUpdateWatcher (name,state,response)   )
+                })
+}} // addFsm func.
+
+
+
+module.exports = addFsm
+
+

package/src/methods/addFunctions.js

@@ -0,0 +1,16 @@
+function addFunctions ( hub, msg ) {
+return function ( ins ) {
+    Object.keys(ins).forEach ( name => {
+                if ( hub.fnCallbacks[name] ) {
+                            hub._debugger ( msg.REGISTERED_FUNCTION_NAME, name )
+                            return
+                    }
+                hub.fnCallbacks [name] = ins[name]
+        })
+}} // addFunctions func.
+
+
+
+module.exports = addFunctions
+
+

package/src/methods/index.js

@@ -0,0 +1,23 @@
+const
+      _setTransitions = require ( './_setTransitions' )
+    , _debugger       = require ( './_debugger'       )
+    , _callback       = require ( './_callback'       )
+
+    , addFsm       = require ( './addFsm'       )
+    , addFunctions = require ( './addFunctions' )
+   ;
+
+const fn = {
+                  _setTransitions
+                , _debugger
+                , _callback
+
+                , addFsm
+                , addFunctions
+        };
+
+
+
+module.exports = fn
+
+

package/src/msg.js

@@ -0,0 +1,12 @@
+const msg = {   // Error and warnings messages
+                  WRONG_REACTIVITY_RECORD  : 'Error: Wrong reactivity record on row %s.'
+                , REGISTERED_FSM_NAME      : 'Warning: FSM "%s" is already registered.'
+                , REGISTERED_FUNCTION_NAME : 'Warning: Function "%s" is already registered.'
+                , MISSING_FSM              : 'Warning: Fsm "%s" is not registered to the hub.'
+                , MISSING_FN               : 'Warning: Function "%s" is not registered to the hub.'
+            };
+
+
+module.exports = msg
+
+

package/test/{hub.js → 01-basics.js}

@@ -1,8 +1,7 @@
 const
   FsmHub  = require ('../src/index.js')
 , Fsm     = require ( '@peter.naydenov/fsm')
-, chai    = require ( 'chai' )
-, expect  = require ( 'expect.js')
+, expect  = require ( 'chai' ).expect
 ;
 
 
@@ -14,7 +13,7 @@ const
   , MISSING_FN               = 'Warning: Function "%s" is not registered to the hub.'
   ;
 
-describe ( 'Finite State Machine', () => {
+describe ( 'Fsm Hub', () => {
 
 
 it ( 'Hub structure', () => {
@@ -26,7 +25,7 @@ it ( 'Hub structure', () => {
             };
 
         const hub = new FsmHub ( hubDetails )
-        
+
         expect ( hub ).to.have.property ( 'fsm' )
         expect ( hub ).to.have.property ('fnCallbacks')
         expect ( hub ).to.have.property ( 'transformers' )
@@ -35,7 +34,7 @@ it ( 'Hub structure', () => {
         expect ( hub ).to.have.property ( 'callbacks' )
 
         expect ( hub.subscribers ).to.have.property ( 'one/active' )
-        expect ( hub.subscribers['one/active'] ).to.be.an.array
+        expect ( hub.subscribers['one/active'] ).to.be.an ( 'array' )
         expect ( hub.subscribers['one/active'][0] ).to.be.equal ( 'two' )
 
         expect ( hub.actions ).to.have.property ( 'one/active/two' )
@@ -98,7 +97,7 @@ it ( 'Add a callback function', () => {
         expect ( activeCallbacks.length ).to.be.equal ( 1 )   // function 'more' should be register only in fnCallbacks.
 
         expect ( hub.callbacks ).to.have.property ( 'two/active' )
-        expect ( hub.callbacks['two/active']).to.be.an.array
+        expect ( hub.callbacks['two/active']).to.be.an ( 'array' )
         expect ( hub.callbacks['two/active'][0]).to.be.equal ( 'showme' )
 
         expect ( hub.fnCallbacks ).to.have.property ( 'showme' )
@@ -169,7 +168,7 @@ it ( 'Use hub-tranformer', done  => {
 
         // Define hub
         const 
-            machine = {
+            hubMachine = {
                             reactivity : [
                                               [ 'one', 'active', 'two', 'activate'  ]
                                             , [ 'two', 'active', 'showme' ]
@@ -190,8 +189,8 @@ it ( 'Use hub-tranformer', done  => {
                         }
         ;
         // Initialize the hub
-        const hub = new FsmHub ( machine, transformerLib );
-
+        const hub = new FsmHub ( hubMachine, transformerLib );
+        
         function showme (transitionResult) {
                     const {
                               second
@@ -229,15 +228,15 @@ it ( 'Wrong length of reactivity record', () => {
                                             'two/showme' : 'simple'
                                         }       
                         };
-        const originalDebuger = FsmHub.prototype._debuger;
-        FsmHub.prototype._debuger  = function ( str, data ) {
+        const originalDebugger = FsmHub.prototype._debugger;
+        FsmHub.prototype._debugger  = function ( str, data ) {
                                         expect ( str ).to.be.equal ( WRONG_REACTIVITY_RECORD )
                                 }
         const hub = new FsmHub ( hubDetails );
 
         expect ( hub.callbacks ).to.have.property ( 'two/active' )
         expect ( hub.callbacks ['two/active'][0]).to.be.equal ( 'showme' )
-        FsmHub.prototype._debuger = originalDebuger
+        FsmHub.prototype._debugger = originalDebugger
     }) // it wrong reactivity record
 
 
@@ -256,15 +255,15 @@ it ( 'Wrong type of reactivity record', () => {
                                             'two/showme' : 'simple'
                                         }       
                         };
-        const originalDebuger = FsmHub.prototype._debuger;
-        FsmHub.prototype._debuger  = function ( str, data ) {
+        const originalDebugger = FsmHub.prototype._debugger;
+        FsmHub.prototype._debugger  = function ( str, data ) {
                                         expect ( str ).to.be.equal ( WRONG_REACTIVITY_RECORD )
                     }
         const hub = new FsmHub ( hubDetails );
 
         expect ( hub.callbacks ).to.have.property ( 'two/active' )
         expect ( hub.callbacks ['two/active'][0]).to.be.equal ( 'showme' )
-        FsmHub.prototype._debuger = originalDebuger
+        FsmHub.prototype._debugger = originalDebugger
     }) // it wrong reactivity record
 
 
@@ -292,7 +291,7 @@ it ( 'Try to add FSM name that is already registered', () => {
                         };
         // Initialize the hub
         const hub = new FsmHub ( hubDescription );
-        hub._debuger  = function ( str, data ) {
+        hub._debugger  = function ( str, data ) {
                     expect ( str ).to.be.equal ( REGISTERED_FSM_NAME )
                 }
 
@@ -317,7 +316,7 @@ it ( 'Try to add function name that is already registered', () => {
                                         ]
                         };
         const hub = new FsmHub ( machine );
-        hub._debuger  = function ( str, data ) {
+        hub._debugger  = function ( str, data ) {
                     expect ( str ).to.be.equal ( REGISTERED_FUNCTION_NAME )
                 }
 
@@ -390,7 +389,7 @@ it ( 'Not registered fsm subscriber', done => {
         const hub = new FsmHub ( machine, transformerLib );
 
         hub.addFsm ({  one })
-        hub._debuger = function ( str, data ) {
+        hub._debugger = function ( str, data ) {
                 expect ( str ).to.be.equal ( MISSING_FSM )
                 done ()
             }
@@ -448,7 +447,7 @@ it ( 'Transformer is not a function', () => {
         const hub = new FsmHub ( machine, transformerLib );
 
         hub.addFsm ({  one, two })
-        // hub._debuger = function ( str, data ) {
+        // hub._debugger = function ( str, data ) {
         //         expect ( str ).to.be.equal ( MISSING_FSM )
         //         done ()
         //     }
@@ -507,13 +506,13 @@ it ( 'Callback-function with data argument', done  => {
                                           }       
                           }
             , transformerLib = {
-                                simple ( state, data ) { return `simple-${state}-${data}` }
+                                simple ( state, data ) { return { try: `simple-${state}-${data.try}`} }
                             }
             ;
           // Initialize the hub
           const hub = new FsmHub ( machine, transformerLib );
           function showme ( data ) {
-                                expect ( data ).to.equal ( 'simple-active-try' )
+                                expect ( data.try ).to.equal ( 'simple-active-try' )
                                 expect ( two.state == 'active' )
                                 one.update ( 'stop' )
                 } // showme func.
@@ -526,119 +525,28 @@ it ( 'Callback-function with data argument', done  => {
           hub.addFsm ({  one, two })
           hub.addFunctions ({ showme, final })
           // Start!
-          one.update ( 'activate', 'try' )
+          one.update ( 'activate', { try:'try'} )
   }) // it callback-function with data argument
 
 
 
 
+  it ( 'Test a Debugger', () => {
+    const 
+        machine = {
+                        reactivity : [
+                                          [ 'one', 'active', 'two', 'activate'  ]
+                                        , [ 'two', 'active', 'showme' ]
+                                    ]
+                        , debug : true
+                    };
+    const hub = new FsmHub ( machine );
+    hub._debugger ( 'Test for %s', 'debugger' )
+}) // it Test debugger
 
-it ( 'Check multiple systems'
-//  , () => {
-//     const 
-//             userDescription = {
-//                               init  : 'none'
-//                             , table : [
-//                                           [ 'none'       , 'start'       , 'inProgress' , 'setupUser'       , [ 'ifSpecial', false ]    ]
-//                                         , [ 'inProgress' , 'ifSpecial'   , 'special'    , 'setupSpecialUser', [ false, 'setupNormal']   ]
-//                                         , [ 'inProgress' , 'setupNormal' , 'active'     , 'setupActiveUser'                             ]
-//                                         , [ 'active'     , 'test'        , 'testUser'   , 'setupTestUser'                               ]
-//                                     ]
-//                     }
-//             , screenDescription = {
-//                               init  : 'none'
-//                             , table : [
-//                                           [ 'none', 'start', 'browse', 'startScreen' ]
-//                                         , [ 'browse', 'page', 'browse', 'loadPage'   ]
-                                        
-//                                         , [ 'none'  , 'sync', 'browse', 'syncUserState',  [ 'page', false ] ]
-//                                         , [ 'browse', 'sync', 'browse', 'syncUserState',  [ 'page', false ] ]
-//                                     ]
-//                             , stateData : {
-//                                               user : 'N/A'  // sync with user state
-//                                             , page : 'N/A'  // current active page
-//                                     }
-//                 }
-//             , hubDescription  = {
-//                               reactivity : [
-//                                             [ 'user' , 'none'   , 'screen', 'sync' ]
-//                                           , [ 'user' , 'active' , 'screen', 'sync' ]
-//                                           , [ 'user', 'testUser', 'screen', 'sync' ]
-//                                         ]
-//                             , transformers : {
-//                                             'user/screen' : 'transferUserState'
-//                                         }
-//                 }
-//             ;
-    
-//     const userLib = {
-//               setupUser ( task, dependencies, stateData, dt) {
-//                     console.log ( 'setupUser' )
-//                     task.done ({ success : true })
-//                } // setupUser func.
-//             , setupSpecialUser ( task, dependencies, stateData, dt) {
-//                     console.log ( 'setupSpecialUser' )
-//                     task.done({ success : false })
-//                } // setupSpecialUser func.
-//             , setupActiveUser ( task, dependencies, stateData, dt) {
-//                      console.log ( 'setup Active User' )
-//                      task.done ({ success : true })
-//                } // setupActiveUser func.
-//             , setupTestUser ( task, dependencies, stateData, dt ) {
-//                     console.log ( 'USER: setup test user' )
-//                     task.done ({ success : true })
-//                }
-//         } // userLib 
-//     const screenLib = {
-//               startScreen (task, dependencies, stateData, dt) {
-//                      console.log ( 'SCREEN: startScreen' )
-//                      task.done ({ success : true })
-//                 }
-//             , loadPage (task, dependencies, stateData, dt) {
-//                     console.log ( `SCREEN: loadPage, user - ${stateData.user}`)
-//                     task.done ({ success : true })
-//                 }
-//             , syncUserState (task, dependencies, stateData, dt) {
-//                     console.log ( `SCREEN: Sync user state. ${dt}`)
-//                     stateData.user = dt
-//                     task.done ({ success : true, stateData })
-//                 }
-//         } // screenLib
-//     const hubTransormers = {
-//             transferUserState ( state, response ) {
-//                         return state
-//                 }
-//         } // hubTransformers
-
-//     const
-//           user   = new Fsm ( userDescription, userLib )
-//         , screen = new Fsm ( screenDescription, screenLib )
-//         , hub    = new FsmHub ( hubDescription, hubTransormers )
-//         ;
-
-//     hub.addFsm ({ user, screen })
-//     user.update ( 'start' )
-//     setTimeout ( () =>  user.update ('test'), 300 )
-// }
-) // it check multiple systems
-
-
-
-
-
-it ( 'Test a Debuger', () => {
-        const 
-            machine = {
-                            reactivity : [
-                                              [ 'one', 'active', 'two', 'activate'  ]
-                                            , [ 'two', 'active', 'showme' ]
-                                        ]
-                            , debug : true
-                        };
-        const hub = new FsmHub ( machine );
-        hub._debuger ( 'Test for %s', 'debuger' )
-}) // it Test debuger
 
+
+  
 }) // describe
 
 

package/test/02-multipleSystem.js

@@ -0,0 +1,159 @@
+const
+  FsmHub  = require ('../src/index.js')
+, Fsm     = require ( '@peter.naydenov/fsm')
+, expect  = require ( 'chai' ).expect
+;
+
+describe ( 'Fsm Hub', () => {
+
+  it ( 'Check multiple systems', done => {
+    
+    /**
+     *  Description:
+     *   Create a 3 fsm systems - human, spy, and recorder
+     *    - Human: Can receive good and bad news and change his mood according the news;
+     *    - Spy: Spy on human and sends to recorder the messages that make him unhappy;
+     *    - Recorder: Storage for bad news. When messages are 3 will stop with the recording and will call function "TimeForChange"
+     */
+
+    const 
+          recorderDescription = {  // Description of the recorder
+                              init  : 'empty'
+                            , table : [
+                                              [ 'empty' , 'write'   , 'used'  , 'add_a_warning'     ]
+                                            , [ 'used'  , 'write'   , 'used'  , 'add_a_warning',   [ 'isFull?', false ]  ]
+                                            , [ 'used'  , 'isFull?'  , 'full'  , 'check_if_full'    ]
+                                    ]
+                            , stateData : {
+                                                reasons: []
+                                            }
+            }
+        , humanDescription = {   // Very weak description of human emotions. Just for testing purposes
+                              init  : 'happy'
+                            , table : [
+                                              [  'happy'   , 'goodNews', 'happy'   , 'feel_happy' ]
+                                            , [  'happy'   , 'badNews' , 'unhappy' , 'feel_bad'   ]
+                                            , [  'unhappy' , 'badNews' , 'unhappy' , 'feel_bad'   ]
+                                            , [  'unhappy' , 'goodNews', 'happy'   , 'feel_bad'   ]
+                                  ]
+            }
+        , spyDescription = {
+                              init: 'positive'
+                            , table : [
+                                          [ 'positive', 'bad'  , 'negative' , 'onBad'  ]
+                                        , [ 'negative', 'good' , 'positive' , 'onGood' ]
+                                        , [ 'negative', 'bad'  , 'negative' , 'onBad'  ]
+                                ]
+            }
+        , hubDescription = {
+                            reactivity : [
+                                      [ 'human'    , 'unhappy'  , 'spy'            , 'bad'     ]
+                                    , [ 'spy'      , 'negative' , 'recorder'       , 'write'   ]
+                                    , [ 'recorder' , 'full'     , 'timeForChange'              ]
+                                    , [ 'recorder' , 'full'     , 'test'              ]
+                                ]
+                            , transformers : {
+                                                  'human/spy'     : 'emotion2spy'
+                                                , 'spy/recorder'  : 'spy2record'
+                                            }
+                    }
+        ;
+    // Define libs
+    const
+            humanLib = {
+                          feel_happy (task,dependencies, stateData, data ) {
+                                    task.done ({ 
+                                                      success : true 
+                                                    , response : data
+                                                })
+                            }
+                        , feel_bad ( task, dependencies, stateData, data ) { 
+                                    task.done ({ 
+                                                  success : true 
+                                                , response: data
+                                            })
+                            }
+                }
+            , spyLib = {
+                          onBad ( task, dependencies, stateData, data  ) {
+                                    task.done ({ 
+                                                  success   : true 
+                                                , response  : data
+                                            })
+                            }
+                        , onGood ( task, dependencies, stateData, data ) {
+                                    task.done ({ 
+                                                  success : true 
+                                                , response : data
+                                            })
+                            }
+                }
+            , recorderLib = {
+                          add_a_warning ( task, dependencies, stateData, data ) {
+                                    const { reasons } = stateData;
+                                    if ( !reasons.includes(data.response) )   stateData.reasons.push ( data.response )
+                                    task.done ({ 
+                                              success : true 
+                                            , stateData
+                                            , response : data
+                                        })
+                            }
+                        , check_if_full ( task, dependencies, stateData, data ) {
+                                    const { reasons } = stateData;
+                                    if ( reasons.length >= 3 )   task.done ({ success : true, response: data })
+                                    else                         task.done ({ success : false, response: data })
+                            }
+                }
+            , hubLib = {
+                            emotion2spy ( state,response) { 
+                                                return { response }
+                                    }  
+                          , spy2record  ( state, response ) { return response }
+                }
+            ;
+    // Define machines and the hub
+    const
+              human    = new Fsm ( humanDescription , humanLib   )
+            , spy      = new Fsm ( spyDescription , spyLib     )
+            , recorder = new Fsm ( recorderDescription, recorderLib )
+            , theHub   = new FsmHub ( hubDescription , hubLib  )
+            ;
+    let result = false
+    
+            
+    function timeForChange ( state, response ) {
+                        result = 'DONE'
+        }
+
+    function test ( state, response ) {
+                    expect ( result ).to.be.equal ( 'DONE' )
+                    expect ( theHub.cache.isEmpty ()         ).to.be.true
+                    expect ( theHub.cacheInternal.isEmpty () ).to.be.true
+                    let rec = recorder.exportState ().stateData.reasons
+                    
+                    expect ( rec ).to.be.an ( 'array' ) 
+                    expect ( rec ).to.have.length ( 3 )
+                    expect ( rec[0] ).to.be.equal ( 'Car crash'      )
+                    expect ( rec[1] ).to.be.equal ( 'Airplane crash' )
+                    expect ( rec[2] ).to.be.equal ( 'Storm'          )
+                    done ()                    
+        }
+
+    theHub.addFsm ({ human, spy, recorder })
+    theHub.addFunctions ({ timeForChange, test })
+
+    human.update ( 'goodNews', 'friends' )
+    human.update ( 'badNews', 'Car crash' )
+    human.update ( 'badNews', 'Airplane crash' )
+    human.update ( 'badNews', 'Storm' )
+
+}) // it check multiple systems
+
+
+
+
+
+
+}) // describe
+
+