yard 0.8.7.6 → 0.9.0

data/spec/cli/yri_spec.rb

@@ -9,89 +9,89 @@ end
 describe YARD::CLI::YRI do
   before do
     @yri = TestYRI.new
-    Registry.stub!(:load)
+    allow(Registry).to receive(:load)
   end
 
-  describe '#find_object' do
-    it "should use cache if available" do
-      @yri.stub!(:cache_object)
-      File.should_receive(:exist?).with('.yardoc').and_return(false)
-      File.should_receive(:exist?).with('bar.yardoc').and_return(true)
-      Registry.should_receive(:load).with('bar.yardoc')
-      Registry.should_receive(:at).ordered.with('Foo').and_return(nil)
-      Registry.should_receive(:at).ordered.with('Foo').and_return('OBJ')
+  describe "#find_object" do
+    it "uses cache if available" do
+      allow(@yri).to receive(:cache_object)
+      expect(File).to receive(:exist?).with('.yardoc').and_return(false)
+      expect(File).to receive(:exist?).with('bar.yardoc').and_return(true)
+      expect(Registry).to receive(:load).with('bar.yardoc')
+      expect(Registry).to receive(:at).ordered.with('Foo').and_return(nil)
+      expect(Registry).to receive(:at).ordered.with('Foo').and_return('OBJ')
       @yri.instance_variable_set("@cache", {'Foo' => 'bar.yardoc'})
-      @yri.find_object('Foo').should == 'OBJ'
+      expect(@yri.find_object('Foo')).to eq 'OBJ'
     end
 
-    it "should never use cache ahead of current directory's .yardoc" do
-      @yri.stub!(:cache_object)
-      File.should_receive(:exist?).with('.yardoc').and_return(true)
-      Registry.should_receive(:load).with('.yardoc')
-      Registry.should_receive(:at).ordered.with('Foo').and_return(nil)
-      Registry.should_receive(:at).ordered.with('Foo').and_return('OBJ')
+    it "never uses cache ahead of current directory's .yardoc" do
+      allow(@yri).to receive(:cache_object)
+      expect(File).to receive(:exist?).with('.yardoc').and_return(true)
+      expect(Registry).to receive(:load).with('.yardoc')
+      expect(Registry).to receive(:at).ordered.with('Foo').and_return(nil)
+      expect(Registry).to receive(:at).ordered.with('Foo').and_return('OBJ')
       @yri.instance_variable_set("@cache", {'Foo' => 'bar.yardoc'})
-      @yri.find_object('Foo').should == 'OBJ'
-      @yri.instance_variable_get("@search_paths")[0].should == '.yardoc'
+      expect(@yri.find_object('Foo')).to eq 'OBJ'
+      expect(@yri.instance_variable_get("@search_paths")[0]).to eq '.yardoc'
     end
   end
 
-  describe '#cache_object' do
-    it "should skip caching for Registry.yardoc_file" do
-      File.should_not_receive(:open).with(CLI::YRI::CACHE_FILE, 'w')
+  describe "#cache_object" do
+    it "skips caching for Registry.yardoc_file" do
+      expect(File).not_to receive(:open).with(CLI::YRI::CACHE_FILE, 'w')
       @yri.cache_object('Foo', Registry.yardoc_file)
     end
   end
 
-  describe '#initialize' do
-    it "should load search paths" do
+  describe "#initialize" do
+    it "loads search paths" do
       path = %r{/\.yard/yri_search_paths$}
-      File.should_receive(:file?).with(%r{/\.yard/yri_cache$}).and_return(false)
-      File.should_receive(:file?).with(path).and_return(true)
-      File.should_receive(:readlines).with(path).and_return(%w(line1 line2))
+      expect(File).to receive(:file?).with(%r{/\.yard/yri_cache$}).and_return(false)
+      expect(File).to receive(:file?).with(path).and_return(true)
+      expect(File).to receive(:readlines).with(path).and_return(%w(line1 line2))
       @yri = YARD::CLI::YRI.new
       spaths = @yri.instance_variable_get("@search_paths")
-      spaths.should include('line1')
-      spaths.should include('line2')
+      expect(spaths).to include('line1')
+      expect(spaths).to include('line2')
     end
 
-    it "should use DEFAULT_SEARCH_PATHS prior to other paths" do
+    it "uses DEFAULT_SEARCH_PATHS prior to other paths" do
       YARD::CLI::YRI::DEFAULT_SEARCH_PATHS.push('foo', 'bar')
       path = %r{/\.yard/yri_search_paths$}
-      File.should_receive(:file?).with(%r{/\.yard/yri_cache$}).and_return(false)
-      File.should_receive(:file?).with(path).and_return(true)
-      File.should_receive(:readlines).with(path).and_return(%w(line1 line2))
+      expect(File).to receive(:file?).with(%r{/\.yard/yri_cache$}).and_return(false)
+      expect(File).to receive(:file?).with(path).and_return(true)
+      expect(File).to receive(:readlines).with(path).and_return(%w(line1 line2))
       @yri = YARD::CLI::YRI.new
       spaths = @yri.instance_variable_get("@search_paths")
-      spaths[0,4].should == %w(foo bar line1 line2)
+      expect(spaths[0,4]).to eq %w(foo bar line1 line2)
       YARD::CLI::YRI::DEFAULT_SEARCH_PATHS.replace([])
     end
   end
 
-  describe '#run' do
-    it "should search for objects and print their documentation" do
+  describe "#run" do
+    it "searches for objects and print their documentation" do
       obj = YARD::CodeObjects::ClassObject.new(:root, 'Foo')
-      @yri.should_receive(:print_object).with(obj)
+      expect(@yri).to receive(:print_object).with(obj)
       @yri.run('Foo')
       Registry.clear
     end
 
-    it "should print usage if no object is provided" do
-      @yri.should_receive(:print_usage)
-      @yri.should_receive(:exit).with(1)
+    it "prints usage if no object is provided" do
+      expect(@yri).to receive(:print_usage)
+      expect(@yri).to receive(:exit).with(1)
       @yri.run('')
     end
 
-    it "should print no documentation exists for object if object is not found" do
-      STDERR.should_receive(:puts).with("No documentation for `Foo'")
-      @yri.should_receive(:exit).with(1)
+    it "prints 'no documentation exists for object' if object is not found" do
+      expect(STDERR).to receive(:puts).with("No documentation for `Foo'")
+      expect(@yri).to receive(:exit).with(1)
       @yri.run('Foo')
     end
 
-    it "should ensure output is serialized" do
+    it "ensures output is serialized" do
       obj = YARD::CodeObjects::ClassObject.new(:root, 'Foo')
-      class << @yri
-        def test_stub; @serializer.should_receive(:serialize).once end
+      allow(@yri).to receive(:test_stub) do
+        expect(@yri.instance_variable_get(:@serializer)).to receive(:serialize).once
       end
       @yri.run('Foo')
     end

data/spec/code_objects/base_spec.rb

@@ -3,47 +3,46 @@ require File.dirname(__FILE__) + '/spec_helper'
 describe YARD::CodeObjects::Base do
   before { Registry.clear }
 
-  # Fix this
-  # it "should not allow empty object name" do
-  #   lambda { Base.new(:root, '') }.should raise_error(ArgumentError)
-  # end
+  it "does not allow empty object name" do
+    expect { Base.new(:root, '') }.to raise_error(ArgumentError)
+  end
 
-  it "should return a unique instance of any registered object" do
+  it "returns a unique instance of any registered object" do
     obj = ClassObject.new(:root, :Me)
     obj2 = ClassObject.new(:root, :Me)
-    obj.object_id.should == obj2.object_id
+    expect(obj.object_id).to eq obj2.object_id
 
     obj3 = ModuleObject.new(obj, :Too)
     obj4 = CodeObjects::Base.new(obj3, :Hello)
     obj4.parent = obj
 
     obj5 = CodeObjects::Base.new(obj3, :hello)
-    obj4.object_id.should_not == obj5.object_id
+    expect(obj4.object_id).not_to eq obj5.object_id
   end
 
-  it "should create a new object if cached object is not of the same class" do
-    ConstantObject.new(:root, "MYMODULE").should be_instance_of(ConstantObject)
-    ModuleObject.new(:root, "MYMODULE").should be_instance_of(ModuleObject)
-    ClassObject.new(:root, "MYMODULE").should be_instance_of(ClassObject)
-    YARD::Registry.at("MYMODULE").should be_instance_of(ClassObject)
+  it "creates a new object if cached object is not of the same class" do
+    expect(ConstantObject.new(:root, "MYMODULE")).to be_instance_of(ConstantObject)
+    expect(ModuleObject.new(:root, "MYMODULE")).to be_instance_of(ModuleObject)
+    expect(ClassObject.new(:root, "MYMODULE")).to be_instance_of(ClassObject)
+    expect(YARD::Registry.at("MYMODULE")).to be_instance_of(ClassObject)
   end
 
