yard 0.8.7.6 → 0.9.0

data/spec/tags/library_spec.rb

@@ -5,30 +5,30 @@ describe YARD::Tags::Library do
     Docstring.new(docstring).tags.first
   end
 
-  describe '#see_tag' do
-    it "should take a URL" do
-      tag("@see http://example.com").name.should == "http://example.com"
+  describe "#see_tag" do
+    it "takes a URL" do
+      expect(tag("@see http://example.com").name).to eq "http://example.com"
     end
 
-    it "should take an object path" do
-      tag("@see String#reverse").name.should == "String#reverse"
+    it "takes an object path" do
+      expect(tag("@see String#reverse").name).to eq "String#reverse"
     end
 
-    it "should take a description after the url/object" do
+    it "takes a description after the url/object" do
       tag = tag("@see http://example.com An Example Site")
-      tag.name.should == "http://example.com"
-      tag.text.should == "An Example Site"
+      expect(tag.name).to eq "http://example.com"
+      expect(tag.text).to eq "An Example Site"
     end
   end
 
-  describe '.define_tag' do
-    it "should allow defining tags with '.' in the name (x.y.z defines method x_y_z)" do
+  describe ".define_tag" do
+    it "allows defining tags with '.' in the name (x.y.z defines method x_y_z)" do
       Tags::Library.define_tag("foo", 'x.y.z')
       Tags::Library.define_tag("foo2", 'x.y.zz', Tags::OverloadTag)
-      Tags::Library.instance.method(:x_y_z_tag).should_not be_nil
-      Tags::Library.instance.method(:x_y_zz_tag).should_not be_nil
-      tag('@x.y.z foo bar').text.should == 'foo bar'
-      tag('@x.y.zz foo(bar)').signature.should == 'foo(bar)'
+      expect(Tags::Library.instance.method(:x_y_z_tag)).not_to be nil
+      expect(Tags::Library.instance.method(:x_y_zz_tag)).not_to be nil
+      expect(tag('@x.y.z foo bar').text).to eq 'foo bar'
+      expect(tag('@x.y.zz foo(bar)').signature).to eq 'foo(bar)'
     end
   end
 end

data/spec/tags/overload_tag_spec.rb

@@ -10,44 +10,44 @@ describe YARD::Tags::OverloadTag do
     eof
   end
 
-  it "should parse the first line as a method signature" do
-    @tag.signature.should == "def bar(a, b = 1, &block)"
-    @tag.parameters.should == [['a', nil], ['b', "1"], ['&block', nil]]
+  it "parses the first line as a method signature" do
+    expect(@tag.signature).to eq "def bar(a, b = 1, &block)"
+    expect(@tag.parameters).to eq [['a', nil], ['b', "1"], ['&block', nil]]
   end
 
-  it "should parse the rest of the text as a new Docstring" do
-    @tag.docstring.should be_instance_of(Docstring)
-    @tag.docstring.should == "Hello world"
+  it "parses the rest of the text as a new Docstring" do
+    expect(@tag.docstring).to be_instance_of(Docstring)
+    expect(@tag.docstring).to eq "Hello world"
   end
 
-  it "should set Docstring's object after #object= is called" do
-    m = mock(:object)
+  it "sets Docstring's object after #object= is called" do
+    m = double(:object)
     @tag.object = m
-    @tag.docstring.object.should == m
+    expect(@tag.docstring.object).to eq m
   end
 
-  it "should respond to #tag, #tags and #has_tag?" do
-    @tag.object = mock(:object)
-    @tag.tags.size.should == 2
-    @tag.tag(:param).name.should == "a"
-    @tag.has_tag?(:return).should == true
+  it "responds to #tag, #tags and #has_tag?" do
+    @tag.object = double(:object)
+    expect(@tag.tags.size).to eq 2
+    expect(@tag.tag(:param).name).to eq "a"
+    expect(@tag.has_tag?(:return)).to be true
   end
 
-  it "should not be a CodeObjects::Base when not hooked up to an object" do
+  it "is not a CodeObjects::Base when not hooked up to an object" do
     @tag.object = nil
-    @tag.is_a?(CodeObjects::Base).should == false
+    expect(@tag.is_a?(CodeObjects::Base)).to be false
   end
 
-  it "should be a CodeObjects::Base when hooked up to an object" do
-    @tag.object = mock(:object)
-    @tag.object.should_receive(:is_a?).at_least(3).times.with(CodeObjects::Base).and_return(true)
-    @tag.is_a?(CodeObjects::Base).should == true
-    @tag.kind_of?(CodeObjects::Base).should == true
-    (CodeObjects::Base === @tag).should == true
+  it "is a CodeObjects::Base when hooked up to an object" do
+    @tag.object = double(:object)
+    expect(@tag.object).to receive(:is_a?).at_least(3).times.with(CodeObjects::Base).and_return(true)
+    expect(@tag.is_a?(CodeObjects::Base)).to be true
+    expect(@tag.kind_of?(CodeObjects::Base)).to be true
+    expect(CodeObjects::Base === @tag).to be true
   end
 
-  it "should not parse 'def' out of method name" do
+  it "does not parse 'def' out of method name" do
     tag = Tags::OverloadTag.new(:overload, "default")
-    tag.signature.should == "default"
+    expect(tag.signature).to eq "default"
   end
 end

data/spec/tags/ref_tag_list_spec.rb

@@ -3,27 +3,27 @@ require File.dirname(__FILE__) + '/../spec_helper'
 describe YARD::Tags::RefTagList do
   before { YARD::Registry.clear }
 
-  it "should accept symbol or string as owner's path and convert it into a proxy" do
+  it "accepts symbol or string as owner's path and convert it into a proxy" do
     t = Tags::RefTagList.new('author', :String)
-    t.owner.should == P(:String)
+    expect(t.owner).to eq P(:String)
   end
 
-  it "should accept proxy object as owner" do
+  it "accepts proxy object as owner" do
     t = Tags::RefTagList.new('author', P(:String))
-    t.owner.should == P(:String)
+    expect(t.owner).to eq P(:String)
   end
 
-  it "should return tags from a proxy object" do
+  it "returns tags from a proxy object" do
     o = CodeObjects::ClassObject.new(:root, :String)
     t = Tags::Tag.new(:author, 'foo')
     o.docstring.add_tag(t)
 
     ref = Tags::RefTagList.new('author', :String)
-    ref.tags.should == [t]
-    ref.tags.first.text.should == 'foo'
+    expect(ref.tags).to eq [t]
+    expect(ref.tags.first.text).to eq 'foo'
   end
 
-  it "should return named tags from a proxy object" do
+  it "returns named tags from a proxy object" do
     o = CodeObjects::ClassObject.new(:root, :String)
     p1 = Tags::Tag.new(:param, 'bar1', nil, 'foo')
     p2 = Tags::Tag.new(:param, 'bar2', nil, 'foo')
@@ -32,8 +32,8 @@ describe YARD::Tags::RefTagList do
     o.docstring.add_tag(p1, t1, p2, p3)
 
     ref = Tags::RefTagList.new('param', :String, 'foo')
-    ref.tags.should == [p1, p2]
-    ref.tags.first.text.should == 'bar1'
+    expect(ref.tags).to eq [p1, p2]
+    expect(ref.tags.first.text).to eq 'bar1'
   end
 
   it "all tags should respond to #owner and be a RefTag" do
@@ -46,8 +46,8 @@ describe YARD::Tags::RefTagList do
 
     ref = Tags::RefTagList.new('param', :String)
     ref.tags.each do |t|
-      t.should be_kind_of(Tags::RefTag)
-      t.owner.should == o
+      expect(t).to be_kind_of(Tags::RefTag)
+      expect(t.owner).to eq o
     end
   end
 end

data/spec/templates/class_spec.rb

@@ -30,15 +30,15 @@ describe YARD::Templates::Engine.template(:default, :docstring) do
     eof
   end
 
-  it "should render html format correctly" do
+  it "renders html format correctly" do
     html_equals(Registry.at('A').format(html_options), :class001)
   end
 
-  it "should render text format correctly" do
+  it "renders text format correctly" do
     text_equals(Registry.at('A').format, :class001)
   end
 
-  it "should hide private constructors" do
+  it "hides private constructors" do
     html_equals(Registry.at('D').format(html_options(:verifier => Verifier.new("!@private"))), :class002)
   end
 end

data/spec/templates/constant_spec.rb

@@ -1,8 +1,8 @@
 require File.dirname(__FILE__) + "/spec_helper"
 
 describe YARD::Templates::Engine.template(:default, :constant) do
-  describe 'fully dressed constant' do
-    it "should render text format correctly" do
+  describe "fully dressed constant" do
+    it "renders text format correctly" do
       YARD.parse_string <<-'eof'
         class YARD::CLI::YRI
           # Default search paths that should be loaded dynamically into YRI. These paths
@@ -20,8 +20,8 @@ describe YARD::Templates::Engine.template(:default, :constant) do
     end
   end
 
-  describe 'simple constant with no documentation' do
-    it "should render text format correctly" do
+  describe "simple constant with no documentation" do
+    it "renders text format correctly" do
       # Short constant should show on single line
       YARD.parse_string <<-'eof'
         MYCONST = 'foo'

data/spec/templates/engine_spec.rb

@@ -1,84 +1,84 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
 describe YARD::Templates::Engine do
-  describe '.register_template_path' do
-    it "should register a String path" do
+  describe ".register_template_path" do
+    it "registers a String path" do
       Engine.register_template_path('.')
-      Engine.template_paths.pop.should == '.'
+      expect(Engine.template_paths.pop).to eq '.'
     end
   end
 
-  describe '.template!' do
-    it "should create a module including Template" do
+  describe ".template!" do
+    it "creates a module including Template" do
       mod = Engine.template!('path/to/template')
-      mod.should include(Template)
-      mod.full_path.to_s.should == 'path/to/template'
+      expect(mod).to include(Template)
+      expect(mod.full_path.to_s).to eq 'path/to/template'
     end
 
-    it "should create a module including Template with full_path" do
+    it "creates a module including Template with full_path" do
       mod = Engine.template!('path/to/template2', '/full/path/to/template2')
-      mod.should include(Template)
-      mod.full_path.to_s.should == '/full/path/to/template2'
+      expect(mod).to include(Template)
+      expect(mod.full_path.to_s).to eq '/full/path/to/template2'
     end
   end
 
-  describe '.template' do
-    it "should raise an error if the template is not found" do
-      lambda { Engine.template(:a, :b, :c) }.should raise_error(ArgumentError)
+  describe ".template" do
+    it "raises an error if the template is not found" do
+      expect { Engine.template(:a, :b, :c) }.to raise_error(ArgumentError)
     end
 
-    it "should create a module including Template" do
-      mock = mock(:template)
-      Engine.should_receive(:find_template_paths).with(nil, 'template/name').and_return(['/full/path/template/name'])
-      Engine.should_receive(:template!).with('template/name', ['/full/path/template/name']).and_return(mock)
-      Engine.template('template/name').should == mock
+    it "creates a module including Template" do
+      mock = double(:template)
+      expect(Engine).to receive(:find_template_paths).with(nil, 'template/name').and_return(['/full/path/template/name'])
+      expect(Engine).to receive(:template!).with('template/name', ['/full/path/template/name']).and_return(mock)
+      expect(Engine.template('template/name')).to eq mock
     end
 
-    it "should create a Template from a relative Template path" do
-      Engine.should_receive(:template_paths).and_return([])
-      File.should_receive(:directory?).with("/full/path/template/notname").and_return(true)
-      start_template = mock(:start_template)
-      start_template.stub!(:full_path).and_return('/full/path/template/name')
-      start_template.stub!(:full_paths).and_return(['/full/path/template/name'])
-      start_template.should_receive(:is_a?).with(Template).and_return(true)
+    it "creates a Template from a relative Template path" do
+      expect(Engine).to receive(:template_paths).and_return([])
+      expect(File).to receive(:directory?).with("/full/path/template/notname").and_return(true)
+      start_template = double(:start_template,
+        :full_path  => '/full/path/template/name',
+        :full_paths => ['/full/path/template/name'])
+      expect(start_template).to receive(:is_a?).with(Template).and_return(true)
       mod = Engine.template(start_template, '..', 'notname')
-      mod.should include(Template)
-      mod.full_path.to_s.should == "/full/path/template/notname"
+      expect(mod).to include(Template)
+      expect(mod.full_path.to_s).to eq "/full/path/template/notname"
     end
 
-    it "should create a Template including other matching templates in path" do
+    it "creates a Template including other matching templates in path" do
       paths = ['/full/path/template/name', '/full/path2/template/name']
-      Engine.should_receive(:find_template_paths).with(nil, 'template').at_least(1).times.and_return([])
-      Engine.should_receive(:find_template_paths).with(nil, 'template/name').and_return(paths)
+      expect(Engine).to receive(:find_template_paths).with(nil, 'template').at_least(1).times.and_return([])
+      expect(Engine).to receive(:find_template_paths).with(nil, 'template/name').and_return(paths)
       ancestors = Engine.template('template/name').ancestors.map {|m| m.class_name }
-      ancestors.should include("Template__full_path2_template_name")
+      expect(ancestors).to include("Template__full_path2_template_name")
     end
 
-    it "should include parent directories before other template paths" do
+    it "includes parent directories before other template paths" do
       paths = ['/full/path/template/name', '/full/path2/template/name']
-      Engine.should_receive(:find_template_paths).with(nil, 'template/name').and_return(paths)
+      expect(Engine).to receive(:find_template_paths).with(nil, 'template/name').and_return(paths)
       ancestors = Engine.template('template/name').ancestors.map {|m| m.class_name }
-      ancestors[0, 4].should == ["Template__full_path_template_name", "Template__full_path_template",
+      expect(ancestors[0, 4]).to eq ["Template__full_path_template_name", "Template__full_path_template",
         "Template__full_path2_template_name", "Template__full_path2_template"]
     end
   end
 
-  describe '.generate' do
-    it "should generate with fulldoc template" do
-      mod = mock(:template)
+  describe ".generate" do
+    it "generates with fulldoc template" do
+      mod = double(:template)
       options = TemplateOptions.new
       options.reset_defaults
       options.objects = [:a, :b, :c]
       options.object = Registry.root
-      mod.should_receive(:run).with(options)
-      Engine.should_receive(:template).with(:default, :fulldoc, :text).and_return(mod)
+      expect(mod).to receive(:run).with(options)
+      expect(Engine).to receive(:template).with(:default, :fulldoc, :text).and_return(mod)
       Engine.generate([:a, :b, :c])
     end
   end
 
-  describe '.render' do
+  describe ".render" do
     def loads_template(*args)
-      Engine.should_receive(:template).with(*args).and_return(@template)
+      expect(Engine).to receive(:template).with(*args).and_return(@template)
     end
 
     before(:all) do
@@ -90,29 +90,28 @@ describe YARD::Templates::Engine do
       @options.reset_defaults
       @options.object = @object
       @options.type = @object.type
-      @template = mock(:template)
-      @template.stub!(:include)
-      @template.should_receive(:run).with(@options)
+      @template = double(:template, :include => nil)
+      expect(@template).to receive(:run).with(@options)
     end
 
-    it "should accept method call with no parameters" do
+    it "accepts method call with no parameters" do
       loads_template(:default, :method, :text)
       @object.format
     end
 
-    it "should allow template key to be changed" do
+    it "allows template key to be changed" do
       loads_template(:javadoc, :method, :text)
       @options.template = :javadoc
       @object.format(:template => :javadoc)
     end
 
-    it "should allow type key to be changed" do
+    it "allows type key to be changed" do
       loads_template(:default, :fulldoc, :text)
       @options.type = :fulldoc
       @object.format(:type => :fulldoc)
     end
 
-    it "should allow format key to be changed" do
+    it "allows format key to be changed" do
       loads_template(:default, :method, :html)
       @options.format = :html
       @object.format(:format => :html)

data/spec/templates/examples/class001.html

@@ -1,38 +1,44 @@
 <h1>Class: A
   <span class="abstract note title">Abstract</span>
-
+  
+  
 </h1>
-
-<dl class="box">
-
-    <dt class="r1">Inherits:</dt>
-    <dd class="r1">
+<div class="box_info">
+  
+  <dl>
+    <dt>Inherits:</dt>
+    <dd>
       <span class="inheritName">B</span>
-
+      
         <ul class="fullTree">
           <li>Object</li>
-
+          
             <li class="next">B</li>
-
+          
             <li class="next">A</li>
-
+          
         </ul>
         <a href="#" class="inheritanceTree">show all</a>
-
-      </dd>
-
-
-
-
-
-
-
-
-    <dt class="r2 last">Defined in:</dt>
-    <dd class="r2 last">(stdin)</dd>
-
-</dl>
-<div class="clear"></div>
+      
+    </dd>
+  </dl>
+  
+
+  
+  
+  
+  
+  
+
+  
+
+  
+  <dl>
+    <dt>Defined in:</dt>
+    <dd>(stdin)</dd>
+  </dl>
+  
+</div>
 
 <h2>Overview</h2><div class="docstring">
   <div class="discussion">
@@ -45,42 +51,43 @@ Comments
   </div>
 </div>
 <div class="tags">
+  
 
   <p class="tag_title">See Also:</p>
   <ul class="see">
-
+    
       <li>A</li>
-
+    
       <li><a href="http://example.com" target="_parent" title="Example">Example</a></li>
-
+    
   </ul>
 <p class="tag_title">Author:</p>
 <ul class="author">
-
+  
     <li>
-
-
-
-
-
+      
+      
+      
+      
+        
         <div class='inline'>Test</div>
-
+      
     </li>
-
+  
 </ul>
 <p class="tag_title">Version:</p>
 <ul class="version">
-
+  
     <li>
-
-
-
-
-
+      
+      
+      
+      
+        
         <div class='inline'>1.0</div>
-
+      
     </li>
-
+  
 </ul>
 
 </div><div id="subclasses">
@@ -92,86 +99,100 @@ Comments
 
 
 
-    <h2>Instance Method Summary <small>(<a href="#" class="summary_toggle">collapse</a>)</small></h2>
 
-    <ul class="summary">
 
+  
+    <h2>
+      Instance Method Summary
+      <small><a href="#" class="summary_toggle">collapse</a></small>
+    </h2>
+
+    <ul class="summary">
+      
         <li class="public deprecated">
   <span class="summary_signature">
+    
+      <a  title="#a (instance method)">#<strong>a</strong>  </a>
+    
 
-      <a  title="#a (instance method)">- <strong>a</strong> </a>
-
-
-
+    
   </span>
-
-
-
-
+  
+  
+  
+  
+  
   <span class="deprecated note title">deprecated</span>
+  
 
-
+  
     <span class="summary_desc"><strong>Deprecated.</strong> <div class='inline'></div></span>
-
+  
 </li>
 
-
+      
         <li class="public ">
   <span class="summary_signature">
+    
+      <a  title="#initialize (instance method)">#<strong>initialize</strong>(test)  &#x21d2; A </a>
+    
 
-      <a  title="#initialize (instance method)">- (A) <strong>initialize</strong>(test) </a>
-
-
-
+    
   </span>
-
+  
+  
     <span class="note title constructor">constructor</span>
-
-
-
-
-
-
-
+  
+  
+  
+  
+  
+  
+
+  
     <span class="summary_desc"><div class='inline'>constructor method!.</div></span>
-
+  
 </li>
 
-
+      
         <li class="public ">
   <span class="summary_signature">
+    
+      <a  title="#method_missing (instance method)">#<strong>method_missing</strong>(*args)  </a>
+    
 
-      <a  title="#method_missing (instance method)">- <strong>method_missing</strong>(*args) </a>
-
-
-
+    
   </span>
-
-
-
-
-
-
-
+  
+  
+  
+  
+  
+  
+  
+
+  
     <span class="summary_desc"><div class='inline'>HI.</div></span>
-
+  
 </li>
 
-
+      
     </ul>
-
+  
 
 
   <div id="constructor_details" class="method_details_list">
   <h2>Constructor Details</h2>
-
+  
     <div class="method_details first">
   <h3 class="signature first" id="initialize-instance_method">
+  
+    #<strong>initialize</strong>(test)  &#x21d2; <tt>A</tt> 
+  
 
-    - (<tt>A</tt>) <strong>initialize</strong>(test)
-
-
+  
 
+  
 </h3><div class="docstring">
   <div class="discussion">
     constructor method!
@@ -179,6 +200,7 @@ Comments
   </div>
 </div>
 <div class="tags">
+  
 
 </div><table class="source_code">
   <tr>
@@ -196,22 +218,24 @@ def initialize(test) end</pre>
   </tr>
 </table>
 </div>
-
+  
 </div>
 <div id="method_missing_details" class="method_details_list">
   <h2>Dynamic Method Handling</h2>
   <p class="notice this">
     This class handles dynamic methods through the <tt>method_missing</tt> method
-
+    
   </p>
-
+  
     <div class="method_details first">
   <h3 class="signature first" id="method_missing-instance_method">
+  
+    #<strong>method_missing</strong>(*args)  
+  
 
-    - <strong>method_missing</strong>(*args)
-
-
+  
 
+  
 </h3><div class="docstring">
   <div class="discussion">
     HI
@@ -219,6 +243,7 @@ def initialize(test) end</pre>
   </div>
 </div>
 <div class="tags">
+  
 
 </div><table class="source_code">
   <tr>
@@ -236,21 +261,23 @@ def method_missing(*args) end</pre>
   </tr>
 </table>
 </div>
-
+  
 </div>
 
 
   <div id="instance_method_details" class="method_details_list">
     <h2>Instance Method Details</h2>
 
-
+    
       <div class="method_details first">
   <h3 class="signature first" id="a-instance_method">
+  
+    #<strong>a</strong>  
+  
 
-    - <strong>a</strong>
-
-
+  
 
+  
 </h3><div class="docstring">
   <div class="discussion">
     <div class="note deprecated"><strong>Deprecated.</strong> <div class='inline'></div></div>
@@ -259,6 +286,7 @@ def method_missing(*args) end</pre>
   </div>
 </div>
 <div class="tags">
+  
 
 </div><table class="source_code">
   <tr>
@@ -276,5 +304,5 @@ def a; end</pre>
   </tr>
 </table>
 </div>
-
+    
   </div>