mattly-hpreserve 0.2.1

data/README.mkdn

@@ -0,0 +1,90 @@
+# Hpreserve
+
+by Matthew Lyon <matt@flowerpowered.com>
+
+## DESCRIPTION:
+
+Hpreserve is a humane, eval-safe template system built atop the Hpricot DOM
+manipulation library. Its primary goal is to not require an interpreter to preview
+a design in a browser. The designer provides their own sample data which is replaced
+by the template parser at runtime.
+
+Unlike similar DOM-replacement libraries lilu and Amrita, Hpreserve does not rely
+on matching DOM IDs to variable names, recognizing that DOM IDs often have semantic
+meaning in their own right. Rather, templates are driven by custom attributes on 
+DOM elements that are removed at runtime.
+
+## FEATURES/PROBLEMS:
+
+* Content Replacement: elements with a "content" attribute will have their contents
+  replaced with the equivalent variable. Namespaced variables are available to the
+  template using '.' to separate the namespaces.
+
+* Content Replacement with Collections: if the variable for an element's content
+  attribute returns an Array, the element's first child node will be used as a 
+  template for iterating over the content of the array. While iterating, the current
+  item in the array is made available as a variable specified by the parent element's
+  "local" attribute:
+  
+  `<ul content='album.songs' local='song'><li content='song.name'>Song Name</li></ul>`
+  
+  **TODO**: Currently, no attempt is made to prevent this local context variable naame 
+  from clobbering an equivalent variable name elsewhere in the variable namespace.
+
+* Partial Includes: Since this huge productivity booster can be replicated in 
+  Textmate (and presumably other decent html editors), elements with an "include"
+  tag have their content replaced by the given variable. You may provide a default 'root'
+  in the variable namespace with "include_base=". Variable substitution is performed
+  on the given value, and a default is available:
+  
+  `<div include='{section.name}_sidebar | sidebar'></div>`
+  
+  This would render f.e. 'blog_sidebar' if 'section.name' resolved to 'blog'. If this
+  value returns empty (that is, there is no 'blog_sidebar') it will render the default
+  'sidebar' instead.
+
+* Filters: given by an element's "filter" attribute and specified using a syntax 
+  similar to the "style" attribute in HTML, filters operate on the node itself, 
+  either modifying the element's contents or altering the element's properties. Filter
+  directives are separated by semi-colons, they may be given arguments after a colon, and
+  multiple arguments are separated by commas:
+  
+  `<a filter='capitalize; link_to: {thing.link}; truncate: 30, ...'>text</a>`
+  
+* Planned Features include more sophisticated controls for iterating over an array
+  variable, and methods for escaping html entities in variables, including an option
+  to do this automatically.
+
+## SYNOPSIS:
+
+    template = File.open('example.html')
+    variables = {'name' => 'value'}
+    Hpreserve::Parser.render(template, variables)
+
+## REQUIREMENTS:
+
+* Hpricot
+* Rspec, if you wish to run the spec suite
+
+## LICENSE:
+
+Copyright (c) 2008 Matt Lyon
+
+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/Rakefile

@@ -0,0 +1,40 @@
+require "rake"
+require "rake/gempackagetask"
+Dir['tasks/**/*.rake'].each { |rake| load rake }
+
+desc "Run the specs."
+task :default => :spec
+
+spec = Gem::Specification.new do |s|
+  s.name         = 'hpreserve'
+  s.version      = '0.2.1'
+  s.summary      = "eval-safe HTML templates using HTML"
+  s.description  = "A humane, eval-safe HTML templating system expressed in HTML."
+
+  s.author       = "Matthew Lyon"
+  s.email        = "matt@flowerpowered.com"
+  s.homepage     = "http://github.com/mattly/hpreserve"
+  
+  # code
+  s.require_path = "lib"
+  s.files        = %w( README.mkdn Rakefile ) + Dir["{spec,lib}/**/*"]
+ 
+  # rdoc
+  s.has_rdoc         = false
+ 
+  # Dependencies
+  s.add_dependency "hpricot", [">= 0.6.0"]
+  
+  # Requirements
+  s.required_ruby_version = ">= 1.8.6"
+  
+  s.platform = Gem::Platform::RUBY
+end
+
+desc "create .gemspec file (useful for github)"
+task :gemspec do
+  filename = "#{spec.name}.gemspec"
+  File.open(filename, "w") do |f|
+    f.puts spec.to_ruby
+  end
+end

data/lib/hpreserve.rb

@@ -0,0 +1,13 @@
+$:.unshift File.dirname(__FILE__)
+
+module Hpreserve
+  
+end
+
+require 'hpreserve/parser'
+require 'hpreserve/extensions'
+require 'hpreserve/abstract_cacher'
+require 'hpreserve/file_cacher'
+require 'hpreserve/variables'
+require 'hpreserve/filters'
+require 'hpreserve/standard_filters'

