Export AST as an object rather than module

The parser expects the AST object to be mutable, which modules are not.

1 files changed, 142 insertions, 136 deletions

diff --git a/lib/handlebars/compiler/ast.js b/lib/handlebars/compiler/ast.js
index f6229e2..b059cc1 100644
--- a/lib/handlebars/compiler/ast.js
+++ b/lib/handlebars/compiler/ast.js
@@ -1,145 +1,151 @@
 import Exception from "../exception";
 
-export function ProgramNode(statements, inverseStrip, inverse) {
-  this.type = "program";
-  this.statements = statements;
-  this.strip = {};
-
-  if(inverse) {
-    this.inverse = new ProgramNode(inverse, inverseStrip);
-    this.strip.right = inverseStrip.left;
-  } else if (inverseStrip) {
-    this.strip.left = inverseStrip.right;
-  }
-}
-
-export function MustacheNode(rawParams, hash, open, strip) {
-  this.type = "mustache";
-  this.hash = hash;
-  this.strip = strip;
-
-  var escapeFlag = open[3] || open[2];
-  this.escaped = escapeFlag !== '{' && escapeFlag !== '&';
-
-  var id = this.id = rawParams[0];
-  var params = this.params = rawParams.slice(1);
-
-  // a mustache is an eligible helper if:
-  // * its id is simple (a single part, not `this` or `..`)
-  var eligibleHelper = this.eligibleHelper = id.isSimple;
-
-  // a mustache is definitely a helper if:
-  // * it is an eligible helper, and
-  // * it has at least one parameter or hash segment
-  this.isHelper = eligibleHelper && (params.length || hash);
-
-  // if a mustache is an eligible helper but not a definite
-  // helper, it is ambiguous, and will be resolved in a later
-  // pass or at runtime.
-}
-
-export function PartialNode(partialName, context, strip) {
-  this.type         = "partial";
-  this.partialName  = partialName;
-  this.context      = context;
-  this.strip = strip;
-}
-
-export function BlockNode(mustache, program, inverse, close) {
-  if(mustache.id.original !== close.path.original) {
-    throw new Exception(mustache.id.original + " doesn't match " + close.path.original);
-  }
-
-  this.type = "block";
-  this.mustache = mustache;
-  this.program  = program;
-  this.inverse  = inverse;
-
-  this.strip = {
-    left: mustache.strip.left,
-    right: close.strip.right
-  };
-
-  (program || inverse).strip.left = mustache.strip.right;
-  (inverse || program).strip.right = close.strip.left;
-
-  if (inverse && !program) {
-    this.isInverse = true;
-  }
-}
-
-export function ContentNode(string) {
-  this.type = "content";
-  this.string = string;
-}
-
-export function HashNode(pairs) {
-  this.type = "hash";
-  this.pairs = pairs;
-}
+var AST = {
+  ProgramNode: function(statements, inverseStrip, inverse) {
+    this.type = "program";
+    this.statements = statements;
+    this.strip = {};
+
+    if(inverse) {
+      this.inverse = new AST.ProgramNode(inverse, inverseStrip);
+      this.strip.right = inverseStrip.left;
+    } else if (inverseStrip) {
+      this.strip.left = inverseStrip.right;
+    }
+  },
+
+  MustacheNode: function(rawParams, hash, open, strip) {
+    this.type = "mustache";
+    this.hash = hash;
+    this.strip = strip;
+
+    var escapeFlag = open[3] || open[2];
+    this.escaped = escapeFlag !== '{' && escapeFlag !== '&';
+
+    var id = this.id = rawParams[0];
+    var params = this.params = rawParams.slice(1);
+
+    // a mustache is an eligible helper if:
+    // * its id is simple (a single part, not `this` or `..`)
+    var eligibleHelper = this.eligibleHelper = id.isSimple;
+
+    // a mustache is definitely a helper if:
+    // * it is an eligible helper, and
+    // * it has at least one parameter or hash segment
+    this.isHelper = eligibleHelper && (params.length || hash);
+
+    // if a mustache is an eligible helper but not a definite
+    // helper, it is ambiguous, and will be resolved in a later
+    // pass or at runtime.
+  },
+
+  PartialNode: function(partialName, context, strip) {
+    this.type         = "partial";
+    this.partialName  = partialName;
+    this.context      = context;
+    this.strip = strip;
+  },
+
+  BlockNode: function(mustache, program, inverse, close) {
+    if(mustache.id.original !== close.path.original) {
+      throw new Exception(mustache.id.original + " doesn't match " + close.path.original);
+    }
 
-export function IdNode(parts) {
-  this.type = "ID";
+    this.type = "block";
+    this.mustache = mustache;
+    this.program  = program;
+    this.inverse  = inverse;
 
-  var original = "",
-      dig = [],
-      depth = 0;
+    this.strip = {
+      left: mustache.strip.left,
+      right: close.strip.right
+    };
 
-  for(var i=0,l=parts.length; i<l; i++) {
-    var part = parts[i].part;
-    original += (parts[i].separator || '') + part;
+    (program || inverse).strip.left = mustache.strip.right;
+    (inverse || program).strip.right = close.strip.left;
 
-    if (part === ".." || part === "." || part === "this") {
-      if (dig.length > 0) { throw new Exception("Invalid path: " + original); }
-      else if (part === "..") { depth++; }
-      else { this.isScoped = true; }
+    if (inverse && !program) {
+      this.isInverse = true;
+    }
+  },
+
+  ContentNode: function(string) {
+    this.type = "content";
+    this.string = string;
+  },
+
+  HashNode: function(pairs) {
+    this.type = "hash";
+    this.pairs = pairs;
+  },
+
+  IdNode: function(parts) {
+    this.type = "ID";
+
+    var original = "",
+        dig = [],
+        depth = 0;
+
+    for(var i=0,l=parts.length; i<l; i++) {
+      var part = parts[i].part;
+      original += (parts[i].separator || '') + part;
+
+      if (part === ".." || part === "." || part === "this") {
+        if (dig.length > 0) { throw new Exception("Invalid path: " + original); }
+        else if (part === "..") { depth++; }
+        else { this.isScoped = true; }
+      }
+      else { dig.push(part); }
     }
-    else { dig.push(part); }
+
+    this.original = original;
+    this.parts    = dig;
+    this.string   = dig.join('.');
+    this.depth    = depth;
+
+    // an ID is simple if it only has one part, and that part is not
+    // `..` or `this`.
+    this.isSimple = parts.length === 1 && !this.isScoped && depth === 0;
+
+    this.stringModeValue = this.string;
+  },
+
+  PartialNameNode: function(name) {
+    this.type = "PARTIAL_NAME";
+    this.name = name.original;
+  },
+
+  DataNode: function(id) {
+    this.type = "DATA";
+    this.id = id;
+  },
+
+  StringNode: function(string) {
+    this.type = "STRING";
+    this.original =
+      this.string =
+      this.stringModeValue = string;
+  },
+
+  IntegerNode: function(integer) {
+    this.type = "INTEGER";
+    this.original =
+      this.integer = integer;
+    this.stringModeValue = Number(integer);
+  },
+
+  BooleanNode: function(bool) {
+    this.type = "BOOLEAN";
+    this.bool = bool;
+    this.stringModeValue = bool === "true";
+  },
+
+  CommentNode: function(comment) {
+    this.type = "comment";
+    this.comment = comment;
   }
+};
 
-  this.original = original;
-  this.parts    = dig;
-  this.string   = dig.join('.');
-  this.depth    = depth;
-
-  // an ID is simple if it only has one part, and that part is not
-  // `..` or `this`.
-  this.isSimple = parts.length === 1 && !this.isScoped && depth === 0;
-
-  this.stringModeValue = this.string;
-}
-
-export function PartialNameNode(name) {
-  this.type = "PARTIAL_NAME";
-  this.name = name.original;
-}
-
-export function DataNode(id) {
-  this.type = "DATA";
-  this.id = id;
-}
-
-export function StringNode(string) {
-  this.type = "STRING";
-  this.original =
-    this.string =
-    this.stringModeValue = string;
-}
-
-export function IntegerNode(integer) {
-  this.type = "INTEGER";
-  this.original =
-    this.integer = integer;
-  this.stringModeValue = Number(integer);
-}
-
-export function BooleanNode(bool) {
-  this.type = "BOOLEAN";
-  this.bool = bool;
-  this.stringModeValue = bool === "true";
-}
-
-export function CommentNode(comment) {
-  this.type = "comment";
-  this.comment = comment;
-}
+// Must be exported as an object rather than the root of the module as the jison lexer
+// most modify the object to operate properly.
+export default AST;