handlebars 0.3.2 → 0.4.0

data/vendor/handlebars/lib/handlebars/compiler/printer.js

@@ -18,31 +18,17 @@ Handlebars.PrintVisitor.prototype.pad = function(string, newline) {
 };
 
 Handlebars.PrintVisitor.prototype.program = function(program) {
-  var out = this.pad("PROGRAM:"),
+  var out = "",
       statements = program.statements,
       inverse = program.inverse,
       i, l;
 
-  this.padding++;
-
   for(i=0, l=statements.length; i<l; i++) {
     out = out + this.accept(statements[i]);
   }
 
   this.padding--;
 
-  if(inverse) {
-    out = out + this.pad("{{^}}");
-
-    this.padding++;
-
-    for(i=0, l=inverse.statements.length; i<l; i++) {
-      out = out + this.accept(inverse.statements[i]);
-    }
-  }
-
-  this.padding--;
-
   return out;
 };
 
@@ -52,25 +38,25 @@ Handlebars.PrintVisitor.prototype.block = function(block) {
   out = out + this.pad("BLOCK:");
   this.padding++;
   out = out + this.accept(block.mustache);
-  out = out + this.accept(block.program);
-  this.padding--;
-
-  return out;
-};
-
-Handlebars.PrintVisitor.prototype.inverse = function(block) {
-  var out = "";
-
-  out = out + this.pad("INVERSE:");
-  this.padding++;
-  out = out + this.accept(block.mustache);
-  out = out + this.accept(block.program);
+  if (block.program) {
+    out = out + this.pad("PROGRAM:");
+    this.padding++;
+    out = out + this.accept(block.program);
+    this.padding--;
+  }
+  if (block.inverse) {
+    if (block.program) { this.padding++; }
+    out = out + this.pad("{{^}}");
+    this.padding++;
+    out = out + this.accept(block.inverse);
+    this.padding--;
+    if (block.program) { this.padding--; }
+  }
   this.padding--;
 
   return out;
 };
 
-
 Handlebars.PrintVisitor.prototype.mustache = function(mustache) {
   var params = mustache.params, paramStrings = [], hash;
 
@@ -86,7 +72,7 @@ Handlebars.PrintVisitor.prototype.mustache = function(mustache) {
 };
 
 Handlebars.PrintVisitor.prototype.partial = function(partial) {
-  var content = this.accept(partial.id);
+  var content = this.accept(partial.partialName);
   if(partial.context) { content = content + " " + this.accept(partial.context); }
   return this.pad("{{> " + content + " }}");
 };
@@ -125,6 +111,14 @@ Handlebars.PrintVisitor.prototype.ID = function(id) {
   }
 };
 
+Handlebars.PrintVisitor.prototype.PARTIAL_NAME = function(partialName) {
+    return "PARTIAL:" + partialName.name;
+};
+
+Handlebars.PrintVisitor.prototype.DATA = function(data) {
+  return "@" + data.id;
+};
+
 Handlebars.PrintVisitor.prototype.content = function(content) {
   return this.pad("CONTENT[ '" + content.string + "' ]");
 };

data/vendor/handlebars/lib/handlebars/runtime.js

@@ -20,12 +20,32 @@ Handlebars.VM = {
         }
       },
       programWithDepth: Handlebars.VM.programWithDepth,
-      noop: Handlebars.VM.noop
+      noop: Handlebars.VM.noop,
+      compilerInfo: null
     };
 
     return function(context, options) {
       options = options || {};
-      return templateSpec.call(container, Handlebars, context, options.helpers, options.partials, options.data);
+      var result = templateSpec.call(container, Handlebars, context, options.helpers, options.partials, options.data);
+
+      var compilerInfo = container.compilerInfo || [],
+          compilerRevision = compilerInfo[0] || 1,
+          currentRevision = Handlebars.COMPILER_REVISION;
+
+      if (compilerRevision !== currentRevision) {
+        if (compilerRevision < currentRevision) {
+          var runtimeVersions = Handlebars.REVISION_CHANGES[currentRevision],
+              compilerVersions = Handlebars.REVISION_CHANGES[compilerRevision];
+          throw "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 "Template was precompiled with a newer version of Handlebars than the current runtime. "+
+                "Please update your runtime to a newer version ("+compilerInfo[1]+").";
+        }
+      }
+
+      return result;
     };
   },
 