data/lib/hpreserve/abstract_cacher.rb

@@ -0,0 +1,35 @@
+module Hpreserve
+  class AbstractCacher
+    
+    attr_accessor :patterns, :storage
+    
+    def initialize(patterns)
+      self.patterns = patterns
+    end
+    
+    def match?(variable)
+      pattern = patterns.detect {|p| variable.match(p[:match]) }
+      return nil unless pattern
+      variable.gsub(pattern[:match], pattern[:key])
+    end
+    
+    
+    # overwrite these in your ConcreteCacher to do use whatever you use
+    
+    def retrieve(key)
+      @storage ||= {}
+      storage[key]
+    end
+    
+    def store(key, value)
+      @storage ||= {}
+      storage[key] = value
+    end
+    
+    def expire(pattern)
+      @storage ||= {}
+      storage.delete_if {|key, value| key.match(pattern) }
+    end
+    
+  end
+end

data/lib/hpreserve/extensions.rb

@@ -0,0 +1,17 @@
+require 'time'
+require 'date'
+
+class Proc
+  def to_hpreserve
+    self.call
+  end
+end
+
+class Time
+  def to_hpreserve
+    { 'default' => self.rfc2822, 
+      'year' => self.year, 'month' => self.month, 'day' => self.day,
+      'short' => self.strftime('%e %b %y, %H:%M'), 
+      'long' => self.strftime('%A %e %B %Y, %I:%M%p') }
+  end
+end

data/lib/hpreserve/file_cacher.rb

@@ -0,0 +1,25 @@
+class Hpreserve::FileCacher < Hpreserve::AbstractCacher
+  
+  attr_accessor :base_dir
+  
+  def initialize(patterns, base)
+    super(patterns)
+    self.base_dir = base
+  end
+  
+  def store(key, value)
+    file = File.join(base_dir, key)
+    FileUtils.mkdir_p(File.dirname(file)) unless File.directory?(File.dirname(file)) 
+    File.open(file, 'w') {|f| f << value }
+  end
+  
+  def retrieve(key)
+    file = File.join(base_dir, key)
+    File.read(file) if File.exists?(file)
+  end
+  
+  def expire(keys)
+    Dir[File.join(base_dir, keys)].each {|f| File.delete(f) }
+  end
+  
+end

data/lib/hpreserve/filters.rb

@@ -0,0 +1,74 @@
+module Hpreserve
+  
+  # todo: rewrite this
+  
+  # Acts as a sandbox to run filters in, most everything except the self.parse method
+  # was stolen from Liquid's Strainer class. Almost all the standard class methods
+  # (especially instance_eval) are undefined, and respond_to? is modified to only
+  # return true on methods defined by the filter modules registered.
+  class Filters
+    
+    @@filter_modules = []
+    
+    def self.register(filterset)
+      [filterset].flatten.each do |mod|
+        raise StandardError("passed filter is not a module") unless mod.is_a?(Module)
+        @@filter_modules << mod
+      end
+    end
+    
+    def self.create
+      filterset = Filters.new
+      @@filter_modules.each { |m| filterset.extend m }
+      filterset
+    end
+    
+    # The filter parser expects a string formatted similar to an html element's "style"
+    # attribute:
+    # 
+    #   * <tt>filter="date: %d %b; truncate_words: 15, ...; capitalize"</tt>
+    #
+    # (to provide an example of two currently filters you wouldn't use
+    # together...) (todo: better examples fool!). Filters are separated by semicolons
+    # and are executed in order given. If the filter needs arguments, those are given
+    # after a colon and separated by commas.
+    def self.parse(str='')
+      str.split(';').inject([]) do |memo, rule|
+        list = rule.split(':')
+        filter = list.shift.strip
+        set = [filter]
+        unless list.empty?
+          list = list.join(':')               # get us back to our original string
+          list = list.split(',')              # becase we care about something else
+          set += list.collect {|a| a.strip }  # get rid of any pesky whitespace
+        end
+        memo << set
+      end
+    end
+    
+    @@required_methods = %w(__send__ __id__ debugger run inspect methods respond_to? extend)
+    
+    # :nodoc
+    # keeping inspect around simply to make irb happy.
+    def inspect; end
+
+    def respond_to?(method)
+      method_name = method.to_s
+      return false if method_name =~ /^__/ 
+      return false if @@required_methods.include?(method_name)
+      super
+    end
+    
+    def run(filter, node, *args)
+      
+      __send__(filter, node, *args) if respond_to?(filter)
+    end
+
+    instance_methods.each do |m| 
+      unless @@required_methods.include?(m) 
+        undef_method m 
+      end
+    end
+    
+  end
+end

data/lib/hpreserve/parser.rb

