yard 0.8.7.6 → 0.9.0

data/spec/templates/helpers/html_syntax_highlight_helper_spec.rb

@@ -4,21 +4,22 @@ describe YARD::Templates::Helpers::HtmlSyntaxHighlightHelper do
   include YARD::Templates::Helpers::HtmlHelper
   include YARD::Templates::Helpers::HtmlSyntaxHighlightHelper
 
-  describe '#html_syntax_highlight' do
+  describe "#html_syntax_highlight" do
+    let(:object) { Registry.root }
+
     before do
-      stub!(:object).and_return Registry.root
       Registry.root.source_type = :ruby
     end
 
-    it "should not highlight source if options.highlight is false" do
-      should_receive(:options).and_return(Options.new.update(:highlight => false))
-      html_syntax_highlight("def x\nend").should == "def x\nend"
+    it "does not highlight source if options.highlight is false" do
+      expect(self).to receive(:options).and_return(Options.new.update(:highlight => false))
+      expect(html_syntax_highlight("def x\nend")).to eq "def x\nend"
     end
 
-    it "should highlight source (legacy)" do
+    it "highlights source (legacy)" do
       type = Parser::SourceParser.parser_type
       Parser::SourceParser.parser_type = :ruby18
-      should_receive(:options).and_return(Options.new.update(:highlight => true))
+      expect(self).to receive(:options).and_return(Options.new.update(:highlight => true))
       expect = "<span class='rubyid_def def kw'>def</span><span class='rubyid_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='rubyid_end end kw'>end</span>"
@@ -27,8 +28,8 @@ describe YARD::Templates::Helpers::HtmlSyntaxHighlightHelper do
       Parser::SourceParser.parser_type = type
     end
 
-    it "should highlight source (ripper)" do
-      should_receive(:options).and_return(Options.new.update(:highlight => true))
+    it "highlights source (ripper)" do
+      expect(self).to receive(:options).and_return(Options.new.update(:highlight => true))
       Parser::SourceParser.parser_type = :ruby
       expect = "<span class='kw'>def</span> <span class='id identifier rubyid_x'>x</span>
         <span class='tstring'><span class='tstring_beg'>'</span>
@@ -40,14 +41,14 @@ describe YARD::Templates::Helpers::HtmlSyntaxHighlightHelper do
       html_equals_string(result, expect)
     end if HAVE_RIPPER
 
-    it "should return escaped unhighlighted source if a syntax error is found (ripper)" do
-      should_receive(:options).and_return(Options.new.update(:highlight => true))
-      html_syntax_highlight("def &x; ... end").should == "def &amp;x; ... end"
+    it "returns escaped unhighlighted source if a syntax error is found (ripper)" do
+      expect(self).to receive(:options).and_return(Options.new.update(:highlight => true))
+      expect(html_syntax_highlight("def &x; ... end")).to eq "def &amp;x; ... end"
     end if HAVE_RIPPER
 
-    it "should return escaped unhighlighted source if a syntax error is found (ripper)" do
-      should_receive(:options).and_return(Options.new.update(:highlight => true))
-      html_syntax_highlight("$ git clone http://url").should == "$ git clone http://url"
+    it "returns escaped unhighlighted source if a syntax error is found (ripper)" do
+      expect(self).to receive(:options).and_return(Options.new.update(:highlight => true))
+      expect(html_syntax_highlight("$ git clone http://url")).to eq "$ git clone http://url"
     end if HAVE_RIPPER
   end
 end

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

@@ -1,7 +1,7 @@
 require File.dirname(__FILE__) + "/../../spec_helper"
 
 describe YARD::Templates::Helpers::Markup::RDocMarkup do
-  describe 'loading mechanism' do
+  describe "loading mechanism" do
     before { @good_libs = [] }
 
     def require(lib)
@@ -25,69 +25,62 @@ describe YARD::Templates::Helpers::Markup::RDocMarkup do
       end
     end
 
