feat(code): allow temp vars

Author: solkimicreb

README.md

@@ -40,6 +40,17 @@ const code = compiler.compileCode('return prop1 + prop2')
 const sum = code({prop1: 1, prop2: 2}) // sum is 3
 ```
 
+The returned function also accepts a second object argument, that may contain temporary variables.
+Temporary variables are added to the context object while the code is executing and removed after.
+They are favored over the permanent context variables.
+
+```js
+const code = compiler.compileCode('return prop1 + prop2')
+const context = {prop1: 1, prop2: 2}
+const temporary = {prop1: 2}
+const sum = code(context, temporary) // sum is 4, context is still {prop1: 1, prop2: 2}
+```
+
 ### compiler.compileExpression(String)
 
 This method creates a function out of a string and returns it. The returned function takes

compiler.js

@@ -10,6 +10,7 @@ if (typeof window !== 'undefined') globalObj = window // eslint-disable-line
 else if (typeof global !== 'undefined') globalObj = global // eslint-disable-line
 else if (typeof self !== 'undefined') globalObj = self // eslint-disable-line
 globalObj.$nxCompileToSandbox = toSandbox
+globalObj.$nxCompileCreateBackup = createBackup
 
 const proxies = new WeakMap()
 const expressionCache = new Map()
@@ -22,10 +23,10 @@ function compileExpression (src) {
   }
   let expression = expressionCache.get(src)
   if (!expression) {
-    expression = new Function('sandbox', // eslint-disable-line
-      `sandbox = $nxCompileToSandbox(sandbox)
+    expression = new Function('context', // eslint-disable-line
+      `const sandbox = $nxCompileToSandbox(context)
       try { with (sandbox) { return ${src} } } catch (err) {
-        if (!(err instanceof ReferenceError || err instanceof TypeError)) throw err
+        if (!(err instanceof TypeError)) throw err
       }`)
     expressionCache.set(src, expression)
   }
@@ -38,9 +39,15 @@ function compileCode (src) {
   }
   let code = codeCache.get(src)
   if (!code) {
-    code = new Function('sandbox', // eslint-disable-line
-    `sandbox = $nxCompileToSandbox(sandbox)
-    with (sandbox) { ${src} }`)
+    code = new Function('context, tempVars', // eslint-disable-line
+    `const backup = $nxCompileCreateBackup(context, tempVars)
+    Object.assign(context, tempVars)
+    const sandbox = $nxCompileToSandbox(context)
+    try {
+      with (sandbox) { ${src} }
+    } finally {
+      Object.assign(context, backup)
+    }`)
     codeCache.set(src, code)
   }
   return code
@@ -58,6 +65,16 @@ function toSandbox (obj) {
   return sandbox
 }
 
+function createBackup (context, tempVars) {
+  if (typeof tempVars === 'object') {
+    const backup = {}
+    for (let key of Object.keys(tempVars)) {
+      backup[key] = context[key]
+    }
+    return backup
+  }
+}
+
 function has () {
   return true
 }

compiler.test.js

@@ -60,5 +60,23 @@ describe('nx-compile', () => {
       const code = compiler.compileCode('inner.prop1')
       expect(() => code({})).to.throw(TypeError)
     })
+
+    it('should accept temporary variables', () => {
+      const code = compiler.compileCode('return tempVar')
+      expect(code({}, {tempVar: 'temp'})).to.equal('temp')
+    })
+
+    it('should favour temporary variables over persistent ones', () => {
+      const code = compiler.compileCode('return tempVar')
+      expect(code({tempVar: 'persistent'}, {tempVar: 'temp'})).to.equal('temp')
+    })
+
+    it('should not modify the passed context persistently', () => {
+      const code = compiler.compileCode('return tempVar')
+      const context = {}
+      const result = code(context, {tempVar: 'temp'})
+      expect(result).to.equal('temp')
+      expect(context.tempVar).to.be.undefined
+    })
   })
 })

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@risingstack/nx-compile",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "description": "Execution of string as code in the context of an object, similarly to Object.eval().",
   "main": "compiler.js",
   "scripts": {