@@ -0,0 +1,86 @@
+module Hpreserve
+  class Parser
+  
+    def self.render(doc='', variables={})
+      doc = new(doc)
+      doc.render(variables)
+    end
+    
+    attr_accessor :doc, :variables, :filter_sandbox, :include_base, :cacher
+  
+    def initialize(doc='')
+      self.doc = Hpricot(doc)
+      self.filter_sandbox = Hpreserve::Filters.create
+    end
+  
+    def variables=(vars)
+      @variables = Hpreserve::Variables.new(vars)
+    end
+  
+    def render(vars=nil)
+      self.variables = vars unless vars.nil?
+      render_includes
+      render_nodes
+      doc.to_s
+    end
+    
+    def render_includes
+      (doc/"[@include]").each do |node|
+        var, default = node['include'].split('|').collect {|s| s.strip }
+        incl = variables.substitute(var)
+        incl = [include_base, incl.split('.')].flatten.compact
+        node.inner_html = variables[incl] || variables[default]
+        node.remove_attribute('include')
+      end
+    end
+    
+    def render_nodes(base=doc)
+      (base/'meta[@content]').each {|node| node.set_attribute('content', variables.substitute(node['content']))}
+      (base/'[@content]:not(meta)').each {|node| render_node_content(node) }
+      (base/'[@filter]').each {|node| render_node_filters(node) }
+    end
+    
+    def render_node_content(node)
+      variable = node.remove_attribute('content').strip
+      cache = cacher.nil? ? nil : cacher.match?(variable)
+      if cache and stored = cacher.retrieve(cache)
+        node.swap(stored)
+      else
+        value = variables[variable.split('.')]
+        value = value['default'] if value.respond_to?(:has_key?)
+        if value.is_a?(Array)
+          render_collection(node, value)
+        else
+          node.inner_html = value
+        end
+        render_node_filters(node) if node['filter']
+        cacher.store(cache, node.to_s) if cache
+      end
+    end
+    
+    def render_node_filters(node)
+      filters = Hpreserve::Filters.parse(node.remove_attribute('filter'))
+      filters.each do |filterset|
+        filter = filterset.shift
+        next unless filter_sandbox.respond_to?(filter)
+        args = filterset.collect {|a| variables.substitute(a) }
+        filter_sandbox.run(filter, node, *args)
+      end
+    end
+    
+    def render_collection(node, values=[])
+      variable_name = node.remove_attribute('local') || 'item'
+      base = node.children.detect {|n| !n.is_a?(Hpricot::Text) }
+      base.following.remove
+      base.preceding.remove
+      template = base.to_s
+      values.each_with_index do |value, index|
+        variables.storage[variable_name] = value
+        ele = (Hpricot(template)/'*').first
+        node.insert_after(ele, node.children.last)
+        render_nodes(ele)
+      end
+      base.swap('')
+    end
+  end
+end

data/lib/hpreserve/standard_filters.rb

@@ -0,0 +1,60 @@
+module Hpreserve
+  module StandardFilters
+  
+    def capitalize(node)
+      node.inner_html = node.inner_text.capitalize
+      node
+    end
+    
+    def date(node, strftime)
+      time = Time.parse(node.inner_html)
+      node.inner_html = time.strftime(strftime)
+      node
+    end
+    
+    # node modification filters
+    
+    def remove(node)
+      node.parent.children.delete(node)
+    end
+    
+    def unwrap(node)
+      node.swap node.inner_html
+    end
+    
+    def link(node, url)
+      attr(node, 'href', url)
+      node
+    end
+    
+    def add_class(node, *klasses)
+      set_class(node, [node.classes, klasses].flatten)
+      node
+    end
+    
+    def set_class(node, *klasses)
+      klasses = klasses.flatten.map! {|c| c.gsub(/[^\-\w]+/,'-').gsub(/^[^a-zA-Z]/,'') }
+      attr(node, 'class', klasses.uniq.join(' '))
+      node
+    end
+    
+    def set_id(node, id)
+      attr(node, 'id', id)
+      node
+    end
+    
+    def attr(node, attrib, value)
+      node.set_attribute(attrib, value)
+      node
+    end
+    
+    def attr_on_child(node, child, attrib, value)
+      child = node.at('#'+child)
+      child.set_attribute(attrib, value) if child
+      node
+    end
+    
+  end
+end
+
+Hpreserve::Filters.register(Hpreserve::StandardFilters)

data/lib/hpreserve/variables.rb