-    it "should load RDoc2.x if rdoc/markup is present" do
+    it "loads RDoc2.x if rdoc/markup is present" do
       @good_libs += ['rdoc/markup', 'rdoc/markup/to_html']
-      load_markup.should == :RDoc2
+      expect(load_markup).to eq :RDoc2
     end
 
-    it "should fail on RDoc2.x if rdoc/markup/to_html is not present" do
+    it "fails on RDoc2.x if rdoc/markup/to_html is not present" do
       @good_libs += ['rdoc/markup']
-      lambda { load_markup }.should raise_error(NameError)
+      expect { load_markup }.to raise_error(NameError)
     end
 
-    it "should load RDoc1.x if RDoc2 fails and rdoc/markup/simple_markup is present" do
+    it "loads RDoc1.x if RDoc2 fails and rdoc/markup/simple_markup is present" do
       @good_libs += ['rdoc/markup/simple_markup', 'rdoc/markup/simple_markup/to_html']
-      load_markup.should == :RDoc1
+      expect(load_markup).to eq :RDoc1
     end
 
-    it "should error on loading if neither lib is present" do
-      lambda { load_markup }.should raise_error(NameError)
+    it "raises an error on loading if neither lib is present" do
+      expect { load_markup }.to raise_error(NameError)
     end
   end
 
-  describe '#to_html' do
+  describe "#to_html" do
     def to_html(text)
       html = YARD::Templates::Helpers::Markup::RDocMarkup.new(text).to_html
       html.strip.gsub(/\r?\n/, '')
     end
 
-    it 'handles typewriter text' do
-      to_html('Hello +<code>+').should == '<p>Hello <tt>&lt;code&gt;</tt></p>'
+    it "handles typewriter text" do
+      expect(to_html('Hello +<code>+')).to eq '<p>Hello <tt>&lt;code&gt;</tt></p>'
     end
   end
 
-  describe '#fix_typewriter' do
+  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 &lt;+.").should ==
-        "Some <tt>typewriter text &lt;</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("Hello +{Foo}+ World").should == "Hello <tt>{Foo}</tt> World"
+    it "converts +text+ to <tt>text</tt>" do
+      expect(fix_typewriter("Some +typewriter text &lt;+.")).to eq "Some <tt>typewriter text &lt;</tt>."
+      expect(fix_typewriter("Not +typewriter text.")).to eq "Not +typewriter text."
+      expect(fix_typewriter("Alternating +type writer+ text +here+.")).to eq "Alternating <tt>type writer</tt> text <tt>here</tt>."
+      expect(fix_typewriter("No ++problem.")).to eq "No ++problem."
+      expect(fix_typewriter("Math + stuff +is ok+")).to eq "Math + stuff <tt>is ok</tt>"
+      expect(fix_typewriter("Hello +{Foo}+ World")).to eq "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>"
+    it "does not apply to code blocks" do
+      expect(fix_typewriter("<code>Hello +hello+</code>")).to eq "<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 ==
-        "<a href='http://foo.com/A+b+c'>A+b+c</a>"
-      fix_typewriter("<foo class='foo+bar+baz'/>").should ==
-        "<foo class='foo+bar+baz'/>"
+    it "does not apply to HTML tag attributes" do
+      expect(fix_typewriter("<a href='http://foo.com/A+b+c'>A+b+c</a>")).to eq "<a href='http://foo.com/A+b+c'>A+b+c</a>"
+      expect(fix_typewriter("<foo class='foo+bar+baz'/>")).to eq "<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>"
+    it "still applies inside of other tags" do
+      expect(fix_typewriter("<p>+foo+</p>")).to eq "<p><tt>foo</tt></p>"
     end
   end
 end

data/spec/templates/helpers/markup_helper_spec.rb

@@ -17,117 +17,117 @@ describe YARD::Templates::Helpers::MarkupHelper do
     YARD::Templates::Helpers::MarkupHelper.clear_markup_cache
   end
 
-  describe '#load_markup_provider' do
+  describe "#load_markup_provider" do
     before do
