starapor-slippers 0.0.6 → 0.0.8

data/README

@@ -1,4 +1,4 @@
-There are many template engines that you can choose for the generation of views in your mvc application. The problem with most of the them, however, is that they are too permissive. These turing-complete engines allow for many complex constructs within the template, which begin at simple if statement and for loops, and expand to complex object traversal. While these permissive languages are intended to offer great flexibility, in reality they promote bad practices. Allowing logic to permeate your view is bad for many reasons: firstly, the code in views is rarely tested; secondly, the separation between the models and the view blurs and business logic creeps into the view.
+There are many template engines that you can choose for the generation of views in your mvc application. The problem with most of the them, however, is that they are too permissive. These turing-complete engines allow for many complex constructs within the template, which begin at simple if statements and for loops, and expand to complex object traversal. While these permissive languages are intended to offer great flexibility, in reality they promote bad practices. Allowing logic to permeate your view is bad for many reasons: firstly, the code in views is rarely tested; secondly, the separation between the models and the view blurs and business logic creeps into the view.
 
 All we want our template engine to do is read a string which has holes in it, and replace those holes with the desired string, much like mail merge. String Template is a template engine originally for Java but now ported to C# and python, which enforces strict separation of model and view by only supporting these strings with holes. Unfortunately, it has not been ported to ruby...until now.
 
@@ -22,14 +22,14 @@ Examples
   engine = Slippers::Engine.new(template, :template_group => template_group)
   engine.render #=> "This is a template and then this is a subtemplate"
 
-4. Applying a new object to a subtemplate
+4. Applying an object to a subtemplate
   subtemplate = Slippers::Template.new("this is a subtemplate with a message of $saying$")
   template_group = Slippers::TemplateGroup.new(:templates => {:message_subtemplate => subtemplate})
   template = "This is a template and then $message:message_subtemplate()$!"
   engine = Slippers::Engine.new(template, :template_group => template_group)
   engine.render(:message => {:saying => 'hello world'}) #=> "This is a template and then this is a subtemplate with a message of hello world!"
 
-5. Applying a new object to an anonymous subtemplate
+5. Applying an object to an anonymous subtemplate
   template = "This is a template and then $message:{this is a subtemplate with a message of $saying$}$!"
   engine = Slippers::Engine.new(template)
   engine.render(:message => {:saying => 'hello world'}) #=> "This is a template and then this is a subtemplate with a message of hello world!"
@@ -41,3 +41,10 @@ Examples
 	template_group = Slippers::TemplateGroup.new(:templates => {:name => subtemplate, :age => age_renderer})
 	engine = Slippers::Engine.new("Introducing $name:name()$ who is $dob:age()$.", :template_group => template_group)
 	engine.render(person) #=> "Introducing Fred Flinstone who is 34 years old."
+	
+7. Select a renderer based on the type of the object to render
+    person = OpenStruct.new({:name => {:first => 'Fred', :last => 'Flinstone'}, :dob => Date.new(DateTime.now.year-34, 2, 4)})
+    template_group = Slippers::TemplateGroup.new(:templates => {:name => Slippers::Engine.new('$first$ $last$'), Date => AgeRenderer.new})
+    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/Rakefile

@@ -1,17 +1,9 @@
+load File.expand_path(File.dirname(__FILE__) + "/tasks/spec.rake")
+#load File.expand_path(File.dirname(__FILE__) + "/tasks/git.rake")
+
 require 'rake'
 require 'spec/rake/spectask'
 
-desc "Run all examples"
-Spec::Rake::SpecTask.new('examples') do |t|
-  t.spec_files = FileList['spec/**/*.rb']
-end
-
-desc "Generate HTML report for failing examples"
-Spec::Rake::SpecTask.new('failing_examples_with_html') do |t|
-  t.spec_files = FileList['failing_examples/**/*.rb']
-  t.spec_opts = ["--format", "html:doc/reports/tools/failing_examples.html", "--diff"]
-  t.fail_on_error = false
-end
 
 desc "Generate the gem using technicalpickles jeweler"
 begin
@@ -31,32 +23,5 @@ rescue LoadError
   puts "Slippers, or one of its dependencies, is not available. Install it with: sudo gem install starapor-slippers -s http://gems.github.com"
 end
 
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = 'slippers'
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
-require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new(:spec) do |t|
-  t.libs << 'lib' << 'spec'
-  t.spec_files = FileList['spec/**/*.rb']
-end
-
-Spec::Rake::SpecTask.new(:rcov) do |t|
-  t.libs << 'lib' << 'spec'
-  t.spec_files = FileList['spec/**/*_spec.rb']
-  t.rcov = true
-end
-
-begin
-  require 'cucumber/rake/task'
-  Cucumber::Rake::Task.new(:features)
-rescue LoadError
-  puts "Cucumber is not available. In order to run features, you must: sudo gem install cucumber"
-end
+task :default => "spec:run"
 
-task :default => :spec

data/VERSION.yml

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

data/lib/engine/binding_wrapper.rb

@@ -6,9 +6,5 @@ module Slippers
     def [](method)
       eval('@'+ method.to_s, @bindings)
     end
-    
-    def to_s
-      "BindingWrapper with #{@bindingsw}"
-    end
   end
 end

data/lib/engine/slippers_nodes.rb

@@ -7,8 +7,8 @@ module Slippers
 
     def value_of(item)
       return '' if to_s == ''
-      return item.send(to_s) if item.respond_to?(to_s)
       return item[to_sym] if item.respond_to?('[]'.to_sym) && item[to_sym]
+      return item.send(to_s) if item.respond_to?(to_s)
       ''
     end
 
@@ -39,10 +39,6 @@ module Slippers
       return '' unless (subtemplate && subtemplate.respond_to?('render')) 
       subtemplate.render(item)
     end
-
-    def to_s
-      text_value
-    end
   end
   
   class AnonymousTemplateNode < Treetop::Runtime::SyntaxNode
@@ -54,10 +50,6 @@ module Slippers
     def apply_attribute_to_subtemplate(item, template_group)
       SlippersParser.new.parse(anonymous_template_words.to_s).eval(item, template_group)
     end
-    
-    def to_s
-      text_value
-    end
   end
 
   class ApplyAttributeToTemplateNode < Treetop::Runtime::SyntaxNode
@@ -70,12 +62,6 @@ module Slippers
       object_to_render = attribute.value_of(item)
       [object_to_render].flatten.inject('') { |rendered, i| rendered + template.apply_attribute_to_subtemplate(i, template_group).to_s }
     end
-
-
-    def to_s
-      text_value
-    end
-
   end
 
   class TemplatedExpressionNode < Treetop::Runtime::SyntaxNode

data/spec/engine.rb

@@ -43,7 +43,7 @@ describe Slippers::Engine do
   it "should render a subtemplate using different rendering technologies" do
     age_renderer = AgeRenderer.new
     subtemplate = Slippers::Engine.new('$first$ $last$')
-    person = OpenStruct.new({:name => {:first => 'Fred', :last => 'Flinstone'}, :dob => Date.new(DateTime.now.year - 34, 2, 4)})
+    person = OpenStruct.new({:name => {:last => 'Flinstone', :first => 'Fred'}, :dob => Date.new(DateTime.now.year - 34, 2, 4)})
     template_group = Slippers::TemplateGroup.new(:templates => {:name => subtemplate, :age => age_renderer})
     engine = Slippers::Engine.new("Introducing $name:name()$ who is $dob:age()$.", :template_group => template_group)
     engine.render(person).should eql("Introducing Fred Flinstone who is 34 years old.")

data/spec/parse_attributes.rb

