yard 0.7.5 → 0.8.0

data/spec/templates/helpers/markup/rdoc_markup_spec.rb

@@ -3,12 +3,12 @@ require File.dirname(__FILE__) + "/../../spec_helper"
 describe YARD::Templates::Helpers::Markup::RDocMarkup do
   describe 'loading mechanism' do
     before { @good_libs = [] }
-    
+
     def require(lib)
       return true if @good_libs.include?(lib)
       raise LoadError
     end
-    
+
     def load_markup
       begin
         require 'rdoc/markup'
@@ -24,12 +24,12 @@ describe YARD::Templates::Helpers::Markup::RDocMarkup do
         end
       end
     end
-    
+
     it "should load RDoc2.x if rdoc/markup is present" do
       @good_libs += ['rdoc/markup', 'rdoc/markup/to_html']
       load_markup.should == :RDoc2
     end
-    
+
     it "should fail on RDoc2.x if rdoc/markup/to_html is not present" do
       @good_libs += ['rdoc/markup']
       lambda { load_markup }.should raise_error(NameError)
@@ -39,44 +39,44 @@ describe YARD::Templates::Helpers::Markup::RDocMarkup do
       @good_libs += ['rdoc/markup/simple_markup', 'rdoc/markup/simple_markup/to_html']
       load_markup.should == :RDoc1
     end
-    
+
     it "should error on loading if neither lib is present" do
       lambda { load_markup }.should raise_error(NameError)
     end
   end
-  
+
   describe '#fix_typewriter' do
     def fix_typewriter(text)
       YARD::Templates::Helpers::Markup::RDocMarkup.new('').send(:fix_typewriter, text)
     end
 
     it "should use #fix_typewriter to convert +text+ to <tt>text</tt>" do
-      fix_typewriter("Some +typewriter text <+.").should == 
+      fix_typewriter("Some +typewriter text <+.").should ==
         "Some <tt>typewriter" +
         " text &lt;</tt>."
-      fix_typewriter("Not +typewriter text.").should == 
+      fix_typewriter("Not +typewriter text.").should ==
         "Not +typewriter text."
-      fix_typewriter("Alternating +type writer+ text +here+.").should == 
+      fix_typewriter("Alternating +type writer+ text +here+.").should ==
         "Alternating <tt>type writer" +
         "</tt> text <tt>here</tt>."
-      fix_typewriter("No ++problem.").should == 
+      fix_typewriter("No ++problem.").should ==
         "No ++problem."
-      fix_typewriter("Math + stuff +is ok+").should == 
+      fix_typewriter("Math + stuff +is ok+").should ==
         "Math + stuff <tt>is ok</tt>"
       fix_typewriter("Hello +{Foo}+ World").should == "Hello <tt>{Foo}</tt> World"
     end
-    
+
     it "should not apply to code blocks" do
       fix_typewriter("<code>Hello +hello+</code>").should == "<code>Hello +hello+</code>"
     end
-    
+
     it "should not apply to HTML tag attributes" do
-      fix_typewriter("<a href='http://foo.com/A+b+c'>A+b+c</a>").should == 
+      fix_typewriter("<a href='http://foo.com/A+b+c'>A+b+c</a>").should ==
         "<a href='http://foo.com/A+b+c'>A+b+c</a>"
-      fix_typewriter("<foo class='foo+bar+baz'/>").should == 
+      fix_typewriter("<foo class='foo+bar+baz'/>").should ==
         "<foo class='foo+bar+baz'/>"
     end
-    
+
     it "should still apply inside of other tags" do
       fix_typewriter("<p>+foo+</p>").should == "<p><tt>foo</tt></p>"
     end

data/spec/templates/helpers/markup_helper_spec.rb

@@ -7,56 +7,59 @@ end
 class GeneratorMock
   attr_accessor :options
   include YARD::Templates::Helpers::MarkupHelper
-  def initialize(options = {}) self.options = options end
+  def initialize(options = Templates::TemplateOptions.new)
+    self.options = options
+  end
 end
 
 describe YARD::Templates::Helpers::MarkupHelper do
   before do
     YARD::Templates::Helpers::MarkupHelper.clear_markup_cache
   end
-  
+
   describe '#load_markup_provider' do
     before do
       log.stub!(:error)
       @gen = GeneratorMock.new
+      @gen.options.reset_defaults
     end
-  
+
     it "should exit on an invalid markup type" do
-      @gen.options = {:markup => :invalid}
+      @gen.options.markup = :invalid
       @gen.load_markup_provider.should == false
     end
 
     it "should fail on when an invalid markup provider is specified" do
-      @gen.stub!(:options).and_return({:markup => :markdown, :markup_provider => :invalid})
+      @gen.options.update(:markup => :markdown, :markup_provider => :invalid)
       @gen.load_markup_provider.should == false
       @gen.markup_class.should == nil
     end
-  
+
     it "should load RDocMarkup if rdoc is specified and it is installed" do
-      @gen.stub!(:options).and_return({:markup => :rdoc})
+      @gen.options.markup = :rdoc
       @gen.load_markup_provider.should == true
       @gen.markup_class.should == YARD::Templates::Helpers::Markup::RDocMarkup
     end
-    
+
     it "should fail if RDoc cannot be loaded" do
-      @gen.stub!(:options).and_return({:markup => :rdoc})
+      @gen.options.markup = :rdoc
       @gen.should_receive(:eval).with('::YARD::Templates::Helpers::Markup::RDocMarkup').and_raise(NameError)
       @gen.load_markup_provider.should == false
       @gen.markup_provider.should == nil
     end
-  
+
     it "should search through available markup providers for the markup type if none is set" do
       @gen.should_receive(:eval).with('::RedcarpetCompat').and_return(mock(:bluecloth))
       @gen.should_receive(:require).with('redcarpet').and_return(true)
       @gen.should_not_receive(:require).with('maruku')
-      @gen.stub!(:options).and_return({:markup => :markdown})
-      # this only raises an exception because we mock out require to avoid 
-      # loading any libraries but our implementation tries to return the library 
+      @gen.options.markup = :markdown
+      # this only raises an exception because we mock out require to avoid
+      # loading any libraries but our implementation tries to return the library
       # name as a constant
       @gen.load_markup_provider.should == true
       @gen.markup_provider.should == :redcarpet
     end
-  
+
     it "should continue searching if some of the providers are unavailable" do
       @gen.should_receive(:require).with('redcarpet').and_raise(LoadError)
       @gen.should_receive(:require).with('rdiscount').and_raise(LoadError)
@@ -65,18 +68,18 @@ describe YARD::Templates::Helpers::MarkupHelper do
       @gen.should_receive(:require).with('maruku').and_raise(LoadError)
       @gen.should_receive(:require).with('rpeg-markdown').and_return(true)
       @gen.should_receive(:eval).with('::PEGMarkdown').and_return(true)
-      @gen.stub!(:options).and_return({:markup => :markdown})
-      # this only raises an exception because we mock out require to avoid 
-      # loading any libraries but our implementation tries to return the library 
+      @gen.options.markup = :markdown
+      # this only raises an exception because we mock out require to avoid
+      # loading any libraries but our implementation tries to return the library
       # name as a constant
       @gen.load_markup_provider.should rescue nil
       @gen.markup_provider.should == :"rpeg-markdown"
     end
-  
+
     it "should override the search if `:markup_provider` is set in options" do
       @gen.should_receive(:require).with('rdiscount').and_return(true)
       @gen.should_receive(:eval).with('::RDiscount').and_return(true)
-      @gen.stub!(:options).and_return({:markup => :markdown, :markup_provider => :rdiscount})
+      @gen.options.update(:markup => :markdown, :markup_provider => :rdiscount)
       @gen.load_markup_provider.should rescue nil
       @gen.markup_provider.should == :rdiscount
     end
@@ -85,42 +88,42 @@ describe YARD::Templates::Helpers::MarkupHelper do
       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})
+      @gen.options.markup = :markdown
       @gen.load_markup_provider.should == false
       @gen.markup_provider.should == nil
     end
 
     it "should fail if overridden provider is not found" do
       @gen.should_receive(:require).with('rdiscount').and_raise(LoadError)
-      @gen.stub!(:options).and_return({:markup => :markdown, :markup_provider => :rdiscount})
+      @gen.options.update(:markup => :markdown, :markup_provider => :rdiscount)
       @gen.load_markup_provider.should == false
       @gen.markup_provider.should == nil
     end
-    
+
     it "should fail if the markup type is not found" do
       log.should_receive(:error).with(/Invalid markup/)
-      @gen.stub!(:options).and_return(:markup => :xxx)
+      @gen.options.markup = :xxx
       @gen.load_markup_provider.should == false
       @gen.markup_provider.should == nil
     end
   end
-  
+
   describe '#markup_for_file' do
     include YARD::Templates::Helpers::MarkupHelper
 
     it "should look for a shebang line" do
       markup_for_file("#!text\ntext here", 'file.rdoc').should == :text
     end
-    
+
     it "should return the default markup type if no shebang is found or no valid ext is found" do
-      stub!(:options).and_return({:markup => :default_type})
+      stub!(:options).and_return(Options.new.update(:markup => :default_type))
       markup_for_file('', 'filename').should == :default_type
     end
-    
+
     it "should look for a file extension if no shebang is found" do
       markup_for_file('', 'filename.MD').should == :markdown
     end
-    
+
     Templates::Helpers::MarkupHelper::MARKUP_EXTENSIONS.each do |type, exts|
       exts.each do |ext|
         it "should recognize .#{ext} as #{type} markup type" do

data/spec/templates/helpers/method_helper_spec.rb

@@ -3,7 +3,7 @@ require File.dirname(__FILE__) + "/../spec_helper"
 describe YARD::Templates::Helpers::MethodHelper do
   include YARD::Templates::Helpers::BaseHelper
   include YARD::Templates::Helpers::MethodHelper
-  
+
   describe '#format_args' do
     it "should not show &blockarg if no @param tag and has @yield" do
       YARD.parse_string <<-'eof'
@@ -20,7 +20,7 @@ describe YARD::Templates::Helpers::MethodHelper do
       eof
       format_args(Registry.at('#foo')).should == ''
     end
-    
+
     it "should show &blockarg if @param block is documented (even with @yield)" do
       YARD.parse_string <<-'eof'
         # @yield [a,b]
@@ -31,17 +31,17 @@ describe YARD::Templates::Helpers::MethodHelper do
       format_args(Registry.at('#foo')).should == '(&block)'
     end
   end
-  
+
   describe '#format_block' do
     before { YARD::Registry.clear }
-    
+
     it "should show block for method with yield" do
       YARD.parse_string <<-'eof'
         def foo; yield(a, b, c) end
       eof
       format_block(Registry.at('#foo')).should == "{|a, b, c| ... }"
     end
-    
+
     it "should show block for method with @yieldparam tags" do
       YARD.parse_string <<-'eof'
         # @yieldparam _self me!
@@ -55,14 +55,14 @@ describe YARD::Templates::Helpers::MethodHelper do
         # @yield blah
         # @yieldparam a
         def foo; end
-        
+
         # @yield blah
         def foo2; end
       eof
       format_block(Registry.at('#foo')).should == "{|a| ... }"
       format_block(Registry.at('#foo2')).should == "{ ... }"
     end
-    
+
     it "should show block for method with @yield and types" do
       YARD.parse_string <<-'eof'
         # @yield [a, b, c] blah

data/spec/templates/helpers/shared_signature_examples.rb

@@ -1,7 +1,9 @@
 shared_examples_for "signature" do
   before do
-    YARD::Registry.clear 
-    stub!(:options).and_return(:default_return => "Object")
+    YARD::Registry.clear
+    @options = Templates::TemplateOptions.new
+    @options.reset_defaults
+    stub!(:options).and_return(@options)
   end
 
   it "should show signature for regular instance method" do
@@ -10,13 +12,13 @@ shared_examples_for "signature" do
   end
 
   it "should allow default return type to be changed" do
-    stub!(:options).and_return(:default_return => "Hello")
+    @options.default_return = "Hello"
     YARD.parse_string "def foo; end"
     signature(Registry.at('#foo')).should == @results[:default_return]
   end
 
   it "should allow default return type to be omitted" do
-    stub!(:options).and_return(:default_return => "")
+    @options.default_return = ""
     YARD.parse_string "def foo; end"
     signature(Registry.at('#foo')).should == @results[:no_default_return]
   end
@@ -58,7 +60,7 @@ shared_examples_for "signature" do
     eof
     signature(Registry.at('#foo')).should == @results[:type_nil]
   end
-  
+
   it "should show 'Type?' if return types are [Type, nil, nil] (extra nil)" do
     YARD.parse_string <<-'eof'
       # @return [Type, nil]
@@ -94,7 +96,7 @@ shared_examples_for "signature" do
   end
 
   it "should not show return for @return [void] if :hide_void_return is true" do
-    stub!(:options).and_return(:hide_void_return => true)
+    @options.hide_void_return = true
     YARD.parse_string <<-'eof'
       # @return [void]
       def foo; end
@@ -108,7 +110,7 @@ shared_examples_for "signature" do
     eof
     signature(Registry.at('#foo')).should == @results[:block]
   end
-  
+
   it "should use regular return tag if the @overload is empty" do
     YARD.parse_string <<-'eof'
       # @overload foobar

data/spec/templates/helpers/text_helper_spec.rb

@@ -4,7 +4,7 @@ require File.dirname(__FILE__) + "/shared_signature_examples"
 describe YARD::Templates::Helpers::TextHelper do
   include YARD::Templates::Helpers::TextHelper
   include YARD::Templates::Helpers::MethodHelper
-  
+
   describe '#signature' do
     before do
       @results = {
@@ -24,9 +24,9 @@ describe YARD::Templates::Helpers::TextHelper do
         :empty_overload => 'root.foobar -> String'
       }
     end
-    
+
     def signature(obj) super(obj).strip end
-    
+
     it_should_behave_like "signature"
   end
 

data/spec/templates/method_spec.rb

@@ -5,17 +5,17 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 describe YARD::Templates::Engine.template(:default, :method) do
   before { Registry.clear }
-  
+
   shared_examples_for "all formats" do
     it "should render html format correctly" do
-      html_equals(Registry.at('#m').format(:format => :html, :no_highlight => true), @template)
+      html_equals(Registry.at('#m').format(html_options), @template)
     end
-    
+
     it "should render text format correctly" do
-      text_equals(Registry.at('#m').format, @template)
+      text_equals(Registry.at('#m').format(text_options), @template)
     end
   end
-  
+
   describe 'regular (deprecated) method' do
     before do
       @template = :method001
@@ -32,10 +32,10 @@ describe YARD::Templates::Engine.template(:default, :method) do
         alias x m
       eof
     end
-    
+
     it_should_behave_like "all formats"
   end
-  
+
   describe 'method with 1 overload' do
     before do
       @template = :method002
@@ -48,10 +48,10 @@ describe YARD::Templates::Engine.template(:default, :method) do
         def m(x) end
       eof
     end
-    
+
     it_should_behave_like "all formats"
   end
-  
+
   describe 'method with 2 overloads' do
     before do
       @template = :method003
@@ -69,10 +69,10 @@ describe YARD::Templates::Engine.template(:default, :method) do
         def m(*args) end
       eof
     end
-    
+
     it_should_behave_like "all formats"
   end
-  
+
   describe 'method void return' do
     before do
       @template = :method004
@@ -84,7 +84,7 @@ describe YARD::Templates::Engine.template(:default, :method) do
 
     it_should_behave_like "all formats"
   end
-  
+
   describe 'method void return in an overload' do
     before do
       @template = :method005
@@ -96,7 +96,7 @@ describe YARD::Templates::Engine.template(:default, :method) do
         def m(*args) end
       eof
     end
-    
+
     it_should_behave_like "all formats"
   end
 end

data/spec/templates/module_spec.rb

@@ -1,7 +1,7 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
 describe YARD::Templates::Engine.template(:default, :module) do
-  before do 
+  before do
     Registry.clear
     YARD.parse_string <<-'eof'
       module B
@@ -22,16 +22,16 @@ describe YARD::Templates::Engine.template(:default, :module) do
         include BaseMod
         attr_accessor :attr1
         attr_reader :attr2
-        
+
         # @overload attr3
         #   @return [String] a string
         # @overload attr3=(value)
         #   @param [String] value sets the string
         #   @return [void]
         attr_accessor :attr3
-        
+
         attr_writer :attr4
-        
+
         def self.a; end
         def a; end
         alias b a
@@ -40,16 +40,16 @@ describe YARD::Templates::Engine.template(:default, :module) do
         #   hello2
         #   @param [String] a hi
         def test_overload(*args) end
-          
+
         # @overload test_multi_overload(a)
         # @overload test_multi_overload(a, b)
         def test_multi_overload(*args) end
-          
+
         # @return [void]
         def void_meth; end
-        
+
         include B
-        
+
         class Y; end
         class Q; end
         class X; end
@@ -59,16 +59,15 @@ describe YARD::Templates::Engine.template(:default, :module) do
         CONSTANT = 'value'
         @@cvar = 'value' # @deprecated
       end
-      
+
       module TMP; include A end
       class TMP2; extend A end
     eof
   end
 
   it "should render html format correctly" do
-    html_equals(Registry.at('A').format(
-          :format => :html, :no_highlight => true, :hide_void_return => true,
-          :verifier => Verifier.new('object.type != :method || object.visibility == :public')),
+    html_equals(Registry.at('A').format(html_options(:hide_void_return => true,
+      :verifier => Verifier.new('object.type != :method || object.visibility == :public'))),
         :module001)
   end
 
@@ -79,13 +78,13 @@ describe YARD::Templates::Engine.template(:default, :module) do
       end
     eof
 
-    text_equals(Registry.at('A').format, :module001)
+    text_equals(Registry.at('A').format(text_options), :module001)
   end
-  
+
   it "should render dot format correctly" do
     Registry.at('A').format(:format => :dot, :dependencies => true, :full => true).should == example_contents(:module001, 'dot')
   end
-  
+
   it "should render groups correctly in html" do
     Registry.clear
     YARD.parse_string <<-'eof'
@@ -94,19 +93,19 @@ describe YARD::Templates::Engine.template(:default, :module) do
         attr_accessor :foo_attr
         def foo; end
         def self.bar; end
-        
+
         # @group Bar
         def baz; end
-        
+
         # @endgroup
-         
+
         def self.baz; end
       end
     eof
-    
-    html_equals(Registry.at('A').format(:format => :html, :no_highlight => true), :module002)
+
+    html_equals(Registry.at('A').format(html_options), :module002)
   end
-  
+
   it "should ignore overwritten/private attributes/constants from inherited list" do
     Registry.clear
     YARD.parse_string <<-'eof'
@@ -124,8 +123,55 @@ describe YARD::Templates::Engine.template(:default, :module) do
         FOO = 2
       end
     eof
-    
-    html_equals(Registry.at('A').format(:format => :html, :no_highlight => true,
-      :verifier => Verifier.new('!@private')), :module003)
+
+    html_equals(Registry.at('A').format(html_options(
+      :verifier => Verifier.new('!@private'))), :module003)
+  end
+
+  it "should embed mixins with :embed_mixins = ['Foo', 'Bar', 'Baz::A*']" do
+    Registry.clear
+    YARD.parse_string <<-'eof'
+      class A
+        # This method is in A
+        def foo; end
+
+        include Foo
+        extend Bar
+        include BarFooBar
+        include Baz::XYZ
+        include Baz::ABC
+      end
+
+      module BarFooBar
+        def bar_foo_bar; end
+      end
+
+      module Foo
+        # Docs for xyz
+        def xyz; end
+        # Docs for bar_attr
+        attr_accessor :bar_attr
+      end
+
+      module Bar
+        # @group Booya
+
+        # Docs for baz in Booya group
+        def baz; end
+      end
+
+      module Baz
+        module XYZ
+          # listed as inherited
+          def baz_xyz; end
+        end
+
+        module ABC
+          def baz_abc; end
+        end
+      end
+    eof
+
+    html_equals(Registry.at('A').format(html_options(:embed_mixins => ['Foo', 'Bar', 'Baz::A*'])), :module004)
   end
 end