-      log.stub!(:error)
+      allow(log).to receive(:error)
       @gen = GeneratorMock.new
       @gen.options.reset_defaults
     end
 
-    it "should exit on an invalid markup type" do
+    it "exits on an invalid markup type" do
       @gen.options.markup = :invalid
-      @gen.load_markup_provider.should == false
+      expect(@gen.load_markup_provider).to be false
     end
 
-    it "should fail on when an invalid markup provider is specified" do
+    it "fails when an invalid markup provider is specified" do
       @gen.options.update(:markup => :markdown, :markup_provider => :invalid)
-      @gen.load_markup_provider.should == false
-      @gen.markup_class.should == nil
+      expect(@gen.load_markup_provider).to be false
+      expect(@gen.markup_class).to eq nil
     end
 
-    it "should load RDocMarkup if rdoc is specified and it is installed" do
+    it "loads RDocMarkup if rdoc is specified and it is installed" do
       @gen.options.markup = :rdoc
-      @gen.load_markup_provider.should == true
-      @gen.markup_class.should == YARD::Templates::Helpers::Markup::RDocMarkup
+      expect(@gen.load_markup_provider).to be true
+      expect(@gen.markup_class).to eq YARD::Templates::Helpers::Markup::RDocMarkup
     end
 
-    it "should fail if RDoc cannot be loaded" do
+    it "fails if RDoc cannot be loaded" do
       @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
+      expect(@gen).to receive(:eval).with('::YARD::Templates::Helpers::Markup::RDocMarkup').and_raise(NameError)
+      expect(@gen.load_markup_provider).to be false
+      expect(@gen.markup_provider).to eq 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')
+    it "searches through available markup providers for the markup type if none is set" do
+      expect(@gen).to receive(:eval).with('::RedcarpetCompat').and_return(double(:bluecloth))
+      expect(@gen).to receive(:require).with('redcarpet').and_return(true)
+      expect(@gen).not_to receive(:require).with('maruku')
       @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
+      expect(@gen.load_markup_provider).to be true
+      expect(@gen.markup_provider).to eq :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)
-      @gen.should_receive(:require).with('kramdown').and_raise(LoadError)
-      @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.should_receive(:eval).with('::PEGMarkdown').and_return(true)
+    it "continues searching if some of the providers are unavailable" do
+      expect(@gen).to receive(:require).with('redcarpet').and_raise(LoadError)
+      expect(@gen).to receive(:require).with('rdiscount').and_raise(LoadError)
+      expect(@gen).to receive(:require).with('kramdown').and_raise(LoadError)
+      expect(@gen).to receive(:require).with('bluecloth').and_raise(LoadError)
+      expect(@gen).to receive(:require).with('maruku').and_raise(LoadError)
+      expect(@gen).to receive(:require).with('rpeg-markdown').and_return(true)
+      expect(@gen).to receive(:eval).with('::PEGMarkdown').and_return(true)
       @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"
+      @gen.load_markup_provider
+      expect(@gen.markup_provider).to eq :"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)
+    it "overrides the search if `:markup_provider` is set in options" do
+      expect(@gen).to receive(:require).with('rdiscount').and_return(true)
+      expect(@gen).to receive(:eval).with('::RDiscount').and_return(true)
       @gen.options.update(:markup => :markdown, :markup_provider => :rdiscount)
-      @gen.load_markup_provider.should rescue nil
-      @gen.markup_provider.should == :rdiscount
+      @gen.load_markup_provider
+      expect(@gen.markup_provider).to eq :rdiscount
     end
 
-    it "should fail if no provider is found" do
+    it "fails if no provider is found" do
       YARD::Templates::Helpers::MarkupHelper::MARKUP_PROVIDERS[:markdown].each do |p|
-        @gen.should_receive(:require).with(p[:lib].to_s).and_raise(LoadError)
+        expect(@gen).to receive(:require).with(p[:lib].to_s).and_raise(LoadError)
       end
       @gen.options.markup = :markdown
