yard 0.2.3.5 → 0.4.0

data/spec/{generators → templates}/helpers/html_helper_spec.rb

@@ -1,7 +1,7 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-describe YARD::Generators::Helpers::HtmlHelper do
-  include YARD::Generators::Helpers::HtmlHelper
+describe YARD::Templates::Helpers::HtmlHelper do
+  include YARD::Templates::Helpers::HtmlHelper
 
   describe '#h' do
     it "should use #h to escape HTML" do
@@ -11,11 +11,53 @@ describe YARD::Generators::Helpers::HtmlHelper do
   
   describe '#fix_typewriter' do
     it "should use #fix_typewriter to convert +text+ to <tt>text</tt>" do
-      fix_typewriter("Some +typewriter text+.").should == "Some <tt>typewriter text</tt>."
-      fix_typewriter("Not +typewriter text.").should == "Not +typewriter text."
-      fix_typewriter("Alternating +type writer+ text +here+.").should == "Alternating <tt>type writer</tt> text <tt>here</tt>."
-      fix_typewriter("No ++problem.").should == "No ++problem."
-      fix_typewriter("Math + stuff +is ok+").should == "Math + stuff <tt>is ok</tt>"
+      fix_typewriter("Some +typewriter text+.").should == 
+        "Some <tt>t\x04y\x04p\x04e\x04w\x04r\x04i\x04t\x04e\x04r\x04" +
+        " \x04t\x04e\x04x\x04t\x04</tt>."
+      fix_typewriter("Not +typewriter text.").should == 
+        "Not +typewriter text."
+      fix_typewriter("Alternating +type writer+ text +here+.").should == 
+        "Alternating <tt>t\x04y\x04p\x04e\x04 \x04w\x04r\x04i\x04t\x04e\x04r" +
+        "\x04</tt> text <tt>h\x04e\x04r\x04e\x04</tt>."
+      fix_typewriter("No ++problem.").should == 
+        "No ++problem."
+      fix_typewriter("Math + stuff +is ok+").should == 
+        "Math + stuff <tt>i\x04s\x04 \x04o\x04k\x04</tt>"
+    end
+  end
+  
+  describe '#format_types' do
+    it "should include brackets by default" do
+      text = ["String"]
+      should_receive(:linkify).at_least(1).times.with("String", "String").and_return("String")
+      format_types(text).should == format_types(text, true)
+      format_types(text).should == "(<tt>String</tt>)"
+    end
+
+    it "should avoid brackets if brackets=false" do
+      should_receive(:linkify).with("String", "String").and_return("String")
+      should_receive(:linkify).with("Symbol", "Symbol").and_return("Symbol")
+      format_types(["String", "Symbol"], false).should == "<tt>String</tt>, <tt>Symbol</tt>"
+    end
+    
+    { "String" => [["String"], 
+        "<tt><a href=''>String</a></tt>"], 
+      "A::B::C" => [["A::B::C"], 
+        "<tt><a href=''>A::B::C</a></tt>"],
+      "Array<String>" => [["Array", "String"], 
+        "<tt><a href=''>Array</a>&lt;<a href=''>String</a>&gt;</tt>"], 
+      "Array<String, Symbol>" => [["Array", "String", "Symbol"], 
+        "<tt><a href=''>Array</a>&lt;<a href=''>String</a>, <a href=''>Symbol</a>&gt;</tt>"],
+      "Array<{String => Array<Symbol>}>" => [["Array", "String", "Array", "Symbol"], 
+        "<tt><a href=''>Array</a>&lt;{<a href=''>String</a> =&gt; " +
+        "<a href=''>Array</a>&lt;<a href=''>Symbol</a>&gt;}&gt;</tt>"]
+    }.each do |text, values|
+      it "should link all classes in #{text}" do
+        should_receive(:h).with('<').at_least(text.count('<')).times.and_return("&lt;")
+        should_receive(:h).with('>').at_least(text.count('>')).times.and_return("&gt;")
+        values[0].each {|v| should_receive(:linkify).with(v, v).and_return("<a href=''>#{v}</a>") }
+        format_types([text], false).should == values[1]
+      end
     end
   end
   
@@ -42,19 +84,19 @@ describe YARD::Generators::Helpers::HtmlHelper do
   
     it "should return nil if serializer is nil" do
       stub!(:serializer).and_return nil
-      stub!(:current_object).and_return Registry.root
+      stub!(:object).and_return Registry.root
       url_for(P("Mod::Class#meth")).should be_nil
     end
   
     it "should return nil if serializer does not implement #serialized_path" do
       stub!(:serializer).and_return Serializers::Base.new
-      stub!(:current_object).and_return Registry.root
+      stub!(:object).and_return Registry.root
       url_for(P("Mod::Class#meth")).should be_nil
     end
   
     it "should link to a path/file for a namespace object" do
       stub!(:serializer).and_return Serializers::FileSystemSerializer.new
-      stub!(:current_object).and_return Registry.root
+      stub!(:object).and_return Registry.root
     
       yard = CodeObjects::ModuleObject.new(:root, :YARD)
       url_for(yard).should == 'YARD.html'
@@ -62,7 +104,7 @@ describe YARD::Generators::Helpers::HtmlHelper do
   
     it "should link to the object's namespace path/file and use the object as the anchor" do
       stub!(:serializer).and_return Serializers::FileSystemSerializer.new
-      stub!(:current_object).and_return Registry.root
+      stub!(:object).and_return Registry.root
     
       yard = CodeObjects::ModuleObject.new(:root, :YARD)
       meth = CodeObjects::MethodObject.new(yard, :meth)
@@ -74,7 +116,7 @@ describe YARD::Generators::Helpers::HtmlHelper do
       serializer = mock(:serializer)
       serializer.stub!(:serialized_path).and_return("file.html")
       stub!(:serializer).and_return(serializer)
-      stub!(:current_object).and_return(obj)
+      stub!(:object).and_return(obj)
       url_for(obj).should == "#%2F-instance_method"
     end
   end
@@ -100,17 +142,17 @@ describe YARD::Generators::Helpers::HtmlHelper do
 
     it "should link static files with file: prefix" do
       stub!(:serializer).and_return Serializers::FileSystemSerializer.new
-      stub!(:current_object).and_return Registry.root
+      stub!(:object).and_return Registry.root
 
       parse_link(resolve_links("{file:TEST.txt#abc}")).should == {
         :inner_text => "TEST.txt",
         :title => "TEST.txt",
-        :href => "TEST.txt.html#abc"
+        :href => "file.TEST.html#abc"
       }
       parse_link(resolve_links("{file:TEST.txt title}")).should == {
         :inner_text => "title",
         :title => "title",
-        :href => "TEST.txt.html"
+        :href => "file.TEST.html"
       }
     end
   
@@ -128,5 +170,20 @@ describe YARD::Generators::Helpers::HtmlHelper do
         :title => "title"
       }
     end
+    
+    it "should create mailto links with mailto: prefixes" do
+      parse_link(resolve_links('{mailto:joanna@example.com}')).should == {
+        :inner_text => 'mailto:joanna@example.com',
+        :target => '_parent',
+        :href => 'mailto:joanna@example.com',
+        :title => 'mailto:joanna@example.com'
+      }
+      parse_link(resolve_links('{mailto:steve@example.com Steve}')).should == {
+        :inner_text => 'Steve',
+        :target => '_parent',
+        :href => 'mailto:steve@example.com',
+        :title => 'Steve'
+      }
+    end
   end
-end
+end

data/spec/templates/helpers/html_syntax_highlight_helper_spec.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::Templates::Helpers::HtmlSyntaxHighlightHelper do
+  include YARD::Templates::Helpers::HtmlHelper
+  include YARD::Templates::Helpers::HtmlSyntaxHighlightHelper
+  
+  describe '#html_syntax_highlight' do
+    it "should not highlight source if options[:no_highlight] is set" do
+      should_receive(:options).and_return(:no_highlight => true)
+      html_syntax_highlight("def x\nend").should == "def x\nend"
+    end
+    
+    it "should highlight source (ruby18)" do
+      should_receive(:options).and_return(:no_highlight => false)
+      expect = "<span class='def def kw'>def</span><span class='x identifier id'>x</span>
+        <span class='string val'>'x'</span><span class='plus op'>+</span>
+        <span class='regexp val'>/x/i</span><span class='end end kw'>end</span>"
+      result = html_syntax_highlight("def x\n  'x' + /x/i\nend")
+      html_equals_string(result, expect)
+    end if RUBY18
+
+    it "should highlight source (ruby19)" do
+      should_receive(:options).and_return(:no_highlight => false)
+      expect = "<span class='kw'>def</span> <span class='id x'>x</span>  
+        <span class='tstring'><span class='tstring_beg'>'</span>
+        <span class='tstring_content'>x</span><span class='tstring_end'>'</span>
+        </span> <span class='op'>+</span> <span class='tstring'>
+        <span class='regexp_beg'>/</span><span class='tstring_content'>x</span>
+        <span class='regexp_end'>/i</span></span>\n<span class='kw'>end</span>"
+      result = html_syntax_highlight("def x\n  'x' + /x/i\nend")
+      html_equals_string(result, expect)
+    end if RUBY19
+    
+    it "should return escaped unhighlighted source if a syntax error is found (ruby19)" do
+      should_receive(:options).and_return(:no_highlight => false)
+      html_syntax_highlight("def &x; ... end").should == "def &amp;x; ... end"
+    end if RUBY19
+  end
+end

data/spec/{generators → templates}/helpers/markup_helper_spec.rb

@@ -1,18 +1,18 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-module YARD::Generators::Helpers::MarkupHelper
+module YARD::Templates::Helpers::MarkupHelper
   public :load_markup_provider, :markup_class, :markup_provider
 end
 
 class MyMock
   attr_accessor :options
-  include YARD::Generators::Helpers::MarkupHelper
+  include YARD::Templates::Helpers::MarkupHelper
 end
 
-describe YARD::Generators::Helpers::MarkupHelper do
+describe YARD::Templates::Helpers::MarkupHelper do
   before do
     @gen = mock('Generator')
-    @gen.extend(YARD::Generators::Helpers::MarkupHelper)
+    @gen.extend(YARD::Templates::Helpers::MarkupHelper)
   end
   
   def generator_should_exit
@@ -42,7 +42,7 @@ describe YARD::Generators::Helpers::MarkupHelper do
   it "should load nothing if rdoc is specified" do
     @gen.stub!(:options).and_return({:markup => :rdoc})
     @gen.load_markup_provider
-    @gen.markup_class.should == YARD::Generators::Helpers::MarkupHelper::SimpleMarkup
+    @gen.markup_class.should == YARD::Templates::Helpers::MarkupHelper::SimpleMarkup
   end
   
   it "should search through available markup providers for the markup type if none is set" do
@@ -76,7 +76,7 @@ describe YARD::Generators::Helpers::MarkupHelper do
 
   it "should fail if no provider is found" do
     generator_should_exit
-    YARD::Generators::Helpers::MarkupHelper::MARKUP_PROVIDERS[:markdown].each do |p|
+    YARD::Templates::Helpers::MarkupHelper::MARKUP_PROVIDERS[:markdown].each do |p|
       @gen.should_receive(:require).with(p[:lib].to_s).and_raise(LoadError)
     end
     @gen.stub!(:options).and_return({:markup => :markdown})
@@ -92,4 +92,3 @@ describe YARD::Generators::Helpers::MarkupHelper do
     @gen.markup_provider.should == nil
   end
 end
-

data/spec/templates/method_spec.rb

@@ -0,0 +1,75 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::Templates::Engine.template(:default, :method) do
+  before { Registry.clear }
+  
+  describe 'regular (deprecated) method' do
+    before do
+      YARD.parse_string <<-'eof'
+        private
+        # Comments
+        # @param [String] x the x argument
+        # @return [String] the result
+        # @raise [Exception] hi!
+        # @deprecated for great justice
+        def m(x) end
+        alias x m
+      eof
+    end
+    
+    it "should render html format correctly" do
+      html_equals(Registry.at('#m').format(:format => :html, :no_highlight => true), :method001)
+    end
+    
+    it "should render text format correctly" do
+      text_equals(Registry.at('#m').format, :method001)
+    end
+  end
+  
+  describe 'method with 1 overload' do
+    before do
+      YARD.parse_string <<-'eof'
+        private
+        # Comments
+        # @overload m(x, y)
+        #   @param [String] x parameter x
+        #   @param [Boolean] y parameter y
+        def m(x) end
+      eof
+    end
+    
+    it "should render html format correctly" do
+      html_equals(Registry.at('#m').format(:format => :html, :no_highlight => true), :method002)
+    end
+
+    it "should render text format correctly" do
+      text_equals(Registry.at('#m').format, :method002)
+    end
+  end
+  
+  describe 'method with 2 overloads' do
+    before do
+      YARD.parse_string <<-'eof'
+        private
+        # Method comments
+        # @overload m(x, y)
+        #   Overload docstring
+        #   @param [String] x parameter x
+        #   @param [Boolean] y parameter y
+        # @overload m(x, y, z)
+        #   @param [String] x parameter x
+        #   @param [Boolean] y parameter y
+        #   @param [Boolean] z parameter z
+        def m(*args) end
+      eof
+    end
+    
+    it "should render html format correctly" do
+      html_equals(Registry.at('#m').format(:format => :html, :no_highlight => true), :method003)
+    end
+
+    it "should render text format correctly" do
+      text_equals(Registry.at('#m').format, :method003)
+    end
+  end
+end

data/spec/templates/module_spec.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::Templates::Engine.template(:default, :method) do
+  before do 
+    Registry.clear
+    YARD.parse_string <<-'eof'
+      module B
+        def c; end
+        def d; end
+      end
+
+      # Comments
+      module A
+        attr_accessor :attr1
+        attr_reader :attr2
+        
+        def self.a; end
+        def a; end
+        alias b a
+        
+        include B
+        
+        class Y; end
+        class Q; end
+        class X; end
+        module Z; end
+        CONSTANT = 'value'
+        @@cvar = 'value'
+      end
+    eof
+  end
+
+  it "should render html format correctly" do
+    html_equals(Registry.at('A').format(:format => :html, :no_highlight => true), :module001)
+  end
+
+  it "should render text format correctly" do
+    YARD.parse_string <<-'eof'
+      module A
+        include D, E, F, A::B::C
+      end
+    eof
+
+    text_equals(Registry.at('A').format, :module001)
+  end
+  
+  it "should render dot format correctly" do
+    Registry.at('A').format(:format => :dot, :dependencies => true, :full => true).should == example(:module001, 'dot')
+  end
+end

data/spec/templates/spec_helper.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+include YARD::Templates
+
+def text_equals(result, expected_example)
+  text_equals_string(result, example(expected_example, :txt))
+end
+
+def text_equals_string(result, expected)
+  result.should == expected
+end
+
+def html_equals(result, expected_example)
+  html_equals_string(result, example(expected_example))
+end
+
+def html_equals_string(result, expected)
+  [expected, result].each do |value|
+    value.gsub!(/(>)\s+|\s+(<)/, '\1\2')
+    value.strip!
+  end
+  result.should == expected
+end
+
+def example(filename, ext = 'html')
+  File.read(File.join(File.dirname(__FILE__), 'examples', "#{filename}.#{ext}"))
+end
+
+module YARD::Templates::Engine
+  class << self
+    public :find_template_paths
+  end
+end

data/spec/templates/tag_spec.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::Templates::Engine.template(:default, :tags) do
+  before { Registry.clear }
+  
+  describe 'all known tags' do
+    before do
+      YARD.parse_string <<-'eof'
+        # Comments
+        # @abstract override me
+        # @param [Hash] opts the options
+        # @option opts :key ('') hello
+        # @option opts :key2 (X) hello
+        # @return [String] the result
+        # @raise [Exception] Exception class
+        # @deprecated for great justice
+        # @see A
+        # @see http://url.com
+        # @see http://url.com Example
+        # @author Name
+        # @since 1.0
+        # @version 1.0
+        # @yield a block
+        # @yieldparam [String] a a value
+        # @yieldreturn [Hash] a hash
+        # @example Wash your car
+        #   car.wash
+        # @example To kill a mockingbird
+        #   a = String.new
+        #   flip(a.reverse)
+        def m(opts = {}) end
+      eof
+    end
+
+    it "should render text format correctly" do
+      text_equals(Registry.at('#m').format, :tag001)
+    end
+  end
+end

data/spec/templates/template_spec.rb

@@ -0,0 +1,398 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::Templates::Template do
+  def template(path)
+    YARD::Templates::Engine.template!(path, '/full/path/' + path.to_s)
+  end
+  
+  describe '#initialize' do
+    it "should not include parent directory if parent directory is a template root path" do
+      mod = template('q')
+      mod.should_not include(template(''))
+    end
+    
+    it "should include parent directory template if exists" do
+      mod1 = template('x')
+      mod2 = template('x/y')
+      mod2.should include(mod1)
+    end
+  end
+  
+  describe '.full_paths' do
+    it "should list full_path" do
+      mod = template(:a)
+      mod.full_paths.should == ['/full/path/a']
+    end
+    
+    it "should list paths of included modules" do
+      mod = template(:a)
+      mod.send(:include, template(:b))
+      mod.full_paths.should == ['/full/path/a', '/full/path/b']
+    end
+    
+    it "should list paths from modules of included modules" do
+      mod = template(:c)
+      mod.send(:include, template(:d))
+      mod.send(:include, template(:a))
+      mod.full_paths.should == ['c', 'a', 'b', 'd'].map {|o| '/full/path/' + o }
+    end
+    
+    it "should only list full paths of modules that respond to full_paths" do
+      mod = template(:d)
+      mod.send(:include, Enumerable)
+      mod.full_paths.should == ['/full/path/d']
+    end
+  end
+  
+  describe '.load_setup_rb' do
+    it "should load setup.rb file for module" do
+      File.should_receive(:file?).with('/full/path/e/setup.rb').and_return(true)
+      File.should_receive(:read).with('/full/path/e/setup.rb').and_return('def success; end')
+      template(:e).new.should respond_to(:success)
+    end
+  end
+  
+  describe '.T' do
+    it "should load template from absolute path" do
+      mod = template(:a)
+      Engine.should_receive(:template).with('other')
+      mod.T('other')
+    end
+  end
+  
+  describe '.find_file' do
+    it "should find file in module's full_path" do
+      File.should_receive(:file?).with('/full/path/a/basename').and_return(false)
+      File.should_receive(:file?).with('/full/path/b/basename').and_return(true)
+      template(:a).find_file('basename').should == '/full/path/b/basename'
+    end
+    
+    it "should return nil if no file is found" do
+      File.should_receive(:file?).with('/full/path/a/basename').and_return(false)
+      File.should_receive(:file?).with('/full/path/b/basename').and_return(false)
+      template(:a).find_file('basename').should be_nil
+    end
+  end
+  
+  describe '.find_nth_file' do
+    it "should find 2nd existing file in template paths" do
+      File.should_receive(:file?).with('/full/path/a/basename').and_return(true)
+      File.should_receive(:file?).with('/full/path/b/basename').and_return(true)
+      template(:a).find_nth_file('basename', 2).should == '/full/path/b/basename'
+    end
+    
+    it "should return nil if no file is found" do
+      File.should_receive(:file?).with('/full/path/a/basename').and_return(true)
+      File.should_receive(:file?).with('/full/path/b/basename').and_return(true)
+      template(:a).find_nth_file('basename', 3).should be_nil
+    end
+  end
+  
+  describe '.extra_includes' do
+    it "should be included when a module is initialized" do
+      module MyModule; end
+      Template.extra_includes << MyModule
+      template(:e).new.should be_kind_of(MyModule)
+    end
+  end
+  
+  describe '.is_a?' do
+    it "should be kind of Template" do
+      template(:e).is_a?(Template).should == true
+    end
+  end
+  
+  describe '#T' do
+    it "should delegate to class method" do
+      template(:e).should_receive(:T).with('test')
+      template(:e).new.T('test')
+    end
+  end
+  
+  describe '#init' do
+    it "should be called during initialization" do
+      module YARD::Templates::Engine::Template__full_path_e
+        def init; sections 1, 2, 3 end 
+      end
+      template(:e).new.sections.should == [1, 2, 3]
+    end
+  end
+  
+  describe '#file' do
+    it "should read the file if it exists" do
+      File.should_receive(:file?).with('/full/path/e/abc').and_return(true)
+      IO.should_receive(:read).with('/full/path/e/abc').and_return('hello world')
+      template(:e).new.file('abc').should == 'hello world'
+    end
+    
+    it "should raise ArgumentError if the file does not exist" do
+      File.should_receive(:file?).with('/full/path/e/abc').and_return(false)
+      lambda { template(:e).new.file('abc') }.should raise_error(ArgumentError)
+    end
+    
+    it "should replace {{{__super__}}} with inherited template contents if allow_inherited=true" do
+      File.should_receive(:file?).with('/full/path/a/abc').twice.and_return(true)
+      File.should_receive(:file?).with('/full/path/b/abc').and_return(true)
+      IO.should_receive(:read).with('/full/path/a/abc').and_return('foo {{{__super__}}}')
+      IO.should_receive(:read).with('/full/path/b/abc').and_return('bar')
+      template(:a).new.file('abc', true).should == "foo bar"
+    end
+
+    it "should not replace {{{__super__}}} with inherited template contents if allow_inherited=false" do
+      File.should_receive(:file?).with('/full/path/a/abc').and_return(true)
+      IO.should_receive(:read).with('/full/path/a/abc').and_return('foo {{{__super__}}}')
+      template(:a).new.file('abc').should == "foo {{{__super__}}}"
+    end
+  end
+  
+  describe '#superb' do
+    it "should return the inherited erb template contents" do
+      File.should_receive(:file?).with('/full/path/a/test.erb').and_return(true)
+      File.should_receive(:file?).with('/full/path/b/test.erb').and_return(true)
+      IO.should_receive(:read).with('/full/path/b/test.erb').and_return('bar')
+      template = template(:a).new
+      template.section = :test
+      template.superb.should == "bar"
+    end
+    
+    it "should work inside an erb template" do
+      File.should_receive(:file?).with('/full/path/a/test.erb').twice.and_return(true)
+      File.should_receive(:file?).with('/full/path/b/test.erb').and_return(true)
+      IO.should_receive(:read).with('/full/path/a/test.erb').and_return('foo<%= superb %>!')
+      IO.should_receive(:read).with('/full/path/b/test.erb').and_return('bar')
+      template = template(:a).new
+      template.section = :test
+      template.erb(:test).should == "foobar!"
+    end
+  end
+  
+  describe '#sections' do
+    it "should allow sections to be set if arguments are provided" do
+      mod = template(:e).new
+      mod.sections 1, 2, [3]
+      mod.sections.should == [1, 2, [3]]
+    end
+  end
+  
+  describe '#run' do
+    it "should render all sections" do
+      mod = template(:e).new
+      mod.should_receive(:render_section).with(:a).and_return('a')
+      mod.should_receive(:render_section).with(:b).and_return('b')
+      mod.should_receive(:render_section).with(:c).and_return('c')
+      mod.sections :a, :b, :c
+      mod.run.should == 'abc'
+    end
+    
+    it "should render all sections with options" do
+      mod = template(:e).new
+      mod.should_receive(:render_section).with(:a).and_return('a')
+      mod.should_receive(:add_options).with(:a => 1).and_yield
+      mod.sections :a
+      mod.run(:a => 1).should == 'a'
+    end
+    
+    it "should run section list if provided" do
+      mod = template(:e).new
+      mod.should_receive(:render_section).with(:q)
+      mod.should_receive(:render_section).with(:x)
+      mod.run({}, [:q, :x])
+    end
+    
+    it "should accept a nil section as empty string" do
+      mod = template(:e).new
+      mod.should_receive(:render_section).with(:a)
+      mod.sections :a
+      mod.run.should == ""
+    end
+  end
+  
+  describe '#add_options' do
+    it "should set instance variables in addition to options" do
+      mod = template(:f).new
+      mod.send(:add_options, {:a => 1, :b => 2})
+      mod.options.should == {:a => 1, :b => 2}
+      mod.instance_variable_get("@a").should == 1
+      mod.instance_variable_get("@b").should == 2
+    end
+    
+    it "should set instance variables and options only for the block" do
+      mod = template(:f).new
+      mod.send(:add_options, {:a => 100, :b => 200}) do
+        mod.options.should == {:a => 100, :b => 200}
+      end
+      mod.options.should_not == {:a => 100, :b => 200}
+    end
+  end
+  
+  describe '#render_section' do
+    it "should call method if method exists by section name as Symbol" do
+      mod = template(:f).new
+      mod.should_receive(:respond_to?).with(:a).and_return(true)
+      mod.should_receive(:respond_to?).with('a').and_return(true)
+      mod.should_receive(:send).with(:a).and_return('a')
+      mod.should_receive(:send).with('a').and_return('a')
+      mod.run({}, [:a, 'a']).should == 'aa'
+    end
+    
+    it "should call erb if no method exists by section name" do
+      mod = template(:f).new
+      mod.should_receive(:respond_to?).with(:a).and_return(false)
+      mod.should_receive(:respond_to?).with('a').and_return(false)
+      mod.should_receive(:erb).with(:a).and_return('a')
+      mod.should_receive(:erb).with('a').and_return('a')
+      mod.run({}, [:a, 'a']).should == 'aa'
+    end
+    
+    it "should run a template if section is one" do
+      mod2 = template(:g)
+      mod2.should_receive(:run)
+      mod = template(:f).new
+      mod.sections mod2
+      mod.run
+    end
+    
+    it "should run a template instance if section is one" do
+      mod2 = template(:g).new
+      mod2.should_receive(:run)
+      mod = template(:f).new
+      mod.sections mod2
+      mod.run
+    end
+  end 
+  
+  describe '#subsections' do
+    it "should set subsections when they are available" do
+      mod = template(:e).new
+      mod.sections :a, [:b, :c]
+      mod.should_receive(:render_section).with(:a) do
+        mod.subsections.should == [:b, :c]
+      end
+      mod.run
+    end
+  end
+  
+  describe '#yield' do
+    it "should yield a subsection" do
+      mod = template(:e).new
+      mod.sections :a, [:b, :c]
+      class << mod
+        def a; "(" + yield + ")" end
+        def b; "b" end
+        def c; "c" end
+      end
+
+      mod.run.should == "(b)"
+    end
+    
+    it "should yield a subsection within a yielded subsection" do
+      mod = template(:e).new
+      mod.sections :a, [:b, [:c]]
+      class << mod
+        def a; "(" + yield + ")" end
+        def b; yield end
+        def c; "c" end
+      end
+
+      mod.run.should == "(c)"
+    end
+    
+    it "should support arbitrary nesting" do
+      mod = template(:e).new
+      mod.sections :a, [:b, [:c, [:d, [:e]]]]
+      class << mod
+        def a; "(" + yield + ")" end
+        def b; yield end
+        def c; yield end
+        def d; yield end
+        def e; "e" end
+      end
+
+      mod.run.should == "(e)"
+    end
+    
+    it "should yield first two elements if yield is called twice" do
+      mod = template(:e).new
+      mod.sections :a, [:b, :c, :d]
+      class << mod
+        def a; "(" + yield + yield + ")" end
+        def b; 'b' end
+        def c; "c" end
+      end
+
+      mod.run.should == "(bc)"
+    end
+    
+    it "should ignore any subsections inside subsection yields" do
+      mod = template(:e).new
+      mod.sections :a, [:b, [:c], :d]
+      class << mod
+        def a; "(" + yield + yield + ")" end
+        def b; 'b' end
+        def d; "d" end
+      end
+
+      mod.run.should == "(bd)"
+    end
+    
+    it "should allow extra options passed via yield" do
+      mod = template(:e).new
+      mod.sections :a, [:b]
+      class << mod
+        def a; "(" + yield(:x => "a") + ")" end
+        def b; options[:x] + @x end
+      end
+
+      mod.run.should == "(aa)"
+    end
+  end
+  
+  describe '#yieldall' do
+    it "should yield all subsections" do
+      mod = template(:e).new
+      mod.sections :a, [:b, [:d, [:e]], :c]
+      class << mod
+        def a; "(" + yieldall + ")" end
+        def b; "b" + yieldall end
+        def c; "c" end
+        def d; 'd' + yieldall end
+        def e; 'e' end
+      end
+
+      mod.run.should == "(bdec)"
+    end
+    
+    it "should yield options to all subsections" do
+      mod = template(:e).new
+      mod.sections :a, [:b, :c]
+      class << mod
+        def a; "(" + yieldall(:x => "2") + ")" end
+        def b; @x end
+        def c; @x end
+      end
+      mod.run.should == "(22)"
+    end
+    
+    it "should yield all subsections more than once" do
+      mod = template(:e).new
+      mod.sections :a, [:b]
+      class << mod
+        def a; "(" + yieldall + yieldall + ")" end
+        def b; "b" end
+      end
+
+      mod.run.should == "(bb)"
+    end
+    
+    it "should not yield if no yieldall is called" do
+      mod = template(:e).new
+      mod.sections :a, [:b]
+      class << mod
+        def a; "()" end
+        def b; "b" end
+      end
+
+      mod.run.should == "()"
+    end
+  end
+end