handlebar 0.2.0 → 0.2.1

data/README.rdoc

@@ -1,6 +1,45 @@
 = handlebar
 
-A simple text templating system
+A simple text template system for generating output for a variety of uses
+including plain-text, HTML, and JavaScript.
+
+== Examples
+
+The straight-forward usage is substitutions:
+
+    template = Handlebar::Template.new("This {{noun}} is {{adjective}}")
+    
+    template.render(:noun => 'shoe', :adjective => 'red')
+    # => "This shoe is red"
+
+If required, the content can be HTML-escaped automatically:
+
+    template = Handlebar::Template.new(
+      "This {{noun}} is {{adjective}}",
+      :escape => :html
+    )
+
+    template.render(:noun => 'goose', :adjective => '<em>blue</em>')
+    # => "This goose is &lt;em&gt;blue&lt;/em&gt;"
+    
+This can also be engaged on a case-by-case basis:
+
+    template = Handlebar::Template.new("This {{&noun}} is {{adjective}}")
+
+    template.render(:noun => '<b>goose</b>', :adjective => '<em>blue</em>')
+    # => "This &lt;b&gt;goose&lt;/b&gt; is <em>blue</em>"
+
+Also available is URI encoding for links:
+
+    template = Handlebar::Template.new(
+      "<a href='/home?user_id={{%user_id}}'>{{&label}}</a>"
+    )
+    
+    template.render(:user_id => 'joe&2', :label => 'Joe&2')
+    # => "<a href='/home?user_id=joe%262'>Joe&amp;2</a>"
+
+A number of other usage cases are described in test/test_handlebar_template.rb
+as a reference.
 
 == Copyright
 

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.2.1

