rspec-core 2.12.2 → 2.13.0

data/spec/rspec/core/configuration_spec.rb

@@ -43,12 +43,12 @@ module RSpec::Core
 
     describe "#treat_symbols_as_metadata_keys_with_true_values?" do
       it 'defaults to false' do
-        config.treat_symbols_as_metadata_keys_with_true_values?.should be_false
+        expect(config.treat_symbols_as_metadata_keys_with_true_values?).to be_false
       end
 
       it 'can be set to true' do
         config.treat_symbols_as_metadata_keys_with_true_values = true
-        config.treat_symbols_as_metadata_keys_with_true_values?.should be_true
+        expect(config.treat_symbols_as_metadata_keys_with_true_values?).to be_true
       end
     end
 
@@ -76,16 +76,16 @@ module RSpec::Core
           mod_config.custom_setting = true
         end
 
-        custom_config.custom_setting.should be_true
+        expect(custom_config.custom_setting).to be_true
       end
 
       it "raises if framework module doesn't support configuration" do
         mod = Module.new
 
-        lambda do
+        expect {
           config.send m, mod do |mod_config|
           end
-        end.should raise_error(/must respond to `configuration`/)
+        }.to raise_error(/must respond to `configuration`/)
       end
     end
 
@@ -117,7 +117,7 @@ module RSpec::Core
         it "sets the mock_framework_adapter to that module" do
           mod = Module.new
           config.mock_with mod
-          config.mock_framework.should eq(mod)
+          expect(config.mock_framework).to eq(mod)
         end
       end
 
@@ -187,14 +187,14 @@ module RSpec::Core
       it "supports multiple calls" do
         config.expect_with :rspec
         config.expect_with :stdlib
-        config.expectation_frameworks.should eq [RSpec::Matchers, Test::Unit::Assertions]
+        expect(config.expectation_frameworks).to eq [RSpec::Matchers, Test::Unit::Assertions]
       end
 
       it "raises if block given with multiple args" do
-        lambda do
+        expect {
           config.expect_with :rspec, :stdlib do |mod_config|
           end
-        end.should raise_error(/expect_with only accepts/)
+        }.to raise_error(/expect_with only accepts/)
       end
 
       it "raises ArgumentError if framework is not supported" do
@@ -234,76 +234,76 @@ module RSpec::Core
       end
 
       it "returns false by default" do
-        config.should_not be_expecting_with_rspec
+        expect(config).not_to be_expecting_with_rspec
       end
 
       it "returns true when `expect_with :rspec` has been configured" do
         config.expect_with :rspec
-        config.should be_expecting_with_rspec
+        expect(config).to be_expecting_with_rspec
       end
 
       it "returns true when `expect_with :rspec, :stdlib` has been configured" do
         config.expect_with :rspec, :stdlib
-        config.should be_expecting_with_rspec
+        expect(config).to be_expecting_with_rspec
       end
 
       it "returns true when `expect_with :stdlib, :rspec` has been configured" do
         config.expect_with :stdlib, :rspec
-        config.should be_expecting_with_rspec
+        expect(config).to be_expecting_with_rspec
       end
 
       it "returns false when `expect_with :stdlib` has been configured" do
         config.expect_with :stdlib
-        config.should_not be_expecting_with_rspec
+        expect(config).not_to be_expecting_with_rspec
       end
     end
 
     describe "#files_to_run" do
       it "loads files not following pattern if named explicitly" do
         config.files_or_directories_to_run = "spec/rspec/core/resources/a_bar.rb"
-        config.files_to_run.should eq([      "spec/rspec/core/resources/a_bar.rb"])
+        expect(config.files_to_run).to eq([      "spec/rspec/core/resources/a_bar.rb"])
       end
 
       it "prevents repetition of dir when start of the pattern" do
         config.pattern = "spec/**/a_spec.rb"
         config.files_or_directories_to_run = "spec"
-        config.files_to_run.should eq(["spec/rspec/core/resources/a_spec.rb"])
+        expect(config.files_to_run).to eq(["spec/rspec/core/resources/a_spec.rb"])
       end
 
       it "does not prevent repetition of dir when later of the pattern" do
         config.pattern = "rspec/**/a_spec.rb"
         config.files_or_directories_to_run = "spec"
-        config.files_to_run.should eq(["spec/rspec/core/resources/a_spec.rb"])
+        expect(config.files_to_run).to eq(["spec/rspec/core/resources/a_spec.rb"])
       end
 
       context "with <path>:<line_number>" do
         it "overrides inclusion filters set on config" do
           config.filter_run_including :foo => :bar
           config.files_or_directories_to_run = "path/to/file.rb:37"
-          config.inclusion_filter.size.should eq(1)
-          config.inclusion_filter[:locations].keys.first.should match(/path\/to\/file\.rb$/)
-          config.inclusion_filter[:locations].values.first.should eq([37])
+          expect(config.inclusion_filter.size).to eq(1)
+          expect(config.inclusion_filter[:locations].keys.first).to match(/path\/to\/file\.rb$/)
+          expect(config.inclusion_filter[:locations].values.first).to eq([37])
         end
 
         it "overrides inclusion filters set before config" do
           config.force(:inclusion_filter => {:foo => :bar})
           config.files_or_directories_to_run = "path/to/file.rb:37"
-          config.inclusion_filter.size.should eq(1)
-          config.inclusion_filter[:locations].keys.first.should match(/path\/to\/file\.rb$/)
-          config.inclusion_filter[:locations].values.first.should eq([37])
+          expect(config.inclusion_filter.size).to eq(1)
+          expect(config.inclusion_filter[:locations].keys.first).to match(/path\/to\/file\.rb$/)
+          expect(config.inclusion_filter[:locations].values.first).to eq([37])
         end
 
         it "clears exclusion filters set on config" do
           config.exclusion_filter = { :foo => :bar }
           config.files_or_directories_to_run = "path/to/file.rb:37"
-          config.exclusion_filter.should be_empty,
+          expect(config.exclusion_filter).to be_empty,
             "expected exclusion filter to be empty:\n#{config.exclusion_filter}"
         end
 
         it "clears exclusion filters set before config" do
           config.force(:exclusion_filter => { :foo => :bar })
           config.files_or_directories_to_run = "path/to/file.rb:37"
-          config.exclusion_filter.should be_empty,
+          expect(config.exclusion_filter).to be_empty,
             "expected exclusion filter to be empty:\n#{config.exclusion_filter}"
         end
       end
@@ -311,17 +311,17 @@ module RSpec::Core
       context "with default pattern" do
         it "loads files named _spec.rb" do
           config.files_or_directories_to_run = "spec/rspec/core/resources"
-          config.files_to_run.should eq([      "spec/rspec/core/resources/a_spec.rb"])
+          expect(config.files_to_run).to eq([      "spec/rspec/core/resources/a_spec.rb"])
         end
 
         it "loads files in Windows", :if => RSpec.windows_os? do
           config.files_or_directories_to_run = "C:\\path\\to\\project\\spec\\sub\\foo_spec.rb"
-          config.files_to_run.should eq([      "C:/path/to/project/spec/sub/foo_spec.rb"])
+          expect(config.files_to_run).to eq([      "C:/path/to/project/spec/sub/foo_spec.rb"])
         end
 
         it "loads files in Windows when directory is specified", :if => RSpec.windows_os? do
           config.files_or_directories_to_run = "spec\\rspec\\core\\resources"
-          config.files_to_run.should eq([      "spec/rspec/core/resources/a_spec.rb"])
+          expect(config.files_to_run).to eq([      "spec/rspec/core/resources/a_spec.rb"])
         end
       end
 
@@ -329,20 +329,20 @@ module RSpec::Core
         it "loads files in the default path when run by rspec" do
           config.stub(:command) { 'rspec' }
           config.files_or_directories_to_run = []
-          config.files_to_run.should_not be_empty
+          expect(config.files_to_run).not_to be_empty
         end
 
         it "loads files in the default path when run with DRB (e.g., spork)" do
           config.stub(:command) { 'spork' }
           RSpec::Core::Runner.stub(:running_in_drb?) { true }
           config.files_or_directories_to_run = []
-          config.files_to_run.should_not be_empty
+          expect(config.files_to_run).not_to be_empty
         end
 
         it "does not load files in the default path when run by ruby" do
           config.stub(:command) { 'ruby' }
           config.files_or_directories_to_run = []
-          config.files_to_run.should be_empty
+          expect(config.files_to_run).to be_empty
         end
       end
 
@@ -359,7 +359,7 @@ module RSpec::Core
           config.files_to_run
         end
 
-        orderings.uniq.size.should eq(1)
+        expect(orderings.uniq.size).to eq(1)
       end
 
       context 'when the given directories match the pattern' do
@@ -403,19 +403,19 @@ module RSpec::Core
           it "loads files following pattern" do
             file = File.expand_path(File.dirname(__FILE__) + "/resources/a_foo.rb")
             config.files_or_directories_to_run = file
-            config.files_to_run.should include(file)
+            expect(config.files_to_run).to include(file)
           end
 
           it "loads files in directories following pattern" do
             dir = File.expand_path(File.dirname(__FILE__) + "/resources")
             config.files_or_directories_to_run = dir
-            config.files_to_run.should include("#{dir}/a_foo.rb")
+            expect(config.files_to_run).to include("#{dir}/a_foo.rb")
           end
 
           it "does not load files in directories not following pattern" do
             dir = File.expand_path(File.dirname(__FILE__) + "/resources")
             config.files_or_directories_to_run = dir
-            config.files_to_run.should_not include("#{dir}/a_bar.rb")
+            expect(config.files_to_run).not_to include("#{dir}/a_bar.rb")
           end
         end
 
@@ -424,16 +424,16 @@ module RSpec::Core
             config.send(setter, "**/*_foo.rb,**/*_bar.rb")
             dir = File.expand_path(File.dirname(__FILE__) + "/resources")
             config.files_or_directories_to_run = dir
-            config.files_to_run.should include("#{dir}/a_foo.rb")
-            config.files_to_run.should include("#{dir}/a_bar.rb")
+            expect(config.files_to_run).to include("#{dir}/a_foo.rb")
+            expect(config.files_to_run).to include("#{dir}/a_bar.rb")
           end
 
           it "supports comma separated values with spaces" do
             config.send(setter, "**/*_foo.rb, **/*_bar.rb")
             dir = File.expand_path(File.dirname(__FILE__) + "/resources")
             config.files_or_directories_to_run = dir
-            config.files_to_run.should include("#{dir}/a_foo.rb")
-            config.files_to_run.should include("#{dir}/a_bar.rb")
+            expect(config.files_to_run).to include("#{dir}/a_foo.rb")
+            expect(config.files_to_run).to include("#{dir}/a_bar.rb")
           end
         end
       end
@@ -442,7 +442,7 @@ module RSpec::Core
     describe "path with line number" do
       it "assigns the line number as a location filter" do
         config.files_or_directories_to_run = "path/to/a_spec.rb:37"
-        config.filter.should eq({:locations => {File.expand_path("path/to/a_spec.rb") => [37]}})
+        expect(config.filter).to eq({:locations => {File.expand_path("path/to/a_spec.rb") => [37]}})
       end
     end
 
@@ -450,7 +450,7 @@ module RSpec::Core
       it "overrides filters" do
         config.filter_run :focused => true
         config.full_description = "foo"
-        config.filter.should_not have_key(:focused)
+        expect(config.filter).not_to have_key(:focused)
       end
     end
 
@@ -458,41 +458,41 @@ module RSpec::Core
 
       it "assigns the file and line number as a location filter" do
         config.files_or_directories_to_run = "path/to/a_spec.rb:37"
-        config.filter.should eq({:locations => {File.expand_path("path/to/a_spec.rb") => [37]}})
+        expect(config.filter).to eq({:locations => {File.expand_path("path/to/a_spec.rb") => [37]}})
       end
 
       it "assigns multiple files with line numbers as location filters" do
         config.files_or_directories_to_run = "path/to/a_spec.rb:37", "other_spec.rb:44"
-        config.filter.should eq({:locations => {File.expand_path("path/to/a_spec.rb") => [37],
+        expect(config.filter).to eq({:locations => {File.expand_path("path/to/a_spec.rb") => [37],
                                                 File.expand_path("other_spec.rb") => [44]}})
       end
 
       it "assigns files with multiple line numbers as location filters" do
         config.files_or_directories_to_run = "path/to/a_spec.rb:37", "path/to/a_spec.rb:44"
-        config.filter.should eq({:locations => {File.expand_path("path/to/a_spec.rb") => [37, 44]}})
+        expect(config.filter).to eq({:locations => {File.expand_path("path/to/a_spec.rb") => [37, 44]}})
       end
     end
 
     context "with multiple line numbers" do
       it "assigns the file and line numbers as a location filter" do
         config.files_or_directories_to_run = "path/to/a_spec.rb:1:3:5:7"
-        config.filter.should eq({:locations => {File.expand_path("path/to/a_spec.rb") => [1,3,5,7]}})
+        expect(config.filter).to eq({:locations => {File.expand_path("path/to/a_spec.rb") => [1,3,5,7]}})
       end
     end
 
     it "assigns the example name as the filter on description" do
       config.full_description = "foo"
-      config.filter.should eq({:full_description => /foo/})
+      expect(config.filter).to eq({:full_description => /foo/})
     end
 
     it "assigns the example names as the filter on description if description is an array" do
       config.full_description = [ "foo", "bar" ]
-      config.filter.should eq({:full_description => Regexp.union(/foo/, /bar/)})
+      expect(config.filter).to eq({:full_description => Regexp.union(/foo/, /bar/)})
     end
 
     describe "#default_path" do
       it 'defaults to "spec"' do
-        config.default_path.should eq('spec')
+        expect(config.default_path).to eq('spec')
       end
     end
 
@@ -518,8 +518,8 @@ module RSpec::Core
           end
 
           group = ExampleGroup.describe('does like, stuff and junk', :magic_key => :include) { }
-          group.should_not respond_to(:you_call_this_a_blt?)
-          group.new.you_call_this_a_blt?.should eq("egad man, where's the mayo?!?!?")
+          expect(group).not_to respond_to(:you_call_this_a_blt?)
+          expect(group.new.you_call_this_a_blt?).to eq("egad man, where's the mayo?!?!?")
         end
       end
 
@@ -530,8 +530,8 @@ module RSpec::Core
           end
 
           group = ExampleGroup.describe('does like, stuff and junk', :magic_key => :include) { }
-          group.should_not respond_to(:you_call_this_a_blt?)
-          group.new.you_call_this_a_blt?.should eq("egad man, where's the mayo?!?!?")
+          expect(group).not_to respond_to(:you_call_this_a_blt?)
+          expect(group.new.you_call_this_a_blt?).to eq("egad man, where's the mayo?!?!?")
         end
       end
 
@@ -557,7 +557,7 @@ module RSpec::Core
         end
 
         group = ExampleGroup.describe(ThatThingISentYou, :magic_key => :extend) { }
-        group.should respond_to(:that_thing)
+        expect(group).to respond_to(:that_thing)
       end
 
     end
@@ -565,12 +565,12 @@ module RSpec::Core
     describe "#run_all_when_everything_filtered?" do
 
       it "defaults to false" do
-        config.run_all_when_everything_filtered?.should be_false
+        expect(config.run_all_when_everything_filtered?).to be_false
       end
 
       it "can be queried with question method" do
         config.run_all_when_everything_filtered = true
-        config.run_all_when_everything_filtered?.should be_true
+        expect(config.run_all_when_everything_filtered?).to be_true
       end
     end
 
@@ -587,8 +587,8 @@ module RSpec::Core
               config.tty = true
               config.output_stream.stub :tty? => true
 
-              config.send(color_option).should be_true
-              config.send(color_option, output).should be_true
+              expect(config.send(color_option)).to be_true
+              expect(config.send(color_option, output)).to be_true
             end
           end
 
@@ -600,8 +600,8 @@ module RSpec::Core
               config.tty = true
               config.output_stream.stub :tty? => false
 
-              config.send(color_option).should be_true
-              config.send(color_option, output).should be_true
+              expect(config.send(color_option)).to be_true
+              expect(config.send(color_option, output)).to be_true
             end
           end
 
@@ -613,8 +613,8 @@ module RSpec::Core
               config.tty = false
               config.output_stream.stub :tty? => true
 
-              config.send(color_option).should be_true
-              config.send(color_option, output).should be_true
+              expect(config.send(color_option)).to be_true
+              expect(config.send(color_option, output)).to be_true
             end
           end
 
@@ -626,8 +626,8 @@ module RSpec::Core
               config.tty = false
               config.output_stream.stub :tty? => false
 
-              config.send(color_option).should be_false
-              config.send(color_option, output).should be_false
+              expect(config.send(color_option)).to be_false
+              expect(config.send(color_option, output)).to be_false
             end
           end
 
@@ -650,7 +650,7 @@ module RSpec::Core
                 config.output_stream = StringIO.new
                 config.output_stream.stub :tty? => true
                 config.send "#{color_option}=", true
-                config.send(color_option).should be_true
+                expect(config.send(color_option)).to be_true
               end
 
               it "leaves output stream intact" do
@@ -659,7 +659,7 @@ module RSpec::Core
                   config.output_stream = 'foo' if what =~ /Win32/
                 end
                 config.send "#{color_option}=", true
-                config.output_stream.should eq($stdout)
+                expect(config.output_stream).to eq($stdout)
               end
             end
 
@@ -675,7 +675,7 @@ module RSpec::Core
                 config.stub(:require) { raise LoadError }
                 config.send "#{color_option}=", true
                 config.color_enabled = true
-                config.send(color_option).should be_false
+                expect(config.send(color_option)).to be_false
               end
             end
           end
@@ -687,7 +687,7 @@ module RSpec::Core
         config.output_stream.stub :tty? => true
         config.force :color => true
         config.color = false
-        config.color.should be_true
+        expect(config.color).to be_true
       end
     end
 
@@ -702,35 +702,35 @@ module RSpec::Core
 
       it "adds to the list of formatters" do
         config.add_formatter :documentation
-        config.formatters.first.should be_an_instance_of(Formatters::DocumentationFormatter)
+        expect(config.formatters.first).to be_an_instance_of(Formatters::DocumentationFormatter)
       end
 
       it "finds a formatter by name (w/ Symbol)" do
         config.add_formatter :documentation
-        config.formatters.first.should be_an_instance_of(Formatters::DocumentationFormatter)
+        expect(config.formatters.first).to be_an_instance_of(Formatters::DocumentationFormatter)
       end
 
       it "finds a formatter by name (w/ String)" do
         config.add_formatter 'documentation'
-        config.formatters.first.should be_an_instance_of(Formatters::DocumentationFormatter)
+        expect(config.formatters.first).to be_an_instance_of(Formatters::DocumentationFormatter)
       end
 
       it "finds a formatter by class" do
         formatter_class = Class.new(Formatters::BaseTextFormatter)
         config.add_formatter formatter_class
-        config.formatters.first.should be_an_instance_of(formatter_class)
+        expect(config.formatters.first).to be_an_instance_of(formatter_class)
       end
 
       it "finds a formatter by class name" do
         stub_const("CustomFormatter", Class.new(Formatters::BaseFormatter))
         config.add_formatter "CustomFormatter"
-        config.formatters.first.should be_an_instance_of(CustomFormatter)
+        expect(config.formatters.first).to be_an_instance_of(CustomFormatter)
       end
 
       it "finds a formatter by class fully qualified name" do
         stub_const("RSpec::CustomFormatter", Class.new(Formatters::BaseFormatter))
         config.add_formatter "RSpec::CustomFormatter"
-        config.formatters.first.should be_an_instance_of(RSpec::CustomFormatter)
+        expect(config.formatters.first).to be_an_instance_of(RSpec::CustomFormatter)
       end
 
       it "requires a formatter file based on its fully qualified name" do
@@ -738,24 +738,24 @@ module RSpec::Core
           stub_const("RSpec::CustomFormatter", Class.new(Formatters::BaseFormatter))
         end
         config.add_formatter "RSpec::CustomFormatter"
-        config.formatters.first.should be_an_instance_of(RSpec::CustomFormatter)
+        expect(config.formatters.first).to be_an_instance_of(RSpec::CustomFormatter)
       end
 
       it "raises NameError if class is unresolvable" do
         config.should_receive(:require).with('rspec/custom_formatter3')
-        lambda { config.add_formatter "RSpec::CustomFormatter3" }.should raise_error(NameError)
+        expect(lambda { config.add_formatter "RSpec::CustomFormatter3" }).to raise_error(NameError)
       end
 
       it "raises ArgumentError if formatter is unknown" do
-        lambda { config.add_formatter :progresss }.should raise_error(ArgumentError)
+        expect(lambda { config.add_formatter :progresss }).to raise_error(ArgumentError)
       end
 
       context "with a 2nd arg defining the output" do
         it "creates a file at that path and sets it as the output" do
           path = File.join(Dir.tmpdir, 'output.txt')
           config.add_formatter('doc', path)
-          config.formatters.first.output.should be_a(File)
-          config.formatters.first.output.path.should eq(path)
+          expect(config.formatters.first.output).to be_a(File)
+          expect(config.formatters.first.output.path).to eq(path)
         end
       end
     end
@@ -770,21 +770,21 @@ module RSpec::Core
 
       it "sets the filter with a hash" do
         config.filter_run_including :foo => true
-        config.inclusion_filter[:foo].should be(true)
+        expect(config.inclusion_filter[:foo]).to be(true)
       end
 
       it "sets the filter with a symbol" do
         RSpec.configuration.stub(:treat_symbols_as_metadata_keys_with_true_values? => true)
         config.filter_run_including :foo
-        config.inclusion_filter[:foo].should be(true)
+        expect(config.inclusion_filter[:foo]).to be(true)
       end
 
       it "merges with existing filters" do
         config.filter_run_including :foo => true
         config.filter_run_including :bar => false
 
-        config.inclusion_filter[:foo].should be(true)
-        config.inclusion_filter[:bar].should be(false)
+        expect(config.inclusion_filter[:foo]).to be(true)
+        expect(config.inclusion_filter[:bar]).to be(false)
       end
     end
 
@@ -798,28 +798,28 @@ module RSpec::Core
 
       it "sets the filter" do
         config.filter_run_excluding :foo => true
-        config.exclusion_filter[:foo].should be(true)
+        expect(config.exclusion_filter[:foo]).to be(true)
       end
 
       it "sets the filter using a symbol" do
         RSpec.configuration.stub(:treat_symbols_as_metadata_keys_with_true_values? => true)
         config.filter_run_excluding :foo
-        config.exclusion_filter[:foo].should be(true)
+        expect(config.exclusion_filter[:foo]).to be(true)
       end
 
       it "merges with existing filters" do
         config.filter_run_excluding :foo => true
         config.filter_run_excluding :bar => false
 
-        config.exclusion_filter[:foo].should be(true)
-        config.exclusion_filter[:bar].should be(false)
+        expect(config.exclusion_filter[:foo]).to be(true)
+        expect(config.exclusion_filter[:bar]).to be(false)
       end
     end
 
     describe "#inclusion_filter" do
       it "returns {} even if set to nil" do
         config.inclusion_filter = nil
-        config.inclusion_filter.should eq({})
+        expect(config.inclusion_filter).to eq({})
       end
     end
 
@@ -827,47 +827,47 @@ module RSpec::Core
       it "treats symbols as hash keys with true values when told to" do
         RSpec.configuration.stub(:treat_symbols_as_metadata_keys_with_true_values? => true)
         config.inclusion_filter = :foo
-        config.inclusion_filter.should eq({:foo => true})
+        expect(config.inclusion_filter).to eq({:foo => true})
       end
 
       it "overrides any inclusion filters set on the command line or in configuration files" do
         config.force(:inclusion_filter => { :foo => :bar })
         config.inclusion_filter = {:want => :this}
-        config.inclusion_filter.should eq({:want => :this})
+        expect(config.inclusion_filter).to eq({:want => :this})
       end
     end
 
     describe "#exclusion_filter" do
       it "returns {} even if set to nil" do
         config.exclusion_filter = nil
-        config.exclusion_filter.should eq({})
+        expect(config.exclusion_filter).to eq({})
       end
 
       describe "the default :if filter" do
         it "does not exclude a spec with  { :if => true } metadata" do
-          config.exclusion_filter[:if].call(true).should be_false
+          expect(config.exclusion_filter[:if].call(true)).to be_false
         end
 
         it "excludes a spec with  { :if => false } metadata" do
-          config.exclusion_filter[:if].call(false).should be_true
+          expect(config.exclusion_filter[:if].call(false)).to be_true
         end
 
         it "excludes a spec with  { :if => nil } metadata" do
-          config.exclusion_filter[:if].call(nil).should be_true
+          expect(config.exclusion_filter[:if].call(nil)).to be_true
         end
       end
 
       describe "the default :unless filter" do
         it "excludes a spec with  { :unless => true } metadata" do
-          config.exclusion_filter[:unless].call(true).should be_true
+          expect(config.exclusion_filter[:unless].call(true)).to be_true
         end
 
         it "does not exclude a spec with { :unless => false } metadata" do
-          config.exclusion_filter[:unless].call(false).should be_false
+          expect(config.exclusion_filter[:unless].call(false)).to be_false
         end
 
         it "does not exclude a spec with { :unless => nil } metadata" do
-          config.exclusion_filter[:unless].call(nil).should be_false
+          expect(config.exclusion_filter[:unless].call(nil)).to be_false
         end
       end
     end
@@ -876,13 +876,13 @@ module RSpec::Core
       it "treats symbols as hash keys with true values when told to" do
         RSpec.configuration.stub(:treat_symbols_as_metadata_keys_with_true_values? => true)
         config.exclusion_filter = :foo
-        config.exclusion_filter.should eq({:foo => true})
+        expect(config.exclusion_filter).to eq({:foo => true})
       end
 
       it "overrides any exclusion filters set on the command line or in configuration files" do
         config.force(:exclusion_filter => { :foo => :bar })
         config.exclusion_filter = {:want => :this}
-        config.exclusion_filter.should eq({:want => :this})
+        expect(config.exclusion_filter).to eq({:want => :this})
       end
     end
 
@@ -891,19 +891,19 @@ module RSpec::Core
 
       it "sets the line numbers" do
         config.line_numbers = ['37']
-        config.filter.should eq({:line_numbers => [37]})
+        expect(config.filter).to eq({:line_numbers => [37]})
       end
 
       it "overrides filters" do
         config.filter_run :focused => true
         config.line_numbers = ['37']
-        config.filter.should eq({:line_numbers => [37]})
+        expect(config.filter).to eq({:line_numbers => [37]})
       end
 
       it "prevents subsequent filters" do
         config.line_numbers = ['37']
         config.filter_run :focused => true
-        config.filter.should eq({:line_numbers => [37]})
+        expect(config.filter).to eq({:line_numbers => [37]})
       end
     end
 
@@ -911,14 +911,14 @@ module RSpec::Core
       context "given true" do
         it "clears the backtrace clean patterns" do
           config.full_backtrace = true
-          config.backtrace_clean_patterns.should eq([])
+          expect(config.backtrace_clean_patterns).to eq([])
         end
       end
 
       context "given false" do
         it "restores backtrace clean patterns" do
           config.full_backtrace = false
-          config.backtrace_clean_patterns.should eq(RSpec::Core::Configuration::DEFAULT_BACKTRACE_PATTERNS)
+          expect(config.backtrace_clean_patterns).to eq(RSpec::Core::Configuration::DEFAULT_BACKTRACE_PATTERNS)
         end
       end
 
@@ -927,24 +927,29 @@ module RSpec::Core
         config_2 = Configuration.new
 
         config_1.full_backtrace = true
-        config_2.backtrace_clean_patterns.should_not be_empty
+        expect(config_2.backtrace_clean_patterns).not_to be_empty
       end
     end
 
     describe "#cleaned_from_backtrace? defaults" do
       it "returns true for rspec files" do
-        config.cleaned_from_backtrace?("lib/rspec/core.rb").
-          should be_true
+        expect(config.cleaned_from_backtrace?("lib/rspec/core.rb")).to be_true
       end
 
       it "returns true for spec_helper" do
-        config.cleaned_from_backtrace?("spec/spec_helper.rb").
-          should be_true
+        expect(config.cleaned_from_backtrace?("spec/spec_helper.rb")).to be_true
       end
 
       it "returns true for java files (for JRuby)" do
-        config.cleaned_from_backtrace?("org/jruby/RubyArray.java:2336").
-          should be_true
+        expect(config.cleaned_from_backtrace?("org/jruby/RubyArray.java:2336")).to be_true
+      end
+
+      it "returns true for files within installed gems" do
+        expect(config.cleaned_from_backtrace?('ruby-1.8.7-p334/gems/mygem-2.3.0/lib/mygem.rb')).to be_true
+      end
+
+      it "returns false for files in projects containing 'gems' in the name" do
+        expect(config.cleaned_from_backtrace?('code/my-gems-plugin/lib/plugin.rb')).to be_false
       end
     end
 
@@ -989,7 +994,7 @@ module RSpec::Core
       it "sets the output" do
         output = mock("output")
         config.output = output
-        config.output.should equal(output)
+        expect(config.output).to equal(output)
       end
     end
 
@@ -1015,16 +1020,16 @@ module RSpec::Core
           end
 
           it "defaults to nil" do
-            config.custom_option.should be_nil
+            expect(config.custom_option).to be_nil
           end
 
           it "adds a predicate" do
-            config.custom_option?.should be_false
+            expect(config.custom_option?).to be_false
           end
 
           it "can be overridden" do
             config.custom_option = "a value"
-            config.custom_option.should eq("a value")
+            expect(config.custom_option).to eq("a value")
           end
         end
 
@@ -1034,26 +1039,26 @@ module RSpec::Core
           end
 
           it "defaults to 'a value'" do
-            config.custom_option.should eq("a value")
+            expect(config.custom_option).to eq("a value")
           end
 
           it "returns true for the predicate" do
-            config.custom_option?.should be_true
+            expect(config.custom_option?).to be_true
           end
 
           it "can be overridden with a truthy value" do
             config.custom_option = "a new value"
-            config.custom_option.should eq("a new value")
+            expect(config.custom_option).to eq("a new value")
           end
 
           it "can be overridden with nil" do
             config.custom_option = nil
-            config.custom_option.should eq(nil)
+            expect(config.custom_option).to eq(nil)
           end
 
           it "can be overridden with false" do
             config.custom_option = false
-            config.custom_option.should eq(false)
+            expect(config.custom_option).to eq(false)
           end
         end
       end
@@ -1073,17 +1078,17 @@ module RSpec::Core
 
         it "delegates the getter to the other option" do
           config.another_custom_option = "this value"
-          config.custom_option.should eq("this value")
+          expect(config.custom_option).to eq("this value")
         end
 
         it "delegates the setter to the other option" do
           config.custom_option = "this value"
-          config.another_custom_option.should eq("this value")
+          expect(config.another_custom_option).to eq("this value")
         end
 
         it "delegates the predicate to the other option" do
           config.custom_option = true
-          config.another_custom_option?.should be_true
+          expect(config.another_custom_option?).to be_true
         end
       end
     end
@@ -1095,7 +1100,7 @@ module RSpec::Core
 
         config.extend(mod, :foo => :bar)
         config.configure_group(group)
-        group.should be_a(mod)
+        expect(group).to be_a(mod)
       end
 
       it "extends with 'module'" do
@@ -1104,7 +1109,7 @@ module RSpec::Core
 
         config.include(mod, :foo => :bar)
         config.configure_group(group)
-        group.included_modules.should include(mod)
+        expect(group.included_modules).to include(mod)
       end
 
       it "requires only one matching filter" do
@@ -1113,7 +1118,7 @@ module RSpec::Core
 
         config.include(mod, :foo => :bar, :baz => :bam)
         config.configure_group(group)
-        group.included_modules.should include(mod)
+        expect(group.included_modules).to include(mod)
       end
 
       it "includes each one before deciding whether to include the next" do
@@ -1129,8 +1134,8 @@ module RSpec::Core
         config.include(mod1)
         config.include(mod2, :foo => :bar)
         config.configure_group(group)
-        group.included_modules.should include(mod1)
-        group.included_modules.should include(mod2)
+        expect(group.included_modules).to include(mod1)
+        expect(group.included_modules).to include(mod2)
       end
 
       module IncludeOrExtendMeOnce
@@ -1186,15 +1191,15 @@ module RSpec::Core
 
     describe "#reset" do
       it "clears the reporter" do
-        config.reporter.should_not be_nil
+        expect(config.reporter).not_to be_nil
         config.reset
-        config.instance_variable_get("@reporter").should be_nil
+        expect(config.instance_variable_get("@reporter")).to be_nil
       end
 
       it "clears the formatters" do
         config.add_formatter "doc"
         config.reset
-        config.formatters.should be_empty
+        expect(config.formatters).to be_empty
       end
     end
 
@@ -1202,21 +1207,21 @@ module RSpec::Core
       it "forces order" do
         config.force :order => "default"
         config.order = "rand"
-        config.order.should eq("default")
+        expect(config.order).to eq("default")
       end
 
       it "forces order and seed with :order => 'rand:37'" do
         config.force :order => "rand:37"
         config.order = "default"
-        config.order.should eq("rand")
-        config.seed.should eq(37)
+        expect(config.order).to eq("rand")
+        expect(config.seed).to eq(37)
       end
 
       it "forces order and seed with :seed => '37'" do
         config.force :seed => "37"
         config.order = "default"
-        config.seed.should eq(37)
-        config.order.should eq("rand")
+        expect(config.seed).to eq(37)
+        expect(config.order).to eq("rand")
       end
 
       it 'can set random ordering' do
@@ -1224,24 +1229,24 @@ module RSpec::Core
         RSpec.stub(:configuration => config)
         list = [1, 2, 3, 4].extend(Extensions::Ordered::Examples)
         Kernel.should_receive(:rand).and_return(3, 1, 4, 2)
-        list.ordered.should eq([2, 4, 1, 3])
+        expect(list.ordered).to eq([2, 4, 1, 3])
       end
 
       it "forces 'false' value" do
         config.add_setting :custom_option
         config.custom_option = true
-        config.custom_option?.should be_true
+        expect(config.custom_option?).to be_true
         config.force :custom_option => false
-        config.custom_option?.should be_false
+        expect(config.custom_option?).to be_false
         config.custom_option = true
-        config.custom_option?.should be_false
+        expect(config.custom_option?).to be_false
       end
     end
 
     describe '#seed' do
       it 'returns the seed as an int' do
         config.seed = '123'
-        config.seed.should eq(123)
+        expect(config.seed).to eq(123)
       end
     end
 
@@ -1250,7 +1255,7 @@ module RSpec::Core
         before { config.order = :random }
 
         it 'returns true' do
-          config.randomize?.should be_true
+          expect(config.randomize?).to be_true
         end
       end
 
@@ -1258,7 +1263,7 @@ module RSpec::Core
         before { config.order = nil }
 
         it 'returns false' do
-          config.randomize?.should be_false
+          expect(config.randomize?).to be_false
         end
       end
     end
@@ -1268,18 +1273,18 @@ module RSpec::Core
         before { config.order = 'random:123' }
 
         it 'sets order to "random"' do
-          config.order.should eq('random')
+          expect(config.order).to eq('random')
         end
 
         it 'sets seed to 123' do
-          config.seed.should eq(123)
+          expect(config.seed).to eq(123)
         end
 
         it 'sets up random ordering' do
           RSpec.stub(:configuration => config)
           list = [1, 2, 3, 4].extend(Extensions::Ordered::Examples)
           Kernel.should_receive(:rand).and_return(3, 1, 4, 2)
-          list.ordered.should eq([2, 4, 1, 3])
+          expect(list.ordered).to eq([2, 4, 1, 3])
         end
       end
 
@@ -1290,18 +1295,18 @@ module RSpec::Core
         end
 
         it "sets the order to nil" do
-          config.order.should be_nil
+          expect(config.order).to be_nil
         end
 
         it "sets the seed to nil" do
-          config.seed.should be_nil
+          expect(config.seed).to be_nil
         end
 
         it 'clears the random ordering' do
           RSpec.stub(:configuration => config)
           list = [1, 2, 3, 4].extend(Extensions::Ordered::Examples)
           Kernel.should_not_receive(:rand)
-          list.ordered.should eq([1, 2, 3, 4])
+          expect(list.ordered).to eq([1, 2, 3, 4])
         end
       end
     end
@@ -1313,18 +1318,18 @@ module RSpec::Core
         examples = [1, 2, 3, 4]
         examples.extend Extensions::Ordered::Examples
         config.order_examples { |examples| examples.reverse }
-        examples.ordered.should eq([4, 3, 2, 1])
+        expect(examples.ordered).to eq([4, 3, 2, 1])
       end
 
       it 'sets #order to "custom"' do
         config.order_examples { |examples| examples.reverse }
-        config.order.should eq("custom")
+        expect(config.order).to eq("custom")
       end
     end
 
     describe "#example_ordering_block" do
       it 'defaults to a block that returns the passed argument' do
-        config.example_ordering_block.call([1, 2, 3]).should eq([1, 2, 3])
+        expect(config.example_ordering_block.call([1, 2, 3])).to eq([1, 2, 3])
       end
     end
 
@@ -1335,18 +1340,18 @@ module RSpec::Core
         groups = [1, 2, 3, 4]
         groups.extend Extensions::Ordered::ExampleGroups
         config.order_groups { |groups| groups.reverse }
-        groups.ordered.should eq([4, 3, 2, 1])
+        expect(groups.ordered).to eq([4, 3, 2, 1])
       end
 
       it 'sets #order to "custom"' do
         config.order_groups { |groups| groups.reverse }
-        config.order.should eq("custom")
+        expect(config.order).to eq("custom")
       end
     end
 
     describe "#group_ordering_block" do
       it 'defaults to a block that returns the passed argument' do
-        config.group_ordering_block.call([1, 2, 3]).should eq([1, 2, 3])
+        expect(config.group_ordering_block.call([1, 2, 3])).to eq([1, 2, 3])
       end
     end
 
@@ -1360,11 +1365,11 @@ module RSpec::Core
       end
 
       it 'sets a block that determines the ordering of a collection extended with Extensions::Ordered::Examples' do
-        examples.ordered.should eq([4, 3, 2, 1])
+        expect(examples.ordered).to eq([4, 3, 2, 1])
       end
 
       it 'sets a block that determines the ordering of a collection extended with Extensions::Ordered::ExampleGroups' do
-        groups.ordered.should eq([4, 3, 2, 1])
+        expect(groups.ordered).to eq([4, 3, 2, 1])
       end
     end
   end