slippers 0.0.10 → 0.0.11

data/Rakefile

@@ -11,7 +11,7 @@ begin
     gem.name = "slippers"
     gem.summary = "A strict templating library for Ruby"
     gem.email = "me@sarahtaraporewalla.com"
-    gem.homepage = "http://github.com/starapor/slippers"
+    gem.homepage = "http://starapor.github.com/slippers"
     gem.description = "A strict templating library for ruby"
     gem.authors = ["Sarah Taraporewalla"]
     gem.files =  FileList["[A-Z]*", "{bin,lib,spec,examples}/**/*"]

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:patch: 10
+:patch: 11
 :major: 0
 :minor: 0

data/lib/engine/engine.rb

@@ -3,6 +3,7 @@ Treetop.load File.dirname(__FILE__) + '/slippers'
 module Slippers
   class Engine
     DEFAULT_STRING = ''
+    MISSING_HANDLER = lambda { return "" }
     def initialize(template, params={})
       @main_template = Slippers::Template.new(template)
       @template_group = params[:template_group]

data/lib/engine/slippers_nodes.rb

@@ -2,15 +2,15 @@ module Slippers
   module AttributeToRenderNode
 
     def eval(object_to_render, template_group)
-      [object_to_render].flatten.inject('') { |rendered, item| rendered + render(value_of(item), template_group) }
+      [object_to_render].flatten.inject('') { |rendered, item| rendered + render(value_of(item, template_group), template_group) }
     end
 
-    def value_of(item)
-      return '' if attribute == ''
+    def value_of(item, template_group)
+      return default_string(template_group) if attribute == ''
       return item.to_s if attribute == 'it'
       return item[to_sym] if item.respond_to?('[]'.to_sym) && item[to_sym]
       return item.send(attribute) if item.respond_to?(attribute)
-      Slippers::Engine::DEFAULT_STRING
+      default_string(template_group)
     end
 
     def render(object_to_render, template_group)
@@ -38,6 +38,12 @@ module Slippers
     def attribute
       text_value
     end
+    
+    private
+      def default_string(template_group)
+        return Slippers::Engine::DEFAULT_STRING unless template_group
+        template_group.default_string
+      end
   end
   
   class AttributeWithExpressionOptionNode < Treetop::Runtime::SyntaxNode
@@ -57,11 +63,17 @@ module Slippers
     end
 
     def apply_attribute_to_subtemplate(item, template_group)
-      return '' unless template_group
+      return invoke_misisng_handler unless template_group
       subtemplate = template_group.find(template_path.to_s)
-      return '' unless (subtemplate && subtemplate.respond_to?('render')) 
+      return invoke_misisng_handler(template_group.missing_handler) unless (subtemplate && subtemplate.respond_to?('render')) 
       subtemplate.render(item)
     end
+    
+    private
+      def invoke_misisng_handler(missing_handler=Slippers::Engine::MISSING_HANDLER)
+        return missing_handler.call(template_path.to_s) if missing_handler.arity == 1
+        missing_handler.call
+      end
   end
   
   class AnonymousTemplateNode < Treetop::Runtime::SyntaxNode
@@ -82,7 +94,7 @@ module Slippers
     end
 
     def find_attribute_and_render(item, template_group)
-      object_to_render = attribute.value_of(item)
+      object_to_render = attribute.value_of(item, template_group)
       [object_to_render].flatten.inject('') { |rendered, i| rendered + template.apply_attribute_to_subtemplate(i, template_group).to_s }
     end
   end
@@ -90,15 +102,19 @@ module Slippers
   class ConditionalTemplateNode < Treetop::Runtime::SyntaxNode
 
     def eval(object_to_render, template_group)
-      attribute = if_clause.value_of(object_to_render)
-      if (attribute && attribute != Slippers::Engine::DEFAULT_STRING) then
+      attribute = if_clause.value_of(object_to_render, template_group)
+      if (attribute && attribute != default_string(template_group)) then
         if_expression.eval(object_to_render, template_group)
       else
-        if else_clause.elements then else_clause.else_expression.eval(object_to_render, template_group) else Slippers::Engine::DEFAULT_STRING end
+        if else_clause.elements then else_clause.else_expression.eval(object_to_render, template_group) else default_string(template_group) end
       end
     end
 
-
+    private
+      def default_string(template_group)
+        return Slippers::Engine::DEFAULT_STRING unless template_group
+        template_group.default_string
+      end
   end
 
   class TemplatedExpressionNode < Treetop::Runtime::SyntaxNode