data/handlebar.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{handlebar}
-  s.version = "0.2.0"
+  s.version = "0.2.1"
 
   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.date = %q{2011-07-04}
   s.description = %q{A simple text templating system}
   s.email = %q{github@tadman.ca}
   s.extra_rdoc_files = [

data/lib/handlebar/support.rb

@@ -3,7 +3,7 @@ require 'cgi'
 
 module Handlebar::Support
   def uri_escape(object)
-    URI.escape(object.to_s)
+    URI.escape(object.to_s, /[^a-z0-9\-\.]/i)
   end
   
   def html_escape(object)

data/lib/handlebar/template.rb

@@ -1,7 +1,7 @@
 class Handlebar::Template
   # == Constants ============================================================
   
-  TOKEN_REGEXP = /((?:[^\{]|\{[^\{]|\{\{\{)+)|\{\{\s*([\&\%\$\.\:\?\*\/\=])?([^\}]*)\}\}/.freeze
+  TOKEN_REGEXP = /((?:[^\{]|\{[^\{]|\{\{\{)+)|\{\{\s*([\&\%\$\.\:\*\/\=]|\?\!?)?([^\}]*)\}\}/.freeze
   TOKEN_TRIGGER = /\{\{/.freeze
 
   # == Utility Classes ======================================================
@@ -66,7 +66,11 @@ class Handlebar::Template
       when Array
         variables
       when Hash
-        Hash[variables.collect { |k, v| [ k.to_sym, v ] }]
+        _variables = variables
+        
+        Hash.new do |h, k|
+          h[k] = (_variables[k.to_sym] || _variables[k.to_s])
+        end
       else
         [ variables ]
       end
@@ -75,21 +79,20 @@ class Handlebar::Template
       # 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
-        ]
+        _templates = templates
+        templates = TemplateHash.new do |h, k|
+          v = _templates[k]
+          
+          h[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
@@ -100,6 +103,11 @@ class Handlebar::Template
       when Array
         _parents = parents.dup
         _parent = _parents.shift
+        
+        unless (_parent.is_a?(Handlebar::Template))
+          _parent = self.class.new(_parent, :escape => @escape_method)
+        end
+        
         _parent.render(
           variables,
           templates.merge(
@@ -114,6 +122,21 @@ class Handlebar::Template
             nil => self.to_proc.call(variables, templates)
           )
         )
+      when String
+        _parent = parents
+        
+        unless (_parent.is_a?(Handlebar::Template))
+          _parent = self.class.new(_parent, :escape => @escape_method)
+        end
+        
+        _parent.render(
+          variables,
+          templates.merge(
+            nil => self.to_proc.call(variables, templates)
+          )
+        )
+      else
+        raise ArgumentError, "Invalid options passed in to parents"
       end
     else
       self.to_proc.call(variables, templates)
@@ -141,7 +164,7 @@ class Handlebar::Template
         tag = tag.empty? ? nil : tag.to_sym
         
         case (tag_type)
-        when ?&
+        when '&'
           # HTML escaped
           index = stack[-1][2][tag.inspect]
 
@@ -149,28 +172,28 @@ class Handlebar::Template
           
           variables and variables[tag] = true
 
-        when ?%
+        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 ?$
+        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 ?.
+        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 ?:
+        when ':'
           # Defines start of a :section
           index = stack[-1][2][tag.inspect]
 
@@ -181,7 +204,7 @@ class Handlebar::Template
           source and source << "h.iterate(v){|v|;v=h.cast_as_vars(v, s);"
           
           sections and sections[tag] = true
-        when ??
+        when '?', '?!'
           # Defines start of a ?conditional
           
           stack[-1][2][tag.inspect]
@@ -189,14 +212,14 @@ class Handlebar::Template
           # 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}]);"
+          source and source << "#{tag_type=='?' ? 'if' : 'unless'}(v&&v.is_a?(Hash)&&v[#{tag.inspect}]);"
 
           variables and variables[tag] = true
-        when ?*
+        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 ?/
+        when '/'
           # Closes out a section or conditional
           closed = stack.pop
           
@@ -212,7 +235,7 @@ class Handlebar::Template
           when :base
             raise ParseError, "Unexpected {{#{tag}}}, too many tags closed"
           end
-        when ?=
+        when '='
           # Literal insertion
           index = stack[-1][2][tag.inspect]
 

data/test/test_handlebar_template.rb

@@ -33,6 +33,12 @@ class TestHandlebarTemplate < Test::Unit::TestCase
     assert_equal 'false', template.render
     assert_equal 'true false', template.render(:boolean => true)
     assert_equal 'false', template.render(:boolean => false)
+
+    template = Handlebar::Template.new('{{?boolean}}true{{/}}{{?!boolean}}false{{/}}')
+
+    assert_equal 'false', template.render
+    assert_equal 'true', template.render(:boolean => true)
+    assert_equal 'false', template.render(:boolean => false)
   end
     
   def test_sectioned_templates
@@ -71,6 +77,26 @@ class TestHandlebarTemplate < Test::Unit::TestCase
     assert_equal 'child', template.render(nil, { :example => '{{*parent}}', :parent => 'child' }.freeze)
   end
 
+  def test_dynamic_variables
+    template = Handlebar::Template.new('{{example}}{{text}}', :escape => :html)
+    
+    generator = Hash.new do |h, k|
+      h[k] = "<#{k}>"
+    end
+    
+    assert_equal '&lt;example&gt;&lt;text&gt;', template.render(generator)
+  end
+  
+  def test_dynamic_templates
+    template = Handlebar::Template.new('<{{*example}}>', :escape => :html)
+    
+    generator = Hash.new do |h, k|
+      h[k] = k.to_s.upcase
+    end
+    
+    assert_equal '<EXAMPLE>', template.render(nil, generator)
+  end
+
   def test_missing_templates
     template = Handlebar::Template.new('{{*example}}', :escape => :html)
     
@@ -86,9 +112,9 @@ class TestHandlebarTemplate < Test::Unit::TestCase
   end
   
   def test_parent_templates
-    parent_template = Handlebar::Template.new('{{a}}[{{*}}]{{b}}')
-    child_template = Handlebar::Template.new('{{c}}{{*}}')
-    final_template = Handlebar::Template.new('{{a}}')
+    parent_template = Handlebar::Template.new('{{a}}[{{*}}]{{b}}'.freeze)
+    child_template = Handlebar::Template.new('{{c}}{{*}}'.freeze)
+    final_template = Handlebar::Template.new('{{a}}'.freeze)
     
     variables = { :a => 'A', :b => 'B', :c => 'C' }
     
@@ -96,6 +122,16 @@ class TestHandlebarTemplate < Test::Unit::TestCase
     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_inline_parent_templates
+    template = Handlebar::Template.new('{{a}}')
+    
+    variables = { :a => 'A', :b => 'B', :c => 'C' }
+    
+    assert_equal 'A', template.render(variables)
+    assert_equal 'CA', template.render(variables, nil, '{{c}}{{*}}'.freeze)
+    assert_equal 'A[CA]B', template.render(variables, nil, %w[ {{c}}{{*}} {{a}}[{{*}}]{{b}} ].freeze)
+  end
   
   def test_extract_variables
     template = Handlebar::Template.new('{{a}}{{?b}}{{=c}}{{/b}}{{&d}}{{$e}}{{.f}}{{%g}}{{:h}}{{i}}{{/h}}')

metadata

@@ -2,7 +2,7 @@
 name: handlebar
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - Scott Tadman
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-30 00:00:00 -04:00
+date: 2011-07-04 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency