handlebars 0.3.2 → 0.4.0

data/vendor/handlebars/spec/qunit_spec.js

@@ -1,22 +1,52 @@
-module("basic context");
+var Handlebars;
+if (!Handlebars) {
+  // Setup for Node package testing
+  Handlebars = require('../lib/handlebars');
+
+  var assert = require("assert"),
+
+      equal = assert.equal,
+      equals = assert.equal,
+      ok = assert.ok;
+
+  // Note that this doesn't have the same context separation as the rspec test.
+  // Both should be run for full acceptance of the two libary modes.
+  var CompilerContext = {
+    compile: function(template, options) {
+      var templateSpec = Handlebars.precompile(template, options);
+      return Handlebars.template(eval('(' + templateSpec + ')'));
+    },
+    compileWithPartial: function(template, options) {
+      return Handlebars.compile(template, options);
+    }
+  };
+} else {
+  var _equal = equal;
+  equals = equal = function(a, b, msg) {
+    // Allow exec with missing message params
+    _equal(a, b, msg || '');
+  };
+}
 
-Handlebars.registerHelper('helperMissing', function(helper, context) {
-  if(helper === "link_to") {
-    return new Handlebars.SafeString("<a>" + context + "</a>");
-  }
-});
+suite("basic context");
 
-var shouldCompileTo = function(string, hashOrArray, expected, message) {
+function shouldCompileTo(string, hashOrArray, expected, message) {
   shouldCompileToWithPartials(string, hashOrArray, false, expected, message);
-};
-var shouldCompileToWithPartials = function(string, hashOrArray, partials, expected, message) {
+}
+
+function shouldCompileToWithPartials(string, hashOrArray, partials, expected, message) {
+  var result = compileWithPartials(string, hashOrArray, partials);
+  equal(result, expected, "'" + expected + "' should === '" + result + "': " + message);
+}
+
+function compileWithPartials(string, hashOrArray, partials) {
   var template = CompilerContext[partials ? 'compileWithPartial' : 'compile'](string), ary;
   if(Object.prototype.toString.call(hashOrArray) === "[object Array]") {
-    helpers = hashOrArray[1];
+    var helpers = hashOrArray[1];
 
     if(helpers) {
       for(var prop in Handlebars.helpers) {
-        helpers[prop] = Handlebars.helpers[prop];
+        helpers[prop] = helpers[prop] || Handlebars.helpers[prop];
       }
     }
 
@@ -27,24 +57,40 @@ var shouldCompileToWithPartials = function(string, hashOrArray, partials, expect
     ary = [hashOrArray];
   }
 
-  result = template.apply(this, ary);
-  equal(result, expected, "'" + expected + "' should === '" + result + "': " + message);
-};
+  return template.apply(this, ary);
+}
+
+function shouldThrow(fn, exception, message) {
+  var caught = false,
+      exType, exMessage;
+
+  if (exception instanceof Array) {
+    exType = exception[0];
+    exMessage = exception[1];
+  } else if (typeof exception === 'string') {
+    exType = Error;
+    exMessage = exception;
+  } else {
+    exType = exception;
+  }
 
-var shouldThrow = function(fn, exception, message) {
-  var caught = false;
   try {
     fn();
   }
   catch (e) {
-    if (e instanceof exception) {
-      caught = true;
+    if (e instanceof exType) {
+      if (!exMessage || e.message === exMessage) {
+        caught = true;
+      }
     }
   }
 
   ok(caught, message || null);
 }
 
+test("most basic", function() {
+  shouldCompileTo("{{foo}}", { foo: "foo" }, "foo");
+});
 
 test("compiling with a basic context", function() {
   shouldCompileTo("Goodbye\n{{cruel}}\n{{world}}!", {cruel: "cruel", world: "world"}, "Goodbye\ncruel\nworld!",
@@ -67,8 +113,8 @@ test("boolean", function() {
 });
 
 test("zeros", function() {
-	shouldCompileTo("num1: {{num1}}, num2: {{num2}}", {num1: 42, num2: 0},
-			"num1: 42, num2: 0");
+  shouldCompileTo("num1: {{num1}}, num2: {{num2}}", {num1: 42, num2: 0},
+      "num1: 42, num2: 0");
 	shouldCompileTo("num: {{.}}", 0, "num: 0");
 	shouldCompileTo("num: {{num1/num2}}", {num1: {num2: 0}}, "num: 0");
 });
@@ -96,6 +142,8 @@ test("escaping expressions", function() {
  shouldCompileTo("{{awesome}}", {awesome: "&\"'`\\<>"}, '&amp;&quot;&#x27;&#x60;\\&lt;&gt;',
         "by default expressions should be escaped");
 
+ shouldCompileTo("{{awesome}}", {awesome: "Escaped, <b> looks like: &lt;b&gt;"}, 'Escaped, &lt;b&gt; looks like: &amp;lt;b&amp;gt;',
+        "escaping should properly handle amperstands");
 });
 
 test("functions returning safestrings shouldn't be escaped", function() {
@@ -107,17 +155,14 @@ test("functions returning safestrings shouldn't be escaped", function() {
 test("functions", function() {
   shouldCompileTo("{{awesome}}", {awesome: function() { return "Awesome"; }}, "Awesome",
                   "functions are called and render their output");
-});
-
-test("functions with context argument", function() {
-  shouldCompileTo("{{awesome frank}}",
-      {awesome: function(context) { return context; },
-        frank: "Frank"},
-      "Frank", "functions are called with context arguments");
+  shouldCompileTo("{{awesome}}", {awesome: function() { return this.more; }, more:  "More awesome"}, "More awesome",
+                  "functions are bound to the context");
 });
 
 test("paths with hyphens", function() {
   shouldCompileTo("{{foo-bar}}", {"foo-bar": "baz"}, "baz", "Paths can contain hyphens (-)");
+  shouldCompileTo("{{foo.foo-bar}}", {foo: {"foo-bar": "baz"}}, "baz", "Paths can contain hyphens (-)");
+  shouldCompileTo("{{foo/foo-bar}}", {foo: {"foo-bar": "baz"}}, "baz", "Paths can contain hyphens (-)");
 });
 
 test("nested paths", function() {
@@ -131,20 +176,15 @@ test("nested paths with empty string value", function() {
 });
 
 test("literal paths", function() {
-	shouldCompileTo("Goodbye {{[@alan]/expression}} world!", {"@alan": {expression: "beautiful"}},
-			"Goodbye beautiful world!", "Literal paths can be used");
+  shouldCompileTo("Goodbye {{[@alan]/expression}} world!", {"@alan": {expression: "beautiful"}},
+      "Goodbye beautiful world!", "Literal paths can be used");
+  shouldCompileTo("Goodbye {{[foo bar]/expression}} world!", {"foo bar": {expression: "beautiful"}},
+      "Goodbye beautiful world!", "Literal paths can be used");
 });
 
-test("--- TODO --- bad idea nested paths", function() {
-  return;
-	var hash     = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}], world: "world"};
-  shouldThrow(function() {
-      CompilerContext.compile("{{#goodbyes}}{{../name/../name}}{{/goodbyes}}")(hash);
-    }, Handlebars.Exception,
-    "Cannot jump (..) into previous context after moving into a context.");
-
-  var string = "{{#goodbyes}}{{.././world}} {{/goodbyes}}";
-  shouldCompileTo(string, hash, "world world world ", "Same context (.) is ignored in paths");
+test('literal references', function() {
+  shouldCompileTo("Goodbye {{[foo bar]}} world!", {"foo bar": "beautiful"},
+      "Goodbye beautiful world!", "Literal paths can be used");
 });
 
 test("that current context path ({{.}}) doesn't hit helpers", function() {
@@ -162,12 +202,40 @@ test("this keyword in paths", function() {
   shouldCompileTo(string, hash, "goodbyeGoodbyeGOODBYE",
     "This keyword in paths evaluates to current context");
 
-  string = "{{#hellos}}{{this/text}}{{/hellos}}"
+  string = "{{#hellos}}{{this/text}}{{/hellos}}";
   hash = {hellos: [{text: "hello"}, {text: "Hello"}, {text: "HELLO"}]};
   shouldCompileTo(string, hash, "helloHelloHELLO", "This keyword evaluates in more complex paths");
 });
 
-module("inverted sections");
+test("this keyword nested inside path", function() {
+  var string = "{{#hellos}}{{text/this/foo}}{{/hellos}}";
+  shouldThrow(function() {
+      CompilerContext.compile(string);
+    }, Error, "Should throw exception");
+});
+
+test("this keyword in helpers", function() {
+  var helpers = {foo: function(value) {
+      return 'bar ' + value;
+  }};
+  var string = "{{#goodbyes}}{{foo this}}{{/goodbyes}}";
+  var hash = {goodbyes: ["goodbye", "Goodbye", "GOODBYE"]};
+  shouldCompileTo(string, [hash, helpers], "bar goodbyebar Goodbyebar GOODBYE",
+    "This keyword in paths evaluates to current context");
+
+  string = "{{#hellos}}{{foo this/text}}{{/hellos}}";
+  hash = {hellos: [{text: "hello"}, {text: "Hello"}, {text: "HELLO"}]};
+  shouldCompileTo(string, [hash, helpers], "bar hellobar Hellobar HELLO", "This keyword evaluates in more complex paths");
+});
+
+test("this keyword nested inside helpers param", function() {
+  var string = "{{#hellos}}{{foo text/this/foo}}{{/hellos}}";
+  shouldThrow(function() {
+      CompilerContext.compile(string);
+    }, Error, "Should throw exception");
+});
+
+suite("inverted sections");
 
 test("inverted sections with unset value", function() {
   var string = "{{#goodbyes}}{{this}}{{/goodbyes}}{{^goodbyes}}Right On!{{/goodbyes}}";
@@ -187,10 +255,10 @@ test("inverted section with empty set", function() {
   shouldCompileTo(string, hash, "Right On!", "Inverted section rendered when value is empty set.");
 });
 
-module("blocks");
+suite("blocks");
 
 test("array", function() {
-  var string   = "{{#goodbyes}}{{text}}! {{/goodbyes}}cruel {{world}}!"
+  var string   = "{{#goodbyes}}{{text}}! {{/goodbyes}}cruel {{world}}!";
   var hash     = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}], world: "world"};
   shouldCompileTo(string, hash, "goodbye! Goodbye! GOODBYE! cruel world!",
                   "Arrays iterate over the contents when not empty");
@@ -200,8 +268,18 @@ test("array", function() {
 
 });
 
+test("array with @index", function() {
+  var string = "{{#goodbyes}}{{@index}}. {{text}}! {{/goodbyes}}cruel {{world}}!";
+  var hash   = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {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");
+});
+
 test("empty block", function() {
-  var string   = "{{#goodbyes}}{{/goodbyes}}cruel {{world}}!"
+  var string   = "{{#goodbyes}}{{/goodbyes}}cruel {{world}}!";
   var hash     = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}], world: "world"};
   shouldCompileTo(string, hash, "cruel world!",
                   "Arrays iterate over the contents when not empty");
@@ -215,30 +293,38 @@ test("nested iteration", function() {
 });
 
 test("block with complex lookup", function() {
-  var string = "{{#goodbyes}}{{text}} cruel {{../name}}! {{/goodbyes}}"
+  var string = "{{#goodbyes}}{{text}} cruel {{../name}}! {{/goodbyes}}";
   var hash     = {name: "Alan", goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}]};
 
   shouldCompileTo(string, hash, "goodbye cruel Alan! Goodbye cruel Alan! GOODBYE cruel Alan! ",
                   "Templates can access variables in contexts up the stack with relative path syntax");
 });
 
-test("helper with complex lookup", function() {
-  var string = "{{#goodbyes}}{{{link ../prefix}}}{{/goodbyes}}"
+test("block with complex lookup using nested context", function() {
+  var string = "{{#goodbyes}}{{text}} cruel {{foo/../name}}! {{/goodbyes}}";
+
+  shouldThrow(function() {
+      CompilerContext.compile(string);
+    }, Error, "Should throw exception");
+});
+
+test("helper with complex lookup$", function() {
+  var string = "{{#goodbyes}}{{{link ../prefix}}}{{/goodbyes}}";
   var hash = {prefix: "/root", goodbyes: [{text: "Goodbye", url: "goodbye"}]};
   var helpers = {link: function(prefix) {
-    return "<a href='" + prefix + "/" + this.url + "'>" + this.text + "</a>"
+    return "<a href='" + prefix + "/" + this.url + "'>" + this.text + "</a>";
   }};
-  shouldCompileTo(string, [hash, helpers], "<a href='/root/goodbye'>Goodbye</a>")
+  shouldCompileTo(string, [hash, helpers], "<a href='/root/goodbye'>Goodbye</a>");
 });
 
 test("helper block with complex lookup expression", function() {
-  var string = "{{#goodbyes}}{{../name}}{{/goodbyes}}"
+  var string = "{{#goodbyes}}{{../name}}{{/goodbyes}}";
   var hash = {name: "Alan"};
-  var helpers = {goodbyes: function(fn) {
+  var helpers = {goodbyes: function(options) {
 		var out = "";
 		var byes = ["Goodbye", "goodbye", "GOODBYE"];
 		for (var i = 0,j = byes.length; i < j; i++) {
-			out += byes[i] + " " + fn(this) + "! ";
+			out += byes[i] + " " + options.fn(this) + "! ";
 		}
     return out;
   }};
@@ -248,8 +334,8 @@ test("helper block with complex lookup expression", function() {
 test("helper with complex lookup and nested template", function() {
   var string = "{{#goodbyes}}{{#link ../prefix}}{{text}}{{/link}}{{/goodbyes}}";
   var hash = {prefix: '/root', goodbyes: [{text: "Goodbye", url: "goodbye"}]};
-  var helpers = {link: function (prefix, fn) {
-      return "<a href='" + prefix + "/" + this.url + "'>" + fn(this) + "</a>";
+  var helpers = {link: function (prefix, options) {
+      return "<a href='" + prefix + "/" + this.url + "'>" + options.fn(this) + "</a>";
   }};
   shouldCompileToWithPartials(string, [hash, helpers], false, "<a href='/root/goodbye'>Goodbye</a>");
 });
@@ -257,8 +343,8 @@ test("helper with complex lookup and nested template", function() {
 test("helper with complex lookup and nested template in VM+Compiler", function() {
   var string = "{{#goodbyes}}{{#link ../prefix}}{{text}}{{/link}}{{/goodbyes}}";
   var hash = {prefix: '/root', goodbyes: [{text: "Goodbye", url: "goodbye"}]};
-  var helpers = {link: function (prefix, fn) {
-      return "<a href='" + prefix + "/" + this.url + "'>" + fn(this) + "</a>";
+  var helpers = {link: function (prefix, options) {
+      return "<a href='" + prefix + "/" + this.url + "'>" + options.fn(this) + "</a>";
   }};
   shouldCompileToWithPartials(string, [hash, helpers], true, "<a href='/root/goodbye'>Goodbye</a>");
 });
@@ -274,22 +360,22 @@ test("block helper", function() {
   var string   = "{{#goodbyes}}{{text}}! {{/goodbyes}}cruel {{world}}!";
   var template = CompilerContext.compile(string);
 
-  result = template({world: "world"}, { helpers: {goodbyes: function(fn) { return fn({text: "GOODBYE"}); }}});
+  var result = template({world: "world"}, { helpers: {goodbyes: function(options) { return options.fn({text: "GOODBYE"}); }}});
   equal(result, "GOODBYE! cruel world!", "Block helper executed");
 });
 
 test("block helper staying in the same context", function() {
-  var string   = "{{#form}}<p>{{name}}</p>{{/form}}"
+  var string   = "{{#form}}<p>{{name}}</p>{{/form}}";
   var template = CompilerContext.compile(string);
 
-  result = template({name: "Yehuda"}, {helpers: {form: function(fn) { return "<form>" + fn(this) + "</form>" } }});
+  var result = template({name: "Yehuda"}, {helpers: {form: function(options) { return "<form>" + options.fn(this) + "</form>"; } }});
   equal(result, "<form><p>Yehuda</p></form>", "Block helper executed with current context");
 });
 
 test("block helper should have context in this", function() {
   var source = "<ul>{{#people}}<li>{{#link}}{{name}}{{/link}}</li>{{/people}}</ul>";
-  var link = function(fn) {
-    return '<a href="/people/' + this.id + '">' + fn(this) + '</a>';
+  var link = function(options) {
+    return '<a href="/people/' + this.id + '">' + options.fn(this) + '</a>';
   };
   var data = { "people": [
     { "name": "Alan", "id": 1 },
@@ -304,31 +390,31 @@ test("block helper for undefined value", function() {
 });
 
 test("block helper passing a new context", function() {
-  var string   = "{{#form yehuda}}<p>{{name}}</p>{{/form}}"
+  var string   = "{{#form yehuda}}<p>{{name}}</p>{{/form}}";
   var template = CompilerContext.compile(string);
 
-  result = template({yehuda: {name: "Yehuda"}}, { helpers: {form: function(context, fn) { return "<form>" + fn(context) + "</form>" }}});
+  var result = template({yehuda: {name: "Yehuda"}}, { helpers: {form: function(context, options) { return "<form>" + options.fn(context) + "</form>"; }}});
   equal(result, "<form><p>Yehuda</p></form>", "Context variable resolved");
 });
 
 test("block helper passing a complex path context", function() {
-  var string   = "{{#form yehuda/cat}}<p>{{name}}</p>{{/form}}"
+  var string   = "{{#form yehuda/cat}}<p>{{name}}</p>{{/form}}";
   var template = CompilerContext.compile(string);
 
-  result = template({yehuda: {name: "Yehuda", cat: {name: "Harold"}}}, { helpers: {form: function(context, fn) { return "<form>" + fn(context) + "</form>" }}});
+  var result = template({yehuda: {name: "Yehuda", cat: {name: "Harold"}}}, { helpers: {form: function(context, options) { return "<form>" + options.fn(context) + "</form>"; }}});
   equal(result, "<form><p>Harold</p></form>", "Complex path variable resolved");
 });
 
 test("nested block helpers", function() {
-  var string   = "{{#form yehuda}}<p>{{name}}</p>{{#link}}Hello{{/link}}{{/form}}"
+  var string   = "{{#form yehuda}}<p>{{name}}</p>{{#link}}Hello{{/link}}{{/form}}";
   var template = CompilerContext.compile(string);
 
-  result = template({
+  var result = template({
     yehuda: {name: "Yehuda" }
   }, {
     helpers: {
-      link: function(fn) { return "<a href='" + this.name + "'>" + fn(this) + "</a>" },
-      form: function(context, fn) { return "<form>" + fn(context) + "</form>" }
+      link: function(options) { return "<a href='" + this.name + "'>" + options.fn(this) + "</a>"; },
+      form: function(context, options) { return "<form>" + options.fn(context) + "</form>"; }
     }
   });
   equal(result, "<form><p>Yehuda</p><a href='Yehuda'>Hello</a></form>", "Both blocks executed");
@@ -345,7 +431,7 @@ test("block inverted sections with empty arrays", function() {
 });
 
 test("block helper inverted sections", function() {
-  var string = "{{#list people}}{{name}}{{^}}<em>Nobody's here</em>{{/list}}"
+  var string = "{{#list people}}{{name}}{{^}}<em>Nobody's here</em>{{/list}}";
   var list = function(context, options) {
     if (context.length > 0) {
       var out = "<ul>";
@@ -366,7 +452,7 @@ test("block helper inverted sections", function() {
   var rootMessage = {
     people: [],
     message: "Nobody's here"
-  }
+  };
 
   var messageString = "{{#list people}}Hello{{^}}{{message}}{{/list}}";
 
@@ -377,25 +463,30 @@ test("block helper inverted sections", function() {
   shouldCompileTo(messageString, [rootMessage, { list: list }], "<p>Nobody&#x27;s here</p>", "the context of an inverse is the parent of the block");
 });
 
-module("helpers hash");
+suite("helpers hash");
 
 test("providing a helpers hash", function() {
-  shouldCompileTo("Goodbye {{cruel}} {{world}}!", [{cruel: "cruel"}, {world: "world"}], "Goodbye cruel world!",
+  shouldCompileTo("Goodbye {{cruel}} {{world}}!", [{cruel: "cruel"}, {world: function() { return "world"; }}], "Goodbye cruel world!",
                   "helpers hash is available");
 
-  shouldCompileTo("Goodbye {{#iter}}{{cruel}} {{world}}{{/iter}}!", [{iter: [{cruel: "cruel"}]}, {world: "world"}],
+  shouldCompileTo("Goodbye {{#iter}}{{cruel}} {{world}}{{/iter}}!", [{iter: [{cruel: "cruel"}]}, {world: function() { return "world"; }}],
                   "Goodbye cruel world!", "helpers hash is available inside other blocks");
 });
 
-test("in cases of conflict, the explicit hash wins", function() {
-
+test("in cases of conflict, helpers win", function() {
+  shouldCompileTo("{{{lookup}}}", [{lookup: 'Explicit'}, {lookup: function() { return 'helpers'; }}], "helpers",
+                  "helpers hash has precedence escaped expansion");
+  shouldCompileTo("{{lookup}}", [{lookup: 'Explicit'}, {lookup: function() { return 'helpers'; }}], "helpers",
+                  "helpers hash has precedence simple expansion");
 });
 
 test("the helpers hash is available is nested contexts", function() {
-
+  shouldCompileTo("{{#outer}}{{#inner}}{{helper}}{{/inner}}{{/outer}}",
+                [{'outer': {'inner': {'unused':[]}}},  {'helper': function() { return 'helper'; }}], "helper",
+                "helpers hash is available in nested contexts.");
 });
 
-module("partials");
+suite("partials");
 
 test("basic partials", function() {
   var string = "Dudes: {{#dudes}}{{> dude}}{{/dudes}}";
@@ -425,17 +516,14 @@ test("rendering undefined partial throws an exception", function() {
   shouldThrow(function() {
       var template = CompilerContext.compile("{{> whatever}}");
       template();
-    }, Handlebars.Exception, "Should throw exception");
+    }, [Handlebars.Exception, 'The partial whatever could not be found'], "Should throw exception");
 });
 
 test("rendering template partial in vm mode throws an exception", function() {
   shouldThrow(function() {
       var template = CompilerContext.compile("{{> whatever}}");
-       var string = "Dudes: {{>dude}} {{another_dude}}";
-       var dude = "{{name}}";
-       var hash = {name:"Jeepers", another_dude:"Creepers"};
       template();
-    }, Handlebars.Exception, "Should throw exception");
+    }, [Handlebars.Exception, 'The partial whatever could not be found'], "Should throw exception");
 });
 
 test("rendering function partial in vm mode", function() {
@@ -455,14 +543,22 @@ test("GH-14: a partial preceding a selector", function() {
    shouldCompileToWithPartials(string, [hash, {}, {dude:dude}], true, "Dudes: Jeepers Creepers", "Regular selectors can follow a partial");
 });
 
-test("Partials with literal paths", function() {
-	var string = "Dudes: {{> [dude]}}";
+test("Partials with slash paths", function() {
+	var string = "Dudes: {{> shared/dude}}";
+	var dude = "{{name}}";
+	var hash = {name:"Jeepers", another_dude:"Creepers"};
+  shouldCompileToWithPartials(string, [hash, {}, {'shared/dude':dude}], true, "Dudes: Jeepers", "Partials can use literal paths");
+});
+
+test("Partials with integer path", function() {
+	var string = "Dudes: {{> 404}}";
 	var dude = "{{name}}";
 	var hash = {name:"Jeepers", another_dude:"Creepers"};
-  shouldCompileToWithPartials(string, [hash, {}, {dude:dude}], true, "Dudes: Jeepers", "Partials can use literal paths");
+  shouldCompileToWithPartials(string, [hash, {}, {404:dude}], true, "Dudes: Jeepers", "Partials can use literal paths");
 });
 
-module("String literal parameters");
+
+suite("String literal parameters");
 
 test("simple literals work", function() {
   var string   = 'Message: {{hello "world" 12 true false}}';
@@ -472,7 +568,7 @@ test("simple literals work", function() {
     if(typeof bool1 !== 'boolean') { bool1 = "NaB"; }
     if(typeof bool2 !== 'boolean') { bool2 = "NaB"; }
     return "Hello " + param + " " + times + " times: " + bool1 + " " + bool2;
-  }}
+  }};
   shouldCompileTo(string, [hash, helpers], "Message: Hello world 12 times: true false", "template with a simple String literal");
 });
 
@@ -485,37 +581,37 @@ test("using a quote in the middle of a parameter raises an error", function() {
 
 test("escaping a String is possible", function(){
   var string   = 'Message: {{{hello "\\"world\\""}}}';
-  var hash     = {}
-  var helpers = {hello: function(param) { return "Hello " + param; }}
+  var hash     = {};
+  var helpers = {hello: function(param) { return "Hello " + param; }};
   shouldCompileTo(string, [hash, helpers], "Message: Hello \"world\"", "template with an escaped String literal");
 });
 
 test("it works with ' marks", function() {
   var string   = 'Message: {{{hello "Alan\'s world"}}}';
-  var hash     = {}
-  var helpers = {hello: function(param) { return "Hello " + param; }}
+  var hash     = {};
+  var helpers = {hello: function(param) { return "Hello " + param; }};
   shouldCompileTo(string, [hash, helpers], "Message: Hello Alan's world", "template with a ' mark");
 });
 
-module("multiple parameters");
+suite("multiple parameters");
 
 test("simple multi-params work", function() {
   var string   = 'Message: {{goodbye cruel world}}';
-  var hash     = {cruel: "cruel", world: "world"}
-  var helpers = {goodbye: function(cruel, world) { return "Goodbye " + cruel + " " + world; }}
+  var hash     = {cruel: "cruel", world: "world"};
+  var helpers = {goodbye: function(cruel, world) { return "Goodbye " + cruel + " " + world; }};
   shouldCompileTo(string, [hash, helpers], "Message: Goodbye cruel world", "regular helpers with multiple params");
 });
 
 test("block multi-params work", function() {
   var string   = 'Message: {{#goodbye cruel world}}{{greeting}} {{adj}} {{noun}}{{/goodbye}}';
-  var hash     = {cruel: "cruel", world: "world"}
-  var helpers = {goodbye: function(cruel, world, fn) {
-    return fn({greeting: "Goodbye", adj: cruel, noun: world});
-  }}
+  var hash     = {cruel: "cruel", world: "world"};
+  var helpers = {goodbye: function(cruel, world, options) {
+    return options.fn({greeting: "Goodbye", adj: cruel, noun: world});
+  }};
   shouldCompileTo(string, [hash, helpers], "Message: Goodbye cruel world", "block helpers with multiple params");
-})
+});
 
-module("safestring");
+suite("safestring");
 
 test("constructing a safestring from a string and checking its type", function() {
   var safe = new Handlebars.SafeString("testing 1, 2, 3");
@@ -523,65 +619,90 @@ test("constructing a safestring from a string and checking its type", function()
   equal(safe, "testing 1, 2, 3", "SafeString is equivalent to its underlying string");
 });
 
-module("helperMissing");
+suite("helperMissing");
 
 test("if a context is not found, helperMissing is used", function() {
-  var string = "{{hello}} {{link_to world}}"
+  shouldThrow(function() {
+      var template = CompilerContext.compile("{{hello}} {{link_to world}}");
+      template({});
+    }, [Error, "Could not find property 'link_to'"], "Should throw exception");
+});
+
+test("if a context is not found, custom helperMissing is used", function() {
+  var string = "{{hello}} {{link_to world}}";
   var context = { hello: "Hello", world: "world" };
 
-  shouldCompileTo(string, context, "Hello <a>world</a>")
+  var helpers = {
+    helperMissing: function(helper, context) {
+      if(helper === "link_to") {
+        return new Handlebars.SafeString("<a>" + context + "</a>");
+      }
+    }
+  };
+
+  shouldCompileTo(string, [context, helpers], "Hello <a>world</a>");
 });
 
-module("knownHelpers");
+suite("knownHelpers");
 
 test("Known helper should render helper", function() {
-  var template = CompilerContext.compile("{{hello}}", {knownHelpers: {"hello" : true}})
+  var template = CompilerContext.compile("{{hello}}", {knownHelpers: {"hello" : true}});
 
   var result = template({}, {helpers: {hello: function() { return "foo"; }}});
   equal(result, "foo", "'foo' should === '" + result);
 });
 
 test("Unknown helper in knownHelpers only mode should be passed as undefined", function() {
-  var template = CompilerContext.compile("{{typeof hello}}", {knownHelpers: {'typeof': true}, knownHelpersOnly: true})
+  var template = CompilerContext.compile("{{typeof hello}}", {knownHelpers: {'typeof': true}, knownHelpersOnly: true});
 
   var result = template({}, {helpers: {'typeof': function(arg) { return typeof arg; }, hello: function() { return "foo"; }}});
   equal(result, "undefined", "'undefined' should === '" + result);
 });
 test("Builtin helpers available in knownHelpers only mode", function() {
-  var template = CompilerContext.compile("{{#unless foo}}bar{{/unless}}", {knownHelpersOnly: true})
+  var template = CompilerContext.compile("{{#unless foo}}bar{{/unless}}", {knownHelpersOnly: true});
 
   var result = template({});
   equal(result, "bar", "'bar' should === '" + result);
 });
 test("Field lookup works in knownHelpers only mode", function() {
-  var template = CompilerContext.compile("{{foo}}", {knownHelpersOnly: true})
+  var template = CompilerContext.compile("{{foo}}", {knownHelpersOnly: true});
 
   var result = template({foo: 'bar'});
   equal(result, "bar", "'bar' should === '" + result);
 });
 test("Conditional blocks work in knownHelpers only mode", function() {
-  var template = CompilerContext.compile("{{#foo}}bar{{/foo}}", {knownHelpersOnly: true})
+  var template = CompilerContext.compile("{{#foo}}bar{{/foo}}", {knownHelpersOnly: true});
 
   var result = template({foo: 'baz'});
   equal(result, "bar", "'bar' should === '" + result);
 });
 test("Invert blocks work in knownHelpers only mode", function() {
-  var template = CompilerContext.compile("{{^foo}}bar{{/foo}}", {knownHelpersOnly: true})
+  var template = CompilerContext.compile("{{^foo}}bar{{/foo}}", {knownHelpersOnly: true});
 
   var result = template({foo: false});
   equal(result, "bar", "'bar' should === '" + result);
 });
+test("Functions are bound to the context in knownHelpers only mode", function() {
+  var template = CompilerContext.compile("{{foo}}", {knownHelpersOnly: true});
+  var result = template({foo: function() { return this.bar; }, bar: 'bar'});
+  equal(result, "bar", "'bar' should === '" + result);
+});
 
-module("blockHelperMissing");
+suite("blockHelperMissing");
 
 test("lambdas are resolved by blockHelperMissing, not handlebars proper", function() {
   var string = "{{#truthy}}yep{{/truthy}}";
   var data = { truthy: function() { return true; } };
   shouldCompileTo(string, data, "yep");
 });
+test("lambdas resolved by blockHelperMissing are bound to the context", function() {
+  var string = "{{#truthy}}yep{{/truthy}}";
+  var boundData = { truthy: function() { return this.truthiness(); }, truthiness: function() { return false; } };
+  shouldCompileTo(string, boundData, "");
+});
 
 var teardown;
-module("built-in helpers", {
+suite("built-in helpers", {
   setup: function(){ teardown = null; },
   teardown: function(){ if (teardown) { teardown(); } }
 });
@@ -609,18 +730,18 @@ test("if", function() {
 
 test("if with function argument", function() {
   var string   = "{{#if goodbye}}GOODBYE {{/if}}cruel {{world}}!";
-  shouldCompileTo(string, {goodbye: function() {return true}, world: "world"}, "GOODBYE cruel world!",
+  shouldCompileTo(string, {goodbye: function() {return true;}, world: "world"}, "GOODBYE cruel world!",
                   "if with function shows the contents when function returns true");
-  shouldCompileTo(string, {goodbye: function() {return this.world}, world: "world"}, "GOODBYE cruel world!",
+  shouldCompileTo(string, {goodbye: function() {return this.world;}, world: "world"}, "GOODBYE cruel world!",
                   "if with function shows the contents when function returns string");
-  shouldCompileTo(string, {goodbye: function() {return false}, world: "world"}, "cruel world!",
+  shouldCompileTo(string, {goodbye: function() {return false;}, world: "world"}, "cruel world!",
                   "if with function does not show the contents when returns false");
-  shouldCompileTo(string, {goodbye: function() {return this.foo}, world: "world"}, "cruel world!",
+  shouldCompileTo(string, {goodbye: function() {return this.foo;}, world: "world"}, "cruel world!",
                   "if with function does not show the contents when returns undefined");
 });
 
 test("each", function() {
-  var string   = "{{#each goodbyes}}{{text}}! {{/each}}cruel {{world}}!"
+  var string   = "{{#each goodbyes}}{{text}}! {{/each}}cruel {{world}}!";
   var hash     = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}], world: "world"};
   shouldCompileTo(string, hash, "goodbye! Goodbye! GOODBYE! cruel world!",
                   "each with array argument iterates over the contents when not empty");
@@ -628,16 +749,60 @@ test("each", function() {
                   "each with array argument ignores the contents when empty");
 });
 
+test("each with an object and @key", function() {
+  var string   = "{{#each goodbyes}}{{@key}}. {{text}}! {{/each}}cruel {{world}}!";
+  var hash     = {goodbyes: {"<b>#1</b>": {text: "goodbye"}, 2: {text: "GOODBYE"}}, world: "world"};
+
+  // Object property iteration order is undefined according to ECMA spec,
+  // so we need to check both possible orders
+  // @see http://stackoverflow.com/questions/280713/elements-order-in-a-for-in-loop
+  var actual = compileWithPartials(string, hash);
+  var expected1 = "&lt;b&gt;#1&lt;/b&gt;. goodbye! 2. GOODBYE! cruel world!";
+  var expected2 = "2. GOODBYE! &lt;b&gt;#1&lt;/b&gt;. goodbye! cruel world!";
+
+  ok(actual === expected1 || actual === expected2, "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");
+});
+
+test("each with @index", function() {
+  var string = "{{#each goodbyes}}{{@index}}. {{text}}! {{/each}}cruel {{world}}!";
+  var hash   = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {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");
+});
+
+test("data passed to helpers", function() {
+  var string = "{{#each letters}}{{this}}{{detectDataInsideEach}}{{/each}}";
+  var hash = {letters: ['a', 'b', 'c']};
+
+  var template = CompilerContext.compile(string);
+  var result = template(hash, {
+    data: {
+      exclaim: '!'
+    }
+  });
+  equal(result, 'a!b!c!', 'should output data');
+});
+
+Handlebars.registerHelper('detectDataInsideEach', function(options) {
+  return options.data && options.data.exclaim;
+});
+
 test("log", function() {
-  var string = "{{log blah}}"
+  var string = "{{log blah}}";
   var hash   = { blah: "whee" };
 
-  var logArg;
+  var levelArg, logArg;
   var originalLog = Handlebars.log;
-  Handlebars.log = function(arg){ logArg = arg; }
-  teardown = function(){ Handlebars.log = originalLog; }
+  Handlebars.log = function(level, arg){ levelArg = level, logArg = arg; };
+  teardown = function(){ Handlebars.log = originalLog; };
 
   shouldCompileTo(string, hash, "", "log should not display");
+  equals(1, levelArg, "should call log with 1");
   equals("whee", logArg, "should call log with 'whee'");
 });
 
@@ -659,6 +824,71 @@ test("passing in data to a compiled function that expects data - works with help
   equals("happy cat", result, "Data output by helper");
 });
 
+test("data can be looked up via @foo", function() {
+  var template = CompilerContext.compile("{{@hello}}");
+  var result = template({}, { data: { hello: "hello" } });
+  equals("hello", result, "@foo retrieves template data");
+});
+
+var objectCreate = Handlebars.createFrame;
+
+test("deep @foo triggers automatic top-level data", function() {
+  var template = CompilerContext.compile('{{#let world="world"}}{{#if foo}}{{#if foo}}Hello {{@world}}{{/if}}{{/if}}{{/let}}');
+
+  var helpers = objectCreate(Handlebars.helpers);
+
+  helpers.let = function(options) {
+    var frame = Handlebars.createFrame(options.data);
+
+    for (var prop in options.hash) {
+      frame[prop] = options.hash[prop];
+    }
+    return options.fn(this, { data: frame });
+  };
+
+  var result = template({ foo: true }, { helpers: helpers });
+  equals("Hello world", result, "Automatic data was triggered");
+});
+
+test("parameter data can be looked up via @foo", function() {
+  var template = CompilerContext.compile("{{hello @world}}");
+  var helpers = {
+    hello: function(noun) {
+      return "Hello " + noun;
+    }
+  };
+
+  var result = template({}, { helpers: helpers, data: { world: "world" } });
+  equals("Hello world", result, "@foo as a parameter retrieves template data");
+});
+
+test("hash values can be looked up via @foo", function() {
+  var template = CompilerContext.compile("{{hello noun=@world}}");
+  var helpers = {
+    hello: function(options) {
+      return "Hello " + options.hash.noun;
+    }
+  };
+
+  var result = template({}, { helpers: helpers, data: { world: "world" } });
+  equals("Hello world", result, "@foo as a parameter retrieves template data");
+});
+
+test("data is inherited downstream", function() {
+  var template = CompilerContext.compile("{{#let foo=bar.baz}}{{@foo}}{{/let}}", { data: true });
+  var helpers = {
+    let: function(options) {
+      for (var prop in options.hash) {
+        options.data[prop] = options.hash[prop];
+      }
+      return options.fn(this);
+    }
+  };
+
+  var result = template({ bar: { baz: "hello world" } }, { helpers: helpers, data: {} });
+  equals("hello world", result, "data variables are inherited downstream");
+});
+
 test("passing in data to a compiled function that expects data - works with helpers in partials", function() {
   var template = CompilerContext.compile("{{>my_partial}}", {data: true});
 
@@ -693,8 +923,8 @@ test("passing in data to a compiled function that expects data - works with bloc
   var template = CompilerContext.compile("{{#hello}}{{world}}{{/hello}}", {data: true});
 
   var helpers = {
-    hello: function(fn) {
-      return fn(this);
+    hello: function(options) {
+      return options.fn(this);
     },
     world: function(options) {
       return options.data.adjective + " world" + (this.exclaim ? "!" : "");
@@ -709,8 +939,8 @@ test("passing in data to a compiled function that expects data - works with bloc
   var template = CompilerContext.compile("{{#hello}}{{world ../zomg}}{{/hello}}", {data: true});
 
   var helpers = {
-    hello: function(fn) {
-      return fn({exclaim: "?"});
+    hello: function(options) {
+      return options.fn({exclaim: "?"});
     },
     world: function(thing, options) {
       return options.data.adjective + " " + thing + (this.exclaim || "");
@@ -725,8 +955,8 @@ test("passing in data to a compiled function that expects data - data is passed
   var template = CompilerContext.compile("{{#hello}}{{world ../zomg}}{{/hello}}", {data: true});
 
   var helpers = {
-    hello: function(fn, inverse) {
-      return fn.data.accessData + " " + fn({exclaim: "?"});
+    hello: function(options) {
+      return options.data.accessData + " " + options.fn({exclaim: "?"});
     },
     world: function(thing, options) {
       return options.data.adjective + " " + thing + (this.exclaim || "");
@@ -741,8 +971,8 @@ test("you can override inherited data when invoking a helper", function() {
   var template = CompilerContext.compile("{{#hello}}{{world zomg}}{{/hello}}", {data: true});
 
   var helpers = {
-    hello: function(fn) {
-      return fn({exclaim: "?", zomg: "world"}, { data: {adjective: "sad"} });
+    hello: function(options) {
+      return options.fn({exclaim: "?", zomg: "world"}, { data: {adjective: "sad"} });
     },
     world: function(thing, options) {
       return options.data.adjective + " " + thing + (this.exclaim || "");
@@ -758,8 +988,8 @@ test("you can override inherited data when invoking a helper with depth", functi
   var template = CompilerContext.compile("{{#hello}}{{world ../zomg}}{{/hello}}", {data: true});
 
   var helpers = {
-    hello: function(fn) {
-      return fn({exclaim: "?"}, { data: {adjective: "sad"} });
+    hello: function(options) {
+      return options.fn({exclaim: "?"}, { data: {adjective: "sad"} });
     },
     world: function(thing, options) {
       return options.data.adjective + " " + thing + (this.exclaim || "");
@@ -776,14 +1006,14 @@ test("helpers take precedence over same-named context properties", function() {
   var helpers = {
     goodbye: function() {
       return this.goodbye.toUpperCase();
-    }
-  };
+    },
 
-  var context = {
     cruel: function(world) {
       return "cruel " + world.toUpperCase();
-    },
+    }
+  };
 
+  var context = {
     goodbye: "goodbye",
     world: "world"
   };
@@ -792,20 +1022,20 @@ test("helpers take precedence over same-named context properties", function() {
   equals(result, "GOODBYE cruel WORLD", "Helper executed");
 });
 
-test("helpers take precedence over same-named context properties", function() {
+test("helpers take precedence over same-named context properties$", function() {
   var template = CompilerContext.compile("{{#goodbye}} {{cruel world}}{{/goodbye}}");
 
   var helpers = {
-    goodbye: function(fn) {
-      return this.goodbye.toUpperCase() + fn(this);
-    }
-  };
+    goodbye: function(options) {
+      return this.goodbye.toUpperCase() + options.fn(this);
+    },
 
-  var context = {
     cruel: function(world) {
       return "cruel " + world.toUpperCase();
-    },
+    }
+  };
 
+  var context = {
     goodbye: "goodbye",
     world: "world"
   };
@@ -820,14 +1050,14 @@ test("Scoped names take precedence over helpers", function() {
   var helpers = {
     goodbye: function() {
       return this.goodbye.toUpperCase();
-    }
-  };
+    },
 
-  var context = {
     cruel: function(world) {
       return "cruel " + world.toUpperCase();
     },
+  };
 
+  var context = {
     goodbye: "goodbye",
     world: "world"
   };
@@ -840,16 +1070,16 @@ test("Scoped names take precedence over block helpers", function() {
   var template = CompilerContext.compile("{{#goodbye}} {{cruel world}}{{/goodbye}} {{this.goodbye}}");
 
   var helpers = {
-    goodbye: function(fn) {
-      return this.goodbye.toUpperCase() + fn(this);
-    }
-  };
+    goodbye: function(options) {
+      return this.goodbye.toUpperCase() + options.fn(this);
+    },
 
-  var context = {
     cruel: function(world) {
       return "cruel " + world.toUpperCase();
     },
+  };
 
+  var context = {
     goodbye: "goodbye",
     world: "world"
   };
@@ -892,8 +1122,8 @@ test("helpers can take an optional hash with booleans", function() {
   var result = template(context, {helpers: helpers});
   equals(result, "GOODBYE CRUEL WORLD", "Helper output hash");
 
-  var template = CompilerContext.compile('{{goodbye cruel="CRUEL" world="WORLD" print=false}}');
-  var result = template(context, {helpers: helpers});
+  template = CompilerContext.compile('{{goodbye cruel="CRUEL" world="WORLD" print=false}}');
+  result = template(context, {helpers: helpers});
   equals(result, "NOT PRINTING", "Boolean helper parameter honored");
 });
 
@@ -910,6 +1140,19 @@ test("block helpers can take an optional hash", function() {
   equals(result, "GOODBYE CRUEL world 12 TIMES", "Hash parameters output");
 });
 
+test("block helpers can take an optional hash with single quoted stings", function() {
+  var template = CompilerContext.compile("{{#goodbye cruel='CRUEL' times=12}}world{{/goodbye}}");
+
+  var helpers = {
+    goodbye: function(options) {
+      return "GOODBYE " + options.hash.cruel + " " + options.fn(this) + " " + options.hash.times + " TIMES";
+    }
+  };
+
+  var result = template({}, {helpers: helpers});
+  equals(result, "GOODBYE CRUEL world 12 TIMES", "Hash parameters output");
+});
+
 test("block helpers can take an optional hash with booleans", function() {
   var helpers = {
     goodbye: function(options) {
@@ -927,8 +1170,8 @@ test("block helpers can take an optional hash with booleans", function() {
   var result = template({}, {helpers: helpers});
   equals(result, "GOODBYE CRUEL world", "Boolean hash parameter honored");
 
-  var template = CompilerContext.compile('{{#goodbye cruel="CRUEL" print=false}}world{{/goodbye}}');
-  var result = template({}, {helpers: helpers});
+  template = CompilerContext.compile('{{#goodbye cruel="CRUEL" print=false}}world{{/goodbye}}');
+  result = template({}, {helpers: helpers});
   equals(result, "NOT PRINTING", "Boolean hash parameter honored");
 });
 
@@ -937,7 +1180,7 @@ test("arguments to helpers can be retrieved from options hash in string form", f
   var template = CompilerContext.compile('{{wycats is.a slave.driver}}', {stringParams: true});
 
   var helpers = {
-    wycats: function(passiveVoice, noun, options) {
+    wycats: function(passiveVoice, noun) {
       return "HELP ME MY BOSS " + passiveVoice + ' ' + noun;
     }
   };
@@ -985,6 +1228,48 @@ test("when inside a block in String mode, .. passes the appropriate context in t
   equals(result, "STOP ME FROM READING HACKER NEWS I need-a dad.joke", "Proper context variable output");
 });
 
+test("in string mode, information about the types is passed along", function() {
+  var template = CompilerContext.compile('{{tomdale "need" dad.joke true false}}', { stringParams: true });
+
+  var helpers = {
+    tomdale: function(desire, noun, trueBool, falseBool, options) {
+      equal(options.types[0], 'STRING', "the string type is passed");
+      equal(options.types[1], 'ID', "the expression type is passed");
+      equal(options.types[2], 'BOOLEAN', "the expression type is passed");
+      equal(desire, "need", "the string form is passed for strings");
+      equal(noun, "dad.joke", "the string form is passed for expressions");
+      equal(trueBool, true, "raw booleans are passed through");
+      equal(falseBool, false, "raw booleans are passed through");
+      return "Helper called";
+    }
+  };
+
+  var result = template({}, { helpers: helpers });
+  equal(result, "Helper called");
+});
+
+test("in string mode, hash parameters get type information", function() {
+  var template = CompilerContext.compile('{{tomdale he.says desire="need" noun=dad.joke bool=true}}', { stringParams: true });
+
+  var helpers = {
+    tomdale: function(exclamation, options) {
+      equal(exclamation, "he.says");
+      equal(options.types[0], "ID");
+
+      equal(options.hashTypes.desire, "STRING");
+      equal(options.hashTypes.noun, "ID");
+      equal(options.hashTypes.bool, "BOOLEAN");
+      equal(options.hash.desire, "need");
+      equal(options.hash.noun, "dad.joke");
+      equal(options.hash.bool, true);
+      return "Helper called";
+    }
+  };
+
+  var result = template({}, { helpers: helpers });
+  equal(result, "Helper called");
+});
+
 test("when inside a block in String mode, .. passes the appropriate context in the options hash to a block helper", function() {
   var template = CompilerContext.compile('{{#with dale}}{{#tomdale ../need dad.joke}}wot{{/tomdale}}{{/with}}', {stringParams: true});
 
@@ -1009,7 +1294,7 @@ test("when inside a block in String mode, .. passes the appropriate context in t
   equals(result, "STOP ME FROM READING HACKER NEWS I need-a dad.joke wot", "Proper context variable output");
 });
 
-module("Regressions")
+suite("Regressions");
 
 test("GH-94: Cannot read property of undefined", function() {
 	var data = {"books":[{"title":"The origin of species","author":{"name":"Charles Darwin"}},{"title":"Lazarillo de Tormes"}]};
@@ -1028,13 +1313,13 @@ test("GH-150: Inverted sections print when they shouldn't", function() {
 });
 
 test("Mustache man page", function() {
-  var string = "Hello {{name}}. You have just won ${{value}}!{{#in_ca}} Well, ${{taxed_value}}, after taxes.{{/in_ca}}"
+  var string = "Hello {{name}}. You have just won ${{value}}!{{#in_ca}} Well, ${{taxed_value}}, after taxes.{{/in_ca}}";
   var data = {
     "name": "Chris",
     "value": 10000,
     "taxed_value": 10000 - (10000 * 0.4),
     "in_ca": true
-  }
+  };
 
   shouldCompileTo(string, data, "Hello Chris. You have just won $10000! Well, $6000, after taxes.", "the hello world mustache example works");
 });
@@ -1065,3 +1350,21 @@ test("bug reported by @fat where lambdas weren't being properly resolved", funct
   var output = "<strong>This is a slightly more complicated blah.</strong>.\n\nCheck this out:\n\n<ul>\n\n<li class=one>@fat</li>\n\n<li class=two>@dhg</li>\n\n<li class=three>@sayrer</li>\n</ul>.\n\n";
   shouldCompileTo(string, data, output);
 });
+
+test("Passing falsy values to Handlebars.compile throws an error", function() {
+  shouldThrow(function() {
+    CompilerContext.compile(null);
+  }, "You must pass a string or Handlebars AST to Handlebars.compile. You passed null");
+});
+
+test('GH-408: Multiple loops fail', function() {
+  var context = [
+    { name: "John Doe", location: { city: "Chicago" } },
+    { name: "Jane Doe", location: { city: "New York"} }
+  ];
+
+  var template = CompilerContext.compile('{{#.}}{{name}}{{/.}}{{#.}}{{name}}{{/.}}{{#.}}{{name}}{{/.}}');
+
+  var result = template(context);
+  equals(result, "John DoeJane DoeJohn DoeJane DoeJohn DoeJane Doe", 'It should output multiple times');
+});