feat(Operators): add string template tag

packages/cerebral/src/operators/index.js

@@ -5,6 +5,7 @@ export {default as wait} from './wait'
 
 export {default as state} from './state'
 export {default as input} from './input'
+export {default as string} from './string'
 
 export {default as concat} from './concat'
 export {default as merge} from './merge'

packages/cerebral/src/operators/input.test.js

@@ -1,21 +1,19 @@
 /* eslint-env mocha */
 import Controller from '../Controller'
 import assert from 'assert'
-import {input, set, state} from './'
+import {input, string} from './'
 
 describe('operator.input', () => {
   it('should read value from input', () => {
     const controller = new Controller({
-      state: {
-        foo: 'bar'
-      },
       signals: {
         test: [
-          set(state`foo`, input`foo`)
+          (context) => {
+            assert.deepEqual(string`foo.${input`foo`}`(context).toValue(), 'foo.bar')
+          }
         ]
       }
     })
-    controller.getSignal('test')({foo: 'baz'})
-    assert.deepEqual(controller.getState(), {foo: 'baz'})
+    controller.getSignal('test')({foo: 'bar'})
   })
 })

packages/cerebral/src/operators/state.test.js

@@ -1,7 +1,7 @@
 /* eslint-env mocha */
 import Controller from '../Controller'
 import assert from 'assert'
-import {input, state} from './'
+import {state, string} from './'
 
 describe('operator.state', () => {
   it('should build path', () => {
@@ -11,8 +11,8 @@ describe('operator.state', () => {
       },
       signals: {
         test: [
-          () => {
-            assert.deepEqual(state`foo.${input`ref`}`({input: {ref: 'bar'}}).path, 'foo.bar')
+          (context) => {
+            assert.deepEqual(string`foo.${state`foo`}`(context).toValue(), 'foo.bar')
           }
         ]
       }

packages/cerebral/src/operators/string.js

@@ -0,0 +1,16 @@
+import populatePath from './helpers/populatePath'
+
+export default function string (strings, ...values) {
+  return (context) => {
+    const target = 'string'
+    const path = populatePath(context, strings, values)
+
+    return {
+      target,
+      path,
+      toValue () {
+        return path
+      }
+    }
+  }
+}

packages/cerebral/src/operators/string.test.js

@@ -0,0 +1,19 @@
+/* eslint-env mocha */
+import Controller from '../Controller'
+import assert from 'assert'
+import {input, string} from './'
+
+describe('operator.string', () => {
+  it('should build path', () => {
+    const controller = new Controller({
+      signals: {
+        test: [
+          (context) => {
+            assert.deepEqual(string`foo.${input`ref`}`(context).toValue(), 'foo.bar')
+          }
+        ]
+      }
+    })
+    controller.getSignal('test')({ref: 'bar'})
+  })
+})