yard 0.8.7.6 → 0.9.0

data/spec/server/commands/library_command_spec.rb

@@ -3,37 +3,37 @@ require 'ostruct'
 
 describe YARD::Server::Commands::LibraryCommand do
   before do
-    Templates::Engine.stub!(:render)
-    Templates::Engine.stub!(:generate)
-    YARD.stub!(:parse)
-    Registry.stub!(:load)
-    Registry.stub!(:save)
+    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)
 
     @cmd = LibraryCommand.new(:adapter => mock_adapter)
     @request = OpenStruct.new(:xhr? => false, :path => "/foo")
     @library = OpenStruct.new(:source_path => '.')
     @cmd.library = @library
-    @cmd.stub!(:load_yardoc).and_return(nil)
+    allow(@cmd).to receive(:load_yardoc).and_return(nil)
   end
 
   def call
-    lambda { @cmd.call(@request) }.should raise_error(NotImplementedError)
+    expect { @cmd.call(@request) }.to raise_error(NotImplementedError)
   end
 
   describe "#call" do
-    it "should raise NotImplementedError" do
+    it "raises NotImplementedError" do
       call
     end
 
-    it "should set :rdoc as the default markup in incremental mode" do
+    it "sets :rdoc as the default markup in incremental mode" do
       @cmd.incremental = true
       call
-      @cmd.options[:markup].should == :rdoc
+      expect(@cmd.options[:markup]).to eq :rdoc
     end
 
-    it "should set :rdoc as the default markup in regular mode" do
+    it "sets :rdoc as the default markup in regular mode" do
       call
-      @cmd.options[:markup].should == :rdoc
+      expect(@cmd.options[:markup]).to eq :rdoc
     end
   end
 end

data/spec/server/commands/static_file_command_spec.rb

@@ -7,60 +7,60 @@ describe YARD::Server::Commands::StaticFileCommand do
     @cmd = StaticFileCommand.new(:adapter => adapter)
   end
 
-  describe '#run' do
+  describe "#run" do
     def run(path, status = nil, body = nil)
       s, h, b = *@cmd.call(mock_request(path))
-      body.should == b.first if body
-      status.should == s if status
+      expect(body).to eq b.first if body
+      expect(status).to eq s if status
       [s, h, b]
     end
 
-    it "should search through document root before static paths" do
-      File.should_receive(:exist?).with('/c/path/to/file.txt').ordered.and_return(false)
+    it "searches through document root before static paths" do
+      expect(File).to receive(:exist?).with('/c/path/to/file.txt').ordered.and_return(false)
       StaticFileCommand::STATIC_PATHS.reverse.each do |path|
-        File.should_receive(:exist?).with(File.join(path, 'path/to/file.txt')).ordered.and_return(false)
+        expect(File).to receive(:exist?).with(File.join(path, 'path/to/file.txt')).ordered.and_return(false)
       end
       run '/path/to/file.txt'
     end
 
-    it "should return file contents if found" do
+    it "returns file contents if found" do
       tpl = Templates::Engine.template(:default, :fulldoc, :html)
-      File.should_receive(:exist?).with('/c/path/to/file.txt').and_return(false)
-      tpl.should_receive(:find_file).with('/path/to/file.txt').and_return('/path/to/foo')
-      File.should_receive(:read).with('/path/to/foo').and_return('FOO')
+      expect(File).to receive(:exist?).with('/c/path/to/file.txt').and_return(false)
+      expect(tpl).to receive(:find_file).with('/path/to/file.txt').and_return('/path/to/foo')
+      expect(File).to receive(:read).with('/path/to/foo').and_return('FOO')
       run('/path/to/file.txt', 200, 'FOO')
     end
 
-    it "should allow registering of new paths and use those before other static paths" do
+    it "allows registering of new paths and use those before other static paths" do
       Server.register_static_path '/foo'
       path = '/foo/path/to/file.txt'
-      File.should_receive(:exist?).with('/c/path/to/file.txt').and_return(false)
-      File.should_receive(:exist?).with(path).and_return(true)
-      File.should_receive(:read).with(path).and_return('FOO')
+      expect(File).to receive(:exist?).with('/c/path/to/file.txt').and_return(false)
+      expect(File).to receive(:exist?).with(path).and_return(true)
+      expect(File).to receive(:read).with(path).and_return('FOO')
       run('/path/to/file.txt', 200, 'FOO')
     end
 
-    it "should not use registered path before docroot" do
+    it "does not use registered path before docroot" do
       Server.register_static_path '/foo'
       path = '/foo/path/to/file.txt'
-      File.should_receive(:exist?).with('/c/path/to/file.txt').and_return(true)
-      File.should_receive(:read).with('/c/path/to/file.txt').and_return('FOO')
+      expect(File).to receive(:exist?).with('/c/path/to/file.txt').and_return(true)
+      expect(File).to receive(:read).with('/c/path/to/file.txt').and_return('FOO')
       run('/c/path/to/file.txt', 200, 'FOO')
     end
 
-    it "should return 404 if not found" do
-      File.should_receive(:exist?).with('/c/path/to/file.txt').ordered.and_return(false)
+    it "returns 404 if not found" do
+      expect(File).to receive(:exist?).with('/c/path/to/file.txt').ordered.and_return(false)
       StaticFileCommand::STATIC_PATHS.reverse.each do |path|
-        File.should_receive(:exist?).with(File.join(path, 'path/to/file.txt')).ordered.and_return(false)
+        expect(File).to receive(:exist?).with(File.join(path, 'path/to/file.txt')).ordered.and_return(false)
       end
       run('/path/to/file.txt', 404)
     end
 
-    it "should return text/html for file with no extension" do
-      File.should_receive(:exist?).with('/c/file').and_return(true)
-      File.should_receive(:read).with('/c/file')
+    it "returns text/html for file with no extension" do
+      expect(File).to receive(:exist?).with('/c/file').and_return(true)
+      expect(File).to receive(:read).with('/c/file')
       s, h, b = *run('/file')
-      h['Content-Type'].should == 'text/html'
+      expect(h['Content-Type']).to eq 'text/html'
     end
 
     {
@@ -73,11 +73,11 @@ describe YARD::Server::Commands::StaticFileCommand do
       "txt" => "text/plain",
       "unknown" => "application/octet-stream"
     }.each do |ext, mime|
-      it "should serve file.#{ext} as #{mime}" do
-        File.should_receive(:exist?).with('/c/file.' + ext).and_return(true)
-        File.should_receive(:read).with('/c/file.' + ext)
+      it "serves file.#{ext} as #{mime}" do
+        expect(File).to receive(:exist?).with('/c/file.' + ext).and_return(true)
+        expect(File).to receive(:read).with('/c/file.' + ext)
         s, h, b = *run('/file.' + ext)
-        h['Content-Type'].should == mime
+        expect(h['Content-Type']).to eq mime
       end
     end
   end

data/spec/server/doc_server_helper_spec.rb

@@ -31,23 +31,23 @@ describe YARD::Server::DocServerHelper do
     @helper = MockDocServerHelper.new
   end
 
-  describe '#url_for' do
-    it "should not link to /library/ if single_library = true" do
+  describe "#url_for" do
+    it "does not link to /library/ if single_library = true" do
       @helper.single_library = true
-      @helper.url_for(Registry.root).should == "/PREFIX/toplevel"
+      expect(@helper.url_for(Registry.root)).to eq "/PREFIX/toplevel"
     end
 
-    it "should return /PREFIX/foo/version if foo has a version" do
+    it "returns /PREFIX/foo/version if foo has a version" do
       @helper.library = LibraryVersion.new('foo', 'bar')
       @helper.adapter.router.request.version_supplied = true
-      @helper.url_for(P('A')).should == '/PREFIX/foo/bar/A'
+      expect(@helper.url_for(P('A'))).to eq '/PREFIX/foo/bar/A'
     end
   end
 
-  describe '#url_for_file' do
-    it "should properly link file objects using file/ prefix" do
+  describe "#url_for_file" do
+    it "properly links file objects using file/ prefix" do
       file = CodeObjects::ExtraFileObject.new('a/b/FooBar.md', '')
-      @helper.url_for_file(file).should == '/PREFIX/foo/file/a/b/FooBar.md'
+      expect(@helper.url_for_file(file)).to eq '/PREFIX/foo/file/a/b/FooBar.md'
     end
   end
 end

data/spec/server/doc_server_serializer_spec.rb

@@ -1,7 +1,7 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
 describe YARD::Server::DocServerSerializer do
-  describe '#serialized_path' do
+  describe "#serialized_path" do
     before do
       Registry.clear
       @serializer = Server::DocServerSerializer.new
@@ -9,45 +9,50 @@ describe YARD::Server::DocServerSerializer do
 
     after(:all) { Server::Adapter.shutdown }
 
-    it "should return '/PREFIX/library/toplevel' for root" do
-      @serializer.serialized_path(Registry.root).should == "toplevel"
+    it "returns '/PREFIX/library/toplevel' for root" do
+      expect(@serializer.serialized_path(Registry.root)).to eq "toplevel"
     end
 
-    it "should return /PREFIX/library/Object for Object in a library" do
-      @serializer.serialized_path(P('A::B::C')).should == 'A/B/C'
+    it "returns /PREFIX/library/Object for Object in a library" do
+      expect(@serializer.serialized_path(P('A::B::C'))).to eq 'A/B/C'
     end
 
-    it "should link to instance method as Class:method" do
+    it "links to instance method as Class:method" do
       obj = CodeObjects::MethodObject.new(:root, :method)
-      @serializer.serialized_path(obj).should == 'toplevel:method'
+      expect(@serializer.serialized_path(obj)).to eq 'toplevel:method'
     end
 
-    it "should link to class method as Class.method" do
+    it "links to class method as Class.method" do
       obj = CodeObjects::MethodObject.new(:root, :method, :class)
-      @serializer.serialized_path(obj).should == 'toplevel.method'
+      expect(@serializer.serialized_path(obj)).to eq 'toplevel.method'
     end
 
-    it "should link to anchor for constant" do
+    it "links to anchor for constant" do
       obj = CodeObjects::ConstantObject.new(:root, :FOO)
-      @serializer.serialized_path(obj).should == 'toplevel#FOO-constant'
+      expect(@serializer.serialized_path(obj)).to eq 'toplevel#FOO-constant'
     end
 
-    it "should link to anchor for class variable" do
+    it "links to anchor for class variable" do
       obj = CodeObjects::ClassVariableObject.new(:root, :@@foo)
-      @serializer.serialized_path(obj).should == 'toplevel#@@foo-classvariable'
+      expect(@serializer.serialized_path(obj)).to eq 'toplevel#@@foo-classvariable'
     end
 
-    it "should link files using file/ prefix" do
+    it "links files using file/ prefix" do
       file = CodeObjects::ExtraFileObject.new('a/b/FooBar.md', '')
-      @serializer.serialized_path(file).should == 'file/FooBar'
+      expect(@serializer.serialized_path(file)).to eq 'file/FooBar'
     end
 
-    it "should handle unicode data" do
+    it "escapes special characters" do
+      obj = CodeObjects::MethodObject.new(:root, :method?)
+      expect(@serializer.serialized_path(obj)).to eq 'toplevel:method%3F'
+    end
+
+    it "handles unicode data" do
       file = CodeObjects::ExtraFileObject.new("test\u0160", '')
       if file.name.encoding == Encoding.find("Windows-1252")
-        @serializer.serialized_path(file).should == 'file/test_8A'
+        expect(@serializer.serialized_path(file)).to eq 'file/test_8A'
       else
-        @serializer.serialized_path(file).should == 'file/test_C5A0'
+        expect(@serializer.serialized_path(file)).to eq 'file/test_C5A0'
       end
     end if defined?(::Encoding)
   end

data/spec/server/rack_adapter_spec.rb

@@ -3,18 +3,18 @@ require File.dirname(__FILE__) + "/spec_helper"
 describe "YARD::Server::RackMiddleware" do
   before do
     begin; require 'rack'; rescue LoadError; pending "rack required for these tests" end
-    @superapp = mock(:superapp)
+    @superapp = double(:superapp)
     @app = YARD::Server::RackMiddleware.new(@superapp, :libraries => {'foo' => [LibraryVersion.new('foo', nil)]})
   end
 
   after(:all) { YARD::Server::Adapter.shutdown }
 
-  it "should handle requests" do
-    @app.call(Rack::MockRequest.env_for('/'))[0].should == 200
+  it "handles requests" do
+    expect(@app.call(Rack::MockRequest.env_for('/'))[0]).to eq 200
   end
 
-  it "should pass up to the next middleware on 404" do
-    @superapp.should_receive(:call).and_return([200, {}, ['OK']])
-    @app.call(Rack::MockRequest.env_for('/INVALID')).should == [200, {}, ['OK']]
+  it "passes up to the next middleware on 404" do
+    expect(@superapp).to receive(:call).and_return([200, {}, ['OK']])
+    expect(@app.call(Rack::MockRequest.env_for('/INVALID'))).to eq [200, {}, ['OK']]
   end
 end

data/spec/server/router_spec.rb

@@ -15,7 +15,7 @@ describe YARD::Server::Router do
     @request = mock_request
   end
 
-  describe '#parse_library_from_path' do
+  describe "#parse_library_from_path" do
     def parse(*args)
       @request.path = '/' + args.join('/')
       @router = MyRouterSpecRouter.new(@adapter)
@@ -23,36 +23,36 @@ describe YARD::Server::Router do
       @router.parse_library_from_path(args.flatten)
     end
 
-    it "should parse library and version name out of path" do
-      parse('project', '1.0.0').should == [@projects[0], []]
-      @request.version_supplied.should be_true
+    it "parses library and version name out of path" do
+      expect(parse('project', '1.0.0')).to eq [@projects[0], []]
+      expect(@request.version_supplied).to be true
     end
 
-    it "should parse library and use latest version if version is not supplied" do
-      parse('project').should == [@projects[1], []]
-      @request.version_supplied.should be_false
+    it "parses library and use latest version if version is not supplied" do
+      expect(parse('project')).to eq [@projects[1], []]
+      expect(@request.version_supplied).to be false
     end
 
-    it "should parse library and use latest version if next component is not a version" do
-      parse('project', 'notaversion').should == [@projects[1], ['notaversion']]
-      @request.version_supplied.should be_false
+    it "parses library and use latest version if next component is not a version" do
+      expect(parse('project', 'notaversion')).to eq [@projects[1], ['notaversion']]
+      expect(@request.version_supplied).to be false
     end
 
-    it "should return nil library if no library is found" do
-      parse('notproject').should == [nil, ['notproject']]
+    it "returns nil library if no library is found" do
+      expect(parse('notproject')).to eq [nil, ['notproject']]
     end
 
-    it "should not parse library or version if single_library == true" do
-      @adapter.stub!(:options).and_return(:single_library => true)
-      parse('notproject').should == [@projects[0], ['notproject']]
+    it "does not parse library or version if single_library == true" do
+      allow(@adapter).to receive(:options).and_return(:single_library => true)
+      expect(parse('notproject')).to eq [@projects[0], ['notproject']]
     end
   end
 
-  describe '#route' do
+  describe "#route" do
     def route_to(route, command, *args)
       req = mock_request(route)
       router = MyRouterSpecRouter.new(@adapter)
-      command.should_receive(:new).and_return do |*args|
+      expect(command).to receive(:new) do |*args|
         @command = command.allocate
         @command.send(:initialize, *args)
         class << @command; def call(req); self end end
@@ -61,61 +61,61 @@ describe YARD::Server::Router do
       router.call(req)
     end
 
-    it "should route /docs/OBJECT to object if single_library = true" do
-      @adapter.stub!(:options).and_return(:single_library => true)
+    it "routes /docs/OBJECT to object if single_library = true" do
+      allow(@adapter).to receive(:options).and_return(:single_library => true)
       route_to('/mydocs/foo/FOO', DisplayObjectCommand)
     end
 
-    it "should route /docs" do
+    it "routes /docs" do
       route_to('/mydocs/foo', LibraryIndexCommand)
     end
 
-    it "should route /docs as index for library if single_library == true" do
-      @adapter.stub!(:options).and_return(:single_library => true)
+    it "routes /docs as index for library if single_library == true" do
+      allow(@adapter).to receive(:options).and_return(:single_library => true)
       route_to('/mydocs/foo/', DisplayObjectCommand)
     end
 
-    it "should route /docs/name/version" do
+    it "routes /docs/name/version" do
       route_to('/mydocs/foo/project/1.0.0', DisplayObjectCommand)
-      @command.library.should == @projects[0]
+      expect(@command.library).to eq @projects[0]
     end
 
-    it "should route /docs/name/ to latest version of library" do
+    it "routes /docs/name/ to latest version of library" do
       route_to('/mydocs/foo/project', DisplayObjectCommand)
-      @command.library.should == @projects[1]
+      expect(@command.library).to eq @projects[1]
     end
 
-    it "should route /list/name/version/class" do
+    it "routes /list/name/version/class" do
       route_to('/mylist/foo/project/1.0.0/class', ListCommand)
-      @command.library.should == @projects[0]
+      expect(@command.library).to eq @projects[0]
     end
 
-    it "should route /list/name/version/methods" do
+    it "routes /list/name/version/methods" do
       route_to('/mylist/foo/project/1.0.0/methods', ListCommand)
-      @command.library.should == @projects[0]
+      expect(@command.library).to eq @projects[0]
     end
 
-    it "should route /list/name/version/files" do
+    it "routes /list/name/version/files" do
       route_to('/mylist/foo/project/1.0.0/files', ListCommand)
-      @command.library.should == @projects[0]
+      expect(@command.library).to eq @projects[0]
     end
 
-    it "should route /list/name to latest version of library" do
+    it "routes /list/name to latest version of library" do
       route_to('/mylist/foo/project/class', ListCommand)
-      @command.library.should == @projects[1]
+      expect(@command.library).to eq @projects[1]
     end
 
-    it "should route /search/name/version" do
+    it "routes /search/name/version" do
       route_to('/mysearch/foo/project/1.0.0', SearchCommand)
-      @command.library.should == @projects[0]
+      expect(@command.library).to eq @projects[0]
     end
 
-    it "should route /search/name to latest version of library" do
+    it "routes /search/name to latest version of library" do
       route_to('/mysearch/foo/project', SearchCommand)
-      @command.library.should == @projects[1]
+      expect(@command.library).to eq @projects[1]
     end
 
-    it "should search static files for non-existent library" do
+    it "searches static files for non-existent library" do
       route_to('/mydocs/foo/notproject', StaticFileCommand)
     end
   end

data/spec/server/static_caching_spec.rb

@@ -3,37 +3,37 @@ require File.dirname(__FILE__) + '/spec_helper'
 describe YARD::Server::StaticCaching do
   include StaticCaching
 
-  describe '#check_static_cache' do
+  describe "#check_static_cache" do
     def adapter; @adapter ||= mock_adapter end
     def request; @request ||= OpenStruct.new end
 
-    it "should return nil if document root is not set" do
+    it "returns nil if document root is not set" do
       adapter.document_root = nil
-      check_static_cache.should be_nil
+      expect(check_static_cache).to be nil
     end
 
-    it "should read a file from document root if path matches file on system" do
+    it "reads a file from document root if path matches file on system" do
       request.path = '/hello/world.html'
-      File.should_receive(:file?).with('/public/hello/world.html').and_return(true)
-      File.should_receive(:open).with('/public/hello/world.html', anything).and_return('body')
+      expect(File).to receive(:file?).with('/public/hello/world.html').and_return(true)
+      expect(File).to receive(:open).with('/public/hello/world.html', anything).and_return('body')
       s, h, b = *check_static_cache
-      s.should == 200
-      b.should == ["body"]
+      expect(s).to eq 200
+      expect(b).to eq ["body"]
     end
 
-    it "should read a file if path matches file on system + .html" do
+    it "reads a file if path matches file on system + .html" do
       request.path = '/hello/world'
-      File.should_receive(:file?).with('/public/hello/world.html').and_return(true)
-      File.should_receive(:open).with('/public/hello/world.html', anything).and_return('body')
+      expect(File).to receive(:file?).with('/public/hello/world.html').and_return(true)
+      expect(File).to receive(:open).with('/public/hello/world.html', anything).and_return('body')
       s, h, b = *check_static_cache
-      s.should == 200
-      b.should == ["body"]
+      expect(s).to eq 200
+      expect(b).to eq ["body"]
     end
 
-    it "should return nil if no matching file is found" do
+    it "returns nil if no matching file is found" do
       request.path = '/hello/foo'
-      File.should_receive(:file?).with('/public/hello/foo.html').and_return(false)
-      check_static_cache.should == nil
+      expect(File).to receive(:file?).with('/public/hello/foo.html').and_return(false)
+      expect(check_static_cache).to eq nil
     end
   end
 end