Bumped package.json version

properly handle ampersands when HTML escaping

.gitignore

@@ -6,3 +6,4 @@ lib/handlebars/compiler/parser.js
 node_modules
 *.sublime-project
 *.sublime-workspace
+npm-debug.log

Rakefile

@@ -2,7 +2,7 @@ require "rubygems"
 require "bundler/setup"
 
 def compile_parser
-  system "jison src/handlebars.yy src/handlebars.l"
+  system "./node_modules/jison/lib/jison/cli-wrapper.js src/handlebars.yy src/handlebars.l"
   if $?.success?
     File.open("lib/handlebars/compiler/parser.js", "w") do |file|
       file.puts File.read("handlebars.js") + ";"
@@ -15,11 +15,11 @@ def compile_parser
 end
 
 file "lib/handlebars/compiler/parser.js" => ["src/handlebars.yy","src/handlebars.l"] do
-  if ENV['PATH'].split(':').any? {|folder| File.exists?(folder+'/jison')}
+  if File.exists?('./node_modules/jison/lib/jison/cli-wrapper.js')
     compile_parser
   else
     puts "Jison is not installed. Trying `npm install jison`."
-    sh "npm install jison -g"
+    sh "npm install jison"
     compile_parser
   end
 end
@@ -28,7 +28,8 @@ task :compile => "lib/handlebars/compiler/parser.js"
 
 desc "run the spec suite"
 task :spec => [:release] do
-  system "rspec -cfs spec"
+  rc = system "rspec -cfs spec"
+  fail "rspec spec failed with exit code #{$?.exitstatus}" if (rc.nil? || ! rc || $?.exitstatus != 0)
 end
 
 task :default => [:compile, :spec]

bin/handlebars

@@ -7,6 +7,17 @@ var optimist = require('optimist')
         'description': 'Output File',
         'alias': 'output'
       },
+      'a': {
+        'type': 'boolean',
+        'description': 'Exports amd style (require.js)',
+        'alias': 'amd'
+      },
+      'h': {
+        'type': 'string',
+        'description': 'Path to handlebar.js (only valid for amd-style)',
+        'alias': 'handlebarPath',
+		'default': ''
+      },
       'k': {
         'type': 'string',
         'description': 'Known helpers',
@@ -78,7 +89,12 @@ if (argv.known) {
 
 var output = [];
 if (!argv.simple) {
-  output.push('(function() {\n  var template = Handlebars.template, templates = Handlebars.templates = Handlebars.templates || {};\n');
+  if (argv.amd) {
+    output.push('define([\'' + argv.handlebarPath + 'handlebars\'], function(Handlebars) {\n');
+  } else {
+    output.push('(function() {\n');
+  }
+  output.push('  var template = Handlebars.template, templates = Handlebars.templates = Handlebars.templates || {};\n');
 }
 function processTemplate(template, root) {
   var path = template,
@@ -121,7 +137,11 @@ argv._.forEach(function(template) {
 
 // Output the content
 if (!argv.simple) {
-  output.push('})();');
+  if (argv.amd) {
+    output.push('});');
+  } else {
+    output.push('})();');
+  }
 }
 output = output.join('');
 

lib/handlebars/base.js

@@ -44,13 +44,10 @@ Handlebars.registerHelper('blockHelperMissing', function(context, options) {
     return inverse(this);
   } else if(type === "[object Array]") {
     if(context.length > 0) {
-      for(var i=0, j=context.length; i<j; i++) {
-        ret = ret + fn(context[i]);
-      }
+      return Handlebars.helpers.each(context, options);
     } else {
-      ret = inverse(this);
+      return inverse(this);
     }
-    return ret;
   } else {
     return fn(context);
   }

lib/handlebars/compiler/compiler.js

@@ -240,7 +240,13 @@ Handlebars.JavaScriptCompiler = function() {};
     ID: function(id) {
       this.addDepth(id.depth);
       this.opcode('getContext', id.depth);
-      this.opcode('lookupOnContext', id.parts[0]);
+
+      var name = id.parts[0];
+      if (!name) {
+        this.opcode('pushContext');
+      } else {
+        this.opcode('lookupOnContext', id.parts[0]);
+      }
 
       for(var i=1, l=id.parts.length; i<l; i++) {
         this.opcode('lookup', id.parts[i]);

lib/handlebars/runtime.js

@@ -56,7 +56,7 @@ Handlebars.VM = {
     } else if (!Handlebars.compile) {
       throw new Handlebars.Exception("The partial " + name + " could not be compiled when running in runtime-only mode");
     } else {
-      partials[name] = Handlebars.compile(partial);
+      partials[name] = Handlebars.compile(partial, {data: data !== undefined});
       return partials[name](context, options);
     }
   }

lib/handlebars/utils.js

@@ -22,6 +22,7 @@ Handlebars.SafeString.prototype.toString = function() {
 
 (function() {
   var escape = {
+    "&": "&",
     "<": "&lt;",
     ">": "&gt;",
     '"': "&quot;",
@@ -29,7 +30,7 @@ Handlebars.SafeString.prototype.toString = function() {
     "`": "&#x60;"
   };
 
-  var badChars = /&(?!\w+;)|[<>"'`]/g;
+  var badChars = /[&<>"'`]/g;
   var possible = /[&<>"'`]/;
 
   var escapeChar = function(chr) {

package.json

@@ -1,14 +1,14 @@
 {
   "name": "handlebars",
   "description": "Extension of the Mustache logicless template language",
-  "version": "1.0.6",
+  "version": "1.0.0-rc.1",
   "homepage": "http://www.handlebarsjs.com/",
   "keywords": [
     "handlebars mustache template html"
   ],
   "repository": {
     "type": "git",
-    "url": "git://github.com/kpdecker/handlebars.js.git"
+    "url": "git://github.com/wycats/handlebars.js.git"
   },
   "engines": {
     "node": ">=0.4.7"

spec/parser_spec.rb

@@ -172,6 +172,10 @@ describe "Parser" do
       mustache id("foo"), [], hash(["bar", "ID:baz"], ["bat", "\"bam\""])
     end
 
+    ast_for("{{foo bat='bam'}}").should == root do
+      mustache id("foo"), [], hash(["bat", "\"bam\""])
+    end
+
     ast_for("{{foo omg bar=baz bat=\"bam\"}}").should == root do
       mustache id("foo"), [id("omg")], hash(["bar", id("baz")], ["bat", string("bam")])
     end

spec/qunit_spec.js

@@ -123,6 +123,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() {
@@ -138,6 +140,8 @@ test("functions", function() {
 
 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() {
@@ -187,6 +191,20 @@ test("this keyword in paths", function() {
   shouldCompileTo(string, hash, "helloHelloHELLO", "This keyword evaluates in more complex paths");
 });
 
+test("this keyword in helpers", function() {
+  var helpers = {foo: function(value, options) {
+      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");
+});
+
 suite("inverted sections");
 
 test("inverted sections with unset value", function() {
@@ -220,6 +238,16 @@ 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 hash     = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}], world: "world"};
@@ -1002,6 +1030,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) {

spec/tokenizer_spec.rb

@@ -51,6 +51,15 @@ describe "Tokenizer" do
     result[4].should be_token("CONTENT", "{{bar}} ")
   end
 
+  it "supports escaping multiple delimiters" do
+    result = tokenize("{{foo}} \\{{bar}} \\{{baz}}")
+    result.should match_tokens(%w(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}}")
+  end
+
   it "supports escaping a triple stash" do
     result = tokenize("{{foo}} \\{{{bar}}} {{baz}}")
     result.should match_tokens(%w(OPEN ID CLOSE CONTENT CONTENT OPEN ID CLOSE))

src/handlebars.l

@@ -11,7 +11,11 @@
 
 [^\x00]+                         { return 'CONTENT'; }
 
-<emu>[^\x00]{2,}?/("{{")         { this.popState(); return 'CONTENT'; }
+<emu>[^\x00]{2,}?/("{{"|<<EOF>>) {
+                                   if(yytext.slice(-1) !== "\\") this.popState();
+                                   if(yytext.slice(-1) === "\\") yytext = yytext.substr(0,yyleng-1);
+                                   return 'CONTENT';
+                                 }
 
 <mu>"{{>"                        { return 'OPEN_PARTIAL'; }
 <mu>"{{#"                        { return 'OPEN_BLOCK'; }
@@ -31,6 +35,7 @@
 <mu>"}}}"                        { this.popState(); return 'CLOSE'; }
 <mu>"}}"                         { this.popState(); return 'CLOSE'; }
 <mu>'"'("\\"["]|[^"])*'"'        { yytext = yytext.substr(1,yyleng-2).replace(/\\"/g,'"'); return 'STRING'; }
+<mu>"'"("\\"[']|[^'])*"'"        { yytext = yytext.substr(1,yyleng-2).replace(/\\"/g,'"'); return 'STRING'; }
 <mu>"@"[a-zA-Z]+                 { yytext = yytext.substr(1); return 'DATA'; }
 <mu>"true"/[}\s]                 { return 'BOOLEAN'; }
 <mu>"false"/[}\s]                { return 'BOOLEAN'; }