@@ -0,0 +1,74 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe SlippersParser do
+  
+  before(:each) do
+    @parser = SlippersParser.new
+  end
+  
+  it "should return the string unparsed when there are no keywords in it" do
+    @parser.parse('').eval(nil).should eql('')
+    @parser.parse('  ').eval(nil).should eql('  ')
+    @parser.parse('this should be returned unchanged').eval.should eql('this should be returned unchanged')
+    @parser.parse(' this should be returned unchanged ').eval.should eql(' this should be returned unchanged ')
+    @parser.parse('this should be 1234567890 ').eval.should eql('this should be 1234567890 ')
+    @parser.parse('this should be abc1234567890 ').eval.should eql('this should be abc1234567890 ')
+    @parser.parse('this should be !@£%^&*()').eval.should eql('this should be !@£%^&*()')
+  end
+  
+  it 'should find the keyword within the delimiters' do
+    message = OpenStruct.new({:message => 'the message', :message2 => 'the second message', :name => 'fred', :full_name => 'fred flinstone'})
+    @parser.parse('$message$').eval(message).should eql('the message')
+    @parser.parse('$message$ for $name$').eval(message).should eql('the message for fred')
+    @parser.parse('we want to find $message$').eval(message).should eql('we want to find the message')
+    @parser.parse('$message$ has spoken').eval(message).should eql('the message has spoken')
+    @parser.parse('Yes! $message$ has spoken').eval(message).should eql('Yes! the message has spoken')
+    @parser.parse('Yes! $full_name$ has spoken').eval(message).should eql('Yes! fred flinstone has spoken')
+    @parser.parse('Yes! $message2$ has spoken').eval(message).should eql('Yes! the second message has spoken')
+    @parser.parse('Yes! "$message2$" has spoken').eval(message).should eql('Yes! "the second message" has spoken')
+    @parser.parse('$$').eval(message).should eql('')
+  end
+  
+  it 'should not match on escaped delimiters' do
+    @parser.parse('stuff \$notmatched\$').eval(stub(:nothing)).should eql('stuff \$notmatched\$')
+  end
+  
+  it "should render a list of objects" do
+    people = [OpenStruct.new({:name => 'fred'}), OpenStruct.new({:name => 'barney'}) ]
+    @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  
+    @parser.parse("This is the $adjective$ template with $message$.").eval(OpenStruct.new).should eql("This is the  template with .")
+  end
+  
+  it "should convert attribute to string" do
+    fred = OpenStruct.new({:name => 'fred', :dob => DateTime.new(1983, 1, 2)})
+    template_group = Slippers::TemplateGroup.new(:templates => {:date => Slippers::Engine.new('$year$')} )
+    @parser.parse("This is $name$ who was born in $dob:date()$").eval(fred, template_group).should eql('This is fred who was born in 1983')
+  end
+
+  it "should render a hash" do
+    hash_object = {:title => 'Domain driven design', :author => 'Eric Evans', :find => 'method on a hash'}
+    @parser.parse("should parse $title$ by $author$").eval(hash_object).should eql("should parse Domain driven design by Eric Evans")
+    @parser.parse("should parse a symbol before a $find$").eval(hash_object).should eql('should parse a symbol before a method on a hash')
+  end
+
+  it "should render a symbol on a hash before its methods" do
+    hash_object = {:find => 'method on a hash'}
+    @parser.parse("should parse a symbol before a $find$").eval(hash_object).should eql('should parse a symbol before a method on a hash')
+    @parser.parse("should still render the method $size$").eval(hash_object).should eql('should still render the method 1')
+  end
+  
+  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_renderers.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class Foo
+end
+class FooRenderer
+  def render(object)
+    "foo renderer"
+  end
+end
+describe SlippersParser do
+  
+  before(:each) do
+    @parser = SlippersParser.new
+  end
+  
+  it 'should return an empty string if the subtemplate does not respond to render' do
+    template_group = Slippers::TemplateGroup.new(:templates => {:not_a_renderer => stub('renderer')})    
+    @parser.parse("$not_a_renderer()$").eval(stub('object'), template_group).should eql('')
+  end
+    
+  it 'should find a renderer based on the type of the object to render' do
+    foo = Foo.new
+    template_group = Slippers::TemplateGroup.new(:templates => {:foo => FooRenderer.new})    
+    @parser.parse("$foo()$").eval(foo, template_group).should eql('foo renderer')
+    @parser.parse("$foobar:foo()$").eval({:foobar => foo}, template_group).should eql('foo renderer')
+  end    
+  
+  it 'should find a renderer based on the type of the object to render' do
+    foo = Foo.new
+    template_group = Slippers::TemplateGroup.new(:templates => {Foo => FooRenderer.new})    
+    @parser.parse("$foobar$").eval({:foobar => foo}, template_group).should eql('foo renderer')
+  end
+end
+
+

data/spec/parse_templates.rb

