handlebar 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+end

data/Gemfile.lock

@@ -0,0 +1,16 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.9.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.2)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Scott Tadman
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,9 @@
+= handlebar
+
+A simple text templating system
+
+== Copyright
+
+Copyright (c) 2011 Scott Tadman, The Working Group Inc. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rake'
+
+require 'jeweler'
+
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "handlebar"
+  gem.homepage = "http://github.com/twg/handlebar"
+  gem.license = "MIT"
+  gem.summary = %Q{Simple text tempating system}
+  gem.description = %Q{A simple text templating system}
+  gem.email = "github@tadman.ca"
+  gem.authors = [ "Scott Tadman" ]
+end
+
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test

data/lib/handlebar/support.rb

@@ -0,0 +1,46 @@
+require 'uri'
+require 'cgi'
+
+module Handlebar::Support
+  def uri_escape(object)
+    URI.escape(object.to_s)
+  end
+  
+  def html_escape(object)
+    CGI.escapeHTML(object.to_s)
+  end
+  
+  def js_escape(object)
+    object.inspect
+  end
+
+  def css_escape(object)
+    [ object ].flatten.join(' ')
+  end
+  
+  def iterate(object)
+    if (object.respond_to?(:each))
+      object.each do |i|
+        yield(i)
+      end
+    elsif (object)
+      yield(object)
+    end
+  end
+  
+  def cast_as_vars(object, stack)
+    if (object.is_a?(Hash))
+      stack.each do |parent|
+        if (parent.is_a?(Hash))
+          object = parent.merge(object)
+        end
+      end
+    
+      object
+    else
+      object.respond_to?(:each) ? object : [ object ]
+    end
+  end
+  
+  extend self
+end

data/lib/handlebar/template.rb

@@ -0,0 +1,155 @@
+class Handlebar::Template
+  # == Constants ============================================================
+  
+  TOKEN_REGEXP = /((?:[^\{]|\{[^\{]|\{\{\{)+)|\{\{\s*([\&\%\$\.\:\?\*\/\=])?([^\}]*)\}\}/.freeze
+  TOKEN_TRIGGER = /\{\{/.freeze
+
+  # == Exceptions ===========================================================
+  
+  class ParseError < Exception ; end
+  class ArgumentError < Exception; end
+  class MissingVariable < Exception ; end
+  class RecursionError < Exception; end
+
+  # == Class Methods ========================================================
+
+  # == Instance Methods =====================================================
+  
+  def initialize(content, context = nil)
+    @context = context
+    @content =
+      case (content)
+      when IO
+        content.read
+      else
+        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
+
+              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}"
+
+      eval(source)
+    end
+  end
+  
+  def interpret(variables = nil, templates = nil)
+    variables =
+      case (variables)
+      when Array
+        variables
+      when Hash
+        Hash[variables.collect { |k, v| [ k.to_sym, v ] }]
+      else
+        [ variables ]
+      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
+            end
+          ]
+        end
+      ]
+    end
+    
+    self.to_proc.call(variables, templates)
+  end
+  alias_method :call, :interpret
+end

data/lib/handlebar.rb

@@ -0,0 +1,6 @@
+module Handlebar
+  # == Submodules ===========================================================
+
+  autoload(:Support, 'handlebar/support')
+  autoload(:Template, 'handlebar/template')
+end

data/notes/example.hb

@@ -0,0 +1,30 @@
+This is an example document with simple {{placeholder}} values included.
+
+Each of these {{variable}} substitutions can be either {{simple}},
+{{=literal}}, {{%url_escaped}}, {{.css_escaped}}, {{$json_escaped}} or
+{{&html_escaped}} depending on preference.
+
+It's even possible to place other {{*templates}} by name using the standard
+markup, or include or default one using {{*}} instead of {{default}}.
+
+Sometimes it's practical to define a block which can be re-used. These are
+called sections:
+
+{{:section}}
+{{title}}
+
+{{:bullet_point}}
+* {{point}}
+{{/}}
+{{/:section}}
+
+{{?conditional}}
+It's also possible to render sections conditionally by testing if a value
+is present and true.
+{{/}}
+
+* For avoiding interpolation, {{{three}}} or more braces can be used. The
+  outer most ones are always stripped, the rest left alone.
+
+* Entire sections can be left unprocessed by declaring {{#raw}} which will
+  be terminated upon the first instance of {{#/}} if found.

data/test/helper.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'handlebar'
+
+class Test::Unit::TestCase
+  def assert_exception(exception_class, message = nil)
+    begin
+      yield
+    rescue exception_class
+      # Expected
+    else
+      flunk message || "Did not raise #{exception_class}"
+    end
+  end
+end

data/test/test_handlebar.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestHandlebar < Test::Unit::TestCase
+  def test_empty_template
+    template = Handlebar::Template.new('')
+  end
+end

data/test/test_handlebar_template.rb

@@ -0,0 +1,85 @@
+require 'helper'
+
+class TestHandlebarTemplate < Test::Unit::TestCase
+  def test_empty_template
+    template = Handlebar::Template.new('')
+    
+    assert_equal '', template.interpret
+  end
+
+  def test_simple_templates
+    template = Handlebar::Template.new('example')
+    
+    assert_equal 'example', template.interpret
+
+    template = Handlebar::Template.new('{{{example}}}')
+    
+    assert_equal '{{example}}', template.interpret
+    
+    template = Handlebar::Template.new('example {{example}} text')
+    
+    assert_equal 'example something text', template.interpret(:example => 'something')
+
+    template = Handlebar::Template.new('example {{  example  }} text')
+    
+    assert_equal 'example something text', template.interpret(: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)
+  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 => [ ])
+
+    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 => [ ])
+  end
+  
+  def test_template_with_context
+    template = Handlebar::Template.new('{{example}}', :html)
+    
+    assert_equal '&lt;strong&gt;', template.interpret('<strong>')
+
+    template = Handlebar::Template.new('{{=example}}', :html)
+    
+    assert_equal '<strong>', template.interpret('<strong>')
+  end
+
+  def test_recursive_templates
+    template = Handlebar::Template.new('{{*example}}', :html)
+    
+    assert_equal 'child', template.interpret(nil, { :example => '{{*parent}}', :parent => 'child' })
+  end
+
+  def test_missing_templates
+    template = Handlebar::Template.new('{{*example}}', :html)
+    
+    assert_equal '', template.interpret(nil, { })
+  end
+
+  def test_recursive_circular_templates
+    template = Handlebar::Template.new('{{*reference}}', :html)
+    
+    assert_exception Handlebar::Template::RecursionError do
+      template.interpret(nil, { :reference => '{{*backreference}}', :backreference => '{{*reference}}' })
+    end
+  end
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: handlebar
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Scott Tadman
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-29 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.5.2
+  type: :development
+  version_requirements: *id002
+description: A simple text templating system
+email: github@tadman.ca
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- 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
+has_rdoc: true
+homepage: http://github.com/twg/handlebar
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.3
+signing_key: 
+specification_version: 3
+summary: Simple text tempating system
+test_files: 
+- test/helper.rb
+- test/test_handlebar.rb
+- test/test_handlebar_template.rb