yard 0.8.7.6 → 0.9.0

data/spec/templates/examples/module004.html

@@ -3,11 +3,11 @@
   
   
 </h1>
-
-<dl class="box">
+<div class="box_info">
   
-    <dt class="r1">Inherits:</dt>
-    <dd class="r1">
+  <dl>
+    <dt>Inherits:</dt>
+    <dd>
       <span class="inheritName">Object</span>
       
         <ul class="fullTree">
@@ -18,41 +18,47 @@
         </ul>
         <a href="#" class="inheritanceTree">show all</a>
       
-      </dd>
-    
+    </dd>
+  </dl>
   
+
   
-    
-      <dt class="r2">Extended by:</dt>
-      <dd class="r2">Bar</dd>
-      
-    
   
-    
-      <dt class="r1">Includes:</dt>
-      <dd class="r1">BarFooBar, Baz::ABC, Baz::XYZ, Foo</dd>
-      
-    
+  <dl>
+      <dt>Extended by:</dt>
+      <dd>Bar</dd>
+  </dl>
   
   
   
-    <dt class="r2 last">Defined in:</dt>
-    <dd class="r2 last">(stdin)</dd>
+  <dl>
+      <dt>Includes:</dt>
+      <dd>BarFooBar, Baz::ABC, Baz::XYZ, Foo</dd>
+  </dl>
   
-</dl>
-<div class="clear"></div>
+  
+
+  
+
+  
+  <dl>
+    <dt>Defined in:</dt>
+    <dd>(stdin)</dd>
+  </dl>
+  
+</div>
 
 
 
 
 
-  <h2>Instance Attribute Summary <small>(<a href="#" class="summary_toggle">collapse</a>)</small></h2>
+  <h2>Instance Attribute Summary <small><a href="#" class="summary_toggle">collapse</a></small></h2>
   <ul class="summary">
     
       <li class="public ">
   <span class="summary_signature">
     
-      <a  title="#bar_attr (instance method)">- <strong>bar_attr</strong> </a>
+      <a  title="#bar_attr (instance method)">#<strong>bar_attr</strong>  </a>
     
 
     
@@ -87,7 +93,7 @@
   
     <h2>
       Booya
-      <small>(<a href="#" class="summary_toggle">collapse</a>)</small>
+      <small><a href="#" class="summary_toggle">collapse</a></small>
     </h2>
 
     <ul class="summary">
@@ -95,7 +101,7 @@
         <li class="public ">
   <span class="summary_signature">
     
-      <a  title="#baz (class method)">+ <strong>baz</strong> </a>
+      <a  title="#baz (class method)">.<strong>baz</strong>  </a>
     
 
     
@@ -122,7 +128,7 @@
         <li class="public ">
   <span class="summary_signature">
     
-      <a  title="#baz_abc (instance method)">- <strong>baz_abc</strong> </a>
+      <a  title="#baz_abc (instance method)">#<strong>baz_abc</strong>  </a>
     
 
     
@@ -150,7 +156,7 @@
   
     <h2>
       Instance Method Summary
-      <small>(<a href="#" class="summary_toggle">collapse</a>)</small>
+      <small><a href="#" class="summary_toggle">collapse</a></small>
     </h2>
 
     <ul class="summary">
@@ -158,7 +164,7 @@
         <li class="public ">
   <span class="summary_signature">
     
-      <a  title="#foo (instance method)">- <strong>foo</strong> </a>
+      <a  title="#foo (instance method)">#<strong>foo</strong>  </a>
     
 
     
@@ -180,7 +186,7 @@
         <li class="public ">
   <span class="summary_signature">
     
-      <a  title="#xyz (instance method)">- <strong>xyz</strong> </a>
+      <a  title="#xyz (instance method)">#<strong>xyz</strong>  </a>
     
 
     
@@ -244,7 +250,7 @@
       <div class="method_details first">
   <h3 class="signature first" id="bar_attr-instance_method">
   
-    - <strong>bar_attr</strong> 
+    #<strong>bar_attr</strong>  
   
 
   
@@ -277,7 +283,7 @@
       <div class="method_details first">
   <h3 class="signature first" id="baz-class_method">
   
-    + <strong>baz</strong> 
+    .<strong>baz</strong>  
   
 
   
@@ -309,7 +315,7 @@
       <div class="method_details first">
   <h3 class="signature first" id="baz_abc-instance_method">
   
-    - <strong>baz_abc</strong> 
+    #<strong>baz_abc</strong>  
   
 
   
@@ -326,7 +332,7 @@
       <div class="method_details ">
   <h3 class="signature " id="foo-instance_method">
   
-    - <strong>foo</strong> 
+    #<strong>foo</strong>  
   
 
   
@@ -361,7 +367,7 @@ def foo; end</pre>
       <div class="method_details ">
   <h3 class="signature " id="xyz-instance_method">
   
-    - <strong>xyz</strong> 
+    #<strong>xyz</strong>  
   
 
   
@@ -385,3 +391,4 @@ def foo; end</pre>
 </div>
     
   </div>
+

data/spec/templates/helpers/base_helper_spec.rb

@@ -3,173 +3,169 @@ require File.dirname(__FILE__) + '/../spec_helper'
 describe YARD::Templates::Helpers::BaseHelper do
   include YARD::Templates::Helpers::BaseHelper
 
-  describe '#run_verifier' do
-    it "should run verifier proc against list if provided" do
+  describe "#run_verifier" do
+    it "runs verifier proc against list if provided" do
       mock = Verifier.new
-      mock.should_receive(:call).with(1)
-      mock.should_receive(:call).with(2)
-      mock.should_receive(:call).with(3)
-      should_receive(:options).at_least(1).times.and_return(Options.new.update(:verifier => mock))
+      expect(mock).to receive(:call).with(1)
+      expect(mock).to receive(:call).with(2)
+      expect(mock).to receive(:call).with(3)
+      expect(self).to receive(:options).at_least(1).times.and_return(Options.new.update(:verifier => mock))
       run_verifier [1, 2, 3]
     end
 
-    it "should prune list if lambda returns false and only false" do
+    it "prunes list if lambda returns false and only false" do
       mock = Verifier.new
-      should_receive(:options).at_least(1).times.and_return(Options.new.update(:verifier => mock))
-      mock.should_receive(:call).with(1).and_return(false)
-      mock.should_receive(:call).with(2).and_return(true)
-      mock.should_receive(:call).with(3).and_return(nil)
-      mock.should_receive(:call).with(4).and_return("value")
-      run_verifier([1, 2, 3, 4]).should == [2, 3, 4]
+      expect(self).to receive(:options).at_least(1).times.and_return(Options.new.update(:verifier => mock))
+      expect(mock).to receive(:call).with(1).and_return(false)
+      expect(mock).to receive(:call).with(2).and_return(true)
+      expect(mock).to receive(:call).with(3).and_return(nil)
+      expect(mock).to receive(:call).with(4).and_return("value")
+      expect(run_verifier([1, 2, 3, 4])).to eq [2, 3, 4]
     end
 
-    it "should return list if no verifier exists" do
-      should_receive(:options).at_least(1).times.and_return(Options.new)
-      run_verifier([1, 2, 3]).should == [1, 2, 3]
+    it "returns list if no verifier exists" do
+      expect(self).to receive(:options).at_least(1).times.and_return(Options.new)
+      expect(run_verifier([1, 2, 3])).to eq [1, 2, 3]
     end
   end
 
-  describe '#h' do
-    it "should return just the text" do
-      h("hello world").should == "hello world"
-      h(nil).should == nil
+  describe "#h" do
+    it "returns just the text" do
+      expect(h("hello world")).to eq "hello world"
+      expect(h(nil)).to eq nil
     end
   end
 
-  describe '#link_object' do
-    it "should return the title if provided" do
-      link_object(1, "title").should == "title"
-      link_object(Registry.root, "title").should == "title"
+  describe "#link_object" do
+    it "returns the title if provided" do
+      expect(link_object(1, "title")).to eq "title"
+      expect(link_object(Registry.root, "title")).to eq "title"
     end
 
-    it "should return a path if argument is a Proxy or object" do
-      link_object(Registry.root).should == "Top Level Namespace"
-      link_object(P("Array")).should == "Array"
+    it "returns a path if argument is a Proxy or object" do
+      expect(link_object(Registry.root)).to eq "Top Level Namespace"
+      expect(link_object(P("Array"))).to eq "Array"
     end
 
-    it "should should return path of Proxified object if argument is a String or Symbol" do
-      link_object("Array").should == "Array"
-      link_object(:"A::B").should == "A::B"
+    it "returns path of Proxified object if argument is a String or Symbol" do
+      expect(link_object("Array")).to eq "Array"
+      expect(link_object(:"A::B")).to eq "A::B"
     end
 
-    it "should return the argument if not an object, proxy, String or Symbol" do
-      link_object(1).should == 1
+    it "returns the argument if not an object, proxy, String or Symbol" do
+      expect(link_object(1)).to eq 1
     end
   end
 
-  describe '#link_url' do
-    it "should return the URL" do
-      link_url("http://url").should == "http://url"
+  describe "#link_url" do
+    it "returns the URL" do
+      expect(link_url("http://url")).to eq "http://url"
     end
   end
 
-  describe '#linkify' do
-    before do
-      stub!(:object).and_return(Registry.root)
-    end
+  describe "#linkify" do
+    let(:object) { Registry.root }
+    # before do
+    #   stub!(:object).and_return(Registry.root)
+    # end
 
-    it "should call #link_url for mailto: links" do
-      should_receive(:link_url)
+    it "calls #link_url for mailto: links" do
+      expect(self).to receive(:link_url)
       linkify("mailto:steve@example.com")
     end
 
-    it "should call #link_url for URL schemes (http://)" do
-      should_receive(:link_url)
+    it "calls #link_url for URL schemes (http://)" do
+      expect(self).to receive(:link_url)
       linkify("http://example.com")
     end
 
-    it "should call #link_file for file: links" do
-      should_receive(:link_file).with('Filename', nil, 'anchor')
+    it "calls #link_file for file: links" do
+      expect(self).to receive(:link_file).with('Filename', nil, 'anchor')
       linkify("file:Filename#anchor")
     end
 
-    it "should pass off to #link_object if argument is an object" do
+    it "passes off to #link_object if argument is an object" do
       obj = CodeObjects::NamespaceObject.new(nil, :YARD)
-      should_receive(:link_object).with(obj)
+      expect(self).to receive(:link_object).with(obj)
       linkify obj
     end
 
-    it "should return empty string and warn if object does not exist" do
-      log.should_receive(:warn).with(/Cannot find object .* for inclusion/)
-      linkify('include:NotExist').should == ''
+    it "returns empty string and warn if object does not exist" do
+      expect(log).to receive(:warn).with(/Cannot find object .* for inclusion/)
+      expect(linkify('include:NotExist')).to eq ''
     end
 
-    it "should pass off to #link_url if argument is recognized as a URL" do
+    it "passes off to #link_url if argument is recognized as a URL" do
       url = "http://yardoc.org/"
-      should_receive(:link_url).with(url, nil, {:target => '_parent'})
+      expect(self).to receive(:link_url).with(url, nil, {:target => '_parent'})
       linkify url
     end
 
-    it "should call #link_include_object for include:ObjectName" do
+    it "calls #link_include_object for include:ObjectName" do
       obj = CodeObjects::NamespaceObject.new(:root, :Foo)
-      should_receive(:link_include_object).with(obj)
+      expect(self).to receive(:link_include_object).with(obj)
       linkify 'include:Foo'
     end
 
-    it "should call #link_include_file for include:file:path/to/file" do
-      File.should_receive(:file?).with('path/to/file').and_return(true)
-      File.should_receive(:read).with('path/to/file').and_return('FOO')
-      linkify('include:file:path/to/file').should == 'FOO'
+    it "calls #link_include_file for include:file:path/to/file" do
+      expect(File).to receive(:file?).with('path/to/file').and_return(true)
+      expect(File).to receive(:read).with('path/to/file').and_return('FOO')
+      expect(linkify('include:file:path/to/file')).to eq 'FOO'
     end
 
-    it "should not allow include:file for path above pwd" do
-      log.should_receive(:warn).with("Cannot include file from path `a/b/../../../../file'")
-      linkify('include:file:a/b/../../../../file').should == ''
+    it "does not allow include:file for path above pwd" do
+      expect(log).to receive(:warn).with("Cannot include file from path `a/b/../../../../file'")
+      expect(linkify('include:file:a/b/../../../../file')).to eq ''
     end
 
-    it "should warn if include:file:path does not exist" do
-      log.should_receive(:warn).with(/Cannot find file .+ for inclusion/)
-      linkify('include:file:notexist').should == ''
+    it "warns if include:file:path does not exist" do
+      expect(log).to receive(:warn).with(/Cannot find file .+ for inclusion/)
+      expect(linkify('include:file:notexist')).to eq ''
     end
   end
 
-  describe '#format_types' do
-    it "should return the list of types separated by commas surrounded by brackets" do
-      format_types(['a', 'b', 'c']).should == '(a, b, c)'
+  describe "#format_types" do
+    it "returns the list of types separated by commas surrounded by brackets" do
+      expect(format_types(['a', 'b', 'c'])).to eq '(a, b, c)'
     end
 
-    it "should return the list of types without brackets if brackets=false" do
-      format_types(['a', 'b', 'c'], false).should == 'a, b, c'
+    it "returns the list of types without brackets if brackets=false" do
+      expect(format_types(['a', 'b', 'c'], false)).to eq 'a, b, c'
     end
 
-    it "should should return an empty string if list is empty or nil" do
-      format_types(nil).should == ""
-      format_types([]).should == ""
+    it "returns an empty string if list is empty or nil" do
+      expect(format_types(nil)).to eq ""
+      expect(format_types([])).to eq ""
     end
   end
 