@@ -0,0 +1,41 @@
+module Hpreserve
+  
+  class Variables
+    
+    attr_accessor :storage
+  
+    def initialize(vars={})
+      self.storage = vars
+    end
+    
+    # climbs the branches of the variable hash's tree, handling non-hashes along the way.
+    def [](*path)
+      path = path.flatten
+      return '' if path.empty?
+      stack = @storage
+      path.each do |piece|
+        # much of this stolen blatantly from liquid
+        if (stack.respond_to?(:has_key?) and stack.has_key?(piece)) ||
+           (stack.respond_to?(:fetch) and piece =~ /^\d+$/)
+          piece = piece.to_i if piece =~ /^\d+$/
+          stack[piece] = stack[piece].to_hpreserve if stack[piece].respond_to?(:to_hpreserve)
+          stack = stack[piece]
+        elsif %w(first last size).include?(piece) and stack.respond_to?(piece)
+          item = stack.send(piece)
+          stack = item.respond_to?(:to_hpreserve) ? item.to_hpreserve : item
+        else
+          return nil
+        end
+      end
+      stack
+    end
+    
+    def substitute(str='')
+      str.gsub(/\{([\w\.]+)[\s\|]*([^\{\}]+)?\}/) do |m|
+        val, default = $1, $2
+        self["#{val}".split('.')] || "#{default}";
+      end
+    end
+    
+  end
+end

data/spec/abstract_cacher_spec.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe Hpreserve::AbstractCacher do
+  
+  it "returns nil if no match for the given variable" do
+    cacher = Hpreserve::AbstractCacher.new([])
+    cacher.match?('things').should be_nil
+  end
+  
+  it "matches against the given variable and return the key" do
+    cacher = Hpreserve::AbstractCacher.new([{:match => %r|^things\.(.*)|, :key => 'thing::\1'}])
+    cacher.match?('things.foo').should == 'thing::foo'
+  end
+  
+  it "returns nil if nothing is retrieved from the cache" do
+    cacher = Hpreserve::AbstractCacher.new([])
+    cacher.storage = {}
+    cacher.retrieve('thing::foo').should == nil
+  end
+  
+  it "returns the stored value if it exists" do
+    cacher = Hpreserve::AbstractCacher.new([])
+    cacher.storage = {'thing::foo' => 'value'}
+    cacher.retrieve('thing::foo').should == 'value'
+  end
+  
+  it "sets the value" do
+    cacher = Hpreserve::AbstractCacher.new([])
+    cacher.storage = {}
+    cacher.store('thing::foo', 'value')
+    cacher.storage['thing::foo'].should == 'value'
+  end
+  
+  it "expires keys matching a given pattern" do
+    cacher = Hpreserve::AbstractCacher.new([])
+    cacher.storage = {'thing::foo' => 'foo', 'thing::bar' => 'bar', 'non::thing' => 'bee'}
+    cacher.expire(/^thing::.*/)
+    cacher.storage.should == {'non::thing' => 'bee'}
+  end
+  
+end

data/spec/file_cacher_spec.rb

@@ -0,0 +1,46 @@
+require 'tmpdir'
+require 'digest/md5'
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe Hpreserve::FileCacher do
+  
+  before do
+    @cacher = Hpreserve::FileCacher.new([], Dir.tmpdir)
+    @key = Digest::MD5.hexdigest("#{Time.now}--#{inspect}")
+  end
+  
+  it "knows about its base directory" do
+    @cacher.patterns.should == []
+    @cacher.base_dir.should == Dir.tmpdir
+  end
+  
+  it "stores values in files matching the key" do
+    @cacher.store(@key, 'new value')
+    File.should be_file(File.join(Dir.tmpdir, @key))
+    File.read(File.join(Dir.tmpdir, @key)).should == 'new value'
+  end
+  
+  it "creates directories as needed if they don't exist" do
+    @cacher.store("#{@key}/foo", 'new value')
+    File.should be_directory(File.join(Dir.tmpdir, @key))
+    File.should be_file(File.join(Dir.tmpdir, @key, 'foo'))
+  end
+  
+  it "retrieves values from files matching the key" do
+    File.open(File.join(Dir.tmpdir, @key), 'w') {|f| f << 'existing value'}
+    @cacher.retrieve(@key).should == 'existing value'
+  end
+  
+  it "returns nil when retrieving a key for a file that doens't exist" do
+    File.should_not be_file(File.join(Dir.tmpdir, @key))
+    @cacher.retrieve(@key).should be_nil
+  end
+  
+  it "deletes files when expiring keys" do
+    files = [1,2].collect {|i| File.join(Dir.tmpdir, "#{@key}-#{i}") }
+    files.each {|file| File.open(file, 'w') {|f| f << 'hi'} }
+    @cacher.expire("#{@key}*")
+    files.each {|file| File.should_not be_file(file)}
+  end
+  
+end

