.gitignore coverage and idea directories

Conflicts:
	lib/handlebars/compiler/javascript-compiler.js

.gitignore

@@ -8,3 +8,6 @@ node_modules
 *.sublime-project
 *.sublime-workspace
 npm-debug.log
+sauce_connect.log*
+/coverage
+/.idea

.jshintrc

@@ -1,14 +1,6 @@
 {
     "predef": [
         "console",
-        "Ember",
-        "DS",
-        "Handlebars",
-        "Metamorph",
-        "ember_assert",
-        "ember_warn",
-        "ember_deprecate",
-        "ember_deprecateFunc",
         "require",
         "suite",
         "equal",
@@ -22,10 +14,12 @@
         "ok",
         "strictEqual",
         "module",
+        "define",
 
         "describe",
         "it",
-        "afterEach"
+        "afterEach",
+        "beforeEach"
     ],
 
     "node" : true,
@@ -41,7 +35,7 @@
     "evil": true,
     "forin": false,
     "immed": false,
-    "laxbreak": false,
+    "laxbreak": true,
     "newcap": true,
     "noarg": true,
     "noempty": false,

.npmignore

@@ -18,5 +18,6 @@ dist/components/*
 spec/*
 src/*
 tasks/*
+tmp/*
 publish/*
 vendor/*

.travis.yml

@@ -1,13 +1,12 @@
 language: node_js
 node_js:
   - "0.8"
-  - "0.10"
 
 before_install:
   - npm install -g grunt-cli
 
 script:
-  - grunt --stack default metrics publish:latest
+  - grunt --stack travis
 
 email:
   on_failure: change
@@ -15,13 +14,17 @@ email:
 env:
   global:
   - S3_BUCKET_NAME=builds.handlebarsjs.com
-  - secure: ! 'PJaukuvkBBsSDOqbIcNSSMgb96VVEaIt/eq9GPjXPeFbSd3hXgwhwVE62Lrq
+  - secure: PJaukuvkBBsSDOqbIcNSSMgb96VVEaIt/eq9GPjXPeFbSd3hXgwhwVE62LrqtJO8BaUfX+PzpiQjEl4D5/KBmvlFZ057Hqmy0zmPOT5mDZfJe8Ja5zyvTMb+KkCWN/tjAp8kawHojE04pn6jIpPdwXFnAYwPhaHbATFrmdt9fdg=
+  - secure: mBcGL2tnmiRujJdV/4fxrVd8E8wn6AW9IQKVcMv8tvOc7i5dOzZ39rpBKLuTMRXDtMV1LyLiuKYb1pHj1IyeadEahcLYFfGygF4LG7Yzp4NWHtRzQ7Q8LXaJV7dXDboYCFkn2a8/Rtx1YSVh/sCONf5UoRC+MUIqrj4UiHN9r3s=
 
-      tJO8BaUfX+PzpiQjEl4D5/KBmvlFZ057Hqmy0zmPOT5mDZfJe8Ja5zyvTMb+
+matrix:
+  include:
+    - node_js: "0.10"
+      env:
+        - PUBLISH=true
+        - secure: pLTzghtVll9yGKJI0AaB0uI8GypfWxLTaIB0ZL8//yN3nAEIKMhf/RRilYTsn/rKj2NUa7vt2edYILi3lttOUlCBOwTc9amiRms1W8Lwr/3IdWPeBLvLuH1zNJRm2lBAwU4LBSqaOwhGaxOQr6KHTnWudhNhgOucxpZfvfI/dFw=
+        - secure: yERYCf7AwL11D9uMtacly/THGV8BlzsMmrt+iQVvGA3GaY6QMmfYqf6P6cCH98sH5etd1Y+1e6YrPeMjqI6lyRllT7FptoyOdHulazQe86VQN4sc0EpqMlH088kB7gGjTut9Z+X9ViooT5XEh9WA5jXEI9pXhQJNoIHkWPuwGuY=
 
-      KkCWN/tjAp8kawHojE04pn6jIpPdwXFnAYwPhaHbATFrmdt9fdg='
-  - secure: ! 'mBcGL2tnmiRujJdV/4fxrVd8E8wn6AW9IQKVcMv8tvOc7i5dOzZ39rpBKLuT
-
-      MRXDtMV1LyLiuKYb1pHj1IyeadEahcLYFfGygF4LG7Yzp4NWHtRzQ7Q8LXaJ
-
-      V7dXDboYCFkn2a8/Rtx1YSVh/sCONf5UoRC+MUIqrj4UiHN9r3s='
+cache:
+  directories:
+    - node_modules

Gruntfile.js

@@ -7,15 +7,14 @@ module.exports = function(grunt) {
 
     jshint: {
       options: {
-        jshintrc: '.jshintrc',
-        force: true
+        jshintrc: '.jshintrc'
       },
       files: [
-        'lib/**/!(parser).js'
+        'dist/**/!(*.min|parser).js'
       ]
     },
 
-    clean: ["dist", "lib/handlebars/compiler/parser.js"],
+    clean: ['tmp', 'dist', 'lib/handlebars/compiler/parser.js'],
 
     copy: {
       dist: {
@@ -42,9 +41,20 @@ module.exports = function(grunt) {
       }
     },
 
-    transpile: {
+    packager: {
+      global: {
+        type: 'global',
+        export: 'Handlebars',
+        files: [{
+          cwd: 'lib/',
+          expand: true,
+          src: ['handlebars*.js'],
+          dest: 'dist/'
+        }]
+      },
+
       amd: {
-        type: "amd",
+        type: 'amd',
         anonymous: true,
         files: [{
           expand: true,
@@ -64,21 +74,6 @@ module.exports = function(grunt) {
         }]
       }
     },
-
-    packager: {
-      options: {
-        export: 'Handlebars'
-      },
-
-      global: {
-        files: [{
-          cwd: 'lib/',
-          expand: true,
-          src: ['handlebars*.js'],
-          dest: 'dist/'
-        }]
-      }
-    },
     requirejs: {
       options: {
         optimize: "none",
@@ -108,57 +103,103 @@ module.exports = function(grunt) {
         files: [{
           cwd: 'dist/',
           expand: true,
-          src: ['handlebars*.js'],
+          src: ['handlebars*.js', '!*.min.js'],
           dest: 'dist/',
           rename: function(dest, src) {
             return dest + src.replace(/\.js$/, '.min.js');
           }
         }]
       }
+    },
+
+    concat: {
+      tests: {
+        src: ['spec/!(require).js'],
+        dest: 'tmp/tests.js'
+      }
+    },
+
+    connect: {
+      server: {
+        options: {
+          base: '.',
+          hostname: '*',
+          port: 9999
+        }
+      }
+    },
+    'saucelabs-mocha': {
+      all: {
+        options: {
+          build: process.env.TRAVIS_JOB_ID,
+          urls: ['http://localhost:9999/spec/?headless=true', 'http://localhost:9999/spec/amd.html?headless=true'],
+          detailedError: true,
+          concurrency: 2,
+          browsers: [
+            {browserName: 'chrome'},
+            {browserName: 'firefox'},
+            {browserName: 'firefox', version: '3.6'},
+            {browserName: 'safari', version: 7, platform: 'OS X 10.9'},
+            {browserName: 'safari', version: 6, platform: 'OS X 10.8'},
+            {browserName: 'safari', version: 5},
+            {browserName: 'opera', version: 12},
+            {browserName: 'opera', version: 11},
+            {browserName: 'internet explorer', version: 11, platform: 'Windows 8.1'},
+            {browserName: 'internet explorer', version: 10, platform: 'Windows 8'},
+            {browserName: 'internet explorer', version: 9, platform: 'Windows 7'},
+            {browserName: 'internet explorer', version: 8, platform: 'XP'},
+            {browserName: 'internet explorer', version: 7, platform: 'XP'},
+            {browserName: 'internet explorer', version: 6, platform: 'XP'}
+          ]
+        }
+      }
+    },
+
+    watch: {
+      scripts: {
+        options: {
+          atBegin: true
+        },
+
+        files: ['src/*', 'lib/**/*.js', 'spec/**/*.js'],
+        tasks: ['build', 'amd', 'tests', 'test']
+      }
     }
   });
 
   // Build a new version of the library
   this.registerTask('build', "Builds a distributable version of the current project", [
-                    'jshint',
-                    'clean',
                     'parser',
                     'node',
-                    'globals']);
+                    'globals',
+                    'jshint']);
 
-  this.registerTask('amd', ['transpile:amd', 'requirejs']);
-  this.registerTask('node', ['transpile:cjs']);
-  this.registerTask('globals', ['packager-fork']);
+  this.registerTask('amd', ['packager:amd', 'requirejs']);
+  this.registerTask('node', ['packager:cjs']);
+  this.registerTask('globals', ['packager:global']);
+  this.registerTask('tests', ['concat:tests']);
 
-  this.registerTask('release', 'Build final packages', ['amd', 'uglify', 'copy:dist', 'copy:components', 'copy:cdnjs']);
+  this.registerTask('release', 'Build final packages', ['amd', 'jshint', 'uglify', 'copy:dist', 'copy:components', 'copy:cdnjs']);
 
   // Load tasks from npm
   grunt.loadNpmTasks('grunt-contrib-clean');
+  grunt.loadNpmTasks('grunt-contrib-concat');
+  grunt.loadNpmTasks('grunt-contrib-connect');
   grunt.loadNpmTasks('grunt-contrib-copy');
   grunt.loadNpmTasks('grunt-contrib-requirejs');
   grunt.loadNpmTasks('grunt-contrib-jshint');
   grunt.loadNpmTasks('grunt-contrib-uglify');
-  grunt.loadNpmTasks('grunt-es6-module-transpiler');
+  grunt.loadNpmTasks('grunt-contrib-watch');
+  grunt.loadNpmTasks('grunt-saucelabs');
+  grunt.loadNpmTasks('es6-module-packager');
 
   grunt.task.loadTasks('tasks');
 
-  grunt.registerTask('packager-fork', function() {
-    // Allows us to run the packager task out of process to work around the multiple
-    // traceur exec issues
-    grunt.util.spawn({grunt: true,  args: ['--stack', 'packager'], opts: {stdio: 'inherit'}}, this.async());
-  });
-  grunt.registerTask('test', function() {
-    var done = this.async();
-
-    var runner = childProcess.fork('./spec/env/runner', [], {stdio: 'inherit'});
-    runner.on('close', function(code) {
-      if (code != 0) {
-        grunt.fatal(code + ' tests failed');
-      }
-      done();
-    });
-  });
   grunt.registerTask('bench', ['metrics']);
+  grunt.registerTask('sauce', process.env.SAUCE_USERNAME ? ['tests', 'connect', 'saucelabs-mocha'] : []);
 
-  grunt.registerTask('default', ['build', 'test', 'release']);
+  grunt.registerTask('travis', process.env.PUBLISH ? ['default', 'sauce', 'metrics', 'publish:latest'] : ['default']);
+
+  grunt.registerTask('dev', ['clean', 'connect', 'watch']);
+  grunt.registerTask('default', ['clean', 'build', 'test', 'release']);
 };

README.markdown

