handlebars 0.0.1 → 0.0.2

data/.gitignore

@@ -1,3 +1,4 @@
 pkg/*
 *.gem
 .bundle
+session.vim

data/README.md

@@ -0,0 +1,39 @@
+Handlebars
+==========
+
+Handlebars is a implementation of [handlebars.js][2], an extension of
+mustache by Yehuda Katz, in Ruby.
+
+
+Current status
+--------------
+
+So far only the parser has been implemented. It supports the whole
+handlebars syntax.
+
+
+Installation
+------------
+
+### [RubyGems](http://rubygems.org/)
+
+    $ gem install handlebars
+
+
+Acknowledgements
+----------------
+
+Thanks to all the [implementers][3] of the original mustache gem.
+Handlebars is based on their codebase and hard work.
+
+
+Meta
+----
+
+* Code: `git clone http://github.com/MSch/handlebars-ruby`
+* Bugs: <http://github.com/MSch/handlebars-ruby/issues>
+* Gems: <http://rubygems.org/gems/handlebars>
+
+[1]:http://github.com/wycats/handlebars.js
+[2]:http://yehudakatz.com/2010/09/09/announcing-handlebars-js/
+[3]:http://github.com/defunkt/mustache/raw/master/CONTRIBUTORS

data/handlebars.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |s|
   s.rubyforge_project         = "handlebars"
 
   s.add_development_dependency "bundler", ">= 1.0.0"
-  s.add_development_dependency "rspec", ">= 2.0.0"
+  s.add_development_dependency "rspec", "~> 2.0.0"
 
   s.files        = `git ls-files`.split("\n")
   s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact

data/lib/handlebars.rb

@@ -1,30 +1,5 @@
-require 'handlebars/compiler'
+require 'handlebars/generator'
+require 'handlebars/parser'
 
 class Handlebars
-  attr_accessor :compiled_partials
-  def compile(input)
-  end
-
-  def compile_to_string(input)
-  end
-
-  def compile_function_body(input)
-  end
-
-  def escape_text(input)
-    CGI.escapeHTML(input)
-  end
-
-  def escape_expression(input)
-  end
-
-
-  def compile_partials(input)
-  end
-
-  def parse_path(input)
-  end
-
-  def filter_output(input, escape=true)
-  end
 end

data/lib/handlebars/generator.rb

@@ -0,0 +1,4 @@
+class Handlebars
+  class Generator
+  end
+end

data/lib/handlebars/parser.rb

@@ -0,0 +1,240 @@
+require 'strscan'
+
+class Handlebars
+  class Parser
+    # A SyntaxError is raised when the Parser comes across unclosed
+    # tags, sections, illegal content in tags, or anything of that
+    # sort.
+    class SyntaxError < StandardError
+      def initialize(message, position)
+        @message = message
+        @lineno, @column, @line = position
+        @stripped_line = @line.strip
+        @stripped_column = @column - (@line.size - @line.lstrip.size)
+      end
+
+      def to_s
+        <<-EOF
+#{@message}
+  Line #{@lineno}
+    #{@stripped_line}
+    #{' ' * @stripped_column}^
+EOF
+      end
+    end
+
+    # After these types of tags, all whitespace will be skipped.
+    SKIP_WHITESPACE = [ '#', '^', '/' ]
+
+    # The content allowed in a tag name.
+    ALLOWED_CONTENT = /(\w|[.?!\/-])*/
+
+    # These types of tags allow any content,
+    # the rest only allow ALLOWED_CONTENT.
+    ANY_CONTENT = [ '!', '=' ]
+
+    attr_reader :scanner, :result
+    attr_writer :otag, :ctag
+
+    # Accepts an options hash which does nothing but may be used in
+    # the future.
+    def initialize(options = {})
+      @options = {}
+    end
+
+    # The opening tag delimiter. This may be changed at runtime.
+    def otag
+      @otag ||= '{{'
+    end
+
+    # The closing tag delimiter. This too may be changed at runtime.
+    def ctag
+      @ctag ||= '}}'
+    end
+
+    # Given a string template, returns an array of tokens.
+    def compile(template)
+      if template.respond_to?(:encoding)
+        @encoding = template.encoding
+        template = template.dup.force_encoding("BINARY")
+      else
+        @encoding = nil
+      end
+
+      # Keeps information about opened sections.
+      @sections = []
+      @result = [:multi]
+      @scanner = StringScanner.new(template)
+
+      # Scan until the end of the template.
+      until @scanner.eos?
+        scan_tags || scan_text
+      end
+
+      if !@sections.empty?
+        # We have parsed the whole file, but there's still opened sections.
+        type, pos, result = @sections.pop
+        error "Unclosed section #{type.inspect}", pos
+      end
+
+      @result
+    end
+
+    # Find {{mustaches}} and add them to the @result array.
+    def scan_tags
+      # Scan until we hit an opening delimiter.
+      return unless @scanner.scan(regexp(otag))
+
+      # Since {{= rewrites ctag, we store the ctag which should be used
+      # when parsing this specific tag.
+      current_ctag = self.ctag
+      type = @scanner.scan(/#|\^|\/|=|!|<|>|&|\{/)
+      @scanner.skip(/\s*/)
+
+      # ANY_CONTENT tags allow any character inside of them, while
+      # other tags (such as variables) are more strict.
+      if ANY_CONTENT.include?(type)
+        r = /\s*#{regexp(type)}?#{regexp(current_ctag)}/
+        content = scan_until_exclusive(r)
+      else
+        content = @scanner.scan(ALLOWED_CONTENT)
+      end
+
+      # We found {{ but we can't figure out what's going on inside.
+      # This applies to all tags except handlebar's shortened {{^}}
+      if type != '^'
+        error "Illegal content in tag" if content.empty?
+      end
+
+      def find_context
+        # A space after the helper indicates a context 'switch'
+        if @scanner.peek(1) == ' '
+          @scanner.skip(/ /)
+          @scanner.scan(ALLOWED_CONTENT)
+        else
+          nil
+        end
+      end
+
+      # Based on the sigil, do what needs to be done.
+      case type
+      when '#'
+        block = [:multi]
+        @result << [:mustache, :section, content, find_context(), block]
+        @sections << [content, position, @result]
+        @result = block
+      when '^'
+        if content.empty?
+          # We are dealing with handlebar's shortened {{^}}
+
+          # Close the section
+          section, pos, result = @sections.pop
+          @result = result
+          if section.nil?
+            error "Inverting unopened section"
+          end
+
+          # Open a new inverted section with the same name
+          block = [:multi]
+          @result << [:mustache, :inverted_section, section, block]
+          @sections << [section, position, @result]
+          @result = block
+        else
+          block = [:multi]
+          @result << [:mustache, :inverted_section, content, block]
+          @sections << [content, position, @result]
+          @result = block
+        end
+      when '/'
+        section, pos, result = @sections.pop
+        @result = result
+
+        if section.nil?
+          error "Closing unopened #{content.inspect}"
+        elsif section != content
+          error "Unclosed section #{section.inspect}", pos
+        end
+      when '!'
+        # ignore comments
+      when '='
+        self.otag, self.ctag = content.split(' ', 2)
+      when '>', '<'
+        @result << [:mustache, :partial, content]
+      when '{', '&'
+        # The closing } in unescaped tags is just a hack for
+        # aesthetics.
+        type = "}" if type == "{"
+        @result << [:mustache, :utag, content]
+      else
+        @result << [:mustache, :etag, content, find_context()]
+      end
+
+      # Skip whitespace and any balancing sigils after the content
+      # inside this tag.
+      @scanner.skip(/\s+/)
+      @scanner.skip(regexp(type)) if type
+
+      # Try to find the closing tag.
+      unless close = @scanner.scan(regexp(current_ctag))
+        error "Unclosed tag"
+      end
+
+      # Skip whitespace following this tag if we need to.
+      @scanner.skip(/\s+/) if SKIP_WHITESPACE.include?(type)
+    end
+
+    # Try to find static text, e.g. raw HTML with no {{mustaches}}.
+    def scan_text
+      text = scan_until_exclusive(regexp(otag))
+
+      if text.nil?
+        # Couldn't find any otag, which means the rest is just static text.
+        text = @scanner.rest
+        # Mark as done.
+        @scanner.clear
+      end
+
+      text.force_encoding(@encoding) if @encoding
+
+      @result << [:static, text]
+    end
+
+    # Scans the string until the pattern is matched. Returns the substring
+    # *excluding* the end of the match, advancing the scan pointer to that
+    # location. If there is no match, nil is returned.
+    def scan_until_exclusive(regexp)
+      pos = @scanner.pos
+      if @scanner.scan_until(regexp)
+        @scanner.pos -= @scanner.matched.size
+        @scanner.pre_match[pos..-1]
+      end
+    end
+
+    # Returns [lineno, column, line]
+    def position
+      # The rest of the current line
+      rest = @scanner.check_until(/\n|\Z/).to_s.chomp
+
+      # What we have parsed so far
+      parsed = @scanner.string[0...@scanner.pos]
+
+      lines = parsed.split("\n")
+
+      [ lines.size, lines.last.size - 1, lines.last + rest ]
+    end
+
+    # Used to quickly convert a string into a regular expression
+    # usable by the string scanner.
+    def regexp(thing)
+      /#{Regexp.escape(thing)}/
+    end
+
+    # Raises a SyntaxError. The message should be the name of the
+    # error - other details such as line number and position are
+    # handled for you.
+    def error(message, pos = position)
+      raise SyntaxError.new(message, pos)
+    end
+  end
+end
+

data/lib/handlebars/version.rb

@@ -1,3 +1,3 @@
 module Handlebars
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/generator_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+require 'handlebars'
+
+describe Handlebars::Generator do
+end

data/spec/parser_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+require 'handlebars'
+
+describe Handlebars::Parser do
+
+  it 'fails when the handlebars inverted section syntax is used without an opened section' do
+    lexer = Handlebars::Parser.new
+    proc {
+      lexer.compile(<<-EOF)
+{{^}}
+<h1>No projects</h1>
+{{/project}}
+EOF
+    }.should raise_error(Handlebars::Parser::SyntaxError)
+  end
+
+  it 'parses the handlebars inverted section syntax' do
+    lexer = Handlebars::Parser.new
+    tokens = lexer.compile(<<-EOF)
+{{#project}}
+<h1>{{name}}</h1>
+<div>{{body}}</div>
+{{^}}
+<h1>No projects</h1>
+{{/project}}
+EOF
+    expected = [:multi,
+      [:mustache, :section, "project", nil, [:multi,
+        [:static, "<h1>"],
+        [:mustache, :etag, "name", nil],
+        [:static, "</h1>\n<div>"],
+        [:mustache, :etag, "body", nil],
+        [:static, "</div>\n"]]],
+      [:mustache, :inverted_section, "project", [:multi,
+        [:static, "<h1>No projects</h1>\n"]]]]
+    tokens.should eq(expected)
+  end
+
+  it 'parses the mustache inverted section syntax' do
+    lexer = Handlebars::Parser.new
+    tokens = lexer.compile(<<-EOF)
+{{#project}}
+<h1>{{name}}</h1>
+<div>{{body}}</div>
+{{/project}}
+{{^project}}
+<h1>No projects</h1>
+{{/project}}
+EOF
+    expected = [:multi, 
+      [:mustache, :section, "project", nil, [:multi, 
+        [:static, "<h1>"], 
+        [:mustache, :etag, "name", nil], 
+        [:static, "</h1>\n<div>"], 
+        [:mustache, :etag, "body", nil], 
+        [:static, "</div>\n"]]], 
+        [:mustache, :inverted_section, "project", [:multi, 
+          [:static, "<h1>No projects</h1>\n"]]]]
+    tokens.should eq(expected)
+  end
+
+  it 'parses helpers with context paths' do
+    lexer = Handlebars::Parser.new
+    tokens = lexer.compile(<<-EOF)
+<h1>{{helper context}}</h1>
+<h1>{{helper ..}}</h1>
+{{#items ..}}
+haha
+{{haha}}
+{{/items}}
+EOF
+
+    expected = [:multi,
+      [:static, "<h1>"],
+      [:mustache, :etag, "helper", "context"],
+      [:static, "</h1>\n<h1>"],
+      [:mustache, :etag, "helper", ".."],
+      [:static, "</h1>\n"],
+      [:mustache, :section, "items", "..", [:multi,
+        [:static, "haha\n"],
+        [:mustache, :etag, "haha", nil],
+        [:static, "\n"]]]]
+    tokens.should eq(expected)
+  end
+
+  it 'parses extended paths' do
+    lexer = Handlebars::Parser.new
+    tokens = lexer.compile(<<-EOF)
+<h1>{{../../header}}</h1>
+<div>{{./header}}
+{{hans/hubert/header}}</div>
+{{#ines/ingrid/items}}
+a
+{{/ines/ingrid/items}}
+EOF
+
+    expected = [:multi,
+      [:static, "<h1>"],
+      [:mustache, :etag, "../../header", nil],
+      [:static, "</h1>\n<div>"],
+      [:mustache, :etag, "./header", nil],
+      [:static, "\n"],
+      [:mustache, :etag, "hans/hubert/header", nil],
+      [:static, "</div>\n"],
+      [:mustache, :section, "ines/ingrid/items", nil, [:multi,
+        [:static, "a\n"]]]]
+    tokens.should eq(expected)
+  end
+
+  it 'parses the mustache example' do
+    lexer = Handlebars::Parser.new
+    tokens = lexer.compile(<<-EOF)
+<h1>{{header}}</h1>
+{{#items}}
+{{#first}}
+  <li><strong>{{name}}</strong></li>
+{{/first}}
+{{#link}}
+  <li><a href="{{url}}">{{name}}</a></li>
+{{/link}}
+{{/items}}
+
+{{#empty}}
+<p>The list is empty.</p>
+{{/empty}}
+EOF
+
+    expected = [:multi,
+      [:static, "<h1>"],
+      [:mustache, :etag, "header", nil],
+      [:static, "</h1>\n"],
+      [:mustache,
+        :section,
+        "items",
+        nil,
+        [:multi,
+          [:mustache,
+            :section,
+            "first",
+            nil,
+            [:multi,
+              [:static, "<li><strong>"],
+              [:mustache, :etag, "name", nil],
+              [:static, "</strong></li>\n"]]],
+          [:mustache,
+            :section,
+            "link",
+            nil,
+            [:multi,
+              [:static, "<li><a href=\""],
+              [:mustache, :etag, "url", nil],
+              [:static, "\">"],
+              [:mustache, :etag, "name", nil],
+              [:static, "</a></li>\n"]]]]],
+      [:mustache,
+        :section,
+        "empty",
+        nil,
+        [:multi, [:static, "<p>The list is empty.</p>\n"]]]]
+
+    tokens.should eq(expected)
+  end
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Martin Schuerrer
@@ -38,7 +38,7 @@ dependencies:
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
         segments: 
         - 2
@@ -59,13 +59,16 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - Gemfile
+- README.md
 - Rakefile
 - handlebars.gemspec
 - lib/handlebars.rb
-- lib/handlebars/compiler.rb
+- lib/handlebars/generator.rb
+- lib/handlebars/parser.rb
 - lib/handlebars/version.rb
+- spec/generator_spec.rb
+- spec/parser_spec.rb
 - spec/spec_helper.rb
-- spec/test_spec.rb
 has_rdoc: true
 homepage: http://github.com/MSch/handlebars-ruby
 licenses: []

data/lib/handlebars/compiler.rb

@@ -1,96 +0,0 @@
-require 'stringio'
-
-class Handlebars
-  class Compiler
-    attr_accessor :input, :pointer, :mustache, :text, :fn, :newlines, :comment, :escaped, :partial, :inverted, :end_condition, :continue_inverted
-    def initialize(input)
-      @input   = input
-      @pointer  = -1
-      @mustache = false
-      @text     = ''
-      @fn       = 'out = ""; lookup = nil; '
-      @newlines = ''
-      @comment  = false
-      @escaped  = true
-      @partial  = false
-      @inverted = false
-      @end_condition = nil
-      @continue_inverted = false
-    end
-
-    def add_text
-     if not @text.empty?
-       @fn << 'out = out + \'' + CGI.escapeHTML(@text) + '\''
-       @fn << @newlines
-       @newlines = ''
-       @text = ''
-     end
-    end
-
-    def parse_mustache
-      chr, part, mustache, param = nil
-      @s = StringScanner.new(input)
-
-      next_char = @s.peek
-      case next_char
-      when '!'
-        @comment = true
-      when '#'
-        @open_block = true
-      when '>'
-        @partial = true
-      when '^'
-        @inverted = true
-        @open_block = true
-      when '{'
-        @escaped = false
-      when '&'
-        @escaped = false
-      end
-      @s.getch
-
-      add_text
-      @mustache = ' '
-
-      while(chr = @s.getch)
-        if @mustache && chr == '}' && @s.peek == '}'
-          parts = @mustache.chomp.split(/\s+/)
-          mustache = parts[0]
-          param = lookup_for(parts[1])
-
-          @mustace = false
-
-          # finish reading off the close of the handlebars
-          @s.getch
-
-        # {{{expression}} is techically valid, but if we started with {{{ we'll try to read 
-        # }}} off of the close of the handlebars
-          @s.getch if (!@escaped && @s.peek == '}')
-
-          if @comment
-            @comment = false
-            return
-          elsif @partial
-            add_partial(mustache, param)
-            return
-          elsif @inverted
-            add_inverted_section(mustache)
-            return
-          elsif @open_block
-            add_block(mustache, param, parts)
-            return
-          else
-            return this.add_expression(mustache, param)
-          end
-
-          @escaped = true
-        elsif @comment
-          ;
-        else
-          @mustace << chr
-        end
-      end
-    end
-
-  end
-end

data/spec/test_spec.rb

@@ -1,8 +0,0 @@
-require 'spec_helper'
-require 'handlebars'
-
-describe 'something' do
-  it 'instanziates Compiler' do
-    Handlebars::Compiler.new('')
-  end
-end