-      @gen.load_markup_provider.should == false
-      @gen.markup_provider.should == nil
+      expect(@gen.load_markup_provider).to be false
+      expect(@gen.markup_provider).to eq nil
     end
 
-    it "should fail if overridden provider is not found" do
-      @gen.should_receive(:require).with('rdiscount').and_raise(LoadError)
+    it "fails if overridden provider is not found" do
+      expect(@gen).to receive(:require).with('rdiscount').and_raise(LoadError)
       @gen.options.update(:markup => :markdown, :markup_provider => :rdiscount)
-      @gen.load_markup_provider.should == false
-      @gen.markup_provider.should == nil
+      expect(@gen.load_markup_provider).to be false
+      expect(@gen.markup_provider).to eq nil
     end
 
-    it "should fail if the markup type is not found" do
-      log.should_receive(:error).with(/Invalid markup/)
+    it "fails if the markup type is not found" do
+      expect(log).to receive(:error).with(/Invalid markup/)
       @gen.options.markup = :xxx
-      @gen.load_markup_provider.should == false
-      @gen.markup_provider.should == nil
+      expect(@gen.load_markup_provider).to be false
+      expect(@gen.markup_provider).to eq nil
     end
   end
 
-  describe '#markup_for_file' do
+  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
+    it "looks for a shebang line" do
+      expect(markup_for_file("#!text\ntext here", 'file.rdoc')).to eq :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(Options.new.update(:markup => :default_type))
-      markup_for_file('', 'filename').should == :default_type
+    it "returns the default markup type if no shebang is found or no valid ext is found" do
+      allow(self).to receive(:options).and_return(Options.new.update(:markup => :default_type))
+      expect(markup_for_file('', 'filename')).to eq :default_type
     end
 
-    it "should look for a file extension if no shebang is found" do
-      markup_for_file('', 'filename.MD').should == :markdown
+    it "looks for a file extension if no shebang is found" do
+      expect(markup_for_file('', 'filename.MD')).to eq :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
+        it "recognizes .#{ext} as #{type} markup type" do
+          expect(markup_for_file('', "filename.#{ext}")).to eq type
         end
       end
     end

data/spec/templates/helpers/method_helper_spec.rb

@@ -4,60 +4,60 @@ describe YARD::Templates::Helpers::MethodHelper do
   include YARD::Templates::Helpers::BaseHelper
   include YARD::Templates::Helpers::MethodHelper
 
-  describe '#format_args' do
-    it "should display keyword arguments" do
+  describe "#format_args" do
+    it "displays keyword arguments" do
       params = [['a:', '1'], ['b:', '2'], ['**kwargs', nil]]
       YARD.parse_string 'def foo; end'
-      Registry.at('#foo').stub(:parameters) { params }
-      format_args(Registry.at('#foo')).should == '(a: 1, b: 2, **kwargs)'
+      allow(Registry.at('#foo')).to receive(:parameters) { params }
+      expect(format_args(Registry.at('#foo'))).to eq '(a: 1, b: 2, **kwargs)'
     end
 
-    it "should not show &blockarg if no @param tag and has @yield" do
+    it "does not show &blockarg if no @param tag and has @yield" do
       YARD.parse_string <<-'eof'
         # @yield blah
         def foo(&block); end
       eof
-      format_args(Registry.at('#foo')).should == ''
+      expect(format_args(Registry.at('#foo'))).to eq ''
     end
 
-    it "should not show &blockarg if no @param tag and has @yieldparam" do
+    it "does not show &blockarg if no @param tag and has @yieldparam" do
       YARD.parse_string <<-'eof'
         # @yieldparam blah test
         def foo(&block); end
       eof
-      format_args(Registry.at('#foo')).should == ''
+      expect(format_args(Registry.at('#foo'))).to eq ''
     end
 
