yard 0.5.8 → 0.6.0

data/spec/templates/helpers/base_helper_spec.rb

@@ -5,7 +5,7 @@ describe YARD::Templates::Helpers::BaseHelper do
   
   describe '#run_verifier' do
     it "should run verifier proc against list if provided" do
-      mock = mock(:verifier)
+      mock = Verifier.new
       mock.should_receive(:call).with(1)
       mock.should_receive(:call).with(2)
       mock.should_receive(:call).with(3)
@@ -14,7 +14,7 @@ describe YARD::Templates::Helpers::BaseHelper do
     end
     
     it "should prune list if lambda returns false and only false" do
-      mock = mock(:verifier)
+      mock = Verifier.new
       should_receive(:options).at_least(1).times.and_return(:verifier => mock)
       mock.should_receive(:call).with(1).and_return(false)
       mock.should_receive(:call).with(2).and_return(true)

data/spec/templates/helpers/html_helper_spec.rb

@@ -36,14 +36,14 @@ describe YARD::Templates::Helpers::HtmlHelper do
   describe '#charset' do
     it "should return foo if LANG=foo" do
       ENV.should_receive(:[]).with('LANG').and_return('shift_jis') if RUBY18
-      Encoding.default_external.should_receive(:name).and_return('shift_jis') if RUBY19
+      Encoding.default_external.should_receive(:name).and_return('shift_jis') if defined?(Encoding)
       charset.should == 'shift_jis'
     end
     
     ['US-ASCII', 'ASCII-7BIT', 'ASCII-8BIT'].each do |type|
       it "should convert #{type} to iso-8859-1" do
         ENV.should_receive(:[]).with('LANG').and_return(type) if RUBY18
-        Encoding.default_external.should_receive(:name).and_return(type) if RUBY19
+        Encoding.default_external.should_receive(:name).and_return(type) if defined?(Encoding)
         charset.should == 'iso-8859-1'
       end
     end
@@ -98,8 +98,16 @@ describe YARD::Templates::Helpers::HtmlHelper do
   
   describe '#htmlify' do
     it "should not use hard breaks for textile markup (RedCloth specific)" do
+      begin; require 'redcloth'; rescue LoadError; pending 'test requires redcloth gem' end
       htmlify("A\nB", :textile).should_not include("<br")
     end
+    
+    it "should handle various encodings" do
+      stub!(:object).and_return(Registry.root)
+      Encoding.default_internal = 'utf-8' if defined?(Encoding)
+      htmlify("\xB0\xB1", :text)
+      # TODO: add more encoding tests
+    end
   end
   
   describe "#link_object" do
@@ -135,6 +143,15 @@ describe YARD::Templates::Helpers::HtmlHelper do
       stub!(:object).and_return(obj)
       link_object("Bar#a").should =~ %r{href="Bar.html#a-instance_method"}
     end
+    
+    it "should use relative path in title" do
+      CodeObjects::ModuleObject.new(:root, :YARD)
+      CodeObjects::ClassObject.new(P('YARD'), :Bar)
+      stub!(:object).and_return(CodeObjects::ModuleObject.new(P('YARD'), :Foo))
+      serializer = Serializers::FileSystemSerializer.new
+      stub!(:serializer).and_return(serializer)
+      link_object("Bar").should =~ %r{>Bar</a>}
+    end
   end
 
   describe '#url_for' do
@@ -243,6 +260,61 @@ describe YARD::Templates::Helpers::HtmlHelper do
         :title => 'Steve'
       }
     end
+    
+    it "should ignore {links} that begin with |...|" do
+      resolve_links("{|x|x == 1}").should == "{|x|x == 1}"
+    end
+    
+    it "should warn about missing reference at right file location for object" do
+      YARD.parse_string <<-eof
+        # Comments here
+        # And a reference to {InvalidObject}
+        class MyObject; end
+      eof
+      logger = mock(:log)
+      logger.should_receive(:warn).ordered.with("In file `(stdin)':2: Cannot resolve link to InvalidObject from text:")
+      logger.should_receive(:warn).ordered.with("...{InvalidObject}")
+      stub!(:log).and_return(logger)
+      stub!(:object).and_return(Registry.at('MyObject'))
+      resolve_links(object.docstring)
+    end
+    
+    it "should show ellipsis on either side if there is more on the line in a reference warning" do
+      YARD.parse_string <<-eof
+        # {InvalidObject1} beginning of line
+        # end of line {InvalidObject2}
+        # Middle of {InvalidObject3} line
+        # {InvalidObject4}
+        class MyObject; end
+      eof
+      logger = mock(:log)
+      logger.should_receive(:warn).ordered.with("In file `(stdin)':1: Cannot resolve link to InvalidObject1 from text:")
+      logger.should_receive(:warn).ordered.with("{InvalidObject1}...")
+      logger.should_receive(:warn).ordered.with("In file `(stdin)':2: Cannot resolve link to InvalidObject2 from text:")
+      logger.should_receive(:warn).ordered.with("...{InvalidObject2}")
+      logger.should_receive(:warn).ordered.with("In file `(stdin)':3: Cannot resolve link to InvalidObject3 from text:")
+      logger.should_receive(:warn).ordered.with("...{InvalidObject3}...")
+      logger.should_receive(:warn).ordered.with("In file `(stdin)':4: Cannot resolve link to InvalidObject4 from text:")
+      logger.should_receive(:warn).ordered.with("{InvalidObject4}")
+      stub!(:log).and_return(logger)
+      stub!(:object).and_return(Registry.at('MyObject'))
+      resolve_links(object.docstring)
+    end
+    
+    it "should warn about missing reference for file template (no object)" do
+      @file = "myfile.txt"
+      logger = mock(:log)
+      logger.should_receive(:warn).ordered.with("In file `myfile.txt':3: Cannot resolve link to InvalidObject from text:")
+      logger.should_receive(:warn).ordered.with("...{InvalidObject Some Title}")
+      stub!(:log).and_return(logger)
+      stub!(:object).and_return(Registry.root)
+      resolve_links(<<-eof)
+        Hello world
+        This is a line
+        And {InvalidObject Some Title}
+        And more.
+      eof
+    end
   end
 
   describe '#signature' do
@@ -269,10 +341,11 @@ describe YARD::Templates::Helpers::HtmlHelper do
     
     it_should_behave_like "signature"
   end
-  
+
   describe '#html_syntax_highlight' do
     before do
       stub!(:options).and_return(:no_highlight => false)
+      stub!(:object).and_return(Registry.root)
     end
     
     it "should return empty string on nil input" do
@@ -280,10 +353,18 @@ describe YARD::Templates::Helpers::HtmlHelper do
     end
     
     it "should call #html_syntax_highlight_ruby by default" do
+      Registry.root.source_type = nil
       should_receive(:html_syntax_highlight_ruby).with('def x; end')
       html_syntax_highlight('def x; end')
     end
     
+    it "should call #html_syntax_highlight_NAME if there's an object with a #source_type" do
+      Registry.root.source_type = :NAME
+      should_receive(:respond_to?).with('html_syntax_highlight_NAME').and_return(true)
+      should_receive(:html_syntax_highlight_NAME).and_return("foobar")
+      html_syntax_highlight('def x; end').should == 'foobar'
+    end
+
     it "should call html_syntax_highlight_NAME if source starts with !!!NAME" do
       should_receive(:respond_to?).with('html_syntax_highlight_NAME').and_return(true)
       should_receive(:html_syntax_highlight_NAME).and_return("foobar")
@@ -318,4 +399,13 @@ describe YARD::Templates::Helpers::HtmlHelper do
       resolve_links("({file:TEST})")
     end
   end
+  
+  describe '#link_url' do
+    it "should add target if scheme is provided" do
+      link_url("http://url.com").should include(" target=\"_parent\"")
+      link_url("https://url.com").should include(" target=\"_parent\"")
+      link_url("irc://url.com").should include(" target=\"_parent\"")
+      link_url("../not/scheme").should_not include("target")
+    end
+  end
 end

data/spec/templates/helpers/html_syntax_highlight_helper_spec.rb

@@ -5,6 +5,11 @@ describe YARD::Templates::Helpers::HtmlSyntaxHighlightHelper do
   include YARD::Templates::Helpers::HtmlSyntaxHighlightHelper
   
   describe '#html_syntax_highlight' do
+    before do
+      stub!(:object).and_return Registry.root
+      Registry.root.source_type = :ruby
+    end
+
     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"

data/spec/templates/helpers/markup_helper_spec.rb

@@ -10,85 +10,112 @@ class MyMock
 end
 
 describe YARD::Templates::Helpers::MarkupHelper do
-  before do
-    @gen = mock('Generator')
-    @gen.extend(YARD::Templates::Helpers::MarkupHelper)
-  end
+  describe '#load_markup_provider' do
+    before do
+      @gen = mock('Generator')
+      @gen.extend(YARD::Templates::Helpers::MarkupHelper)
+    end
   
-  def generator_should_exit
-    STDERR.should_receive(:puts)
-    @gen.should_receive(:exit)
-  end
+    def generator_should_exit
+      STDERR.should_receive(:puts)
+      @gen.should_receive(:exit)
+    end
   
-  it "should exit on an invalid markup type" do
-    generator_should_exit
-    @gen.stub!(:options).and_return({:markup => :invalid})
+    it "should exit on an invalid markup type" do
+      generator_should_exit
+      @gen.stub!(:options).and_return({:markup => :invalid})
     
-    # it will raise since providers == nil
-    # but in reality it would have already `exit`ed.
-    @gen.load_markup_provider rescue nil 
-  end
+      # it will raise since providers == nil
+      # but in reality it would have already `exit`ed.
+      @gen.load_markup_provider rescue nil 
+    end
 
-  it "should exit on when an invalid markup provider is specified" do
-    generator_should_exit
-    @gen.stub!(:options).and_return({:markup => :markdown, :markup_provider => :invalid})
+    it "should exit on when an invalid markup provider is specified" do
+      generator_should_exit
+      @gen.stub!(:options).and_return({:markup => :markdown, :markup_provider => :invalid})
     
-    # it will raise since providers == nil
-    # but in reality it would have already `exit`ed.
-    @gen.load_markup_provider rescue nil
-    @gen.markup_class.should == nil
-  end
+      # it will raise since providers == nil
+      # but in reality it would have already `exit`ed.
+      @gen.load_markup_provider rescue nil
+      @gen.markup_class.should == nil
+    end
   
-  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::Templates::Helpers::MarkupHelper::SimpleMarkup
-  end
+    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::Templates::Helpers::MarkupHelper::SimpleMarkup
+    end
   
-  it "should search through available markup providers for the markup type if none is set" do
-    @gen.should_receive(:require).with('bluecloth').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 
-    # name as a constant
-    @gen.load_markup_provider rescue nil
-    @gen.markup_provider.should == :bluecloth
-  end
+    it "should search through available markup providers for the markup type if none is set" do
+      @gen.should_receive(:require).with('bluecloth').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 
+      # name as a constant
+      @gen.load_markup_provider rescue nil
+      @gen.markup_provider.should == :bluecloth
+    end
   
-  it "should continue searching if some of the providers are unavailable" do
-    @gen.should_receive(:require).with('bluecloth').and_raise(LoadError)
-    @gen.should_receive(:require).with('maruku').and_raise(LoadError)
-    @gen.should_receive(:require).with('rpeg-markdown').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 
-    # name as a constant
-    @gen.load_markup_provider rescue nil
-    @gen.markup_provider.should == :"rpeg-markdown"
-  end
+    it "should continue searching if some of the providers are unavailable" do
+      @gen.should_receive(:require).with('bluecloth').and_raise(LoadError)
+      @gen.should_receive(:require).with('maruku').and_raise(LoadError)
+      @gen.should_receive(:require).with('rpeg-markdown').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 
+      # name as a constant
+      @gen.load_markup_provider 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.stub!(:options).and_return({:markup => :markdown, :markup_provider => :rdiscount})
-    @gen.load_markup_provider rescue nil
-    @gen.markup_provider.should == :rdiscount
-  end
+    it "should override the search if `:markup_provider` is set in options" do
+      @gen.should_receive(:require).with('rdiscount').and_return(true)
+      @gen.stub!(:options).and_return({:markup => :markdown, :markup_provider => :rdiscount})
+      @gen.load_markup_provider rescue nil
+      @gen.markup_provider.should == :rdiscount
+    end
 
-  it "should fail if no provider is found" do
-    generator_should_exit
-    YARD::Templates::Helpers::MarkupHelper::MARKUP_PROVIDERS[:markdown].each do |p|
-      @gen.should_receive(:require).with(p[:lib].to_s).and_raise(LoadError)
+    it "should fail if no provider is found" do
+      generator_should_exit
+      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.load_markup_provider rescue nil
+      @gen.markup_provider.should == nil
+    end
+
+    it "should fail if overridden provider is not found" do
+      generator_should_exit
+      @gen.should_receive(:require).with('rdiscount').and_raise(LoadError)
+      @gen.stub!(:options).and_return({:markup => :markdown, :markup_provider => :rdiscount})
+      @gen.load_markup_provider rescue nil
+      @gen.markup_provider.should == nil
     end
-    @gen.stub!(:options).and_return({:markup => :markdown})
-    @gen.load_markup_provider rescue nil
-    @gen.markup_provider.should == nil
   end
+  
+  describe '#markup_for_file' do
+    include YARD::Templates::Helpers::MarkupHelper
 
-  it "should fail if overridden provider is not found" do
-    generator_should_exit
-    @gen.should_receive(:require).with('rdiscount').and_raise(LoadError)
-    @gen.stub!(:options).and_return({:markup => :markdown, :markup_provider => :rdiscount})
-    @gen.load_markup_provider rescue nil
-    @gen.markup_provider.should == nil
+    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})
+      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
+          markup_for_file('', "filename.#{ext}").should == type
+        end
+      end
+    end
   end
 end

data/spec/templates/helpers/shared_signature_examples.rb

@@ -58,6 +58,15 @@ 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]
+      # @return [nil]
+      def foo; end
+    eof
+    signature(Registry.at('#foo')).should == @results[:type_nil]
+  end
 
   it "should show 'Type+' if return types are [Type, Array<Type>]" do
     YARD.parse_string <<-'eof'

data/spec/templates/helpers/text_helper_spec.rb

@@ -28,4 +28,16 @@ describe YARD::Templates::Helpers::TextHelper do
     
     it_should_behave_like "signature"
   end
+
+  describe '#align_right' do
+    it "should align text right" do
+      text = "Method: #some_method (SomeClass)"
+      align_right(text).should == ' ' * 40 + text
+    end
+
+    it "should truncate text that is longer than allowed width" do
+      text = "(Defined in: /home/user/.rip/.packages/some_gem-2460672e333ac07b9190ade88ec9a91c/long/path.rb)"
+      align_right(text).should == ' ' + text[0,68] + '...'
+    end
+  end
 end

data/spec/templates/module_spec.rb

@@ -56,10 +56,6 @@ describe YARD::Templates::Engine.template(:default, :module) do
       module TMP; include A end
       class TMP2; extend A end
     eof
-    
-    # Hack to clear mixin list
-    mod = YARD::Templates::Engine.template(:default, :module)
-    mod.send(:class_variable_set, "@@mixed_into", nil)
   end
 
   it "should render html format correctly" do
@@ -82,4 +78,25 @@ describe YARD::Templates::Engine.template(:default, :module) do
   it "should render dot format correctly" do
     Registry.at('A').format(:format => :dot, :dependencies => true, :full => true).should == example(:module001, 'dot')
   end
+  
+  it "should render groups correctly in html" do
+    Registry.clear
+    YARD.parse_string <<-'eof'
+      module A
+        # @group Foo
+        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)
+  end
 end

data/spec/templates/section_spec.rb

@@ -0,0 +1,146 @@
+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])
+      s.name.should == :name
+      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
+      s[0].should == Section.new(:foo)
+      s[1].should == Section.new(:bar)
+    end
+
+    it "should make a list of sections" do
+      s = Section.new(:name, [:foo, [:bar]])
+      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
+      arr.class.should == Array
+      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)
+      s.unshift :bar
+      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)
+      s.to_a.should == [:foo, [:bar, [:baz, [:qux]]]]
+    end
+  end
+end