tadpole 0.1.0

data/lib/tadpole/template.rb

@@ -0,0 +1,258 @@
+require 'ostruct'
+
+class OpenHashStruct < OpenStruct
+  def [](key)  send(key.to_s) end
+  def []=(k,v) send(key.to_s+'=', v) end
+  def to_hash; @table.dup end
+  alias has_key? respond_to?
+end
+
+module Tadpole
+  module Template
+    class MissingSectionError < Exception; end
+    
+    module ClassMethods
+      attr_accessor :path, :template_paths, :sections
+      attr_accessor :before_run_filters, :before_section_filters
+      
+      def run(*args, &block)
+        new(*args).run(&block)
+      end
+      
+      def new(opts = {}, &block)
+        obj = Object.new.extend(self)
+        class << obj; 
+          extend ClassMethods 
+          include Filters::InstanceMethods
+        end
+        obj.instance_eval("def class; #{self} end", __FILE__, __LINE__)
+        obj.send(:initialize, opts, &block)
+        obj
+      end
+    end
+    
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+    
+    attr_accessor :options
+    attr_accessor :current_section, :subsections
+    
+    def options; @options ||= OpenHashStruct.new end
+    
+    def options=(hash) 
+      if hash.is_a?(OpenStruct)
+        @options = hash
+      else
+        @options = OpenHashStruct.new(hash) 
+      end
+    end
+    
+    def method_missing(meth, *args, &block)
+      if options.respond_to?(meth)
+        options[meth]
+      elsif meth.to_s =~ /=$/ && options.has_key?(meth.to_s.gsub(/=$/, ''))
+        options[meth] = *args
+      else
+        super
+      end
+    end
+
+    def template_paths; self.class.template_paths end
+    def path; self.class.path end
+
+    def sections(*new_sections)
+      new_sections.compact!
+      if new_sections.empty? 
+        @sections 
+      elsif new_sections.size == 1 && new_sections.first.is_a?(Array)
+        @sections = new_sections.first
+      else
+        @sections = new_sections
+      end
+    end
+    
+    def compile_sections(list = sections)
+      return unless Array === list
+      list.map do |section|
+        case section
+        when Array
+          compile_sections(section)
+        when String, Symbol
+          if respond_to?(section)
+            section
+          else
+            find_section_provider(section)
+          end
+        when Module
+          section.new(options)
+        else
+          section
+        end
+      end
+    end
+    
+    def initialize(opts = {}, &block)
+      self.options = opts
+      @providers = {}
+      #self.sections(*sections)
+      
+      init(&block)
+
+      if Tadpole.caching
+        @compiled_sections = compile_sections(sections) 
+      end
+    end
+    
+    def init; end
+
+    def run(opts = {}, &block)
+      return '' if run_before_run.is_a?(FalseClass)
+      
+      old_opts = options
+      self.options = options.to_hash.update(opts)
+      out = run_sections(@compiled_sections || sections, &block)
+      self.options = old_opts
+      out
+    rescue => e
+      me = NoMethodError.new("In #{self.inspect}: #{e.message}")
+      me.set_backtrace(e.backtrace)
+      raise me
+    end
+    alias to_s run
+    
+    def run_sections(sects, break_first = false, locals = {}, &block)
+      out = ''
+      sects = sects.first if sects.first.is_a?(Array)
+      sects.each_with_index do |section, i|
+        (break_first ? break : next) if section.is_a?(Array)
+        
+        self.current_section = section_name(section)
+        
+        next if run_before_sections.is_a?(FalseClass)
+
+        if sects[i+1].is_a?(Array)
+          old, self.subsections = subsections, sects[i+1]
+          out += run_subsections(section, sects[i+1], locals, &block)
+          self.subsections = old
+        else
+          out += render(section, locals, true, &block)
+        end
+        
+        break if break_first
+      end
+      out
+    end
+    
+    def run_subsections(section, subsections, locals = {}, &block)
+      list = subsections.dup
+
+      render(section, locals, true) do |*args|
+        if list.empty?
+          raise LocalJumpError, "Section `#{section}' yielded with no sub-section given."
+        end
+        
+        ysection, locals = *parse_yield_args(*args)
+        if ysection
+          render(ysection, locals, true)
+        else
+          data = run_sections(list, true, locals, &block) 
+          list.shift; list.shift if list.first.is_a?(Array)
+          list = subsections.dup if list.empty? 
+          data
+        end
+      end
+    end
+    
+    def all_sections(&block)
+      subsections.each do |s|
+        next if Array === s
+        yield section_name(s)
+      end
+    end
+    
+    def yieldall(locals = {}, &block)
+      run_sections(subsections, false, locals, &block) 
+    end
+    
+    def render(section, locals = {}, call_method = false, &block)
+      case section
+      when String, Symbol
+        if call_method && respond_to?(section) 
+          send(section, &block)
+        else
+          find_section_provider(section).render(locals, &block)
+        end
+      when Template
+        section.run(locals, &block)
+      when Module
+        section.new(options).run(locals, &block)
+      when SectionProviders::SectionProvider
+        section.render(locals, &block)
+      else
+        raise MissingSectionError, "missing section #{section.inspect}"
+      end
+    end
+
+    def inspect
+      "#<Template:0x%s path='%s' sections=%s%s>" % [object_id.to_s(16), 
+        path, sections.inspect, @compiled_sections ? ' (compiled)' : ''] 
+    end
+    
+    private
+    
+    def section_name(section)
+      case section
+      when SectionProviders::SectionProvider
+        @providers.index(section) || section
+      else
+        section.respond_to?(:path) ? section.path : section
+      end.to_s
+    end
+    
+    def parse_yield_args(*args)
+      sym = args.shift
+      if Hash === sym
+        [nil, sym]
+      elsif sym
+        [sym, args.first || {}]
+      else
+        [nil, {}]
+      end
+    end
+
+    def find_section_provider(section)
+      section = section.to_s
+      @providers ||= {}
+      return @providers[section] if @providers[section]
+      
+      filename, provider = nil, nil
+      template_paths.each do |template_path|
+        SectionProviders.providers.each do |prov|
+          filename = prov.provides?(File.join(template_path, section))
+          break provider = prov if filename
+        end
+        break if provider && filename
+      end
+      
+      raise ArgumentError, "missing section `#{section}'" if !provider 
+      @providers[section] = provider.new(filename, self)
+    end
+    
+    def find_template(filename)
+      template_paths.each do |template_path|
+        file = File.join(template_path, filename)
+        return file if File.file? file
+      end
+      nil
+    end
+    
+    def template_contents(filename)
+      if file = find_template(filename)
+        File.read(file)
+      else
+        raise ArgumentError, "missing template file `#{filename}' in #{self.inspect}"
+      end
+    end
+  end
+end

data/lib/tadpole.rb

@@ -0,0 +1,32 @@
+require 'rubygems'
+
+module Tadpole
+  Version = '0.1.0'
+  Root = File.dirname(__FILE__) 
+  
+  module SectionProviders
+    autoload :ERBProvider,      Root + '/tadpole/providers/erb'
+    autoload :FileProvider,     Root + '/tadpole/providers/file'
+    autoload :HamlProvider,     Root + '/tadpole/providers/haml'
+    autoload :MarkabyProvider,  Root + '/tadpole/providers/markaby'
+    autoload :TemplateProvider, Root + '/tadpole/providers/template'
+  end
+  
+  module Filters
+    autoload :ClassMethods,     Root + '/tadpole/filters'
+    autoload :InstanceMethods,  Root + '/tadpole/filters'
+  end
+  
+  autoload :Template,     Root + '/tadpole/template'
+  autoload :LocalTemplate, Root + '/tadpole/local_template'
+end
+
+['tadpole/main', 'tadpole/providers/section_provider'].each do |path|
+  require File.join(Tadpole::Root, path)
+end
+
+module Tadpole::SectionProviders
+  register_provider TemplateProvider, ERBProvider, HamlProvider, FileProvider
+end
+
+    

data/spec/basic_spec.rb

@@ -0,0 +1,88 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'tadpole')
+
+Tadpole.caching = false
+
+describe 'Tadpole' do
+  before { Tadpole.template_paths.clear }
+
+  it "should be an alias to Tadpole.template" do
+    Tadpole.should_receive(:template).with(:x, :y, :z)
+    Tadpole(:x, :y, :z) 
+  end
+end
+
+describe Tadpole, '.template' do
+  before { Tadpole.template_paths.clear }
+  
+  it "should raise ArgumentError if path does not exist in template_paths" do
+    lambda { Tadpole(:x, :y, :z) }.should raise_error(ArgumentError)
+  end
+  
+  it "should create the module with the path name" do
+    Tadpole.register_template_path ''
+    File.should_receive(:directory?).exactly(3).times.and_return(true)
+    Tadpole('default/html')
+    Tadpole.constants.should include("Template_default_html")
+    Tadpole.constants.should include("LocalTemplate_default_html")
+    Tadpole.constants.should include("LocalTemplate_default")
+  end
+  
+  it "should override templates from other template paths" do
+    Tadpole.register_template_path 'a'
+    Tadpole.register_template_path 'b'
+    File.should_receive(:directory?).exactly(6).times.and_return(true)
+    Tadpole(:new, :template)
+    Tadpole.constants.should include("Template_new_template")
+    Tadpole.constants.should include("LocalTemplate_a_new_template")
+    Tadpole.constants.should include("LocalTemplate_a_new")
+    Tadpole.constants.should include("LocalTemplate_b_new_template")
+    Tadpole.constants.should include("LocalTemplate_b_new")
+    Tadpole::Template_new_template.ancestors.should == [Tadpole::Template_new_template, 
+      Tadpole::LocalTemplate_b_new_template, Tadpole::LocalTemplate_a_new_template, 
+      Tadpole::LocalTemplate_b_new, Tadpole::LocalTemplate_a_new, Tadpole::LocalTemplate,
+      Tadpole::Template]
+  end
+end
+
+describe Tadpole, "::Template" do
+  before { Tadpole.template_paths.clear; Tadpole.register_template_path '.' }
+
+  it "should act as a class (have a .new, #inspect, etc.)" do
+    #File.should_receive(:directory?).and_return(true)
+    #Tadpole.caching = false
+    Tadpole(:default, :html).should respond_to(:new)
+    Tadpole::Template.should === Tadpole(:default, :html).new
+    #Tadpole.caching = false
+  end
+  
+  it "should #run with Symbol sections as methods" do
+    File.should_receive(:directory?).at_least(1).times.and_return(true)
+    obj = Tadpole(:x, :q).new
+    obj.stub!(:sections).and_return([:a, :b, :c])
+    obj.should_receive(:a).and_return('X')
+    obj.should_receive(:b).and_return('Y')
+    obj.should_receive(:c).and_return('Z')
+    obj.run.should == 'XYZ'
+  end
+
+  it "should #run with Symbol sections as templates" do
+    File.should_receive(:directory?).at_least(1).times.and_return(true)
+    qr, qs = Tadpole(:Q,:R).new, Tadpole(:Q, :S).new
+    Tadpole(:Q, :R).should_receive(:new).and_return(qr)
+    Tadpole(:Q, :S).should_receive(:new).and_return(qs)
+    obj = Tadpole(:Q).new
+    obj.stub!(:sections).and_return([:a, :R, :S])
+    obj.should_receive(:a).and_return('X')
+    qr.should_receive(:run).and_return('Y')
+    qs.should_receive(:run).and_return('Z')
+    obj.run.should == 'XYZ'
+  end
+  
+  it "should alias .run as new.run" do
+    File.should_receive(:directory?).at_least(1).times.and_return(true)
+    obj = mock(:obj)
+    obj.stub!(:run)
+    Tadpole(:s).should_receive(:new).and_return(obj)
+    Tadpole(:s).run
+  end
+end

