math-codegen 0.3.4 → 0.4.1

package/README.md

@@ -1,9 +1,8 @@
-# math-codegen 
+# math-codegen
 
-[![Build Status][travis-image]][travis-url] 
+[![Build Status][travis-image]][travis-url]
 [![NPM][npm-image]][npm-url]
-[![Coverage Status][coveralls-image]][coveralls-url]
-[![Stability](https://img.shields.io/badge/stability-unstable-yellow.svg)]()
+[![codecov](https://codecov.io/gh/mauriciopoppe/math-codegen/branch/master/graph/badge.svg)](https://codecov.io/gh/mauriciopoppe/math-codegen)
 
 [![js-standard-style](https://cdn.rawgit.com/feross/standard/master/badge.svg)](https://github.com/feross/standard)
 
@@ -40,11 +39,11 @@
 
 An interpreter for mathematical expressions which allows the programmer to change the usual semantic of an
 operator bringing the operator overloading polymorphism to JavaScript (emulated with function calls),
-in addition an expression can be evaluated under any adapted namespace providing expression portability between numeric libraries 
+in addition an expression can be evaluated under any adapted namespace providing expression portability between numeric libraries
 
 ### Lifecycle
 
-- `parse`: a mathematical expression is parsed with [`mr-parse`](https://github.com/maurizzzio/mr-parser), in the ideal scenario
+- `parse`: a mathematical expression is parsed with [`mr-parse`](https://github.com/mauriciopoppe/mr-parser), in the ideal scenario
 it would use [math.js expression parser](http://mathjs.org/docs/expressions/index.html) however it's not modularized yet
 and including all math.js is just an overkill, probably `mr-parse` will be replaced with math.js expression parser when
 it reaches npm as a module :)
@@ -90,7 +89,7 @@ on the namespace to transform these values into values the namespace can operate
 
 Now that we have a parsed expression we have to compile it against a namespace to produce
 executable JavaScript code
- 
+
 ```javascript
 parse('1 + 2 * x').compile(namespace)
 
@@ -105,7 +104,7 @@ parse('1 + 2 * x').compile(namespace)
       return ns.add(ns.factory(1), ns.mul(ns.factory(2), (scope["x"] || ns["x"]) ))
     }
   }
-})(definitions)   // definitions created by math-codegen    
+})(definitions)   // definitions created by math-codegen
 ```
 
 #### Eval
@@ -122,7 +121,7 @@ Math.js expression parser API is quite similar having the same lifecycle however
 important facts I've found:
 
 - `math.js` v1.x arrays can represent matrices with `ns.matrix` or as a raw arrays, `math-codegen` doesn't
-make any assumptions of the arrays and treats them just like any other literal allowing the namespace to 
+make any assumptions of the arrays and treats them just like any other literal allowing the namespace to
 decide what to do with an array in its `factory` method
 
 ### Operators
@@ -189,37 +188,37 @@ new CodeGenerator([options]).parse(code).compile(namespace).eval(scope)
 * `interpreter` {Interpreter} Instance of the Interpreter class
 * `defs` {Object} An object with additional definitions available during the compilation
 that exist during the instance lifespan
- 
+
 **params**
 * `options` {Object} Options available for the interpreter
-  * `[options.factory="ns.factory"]` {string} factory method under the namespace 
+  * `[options.factory="ns.factory"]` {string} factory method under the namespace
   * `[options.raw=false]` {boolean} True to interpret OperatorNode, UnaryNode and ArrayNode
    in a raw way without wrapping the operators with identifiers e.g. `-1` will be compiled as
    `-1` instead of `ns.negative(ns.factory(1))`
   * `[options.rawArrayExpressionElements=true]` {boolean} true to interpret the array elements in a raw way
   * `[options.rawCallExpressionElements=false]` {boolean} true to interpret call expression
-   elements in a raw way
+  * `[options.applyFactoryToScope=false]` {boolean} true to apply the factory function on non-function values of the scope/namespace
 
 ### `instance.parse(code)`
 
 **chainable**
 **params**
 * `code` {string} string to be parsed
- 
-Parses a program using [`mr-parse`](https://github.com/maurizzzio/mr-parser), each Expression Statement is saved in
+
+Parses a program using [`mr-parse`](https://github.com/mauriciopoppe/mr-parser), each Expression Statement is saved in
 `instance.statements`
 
-The documentation for the available nodes is described in [`mr-parse`](https://github.com/maurizzzio/mr-parser) 
-  
+The documentation for the available nodes is described in [`mr-parse`](https://github.com/mauriciopoppe/mr-parser)
+
 ### `instance.compile(namespace)`
-  
+
 **chainable**
 **params**
 * `namespace` {Object}
 
 Compiles the code making `namespace`'s properties available during evaluation, **it's required
 to have the `factory` property defined**
- 
+
 **returns** {Object}
 * `return.code` {string} the body of the function to be evaluated with `eval`
 * `return.eval` {Function} Function to be evaluated under a context
@@ -346,11 +345,7 @@ instance
 
 ## License
 
-2015 MIT © [Mauricio Poppe]()
+MIT
 
 [npm-image]: https://img.shields.io/npm/v/math-codegen.svg?style=flat
 [npm-url]: https://npmjs.org/package/math-codegen
-[travis-image]: https://travis-ci.org/maurizzzio/math-codegen.svg?branch=master
-[travis-url]: https://travis-ci.org/maurizzzio/math-codegen
-[coveralls-image]: https://coveralls.io/repos/maurizzzio/math-codegen/badge.svg?branch=master
-[coveralls-url]: https://coveralls.io/r/maurizzzio/math-codegen?branch=master

package/lib/CodeGenerator.js

@@ -16,6 +16,7 @@ CodeGenerator.prototype.setDefs = function (defs) {
 }
 
 CodeGenerator.prototype.compile = function (namespace) {
+  var self = this
   if (!namespace || !(typeof namespace === 'object' || typeof namespace === 'function')) {
     throw TypeError('namespace must be an object')
   }
@@ -34,11 +35,18 @@ CodeGenerator.prototype.compile = function (namespace) {
   this.defs.ns = namespace
   this.defs.$$mathCodegen = {
     getProperty: function (symbol, scope, ns) {
+      function applyFactoryIfNeeded (value) {
+        if (self.interpreter.options.applyFactoryToScope && typeof value !== 'function') {
+          return ns.factory(value)
+        }
+        return value
+      }
+
       if (symbol in scope) {
-        return scope[symbol]
+        return applyFactoryIfNeeded(scope[symbol])
       }
       if (symbol in ns) {
-        return ns[symbol]
+        return applyFactoryIfNeeded(ns[symbol])
       }
       throw SyntaxError('symbol "' + symbol + '" is undefined')
     },

package/lib/Interpreter.js

@@ -18,7 +18,8 @@ var Interpreter = function (owner, options) {
     factory: 'ns.factory',
     raw: false,
     rawArrayExpressionElements: true,
-    rawCallExpressionElements: false
+    rawCallExpressionElements: false,
+    applyFactoryToScope: false
   }, options)
 }
 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "math-codegen",
-  "version": "0.3.4",
+  "version": "0.4.1",
   "description": "Generates code from mathematical expressions",
-  "bugs": "https://github.com/maurizzzio/math-codegen/issues",
+  "bugs": "https://github.com/mauricopoppe/math-codegen/issues",
   "license": "MIT",
   "main": "index.js",
   "author": "Mauricio Poppe <mauricio.poppe@gmail.com>",
@@ -24,20 +24,19 @@
     "parse"
   ],
   "dependencies": {
-    "extend": "^3.0.0",
-    "mr-parser": "^0.1.0"
+    "extend": "^3.0.2",
+    "mr-parser": "^0.2.1"
   },
   "devDependencies": {
-    "coveralls": "^2.11.2",
+    "coveralls": "^2.11.4",
     "doctoc": "^0.14.2",
-    "istanbul": "^0.3.8",
-    "mocha": "^2.2.1",
-    "mocha-lcov-reporter": "^0.0.2",
-    "nodemon": "^1.3.7",
-    "standard": "^4.5.4"
+    "mocha": "^2.3.3",
+    "nodemon": "^1.7.1",
+    "standard": "^4.5.4",
+    "nyc": "^15.1.0"
   },
   "scripts": {
-    "istanbul": "istanbul cover _mocha --report lcovonly -- -R spec test/",
+    "coverage": "nyc npm run test",
     "lint": "standard",
     "test": "mocha -R spec test/",
     "test:watch": "nodemon --watch lib --watch test --watch index.js --exec 'npm test'",