initial commit

Author: Mauricio Poppe

.editorconfig

@@ -0,0 +1,17 @@
+# http://editorconfig.org
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+end_of_line = lf
+
+[*.md]
+trim_trailing_whitespace = false
+
+[Makefile]
+indent_style = tab
+indent_size = 2

.eslintrc

@@ -0,0 +1,55 @@
+//
+// ESLint Configuration for generator-node-npm
+//
+// author: @iMauricio
+// date: 3/18/2015
+//
+// Helpful resources:
+//
+// - rules: http://eslint.org/docs/rules/
+// - configuration: http://eslint.org/docs/configuring/
+//
+// temporarily disable warnings
+// /*eslint-disable */
+// ...
+// /*eslint-enable */
+{
+    // check http://eslint.org/docs/configuring/#specifying-language-options
+    "ecmaFeatures": {
+      "generators": false
+    },
+    "parser": "espree",
+    "env": {
+        "node": true,
+        "mocha": true,
+        "browser": false                // true in the case it's module which will be bundled
+    },
+
+    // if the module needs globals set them here
+    "globals": {},
+
+    // 0 - turn the rule off
+    // 1 - turn the rule on as a warning (doesn't affect exit code)
+    // 2 - turn the rule on as an error (exit code is 1 when triggered)
+    "rules": {
+        "yoda": 0,                      // allow non-literals to be first in comparison expressions
+        "no-console": 0,                // disallow use of console (off by default in the node environment)
+        "no-trailing-spaces": 0,        // disable throwing errors for trailing spaces
+        "no-unused-expressions": 0,     // disallow usage of expressions in statement position
+        "quotes": [2, "single"],        // specify whether double or single quotes should be used
+        "strict": [2, "global"],        // controls location of Use Strict Directives
+        "no-unused-vars": [1, {
+            "vars": "all",
+            "args": "after-used"
+        }],
+        "no-shadow": 0,                 // disallow declaration of variables already declared in the outer scope
+        "eol-last": 0,                  // enforce newline at the end of file, with no multiple empty lines
+        "indent": [2, 2],               // this option sets a specific tab width for your code
+        "space-before-function-parentheses": [
+            2, {
+                "anonymous": "always",
+                "named": "never"
+            }
+        ]
+    }
+}

.gitignore

@@ -0,0 +1,45 @@
+# Created by https://www.gitignore.io
+
+### Node ###
+# Dependency directory
+node_modules
+npm-debug.log
+
+# Coverage directory used by tools like istanbul
+coverage
+
+
+### WebStorm ###
+## Directory-based project format:
+.idea/
+
+## File-based project format:
+*.iml
+*.ipr
+*.iws
+
+
+### SublimeText ###
+# cache files for sublime text
+*.tmlanguage.cache
+*.tmPreferences.cache
+*.stTheme.cache
+
+# workspace files are user-specific
+*.sublime-workspace
+
+# project files should be checked into the repository, unless a significant
+# proportion of contributors will probably not be using SublimeText
+# *.sublime-project
+
+# sftp configuration file
+sftp-config.json
+
+
+### Vim ###
+[._]*.s[a-w][a-z]
+[._]s[a-w][a-z]
+*.un~
+Session.vim
+.netrwhist
+*~

.travis.yml

@@ -0,0 +1,13 @@
+language: node_js
+env: CI=true
+sudo: false
+
+node_js:
+  - '0.10'
+
+install:
+  - npm install
+
+script:
+  - npm run lint
+  - npm run istanbul && cat ./coverage/lcov.info | coveralls

README.md