-    it "should show &blockarg if @param block is documented (even with @yield)" do
+    it "shows &blockarg if @param block is documented (even with @yield)" do
       YARD.parse_string <<-'eof'
         # @yield [a,b]
         # @yieldparam a test
         # @param block test
         def foo(&block) end
       eof
-      format_args(Registry.at('#foo')).should == '(&block)'
+      expect(format_args(Registry.at('#foo'))).to eq '(&block)'
     end
   end
 
-  describe '#format_block' do
+  describe "#format_block" do
     before { YARD::Registry.clear }
 
-    it "should show block for method with yield" do
+    it "shows 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| ... }"
+      expect(format_block(Registry.at('#foo'))).to eq "{|a, b, c| ... }"
     end
 
-    it "should show block for method with @yieldparam tags" do
+    it "shows block for method with @yieldparam tags" do
       YARD.parse_string <<-'eof'
         # @yieldparam _self me!
         def foo; end
       eof
-      format_block(Registry.at('#foo')).should == "{|_self| ... }"
+      expect(format_block(Registry.at('#foo'))).to eq "{|_self| ... }"
     end
 
-    it "should show block for method with @yield but no types" do
+    it "shows block for method with @yield but no types" do
       YARD.parse_string <<-'eof'
         # @yield blah
         # @yieldparam a
@@ -66,17 +66,17 @@ describe YARD::Templates::Helpers::MethodHelper do
         # @yield blah
         def foo2; end
       eof
-      format_block(Registry.at('#foo')).should == "{|a| ... }"
-      format_block(Registry.at('#foo2')).should == "{ ... }"
+      expect(format_block(Registry.at('#foo'))).to eq "{|a| ... }"
+      expect(format_block(Registry.at('#foo2'))).to eq "{ ... }"
     end
 
-    it "should show block for method with @yield and types" do
+    it "shows block for method with @yield and types" do
       YARD.parse_string <<-'eof'
         # @yield [a, b, c] blah
         # @yieldparam a
         def foo; end
       eof
-      format_block(Registry.at('#foo')).should == "{|a, b, c| ... }"
+      expect(format_block(Registry.at('#foo'))).to eq "{|a, b, c| ... }"
     end
   end
 end

data/spec/templates/helpers/shared_signature_examples.rb

@@ -3,121 +3,123 @@ shared_examples_for "signature" do
     YARD::Registry.clear
     @options = Templates::TemplateOptions.new
     @options.reset_defaults
-    stub!(:options).and_return(@options)
+    allow(self).to receive(:options).and_return(@options)
   end
 
-  it "should show signature for regular instance method" do
+  def trim(sig) sig.gsub(/\s+/, ' ') end
+
+  it "shows signature for regular instance method" do
     YARD.parse_string "def foo; end"
-    signature(Registry.at('#foo')).should == @results[:regular]
+    expect(trim(signature(Registry.at('#foo')))).to eq @results[:regular]
   end
 
-  it "should allow default return type to be changed" do
+  it "allows default return type to be changed" do
     @options.default_return = "Hello"
     YARD.parse_string "def foo; end"
-    signature(Registry.at('#foo')).should == @results[:default_return]
+    expect(trim(signature(Registry.at('#foo')))).to eq @results[:default_return]
   end
 
-  it "should allow default return type to be omitted" do
+  it "allows default return type to be omitted" do
     @options.default_return = ""
     YARD.parse_string "def foo; end"
-    signature(Registry.at('#foo')).should == @results[:no_default_return]
+    expect(trim(signature(Registry.at('#foo')))).to eq @results[:no_default_return]
   end
 
-  it "should show signature for private class method" do
+  it "shows signature for private class method" do
     YARD.parse_string "class A; private; def self.foo; end end"
-    signature(Registry.at('A.foo')).should == @results[:private_class]
+    expect(trim(signature(Registry.at('A.foo')))).to eq @results[:private_class]
   end
 
-  it "should show return type for single type" do
+  it "shows return type for single type" do
     YARD.parse_string <<-'eof'
       # @return [String]
       def foo; end
     eof
-    signature(Registry.at('#foo')).should == @results[:single]
+    expect(trim(signature(Registry.at('#foo')))).to eq @results[:single]
   end
 
-  it "should show return type for 2 types" do
+  it "shows return type for 2 types" do
     YARD.parse_string <<-'eof'
       # @return [String, Symbol]
       def foo; end
     eof
-    signature(Registry.at('#foo')).should == @results[:two_types]
+    expect(trim(signature(Registry.at('#foo')))).to eq @results[:two_types]
   end
 
-  it "should show return type for 2 types over multiple tags" do
+  it "shows return type for 2 types over multiple tags" do
     YARD.parse_string <<-'eof'
       # @return [String]
       # @return [Symbol]
       def foo; end
     eof
-    signature(Registry.at('#foo')).should == @results[:two_types_multitag]
+    expect(trim(signature(Registry.at('#foo')))).to eq @results[:two_types_multitag]
   end
 
-  it "should show 'Type?' if return types are [Type, nil]" do
+  it "shows 'Type?' if return types are [Type, nil]" do
     YARD.parse_string <<-'eof'
       # @return [Type, nil]
       def foo; end
     eof
-    signature(Registry.at('#foo')).should == @results[:type_nil]
+    expect(trim(signature(Registry.at('#foo')))).to eq @results[:type_nil]
   end
 
-  it "should show 'Type?' if return types are [Type, nil, nil] (extra nil)" do
+  it "shows '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]
+    expect(trim(signature(Registry.at('#foo')))).to eq @results[:type_nil]
   end
 
-  it "should show 'Type+' if return types are [Type, Array<Type>]" do
+  it "shows 'Type+' if return types are [Type, Array<Type>]" do
     YARD.parse_string <<-'eof'
       # @return [Type, <Type>]
       def foo; end
     eof
-    signature(Registry.at('#foo')).should == @results[:type_array]
+    expect(trim(signature(Registry.at('#foo')))).to eq @results[:type_array]
   end
 
-  it "should (Type, ...) for more than 2 return types" do
+  it "shows (Type, ...) for more than 2 return types" do
     YARD.parse_string <<-'eof'
       # @return [Type, <Type>]
       # @return [AnotherType]
       def foo; end
     eof
-    signature(Registry.at('#foo')).should == @results[:multitype]
+    expect(trim(signature(Registry.at('#foo')))).to eq @results[:multitype]
   end
 
-  it "should show (void) for @return [void] by default" do
+  it "shows (void) for @return [void] by default" do
     YARD.parse_string <<-'eof'
       # @return [void]
       def foo; end
     eof
-    signature(Registry.at('#foo')).should == @results[:void]
+    expect(trim(signature(Registry.at('#foo')))).to eq @results[:void]
   end
 
-  it "should not show return for @return [void] if :hide_void_return is true" do
+  it "does not show return for @return [void] if :hide_void_return is true" do
     @options.hide_void_return = true
     YARD.parse_string <<-'eof'
       # @return [void]
       def foo; end
     eof
-    signature(Registry.at('#foo')).should == @results[:hide_void]
+    expect(trim(signature(Registry.at('#foo')))).to eq @results[:hide_void]
   end
 
-  it "should show block for method with yield" do
+  it "shows block for method with yield" do
     YARD.parse_string <<-'eof'
       def foo; yield(a, b, c) end
     eof
-    signature(Registry.at('#foo')).should == @results[:block]
+    expect(trim(signature(Registry.at('#foo')))).to eq @results[:block]
   end
 
-  it "should use regular return tag if the @overload is empty" do
+  it "uses regular return tag if the @overload is empty" do
     YARD.parse_string <<-'eof'
       # @overload foobar
       #   Hello world
       # @return [String]
       def foo; end
     eof
-    signature(Registry.at('#foo').tag(:overload)).should == @results[:empty_overload]
+    expect(trim(signature(Registry.at('#foo').tag(:overload)))).to eq @results[:empty_overload]
   end
 end