yard 0.8.7.6 → 0.9.0

data/spec/rubygems/doc_manager_spec.rb

@@ -5,104 +5,104 @@ require 'fileutils'
 describe Gem::DocManager do
   before do
     # Ensure filesystem integrity
-    FileUtils.stub(:mkdir_p)
-    FileUtils.stub(:rm_rf)
-    Dir.stub(:chdir)
+    allow(FileUtils).to receive(:mkdir_p)
+    allow(FileUtils).to receive(:rm_rf)
+    allow(Dir).to receive(:chdir)
 
-    YARD::CLI::Yardoc.stub(:run)
+    allow(YARD::CLI::Yardoc).to receive(:run)
 
     @spec_file = File.join(YARD::ROOT, '..', 'yard.gemspec')
     @spec = Gem::SourceIndex.load_specification(@spec_file)
     @spec.has_yardoc = false # no yardoc docs for now
     @yardopts = File.join(@spec.full_gem_path, '.yardopts')
     @doc = Gem::DocManager.new(@spec)
-    @doc.stub(:install_ri_yard_orig)
-    @doc.stub(:install_rdoc_yard_orig)
+    allow(@doc).to receive(:install_ri_yard_orig)
+    allow(@doc).to receive(:install_rdoc_yard_orig)
   end
 
-  def runs; YARD::CLI::Yardoc.should_receive(:run) end
+  def runs; expect(YARD::CLI::Yardoc).to receive(:run) end
 
-  describe '.load_yardoc' do
-    it "should properly load YARD" do
-      Gem::DocManager.should_receive(:require) do |path|
-        File.expand_path(path).should == YARD::ROOT + '/yard'
+  describe ".load_yardoc" do
+    it "properly loads YARD" do
+      expect(Gem::DocManager).to receive(:require) do |path|
+        expect(File.expand_path(path)).to eq YARD::ROOT + '/yard'
       end
       Gem::DocManager.load_yardoc
     end
   end
 
-  describe '#install_ri_yard' do
+  describe "#install_ri_yard" do
     def install
       msg = "Building YARD (yri) index for #{@spec.full_name}..."
-      @doc.should_receive(:say).with(msg)
+      expect(@doc).to receive(:say).with(msg)
       @doc.install_ri_yard
     end
 
-    it "should pass --quiet to all documentation" do
+    it "passes --quiet to all documentation" do
       runs.with('-c', '-n', '--quiet', 'lib')
       install
     end
 
-    it "should pass extra_rdoc_files to documentation" do
+    it "passes extra_rdoc_files to documentation" do
       @spec.extra_rdoc_files = %w(README LICENSE)
       runs.with('-c', '-n', '--quiet', 'lib', '-', 'README', 'LICENSE')
       install
     end
 
-    it "should add --backtrace if Gem.configuration.backtrace" do
+    it "adds --backtrace if Gem.configuration.backtrace" do
       Gem.configuration.backtrace = true
       runs.with('-c', '-n', '--quiet', '--backtrace', 'lib')
       install
       Gem.configuration.backtrace = false
     end
 
-    it "should add require_paths if there is no .yardopts" do
-      File.should_receive(:file?).with(@yardopts).and_return(true)
+    it "adds require_paths if there is no .yardopts" do
+      expect(File).to receive(:file?).with(@yardopts).and_return(true)
       runs.with('-c', '-n', '--quiet')
       install
     end
 
-    it "should add extra_rdoc_files if there is no .yardopts" do
+    it "adds extra_rdoc_files if there is no .yardopts" do
       @spec.extra_rdoc_files = %w(README LICENSE)
-      File.should_receive(:file?).with(@yardopts).and_return(true)
+      expect(File).to receive(:file?).with(@yardopts).and_return(true)
       runs.with('-c', '-n', '--quiet')
       install
     end
 
-    it "should switch to directory before running command" do
+    it "switches to directory before running command" do
       old = Dir.pwd
-      Dir.should_receive(:chdir).with(@spec.full_gem_path)
-      Dir.should_receive(:chdir).with(old)
+      expect(Dir).to receive(:chdir).with(@spec.full_gem_path)
+      expect(Dir).to receive(:chdir).with(old)
       install
     end
 
-    it "should ensure that directory is switched back at end of command in failure" do
+    it "ensures that directory is switched back at end of command in failure" do
       old = Dir.pwd
-      Dir.should_receive(:chdir).with(@spec.full_gem_path)
-      Dir.should_receive(:chdir).with(old)
-      @doc.ui.errs.should_receive(:puts).with(/ERROR:\s*While generating documentation/)
-      @doc.ui.errs.should_receive(:puts).with(/MESSAGE:\s*foo/)
-      @doc.ui.errs.should_receive(:puts).with(/YARDOC args:\s*-c -n --quiet lib/)
-      @doc.ui.errs.should_receive(:puts).with("(continuing with the rest of the installation)")
-      YARD::CLI::Yardoc.should_receive(:run).and_raise(RuntimeError.new("foo"))
+      expect(Dir).to receive(:chdir).with(@spec.full_gem_path)
+      expect(Dir).to receive(:chdir).with(old)
+      expect(@doc.ui.errs).to receive(:puts).with(/ERROR:\s*While generating documentation/)
+      expect(@doc.ui.errs).to receive(:puts).with(/MESSAGE:\s*foo/)
+      expect(@doc.ui.errs).to receive(:puts).with(/YARDOC args:\s*-c -n --quiet lib/)
+      expect(@doc.ui.errs).to receive(:puts).with("(continuing with the rest of the installation)")
+      expect(YARD::CLI::Yardoc).to receive(:run).and_raise(RuntimeError.new("foo"))
       install
     end
 
-    it "should handle permission errors" do
-      YARD::CLI::Yardoc.should_receive(:run).and_raise(Errno::EACCES.new("- dir"))
-      lambda { install }.should raise_error(Gem::FilePermissionError)
+    it "handles permission errors" do
+      expect(YARD::CLI::Yardoc).to receive(:run).and_raise(Errno::EACCES.new("- dir"))
+      expect { install }.to raise_error(Gem::FilePermissionError)
     end
   end
 
-  describe '#install_rdoc_yard' do
+  describe "#install_rdoc_yard" do
     def install
       msg = "Installing YARD documentation for #{@spec.full_name}..."
-      @doc.should_receive(:say).with(msg)
+      expect(@doc).to receive(:say).with(msg)
       @doc.install_rdoc_yard
     end
 
-    it "should add -o outdir when generating docs" do
-      File.should_receive(:file?).with(@yardopts).and_return(true)
+    it "adds -o outdir when generating docs" do
+      expect(File).to receive(:file?).with(@yardopts).and_return(true)
       @spec.has_yardoc = true
       doc_dir = File.join(@doc.instance_variable_get("@doc_dir"), 'rdoc')
       runs.with('-o', doc_dir, '--quiet')

data/spec/serializers/file_system_serializer_spec.rb

@@ -4,47 +4,46 @@ require 'stringio'
 
 describe YARD::Serializers::FileSystemSerializer do
   before do
-    FileUtils.stub!(:mkdir_p)
-    File.stub!(:open)
+    allow(FileUtils).to receive(:mkdir_p)
+    allow(File).to receive(:open)
   end
 
-  describe '#basepath' do
-    it "should default the base path to the 'doc/'" do
+  describe "#basepath" do
+    it "defaults the base path to the 'doc/'" do
       obj = Serializers::FileSystemSerializer.new
-      obj.basepath.should == 'doc'
+      expect(obj.basepath).to eq 'doc'
     end
   end
 
-  describe '#extension' do
-    it "should default the file extension to .html" do
+  describe "#extension" do
+    it "defaults the file extension to .html" do
       obj = Serializers::FileSystemSerializer.new
-      obj.extension.should == "html"
+      expect(obj.extension).to eq "html"
     end
   end
 
-  describe '#serialized_path' do
-    it "should allow no extension to be used" do
+  describe "#serialized_path" do
+    it "allows no extension to be used" do
       obj = Serializers::FileSystemSerializer.new :extension => nil
       yard = CodeObjects::ClassObject.new(nil, :FooBar)
-      obj.serialized_path(yard).should == 'FooBar'
+      expect(obj.serialized_path(yard)).to eq 'FooBar'
     end
 
-    it "should serialize to top-level-namespace for root" do
+    it "serializes to top-level-namespace for root" do
       obj = Serializers::FileSystemSerializer.new :extension => nil
-      obj.serialized_path(Registry.root).should == "top-level-namespace"
+      expect(obj.serialized_path(Registry.root)).to eq "top-level-namespace"
     end
 
-    it "should return serialized_path for a String" do
+    it "returns serialized_path for a String" do
       s = Serializers::FileSystemSerializer.new(:basepath => 'foo', :extension => 'txt')
-      s.serialized_path('test.txt').should == 'test.txt'
+      expect(s.serialized_path('test.txt')).to eq 'test.txt'
     end
 
-    it "should remove special chars from path" do
+    it "removes special chars from path" do
       m = CodeObjects::MethodObject.new(nil, 'a')
       s = Serializers::FileSystemSerializer.new
 
-      { :/ => '_2F_i.html',
-        :gsub! => 'gsub_21_i.html',
+      { :gsub! => 'gsub_21_i.html',
         :ask? => 'ask_3F_i.html',
         :=== => '_3D_3D_3D_i.html',
         :+ => '_2B_i.html',
@@ -59,25 +58,25 @@ describe YARD::Serializers::FileSystemSerializer do
         :/ => '_2F_i.html',
         :=~ => '_3D_7E_i.html'
       }.each do |meth, value|
-        m.stub!(:name).and_return(meth)
-        s.serialized_path(m).should == value
+        allow(m).to receive(:name).and_return(meth)
+        expect(s.serialized_path(m)).to eq value
       end
     end
 
-    it "should handle ExtraFileObject's" do
+    it "handles ExtraFileObject's" do
       s = Serializers::FileSystemSerializer.new
       e = CodeObjects::ExtraFileObject.new('filename.txt', '')
-      s.serialized_path(e).should == 'file.filename.html'
+      expect(s.serialized_path(e)).to eq 'file.filename.html'
     end
 
-    it "should differentiate instance and class methods from serialized path" do
+    it "differentiates instance and class methods from serialized path" do
       s = Serializers::FileSystemSerializer.new
       m1 = CodeObjects::MethodObject.new(nil, 'meth')
       m2 = CodeObjects::MethodObject.new(nil, 'meth', :class)
-      s.serialized_path(m1).should_not == s.serialized_path(m2)
+      expect(s.serialized_path(m1)).not_to eq s.serialized_path(m2)
     end
 
-    it "should serialize path from overload tag" do
+    it "serializes path from overload tag" do
       YARD.parse_string <<-'eof'
         class Foo
           # @overload bar
@@ -87,12 +86,33 @@ describe YARD::Serializers::FileSystemSerializer do
 
       serializer = Serializers::FileSystemSerializer.new
       object = Registry.at('Foo#bar').tag(:overload)
-      serializer.serialized_path(object).should == "Foo/bar_i.html"
+      expect(serializer.serialized_path(object)).to eq "Foo/bar_i.html"
+    end
+
+    it "maps matching case sensitive object names to different files on disk" do
+      Registry.clear
+      o1 = CodeObjects::ClassObject.new(:root, "AB")
+      o2 = CodeObjects::ClassObject.new(:root, "Ab")
+      s = Serializers::FileSystemSerializer.new
+      expect([["AB_.html", "Ab.html"], ["AB.html", "Ab_.html"]]).to include(
+        [s.serialized_path(o1), s.serialized_path(o2)])
+    end
+
+    it "handles case sensitivity of nested paths for objects with matching names" do
+      Registry.clear
+      YARD.parse_string <<-eof
+        class Abc; class D; end end
+        class ABC; class D; end end
+      eof
+
+      s = Serializers::FileSystemSerializer.new
+      expect(s.serialized_path(Registry.at('ABC::D'))).to eq "ABC/D.html"
+      expect(s.serialized_path(Registry.at('Abc::D'))).to eq "Abc/D.html"
     end
   end
 
-  describe '#serialize' do
-    it "should serialize to the correct path" do
+  describe "#serialize" do
+    it "serializes to the correct path" do
       yard = CodeObjects::ClassObject.new(nil, :FooBar)
       meth = CodeObjects::MethodObject.new(yard, :baz, :class)
       meth2 = CodeObjects::MethodObject.new(yard, :baz)
@@ -101,24 +121,24 @@ describe YARD::Serializers::FileSystemSerializer do
         'foo/FooBar/baz_i.txt' => meth2,
         'foo/FooBar.txt' => yard }.each do |path, obj|
         io = StringIO.new
-        File.should_receive(:open).with(path, 'wb').and_yield(io)
-        io.should_receive(:write).with("data")
+        expect(File).to receive(:open).with(path, 'wb').and_yield(io)
+        expect(io).to receive(:write).with("data")
 
         s = Serializers::FileSystemSerializer.new(:basepath => 'foo', :extension => 'txt')
         s.serialize(obj, "data")
       end
     end
 
-    it "should guarantee the directory exists" do
+    it "guarantees the directory exists" do
       o1 = CodeObjects::ClassObject.new(nil, :Really)
       o2 = CodeObjects::ClassObject.new(o1, :Long)
       o3 = CodeObjects::ClassObject.new(o2, :PathName)
       obj = CodeObjects::MethodObject.new(o3, :foo)
 
-      FileUtils.should_receive(:mkdir_p).once.with('doc/Really/Long/PathName')
+      expect(FileUtils).to receive(:mkdir_p).once.with('doc/Really/Long/PathName')
 
       s = Serializers::FileSystemSerializer.new
       s.serialize(obj, "data")
     end
   end
-end
+end

data/spec/serializers/yardoc_serializer_spec.rb

@@ -16,30 +16,30 @@ describe YARD::Serializers::YardocSerializer do
     @bar = CodeObjects::MethodObject.new(@foo, :bar)
   end
 
-  describe '#dump' do
-    it "should maintain object equality when loading a dumped object" do
+  describe "#dump" do
+    it "maintains object equality when loading a dumped object" do
       newfoo = @serializer.internal_dump(@foo)
-      newfoo.should equal(@foo)
-      newfoo.should == @foo
-      @foo.should equal(newfoo)
-      @foo.should == newfoo
-      newfoo.hash.should == @foo.hash
+      expect(newfoo).to equal(@foo)
+      expect(newfoo).to eq @foo
+      expect(@foo).to equal(newfoo)
+      expect(@foo).to eq newfoo
+      expect(newfoo.hash).to eq @foo.hash
     end
 
-    it "should maintain hash key equality when loading a dumped object" do
+    it "maintains hash key equality when loading a dumped object" do
       newfoo = @serializer.internal_dump(@foo)
-      {@foo => 1}.should have_key(newfoo)
-      {newfoo => 1}.should have_key(@foo)
+      expect({@foo => 1}).to have_key(newfoo)
+      expect({newfoo => 1}).to have_key(@foo)
     end
   end
 
-  describe '#serialize' do
-    it "should accept a hash of codeobjects (and write to root)" do
+  describe "#serialize" do
+    it "accepts a hash of codeobjects (and write to root)" do
       data = {:root => Registry.root}
       marshaldata = Marshal.dump(data)
-      filemock = mock(:file)
-      filemock.should_receive(:write).with(marshaldata)
-      File.should_receive(:open!).with('.yardoc/objects/root.dat', 'wb').and_yield(filemock)
+      filemock = double(:file)
+      expect(filemock).to receive(:write).with(marshaldata)
+      expect(File).to receive(:open!).with('.yardoc/objects/root.dat', 'wb').and_yield(filemock)
       @serializer.serialize(data)
     end
   end

data/spec/server/adapter_spec.rb

@@ -3,36 +3,36 @@ require File.dirname(__FILE__) + '/spec_helper'
 describe YARD::Server::Adapter do
   after(:all) { Server::Adapter.shutdown }
 
-  describe '#add_library' do
-    it "should add a library" do
+  describe "#add_library" do
+    it "adds a library" do
       lib = LibraryVersion.new('yard')
       a = Adapter.new({})
-      a.libraries.should be_empty
+      expect(a.libraries).to be_empty
       a.add_library(lib)
-      a.libraries['yard'].should == [lib]
+      expect(a.libraries['yard']).to eq [lib]
     end
   end
 
-  describe '#start' do
-    it "should not implement #start" do
-      lambda { Adapter.new({}).start }.should raise_error(NotImplementedError)
+  describe "#start" do
+    it "does not implement #start" do
+      expect { Adapter.new({}).start }.to raise_error(NotImplementedError)
     end
   end
 
-  describe '.setup' do
-    it 'should add template paths and helpers' do
+  describe ".setup" do
+    it "adds template paths and helpers" do
       Adapter.setup
-      Templates::Template.extra_includes.should include(DocServerHelper)
-      Templates::Engine.template_paths.should include(YARD::ROOT + '/yard/server/templates')
+      expect(Templates::Template.extra_includes).to include(DocServerHelper)
+      expect(Templates::Engine.template_paths).to include(YARD::ROOT + '/yard/server/templates')
     end
   end
 
-  describe '.shutdown' do
-    it 'should cleanup template paths and helpers' do
+  describe ".shutdown" do
+    it "cleans up template paths and helpers" do
       Adapter.setup
       Adapter.shutdown
-      Templates::Template.extra_includes.should_not include(DocServerHelper)
-      Templates::Engine.template_paths.should_not include(YARD::ROOT + '/yard/server/templates')
+      expect(Templates::Template.extra_includes).not_to include(DocServerHelper)
+      expect(Templates::Engine.template_paths).not_to include(YARD::ROOT + '/yard/server/templates')
     end
   end
 end

data/spec/server/commands/base_spec.rb

@@ -9,79 +9,79 @@ class MyCacheCommand < Base
 end
 
 describe YARD::Server::Commands::Base do
-  describe '#cache' do
+  describe "#cache" do
     before do
       @command = MyCacheCommand.new(:adapter => mock_adapter, :caching => true)
       @command.request = OpenStruct.new
     end
 
-    it "should not cache if caching == false" do
-      File.should_not_receive(:open)
+    it "does not cache if caching == false" do
+      expect(File).not_to receive(:open)
       @command.caching = false
       @command.run
     end
 
-    it "should require document root to cache" do
-      File.should_not_receive(:open)
+    it "requires document root to cache" do
+      expect(File).not_to receive(:open)
       @command.adapter.document_root = nil
       @command.run
     end
 
-    it "should cache to path/to/file.html and create directories" do
-      FileUtils.should_receive(:mkdir_p).with('/public/path/to')
-      File.should_receive(:open).with('/public/path/to/file.html', anything)
+    it "caches to path/to/file.html and create directories" do
+      expect(FileUtils).to receive(:mkdir_p).with('/public/path/to')
+      expect(File).to receive(:open).with('/public/path/to/file.html', anything)
       @command.request.path = '/path/to/file.html'
       @command.run
     end
   end
 
-  describe '#redirect' do
-    it "should return a valid redirection" do
+  describe "#redirect" do
+    it "returns a valid redirection" do
       cmd = MyProcCommand.new { redirect '/foo' }
-      cmd.call(mock_request('/foo')).should ==
-        [302, {"Content-Type" => "text/html", "Location" => "/foo"}, [""]]
+      expect(cmd.call(mock_request('/foo'))).to eq(
+        [302, {"Content-Type" => "text/html", "Location" => "/foo"}, [""]])
     end
   end
 
-  describe '#call' do
-    it "should handle a NotFoundError and use message as body" do
+  describe "#call" do
+    it "handles a NotFoundError and use message as body" do
       cmd = MyProcCommand.new { raise NotFoundError, "hello world" }
       s, h, b = *cmd.call(mock_request('/foo'))
-      s.should == 404
-      b.should == ["hello world"]
+      expect(s).to eq 404
+      expect(b).to eq ["hello world"]
     end
 
-    it "should not use message as body if not provided in NotFoundError" do
+    it "does not use message as body if not provided in NotFoundError" do
       cmd = MyProcCommand.new { raise NotFoundError }
       s, h, b = *cmd.call(mock_request('/foo'))
-      s.should == 404
-      b.should == ["Not found: /foo"]
+      expect(s).to eq 404
+      expect(b).to eq ["Not found: /foo"]
     end
 
-    it "should handle 404 status code from #run" do
+    it "handles 404 status code from #run" do
       cmd = MyProcCommand.new { self.status = 404 }
       s, h, b = *cmd.call(mock_request('/foo'))
-      s.should == 404
-      b.should == ["Not found: /foo"]
+      expect(s).to eq 404
+      expect(b).to eq ["Not found: /foo"]
     end
 
-    it "should not override body if status is 404 and body is defined" do
+    it "does not override body if status is 404 and body is defined" do
       cmd = MyProcCommand.new { self.body = "foo"; self.status = 404 }
       s, h, b = *cmd.call(mock_request('/bar'))
-      s.should == 404
-      b.should == ['foo']
+      expect(s).to eq 404
+      expect(b).to eq ['foo']
     end
 
-    it "should handle body as Array" do
+    it "handles body as Array" do
       cmd = MyProcCommand.new { self.body = ['a', 'b', 'c'] }
       s, h, b = *cmd.call(mock_request('/foo'))
-      b.should == %w(a b c)
+      expect(b).to eq %w(a b c)
     end
 
-    it "should allow headers to be defined" do
+    it "allows headers to be defined" do
       cmd = MyProcCommand.new { self.headers['Foo'] = 'BAR' }
       s, h, b = *cmd.call(mock_request('/foo'))
-      h['Foo'].should == 'BAR'
+      expect(h['Foo']).to eq 'BAR'
     end
   end
 end