rspec-core 2.12.2 → 2.13.0

data/lib/rspec/core/metadata.rb

@@ -126,8 +126,12 @@ module RSpec
 
         def described_class
           container_stack.each do |g|
-            return g[:described_class] if g.has_key?(:described_class)
-            return g[:describes]       if g.has_key?(:describes)
+            [:described_class, :describes].each do |key|
+              if g.has_key?(key)
+                value = g[key]
+                return value unless value.nil?
+              end
+            end
           end
 
           container_stack.reverse.each do |g|

data/lib/rspec/core/option_parser.rb

@@ -135,8 +135,14 @@ module RSpec::Core
           options[:color] = o
         end
 
-        parser.on('-p', '--profile', 'Enable profiling of examples and list 10 slowest examples.') do |o|
-          options[:profile_examples] = o
+        parser.on('-p', '--[no-]profile [COUNT]', 'Enable profiling of examples and list the slowest examples (default: 10).') do |argument|
+          options[:profile_examples] = if argument.nil?
+                                         true
+                                       elsif argument == false
+                                         false
+                                       else
+                                         argument.to_i
+                                       end
         end
 
         parser.separator <<-FILTERING

data/lib/rspec/core/pending.rb

@@ -68,6 +68,13 @@ module RSpec
       #       it "does something", :pending => true do
       #         # ...
       #       end
+      #
+      #   or pass `:pending => "something else getting finished"` to add a
+      #   message to the summary report:
+      #
+      #       it "does something", :pending => "something else getting finished" do
+      #         # ...
+      #       end
       def pending(*args)
         return self.class.before(:each) { pending(*args) } unless example
 

data/lib/rspec/core/shared_context.rb

@@ -18,7 +18,7 @@ module RSpec
     #     end
     module SharedContext
       include Hooks
-      include Let::ExampleGroupMethods
+      include MemoizedHelpers::ClassMethods
 
       def included(group)
         [:before, :after].each do |type|

data/lib/rspec/core/version.rb

@@ -1,7 +1,7 @@
 module RSpec
   module Core
     module Version
-      STRING = '2.12.2'
+      STRING = '2.13.0'
     end
   end
 end

data/spec/autotest/failed_results_re_spec.rb

@@ -16,14 +16,14 @@ describe "failed_results_re for autotest" do
   shared_examples "autotest failed_results_re" do
     it "matches a failure" do
       output = run_example { fail }
-      output.should match(Autotest::Rspec2.new.failed_results_re)
-      output.should include(__FILE__.sub(File.expand_path('.'),'.'))
+      expect(output).to match(Autotest::Rspec2.new.failed_results_re)
+      expect(output).to include(__FILE__.sub(File.expand_path('.'),'.'))
     end
 
     it "does not match when there are no failures" do
       output = run_example { } # pass
-      output.should_not match(Autotest::Rspec2.new.failed_results_re)
-      output.should_not include(__FILE__.sub(File.expand_path('.'),'.'))
+      expect(output).not_to match(Autotest::Rspec2.new.failed_results_re)
+      expect(output).not_to include(__FILE__.sub(File.expand_path('.'),'.'))
     end
   end
 

data/spec/autotest/rspec_spec.rb

@@ -11,8 +11,7 @@ describe Autotest::Rspec2 do
 
   it "uses autotest's prefix" do
     rspec_autotest.prefix = "this is the prefix "
-    rspec_autotest.
-      make_test_cmd({'a' => 'b'}).should match(/this is the prefix/)
+    expect(rspec_autotest.make_test_cmd({'a' => 'b'})).to match(/this is the prefix/)
   end
 
   describe "commands" do
@@ -28,37 +27,43 @@ describe Autotest::Rspec2 do
       @to_test = files.map { |f| File.expand_path(f) }.join ' '
     end
 
+    it "uses double quotes for windows compatibility" do
+      command = rspec_autotest.make_test_cmd(@files_to_test)
+      expect(command).to include('"')
+      expect(command).not_to include("'")
+    end
+
     it "makes the appropriate test command" do
       actual_command = rspec_autotest.make_test_cmd(@files_to_test)
-      expected_command = /#{ruby_cmd}.*'#{spec_cmd}' (.*)/
+      expected_command = /#{ruby_cmd}.*"#{spec_cmd}" (.*)/
 
-      actual_command.should match(expected_command)
+      expect(actual_command).to match(expected_command)
 
       actual_command =~ expected_command
-      $1.should =~ /#{File.expand_path('file_one')}/
-      $1.should =~ /#{File.expand_path('file_two')}/
+      expect($1).to match /#{File.expand_path('file_one')}/
+      expect($1).to match /#{File.expand_path('file_two')}/
     end
 
     it "returns a blank command for no files" do
-      rspec_autotest.make_test_cmd({}).should eq('')
+      expect(rspec_autotest.make_test_cmd({})).to eq('')
     end
 
     it "quotes the paths of files to test" do
       cmd = rspec_autotest.make_test_cmd(@files_to_test)
       @files_to_test.keys.each do |file_to_test|
-        cmd.should match(/'#{File.expand_path(file_to_test)}'/)
+        expect(cmd).to match(/"#{File.expand_path(file_to_test)}"/)
       end
     end
 
     it "quotes the path of the ruby executable" do
       cmd = rspec_autotest.make_test_cmd(@files_to_test)
-      cmd.should match(%r('/path/to/ruby'))
+      expect(cmd).to match(%r("/path/to/ruby"))
     end
 
     it "gives '--tty' to #{Autotest::Rspec2::RSPEC_EXECUTABLE}, not '--autotest'" do
       cmd = rspec_autotest.make_test_cmd(@files_to_test)
-      cmd.should match(' --tty ')
-      cmd.should_not match(' --autotest ')
+      expect(cmd).to match(' --tty ')
+      expect(cmd).not_to match(' --autotest ')
     end
   end
 
@@ -70,19 +75,19 @@ describe Autotest::Rspec2 do
     end
 
     it "finds the spec file for a given lib file" do
-      rspec_autotest.should map_specs([@spec_file]).to(@lib_file)
+      expect(rspec_autotest).to map_specs([@spec_file]).to(@lib_file)
     end
 
     it "finds the spec file if given a spec file" do
-      rspec_autotest.should map_specs([@spec_file]).to(@spec_file)
+      expect(rspec_autotest).to map_specs([@spec_file]).to(@spec_file)
     end
 
     it "ignores files in spec dir that aren't specs" do
-      rspec_autotest.should map_specs([]).to("spec/spec_helper.rb")
+      expect(rspec_autotest).to map_specs([]).to("spec/spec_helper.rb")
     end
 
     it "ignores untracked files (in @file)"  do
-      rspec_autotest.should map_specs([]).to("lib/untracked_file")
+      expect(rspec_autotest).to map_specs([]).to("lib/untracked_file")
     end
   end
 
@@ -91,12 +96,12 @@ describe Autotest::Rspec2 do
     let(:spec_file)    { "spec/autotest/some_spec.rb" }
 
     it "returns no failures if no failures were given in the output" do
-      rspec_autotest.consolidate_failures([[]]).should eq({})
+      expect(rspec_autotest.consolidate_failures([[]])).to eq({})
     end
 
     it "returns a hash with the spec filename => spec name for each failure or error" do
       failures = [ [ "false should be false", spec_file ] ]
-      rspec_autotest.consolidate_failures(failures).should eq({
+      expect(rspec_autotest.consolidate_failures(failures)).to eq({
         spec_file => ["false should be false"]
       })
     end
@@ -107,11 +112,11 @@ describe Autotest::Rspec2 do
       end
 
       it "excludes the subject file" do
-        rspec_autotest.consolidate_failures(failures).keys.should_not include(subject_file)
+        expect(rspec_autotest.consolidate_failures(failures).keys).not_to include(subject_file)
       end
 
       it "includes the spec file" do
-        rspec_autotest.consolidate_failures(failures).keys.should include(spec_file)
+        expect(rspec_autotest.consolidate_failures(failures).keys).to include(spec_file)
       end
     end
   end
@@ -122,7 +127,7 @@ describe Autotest::Rspec2 do
       ['filename.rb', './filename.rb', File.expand_path('filename.rb')].each do |file|
         @files_to_test[file] = []
       end
-      rspec_autotest.normalize(@files_to_test).should have(1).file
+      expect(rspec_autotest.normalize(@files_to_test)).to have(1).file
     end
   end
 end

data/spec/command_line/order_spec.rb

@@ -87,12 +87,12 @@ describe 'command line', :ui do
       RSpec.configuration.seed = srand && srand # reset seed in same process
       run_command 'tmp/aruba/spec/order_spec.rb --order rand -f doc'
 
-      stdout.string.should match(/Randomized with seed \d+/)
+      expect(stdout.string).to match(/Randomized with seed \d+/)
 
-      top_level_groups      {|first_run, second_run| first_run.should_not eq(second_run)}
-      nested_groups         {|first_run, second_run| first_run.should_not eq(second_run)}
-      examples('group 1')   {|first_run, second_run| first_run.should_not eq(second_run)}
-      examples('group 1-1') {|first_run, second_run| first_run.should_not eq(second_run)}
+      top_level_groups      {|first_run, second_run| expect(first_run).to_not eq(second_run)}
+      nested_groups         {|first_run, second_run| expect(first_run).to_not eq(second_run)}
+      examples('group 1')   {|first_run, second_run| expect(first_run).to_not eq(second_run)}
+      examples('group 1-1') {|first_run, second_run| expect(first_run).to_not eq(second_run)}
     end
   end
 
@@ -100,12 +100,12 @@ describe 'command line', :ui do
     it 'runs the examples and groups in the same order each time' do
       2.times { run_command 'tmp/aruba/spec/order_spec.rb --order rand:123 -f doc' }
 
-      stdout.string.should match(/Randomized with seed 123/)
+      expect(stdout.string).to match(/Randomized with seed 123/)
 
-      top_level_groups      {|first_run, second_run| first_run.should eq(second_run)}
-      nested_groups         {|first_run, second_run| first_run.should eq(second_run)}
-      examples('group 1')   {|first_run, second_run| first_run.should eq(second_run)}
-      examples('group 1-1') {|first_run, second_run| first_run.should eq(second_run)}
+      top_level_groups      {|first_run, second_run| expect(first_run).to eq(second_run)}
+      nested_groups         {|first_run, second_run| expect(first_run).to eq(second_run)}
+      examples('group 1')   {|first_run, second_run| expect(first_run).to eq(second_run)}
+      examples('group 1-1') {|first_run, second_run| expect(first_run).to eq(second_run)}
     end
   end
 
@@ -113,20 +113,20 @@ describe 'command line', :ui do
     it "forces '--order rand' and runs the examples and groups in the same order each time" do
       2.times { run_command 'tmp/aruba/spec/order_spec.rb --seed 123 -f doc' }
 
-      stdout.string.should match(/Randomized with seed \d+/)
+      expect(stdout.string).to match(/Randomized with seed \d+/)
 
-      top_level_groups      {|first_run, second_run| first_run.should eq(second_run)}
-      nested_groups         {|first_run, second_run| first_run.should eq(second_run)}
-      examples('group 1')   {|first_run, second_run| first_run.should eq(second_run)}
-      examples('group 1-1') {|first_run, second_run| first_run.should eq(second_run)}
+      top_level_groups      {|first_run, second_run| expect(first_run).to eq(second_run)}
+      nested_groups         {|first_run, second_run| expect(first_run).to eq(second_run)}
+      examples('group 1')   {|first_run, second_run| expect(first_run).to eq(second_run)}
+      examples('group 1-1') {|first_run, second_run| expect(first_run).to eq(second_run)}
     end
 
     it "runs examples in the same order, regardless of the order in which files are given" do
       run_command 'tmp/aruba/spec/simple_spec.rb tmp/aruba/spec/simple_spec2.rb --seed 1337 -f doc'
       run_command 'tmp/aruba/spec/simple_spec2.rb tmp/aruba/spec/simple_spec.rb --seed 1337 -f doc'
 
-      top_level_groups      {|first_run, second_run| first_run.should eq(second_run)}
-      nested_groups         {|first_run, second_run| first_run.should eq(second_run)}
+      top_level_groups      {|first_run, second_run| expect(first_run).to eq(second_run)}
+      nested_groups         {|first_run, second_run| expect(first_run).to eq(second_run)}
     end
   end
 
@@ -136,9 +136,9 @@ describe 'command line', :ui do
 
       run_command 'tmp/aruba/spec/order_spec.rb --order default -f doc'
 
-      stdout.string.should_not match(/Randomized/)
+      expect(stdout.string).not_to match(/Randomized/)
 
-      stdout.string.should match(
+      expect(stdout.string).to match(
         /group 1.*group 1 example 1.*group 1 example 2.*group 1-1.*group 1-2.*group 2.*/m
       )
     end
@@ -169,10 +169,10 @@ describe 'command line', :ui do
     it 'orders the groups and examples by the provided strategy' do
       run_command 'tmp/aruba/spec/custom_order_spec.rb -f doc'
 
-      top_level_groups    { |groups| groups.flatten.should eq(['group A', 'group B']) }
+      top_level_groups    { |groups| expect(groups.flatten).to eq(['group A', 'group B']) }
       examples('group B') do |examples|
         letters = examples.flatten.map { |e| e[/(.)\z/, 1] }
-        letters.should eq(['A', 'B', 'C', 'D'])
+        expect(letters).to eq(['A', 'B', 'C', 'D'])
       end
     end
   end

data/spec/rspec/core/command_line_spec.rb

@@ -27,13 +27,13 @@ module RSpec::Core
     it "assigns ConfigurationOptions built from Array of options to @options" do
       config_options = ConfigurationOptions.new(%w[--color])
       command_line   = CommandLine.new(%w[--color])
-      command_line.instance_eval { @options.options }.should eq(config_options.parse_options)
+      expect(command_line.instance_eval { @options.options }).to eq(config_options.parse_options)
     end
 
     it "assigns submitted ConfigurationOptions to @options" do
       config_options = ConfigurationOptions.new(%w[--color])
       command_line   = CommandLine.new(config_options)
-      command_line.instance_eval { @options }.should be(config_options)
+      expect(command_line.instance_eval { @options }).to be(config_options)
     end
 
     describe "#run" do
@@ -42,17 +42,17 @@ module RSpec::Core
 
         it "returns 0 if spec passes" do
           command_line = build_command_line passing_spec_filename
-          command_line.run(err, out).should eq 0
+          expect(command_line.run(err, out)).to eq 0
         end
 
         it "returns 1 if spec fails" do
           command_line = build_command_line failing_spec_filename
-          command_line.run(err, out).should eq 1
+          expect(command_line.run(err, out)).to eq 1
         end
 
         it "returns 2 if spec fails and --failure-exit-code is 2" do
           command_line = build_command_line failing_spec_filename, "--failure-exit-code", "2"
-          command_line.run(err, out).should eq 2
+          expect(command_line.run(err, out)).to eq 2
         end
       end
 
@@ -91,7 +91,7 @@ module RSpec::Core
         config.output_stream = output_file
         command_line = build_command_line
         command_line.run err, out
-        command_line.instance_eval { @configuration.output_stream }.should eq output_file
+        expect(command_line.instance_eval { @configuration.output_stream }).to eq output_file
       end
     end
 

data/spec/rspec/core/configuration_options_spec.rb

@@ -13,6 +13,13 @@ describe RSpec::Core::ConfigurationOptions, :isolated_directory => true, :isolat
     end
   end
 
+  it "duplicates the arguments array" do
+    args = ['-e', 'some spec']
+    coo = RSpec::Core::ConfigurationOptions.new(args)
+    coo.parse_options
+    expect(args).to eq(['-e', 'some spec'])
+  end
+
   describe "#configure" do
     it "sends libs before requires" do
       opts = config_options_object(*%w[--require a/path -I a/lib])
@@ -50,14 +57,14 @@ describe RSpec::Core::ConfigurationOptions, :isolated_directory => true, :isolat
       opts = config_options_object(*%w[--tag awesome])
       config = RSpec::Core::Configuration.new
       opts.configure(config)
-      config.inclusion_filter.should have_key(:awesome)
+      expect(config.inclusion_filter).to have_key(:awesome)
     end
 
     it "merges the :exclusion_filter option with the default exclusion_filter" do
       opts = config_options_object(*%w[--tag ~slow])
       config = RSpec::Core::Configuration.new
       opts.configure(config)
-      config.exclusion_filter.should have_key(:slow)
+      expect(config.exclusion_filter).to have_key(:slow)
     end
 
     it "forces color_enabled" do
@@ -80,8 +87,8 @@ describe RSpec::Core::ConfigurationOptions, :isolated_directory => true, :isolat
         opts = config_options_object(*[cli_option, cli_value].compact)
         config = RSpec::Core::Configuration.new
         config.should_receive(:force) do |pair|
-          pair.keys.first.should eq(config_key)
-          pair.values.first.should eq(config_value)
+          expect(pair.keys.first).to eq(config_key)
+          expect(pair.values.first).to eq(config_value)
         end
         opts.configure(config)
       end
@@ -115,195 +122,203 @@ describe RSpec::Core::ConfigurationOptions, :isolated_directory => true, :isolat
 
   describe "-c, --color, and --colour" do
     it "sets :color => true" do
-      parse_options('-c').should include(:color => true)
-      parse_options('--color').should include(:color => true)
-      parse_options('--colour').should include(:color => true)
+      expect(parse_options('-c')).to include(:color => true)
+      expect(parse_options('--color')).to include(:color => true)
+      expect(parse_options('--colour')).to include(:color => true)
     end
   end
 
   describe "--no-color" do
     it "sets :color => false" do
-      parse_options('--no-color').should include(:color => false)
+      expect(parse_options('--no-color')).to include(:color => false)
     end
 
     it "overrides previous :color => true" do
-      parse_options('--color', '--no-color').should include(:color => false)
+      expect(parse_options('--color', '--no-color')).to include(:color => false)
     end
 
     it "gets overriden by a subsequent :color => true" do
-      parse_options('--no-color', '--color').should include(:color => true)
+      expect(parse_options('--no-color', '--color')).to include(:color => true)
     end
   end
 
   describe "-I" do
     example "adds to :libs" do
-      parse_options('-I', 'a_dir').should include(:libs => ['a_dir'])
+      expect(parse_options('-I', 'a_dir')).to include(:libs => ['a_dir'])
     end
     example "can be used more than once" do
-      parse_options('-I', 'dir_1', '-I', 'dir_2').should include(:libs => ['dir_1','dir_2'])
+      expect(parse_options('-I', 'dir_1', '-I', 'dir_2')).to include(:libs => ['dir_1','dir_2'])
     end
   end
 
   describe '--require' do
     example "requires files" do
-      parse_options('--require', 'a/path').should include(:requires => ['a/path'])
+      expect(parse_options('--require', 'a/path')).to include(:requires => ['a/path'])
     end
     example "can be used more than once" do
-      parse_options('--require', 'path/1', '--require', 'path/2').should include(:requires => ['path/1','path/2'])
+      expect(parse_options('--require', 'path/1', '--require', 'path/2')).to include(:requires => ['path/1','path/2'])
     end
   end
 
   describe "--format, -f" do
     it "sets :formatter" do
       [['--format', 'd'], ['-f', 'd'], '-fd'].each do |args|
-        parse_options(*args).should include(:formatters => [['d']])
+        expect(parse_options(*args)).to include(:formatters => [['d']])
       end
     end
 
     example "can accept a class name" do
-      parse_options('-fSome::Formatter::Class').should include(:formatters => [['Some::Formatter::Class']])
+      expect(parse_options('-fSome::Formatter::Class')).to include(:formatters => [['Some::Formatter::Class']])
     end
   end
 
   describe "--profile, -p" do
-    it "sets :profile_examples => true" do
-      parse_options('-p').should include(:profile_examples => true)
-      parse_options('--profile').should include(:profile_examples => true)
+    it "sets :profile_examples" do
+      expect(parse_options('-p')).to include(:profile_examples => true)
+      expect(parse_options('--profile')).to include(:profile_examples => true)
+      expect(parse_options('-p', '4')).to include(:profile_examples => 4)
+      expect(parse_options('--profile', '3')).to include(:profile_examples => 3)
+    end
+  end
+
+  describe "--no-profile" do
+    it "sets :profile_examples to false" do
+      expect(parse_options('--no-profile')).to include(:profile_examples => false)
     end
   end
 
   describe '--line_number' do
     it "sets :line_number" do
-      parse_options('-l','3').should include(:line_numbers => ['3'])
-      parse_options('--line_number','3').should include(:line_numbers => ['3'])
+      expect(parse_options('-l','3')).to include(:line_numbers => ['3'])
+      expect(parse_options('--line_number','3')).to include(:line_numbers => ['3'])
     end
 
     it "can be specified multiple times" do
-      parse_options('-l','3', '-l', '6').should include(:line_numbers => ['3', '6'])
-      parse_options('--line_number','3', '--line_number', '6').should include(:line_numbers => ['3', '6'])
+      expect(parse_options('-l','3', '-l', '6')).to include(:line_numbers => ['3', '6'])
+      expect(parse_options('--line_number','3', '--line_number', '6')).to include(:line_numbers => ['3', '6'])
     end
   end
 
   describe "--example" do
     it "sets :full_description" do
-      parse_options('--example','foo').should include(:full_description => [/foo/])
-      parse_options('-e','bar').should include(:full_description => [/bar/])
+      expect(parse_options('--example','foo')).to include(:full_description => [/foo/])
+      expect(parse_options('-e','bar')).to include(:full_description => [/bar/])
     end
   end
 
   describe "--backtrace, -b" do
     it "sets full_backtrace on config" do
-      parse_options("--backtrace").should include(:full_backtrace => true)
-      parse_options("-b").should include(:full_backtrace => true)
+      expect(parse_options("--backtrace")).to include(:full_backtrace => true)
+      expect(parse_options("-b")).to include(:full_backtrace => true)
     end
   end
 
   describe "--debug, -d" do
     it "sets :debug => true" do
-      parse_options("--debug").should include(:debug => true)
-      parse_options("-d").should include(:debug => true)
+      expect(parse_options("--debug")).to include(:debug => true)
+      expect(parse_options("-d")).to include(:debug => true)
     end
   end
 
   describe "--fail-fast" do
     it "defaults to false" do
-      parse_options[:fail_fast].should be_false
+      expect(parse_options[:fail_fast]).to be_false
     end
 
     it "sets fail_fast on config" do
-      parse_options("--fail-fast")[:fail_fast].should be_true
+      expect(parse_options("--fail-fast")[:fail_fast]).to be_true
     end
   end
 
   describe "--failure-exit-code" do
     it "sets :failure_exit_code" do
-      parse_options('--failure-exit-code', '0').should include(:failure_exit_code => 0)
-      parse_options('--failure-exit-code', '1').should include(:failure_exit_code => 1)
-      parse_options('--failure-exit-code', '2').should include(:failure_exit_code => 2)
+      expect(parse_options('--failure-exit-code', '0')).to include(:failure_exit_code => 0)
+      expect(parse_options('--failure-exit-code', '1')).to include(:failure_exit_code => 1)
+      expect(parse_options('--failure-exit-code', '2')).to include(:failure_exit_code => 2)
     end
 
     it "overrides previous :failure_exit_code" do
-      parse_options('--failure-exit-code', '2', '--failure-exit-code', '3').should include(:failure_exit_code => 3)
+      expect(parse_options('--failure-exit-code', '2', '--failure-exit-code', '3')).to include(:failure_exit_code => 3)
     end
   end
 
   describe "--options" do
     it "sets :custom_options_file" do
-      parse_options(*%w[-O my.opts]).should include(:custom_options_file => "my.opts")
-      parse_options(*%w[--options my.opts]).should include(:custom_options_file => "my.opts")
+      expect(parse_options(*%w[-O my.opts])).to include(:custom_options_file => "my.opts")
+      expect(parse_options(*%w[--options my.opts])).to include(:custom_options_file => "my.opts")
     end
   end
 
   describe "--drb, -X" do
     context "combined with --debug" do
       it "turns off the debugger if --drb is specified first" do
-        config_options_object("--drb", "--debug").drb_argv.should_not include("--debug")
-        config_options_object("--drb", "-d"     ).drb_argv.should_not include("--debug")
-        config_options_object("-X",    "--debug").drb_argv.should_not include("--debug")
-        config_options_object("-X",    "-d"     ).drb_argv.should_not include("--debug")
+        expect(config_options_object("--drb", "--debug").drb_argv).not_to include("--debug")
+        expect(config_options_object("--drb", "-d"     ).drb_argv).not_to include("--debug")
+        expect(config_options_object("-X",    "--debug").drb_argv).not_to include("--debug")
+        expect(config_options_object("-X",    "-d"     ).drb_argv).not_to include("--debug")
       end
 
       it "turns off the debugger option if --drb is specified later" do
-        config_options_object("--debug", "--drb").drb_argv.should_not include("--debug")
-        config_options_object("-d",      "--drb").drb_argv.should_not include("--debug")
-        config_options_object("--debug", "-X"   ).drb_argv.should_not include("--debug")
-        config_options_object("-d",      "-X"   ).drb_argv.should_not include("--debug")
+        expect(config_options_object("--debug", "--drb").drb_argv).not_to include("--debug")
+        expect(config_options_object("-d",      "--drb").drb_argv).not_to include("--debug")
+        expect(config_options_object("--debug", "-X"   ).drb_argv).not_to include("--debug")
+        expect(config_options_object("-d",      "-X"   ).drb_argv).not_to include("--debug")
       end
 
       it "turns off the debugger option if --drb is specified in the options file" do
         File.open("./.rspec", "w") {|f| f << "--drb"}
-        config_options_object("--debug").drb_argv.should_not include("--debug")
-        config_options_object("-d"     ).drb_argv.should_not include("--debug")
+        expect(config_options_object("--debug").drb_argv).not_to include("--debug")
+        expect(config_options_object("-d"     ).drb_argv).not_to include("--debug")
       end
 
       it "turns off the debugger option if --debug is specified in the options file" do
         File.open("./.rspec", "w") {|f| f << "--debug"}
-        config_options_object("--drb").drb_argv.should_not include("--debug")
-        config_options_object("-X"   ).drb_argv.should_not include("--debug")
+        expect(config_options_object("--drb").drb_argv).not_to include("--debug")
+        expect(config_options_object("-X"   ).drb_argv).not_to include("--debug")
       end
     end
 
     it "does not send --drb back to the parser after parsing options" do
-      config_options_object("--drb", "--color").drb_argv.should_not include("--drb")
+      expect(config_options_object("--drb", "--color").drb_argv).not_to include("--drb")
     end
 
   end
 
   describe "--no-drb" do
     it "disables drb" do
-      parse_options("--no-drb").should include(:drb => false)
+      expect(parse_options("--no-drb")).to include(:drb => false)
     end
 
     it "overrides a previous drb => true" do
-      parse_options("--drb", "--no-drb").should include(:drb => false)
+      expect(parse_options("--drb", "--no-drb")).to include(:drb => false)
     end
 
     it "gets overriden by a subsquent drb => true" do
-      parse_options("--no-drb", "--drb").should include(:drb => true)
+      expect(parse_options("--no-drb", "--drb")).to include(:drb => true)
     end
   end
 
 
   describe "files_or_directories_to_run" do
     it "parses files from '-c file.rb dir/file.rb'" do
-      parse_options("-c", "file.rb", "dir/file.rb").should include(
+      expect(parse_options("-c", "file.rb", "dir/file.rb")).to include(
         :files_or_directories_to_run => ["file.rb", "dir/file.rb"]
       )
     end
 
     it "parses dir from 'dir'" do
-      parse_options("dir").should include(:files_or_directories_to_run => ["dir"])
+      expect(parse_options("dir")).to include(:files_or_directories_to_run => ["dir"])
     end
 
     it "parses dir and files from 'spec/file1_spec.rb, spec/file2_spec.rb'" do
-      parse_options("dir", "spec/file1_spec.rb", "spec/file2_spec.rb").should include(
+      expect(parse_options("dir", "spec/file1_spec.rb", "spec/file2_spec.rb")).to include(
         :files_or_directories_to_run => ["dir", "spec/file1_spec.rb", "spec/file2_spec.rb"]
       )
     end
 
     it "provides no files or directories if spec directory does not exist" do
       FileTest.stub(:directory?).with("spec").and_return false
-      parse_options().should include(:files_or_directories_to_run => [])
+      expect(parse_options()).to include(:files_or_directories_to_run => [])
     end
   end
 
@@ -319,8 +334,7 @@ describe RSpec::Core::ConfigurationOptions, :isolated_directory => true, :isolat
 
   describe "#filter_manager" do
     it "returns the same object as RSpec::configuration.filter_manager" do
-      config_options_object.filter_manager.
-        should be(RSpec::configuration.filter_manager)
+      expect(config_options_object.filter_manager).to be(RSpec::configuration.filter_manager)
     end
   end
 
@@ -331,37 +345,37 @@ describe RSpec::Core::ConfigurationOptions, :isolated_directory => true, :isolat
       File.open(File.expand_path("~/.rspec"), "w") {|f| f << "--color"}
       with_env_vars 'SPEC_OPTS' => "--debug --example 'foo bar'" do
         options = parse_options("--drb")
-        options[:color].should be_true
-        options[:line_numbers].should eq(["37"])
-        options[:debug].should be_true
-        options[:full_description].should eq([/foo\ bar/])
-        options[:drb].should be_true
-        options[:formatters].should eq([['global']])
+        expect(options[:color]).to be_true
+        expect(options[:line_numbers]).to eq(["37"])
+        expect(options[:debug]).to be_true
+        expect(options[:full_description]).to eq([/foo\ bar/])
+        expect(options[:drb]).to be_true
+        expect(options[:formatters]).to eq([['global']])
       end
     end
 
     it "prefers SPEC_OPTS over CLI" do
       with_env_vars 'SPEC_OPTS' => "--format spec_opts" do
-        parse_options("--format", "cli")[:formatters].should eq([['spec_opts']])
+        expect(parse_options("--format", "cli")[:formatters]).to eq([['spec_opts']])
       end
     end
 
     it "prefers CLI over file options" do
       File.open("./.rspec", "w") {|f| f << "--format project"}
       File.open(File.expand_path("~/.rspec"), "w") {|f| f << "--format global"}
-      parse_options("--format", "cli")[:formatters].should eq([['cli']])
+      expect(parse_options("--format", "cli")[:formatters]).to eq([['cli']])
     end
 
     it "prefers project file options over global file options" do
       File.open("./.rspec", "w") {|f| f << "--format project"}
       File.open(File.expand_path("~/.rspec"), "w") {|f| f << "--format global"}
-      parse_options[:formatters].should eq([['project']])
+      expect(parse_options[:formatters]).to eq([['project']])
     end
 
     it "prefers local file options over project file options" do
       File.open("./.rspec-local", "w") {|f| f << "--format local"}
       File.open("./.rspec", "w") {|f| f << "--format global"}
-      parse_options[:formatters].should eq([['local']])
+      expect(parse_options[:formatters]).to eq([['local']])
     end
 
     context "with custom options file" do
@@ -370,14 +384,14 @@ describe RSpec::Core::ConfigurationOptions, :isolated_directory => true, :isolat
         File.open(File.expand_path("~/.rspec"), "w") {|f| f << "--format global"}
         File.open("./custom.opts", "w") {|f| f << "--color"}
         options = parse_options("-O", "./custom.opts")
-        options[:format].should be_nil
-        options[:color].should be_true
+        expect(options[:format]).to be_nil
+        expect(options[:color]).to be_true
       end
 
       it "parses -e 'full spec description'" do
         File.open("./custom.opts", "w") {|f| f << "-e 'The quick brown fox jumps over the lazy dog'"}
         options = parse_options("-O", "./custom.opts")
-        options[:full_description].should eq([/The\ quick\ brown\ fox\ jumps\ over\ the\ lazy\ dog/])
+        expect(options[:full_description]).to eq([/The\ quick\ brown\ fox\ jumps\ over\ the\ lazy\ dog/])
       end
     end
   end