data/spec/filters_spec.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe Hpreserve::Filters do
+  
+  describe "sandbox" do
+    before { @f = Hpreserve::Filters.create }
+    # note: #should and #should_not are undefined at initialize and are not available
+    
+    it "extends with @@filter_modules" do
+      @f.respond_to?('capitalize').should be_true
+    end
+    
+    it "does not respond to or send non-allowed methods" do
+      lambda { @f.__send__('instance_eval')}.should raise_error(NoMethodError)
+    end
+    
+    it "executes filters via the 'run' method" do
+      @doc = Hpricot('<span>foo</span>')
+      @f.run('capitalize', @doc.at('span'))
+      @doc.at('span').inner_html.should == 'Foo'
+    end
+    
+  end
+  
+  describe "filterstring parser" do
+    it "handles single filters without arguments" do
+      Hpreserve::Filters.parse('upcase').should == [['upcase']]
+    end
+    
+    it "handles multiple filters without arguments" do
+      Hpreserve::Filters.parse('upcase; downcase').should == [['upcase'], ['downcase']]
+    end
+    
+    it "handles single filters with arguments" do
+      Hpreserve::Filters.parse('truncate: 30, ...').should == [['truncate', '30', '...']]
+    end
+    
+    it "handles complex filter directives" do
+      Hpreserve::Filters.parse(
+        'truncate: 30, ...; capitalize; link_to: @item.link; add_class: @item.type'
+      ).should == [
+        ['truncate', '30', '...'], ['capitalize'], ['link_to', '@item.link'], 
+        ['add_class', '@item.type']
+      ]
+    end
+    
+  end
+   
+end

data/spec/parser_spec.rb