data/spec/examples/filters/setup.rb

@@ -0,0 +1,9 @@
+before_run :test
+before_section :a, :run_a
+before_section :all
+
+def test; end
+def run_a; end
+def all(section) end
+  
+def init; sections 'a', 'b' end

data/spec/examples/render/1/a.txt

@@ -0,0 +1 @@
+x

data/spec/examples/render/1/b.txt

@@ -0,0 +1 @@
+y

data/spec/examples/render/1/d.erb

@@ -0,0 +1 @@
+<%= value %>

data/spec/examples/render/1/setup.rb

@@ -0,0 +1,13 @@
+def init
+  sections 'a', 'b', :c, 'd'
+end
+
+def c
+  'z'
+end
+
+def d
+  render('d', :value => '1')
+end
+
+# Expected: xyz1

data/spec/examples/render/2/setup.rb

@@ -0,0 +1,9 @@
+def init
+  sections :a, [:b, [:c]]
+end
+
+def a; '{' + yield + '}' end
+def b; '(' + yield + ')' end
+def c; '[]' end
+
+# Expected: {([])}

data/spec/examples/render/3/setup.rb

@@ -0,0 +1,12 @@
+def init
+  sections :a, [:b, [:c]], :x, :y, :z
+end
+
+def a; '{' + yield + '}' end
+def b; '(' + yield + ')' end
+def c; '[]' end
+def x; 'a' end
+def y; 'b' end
+def z; 'c' end
+
+# Expected: {([])}abc

data/spec/examples/render/4/a.erb

@@ -0,0 +1 @@
+<% if x < 4 %><%= x %><%= render 'a', :x => x + 1 %><% end %>

data/spec/examples/render/4/setup.rb

@@ -0,0 +1,9 @@
+def init
+  sections 'a'
+end
+
+def a
+  render 'a', :x => 1
+end
+
+# Expected: 123

data/spec/examples/render/5/setup.rb

@@ -0,0 +1,17 @@
+def init
+  sections 'a', ['b', 'c']
+end
+
+def a
+  'x' + yield + yield + yield
+end
+
+def b
+  'y'
+end
+
+def c
+  'z'
+end
+
+# Expected: xyzy

data/spec/examples/render/6/setup.rb

@@ -0,0 +1,12 @@
+def init
+  sections [:a, [:b, [:c, :d], :e, :f]]
+end
+
+def a; 'A' + yieldall + 'G' end
+def b; 'B(' + subsections.map {|x| section_name(x).upcase }.join + ')' end
+def c; 'XXX' end
+def d; 'XXX' end
+def e; 'E' end
+def f; 'F' end
+
+# Expected: AB(CD)EFG

data/spec/filters_spec.rb

@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'tadpole')
+
+describe Tadpole::Filters do
+  before do
+    Tadpole.template_paths.clear
+    Tadpole.register_template_path File.dirname(__FILE__) + '/examples' 
+  end
+  
+  it "should call before_run filter" do
+    obj = Template(:filters).new
+    obj.should_receive(:test)
+    obj.run
+  end
+
+  it "should call before_section filter for specific section" do
+    obj = Template(:filters).new
+    obj.should_receive(:run_a).with('a')
+    obj.run
+  end
+
+  it "should call before_section filter for all sections" do
+    obj = Template(:filters).new
+    obj.should_receive(:all).exactly(2).times
+    obj.run
+  end
+  
+  it "should allow filters specified directly in LocalTemplate" do
+    eval "module Tadpole::LocalTemplate; before_run :xyz end"
+    
+    File.should_receive(:directory?).at_least(:once).and_return(true)
+    obj = Template('a/b/c/d').new
+    obj.should_receive(:xyz)
+    obj.sections []
+    obj.run
+    Tadpole::LocalTemplate.before_run_filters.clear
+  end
+end

data/spec/render_spec.rb

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'tadpole')
+
+describe Tadpole, '::Template' do
+  before do
+    Tadpole.template_paths.clear
+    Tadpole.register_template_path File.dirname(__FILE__) + '/examples' 
+  end
+  
+  it "should render sections in order" do
+    Template('render/1').new.run.should == 'xyz1'
+  end
+  
+  it "should render heirarchical sections" do
+    Template('render/2').new.run.should == '{([])}'
+  end
+  
+  it "should render heirarchical sections and then continue rendering in order" do
+    Template('render/3').new.run.should == '{([])}abc'
+  end
+  
+  it "should render filename from inside template" do
+    Template('render/4').new.run.should == '123'
+  end
+  
+  it "should restart subsection render loop if yield is called more times than subsections" do
+    Template('render/5').new.run.should == 'xyzy'
+  end
+  
+  it "should handle subsections with subsections" do
+    Template('render/6').new.run.should == 'AB(CD)EFG'
+  end
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification 
+name: tadpole
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Loren Segal
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-05-13 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: 
+email: lsegal@soen.ca
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/tadpole
+- lib/tadpole/filters.rb
+- lib/tadpole/local_template.rb
+- lib/tadpole/main.rb
+- lib/tadpole/providers
+- lib/tadpole/providers/erb.rb
+- lib/tadpole/providers/file.rb
+- lib/tadpole/providers/haml.rb
+- lib/tadpole/providers/markaby.rb
+- lib/tadpole/providers/section_provider.rb
+- lib/tadpole/providers/template.rb
+- lib/tadpole/template.rb
+- lib/tadpole.rb
+- spec/basic_spec.rb
+- spec/examples
+- spec/examples/filters
+- spec/examples/filters/a.txt
+- spec/examples/filters/b.txt
+- spec/examples/filters/setup.rb
+- spec/examples/render
+- spec/examples/render/1
+- spec/examples/render/1/a.txt
+- spec/examples/render/1/b.txt
+- spec/examples/render/1/d.erb
+- spec/examples/render/1/setup.rb
+- spec/examples/render/2
+- spec/examples/render/2/setup.rb
+- spec/examples/render/3
+- spec/examples/render/3/setup.rb
+- spec/examples/render/4
+- spec/examples/render/4/a.erb
+- spec/examples/render/4/setup.rb
+- spec/examples/render/5
+- spec/examples/render/5/setup.rb
+- spec/examples/render/6
+- spec/examples/render/6/setup.rb
+- spec/filters_spec.rb
+- spec/render_spec.rb
+- benchmarks/eval-vs-non-eval.rb
+- benchmarks/require-vs-none.rb
+- benchmarks/run-caching.rb
+- examples/example1
+- examples/example1/custom
+- examples/example1/custom/html
+- examples/example1/custom/html/body
+- examples/example1/custom/html/body/important.html
+- examples/example1/custom/html/body/setup.rb
+- examples/example1/custom/html/setup.rb
+- examples/example1/default
+- examples/example1/default/html
+- examples/example1/default/html/body
+- examples/example1/default/html/body/info.erb
+- examples/example1/default/html/body/setup.rb
+- examples/example1/default/html/main.haml
+- examples/example1/default/html/setup.rb
+- examples/example1/run.rb
+- examples/example2
+- examples/example2/run.rb
+- examples/example2/tadpole
+- examples/example2/tadpole/html
+- examples/example2/tadpole/html/content.haml
+- examples/example2/tadpole/html/main.haml
+- examples/example2/tadpole/html/readme
+- examples/example2/tadpole/html/readme/setup.rb
+- examples/example2/tadpole/html/setup.rb
+- examples/example2/tadpole/markdown
+- examples/example2/tadpole/markdown/copyright.md
+- examples/example2/tadpole/markdown/examples.md
+- examples/example2/tadpole/markdown/quick
+- examples/example2/tadpole/markdown/quick/create.md
+- examples/example2/tadpole/markdown/quick/heirarchical.md
+- examples/example2/tadpole/markdown/quick/override.md
+- examples/example2/tadpole/markdown/quick/quick.erb
+- examples/example2/tadpole/markdown/quick/setup.rb
+- examples/example2/tadpole/markdown/readme
+- examples/example2/tadpole/markdown/readme/readme_notice.txt
+- examples/example2/tadpole/markdown/readme/setup.rb
+- examples/example2/tadpole/markdown/setup.rb
+- examples/example2/tadpole/markdown/title.md
+- examples/example2/tadpole/markdown/what.md
+- examples/example2/tadpole/markdown/why.md
+- LICENSE
+- README.html
+- README.markdown
+has_rdoc: false
+homepage: http://www.soen.ca
+post_install_message: 
+rdoc_options: []
+
+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: tadpole
+rubygems_version: 1.1.1
+signing_key: 
+specification_version: 2
+summary: A Small but Extensible Templating Engine for Ruby
+test_files: []
+