Use AST manipulation rather than string based for rewrites

Sakefile

@@ -20,55 +20,12 @@ task('compile:six', () => {
 
 task('watch:six', () => launch('node bin/six -cwo ./lib ./src'))
 
-var dot = require("dot")
-
-dot.templateSettings = {
-  evaluate:    /\{\{([\s\S]+?)\}\}/g,
-  interpolate: /\{\{=([\s\S]+?)\}\}/g,
-  encode:      /\{\{!([\s\S]+?)\}\}/g,
-  use:         /\{\{#([\s\S]+?)\}\}/g,
-  define:      /\{\{##\s*([\w\.$]+)\s*(\:|=)([\s\S]+?)#\}\}/g,
-  conditional: /\{\{\?(\?)?\s*([\s\S]*?)\s*\}\}/g,
-  iterate:     /\{\{~\s*(?:\}\}|([\s\S]+?)\s*\:\s*([\w$]+)\s*(?:\:\s*([\w$]+))?\s*\}\})/g,
-  varname: 'it',
-  strip: true,
-  append: true,
-  selfcontained: true
-}
-
-var filterPath = __dirname + "/src/filters/"
-var filterOut = __dirname + "/lib/filters/"
-
-task('compile:dot', () => {
-  readdirSync(filterPath).forEach(file => {
-    if (path.extname(file) === ".dot") {
-      var source = readFileSync(filterPath + file).toString()
-      source = "exports.filter = " + dot.template(source).toString()
-      writeFileSync(filterOut + file.replace(".dot", ".js"), source, 'utf8')
-    }
-  })
-})
-
-task('watch:dot', () => {
-  watch(filterPath, (event, filename) => invoke("compile:dot"))
-})
-
 task('compile', () => {
   invoke('compile:six')
-  invoke('compile:dot')
 })
 
 task('watch', () => {
   invoke('watch:six')
-  invoke('watch:dot')
-})
-
-var Six = require("./lib/six")
-
-task("build:browserrr", () => {
-
-  console.log(Six.compile(readFileSync("./src/six.six").toString(), {global:true}))
-
 })
 
 import compile from "./lib/six"

lib/es6.js → lib/core/es6.js

@@ -18,15 +18,15 @@ define(function (require, exports) {
       writable: true,
       configurable: true
     }});
-  Array.prototype.iterator = function () {
-    return {
-      elements: this,
-      index: 0,
-      next: function () {
-        if (this.index >= this.elements.length)
-          throw StopIteration;
-        return this.elements[this.index++];
-      }
-    };
-  };
+  Object.defineProperty(Array.prototype, "iterator", {value: function () {
+      return {
+        elements: this,
+        index: 0,
+        next: function () {
+          if (this.index >= this.elements.length)
+            throw StopIteration;
+          return this.elements[this.index++];
+        }
+      };
+    }});
 });

lib/core/hooks.js

@@ -0,0 +1,28 @@
+if (typeof exports === 'object' && typeof define !== 'function') {
+  var define = function (factory) {
+    factory(require, exports);
+  };
+}
+define(function (require, exports) {
+  var esprima = require("esprima-six");
+  var parse = esprima.parse;
+  var hooks = exports.hooks = [];
+  hooks.push(function (tree) {
+    var egal = parse("(function ( x, y ) { return (x === y)?( x !== 0 || 1/x === 1/y ) : ( x !== x && y !==y )})()").body[0].expression;
+    var egaller = function (left, right) {
+      return {
+        type: egal.type,
+        arguments: [
+          left,
+          right
+        ],
+        callee: egal.callee
+      };
+    };
+    tree.traverse(function (node) {
+      if (node.type === "BinaryExpression" && /^is/.test(node.operator)) {
+        node.overload(egaller(node.left.toAST(), node.right.toAST()));
+      }
+    }.bind(this));
+  }.bind(this));
+});

lib/core/rewriter.js

@@ -0,0 +1,37 @@
+if (typeof exports === 'object' && typeof define !== 'function') {
+  var define = function (factory) {
+    factory(require, exports);
+  };
+}
+define(function (require, exports) {
+  require("./es6");
+  var esprima = require("esprima-six");
+  var parse = esprima.parse;
+  var esgen = require("escodegen").generate;
+  var Tree = require("./tree").Tree;
+  var hooks = require("./hooks").hooks;
+  var config = exports.config = {
+      format: {
+        indent: {style: "    "},
+        quotes: "double",
+        compact: false
+      },
+      comment: true
+    };
+  var rewrite = exports.rewrite = function (src, options) {
+      var sourceTree = new Tree(parse(src), options);
+      var hook;
+      void function (_iterator) {
+        try {
+          while (true) {
+            hook = _iterator.next();
+            hook(sourceTree, options);
+          }
+        } catch (e) {
+          if (e !== StopIteration)
+            throw e;
+        }
+      }.call(this, hooks.iterator());
+      return esgen(sourceTree.toAST(), config);
+    };
+});

lib/core/tree.js

@@ -0,0 +1,188 @@
+if (typeof exports === 'object' && typeof define !== 'function') {
+  var define = function (factory) {
+    factory(require, exports);
+  };
+}
+define(function (require, exports) {
+  var isArray = Array.isArray;
+  var push = Array.prototype.push;
+  var slice = Array.prototype.slice;
+  var iterator = Array.prototype.iterator;
+  var indexOf = Array.prototype.indexOf;
+  var forEach = Array.prototype.forEach;
+  var keys = Object.keys;
+  var defineProperty = Object.defineProperty;
+  var defineProperties = Object.defineProperties;
+  var Tree = function () {
+      function Tree(ast, options) {
+        this.root = new Node(ast);
+      }
+      Tree.prototype.traverse = function (visitor) {
+        visitor.call(this.root, this.root);
+        this.root.traverse(visitor);
+      };
+      Tree.prototype.toAST = function () {
+        return this.root.toAST();
+      };
+      return Tree;
+    }();
+  var Node = function () {
+      function Node(ast, opts) {
+        opts || (opts = {});
+        defineProperties(this, {
+          children: {value: new NodeSet(null, {
+              parent: this,
+              key: "children"
+            })},
+          nodeType: {value: "Node"},
+          nodeKey: {value: opts.key || null},
+          parent: {value: opts.parent || null}
+        });
+        this.set(ast);
+      }
+      Node.prototype.create = function (ast, opts) {
+        return new (isArray(ast) ? NodeSet : Node)(ast, opts);
+      };
+      Node.prototype.clean = function () {
+        var key;
+        void function (_iterator) {
+          try {
+            while (true) {
+              key = _iterator.next(), key = key.key;
+              delete this[key];
+            }
+          } catch (e) {
+            if (e !== StopIteration)
+              throw e;
+          }
+        }.call(this, this.iterator());
+        this.children = new NodeSet(null, {
+          parent: this,
+          key: "children"
+        });
+      };
+      Node.prototype.set = function (ast) {
+        var key;
+        void function (_iterator) {
+          try {
+            while (true) {
+              key = _iterator.next();
+              if (typeof ast[key] === "object" && key !== "range" && ast[key] !== null) {
+                this.append(this[key] = this.create(ast[key], {
+                  parent: this,
+                  key: key
+                }));
+              } else {
+                this[key] = ast[key];
+              }
+            }
+          } catch (e) {
+            if (e !== StopIteration)
+              throw e;
+          }
+        }.call(this, keys(ast).iterator());
+      };
+      Node.prototype.overload = function (ast) {
+        this.clean();
+        this.set(ast);
+      };
+      Node.prototype.append = function (node) {
+        push.call(this.children, node);
+      };
+      Node.prototype.traverse = function (visitor) {
+        var child;
+        void function (_iterator) {
+          try {
+            while (true) {
+              child = _iterator.next();
+              visitor.call(child, child);
+              child.traverse(visitor);
+            }
+          } catch (e) {
+            if (e !== StopIteration)
+              throw e;
+          }
+        }.call(this, this.children.iterator());
+      };
+      Node.prototype.iterator = function () {
+        return {
+          elements: keys(this).map(function (key) {
+            return {
+              key: key,
+              value: this[key]
+            };
+          }.bind(this)),
+          index: 0,
+          next: function () {
+            if (this.index >= this.elements.length)
+              throw StopIteration;
+            return this.elements[this.index++];
+          }
+        };
+      };
+      Node.prototype.toAST = function () {
+        var ast = {};
+        var key, value;
+        void function (_iterator) {
+          try {
+            while (true) {
+              key = _iterator.next(), value = key.value, key = key.key;
+              ast[key] = typeof value === "object" ? value.toAST() : value;
+            }
+          } catch (e) {
+            if (e !== StopIteration)
+              throw e;
+          }
+        }.call(this, this.iterator());
+        return ast;
+      };
+      return Node;
+    }();
+  var NodeSet = function (_super) {
+      function __ctor() {
+        this.constructor = NodeSet;
+      }
+      __ctor.prototype = _super.prototype;
+      NodeSet.prototype = new __ctor();
+      NodeSet.__super__ = _super.prototype;
+      function NodeSet(items, opts) {
+        opts || (opts = {});
+        defineProperties(this, {
+          nodeType: {value: "NodeSet"},
+          nodeKey: {value: opts.key || null},
+          parent: {value: opts.parent || null}
+        });
+        this.length = 0;
+        items && items.forEach(function (item) {
+          return push.call(this, this.create(item, {parent: this}));
+        }.bind(this));
+      }
+      NodeSet.prototype.traverse = function (visitor) {
+        var child;
+        void function (_iterator) {
+          try {
+            while (true) {
+              child = _iterator.next();
+              visitor.call(child, child);
+              child.traverse(visitor);
+            }
+          } catch (e) {
+            if (e !== StopIteration)
+              throw e;
+          }
+        }.call(this, this.iterator());
+      };
+      NodeSet.prototype.toAST = function () {
+        return slice.call(this);
+      };
+      return NodeSet;
+    }(Node);
+  defineProperties(NodeSet.prototype, {
+    iterator: {value: iterator},
+    push: {value: push},
+    slice: {value: slice},
+    forEach: {value: forEach},
+    indexOf: {value: indexOf}
+  });
+  exports.Tree = Tree;
+});