@@ -0,0 +1,68 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class Person
+  def initialize(first, last)
+    @first, @last = first, last
+  end
+  attr_reader :first, :last
+  
+end
+
+describe SlippersParser do
+  
+  before(:each) do
+    @parser = SlippersParser.new
+  end
+
+  it 'should parse the subtemplate found within the delimiters' do
+    template = Slippers::Engine.new('template for this')
+    template_with_underscore = Slippers::Engine.new('template with underscore')
+    predefined_templates = {:template => template, :template_with_underscore => template_with_underscore, :template2 => template}
+    template_group = Slippers::TemplateGroup.new(:templates => predefined_templates)
+    
+    @parser.parse('$template()$').eval(nil, template_group).should eql('template for this')
+    @parser.parse('$template2()$').eval(nil, template_group).should eql('template for this')
+    @parser.parse('Stuff before $template()$ and after').eval(nil, template_group).should eql('Stuff before template for this and after')
+    @parser.parse('then there is $template_with_underscore()$').eval(nil, template_group).should eql('then there is template with underscore')
+  end 
+
+   it 'should apply the attribute to a subtemplate when parsing it' do
+     person = OpenStruct.new({:name => Person.new('fred', 'flinstone')})
+     subtemplate = Slippers::Engine.new('Hello $first$ $last$')
+     template_group = Slippers::TemplateGroup.new(:templates => {:person => subtemplate})
+     
+     @parser.parse('$name:person()$').eval(person, template_group).should eql('Hello fred flinstone')
+   end
+  
+  it 'should parse an anonymous subtemplate' do
+    @parser.parse('$people:{template for this $name$}$').eval(:people => {:name => 'fred'}).should eql('template for this fred')
+    @parser.parse('$people:{template for this "$name$"}$').eval(:people => {:name => 'fred'}).should eql('template for this "fred"')
+    @parser.parse('${template for this $name$}$').eval(:name => 'fred').should eql('template for this fred')
+  end
+  
+  it "should apply a list of objects to subtemplates" do
+    people = [ Person.new('fred', 'flinstone'), Person.new('barney', 'rubble') ]
+    subtemplate = Slippers::Engine.new('this is $first$ $last$ ')
+    template_group = Slippers::TemplateGroup.new(:templates => {:person => subtemplate})
+    object_to_render = OpenStruct.new({:people => people})
+
+    @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
+    @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 parse the file template from the template group" do
+    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
+
+  
+end
+
+

data/spec/template_group_directory.rb

@@ -32,7 +32,5 @@ describe Slippers::TemplateGroupDirectory do
     template_group.find('person').should eql(template)
     template_group.find('not_this').should eql(nil)
   end
-  
-  
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: starapor-slippers
 version: !ruby/object:Gem::Version 
-  version: 0.0.6
+  version: 0.0.8
 platform: ruby
 authors: 
 - Sarah Taraporewalla
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-17 00:00:00 -07:00
+date: 2009-09-25 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -62,9 +62,10 @@ files:
 - spec/binding_wrapper.rb
 - spec/engine.rb
 - spec/file_template.rb
-- spec/parser.rb
+- spec/parse_attributes.rb
+- spec/parse_renderers.rb
+- spec/parse_templates.rb
 - spec/person_template.st
-- spec/slippers_spec.rb
 - spec/spec_helper.rb
 - spec/template_group.rb
 - spec/template_group_directory.rb

data/spec/parser.rb

@@ -1,134 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-class Person
-  def initialize(first, last)
-    @first, @last = first, last
-  end
-  attr_reader :first, :last
-  def full_name
-    to_s
-  end
-  def to_s
-    first + ' ' + last
-  end
-end
-describe SlippersParser do
-  
-  before(:each) do
-    @parser = SlippersParser.new
-  end
-  
-  it "should return the string unparsed when there are no keywords in it" do
-    @parser.parse('').eval(nil).should eql('')
-    @parser.parse('  ').eval(nil).should eql('  ')
-    @parser.parse('this should be returned unchanged').eval.should eql('this should be returned unchanged')
-    @parser.parse(' this should be returned unchanged ').eval.should eql(' this should be returned unchanged ')
-    @parser.parse('this should be 1234567890 ').eval.should eql('this should be 1234567890 ')
-    @parser.parse('this should be abc1234567890 ').eval.should eql('this should be abc1234567890 ')
-    @parser.parse('this should be !@£%^&*()').eval.should eql('this should be !@£%^&*()')
-  end
-  
-  it 'should find the keyword within the delimiters' do
-    message = OpenStruct.new({:message => 'the message', :message2 => 'the second message', :name => 'fred', :full_name => 'fred flinstone'})
-    @parser.parse('$message$').eval(message).should eql('the message')
-    @parser.parse('$message$ for $name$').eval(message).should eql('the message for fred')
-    @parser.parse('we want to find $message$').eval(message).should eql('we want to find the message')
-    @parser.parse('$message$ has spoken').eval(message).should eql('the message has spoken')
-    @parser.parse('Yes! $message$ has spoken').eval(message).should eql('Yes! the message has spoken')
-    @parser.parse('Yes! $full_name$ has spoken').eval(message).should eql('Yes! fred flinstone has spoken')
-    @parser.parse('Yes! $message2$ has spoken').eval(message).should eql('Yes! the second message has spoken')
-    @parser.parse('Yes! "$message2$" has spoken').eval(message).should eql('Yes! "the second message" has spoken')
-    @parser.parse('$$').eval(message).should eql('')
-  end
-  
-  it 'should parse the subtemplate found within the delimiters' do
-    template = Slippers::Engine.new('template for this')
-    template_with_underscore = Slippers::Engine.new('template with underscore')
-    template_group = Slippers::TemplateGroup.new(:templates => {:template => template, :template_with_underscore => template_with_underscore, :template2 => template})
-    @parser.parse('$template()$').eval(nil, template_group).should eql('template for this')
-    @parser.parse('$template2()$').eval(nil, template_group).should eql('template for this')
-    @parser.parse('Stuff before $template()$ and after').eval(nil, template_group).should eql('Stuff before template for this and after')
-    @parser.parse('then there is $template_with_underscore()$').eval(nil, template_group).should eql('then there is template with underscore')
-  end 
-  
-  it 'should parse an anonymous subtemplate' do
-    @parser.parse('$people:{template for this $name$}$').eval(:people => {:name => 'fred'}).should eql('template for this fred')
-    @parser.parse('$people:{template for this "$name$"}$').eval(:people => {:name => 'fred'}).should eql('template for this "fred"')
-    @parser.parse('${template for this $name$}$').eval(:name => 'fred').should eql('template for this fred')
-  end
-  
-  it 'should parse an anonymous subtemplate within an anonymous subtemplate' do
-    stuff = @parser.parse('$cars:{I really like $types:{toyota}$ }$')
-    stuff.eval(:cars => {:types => 'toyota'}) if stuff
-    #.should eql('template for this')
-  end
-  
-  it 'should apply the attribute to a subtemplate when parsing it' do
-    subtemplate = Slippers::Engine.new('Hello $first$ $last$')
-    template_group = Slippers::TemplateGroup.new(:templates => {:person => subtemplate})
-    person = OpenStruct.new({:name => OpenStruct.new({:first => 'fred', :last => 'flinstone'})})
-    @parser.parse('$name:person()$').eval(person, template_group).should eql('Hello fred flinstone')
-  end
-  
-  it 'should not match on escaped delimiters' do
-    @parser.parse('stuff \$notmatched\$').eval(stub(:nothing)).should eql('stuff \$notmatched\$')
-  end
-  
-  it "should render a list of objects" do
-    people = [OpenStruct.new({:name => 'fred'}), OpenStruct.new({:name => 'barney'}) ]
-    @parser.parse('this is $name$').eval(people).should eql("this is fredbarney")
-  end
-
-  it "should apply a list of objects to subtemplates" do
-    people = [ Person.new('fred', 'flinstone'), Person.new('barney', 'rubble') ]
-    subtemplate = Slippers::Engine.new('this is $first$ $last$ ')
-    template_group = Slippers::TemplateGroup.new(:templates => {:person => subtemplate})
-    object_to_render = OpenStruct.new({:people => people})
-
-    @parser.parse('$people:person()$').eval(object_to_render, template_group).should eql("this is fred flinstone this is barney rubble ")
-  end
-
-  it "should substitue in an empty string when the subtemplate cannot be found" do
-    person = OpenStruct.new({:name => 'red'})
-    @parser.parse("This is the unknown template $name:unknown()$!").eval(person).should eql("This is the unknown template !")
-  end
-  
-  it "should substitute in an empty string when the attribute cannot be found" do  
-    @parser.parse("This is the $adjective$ template with $message$.").eval(OpenStruct.new).should eql("This is the  template with .")
-  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'})
-    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 convert attribute to string" do
-    fred = OpenStruct.new({:name => 'fred', :dob => DateTime.new(1983, 1, 2)})
-    template_group = Slippers::TemplateGroup.new(:templates => {:date => Slippers::Engine.new('$year$')} )
-    @parser.parse("This is $name$ who was born in $dob:date()$").eval(fred, template_group).should eql('This is fred who was born in 1983')
-  end
-
-  it "should render a hash" do
-    hash_object = {:title => 'Domain driven design', :author => 'Eric Evans'}
-    @parser.parse("should parse $title$ by $author$").eval(hash_object).should eql("should parse Domain driven design by Eric Evans")
-  end
-  
-  it 'should return an empty string if the subtemplate does not respond to render' do
-    template_group = Slippers::TemplateGroup.new(:templates => {:not_a_renderer => stub('renderer')})    
-    @parser.parse("$not_a_renderer()$").eval(stub('object'), template_group).should eql('')
-  end
-  
-  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(Person.new('fred', 'flinestone')).should eql('')
-  end
-   
-end
-
-

data/spec/slippers_spec.rb

@@ -1,5 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe "Slippers" do
-
-end