starapor-slippers 0.0.8 → 0.0.9

data/README

@@ -48,3 +48,5 @@ Examples
     engine = Slippers::Engine.new("Introducing $name:name()$ who is $dob$.", :template_group => template_group)
     engine.render(person) #=> "Introducing Fred Flinstone who is 34 years old."
 
+
+

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:patch: 8
+:patch: 9
 :major: 0
 :minor: 0

data/lib/engine/engine.rb

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

data/lib/engine/slippers_nodes.rb

@@ -7,9 +7,10 @@ module Slippers
 
     def value_of(item)
       return '' if to_s == ''
+      return item.to_s if text_value == 'it'
       return item[to_sym] if item.respond_to?('[]'.to_sym) && item[to_sym]
       return item.send(to_s) if item.respond_to?(to_s)
-      ''
+      Slippers::Engine::DEFAULT_STRING
     end
 
     def render(object_to_render, template_group)

data/lib/engine/template_group.rb

@@ -7,7 +7,7 @@ module Slippers
     
     def find(subtemplate)
       return nil unless @templates
-      return @templates[subtemplate.to_sym] if @templates.include?(subtemplate.to_sym)
+      return create_template(subtemplate.to_sym) if @templates.include?(subtemplate.to_sym)
       find_in_super_group(subtemplate)
     end
     
@@ -30,5 +30,11 @@ module Slippers
         return nil unless @super_group 
         @super_group.find(subtemplate)
       end
+      
+      def create_template(subtemplate)
+        template = @templates[subtemplate]
+        return template unless template.is_a?(String)
+        Slippers::Engine.new(template)
+      end
   end
 end

data/lib/engine/template_group_directory.rb

@@ -1,17 +1,17 @@
 module Slippers
   class TemplateGroupDirectory < TemplateGroup
-    def initialize(directory_path, params={})
-      @directory_path = directory_path
+    def initialize(directory_paths, params={})
+      @directory_paths = directory_paths
       @super_group = params[:super_group]
     end
-    attr_reader :directory_path
+    attr_reader :directory_paths
     
     def find(subtemplate)
-      file_name = @directory_path + '/' + subtemplate + '.st'
-      return find_renderer(subtemplate) unless File.exist?(file_name)
-      Engine.new(FileTemplate.new(file_name).template, :template_group => self)
-      
+      file_name = @directory_paths.map { |directory_path| directory_path + '/' + subtemplate + '.st' }.find { |f| File.exist? f}   
+      return Engine.new(FileTemplate.new(file_name).template, :template_group => self) if file_name
+      find_renderer_or_supergroup(subtemplate)      
     end
+    
     def has_registered?(class_name)
        return false unless @super_group
        @super_group.has_registered?(class_name)  
@@ -25,16 +25,17 @@ module Slippers
 
     def eql?(other)
       return false unless other
-      directory_path.eql?(other.directory_path)
+      directory_paths.eql?(other.directory_paths)
     end
     def hash
-      @directory_path.hash
+      @directory_paths.hash
     end
     
     private
-      def find_renderer(subtemplate)
-        file_name = @directory_path + '/' + subtemplate + '.rb'
-        return find_in_super_group(subtemplate) unless File.exist?(file_name)
+      def find_renderer_or_supergroup(subtemplate)
+        file_name = @directory_paths.map { |directory_path| directory_path + '/' + subtemplate + '.rb' }.find { |f| File.exist? f}   
+        return find_in_super_group(subtemplate) unless file_name
+
         renderer_name = subtemplate.split('/')[-1]
         load File.expand_path(file_name)
         create_renderer renderer_name

data/lib/ramazeTemplates/slippers.rb

@@ -13,9 +13,9 @@ module Ramaze
       private
         def self.template_group(action)
           subtemplates = action.instance.ancestral_trait[:slippers_options] || {}
-          view_root = "#{action.instance.options[:roots]}/#{action.instance.options[:views]}"
+          views = action.instance.options[:views].map{|view| "#{action.instance.options[:roots]}/#{view}" }
           super_group = ::Slippers::TemplateGroup.new(:templates => subtemplates)
-          ::Slippers::TemplateGroupDirectory.new(view_root, :super_group => super_group)          
+          ::Slippers::TemplateGroupDirectory.new(views, :super_group => super_group)          
         end
     end
   end

data/spec/parse_attributes.rb

@@ -38,8 +38,12 @@ describe SlippersParser do
     @parser.parse('this is $name$').eval(people).should eql("this is fredbarney")
   end
   
-  it "should substitute in an empty string when the attribute cannot be found" do  
+  it "should render the default string when the attribute cannot be found on the object to render" 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')
   end
   
   it "should convert attribute to string" do
