rspec-expectations 2.99.2 → 3.0.0.beta1

data/lib/rspec/matchers/operator_matcher.rb

@@ -1,95 +1,81 @@
 module RSpec
   module Matchers
-    module BuiltIn
-      class OperatorMatcher
-        class << self
-          def registry
-            @registry ||= {}
-          end
+    class OperatorMatcher
+      class << self
+        def registry
+          @registry ||= {}
+        end
 
-          def register(klass, operator, matcher)
-            registry[klass] ||= {}
-            registry[klass][operator] = matcher
-          end
+        def register(klass, operator, matcher)
+          registry[klass] ||= {}
+          registry[klass][operator] = matcher
+        end
 
-          def unregister(klass, operator)
-            registry[klass] && registry[klass].delete(operator)
-          end
+        def unregister(klass, operator)
+          registry[klass] && registry[klass].delete(operator)
+        end
 
-          def get(klass, operator)
-            klass.ancestors.each { |ancestor|
-              matcher = registry[ancestor] && registry[ancestor][operator]
-              return matcher if matcher
-            }
+        def get(klass, operator)
+          klass.ancestors.each { |ancestor|
+            matcher = registry[ancestor] && registry[ancestor][operator]
+            return matcher if matcher
+          }
 
-            nil
-          end
+          nil
         end
+      end
 
-        def initialize(actual)
-          @actual = actual
-        end
+      def initialize(actual)
+        @actual = actual
+      end
 
-        def self.use_custom_matcher_or_delegate(operator)
-          define_method(operator) do |expected|
-            if !has_non_generic_implementation_of?(operator) && matcher = OperatorMatcher.get(@actual.class, operator)
-              @actual.__send__(::RSpec::Matchers.last_should, matcher.new(expected))
-            else
-              eval_match(@actual, operator, expected)
-            end
+      def self.use_custom_matcher_or_delegate(operator)
+        define_method(operator) do |expected|
+          if uses_generic_implementation_of?(operator) && matcher = OperatorMatcher.get(@actual.class, operator)
+            @actual.__send__(::RSpec::Matchers.last_should, matcher.new(expected))
+          else
+            eval_match(@actual, operator, expected)
           end
+        end
 
-          negative_operator = operator.sub(/^=/, '!')
-          if negative_operator != operator && respond_to?(negative_operator)
-            define_method(negative_operator) do |expected|
-              opposite_should = ::RSpec::Matchers.last_should == :should ? :should_not : :should
-              raise "RSpec does not support `#{::RSpec::Matchers.last_should} #{negative_operator} expected`.  " +
-                "Use `#{opposite_should} #{operator} expected` instead."
-            end
+        negative_operator = operator.sub(/^=/, '!')
+        if negative_operator != operator && respond_to?(negative_operator)
+          define_method(negative_operator) do |expected|
+            opposite_should = ::RSpec::Matchers.last_should == :should ? :should_not : :should
+            raise "RSpec does not support `#{::RSpec::Matchers.last_should} #{negative_operator} expected`.  " +
+              "Use `#{opposite_should} #{operator} expected` instead."
           end
         end
+      end
 
-        ['==', '===', '=~', '>', '>=', '<', '<='].each do |operator|
-          use_custom_matcher_or_delegate operator
-        end
+      ['==', '===', '=~', '>', '>=', '<', '<='].each do |operator|
+        use_custom_matcher_or_delegate operator
+      end
 
-        def fail_with_message(message)
-          RSpec::Expectations.fail_with(message, @expected, @actual)
-        end
+      def fail_with_message(message)
+        RSpec::Expectations.fail_with(message, @expected, @actual)
+      end
 
-        def description
-          "#{@operator} #{@expected.inspect}"
-        end
+      def description
+        "#{@operator} #{@expected.inspect}"
+      end
 
-      private
+    private
 
-        if Method.method_defined?(:owner) # 1.8.6 lacks Method#owner :-(
-          def has_non_generic_implementation_of?(op)
-            Expectations.method_handle_for(@actual, op).owner != ::Kernel
-          rescue NameError
-            false
-          end
-        else
-          def has_non_generic_implementation_of?(op)
-            # This is a bit of a hack, but:
-            #
-            # {}.method(:=~).to_s # => "#<Method: Hash(Kernel)#=~>"
-            #
-            # In the absence of Method#owner, this is the best we
-            # can do to see if the method comes from Kernel.
-            !Expectations.method_handle_for(@actual, op).to_s.include?('(Kernel)')
-          rescue NameError
-            false
-          end
-        end
+      def uses_generic_implementation_of?(op)
+        Expectations.method_handle_for(@actual, op).owner == ::Kernel
+      rescue NameError
+        false
+      end
 
-        def eval_match(actual, operator, expected)
-          ::RSpec::Matchers.last_matcher = self
-          @operator, @expected = operator, expected
-          __delegate_operator(actual, operator, expected)
-        end
+      def eval_match(actual, operator, expected)
+        ::RSpec::Matchers.last_matcher = self
+        @operator, @expected = operator, expected
+        __delegate_operator(actual, operator, expected)
       end
+    end
 
+    module BuiltIn
       class PositiveOperatorMatcher < OperatorMatcher
         def __delegate_operator(actual, operator, expected)
           if actual.__send__(operator, expected)

data/lib/rspec/matchers/pretty.rb

@@ -21,8 +21,6 @@ module RSpec
       end
 
       def _pretty_print(array)
-        RSpec.deprecate("`RSpec::Matchers::Pretty#_pretty_print`",
-                        :replacement => "`RSpec::Matchers::Pretty#to_sentence`")
         result = ""
         array.each_with_index do |item, index|
           if index < (array.length - 2)
@@ -45,8 +43,6 @@ module RSpec
       end
 
       def expected_to_sentence
-        RSpec.deprecate("`RSpec::Matchers::Pretty#expected_to_sentence`",
-                        :replacement => "`RSpec::Matchers::Pretty#to_sentence(expected)`")
         to_sentence(@expected) if defined?(@expected)
       end
 

data/lib/rspec/matchers/test_unit_integration.rb

@@ -3,26 +3,9 @@
 # and a 1.9 bug can lead to infinite recursion from the `super` call in our
 # method_missing hook.  See this gist for more info:
 # https://gist.github.com/845896
-if defined?(MiniTest::TestCase)
-  MiniTest::TestCase.add_setup_hook do |instance|
-    unless ::RSpec::Matchers === instance
-      ::RSpec.deprecate("rspec-expectations' built-in integration with minitest < 5.x",
-                        :replacement => "`include RSpec::Matchers` from within `Minitest::TestCase`")
-
-      MiniTest::TestCase.send(:include, RSpec::Matchers)
-    end
-  end
-elsif defined?(Test::Unit::TestCase)
-  Test::Unit::TestCase.class_eval do
-    def setup
-      unless ::RSpec::Matchers === self
-        ::RSpec.deprecate("rspec-expectations' built-in integration with Test::Unit",
-                          :replacement => "`include RSpec::Matchers` from within `Test::Unit::TestCase`")
-
-        Test::Unit::TestCase.send(:include, RSpec::Matchers)
-      end
-
-      super if defined?(super)
-    end
-  end
+if defined?(MiniTest::Unit::TestCase)
+  MiniTest::Unit::TestCase.send(:include, RSpec::Matchers)
+end
+if defined?(Test::Unit::TestCase)
+  Test::Unit::TestCase.send(:include, RSpec::Matchers)
 end

data/spec/rspec/expectations/expectation_target_spec.rb

@@ -22,12 +22,6 @@ module RSpec
           }.to raise_error(ArgumentError)
         end
 
-        it 'raises a wrong number of args ArgumentError when given two args' do
-          expect {
-            expect(1, 2)
-          }.to raise_error(ArgumentError, /wrong number of arg/)
-        end
-
         it 'raises an ArgumentError when given neither an argument nor a block' do
           expect {
             expect
@@ -82,62 +76,6 @@ module RSpec
           }.to raise_error(ArgumentError)
         end
       end
-
-      context "when passed a block" do
-        it 'can be used with a block matcher' do
-          expect { }.not_to raise_error
-        end
-
-        context 'when passed a value matcher' do
-          it 'issues a warning to instruct the user to use a value expression or fix the matcher (for `to`)' do
-            expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /block expectation/)
-            expect { }.to be_an(Object)
-          end
-
-          it 'issues a warning to instruct the user to use a value expression or fix the matcher (for `not_to`)' do
-            expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /block expectation/)
-            expect { }.not_to be_an(String)
-          end
-
-          it 'issues a warning to instruct the user to use a value expression or fix the matcher (for `to_not`)' do
-            expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /block expectation/)
-            expect { }.to_not be_an(String)
-          end
-
-          it 'assumes a custom matcher that does not define `supports_block_expectations?` is not a block matcher (since it is relatively rare)' do
-            custom_matcher = Module.new do
-              def self.matches?(value); true; end
-              def self.description; "foo"; end
-            end
-
-            expect_deprecation_with_call_site(__FILE__, __LINE__ + 2, /block expectation/)
-            expect(3).to custom_matcher # to show the custom matcher can be used as a matcher
-            expect { 3 }.to custom_matcher
-          end
-
-          it "uses the matcher's `description` in the warning" do
-            custom_matcher = Module.new do
-              def self.matches?(value); true; end
-              def self.description; "matcher-description"; end
-            end
-
-            expect_deprecation_with_replacement(/\(matcher-description\)/)
-            expect { }.to custom_matcher
-          end
-
-          context 'when the matcher does not define `description` (since it is an optional part of the protocol)' do
-            it 'uses `inspect` in the warning instead' do
-              custom_matcher = Module.new do
-                def self.matches?(value); true; end
-                def self.inspect; "matcher-inspect"; end
-              end
-
-              expect_deprecation_with_replacement(/\(matcher-inspect\)/)
-              expect { }.to custom_matcher
-            end
-          end
-        end
-      end
     end
   end
 end

data/spec/rspec/expectations/extensions/kernel_spec.rb

@@ -32,10 +32,6 @@ describe Object, "#should" do
           true
         end
 
-        def respond_to?(name, include_all=false)
-          super || name == :proxied? || @target.respond_to?(name, include_all)
-        end
-
         def method_missing(name, *args)
           @target.send(name, *args)
         end

data/spec/rspec/expectations_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 module RSpec
   describe Expectations do
     def file_contents_for(lib, filename)
@@ -9,18 +7,6 @@ module RSpec
       File.read(file)
     end
 
-    it 'has an up-to-date caller_filter file' do
-      expectations = file_contents_for("expectations", "rspec/expectations/caller_filter.rb")
-      core         = file_contents_for("core",         "rspec/core/caller_filter.rb")
-
-      expect(expectations).to eq(core)
-    end
-
-    it 'prints a deprecation warning when the root file is loaded' do
-      expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /rspec-expectations/)
-      load "rspec-expectations.rb"
-    end
-
     describe '.method_handle_for(object, method_name)' do
 
       class UntamperedClass
@@ -30,18 +16,11 @@ module RSpec
       end
 
       class ClassWithMethodOverridden < UntamperedClass
-        def method(name)
+        def method
           :baz
         end
       end
 
-      class ProxyClass < Struct.new(:original)
-        undef :=~, :method
-        def method_missing(name, *args, &block)
-          original.__send__(name, *args, &block)
-        end
-      end
-
       if RUBY_VERSION.to_f > 1.8
         class BasicClass < BasicObject
           def foo
@@ -64,27 +43,7 @@ module RSpec
         expect(Expectations.method_handle_for(object, :foo).call).to eq :bar
       end
 
-      it 'fetches method definitions for proxy objects' do
-        object = ProxyClass.new([])
-        expect(Expectations.method_handle_for(object, :=~)).to be_a Method
-      end
-
-      it 'fails with `NameError` when an error is raised when fetching a method from an object that has overriden `method`' do
-        object = double
-        allow(object).to receive(:method).and_raise(Exception)
-        expect {
-          Expectations.method_handle_for(object, :some_undefined_method)
-        }.to raise_error(NameError)
-      end
-
-      it 'fails with `NameError` when a method is fetched from an object that has overriden `method` and is not a method' do
-        object = ProxyClass.new(double(:method => :baz))
-        expect {
-          Expectations.method_handle_for(object, :=~)
-        }.to raise_error(NameError)
-      end
-
-      it 'fetches method definitions for basic objects', :if => (RUBY_VERSION.to_i >= 2 && RUBY_ENGINE != 'rbx') do
+      it 'fetches method definitions for basic objects', :if => RUBY_VERSION.to_i >= 2 do
         object = BasicClass.new
         expect(Expectations.method_handle_for(object, :foo).call).to eq :bar
       end

data/spec/rspec/matchers/base_matcher_spec.rb

@@ -39,39 +39,24 @@ module RSpec::Matchers::BuiltIn
 
     end
 
-    describe "#failure_message_for_should" do
-      context "when the parameter to .new is omitted" do
-        it "describes what was expected" do
-          matcher_class = Class.new(BaseMatcher) do
-            def name=(name)
-              @name = name
-            end
-
-            def match(expected, actual)
-              false
-            end
+    describe "#==" do
+      it "responds the same way as matches?" do
+        matcher = Class.new(BaseMatcher) do
+          def initialize(expected)
+            @expected = expected
           end
 
-          matcher = matcher_class.new
-          matcher.name = "be something"
-          matcher.matches?("foo")
-          expect(matcher.failure_message_for_should).to eq('expected "foo" to be something')
+          def matches?(actual)
+            (@actual = actual) == @expected
+          end
         end
-      end
-    end
 
-    it_behaves_like "an RSpec matcher", :valid_value => 3, :invalid_value => 4 do
-      matcher_class = Class.new(BaseMatcher) do
-        def initialize(expected)
-          @expected = expected
-        end
+        expect(matcher.new(3).matches?(3)).to be_truthy
+        expect(matcher.new(3)).to eq(3)
 
-        def matches?(actual)
-          (@actual = actual) == @expected
-        end
+        expect(matcher.new(3).matches?(4)).to be_falsey
+        expect(matcher.new(3)).not_to eq(4)
       end
-
-      let(:matcher) { matcher_class.new(3) }
     end
   end
 end

data/spec/rspec/matchers/be_spec.rb

@@ -31,20 +31,14 @@ describe "expect(...).to be_predicate" do
     }.to raise_error(NameError, /happy\?/)
   end
 
-  it 'warns of deprecation when :predicate? is private' do
+  it 'fails when :predicate? is private' do
     privately_happy = Class.new do
       private
         def happy?
           true
         end
     end
-    allow(RSpec).to receive(:deprecate)
-    expect(RSpec).to receive(:deprecate).with(
-      "matching with be_happy on private method happy?",
-      :replacement => "`expect(object.send(:happy?)).to be_true` or change the method's visibility to public",
-      :call_site => RSpec::Mocks::ArgumentMatchers::RegexpMatcher.new(/#{__FILE__}:#{__LINE__ + 2}/)
-    )
-    expect(privately_happy.new).to be_happy
+    expect { expect(privately_happy.new).to be_happy }.to raise_error
   end
 
   it "fails on error other than NameError" do
@@ -68,26 +62,6 @@ describe "expect(...).to be_predicate" do
     value = double(:happy? => false)
     expect(matcher == value).to be false
   end
-
-  it 'warns of deprecation when actual does not respond to :predicate?' do
-    oddly_happy_class = Class.new do
-      def method_missing(method)
-        return true if method == :happy?
-      end
-    end
-    expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /Matching with be_happy on an object that doesn't respond to `happy\?`/)
-    expect(oddly_happy_class.new).to be_happy
-  end
-
-  it 'does not warn of deprecation when actual responds to present tense predicate' do
-    present_happy_class = Class.new do
-      def exists?
-        true
-      end
-    end
-    expect_no_deprecation
-    expect(present_happy_class.new).to be_exist
-  end
 end
 
 describe "expect(...).not_to be_predicate" do
@@ -283,49 +257,6 @@ describe "expect(...).to be_truthy" do
   end
 end
 
-describe "expect(...).to be_false" do
-  it "is deprecated" do
-    expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /be_false/)
-    expect(false).to be_false
-  end
-
-  it "has the correct call site in the deprecation message" do
-    expect_deprecation_with_call_site(__FILE__, __LINE__ + 1)
-    expect(false).to be_false
-  end
-
-  it "still passes" do
-    allow(RSpec).to receive(:deprecate)
-    expect(false).to be_false
-  end
-
-  it "still fails" do
-    allow(RSpec).to receive(:deprecate)
-    expect {
-      expect(true).to be_false
-    }.to fail_with(/expected: falsey value/)
-  end
-end
-
-describe "expect(...).to be_true" do
-  it "is deprecated" do
-    expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /be_true/)
-    expect(true).to be_true
-  end
-
-  it "still passes" do
-    allow(RSpec).to receive(:deprecate)
-    expect(true).to be_true
-  end
-
-  it "still fails" do
-    allow(RSpec).to receive(:deprecate)
-    expect {
-      expect(false).to be_true
-    }.to fail_with(/expected: truthy value/)
-  end
-end
-
 describe "expect(...).to be_falsey" do
   it "passes when actual equal?(false)" do
     expect(false).to be_falsey