@@ -1,5 +1,5 @@
-[![Build Status](https://travis-ci.org/wycats/handlebars.js.png?branch=master)](https://travis-ci.org/wycats/handlebars.js)
-
+[![Travis Build Status](https://travis-ci.org/wycats/handlebars.js.png?branch=master)](https://travis-ci.org/wycats/handlebars.js)
+[![Selenium Test Status](https://saucelabs.com/buildstatus/handlebars)](https://saucelabs.com/u/handlebars)
 
 Handlebars.js
 =============
@@ -14,9 +14,7 @@ Checkout the official Handlebars docs site at
 
 Installing
 ----------
-Installing Handlebars is easy. Simply download the package [from the
-official site](http://handlebarsjs.com/) and add it to your web pages
-(you should usually use the most recent version).
+Installing Handlebars is easy. Simply download the package [from the official site](http://handlebarsjs.com/) or the [bower repository][bower-repo] and add it to your web pages (you should usually use the most recent version).
 
 Alternatively, if you prefer having the latest version of handlebars from
 the 'master' branch, passing builds of the 'master' branch are automatically
@@ -325,6 +323,8 @@ Handlebars has been designed to work in any ECMAScript 3 environment. This inclu
 Older versions and other runtimes are likely to work but have not been formally
 tested.
 
+[![Selenium Test Status](https://saucelabs.com/browser-matrix/handlebars.svg)](https://saucelabs.com/u/handlebars)
+
 Performance
 -----------
 
@@ -364,6 +364,7 @@ Handlebars in the Wild
 * [CoSchedule](http://coschedule.com) An editorial calendar for WordPress that uses Handlebars.js
 * [Ember.js](http://www.emberjs.com) makes Handlebars.js the primary way to
   structure your views, also with automatic data binding support.
+* [Ghost](https://ghost.org/) Just a blogging platform.
 * [handlebars_assets](http://github.com/leshill/handlebars_assets): A Rails Asset Pipeline gem
   from Les Hill (@leshill).
 * [handlebars-helpers](https://github.com/assemble/handlebars-helpers) is an extensive library
@@ -382,13 +383,14 @@ Handlebars in the Wild
   templating engine, extending it with automatic data binding support.
 * [YUI](http://yuilibrary.com/yui/docs/handlebars/) implements a port of handlebars
 * [Swag](https://github.com/elving/swag) by [@elving](https://github.com/elving) is a growing collection of helpers for handlebars.js. Give your handlebars.js templates some swag son!
+* [DOMBars](https://github.com/blakeembrey/dombars) is a DOM-based templating engine built on the Handlebars parser and runtime
 
 External Resources
 ------------------
 
 * [Gist about Synchronous and asynchronous loading of external handlebars templates](https://gist.github.com/2287070)
 
-Have a project using Handlebars? Send us a [pull request](https://github.com/wycats/handlebars.js/pull/new/master)!
+Have a project using Handlebars? Send us a [pull request][pull-request]!
 
 Helping Out
 -----------
@@ -405,12 +407,27 @@ in the root of the project. That will build Handlebars and output the
 results to the dist/ folder. To re-run tests, run `grunt test` or `npm test`.
 You can also run our set of benchmarks with `grunt bench`.
 
+The `grunt dev` implements watching for tests and allows for in browser testing at `http://localhost:9999/spec/`.
+
 If you notice any problems, please report them to the GitHub issue tracker at
 [http://github.com/wycats/handlebars.js/issues](http://github.com/wycats/handlebars.js/issues).
 Feel free to contact commondream or wycats through GitHub with any other
 questions or feature requests. To submit changes fork the project and
 send a pull request.
 
+### Ember testing
+
+The current ember distribution should be tested as part of the handlebars release process. This requires building the `handlebars-source` gem locally and then executing the ember test script.
+
+```sh
+grunt build release
+export HANDLEBARS_PATH=`pwd`
+
+cd $emberRepoDir
+bundle exec rake clean
+bundle exec rake test
+```
+
 ### Releasing
 
 Handlebars utilizes the [release yeoman generator][generator-release] to perform most release tasks.
@@ -423,6 +440,10 @@ yo release:release patch
 npm publish
 yo release:publish cdnjs handlebars.js dist/cdnjs/
 yo release:publish components handlebars.js dist/components/
+
+cd dist/components/
+gem build handlebars-source.gemspec
+gem push handlebars-source-*.gem
 ```
 
 After this point the handlebars site needs to be updated to point to the new version numbers.
@@ -431,5 +452,7 @@ License
 -------
 Handlebars.js is released under the MIT license.
 
-[builds-page]: http://builds.handlebarsjs.com.s3.amazonaws.com/index.html
+[bower-repo]: https://github.com/components/handlebars.js
+[builds-page]: http://builds.handlebarsjs.com.s3.amazonaws.com/bucket-listing.html?sort=lastmod&sortdir=desc
 [generator-release]: https://github.com/walmartlabs/generator-release
+[pull-request]: https://github.com/wycats/handlebars.js/pull/new/master

bench/templates/subexpression.js

@@ -0,0 +1,14 @@
+module.exports = {
+  helpers: {
+    echo: function(value) {
+      return 'foo ' + value;
+    },
+    header: function() {
+      return "Colors";
+    }
+  },
+  handlebars: "{{echo (header)}}",
+  eco: "<%= @echo(@header()) %>"
+};
+
+module.exports.context = module.exports.helpers;

bin/handlebars

@@ -127,7 +127,7 @@ extension = new RegExp('\\.' + extension + '$');
 var output = [];
 if (!argv.simple) {
   if (argv.amd) {
-    output.push('define([\'' + argv.handlebarPath + 'handlebars\'], function(Handlebars) {\n  Handlebars = Handlebars["default"];');
+    output.push('define([\'' + argv.handlebarPath + 'handlebars.runtime\'], function(Handlebars) {\n  Handlebars = Handlebars["default"];');
   } else if (argv.commonjs) {
     output.push('var Handlebars = require("' + argv.commonjs + '");');
   } else {
@@ -150,9 +150,9 @@ function processTemplate(template, root) {
         processTemplate(path, root || template);
       }
     });
-  } else {
+  } else if (extension.test(path)) {
     var data = fs.readFileSync(path, 'utf8');
-    
+
     if (argv.bom && data.indexOf('\uFEFF') === 0) {
       data = data.substring(1);
     }

components/bower.json

@@ -1,6 +1,6 @@
 {
   "name": "handlebars",
-  "version": "1.1.1",
+  "version": "1.3.0",
   "main": "handlebars.js",
   "dependencies": {}
 }

components/handlebars.js.nuspec

@@ -2,7 +2,7 @@
 <package>
 	<metadata>
 		<id>handlebars.js</id>
-		<version>1.1.1</version>
+		<version>1.3.0</version>
 		<authors>handlebars.js Authors</authors>
 		<licenseUrl>https://github.com/wycats/handlebars.js/blob/master/LICENSE</licenseUrl>
 		<projectUrl>https://github.com/wycats/handlebars.js/</projectUrl>

lib/handlebars.js

@@ -1,7 +1,8 @@
+/*globals Handlebars: true */
 import Handlebars from "./handlebars.runtime";
 
 // Compiler imports
-module AST from "./handlebars/compiler/ast";
+import AST from "./handlebars/compiler/ast";
 import { parser as Parser, parse } from "./handlebars/compiler/base";
 import { Compiler, compile, precompile } from "./handlebars/compiler/compiler";
 import JavaScriptCompiler from "./handlebars/compiler/javascript-compiler";
@@ -13,7 +14,9 @@ var create = function() {
   hb.compile = function(input, options) {
     return compile(input, options, hb);
   };
-  hb.precompile = precompile;
+  hb.precompile = function (input, options) {
+    return precompile(input, options, hb);
+  };
 
   hb.AST = AST;
   hb.Compiler = Compiler;

lib/handlebars.runtime.js

@@ -1,3 +1,4 @@
+/*globals Handlebars: true */
 module base from "./handlebars/base";
 
 // Each of these augment the Handlebars object. No need to setup here.

lib/handlebars/base.js

@@ -1,8 +1,7 @@
-/*globals Exception, Utils */
 module Utils from "./utils";
 import Exception from "./exception";
 
-export var VERSION = "1.1.1";
+export var VERSION = "1.3.0";
 export var COMPILER_REVISION = 4;
 
 export var REVISION_CHANGES = {
@@ -12,25 +11,11 @@ export var REVISION_CHANGES = {
   4: '>= 1.0.0'
 };
 
-var toString = Object.prototype.toString,
+var isArray = Utils.isArray,
+    isFunction = Utils.isFunction,
+    toString = Utils.toString,
     objectType = '[object Object]';
 
-// Sourced from lodash
-// https://github.com/bestiejs/lodash/blob/master/LICENSE.txt
-var isFunction = function(value) {
-  return typeof value === 'function';
-};
-// fallback for older versions of Chrome and Safari
-if (isFunction(/x/)) {
-  isFunction = function(value) {
-    return typeof value === 'function' && toString.call(value) === '[object Function]';
-  };
-}
-
-function isArray(value) {
-  return (value && typeof value === 'object') ? toString.call(value) === '[object Array]' : false;
-}
-
 export function HandlebarsEnvironment(helpers, partials) {
   this.helpers = helpers || {};
   this.partials = partials || {};
@@ -68,7 +53,7 @@ function registerDefaultHelpers(instance) {
     if(arguments.length === 2) {
       return undefined;
     } else {
-      throw new Error("Missing helper: '" + arg + "'");
+      throw new Exception("Missing helper: '" + arg + "'");
     }
   });
 
@@ -107,7 +92,7 @@ function registerDefaultHelpers(instance) {
         for(var j = context.length; i<j; i++) {
           if (data) {
             data.index = i;
-            data.first = (i === 0)
+            data.first = (i === 0);
             data.last  = (i === (context.length-1));
           }
           ret = ret + fn(context[i], { data: data });
@@ -115,7 +100,11 @@ function registerDefaultHelpers(instance) {
       } else {
         for(var key in context) {
           if(context.hasOwnProperty(key)) {
-            if(data) { data.key = key; }
+            if(data) { 
+              data.key = key; 
+              data.index = i;
+              data.first = (i === 0);
+            }
             ret = ret + fn(context[key], {data: data});
             i++;
           }

lib/handlebars/compiler/ast.js

@@ -1,145 +1,226 @@
 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;
-  }
+function LocationInfo(locInfo){
+  locInfo = locInfo || {};
+  this.firstLine   = locInfo.first_line;
+  this.firstColumn = locInfo.first_column;
+  this.lastColumn  = locInfo.last_column;
+  this.lastLine    = locInfo.last_line;
 }
 
-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;
-}
-
-export function IdNode(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; }
+var AST = {
+  ProgramNode: function(statements, inverseStrip, inverse, locInfo) {
+    var inverseLocationInfo, firstInverseNode;
+    if (arguments.length === 3) {
+      locInfo = inverse;
+      inverse = null;
+    } else if (arguments.length === 2) {
+      locInfo = inverseStrip;
+      inverseStrip = null;
     }
-    else { dig.push(part); }
+
+    LocationInfo.call(this, locInfo);
+    this.type = "program";
+    this.statements = statements;
+    this.strip = {};
+
+    if(inverse) {
+      firstInverseNode = inverse[0];
+      if (firstInverseNode) {
+        inverseLocationInfo = {
+          first_line: firstInverseNode.firstLine,
+          last_line: firstInverseNode.lastLine,
+          last_column: firstInverseNode.lastColumn,
+          first_column: firstInverseNode.firstColumn
+        };
+        this.inverse = new AST.ProgramNode(inverse, inverseStrip, inverseLocationInfo);
+      } else {
+        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, locInfo) {
+    LocationInfo.call(this, locInfo);
+    this.type = "mustache";
+    this.strip = strip;
+
+    // Open may be a string parsed from the parser or a passed boolean flag
+    if (open != null && open.charAt) {
+      // Must use charAt to support IE pre-10
+      var escapeFlag = open.charAt(3) || open.charAt(2);
+      this.escaped = escapeFlag !== '{' && escapeFlag !== '&';
+    } else {
+      this.escaped = !!open;
+    }
+
+    if (rawParams instanceof AST.SexprNode) {
+      this.sexpr = rawParams;
+    } else {
+      // Support old AST API
+      this.sexpr = new AST.SexprNode(rawParams, hash);
+    }
+
+    this.sexpr.isRoot = true;
+
+    // Support old AST API that stored this info in MustacheNode
+    this.id = this.sexpr.id;
+    this.params = this.sexpr.params;
+    this.hash = this.sexpr.hash;
+    this.eligibleHelper = this.sexpr.eligibleHelper;
+    this.isHelper = this.sexpr.isHelper;
+  },
+
+  SexprNode: function(rawParams, hash, locInfo) {
+    LocationInfo.call(this, locInfo);
+
+    this.type = "sexpr";
+    this.hash = hash;
+
+    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, locInfo) {
+    LocationInfo.call(this, locInfo);
+    this.type         = "partial";
+    this.partialName  = partialName;
+    this.context      = context;
+    this.strip = strip;
+  },
+
+  BlockNode: function(mustache, program, inverse, close, locInfo) {
+    LocationInfo.call(this, locInfo);
+
+    if(mustache.sexpr.id.original !== close.path.original) {
+      throw new Exception(mustache.sexpr.id.original + " doesn't match " + close.path.original, this);
+    }
+
+    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;
+    }
+  },
+
+  ContentNode: function(string, locInfo) {
+    LocationInfo.call(this, locInfo);
+    this.type = "content";
+    this.string = string;
+  },
+
+  HashNode: function(pairs, locInfo) {
+    LocationInfo.call(this, locInfo);
+    this.type = "hash";
+    this.pairs = pairs;
+  },
+
+  IdNode: function(parts, locInfo) {
+    LocationInfo.call(this, locInfo);
+    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, this);
+        } else if (part === "..") {
+          depth++;
+        } else {
+          this.isScoped = true;
+        }
+      } 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, locInfo) {
+    LocationInfo.call(this, locInfo);
+    this.type = "PARTIAL_NAME";
+    this.name = name.original;
+  },
+
+  DataNode: function(id, locInfo) {
+    LocationInfo.call(this, locInfo);
+    this.type = "DATA";
+    this.id = id;
+  },
+
+  StringNode: function(string, locInfo) {
+    LocationInfo.call(this, locInfo);
+    this.type = "STRING";
+    this.original =
+      this.string =
+      this.stringModeValue = string;
+  },
+
+  IntegerNode: function(integer, locInfo) {
+    LocationInfo.call(this, locInfo);
+    this.type = "INTEGER";
+    this.original =
+      this.integer = integer;
+    this.stringModeValue = Number(integer);
+  },
+
+  BooleanNode: function(bool, locInfo) {
+    LocationInfo.call(this, locInfo);
+    this.type = "BOOLEAN";
+    this.bool = bool;
+    this.stringModeValue = bool === "true";
+  },
+
+  CommentNode: function(comment, locInfo) {
+    LocationInfo.call(this, locInfo);
+    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;

lib/handlebars/compiler/base.js

@@ -1,5 +1,5 @@
 import parser from "./parser";
-module AST from "./ast";
+import AST from "./ast";
 
 export { parser };
 

lib/handlebars/compiler/compiler.js

@@ -1,7 +1,4 @@
 import Exception from "../exception";
-import { parse } from "./base";
-import JavaScriptCompiler from "./javascript-compiler";
-module AST from "./ast";
 
 export function Compiler() {}
 
@@ -159,12 +156,13 @@ Compiler.prototype = {
       inverse = this.compileProgram(inverse);
     }
 
-    var type = this.classifyMustache(mustache);
+    var sexpr = mustache.sexpr;
+    var type = this.classifySexpr(sexpr);
 
     if (type === "helper") {
-      this.helperMustache(mustache, program, inverse);
+      this.helperSexpr(sexpr, program, inverse);
     } else if (type === "simple") {
-      this.simpleMustache(mustache);
+      this.simpleSexpr(sexpr);
 
       // now that the simple mustache is resolved, we need to
       // evaluate it by executing `blockHelperMissing`
@@ -173,7 +171,7 @@ Compiler.prototype = {
       this.opcode('emptyHash');
       this.opcode('blockValue');
     } else {
-      this.ambiguousMustache(mustache, program, inverse);
+      this.ambiguousSexpr(sexpr, program, inverse);
 
       // now that the simple mustache is resolved, we need to
       // evaluate it by executing `blockHelperMissing`
@@ -201,6 +199,12 @@ Compiler.prototype = {
         }
         this.opcode('getContext', val.depth || 0);
         this.opcode('pushStringParam', val.stringModeValue, val.type);
+
+        if (val.type === 'sexpr') {
+          // Subexpressions get evaluated and passed in
+          // in string params mode.
+          this.sexpr(val);
+        }
       } else {
         this.accept(val);
       }
@@ -229,26 +233,17 @@ Compiler.prototype = {
   },
 
   mustache: function(mustache) {
-    var options = this.options;
-    var type = this.classifyMustache(mustache);
+    this.sexpr(mustache.sexpr);
 
-    if (type === "simple") {
-      this.simpleMustache(mustache);
-    } else if (type === "helper") {
-      this.helperMustache(mustache);
-    } else {
-      this.ambiguousMustache(mustache);
-    }
-
-    if(mustache.escaped && !options.noEscape) {
+    if(mustache.escaped && !this.options.noEscape) {
       this.opcode('appendEscaped');
     } else {
       this.opcode('append');
     }
   },
 
-  ambiguousMustache: function(mustache, program, inverse) {
-    var id = mustache.id,
+  ambiguousSexpr: function(sexpr, program, inverse) {
+    var id = sexpr.id,
         name = id.parts[0],
         isBlock = program != null || inverse != null;
 
@@ -260,8 +255,8 @@ Compiler.prototype = {
     this.opcode('invokeAmbiguous', name, isBlock);
   },
 
-  simpleMustache: function(mustache) {
-    var id = mustache.id;
+  simpleSexpr: function(sexpr) {
+    var id = sexpr.id;
 
     if (id.type === 'DATA') {
       this.DATA(id);
@@ -277,16 +272,28 @@ Compiler.prototype = {
     this.opcode('resolvePossibleLambda');
   },
 
-  helperMustache: function(mustache, program, inverse) {
-    var params = this.setupFullMustacheParams(mustache, program, inverse),
-        name = mustache.id.parts[0];
+  helperSexpr: function(sexpr, program, inverse) {
+    var params = this.setupFullMustacheParams(sexpr, program, inverse),
+        name = sexpr.id.parts[0];
 
     if (this.options.knownHelpers[name]) {
       this.opcode('invokeKnownHelper', params.length, name);
     } else if (this.options.knownHelpersOnly) {
-      throw new Error("You specified knownHelpersOnly, but used the unknown helper " + name);
+      throw new Exception("You specified knownHelpersOnly, but used the unknown helper " + name, sexpr);
     } else {
-      this.opcode('invokeHelper', params.length, name);
+      this.opcode('invokeHelper', params.length, name, sexpr.isRoot);
+    }
+  },
+
+  sexpr: function(sexpr) {
+    var type = this.classifySexpr(sexpr);
+
+    if (type === "simple") {
+      this.simpleSexpr(sexpr);
+    } else if (type === "helper") {
+      this.helperSexpr(sexpr);
+    } else {
+      this.ambiguousSexpr(sexpr);
     }
   },
 
@@ -309,7 +316,7 @@ Compiler.prototype = {
   DATA: function(data) {
     this.options.data = true;
     if (data.id.isScoped || data.id.depth) {
-      throw new Exception('Scoped data references are not supported: ' + data.original);
+      throw new Exception('Scoped data references are not supported: ' + data.original, data);
     }
 
     this.opcode('lookupData');
@@ -343,7 +350,6 @@ Compiler.prototype = {
   },
 
   addDepth: function(depth) {
-    if(isNaN(depth)) { throw new Error("EWOT"); }
     if(depth === 0) { return; }
 
     if(!this.depths[depth]) {
@@ -352,14 +358,14 @@ Compiler.prototype = {
     }
   },
 
-  classifyMustache: function(mustache) {
-    var isHelper   = mustache.isHelper;
-    var isEligible = mustache.eligibleHelper;
+  classifySexpr: function(sexpr) {
+    var isHelper   = sexpr.isHelper;
+    var isEligible = sexpr.eligibleHelper;
     var options    = this.options;
 
     // if ambiguous, we can possibly resolve the ambiguity now
     if (isEligible && !isHelper) {
-      var name = mustache.id.parts[0];
+      var name = sexpr.id.parts[0];
 
       if (options.knownHelpers[name]) {
         isHelper = true;
@@ -386,35 +392,27 @@ Compiler.prototype = {
 
         this.opcode('getContext', param.depth || 0);
         this.opcode('pushStringParam', param.stringModeValue, param.type);
+
+        if (param.type === 'sexpr') {
+          // Subexpressions get evaluated and passed in
+          // in string params mode.
+          this.sexpr(param);
+        }
       } else {
         this[param.type](param);
       }
     }
   },
 
-  setupMustacheParams: function(mustache) {
-    var params = mustache.params;
-    this.pushParams(params);
-
-    if(mustache.hash) {
-      this.hash(mustache.hash);
-    } else {
-      this.opcode('emptyHash');
-    }
-
-    return params;
-  },
-
-  // this will replace setupMustacheParams when we're done
-  setupFullMustacheParams: function(mustache, program, inverse) {
-    var params = mustache.params;
+  setupFullMustacheParams: function(sexpr, program, inverse) {
+    var params = sexpr.params;
     this.pushParams(params);
 
     this.opcode('pushProgram', program);
     this.opcode('pushProgram', inverse);
 
-    if(mustache.hash) {
-      this.hash(mustache.hash);
+    if (sexpr.hash) {
+      this.hash(sexpr.hash);
     } else {
       this.opcode('emptyHash');
     }
@@ -423,8 +421,8 @@ Compiler.prototype = {
   }
 };
 
-export function precompile(input, options) {
-  if (input == null || (typeof input !== 'string' && input.constructor !== AST.ProgramNode)) {
+export function precompile(input, options, env) {
+  if (input == null || (typeof input !== 'string' && input.constructor !== env.AST.ProgramNode)) {
     throw new Exception("You must pass a string or Handlebars AST to Handlebars.precompile. You passed " + input);
   }
 
@@ -433,13 +431,13 @@ export function precompile(input, options) {
     options.data = true;
   }
 
-  var ast = parse(input);
-  var environment = new Compiler().compile(ast, options);
-  return new JavaScriptCompiler().compile(environment, options);
+  var ast = env.parse(input);
+  var environment = new env.Compiler().compile(ast, options);
+  return new env.JavaScriptCompiler().compile(environment, options);
 }
 
 export function compile(input, options, env) {
-  if (input == null || (typeof input !== 'string' && input.constructor !== AST.ProgramNode)) {
+  if (input == null || (typeof input !== 'string' && input.constructor !== env.AST.ProgramNode)) {
     throw new Exception("You must pass a string or Handlebars AST to Handlebars.compile. You passed " + input);
   }
 
@@ -452,9 +450,9 @@ export function compile(input, options, env) {
   var compiled;
 
   function compileInput() {
-    var ast = parse(input);
-    var environment = new Compiler().compile(ast, options);
-    var templateSpec = new JavaScriptCompiler().compile(environment, options, undefined, true);
+    var ast = env.parse(input);
+    var environment = new env.Compiler().compile(ast, options);
+    var templateSpec = new env.JavaScriptCompiler().compile(environment, options, undefined, true);
     return env.template(templateSpec);
   }
 

lib/handlebars/compiler/javascript-compiler.js

@@ -1,4 +1,5 @@
 import { COMPILER_REVISION, REVISION_CHANGES, log } from "../base";
+import Exception from "../exception";
 
 function Literal(value) {
   this.value = value;
@@ -32,6 +33,12 @@ JavaScriptCompiler.prototype = {
     }
   },
 
+  compilerInfo: function() {
+    var revision = COMPILER_REVISION,
+        versions = REVISION_CHANGES[revision];
+    return "this.compilerInfo = ["+revision+",'"+versions+"'];\n";
+  },
+
   appendToBuffer: function(string) {
     if (this.environment.isSimple) {
       return "return " + string + ";";
@@ -70,6 +77,7 @@ JavaScriptCompiler.prototype = {
     this.stackSlot = 0;
     this.stackVars = [];
     this.registers = { list: [] };
+    this.hashes = [];
     this.compileStack = [];
     this.inlineStack = [];
 
@@ -97,6 +105,10 @@ JavaScriptCompiler.prototype = {
     // Flush any trailing content that might be pending.
     this.pushSource('');
 
+    if (this.stackSlot || this.inlineStack.length || this.compileStack.length) {
+      throw new Exception('Compile completed with content left on stack');
+    }
+
     return this.createFunctionContext(asObject);
   },
 
@@ -165,9 +177,7 @@ JavaScriptCompiler.prototype = {
     var source = this.mergeSource();
 
     if (!this.isChild) {
-      var revision = COMPILER_REVISION,
-          versions = REVISION_CHANGES[revision];
-      source = "this.compilerInfo = ["+revision+",'"+versions+"'];\n"+source;
+      source = this.compilerInfo()+source;
     }
 
     if (asObject) {
@@ -240,9 +250,6 @@ JavaScriptCompiler.prototype = {
     var current = this.topStack();
     params.splice(1, 0, current);
 
-    // Use the options value generated from the invocation
-    params[params.length-1] = 'options';
-
     this.pushSource("if (!" + this.lastHelper + ") { " + current + " = blockHelperMissing.call(" + params.join(", ") + "); }");
   },
 
@@ -378,7 +385,7 @@ JavaScriptCompiler.prototype = {
   //
   // Push the data lookup operator
   lookupData: function() {
-    this.push('data');
+    this.pushStackLiteral('data');
   },
 
   // [pushStringParam]
@@ -394,10 +401,14 @@ JavaScriptCompiler.prototype = {
 
     this.pushString(type);
 
-    if (typeof string === 'string') {
-      this.pushString(string);
-    } else {
-      this.pushStackLiteral(string);
+    // If it's a subexpression, the string result
+    // will be pushed after this opcode.
+    if (type !== 'sexpr') {
+      if (typeof string === 'string') {
+        this.pushString(string);
+      } else {
+        this.pushStackLiteral(string);
+      }
     }
   },
 
@@ -405,21 +416,25 @@ JavaScriptCompiler.prototype = {
     this.pushStackLiteral('{}');
 
     if (this.options.stringParams) {
-      this.register('hashTypes', '{}');
-      this.register('hashContexts', '{}');
+      this.push('{}'); // hashContexts
+      this.push('{}'); // hashTypes
     }
   },
   pushHash: function() {
+    if (this.hash) {
+      this.hashes.push(this.hash);
+    }
     this.hash = {values: [], types: [], contexts: []};
   },
   popHash: function() {
     var hash = this.hash;
-    this.hash = undefined;
+    this.hash = this.hashes.pop();
 
     if (this.options.stringParams) {
-      this.register('hashContexts', '{' + hash.contexts.join(',') + '}');
-      this.register('hashTypes', '{' + hash.types.join(',') + '}');
+      this.push('{' + hash.contexts.join(',') + '}');
+      this.push('{' + hash.types.join(',') + '}');
     }
+
     this.push('{\n    ' + hash.values.join(',\n    ') + '\n  }');
   },
 
@@ -481,18 +496,31 @@ JavaScriptCompiler.prototype = {
   // and pushes the helper's return value onto the stack.
   //
   // If the helper is not found, `helperMissing` is called.
-  invokeHelper: function(paramSize, name) {
+  invokeHelper: function(paramSize, name, isRoot) {
     this.context.aliases.helperMissing = 'helpers.helperMissing';
+    this.useRegister('helper');
 
     var helper = this.lastHelper = this.setupHelper(paramSize, name, true);
     var nonHelper = this.nameLookup('depth' + this.lastContext, name, 'context');
 
-    this.push(helper.name + ' || ' + nonHelper);
-    this.replaceStack(function(name) {
-      return name + ' ? ' + name + '.call(' +
-          helper.callParams + ") " + ": helperMissing.call(" +
-          helper.helperMissingParams + ")";
-    });
+    var lookup = 'helper = ' + helper.name + ' || ' + nonHelper;
+    if (helper.paramsInit) {
+      lookup += ',' + helper.paramsInit;
+    }
+
+    this.push(
+      '('
+        + lookup
+        + ',helper '
+          + '? helper.call(' + helper.callParams + ') '
+          + ': helperMissing.call(' + helper.helperMissingParams + '))');
+
+    // Always flush subexpressions. This is both to prevent the compounding size issue that
+    // occurs when the code has to be duplicated for inlining and also to prevent errors
+    // due to the incorrect options object being passed due to the shared register.
+    if (!isRoot) {
+      this.flushInline();
+    }
   },
 
   // [invokeKnownHelper]
@@ -521,8 +549,9 @@ JavaScriptCompiler.prototype = {
   // `knownHelpersOnly` flags at compile-time.
   invokeAmbiguous: function(name, helperCall) {
     this.context.aliases.functionType = '"function"';
+    this.useRegister('helper');
 
-    this.pushStackLiteral('{}');    // Hash value
+    this.emptyHash();
     var helper = this.setupHelper(0, name, helperCall);
 
     var helperName = this.lastHelper = this.nameLookup('helpers', name, 'helper');
@@ -530,8 +559,11 @@ JavaScriptCompiler.prototype = {
     var nonHelper = this.nameLookup('depth' + this.lastContext, name, 'context');
     var nextStack = this.nextStack();
 
-    this.pushSource('if (' + nextStack + ' = ' + helperName + ') { ' + nextStack + ' = ' + nextStack + '.call(' + helper.callParams + '); }');
-    this.pushSource('else { ' + nextStack + ' = ' + nonHelper + '; ' + nextStack + ' = typeof ' + nextStack + ' === functionType ? ' + nextStack + '.call(' + helper.callParams + ') : ' + nextStack + '; }');
+    if (helper.paramsInit) {
+      this.pushSource(helper.paramsInit);
+    }
+    this.pushSource('if (helper = ' + helperName + ') { ' + nextStack + ' = helper.call(' + helper.callParams + '); }');
+    this.pushSource('else { helper = ' + nonHelper + '; ' + nextStack + ' = typeof helper === functionType ? helper.call(' + helper.callParams + ') : helper; }');
   },
 
   // [invokePartial]
@@ -677,7 +709,9 @@ JavaScriptCompiler.prototype = {
   replaceStack: function(callback) {
     var prefix = '',
         inline = this.isInline(),
-        stack;
+        stack,
+        createdStack,
+        usedLiteral;
 
     // If we are currently inline then we want to merge the inline statement into the
     // replacement statement via ','
@@ -687,9 +721,11 @@ JavaScriptCompiler.prototype = {
       if (top instanceof Literal) {
         // Literals do not need to be inlined
         stack = top.value;
+        usedLiteral = true;
       } else {
         // Get or create the current stack name for use by the inline
-        var name = this.stackSlot ? this.topStackName() : this.incrStack();
+        createdStack = !this.stackSlot;
+        var name = !createdStack ? this.topStackName() : this.incrStack();
 
         prefix = '(' + this.push(name) + ' = ' + top + '),';
         stack = this.topStack();
@@ -701,9 +737,12 @@ JavaScriptCompiler.prototype = {
     var item = callback.call(this, stack);
 
     if (inline) {
-      if (this.inlineStack.length || this.compileStack.length) {
+      if (!usedLiteral) {
         this.popStack();
       }
+      if (createdStack) {
+        this.stackSlot--;
+      }
       this.push('(' + prefix + item + ')');
     } else {
       // Prevent modification of the context depth variable. Through replaceStack
@@ -754,6 +793,9 @@ JavaScriptCompiler.prototype = {
       return item.value;
     } else {
       if (!inline) {
+        if (!this.stackSlot) {
+          throw new Exception('Invalid stack pop');
+        }
         this.stackSlot--;
       }
       return item;
@@ -782,25 +824,29 @@ JavaScriptCompiler.prototype = {
   },
 
   setupHelper: function(paramSize, name, missingParams) {
-    var params = [];
-    this.setupParams(paramSize, params, missingParams);
+    var params = [],
+        paramsInit = this.setupParams(paramSize, params, missingParams);
     var foundHelper = this.nameLookup('helpers', name, 'helper');
 
     return {
       params: params,
+      paramsInit: paramsInit,
       name: foundHelper,
       callParams: ["depth0"].concat(params).join(", "),
       helperMissingParams: missingParams && ["depth0", this.quotedString(name)].concat(params).join(", ")
     };
   },
 
-  // the params and contexts arguments are passed in arrays
-  // to fill in
-  setupParams: function(paramSize, params, useRegister) {
+  setupOptions: function(paramSize, params) {
     var options = [], contexts = [], types = [], param, inverse, program;
 
     options.push("hash:" + this.popStack());
 
+    if (this.options.stringParams) {
+      options.push("hashTypes:" + this.popStack());
+      options.push("hashContexts:" + this.popStack());
+    }
+
     inverse = this.popStack();
     program = this.popStack();
 
@@ -813,7 +859,7 @@ JavaScriptCompiler.prototype = {
       }
 
       if (!inverse) {
-       this.context.aliases.self = "this";
+        this.context.aliases.self = "this";
         inverse = "self.noop";
       }
 
@@ -834,22 +880,28 @@ JavaScriptCompiler.prototype = {
     if (this.options.stringParams) {
       options.push("contexts:[" + contexts.join(",") + "]");
       options.push("types:[" + types.join(",") + "]");
-      options.push("hashContexts:hashContexts");
-      options.push("hashTypes:hashTypes");
     }
 
     if(this.options.data) {
       options.push("data:data");
     }
 
-    options = "{" + options.join(",") + "}";
+    return options;
+  },
+
+  // the params and contexts arguments are passed in arrays
+  // to fill in
+  setupParams: function(paramSize, params, useRegister) {
+    var options = '{' + this.setupOptions(paramSize, params).join(',') + '}';
+
     if (useRegister) {
-      this.register('options', options);
+      this.useRegister('options');
       params.push('options');
+      return 'options=' + options;
     } else {
       params.push(options);
+      return '';
     }
-    return params.join(", ");
   }
 };
 
@@ -878,7 +930,7 @@ for(var i=0, l=reservedWords.length; i<l; i++) {
 }
 
 JavaScriptCompiler.isValidJavaScriptVariableName = function(name) {
-  if(!JavaScriptCompiler.RESERVED_WORDS[name] && /^[a-zA-Z_$][0-9a-zA-Z_$]+$/.test(name)) {
+  if(!JavaScriptCompiler.RESERVED_WORDS[name] && /^[a-zA-Z_$][0-9a-zA-Z_$]*$/.test(name)) {
     return true;
   }
   return false;

lib/handlebars/compiler/printer.js

@@ -26,7 +26,6 @@ PrintVisitor.prototype.pad = function(string, newline) {
 PrintVisitor.prototype.program = function(program) {
   var out = "",
       statements = program.statements,
-      inverse = program.inverse,
       i, l;
 
   for(i=0, l=statements.length; i<l; i++) {
@@ -63,8 +62,8 @@ PrintVisitor.prototype.block = function(block) {
   return out;
 };
 
-PrintVisitor.prototype.mustache = function(mustache) {
-  var params = mustache.params, paramStrings = [], hash;
+PrintVisitor.prototype.sexpr = function(sexpr) {
+  var params = sexpr.params, paramStrings = [], hash;
 
   for(var i=0, l=params.length; i<l; i++) {
     paramStrings.push(this.accept(params[i]));
@@ -72,9 +71,13 @@ PrintVisitor.prototype.mustache = function(mustache) {
 
   params = "[" + paramStrings.join(", ") + "]";
 
-  hash = mustache.hash ? " " + this.accept(mustache.hash) : "";
+  hash = sexpr.hash ? " " + this.accept(sexpr.hash) : "";
 
-  return this.pad("{{ " + this.accept(mustache.id) + " " + params + hash + " }}");
+  return this.accept(sexpr.id) + " " + params + hash;
+};
+
+PrintVisitor.prototype.mustache = function(mustache) {
+  return this.pad("{{ " + this.accept(mustache.sexpr) + " }}");
 };
 
 PrintVisitor.prototype.partial = function(partial) {

lib/handlebars/exception.js

@@ -1,13 +1,25 @@
 
 var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack'];
 
-function Exception(/* message */) {
-  var tmp = Error.prototype.constructor.apply(this, arguments);
+function Exception(message, node) {
+  var line;
+  if (node && node.firstLine) {
+    line = node.firstLine;
+
+    message += ' - ' + line + ':' + node.firstColumn;
+  }
+
+  var tmp = Error.prototype.constructor.call(this, message);
 
   // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
   for (var idx = 0; idx < errorProps.length; idx++) {
     this[errorProps[idx]] = tmp[errorProps[idx]];
   }
+
+  if (line) {
+    this.lineNumber = line;
+    this.column = node.firstColumn;
+  }
 }
 
 Exception.prototype = new Error();

lib/handlebars/runtime.js

@@ -1,9 +1,8 @@
-/*global Utils */
 module Utils from "./utils";
 import Exception from "./exception";
 import { COMPILER_REVISION, REVISION_CHANGES } from "./base";
 
-function checkRevision(compilerInfo) {
+export function checkRevision(compilerInfo) {
   var compilerRevision = compilerInfo && compilerInfo[0] || 1,
       currentRevision = COMPILER_REVISION;
 
@@ -11,11 +10,11 @@ function checkRevision(compilerInfo) {
     if (compilerRevision < currentRevision) {
       var runtimeVersions = REVISION_CHANGES[currentRevision],
           compilerVersions = REVISION_CHANGES[compilerRevision];
-      throw new Error("Template was precompiled with an older version of Handlebars than the current runtime. "+
+      throw new Exception("Template was precompiled with an older version of Handlebars than the current runtime. "+
             "Please update your precompiler to a newer version ("+runtimeVersions+") or downgrade your runtime to an older version ("+compilerVersions+").");
     } else {
       // Use the embedded version info since the runtime doesn't know about this revision yet
-      throw new Error("Template was precompiled with a newer version of Handlebars than the current runtime. "+
+      throw new Exception("Template was precompiled with a newer version of Handlebars than the current runtime. "+
             "Please update your runtime to a newer version ("+compilerInfo[1]+").");
     }
   }
@@ -25,28 +24,23 @@ function checkRevision(compilerInfo) {
 
 export function template(templateSpec, env) {
   if (!env) {
-    throw new Error("No environment passed to template");
+    throw new Exception("No environment passed to template");
   }
 
-  var invokePartialWrapper;
-  if (env.compile) {
-    invokePartialWrapper = function(partial, name, context, helpers, partials, data) {
-      // TODO : Check this for all inputs and the options handling (partial flag, etc). This feels
-      // like there should be a common exec path
-      var result = invokePartial.apply(this, arguments);
-      if (result) { return result; }
+  // Note: Using env.VM references rather than local var references throughout this section to allow
+  // for external users to override these as psuedo-supported APIs.
+  var invokePartialWrapper = function(partial, name, context, helpers, partials, data) {
+    var result = env.VM.invokePartial.apply(this, arguments);
+    if (result != null) { return result; }
 
+    if (env.compile) {
       var options = { helpers: helpers, partials: partials, data: data };
       partials[name] = env.compile(partial, { data: data !== undefined }, env);
       return partials[name](context, options);
-    };
-  } else {
-    invokePartialWrapper = function(partial, name /* , context, helpers, partials, data */) {
-      var result = invokePartial.apply(this, arguments);
-      if (result) { return result; }
+    } else {
       throw new Exception("The partial " + name + " could not be compiled when running in runtime-only mode");
-    };
-  }
+    }
+  };
 
   // Just add water
   var container = {
@@ -72,8 +66,8 @@ export function template(templateSpec, env) {
       }
       return ret;
     },
-    programWithDepth: programWithDepth,
-    noop: noop,
+    programWithDepth: env.VM.programWithDepth,
+    noop: env.VM.noop,
     compilerInfo: null
   };
 
@@ -95,7 +89,7 @@ export function template(templateSpec, env) {
           options.data);
 
     if (!options.partial) {
-      checkRevision(container.compilerInfo);
+      env.VM.checkRevision(container.compilerInfo);
     }
 
     return result;

lib/handlebars/utils.js

@@ -1,7 +1,6 @@
+/*jshint -W004 */
 import SafeString from "./safe-string";
 
-var isArray = Array.isArray;
-
 var escape = {
   "&": "&",
   "<": "&lt;",
@@ -20,12 +19,32 @@ function escapeChar(chr) {
 
 export function extend(obj, value) {
   for(var key in value) {
-    if(value.hasOwnProperty(key)) {
+    if(Object.prototype.hasOwnProperty.call(value, key)) {
       obj[key] = value[key];
     }
   }
 }
 
+export var toString = Object.prototype.toString;
+
+// Sourced from lodash
+// https://github.com/bestiejs/lodash/blob/master/LICENSE.txt
+var isFunction = function(value) {
+  return typeof value === 'function';
+};
+// fallback for older versions of Chrome and Safari
+if (isFunction(/x/)) {
+  isFunction = function(value) {
+    return typeof value === 'function' && toString.call(value) === '[object Function]';
+  };
+}
+export var isFunction;
+
+export var isArray = Array.isArray || function(value) {
+  return (value && typeof value === 'object') ? toString.call(value) === '[object Array]' : false;
+};
+
+
 export function escapeExpression(string) {
   // don't escape SafeStrings, since they're already safe
   if (string instanceof SafeString) {

lib/index.js

@@ -3,9 +3,9 @@
 
 // var local = handlebars.create();
 
-var handlebars = require('../dist/cjs/handlebars').default;
+var handlebars = require('../dist/cjs/handlebars')["default"];
 
-handlebars.Visitor = require('../dist/cjs/handlebars/compiler/visitor').default;
+handlebars.Visitor = require('../dist/cjs/handlebars/compiler/visitor')["default"];
 
 var printer = require('../dist/cjs/handlebars/compiler/printer');
 handlebars.PrintVisitor = printer.PrintVisitor;

package.json

@@ -1,7 +1,7 @@
 {
   "name": "handlebars",
   "barename": "handlebars",
-  "version": "1.1.1",
+  "version": "1.3.0",
   "description": "Handlebars provides the power necessary to let you build semantic templates effectively with no frustration",
   "homepage": "http://www.handlebarsjs.com/",
   "keywords": [
@@ -15,7 +15,7 @@
     "url": "https://github.com/wycats/handlebars.js.git"
   },
   "author": "Yehuda Katz",
-  "license": "BSD",
+  "license": "MIT",
   "readmeFilename": "README.md",
   "engines": {
     "node": ">=0.4.7"
@@ -33,19 +33,22 @@
     "dustjs-linkedin": "~2.0.2",
     "eco": "~1.1.0-rc-3",
     "grunt": "~0.4.1",
+    "grunt-cli": "~0.1.10",
     "grunt-contrib-clean": "~0.4.1",
+    "grunt-contrib-concat": "~0.3.0",
+    "grunt-contrib-connect": "~0.5.0",
     "grunt-contrib-copy": "~0.4.1",
-    "grunt-contrib-jshint": "~0.6.3",
+    "grunt-contrib-jshint": "0.x",
     "grunt-contrib-requirejs": "~0.4.1",
     "grunt-contrib-uglify": "~0.2.2",
-    "grunt-es6-module-transpiler": "joefiorini/grunt-es6-module-transpiler",
-    "es6-module-packager": "*",
+    "grunt-contrib-watch": "~0.5.3",
+    "grunt-saucelabs": "~4.1.2",
+    "es6-module-packager": "0.x",
     "jison": "~0.3.0",
     "keen.io": "0.0.3",
     "mocha": "*",
     "mustache": "~0.7.2",
     "semver": "~2.1.0",
-    "should": "~1.2.2",
     "underscore": "~1.5.1"
   },
   "main": "lib/index.js",

release-notes.md

@@ -2,7 +2,63 @@
 
 ## Development
 
-[Commits](https://github.com/wycats/handlebars.js/compare/v1.1.1...master)
+[Commits](https://github.com/wycats/handlebars.js/compare/v1.3.0...master)
+
+## v1.3.0 - January 1st, 2014
+- [#690](https://github.com/wycats/handlebars.js/pull/690) - Added support for subexpressions ([@machty](https://api.github.com/users/machty))
+- [#696](https://github.com/wycats/handlebars.js/pull/696) - Fix for reserved keyword "default" ([@nateirwin](https://api.github.com/users/nateirwin))
+- [#692](https://github.com/wycats/handlebars.js/pull/692) - add line numbers to nodes when parsing ([@fivetanley](https://api.github.com/users/fivetanley))
+- [#695](https://github.com/wycats/handlebars.js/pull/695) - Pull options out from param setup to allow easier extension ([@blakeembrey](https://api.github.com/users/blakeembrey))
+- [#694](https://github.com/wycats/handlebars.js/pull/694) - Make the environment reusable ([@blakeembrey](https://api.github.com/users/blakeembrey))
+- [#636](https://github.com/wycats/handlebars.js/issues/636) - Print line and column of errors ([@sgronblo](https://api.github.com/users/sgronblo))
+- Use literal for data lookup - c1a93d3
+- Add stack handling sanity checks - cd885bf
+- Fix stack id "leak" on replaceStack - ddfe457
+- Fix incorrect stack pop when replacing literals - f4d337d
+
+[Commits](https://github.com/wycats/handlebars.js/compare/v1.2.1...v1.3.0)
+
+## v1.2.1 - December 26th, 2013
+- [#684](https://github.com/wycats/handlebars.js/pull/684) - Allow any number of trailing characters for valid JavaScript variable ([@blakeembrey](https://api.github.com/users/blakeembrey))
+- [#686](https://github.com/wycats/handlebars.js/pull/686) - Falsy AMD module names in version 1.2.0 ([@kpdecker](https://api.github.com/users/kpdecker))
+
+[Commits](https://github.com/wycats/handlebars.js/compare/v1.2.0...v1.2.1)
+
+## v1.2.0 - December 23rd, 2013
+- [#675](https://github.com/wycats/handlebars.js/issues/675) - Cannot compile empty template for partial ([@erwinw](https://api.github.com/users/erwinw))
+- [#677](https://github.com/wycats/handlebars.js/issues/677) - Triple brace statements fail under IE ([@hamzaCM](https://api.github.com/users/hamzaCM))
+- [#655](https://github.com/wycats/handlebars.js/issues/655) - Loading Handlebars using bower ([@niki4810](https://api.github.com/users/niki4810))
+- [#657](https://github.com/wycats/handlebars.js/pull/657) - Fixes issue where cli compiles non handlebars templates ([@chrishoage](https://api.github.com/users/chrishoage))
+- [#681](https://github.com/wycats/handlebars.js/pull/681) - Adds in-browser testing and Saucelabs CI ([@kpdecker](https://api.github.com/users/kpdecker))
+- [#661](https://github.com/wycats/handlebars.js/pull/661) - Add @first and @index to #each object iteration ([@cgp](https://api.github.com/users/cgp))
+- [#650](https://github.com/wycats/handlebars.js/pull/650) - Handlebars is MIT-licensed ([@thomasboyt](https://api.github.com/users/thomasboyt))
+- [#641](https://github.com/wycats/handlebars.js/pull/641) - Document ember testing process ([@kpdecker](https://api.github.com/users/kpdecker))
+- [#662](https://github.com/wycats/handlebars.js/issues/662) - handlebars-source 1.1.2 is missing from RubyGems.
+- [#656](https://github.com/wycats/handlebars.js/issues/656) - Expose COMPILER_REVISION checks as a hook ([@machty](https://api.github.com/users/machty))
+- [#668](https://github.com/wycats/handlebars.js/issues/668) - Consider publishing handlebars-runtime as a separate module on npm ([@dlmanning](https://api.github.com/users/dlmanning))
+- [#679](https://github.com/wycats/handlebars.js/issues/679) - Unable to override invokePartial ([@mattbrailsford](https://api.github.com/users/mattbrailsford))
+- [#646](https://github.com/wycats/handlebars.js/pull/646) - Fix "\\{{" immediately following "\{{" ([@dmarcotte](https://api.github.com/users/dmarcotte))
+- Allow extend to work with non-prototyped objects - eb53f2e
+- Add JavascriptCompiler public API tests - 1a751b2
+- Add AST test coverage for more complex paths - ddea5be
+- Fix handling of boolean escape in MustacheNode - b4968bb
+
+Compatibility notes:
+- `@index` and `@first` are now supported for `each` iteration on objects
+- `Handlebars.VM.checkRevision` and `Handlebars.JavaScriptCompiler.prototype.compilerInfo` now available to modify the version checking behavior.
+- Browserify users may link to the runtime library via `require('handlebars/runtime')`
+
+[Commits](https://github.com/wycats/handlebars.js/compare/v1.1.2...v1.2.0)
+
+## v1.1.2 - November 5th, 2013
+
+- [#645](https://github.com/wycats/handlebars.js/issues/645) - 1.1.1 fails under IE8 ([@kpdecker](https://api.github.com/users/kpdecker))
+- [#644](https://github.com/wycats/handlebars.js/issues/644) - Using precompiled templates (AMD mode) with handlebars.runtime 1.1.1 ([@fddima](https://api.github.com/users/fddima))
+
+- Add simple binary utility tests - 96a45a4
+- Fix empty string compilation - eea708a
+
+[Commits](https://github.com/wycats/handlebars.js/compare/v1.1.1...v1.1.2)
 
 ## v1.1.1 - November 4th, 2013
 

runtime.js

@@ -0,0 +1,3 @@
+// Create a simple path alias to allow browserify to resolve
+// the runtime on a supported path.
+module.exports = require('./dist/cjs/handlebars.runtime');

spec/amd.html

@@ -0,0 +1,73 @@
+<html>
+  <head>
+    <title>Mocha</title>
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+
+    <link rel="stylesheet" href="/node_modules/mocha/mocha.css" />
+    <style>
+      .headless .suite > h1,
+      .headless .test.pass {
+        display: none;
+      }
+    </style>
+
+    <script>
+      // Show only errors in "headless", non-interactive mode.
+      if (/headless=true/.test(location.href)) {
+        document.documentElement.className = 'headless';
+      }
+    </script>
+    <script src="/node_modules/mocha/mocha.js"></script>
+    <script>
+      mocha.setup('bdd');
+    </script>
+
+    <script src="/spec/env/require.js"></script>
+
+    <script src="/spec/env/common.js"></script>
+    <script>
+      requirejs.config({
+        paths: {
+          handlebars: '/dist/handlebars.amd',
+          tests: '/tmp/tests'
+        }
+      });
+
+      var CompilerContext = {
+        compile: function(template, options) {
+          var templateSpec = handlebarsEnv.precompile(template, options);
+          return handlebarsEnv.template(safeEval(templateSpec));
+        },
+        compileWithPartial: function(template, options) {
+          return handlebarsEnv.compile(template, options);
+        }
+      };
+
+      function safeEval(templateSpec) {
+        var ret;
+        eval('ret = ' + templateSpec);
+        return ret;
+      }
+    </script>
+    <script>
+      onload = function(){
+
+        require(['handlebars'], function(Handlebars) {
+          window.Handlebars = Handlebars['default'];
+
+          require(['tests'], function(Handlebars) {
+            // The test harness leaks under FF. We should have decent global leak coverage from other tests
+            if (!navigator.userAgent.match(/Firefox\/([\d.]+)/)) {
+              mocha.checkLeaks();
+            }
+            mocha.run();
+          });
+        });
+      };
+    </script>
+  </head>
+  <body>
+    <div id="mocha"></div>
+  </body>
+</html>

spec/ast.js

@@ -0,0 +1,276 @@
+/*global Handlebars, handlebarsEnv, shouldThrow */
+describe('ast', function() {
+  if (!Handlebars.AST) {
+    return;
+  }
+
+  var LOCATION_INFO = {
+    last_line: 0,
+    first_line: 0,
+    first_column: 0,
+    last_column: 0
+  };
+
+  function testLocationInfoStorage(node){
+    var properties = [ 'firstLine', 'lastLine', 'firstColumn', 'lastColumn' ],
+        property,
+        propertiesLen = properties.length,
+        i;
+
+    for (i = 0; i < propertiesLen; i++){
+      property = properties[0];
+      equals(node[property], 0);
+    }
+  }
+
+  describe('MustacheNode', function() {
+    function testEscape(open, expected) {
+      var mustache = new handlebarsEnv.AST.MustacheNode([{}], {}, open, false);
+      equals(mustache.escaped, expected);
+    }
+
+    it('should store args', function() {
+      var id = {isSimple: true},
+          hash = {},
+          mustache = new handlebarsEnv.AST.MustacheNode([id, 'param1'], hash, '', false, LOCATION_INFO);
+      equals(mustache.type, 'mustache');
+      equals(mustache.hash, hash);
+      equals(mustache.escaped, true);
+      equals(mustache.id, id);
+      equals(mustache.params.length, 1);
+      equals(mustache.params[0], 'param1');
+      equals(!!mustache.isHelper, true);
+      testLocationInfoStorage(mustache);
+    });
+    it('should accept token for escape', function() {
+      testEscape('{{', true);
+      testEscape('{{~', true);
+      testEscape('{{#', true);
+      testEscape('{{~#', true);
+      testEscape('{{/', true);
+      testEscape('{{~/', true);
+      testEscape('{{^', true);
+      testEscape('{{~^', true);
+      testEscape('{', true);
+      testEscape('{', true);
+
+      testEscape('{{&', false);
+      testEscape('{{~&', false);
+      testEscape('{{{', false);
+      testEscape('{{~{', false);
+    });
+    it('should accept boolean for escape', function() {
+      testEscape(true, true);
+      testEscape({}, true);
+
+      testEscape(false, false);
+      testEscape(undefined, false);
+    });
+  });
+  describe('BlockNode', function() {
+    it('should throw on mustache mismatch (old sexpr-less version)', function() {
+      shouldThrow(function() {
+        var mustacheNode = new handlebarsEnv.AST.MustacheNode([{ original: 'foo'}], null, '{{', {});
+        new handlebarsEnv.AST.BlockNode(mustacheNode, {}, {}, {path: {original: 'bar'}});
+      }, Handlebars.Exception, "foo doesn't match bar");
+    });
+    it('should throw on mustache mismatch', function() {
+      shouldThrow(function() {
+        var sexprNode = new handlebarsEnv.AST.SexprNode([{ original: 'foo'}], null);
+        var mustacheNode = new handlebarsEnv.AST.MustacheNode(sexprNode, null, '{{', {});
+        new handlebarsEnv.AST.BlockNode(mustacheNode, {}, {}, {path: {original: 'bar'}}, {first_line: 2, first_column: 2});
+      }, Handlebars.Exception, "foo doesn't match bar - 2:2");
+    });
+
+    it('stores location info', function(){
+      var sexprNode = new handlebarsEnv.AST.SexprNode([{ original: 'foo'}], null);
+      var mustacheNode = new handlebarsEnv.AST.MustacheNode(sexprNode, null, '{{', {});
+      var block = new handlebarsEnv.AST.BlockNode(mustacheNode,
+                                                  {strip: {}}, {strip: {}},
+                                                  {
+                                                    strip: {},
+                                                    path: {original: 'foo'}
+                                                  },
+                                                  LOCATION_INFO);
+      testLocationInfoStorage(block);
+    });
+  });
+  describe('IdNode', function() {
+    it('should throw on invalid path', function() {
+      shouldThrow(function() {
+        new handlebarsEnv.AST.IdNode([
+          {part: 'foo'},
+          {part: '..'},
+          {part: 'bar'}
+        ], {first_line: 1, first_column: 1});
+      }, Handlebars.Exception, "Invalid path: foo.. - 1:1");
+      shouldThrow(function() {
+        new handlebarsEnv.AST.IdNode([
+          {part: 'foo'},
+          {part: '.'},
+          {part: 'bar'}
+        ], {first_line: 1, first_column: 1});
+      }, Handlebars.Exception, "Invalid path: foo. - 1:1");
+      shouldThrow(function() {
+        new handlebarsEnv.AST.IdNode([
+          {part: 'foo'},
+          {part: 'this'},
+          {part: 'bar'}
+        ], {first_line: 1, first_column: 1});
+      }, Handlebars.Exception, "Invalid path: foothis - 1:1");
+    });
+
+    it('stores location info', function(){
+      var idNode = new handlebarsEnv.AST.IdNode([], LOCATION_INFO);
+      testLocationInfoStorage(idNode);
+    });
+  });
+
+  describe("HashNode", function(){
+
+    it('stores location info', function(){
+      var hash = new handlebarsEnv.AST.HashNode([], LOCATION_INFO);
+      testLocationInfoStorage(hash);
+    });
+  });
+
+  describe("ContentNode", function(){
+
+    it('stores location info', function(){
+      var content = new handlebarsEnv.AST.ContentNode("HI", LOCATION_INFO);
+      testLocationInfoStorage(content);
+    });
+  });
+
+  describe("CommentNode", function(){
+
+    it('stores location info', function(){
+      var comment = new handlebarsEnv.AST.CommentNode("HI", LOCATION_INFO);
+      testLocationInfoStorage(comment);
+    });
+  });
+
+  describe("IntegerNode", function(){
+
+    it('stores location info', function(){
+      var integer = new handlebarsEnv.AST.IntegerNode("6", LOCATION_INFO);
+      testLocationInfoStorage(integer);
+    });
+  });
+
+  describe("StringNode", function(){
+
+    it('stores location info', function(){
+      var string = new handlebarsEnv.AST.StringNode("6", LOCATION_INFO);
+      testLocationInfoStorage(string);
+    });
+  });
+
+  describe("BooleanNode", function(){
+
+    it('stores location info', function(){
+      var bool = new handlebarsEnv.AST.BooleanNode("true", LOCATION_INFO);
+      testLocationInfoStorage(bool);
+    });
+  });
+
+  describe("DataNode", function(){
+
+    it('stores location info', function(){
+      var data = new handlebarsEnv.AST.DataNode("YES", LOCATION_INFO);
+      testLocationInfoStorage(data);
+    });
+  });
+
+  describe("PartialNameNode", function(){
+
+    it('stores location info', function(){
+      var pnn = new handlebarsEnv.AST.PartialNameNode({original: "YES"}, LOCATION_INFO);
+      testLocationInfoStorage(pnn);
+    });
+  });
+
+  describe("PartialNode", function(){
+
+    it('stores location info', function(){
+      var pn = new handlebarsEnv.AST.PartialNode("so_partial", {}, {}, LOCATION_INFO);
+      testLocationInfoStorage(pn);
+    });
+  });
+  describe("ProgramNode", function(){
+
+    describe("storing location info", function(){
+      it("stores when `inverse` argument isn't passed", function(){
+        var pn = new handlebarsEnv.AST.ProgramNode([], LOCATION_INFO);
+        testLocationInfoStorage(pn);
+      });
+
+      it("stores when `inverse` or `stripInverse` arguments passed", function(){
+        var pn = new handlebarsEnv.AST.ProgramNode([], {strip: {}}, undefined, LOCATION_INFO);
+        testLocationInfoStorage(pn);
+
+        var clone = {
+          strip: {},
+          firstLine: 0,
+          lastLine: 0,
+          firstColumn: 0,
+          lastColumn: 0
+        };
+        pn = new handlebarsEnv.AST.ProgramNode([], {strip: {}}, [ clone ], LOCATION_INFO);
+        testLocationInfoStorage(pn);
+
+        // Assert that the newly created ProgramNode has the same location
+        // information as the inverse
+        testLocationInfoStorage(pn.inverse);
+      });
+    });
+  });
+
+  describe("Line Numbers", function(){
+    var ast, statements;
+
+    function testColumns(node, firstLine, lastLine, firstColumn, lastColumn){
+      equals(node.firstLine, firstLine);
+      equals(node.lastLine, lastLine);
+      equals(node.firstColumn, firstColumn);
+      equals(node.lastColumn, lastColumn);
+    }
+
+    ast = Handlebars.parse("line 1 {{line1Token}}\n line 2 {{line2token}}\n line 3 {{#blockHelperOnLine3}}\nline 4{{line4token}}\n" +
+                           "line5{{else}}\n{{line6Token}}\n{{/blockHelperOnLine3}}");
+    statements = ast.statements;
+
+    it('gets ContentNode line numbers', function(){
+      var contentNode = statements[0];
+      testColumns(contentNode, 1, 1, 0, 7);
+    });
+
+    it('gets MustacheNode line numbers', function(){
+      var mustacheNode = statements[1];
+      testColumns(mustacheNode, 1, 1, 7, 21);
+    });
+
+    it('gets line numbers correct when newlines appear', function(){
+      var secondContentNode = statements[2];
+      testColumns(secondContentNode, 1, 2, 21, 8);
+    });
+
+    it('gets MustacheNode line numbers correct across newlines', function(){
+      var secondMustacheNode = statements[3];
+      testColumns(secondMustacheNode, 2, 2, 8, 22);
+     });
+
+     it('gets the block helper information correct', function(){
+       var blockHelperNode = statements[5];
+       testColumns(blockHelperNode, 3, 7, 8, 23);
+     });
+
+     it('correctly records the line numbers of an inverse of a block helper', function(){
+       var blockHelperNode = statements[5],
+           inverse = blockHelperNode.inverse;
+
+       testColumns(inverse, 5, 6, 13, 0);
+     });
+  });
+});
+

spec/basic.js

@@ -1,3 +1,4 @@
+/*global CompilerContext, Handlebars, beforeEach, shouldCompileTo */
 global.handlebarsEnv = null;
 
 beforeEach(function() {
@@ -160,9 +161,9 @@ describe("basic context", function() {
 
   it("this keyword nested inside path", function() {
     var string = "{{#hellos}}{{text/this/foo}}{{/hellos}}";
-    (function() {
+    shouldThrow(function() {
       CompilerContext.compile(string);
-    }).should.throw(Error);
+    }, Error);
   });
 
   it("this keyword in helpers", function() {
@@ -181,8 +182,8 @@ describe("basic context", function() {
 
   it("this keyword nested inside helpers param", function() {
     var string = "{{#hellos}}{{foo text/this/foo}}{{/hellos}}";
-    (function() {
+    shouldThrow(function() {
       CompilerContext.compile(string);
-    }).should.throw(Error);
+    }, Error);
   });
 });

spec/blocks.js

@@ -42,9 +42,9 @@ describe('blocks', function() {
   it("block with complex lookup using nested context", function() {
     var string = "{{#goodbyes}}{{text}} cruel {{foo/../name}}! {{/goodbyes}}";
 
-    (function() {
+    shouldThrow(function() {
       CompilerContext.compile(string);
-    }).should.throw(Error);
+    }, Error);
   });
 
   it("block with deep nested complex lookup", function() {

spec/builtins.js

@@ -73,7 +73,7 @@ describe('builtin helpers', function() {
       var expected1 = "<b>#1</b>. goodbye! 2. GOODBYE! cruel world!";
       var expected2 = "2. GOODBYE! <b>#1</b>. goodbye! cruel world!";
 
-      (actual === expected1 || actual === expected2).should.equal(true, "each with object argument iterates over the contents when not empty");
+      equals(actual === expected1 || actual === expected2, true, "each with object argument iterates over the contents when not empty");
       shouldCompileTo(string, {goodbyes: [], world: "world"}, "cruel world!",
                       "each with object argument ignores the contents when empty");
     });
@@ -98,6 +98,17 @@ describe('builtin helpers', function() {
       equal(result, "0. goodbye! 0 1 2 After 0 1. Goodbye! 0 1 2 After 1 2. GOODBYE! 0 1 2 After 2 cruel world!", "The @index variable is used");
     });
 
+    it("each object with @index", function() {
+      var string = "{{#each goodbyes}}{{@index}}. {{text}}! {{/each}}cruel {{world}}!";
+      var hash   = {goodbyes: {'a': {text: "goodbye"}, b: {text: "Goodbye"}, c: {text: "GOODBYE"}}, world: "world"};
+
+      var template = CompilerContext.compile(string);
+      var result = template(hash);
+
+      equal(result, "0. goodbye! 1. Goodbye! 2. GOODBYE! cruel world!", "The @index variable is used");
+    });
+
+
     it("each with @first", function() {
       var string = "{{#each goodbyes}}{{#if @first}}{{text}}! {{/if}}{{/each}}cruel {{world}}!";
       var hash   = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}], world: "world"};
@@ -118,6 +129,16 @@ describe('builtin helpers', function() {
       equal(result, "(goodbye! goodbye! goodbye!) (goodbye!) (goodbye!) cruel world!", "The @first variable is used");
     });
 
+    it("each object with @first", function() {
+      var string = "{{#each goodbyes}}{{#if @first}}{{text}}! {{/if}}{{/each}}cruel {{world}}!";
+      var hash   = {goodbyes: {'foo': {text: "goodbye"}, bar: {text: "Goodbye"}}, world: "world"};
+
+      var template = CompilerContext.compile(string);
+      var result = template(hash);
+
+      equal(result, "goodbye! cruel world!", "The @first variable is used");
+    });
+
     it("each with @last", function() {
       var string = "{{#each goodbyes}}{{#if @last}}{{text}}! {{/if}}{{/each}}cruel {{world}}!";
       var hash   = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}], world: "world"};

spec/data.js

@@ -1,4 +1,4 @@
-/*global CompilerContext */
+/*global CompilerContext, Handlebars, handlebarsEnv, shouldThrow */
 describe('data', function() {
   it("passing in data to a compiled function that expects data - works with helpers", function() {
     var template = CompilerContext.compile("{{hello}}", {data: true});
@@ -88,25 +88,25 @@ describe('data', function() {
   it("parameter data throws when using this scope references", function() {
     var string = "{{#goodbyes}}{{text}} cruel {{@./name}}! {{/goodbyes}}";
 
-    (function() {
+    shouldThrow(function() {
       CompilerContext.compile(string);
-    }).should.throw(Error);
+    }, Error);
   });
 
   it("parameter data throws when using parent scope references", function() {
     var string = "{{#goodbyes}}{{text}} cruel {{@../name}}! {{/goodbyes}}";
 
-    (function() {
+    shouldThrow(function() {
       CompilerContext.compile(string);
-    }).should.throw(Error);
+    }, Error);
   });
 
   it("parameter data throws when using complex scope references", function() {
     var string = "{{#goodbyes}}{{text}} cruel {{@foo/../name}}! {{/goodbyes}}";
 
-    (function() {
+    shouldThrow(function() {
       CompilerContext.compile(string);
-    }).should.throw(Error);
+    }, Error);
   });
 
   it("data is inherited downstream", function() {

spec/env/common.js

@@ -1,12 +1,12 @@
-global.should = require('should');
-
 global.shouldCompileTo = function(string, hashOrArray, expected, message) {
   shouldCompileToWithPartials(string, hashOrArray, false, expected, message);
 };
 
 global.shouldCompileToWithPartials = function(string, hashOrArray, partials, expected, message) {
   var result = compileWithPartials(string, hashOrArray, partials);
-  result.should.equal(expected, "'" + expected + "' should === '" + result + "': " + message);
+  if (result !== expected) {
+    throw new Error("'" + expected + "' should === '" + result + "': " + message);
+  }
 };
 
 global.compileWithPartials = function(string, hashOrArray, partials) {
@@ -24,5 +24,25 @@ global.compileWithPartials = function(string, hashOrArray, partials) {
 
 
 global.equals = global.equal = function(a, b, msg) {
-  a.should.equal(b, msg || '');
+  if (a !== b) {
+    throw new Error("'" + b + "' should === '" + a + "'" + (msg ? ": " + msg : ''));
+  }
+};
+
+global.shouldThrow = function(callback, type, msg) {
+  var failed;
+  try {
+    callback();
+    failed = true;
+  } catch (err) {
+    if (type && !(err instanceof type)) {
+      throw new Error('Type failure');
+    }
+    if (msg && !(msg.test ? msg.test(err.message) : msg === err.message)) {
+      throw new Error('Message failure');
+    }
+  }
+  if (failed) {
+    throw new Error('It failed to throw');
+  }
 };

spec/env/runtime.js

@@ -8,11 +8,21 @@ var _ = require('underscore'),
 global.Handlebars = undefined;
 vm.runInThisContext(fs.readFileSync(__dirname + '/../../dist/handlebars.runtime.js'), 'dist/handlebars.runtime.js');
 
+var parse = require('../../dist/cjs/handlebars/compiler/base').parse;
 var compiler = require('../../dist/cjs/handlebars/compiler/compiler');
+var JavaScriptCompiler = require('../../dist/cjs/handlebars/compiler/javascript-compiler')['default'];
 
 global.CompilerContext = {
   compile: function(template, options) {
-    var templateSpec = compiler.precompile(template, options);
+    // Hack the compiler on to the environment for these specific tests
+    handlebarsEnv.precompile = function(template, options) {
+      return compiler.precompile(template, options, handlebarsEnv);
+    };
+    handlebarsEnv.parse = parse;
+    handlebarsEnv.Compiler = compiler.Compiler;
+    handlebarsEnv.JavaScriptCompiler = JavaScriptCompiler;
+
+    var templateSpec = handlebarsEnv.precompile(template, options);
     return handlebarsEnv.template(safeEval(templateSpec));
   },
   compileWithPartial: function(template, options) {
@@ -20,6 +30,10 @@ global.CompilerContext = {
     handlebarsEnv.compile = function(template, options) {
       return compiler.compile(template, options, handlebarsEnv);
     };
+    handlebarsEnv.parse = parse;
+    handlebarsEnv.Compiler = compiler.Compiler;
+    handlebarsEnv.JavaScriptCompiler = JavaScriptCompiler;
+
     return handlebarsEnv.compile(template, options);
   }
 };

spec/expected/empty.amd.js

@@ -0,0 +1,11 @@
+define(['handlebars.runtime'], function(Handlebars) {
+  Handlebars = Handlebars["default"];  var template = Handlebars.template, templates = Handlebars.templates = Handlebars.templates || {};
+return templates['empty'] = template(function (Handlebars,depth0,helpers,partials,data) {
+  this.compilerInfo = [4,'>= 1.0.0'];
+helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
+  var buffer = "";
+
+
+  return buffer;
+  });
+});

spec/helpers.js

@@ -1,4 +1,4 @@
-/*global CompilerContext, shouldCompileTo, shouldCompileToWithPartials */
+/*global CompilerContext, Handlebars, shouldCompileTo, shouldCompileToWithPartials, shouldThrow, handlebarsEnv */
 describe('helpers', function() {
   it("helper with complex lookup$", function() {
     var string = "{{#goodbyes}}{{{link ../prefix}}}{{/goodbyes}}";
@@ -212,10 +212,10 @@ describe('helpers', function() {
     });
 
     it("using a quote in the middle of a parameter raises an error", function() {
-      (function() {
-        var string   = 'Message: {{hello wo"rld"}}';
+      var string   = 'Message: {{hello wo"rld"}}';
+      shouldThrow(function() {
         CompilerContext.compile(string);
-      }).should.throw(Error);
+      }, Error);
     });
 
     it("escaping a String is possible", function(){
@@ -351,10 +351,10 @@ describe('helpers', function() {
 
   describe("helperMissing", function() {
     it("if a context is not found, helperMissing is used", function() {
-      (function() {
+      shouldThrow(function() {
           var template = CompilerContext.compile("{{hello}} {{link_to world}}");
           template({});
-      }).should.throw(/Missing helper: 'link_to'/);
+      }, undefined, /Missing helper: 'link_to'/);
     });
 
     it("if a context is not found, custom helperMissing is used", function() {
@@ -417,9 +417,9 @@ describe('helpers', function() {
       equal(result, "bar", "'bar' should === '" + result);
     });
     it("Unknown helper call in knownHelpers only mode should throw", function() {
-      (function() {
+      shouldThrow(function() {
         CompilerContext.compile("{{typeof hello}}", {knownHelpersOnly: true});
-      }).should.throw(Error);
+      }, Error);
     });
   });
 
@@ -491,7 +491,7 @@ describe('helpers', function() {
 
         cruel: function(world) {
           return "cruel " + world.toUpperCase();
-        },
+        }
       };
 
       var context = {
@@ -513,7 +513,7 @@ describe('helpers', function() {
 
         cruel: function(world) {
           return "cruel " + world.toUpperCase();
-        },
+        }
       };
 
       var context = {

spec/index.html

@@ -0,0 +1,59 @@
+<html>
+  <head>
+    <title>Mocha</title>
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+
+    <link rel="stylesheet" href="/node_modules/mocha/mocha.css" />
+    <style>
+      .headless .suite > h1,
+      .headless .test.pass {
+        display: none;
+      }
+    </style>
+
+    <script>
+      // Show only errors in "headless", non-interactive mode.
+      if (/headless=true/.test(location.href)) {
+        document.documentElement.className = 'headless';
+      }
+    </script>
+    <script src="/node_modules/mocha/mocha.js"></script>
+    <script>
+      mocha.setup('bdd');
+    </script>
+    <script src="/dist/handlebars.js"></script>
+
+    <script src="/spec/env/common.js"></script>
+    <script>
+      var CompilerContext = {
+        compile: function(template, options) {
+          var templateSpec = handlebarsEnv.precompile(template, options);
+          return handlebarsEnv.template(safeEval(templateSpec));
+        },
+        compileWithPartial: function(template, options) {
+          return handlebarsEnv.compile(template, options);
+        }
+      };
+
+      function safeEval(templateSpec) {
+        var ret;
+        eval('ret = ' + templateSpec);
+        return ret;
+      }
+    </script>
+    <script src="/tmp/tests.js"></script>
+    <script>
+      onload = function(){
+        // The test harness leaks under FF. We should have decent global leak coverage from other tests
+        if (!navigator.userAgent.match(/Firefox\/([\d.]+)/)) {
+          mocha.checkLeaks();
+        }
+        mocha.run();
+      };
+    </script>
+  </head>
+  <body>
+    <div id="mocha"></div>
+  </body>
+</html>

spec/javascript-compiler.js

@@ -0,0 +1,69 @@
+/*global Handlebars, beforeEach, handlebarsEnv, shouldCompileTo */
+describe('javascript-compiler api', function() {
+  if (!Handlebars.JavaScriptCompiler) {
+    return;
+  }
+
+  describe('#nameLookup', function() {
+    var $superName;
+    beforeEach(function() {
+      $superName = handlebarsEnv.JavaScriptCompiler.prototype.nameLookup;
+    });
+    afterEach(function() {
+      handlebarsEnv.JavaScriptCompiler.prototype.nameLookup = $superName;
+    });
+
+    it('should allow override', function() {
+      handlebarsEnv.JavaScriptCompiler.prototype.nameLookup = function(parent, name) {
+        return parent + '.bar_' + name;
+      };
+      shouldCompileTo("{{foo}}", { bar_foo: "food" }, "food");
+    });
+  });
+  describe('#compilerInfo', function() {
+    var $superCheck, $superInfo;
+    beforeEach(function() {
+      $superCheck = handlebarsEnv.VM.checkRevision;
+      $superInfo = handlebarsEnv.JavaScriptCompiler.prototype.compilerInfo;
+    });
+    afterEach(function() {
+      handlebarsEnv.VM.checkRevision = $superCheck;
+      handlebarsEnv.JavaScriptCompiler.prototype.compilerInfo = $superInfo;
+    });
+    it('should allow compilerInfo override', function() {
+      handlebarsEnv.JavaScriptCompiler.prototype.compilerInfo = function() {
+        return 'this.compilerInfo = "crazy";';
+      };
+      handlebarsEnv.VM.checkRevision = function(compilerInfo) {
+        if (compilerInfo !== 'crazy') {
+          throw new Error('It didn\'t work');
+        }
+      };
+      shouldCompileTo("{{foo}} ", { foo: "food" }, "food ");
+    });
+  });
+  describe('buffer', function() {
+    var $superAppend, $superCreate;
+    beforeEach(function() {
+      $superAppend = handlebarsEnv.JavaScriptCompiler.prototype.appendToBuffer;
+      $superCreate = handlebarsEnv.JavaScriptCompiler.prototype.initializeBuffer;
+    });
+    afterEach(function() {
+      handlebarsEnv.JavaScriptCompiler.prototype.appendToBuffer = $superAppend;
+      handlebarsEnv.JavaScriptCompiler.prototype.initializeBuffer = $superCreate;
+    });
+
+    it('should allow init buffer override', function() {
+      handlebarsEnv.JavaScriptCompiler.prototype.initializeBuffer = function() {
+        return this.quotedString('foo_');
+      };
+      shouldCompileTo("{{foo}} ", { foo: "food" }, "foo_food ");
+    });
+    it('should allow append buffer override', function() {
+      handlebarsEnv.JavaScriptCompiler.prototype.appendToBuffer = function(string) {
+        return $superAppend.call(this, string + ' + "_foo"');
+      };
+      shouldCompileTo("{{foo}}", { foo: "food" }, "food_foo");
+    });
+  });
+});

spec/parser.js

@@ -1,3 +1,4 @@
+/*global Handlebars */
 describe('parser', function() {
   if (!Handlebars.print) {
     return;
@@ -9,165 +10,165 @@ describe('parser', function() {
   }
 
   it('parses simple mustaches', function() {
-    ast_for('{{foo}}').should.equal("{{ ID:foo [] }}\n");
-    ast_for('{{foo?}}').should.equal("{{ ID:foo? [] }}\n");
-    ast_for('{{foo_}}').should.equal("{{ ID:foo_ [] }}\n");
-    ast_for('{{foo-}}').should.equal("{{ ID:foo- [] }}\n");
-    ast_for('{{foo:}}').should.equal("{{ ID:foo: [] }}\n");
+    equals(ast_for('{{foo}}'), "{{ ID:foo [] }}\n");
+    equals(ast_for('{{foo?}}'), "{{ ID:foo? [] }}\n");
+    equals(ast_for('{{foo_}}'), "{{ ID:foo_ [] }}\n");
+    equals(ast_for('{{foo-}}'), "{{ ID:foo- [] }}\n");
+    equals(ast_for('{{foo:}}'), "{{ ID:foo: [] }}\n");
   });
 
   it('parses simple mustaches with data', function() {
-    ast_for("{{@foo}}").should.equal("{{ @ID:foo [] }}\n");
+    equals(ast_for("{{@foo}}"), "{{ @ID:foo [] }}\n");
   });
 
   it('parses mustaches with paths', function() {
-    ast_for("{{foo/bar}}").should.equal("{{ PATH:foo/bar [] }}\n");
+    equals(ast_for("{{foo/bar}}"), "{{ PATH:foo/bar [] }}\n");
   });
 
   it('parses mustaches with this/foo', function() {
-    ast_for("{{this/foo}}").should.equal("{{ ID:foo [] }}\n");
+    equals(ast_for("{{this/foo}}"), "{{ ID:foo [] }}\n");
   });
 
   it('parses mustaches with - in a path', function() {
-    ast_for("{{foo-bar}}").should.equal("{{ ID:foo-bar [] }}\n");
+    equals(ast_for("{{foo-bar}}"), "{{ ID:foo-bar [] }}\n");
   });
 
   it('parses mustaches with parameters', function() {
-    ast_for("{{foo bar}}").should.equal("{{ ID:foo [ID:bar] }}\n");
+    equals(ast_for("{{foo bar}}"), "{{ ID:foo [ID:bar] }}\n");
   });
 
   it('parses mustaches with string parameters', function() {
-    ast_for("{{foo bar \"baz\" }}").should.equal('{{ ID:foo [ID:bar, "baz"] }}\n');
+    equals(ast_for("{{foo bar \"baz\" }}"), '{{ ID:foo [ID:bar, "baz"] }}\n');
   });
 
   it('parses mustaches with INTEGER parameters', function() {
-    ast_for("{{foo 1}}").should.equal("{{ ID:foo [INTEGER{1}] }}\n");
+    equals(ast_for("{{foo 1}}"), "{{ ID:foo [INTEGER{1}] }}\n");
   });
 
   it('parses mustaches with BOOLEAN parameters', function() {
-    ast_for("{{foo true}}").should.equal("{{ ID:foo [BOOLEAN{true}] }}\n");
-    ast_for("{{foo false}}").should.equal("{{ ID:foo [BOOLEAN{false}] }}\n");
+    equals(ast_for("{{foo true}}"), "{{ ID:foo [BOOLEAN{true}] }}\n");
+    equals(ast_for("{{foo false}}"), "{{ ID:foo [BOOLEAN{false}] }}\n");
   });
 
   it('parses mutaches with DATA parameters', function() {
-    ast_for("{{foo @bar}}").should.equal("{{ ID:foo [@ID:bar] }}\n");
+    equals(ast_for("{{foo @bar}}"), "{{ ID:foo [@ID:bar] }}\n");
   });
 
   it('parses mustaches with hash arguments', function() {
-    ast_for("{{foo bar=baz}}").should.equal("{{ ID:foo [] HASH{bar=ID:baz} }}\n");
-    ast_for("{{foo bar=1}}").should.equal("{{ ID:foo [] HASH{bar=INTEGER{1}} }}\n");
-    ast_for("{{foo bar=true}}").should.equal("{{ ID:foo [] HASH{bar=BOOLEAN{true}} }}\n");
-    ast_for("{{foo bar=false}}").should.equal("{{ ID:foo [] HASH{bar=BOOLEAN{false}} }}\n");
-    ast_for("{{foo bar=@baz}}").should.equal("{{ ID:foo [] HASH{bar=@ID:baz} }}\n");
+    equals(ast_for("{{foo bar=baz}}"), "{{ ID:foo [] HASH{bar=ID:baz} }}\n");
+    equals(ast_for("{{foo bar=1}}"), "{{ ID:foo [] HASH{bar=INTEGER{1}} }}\n");
+    equals(ast_for("{{foo bar=true}}"), "{{ ID:foo [] HASH{bar=BOOLEAN{true}} }}\n");
+    equals(ast_for("{{foo bar=false}}"), "{{ ID:foo [] HASH{bar=BOOLEAN{false}} }}\n");
+    equals(ast_for("{{foo bar=@baz}}"), "{{ ID:foo [] HASH{bar=@ID:baz} }}\n");
 
-    ast_for("{{foo bar=baz bat=bam}}").should.equal("{{ ID:foo [] HASH{bar=ID:baz, bat=ID:bam} }}\n");
-    ast_for("{{foo bar=baz bat=\"bam\"}}").should.equal('{{ ID:foo [] HASH{bar=ID:baz, bat="bam"} }}\n');
+    equals(ast_for("{{foo bar=baz bat=bam}}"), "{{ ID:foo [] HASH{bar=ID:baz, bat=ID:bam} }}\n");
+    equals(ast_for("{{foo bar=baz bat=\"bam\"}}"), '{{ ID:foo [] HASH{bar=ID:baz, bat="bam"} }}\n');
 
-    ast_for("{{foo bat='bam'}}").should.equal('{{ ID:foo [] HASH{bat="bam"} }}\n');
+    equals(ast_for("{{foo bat='bam'}}"), '{{ ID:foo [] HASH{bat="bam"} }}\n');
 
-    ast_for("{{foo omg bar=baz bat=\"bam\"}}").should.equal('{{ ID:foo [ID:omg] HASH{bar=ID:baz, bat="bam"} }}\n');
-    ast_for("{{foo omg bar=baz bat=\"bam\" baz=1}}").should.equal('{{ ID:foo [ID:omg] HASH{bar=ID:baz, bat="bam", baz=INTEGER{1}} }}\n');
-    ast_for("{{foo omg bar=baz bat=\"bam\" baz=true}}").should.equal('{{ ID:foo [ID:omg] HASH{bar=ID:baz, bat="bam", baz=BOOLEAN{true}} }}\n');
-    ast_for("{{foo omg bar=baz bat=\"bam\" baz=false}}").should.equal('{{ ID:foo [ID:omg] HASH{bar=ID:baz, bat="bam", baz=BOOLEAN{false}} }}\n');
+    equals(ast_for("{{foo omg bar=baz bat=\"bam\"}}"), '{{ ID:foo [ID:omg] HASH{bar=ID:baz, bat="bam"} }}\n');
+    equals(ast_for("{{foo omg bar=baz bat=\"bam\" baz=1}}"), '{{ ID:foo [ID:omg] HASH{bar=ID:baz, bat="bam", baz=INTEGER{1}} }}\n');
+    equals(ast_for("{{foo omg bar=baz bat=\"bam\" baz=true}}"), '{{ ID:foo [ID:omg] HASH{bar=ID:baz, bat="bam", baz=BOOLEAN{true}} }}\n');
+    equals(ast_for("{{foo omg bar=baz bat=\"bam\" baz=false}}"), '{{ ID:foo [ID:omg] HASH{bar=ID:baz, bat="bam", baz=BOOLEAN{false}} }}\n');
   });
 
   it('parses contents followed by a mustache', function() {
-    ast_for("foo bar {{baz}}").should.equal("CONTENT[ \'foo bar \' ]\n{{ ID:baz [] }}\n");
+    equals(ast_for("foo bar {{baz}}"), "CONTENT[ \'foo bar \' ]\n{{ ID:baz [] }}\n");
   });
 
   it('parses a partial', function() {
-    ast_for("{{> foo }}").should.equal("{{> PARTIAL:foo }}\n");
+    equals(ast_for("{{> foo }}"), "{{> PARTIAL:foo }}\n");
   });
 
   it('parses a partial with context', function() {
-    ast_for("{{> foo bar}}").should.equal("{{> PARTIAL:foo ID:bar }}\n");
+    equals(ast_for("{{> foo bar}}"), "{{> PARTIAL:foo ID:bar }}\n");
   });
 
   it('parses a partial with a complex name', function() {
-    ast_for("{{> shared/partial?.bar}}").should.equal("{{> PARTIAL:shared/partial?.bar }}\n");
+    equals(ast_for("{{> shared/partial?.bar}}"), "{{> PARTIAL:shared/partial?.bar }}\n");
   });
 
   it('parses a comment', function() {
-    ast_for("{{! this is a comment }}").should.equal("{{! ' this is a comment ' }}\n");
+    equals(ast_for("{{! this is a comment }}"), "{{! ' this is a comment ' }}\n");
   });
 
   it('parses a multi-line comment', function() {
-    ast_for("{{!\nthis is a multi-line comment\n}}").should.equal("{{! \'\nthis is a multi-line comment\n\' }}\n");
+    equals(ast_for("{{!\nthis is a multi-line comment\n}}"), "{{! \'\nthis is a multi-line comment\n\' }}\n");
   });
 
   it('parses an inverse section', function() {
-    ast_for("{{#foo}} bar {{^}} baz {{/foo}}").should.equal("BLOCK:\n  {{ ID:foo [] }}\n  PROGRAM:\n    CONTENT[ ' bar ' ]\n  {{^}}\n    CONTENT[ ' baz ' ]\n");
+    equals(ast_for("{{#foo}} bar {{^}} baz {{/foo}}"), "BLOCK:\n  {{ ID:foo [] }}\n  PROGRAM:\n    CONTENT[ ' bar ' ]\n  {{^}}\n    CONTENT[ ' baz ' ]\n");
   });
 
   it('parses an inverse (else-style) section', function() {
-    ast_for("{{#foo}} bar {{else}} baz {{/foo}}").should.equal("BLOCK:\n  {{ ID:foo [] }}\n  PROGRAM:\n    CONTENT[ ' bar ' ]\n  {{^}}\n    CONTENT[ ' baz ' ]\n");
+    equals(ast_for("{{#foo}} bar {{else}} baz {{/foo}}"), "BLOCK:\n  {{ ID:foo [] }}\n  PROGRAM:\n    CONTENT[ ' bar ' ]\n  {{^}}\n    CONTENT[ ' baz ' ]\n");
   });
 
   it('parses empty blocks', function() {
-    ast_for("{{#foo}}{{/foo}}").should.equal("BLOCK:\n  {{ ID:foo [] }}\n  PROGRAM:\n");
+    equals(ast_for("{{#foo}}{{/foo}}"), "BLOCK:\n  {{ ID:foo [] }}\n  PROGRAM:\n");
   });
 
   it('parses empty blocks with empty inverse section', function() {
-    ast_for("{{#foo}}{{^}}{{/foo}}").should.equal("BLOCK:\n  {{ ID:foo [] }}\n  PROGRAM:\n");
+    equals(ast_for("{{#foo}}{{^}}{{/foo}}"), "BLOCK:\n  {{ ID:foo [] }}\n  PROGRAM:\n");
   });
 
   it('parses empty blocks with empty inverse (else-style) section', function() {
-    ast_for("{{#foo}}{{else}}{{/foo}}").should.equal("BLOCK:\n  {{ ID:foo [] }}\n  PROGRAM:\n");
+    equals(ast_for("{{#foo}}{{else}}{{/foo}}"), "BLOCK:\n  {{ ID:foo [] }}\n  PROGRAM:\n");
   });
 
   it('parses non-empty blocks with empty inverse section', function() {
-    ast_for("{{#foo}} bar {{^}}{{/foo}}").should.equal("BLOCK:\n  {{ ID:foo [] }}\n  PROGRAM:\n    CONTENT[ ' bar ' ]\n  {{^}}\n");
+    equals(ast_for("{{#foo}} bar {{^}}{{/foo}}"), "BLOCK:\n  {{ ID:foo [] }}\n  PROGRAM:\n    CONTENT[ ' bar ' ]\n  {{^}}\n");
   });
 
   it('parses non-empty blocks with empty inverse (else-style) section', function() {
-    ast_for("{{#foo}} bar {{else}}{{/foo}}").should.equal("BLOCK:\n  {{ ID:foo [] }}\n  PROGRAM:\n    CONTENT[ ' bar ' ]\n  {{^}}\n");
+    equals(ast_for("{{#foo}} bar {{else}}{{/foo}}"), "BLOCK:\n  {{ ID:foo [] }}\n  PROGRAM:\n    CONTENT[ ' bar ' ]\n  {{^}}\n");
   });
 
   it('parses empty blocks with non-empty inverse section', function() {
-    ast_for("{{#foo}}{{^}} bar {{/foo}}").should.equal("BLOCK:\n  {{ ID:foo [] }}\n  PROGRAM:\n  {{^}}\n    CONTENT[ ' bar ' ]\n");
+    equals(ast_for("{{#foo}}{{^}} bar {{/foo}}"), "BLOCK:\n  {{ ID:foo [] }}\n  PROGRAM:\n  {{^}}\n    CONTENT[ ' bar ' ]\n");
   });
 
   it('parses empty blocks with non-empty inverse (else-style) section', function() {
-    ast_for("{{#foo}}{{else}} bar {{/foo}}").should.equal("BLOCK:\n  {{ ID:foo [] }}\n  PROGRAM:\n  {{^}}\n    CONTENT[ ' bar ' ]\n");
+    equals(ast_for("{{#foo}}{{else}} bar {{/foo}}"), "BLOCK:\n  {{ ID:foo [] }}\n  PROGRAM:\n  {{^}}\n    CONTENT[ ' bar ' ]\n");
   });
 
   it('parses a standalone inverse section', function() {
-    ast_for("{{^foo}}bar{{/foo}}").should.equal("BLOCK:\n  {{ ID:foo [] }}\n  {{^}}\n    CONTENT[ 'bar' ]\n");
+    equals(ast_for("{{^foo}}bar{{/foo}}"), "BLOCK:\n  {{ ID:foo [] }}\n  {{^}}\n    CONTENT[ 'bar' ]\n");
   });
 
   it("raises if there's a Parse error", function() {
-    (function() {
+    shouldThrow(function() {
       ast_for("foo{{^}}bar");
-    }).should.throw(/Parse error on line 1/);
-    (function() {
+    }, Error, /Parse error on line 1/);
+    shouldThrow(function() {
       ast_for("{{foo}");
-    }).should.throw(/Parse error on line 1/);
-    (function() {
+    }, Error, /Parse error on line 1/);
+    shouldThrow(function() {
       ast_for("{{foo &}}");
-    }).should.throw(/Parse error on line 1/);
-    (function() {
+    }, Error, /Parse error on line 1/);
+    shouldThrow(function() {
       ast_for("{{#goodbyes}}{{/hellos}}");
-    }).should.throw(/goodbyes doesn't match hellos/);
+    }, Error, /goodbyes doesn't match hellos/);
   });
 
   it('knows how to report the correct line number in errors', function() {
-    (function() {
+    shouldThrow(function() {
       ast_for("hello\nmy\n{{foo}");
-    }).should.throw(/Parse error on line 3/);
-    (function() {
+    }, Error, /Parse error on line 3/);
+    shouldThrow(function() {
       ast_for("hello\n\nmy\n\n{{foo}");
-    }).should.throw(/Parse error on line 5/);
+    }, Error, /Parse error on line 5/);
   });
 
   it('knows how to report the correct line number in errors when the first character is a newline', function() {
-    (function() {
+    shouldThrow(function() {
       ast_for("\n\nhello\n\nmy\n\n{{foo}");
-    }).should.throw(/Parse error on line 7/);
+    }, Error, /Parse error on line 7/);
   });
 
   describe('externally compiled AST', function() {
     it('can pass through an already-compiled AST', function() {
-      ast_for(new Handlebars.AST.ProgramNode([ new Handlebars.AST.ContentNode("Hello")])).should.equal("CONTENT[ \'Hello\' ]\n");
+      equals(ast_for(new Handlebars.AST.ProgramNode([ new Handlebars.AST.ContentNode("Hello")])), "CONTENT[ \'Hello\' ]\n");
     });
   });
 });

spec/partials.js

@@ -32,17 +32,17 @@ describe('partials', function() {
   });
 
   it("rendering undefined partial throws an exception", function() {
-    (function() {
+    shouldThrow(function() {
         var template = CompilerContext.compile("{{> whatever}}");
         template();
-    }).should.throw(Handlebars.Exception, 'The partial whatever could not be found');
+    }, Handlebars.Exception, 'The partial whatever could not be found');
   });
 
   it("rendering template partial in vm mode throws an exception", function() {
-    (function() {
+    shouldThrow(function() {
       var template = CompilerContext.compile("{{> whatever}}");
       template();
-    }).should.throw(Handlebars.Exception, 'The partial whatever could not be found');
+    }, Handlebars.Exception, 'The partial whatever could not be found');
   });
 
   it("rendering function partial in vm mode", function() {
@@ -123,4 +123,10 @@ describe('partials', function() {
     var hash = {name:"Jeepers", another_dude:"Creepers"};
     shouldCompileToWithPartials(string, [hash, {}, {'+404/asdf?.bar':dude}], true, "Dudes: Jeepers", "Partials can use literal paths");
   });
+
+  it('should handle empty partial', function() {
+    var string = "Dudes: {{#dudes}}{{> dude}}{{/dudes}}";
+    var partial = "";
+    var hash = {dudes: [{name: "Yehuda", url: "http://yehuda"}, {name: "Alan", url: "http://alan"}]};
+    shouldCompileToWithPartials(string, [hash, {}, {dude: partial}], true, "Dudes: ");  });
 });

spec/regressions.js

@@ -1,4 +1,4 @@
-/*global CompilerContext, shouldCompileTo */
+/*global CompilerContext, Handlebars, shouldCompileTo, shouldThrow */
 describe('Regressions', function() {
   it("GH-94: Cannot read property of undefined", function() {
     var data = {"books":[{"title":"The origin of species","author":{"name":"Charles Darwin"}},{"title":"Lazarillo de Tormes"}]};
@@ -85,12 +85,19 @@ describe('Regressions', function() {
   });
 
   it('GH-437: Matching escaping', function() {
-    (function() {
+    shouldThrow(function() {
       CompilerContext.compile('{{{a}}');
-    }).should.throw(Error);
-    (function() {
+    }, Error);
+    shouldThrow(function() {
       CompilerContext.compile('{{a}}}');
-    }).should.throw(Error);
+    }, Error);
+  });
+
+  it("GH-676: Using array in escaping mustache fails", function() {
+    var string = "{{arr}}";
+    var data = { "arr": [1,2] };
+
+    shouldCompileTo(string, data, data.arr.toString(), "it works as expected");
   });
 
   it("Mustache man page", function() {
@@ -106,14 +113,18 @@ describe('Regressions', function() {
   });
 
   it("Passing falsy values to Handlebars.compile throws an error", function() {
-    (function() {
+    shouldThrow(function() {
       CompilerContext.compile(null);
-    }).should.throw("You must pass a string or Handlebars AST to Handlebars.precompile. You passed null");
+    }, Error, 'You must pass a string or Handlebars AST to Handlebars.precompile. You passed null');
   });
 
   if (Handlebars.AST) {
     it("can pass through an already-compiled AST via compile/precompile", function() {
       equal(Handlebars.compile(new Handlebars.AST.ProgramNode([ new Handlebars.AST.ContentNode("Hello")]))(), 'Hello');
     });
+
+    it("can pass through an empty string", function() {
+      equal(Handlebars.compile('')(), '');
+    });
   }
 });

spec/require.js

@@ -2,22 +2,22 @@ if (typeof(require) !== 'undefined' && require.extensions[".handlebars"]) {
   describe('Require', function() {
     it('Load .handlebars files with require()', function() {
       var template = require("./artifacts/example_1");
-      template.should.eql(require("./artifacts/example_1.handlebars"));
+      equal(template, require("./artifacts/example_1.handlebars"));
 
       var expected = 'foo\n';
       var result = template({foo: "foo"});
 
-      result.should.equal(expected);
+      equal(result, expected);
     });
 
     it('Load .hbs files with require()', function() {
       var template = require("./artifacts/example_2");
-      template.should.eql(require("./artifacts/example_2.hbs"));
+      equal(template, require("./artifacts/example_2.hbs"));
 
       var expected = 'Hello, World!\n';
       var result = template({name: "World"});
 
-      result.should.equal(expected);
+      equal(result, expected);
     });
   });
 }

spec/string-params.js

@@ -142,4 +142,20 @@ describe('string params mode', function() {
 
     equals(result, "STOP ME FROM READING HACKER NEWS I need-a dad.joke wot", "Proper context variable output");
   });
+
+  it("with nested block ambiguous", function() {
+    var template = CompilerContext.compile('{{#with content}}{{#view}}{{firstName}} {{lastName}}{{/view}}{{/with}}', {stringParams: true});
+
+    var helpers  = {
+      with: function(options) {
+        return "WITH";
+      },
+      view: function() {
+        return "VIEW";
+      }
+    };
+
+    var result = template({}, {helpers: helpers});
+    equals(result, "WITH");
+  });
 });

spec/subexpressions.js

@@ -0,0 +1,166 @@
+/*global CompilerContext, shouldCompileTo */
+describe('subexpressions', function() {
+  it("arg-less helper", function() {
+    var string   = "{{foo (bar)}}!";
+    var context  = {};
+    var helpers  = {
+      foo: function(val) {
+        return val+val;
+      },
+      bar: function() {
+        return "LOL";
+      }
+    };
+    shouldCompileTo(string, [context, helpers], "LOLLOL!");
+  });
+
+  it("helper w args", function() {
+    var string   = '{{blog (equal a b)}}';
+
+    var context  = { bar: "LOL" };
+    var helpers  = {
+      blog: function(val) {
+        return "val is " + val;
+      },
+      equal: function(x, y) {
+        return x === y;
+      }
+    };
+    shouldCompileTo(string, [context, helpers], "val is true");
+  });
+
+  it("supports much nesting", function() {
+    var string   = '{{blog (equal (equal true true) true)}}';
+
+    var context  = { bar: "LOL" };
+    var helpers  = {
+      blog: function(val) {
+        return "val is " + val;
+      },
+      equal: function(x, y) {
+        return x === y;
+      }
+    };
+    shouldCompileTo(string, [context, helpers], "val is true");
+  });
+
+  it("provides each nested helper invocation its own options hash", function() {
+    var string = '{{equal (equal true true) true}}';
+
+    var lastOptions = null;
+    var helpers  = {
+      equal: function(x, y, options) {
+        if (!options || options === lastOptions) {
+          throw new Error("options hash was reused");
+        }
+        lastOptions = options;
+        return x === y;
+      }
+    };
+    shouldCompileTo(string, [{}, helpers], "true");
+  });
+
+  it("with hashes", function() {
+    var string   = '{{blog (equal (equal true true) true fun="yes")}}';
+
+    var context  = { bar: "LOL" };
+    var helpers  = {
+      blog: function(val) {
+        return "val is " + val;
+      },
+      equal: function(x, y) {
+        return x === y;
+      }
+    };
+    shouldCompileTo(string, [context, helpers], "val is true");
+  });
+
+  it("as hashes", function() {
+    var string   = '{{blog fun=(equal (blog fun=1) "val is 1")}}';
+
+    var helpers  = {
+      blog: function(options) {
+        return "val is " + options.hash.fun;
+      },
+      equal: function(x, y) {
+        return x === y;
+      }
+    };
+    shouldCompileTo(string, [{}, helpers], "val is true");
+  });
+
+  it("in string params mode,", function() {
+    var template = CompilerContext.compile('{{snog (blorg foo x=y) yeah a=b}}', {stringParams: true});
+
+    var helpers = {
+      snog: function(a, b, options) {
+        equals(a, 'foo');
+        equals(options.types.length, 2, "string params for outer helper processed correctly");
+        equals(options.types[0], 'sexpr', "string params for outer helper processed correctly");
+        equals(options.types[1], 'ID', "string params for outer helper processed correctly");
+        return a + b;
+      },
+
+      blorg: function(a, options) {
+        equals(options.types.length, 1, "string params for inner helper processed correctly");
+        equals(options.types[0], 'ID', "string params for inner helper processed correctly");
+        return a;
+      }
+    };
+
+    var result = template({
+      foo: {},
+      yeah: {}
+    }, {helpers: helpers});
+
+    equals(result, "fooyeah");
+  });
+
+  it("as hashes in string params mode", function() {
+
+    var template = CompilerContext.compile('{{blog fun=(bork)}}', {stringParams: true});
+
+    var helpers  = {
+      blog: function(options) {
+        equals(options.hashTypes.fun, 'sexpr');
+        return "val is " + options.hash.fun;
+      },
+      bork: function() {
+        return "BORK";
+      }
+    };
+
+    var result = template({}, {helpers: helpers});
+    equals(result, "val is BORK");
+  });
+
+  it("subexpression functions on the context", function() {
+    var string   = "{{foo (bar)}}!";
+    var context  = {
+      bar: function() {
+        return "LOL";
+      }
+    };
+    var helpers  = {
+      foo: function(val) {
+        return val+val;
+      }
+    };
+    shouldCompileTo(string, [context, helpers], "LOLLOL!");
+  });
+
+  it("subexpressions can't just be property lookups", function() {
+    var string   = "{{foo (bar)}}!";
+    var context  = {
+      bar: "LOL"
+    };
+    var helpers  = {
+      foo: function(val) {
+        return val+val;
+      }
+    };
+    shouldThrow(function() {
+      shouldCompileTo(string, [context, helpers], "LOLLOL!");
+    });
+  });
+});

spec/tokenizer.js

@@ -1,13 +1,12 @@
-var should = require('should');
-
-should.Assertion.prototype.match_tokens = function(tokens) {
-  this.obj.forEach(function(value, index) {
-    value.name.should.equal(tokens[index]);
-  });
-};
-should.Assertion.prototype.be_token = function(name, text) {
-  this.obj.should.eql({name: name, text: text});
-};
+function shouldMatchTokens(result, tokens) {
+  for (var index = 0; index < result.length; index++) {
+    equals(result[index].name, tokens[index]);
+  }
+}
+function shouldBeToken(result, name, text) {
+  equals(result.name, name);
+  equals(result.text, text);
+}
 
 describe('Tokenizer', function() {
   if (!Handlebars.Parser) {
@@ -35,324 +34,361 @@ describe('Tokenizer', function() {
 
   it('tokenizes a simple mustache as "OPEN ID CLOSE"', function() {
     var result = tokenize("{{foo}}");
-    result.should.match_tokens(['OPEN', 'ID', 'CLOSE']);
-    result[1].should.be_token("ID", "foo");
+    shouldMatchTokens(result, ['OPEN', 'ID', 'CLOSE']);
+    shouldBeToken(result[1], "ID", "foo");
   });
 
   it('supports unescaping with &', function() {
     var result = tokenize("{{&bar}}");
-    result.should.match_tokens(['OPEN', 'ID', 'CLOSE']);
+    shouldMatchTokens(result, ['OPEN', 'ID', 'CLOSE']);
 
-    result[0].should.be_token("OPEN", "{{&");
-    result[1].should.be_token("ID", "bar");
+    shouldBeToken(result[0], "OPEN", "{{&");
+    shouldBeToken(result[1], "ID", "bar");
   });
 
   it('supports unescaping with {{{', function() {
     var result = tokenize("{{{bar}}}");
-    result.should.match_tokens(['OPEN_UNESCAPED', 'ID', 'CLOSE_UNESCAPED']);
+    shouldMatchTokens(result, ['OPEN_UNESCAPED', 'ID', 'CLOSE_UNESCAPED']);
 
-    result[1].should.be_token("ID", "bar");
+    shouldBeToken(result[1], "ID", "bar");
   });
 
   it('supports escaping delimiters', function() {
     var result = tokenize("{{foo}} \\{{bar}} {{baz}}");
-    result.should.match_tokens(['OPEN', 'ID', 'CLOSE', 'CONTENT', 'CONTENT', 'OPEN', 'ID', 'CLOSE']);
+    shouldMatchTokens(result, ['OPEN', 'ID', 'CLOSE', 'CONTENT', 'CONTENT', 'OPEN', 'ID', 'CLOSE']);
 
-    result[3].should.be_token("CONTENT", " ");
-    result[4].should.be_token("CONTENT", "{{bar}} ");
+    shouldBeToken(result[3], "CONTENT", " ");
+    shouldBeToken(result[4], "CONTENT", "{{bar}} ");
   });
 
   it('supports escaping multiple delimiters', function() {
     var result = tokenize("{{foo}} \\{{bar}} \\{{baz}}");
-    result.should.match_tokens(['OPEN', 'ID', 'CLOSE', 'CONTENT', 'CONTENT', 'CONTENT']);
+    shouldMatchTokens(result, ['OPEN', 'ID', 'CLOSE', 'CONTENT', 'CONTENT', 'CONTENT']);
 
-    result[3].should.be_token("CONTENT", " ");
-    result[4].should.be_token("CONTENT", "{{bar}} ");
-    result[5].should.be_token("CONTENT", "{{baz}}");
+    shouldBeToken(result[3], "CONTENT", " ");
+    shouldBeToken(result[4], "CONTENT", "{{bar}} ");
+    shouldBeToken(result[5], "CONTENT", "{{baz}}");
   });
 
   it('supports escaping a triple stash', function() {
     var result = tokenize("{{foo}} \\{{{bar}}} {{baz}}");
-    result.should.match_tokens(['OPEN', 'ID', 'CLOSE', 'CONTENT', 'CONTENT', 'OPEN', 'ID', 'CLOSE']);
+    shouldMatchTokens(result, ['OPEN', 'ID', 'CLOSE', 'CONTENT', 'CONTENT', 'OPEN', 'ID', 'CLOSE']);
 
-    result[4].should.be_token("CONTENT", "{{{bar}}} ");
+    shouldBeToken(result[4], "CONTENT", "{{{bar}}} ");
   });
 
   it('supports escaping escape character', function() {
     var result = tokenize("{{foo}} \\\\{{bar}} {{baz}}");
-    result.should.match_tokens(['OPEN', 'ID', 'CLOSE', 'CONTENT', 'OPEN', 'ID', 'CLOSE', 'CONTENT', 'OPEN', 'ID', 'CLOSE']);
+    shouldMatchTokens(result, ['OPEN', 'ID', 'CLOSE', 'CONTENT', 'OPEN', 'ID', 'CLOSE', 'CONTENT', 'OPEN', 'ID', 'CLOSE']);
 
-    result[3].should.be_token("CONTENT", " \\");
-    result[5].should.be_token("ID", "bar");
+    shouldBeToken(result[3], "CONTENT", " \\");
+    shouldBeToken(result[5], "ID", "bar");
   });
 
   it('supports escaping multiple escape characters', function() {
     var result = tokenize("{{foo}} \\\\{{bar}} \\\\{{baz}}");
-      result.should.match_tokens(['OPEN', 'ID', 'CLOSE', 'CONTENT', 'OPEN', 'ID', 'CLOSE', 'CONTENT', 'OPEN', 'ID', 'CLOSE']);
+    shouldMatchTokens(result, ['OPEN', 'ID', 'CLOSE', 'CONTENT', 'OPEN', 'ID', 'CLOSE', 'CONTENT', 'OPEN', 'ID', 'CLOSE']);
 
-      result[3].should.be_token("CONTENT", " \\");
-      result[5].should.be_token("ID", "bar");
-      result[7].should.be_token("CONTENT", " \\");
-      result[9].should.be_token("ID", "baz");
+    shouldBeToken(result[3], "CONTENT", " \\");
+    shouldBeToken(result[5], "ID", "bar");
+    shouldBeToken(result[7], "CONTENT", " \\");
+    shouldBeToken(result[9], "ID", "baz");
   });
 
-  it('supports mixed escaped delimiters and escaped escape characters', function() {
+  it('supports escaped mustaches after escaped escape characters', function() {
     var result = tokenize("{{foo}} \\\\{{bar}} \\{{baz}}");
-    result.should.match_tokens(['OPEN', 'ID', 'CLOSE', 'CONTENT', 'OPEN', 'ID', 'CLOSE', 'CONTENT', 'CONTENT', 'CONTENT']);
+    shouldMatchTokens(result, ['OPEN', 'ID', 'CLOSE', 'CONTENT', 'OPEN', 'ID', 'CLOSE', 'CONTENT', 'CONTENT', 'CONTENT']);
 
-    result[3].should.be_token("CONTENT", " \\");
-    result[4].should.be_token("OPEN", "{{");
-    result[5].should.be_token("ID", "bar");
-    result[7].should.be_token("CONTENT", " ");
-    result[8].should.be_token("CONTENT", "{{baz}}");
+    shouldBeToken(result[3], "CONTENT", " \\");
+    shouldBeToken(result[4], "OPEN", "{{");
+    shouldBeToken(result[5], "ID", "bar");
+    shouldBeToken(result[7], "CONTENT", " ");
+    shouldBeToken(result[8], "CONTENT", "{{baz}}");
+  });
+
+  it('supports escaped escape characters after escaped mustaches', function() {
+    var result = tokenize("{{foo}} \\{{bar}} \\\\{{baz}}");
+    shouldMatchTokens(result, ['OPEN', 'ID', 'CLOSE', 'CONTENT', 'CONTENT', 'CONTENT', 'OPEN', 'ID', 'CLOSE']);
+
+    shouldBeToken(result[4], "CONTENT", "{{bar}} ");
+    shouldBeToken(result[5], "CONTENT", "\\");
+    shouldBeToken(result[6], "OPEN", "{{");
+    shouldBeToken(result[7], "ID", "baz");
   });
 
   it('supports escaped escape character on a triple stash', function() {
     var result = tokenize("{{foo}} \\\\{{{bar}}} {{baz}}");
-    result.should.match_tokens(['OPEN', 'ID', 'CLOSE', 'CONTENT', 'OPEN_UNESCAPED', 'ID', 'CLOSE_UNESCAPED', 'CONTENT', 'OPEN', 'ID', 'CLOSE']);
+    shouldMatchTokens(result, ['OPEN', 'ID', 'CLOSE', 'CONTENT', 'OPEN_UNESCAPED', 'ID', 'CLOSE_UNESCAPED', 'CONTENT', 'OPEN', 'ID', 'CLOSE']);
 
-    result[3].should.be_token("CONTENT", " \\");
-    result[5].should.be_token("ID", "bar");
+    shouldBeToken(result[3], "CONTENT", " \\");
+    shouldBeToken(result[5], "ID", "bar");
   });
 
   it('tokenizes a simple path', function() {
     var result = tokenize("{{foo/bar}}");
-    result.should.match_tokens(['OPEN', 'ID', 'SEP', 'ID', 'CLOSE']);
+    shouldMatchTokens(result, ['OPEN', 'ID', 'SEP', 'ID', 'CLOSE']);
   });
 
   it('allows dot notation', function() {
     var result = tokenize("{{foo.bar}}");
-    result.should.match_tokens(['OPEN', 'ID', 'SEP', 'ID', 'CLOSE']);
+    shouldMatchTokens(result, ['OPEN', 'ID', 'SEP', 'ID', 'CLOSE']);
 
-    tokenize("{{foo.bar.baz}}").should.match_tokens(['OPEN', 'ID', 'SEP', 'ID', 'SEP', 'ID', 'CLOSE']);
+    shouldMatchTokens(tokenize("{{foo.bar.baz}}"), ['OPEN', 'ID', 'SEP', 'ID', 'SEP', 'ID', 'CLOSE']);
   });
 
   it('allows path literals with []', function() {
     var result = tokenize("{{foo.[bar]}}");
-    result.should.match_tokens(['OPEN', 'ID', 'SEP', 'ID', 'CLOSE']);
+    shouldMatchTokens(result, ['OPEN', 'ID', 'SEP', 'ID', 'CLOSE']);
   });
 
   it('allows multiple path literals on a line with []', function() {
     var result = tokenize("{{foo.[bar]}}{{foo.[baz]}}");
-    result.should.match_tokens(['OPEN', 'ID', 'SEP', 'ID', 'CLOSE', 'OPEN', 'ID', 'SEP', 'ID', 'CLOSE']);
+    shouldMatchTokens(result, ['OPEN', 'ID', 'SEP', 'ID', 'CLOSE', 'OPEN', 'ID', 'SEP', 'ID', 'CLOSE']);
   });
 
   it('tokenizes {{.}} as OPEN ID CLOSE', function() {
     var result = tokenize("{{.}}");
-    result.should.match_tokens(['OPEN', 'ID', 'CLOSE']);
+    shouldMatchTokens(result, ['OPEN', 'ID', 'CLOSE']);
   });
 
   it('tokenizes a path as "OPEN (ID SEP)* ID CLOSE"', function() {
     var result = tokenize("{{../foo/bar}}");
-    result.should.match_tokens(['OPEN', 'ID', 'SEP', 'ID', 'SEP', 'ID', 'CLOSE']);
-    result[1].should.be_token("ID", "..");
+    shouldMatchTokens(result, ['OPEN', 'ID', 'SEP', 'ID', 'SEP', 'ID', 'CLOSE']);
+    shouldBeToken(result[1], "ID", "..");
   });
 
   it('tokenizes a path with .. as a parent path', function() {
     var result = tokenize("{{../foo.bar}}");
-    result.should.match_tokens(['OPEN', 'ID', 'SEP', 'ID', 'SEP', 'ID', 'CLOSE']);
-    result[1].should.be_token("ID", "..");
+    shouldMatchTokens(result, ['OPEN', 'ID', 'SEP', 'ID', 'SEP', 'ID', 'CLOSE']);
+    shouldBeToken(result[1], "ID", "..");
   });
 
   it('tokenizes a path with this/foo as OPEN ID SEP ID CLOSE', function() {
     var result = tokenize("{{this/foo}}");
-    result.should.match_tokens(['OPEN', 'ID', 'SEP', 'ID', 'CLOSE']);
-    result[1].should.be_token("ID", "this");
-    result[3].should.be_token("ID", "foo");
+    shouldMatchTokens(result, ['OPEN', 'ID', 'SEP', 'ID', 'CLOSE']);
+    shouldBeToken(result[1], "ID", "this");
+    shouldBeToken(result[3], "ID", "foo");
   });
 
   it('tokenizes a simple mustache with spaces as "OPEN ID CLOSE"', function() {
     var result = tokenize("{{  foo  }}");
-    result.should.match_tokens(['OPEN', 'ID', 'CLOSE']);
-    result[1].should.be_token("ID", "foo");
+    shouldMatchTokens(result, ['OPEN', 'ID', 'CLOSE']);
+    shouldBeToken(result[1], "ID", "foo");
   });
 
   it('tokenizes a simple mustache with line breaks as "OPEN ID ID CLOSE"', function() {
     var result = tokenize("{{  foo  \n   bar }}");
-    result.should.match_tokens(['OPEN', 'ID', 'ID', 'CLOSE']);
-    result[1].should.be_token("ID", "foo");
+    shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'CLOSE']);
+    shouldBeToken(result[1], "ID", "foo");
   });
 
   it('tokenizes raw content as "CONTENT"', function() {
     var result = tokenize("foo {{ bar }} baz");
-    result.should.match_tokens(['CONTENT', 'OPEN', 'ID', 'CLOSE', 'CONTENT']);
-    result[0].should.be_token("CONTENT", "foo ");
-    result[4].should.be_token("CONTENT", " baz");
+    shouldMatchTokens(result, ['CONTENT', 'OPEN', 'ID', 'CLOSE', 'CONTENT']);
+    shouldBeToken(result[0], "CONTENT", "foo ");
+    shouldBeToken(result[4], "CONTENT", " baz");
   });
 
   it('tokenizes a partial as "OPEN_PARTIAL ID CLOSE"', function() {
     var result = tokenize("{{> foo}}");
-    result.should.match_tokens(['OPEN_PARTIAL', 'ID', 'CLOSE']);
+    shouldMatchTokens(result, ['OPEN_PARTIAL', 'ID', 'CLOSE']);
   });
 
   it('tokenizes a partial with context as "OPEN_PARTIAL ID ID CLOSE"', function() {
     var result = tokenize("{{> foo bar }}");
-    result.should.match_tokens(['OPEN_PARTIAL', 'ID', 'ID', 'CLOSE']);
+    shouldMatchTokens(result, ['OPEN_PARTIAL', 'ID', 'ID', 'CLOSE']);
   });
 
   it('tokenizes a partial without spaces as "OPEN_PARTIAL ID CLOSE"', function() {
     var result = tokenize("{{>foo}}");
-    result.should.match_tokens(['OPEN_PARTIAL', 'ID', 'CLOSE']);
+    shouldMatchTokens(result, ['OPEN_PARTIAL', 'ID', 'CLOSE']);
   });
 
   it('tokenizes a partial space at the }); as "OPEN_PARTIAL ID CLOSE"', function() {
     var result = tokenize("{{>foo  }}");
-    result.should.match_tokens(['OPEN_PARTIAL', 'ID', 'CLOSE']);
+    shouldMatchTokens(result, ['OPEN_PARTIAL', 'ID', 'CLOSE']);
   });
 
   it('tokenizes a partial space at the }); as "OPEN_PARTIAL ID CLOSE"', function() {
     var result = tokenize("{{>foo/bar.baz  }}");
-    result.should.match_tokens(['OPEN_PARTIAL', 'ID', 'SEP', 'ID', 'SEP', 'ID', 'CLOSE']);
+    shouldMatchTokens(result, ['OPEN_PARTIAL', 'ID', 'SEP', 'ID', 'SEP', 'ID', 'CLOSE']);
   });
 
   it('tokenizes a comment as "COMMENT"', function() {
     var result = tokenize("foo {{! this is a comment }} bar {{ baz }}");
-    result.should.match_tokens(['CONTENT', 'COMMENT', 'CONTENT', 'OPEN', 'ID', 'CLOSE']);
-    result[1].should.be_token("COMMENT", " this is a comment ");
+    shouldMatchTokens(result, ['CONTENT', 'COMMENT', 'CONTENT', 'OPEN', 'ID', 'CLOSE']);
+    shouldBeToken(result[1], "COMMENT", " this is a comment ");
   });
 
   it('tokenizes a block comment as "COMMENT"', function() {
     var result = tokenize("foo {{!-- this is a {{comment}} --}} bar {{ baz }}");
-    result.should.match_tokens(['CONTENT', 'COMMENT', 'CONTENT', 'OPEN', 'ID', 'CLOSE']);
-    result[1].should.be_token("COMMENT", " this is a {{comment}} ");
+    shouldMatchTokens(result, ['CONTENT', 'COMMENT', 'CONTENT', 'OPEN', 'ID', 'CLOSE']);
+    shouldBeToken(result[1], "COMMENT", " this is a {{comment}} ");
   });
 
   it('tokenizes a block comment with whitespace as "COMMENT"', function() {
     var result = tokenize("foo {{!-- this is a\n{{comment}}\n--}} bar {{ baz }}");
-    result.should.match_tokens(['CONTENT', 'COMMENT', 'CONTENT', 'OPEN', 'ID', 'CLOSE']);
-    result[1].should.be_token("COMMENT", " this is a\n{{comment}}\n");
+    shouldMatchTokens(result, ['CONTENT', 'COMMENT', 'CONTENT', 'OPEN', 'ID', 'CLOSE']);
+    shouldBeToken(result[1], "COMMENT", " this is a\n{{comment}}\n");
   });
 
   it('tokenizes open and closing blocks as OPEN_BLOCK, ID, CLOSE ..., OPEN_ENDBLOCK ID CLOSE', function() {
     var result = tokenize("{{#foo}}content{{/foo}}");
-    result.should.match_tokens(['OPEN_BLOCK', 'ID', 'CLOSE', 'CONTENT', 'OPEN_ENDBLOCK', 'ID', 'CLOSE']);
+    shouldMatchTokens(result, ['OPEN_BLOCK', 'ID', 'CLOSE', 'CONTENT', 'OPEN_ENDBLOCK', 'ID', 'CLOSE']);
   });
 
   it('tokenizes inverse sections as "OPEN_INVERSE CLOSE"', function() {
-    tokenize("{{^}}").should.match_tokens(['OPEN_INVERSE', 'CLOSE']);
-    tokenize("{{else}}").should.match_tokens(['OPEN_INVERSE', 'CLOSE']);
-    tokenize("{{ else }}").should.match_tokens(['OPEN_INVERSE', 'CLOSE']);
+    shouldMatchTokens(tokenize("{{^}}"), ['OPEN_INVERSE', 'CLOSE']);
+    shouldMatchTokens(tokenize("{{else}}"), ['OPEN_INVERSE', 'CLOSE']);
+    shouldMatchTokens(tokenize("{{ else }}"), ['OPEN_INVERSE', 'CLOSE']);
   });
 
   it('tokenizes inverse sections with ID as "OPEN_INVERSE ID CLOSE"', function() {
     var result = tokenize("{{^foo}}");
-    result.should.match_tokens(['OPEN_INVERSE', 'ID', 'CLOSE']);
-    result[1].should.be_token("ID", "foo");
+    shouldMatchTokens(result, ['OPEN_INVERSE', 'ID', 'CLOSE']);
+    shouldBeToken(result[1], "ID", "foo");
   });
 
   it('tokenizes inverse sections with ID and spaces as "OPEN_INVERSE ID CLOSE"', function() {
     var result = tokenize("{{^ foo  }}");
-    result.should.match_tokens(['OPEN_INVERSE', 'ID', 'CLOSE']);
-    result[1].should.be_token("ID", "foo");
+    shouldMatchTokens(result, ['OPEN_INVERSE', 'ID', 'CLOSE']);
+    shouldBeToken(result[1], "ID", "foo");
   });
 
   it('tokenizes mustaches with params as "OPEN ID ID ID CLOSE"', function() {
     var result = tokenize("{{ foo bar baz }}");
-    result.should.match_tokens(['OPEN', 'ID', 'ID', 'ID', 'CLOSE']);
-    result[1].should.be_token("ID", "foo");
-    result[2].should.be_token("ID", "bar");
-    result[3].should.be_token("ID", "baz");
+    shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'ID', 'CLOSE']);
+    shouldBeToken(result[1], "ID", "foo");
+    shouldBeToken(result[2], "ID", "bar");
+    shouldBeToken(result[3], "ID", "baz");
   });
 
   it('tokenizes mustaches with String params as "OPEN ID ID STRING CLOSE"', function() {
     var result = tokenize("{{ foo bar \"baz\" }}");
-    result.should.match_tokens(['OPEN', 'ID', 'ID', 'STRING', 'CLOSE']);
-    result[3].should.be_token("STRING", "baz");
+    shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'STRING', 'CLOSE']);
+    shouldBeToken(result[3], "STRING", "baz");
   });
 
   it('tokenizes mustaches with String params using single quotes as "OPEN ID ID STRING CLOSE"', function() {
     var result = tokenize("{{ foo bar \'baz\' }}");
-    result.should.match_tokens(['OPEN', 'ID', 'ID', 'STRING', 'CLOSE']);
-    result[3].should.be_token("STRING", "baz");
+    shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'STRING', 'CLOSE']);
+    shouldBeToken(result[3], "STRING", "baz");
   });
 
   it('tokenizes String params with spaces inside as "STRING"', function() {
     var result = tokenize("{{ foo bar \"baz bat\" }}");
-    result.should.match_tokens(['OPEN', 'ID', 'ID', 'STRING', 'CLOSE']);
-    result[3].should.be_token("STRING", "baz bat");
+    shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'STRING', 'CLOSE']);
+    shouldBeToken(result[3], "STRING", "baz bat");
   });
 
   it('tokenizes String params with escapes quotes as STRING', function() {
     var result = tokenize('{{ foo "bar\\"baz" }}');
-    result.should.match_tokens(['OPEN', 'ID', 'STRING', 'CLOSE']);
-    result[2].should.be_token("STRING", 'bar"baz');
+    shouldMatchTokens(result, ['OPEN', 'ID', 'STRING', 'CLOSE']);
+    shouldBeToken(result[2], "STRING", 'bar"baz');
   });
 
   it('tokenizes String params using single quotes with escapes quotes as STRING', function() {
     var result = tokenize("{{ foo 'bar\\'baz' }}");
-    result.should.match_tokens(['OPEN', 'ID', 'STRING', 'CLOSE']);
-    result[2].should.be_token("STRING", "bar'baz");
+    shouldMatchTokens(result, ['OPEN', 'ID', 'STRING', 'CLOSE']);
+    shouldBeToken(result[2], "STRING", "bar'baz");
   });
 
   it('tokenizes numbers', function() {
     var result = tokenize('{{ foo 1 }}');
-    result.should.match_tokens(['OPEN', 'ID', 'INTEGER', 'CLOSE']);
-    result[2].should.be_token("INTEGER", "1");
+    shouldMatchTokens(result, ['OPEN', 'ID', 'INTEGER', 'CLOSE']);
+    shouldBeToken(result[2], "INTEGER", "1");
 
     result = tokenize('{{ foo -1 }}');
-    result.should.match_tokens(['OPEN', 'ID', 'INTEGER', 'CLOSE']);
-    result[2].should.be_token("INTEGER", "-1");
+    shouldMatchTokens(result, ['OPEN', 'ID', 'INTEGER', 'CLOSE']);
+    shouldBeToken(result[2], "INTEGER", "-1");
   });
 
   it('tokenizes booleans', function() {
     var result = tokenize('{{ foo true }}');
-    result.should.match_tokens(['OPEN', 'ID', 'BOOLEAN', 'CLOSE']);
-    result[2].should.be_token("BOOLEAN", "true");
+    shouldMatchTokens(result, ['OPEN', 'ID', 'BOOLEAN', 'CLOSE']);
+    shouldBeToken(result[2], "BOOLEAN", "true");
 
     result = tokenize('{{ foo false }}');
-    result.should.match_tokens(['OPEN', 'ID', 'BOOLEAN', 'CLOSE']);
-    result[2].should.be_token("BOOLEAN", "false");
+    shouldMatchTokens(result, ['OPEN', 'ID', 'BOOLEAN', 'CLOSE']);
+    shouldBeToken(result[2], "BOOLEAN", "false");
   });
 
   it('tokenizes hash arguments', function() {
     var result = tokenize("{{ foo bar=baz }}");
-    result.should.match_tokens(['OPEN', 'ID', 'ID', 'EQUALS', 'ID', 'CLOSE']);
+    shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'EQUALS', 'ID', 'CLOSE']);
 
     result = tokenize("{{ foo bar baz=bat }}");
-    result.should.match_tokens(['OPEN', 'ID', 'ID', 'ID', 'EQUALS', 'ID', 'CLOSE']);
+    shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'ID', 'EQUALS', 'ID', 'CLOSE']);
 
     result = tokenize("{{ foo bar baz=1 }}");
-    result.should.match_tokens(['OPEN', 'ID', 'ID', 'ID', 'EQUALS', 'INTEGER', 'CLOSE']);
+    shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'ID', 'EQUALS', 'INTEGER', 'CLOSE']);
 
     result = tokenize("{{ foo bar baz=true }}");
-    result.should.match_tokens(['OPEN', 'ID', 'ID', 'ID', 'EQUALS', 'BOOLEAN', 'CLOSE']);
+    shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'ID', 'EQUALS', 'BOOLEAN', 'CLOSE']);
 
     result = tokenize("{{ foo bar baz=false }}");
-    result.should.match_tokens(['OPEN', 'ID', 'ID', 'ID', 'EQUALS', 'BOOLEAN', 'CLOSE']);
+    shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'ID', 'EQUALS', 'BOOLEAN', 'CLOSE']);
 
     result = tokenize("{{ foo bar\n  baz=bat }}");
-    result.should.match_tokens(['OPEN', 'ID', 'ID', 'ID', 'EQUALS', 'ID', 'CLOSE']);
+    shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'ID', 'EQUALS', 'ID', 'CLOSE']);
 
     result = tokenize("{{ foo bar baz=\"bat\" }}");
-    result.should.match_tokens(['OPEN', 'ID', 'ID', 'ID', 'EQUALS', 'STRING', 'CLOSE']);
+    shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'ID', 'EQUALS', 'STRING', 'CLOSE']);
 
     result = tokenize("{{ foo bar baz=\"bat\" bam=wot }}");
-    result.should.match_tokens(['OPEN', 'ID', 'ID', 'ID', 'EQUALS', 'STRING', 'ID', 'EQUALS', 'ID', 'CLOSE']);
+    shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'ID', 'EQUALS', 'STRING', 'ID', 'EQUALS', 'ID', 'CLOSE']);
 
     result = tokenize("{{foo omg bar=baz bat=\"bam\"}}");
-    result.should.match_tokens(['OPEN', 'ID', 'ID', 'ID', 'EQUALS', 'ID', 'ID', 'EQUALS', 'STRING', 'CLOSE']);
-    result[2].should.be_token("ID", "omg");
+    shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'ID', 'EQUALS', 'ID', 'ID', 'EQUALS', 'STRING', 'CLOSE']);
+    shouldBeToken(result[2], "ID", "omg");
   });
 
   it('tokenizes special @ identifiers', function() {
     var result = tokenize("{{ @foo }}");
-    result.should.match_tokens(['OPEN', 'DATA', 'ID', 'CLOSE']);
-    result[2].should.be_token("ID", "foo");
+    shouldMatchTokens(result, ['OPEN', 'DATA', 'ID', 'CLOSE']);
+    shouldBeToken(result[2], "ID", "foo");
 
     result = tokenize("{{ foo @bar }}");
-    result.should.match_tokens(['OPEN', 'ID', 'DATA', 'ID', 'CLOSE']);
-    result[3].should.be_token("ID", "bar");
+    shouldMatchTokens(result, ['OPEN', 'ID', 'DATA', 'ID', 'CLOSE']);
+    shouldBeToken(result[3], "ID", "bar");
 
     result = tokenize("{{ foo bar=@baz }}");
-    result.should.match_tokens(['OPEN', 'ID', 'ID', 'EQUALS', 'DATA', 'ID', 'CLOSE']);
-    result[5].should.be_token("ID", "baz");
+    shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'EQUALS', 'DATA', 'ID', 'CLOSE']);
+    shouldBeToken(result[5], "ID", "baz");
   });
 
   it('does not time out in a mustache with a single } followed by EOF', function() {
-    tokenize("{{foo}").should.match_tokens(['OPEN', 'ID']);
+    shouldMatchTokens(tokenize("{{foo}"), ['OPEN', 'ID']);
   });
 
   it('does not time out in a mustache when invalid ID characters are used', function() {
-    tokenize("{{foo & }}").should.match_tokens(['OPEN', 'ID']);
+    shouldMatchTokens(tokenize("{{foo & }}"), ['OPEN', 'ID']);
+  });
+
+  it('tokenizes subexpressions', function() {
+    var result = tokenize("{{foo (bar)}}");
+    shouldMatchTokens(result, ['OPEN', 'ID', 'OPEN_SEXPR', 'ID', 'CLOSE_SEXPR', 'CLOSE']);
+    shouldBeToken(result[1], "ID", "foo");
+    shouldBeToken(result[3], "ID", "bar");
+
+    result = tokenize("{{foo (a-x b-y)}}");
+    shouldMatchTokens(result, ['OPEN', 'ID', 'OPEN_SEXPR', 'ID', 'ID', 'CLOSE_SEXPR', 'CLOSE']);
+    shouldBeToken(result[1], "ID", "foo");
+    shouldBeToken(result[3], "ID", "a-x");
+    shouldBeToken(result[4], "ID", "b-y");
+  });
+
+  it('tokenizes nested subexpressions', function() {
+    var result = tokenize("{{foo (bar (lol rofl)) (baz)}}");
+    shouldMatchTokens(result, ['OPEN', 'ID', 'OPEN_SEXPR', 'ID', 'OPEN_SEXPR', 'ID', 'ID', 'CLOSE_SEXPR', 'CLOSE_SEXPR', 'OPEN_SEXPR', 'ID', 'CLOSE_SEXPR', 'CLOSE']);
+    shouldBeToken(result[3],  "ID", "bar");
+    shouldBeToken(result[5],  "ID", "lol");
+    shouldBeToken(result[6],  "ID", "rofl");
+    shouldBeToken(result[10], "ID", "baz");
+  });
+
+  it('tokenizes nested subexpressions: literals', function() {
+    var result = tokenize("{{foo (bar (lol true) false) (baz 1) (blah 'b') (blorg \"c\")}}");
+    shouldMatchTokens(result, ['OPEN', 'ID', 'OPEN_SEXPR', 'ID', 'OPEN_SEXPR', 'ID', 'BOOLEAN', 'CLOSE_SEXPR', 'BOOLEAN', 'CLOSE_SEXPR', 'OPEN_SEXPR', 'ID', 'INTEGER', 'CLOSE_SEXPR', 'OPEN_SEXPR', 'ID', 'STRING', 'CLOSE_SEXPR', 'OPEN_SEXPR', 'ID', 'STRING', 'CLOSE_SEXPR', 'CLOSE']);
   });
 });

spec/utils.js

@@ -1,11 +1,13 @@
-/*global shouldCompileTo */
+/*global Handlebars, shouldCompileTo */
 
 describe('utils', function() {
   describe('#SafeString', function() {
     it("constructing a safestring from a string and checking its type", function() {
       var safe = new Handlebars.SafeString("testing 1, 2, 3");
-      safe.should.be.instanceof(Handlebars.SafeString);
-      (safe == "testing 1, 2, 3").should.equal(true, "SafeString is equivalent to its underlying string");
+      if (!(safe instanceof Handlebars.SafeString)) {
+        throw new Error('Must be instance of SafeString');
+      }
+      equals(safe == 'testing 1, 2, 3', true, 'SafeString is equivalent to its underlying string');
     });
 
     it("it should not escape SafeString properties", function() {
@@ -17,41 +19,41 @@ describe('utils', function() {
 
   describe('#escapeExpression', function() {
     it('shouhld escape html', function() {
-      Handlebars.Utils.escapeExpression('foo<&"\'>').should.equal('foo&lt;&amp;&quot;&#x27;&gt;');
+      equals(Handlebars.Utils.escapeExpression('foo<&"\'>'), 'foo&lt;&amp;&quot;&#x27;&gt;');
     });
     it('should not escape SafeString', function() {
       var string = new Handlebars.SafeString('foo<&"\'>');
-      Handlebars.Utils.escapeExpression(string).should.equal('foo<&"\'>');
+      equals(Handlebars.Utils.escapeExpression(string), 'foo<&"\'>');
 
     });
     it('should handle falsy', function() {
-      Handlebars.Utils.escapeExpression('').should.equal('');
-      Handlebars.Utils.escapeExpression(undefined).should.equal('');
-      Handlebars.Utils.escapeExpression(null).should.equal('');
-      Handlebars.Utils.escapeExpression(false).should.equal('');
+      equals(Handlebars.Utils.escapeExpression(''), '');
+      equals(Handlebars.Utils.escapeExpression(undefined), '');
+      equals(Handlebars.Utils.escapeExpression(null), '');
+      equals(Handlebars.Utils.escapeExpression(false), '');
 
-      Handlebars.Utils.escapeExpression(0).should.equal('0');
+      equals(Handlebars.Utils.escapeExpression(0), '0');
     });
     it('should handle empty objects', function() {
-      Handlebars.Utils.escapeExpression({}).should.equal({}.toString());
-      Handlebars.Utils.escapeExpression([]).should.equal([].toString());
+      equals(Handlebars.Utils.escapeExpression({}), {}.toString());
+      equals(Handlebars.Utils.escapeExpression([]), [].toString());
     });
   });
 
   describe('#isEmpty', function() {
     it('should not be empty', function() {
-      Handlebars.Utils.isEmpty(undefined).should.equal(true);
-      Handlebars.Utils.isEmpty(null).should.equal(true);
-      Handlebars.Utils.isEmpty(false).should.equal(true);
-      Handlebars.Utils.isEmpty('').should.equal(true);
-      Handlebars.Utils.isEmpty([]).should.equal(true);
+      equals(Handlebars.Utils.isEmpty(undefined), true);
+      equals(Handlebars.Utils.isEmpty(null), true);
+      equals(Handlebars.Utils.isEmpty(false), true);
+      equals(Handlebars.Utils.isEmpty(''), true);
+      equals(Handlebars.Utils.isEmpty([]), true);
     });
 
     it('should be empty', function() {
-      Handlebars.Utils.isEmpty(0).should.equal(false);
-      Handlebars.Utils.isEmpty([1]).should.equal(false);
-      Handlebars.Utils.isEmpty('foo').should.equal(false);
-      Handlebars.Utils.isEmpty({bar: 1}).should.equal(false);
+      equals(Handlebars.Utils.isEmpty(0), false);
+      equals(Handlebars.Utils.isEmpty([1]), false);
+      equals(Handlebars.Utils.isEmpty('foo'), false);
+      equals(Handlebars.Utils.isEmpty({bar: 1}), false);
     });
   });
 });

src/handlebars.l

@@ -12,8 +12,8 @@ function strip(start, end) {
 LEFT_STRIP    "~"
 RIGHT_STRIP   "~"
 
-LOOKAHEAD           [=~}\s\/.]
-LITERAL_LOOKAHEAD   [~}\s]
+LOOKAHEAD           [=~}\s\/.)]
+LITERAL_LOOKAHEAD   [~}\s)]
 
 /*
 ID is the inverse of control characters.
@@ -43,14 +43,17 @@ ID    [^\s!"#%-,\.\/;->@\[-\^`\{-~]+/{LOOKAHEAD}
 
 [^\x00]+                         return 'CONTENT';
 
-<emu>[^\x00]{2,}?/("{{"|<<EOF>>) {
-                                   if(yytext.slice(-1) !== "\\") this.popState();
-                                   if(yytext.slice(-1) === "\\") strip(0,1);
+// marks CONTENT up to the next mustache or escaped mustache
+<emu>[^\x00]{2,}?/("{{"|"\\{{"|"\\\\{{"|<<EOF>>) {
+                                   this.popState();
                                    return 'CONTENT';
                                  }
 
 <com>[\s\S]*?"--}}"              strip(0,4); this.popState(); return 'COMMENT';
 
+<mu>"("                          return 'OPEN_SEXPR';
+<mu>")"                          return 'CLOSE_SEXPR';
+
 <mu>"{{"{LEFT_STRIP}?">"         return 'OPEN_PARTIAL';
 <mu>"{{"{LEFT_STRIP}?"#"         return 'OPEN_BLOCK';
 <mu>"{{"{LEFT_STRIP}?"/"         return 'OPEN_ENDBLOCK';
@@ -66,7 +69,7 @@ ID    [^\s!"#%-,\.\/;->@\[-\^`\{-~]+/{LOOKAHEAD}
 <mu>".."                         return 'ID';
 <mu>"."/{LOOKAHEAD}              return 'ID';
 <mu>[\/.]                        return 'SEP';
-<mu>\s+                          /*ignore whitespace*/
+<mu>\s+                          // ignore whitespace
 <mu>"}"{RIGHT_STRIP}?"}}"        this.popState(); return 'CLOSE_UNESCAPED';
 <mu>{RIGHT_STRIP}?"}}"           this.popState(); return 'CLOSE';
 <mu>'"'("\\"["]|[^"])*'"'        yytext = strip(1,2).replace(/\\"/g,'"'); return 'STRING';

src/handlebars.yy

@@ -6,8 +6,8 @@
 
 function stripFlags(open, close) {
   return {
-    left: open[2] === '~',
-    right: close[0] === '~' || close[1] === '~'
+    left: open.charAt(2) === '~',
+    right: close.charAt(0) === '~' || close.charAt(1) === '~'
   };
 }
 
@@ -16,16 +16,17 @@ function stripFlags(open, close) {
 %%
 
 root
-  : statements EOF { return new yy.ProgramNode($1); }
+  : statements EOF { return new yy.ProgramNode($1, @$); }
+  | EOF { return new yy.ProgramNode([], @$); }
   ;
 
 program
-  : simpleInverse statements -> new yy.ProgramNode([], $1, $2)
-  | statements simpleInverse statements -> new yy.ProgramNode($1, $2, $3)
-  | statements simpleInverse -> new yy.ProgramNode($1, $2, [])
-  | statements -> new yy.ProgramNode($1)
-  | simpleInverse -> new yy.ProgramNode([])
-  | "" -> new yy.ProgramNode([])
+  : simpleInverse statements -> new yy.ProgramNode([], $1, $2, @$)
+  | statements simpleInverse statements -> new yy.ProgramNode($1, $2, $3, @$)
+  | statements simpleInverse -> new yy.ProgramNode($1, $2, [], @$)
+  | statements -> new yy.ProgramNode($1, @$)
+  | simpleInverse -> new yy.ProgramNode([], @$)
+  | "" -> new yy.ProgramNode([], @$)
   ;
 
 statements
@@ -34,20 +35,20 @@ statements
   ;
 
 statement
-  : openInverse program closeBlock -> new yy.BlockNode($1, $2.inverse, $2, $3)
-  | openBlock program closeBlock -> new yy.BlockNode($1, $2, $2.inverse, $3)
+  : openInverse program closeBlock -> new yy.BlockNode($1, $2.inverse, $2, $3, @$)
+  | openBlock program closeBlock -> new yy.BlockNode($1, $2, $2.inverse, $3, @$)
   | mustache -> $1
   | partial -> $1
-  | CONTENT -> new yy.ContentNode($1)
-  | COMMENT -> new yy.CommentNode($1)
+  | CONTENT -> new yy.ContentNode($1, @$)
+  | COMMENT -> new yy.CommentNode($1, @$)
   ;
 
 openBlock
-  : OPEN_BLOCK inMustache CLOSE -> new yy.MustacheNode($2[0], $2[1], $1, stripFlags($1, $3))
+  : OPEN_BLOCK sexpr CLOSE -> new yy.MustacheNode($2, null, $1, stripFlags($1, $3), @$)
   ;
 
 openInverse
-  : OPEN_INVERSE inMustache CLOSE -> new yy.MustacheNode($2[0], $2[1], $1, stripFlags($1, $3))
+  : OPEN_INVERSE sexpr CLOSE -> new yy.MustacheNode($2, null, $1, stripFlags($1, $3), @$)
   ;
 
 closeBlock
@@ -57,34 +58,34 @@ closeBlock
 mustache
   // Parsing out the '&' escape token at AST level saves ~500 bytes after min due to the removal of one parser node.
   // This also allows for handler unification as all mustache node instances can utilize the same handler
-  : OPEN inMustache CLOSE -> new yy.MustacheNode($2[0], $2[1], $1, stripFlags($1, $3))
-  | OPEN_UNESCAPED inMustache CLOSE_UNESCAPED -> new yy.MustacheNode($2[0], $2[1], $1, stripFlags($1, $3))
+  : OPEN sexpr CLOSE -> new yy.MustacheNode($2, null, $1, stripFlags($1, $3), @$)
+  | OPEN_UNESCAPED sexpr CLOSE_UNESCAPED -> new yy.MustacheNode($2, null, $1, stripFlags($1, $3), @$)
   ;
 
-
 partial
-  : OPEN_PARTIAL partialName path? CLOSE -> new yy.PartialNode($2, $3, stripFlags($1, $4))
+  : OPEN_PARTIAL partialName path? CLOSE -> new yy.PartialNode($2, $3, stripFlags($1, $4), @$)
   ;
 
 simpleInverse
   : OPEN_INVERSE CLOSE -> stripFlags($1, $2)
   ;
 
-inMustache
-  : path param* hash? -> [[$1].concat($2), $3]
-  | dataName -> [[$1], null]
+sexpr
+  : path param* hash? -> new yy.SexprNode([$1].concat($2), $3, @$)
+  | dataName -> new yy.SexprNode([$1], null, @$)
   ;
 
 param
   : path -> $1
-  | STRING -> new yy.StringNode($1)
-  | INTEGER -> new yy.IntegerNode($1)
-  | BOOLEAN -> new yy.BooleanNode($1)
+  | STRING -> new yy.StringNode($1, @$)
+  | INTEGER -> new yy.IntegerNode($1, @$)
+  | BOOLEAN -> new yy.BooleanNode($1, @$)
   | dataName -> $1
+  | OPEN_SEXPR sexpr CLOSE_SEXPR {$2.isHelper = true; $$ = $2;}
   ;
 
 hash
-  : hashSegment+ -> new yy.HashNode($1)
+  : hashSegment+ -> new yy.HashNode($1, @$)
   ;
 
 hashSegment
@@ -92,17 +93,17 @@ hashSegment
   ;
 
 partialName
-  : path -> new yy.PartialNameNode($1)
-  | STRING -> new yy.PartialNameNode(new yy.StringNode($1))
-  | INTEGER -> new yy.PartialNameNode(new yy.IntegerNode($1))
+  : path -> new yy.PartialNameNode($1, @$)
+  | STRING -> new yy.PartialNameNode(new yy.StringNode($1, @$), @$)
+  | INTEGER -> new yy.PartialNameNode(new yy.IntegerNode($1, @$))
   ;
 
 dataName
-  : DATA path -> new yy.DataNode($2)
+  : DATA path -> new yy.DataNode($2, @$)
   ;
 
 path
-  : pathSegments -> new yy.IdNode($1)
+  : pathSegments -> new yy.IdNode($1, @$)
   ;
 
 pathSegments

src/parser-prefix.js

@@ -0,0 +1 @@
+/* jshint ignore:start */

src/parser-suffix.js

@@ -1 +1,2 @@
 export default handlebars;
+/* jshint ignore:end */

tasks/packager.js

@@ -1,13 +0,0 @@
-module.exports = function(grunt) {
-  grunt.registerMultiTask('packager', 'Transpiles scripts written using ES6 to ES5.', function() {
-    // Execute in here to prevent traceur private var blowup
-    var Packager = require('es6-module-packager').default,
-        fs = require('fs');
-
-    var options = this.options();
-    this.files.forEach(function(file) {
-      var packager = new Packager(file.src[0], {export: options.export});
-      fs.writeFileSync(file.dest, packager.toLocals());
-    });
-  });
-};

tasks/parser.js

@@ -12,7 +12,7 @@ module.exports = function(grunt) {
         return;
       }
 
-      var src = ['handlebars.js', 'src/parser-suffix.js'].map(grunt.file.read).join('');
+      var src = ['src/parser-prefix.js', 'handlebars.js', 'src/parser-suffix.js'].map(grunt.file.read).join('');
       grunt.file.delete('handlebars.js');
 
       grunt.file.write('lib/handlebars/compiler/parser.js', src);

tasks/test.js

@@ -0,0 +1,32 @@
+var childProcess = require('child_process'),
+    fs = require('fs');
+
+module.exports = function(grunt) {
+  grunt.registerTask('test:bin', function() {
+    var done = this.async();
+
+    childProcess.exec('./bin/handlebars -a spec/artifacts/empty.handlebars', function(err, stdout) {
+      if (err) {
+        throw err;
+      }
+
+      if (stdout.toString() !== fs.readFileSync('./spec/expected/empty.amd.js').toString()) {
+        throw new Error('Expected binary output differed');
+      }
+
+      done();
+    });
+  });
+  grunt.registerTask('test:mocha', function() {
+    var done = this.async();
+
+    var runner = childProcess.fork('./spec/env/runner', [], {stdio: 'inherit'});
+    runner.on('close', function(code) {
+      if (code != 0) {
+        grunt.fatal(code + ' tests failed');
+      }
+      done();
+    });
+  });
+  grunt.registerTask('test', ['test:bin', 'test:mocha']);
+};