@@ -0,0 +1,38 @@
+# math-codegen 
+
+[![NPM][npm-image]][npm-url]
+
+[![Build Status][travis-image]][travis-url] [![Coverage Status][coveralls-image]][coveralls-url]  [![Dependency Status][david-image]][david-url]
+
+> Generates code from mathematical expressions
+
+## Install
+
+```sh
+$ npm install --save math-codegen
+```
+
+## Usage
+
+```js
+var mathCodegen = require('math-codegen');
+mathCodegen('Rainbow');
+```
+
+
+## API
+
+Coming soon...
+
+## License
+
+2015 MIT © [Mauricio Poppe]()
+
+[npm-image]: https://nodei.co/npm/math-codegen.png?downloads=true
+[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
+[coveralls-url]: https://coveralls.io/r/maurizzzio/math-codegen
+[david-image]: https://david-dm.org/maurizzzio/math-codegen.svg
+[david-url]: https://david-dm.org/maurizzzio/math-codegen

index.js

@@ -0,0 +1,8 @@
+/*
+ * math-codegen
+ *
+ * Copyright (c) 2015 Mauricio Poppe
+ * Licensed under the MIT license.
+ */
+'use strict';
+module.exports = require('./lib/CodeGenerator');

lib/CodeGenerator.js

@@ -0,0 +1,74 @@
+/**
+ * Created by mauricio on 5/12/15.
+ */
+'use strict';
+
+var esprima = require('esprima');
+var Interpreter = require('./Interpreter');
+var extend = require('extend');
+
+function CodeGenerator(options, defs) {
+  this.statements = [];
+  this.options = extend({
+    factory: 'ns.factory',
+    raw: false,
+    rawArrayExpressionElements: true,
+    rawCallExpressionElements: false
+  }, options);
+  this.defs = defs || {};
+  this.interpreter = new Interpreter(this);
+}
+
+CodeGenerator.prototype.setDefs = function (defs) {
+  this.defs = extend(this.defs, defs);
+  return this;
+};
+
+CodeGenerator.prototype.compile = function () {
+  if (typeof this.defs.ns !== 'object') {
+    throw Error('"ns" property needs to be defined on defs');
+  }
+
+  // default process scope hook
+  this.defs._processScope = this.defs._processScope || function () {};
+
+  var defsCode = Object.keys(this.defs).map(function (name) {
+    return 'var ' + name + ' = defs["' + name + '"];';
+  });
+
+  // statement join
+  if (!this.statements.length) {
+    throw Error('there are no statements saved in this generator');
+  }
+
+  // last statement is always a return statement
+  this.statements[this.statements.length - 1] = 'return ' + this.statements[this.statements.length - 1];
+
+  var code = this.statements.join(';\n');
+  var factoryCode =
+    defsCode.join(' ') +
+    'return {' +
+    '  eval: function (scope) {' +
+    '    scope = scope || {};' +
+    '    _processScope(scope);' +
+    '    ' + code +
+    '  },' +
+    '  code: \'' + code + '\'' +
+    '};';
+
+  /* eslint-disable */
+  var factory = new Function('defs', factoryCode);
+  /* eslint-enable */
+  return factory(this.defs);
+};
+
+CodeGenerator.prototype.parse = function (code) {
+  var self = this;
+  var program = esprima.parse(code);
+  this.statements = program.body.map(function (statement) {
+    return self.interpreter.next(statement);
+  });
+  return this;
+};
+
+module.exports = CodeGenerator;

lib/interpreter.js

@@ -0,0 +1,35 @@
+'use strict';
+var extend = require('extend');
+var utils = require('./utils');
+
+var types = {
+  // node
+  ArrayExpression: require('./node/ArrayExpression'),
+  AssignmentExpression: require('./node/AssignmentExpression'),
+  BinaryExpression: require('./node/BinaryExpression'),
+  CallExpression: require('./node/CallExpression'),
+  ConditionalExpression: require('./node/ConditionalExpression'),
+  ExpressionStatement: require('./node/ExpressionStatement'),
+  UnaryExpression: require('./node/UnaryExpression'),
+  // misc
+  Identifier: require('./misc/Identifier'),
+  Literal: require('./misc/Literal')
+};
+
+var Interpreter = function (owner) {
+  this.options = owner.options;
+};
+
+extend(Interpreter.prototype, types);
+
+// run is the main method which decides which expression to call
+Interpreter.prototype.next = function (node) {
+  if (!(node.type in this)) {
+    throw new TypeError('the node type ' + node.type + ' is not implemented');
+  }
+  return this[node.type](node);
+};
+
+Interpreter.prototype.rawify = utils.rawify;
+
+module.exports = Interpreter;

lib/misc/BinaryOperator.js

@@ -0,0 +1,15 @@
+'use strict';
+
+// https://github.com/estree/estree/blob/master/spec.md#binaryoperator
+module.exports = {
+  '+': 'add',
+  '-': 'sub',
+  '*': 'mul',
+  '/': 'div',
+  '^': 'pow',
+  '%': 'mod',
+  '<': 'lessThan',
+  '>': 'greaterThan',
+  '<=': 'lessEqualThan',
+  '>=': 'greaterEqualThan'
+};

lib/misc/Identifier.js

@@ -0,0 +1,6 @@
+'use strict';
+module.exports = function (node) {
+  var id = node.name;
+  return '(scope["' + id + '"] || ' +
+    'ns["' + id + '"] || ' + id + ' )';
+};

lib/misc/Literal.js

@@ -0,0 +1,8 @@
+'use strict';
+module.exports = function (node) {
+  // TODO: check the type of node.value/node.raw
+  if (this.options.raw) {
+    return node.raw;
+  }
+  return this.options.factory + '(' + node.raw + ')';
+};

lib/misc/UnaryOperator.js

@@ -0,0 +1,9 @@
+'use strict';
+
+// https://github.com/estree/estree/blob/master/spec.md#unaryoperator
+module.exports = {
+  '+': 'positive',
+  '-': 'negative',
+  '!': 'logicalNegation',
+  '~': 'oneComplement'
+};

lib/node/ArrayExpression.js

@@ -0,0 +1,16 @@
+'use strict';
+module.exports = function (node) {
+  var self = this;
+  var arr = [];
+  this.rawify(this.options.rawArrayExpressionElements, function () {
+    arr = node.elements.map(function (el) {
+      return self.next(el);
+    });
+  });
+  var arrString = '[' + arr.join(',') + ']';
+
+  if (this.options.raw) {
+    return arrString;
+  }
+  return this.options.factory + '(' + arrString + ')';
+};

lib/node/AssignmentExpression.js

@@ -0,0 +1,20 @@
+/**
+ * Created by mauricio on 5/14/15.
+ */
+'use strict';
+
+// https://github.com/estree/estree/blob/master/spec.md#binaryoperator
+var operators = {
+  '=': equalOperator
+};
+
+function equalOperator(node) {
+  return '(scope["' + node.left.name + '"] = ' + this.next(node.right) + ')';
+}
+
+module.exports = function (node) {
+  if (!(node.operator in operators)) {
+    throw SyntaxError(node.operator + ' not implemented');
+  }
+  return operators[node.operator].call(this, node);
+};

lib/node/BinaryExpression.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var operators = require('../misc/BinaryOperator');
+
+module.exports = function (node) {
+  if (this.options.raw) {
+    return ['(' + this.next(node.left), node.operator, this.next(node.right) + ')'].join(' ');
+  }
+
+  if (!(node.operator in operators)) {
+    throw SyntaxError(node.operator + ' not implemented');
+  }
+
+  // transform to CallExpression
+  var binaryNode = {
+    callee: {
+      type: 'Identifier',
+      name: operators[node.operator]
+    },
+    arguments: [node.left, node.right]
+  };
+
+  return this.CallExpression(binaryNode);
+};