yard 0.8.7.6 → 0.9.0

data/spec/parser/tag_parsing_spec.rb

@@ -3,16 +3,15 @@ require File.join(File.dirname(__FILE__), '..', 'spec_helper')
 describe YARD::Parser, "tag handling" do
   before { parse_file :tag_handler_001, __FILE__ }
 
-  it "should know the list of all available tags" do
-    P("Foo#foo").tags.should include(P("Foo#foo").tag(:api))
+  it "knows the list of all available tags" do
+    expect(P("Foo#foo").tags).to include(P("Foo#foo").tag(:api))
   end
 
-  it "should know the text of tags on a method" do
-    P("Foo#foo").tag(:api).text.should == "public"
+  it "knows the text of tags on a method" do
+    expect(P("Foo#foo").tag(:api).text).to eq "public"
   end
 
-  it "should return true when asked whether a tag exists" do
-    P("Foo#foo").has_tag?(:api).should == true
+  it "returns true when asked whether a tag exists" do
+    expect(P("Foo#foo").has_tag?(:api)).to be true
   end
-
 end

data/spec/rake/yardoc_task_spec.rb

@@ -7,12 +7,12 @@ describe YARD::Rake::YardocTask do
     @yardoc.use_document_file = false
     @yardoc.use_yardopts_file = false
     @yardoc.generate = false
-    Templates::Engine.stub!(:render)
-    Templates::Engine.stub!(:generate)
-    YARD.stub!(:parse)
-    Registry.stub!(:load)
-    Registry.stub!(:save)
-    YARD::CLI::Yardoc.stub!(:new).and_return(@yardoc)
+    allow(Templates::Engine).to receive(:render)
+    allow(Templates::Engine).to receive(:generate)
+    allow(YARD).to receive(:parse)
+    allow(Registry).to receive(:load)
+    allow(Registry).to receive(:save)
+    allow(YARD::CLI::Yardoc).to receive(:new).and_return(@yardoc)
     ::Rake.application.clear
   end
 
@@ -20,103 +20,93 @@ describe YARD::Rake::YardocTask do
     ::Rake.application.tasks[0].invoke
   end
 
-  describe '#initialize' do
-    it "should allow separate rake task name to be set" do
+  describe "#initialize" do
+    it "allows separate rake task name to be set" do
       YARD::Rake::YardocTask.new(:notyardoc)
-      ::Rake.application.tasks[0].name.should == "notyardoc"
+      expect(::Rake.application.tasks[0].name).to eq "notyardoc"
     end
   end
 
-  describe '#files' do
-    it "should allow files to be set" do
+  describe "#files" do
+    it "allows files to be set" do
       YARD::Rake::YardocTask.new do |t|
         t.files = ['a', 'b', 'c']
       end
       run
-      @yardoc.files.should == %w(a b c)
+      expect(@yardoc.files).to eq %w(a b c)
     end
   end
 
-  describe '#options' do
-    it "should allow extra options to be set" do
+  describe "#options" do
+    it "allows extra options to be set" do
       YARD::Rake::YardocTask.new do |t|
         t.options = ['--private', '--protected']
       end
       run
-      @yardoc.visibilities.should == [:public, :private, :protected]
+      expect(@yardoc.visibilities).to eq [:public, :private, :protected]
     end
 
-    it "should allow --api and --no-api" do
+    it "allows --api and --no-api" do
       YARD::Rake::YardocTask.new do |t|
         t.options = %w(--api public --no-api)
       end
       run
-      @yardoc.options.verifier.expressions.
-        should include('["public"].include?(@api.text) || !@api')
+      expect(@yardoc.options.verifier.expressions).to include('["public"].include?(@api.text) || !@api')
     end
   end
 
-  describe '#stats_options' do
+  describe "#stats_options" do
     before do
       @yard_stats = Object.new
-      @yard_stats.stub!(:run)
-      YARD::CLI::Stats.stub!(:new).and_return(@yard_stats)
+      allow(@yard_stats).to receive(:run)
+      allow(YARD::CLI::Stats).to receive(:new).and_return(@yard_stats)
     end
 
-    it "should not invoke stats" do
-      @yard_stats.should_not_receive(:run)
-      @yardoc.statistics = true
-      YARD::Rake::YardocTask.new do |t|
-      end
-      run
-      @yardoc.statistics.should == true
-    end
-
-    it "should invoke stats" do
-      @yard_stats.should_receive(:run).with('--list-undoc', '--use-cache')
+    it "invokes stats" do
+      expect(@yard_stats).to receive(:run).with('--list-undoc', '--use-cache')
       @yardoc.statistics = true
       YARD::Rake::YardocTask.new do |t|
         t.stats_options = %w(--list-undoc)
       end
       run
-      @yardoc.statistics.should == false
+      expect(@yardoc.statistics).to be false
     end
   end
 
-  describe '#before' do
-    it "should allow before callback" do
+  describe "#before" do
+    it "allows before callback" do
       proc = lambda { }
-      proc.should_receive(:call)
-      @yardoc.should_receive(:run)
+      expect(proc).to receive(:call)
+      expect(@yardoc).to receive(:run)
       YARD::Rake::YardocTask.new {|t| t.before = proc }
       run
     end
   end
 
-  describe '#after' do
-    it "should allow after callback" do
+  describe "#after" do
+    it "allows after callback" do
       proc = lambda { }
-      proc.should_receive(:call)
-      @yardoc.should_receive(:run)
+      expect(proc).to receive(:call)
+      expect(@yardoc).to receive(:run)
       YARD::Rake::YardocTask.new {|t| t.after = proc }
       run
     end
   end
 
-  describe '#verifier' do
-    it "should allow a verifier proc to be set" do
+  describe "#verifier" do
+    it "allows a verifier proc to be set" do
       verifier = Verifier.new
-      @yardoc.should_receive(:run) do
-        @yardoc.options[:verifier].should == verifier
+      expect(@yardoc).to receive(:run) do
+        expect(@yardoc.options[:verifier]).to eq verifier
       end
       YARD::Rake::YardocTask.new {|t| t.verifier = verifier }
       run
     end
 
-    it "should override --query options" do
+    it "overrides --query options" do
       verifier = Verifier.new
-      @yardoc.should_receive(:run) do
-        @yardoc.options[:verifier].should == verifier
+      expect(@yardoc).to receive(:run) do
+        expect(@yardoc.options[:verifier]).to eq verifier
       end
       YARD::Rake::YardocTask.new do |t|
         t.options += ['--query', '@return']

data/spec/registry_spec.rb

@@ -6,312 +6,312 @@ require "thread"
 describe YARD::Registry do
   before { Registry.clear }
 
-  describe '.yardoc_file_for_gem' do
+  describe ".yardoc_file_for_gem" do
     before do
-      @gem = mock('gem')
-      @gem.stub!(:name).and_return('foo')
-      @gem.stub!(:full_name).and_return('foo-1.0')
-      @gem.stub!(:full_gem_path).and_return('/path/to/foo')
+      @gem = double('gem')
+      allow(@gem).to receive(:name).and_return('foo')
+      allow(@gem).to receive(:full_name).and_return('foo-1.0')
+      allow(@gem).to receive(:full_gem_path).and_return('/path/to/foo')
     end
 
-    it "should return nil if gem isn't found" do
-      Gem.source_index.should_receive(:find_name).with('foo', '>= 0').and_return([])
-      Registry.yardoc_file_for_gem('foo').should == nil
+    it "returns nil if gem isn't found" do
+      expect(Gem.source_index).to receive(:find_name).with('foo', '>= 0').and_return([])
+      expect(Registry.yardoc_file_for_gem('foo')).to eq nil
     end
 
-    it "should allow version to be specified" do
-      Gem.source_index.should_receive(:find_name).with('foo', '= 2').and_return([])
-      Registry.yardoc_file_for_gem('foo', '= 2').should == nil
+    it "allows version to be specified" do
+      expect(Gem.source_index).to receive(:find_name).with('foo', '= 2').and_return([])
+      expect(Registry.yardoc_file_for_gem('foo', '= 2')).to eq nil
     end
 
-    it "should return existing .yardoc path for gem when for_writing=false" do
-      File.should_receive(:exist?).and_return(false)
-      File.should_receive(:exist?).with('/path/to/foo/.yardoc').and_return(true)
-      Gem.source_index.should_receive(:find_name).with('foo', '>= 0').and_return([@gem])
-      Registry.yardoc_file_for_gem('foo').should == '/path/to/foo/.yardoc'
+    it "returns existing .yardoc path for gem when for_writing=false" do
+      expect(File).to receive(:exist?).and_return(false)
+      expect(File).to receive(:exist?).with('/path/to/foo/.yardoc').and_return(true)
+      expect(Gem.source_index).to receive(:find_name).with('foo', '>= 0').and_return([@gem])
+      expect(Registry.yardoc_file_for_gem('foo')).to eq '/path/to/foo/.yardoc'
     end
 
-    it "should return nil if no .yardoc path exists in gem when for_writing=false" do
-      File.should_receive(:exist?).and_return(false)
-      File.should_receive(:exist?).with('/path/to/foo/.yardoc').and_return(false)
-      Gem.source_index.should_receive(:find_name).with('foo', '>= 0').and_return([@gem])
-      Registry.yardoc_file_for_gem('foo').should == nil
+    it "returns nil if no .yardoc path exists in gem when for_writing=false" do
+      expect(File).to receive(:exist?).and_return(false)
+      expect(File).to receive(:exist?).with('/path/to/foo/.yardoc').and_return(false)
+      expect(Gem.source_index).to receive(:find_name).with('foo', '>= 0').and_return([@gem])
+      expect(Registry.yardoc_file_for_gem('foo')).to eq nil
     end
 
-    it "should search local gem path first if for_writing=false" do
-      File.should_receive(:exist?).and_return(true)
-      Gem.source_index.should_receive(:find_name).with('foo', '>= 0').and_return([@gem])
-      Registry.yardoc_file_for_gem('foo').should =~ %r{/.yard/gem_index/foo-1.0.yardoc$}
+    it "searches local gem path first if for_writing=false" do
+      expect(File).to receive(:exist?).and_return(true)
+      expect(Gem.source_index).to receive(:find_name).with('foo', '>= 0').and_return([@gem])
+      expect(Registry.yardoc_file_for_gem('foo')).to match %r{/.yard/gem_index/foo-1.0.yardoc$}
     end
 
-    it "should return global .yardoc path for gem if for_writing=true and dir is writable" do
-      File.should_receive(:writable?).with(@gem.full_gem_path).and_return(true)
-      Gem.source_index.should_receive(:find_name).with('foo', '>= 0').and_return([@gem])
-      Registry.yardoc_file_for_gem('foo', '>= 0', true).should == '/path/to/foo/.yardoc'
+    it "returns global .yardoc path for gem if for_writing=true and dir is writable" do
+      expect(File).to receive(:writable?).with(@gem.full_gem_path).and_return(true)
+      expect(Gem.source_index).to receive(:find_name).with('foo', '>= 0').and_return([@gem])
+      expect(Registry.yardoc_file_for_gem('foo', '>= 0', true)).to eq '/path/to/foo/.yardoc'
     end
 
-    it "should return local .yardoc path for gem if for_writing=true and dir is not writable" do
-      File.should_receive(:writable?).with(@gem.full_gem_path).and_return(false)
-      Gem.source_index.should_receive(:find_name).with('foo', '>= 0').and_return([@gem])
-      Registry.yardoc_file_for_gem('foo', '>= 0', true).should =~ %r{/.yard/gem_index/foo-1.0.yardoc$}
+    it "returns local .yardoc path for gem if for_writing=true and dir is not writable" do
+      expect(File).to receive(:writable?).with(@gem.full_gem_path).and_return(false)
+      expect(Gem.source_index).to receive(:find_name).with('foo', '>= 0').and_return([@gem])
+      expect(Registry.yardoc_file_for_gem('foo', '>= 0', true)).to match %r{/.yard/gem_index/foo-1.0.yardoc$}
     end
 
-    it "should return gem path if gem starts with yard-doc- and for_writing=false" do
-      @gem.stub!(:name).and_return('yard-doc-core')
-      @gem.stub!(:full_name).and_return('yard-doc-core-1.0')
-      @gem.stub!(:full_gem_path).and_return('/path/to/yard-doc-core')
-      Gem.source_index.should_receive(:find_name).with('yard-doc-core', '>= 0').and_return([@gem])
-      File.should_receive(:exist?).with('/path/to/yard-doc-core/.yardoc').and_return(true)
-      Registry.yardoc_file_for_gem('yard-doc-core').should == '/path/to/yard-doc-core/.yardoc'
+    it "returns gem path if gem starts with yard-doc- and for_writing=false" do
+      allow(@gem).to receive(:name).and_return('yard-doc-core')
+      allow(@gem).to receive(:full_name).and_return('yard-doc-core-1.0')
+      allow(@gem).to receive(:full_gem_path).and_return('/path/to/yard-doc-core')
+      expect(Gem.source_index).to receive(:find_name).with('yard-doc-core', '>= 0').and_return([@gem])
+      expect(File).to receive(:exist?).with('/path/to/yard-doc-core/.yardoc').and_return(true)
+      expect(Registry.yardoc_file_for_gem('yard-doc-core')).to eq '/path/to/yard-doc-core/.yardoc'
     end
 
-    it "should return nil if gem starts with yard-doc- and for_writing=true" do
-      @gem.stub!(:name).and_return('yard-doc-core')
-      @gem.stub!(:full_name).and_return('yard-doc-core-1.0')
-      @gem.stub!(:full_gem_path).and_return('/path/to/yard-doc-core')
-      Gem.source_index.should_receive(:find_name).with('yard-doc-core', '>= 0').and_return([@gem])
-      File.should_receive(:exist?).with('/path/to/yard-doc-core/.yardoc').and_return(true)
-      Registry.yardoc_file_for_gem('yard-doc-core', '>= 0', true).should == nil
+    it "returns nil if gem starts with yard-doc- and for_writing=true" do
+      allow(@gem).to receive(:name).and_return('yard-doc-core')
+      allow(@gem).to receive(:full_name).and_return('yard-doc-core-1.0')
+      allow(@gem).to receive(:full_gem_path).and_return('/path/to/yard-doc-core')
+      expect(Gem.source_index).to receive(:find_name).with('yard-doc-core', '>= 0').and_return([@gem])
+      expect(File).to receive(:exist?).with('/path/to/yard-doc-core/.yardoc').and_return(true)
+      expect(Registry.yardoc_file_for_gem('yard-doc-core', '>= 0', true)).to eq nil
     end
   end
 
-  describe '.root' do
-    it "should have an empty path for root" do
-      Registry.root.path.should == ""
+  describe ".root" do
+    it "has an empty path for root" do
+      expect(Registry.root.path).to eq ""
     end
   end
 
-  describe '.locale' do
-    it "should load locale object" do
+  describe ".locale" do
+    it "loads locale object" do
       fr_locale = I18n::Locale.new("fr")
       store = Registry.send(:thread_local_store)
-      store.should_receive(:locale).with("fr").and_return(fr_locale)
-      Registry.locale("fr").should == fr_locale
+      expect(store).to receive(:locale).with("fr").and_return(fr_locale)
+      expect(Registry.locale("fr")).to eq fr_locale
     end
   end
 
-  describe '.resolve' do
-    it "should resolve any existing namespace" do
+  describe ".resolve" do
+    it "resolves any existing namespace" do
       o1 = ModuleObject.new(:root, :A)
       o2 = ModuleObject.new(o1, :B)
       o3 = ModuleObject.new(o2, :C)
-      Registry.resolve(o1, "B::C").should == o3
+      expect(Registry.resolve(o1, "B::C")).to eq o3
       Registry.resolve(:root, "A::B::C")
     end
 
-    it "should resolve an object in the root namespace when prefixed with ::" do
+    it "resolves an object in the root namespace when prefixed with ::" do
       o1 = ModuleObject.new(:root, :A)
       o2 = ModuleObject.new(o1, :B)
       o3 = ModuleObject.new(o2, :C)
-      Registry.resolve(o3, "::A").should == o1
+      expect(Registry.resolve(o3, "::A")).to eq o1
 
-      Registry.resolve(o3, "::String", false, true).should == P(:String)
+      expect(Registry.resolve(o3, "::String", false, true)).to eq P(:String)
     end
 
-    it "should resolve instance methods with # prefix" do
+    it "resolves instance methods with # prefix" do
       o1 = ModuleObject.new(:root, :A)
       o2 = ModuleObject.new(o1, :B)
       o3 = ModuleObject.new(o2, :C)
       o4 = MethodObject.new(o3, :methname)
-      Registry.resolve(o1, "B::C#methname").should == o4
-      Registry.resolve(o2, "C#methname").should == o4
-      Registry.resolve(o3, "#methname").should == o4
+      expect(Registry.resolve(o1, "B::C#methname")).to eq o4
+      expect(Registry.resolve(o2, "C#methname")).to eq o4
+      expect(Registry.resolve(o3, "#methname")).to eq o4
     end
 
-    it "should resolve instance methods in the root without # prefix" do
+    it "resolves instance methods in the root without # prefix" do
       o = MethodObject.new(:root, :methname)
-      Registry.resolve(:root, 'methname').should == o
+      expect(Registry.resolve(:root, 'methname')).to eq o
     end
 
-    it "should resolve superclass methods when inheritance = true" do
+    it "resolves superclass methods when inheritance = true" do
       superyard = ClassObject.new(:root, :SuperYard)
       yard = ClassObject.new(:root, :YARD)
       yard.superclass = superyard
       imeth = MethodObject.new(superyard, :hello)
       cmeth = MethodObject.new(superyard, :class_hello, :class)
 
-      Registry.resolve(yard, "#hello", false).should be_nil
-      Registry.resolve(yard, "#hello", true).should == imeth
-      Registry.resolve(yard, "class_hello", false).should be_nil
-      Registry.resolve(yard, "class_hello", true).should == cmeth
+      expect(Registry.resolve(yard, "#hello", false)).to be nil
+      expect(Registry.resolve(yard, "#hello", true)).to eq imeth
+      expect(Registry.resolve(yard, "class_hello", false)).to be nil
+      expect(Registry.resolve(yard, "class_hello", true)).to eq cmeth
     end
 
-    it "should resolve mixin methods when inheritance = true" do
+    it "resolves mixin methods when inheritance = true" do
       yard = ClassObject.new(:root, :YARD)
       mixin = ModuleObject.new(:root, :Mixin)
       yard.mixins(:instance) << mixin
       imeth = MethodObject.new(mixin, :hello)
       cmeth = MethodObject.new(mixin, :class_hello, :class)
 
-      Registry.resolve(yard, "#hello", false).should be_nil
-      Registry.resolve(yard, "#hello", true).should == imeth
-      Registry.resolve(yard, "class_hello", false).should be_nil
-      Registry.resolve(yard, "class_hello", true).should == cmeth
+      expect(Registry.resolve(yard, "#hello", false)).to be nil
+      expect(Registry.resolve(yard, "#hello", true)).to eq imeth
+      expect(Registry.resolve(yard, "class_hello", false)).to be nil
+      expect(Registry.resolve(yard, "class_hello", true)).to eq cmeth
     end
 
-    it "should resolve methods in Object when inheritance = true" do
+    it "resolves methods in Object when inheritance = true" do
       YARD.parse_string <<-eof
         class Object; def foo; end end
         class A; end
         class MyObject < A; end
       eof
 
-      Registry.resolve(P('MyObject'), '#foo', true).should == P('Object#foo')
+      expect(Registry.resolve(P('MyObject'), '#foo', true)).to eq P('Object#foo')
     end
 
-    it "should resolve methods in BasicObject when inheritance = true" do
+    it "resolves methods in BasicObject when inheritance = true" do
       YARD.parse_string <<-eof
         class BasicObject; def foo; end end
         class A; end
         class MyObject < A; end
       eof
 
-      Registry.resolve(P('MyObject'), '#foo', true).should == P('BasicObject#foo')
+      expect(Registry.resolve(P('MyObject'), '#foo', true)).to eq P('BasicObject#foo')
     end
 
-    it "should not resolve methods in Object if inheriting BasicObject when inheritance = true" do
+    it "does not resolve methods in Object if inheriting BasicObject when inheritance = true" do
       YARD.parse_string <<-eof
         class Object; def foo; end end
         class MyObject < BasicObject; end
       eof
 
-      Registry.resolve(P('MyObject'), '#foo', true).should be_nil
+      expect(Registry.resolve(P('MyObject'), '#foo', true)).to be nil
     end
 
-    it "should allow type=:typename to ensure resolved object is of a certain type" do
+    it "allows type=:typename to ensure resolved object is of a certain type" do
       YARD.parse_string "class Foo; end"
-      Registry.resolve(Registry.root, 'Foo').should == Registry.at('Foo')
-      Registry.resolve(Registry.root, 'Foo', false, false, :method).should be_nil
+      expect(Registry.resolve(Registry.root, 'Foo')).to eq Registry.at('Foo')
+      expect(Registry.resolve(Registry.root, 'Foo', false, false, :method)).to be nil
     end
 
-    it "should allow keep trying to find obj where type equals object type" do
+    it "allows keep trying to find obj where type equals object type" do
       YARD.parse_string <<-eof
         module Foo
           class Bar; end
           def self.Bar; end
         end
       eof
-      Registry.resolve(P('Foo'), 'Bar').should == Registry.at('Foo::Bar')
-      Registry.resolve(P('Foo'), 'Bar', false, false, :method).should == 
-        Registry.at('Foo.Bar')
+      expect(Registry.resolve(P('Foo'), 'Bar')).to eq Registry.at('Foo::Bar')
+      expect(Registry.resolve(P('Foo'), 'Bar', false, false, :method)).to eq(
+        Registry.at('Foo.Bar'))
     end
 
-    it "should return proxy fallback with given type if supplied" do
+    it "returns proxy fallback with given type if supplied" do
       YARD.parse_string "module Foo; end"
       proxy = Registry.resolve(P('Foo'), 'Bar', false, true, :method)
-      proxy.type.should == :method
+      expect(proxy.type).to eq :method
       proxy = Registry.resolve(P('Qux'), 'Bar', false, true, :method)
-      proxy.type.should == :method
+      expect(proxy.type).to eq :method
     end
 
-    it "should only check 'Path' in lookup on root namespace" do
-      Registry.should_receive(:at).once.with('Test').and_return(true)
+    it "only checks 'Path' in lookup on root namespace" do
+      expect(Registry).to receive(:at).once.with('Test').and_return(true)
       Registry.resolve(Registry.root, "Test")
     end
 
-    it "should not perform lookup by joining namespace and name without separator" do
+    it "does not perform lookup by joining namespace and name without separator" do
       yard = ClassObject.new(:root, :YARD)
-      Registry.should_not_receive(:at).with('YARDB')
+      expect(Registry).not_to receive(:at).with('YARDB')
       Registry.resolve(yard, 'B')
     end
   end
 
-  describe '.all' do
-    it "should return objects of types specified by arguments" do
+  describe ".all" do
+    it "returns objects of types specified by arguments" do
       ModuleObject.new(:root, :A)
       o1 = ClassObject.new(:root, :B)
       o2 = MethodObject.new(:root, :testing)
       r = Registry.all(:method, :class)
-      r.should include(o1, o2)
+      expect(r).to include(o1, o2)
     end
 
-    it "should return code objects" do
+    it "returns code objects" do
       o1 = ModuleObject.new(:root, :A)
       o2 = ClassObject.new(:root, :B)
       MethodObject.new(:root, :testing)
       r = Registry.all.select {|t| NamespaceObject === t }
-      r.should include(o1, o2)
+      expect(r).to include(o1, o2)
     end
 
-    it "should allow .all to omit list" do
+    it "allows .all to omit list" do
       o1 = ModuleObject.new(:root, :A)
       o2 = ClassObject.new(:root, :B)
       r = Registry.all
-      r.should include(o1, o2)
+      expect(r).to include(o1, o2)
     end
   end
 
-  describe '.paths' do
-    it "should return all object paths" do
+  describe ".paths" do
+    it "returns all object paths" do
       o1 = ModuleObject.new(:root, :A)
       o2 = ClassObject.new(:root, :B)
-      Registry.paths.should include('A', 'B')
+      expect(Registry.paths).to include('A', 'B')
     end
   end
 
-  describe '.load_yardoc' do
-    it "should delegate load to RegistryStore" do
+  describe ".load_yardoc" do
+    it "delegates load to RegistryStore" do
       store = RegistryStore.new
-      store.should_receive(:load).with('foo')
-      RegistryStore.should_receive(:new).and_return(store)
+      expect(store).to receive(:load).with('foo')
+      expect(RegistryStore).to receive(:new).and_return(store)
       Registry.yardoc_file = 'foo'
       Registry.load_yardoc
     end
 
-    it "should return itself" do
-      Registry.load_yardoc.should == Registry
+    it "returns itself" do
+      expect(Registry.load_yardoc).to eq Registry
     end
 
-    it "should maintain hash key equality on loaded objects" do
+    it "maintains hash key equality on loaded objects" do
       Registry.clear
       Registry.load!(File.dirname(__FILE__) + '/serializers/data/serialized_yardoc')
       baz = Registry.at('Foo#baz')
-      Registry.at('Foo').aliases.keys.should include(baz)
-      Registry.at('Foo').aliases.has_key?(baz).should == true
+      expect(Registry.at('Foo').aliases.keys).to include(baz)
+      expect(Registry.at('Foo').aliases.has_key?(baz)).to be true
     end
   end
 
   ['load', 'load_all', 'load!'].each do |meth|
     describe('.' + meth) do
-      it "should return itself" do
-        Registry.send(meth).should == Registry
+      it "returns itself" do
+        expect(Registry.send(meth)).to eq Registry
       end
     end
   end
 
-  describe '.each' do
+  describe ".each" do
     before do
       YARD.parse_string "def a; end; def b; end; def c; end"
     end
 
     after { Registry.clear }
 
-    it "should iterate over .all" do
+    it "iterates over .all" do
       items = []
       Registry.each {|x| items << x.path }
-      items.sort.should == ['#a', '#b', '#c']
+      expect(items.sort).to eq ['#a', '#b', '#c']
     end
 
-    it "should include Enumerable and allow for find, select" do
-      Registry.find {|x| x.path == "#a" }.should be_a(CodeObjects::MethodObject)
+    it "includes Enumerable and allow for find, select" do
+      expect(Registry.find {|x| x.path == "#a" }).to be_a(CodeObjects::MethodObject)
     end
   end
 
-  describe '.instance' do
-    it "should return itself" do
-      Registry.instance.should == Registry
+  describe ".instance" do
+    it "returns itself" do
+      expect(Registry.instance).to eq Registry
     end
   end
 
-  describe '.single_object_db' do
-    it "should default to nil" do
-      Registry.single_object_db.should == nil
-      Thread.new { Registry.single_object_db.should == nil }.join
+  describe ".single_object_db" do
+    it "defaults to nil" do
+      expect(Registry.single_object_db).to eq nil
+      Thread.new { expect(Registry.single_object_db).to eq nil }.join
     end
   end
 
-  describe 'Thread local' do
-    it "should maintain two Registries in separate threads" do
+  describe "Thread local" do
+    it "maintains two Registries in separate threads" do
       barrier = 0
       mutex   = Mutex.new
       threads = []
@@ -322,7 +322,7 @@ describe YARD::Registry do
         while barrier < 2 do
           s = "barrier < 2, spinning"
         end
-        Registry.at('Foo').docstring.should == "docstring 1"
+        expect(Registry.at('Foo').docstring).to eq "docstring 1"
       end
       threads << Thread.new do
         Registry.clear
@@ -331,29 +331,29 @@ describe YARD::Registry do
         while barrier < 2 do
           s = "barrier < 2, spinning"
         end
-        Registry.at('Foo').docstring.should == "docstring 2"
+        expect(Registry.at('Foo').docstring).to eq "docstring 2"
       end
       threads.each {|t| t.join }
     end
 
-    it "should allow setting of yardoc_file in separate threads" do
+    it "allows setting of yardoc_file in separate threads" do
       barrier = 0
       mutex   = Mutex.new
       threads = []
       threads << Thread.new do
-        Registry.yardoc_file.should == '.yardoc'
+        expect(Registry.yardoc_file).to eq '.yardoc'
         Registry.yardoc_file = 'foo'
         mutex.synchronize { barrier += 1 }
         while barrier == 1 do
           s = "barrier = 1, spinning"
         end
-        Registry.yardoc_file.should == 'foo'
+        expect(Registry.yardoc_file).to eq 'foo'
       end
       threads << Thread.new do
         while barrier == 0 do
           s = "barrier = 0, spinning"
         end
-        Registry.yardoc_file.should == '.yardoc'
+        expect(Registry.yardoc_file).to eq '.yardoc'
         mutex.synchronize { barrier += 1 }
         Registry.yardoc_file = 'foo2'
       end
@@ -361,28 +361,28 @@ describe YARD::Registry do
       Registry.yardoc_file = Registry::DEFAULT_YARDOC_FILE
     end
 
-    it "should automatically clear in new threads" do
-      Thread.new { Registry.all.should be_empty }.join
+    it "automatically clears in new threads" do
+      Thread.new { expect(Registry.all).to be_empty }.join
     end
 
-    it "should allow setting of po_dir in separate threads" do
+    it "allows setting of po_dir in separate threads" do
       barrier = 0
       mutex   = Mutex.new
       threads = []
       threads << Thread.new do
-        Registry.po_dir.should == 'po'
+        expect(Registry.po_dir).to eq 'po'
         Registry.po_dir = 'locale'
         mutex.synchronize { barrier += 1 }
         while barrier == 1 do
           s = "barrier = 1, spinning"
         end
-        Registry.po_dir.should == 'locale'
+        expect(Registry.po_dir).to eq 'locale'
       end
       threads << Thread.new do
         while barrier == 0 do
           s = "barrier = 0, spinning"
         end
-        Registry.po_dir.should == 'po'
+        expect(Registry.po_dir).to eq 'po'
         mutex.synchronize { barrier += 1 }
         Registry.po_dir = '.'
       end