@@ -0,0 +1,213 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe Hpreserve::Parser do
+  
+  describe "includes" do
+    before do
+      @doc = Hpreserve::Parser.new("<div include='header'> </div>")
+      @doc.variables = {'header' => 'value'}
+      @doc.render_includes
+    end
+    
+    it "replaces includes with their content" do
+      @doc.doc.at('div').inner_html.should == "value"
+    end
+    
+    it "removes include attribute from the node" do
+      @doc.doc.at('div').has_attribute?('include').should be_false
+    end
+    
+    it "handles namespaced includes" do
+      @doc.doc = Hpricot("<div include='contrived.example'> </div>")
+      @doc.variables = {'contrived' => {'example' => 'value'}}
+      @doc.render_includes
+      @doc.doc.at('div').inner_html.should == "value"
+    end
+    
+    it "uses the include_base attribute" do
+      @doc.include_base = 'filesystem'
+      @doc.variables = {'filesystem' => {'header' => 'value'}}
+      @doc.render_includes
+      @doc.doc.at('div').inner_html.should == 'value'
+    end
+    
+    it "substitutes variables in the include string" do
+      @doc.doc = Hpricot("<div include='{a}_sidebar'> </div>")
+      @doc.variables = {'a' => 'b', 'b_sidebar' => 'value'}
+      @doc.render_includes
+      @doc.doc.at('div').inner_html.should == 'value'
+    end
+    
+    it "ignores a default include if the given include exists" do
+      @doc.doc = Hpricot("<div include='{a}_sidebar | sidebar'> </div>")
+      @doc.variables = {'a' => 'a', 'a_sidebar' => 'value'}
+      @doc.render_includes
+      @doc.doc.at('div').inner_html.should == 'value'
+    end
+    
+    it "falls back to a default include if the given value returns empty" do
+      @doc.doc = Hpricot("<div include='{a}_sidebar | sidebar'> </div>")
+      @doc.variables = {'a' => 'b', 'sidebar' => 'value'}
+      @doc.render_includes
+      @doc.doc.at('div').inner_html.should == 'value'
+    end
+    
+    it "doesn't care about whitespace (or lack of) in the include directive" do
+      @doc.variables = {'a' => 'a', 'a_sidebar' => 'a_value', 'sidebar' => 'value'}
+      
+      ["{a}_sidebar|sidebar", " {a}_sidebar | sidebar ", "   {a}_sidebar  "].each do |i|
+        @doc.doc = Hpricot("<div include='#{i}'> </div>")
+        @doc.render_includes
+        @doc.doc.at('div').inner_html.should == 'a_value'
+      end
+    end
+    
+  end
+  
+  describe "simple content replacement" do
+    
+    before do
+      @doc = Hpreserve::Parser.new("Hello <span content='name'>Name</span>.")
+      @doc.variables = {'name' => 'Jack'}
+      @doc.render_node_content(@doc.doc.at('span'))
+    end
+    
+    it "replaces content= nodes with string content" do
+      @doc.doc.to_plain_text.should == "Hello Jack."
+    end
+    
+    it "removes content attributes from the nodes" do
+      @doc.doc.at('span').has_attribute?('content').should be_false
+    end
+  end
+  
+  describe "content replacement" do
+    
+    it "ignores nested content attributes" do
+      @doc = Hpreserve::Parser.new("Hi <span content='name'><span content='firstname'>Name</span></span>")
+      @doc.variables = {'name' => 'Jack Shepherd', 'firstname' => 'Jack'}
+      @doc.doc.search('span').each {|n| @doc.render_node_content(n) }
+      @doc.doc.to_plain_text.should == "Hi Jack Shepherd"
+    end
+    
+    it "handles variable paths that end up in hashes" do
+      @doc = Hpreserve::Parser.new("Hi <span content='name'>Name</span>")
+      @doc.variables = {'name' => {'default' => 'Jack Shepherd', 'first' => 'Jack', 'last' => 'Shepherd'}}
+      @doc.render_node_content(@doc.doc.at('span'))
+      @doc.doc.to_plain_text.should == "Hi Jack Shepherd"
+    end
+    
+    it "ignores whitespace in variable names" do
+      @doc = Hpreserve::Parser.new("Hi <span content='  name  '>Name</span>")
+      @doc.variables = {'name' => 'Jack Shepherd'}
+      @doc.render_node_content(@doc.doc.at('span'))
+      @doc.doc.to_plain_text.should == 'Hi Jack Shepherd'
+    end
+    
+    describe "on meta tags" do
+      before do
+        @doc = Hpreserve::Parser.new("<head><meta name='foo' content='plain content' /><meta name='bar'  content='{bar}' /></head>")
+        @doc.variables = {'bar' => 'value'}
+        @doc.render
+      end
+      
+      it "does not insert the content into the node" do
+        @doc.doc.at('meta[@name=foo]').inner_html.should == ''
+        @doc.doc.at('meta[@name=bar]').inner_html.should == ''
+      end
+      
+      it "ignores lack of variables in content string" do
+        @doc.doc.at('meta[@name=foo]')['content'].should == 'plain content'
+      end
+      
+      it "substitutes variables in content string" do
+        @doc.doc.at('meta[@name=bar]')['content'].should == 'value'
+      end
+    end
+    
+  end
+    
+  describe "collections" do
+
+    it "handles simple collections" do
+      @doc = Hpreserve::Parser.new("<ul content='items' local='item'><li content='item'>One</li><li>Another</li></ul>")
+      @doc.variables = {'items' => %w(one two three four)}
+      @doc.render_node_content(@doc.doc.at('ul'))
+      @doc.doc.to_html.should == "<ul><li>one</li><li>two</li><li>three</li><li>four</li></ul>"
+    end
+    
+    it "handles nested collections" do
+      @doc = Hpreserve::Parser.new("<ul content='sections' local='section'><li><span content='section.name'>Section</span>: <span content='section.authors' local='author'><span content='author'>Author</span></span></li></ul>")
+      @doc.variables = {'sections' => [{'name' => 'one', 'authors' => ['me', 'you']}, {'name' => 'two', 'authors' => ['me']}]}
+      @doc.render_node_content(@doc.doc.at('ul'))
+      @doc.doc.to_html.should == "<ul><li><span>one</span>: <span><span>me</span><span>you</span></span></li><li><span>two</span>: <span><span>me</span></span></li></ul>"
+    end
+    
+    it "handles whitespace" do
+      @doc = Hpreserve::Parser.new("<ul content='items' local='item'>
+
+        <li content='item'>1</li>
+
+      </ul>")
+      @doc.variables = {'items' => ['one']}
+      @doc.render_node_content(@doc.doc.at('ul'))
+      @doc.doc.to_html.should == "<ul><li>one</li></ul>"
+    end
+    
+  end
+  
+  describe "caching" do
+    before do
+      @doc = Hpreserve::Parser.new("<span content='some.thing'>non-rendered</span>")
+      @doc.variables = {'some' => {'thing' => 'from variables'}}
+      cacher_matches([{:match => /^some\.thing/, :key => 'something'}])
+    end
+    
+    def cacher_matches(match=[])
+      @doc.cacher = Hpreserve::AbstractCacher.new(match)
+    end
+    
+    def render
+      @doc.render_node_content(@doc.doc.at('span'))
+    end
+    
+    it "ignores the cacher if no match is found" do
+      cacher_matches()
+      render
+      @doc.doc.to_s.should == '<span>from variables</span>'
+    end
+    
+    it "checks the cache if a match is found" do
+      @doc.cacher.should_receive(:retrieve).with('something')
+      render
+    end
+    
+    it "uses the value from the cache if a match is found and the key exists in the cache" do
+      @doc.cacher.store('something', 'from cacher')
+      render
+      @doc.doc.to_s.should == 'from cacher'
+    end
+    
+    it "does not render if a match is found and the key exists in the cache" do
+      @doc.cacher.store('something', 'from cacher')
+      @doc.variables.should_not_receive(:[])
+      render
+    end
+    
+    it "stores the value in the cache if a match is found and no key is pre-existing" do
+      @doc.cacher.should_receive(:store).with('something','<span>from variables</span>')
+      render
+    end
+  end
+  
+  describe "filter handler" do
+
+    it "runs the given filterset on a node" do
+      @doc = Hpreserve::Parser.new("<span filter='capitalize'>foo</span>")
+      @doc.render_node_filters(@doc.doc.at('span'))
+      @doc.doc.at('span').inner_html.should == 'Foo'
+    end
+    
+  end
+    
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems'
+  gem 'rspec'
+  require 'spec'
+end
+
+require 'rubygems'
+gem 'ruby-debug'
+require 'ruby-debug'
+
+require "hpricot"
+require "#{File.dirname(__FILE__)}/../lib/hpreserve"
+
+Debugger.start

data/spec/standard_filters_spec.rb

@@ -0,0 +1,140 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe Hpreserve::StandardFilters do
+
+  describe "upcase" do
+    before { @f = Hpreserve::Filters.create }
+    
+    it "capitalizes the text of the node" do
+      @doc = Hpricot("<span>foo</span>")
+      @f.run 'capitalize', @doc.at('span')
+      @doc.at('span').inner_text.should == 'Foo'
+    end
+    
+  end
+  
+  describe "date" do
+    before { @f = Hpreserve::Filters.create }
+    
+    it "handles strftime arguments" do
+      @doc = Hpricot("<span>Wed, 26 Mar 2008 23:45:55 -0700</span>")
+      @f.run 'date', @doc.at('span'), '%e %b %y'
+      @doc.at('span').inner_html.should == '26 Mar 08'
+    end
+  end
+  
+  
+  describe "remove" do
+    before { @f = Hpreserve::Filters.create }
+    
+    it "removes the node from the document" do
+      @doc = Hpricot("<div>blah <div>Attention Client: This will be cooler</div><div>blah</div></div>")
+      @f.run 'remove', @doc.at('div div')
+      @doc.to_plain_text.should == "blah blah"
+    end
+  end
+  
+  describe "unwrap" do
+    before { @f = Hpreserve::Filters.create }
+    
+    it "replaces the node with its content" do
+      @doc = Hpricot("<div>Value</div>")
+      @f.run 'unwrap', @doc.at('div')
+      @doc.to_s.should == 'Value'
+    end
+  end
+  
+  describe "link" do
+    before { @f = Hpreserve::Filters.create }
+    
+    it "sets the href attribute to the url value" do
+      @doc = Hpricot("<a href=''>Foo</a>")
+      @f.run 'link', @doc.at('a'), 'foo.com'
+      @doc.at('a')['href'].should == 'foo.com'
+    end
+  end
+  
+  describe "add_class" do
+    before { @f = Hpreserve::Filters.create }
+    
+    it "appends the class to the element's classes" do
+      @doc = Hpricot("<span class='foo'>Foo</span>")
+      @f.run 'add_class', @doc.at('span'), 'bar'
+      @doc.at('span').classes.should == ['foo', 'bar']
+    end
+  end
+  
+  describe "set_class" do
+    before do
+      @f = Hpreserve::Filters.create
+      @doc = Hpricot("<span class='foo'>Foo</span>")
+    end
+    
+    it "replacess the element's classes" do
+      @f.run 'set_class', @doc.at('span'), 'bar'
+      @doc.at('span').classes.should == ['bar']
+    end
+    
+    it "santizes the class name" do
+      @f.run 'set_class', @doc.at('span'), '.foo and bar'
+      @doc.at('span').classes.should == ['foo-and-bar']
+    end
+    
+    it "handles multiple class names with commas" do
+      @f.run 'set_class', @doc.at('span'), 'foo', 'bar'
+      @doc.at('span').classes.should == %w(foo bar)
+    end
+    
+  end
+  
+  describe "set_id" do
+    before { @f = Hpreserve::Filters.create }
+    
+    it "sets the element's id" do
+      @doc = Hpricot("<span>foo</span>")
+      @f.run 'set_id', @doc.at('span'), 'bar'
+      @doc.at('span')['id'].should == 'bar'
+    end
+    
+    it "replaces the element's id" do
+      @doc = Hpricot("<span id='foo'>foo</span>")
+      @f.run 'set_id', @doc.at('span'), 'bar'
+      @doc.at('span')['id'].should == 'bar'
+    end
+  end
+
+  
+  describe "attr" do
+    before { @f = Hpreserve::Filters.create }
+    
+    it "sets the attr for src" do
+      @doc = Hpricot('<span>foo</span>')
+      @f.run 'attr', @doc.at('span'), 'src', '/lolcat.jpg'
+      @doc.at('span')['src'].should == '/lolcat.jpg'
+    end
+    
+    it "clobbers the attr for src" do
+      @doc = Hpricot('<img src="/loldog.jpg" />')
+      @f.run 'attr', @doc.at('img'), 'src', '/lolcat.jpg'
+      @doc.at('img')['src'].should == '/lolcat.jpg'
+    end
+  end
+  
+  describe "attr_on_child" do
+    before { @f = Hpreserve::Filters.create }
+    
+    it "sets the attr on the named child element" do
+      @doc = Hpricot('<div><span id="foo">foo</span><span id="bar">bar</span></div>')
+      @f.run 'attr_on_child', @doc.at('div'), 'foo', 'class', 'active'
+      @doc.at('#foo').classes.should == ['active']
+    end
+    
+    it "handles a child not found" do
+      html = '<div><span id="bar">bar</span></div>'
+      @doc = Hpricot(html)
+      @f.run 'attr_on_child', @doc.at('div'), 'foo', 'class', 'active'
+      @doc.to_s.should == html
+    end
+  end
+  
+end

data/spec/variables_spec.rb

@@ -0,0 +1,116 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe Hpreserve::Variables do
+  
+  describe "initialization" do
+    it "stores the variables in @storage" do
+      v = Hpreserve::Variables.new('foo')
+      v.instance_variable_get(:@storage).should == 'foo'
+    end
+  end
+  
+  describe "substitute" do
+    before do
+      @var = Hpreserve::Variables.new({'a' => 'b', 'b' => {'c' => 'val'}})
+    end
+    
+    it "substitutes variables" do
+      @var.substitute('{a}').should == 'b'
+    end
+    
+    it "substitutes variables with other things around them" do
+      @var.substitute('foo{a}ar').should == 'foobar'
+    end
+    
+    it "substitutes multiple variables in the string" do
+      @var.substitute('foo{a}ar_{b.c}').should == 'foobar_val'
+    end
+    
+    it "ignores strings without substitute values" do
+      @var.substitute('foo').should == 'foo'
+    end
+    
+    it "uses defaults if no value found" do
+      @var.substitute('{foo | bar}').should == 'bar'
+    end
+    
+    it "ignores defaults if value found" do
+      @var.substitute('{a | bar}').should == 'b'
+    end
+    
+    it "ignores whitespace around default" do
+      @var.substitute('{foo   |    bar}').should == 'bar'
+      @var.substitute('{foo|bar}').should == 'bar'
+    end
+    
+    it "returns an empty string if no default and no value found" do
+      @var.substitute('{foo}').should == ''
+    end
+  end
+  
+  describe "retrieval" do
+    before do
+      @var = Hpreserve::Variables.new({'a' => {'b' => {'c' => 'value'}}})
+    end
+
+    it "ignores requests for empty arrays" do
+      @var[[]].should == ''
+    end
+    
+    it "pulls the variables out of the nest" do
+      @var['a','b','c'].should == 'value'
+      @var[%w(a b c)].should == 'value'
+    end
+    
+    it "doesn't have a problem with non-existant variables" do
+      @var[%w(z y x)].should == nil
+    end
+    
+    it "calls proc variables" do
+      @var.storage['x'] = proc { 'value' }
+      @var['x'].should == 'value'
+    end
+    
+    it "replaces proc variables with their results, thus calling them only once" do
+      i = 0
+      @var.storage['x'] = proc { i+=1 }
+      3.times { @var['x'] }
+      @var['x'].should == 1
+    end
+    
+    it "descends into proc variables" do
+      @var.storage['x'] = proc { {'a' => 'value'} }
+      @var[%w(x a)].should == 'value'
+    end
+    
+    it "handles date and time variables" do
+      time = Time.now
+      @var.storage['today'] = time
+      @var['today']['default'].should == time.rfc2822
+      @var['today']['year'].should == time.year
+    end
+    
+    it "knows the size of arrays" do
+      @var.storage['x'] = %w(one two three four)
+      @var['x','size'].should == 4
+    end
+    
+    it "handles first and last on arrays" do
+      @var.storage['x'] = %w(one two three four)
+      @var['x','first'].should == 'one'
+      @var['x','last'].should == 'four'
+    end
+    
+    it "handles numbers on arrays" do
+      @var.storage['x'] = %w(one two three four)
+      @var['x','1'].should == 'two'
+    end
+    
+    it "handles procs in arrays" do
+      @var.storage['x'] = [proc {'one'}, proc {'two'}]
+      @var['x','first'].should == 'one'
+      @var['x','1'].should == 'two'
+    end
+  end
+  
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: mattly-hpreserve
+version: !ruby/object:Gem::Version 
+  version: 0.2.1
+platform: ruby
+authors: 
+- Matthew Lyon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-07-06 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.6.0
+    version: 
+description: A humane, eval-safe HTML templating system expressed in HTML
+email: matt@flowerpowered.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.mkdn
+- Rakefile
+- spec/abstract_cacher_spec.rb
+- spec/file_cacher_spec.rb
+- spec/filters_spec.rb
+- spec/parser_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/standard_filters_spec.rb
+- spec/variables_spec.rb
+- lib/hpreserve
+- lib/hpreserve/abstract_cacher.rb
+- lib/hpreserve/extensions.rb
+- lib/hpreserve/file_cacher.rb
+- lib/hpreserve/filters.rb
+- lib/hpreserve/parser.rb
+- lib/hpreserve/standard_filters.rb
+- lib/hpreserve/variables.rb
+- lib/hpreserve.rb
+has_rdoc: false
+homepage: http://github.com/mattly/hpreserve
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.6
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: eval-safe HTML templates using HTML
+test_files: []
+