handlebars 0.0.2 → 0.2.0

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

@@ -0,0 +1,7 @@
+// Each of these module will augment the Handlebars object as it loads. No need to perform addition operations
+module.exports = require("./base");
+require("./visitor");
+require("./printer");
+
+require("./ast");
+require("./compiler");

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

@@ -0,0 +1,137 @@
+var Handlebars = require("./base");
+
+// BEGIN(BROWSER)
+Handlebars.PrintVisitor = function() { this.padding = 0; };
+Handlebars.PrintVisitor.prototype = new Handlebars.Visitor();
+
+Handlebars.PrintVisitor.prototype.pad = function(string, newline) {
+  var out = "";
+
+  for(var i=0,l=this.padding; i<l; i++) {
+    out = out + "  ";
+  }
+
+  out = out + string;
+
+  if(newline !== false) { out = out + "\n"; }
+  return out;
+};
+
+Handlebars.PrintVisitor.prototype.program = function(program) {
+  var out = this.pad("PROGRAM:"),
+      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;
+};
+
+Handlebars.PrintVisitor.prototype.block = function(block) {
+  var out = "";
+
+  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);
+  this.padding--;
+
+  return out;
+};
+
+
+Handlebars.PrintVisitor.prototype.mustache = function(mustache) {
+  var params = mustache.params, paramStrings = [], hash;
+
+  for(var i=0, l=params.length; i<l; i++) {
+    paramStrings.push(this.accept(params[i]));
+  }
+
+  params = "[" + paramStrings.join(", ") + "]";
+
+  hash = mustache.hash ? " " + this.accept(mustache.hash) : "";
+
+  return this.pad("{{ " + this.accept(mustache.id) + " " + params + hash + " }}");
+};
+
+Handlebars.PrintVisitor.prototype.partial = function(partial) {
+  var content = this.accept(partial.id);
+  if(partial.context) { content = content + " " + this.accept(partial.context); }
+  return this.pad("{{> " + content + " }}");
+};
+
+Handlebars.PrintVisitor.prototype.hash = function(hash) {
+  var pairs = hash.pairs;
+  var joinedPairs = [], left, right;
+
+  for(var i=0, l=pairs.length; i<l; i++) {
+    left = pairs[i][0];
+    right = this.accept(pairs[i][1]);
+    joinedPairs.push( left + "=" + right );
+  }
+
+  return "HASH{" + joinedPairs.join(", ") + "}";
+};
+
+Handlebars.PrintVisitor.prototype.STRING = function(string) {
+  return '"' + string.string + '"';
+};
+
+Handlebars.PrintVisitor.prototype.INTEGER = function(integer) {
+  return "INTEGER{" + integer.integer + "}";
+};
+
+Handlebars.PrintVisitor.prototype.BOOLEAN = function(bool) {
+  return "BOOLEAN{" + bool.bool + "}";
+};
+
+Handlebars.PrintVisitor.prototype.ID = function(id) {
+  var path = id.parts.join("/");
+  if(id.parts.length > 1) {
+    return "PATH:" + path;
+  } else {
+    return "ID:" + path;
+  }
+};
+
+Handlebars.PrintVisitor.prototype.content = function(content) {
+  return this.pad("CONTENT[ '" + content.string + "' ]");
+};
+
+Handlebars.PrintVisitor.prototype.comment = function(comment) {
+  return this.pad("{{! '" + comment.comment + "' }}");
+};
+// END(BROWSER)
+
+exports.PrintVisitor = Handlebars.PrintVisitor;

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

@@ -0,0 +1,13 @@
+var Handlebars = require("./base");
+
+// BEGIN(BROWSER)
+
+Handlebars.Visitor = function() {};
+
+Handlebars.Visitor.prototype = {
+  accept: function(object) {
+    return this[object.type](object);
+  }
+};
+// END(BROWSER)
+

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