@@ -56,7 +76,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);
     }
   }

data/vendor/handlebars/lib/handlebars/utils.js

@@ -1,14 +1,16 @@
 var Handlebars = require("./base");
 
 // BEGIN(BROWSER)
+
+var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack'];
+
 Handlebars.Exception = function(message) {
   var tmp = Error.prototype.constructor.apply(this, arguments);
 
-  for (var p in tmp) {
-    if (tmp.hasOwnProperty(p)) { this[p] = tmp[p]; }
+  // 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]];
   }
-
-  this.message = tmp.message;
 };
 Handlebars.Exception.prototype = new Error();
 
@@ -22,6 +24,7 @@ Handlebars.SafeString.prototype.toString = function() {
 
 (function() {
   var escape = {
+    "&": "&amp;",
     "<": "&lt;",
     ">": "&gt;",
     '"': "&quot;",
@@ -29,7 +32,7 @@ Handlebars.SafeString.prototype.toString = function() {
     "`": "&#x60;"
   };
 
-  var badChars = /&(?!\w+;)|[<>"'`]/g;
+  var badChars = /[&<>"'`]/g;
   var possible = /[&<>"'`]/;
 
   var escapeChar = function(chr) {
@@ -50,11 +53,7 @@ Handlebars.SafeString.prototype.toString = function() {
     },
 
     isEmpty: function(value) {
-      if (typeof value === "undefined") {
-        return true;
-      } else if (value === null) {
-        return true;
-      } else if (value === false) {
+      if (!value && value !== 0) {
         return true;
       } else if(Object.prototype.toString.call(value) === "[object Array]" && value.length === 0) {
         return true;

data/vendor/handlebars/package.json

@@ -1,14 +1,14 @@
 {
   "name": "handlebars",
   "description": "Extension of the Mustache logicless template language",
-  "version": "1.0.5beta",
+  "version": "1.0.8",
   "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"
@@ -17,9 +17,19 @@
     "optimist": "~0.3",
     "uglify-js": "~1.2"
   },
-  "devDependencies": {},
+  "devDependencies": {
+    "benchmark": "~1.0",
+    "dust": "~0.3",
+    "jison": "~0.3",
+    "mocha": "*",
+    "mustache": "~0.7.2"
+  },
   "main": "lib/handlebars.js",
   "bin": {
     "handlebars": "bin/handlebars"
-  }
-}
+  },
+  "scripts": {
+    "test": "node_modules/.bin/mocha -u qunit spec/qunit_spec.js"
+  },
+  "optionalDependencies": {}
+}

data/vendor/handlebars/spec/acceptance_spec.rb

@@ -39,11 +39,11 @@ Module.new do
     end
   end
 
-  js_context["p"] = proc do |str|
+  js_context["p"] = proc do |this, str|
     p str
   end
 
-  js_context["ok"] = proc do |ok, message|
+  js_context["ok"] = proc do |this, ok, message|
     js_context["$$RSPEC1$$"] = ok
 
     result = js_context.eval("!!$$RSPEC1$$")
@@ -58,7 +58,7 @@ Module.new do
     assert result, message
   end
 
-  js_context["equals"] = proc do |first, second, message|
+  js_context["equals"] = proc do |this, first, second, message|
     js_context["$$RSPEC1$$"] = first
     js_context["$$RSPEC2$$"] = second
 
@@ -77,11 +77,11 @@ Module.new do
 
   js_context["equal"] = js_context["equals"]
 
-  js_context["module"] = proc do |name|
+  js_context["suite"] = proc do |this, name|
     test_context.module(name)
   end
 
-  js_context["test"] = proc do |name, function|
+  js_context["test"] = proc do |this, name, function|
     test_context.test(name, function)
   end
 

data/vendor/handlebars/spec/parser_spec.rb

@@ -7,11 +7,9 @@ describe "Parser" do
     @compiles = true
   end
 
-  def program(&block)
+  def root(&block)
     ASTBuilder.build do
-      program do
-        instance_eval(&block)
-      end
+      instance_eval(&block)
     end
   end
 
@@ -112,115 +110,143 @@ describe "Parser" do
       "ID:#{id}"
     end
 
+    def data(id)
+      "@#{id}"
+    end
+
+    def partial_name(name)
+      "PARTIAL:#{name}"
+    end
+
     def path(*parts)
       "PATH:#{parts.join("/")}"
     end
   end
 
   it "parses simple mustaches" do
-    ast_for("{{foo}}").should == program { mustache id("foo") }
+    ast_for("{{foo}}").should == root { mustache id("foo") }
+  end
+
+  it "parses simple mustaches with data" do
+    ast_for("{{@foo}}").should == root { mustache data("foo") }
   end
 
   it "parses mustaches with paths" do
-    ast_for("{{foo/bar}}").should == program { mustache path("foo", "bar") }
+    ast_for("{{foo/bar}}").should == root { mustache path("foo", "bar") }
   end
 
   it "parses mustaches with this/foo" do
-    ast_for("{{this/foo}}").should == program { mustache id("foo") }
+    ast_for("{{this/foo}}").should == root { mustache id("foo") }
   end
 
   it "parses mustaches with - in a path" do
-    ast_for("{{foo-bar}}").should == program { mustache id("foo-bar") }
+    ast_for("{{foo-bar}}").should == root { mustache id("foo-bar") }
   end
 
   it "parses mustaches with parameters" do
-    ast_for("{{foo bar}}").should == program { mustache id("foo"), [id("bar")] }
+    ast_for("{{foo bar}}").should == root { mustache id("foo"), [id("bar")] }
   end
 
   it "parses mustaches with hash arguments" do
-    ast_for("{{foo bar=baz}}").should == program do
+    ast_for("{{foo bar=baz}}").should == root do
       mustache id("foo"), [], hash(["bar", id("baz")])
     end
 
-    ast_for("{{foo bar=1}}").should == program do
+    ast_for("{{foo bar=1}}").should == root do
       mustache id("foo"), [], hash(["bar", integer("1")])
     end
 
-    ast_for("{{foo bar=true}}").should == program do
+    ast_for("{{foo bar=true}}").should == root do
       mustache id("foo"), [], hash(["bar", boolean("true")])
     end
 
-    ast_for("{{foo bar=false}}").should == program do
+    ast_for("{{foo bar=false}}").should == root do
       mustache id("foo"), [], hash(["bar", boolean("false")])
     end
 
-    ast_for("{{foo bar=baz bat=bam}}").should == program do
+    ast_for("{{foo bar=@baz}}").should == root do
+      mustache id("foo"), [], hash(["bar", data("baz")])
+    end
+
+    ast_for("{{foo bar=baz bat=bam}}").should == root do
       mustache id("foo"), [], hash(["bar", "ID:baz"], ["bat", "ID:bam"])
     end
 
-    ast_for("{{foo bar=baz bat=\"bam\"}}").should == program do
+    ast_for("{{foo bar=baz bat=\"bam\"}}").should == root do
       mustache id("foo"), [], hash(["bar", "ID:baz"], ["bat", "\"bam\""])
     end
 
-    ast_for("{{foo omg bar=baz bat=\"bam\"}}").should == program do
+    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
 
-    ast_for("{{foo omg bar=baz bat=\"bam\" baz=1}}").should == program do
+    ast_for("{{foo omg bar=baz bat=\"bam\" baz=1}}").should == root do
       mustache id("foo"), [id("omg")], hash(["bar", id("baz")], ["bat", string("bam")], ["baz", integer("1")])
     end
 
-    ast_for("{{foo omg bar=baz bat=\"bam\" baz=true}}").should == program do
+    ast_for("{{foo omg bar=baz bat=\"bam\" baz=true}}").should == root do
       mustache id("foo"), [id("omg")], hash(["bar", id("baz")], ["bat", string("bam")], ["baz", boolean("true")])
     end
 
-    ast_for("{{foo omg bar=baz bat=\"bam\" baz=false}}").should == program do
+    ast_for("{{foo omg bar=baz bat=\"bam\" baz=false}}").should == root do
       mustache id("foo"), [id("omg")], hash(["bar", id("baz")], ["bat", string("bam")], ["baz", boolean("false")])
     end
   end
 
   it "parses mustaches with string parameters" do
-    ast_for("{{foo bar \"baz\" }}").should == program { mustache id("foo"), [id("bar"), string("baz")] }
+    ast_for("{{foo bar \"baz\" }}").should == root { mustache id("foo"), [id("bar"), string("baz")] }
   end
 
   it "parses mustaches with INTEGER parameters" do
-    ast_for("{{foo 1}}").should == program { mustache id("foo"), [integer("1")] }
+    ast_for("{{foo 1}}").should == root { mustache id("foo"), [integer("1")] }
   end
 
   it "parses mustaches with BOOLEAN parameters" do
-    ast_for("{{foo true}}").should == program { mustache id("foo"), [boolean("true")] }
-    ast_for("{{foo false}}").should == program { mustache id("foo"), [boolean("false")] }
+    ast_for("{{foo true}}").should == root { mustache id("foo"), [boolean("true")] }
+    ast_for("{{foo false}}").should == root { mustache id("foo"), [boolean("false")] }
+  end
+
+  it "parses mutaches with DATA parameters" do
+    ast_for("{{foo @bar}}").should == root { mustache id("foo"), [data("bar")] }
   end
 
   it "parses contents followed by a mustache" do
-    ast_for("foo bar {{baz}}").should == program do
+    ast_for("foo bar {{baz}}").should == root do
       content "foo bar "
       mustache id("baz")
     end
   end
 
   it "parses a partial" do
-    ast_for("{{> foo }}").should == program { partial id("foo") }
+    ast_for("{{> foo }}").should == root { partial partial_name("foo") }
   end
 
   it "parses a partial with context" do
-    ast_for("{{> foo bar}}").should == program { partial id("foo"), id("bar") }
+    ast_for("{{> foo bar}}").should == root { partial partial_name("foo"), id("bar") }
+  end
+
+  it "parses a partial with a complex name" do
+    ast_for("{{> shared/partial}}").should == root { partial partial_name("shared/partial") }
   end
 
   it "parses a comment" do
-    ast_for("{{! this is a comment }}").should == program do
+    ast_for("{{! this is a comment }}").should == root do
       comment " this is a comment "
     end
   end
 
   it "parses a multi-line comment" do
-    ast_for("{{!\nthis is a multi-line comment\n}}").should == program do
+    ast_for("{{!\nthis is a multi-line comment\n}}").should == root do
       multiline_comment "this is a multi-line comment"
     end
   end
 
   it "parses an inverse section" do
-    ast_for("{{#foo}} bar {{^}} baz {{/foo}}").should == program do
+    ast_for("{{#foo}} bar {{^}} baz {{/foo}}").should == root do
       block do
         mustache id("foo")
 
@@ -235,12 +261,136 @@ describe "Parser" do
     end
   end
 
-  it "parses a standalone inverse section" do
-    ast_for("{{^foo}}bar{{/foo}}").should == program do
-      inverted_block do
+  it "parses an inverse ('else'-style) section" do
+    ast_for("{{#foo}} bar {{else}} baz {{/foo}}").should == root do
+      block do
+        mustache id("foo")
+
+        program do
+          content " bar "
+        end
+
+        inverse do
+          content " baz "
+        end
+      end
+    end
+  end
+
+  it "parses empty blocks" do
+    ast_for("{{#foo}}{{/foo}}").should == root do
+      block do
         mustache id("foo")
 
         program do
+          #  empty program
+        end
+      end
+    end
+  end
+
+  it "parses empty blocks with empty inverse section" do
+    ast_for("{{#foo}}{{^}}{{/foo}}").should == root do
+      block do
+        mustache id("foo")
+
+        program do
+          #  empty program
+        end
+
+        inverse do
+          #  empty inverse
+        end
+      end
+    end
+  end
+
+  it "parses empty blocks with empty inverse ('else'-style) section" do
+    ast_for("{{#foo}}{{else}}{{/foo}}").should == root do
+      block do
+        mustache id("foo")
+
+        program do
+          #  empty program
+        end
+
+        inverse do
+          #  empty inverse
+        end
+      end
+    end
+  end
+
+  it "parses non-empty blocks with empty inverse section" do
+    ast_for("{{#foo}} bar {{^}}{{/foo}}").should == root do
+      block do
+        mustache id("foo")
+
+        program do
+          content " bar "
+        end
+
+        inverse do
+          #  empty inverse
+        end
+      end
+    end
+  end
+
+  it "parses non-empty blocks with empty inverse ('else'-style) section" do
+    ast_for("{{#foo}} bar {{else}}{{/foo}}").should == root do
+      block do
+        mustache id("foo")
+
+        program do
+          content " bar "
+        end
+
+        inverse do
+          #  empty inverse
+        end
+      end
+    end
+  end
+
+  it "parses empty blocks with non-empty inverse section" do
+    ast_for("{{#foo}}{{^}} bar {{/foo}}").should == root do
+      block do
+        mustache id("foo")
+
+        program do
+          #  empty program
+        end
+
+        inverse do
+          content " bar "
+        end
+      end
+    end
+  end
+
+  it "parses empty blocks with non-empty inverse ('else'-style) section" do
+    ast_for("{{#foo}}{{else}} bar {{/foo}}").should == root do
+      block do
+        mustache id("foo")
+
+        program do
+          #  empty program
+        end
+
+        inverse do
+          content " bar "
+        end
+      end
+    end
+  end
+
+  it "parses a standalone inverse section" do
+    ast_for("{{^foo}}bar{{/foo}}").should == root do
+      block do
+        mustache id("foo")
+
+        inverse do
           content "bar"
         end
       end
@@ -261,4 +411,23 @@ describe "Parser" do
   it "knows how to report the correct line number in errors when the first character is a newline" do
     lambda { ast_for("\n\nhello\n\nmy\n\n{{foo}") }.should raise_error(V8::JSError, /Parse error on line 7/m)
   end
+
+  context "externally compiled AST" do
+
+    it "can pass through an already-compiled AST" do
+      ast_for(@context.eval('new Handlebars.AST.ProgramNode([ new Handlebars.AST.ContentNode("Hello")]);')).should == root do
+        content "Hello"
+      end
+    end
+
+    it "can pass through an already-compiled AST via compile/precompile" do
+      @context = Handlebars::Spec::FULL_CONTEXT
+
+      code = 'Handlebars.compile(new Handlebars.AST.ProgramNode([ new Handlebars.AST.ContentNode("Hello")]))();'
+      @context.eval(code).should == "Hello"
+
+      code = @context.eval 'Handlebars.precompile(new Handlebars.AST.ProgramNode([ new Handlebars.AST.ContentNode("Hello")]))'
+      @context.eval("(#{code})(this)").should == "Hello"
+    end
+  end
 end