-  describe '#format_object_type' do
-    it "should return Exception if type is Exception" do
-      obj = mock(:object)
-      obj.stub!(:is_a?).with(YARD::CodeObjects::ClassObject).and_return(true)
-      obj.stub!(:is_exception?).and_return(true)
-      format_object_type(obj).should == "Exception"
+  describe "#format_object_type" do
+    it "returns Exception if type is Exception" do
+      obj = double(:object, :is_exception? => true)
+      allow(obj).to receive(:is_a?) { |arg| arg == YARD::CodeObjects::ClassObject }
+      expect(format_object_type(obj)).to eq "Exception"
     end
 
-    it "should return Class if type is Class" do
-      obj = mock(:object)
-      obj.stub!(:is_a?).with(YARD::CodeObjects::ClassObject).and_return(true)
-      obj.stub!(:is_exception?).and_return(false)
-      format_object_type(obj).should == "Class"
+    it "returns Class if type is Class" do
+      obj = double(:object, :is_exception? => false)
+      allow(obj).to receive(:is_a?) { |arg| arg == YARD::CodeObjects::ClassObject }
+      expect(format_object_type(obj)).to eq "Class"
     end
 
-    it "should return object type in other cases" do
-      obj = mock(:object)
-      obj.stub!(:type).and_return("value")
-      format_object_type(obj).should == "Value"
+    it "returns object type in other cases" do
+      obj = double(:object, :type => "value")
+      expect(format_object_type(obj)).to eq "Value"
     end
   end
 
-  describe '#format_object_title' do
-    it "should return Top Level Namespace for root object" do
-      format_object_title(Registry.root).should == "Top Level Namespace"
+  describe "#format_object_title" do
+    it "returns Top Level Namespace for root object" do
+      expect(format_object_title(Registry.root)).to eq "Top Level Namespace"
     end
 
-    it "should return 'type: title' in other cases" do
-      obj = mock(:object)
-      obj.stub!(:type).and_return(:class)
-      obj.stub!(:title).and_return("A::B::C")
-      format_object_title(obj).should == "Class: A::B::C"
+    it "returns 'type: title' in other cases" do
+      obj = double(:object, :type => :class, :title => "A::B::C")
+      expect(format_object_title(obj)).to eq "Class: A::B::C"
     end
   end
 end

data/spec/templates/helpers/html_helper_spec.rb

@@ -14,71 +14,71 @@ describe YARD::Templates::Helpers::HtmlHelper do
     end
   end
 
-  describe '#h' do
-    it "should use #h to escape HTML" do
-      h('Usage: foo "bar" <baz>').should == "Usage: foo &quot;bar&quot; &lt;baz&gt;"
+  describe "#h" do
+    it "uses #h to escape HTML" do
+      expect(h('Usage: foo "bar" <baz>')).to eq "Usage: foo &quot;bar&quot; &lt;baz&gt;"
     end
   end
 
-  describe '#charset' do
-    it "should return foo if LANG=foo" do
-      ENV.should_receive(:[]).with('LANG').and_return('shift_jis') if YARD.ruby18?
-      Encoding.default_external.should_receive(:name).and_return('shift_jis') if defined?(Encoding)
-      charset.should == 'shift_jis'
+  describe "#charset" do
+    it "returns foo if LANG=foo" do
+      expect(ENV).to receive(:[]).with('LANG').and_return('shift_jis') if YARD.ruby18?
+      expect(Encoding.default_external).to receive(:name).and_return('shift_jis') if defined?(Encoding)
+      expect(charset).to eq '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 YARD.ruby18?
-        Encoding.default_external.should_receive(:name).and_return(type) if defined?(Encoding)
-        charset.should == 'iso-8859-1'
+      it "converts #{type} to iso-8859-1" do
+        expect(ENV).to receive(:[]).with('LANG').and_return(type) if YARD.ruby18?
+        expect(Encoding.default_external).to receive(:name).and_return(type) if defined?(Encoding)
+        expect(charset).to eq 'iso-8859-1'
       end
     end
 
-    it "should support utf8 as an encoding value for utf-8" do
+    it "supports utf8 as an encoding value for utf-8" do
       type = 'utf8'
-      ENV.should_receive(:[]).with('LANG').and_return(type) if YARD.ruby18?
-      Encoding.default_external.should_receive(:name).and_return(type) if defined?(Encoding)
-      charset.should == 'utf-8'
+      expect(ENV).to receive(:[]).with('LANG').and_return(type) if YARD.ruby18?
+      expect(Encoding.default_external).to receive(:name).and_return(type) if defined?(Encoding)
+      expect(charset).to eq 'utf-8'
     end
 
-    it "should take file encoding if there is a file" do
+    it "takes file encoding if there is a file" do
       @file = OpenStruct.new(:contents => 'foo'.force_encoding('sjis'))
       # not the correct charset name, but good enough
-      ['Shift_JIS', 'Windows-31J'].should include(charset)
+      expect(['Shift_JIS', 'Windows-31J']).to include(charset)
     end if YARD.ruby19?
 
-    it "should take file encoding if there is a file" do
-      ENV.stub!(:[]).with('LANG').and_return('utf-8') if YARD.ruby18?
+    it "takes file encoding if there is a file" do
+      allow(ENV).to receive(:[]).with('LANG').and_return('utf-8') if YARD.ruby18?
       @file = OpenStruct.new(:contents => 'foo')
-      charset.should == 'utf-8'
+      expect(charset).to eq 'utf-8'
     end if YARD.ruby18?
 
     if YARD.ruby18?
-      it "should return utf-8 if no LANG env is set" do
-        ENV.should_receive(:[]).with('LANG').and_return(nil)
-        charset.should == 'utf-8'
+      it "returns utf-8 if no LANG env is set" do
+        expect(ENV).to receive(:[]).with('LANG').and_return(nil)
+        expect(charset).to eq 'utf-8'
       end
 
-      it "should only return charset part of lang" do
-        ENV.should_receive(:[]).with('LANG').and_return('en_US.UTF-8')
-        charset.should == 'utf-8'
+      it "only returns charset part of lang" do
+        expect(ENV).to receive(:[]).with('LANG').and_return('en_US.UTF-8')
+        expect(charset).to eq 'utf-8'
       end
     end
   end
 