data/lib/engine/template_group.rb

@@ -3,8 +3,12 @@ module Slippers
     def initialize(params={})
       @templates = params[:templates]
       @super_group = params[:super_group]
+      @missing_handler = params[:missing_template_handler] || Slippers::Engine::MISSING_HANDLER
+      @default_string = params[:default_string] || Slippers::Engine::DEFAULT_STRING
     end
     
+    attr_reader :missing_handler, :default_string
+    
     def find(subtemplate)
       return nil unless @templates
       return create_template(subtemplate.to_sym) if @templates.include?(subtemplate.to_sym)

data/lib/engine/template_group_directory.rb

@@ -3,8 +3,11 @@ module Slippers
     def initialize(directory_paths, params={})
       @directory_paths = directory_paths
       @super_group = params[:super_group]
+      @missing_handler = params[:missing_template_handler] || Slippers::Engine::MISSING_HANDLER
+      @default_string = params[:default_string] || Slippers::Engine::DEFAULT_STRING
     end
-    attr_reader :directory_paths
+
+    attr_reader :directory_paths, :missing_handler, :default_string
     
     def find(subtemplate)
       file_name = @directory_paths.map { |directory_path| directory_path + '/' + subtemplate + '.st' }.find { |f| File.exist? f}   

data/spec/engine.rb

@@ -79,6 +79,13 @@ describe Slippers::Engine do
     engine = Slippers::Engine.new('$this_is_bad')
     engine.render(stub('object')).should eql('')
   end
+  
+  it "should handle missing handlers" do
+    template = "This is a string without any holes in it"
+    engine = Slippers::Engine.new(template, :missing_template_handler => nil, :default_string => nil)
+    engine.render.should eql("This is a string without any holes in it")
+  end
+  
 end
 
 class AgeRenderer  

data/spec/parse_attributes.rb

@@ -38,13 +38,16 @@ describe SlippersParser do
     @parser.parse('this is $name$').eval(people).should eql("this is fredbarney")
   end
   
-  it "should render the default string when the attribute cannot be found on the object to render" do  
+  it "should render the default string when the attribute cannot be found on the object to render and there is no template group" do  
     Slippers::Engine::DEFAULT_STRING.should eql('') 
     @parser.parse("This is the $adjective$ template with $message$.").eval(OpenStruct.new).should eql("This is the  template with .")
     @parser.parse("$not_me$").eval(:object).should eql('')
-    Slippers::Engine::DEFAULT_STRING = "foo"
-    @parser.parse("$not_me$").eval(:object).should eql('foo')
-    Slippers::Engine::DEFAULT_STRING = ""
+  end  
+  
+  it "should render the default string of the template group when the attribute cannot be found on the object to render" do  
+    template_group = Slippers::TemplateGroup.new(:default_string => "foo" )
+    template_group.default_string.should eql('foo')
+    @parser.parse("$not_me$").eval(:object, template_group).should eql('foo')
   end
   
   it "should convert attribute to string" do

data/spec/parse_templates.rb

@@ -49,11 +49,19 @@ describe SlippersParser do
     @parser.parse('$people:person()$').eval(object_to_render, template_group).should eql("this is fred flinstone this is barney rubble ")
   end
 
-  it "should render an empty string when the subtemplate cannot be found" do
+  it "should call the default missing handler when the subtemplate cannot be found and there is no template group" do
+    Slippers::Engine::MISSING_HANDLER.call.should eql('')
     @parser.parse("This is the unknown template $unknown()$!").eval(Person.new('fred', 'flinstone')).should eql("This is the unknown template !")
     @parser.parse("This is the unknown template $first:unknown()$!").eval(Person.new('fred', 'flinstone')).should eql("This is the unknown template !")
   end
   
+  it "should call the missing handler when the subtemplate cannot be found" do
+    missing_handler = lambda { |template| "Warning: the template [#{template}] is missing" }
+    template_group = Slippers::TemplateGroup.new(:missing_template_handler => missing_handler)
+    @parser.parse("This is the unknown template $unknown()$!").eval(:object, template_group).should eql("This is the unknown template Warning: the template [unknown] is missing!")
+    @parser.parse("This is the unknown template $first:unknown()$!").eval(Person.new('fred', 'flinstone'), template_group).should eql("This is the unknown template Warning: the template [unknown] is missing!")
+  end
+  
   it "should parse the file template from the template group" do
     template_group = Slippers::TemplateGroupDirectory.new(['spec/views'])
     name = OpenStruct.new({:first => 'fred', :last => 'flinestone'})