@@ -0,0 +1,68 @@
+var Handlebars = require("./base");
+
+// BEGIN(BROWSER)
+Handlebars.VM = {
+  template: function(templateSpec) {
+    // Just add water
+    var container = {
+      escapeExpression: Handlebars.Utils.escapeExpression,
+      invokePartial: Handlebars.VM.invokePartial,
+      programs: [],
+      program: function(i, fn, data) {
+        var programWrapper = this.programs[i];
+        if(data) {
+          return Handlebars.VM.program(fn, data);
+        } else if(programWrapper) {
+          return programWrapper;
+        } else {
+          programWrapper = this.programs[i] = Handlebars.VM.program(fn);
+          return programWrapper;
+        }
+      },
+      programWithDepth: Handlebars.VM.programWithDepth,
+      noop: Handlebars.VM.noop
+    };
+
+    return function(context, options) {
+      options = options || {};
+      return templateSpec.call(container, Handlebars, context, options.helpers, options.partials, options.data);
+    };
+  },
+
+  programWithDepth: function(fn, data, $depth) {
+    var args = Array.prototype.slice.call(arguments, 2);
+
+    return function(context, options) {
+      options = options || {};
+
+      return fn.apply(this, [context, options.data || data].concat(args));
+    };
+  },
+  program: function(fn, data) {
+    return function(context, options) {
+      options = options || {};
+
+      return fn(context, options.data || data);
+    };
+  },
+  noop: function() { return ""; },
+  invokePartial: function(partial, name, context, helpers, partials, data) {
+    var options = { helpers: helpers, partials: partials, data: data };
+
+    if(partial === undefined) {
+      throw new Handlebars.Exception("The partial " + name + " could not be found");
+    } else if(partial instanceof Function) {
+      return partial(context, options);
+    } 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);
+      return partials[name](context, options);
+    }
+  }
+};
+
+Handlebars.template = Handlebars.VM.template;
+
+// END(BROWSER)
+

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