-  describe '#format_types' do
-    it "should include brackets by default" do
+  describe "#format_types" do
+    it "includes 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>)"
+      expect(self).to receive(:linkify).at_least(1).times.with("String", "String").and_return("String")
+      expect(format_types(text)).to eq format_types(text, true)
+      expect(format_types(text)).to eq "(<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>"
+    it "avoids brackets if brackets=false" do
+      expect(self).to receive(:linkify).with("String", "String").and_return("String")
+      expect(self).to receive(:linkify).with("Symbol", "Symbol").and_return("Symbol")
+      expect(format_types(["String", "Symbol"], false)).to eq "<tt>String</tt>, <tt>Symbol</tt>"
     end
 
     { "String" => [["String"],
@@ -93,28 +93,32 @@ describe YARD::Templates::Helpers::HtmlHelper do
         "<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]
+      it "links all classes in #{text}" do
+        if text.count('<') > 0
+          expect(self).to receive(:h).with('<').at_least(text.count('<')).times.and_return("&lt;")
+        end
+        if text.count('>') > 0
+          expect(self).to receive(:h).with('>').at_least(text.count('>')).times.and_return("&gt;")
+        end
+        values[0].each {|v| expect(self).to receive(:linkify).with(v, v).and_return("<a href=''>#{v}</a>") }
+        expect(format_types([text], false)).to eq values[1]
       end
     end
   end
 
-  describe '#htmlify' do
-    it "should not use hard breaks for textile markup (RedCloth specific)" do
+  describe "#htmlify" do
+    it "does 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")
+      expect(htmlify("A\nB", :textile)).not_to include("<br")
     end
 
-    it "should use hard breaks for textile_strict markup (RedCloth specific)" do
+    it "uses hard breaks for textile_strict markup (RedCloth specific)" do
       begin; require 'redcloth'; rescue LoadError; pending 'test requires redcloth gem' end
-      htmlify("A\nB", :textile_strict).should include("<br")
+      expect(htmlify("A\nB", :textile_strict)).to include("<br")
     end
 
-    it "should handle various encodings" do
-      stub!(:object).and_return(Registry.root)
+    it "handles various encodings" do
+      allow(self).to receive(:object).and_return(Registry.root)
       text = "\xB0\xB1"
       if defined?(Encoding)
         Encoding.default_internal = 'utf-8'
@@ -124,53 +128,53 @@ describe YARD::Templates::Helpers::HtmlHelper do
       # TODO: add more encoding tests
     end
 
-    it "should return pre-formatted text with :pre markup" do
-      htmlify("fo\no\n\nbar<>", :pre).should == "<pre>fo\no\n\nbar&lt;&gt;</pre>"
+    it "returns pre-formatted text with :pre markup" do
+      expect(htmlify("fo\no\n\nbar<>", :pre)).to eq "<pre>fo\no\n\nbar&lt;&gt;</pre>"
     end
 
-    it "should return regular text with :text markup" do
-      htmlify("fo\no\n\nbar<>", :text).should == "fo<br/>o<br/><br/>bar&lt;&gt;"
+    it "returns regular text with :text markup" do
+      expect(htmlify("fo\no\n\nbar<>", :text)).to eq "fo<br/>o<br/><br/>bar&lt;&gt;"
     end
 
-    it "should return unmodified text with :none markup" do
-      htmlify("fo\no\n\nbar<>", :none).should == "fo\no\n\nbar&lt;&gt;"
+    it "returns unmodified text with :none markup" do
+      expect(htmlify("fo\no\n\nbar<>", :none)).to eq "fo\no\n\nbar&lt;&gt;"
     end
 
-    it "should highlight ruby if markup is :ruby" do
-      htmlify("class Foo; end", :ruby).should =~ /\A<pre class="code ruby"><span/
+    it "highlights ruby if markup is :ruby" do
+      expect(htmlify("class Foo; end", :ruby)).to match /\A<pre class="code ruby"><span/
     end
 
-    it "should include file and htmlify it" do
+    it "includes file and htmlifies it" do
       load_markup_provider(:rdoc)
-      File.should_receive(:file?).with('foo.rdoc').and_return(true)
-      File.should_receive(:read).with('foo.rdoc').and_return('HI')
-      htmlify("{include:file:foo.rdoc}", :rdoc).gsub(/\s+/, '').should == "<p><p>HI</p></p>"
+      expect(File).to receive(:file?).with('foo.rdoc').and_return(true)
+      expect(File).to receive(:read).with('foo.rdoc').and_return('HI')
+      expect(htmlify("{include:file:foo.rdoc}", :rdoc).gsub(/\s+/, '')).to eq "<p><p>HI</p></p>"
     end
 
-    it "should autolink URLs (markdown specific)" do
+    it "autolinks URLs (markdown specific)" do
       log.enter_level(Logger::FATAL) do
         unless markup_class(:markdown).to_s == "RedcarpetCompat"
           pending 'This test depends on a markdown engine that supports autolinking'
         end
       end
-      htmlify('http://example.com', :markdown).chomp.gsub('&#47;', '/').should ==
-        '<p><a href="http://example.com">http://example.com</a></p>'
+      expect(htmlify('http://example.com', :markdown).chomp.gsub('&#47;', '/')).to eq(
+        '<p><a href="http://example.com">http://example.com</a></p>')
     end
 
-    it "should not autolink URLs inside of {} (markdown specific)" do
+    it "does not autolink URLs inside of {} (markdown specific)" do
       log.enter_level(Logger::FATAL) do
         pending 'This test depends on markdown' unless markup_class(:markdown)
       end
-      htmlify('{http://example.com Title}', :markdown).chomp.should =~
-        %r{<p><a href="http://example.com".*>Title</a></p>}
-      htmlify('{http://example.com}', :markdown).chomp.should =~
-        %r{<p><a href="http://example.com".*>http://example.com</a></p>}
+      expect(htmlify('{http://example.com Title}', :markdown).chomp).to match(
+        %r{<p><a href="http://example.com".*>Title</a></p>})
+      expect(htmlify('{http://example.com}', :markdown).chomp).to match(
+        %r{<p><a href="http://example.com".*>http://example.com</a></p>})
     end
 
-    it "should create tables (markdown specific)" do
+    it "creates tables (markdown specific)" do
       log.enter_level(Logger::FATAL) do
         unless markup_class(:markdown).to_s == "RedcarpetCompat"
-          pending 'This test depends on a markdown engine that supports tables'
+          skip "This test depends on a markdown engine that supports tables"
         end
       end
 
@@ -182,12 +186,12 @@ describe YARD::Templates::Helpers::HtmlHelper do
       EOF
 
       html = htmlify(markdown, :markdown)
-      html.should =~ %r{<table>}
-      html.should =~ %r{<th>City</th>}
-      html.should =~ %r{<td>NC</td>}
+      expect(html).to match %r{<table>}
+      expect(html).to match %r{<th>City</th>}
+      expect(html).to match %r{<td>NC</td>}
     end
 
-    it 'should handle fenced code blocks (Redcarpet specific)' do
+    it "handles fenced code blocks (Redcarpet specific)" do
       log.enter_level(Logger::FATAL) do
         unless markup_class(:markdown).to_s == 'RedcarpetCompat'
           pending 'This test is Redcarpet specific'
@@ -196,26 +200,24 @@ describe YARD::Templates::Helpers::HtmlHelper do
 
       markdown = "Introduction:\n```ruby\nputs\n\nputs\n```"
       html = htmlify(markdown, :markdown)
-      html.should =~ %r{^<p>Introduction:</p>.*<code class="ruby">}m
+      expect(html).to match %r{^<p>Introduction:</p>.*<code class="ruby">}m
     end
   end
 
   describe "#link_object" do
-    before do
-      stub!(:object).and_return(CodeObjects::NamespaceObject.new(nil, :YARD))
-    end
+    let(:object) { CodeObjects::NamespaceObject.new(nil, :YARD) }
 
-    it "should return the object path if there's no serializer and no title" do
-      stub!(:serializer).and_return nil
-      link_object(CodeObjects::NamespaceObject.new(nil, :YARD)).should == "YARD"
+    it "returns the object path if there's no serializer and no title" do
+      allow(self).to receive(:serializer).and_return(nil)
+      expect(link_object(CodeObjects::NamespaceObject.new(nil, :YARD))).to eq "YARD"
     end
 
-    it "should return the title if there's a title but no serializer" do
-      stub!(:serializer).and_return nil
-      link_object(CodeObjects::NamespaceObject.new(nil, :YARD), 'title').should == "title"
+    it "returns the title if there's a title but no serializer" do
+      allow(self).to receive(:serializer).and_return(nil)
+      expect(link_object(CodeObjects::NamespaceObject.new(nil, :YARD), 'title')).to eq "title"
     end
 
-    it "should link objects from overload tag" do
+    it "links objects from overload tag" do
       YARD.parse_string <<-'eof'
         module Foo
           class Bar; def a; end end
@@ -228,50 +230,46 @@ describe YARD::Templates::Helpers::HtmlHelper do
       obj = Registry.at('Foo::Baz#a').tag(:overload)
       foobar = Registry.at('Foo::Bar')
       foobaz = Registry.at('Foo::Baz')
-      serializer = Serializers::FileSystemSerializer.new
-      stub!(:serializer).and_return(serializer)
-      stub!(:object).and_return(obj)
-      link_object("Bar#a").should =~ %r{href="Bar.html#a-instance_method"}
+      allow(self).to receive(:serializer).and_return(Serializers::FileSystemSerializer.new)
+      allow(self).to receive(:object).and_return(obj)
+      expect(link_object("Bar#a")).to match %r{href="Bar.html#a-instance_method"}
     end
 
-    it "should use relative path in title" do
+    it "uses 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>}
+      allow(self).to receive(:object).and_return(CodeObjects::ModuleObject.new(P('YARD'), :Foo))
+      allow(self).to receive(:serializer).and_return(Serializers::FileSystemSerializer.new)
+      expect(link_object("Bar")).to match %r{>Bar</a>}
     end
 
-    it "should use #title if overridden" do
+    it "uses #title if overridden" do
       CodeObjects::ModuleObject.new(:root, :YARD)
       CodeObjects::ClassObject.new(P('YARD'), :Bar)
-      Registry.at('YARD::Bar').stub(:title).and_return('TITLE!')
-      stub!(:object).and_return(Registry.at('YARD::Bar'))
+      allow(Registry.at('YARD::Bar')).to receive(:title).and_return('TITLE!')
+      allow(self).to receive(:object).and_return(Registry.at('YARD::Bar'))
       serializer = Serializers::FileSystemSerializer.new
-      stub!(:serializer).and_return(serializer)
-      link_object("Bar").should =~ %r{>TITLE!</a>}
+      allow(self).to receive(:serializer).and_return(Serializers::FileSystemSerializer.new)
+      expect(link_object("Bar")).to match %r{>TITLE!</a>}
     end
 
-    it "should use relative path to parent class in title" do
+    it "uses relative path to parent class in title" do
       root = CodeObjects::ModuleObject.new(:root, :YARD)
       obj = CodeObjects::ModuleObject.new(root, :SubModule)
-      stub!(:object).and_return(obj)
-      serializer = Serializers::FileSystemSerializer.new
-      stub!(:serializer).and_return(serializer)
-      link_object("YARD").should =~ %r{>YARD</a>}
+      allow(self).to receive(:object).and_return(obj)
+      allow(self).to receive(:serializer).and_return(Serializers::FileSystemSerializer.new)
+      expect(link_object("YARD")).to match %r{>YARD</a>}
     end
 
-    it "should use Klass.foo when linking to class method in current namespace" do
+    it "uses Klass.foo when linking to class method in current namespace" do
       root = CodeObjects::ModuleObject.new(:root, :Klass)
       obj = CodeObjects::MethodObject.new(root, :foo, :class)
-      stub!(:object).and_return(root)
-      serializer = Serializers::FileSystemSerializer.new
-      stub!(:serializer).and_return(serializer)
-      link_object("foo").should =~ %r{>Klass.foo</a>}
+      allow(self).to receive(:object).and_return(root)
+      allow(self).to receive(:serializer).and_return(Serializers::FileSystemSerializer.new)
+      expect(link_object("foo")).to match %r{>Klass.foo</a>}
     end
 
-    it "should escape method name in title" do
+    it "escapes method name in title" do
       YARD.parse_string <<-'eof'
         class Array
           def &(other)
@@ -279,73 +277,71 @@ describe YARD::Templates::Helpers::HtmlHelper do
         end
       eof
       obj = Registry.at('Array#&')
-      serializer = Serializers::FileSystemSerializer.new
-      stub!(:serializer).and_return(serializer)
-      stub!(:object).and_return(obj)
-      link_object("Array#&").should =~ %r{title="Array#&amp; \(method\)"}
+      allow(self).to receive(:serializer).and_return(Serializers::FileSystemSerializer.new)
+      allow(self).to receive(:object).and_return(obj)
+      expect(link_object("Array#&")).to match %r{title="Array#&amp; \(method\)"}
     end
   end
 
-  describe '#url_for' do
+  describe "#url_for" do
     before { Registry.clear }
 
-    it "should return nil if serializer is nil" do
-      stub!(:serializer).and_return nil
-      stub!(:object).and_return Registry.root
-      url_for(P("Mod::Class#meth")).should be_nil
+    it "returns nil if serializer is nil" do
+      allow(self).to receive(:serializer).and_return nil
+      allow(self).to receive(:object).and_return Registry.root
+      expect(url_for(P("Mod::Class#meth"))).to be nil
     end
 
-    it "should return nil if object is hidden" do
+    it "returns nil if object is hidden" do
       yard = CodeObjects::ModuleObject.new(:root, :YARD)
 
-      stub!(:serializer).and_return Serializers::FileSystemSerializer.new
-      stub!(:object).and_return Registry.root
-      stub!(:options).and_return OpenStruct.new(:verifier => Verifier.new('false'))
+      allow(self).to receive(:serializer).and_return(Serializers::FileSystemSerializer.new)
+      allow(self).to receive(:object).and_return Registry.root
+      allow(self).to receive(:options).and_return OpenStruct.new(:verifier => Verifier.new('false'))
 
-      url_for(yard).should be_nil
+      expect(url_for(yard)).to be nil
     end
 
-    it "should return nil if serializer does not implement #serialized_path" do
-      stub!(:serializer).and_return Serializers::Base.new
-      stub!(:object).and_return Registry.root
-      url_for(P("Mod::Class#meth")).should be_nil
+    it "returns nil if serializer does not implement #serialized_path" do
+      allow(self).to receive(:serializer).and_return Serializers::Base.new
+      allow(self).to receive(:object).and_return Registry.root
+      expect(url_for(P("Mod::Class#meth"))).to be nil
     end
 
-    it "should link to a path/file for a namespace object" do
-      stub!(:serializer).and_return Serializers::FileSystemSerializer.new
-      stub!(:object).and_return Registry.root
+    it "links to a path/file for a namespace object" do
+      allow(self).to receive(:serializer).and_return Serializers::FileSystemSerializer.new
+      allow(self).to receive(:object).and_return Registry.root
 
       yard = CodeObjects::ModuleObject.new(:root, :YARD)
-      url_for(yard).should == 'YARD.html'
+      expect(url_for(yard)).to eq 'YARD.html'
     end
 
-    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!(:object).and_return Registry.root
+    it "links to the object's namespace path/file and use the object as the anchor" do
+      allow(self).to receive(:serializer).and_return Serializers::FileSystemSerializer.new
+      allow(self).to receive(:object).and_return Registry.root
 
       yard = CodeObjects::ModuleObject.new(:root, :YARD)
       meth = CodeObjects::MethodObject.new(yard, :meth)
-      url_for(meth).should == 'YARD.html#meth-instance_method'
+      expect(url_for(meth)).to eq 'YARD.html#meth-instance_method'
     end
 
-    it "should properly urlencode methods with punctuation in links" do
+    it "properly urlencodes methods with punctuation in links" do
       obj = CodeObjects::MethodObject.new(nil, :/)
-      serializer = mock(:serializer)
-      serializer.stub!(:serialized_path).and_return("file.html")
-      stub!(:serializer).and_return(serializer)
-      stub!(:object).and_return(obj)
-      url_for(obj).should == "#%2F-instance_method"
+      serializer = double(:serializer, :serialized_path => "file.html")
+      allow(self).to receive(:serializer).and_return serializer
+      allow(self).to receive(:object).and_return obj
+      expect(url_for(obj)).to eq "#%2F-instance_method"
     end
   end
 
-  describe '#anchor_for' do
-    it "should not urlencode data when called directly" do
+  describe "#anchor_for" do
+    it "does not urlencode data when called directly" do
       obj = CodeObjects::MethodObject.new(nil, :/)
-      anchor_for(obj).should == "/-instance_method"
+      expect(anchor_for(obj)).to eq "/-instance_method"
     end
   end
 
-  describe '#resolve_links' do
+  describe "#resolve_links" do
     def parse_link(link)
       results = {}
       link =~ /<a (.+?)>(.+?)<\/a>/m
@@ -356,119 +352,119 @@ describe YARD::Templates::Helpers::HtmlHelper do
       results
     end
 
-    it "should escape {} syntax with backslash (\\{foo bar})" do
+    it "escapes {} syntax with backslash (\\{foo bar})" do
       input  = '\{foo bar} \{XYZ} \{file:FOO} $\{N-M}'
       output = '{foo bar} {XYZ} {file:FOO} ${N-M}'
-      resolve_links(input).should == output
+      expect(resolve_links(input)).to eq output
     end
 
-    it "should escape {} syntax with ! (!{foo bar})" do
+    it "escapes {} syntax with ! (!{foo bar})" do
       input  = '!{foo bar} !{XYZ} !{file:FOO} $!{N-M}'
       output = '{foo bar} {XYZ} {file:FOO} ${N-M}'
-      resolve_links(input).should == output
+      expect(resolve_links(input)).to eq output
     end
 
-    it "should link static files with file: prefix" do
-      stub!(:serializer).and_return Serializers::FileSystemSerializer.new
-      stub!(:object).and_return Registry.root
+    it "links static files with file: prefix" do
+      allow(self).to receive(:serializer).and_return Serializers::FileSystemSerializer.new
+      allow(self).to receive(:object).and_return Registry.root
 
-      parse_link(resolve_links("{file:TEST.txt#abc}")).should == {
+      expect(parse_link(resolve_links("{file:TEST.txt#abc}"))).to eq({
         :inner_text => "TEST",
         :title => "TEST",
         :href => "file.TEST.html#abc"
-      }
-      parse_link(resolve_links("{file:TEST.txt title}")).should == {
+      })
+      expect(parse_link(resolve_links("{file:TEST.txt title}"))).to eq({
         :inner_text => "title",
         :title => "title",
         :href => "file.TEST.html"
-      }
+      })
     end
 
-    it "should create regular links with http:// or https:// prefixes" do
-      parse_link(resolve_links("{http://example.com}")).should == {
+    it "creates regular links with http:// or https:// prefixes" do
+      expect(parse_link(resolve_links("{http://example.com}"))).to eq({
         :inner_text => "http://example.com",
         :target => "_parent",
         :href => "http://example.com",
         :title => "http://example.com"
-      }
-      parse_link(resolve_links("{http://example.com title}")).should == {
+      })
+      expect(parse_link(resolve_links("{http://example.com title}"))).to eq({
         :inner_text => "title",
         :target => "_parent",
         :href => "http://example.com",
         :title => "title"
-      }
+      })
     end
 
-    it "should create mailto links with mailto: prefixes" do
-      parse_link(resolve_links('{mailto:joanna@example.com}')).should == {
+    it "creates mailto links with mailto: prefixes" do
+      expect(parse_link(resolve_links('{mailto:joanna@example.com}'))).to eq({
         :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 == {
+      })
+      expect(parse_link(resolve_links('{mailto:steve@example.com Steve}'))).to eq({
         :inner_text => 'Steve',
         :target => '_parent',
         :href => 'mailto:steve@example.com',
         :title => 'Steve'
-      }
+      })
     end
 
-    it "should ignore {links} that begin with |...|" do
-      resolve_links("{|x|x == 1}").should == "{|x|x == 1}"
+    it "ignores {links} that begin with |...|" do
+      expect(resolve_links("{|x|x == 1}")).to eq "{|x|x == 1}"
     end
 
-    it "should gracefully ignore {} in links" do
-      should_receive(:linkify).with('Foo', 'Foo').and_return('FOO')
-      resolve_links("{} {} {Foo Foo}").should == '{} {} FOO'
+    it "gracefully ignores {} in links" do
+      allow(self).to receive(:linkify).with('Foo', 'Foo').and_return('FOO')
+      expect(resolve_links("{} {} {Foo Foo}")).to eq '{} {} FOO'
     end
 
     %w(tt code pre).each do |tag|
-      it "should ignore links in <#{tag}>" do
+      it "ignores links in <#{tag}>" do
         text = "<#{tag}>{Foo}</#{tag}>"
-        resolve_links(text).should == text
+        expect(resolve_links(text)).to eq text
       end
     end
 
-    it "should resolve {Name}" do
-      should_receive(:link_file).with('TEST', nil, nil).and_return('')
+    it "resolves {Name}" do
+      expect(self).to receive(:link_file).with('TEST', nil, nil).and_return('')
       resolve_links("{file:TEST}")
     end
 
-    it "should resolve ({Name})" do
-      should_receive(:link_file).with('TEST', nil, nil).and_return('')
+    it "resolves ({Name})" do
+      expect(self).to receive(:link_file).with('TEST', nil, nil).and_return('')
       resolve_links("({file:TEST})")
     end
 
-    it "should resolve link with newline in title-part" do
-      parse_link(resolve_links("{http://example.com foo\nbar}")).should == {
+    it "resolves link with newline in title-part" do
+      expect(parse_link(resolve_links("{http://example.com foo\nbar}"))).to eq({
         :inner_text => "foo bar",
         :target => "_parent",
         :href => "http://example.com",
         :title => "foo bar"
-      }
+      })
     end
 
-    it "should resolve links to methods whose names have been escaped" do
-      should_receive(:linkify).with('Object#<<', nil).and_return('')
+    it "resolves links to methods whose names have been escaped" do
+      expect(self).to receive(:linkify).with('Object#<<', nil).and_return('')
       resolve_links("{Object#&lt;&lt;}")
     end
 
-    it "should warn about missing reference at right file location for object" do
+    it "warns 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'))
+      logger = double(:log)
+      expect(logger).to receive(:warn).ordered.with("In file `(stdin)':2: Cannot resolve link to InvalidObject from text:")
+      expect(logger).to receive(:warn).ordered.with("...{InvalidObject}")
+      allow(self).to receive(:log).and_return(logger)
+      allow(self).to receive(: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
+    it "shows 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}
@@ -476,27 +472,27 @@ describe YARD::Templates::Helpers::HtmlHelper do
         # {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'))
+      logger = double(:log)
+      expect(logger).to receive(:warn).ordered.with("In file `(stdin)':1: Cannot resolve link to InvalidObject1 from text:")
+      expect(logger).to receive(:warn).ordered.with("{InvalidObject1}...")
+      expect(logger).to receive(:warn).ordered.with("In file `(stdin)':2: Cannot resolve link to InvalidObject2 from text:")
+      expect(logger).to receive(:warn).ordered.with("...{InvalidObject2}")
+      expect(logger).to receive(:warn).ordered.with("In file `(stdin)':3: Cannot resolve link to InvalidObject3 from text:")
+      expect(logger).to receive(:warn).ordered.with("...{InvalidObject3}...")
+      expect(logger).to receive(:warn).ordered.with("In file `(stdin)':4: Cannot resolve link to InvalidObject4 from text:")
+      expect(logger).to receive(:warn).ordered.with("{InvalidObject4}")
+      allow(self).to receive(:log).and_return(logger)
+      allow(self).to receive(:object).and_return(Registry.at('MyObject'))
       resolve_links(object.docstring)
     end
 
-    it "should warn about missing reference for file template (no object)" do
+    it "warns about missing reference for file template (no object)" do
       @file = CodeObjects::ExtraFileObject.new('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)
+      logger = double(:log)
+      expect(logger).to receive(:warn).ordered.with("In file `myfile.txt':3: Cannot resolve link to InvalidObject from text:")
+      expect(logger).to receive(:warn).ordered.with("...{InvalidObject Some Title}")
+      allow(self).to receive(:log).and_return(logger)
+      allow(self).to receive(:object).and_return(Registry.root)
       resolve_links(<<-eof)
         Hello world
         This is a line
@@ -506,23 +502,24 @@ describe YARD::Templates::Helpers::HtmlHelper do
     end
   end
 
-  describe '#signature' do
+  describe "#signature" do
     before do
+      arrow = "&#x21d2;"
       @results = {
-        :regular => "- (Object) <strong>foo</strong>",
-        :default_return => "- (Hello) <strong>foo</strong>",
-        :no_default_return => "- <strong>foo</strong>",
-        :private_class => "+ (Object) <strong>foo</strong>  <span class=\"extras\">(private)</span>",
-        :single => "- (String) <strong>foo</strong>",
-        :two_types => "- (String, Symbol) <strong>foo</strong>",
-        :two_types_multitag => "- (String, Symbol) <strong>foo</strong>",
-        :type_nil => "- (Type<sup>?</sup>) <strong>foo</strong>",
-        :type_array => "- (Type<sup>+</sup>) <strong>foo</strong>",
-        :multitype => "- (Type, ...) <strong>foo</strong>",
-        :void => "- (void) <strong>foo</strong>",
-        :hide_void => "- <strong>foo</strong>",
-        :block => "- (Object) <strong>foo</strong> {|a, b, c| ... }",
-        :empty_overload => '- (String) <strong>foobar</strong>'
+        :regular => "#<strong>foo</strong> #{arrow} Object",
+        :default_return => "#<strong>foo</strong> #{arrow} Hello",
+        :no_default_return => "#<strong>foo</strong>",
+        :private_class => ".<strong>foo</strong> #{arrow} Object <span class=\"extras\">(private)</span>",
+        :single => "#<strong>foo</strong> #{arrow} String",
+        :two_types => "#<strong>foo</strong> #{arrow} String, Symbol",
+        :two_types_multitag => "#<strong>foo</strong> #{arrow} String, Symbol",
+        :type_nil => "#<strong>foo</strong> #{arrow} Type<sup>?</sup>",
+        :type_array => "#<strong>foo</strong> #{arrow} Type<sup>+</sup>",
+        :multitype => "#<strong>foo</strong> #{arrow} Type, ...",
+        :void => "#<strong>foo</strong> #{arrow} void",
+        :hide_void => "#<strong>foo</strong>",
+        :block => "#<strong>foo</strong> {|a, b, c| ... } #{arrow} Object",
+        :empty_overload => "#<strong>foobar</strong> #{arrow} String"
       }
     end
 
@@ -531,23 +528,23 @@ describe YARD::Templates::Helpers::HtmlHelper do
 
     it_should_behave_like "signature"
 
-    it "should link to regular method if overload name does not have the same method name" do
+    it "links to regular method if overload name does not have the same method name" do
       YARD.parse_string <<-eof
         class Foo
           # @overload bar(a, b, c)
           def foo; end
         end
       eof
-      serializer = mock(:serializer)
-      serializer.stub!(:serialized_path).with(Registry.at('Foo')).and_return('')
-      stub!(:serializer).and_return(serializer)
-      stub!(:object).and_return(Registry.at('Foo'))
-      signature(Registry.at('Foo#foo').tag(:overload), true).should ==
-        "<a href=\"#foo-instance_method\" title=\"#bar (instance method)\">- <strong>bar</strong>(a, b, c) </a>"
+      serializer = double(:serializer)
+      allow(serializer).to receive(:serialized_path).with(Registry.at('Foo')).and_return('')
+      allow(self).to receive(:serializer).and_return(serializer)
+      allow(self).to receive(:object).and_return(Registry.at('Foo'))
+      expect(signature(Registry.at('Foo#foo').tag(:overload), true)).to eq(
+        "<a href=\"#foo-instance_method\" title=\"#bar (instance method)\">#<strong>bar</strong>(a, b, c)  </a>")
     end
   end
 
-  describe '#html_syntax_highlight' do
+  describe "#html_syntax_highlight" do
     subject do
       obj = OpenStruct.new
       obj.options = options
@@ -556,89 +553,89 @@ describe YARD::Templates::Helpers::HtmlHelper do
       obj
     end
 
-    it "should return empty string on nil input" do
-      subject.html_syntax_highlight(nil).should == ''
+    it "returns empty string on nil input" do
+      expect(subject.html_syntax_highlight(nil)).to eq ''
     end
 
-    it "should call #html_syntax_highlight_ruby by default" do
+    it "calls #html_syntax_highlight_ruby by default" do
       Registry.root.source_type = nil
-      subject.should_receive(:html_syntax_highlight_ruby).with('def x; end')
+      expect(subject).to receive(:html_syntax_highlight_ruby).with('def x; end')
       subject.html_syntax_highlight('def x; end')
     end
 
-    it "should call #html_syntax_highlight_NAME if there's an object with a #source_type" do
+    it "calls #html_syntax_highlight_NAME if there's an object with a #source_type" do
       subject.object = OpenStruct.new(:source_type => :NAME)
-      subject.should_receive(:respond_to?).with('html_markup_html').and_return(true)
-      subject.should_receive(:respond_to?).with('html_syntax_highlight_NAME').and_return(true)
-      subject.should_receive(:html_syntax_highlight_NAME).and_return("foobar")
-      subject.htmlify('<pre><code>def x; end</code></pre>', :html).should ==
-        '<pre class="code NAME"><code class="NAME">foobar</code></pre>'
+      expect(subject).to receive(:html_markup_html) { |text| text }
+      expect(subject).to receive(:html_syntax_highlight_NAME).and_return("foobar")
+      expect(subject.htmlify('<pre><code>def x; end</code></pre>', :html)).to eq(
+        '<pre class="code NAME"><code class="NAME">foobar</code></pre>')
     end
 
-    it "should add !!!LANG to className in outputted pre tag" do
+    it "adds !!!LANG to className in outputted pre tag" do
       subject.object = OpenStruct.new(:source_type => :LANG)
-      subject.should_receive(:respond_to?).with('html_markup_html').and_return(true)
-      subject.should_receive(:respond_to?).with('html_syntax_highlight_LANG').and_return(true)
-      subject.should_receive(:html_syntax_highlight_LANG).and_return("foobar")
-      subject.htmlify("<pre><code>!!!LANG\ndef x; end</code></pre>", :html).should ==
-        '<pre class="code LANG"><code class="LANG">foobar</code></pre>'
+      expect(subject).to receive(:html_markup_html) { |text| text }
+      expect(subject).to receive(:html_syntax_highlight_LANG).and_return("foobar")
+      expect(subject.htmlify("<pre><code>!!!LANG\ndef x; end</code></pre>", :html)).to eq(
+        '<pre class="code LANG"><code class="LANG">foobar</code></pre>')
     end
 
-    it "should call html_syntax_highlight_NAME if source starts with !!!NAME" do
-      subject.should_receive(:respond_to?).with('html_syntax_highlight_NAME').and_return(true)
-      subject.should_receive(:html_syntax_highlight_NAME).and_return("foobar")
-      subject.html_syntax_highlight(<<-eof
+    it "calls html_syntax_highlight_NAME if source starts with !!!NAME" do
+      expect(subject).to receive(:html_syntax_highlight_NAME).and_return("foobar")
+      expect(subject.html_syntax_highlight(<<-eof
         !!!NAME
         def x; end
       eof
-      ).should == "foobar"
+      )).to eq "foobar"
     end
 
-    it "should not highlight if highlight option is false" do
+    it "does not highlight if highlight option is false" do
       subject.options.highlight = false
-      subject.should_not_receive(:html_syntax_highlight_ruby)
-      subject.html_syntax_highlight('def x; end').should == 'def x; end'
+      expect(subject).not_to receive(:html_syntax_highlight_ruby)
+      expect(subject.html_syntax_highlight('def x; end')).to eq 'def x; end'
     end
 
-    it "should not highlight if there is no highlight method specified by !!!NAME" do
-      subject.should_receive(:respond_to?).with('html_syntax_highlight_NAME').and_return(false)
-      subject.should_not_receive(:html_syntax_highlight_NAME)
-      subject.html_syntax_highlight("!!!NAME\ndef x; end").should == "def x; end"
+    it "does not highlight if there is no highlight method specified by !!!NAME" do
+      def subject.respond_to?(method, include_all=false)
+        return false if method == 'html_syntax_highlight_NAME'
+        super
+      end
+      expect(subject).not_to receive(:html_syntax_highlight_NAME)
+      expect(subject.html_syntax_highlight("!!!NAME\ndef x; end")).to eq "def x; end"
     end
 
-    it "should highlight as ruby if htmlify(text, :ruby) is called" do
-      subject.should_receive(:html_syntax_highlight_ruby).with('def x; end').and_return('x')
-      subject.htmlify('def x; end', :ruby).should == '<pre class="code ruby">x</pre>'
+    it "highlights as ruby if htmlify(text, :ruby) is called" do
+      expect(subject).to receive(:html_syntax_highlight_ruby).with('def x; end').and_return('x')
+      expect(subject.htmlify('def x; end', :ruby)).to eq '<pre class="code ruby">x</pre>'
     end
 
-    it "should not prioritize object source type when called directly" do
-      subject.should_receive(:html_syntax_highlight_ruby).with('def x; end').and_return('x')
+    it "does not prioritize object source type when called directly" do
+      expect(subject).to receive(:html_syntax_highlight_ruby).with('def x; end').and_return('x')
       subject.object = OpenStruct.new(:source_type => :c)
-      subject.html_syntax_highlight("def x; end").should == "x"
+      expect(subject.html_syntax_highlight("def x; end")).to eq "x"
     end
 
-    it "shouldn't escape code snippets twice" do
-      subject.htmlify('<pre lang="foo"><code>{"foo" => 1}</code></pre>', :html).should ==
-        '<pre class="code foo"><code class="foo">{&quot;foo&quot; =&gt; 1}</code></pre>'
+    it "doesn't escape code snippets twice" do
+      expect(subject.htmlify('<pre lang="foo"><code>{"foo" => 1}</code></pre>', :html)).to eq(
+        '<pre class="code foo"><code class="foo">{&quot;foo&quot; =&gt; 1}</code></pre>')
     end
 
-    it "should highlight source when matching a pre lang= tag" do
-      subject.htmlify('<pre lang="foo"><code>x = 1</code></pre>', :html).should ==
-        '<pre class="code foo"><code class="foo">x = 1</code></pre>'
+    it "highlights source when matching a pre lang= tag" do
+      expect(subject.htmlify('<pre lang="foo"><code>x = 1</code></pre>', :html)).to eq(
+        '<pre class="code foo"><code class="foo">x = 1</code></pre>')
     end
 
-    it "should highlight source when matching a code class= tag" do
-      subject.htmlify('<pre><code class="foo">x = 1</code></pre>', :html).should ==
-        '<pre class="code foo"><code class="foo">x = 1</code></pre>'
+    it "highlights source when matching a code class= tag" do
+      expect(subject.htmlify('<pre><code class="foo">x = 1</code></pre>', :html)).to eq(
+        '<pre class="code foo"><code class="foo">x = 1</code></pre>')
     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")
+  describe "#link_url" do
+    it "adds target if scheme is provided" do
+      expect(link_url("http://url.com")).to include(" target=\"_parent\"")
+      expect(link_url("https://url.com")).to include(" target=\"_parent\"")
+      expect(link_url("irc://url.com")).to include(" target=\"_parent\"")
+      expect(link_url("../not/scheme")).not_to include("target")
     end
   end
 end