Implements Parallel (#4)

* Creates parallel state constructor

- It follows description from README.md

* Udpates README.md to remove "to be implemented" flag from Parallel

* Change code to extract scope and event name for parallel emit

* Removes constructor assertions for instantiation and input type

* Fix typo: s/collon/colon

* Rewrite arrow function to regular function syntax for `state` getter

* Fixes typos collon and remove to be implemented from README

Author: brunoskonrad

README.md

@@ -79,8 +79,8 @@ machine.join('next', nanostate('review', {
 }))
 ```
 
-## Parallel (to be implemented)
-To be implemented. Sometimes there's multiple parallel states that need
+## Parallel
+Sometimes there's multiple parallel states that need
 expressing; `nanostate.parallel` helps with that. For example when editing
 text, a particular piece of text might be `bold`, `italic` and `underlined` at
 the same time. The trick is that all of these states operate in parallel

index.js

@@ -1,5 +1,6 @@
 var Nanobus = require('nanobus')
 var assert = require('assert')
+var Parallelstate = require('./parallel-state')
 
 module.exports = Nanostate
 
@@ -23,3 +24,7 @@ Nanostate.prototype.emit = function (eventName) {
   this.state = nextState
   Nanobus.prototype.emit.call(this, eventName)
 }
+
+Nanostate.parallel = function (transitions) {
+  return new Parallelstate(transitions)
+}

parallel-state.js

@@ -0,0 +1,38 @@
+var Nanobus = require('nanobus')
+var assert = require('assert')
+
+module.exports = Parallelstate
+
+function Parallelstate (transitions) {
+  assert.equal(typeof transitions, 'object', 'nanostate: transitions should be type object')
+
+  this.scopes = Object.keys(transitions)
+  this.transitions = transitions
+
+  Object.defineProperty(this, 'state', {
+    get: function () {
+      return this.scopes.reduce(function (state, scope) {
+        state[scope] = transitions[scope].state
+        return state
+      }, {})
+    }
+  })
+
+  Nanobus.call(this)
+}
+
+Parallelstate.prototype = Object.create(Nanobus.prototype)
+
+Parallelstate.prototype.emit = function (eventName) {
+  var hasColon = eventName.indexOf(':') >= 0
+  assert.ok(hasColon, `nanostate.emit: invalid transition ${this.state} -> ${eventName}. For parallel nanostate eventName must have a colon ":"`)
+
+  var eventNameSplitted = eventName.split(':')
+  var scope = eventNameSplitted[0]
+  var event = eventNameSplitted[1]
+  assert.ok(scope, `nanostate.emit: invalid scope ${scope} for parallel emitting`)
+
+  this.transitions[scope].emit(event)
+
+  Nanobus.prototype.emit.call(this, eventName)
+}

test.js

@@ -36,3 +36,59 @@ function move (assert, machine, states) {
     assert.equal(machine.state, expected, `from ${initial} to ${expected}`)
   })
 }
+
+var createParallelTransitions = () => ({
+  bold: nanostate('off', {
+    on: { 'toggle': 'off' },
+    off: { 'toggle': 'on' }
+  }),
+  underline: nanostate('off', {
+    on: { 'toggle': 'off' },
+    off: { 'toggle': 'on' }
+  }),
+  italics: nanostate('off', {
+    on: { 'toggle': 'off' },
+    off: { 'toggle': 'on' }
+  }),
+  list: nanostate('none', {
+    none: { bullets: 'bullets', numbers: 'numbers' },
+    bullets: { none: 'none', numbers: 'numbers' },
+    numbers: { bullets: 'bullets', none: 'none' }
+  })
+})
+
+tape('create parallel state', (assert) => {
+  var machine = nanostate.parallel(createParallelTransitions())
+
+  machine.emit('bold:toggle')
+  assert.deepEqual(machine.state, {
+    bold: 'on', underline: 'off', italics: 'off', list: 'none'
+  })
+
+  assert.end()
+})
+
+tape('change states in parallel machine', (assert) => {
+  var machine = nanostate.parallel(createParallelTransitions())
+
+  machine.emit('underline:toggle')
+  machine.emit('list:numbers')
+  assert.deepEqual(machine.state, {
+    bold: 'off', underline: 'on', italics: 'off', list: 'numbers'
+  })
+
+  machine.emit('bold:toggle')
+  machine.emit('underline:toggle')
+  machine.emit('italics:toggle')
+  machine.emit('list:bullets')
+  assert.deepEqual(machine.state, {
+    bold: 'on', underline: 'off', italics: 'on', list: 'bullets'
+  })
+
+  machine.emit('list:none')
+  assert.deepEqual(machine.state, {
+    bold: 'on', underline: 'off', italics: 'on', list: 'none'
+  })
+
+  assert.end()
+})