handlebar 0.1.0 → 0.2.0

data/VERSION

@@ -0,0 +1 @@
+0.2.0

data/handlebar.gemspec

@@ -0,0 +1,62 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{handlebar}
+  s.version = "0.2.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Scott Tadman"]
+  s.date = %q{2011-06-30}
+  s.description = %q{A simple text templating system}
+  s.email = %q{github@tadman.ca}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "handlebar.gemspec",
+    "lib/handlebar.rb",
+    "lib/handlebar/support.rb",
+    "lib/handlebar/template.rb",
+    "notes/example.hb",
+    "test/helper.rb",
+    "test/test_handlebar.rb",
+    "test/test_handlebar_template.rb"
+  ]
+  s.homepage = %q{http://github.com/twg/handlebar}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.5.3}
+  s.summary = %q{Simple text tempating system}
+  s.test_files = [
+    "test/helper.rb",
+    "test/test_handlebar.rb",
+    "test/test_handlebar_template.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+    else
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    end
+  else
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+  end
+end
+

data/lib/handlebar/template.rb

@@ -4,6 +4,18 @@ class Handlebar::Template
   TOKEN_REGEXP = /((?:[^\{]|\{[^\{]|\{\{\{)+)|\{\{\s*([\&\%\$\.\:\?\*\/\=])?([^\}]*)\}\}/.freeze
   TOKEN_TRIGGER = /\{\{/.freeze
 
+  # == Utility Classes ======================================================
+  
+  class TemplateHash < Hash; end
+
+  class VariableTracker < Hash
+    def initialize
+      super do |h, k|
+        h[k] = h.length
+      end
+    end
+  end
+
   # == Exceptions ===========================================================
   
   class ParseError < Exception ; end
@@ -15,8 +27,20 @@ class Handlebar::Template
 
   # == Instance Methods =====================================================
   
-  def initialize(content, context = nil)
-    @context = context
+  def initialize(content, options = nil)
+    if (options)
+      if (source = options[:escape])
+        case (source.to_sym)
+        when :html, :html_escape
+          @escape_method = :html_escape
+        when :text, nil
+          # Default, ignored
+        else
+          raise ArgumentError, "Unknown escape source #{source}"
+        end
+      end
+    end
+    
     @content =
       case (content)
       when IO
@@ -25,102 +49,18 @@ class Handlebar::Template
         content.to_s
       end
   end
-  
+
   def to_proc
-    @proc ||= begin
-      method = ''
-      variables = nil
-      stack = [ [ :base, nil, 0 ] ]
-      h = Handlebar::Support
-      
-      @content.scan(TOKEN_REGEXP).each do |text, tag_type, tag|
-        if (text)
-          text = text.sub(/\{(\{\{+)/, '\1').sub(/\}(\}\}+)/, '\1')
-          
-          method << "r<<#{text.inspect};"
-        else
-          tag = tag.strip
-          
-          case (tag_type)
-          when ?&
-            # HTML escaped
-            method << "v&&r<<h.html_escape(v[#{tag.to_sym.inspect}].to_s);"
-          when ?%
-            # URI escaped
-            method << "v&&r<<h.uri_escape(v[#{tag.to_sym.inspect}].to_s);"
-          when ?$
-            # JavaScript escaped
-            method << "v&&r<<h.js_escape(v[#{tag.to_sym.inspect}].to_s);"
-          when ?.
-            # CSS escaped
-            method << "v&&r<<h.css_escape(v[#{tag.to_sym.inspect}].to_s);"
-          when ?:
-            # Defines start of a :section
-            variables ||= 's=[];'
-            stack << [ :section, tag, 0 ]
-            method << "if(v);s<<v;v=v.is_a?(Hash)&&v[#{tag.to_sym.inspect}];"
-            method << "h.iterate(v){|v|;v=h.cast_as_vars(v, s);"
-          when ??
-            # Defines start of a ?conditional
-            stack << [ :conditional, tag ]
-            method << "if(v&&v.is_a?(Hash)&&v[#{tag.to_sym.inspect}]);"
-          when ?*
-            method << "_t=t&&t[#{tag.to_sym.inspect}];r<<(_t.respond_to?(:call)?_t.call(v,t):_t.to_s);"
-          when ?/
-            # Closes out a section or conditional
-            closed = stack.pop
-            
-            case (closed[0])
-            when :section
-              unless (tag == closed[1] or tag.empty?)
-                raise ParseError, "Template contains unexpected {{#{tag}}}, expected {{#{closed[1]}}}"
-              end
+    @_proc ||= begin
+      source = ''
 
-              method << "};v=s.pop;end;"
-            when :conditional
-              method << "end;"
-            when :base
-              raise ParseError, "Unexpected {{#{tag}}}, too many tags closed"
-            end
-          when ?=
-            # Literal insertion
-            method << "v&&r<<(v.is_a?(Array)?v[#{stack[-1][2]}]:v[#{tag.to_sym.inspect}]).to_s;"
-
-            stack[-1][2] += 1
-          else
-            # Contextual insertion
-            subst = "v.is_a?(Array)?v[#{stack[-1][2]}]:v[#{tag.to_sym.inspect}]"
-            
-            if (@context)
-              method << "v&&r<<h.#{@context}_escape(#{subst}.to_s);"
-            else
-              method << "v&&r<<(#{subst}).to_s;"
-            end
-            
-            stack[-1][2] += 1
-          end
-        end
-      end
-      
-      unless (stack.length == 1)
-        case (stack[1][0])
-        when :section
-          raise ParseError, "Unclosed {{:#{stack[1][1]}}} in template"
-        when :conditional
-          raise ParseError, "Unclosed {{?#{stack[1][1]}}} in template"
-        else
-          raise ParseError, "Unclosed {{#{stack[1][1]}}} in template"
-        end
-      end
-      
-      c = false
-      source = "lambda{|v,t|raise RecursionError if(c);c=true;#{variables}r='';#{method}c=false;r}"
+      self.compile(:source => source, :escape_method => @escape_method)
 
       eval(source)
     end
   end
   
-  def interpret(variables = nil, templates = nil)
+  def render(variables = nil, templates = nil, parents = nil)
     variables =
       case (variables)
       when Array
@@ -132,24 +72,205 @@ class Handlebar::Template
       end
       
     if (templates)
-      templates = Hash[
-        templates.collect do |k, v|
-          [
-            k,
-            case (v)
-            when Handlebar::Template, Proc
-              v
-            when TOKEN_TRIGGER
-              self.class.new(v)
-            else
-              v.to_s
+      # Unless the template options have already been processed, mapping
+      # will need to be performed.
+      unless (templates.is_a?(TemplateHash))
+        templates = TemplateHash[
+          templates.collect do |k, v|
+            [
+              k,
+              case (v)
+              when Handlebar::Template, Proc, Array
+                v
+              when TOKEN_TRIGGER
+                self.class.new(v, :escape => @escape_method)
+              else
+                v.to_s
+              end
+            ]
+          end
+        ]
+      end
+    else
+      templates = TemplateHash.new
+    end
+    
+    if (parents)
+      case (parents)
+      when Array
+        _parents = parents.dup
+        _parent = _parents.shift
+        _parent.render(
+          variables,
+          templates.merge(
+            nil => self.to_proc.call(variables, templates)
+          ),
+          _parents.empty? ? nil : _parents
+        )
+      when Handlebar::Template, Proc
+        parents.render(
+          variables,
+          templates.merge(
+            nil => self.to_proc.call(variables, templates)
+          )
+        )
+      end
+    else
+      self.to_proc.call(variables, templates)
+    end
+  end
+  alias_method :call, :render
+
+  def compile(options)
+    escape_method = options[:escape_method]
+    sections = options[:sections]
+    templates = options[:templates]
+    variables = options[:variables]
+    source = options[:source]
+
+    stack = [ [ :base, nil, VariableTracker.new ] ]
+    stack_variables = nil
+    
+    @content.scan(TOKEN_REGEXP).each do |text, tag_type, tag|
+      if (text)
+        text = text.sub(/\{(\{\{+)/, '\1').sub(/\}(\}\}+)/, '\1')
+        
+        source and source << "r<<#{text.inspect};"
+      else
+        tag = tag.strip
+        tag = tag.empty? ? nil : tag.to_sym
+        
+        case (tag_type)
+        when ?&
+          # HTML escaped
+          index = stack[-1][2][tag.inspect]
+
+          source and source << "v&&r<<h.html_escape(v[#{tag.inspect}].to_s);"
+          
+          variables and variables[tag] = true
+
+        when ?%
+          # URI escaped
+          index = stack[-1][2][tag.inspect]
+
+          source and source << "v&&r<<h.uri_escape(v.is_a?(Array)?v[#{index}]:v[#{tag.inspect}]);"
+
+          variables and variables[tag] = true
+        when ?$
+          # JavaScript escaped
+          index = stack[-1][2][tag.inspect]
+
+          source and source << "v&&r<<h.js_escape(v.is_a?(Array)?v[#{index}]:v[#{tag.inspect}]);"
+
+          variables and variables[tag] = true
+        when ?.
+          # CSS escaped
+          index = stack[-1][2][tag.inspect]
+
+          source and source << "v&&r<<h.css_escape(v.is_a?(Array)?v[#{index}]:v[#{tag.inspect}]);"
+
+          variables and variables[tag] = true
+        when ?:
+          # Defines start of a :section
+          index = stack[-1][2][tag.inspect]
+
+          stack_variables ||= 's=[];'
+          stack << [ :section, tag, VariableTracker.new ]
+
+          source and source << "if(v);s<<v;v=v.is_a?(Array)?v[#{index}]:(v.is_a?(Hash)&&v[#{tag.inspect}]);"
+          source and source << "h.iterate(v){|v|;v=h.cast_as_vars(v, s);"
+          
+          sections and sections[tag] = true
+        when ??
+          # Defines start of a ?conditional
+          
+          stack[-1][2][tag.inspect]
+
+          # The stack will inherit the variable assignment locations from the
+          # existing stack layer.
+          stack << [ :conditional, tag, stack[-1][2] ]
+          source and source << "if(v&&v.is_a?(Hash)&&v[#{tag.inspect}]);"
+
+          variables and variables[tag] = true
+        when ?*
+          source and source << "_t=t&&t[#{tag.inspect}];r<<(_t.respond_to?(:call)?_t.call(v,t):_t.to_s);"
+          
+          templates and templates[tag] = true
+        when ?/
+          # Closes out a section or conditional
+          closed = stack.pop
+          
+          case (closed[0])
+          when :section
+            if (tag and tag != closed[1])
+              raise ParseError, "Template contains unexpected {{#{tag}}}, expected {{#{closed[1]}}}"
             end
-          ]
+            
+            source and source << "};v=s.pop;end;"
+          when :conditional
+            source and source << "end;"
+          when :base
+            raise ParseError, "Unexpected {{#{tag}}}, too many tags closed"
+          end
+        when ?=
+          # Literal insertion
+          index = stack[-1][2][tag.inspect]
+
+          source and source << "v&&r<<(v.is_a?(Array)?v[#{index}]:v[#{tag.inspect}]).to_s;"
+
+          variables and variables[tag] = true
+        else
+          # Contextual insertion
+          index = stack[-1][2][tag.inspect]
+
+          subst = "v.is_a?(Array)?v[#{stack[-1][2][tag.inspect]}]:v[#{tag.inspect}]"
+          
+          if (escape_method)
+            source and source << "v&&r<<h.#{escape_method}(#{subst}.to_s);"
+          else
+            source and source << "v&&r<<(#{subst}).to_s;"
+          end
+
+          variables and variables[tag] = true
         end
-      ]
+      end
+    end
+    
+    unless (stack.length == 1)
+      case (stack[1][0])
+      when :section
+        raise ParseError, "Unclosed {{:#{stack[1][1]}}} in template"
+      when :conditional
+        raise ParseError, "Unclosed {{?#{stack[1][1]}}} in template"
+      else
+        raise ParseError, "Unclosed {{#{stack[1][1]}}} in template"
+      end
+    end
+    
+    if (source)
+      source.replace("begin;c=false;h=Handlebar::Support;lambda{|v,t|raise RecursionError if(c);c=true;#{stack_variables}r='';#{source}c=false;r};end")
     end
     
-    self.to_proc.call(variables, templates)
+    true
+  end
+  
+  def to_yaml(dump)
+    _proc, @_proc = @_proc, nil
+    
+    super(dump)
+    
+    @_proc = _proc
+    
+    dump
+  end
+    
+  def marshal_dump
+    [ @content, { :escape => @escape_method } ]
+  end
+  
+  def marshal_load(dump)
+    @content, options = dump
+    
+    @escape_method = options[:escape]
   end
-  alias_method :call, :interpret
 end

data/test/test_handlebar_template.rb

@@ -1,85 +1,179 @@
 require 'helper'
 
+require 'yaml'
+
 class TestHandlebarTemplate < Test::Unit::TestCase
   def test_empty_template
     template = Handlebar::Template.new('')
     
-    assert_equal '', template.interpret
+    assert_equal '', template.render
   end
 
   def test_simple_templates
     template = Handlebar::Template.new('example')
     
-    assert_equal 'example', template.interpret
+    assert_equal 'example', template.render
 
     template = Handlebar::Template.new('{{{example}}}')
     
-    assert_equal '{{example}}', template.interpret
+    assert_equal '{{example}}', template.render
     
     template = Handlebar::Template.new('example {{example}} text')
     
-    assert_equal 'example something text', template.interpret(:example => 'something')
+    assert_equal 'example something text', template.render(:example => 'something')
 
     template = Handlebar::Template.new('example {{  example  }} text')
     
-    assert_equal 'example something text', template.interpret(:example => 'something')
+    assert_equal 'example something text', template.render(:example => 'something')
   end
   
   def test_boolean_templates
     template = Handlebar::Template.new('{{?boolean}}true {{/}}false')
     
-    assert_equal 'false', template.interpret
-    assert_equal 'true false', template.interpret(:boolean => true)
-    assert_equal 'false', template.interpret(:boolean => false)
+    assert_equal 'false', template.render
+    assert_equal 'true false', template.render(:boolean => true)
+    assert_equal 'false', template.render(:boolean => false)
   end
     
   def test_sectioned_templates
     template = Handlebar::Template.new('<head>{{:head}}<{{tag}}>{{/}}</head>')
     
-    assert_equal '<head><meta></head>', template.interpret(:head => 'meta')
-    assert_equal '<head><meta><link></head>', template.interpret(:head => %w[ meta link ])
-    assert_equal '<head><meta><link></head>', template.interpret(:head => [ { :tag => 'meta' }, { :tag => 'link' } ])
-    assert_equal '<head></head>', template.interpret
-    assert_equal '<head></head>', template.interpret(:head => nil)
-    assert_equal '<head></head>', template.interpret(:head => [ ])
+    assert_equal '<head><meta></head>', template.render(:head => 'meta')
+    assert_equal '<head><meta><link></head>', template.render(:head => %w[ meta link ])
+    assert_equal '<head><meta><link></head>', template.render(:head => [ { :tag => 'meta' }, { :tag => 'link' } ])
+    assert_equal '<head></head>', template.render
+    assert_equal '<head></head>', template.render(:head => nil)
+    assert_equal '<head></head>', template.render(:head => [ ])
 
     template = Handlebar::Template.new('<div>{{:link}}<a href="{{href}}" alt="{{alt}}">{{/}}</div>')
     
-    assert_equal '<div><a href="meta" alt=""></div>', template.interpret(:link => 'meta')
-    assert_equal '<div><a href="meta" alt="link"></div>', template.interpret(:link => [ %w[ meta link ] ])
-    assert_equal '<div><a href="/h" alt=""><a href="" alt="alt"><a href="/" alt="top"></div>', template.interpret(:link => [ { :href => '/h' }, { :alt => 'alt' }, { :href => '/', :alt => 'top' } ])
-    assert_equal '<div></div>', template.interpret
-    assert_equal '<div></div>', template.interpret(:link => nil)
-    assert_equal '<div></div>', template.interpret(:link => [ ])
+    assert_equal '<div><a href="meta" alt=""></div>', template.render(:link => 'meta')
+    assert_equal '<div><a href="meta" alt="link"></div>', template.render(:link => [ %w[ meta link ] ])
+    assert_equal '<div><a href="/h" alt=""><a href="" alt="alt"><a href="/" alt="top"></div>', template.render(:link => [ { :href => '/h' }, { :alt => 'alt' }, { :href => '/', :alt => 'top' } ])
+    assert_equal '<div></div>', template.render
+    assert_equal '<div></div>', template.render(:link => nil)
+    assert_equal '<div></div>', template.render(:link => [ ])
   end
   
   def test_template_with_context
-    template = Handlebar::Template.new('{{example}}', :html)
+    template = Handlebar::Template.new('{{example}}', :escape => :html)
     
-    assert_equal '&lt;strong&gt;', template.interpret('<strong>')
+    assert_equal '&lt;strong&gt;', template.render('<strong>')
 
-    template = Handlebar::Template.new('{{=example}}', :html)
+    template = Handlebar::Template.new('{{=example}}', :escape => :html)
     
-    assert_equal '<strong>', template.interpret('<strong>')
+    assert_equal '<strong>', template.render('<strong>')
   end
 
   def test_recursive_templates
-    template = Handlebar::Template.new('{{*example}}', :html)
+    template = Handlebar::Template.new('{{*example}}', :escape => :html)
     
-    assert_equal 'child', template.interpret(nil, { :example => '{{*parent}}', :parent => 'child' })
+    assert_equal 'child', template.render(nil, { :example => '{{*parent}}', :parent => 'child' }.freeze)
   end
 
   def test_missing_templates
-    template = Handlebar::Template.new('{{*example}}', :html)
+    template = Handlebar::Template.new('{{*example}}', :escape => :html)
     
-    assert_equal '', template.interpret(nil, { })
+    assert_equal '', template.render(nil, { })
   end
 
   def test_recursive_circular_templates
-    template = Handlebar::Template.new('{{*reference}}', :html)
+    template = Handlebar::Template.new('{{*reference}}', :escape => :html)
     
     assert_exception Handlebar::Template::RecursionError do
-      template.interpret(nil, { :reference => '{{*backreference}}', :backreference => '{{*reference}}' })
+      template.render(nil, { :reference => '{{*backreference}}', :backreference => '{{*reference}}' }.freeze)
     end
   end
+  
+  def test_parent_templates
+    parent_template = Handlebar::Template.new('{{a}}[{{*}}]{{b}}')
+    child_template = Handlebar::Template.new('{{c}}{{*}}')
+    final_template = Handlebar::Template.new('{{a}}')
+    
+    variables = { :a => 'A', :b => 'B', :c => 'C' }
+    
+    assert_equal 'A', final_template.render(variables)
+    assert_equal 'CA', final_template.render(variables, nil, child_template)
+    assert_equal 'A[CA]B', final_template.render(variables, nil, [ child_template, parent_template ].freeze)
+  end
+  
+  def test_extract_variables
+    template = Handlebar::Template.new('{{a}}{{?b}}{{=c}}{{/b}}{{&d}}{{$e}}{{.f}}{{%g}}{{:h}}{{i}}{{/h}}')
+    
+    variables = { }
+    sections = { }
+    templates = { }
+
+    template.compile(
+      :variables => variables,
+      :sections => sections,
+      :templates => templates
+    )
+    
+    assert_equal [ :a, :b, :c, :d, :e, :f, :g, :i ], variables.keys.sort_by(&:to_s)
+    assert_equal [ :h ], sections.keys.sort_by(&:to_s)
+    assert_equal [ ], templates.keys.sort_by(&:to_s)
+  end
+
+  def test_chain_extract_variables
+    template = Handlebar::Template.new('{{a}}{{?b}}{{=c}}{{/b}}{{&d}}{{$e}}{{.f}}{{%g}}{{:h}}{{i}}{{/h}}')
+    
+    variables = { :x => true }
+    sections = { :y => true }
+    templates = { :z => true }
+
+    template.compile(
+      :variables => variables,
+      :sections => sections,
+      :templates => templates
+    )
+    
+    assert_equal [ :a, :b, :c, :d, :e, :f, :g, :i, :x ], variables.keys.sort_by(&:to_s)
+    assert_equal [ :h, :y ], sections.keys.sort_by(&:to_s)
+    assert_equal [ :z ], templates.keys.sort_by(&:to_s)
+  end
+
+  def test_variable_tracker
+    tracker = Handlebar::Template::VariableTracker.new
+    
+    assert_equal true, tracker.empty?
+    assert_equal 0, tracker[:a]
+    assert_equal 1, tracker[:b]
+    assert_equal 2, tracker[:c]
+    assert_equal 0, tracker[:a]
+    assert_equal 2, tracker[:c]
+    assert_equal 3, tracker[:z]
+  end
+  
+  def test_clone
+    template = Handlebar::Template.new('<p>{{example}}</p>', :escape => :html)
+  
+    cloned = template.clone
+    
+    assert_equal '<p>&lt;strong&gt;</p>', cloned.render('<strong>')
+  end
+  
+  def test_serialization_with_yaml
+    template = Handlebar::Template.new('<p>{{example}}</p>', :escape => :html)
+    
+    assert_equal '<p>&lt;strong&gt;</p>', template.render('<strong>')
+    
+    serialized_template = YAML.dump(template)
+    
+    deserialized_template = YAML.load(serialized_template)
+    
+    assert_equal '<p>&lt;strong&gt;</p>', deserialized_template.render('<strong>')
+  end
+
+  def test_serialization_with_marshal
+    template = Handlebar::Template.new('<p>{{example}}</p>', :escape => :html)
+    
+    assert_equal '<p>&lt;strong&gt;</p>', template.render('<strong>')
+    
+    serialized_template = Marshal.dump(template)
+    
+    deserialized_template = Marshal.load(serialized_template)
+    
+    assert_equal '<p>&lt;strong&gt;</p>', deserialized_template.render('<strong>')
+  end
 end

metadata

@@ -2,7 +2,7 @@
 name: handlebar
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Scott Tadman
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-29 00:00:00 -04:00
+date: 2011-06-30 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -51,6 +51,8 @@ files:
 - LICENSE.txt
 - README.rdoc
 - Rakefile
+- VERSION
+- handlebar.gemspec
 - lib/handlebar.rb
 - lib/handlebar/support.rb
 - lib/handlebar/template.rb