data/spec/template_group.rb

@@ -2,12 +2,12 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 describe Slippers::TemplateGroup do
   it 'should find the right template' do
-    subtemplate = Slippers::Engine.new('Hello $first$ $last$')
-    template_group = Slippers::TemplateGroup.new(:templates => {:person => subtemplate})
-    template_group.find(:person).should eql(subtemplate)
-    template_group.find('person').should eql(subtemplate)
-  end  
-  
+     subtemplate = Slippers::Engine.new('Hello $first$ $last$')
+     template_group = Slippers::TemplateGroup.new(:templates => {:person => subtemplate})
+     template_group.find(:person).should eql(subtemplate)
+     template_group.find('person').should eql(subtemplate)
+   end  
+   
   it 'should wrap a template string in the engine if it is not one' do
     subtemplate = Slippers::Engine.new('Hello $first$ $last$')
     template_group = Slippers::TemplateGroup.new(:templates => {:person => 'Hello $first$ $last$'})
@@ -48,5 +48,25 @@ describe Slippers::TemplateGroup do
     template_group.has_registered?(date.class).should be_false
     template_group.render(date).should eql('')
   end
- 
+  
+  it 'missing handler should be the provided handler' do
+    missing_handler = Proc.new{ |foo| foo.to_s }
+    template_group = Slippers::TemplateGroup.new(:missing_template_handler => missing_handler)
+    template_group.missing_handler.should eql(missing_handler)
+  end  
+  
+  it 'missing handler should be the default handler when none is provided' do
+    template_group = Slippers::TemplateGroup.new()
+    template_group.missing_handler.should eql(Slippers::Engine::MISSING_HANDLER)
+  end  
+  
+  it 'default string should be the provided default' do
+    template_group = Slippers::TemplateGroup.new(:default_string => "Hello Mum")
+    template_group.default_string.should eql("Hello Mum")
+  end  
+  
+  it 'missing handler should be the default handler when none is provided' do
+    template_group = Slippers::TemplateGroup.new()
+    template_group.default_string.should eql(Slippers::Engine::DEFAULT_STRING)
+  end  
 end

data/spec/template_group_directory.rb

@@ -39,5 +39,32 @@ describe Slippers::TemplateGroupDirectory do
     template_group.find('person/age').should eql(Slippers::Engine.new('The age for him is $age$', :template_group => template_group))
   end
   
+  it 'should accept missing handlers' do 
+    template_group = Slippers::TemplateGroupDirectory.new(['spec/views'], :missing_template_handler => nil, :default_string => nil)
+    template_group.find('index').should eql(Slippers::Engine.new('Hey foo', :template_group => template_group))
+    template_group.find('person/age').should eql(Slippers::Engine.new('The age for him is $age$', :template_group => template_group))   
+  end
+  
+  it 'missing handler should be the provided handler' do
+    missing_handler = Proc.new{ |foo| foo.to_s }
+    template_group = Slippers::TemplateGroupDirectory.new(['spec/views'], :missing_template_handler => missing_handler)
+    template_group.missing_handler.should eql(missing_handler)
+  end  
+  
+  it 'missing handler should be the default handler when none is provided' do
+    template_group = template_group = Slippers::TemplateGroupDirectory.new(['spec/views'])
+    template_group.missing_handler.should eql(Slippers::Engine::MISSING_HANDLER)
+  end  
+  
+  it 'default string should be the provided default' do
+    template_group = Slippers::TemplateGroupDirectory.new(['spec/views'], :default_string => "Hello Mum")
+    template_group.default_string.should eql("Hello Mum")
+  end  
+  
+  it 'missing handler should be the default handler when none is provided' do
+    template_group = Slippers::TemplateGroupDirectory.new(['spec/views'])
+    template_group.default_string.should eql(Slippers::Engine::DEFAULT_STRING)
+  end  
+  
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: slippers
 version: !ruby/object:Gem::Version 
-  version: 0.0.10
+  version: 0.0.11
 platform: ruby
 authors: 
 - Sarah Taraporewalla
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-29 00:00:00 +01:00
+date: 2009-09-30 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -145,7 +145,7 @@ files:
 - spec/views/person/date_renderer.rb
 - spec/views/person/name.st
 has_rdoc: true
-homepage: http://github.com/starapor/slippers
+homepage: http://starapor.github.com/slippers
 licenses: []
 
 post_install_message: