hbs 0.1.0

data/js/spec/spec_helper.rb

@@ -0,0 +1,106 @@
+require "v8"
+
+# Monkey patches due to bugs in RubyRacer
+class V8::JSError
+  def initialize(try, to)
+    @to = to
+    begin
+      super(initialize_unsafe(try))
+    rescue Exception => e
+      # Original code does not make an Array here
+      @boundaries = [Boundary.new(:rbframes => e.backtrace)]
+      @value = e
+      super("BUG! please report. JSError#initialize failed!: #{e.message}")
+    end
+  end
+
+  def parse_js_frames(try)
+    raw = @to.rb(try.StackTrace())
+    if raw && !raw.empty?
+      raw.split("\n")[1..-1].tap do |frames|
+        # Original code uses strip!, and the frames are not guaranteed to be strippable
+        frames.each {|frame| frame.strip.chomp!(",")}
+      end
+    else
+      []
+    end
+  end
+end
+
+module Handlebars
+  module Spec
+    def self.js_backtrace(context)
+      begin
+        context.eval("throw")
+      rescue V8::JSError => e
+        return e.backtrace(:javascript)
+      end
+    end
+
+    def self.remove_exports(string)
+      match = string.match(%r{\A(.*?)^// BEGIN\(BROWSER\)\n(.*)\n^// END\(BROWSER\)(.*?)\Z}m)
+      prelines = match ? match[1].count("\n") + 1 : 0
+      ret = match ? match[2] : string
+      ("\n" * prelines) + ret
+    end
+
+    def self.js_load(file)
+      str = File.read(file)
+      CONTEXT.eval(remove_exports(str), file)
+    end
+
+    CONTEXT = V8::Context.new
+    CONTEXT.instance_eval do |context|
+      context["exports"] = nil
+
+      context["p"] = proc do |val|
+        p val if ENV["DEBUG_JS"]
+      end
+
+      context["puts"] = proc do |val|
+        puts val if ENV["DEBUG_JS"]
+      end
+
+      context["puts_node"] = proc do |val|
+        puts context["Handlebars"]["PrintVisitor"].new.accept(val)
+        puts
+      end
+
+      context["puts_caller"] = proc do
+        puts "BACKTRACE:"
+        puts Handlebars::Spec.js_backtrace(context)
+        puts
+      end
+
+      Handlebars::Spec.js_load('lib/handlebars/parser.js')
+      Handlebars::Spec.js_load('lib/handlebars/base.js');
+      Handlebars::Spec.js_load('lib/handlebars/ast.js');
+      Handlebars::Spec.js_load('lib/handlebars/visitor.js');
+      Handlebars::Spec.js_load('lib/handlebars/printer.js')
+      Handlebars::Spec.js_load('lib/handlebars/utils.js')
+      Handlebars::Spec.js_load('lib/handlebars/compiler.js')
+      Handlebars::Spec.js_load('lib/handlebars.js')
+
+      context["Handlebars"]["logger"]["level"] = ENV["DEBUG_JS"] ? context["Handlebars"]["logger"][ENV["DEBUG_JS"]] : 4
+
+      context["Handlebars"]["logger"]["log"] = proc do |level, str|
+        logger_level = context["Handlebars"]["logger"]["level"].to_i
+
+        if logger_level <= level
+          puts str
+        end
+      end
+    end
+  end
+end
+
+
+require "test/unit/assertions"
+
+RSpec.configure do |config|
+  config.include Test::Unit::Assertions
+
+  config.before(:all) do
+    @context = Handlebars::Spec::CONTEXT
+  end
+end

data/js/spec/tokenizer_spec.rb

@@ -0,0 +1,227 @@
+require "spec_helper"
+require "timeout"
+
+describe "Tokenizer" do
+  let(:parser) { @context["handlebars"] }
+  let(:lexer) { @context["handlebars"]["lexer"] }
+
+  Token = Struct.new(:name, :text)
+
+  def tokenize(string)
+    lexer.setInput(string)
+    out = []
+
+    while token = lexer.lex
+      # p token
+      result = parser.terminals_[token] || token
+      # p result
+      break if !result || result == "EOF" || result == "INVALID"
+      out << Token.new(result, lexer.yytext)
+    end
+
+    out
+  end
+
+  RSpec::Matchers.define :match_tokens do |tokens|
+    match do |result|
+      result.map(&:name).should == tokens
+    end
+  end
+
+  RSpec::Matchers.define :be_token do |name, string|
+    match do |token|
+      token.name.should == name
+      token.text.should == string
+    end
+  end
+
+  it "tokenizes a simple mustache as 'OPEN ID CLOSE'" do
+    result = tokenize("{{foo}}")
+    result.should match_tokens(%w(OPEN ID CLOSE))
+    result[1].should be_token("ID", "foo")
+  end
+
+  it "tokenizes a simple path" do
+    result = tokenize("{{foo/bar}}")
+    result.should match_tokens(%w(OPEN ID SEP ID CLOSE))
+  end
+
+  it "allows dot notation" do
+    result = tokenize("{{foo.bar}}")
+    result.should match_tokens(%w(OPEN ID SEP ID CLOSE))
+
+    tokenize("{{foo.bar.baz}}").should match_tokens(%w(OPEN ID SEP ID SEP ID CLOSE))
+  end
+
+  it "tokenizes {{.}} as OPEN ID CLOSE" do
+    result = tokenize("{{.}}")
+    result.should match_tokens(%w(OPEN ID CLOSE))
+  end
+
+  it "tokenizes a path as 'OPEN (ID SEP)* ID CLOSE'" do
+    result = tokenize("{{../foo/bar}}")
+    result.should match_tokens(%w(OPEN ID SEP ID SEP ID CLOSE))
+    result[1].should be_token("ID", "..")
+  end
+
+  it "tokenizes a path with .. as a parent path" do
+    result = tokenize("{{../foo.bar}}")
+    result.should match_tokens(%w(OPEN ID SEP ID SEP ID CLOSE))
+    result[1].should be_token("ID", "..")
+  end
+
+  it "tokenizes a path with this/foo as OPEN ID SEP ID CLOSE" do
+    result = tokenize("{{this/foo}}")
+    result.should match_tokens(%w(OPEN ID SEP ID CLOSE))
+    result[1].should be_token("ID", "this")
+    result[3].should be_token("ID", "foo")
+  end
+
+  it "tokenizes a simple mustache with spaces as 'OPEN ID CLOSE'" do
+    result = tokenize("{{  foo  }}")
+    result.should match_tokens(%w(OPEN ID CLOSE))
+    result[1].should be_token("ID", "foo")
+  end
+
+  it "tokenizes a simple mustache with line breaks as 'OPEN ID ID CLOSE'" do
+    result = tokenize("{{  foo  \n   bar }}")
+    result.should match_tokens(%w(OPEN ID ID CLOSE))
+    result[1].should be_token("ID", "foo")
+  end
+
+  it "tokenizes raw content as 'CONTENT'" do
+    result = tokenize("foo {{ bar }} baz")
+    result.should match_tokens(%w(CONTENT OPEN ID CLOSE CONTENT))
+    result[0].should be_token("CONTENT", "foo ")
+    result[4].should be_token("CONTENT", " baz")
+  end
+
+  it "tokenizes a partial as 'OPEN_PARTIAL ID CLOSE'" do
+    result = tokenize("{{> foo}}")
+    result.should match_tokens(%w(OPEN_PARTIAL ID CLOSE))
+  end
+
+  it "tokenizes a partial with context as 'OPEN_PARTIAL ID ID CLOSE'" do
+    result = tokenize("{{> foo bar }}")
+    result.should match_tokens(%w(OPEN_PARTIAL ID ID CLOSE))
+  end
+
+  it "tokenizes a partial without spaces as 'OPEN_PARTIAL ID CLOSE'" do
+    result = tokenize("{{>foo}}")
+    result.should match_tokens(%w(OPEN_PARTIAL ID CLOSE))
+  end
+
+  it "tokenizes a partial space at the end as 'OPEN_PARTIAL ID CLOSE'" do
+    result = tokenize("{{>foo  }}")
+    result.should match_tokens(%w(OPEN_PARTIAL ID CLOSE))
+  end
+
+  it "tokenizes a comment as 'COMMENT'" do
+    result = tokenize("foo {{! this is a comment }} bar {{ baz }}")
+    result.should match_tokens(%w(CONTENT COMMENT CONTENT OPEN ID CLOSE))
+    result[1].should be_token("COMMENT", " this is a comment ")
+  end
+
+  it "tokenizes open and closing blocks as 'OPEN_BLOCK ID CLOSE ... OPEN_ENDBLOCK ID CLOSE'" do
+    result = tokenize("{{#foo}}content{{/foo}}")
+    result.should match_tokens(%w(OPEN_BLOCK ID CLOSE CONTENT OPEN_ENDBLOCK ID CLOSE))
+  end
+
+  it "tokenizes inverse sections as 'OPEN_INVERSE CLOSE'" do
+    tokenize("{{^}}").should match_tokens(%w(OPEN_INVERSE CLOSE))
+    tokenize("{{else}}").should match_tokens(%w(OPEN_INVERSE CLOSE))
+    tokenize("{{ else }}").should match_tokens(%w(OPEN_INVERSE CLOSE))
+  end
+
+  it "tokenizes inverse sections with ID as 'OPEN_INVERSE ID CLOSE'" do
+    result = tokenize("{{^foo}}")
+    result.should match_tokens(%w(OPEN_INVERSE ID CLOSE))
+    result[1].should be_token("ID", "foo")
+  end
+
+  it "tokenizes inverse sections with ID and spaces as 'OPEN_INVERSE ID CLOSE'" do
+    result = tokenize("{{^ foo  }}")
+    result.should match_tokens(%w(OPEN_INVERSE ID CLOSE))
+    result[1].should be_token("ID", "foo")
+  end
+
+  it "tokenizes mustaches with params as 'OPEN ID ID ID CLOSE'" do
+    result = tokenize("{{ foo bar baz }}")
+    result.should match_tokens(%w(OPEN ID ID ID CLOSE))
+    result[1].should be_token("ID", "foo")
+    result[2].should be_token("ID", "bar")
+    result[3].should be_token("ID", "baz")
+  end
+
+  it "tokenizes mustaches with String params as 'OPEN ID ID STRING CLOSE'" do
+    result = tokenize("{{ foo bar \"baz\" }}")
+    result.should match_tokens(%w(OPEN ID ID STRING CLOSE))
+    result[3].should be_token("STRING", "baz")
+  end
+
+  it "tokenizes String params with spaces inside as 'STRING'" do
+    result = tokenize("{{ foo bar \"baz bat\" }}")
+    result.should match_tokens(%w(OPEN ID ID STRING CLOSE))
+    result[3].should be_token("STRING", "baz bat")
+  end
+
+  it "tokenizes String params with escapes quotes as 'STRING'" do
+    result = tokenize(%|{{ foo "bar\\"baz" }}|)
+    result.should match_tokens(%w(OPEN ID STRING CLOSE))
+    result[2].should be_token("STRING", %{bar"baz})
+  end
+
+  it "tokenizes numbers" do
+    result = tokenize(%|{{ foo 1 }}|)
+    result.should match_tokens(%w(OPEN ID INTEGER CLOSE))
+    result[2].should be_token("INTEGER", "1")
+  end
+
+  it "tokenizes booleans" do
+    result = tokenize(%|{{ foo true }}|)
+    result.should match_tokens(%w(OPEN ID BOOLEAN CLOSE))
+    result[2].should be_token("BOOLEAN", "true")
+
+    result = tokenize(%|{{ foo false }}|)
+    result.should match_tokens(%w(OPEN ID BOOLEAN CLOSE))
+    result[2].should be_token("BOOLEAN", "false")
+  end
+
+  it "tokenizes hash arguments" do
+    result = tokenize("{{ foo bar=baz }}")
+    result.should match_tokens %w(OPEN ID ID EQUALS ID CLOSE)
+
+    result = tokenize("{{ foo bar baz=bat }}")
+    result.should match_tokens %w(OPEN ID ID ID EQUALS ID CLOSE)
+
+    result = tokenize("{{ foo bar baz=1 }}")
+    result.should match_tokens %w(OPEN ID ID ID EQUALS INTEGER CLOSE)
+
+    result = tokenize("{{ foo bar baz=true }}")
+    result.should match_tokens %w(OPEN ID ID ID EQUALS BOOLEAN CLOSE)
+
+    result = tokenize("{{ foo bar baz=false }}")
+    result.should match_tokens %w(OPEN ID ID ID EQUALS BOOLEAN CLOSE)
+
+    result = tokenize("{{ foo bar\n  baz=bat }}")
+    result.should match_tokens %w(OPEN ID ID ID EQUALS ID CLOSE)
+
+    result = tokenize("{{ foo bar baz=\"bat\" }}")
+    result.should match_tokens %w(OPEN ID ID ID EQUALS STRING CLOSE)
+
+    result = tokenize("{{ foo bar baz=\"bat\" bam=wot }}")
+    result.should match_tokens %w(OPEN ID ID ID EQUALS STRING ID EQUALS ID CLOSE)
+
+    result = tokenize("{{foo omg bar=baz bat=\"bam\"}}")
+    result.should match_tokens %w(OPEN ID ID ID EQUALS ID ID EQUALS STRING CLOSE)
+    result[2].should be_token("ID", "omg")
+  end
+
+  it "does not time out in a mustache with a single } followed by EOF" do
+    Timeout.timeout(1) { tokenize("{{foo}").should match_tokens(%w(OPEN ID)) }
+  end
+
+  it "does not time out in a mustache when invalid ID characters are used" do
+    Timeout.timeout(1) { tokenize("{{foo & }}").should match_tokens(%w(OPEN ID)) }
+  end
+end

data/js/src/handlebars.l

@@ -0,0 +1,34 @@
+
+%x mu
+
+%%
+
+[^\x00]*?/("{{")                 { this.begin("mu"); if (yytext) return 'CONTENT'; }
+[^\x00]+                         { return 'CONTENT'; }
+
+<mu>"{{>"                    { return 'OPEN_PARTIAL'; }
+<mu>"{{#"                    { return 'OPEN_BLOCK'; }
+<mu>"{{/"                    { return 'OPEN_ENDBLOCK'; }
+<mu>"{{^"                    { return 'OPEN_INVERSE'; }
+<mu>"{{"\s*"else"            { return 'OPEN_INVERSE'; }
+<mu>"{{{"                    { return 'OPEN_UNESCAPED'; }
+<mu>"{{&"                    { return 'OPEN_UNESCAPED'; }
+<mu>"{{!"[\s\S]*?"}}"        { yytext = yytext.substr(3,yyleng-5); this.begin("INITIAL"); return 'COMMENT'; }
+<mu>"{{"                     { return 'OPEN'; }
+
+<mu>"="                      { return 'EQUALS'; }
+<mu>"."/[} ]                 { return 'ID'; }
+<mu>".."                     { return 'ID'; }
+<mu>[/.]                     { return 'SEP'; }
+<mu>\s+                      { /*ignore whitespace*/ }
+<mu>"}}}"                    { this.begin("INITIAL"); return 'CLOSE'; }
+<mu>"}}"                     { this.begin("INITIAL"); return 'CLOSE'; }
+<mu>'"'("\\"["]|[^"])*'"'    { yytext = yytext.substr(1,yyleng-2).replace(/\\"/g,'"'); return 'STRING'; }
+<mu>"true"/[}\s]             { return 'BOOLEAN'; }
+<mu>"false"/[}\s]            { return 'BOOLEAN'; }
+<mu>[0-9]+/[}\s]             { return 'INTEGER'; }
+<mu>[a-zA-Z0-9_$-]+/[=}\s/.] { return 'ID'; }
+<mu>.                        { return 'INVALID'; }
+
+<INITIAL,mu><<EOF>>          { return 'EOF'; }
+

data/js/src/handlebars.yy

@@ -0,0 +1,99 @@
+%start root
+
+%%
+
+root
+  : program EOF { return $1 }
+  ;
+
+program
+  : statements simpleInverse statements { $$ = new yy.ProgramNode($1, $3) }
+  | statements { $$ = new yy.ProgramNode($1) }
+  | "" { $$ = new yy.ProgramNode([]) }
+  ;
+
+statements
+  : statement { $$ = [$1] }
+  | statements statement { $1.push($2); $$ = $1 }
+  ;
+
+statement
+  : openInverse program closeBlock { $$ = new yy.InverseNode($1, $2, $3) }
+  | openBlock program closeBlock { $$ = new yy.BlockNode($1, $2, $3) }
+  | mustache { $$ = $1 }
+  | partial { $$ = $1 }
+  | CONTENT { $$ = new yy.ContentNode($1) }
+  | COMMENT { $$ = new yy.CommentNode($1) }
+  ;
+
+openBlock
+  : OPEN_BLOCK inMustache CLOSE { $$ = new yy.MustacheNode($2[0], $2[1]) }
+  ;
+
+openInverse
+  : OPEN_INVERSE inMustache CLOSE { $$ = new yy.MustacheNode($2[0], $2[1]) }
+  ;
+
+closeBlock
+  : OPEN_ENDBLOCK path CLOSE { $$ = $2 }
+  ;
+
+mustache
+  : OPEN inMustache CLOSE { $$ = new yy.MustacheNode($2[0], $2[1]) }
+  | OPEN_UNESCAPED inMustache CLOSE { $$ = new yy.MustacheNode($2[0], $2[1], true) }
+  ;
+
+
+partial
+  : OPEN_PARTIAL path CLOSE { $$ = new yy.PartialNode($2) }
+  | OPEN_PARTIAL path path CLOSE { $$ = new yy.PartialNode($2, $3) }
+  ;
+
+simpleInverse
+  : OPEN_INVERSE CLOSE { }
+  ;
+
+inMustache
+  : path params hash { $$ = [[$1].concat($2), $3] }
+  | path params { $$ = [[$1].concat($2), null] }
+  | path hash { $$ = [[$1], $2] }
+  | path { $$ = [[$1], null] }
+  ;
+
+params
+  : params param { $1.push($2); $$ = $1; }
+  | param { $$ = [$1] }
+  ;
+
+param
+  : path { $$ = $1 }
+  | STRING { $$ = new yy.StringNode($1) }
+  | INTEGER { $$ = new yy.IntegerNode($1) }
+  | BOOLEAN { $$ = new yy.BooleanNode($1) }
+  ;
+
+hash
+  : hashSegments { $$ = new yy.HashNode($1) }
+  ;
+
+hashSegments
+  : hashSegments hashSegment { $1.push($2); $$ = $1 }
+  | hashSegment { $$ = [$1] }
+  ;
+
+hashSegment
+  : ID EQUALS path { $$ = [$1, $3] }
+  | ID EQUALS STRING { $$ = [$1, new yy.StringNode($3)] }
+  | ID EQUALS INTEGER { $$ = [$1, new yy.IntegerNode($3)] }
+  | ID EQUALS BOOLEAN { $$ = [$1, new yy.BooleanNode($3)] }
+  ;
+
+path
+  : pathSegments { $$ = new yy.IdNode($1) }
+  ;
+
+pathSegments
+  : pathSegments SEP ID { $1.push($3); $$ = $1; }
+  | ID { $$ = [$1] }
+  ;
+