-  it "should simplify complex namespace paths" do
+  it "simplifies complex namespace paths" do
     obj = ClassObject.new(:root, "A::B::C::D")
-    obj.name.should == :D
-    obj.path.should == "A::B::C::D"
-    obj.namespace.should == P("A::B::C")
+    expect(obj.name).to eq :D
+    expect(obj.path).to eq "A::B::C::D"
+    expect(obj.namespace).to eq P("A::B::C")
   end
 
   # @bug gh-552
-  it "should simplify complex namespace paths when path starts with ::" do
+  it "simplifies complex namespace paths when path starts with ::" do
     obj = ClassObject.new(:root, "::A::B::C::D")
-    obj.name.should == :D
-    obj.path.should == "A::B::C::D"
-    obj.namespace.should == P("A::B::C")
+    expect(obj.name).to eq :D
+    expect(obj.path).to eq "A::B::C::D"
+    expect(obj.namespace).to eq P("A::B::C")
   end
 
-  it "should recall the block if #new is called on an existing object" do
+  it "calls the block again if #new is called on an existing object" do
     o1 = ClassObject.new(:root, :Me) do |o|
       o.docstring = "DOCSTRING"
     end
@@ -52,74 +51,76 @@ describe YARD::CodeObjects::Base do
       o.docstring = "NOT_DOCSTRING"
     end
 
-    o1.object_id.should == o2.object_id
-    o1.docstring.should == "NOT_DOCSTRING"
-    o2.docstring.should == "NOT_DOCSTRING"
+    expect(o1.object_id).to eq o2.object_id
+    expect(o1.docstring).to eq "NOT_DOCSTRING"
+    expect(o2.docstring).to eq "NOT_DOCSTRING"
   end
 
-  it "should allow complex name and convert that to namespace" do
+  it "allows complex name and converts it to namespace" do
     obj = CodeObjects::Base.new(nil, "A::B")
-    obj.namespace.path.should == "A"
-    obj.name.should == :B
+    expect(obj.namespace.path).to eq "A"
+    expect(obj.name).to eq :B
   end
 
-  it "should allow namespace to be nil and not register in the Registry" do
+  it "allows namespace to be nil and not register in the Registry" do
     obj = CodeObjects::Base.new(nil, :Me)
-    obj.namespace.should == nil
-    Registry.at(:Me).should == nil
+    expect(obj.namespace).to eq nil
+    expect(Registry.at(:Me)).to eq nil
   end
 
-  it "should allow namespace to be a NamespaceObject" do
+  it "allows namespace to be a NamespaceObject" do
     ns = ModuleObject.new(:root, :Name)
     obj = CodeObjects::Base.new(ns, :Me)
-    obj.namespace.should == ns
+    expect(obj.namespace).to eq ns
   end
 
-  it "should allow :root to be the shorthand namespace of `Registry.root`" do
+  it "allows :root to be the shorthand namespace of `Registry.root`" do
     obj = CodeObjects::Base.new(:root, :Me)
-    obj.namespace.should == Registry.root
+    expect(obj.namespace).to eq Registry.root
   end
 
-  it "should not allow any other types as namespace" do
-    lambda { CodeObjects::Base.new("ROOT!", :Me) }.should raise_error(ArgumentError)
+  it "does not allow any other types as namespace" do
+    expect { CodeObjects::Base.new("ROOT!", :Me) }.to raise_error(ArgumentError)
   end
 
-  it "should register itself in the registry if namespace is supplied" do
+  it "registers itself in the registry if namespace is supplied" do
     obj = ModuleObject.new(:root, :Me)
-    Registry.at(:Me).should == obj
+    expect(Registry.at(:Me)).to eq obj
 
     obj2 = ModuleObject.new(obj, :Too)
-    Registry.at(:"Me::Too").should == obj2
+    expect(Registry.at(:"Me::Too")).to eq obj2
   end
 
-  it "should set any attribute using #[]=" do
-    obj = ModuleObject.new(:root, :YARD)
-    obj[:some_attr] = "hello"
-    obj[:some_attr].should == "hello"
-  end
+  describe "#[]=" do
+    it "sets any attribute" do
+      obj = ModuleObject.new(:root, :YARD)
+      obj[:some_attr] = "hello"
+      expect(obj[:some_attr]).to eq "hello"
+    end
 
-  it "#[]= should use the accessor method if available" do
-    obj = CodeObjects::Base.new(:root, :YARD)
-    obj[:source] = "hello"
-    obj.source.should == "hello"
-    obj.source = "unhello"
-    obj[:source].should == "unhello"
+    it "uses the accessor method if available" do
+      obj = CodeObjects::Base.new(:root, :YARD)
+      obj[:source] = "hello"
+      expect(obj.source).to eq "hello"
+      obj.source = "unhello"
+      expect(obj[:source]).to eq "unhello"
+    end
   end
 
-  it "should set attributes via attr= through method_missing" do
+  it "sets attributes via attr= through method_missing" do
     obj = CodeObjects::Base.new(:root, :YARD)
     obj.something = 2
-    obj.something.should == 2
-    obj[:something].should == 2
+    expect(obj.something).to eq 2
+    expect(obj[:something]).to eq 2
   end
 
-  it "should exist in the parent's #children after creation" do
+  it "exists in the parent's #children after creation" do
     obj = ModuleObject.new(:root, :YARD)
     obj2 = MethodObject.new(obj, :testing)
-    obj.children.should include(obj2)
+    expect(obj.children).to include(obj2)
   end
 
-  it "should properly re-indent source starting from 0 indentation" do
+  it "properly re-indents source starting from 0 indentation" do
     obj = CodeObjects::Base.new(nil, :test)
     obj.source = <<-eof
       def mymethod
@@ -131,7 +132,7 @@ describe YARD::CodeObjects::Base do
         end
       end
     eof
-    obj.source.should == "def mymethod\n  if x == 2 &&\n      5 == 5\n    3\n  else\n    1\n  end\nend"
+    expect(obj.source).to eq "def mymethod\n  if x == 2 &&\n      5 == 5\n    3\n  else\n    1\n  end\nend"
 
     Registry.clear
     Parser::SourceParser.parse_string <<-eof
@@ -139,7 +140,7 @@ describe YARD::CodeObjects::Base do
         super(key)
       end
     eof
-    Registry.at('#key?').source.should == "def key?(key)\n  super(key)\nend"
+    expect(Registry.at('#key?').source).to eq "def key?(key)\n  super(key)\nend"
 
     Registry.clear
     Parser::SourceParser.parse_string <<-eof
@@ -151,10 +152,10 @@ describe YARD::CodeObjects::Base do
           end
         end
     eof
-    Registry.at('#key?').source.should == "def key?(key)\n  if x == 2\n    puts key\n  else\n    exit\n  end\nend"
+    expect(Registry.at('#key?').source).to eq "def key?(key)\n  if x == 2\n    puts key\n  else\n    exit\n  end\nend"
   end
 
-  it "should not add newlines to source when parsing sub blocks" do
+  it "does not add newlines to source when parsing sub blocks" do
     Parser::SourceParser.parse_string <<-eof
       module XYZ
         module ZYX
@@ -166,47 +167,47 @@ describe YARD::CodeObjects::Base do
         end
       end
     eof
-    Registry.at('XYZ::ZYX::ABC#msg').source.should == "def msg\n  hello_world\nend"
+    expect(Registry.at('XYZ::ZYX::ABC#msg').source).to eq "def msg\n  hello_world\nend"
   end
 
-  it "should handle source for 'def x; end'" do
+  it "handles source for 'def x; end'" do
     Registry.clear
     Parser::SourceParser.parse_string "def x; 2 end"
-    Registry.at('#x').source.should == "def x; 2 end"
+    expect(Registry.at('#x').source).to eq "def x; 2 end"
   end
 
-  it "should set file and line information" do
+  it "sets file and line information" do
     Parser::SourceParser.parse_string <<-eof
       class X; end
     eof
-    Registry.at(:X).file.should == '(stdin)'
-    Registry.at(:X).line.should == 1
+    expect(Registry.at(:X).file).to eq '(stdin)'
+    expect(Registry.at(:X).line).to eq 1
   end
 
-  it "should maintain all file associations when objects are defined multiple times in one file" do
+  it "maintains all file associations when objects are defined multiple times in one file" do
     Parser::SourceParser.parse_string <<-eof
       class X; end
       class X; end
       class X; end
     eof
 
-    Registry.at(:X).file.should == '(stdin)'
-    Registry.at(:X).line.should == 1
-    Registry.at(:X).files.should == [['(stdin)', 1], ['(stdin)', 2], ['(stdin)', 3]]
+    expect(Registry.at(:X).file).to eq '(stdin)'
+    expect(Registry.at(:X).line).to eq 1
+    expect(Registry.at(:X).files).to eq [['(stdin)', 1], ['(stdin)', 2], ['(stdin)', 3]]
   end
 
-  it "should maintain all file associations when objects are defined multiple times in multiple files" do
+  it "maintains all file associations when objects are defined multiple times in multiple files" do
     3.times do |i|
-      File.stub!(:read_binary).and_return("class X; end")
+      allow(File).to receive(:read_binary).and_return("class X; end")
       Parser::SourceParser.new.parse("file#{i+1}.rb")
     end
 
-    Registry.at(:X).file.should == 'file1.rb'
-    Registry.at(:X).line.should == 1
-    Registry.at(:X).files.should == [['file1.rb', 1], ['file2.rb', 1], ['file3.rb', 1]]
+    expect(Registry.at(:X).file).to eq 'file1.rb'
+    expect(Registry.at(:X).line).to eq 1
+    expect(Registry.at(:X).files).to eq [['file1.rb', 1], ['file2.rb', 1], ['file3.rb', 1]]
   end
 
-  it "should prioritize the definition with a docstring when returning #file" do
+  it "prioritizes the definition with a docstring when returning #file" do
     Parser::SourceParser.parse_string <<-eof
       class X; end
       class X; end
@@ -214,172 +215,172 @@ describe YARD::CodeObjects::Base do
       class X; end
     eof
 
-    Registry.at(:X).file.should == '(stdin)'
-    Registry.at(:X).line.should == 4
-    Registry.at(:X).files.should == [['(stdin)', 4], ['(stdin)', 1], ['(stdin)', 2]]
+    expect(Registry.at(:X).file).to eq '(stdin)'
+    expect(Registry.at(:X).line).to eq 4
+    expect(Registry.at(:X).files).to eq [['(stdin)', 4], ['(stdin)', 1], ['(stdin)', 2]]
   end
 
-  describe '#format' do
-    it "should send to Templates.render" do
+  describe "#format" do
+    it "sends object to Templates.render" do
       object = MethodObject.new(:root, :method)
-      Templates::Engine.should_receive(:render).with(:x => 1, :object => object)
+      expect(Templates::Engine).to receive(:render).with(:x => 1, :object => object)
       object.format :x => 1
     end
   end
 
-  describe '#source_type' do
-    it "should default source_type to :ruby" do
+  describe "#source_type" do
+    it "defaults to :ruby" do
       object = MethodObject.new(:root, :method)
-      object.source_type.should == :ruby
+      expect(object.source_type).to eq :ruby
     end
   end
 
-  describe '#relative_path' do
-    it "should accept a string" do
+  describe "#relative_path" do
+    it "accepts a string" do
       YARD.parse_string "module A; class B; end; class C; end; end"
-      Registry.at('A::B').relative_path(Registry.at('A::C')).should ==
-        Registry.at('A::B').relative_path('A::C')
+      expect(Registry.at('A::B').relative_path(Registry.at('A::C'))).to eq(
+        Registry.at('A::B').relative_path('A::C'))
     end
 
-    it "should return full class name when objects share a common class prefix" do
+    it "returns full class name when objects share a common class prefix" do
       YARD.parse_string "module User; end; module UserManager; end"
-      Registry.at('User').relative_path('UserManager').should == 'UserManager'
-      Registry.at('User').relative_path(Registry.at('UserManager')).should == 'UserManager'
+      expect(Registry.at('User').relative_path('UserManager')).to eq 'UserManager'
+      expect(Registry.at('User').relative_path(Registry.at('UserManager'))).to eq 'UserManager'
     end
 
-    it "should return the relative path when they share a common namespace" do
+    it "returns the relative path when they share a common namespace" do
       YARD.parse_string "module A; class B; end; class C; end; end"
-      Registry.at('A::B').relative_path(Registry.at('A::C')).should == 'C'
+      expect(Registry.at('A::B').relative_path(Registry.at('A::C'))).to eq 'C'
       YARD.parse_string "module Foo; module A; end; module B; def foo; end end end"
-      Registry.at('Foo::A').relative_path(Registry.at('Foo::B#foo')).should == 'B#foo'
+      expect(Registry.at('Foo::A').relative_path(Registry.at('Foo::B#foo'))).to eq 'B#foo'
     end
 
-    it "should return the full path if they don't have a common namespace" do
+    it "returns the full path if they don't have a common namespace" do
       YARD.parse_string "module A; class B; end; end; module D; class C; end; end"
-      Registry.at('A::B').relative_path('D::C').should == 'D::C'
+      expect(Registry.at('A::B').relative_path('D::C')).to eq 'D::C'
       YARD.parse_string 'module C::B::C; module Apple; end; module Ant; end end'
-      Registry.at('C::B::C::Apple').relative_path('C::B::C::Ant').should == 'Ant'
+      expect(Registry.at('C::B::C::Apple').relative_path('C::B::C::Ant')).to eq 'Ant'
       YARD.parse_string 'module OMG::ABC; end; class Object; end'
-      Registry.at('OMG::ABC').relative_path('Object').should == "Object"
+      expect(Registry.at('OMG::ABC').relative_path('Object')).to eq "Object"
       YARD.parse_string("class YARD::Config; MYCONST = 1; end")
-      Registry.at('YARD::Config').relative_path('YARD::Config::MYCONST').should == "MYCONST"
+      expect(Registry.at('YARD::Config').relative_path('YARD::Config::MYCONST')).to eq "MYCONST"
     end
 
-    it "should return a relative path for class methods" do
+    it "returns a relative path for class methods" do
       YARD.parse_string "module A; def self.b; end; def self.c; end; end"
-      Registry.at('A.b').relative_path('A.c').should == 'c'
-      Registry.at('A').relative_path('A.c').should == 'c'
+      expect(Registry.at('A.b').relative_path('A.c')).to eq 'c'
+      expect(Registry.at('A').relative_path('A.c')).to eq 'c'
     end
 
-    it "should return a relative path for instance methods" do
+    it "returns a relative path for instance methods" do
       YARD.parse_string "module A; def b; end; def c; end; end"
-      Registry.at('A#b').relative_path('A#c').should == '#c'
-      Registry.at('A').relative_path('A#c').should == '#c'
+      expect(Registry.at('A#b').relative_path('A#c')).to eq '#c'
+      expect(Registry.at('A').relative_path('A#c')).to eq '#c'
     end
 
-    it "should return full path if relative path is to parent namespace" do
+    it "returns full path if relative path is to parent namespace" do
       YARD.parse_string "module A; module B; end end"
-      Registry.at('A::B').relative_path('A').should == 'A'
+      expect(Registry.at('A::B').relative_path('A')).to eq 'A'
     end
 
-    it "should only return name for relative path to self" do
+    it "only returns name for relative path to self" do
       YARD.parse_string("class A::B::C; def foo; end end")
-      Registry.at('A::B::C').relative_path('A::B::C').should == 'C'
-      Registry.at('A::B::C#foo').relative_path('A::B::C#foo').should == '#foo'
+      expect(Registry.at('A::B::C').relative_path('A::B::C')).to eq 'C'
+      expect(Registry.at('A::B::C#foo').relative_path('A::B::C#foo')).to eq '#foo'
     end
   end
 
-  describe '#docstring=' do
-    it "should convert string into Docstring when #docstring= is set" do
+  describe "#docstring=" do
+    it "converts string into Docstring when #docstring= is set" do
       o = ClassObject.new(:root, :Me)
       o.docstring = "DOCSTRING"
-      o.docstring.should be_instance_of(Docstring)
+      expect(o.docstring).to be_instance_of(Docstring)
     end
 
-    it "should set docstring to docstring of other object if docstring is '(see Path)'" do
+    it "sets docstring to docstring of other object if docstring is '(see Path)'" do
       ClassObject.new(:root, :AnotherObject) {|x| x.docstring = "FOO" }
       o = ClassObject.new(:root, :Me)
       o.docstring = '(see AnotherObject)'
-      o.docstring.should == "FOO"
+      expect(o.docstring).to eq "FOO"
     end
 
-    it "should not copy docstring mid-docstring" do
+    it "does not copy docstring mid-docstring" do
       doc = "Hello.\n(see file.rb)\nmore documentation"
       o = ClassObject.new(:root, :Me)
       o.docstring = doc
-      o.docstring.should == doc
+      expect(o.docstring).to eq doc
     end
 
-    it "should allow extra docstring after (see Path)" do
+    it "allows extra docstring after (see Path)" do
       ClassObject.new(:root, :AnotherObject) {|x| x.docstring = "FOO" }
       o = ClassObject.new(:root, :Me)
       o.docstring = Docstring.new("(see AnotherObject)\n\nEXTRA\n@api private", o)
-      o.docstring.should == "FOO\n\nEXTRA"
-      o.docstring.should have_tag(:api)
+      expect(o.docstring).to eq "FOO\n\nEXTRA"
+      expect(o.docstring).to have_tag(:api)
     end
   end
 
-  describe '#docstring' do
-    it "should return empty string if docstring was '(see Path)' and Path is not resolved" do
+  describe "#docstring" do
+    it "returns an empty string if docstring was '(see Path)' and Path is not resolved" do
       o = ClassObject.new(:root, :Me)
       o.docstring = '(see AnotherObject)'
-      o.docstring.should == ""
+      expect(o.docstring).to eq ""
     end
 
-    it "should return docstring when object is resolved" do
+    it "returns docstring when object is resolved" do
       o = ClassObject.new(:root, :Me)
       o.docstring = '(see AnotherObject)'
-      o.docstring.should == ""
+      expect(o.docstring).to eq ""
       ClassObject.new(:root, :AnotherObject) {|x| x.docstring = "FOO" }
-      o.docstring.should == "FOO"
+      expect(o.docstring).to eq "FOO"
     end
 
-    describe 'localization' do
-      it "should return localized docstring" do
+    describe "localization" do
+      it "returns localized docstring" do
         fr_locale = YARD::I18n::Locale.new('fr')
-        fr_locale.stub!(:translate).with('Hello').and_return('Bonjour')
+        allow(fr_locale).to receive(:translate).with('Hello').and_return('Bonjour')
 
         o = ClassObject.new(:root, :Me)
         o.docstring = 'Hello'
-        o.docstring.should == 'Hello'
+        expect(o.docstring).to eq 'Hello'
 
-        Registry.stub!(:locale).with('fr').and_return(fr_locale)
-        o.docstring('fr').should == "Bonjour"
+        allow(Registry).to receive(:locale).with('fr').and_return(fr_locale)
+        expect(o.docstring('fr')).to eq "Bonjour"
       end
 
-      it "should return updated localized docstring" do
+      it "returns updated localized docstring" do
         fr_locale = YARD::I18n::Locale.new('fr')
-        Registry.stub!(:locale).with('fr').and_return(fr_locale)
+        allow(Registry).to receive(:locale).with('fr').and_return(fr_locale)
 
         o = ClassObject.new(:root, :Me)
         o.docstring = 'Hello'
-        o.docstring.should == 'Hello'
+        expect(o.docstring).to eq 'Hello'
 
-        fr_locale.stub!(:translate).with('Hello').and_return('Bonjour')
-        o.docstring('fr').should == "Bonjour"
+        allow(fr_locale).to receive(:translate).with('Hello').and_return('Bonjour')
+        expect(o.docstring('fr')).to eq "Bonjour"
 
         o.docstring = 'World'
-        fr_locale.stub!(:translate).with('World').and_return('Monde')
-        o.docstring('fr').should == "Monde"
-        o.docstring.should == 'World'
+        allow(fr_locale).to receive(:translate).with('World').and_return('Monde')
+        expect(o.docstring('fr')).to eq "Monde"
+        expect(o.docstring).to eq 'World'
       end
     end
   end
 
-  describe '#add_file' do
-    it "should only add a file/line combination once" do
+  describe "#add_file" do
+    it "only adds a file/line combination once" do
       o = ClassObject.new(:root, :Me)
       o.add_file('filename', 12)
-      o.files.should == [['filename', 12]]
+      expect(o.files).to eq [['filename', 12]]
       o.add_file('filename', 12)
-      o.files.should == [['filename', 12]]
+      expect(o.files).to eq [['filename', 12]]
       o.add_file('filename', 40) # different line
-      o.files.should == [['filename', 12], ['filename', 40]]
+      expect(o.files).to eq [['filename', 12], ['filename', 40]]
     end
   end
 
-  describe '#copy_to' do
-    it "should copy all data to new object" do
+  describe "#copy_to" do
+    it "copies all data to new object" do
       YARD.parse_string <<-eof
         private
         # A docstring
@@ -390,27 +391,27 @@ describe YARD::CodeObjects::Base do
       eof
       foo_c = MethodObject.new(:root, :foo, :class)
       Registry.at('#foo').copy_to(foo_c)
-      foo_c.scope.should == :class
-      foo_c.visibility.should == :private
-      foo_c.type.should == :method
-      foo_c.class.should == MethodObject
-      foo_c.path.should == '::foo'
-      foo_c.docstring.should == "A docstring"
-      foo_c.tag(:return).types.should == ['String']
-      foo_c.file.should == '(stdin)'
-      foo_c.line.should == 4
-      foo_c.source.should =~ /source_code_here/
-      foo_c.signature.should == 'def foo(a, b, c)'
-      foo_c.parameters.should == [['a', nil], ['b', nil], ['c', nil]]
+      expect(foo_c.scope).to eq :class
+      expect(foo_c.visibility).to eq :private
+      expect(foo_c.type).to eq :method
+      expect(foo_c.class).to eq MethodObject
+      expect(foo_c.path).to eq '::foo'
+      expect(foo_c.docstring).to eq "A docstring"
+      expect(foo_c.tag(:return).types).to eq ['String']
+      expect(foo_c.file).to eq '(stdin)'
+      expect(foo_c.line).to eq 4
+      expect(foo_c.source).to match /source_code_here/
+      expect(foo_c.signature).to eq 'def foo(a, b, c)'
+      expect(foo_c.parameters).to eq [['a', nil], ['b', nil], ['c', nil]]
     end
 
-    it "should return copied object" do
+    it "returns the copied object" do
       YARD.parse_string 'def foo; end'
       foo_c = MethodObject.new(:root, :foo, :class)
-      Registry.at('#foo').copy_to(foo_c).should == foo_c
+      expect(Registry.at('#foo').copy_to(foo_c)).to eq foo_c
     end
 
-    it "should copy docstring and rewrite tags for new object" do
+    it "copies docstring and rewrite tags to new object" do
       YARD.parse_string <<-eof
         # @return [String] a tag
         def foo; end
@@ -418,20 +419,20 @@ describe YARD::CodeObjects::Base do
       foo_c = MethodObject.new(:root, :foo, :class)
       foo_i = Registry.at('#foo')
       foo_i.copy_to(foo_c)
-      foo_i.tags.should_not == foo_c.tags
-      foo_c.tags.first.object.should == foo_c
+      expect(foo_i.tags).not_to eq foo_c.tags
+      expect(foo_c.tags.first.object).to eq foo_c
     end
 
-    it "should only copy #copyable_attributes" do
+    it "only copies #copyable_attributes" do
       foo = MethodObject.new(:root, :foo)
-      foo.should_receive(:copyable_attributes).and_return %w(a b c)
-      foo.should_receive(:instance_variable_get).with('@a').and_return(1)
-      foo.should_receive(:instance_variable_get).with('@b').and_return(2)
-      foo.should_receive(:instance_variable_get).with('@c').and_return(3)
+      expect(foo).to receive(:copyable_attributes).and_return %w(a b c)
+      expect(foo).to receive(:instance_variable_get).with('@a').and_return(1)
+      expect(foo).to receive(:instance_variable_get).with('@b').and_return(2)
+      expect(foo).to receive(:instance_variable_get).with('@c').and_return(3)
       bar = MethodObject.new(:root, :bar)
-      bar.should_receive(:instance_variable_set).with('@a', 1)
-      bar.should_receive(:instance_variable_set).with('@b', 2)
-      bar.should_receive(:instance_variable_set).with('@c', 3)
+      expect(bar).to receive(:instance_variable_set).with('@a', 1)
+      expect(bar).to receive(:instance_variable_set).with('@b', 2)
+      expect(bar).to receive(:instance_variable_set).with('@c', 3)
       foo.copy_to(bar)
     end
   end