feather 0.3.0

data/.document

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

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.md

@@ -0,0 +1,52 @@
+# feather
+
+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 = Feather::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 = Feather::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 = Feather::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 = Feather::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 sample template is located in:
+
+    notes/example.ft
+
+A number of other usage cases are described in test/test_feather_template.rb
+as a reference.
+
+## Copyright
+
+Copyright (c) 2011-2012 Scott Tadman, The Working Group Inc.
+See LICENSE.txt for further details.
+

data/Rakefile

@@ -0,0 +1,26 @@
+require 'rubygems'
+
+require 'rake'
+require 'jeweler'
+
+Jeweler::Tasks.new do |gem|
+  gem.name = "feather"
+  gem.homepage = "http://github.com/twg/feather"
+  gem.license = "MIT"
+  gem.summary = %Q{Light-weight text tempating system}
+  gem.description = %Q{A simple light-weight 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/VERSION

@@ -0,0 +1 @@
+0.3.0

data/lib/feather.rb

@@ -0,0 +1,20 @@
+module Feather
+  # == Submodules ===========================================================
+
+  autoload(:Support, 'feather/support')
+  autoload(:Template, 'feather/template')
+
+  def self.version
+    @version ||= File.readlines(
+      File.expand_path('../VERSION', File.dirname(__FILE__))
+  ).first.chomp
+  end
+
+  def self.new(*args)
+    template = Feather::Template.new(*args)
+
+    yield(template) if (block_given?)
+
+    template
+  end
+end

data/lib/feather/support.rb

@@ -0,0 +1,73 @@
+require 'uri'
+require 'cgi'
+
+module Feather::Support
+  def uri_escape(object)
+    URI.escape(object.to_s, /[^a-z0-9\-\.]/i)
+  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
+  
+  def variable_stack(variables, force_as_array = true)
+    case (variables)
+    when Hash
+      remapped = Hash[
+        variables.collect do |k, v|
+          [ k ? k.to_sym : k, variable_stack(v, false) ]
+        end
+      ]
+      
+      if (default = variables.default)
+        remapped.default = default
+      end
+
+      if (default_proc = variables.default_proc)
+        remapped.default_proc = default_proc
+      end
+      
+      remapped
+    when Array
+      variables.collect do |v|
+        variable_stack(v, false)
+      end
+    else
+      force_as_array ? [ variables ] : variables
+    end
+  end
+  
+  extend self
+end

data/lib/feather/template.rb

@@ -0,0 +1,295 @@
+class Feather::Template
+  # == Constants ============================================================
+  
+  TOKEN_REGEXP = /((?:[^\{]|\{[^\{]|\{\{\{)+)|\{\{\s*([\&\%\$\.\:\*\/\=]|\?\!?)?([^\}]*)\}\}/.freeze
+  TOKEN_TRIGGER = /\{\{/.freeze
+    
+  TO_YAML_PROPERTIES = %w[ @content @escape_method ].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
+  class ArgumentError < Exception; end
+  class MissingVariable < Exception ; end
+  class RecursionError < Exception; end
+
+  # == Class Methods ========================================================
+  
+  # == Instance Methods =====================================================
+  
+  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
+        content.read
+      else
+        content.to_s
+      end
+
+    yield(self) if (block_given?)
+  end
+
+  def to_proc
+    @_proc ||= begin
+      source = ''
+
+      self.compile(:source => source, :escape_method => @escape_method)
+
+      eval(source)
+    end
+  end
+  
+  def render(variables = nil, templates = nil, parents = nil)
+    variables = Feather::Support.variable_stack(variables, true)
+    
+    if (templates)
+      # Unless the template options have already been processed, mapping
+      # will need to be performed.
+      unless (templates.is_a?(TemplateHash))
+        _templates = templates
+        templates = TemplateHash.new do |h, k|
+          v = _templates[k]
+          
+          h[k] =
+            case (v)
+            when Feather::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
+        
+        unless (_parent.is_a?(Feather::Template))
+          _parent = self.class.new(_parent, :escape => @escape_method)
+        end
+        
+        _parent.render(
+          variables,
+          templates.merge(
+            nil => self.to_proc.call(variables, templates)
+          ),
+          _parents.empty? ? nil : _parents
+        )
+      when Feather::Template, Proc
+        parents.render(
+          variables,
+          templates.merge(
+            nil => self.to_proc.call(variables, templates)
+          )
+        )
+      when String
+        _parent = parents
+        
+        unless (_parent.is_a?(Feather::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)
+    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
+
+          # The stack will inherit the variable assignment locations from the
+          # existing stack layer.
+          stack << [ :conditional, tag, stack[-1][2] ]
+          source and source << "#{tag_type=='?' ? 'if' : 'unless'}(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=Feather::Support;lambda{|v,t|raise RecursionError if(c);c=true;#{stack_variables}r='';#{source}c=false;r};end")
+    end
+    
+    true
+  end
+  
+  def to_yaml_properties
+    TO_YAML_PROPERTIES
+  end
+  
+  def psych_to_yaml(dump)
+    # Avoid serializing the generated proc by moving it to a temporary
+    # variable for the duration of this operation.
+    _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
+end

data/notes/example.ft

@@ -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,20 @@
+require 'rubygems'
+
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'feather'
+
+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_feather.rb

@@ -0,0 +1,18 @@
+require_relative './helper'
+
+class TestFeather < Test::Unit::TestCase
+  def test_module_loaded
+    assert Feather
+
+    assert Feather.version
+    assert Feather.version.match(/^\d/)
+    assert !Feather.version.match(/\n/)
+  end
+
+  def test_empty_template
+    template = Feather.new('')
+
+    assert template
+    assert_equal '', template.render
+  end
+end

data/test/test_feather_support.rb

@@ -0,0 +1,47 @@
+require_relative './helper'
+
+require 'yaml'
+
+class TestFeatherSupport < Test::Unit::TestCase
+  def test_variable_stack
+    test = { :test => [ { :a => 'a', :b => 'b' }, { :c => 'c' } ] }
+    
+    variables = Feather::Support.variable_stack(test)
+    
+    assert_equal test, variables
+    
+    assert_equal 'a', variables[:test][0][:a]
+    assert_equal 'b', variables[:test][0][:b]
+    assert_equal 'c', variables[:test][1][:c]
+
+    test = { 'test' => [ { 'a' => :a, 'b' => :b }, { 'c' => :c } ] }
+    
+    variables = Feather::Support.variable_stack(test)
+    
+    assert_equal :a, variables[:test][0][:a]
+    assert_equal :b, variables[:test][0][:b]
+    assert_equal :c, variables[:test][1][:c]
+
+    assert_equal 'test',  Feather::Support.variable_stack('test', false)
+    assert_equal [ 'test' ],  Feather::Support.variable_stack('test')
+    assert_equal [ 'test' ],  Feather::Support.variable_stack([ 'test' ], false)
+    assert_equal [ 'test' ],  Feather::Support.variable_stack([ 'test' ])
+    
+    variables = Feather::Support.variable_stack(:head => [ { :tag => 'meta' }, { :tag => 'link' } ])
+    
+    assert_equal 'meta', variables[:head][0][:tag]
+    assert_equal 'link', variables[:head][1][:tag]
+    
+    test = { 'top' => { 'layer' => 'top', 't' => 'top', 'middle' => { 'layer' => 'middle', 'm' => 'middle', 'bottom' => { 'layer' => 'bottom', 'b' => 'bottom' } } } }
+    
+    variables = Feather::Support.variable_stack(test)
+    
+    assert_equal 'top', variables[:top][:t]
+    assert_equal 'middle', variables[:top][:middle][:m]
+    assert_equal 'bottom', variables[:top][:middle][:bottom][:b]
+
+    assert_equal 'top', variables[:top][:layer]
+    assert_equal 'middle', variables[:top][:middle][:layer]
+    assert_equal 'bottom', variables[:top][:middle][:bottom][:layer]
+  end
+end

data/test/test_feather_template.rb

@@ -0,0 +1,246 @@
+require_relative './helper'
+
+require 'yaml'
+
+class TestFeatherTemplate < Test::Unit::TestCase
+  def test_empty_template
+    template = Feather::Template.new('')
+    
+    assert_equal '', template.render
+  end
+
+  def test_simple_templates
+    template = Feather::Template.new('example')
+    
+    assert_equal 'example', template.render
+
+    template = Feather::Template.new('{{{example}}}')
+    
+    assert_equal '{{example}}', template.render
+    
+    template = Feather::Template.new('example {{example}} text')
+    
+    assert_equal 'example something text', template.render(:example => 'something')
+
+    template = Feather::Template.new('example {{  example  }} text')
+    
+    assert_equal 'example something text', template.render(:example => 'something')
+  end
+  
+  def test_boolean_templates
+    template = Feather::Template.new('{{?boolean}}true {{/}}false')
+    
+    assert_equal 'false', template.render
+    assert_equal 'true false', template.render(:boolean => true)
+    assert_equal 'false', template.render(:boolean => false)
+
+    template = Feather::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)
+
+    template = Feather::Template.new('{{?boolean}}{{true}}{{/boolean}}{{?!boolean}}{{false}}{{/boolean}}')
+
+    assert_equal '', template.render
+    assert_equal 'TRUE', template.render(:boolean => true, :true => 'TRUE')
+    assert_equal 'FALSE', template.render(:boolean => false, :false => 'FALSE')
+    
+    template = Feather::Template.new('{{?boolean}}{{/boolean}}{{?!boolean}}{{/boolean}}')
+    
+    assert_equal '', template.render
+    assert_equal '', template.render(:boolean => true)
+    assert_equal '', template.render(:boolean => false)
+  end
+  
+  def test_sectioned_templates
+    template = Feather::Template.new('<head>{{:head}}<{{tag}}>{{/}}</head>')
+    
+    assert_equal '<head><meta></head>', template.render(:head => 'meta')
+    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' => [ :meta, :link ])
+    assert_equal '<head><meta><link></head>', template.render(:head => [ { :tag => 'meta' }, { :tag => '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([ ])
+    assert_equal '<head></head>', template.render({ })
+    assert_equal '<head><></head>', template.render('')
+    assert_equal '<head><></head>', template.render(:head => '')
+    assert_equal '<head></head>', template.render(:head => nil)
+    assert_equal '<head></head>', template.render(:head => [ ])
+
+    template = Feather::Template.new('<div>{{:link}}<a href="{{href}}" alt="{{alt}}">{{/}}</div>')
+    
+    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 = Feather::Template.new('{{example}}', :escape => :html)
+    
+    assert_equal '&lt;strong&gt;', template.render('<strong>')
+
+    template = Feather::Template.new('{{=example}}', :escape => :html)
+    
+    assert_equal '<strong>', template.render('<strong>')
+  end
+
+  def test_recursive_templates
+    template = Feather::Template.new('{{*example}}', :escape => :html)
+    
+    assert_equal 'child', template.render(nil, { :example => '{{*parent}}', :parent => 'child' }.freeze)
+  end
+
+  def test_dynamic_variables
+    template = Feather::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 = Feather::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 = Feather::Template.new('{{*example}}', :escape => :html)
+    
+    assert_equal '', template.render(nil, { })
+  end
+
+  def test_recursive_circular_templates
+    template = Feather::Template.new('{{*reference}}', :escape => :html)
+    
+    assert_exception Feather::Template::RecursionError do
+      template.render(nil, { :reference => '{{*backreference}}', :backreference => '{{*reference}}' }.freeze)
+    end
+  end
+  
+  def test_parent_templates
+    parent_template = Feather::Template.new('{{a}}[{{*}}]{{b}}'.freeze)
+    child_template = Feather::Template.new('{{c}}{{*}}'.freeze)
+    final_template = Feather::Template.new('{{a}}'.freeze)
+    
+    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_inline_parent_templates
+    template = Feather::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 = Feather::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 = Feather::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 = Feather::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 = Feather::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 = Feather::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 = Feather::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
+  
+  def test_with_broken_input
+    template = Feather::Template.new('{{}}')
+    
+    assert_equal '', template.render
+    assert_equal '', template.render(nil)
+    assert_equal '', template.render(nil => nil)
+    
+    template = Feather::Template.new('{{test}}')
+    
+    assert_equal '', template.render(nil => nil)
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: feather
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+  prerelease: 
+platform: ruby
+authors:
+- Scott Tadman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A simple light-weight text templating system
+email: github@tadman.ca
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- .document
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- lib/feather.rb
+- lib/feather/support.rb
+- lib/feather/template.rb
+- notes/example.ft
+- test/helper.rb
+- test/test_feather.rb
+- test/test_feather_support.rb
+- test/test_feather_template.rb
+homepage: http://github.com/twg/feather
+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.8.24
+signing_key: 
+specification_version: 3
+summary: Light-weight text tempating system
+test_files: []