@@ -0,0 +1,68 @@
+var Handlebars = require("./base");
+
+// BEGIN(BROWSER)
+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]; }
+  }
+
+  this.message = tmp.message;
+};
+Handlebars.Exception.prototype = new Error();
+
+// Build out our basic SafeString type
+Handlebars.SafeString = function(string) {
+  this.string = string;
+};
+Handlebars.SafeString.prototype.toString = function() {
+  return this.string.toString();
+};
+
+(function() {
+  var escape = {
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#x27;",
+    "`": "&#x60;"
+  };
+
+  var badChars = /&(?!\w+;)|[<>"'`]/g;
+  var possible = /[&<>"'`]/;
+
+  var escapeChar = function(chr) {
+    return escape[chr] || "&amp;";
+  };
+
+  Handlebars.Utils = {
+    escapeExpression: function(string) {
+      // don't escape SafeStrings, since they're already safe
+      if (string instanceof Handlebars.SafeString) {
+        return string.toString();
+      } else if (string == null || string === false) {
+        return "";
+      }
+
+      if(!possible.test(string)) { return string; }
+      return string.replace(badChars, escapeChar);
+    },
+
+    isEmpty: function(value) {
+      if (typeof value === "undefined") {
+        return true;
+      } else if (value === null) {
+        return true;
+      } else if (value === false) {
+        return true;
+      } else if(Object.prototype.toString.call(value) === "[object Array]" && value.length === 0) {
+        return true;
+      } else {
+        return false;
+      }
+    }
+  };
+})();
+// END(BROWSER)
+

data/vendor/handlebars/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "handlebars",
+  "description": "Extension of the Mustache logicless template language",
+  "version": "1.0.5beta",
+  "homepage": "http://www.handlebarsjs.com/",
+  "keywords": [
+    "handlebars mustache template html"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/kpdecker/handlebars.js.git"
+  },
+  "engines": {
+    "node": ">=0.4.7"
+  },
+  "dependencies": {
+    "optimist": "~0.3",
+    "uglify-js": "~1.2"
+  },
+  "devDependencies": {},
+  "main": "lib/handlebars.js",
+  "bin": {
+    "handlebars": "bin/handlebars"
+  }
+}

data/vendor/handlebars/spec/acceptance_spec.rb

@@ -0,0 +1,101 @@
+require "spec_helper"
+
+class TestContext
+  class TestModule
+    attr_reader :name, :tests
+
+    def initialize(name)
+      @name = name
+      @tests = []
+    end
+  end
+
+  attr_reader :modules
+
+  def initialize
+    @modules = []
+  end
+
+  def module(name)
+    @modules << TestModule.new(name)
+  end
+
+  def test(name, function)
+    @modules.last.tests << [name, function]
+  end
+end
+
+test_context = TestContext.new
+js_context = Handlebars::Spec::CONTEXT
+
+Module.new do
+  extend Test::Unit::Assertions
+
+  def self.js_backtrace(context)
+    begin
+      context.eval("throw")
+    rescue V8::JSError => e
+      return e.backtrace(:javascript)
+    end
+  end
+
+  js_context["p"] = proc do |str|
+    p str
+  end
+
+  js_context["ok"] = proc do |ok, message|
+    js_context["$$RSPEC1$$"] = ok
+
+    result = js_context.eval("!!$$RSPEC1$$")
+
+    message ||= "#{ok} was not truthy"
+
+    unless result
+      backtrace = js_backtrace(js_context)
+      message << "\n#{backtrace.join("\n")}"
+    end
+
+    assert result, message
+  end
+
+  js_context["equals"] = proc do |first, second, message|
+    js_context["$$RSPEC1$$"] = first
+    js_context["$$RSPEC2$$"] = second
+
+    result = js_context.eval("$$RSPEC1$$ == $$RSPEC2$$")
+
+    additional_message = "#{first.inspect} did not == #{second.inspect}"
+    message = message ? "#{message} (#{additional_message})" : additional_message
+
+    unless result
+      backtrace = js_backtrace(js_context)
+      message << "\n#{backtrace.join("\n")}"
+    end
+
+    assert result, message
+  end
+
+  js_context["equal"] = js_context["equals"]
+
+  js_context["module"] = proc do |name|
+    test_context.module(name)
+  end
+
+  js_context["test"] = proc do |name, function|
+    test_context.test(name, function)
+  end
+
+  local = Regexp.escape(File.expand_path(Dir.pwd))
+  qunit_spec = File.expand_path("../qunit_spec.js", __FILE__)
+  js_context.load(qunit_spec.sub(/^#{local}\//, ''))
+end
+
+test_context.modules.each do |mod|
+  describe mod.name do
+    mod.tests.each do |name, function|
+      it name do
+        function.call
+      end
+    end
+  end
+end

data/vendor/handlebars/spec/parser_spec.rb

@@ -0,0 +1,264 @@
+require "spec_helper"
+
+describe "Parser" do
+  let(:handlebars) { @context["Handlebars"] }
+
+  before(:all) do
+    @compiles = true
+  end
+
+  def program(&block)
+    ASTBuilder.build do
+      program do
+        instance_eval(&block)
+      end
+    end
+  end
+
+  def ast_for(string)
+    ast = handlebars.parse(string)
+    handlebars.print(ast)
+  end
+
+  class ASTBuilder
+    def self.build(&block)
+      ret = new
+      ret.evaluate(&block)
+      ret.out
+    end
+
+    attr_reader :out
+
+    def initialize
+      @padding = 0
+      @out = ""
+    end
+
+    def evaluate(&block)
+      instance_eval(&block)
+    end
+
+    def pad(string)
+      @out << ("  " * @padding) + string + "\n"
+    end
+
+    def with_padding
+      @padding += 1
+      ret = yield
+      @padding -= 1
+      ret
+    end
+
+    def program
+      pad("PROGRAM:")
+      with_padding { yield }
+    end
+
+    def inverse
+      pad("{{^}}")
+      with_padding { yield }
+    end
+
+    def block
+      pad("BLOCK:")
+      with_padding { yield }
+    end
+
+    def inverted_block
+      pad("INVERSE:")
+      with_padding { yield }
+    end
+
+    def mustache(id, params = [], hash = nil)
+      hash = " #{hash}" if hash
+      pad("{{ #{id} [#{params.join(", ")}]#{hash} }}")
+    end
+
+    def partial(id, context = nil)
+      content = id.dup
+      content << " #{context}" if context
+      pad("{{> #{content} }}")
+    end
+
+    def comment(comment)
+      pad("{{! '#{comment}' }}")
+    end
+
+    def multiline_comment(comment)
+      pad("{{! '\n#{comment}\n' }}")
+    end
+
+    def content(string)
+      pad("CONTENT[ '#{string}' ]")
+    end
+
+    def string(string)
+      string.inspect
+    end
+
+    def integer(string)
+      "INTEGER{#{string}}"
+    end
+
+    def boolean(string)
+      "BOOLEAN{#{string}}"
+    end
+
+    def hash(*pairs)
+      "HASH{" + pairs.map {|k,v| "#{k}=#{v}" }.join(", ") + "}"
+    end
+
+    def id(id)
+      "ID:#{id}"
+    end
+
+    def path(*parts)
+      "PATH:#{parts.join("/")}"
+    end
+  end
+
+  it "parses simple mustaches" do
+    ast_for("{{foo}}").should == program { mustache id("foo") }
+  end
+
+  it "parses mustaches with paths" do
+    ast_for("{{foo/bar}}").should == program { mustache path("foo", "bar") }
+  end
+
+  it "parses mustaches with this/foo" do
+    ast_for("{{this/foo}}").should == program { mustache id("foo") }
+  end
+
+  it "parses mustaches with - in a path" do
+    ast_for("{{foo-bar}}").should == program { mustache id("foo-bar") }
+  end
+
+  it "parses mustaches with parameters" do
+    ast_for("{{foo bar}}").should == program { mustache id("foo"), [id("bar")] }
+  end
+
+  it "parses mustaches with hash arguments" do
+    ast_for("{{foo bar=baz}}").should == program do
+      mustache id("foo"), [], hash(["bar", id("baz")])
+    end
+
+    ast_for("{{foo bar=1}}").should == program do
+      mustache id("foo"), [], hash(["bar", integer("1")])
+    end
+
+    ast_for("{{foo bar=true}}").should == program do
+      mustache id("foo"), [], hash(["bar", boolean("true")])
+    end
+
+    ast_for("{{foo bar=false}}").should == program do
+      mustache id("foo"), [], hash(["bar", boolean("false")])
+    end
+
+    ast_for("{{foo bar=baz bat=bam}}").should == program do
+      mustache id("foo"), [], hash(["bar", "ID:baz"], ["bat", "ID:bam"])
+    end
+
+    ast_for("{{foo bar=baz bat=\"bam\"}}").should == program do
+      mustache id("foo"), [], hash(["bar", "ID:baz"], ["bat", "\"bam\""])
+    end
+
+    ast_for("{{foo omg bar=baz bat=\"bam\"}}").should == program 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
+      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
+      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
+      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")] }
+  end
+
+  it "parses mustaches with INTEGER parameters" do
+    ast_for("{{foo 1}}").should == program { 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")] }
+  end
+
+  it "parses contents followed by a mustache" do
+    ast_for("foo bar {{baz}}").should == program do
+      content "foo bar "
+      mustache id("baz")
+    end
+  end
+
+  it "parses a partial" do
+    ast_for("{{> foo }}").should == program { partial id("foo") }
+  end
+
+  it "parses a partial with context" do
+    ast_for("{{> foo bar}}").should == program { partial id("foo"), id("bar") }
+  end
+
+  it "parses a comment" do
+    ast_for("{{! this is a comment }}").should == program 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
+      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
+      block do
+        mustache id("foo")
+
+        program do
+          content " bar "
+        end
+
+        inverse do
+          content " baz "
+        end
+      end
+    end
+  end
+
+  it "parses a standalone inverse section" do
+    ast_for("{{^foo}}bar{{/foo}}").should == program do
+      inverted_block do
+        mustache id("foo")
+
+        program do
+          content "bar"
+        end
+      end
+    end
+  end
+
+  it "raises if there's a Parse error" do
+    lambda { ast_for("{{foo}") }.should   raise_error(V8::JSError, /Parse error on line 1/)
+    lambda { ast_for("{{foo &}}")}.should raise_error(V8::JSError, /Parse error on line 1/)
+    lambda { ast_for("{{#goodbyes}}{{/hellos}}") }.should raise_error(V8::JSError, /goodbyes doesn't match hellos/)
+  end
+
+  it "knows how to report the correct line number in errors" do
+    lambda { ast_for("hello\nmy\n{{foo}") }.should     raise_error(V8::JSError, /Parse error on line 3/m)
+    lambda { ast_for("hello\n\nmy\n\n{{foo}") }.should raise_error(V8::JSError, /Parse error on line 5/m)
+  end
+
+  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
+end