rspec-expectations 2.99.0.beta1 → 2.99.0.beta2

data/lib/rspec/matchers/built_in/raise_error.rb

@@ -2,6 +2,8 @@ module RSpec
   module Matchers
     module BuiltIn
       class RaiseError
+        include MatchAliases
+
         def initialize(expected_error_or_message=Exception, expected_message=nil, &block)
           @block = block
           @actual_error = nil
@@ -51,7 +53,6 @@ module RSpec
         ensure
           return (@raised_expected_error & @with_expected_message) ? (@eval_block ? @eval_block_passed : true) : false
         end
-        alias == matches?
 
         def does_not_match?(given_proc)
           !matches?(given_proc, :negative_expectation)

data/lib/rspec/matchers/built_in/respond_to.rb

@@ -2,6 +2,8 @@ module RSpec
   module Matchers
     module BuiltIn
       class RespondTo
+        include MatchAliases
+
         def initialize(*names)
           @names = names
           @expected_arity = nil
@@ -10,7 +12,6 @@ module RSpec
         def matches?(actual)
           find_failing_method_names(actual, :reject).empty?
         end
-        alias == matches?
 
         def does_not_match?(actual)
           find_failing_method_names(actual, :select).empty?

data/lib/rspec/matchers/built_in/satisfy.rb

@@ -2,6 +2,8 @@ module RSpec
   module Matchers
     module BuiltIn
       class Satisfy
+        include MatchAliases
+
         def initialize(&block)
           @block = block
         end
@@ -11,7 +13,6 @@ module RSpec
           @actual = actual
           @block.call(actual)
         end
-        alias == matches?
 
         def failure_message_for_should
           "expected #{@actual} to satisfy block"

data/lib/rspec/matchers/built_in/throw_symbol.rb

@@ -2,6 +2,8 @@ module RSpec
   module Matchers
     module BuiltIn
       class ThrowSymbol
+        include MatchAliases
+
         def initialize(expected_symbol = nil, expected_arg=nil)
           @expected_symbol = expected_symbol
           @expected_arg = expected_arg
@@ -51,7 +53,6 @@ module RSpec
             end
           end
         end
-        alias == matches?
 
         def failure_message_for_should
           "expected #{expected} to be thrown, got #{caught}"

data/lib/rspec/matchers/built_in/yield.rb

@@ -181,6 +181,8 @@ module RSpec
       end
 
       class YieldWithArgs
+        include MatchAliases
+
         def initialize(*args)
           @expected = args
         end
@@ -190,7 +192,6 @@ module RSpec
           @actual = @probe.single_yield_args
           @probe.yielded_once?(:yield_with_args) && args_match?
         end
-        alias == matches?
 
         def failure_message_for_should
           "expected given block to yield with arguments, but #{positive_failure_reason}"
@@ -251,6 +252,8 @@ module RSpec
       end
 
       class YieldSuccessiveArgs
+        include MatchAliases
+
         def initialize(*args)
           @expected = args
         end
@@ -260,7 +263,6 @@ module RSpec
           @actual = @probe.successive_yield_args
           args_match?
         end
-        alias == matches?
 
         def failure_message_for_should
           "expected given block to yield successively with arguments, but yielded with unexpected arguments" +

data/lib/rspec/matchers/match_aliases.rb

@@ -0,0 +1,22 @@
+module RSpec
+  module Matchers
+    module MatchAliases
+      def ==(other)
+        return true if equal?(other)
+
+        matched = matches?(other)
+
+        if matched
+          RSpec.deprecate("Using `matcher == value` as an alias for `#matches?`", :replacement => "`matcher === value`")
+        end
+
+        matched
+      end
+
+      def ===(other)
+        matches?(other)
+      end
+    end
+  end
+end
+

data/lib/rspec/matchers/matcher.rb

@@ -11,7 +11,7 @@ module RSpec
         include RSpec::Matchers::Pretty
         include RSpec::Matchers
 
-        attr_reader :expected, :actual, :rescued_exception
+        attr_reader :actual, :rescued_exception
         attr_accessor :matcher_execution_context
 
         # @api private
@@ -34,6 +34,23 @@ module RSpec
           :@expected_exception
         ].to_set
 
+        def expected
+          if @expected.size == 1
+            RSpec.warn_deprecation(
+              "Custom matchers in 3.x will set expected to be a single value "+
+              "(when provided as such) rather than an array. This may change "+
+              "the behaviour of your matcher.\n"+
+              "To continue to access this as an array use `expected_array`\n"+
+              "Called from: #{ RSpec::CallerFilter.first_non_rspec_line }\n\n"
+            )
+          end
+          @expected
+        end
+
+        def expected_as_array
+          @expected
+        end
+
         # @api private
         def for_expected(*expected)
           @expected = expected

data/lib/rspec/matchers/operator_matcher.rb

@@ -1,95 +1,95 @@
 module RSpec
   module Matchers
-    class OperatorMatcher
-      class << self
-        def registry
-          @registry ||= {}
-        end
+    module BuiltIn
+      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
+            nil
+          end
         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 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)
+        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
-        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."
+          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
-      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 uses_generic_implementation_of?(op)
-          Expectations.method_handle_for(@actual, op).owner == ::Kernel
-        rescue NameError
-          false
-        end
-      else
-        def uses_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
+        if Method.method_defined?(:owner) # 1.8.6 lacks Method#owner :-(
+          def uses_generic_implementation_of?(op)
+            Expectations.method_handle_for(@actual, op).owner == ::Kernel
+          rescue NameError
+            false
+          end
+        else
+          def uses_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
-      end
 
-      def eval_match(actual, operator, expected)
-        ::RSpec::Matchers.last_matcher = self
-        @operator, @expected = operator, expected
-        __delegate_operator(actual, operator, expected)
+        def eval_match(actual, operator, expected)
+          ::RSpec::Matchers.last_matcher = self
+          @operator, @expected = operator, expected
+          __delegate_operator(actual, operator, expected)
+        end
       end
-    end
 
-    module BuiltIn
       class PositiveOperatorMatcher < OperatorMatcher
         def __delegate_operator(actual, operator, expected)
           if actual.__send__(operator, expected)

data/lib/rspec/matchers/test_unit_integration.rb

@@ -3,9 +3,26 @@
 # 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::Unit::TestCase)
-  MiniTest::Unit::TestCase.send(:include, RSpec::Matchers)
-end
-if defined?(Test::Unit::TestCase)
-  Test::Unit::TestCase.send(:include, RSpec::Matchers)
+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
 end

data/spec/rspec/expectations_spec.rb

@@ -50,7 +50,7 @@ module RSpec
         expect(Expectations.method_handle_for(object, :foo).call).to eq :bar
       end
 
-      it 'fetches method definitions for basic objects', :if => RUBY_VERSION.to_i >= 2 do
+      it 'fetches method definitions for basic objects', :if => (RUBY_VERSION.to_i >= 2 && RUBY_ENGINE != 'rbx') 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,24 +39,39 @@ module RSpec::Matchers::BuiltIn
 
     end
 
-    describe "#==" do
-      it "responds the same way as matches?" do
-        matcher = Class.new(BaseMatcher) do
-          def initialize(expected)
-            @expected = expected
-          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 matches?(actual)
-            (@actual = actual) == @expected
+            def match(expected, actual)
+              false
+            end
           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')
         end
+      end
+    end
 
-        expect(matcher.new(3).matches?(3)).to be_truthy
-        expect(matcher.new(3)).to eq(3)
+    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?(4)).to be_falsey
-        expect(matcher.new(3)).not_to eq(4)
+        def matches?(actual)
+          (@actual = actual) == @expected
+        end
       end
+
+      let(:matcher) { matcher_class.new(3) }
     end
   end
 end

data/spec/rspec/matchers/be_close_spec.rb

@@ -8,7 +8,10 @@ module RSpec
       end
 
       it "is deprecated" do
-        expect(RSpec).to receive(:deprecate).with(/be_close.*/, :replacement => "be_within(0.5).of(3.0)")
+        expect_deprecation_with_type('be_close(3.0, 0.5)',
+          'be_within(0.5).of(3.0)',
+          'the be_close matcher'
+        )
         be_close(3.0, 0.5)
       end
 

data/spec/rspec/matchers/be_spec.rb

@@ -264,7 +264,7 @@ end
 
 describe "expect(...).to be_false" do
   it "is deprecated" do
-    expect(RSpec).to receive(:deprecate).with(/be_false/, :replacement => match(/falsey.*false/))
+    expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /be_false/)
     expect(false).to be_false
   end
 
@@ -288,7 +288,7 @@ end
 
 describe "expect(...).to be_true" do
   it "is deprecated" do
-    expect(RSpec).to receive(:deprecate).with(/be_true/, :replacement => match(/truthy.*true/))
+    expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /be_true/)
     expect(true).to be_true
   end