yard 0.8.7.6 → 0.9.0

data/spec/cli/graph_spec.rb

@@ -1,17 +1,17 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
 describe YARD::CLI::Graph do
-  it "should serialize output" do
-    Registry.should_receive(:load).at_least(1).times
-    subject.stub(:yardopts) { [] }
-    subject.options.serializer.should_receive(:serialize).once
+  it "serializes output" do
+    expect(Registry).to receive(:load).at_least(1).times
+    allow(subject).to receive(:yardopts) { [] }
+    expect(subject.options.serializer).to receive(:serialize).once
     subject.run
   end
 
-  it 'should read yardoc file from .yardopts' do
-    subject.stub(:yardopts) { %w(--db /path/to/db) }
-    subject.options.serializer.should_receive(:serialize).once
+  it "reads yardoc file from .yardopts" do
+    allow(subject).to receive(:yardopts) { %w(--db /path/to/db) }
+    expect(subject.options.serializer).to receive(:serialize).once
     subject.run
-    Registry.yardoc_file.should == '/path/to/db'
+    expect(Registry.yardoc_file).to eq '/path/to/db'
   end
 end

data/spec/cli/help_spec.rb

@@ -1,21 +1,21 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
 describe YARD::CLI::Help do
-  describe '#run' do
-    it "should accept 'help command'" do
-      CLI::Yardoc.should_receive(:run).with('--help')
+  describe "#run" do
+    it "accepts help command" do
+      expect(CLI::Yardoc).to receive(:run).with('--help')
       CLI::Help.run('doc')
     end
 
-    it "should accept no arguments (lists all commands)" do
-      CLI::CommandParser.should_receive(:run).with('--help')
+    it "accepts no arguments (and lists all commands)" do
+      expect(CLI::CommandParser).to receive(:run).with('--help')
       CLI::Help.run
     end
 
-    it "should show all commands if command isn't found" do
-      CLI::CommandParser.should_receive(:run).with('--help')
+    it "shows all commands if command isn't found" do
+      expect(CLI::CommandParser).to receive(:run).with('--help')
       help = CLI::Help.new
-      log.should_receive(:puts).with(/not found/)
+      expect(log).to receive(:puts).with(/not found/)
       help.run('unknown')
     end
   end

data/spec/cli/i18n_spec.rb

@@ -6,105 +6,101 @@ describe YARD::CLI::I18n do
     @i18n.use_document_file = false
     @i18n.use_yardopts_file = false
     output_path = File.expand_path(@i18n.options.serializer.basepath)
-    File.stub!(:open!).with(output_path, "wb")
-    YARD.stub!(:parse)
+    allow(File).to receive(:open!).with(output_path, "wb")
+    allow(YARD).to receive(:parse)
   end
 
-  describe 'Defaults' do
+  describe "Defaults" do
     before do
       @i18n = YARD::CLI::I18n.new
-      @i18n.stub!(:yardopts).and_return([])
-      @i18n.stub!(:support_rdoc_document_file!).and_return([])
+      allow(@i18n).to receive(:yardopts).and_return([])
+      allow(@i18n).to receive(:support_rdoc_document_file!).and_return([])
       @i18n.parse_arguments
     end
 
-    it "should read .yardopts by default" do
-      @i18n.use_yardopts_file.should == true
+    it "reads .yardopts by default" do
+      expect(@i18n.use_yardopts_file).to be true
     end
 
-    it "should use {lib,app}/**/*.rb and ext/**/*.c as default file glob" do
-      @i18n.files.should == ['{lib,app}/**/*.rb', 'ext/**/*.c']
-    end
-
-    it "should only show public visibility by default" do
-      @i18n.visibilities.should == [:public]
+    it "only shows public visibility by default" do
+      expect(@i18n.visibilities).to eq [:public]
     end
   end
 
-  describe 'General options' do
+  describe "General options" do
     def self.should_accept(*args, &block)
       @counter ||= 0
       @counter += 1
       counter = @counter
       args.each do |arg|
         define_method("test_options_#{@counter}", &block)
-        it("should accept #{arg}") { send("test_options_#{counter}", arg) }
+        it("accepts #{arg}") { send("test_options_#{counter}", arg) }
       end
     end
 
     should_accept('--yardopts') do |arg|
       @i18n = YARD::CLI::I18n.new
       @i18n.use_document_file = false
-      @i18n.should_receive(:yardopts).at_least(1).times.and_return([])
+      expect(@i18n).to receive(:yardopts).at_least(1).times.and_return([])
       @i18n.parse_arguments(arg)
-      @i18n.use_yardopts_file.should == true
+      expect(@i18n.use_yardopts_file).to be true
       @i18n.parse_arguments('--no-yardopts', arg)
-      @i18n.use_yardopts_file.should == true
+      expect(@i18n.use_yardopts_file).to be true
     end
 
     should_accept('--yardopts with filename') do |arg|
       @i18n = YARD::CLI::I18n.new
-      File.should_receive(:read_binary).with('.yardopts_i18n').and_return('')
+      expect(File).to receive(:read_binary).with('.yardopts_i18n').and_return('')
       @i18n.use_document_file = false
       @i18n.parse_arguments('--yardopts', '.yardopts_i18n')
-      @i18n.use_yardopts_file.should == true
-      @i18n.options_file.should == '.yardopts_i18n'
+      expect(@i18n.use_yardopts_file).to be true
+      expect(@i18n.options_file).to eq '.yardopts_i18n'
     end
 
     should_accept('--no-yardopts') do |arg|
       @i18n = YARD::CLI::I18n.new
       @i18n.use_document_file = false
-      @i18n.should_not_receive(:yardopts)
+      expect(@i18n).not_to receive(:yardopts)
       @i18n.parse_arguments(arg)
-      @i18n.use_yardopts_file.should == false
+      expect(@i18n.use_yardopts_file).to be false
       @i18n.parse_arguments('--yardopts', arg)
-      @i18n.use_yardopts_file.should == false
+      expect(@i18n.use_yardopts_file).to be false
     end
 
     should_accept('--exclude') do |arg|
-      YARD.should_receive(:parse).with(['a'], ['nota', 'b'])
+      expect(YARD).to receive(:parse).with(['a'], ['nota', 'b'])
       @i18n.run(arg, 'nota', arg, 'b', 'a')
     end
   end
 
-  describe '.yardopts handling' do
+  describe ".yardopts handling" do
     before do
       @i18n.use_yardopts_file = true
     end
 
-    it "should search for and use yardopts file specified by #options_file" do
-      File.should_receive(:read_binary).with("test").and_return("-o \n\nMYPATH\nFILE1 FILE2")
+    it "searches for and uses yardopts file specified by #options_file" do
+      expect(File).to receive(:read_binary).with("test").and_return("-o \n\nMYPATH\nFILE1 FILE2")
       @i18n.use_document_file = false
       @i18n.options_file = "test"
-      File.should_receive(:open!).with(File.expand_path("MYPATH"), "wb")
+      expect(File).to receive(:open!).with(File.expand_path("MYPATH"), "wb")
       @i18n.run
-      @i18n.files.should == ["FILE1", "FILE2"]
+      expect(@i18n.files).to eq ["FILE1", "FILE2"]
     end
   end
 
-  describe '#run' do
-    it "should parse_arguments if run() is called" do
-      @i18n.should_receive(:parse_arguments)
+  describe "#run" do
+    it "calls parse_arguments if run() is called" do
+      expect(@i18n).to receive(:parse_arguments)
       @i18n.run
     end
 
-    it "should parse_arguments if run(arg1, arg2, ...) is called" do
-      @i18n.should_receive(:parse_arguments)
+    it "calls parse_arguments if run(arg1, arg2, ...) is called" do
+      expect(@i18n).to receive(:parse_arguments)
       @i18n.run('--private', '-p', 'foo')
     end
 
-    it "should not parse_arguments if run(nil) is called" do
-      @i18n.should_not_receive(:parse_arguments)
+    it "doesn't call parse_arguments if run(nil) is called" do
+      expect(@i18n).not_to receive(:parse_arguments)
       @i18n.run(nil)
     end
   end

data/spec/cli/list_spec.rb

@@ -1,8 +1,8 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
 describe YARD::CLI::List do
-  it "should pass command off to Yardoc with --list" do
-    YARD::CLI::Yardoc.should_receive(:run).with('-c', '--list', '--foo')
+  it "passes command off to Yardoc with --list" do
+    expect(YARD::CLI::Yardoc).to receive(:run).with('-c', '--list', '--foo')
     YARD::CLI::List.run('--foo')
   end
 end

data/spec/cli/markup_types_spec.rb

@@ -6,16 +6,16 @@ describe YARD::CLI::MarkupTypes do
     data = log.io.string
     exts = YARD::Templates::Helpers::MarkupHelper::MARKUP_EXTENSIONS
     YARD::Templates::Helpers::MarkupHelper::MARKUP_PROVIDERS.each do |name, providers|
-      data.should match(/\b#{name}\b/)
+      expect(data).to match(/\b#{name}\b/)
 
       # Match all extensions
       exts[name].each do |ext|
-        data.should include(".#{ext}")
+        expect(data).to include(".#{ext}")
       end if exts[name]
 
       # Match all provider libs
       providers.each do |provider|
-        data.should match(/\b#{provider[:lib]}\b/)
+        expect(data).to match(/\b#{provider[:lib]}\b/)
       end
     end
   end

data/spec/cli/server_spec.rb

@@ -4,15 +4,14 @@ class Server::WebrickAdapter; def start; end end
 
 describe YARD::CLI::Server do
   before do
-    CLI::Yardoc.stub!(:run)
+    allow(CLI::Yardoc).to receive(:run)
     @no_verify_libraries = false
     @set_libraries = true
     @no_adapter_mock = false
     @libraries = {}
     @options = {:single_library => true, :caching => false}
     @server_options = {:Port => 8808}
-    @adapter = mock(:adapter)
-    @adapter.stub!(:setup)
+    @adapter = double(:adapter, :setup => nil)
     new_cli
   end
 
@@ -46,15 +45,15 @@ describe YARD::CLI::Server do
       @libraries.values.each do |libs|
         libs.each do |lib|
           yfile = File.expand_path(lib.yardoc_file)
-          File.stub!(:exist?).with(yfile).and_return(true)
+          allow(File).to receive(:exist?).with(yfile).and_return(true)
         end
       end
     end
     unless @no_adapter_mock
-      @cli.stub!(:adapter).and_return(@adapter)
-      @adapter.should_receive(:new).
+      allow(@cli).to receive(:adapter).and_return(@adapter)
+      expect(@adapter).to receive(:new).
         with(@libraries, @options, @server_options).and_return(@adapter)
-      @adapter.should_receive(:start)
+      expect(@adapter).to receive(:start)
     end
 
     @cli.run(*args.flatten)
@@ -62,12 +61,12 @@ describe YARD::CLI::Server do
   end
 
   def assert_libraries(expected_libs, actual_libs)
-    actual_libs.should == expected_libs
+    expect(actual_libs).to eq expected_libs
     expected_libs.each do |name, libs|
       libs.each_with_index do |expected,i|
         actual = actual_libs[name][i]
         [:source, :source_path, :yardoc_file].each do |m|
-          actual.send(m).should == expected.send(m)
+          expect(actual.send(m)).to eq expected.send(m)
         end
       end
     end
@@ -75,34 +74,34 @@ describe YARD::CLI::Server do
 
   # Mocks the existence of a file.
   def mock_file(filename, content = nil)
-    File.stub!(:exist?).with(filename).and_return(true)
-    File.stub!(:read_binary).with(filename).and_return(content) if content
+    allow(File).to receive(:exist?).with(filename).and_return(true)
+    allow(File).to receive(:read_binary).with(filename).and_return(content) if content
     filename_e = File.expand_path(filename)
     mock_file(filename_e) unless filename_e == filename
   end
 
-  describe 'when .yardopts file exists' do
+  context 'when .yardopts file exists' do
     before :each do
       Registry.yardoc_file = Registry::DEFAULT_YARDOC_FILE
-      Dir.stub!(:pwd).and_return('/path/to/bar')
+      allow(Dir).to receive(:pwd).and_return('/path/to/bar')
       @name = 'bar'
     end
 
-    it "should use .yardoc as the yardoc db if .yardopts doesn't specify an alternate path" do
+    it "uses .yardoc as the yardoc db if .yardopts doesn't specify an alternate path" do
       mock_file '/path/to/bar/.yardopts', '--protected'
       @libraries[@name] = [Server::LibraryVersion.new(@name, nil, File.expand_path('/path/to/bar/.yardoc'))]
       @libraries.values[0][0].source_path = File.expand_path('/path/to/bar')
       run
     end
 
-    it "should use the yardoc db location specified by .yardopts" do
+    it "uses the yardoc db location specified by .yardopts" do
       mock_file '/path/to/bar/.yardopts', '--db foo'
       @libraries[@name] = [Server::LibraryVersion.new(@name, nil, File.expand_path('/path/to/bar/foo'))]
       @libraries.values[0][0].source_path = File.expand_path('/path/to/bar')
       run
     end
 
-    it "should parse .yardopts when the library list is odd" do
+    it "parses .yardopts when the library list is odd" do
       mock_file '/path/to/bar/.yardopts', '--db foo'
       @libraries['a'] = [Server::LibraryVersion.new('a', nil, File.expand_path('/path/to/bar/foo'))]
       @libraries.values[0][0].source_path = File.expand_path('/path/to/bar')
@@ -110,203 +109,190 @@ describe YARD::CLI::Server do
     end
   end
 
-  describe "when .yardopts file doesn't exist" do
+  context "when .yardopts file doesn't exist" do
     before :each do
-      File.stub(:exist?).with(/^(.*[\\\/])?\.yardopts$/).and_return(false)
+      allow(File).to receive(:exist?).with(/^(.*[\\\/])?\.yardopts$/).and_return(false)
     end
 
-    it "should default to .yardoc if no library is specified" do
-      Dir.should_receive(:pwd).at_least(:once).and_return(File.expand_path('/path/to/foo'))
+    it "defaults to .yardoc if no library is specified" do
+      expect(Dir).to receive(:pwd).at_least(:once).and_return(File.expand_path('/path/to/foo'))
       @libraries['foo'] = [Server::LibraryVersion.new('foo', nil, File.expand_path('/path/to/foo/.yardoc'))]
       run
     end
 
-    it "should use .yardoc as yardoc file if library list is odd" do
+    it "uses .yardoc as yardoc file if library list is odd" do
       @libraries['a'] = [Server::LibraryVersion.new('a', nil, File.expand_path('.yardoc'))]
       run 'a'
     end
 
-    it "should force multi library if more than one library is listed" do
-      File.stub(:exist?).with('b').and_return(true)
+    it "forces multi library if more than one library is listed" do
+      allow(File).to receive(:exist?).with('b').and_return(true)
       @options[:single_library] = false
       @libraries['a'] = [Server::LibraryVersion.new('a', nil, File.expand_path('b'))]
       @libraries['c'] = [Server::LibraryVersion.new('c', nil, File.expand_path('.yardoc'))]
       run %w(a b c)
     end
 
-    it "should fail if specified directory does not exist" do
+    it "fails if specified directory does not exist" do
       @set_libraries = false
-      File.stub(:exist?).with('b').and_return(false)
-      log.should_receive(:warn).with(/Cannot find yardoc db for a: "b"/)
+      allow(File).to receive(:exist?).with('b').and_return(false)
+      expect(log).to receive(:warn).with(/Cannot find yardoc db for a: "b"/)
       run %w(a b)
     end
   end
 
-  describe 'General options' do
+  describe "General options" do
     before do
-      File.stub(:exist?).with(/\.yardopts$/).and_return(false)
+      allow(File).to receive(:exist?).with(/\.yardopts$/).and_return(false)
     end
 
-    it "should accept -m, --multi-library" do
+    it "accepts -m, --multi-library" do
       @options[:single_library] = false
       run '-m'
       run '--multi-library'
     end
 
-    it "should accept -c, --cache" do
+    it "accepts -c, --cache" do
       @options[:caching] = true
       run '-c'
       run '--cache'
     end
 
-    it "should accept -r, --reload" do
+    it "accepts -r, --reload" do
       @options[:incremental] = true
       run '-r'
       run '--reload'
     end
 
-    it "should accept -d, --daemon" do
+    it "accepts -d, --daemon" do
       @server_options[:daemonize] = true
       run '-d'
       run '--daemon'
     end
 
-    it "should accept -B, --bind" do
+    it "accepts -B, --bind" do
       @server_options[:Host] = 'example.com'
       run '-B', 'example.com'
       run '--bind', 'example.com'
     end    
 
-    it "should bind address with WebRick adapter" do
+    it "binds address with WebRick adapter" do
       @server_options[:Host] = 'example.com'
       run '-B', 'example.com', '-a', 'webrick'
       run '--bind', 'example.com', '-a', 'webrick'
     end  
 
-    it "should bind address with Rack adapter" do
+    it "binds address with Rack adapter" do
       @server_options[:Host] = 'example.com'
       run '-B', 'example.com', '-a', 'rack'
       run '--bind', 'example.com', '-a', 'rack'
     end          
 
-    it "should accept -p, --port" do
+    it "accepts -p, --port" do
       @server_options[:Port] = 10
       run '-p', '10'
       run '--port', '10'
     end
 
-    it "should accept --docroot" do
+    it "accepts --docroot" do
       @server_options[:DocumentRoot] = Dir.pwd + '/__foo/bar'
       run '--docroot', '__foo/bar'
     end
 
-    it "should accept -a webrick to create WEBrick adapter" do
-      @cli.should_receive(:adapter=).with(YARD::Server::WebrickAdapter)
+    it "accepts -a webrick to create WEBrick adapter" do
+      expect(@cli).to receive(:adapter=).with(YARD::Server::WebrickAdapter)
       run '-a', 'webrick'
     end
 
-    it "should accept -a rack to create Rack adapter" do
+    it "accepts -a rack to create Rack adapter" do
       rack_required
-      @cli.should_receive(:adapter=).with(YARD::Server::RackAdapter)
+      expect(@cli).to receive(:adapter=).with(YARD::Server::RackAdapter)
       run '-a', 'rack'
     end
 
-    it "should default to Rack adapter if exists on system" do
+    it "defaults to Rack adapter if exists on system" do
       rack_required
-      @cli.should_receive(:require).with('rubygems').and_return(false)
-      @cli.should_receive(:require).with('rack').and_return(true)
-      @cli.should_receive(:adapter=).with(YARD::Server::RackAdapter)
+      expect(@cli).to receive(:require).with('rubygems').and_return(false)
+      expect(@cli).to receive(:require).with('rack').and_return(true)
+      expect(@cli).to receive(:adapter=).with(YARD::Server::RackAdapter)
       @cli.send(:select_adapter)
     end
 
-    it "should fall back to WEBrick adapter if Rack is not on system" do
-      @cli.should_receive(:require).with('rubygems').and_return(false)
-      @cli.should_receive(:require).with('rack').and_raise(LoadError)
-      @cli.should_receive(:adapter=).with(YARD::Server::WebrickAdapter)
+    it "falls back to WEBrick adapter if Rack is not on system" do
+      expect(@cli).to receive(:require).with('rubygems').and_return(false)
+      expect(@cli).to receive(:require).with('rack').and_raise(LoadError)
+      expect(@cli).to receive(:adapter=).with(YARD::Server::WebrickAdapter)
       @cli.send(:select_adapter)
     end
 
-    it "should accept -s, --server" do
+    it "accepts -s, --server" do
       @server_options[:server] = 'thin'
       run '-s', 'thin'
       run '--server', 'thin'
     end
 
-    it "should accept -g, --gems" do
+    it "accepts -g, --gems" do
       @no_verify_libraries = true
       @options[:single_library] = false
       @libraries['gem1'] = [Server::LibraryVersion.new('gem1', '1.0.0', nil, :gem)]
       @libraries['gem2'] = [Server::LibraryVersion.new('gem2', '1.0.0', nil, :gem)]
-      gem1 = mock(:gem1)
-      gem1.stub!(:name).and_return('gem1')
-      gem1.stub!(:version).and_return('1.0.0')
-      gem1.stub!(:full_gem_path).and_return('/path/to/foo')
-      gem2 = mock(:gem2)
-      gem2.stub!(:name).and_return('gem2')
-      gem2.stub!(:version).and_return('1.0.0')
-      gem2.stub!(:full_gem_path).and_return('/path/to/bar')
+      gem1 = double(:gem1, :name => 'gem1', :version => '1.0.0', :full_gem_path => '/path/to/foo')
+      gem2 = double(:gem2, :name => 'gem2', :version => '1.0.0', :full_gem_path => '/path/to/bar')
       specs = {'gem1' => gem1, 'gem2' => gem2}
-      source = mock(:source_index)
-      source.stub!(:find_name).and_return do |k, ver|
+      source = double(:source_index)
+      allow(source).to receive(:find_name) do |k, ver|
         k == '' ? specs.values : specs.grep(k).map {|name| specs[name] }
       end
-      Gem.stub!(:source_index).and_return(source)
+      allow(Gem).to receive(:source_index).and_return(source)
       run '-g'
       run '--gems'
     end
 
-    it "should accept -G, --gemfile" do
+    it "accepts -G, --gemfile" do
       bundler_required
       @no_verify_libraries = true
       @options[:single_library] = false
 
       @libraries['gem1'] = [Server::LibraryVersion.new('gem1', '1.0.0', nil, :gem)]
       @libraries['gem2'] = [Server::LibraryVersion.new('gem2', '1.0.0', nil, :gem)]
-      gem1 = mock(:gem1)
-      gem1.stub!(:name).and_return('gem1')
-      gem1.stub!(:version).and_return('1.0.0')
-      gem1.stub!(:full_gem_path).and_return('/path/to/foo')
-      gem2 = mock(:gem2)
-      gem2.stub!(:name).and_return('gem2')
-      gem2.stub!(:version).and_return('1.0.0')
-      gem2.stub!(:full_gem_path).and_return('/path/to/bar')
+      gem1 = double(:gem1, :name => 'gem1', :version => '1.0.0', :full_gem_path => '/path/to/foo')
+      gem2 = double(:gem2, :name => 'gem2', :version => '1.0.0', :full_gem_path => '/path/to/bar')
       specs = {'gem1' => gem1, 'gem2' => gem2}
-      lockfile_parser = mock(:new)
-      lockfile_parser.stub!(:specs).and_return([gem1, gem2])
-      Bundler::LockfileParser.stub!(:new).and_return(lockfile_parser)
+      lockfile_parser = double(:new, :specs => [gem1, gem2])
+      allow(Bundler::LockfileParser).to receive(:new).and_return(lockfile_parser)
 
-      File.should_receive(:exist?).at_least(2).times.with("Gemfile.lock").and_return(true)
-      File.stub!(:read)
+      expect(File).to receive(:exist?).at_least(2).times.with("Gemfile.lock").and_return(true)
+      allow(File).to receive(:read)
 
       run '-G'
       run '--gemfile'
 
-      File.should_receive(:exist?).with("different_name.lock").and_return(true)
+      expect(File).to receive(:exist?).with("different_name.lock").and_return(true)
       run '--gemfile', 'different_name'
     end
 
-    it "should warn if lockfile is not found (with -G)" do
+    it "warns if lockfile is not found (with -G)" do
       bundler_required
-      File.should_receive(:exist?).with(/\.yardopts$/).at_least(:once).and_return(false)
-      File.should_receive(:exist?).with('somefile.lock').and_return(false)
-      log.should_receive(:warn).with(/Cannot find somefile.lock/)
+      expect(File).to receive(:exist?).with(/\.yardopts$/).at_least(:once).and_return(false)
+      expect(File).to receive(:exist?).with('somefile.lock').and_return(false)
+      expect(log).to receive(:warn).with(/Cannot find somefile.lock/)
       run '-G', 'somefile'
     end
 
-    it "should error if Bundler not available (with -G)" do
-      @cli.should_receive(:require).with('bundler').and_raise(LoadError)
-      log.should_receive(:error).with(/Bundler not available/)
+    it "displays an error if Bundler not available (with -G)" do
+      expect(@cli).to receive(:require).with('bundler').and_raise(LoadError)
+      expect(log).to receive(:error).with(/Bundler not available/)
       run '-G'
     end
 
-    it "should load template paths after adapter template paths" do
+    it "loads template paths after adapter template paths" do
       unstub_adapter
       @cli.adapter = Server::WebrickAdapter
       run '-t', 'foo'
-      Templates::Engine.template_paths.last.should == 'foo'
+      expect(Templates::Engine.template_paths.last).to eq 'foo'
     end
 
-    it "should load ruby code (-e) after adapter" do
+    it "loads ruby code (-e) after adapter" do
       unstub_adapter
       @cli.adapter = Server::WebrickAdapter
       path = File.dirname(__FILE__) + '/tmp.adapterscript.rb'
@@ -315,7 +301,7 @@ describe YARD::CLI::Server do
           f.puts "YARD::Templates::Engine.register_template_path 'foo'"
           f.flush
           run '-e', f.path
-          Templates::Engine.template_paths.last.should == 'foo'
+          expect(Templates::Engine.template_paths.last).to eq 'foo'
         end
       ensure
         File.unlink(path)