@@ -63,12 +67,7 @@ describe SlippersParser do
   it 'should return an empty string if the template is not correctly formed' do
     @parser.parse("$not_properly_formed").should eql(nil)
   end
-  
-  it 'should render an empty string if it cannot find the attribute to render' do
-    @parser.parse("$not_me$").eval(:object).should eql('')
-  end
-  
-   
+
 end
 
 

data/spec/parse_templates.rb

@@ -55,14 +55,19 @@ describe SlippersParser do
   end
   
   it "should parse the file template from the template group" do
-    template_group = Slippers::TemplateGroupDirectory.new('spec/views')
+    template_group = Slippers::TemplateGroupDirectory.new(['spec/views'])
     name = OpenStruct.new({:first => 'fred', :last => 'flinestone'})
     people = OpenStruct.new({:fred => name})
     @parser.parse("should parse $person/name()$").eval(name, template_group).should eql("should parse fred flinestone")
     @parser.parse("should parse $fred:person/name()$").eval(people, template_group).should eql("should parse fred flinestone")
   end
-
   
+  it 'should render the object if the keyword it is used' do
+    supergroup = Slippers::TemplateGroup.new(:templates => {:bold => Slippers::Engine.new("<b>$it$</b>")})
+    subgroup = Slippers::TemplateGroup.new(:templates => {}, :super_group => supergroup)
+    @parser.parse("<b>$it$</b>").eval("Sarah", subgroup).should eql('<b>Sarah</b>')
+    @parser.parse("$name:bold()$").eval({:name => "Sarah"}, subgroup).should eql('<b>Sarah</b>')
+  end
 end
 
 

data/spec/template_group.rb

@@ -6,6 +6,13 @@ describe Slippers::TemplateGroup do
     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$'})
+    template_group.find(:person).should eql(subtemplate)
+    template_group.find('person').should eql(subtemplate)
   end
   
   it 'should return nil if it cannot find the right template' do
@@ -15,7 +22,7 @@ describe Slippers::TemplateGroup do
   end
   
   it 'should look in the super template group if it cannot find the template' do
-    template = stub 'template'
+    template = Slippers::Engine.new('Hello $first$ $last$')
     super_template_group = Slippers::TemplateGroup.new(:templates => {:person => template})
     template_group = Slippers::TemplateGroup.new(:templates => {}, :super_group => super_template_group)
     template_group.find(:person).should eql(template)
@@ -41,5 +48,5 @@ describe Slippers::TemplateGroup do
     template_group.has_registered?(date.class).should be_false
     template_group.render(date).should eql('')
   end
-
+ 
 end

data/spec/template_group_directory.rb

@@ -3,24 +3,24 @@ require File.dirname(__FILE__) + '/spec_helper'
 describe Slippers::TemplateGroupDirectory do
   
   it 'should find the file in the directory folder' do
-    template_group = Slippers::TemplateGroupDirectory.new('spec/views')
+    template_group = Slippers::TemplateGroupDirectory.new(['spec/views'])
     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 'should return nil if it cannot find the file in the directory folder' do
-    template_group = Slippers::TemplateGroupDirectory.new('spec/views')
+    template_group = Slippers::TemplateGroupDirectory.new(['spec/views'])
     template_group.find('person/not_found').should eql(nil)
   end
 
   it 'should read the st template file and return a new slipers engine for it' do
-    template_group = Slippers::TemplateGroupDirectory.new('spec/views')
+    template_group = Slippers::TemplateGroupDirectory.new(['spec/views'])
     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 'should load the ruby file found in the directory folder' do
-    template_group = Slippers::TemplateGroupDirectory.new('spec/views')
+    template_group = Slippers::TemplateGroupDirectory.new(['spec/views'])
     template_group.find('person/date_renderer').class.should eql(DateRenderer)
     template_group.find('money').class.should eql(Money)
   end
@@ -28,9 +28,16 @@ describe Slippers::TemplateGroupDirectory do
   it 'should look in the super template group if it cannot find the template' do
     template = stub 'template'
     super_template_group = Slippers::TemplateGroup.new(:templates => {:person => template})
-    template_group = Slippers::TemplateGroupDirectory.new('spec/views', :super_group => super_template_group)
+    template_group = Slippers::TemplateGroupDirectory.new(['spec/views'], :super_group => super_template_group)
     template_group.find('person').should eql(template)
     template_group.find('not_this').should eql(nil)
   end
+  
+  it 'should look in all the directories provided for the template' do
+    template_group = Slippers::TemplateGroupDirectory.new(['examples/blog', 'spec/views'])
+    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
+  
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: starapor-slippers
 version: !ruby/object:Gem::Version 
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors: 
 - Sarah Taraporewalla
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-25 00:00:00 -07:00
+date: 2009-09-27 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency