yard 0.7.5 → 0.8.0

data/spec/templates/onefile_spec.rb

@@ -6,7 +6,7 @@ class StringSerializer < YARD::Serializers::Base
     @files = files
     @string = string
   end
-  
+
   def serialize(object, data)
     files << object
     string << data
@@ -14,34 +14,51 @@ class StringSerializer < YARD::Serializers::Base
 end
 
 describe YARD::Templates::Engine.template(:default, :onefile) do
-  before { Registry.clear }
+  before do
+    Registry.clear
+    if defined?(::Encoding)
+      @eenc, Encoding.default_external = Encoding.default_external, 'ascii-8bit'
+      @ienc, Encoding.default_internal = Encoding.default_internal, 'ascii-8bit'
+    end
+  end
 
-  it "should render html" do
-    files = []
-    string = ''
+  after do
+    if defined?(::Encoding)
+      Encoding.default_internal = @ienc
+      Encoding.default_external = @eenc
+    end
+  end
+
+  def render
+    @files = []
+    @output = ''
     YARD.parse_string <<-eof
       class A
         # Foo method
         # @return [String]
         def foo; end
-        
+
         # Bar method
         # @return [Numeric]
         def bar; end
       end
     eof
-    readme = CodeObjects::ExtraFileObject.new('README', 
+    readme = CodeObjects::ExtraFileObject.new('README',
       "# This is a code comment\n\n# Top of file\n\n\nclass C; end")
-    Templates::Engine.generate Registry.all(:class), 
-      :serializer => StringSerializer.new(files, string),
+    Templates::Engine.generate Registry.all(:class),
+      :serializer => StringSerializer.new(@files, @output),
       :onefile => true, :format => :html, :readme => readme, :files => [readme,
         CodeObjects::ExtraFileObject.new('LICENSE', 'This is a license!')
       ]
-    files.should == ['index.html']
-    string.should include("This is a code comment")
-    string.should include("This is a license!")
-    string.should include("Class: A")
-    string.should include("Foo method")
-    string.should include("Bar method")
+  end
+
+  it "should render html" do
+    render
+    @files.should == ['index.html']
+    @output.should include("This is a code comment")
+    @output.should include("This is a license!")
+    @output.should include("Class: A")
+    @output.should include("Foo method")
+    @output.should include("Bar method")
   end
 end

data/spec/templates/section_spec.rb

@@ -2,7 +2,7 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 describe YARD::Templates::Section do
   include YARD::Templates
-  
+
   describe '#initialize' do
     it "should convert first argument to splat if it is array" do
       s = Section.new(:name, [:foo, :bar])
@@ -10,7 +10,7 @@ describe YARD::Templates::Section do
       s[0].name.should == :foo
       s[1].name.should == :bar
     end
-    
+
     it "should allow initialization with Section objects" do
       s = Section.new(:name, [:foo, Section.new(:bar)])
       s.name.should == :name
@@ -23,67 +23,67 @@ describe YARD::Templates::Section do
       s.should == Section.new(:name, Section.new(:foo, Section.new(:bar)))
     end
   end
-  
+
   describe '#[]' do
     it "should use Array#[] if argument is integer" do
       Section.new(:name, [:foo, :bar])[0].name.should == :foo
     end
-    
+
     it "should return new Section object if more than one argument" do
       Section.new(:name, :foo, :bar, :baz)[1, 2].should ==
         Section.new(:name, :bar, :baz)
     end
-    
+
     it "should return new Section object if arg is Range" do
       Section.new(:name, :foo, :bar, :baz)[1..2].should ==
         Section.new(:name, :bar, :baz)
     end
-    
+
     it "should look for section by name if arg is object" do
       Section.new(:name, :foo, :bar, [:baz])[:bar][:baz].should ==
         Section.new(:baz)
     end
   end
-  
+
   describe '#eql?' do
     it "should check for equality of two equal sections" do
       Section.new(:foo, [:a, :b]).should be_eql(Section.new(:foo, :a, :b))
       Section.new(:foo, [:a, :b]).should == Section.new(:foo, :a, :b)
     end
-    
+
     it "should not be equal if section names are different" do
       Section.new(:foo, [:a, :b]).should_not be_eql(Section.new(:bar, :a, :b))
       Section.new(:foo, [:a, :b]).should_not == Section.new(:bar, :a, :b)
     end
   end
-  
+
   describe '#==' do
     it "should allow comparison to Symbol" do
       Section.new(:foo, 2, 3).should == :foo
     end
-    
+
     it "should allow comparison to String" do
       Section.new("foo", 2, 3).should == "foo"
     end
-    
+
     it "should allow comparison to Template" do
       t = YARD::Templates::Engine.template!(:xyzzy, '/full/path/xyzzy')
       Section.new(t, 2, 3).should == t
     end
-    
+
     it "should allow comparison to Section" do
       Section.new(1, [2, 3]).should == Section.new(1, 2, 3)
     end
-    
+
     it "should allow comparison to Object" do
       Section.new(1, [2, 3]).should == 1
     end
-    
+
     it "should allow comparison to Array" do
       Section.new(1, 2, [3]).should == [1, [2, [3]]]
     end
   end
-  
+
   describe '#to_a' do
     it "should convert Section to regular Array list" do
       arr = Section.new(1, 2, [3, [4]]).to_a
@@ -91,37 +91,37 @@ describe YARD::Templates::Section do
       arr.should == [1, [2, [3, [4]]]]
     end
   end
-  
+
   describe '#place' do
     it "should place objects as Sections" do
       Section.new(1, 2, 3).place(4).before(3).should == [1, [2, 4, 3]]
     end
-    
+
     it "should place objects anywhere inside Section with before/after_any" do
       Section.new(1, 2, [3, [4]]).place(5).after_any(4).should == [1, [2, [3, [4, 5]]]]
       Section.new(1, 2, [3, [4]]).place(5).before_any(4).should == [1, [2, [3, [5, 4]]]]
     end
-    
+
     it "should allow multiple sections to be placed" do
       Section.new(1, 2, 3).place(4, 5).after(3).to_a.should == [1, [2, 3, 4, 5]]
       Section.new(1, 2, 3).place(4, [5]).after(3).to_a.should == [1, [2, 3, 4, [5]]]
     end
   end
-  
+
   describe '#push' do
     it "should push objects as Sections" do
       s = Section.new(:foo)
       s.push :bar
       s[0].should == Section.new(:bar)
     end
-    
+
     it "should alias to #<<" do
       s = Section.new(1)
       s << :index
       s[:index].should be_a(Section)
     end
   end
-  
+
   describe '#unshift' do
     it "should unshift objects as Sections" do
       s = Section.new(:foo)
@@ -129,14 +129,14 @@ describe YARD::Templates::Section do
       s[0].should == Section.new(:bar)
     end
   end
-  
+
   describe '#any' do
     it "should find item inside sections" do
       s = Section.new(:foo, Section.new(:bar, Section.new(:bar)))
       s.any(:bar).push(:baz)
       s.to_a.should == [:foo, [:bar, [:bar, :baz]]]
     end
-    
+
     it "should find item in any deeply nested set of sections" do
       s = Section.new(:foo, Section.new(:bar, Section.new(:baz)))
       s.any(:baz).push(:qux)

data/spec/templates/spec_helper.rb

@@ -2,7 +2,7 @@ require File.dirname(__FILE__) + '/../spec_helper'
 
 include YARD::Templates
 
-def only_copy?(result, example, type) 
+def only_copy?(result, example, type)
   if $COPY == :all || $COPY == example
     puts(result) unless $COPYT && $COPYT != type
   end
@@ -40,3 +40,33 @@ module YARD::Templates::Engine
     public :find_template_paths
   end
 end
+
+class TestHtmlTemplateOptions < Templates::TemplateOptions
+  default_attr :markup, :none
+  default_attr :default_return, ""
+  default_attr :format, :html
+  default_attr :highlight, false
+end
+
+class TestTextTemplateOptions < Templates::TemplateOptions
+  default_attr :markup, :none
+  default_attr :default_return, ""
+  default_attr :format, :text
+  default_attr :highlight, false
+end
+
+def html_options(opts = {})
+  template_options(opts, TestHtmlTemplateOptions)
+end
+
+def text_options(opts = {})
+  template_options(opts, TestTextTemplateOptions)
+end
+
+def template_options(opts, klass)
+  options = klass.new
+  options.reset_defaults
+  options.update(opts)
+  options
+end
+

data/spec/templates/tag_spec.rb

@@ -2,7 +2,7 @@ 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'
@@ -33,18 +33,18 @@ describe YARD::Templates::Engine.template(:default, :tags) do
     end
 
     it "should render text format correctly" do
-      text_equals(Registry.at('#m').format, :tag001)
+      text_equals(Registry.at('#m').format(text_options), :tag001)
     end
   end
-  
+
   describe 'param tags on non-methods' do
     it 'should not display @param tags on non-method objects' do
       YARD.parse_string <<-'eof'
         # @param [#to_s] name the name
         module Foo; end
       eof
-      
-      proc = lambda { Registry.at('Foo').format(:format => :html) }
+
+      proc = lambda { Registry.at('Foo').format(html_options) }
       proc.should_not raise_error(NoMethodError)
     end
   end

data/spec/templates/template_spec.rb

@@ -8,13 +8,13 @@ describe YARD::Templates::Template do
   before :each do
     YARD::Templates::ErbCache.clear!
   end
-  
+
   describe '.include_parent' 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 overridden parent directory" do
       Engine.stub!(:template_paths).and_return(['/foo', '/bar'])
       File.should_receive(:directory?).with('/foo/a/b').and_return(true)
@@ -24,40 +24,40 @@ describe YARD::Templates::Template do
       ancestors = Engine.template('a/b').ancestors.map {|c| c.class_name }
       ancestors[0, 3].should == %w( Template__foo_a_b Template__bar_a Template__foo_a )
     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)
@@ -65,7 +65,7 @@ describe YARD::Templates::Template do
       template(:e).new.should respond_to(:success)
     end
   end
-  
+
   describe '.T' do
     it "should load template from absolute path" do
       mod = template(:a)
@@ -73,77 +73,85 @@ describe YARD::Templates::Template do
       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
+
+    it "should support lambdas in list" do
+      module MyModule2; end
+      Template.extra_includes << lambda {|opts| MyModule2 if opts.format == :html }
+      template(:f).new(:format => :html).should be_kind_of(MyModule2)
+      metaclass = (class << template(:g).new(:format => :text); self end)
+      metaclass.ancestors.should_not include(MyModule2)
+    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 
+        def init; sections 1, 2, 3 end
       end
       template(:e).new.sections.should == Section.new(nil, 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)
@@ -158,7 +166,7 @@ describe YARD::Templates::Template do
       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)
@@ -168,7 +176,7 @@ describe YARD::Templates::Template do
       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)
@@ -179,7 +187,7 @@ describe YARD::Templates::Template do
       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
@@ -187,7 +195,7 @@ describe YARD::Templates::Template do
       mod.sections.should == Section.new(nil, 1, 2, [3])
     end
   end
-  
+
   describe '#run' do
     it "should render all sections" do
       mod = template(:e).new
@@ -197,7 +205,7 @@ describe YARD::Templates::Template do
       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(Section.new(:a)).and_return('a')
@@ -205,14 +213,14 @@ describe YARD::Templates::Template do
       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(Section.new(:q))
       mod.should_receive(:render_section).with(Section.new(: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(Section.new(:a))
@@ -220,7 +228,7 @@ describe YARD::Templates::Template do
       mod.run.should == ""
     end
   end
-  
+
   describe '#add_options' do
     it "should set instance variables in addition to options" do
       mod = template(:f).new
@@ -229,7 +237,7 @@ describe YARD::Templates::Template do
       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
@@ -238,7 +246,7 @@ describe YARD::Templates::Template do
       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
@@ -248,7 +256,7 @@ describe YARD::Templates::Template do
       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)
@@ -257,7 +265,7 @@ describe YARD::Templates::Template do
       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)
@@ -265,7 +273,7 @@ describe YARD::Templates::Template do
       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)
@@ -273,8 +281,8 @@ describe YARD::Templates::Template do
       mod.sections mod2
       mod.run
     end
-  end 
-  
+  end
+
   describe '#yield' do
     it "should yield a subsection" do
       mod = template(:e).new
@@ -287,7 +295,7 @@ describe YARD::Templates::Template do
 
       mod.run.should == "(b)"
     end
-    
+
     it "should yield a subsection within a yielded subsection" do
       mod = template(:e).new
       mod.sections :a, [:b, [:c]]
@@ -299,7 +307,7 @@ describe YARD::Templates::Template do
 
       mod.run.should == "(c)"
     end
-    
+
     it "should support arbitrary nesting" do
       mod = template(:e).new
       mod.sections :a, [:b, [:c, [:d, [:e]]]]
@@ -313,7 +321,7 @@ describe YARD::Templates::Template do
 
       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]
@@ -325,7 +333,7 @@ describe YARD::Templates::Template do
 
       mod.run.should == "(bc)"
     end
-    
+
     it "should ignore any subsections inside subsection yields" do
       mod = template(:e).new
       mod.sections :a, [:b, [:c], :d]
@@ -337,19 +345,19 @@ describe YARD::Templates::Template do
 
       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
+        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
@@ -364,7 +372,7 @@ describe YARD::Templates::Template do
 
       mod.run.should == "(bdec)"
     end
-    
+
     it "should yield options to all subsections" do
       mod = template(:e).new
       mod.sections :a, [:b, :c]
@@ -375,7 +383,7 @@ describe YARD::Templates::Template do
       end
       mod.run.should == "(22)"
     end
-    
+
     it "should yield all subsections more than once" do
       mod = template(:e).new
       mod.sections :a, [:b]
@@ -386,7 +394,7 @@ describe YARD::Templates::Template do
 
       mod.run.should == "(bb)"
     end
-    
+
     it "should not yield if no yieldall is called" do
       mod = template(:e).new
       mod.sections :a, [:b]