starapor-slippers 0.0.0

data/lib/engine/template_group.rb

@@ -0,0 +1,20 @@
+module Slippers
+  class TemplateGroup
+    def initialize(params={})
+      @templates = params[:templates]
+      @super_group = params[:super_group]
+    end
+    
+    def find(subtemplate)
+      return nil unless @templates
+      return @templates[subtemplate.to_sym] if @templates.include?(subtemplate.to_sym)
+      find_in_super_group(subtemplate)
+    end
+    
+    private
+      def find_in_super_group(subtemplate)
+        return nil unless @super_group 
+        @super_group.find(subtemplate)
+      end
+  end
+end

data/lib/engine/template_group_directory.rb

@@ -0,0 +1,39 @@
+module Slippers
+  class TemplateGroupDirectory < TemplateGroup
+    def initialize(directory_path, params={})
+      @directory_path = directory_path
+      @super_group = params[:super_group]
+    end
+    attr_reader :directory_path
+    
+    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)
+      
+    end
+    
+    def eql?(other)
+      return false unless other
+      directory_path.eql?(other.directory_path)
+    end
+    def hash
+      @directory_path.hash
+    end
+    
+    private
+      def find_renderer(subtemplate)
+        file_name = @directory_path + '/' + subtemplate + '.rb'
+        return find_in_super_group(subtemplate) unless File.exist?(file_name)
+        renderer_name = subtemplate.split('/')[-1]
+        load File.expand_path(file_name)
+        renderer_name.camelize.constantize.new
+      end
+      
+      def find_in_super_group(subtemplate)
+        return nil unless @super_group 
+        @super_group.find(subtemplate)
+      end
+  end
+end

data/lib/ramazeTemplates/0001-SarahTaraporewalla-adding-new-template-file-for-sli.patch

@@ -0,0 +1,25 @@
+From 5a6c869d4709ce84d7c07b5dd33cf06e39c0111e Mon Sep 17 00:00:00 2001
+From: Sarah Taraporewalla <sarah.tarap@gmail.com>
+Date: Mon, 16 Feb 2009 20:44:08 +0000
+Subject: [PATCH] SarahTaraporewalla: adding new template file for slippers template engine
+
+---
+ lib/ramaze/template.rb |    2 +-
+ 1 files changed, 1 insertions(+), 1 deletions(-)
+
+diff --git a/lib/ramaze/template.rb b/lib/ramaze/template.rb
+index 096816b..99f1f94 100644
+--- a/lib/ramaze/template.rb
++++ b/lib/ramaze/template.rb
+@@ -18,7 +18,7 @@ module Ramaze
+ 
+     AVAILABLE_ENGINES = %w[
+       Amrita2 Builder Erubis Haml Liquid Markaby Maruku Nagoro None RedCloth
+-      Remarkably Sass Tagz Tenjin XSLT
++      Remarkably Sass Slippers Tagz Tenjin XSLT
+     ]
+ 
+     AVAILABLE_ENGINES.each do |const|
+-- 
+1.6.1
+

data/lib/ramazeTemplates/slippers.rb

@@ -0,0 +1,25 @@
+require '/Users/starapor/Development/slippers/slippers'
+
+module Ramaze
+  module Template
+    class Slippers < Template
+
+      ENGINES[self] = %w[ st ]
+      class << self
+        def transform(action)
+          slippers = wrap_compile(action)
+          object_to_render = ::Slippers::BindingWrapper.new(action.binding)
+          slippers.render(object_to_render)
+        end
+
+        def compile(action, template)
+          subtemplates = action.controller.trait[:slippers_options] || {}
+         
+          template_group_directory = ::Slippers::TemplateGroupDirectory.new(Global.view_root)
+          template_group = ::Slippers::TemplateGroup.new(:super_group => template_group_directory, :templates => subtemplates)
+          ::Slippers::Engine.new(template, :template_group => template_group)
+        end
+      end
+    end
+  end
+end

data/lib/slippers.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'treetop'
+require 'active_support'
+
+require File.dirname(__FILE__) + '/engine/template'
+require File.dirname(__FILE__) + '/engine/file_template'
+require File.dirname(__FILE__) + '/engine/template_group'
+require File.dirname(__FILE__) + '/engine/template_group_directory'
+require File.dirname(__FILE__) + '/engine/engine'
+require File.dirname(__FILE__) + '/engine/binding_wrapper'
+require File.dirname(__FILE__) + '/engine/slippers_nodes'
+
+
+

data/spec/binding_wrapper.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Slippers::BindingWrapper do
+  def f
+      @a = 22
+      @b = 33
+      binding
+  end
+  
+  it "should evaluate the bindings" do
+    bindings_wrapper = Slippers::BindingWrapper.new(f())
+    bindings_wrapper['a'].should eql(22)
+  end
+end

data/spec/engine.rb

@@ -0,0 +1,76 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Slippers::Engine do
+  before do
+    template = 'Hello $first$ $last$'
+    @engine = Slippers::Engine.new(template)
+  end
+  
+  it "should render a template without any holes" do
+    template = "This is a string without any holes in it"
+    engine = Slippers::Engine.new(template)
+    engine.render.should eql("This is a string without any holes in it")
+  end
+
+  it "should fill in a hole within a template" do
+    template = "This is a string with a message of $message$"
+    engine = Slippers::Engine.new(template)
+    engine.render(:message => "hello world").should eql("This is a string with a message of hello world")
+  end
+
+  it "should render a subtemplate within a template" do
+    subtemplate = Slippers::Engine.new("this is a subtemplate")
+    template_group = Slippers::TemplateGroup.new(:templates => {:message => subtemplate})
+    template = "This is a template and then $message()$"
+    engine = Slippers::Engine.new(template, :template_group => template_group)
+    engine.render.should eql("This is a template and then this is a subtemplate")
+  end
+
+  it "should apply a template to an attribute" do
+    subtemplate = Slippers::Engine.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'}).should eql("This is a template and then this is a subtemplate with a message of hello world!")
+  end
+
+  it "should apply an anonymous subtemplate to an attribute" do
+    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'}).should eql("This is a template and then this is a subtemplate with a message of hello world!")
+  end
+  
+  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)})
+    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.")
+  end
+   
+  it 'should render a bindings wrapper' do
+    @first = 'fred'
+    @last = 'flinstone'
+    
+    person_binding = Slippers::BindingWrapper.new(binding)
+    @engine.render(person_binding).should eql('Hello fred flinstone')
+  end
+  
+  it 'should render a list of objects' do
+    subtemplate = Slippers::Engine.new('Hello $first$ $last$ ')
+    template_group = Slippers::TemplateGroup.new(:templates => {:person => subtemplate})
+    template = 'Say: $people:person()$'
+    @people = [OpenStruct.new({:first => 'fred', :last => 'flinstone'}), OpenStruct.new({:first => 'barney', :last => 'rubble'})]
+    
+    engine = Slippers::Engine.new(template, :template_group => template_group)
+    engine.render(Slippers::BindingWrapper.new(binding)).should eql('Say: Hello fred flinstone Hello barney rubble ')
+  end
+end
+
+class AgeRenderer  
+  def render(date)
+     age = DateTime.now.year - date.year
+     age.to_s + " years old"
+  end
+end

data/spec/file_template.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/spec_helper'
+  
+describe Slippers::FileTemplate, " when rendering" do
+  it "should read the template from a file" do
+    template_file = Slippers::FileTemplate.new('spec/person_template.st')
+    template_file.template.should eql('This is a $template$')
+  end
+end
+

data/spec/parser.rb

@@ -0,0 +1,111 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class Person
+  def initialize(first, last)
+    @first, @last = first, last
+  end
+  attr_reader :first, :last
+  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', :name => 'fred'})
+    @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')
+  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})
+    @parser.parse('$template()$').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('${template for this $name$}$').eval(:name => 'fred').should eql('template for this fred')
+  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.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
+   
+end
+
+

data/spec/person_template.st

@@ -0,0 +1 @@
+This is a $template$

data/spec/slippers_spec.rb

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

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'spec'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'slippers'
+require 'ostruct'
+require 'date'
+require 'mocha'
+require 'tempfile'
+
+Spec::Runner.configure do |config|
+  
+end
+

data/spec/template_group.rb

@@ -0,0 +1,24 @@
+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
+  
+  it 'should return nil if it cannot find the right template' do
+    template_group = Slippers::TemplateGroup.new()
+    template_group.find(:not_this).should eql(nil)
+    template_group.find('not_this').should eql(nil)
+  end
+  
+  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::TemplateGroup.new(:templates => {}, :super_group => super_template_group)
+    template_group.find(:person).should eql(template)
+    template_group.find(:not_this).should eql(nil)
+  end
+end

data/spec/template_group_directory.rb

@@ -0,0 +1,38 @@
+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.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.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.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.find('person/date_renderer').class.should eql(DateRenderer)
+    template_group.find('money').class.should eql(Money)
+  end
+  
+  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.find('person').should eql(template)
+    template_group.find('not_this').should eql(nil)
+  end
+  
+  
+
+end

data/spec/views/index.st

@@ -0,0 +1 @@
+Hey foo

data/spec/views/money.rb

@@ -0,0 +1,2 @@
+class Money
+end

data/spec/views/person/age.st

@@ -0,0 +1 @@
+The age for him is $age$

data/spec/views/person/date_renderer.rb

@@ -0,0 +1,5 @@
+class DateRenderer
+  def render(date)
+    date.day + ' ' + date.month + ' ' + date.year
+  end
+end

data/spec/views/person/name.st

@@ -0,0 +1 @@
+$first$ $last$

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification 
+name: starapor-slippers
+version: !ruby/object:Gem::Version 
+  version: 0.0.0
+platform: ruby
+authors: 
+- Sarah Taraporewalla
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-25 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: schacon-git
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: A strict templating library for ruby
+email: me@sarahtaraporewalla.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- LICENSE
+- Rakefile
+- README
+- VERSION.yml
+- lib/engine
+- lib/engine/binding_wrapper.rb
+- lib/engine/engine.rb
+- lib/engine/file_template.rb
+- lib/engine/slippers.treetop
+- lib/engine/slippers_nodes.rb
+- lib/engine/template.rb
+- lib/engine/template_group.rb
+- lib/engine/template_group_directory.rb
+- lib/ramazeTemplates
+- lib/ramazeTemplates/0001-SarahTaraporewalla-adding-new-template-file-for-sli.patch
+- lib/ramazeTemplates/slippers.rb
+- lib/slippers.rb
+- spec/binding_wrapper.rb
+- spec/engine.rb
+- spec/file_template.rb
+- spec/parser.rb
+- spec/person_template.st
+- spec/slippers_spec.rb
+- spec/spec_helper.rb
+- spec/template_group.rb
+- spec/template_group_directory.rb
+- spec/views
+- spec/views/index.st
+- spec/views/money.rb
+- spec/views/person
+- spec/views/person/age.st
+- spec/views/person/date_renderer.rb
+- spec/views/person/name.st
+- examples/blog
+- examples/blog/blog.db
+- examples/blog/controller
+- examples/blog/controller/main.rb
+- examples/blog/model
+- examples/blog/model/entry.rb
+- examples/blog/public
+- examples/blog/public/styles
+- examples/blog/public/styles/blog.css
+- examples/blog/README
+- examples/blog/spec
+- examples/blog/spec/blog.rb
+- examples/blog/start.rb
+- examples/blog/view
+- examples/blog/view/edit.st
+- examples/blog/view/edit.xhtml
+- examples/blog/view/entry.st
+- examples/blog/view/index.st
+- examples/blog/view/index.xhtml
+- examples/blog/view/layout.st
+- examples/blog/view/layout.xhtml
+- examples/blog/view/new.st
+- examples/blog/view/new.xhtml
+- examples/main_controller.rb
+- examples/start.rb
+- examples/todolist
+- examples/todolist/public
+- examples/todolist/public/favicon.ico
+- examples/todolist/public/js
+- examples/todolist/public/js/jquery.js
+- examples/todolist/public/ramaze.png
+- examples/todolist/Rakefile
+- examples/todolist/README
+- examples/todolist/spec
+- examples/todolist/spec/todolist.rb
+- examples/todolist/src
+- examples/todolist/src/controller
+- examples/todolist/src/controller/main.rb
+- examples/todolist/src/element
+- examples/todolist/src/element/page.rb
+- examples/todolist/src/model.rb
+- examples/todolist/start.rb
+- examples/todolist/template
+- examples/todolist/template/index.st
+- examples/todolist/template/index.xhtml
+- examples/todolist/template/new.st
+- examples/todolist/template/new.xhtml
+- examples/todolist/template/tasks.st
+- examples/todolist/todolist.db
+- examples/todolist.db
+- examples/view
+- examples/view/index.st
+- examples/view/person
+- examples/view/person/age.st
+- examples/view/person/index.st
+- examples/view/person/name.st
+has_rdoc: true
+homepage: http://github.com/starapor/slippers
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  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: A strict templating library for Ruby
+test_files: []
+