rspec-expectations 3.8.5 → 3.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58597a62f47f10ecd74eda0086bcee4ca68878120d63cc670ebae37f9db1d252
-  data.tar.gz: 7443ec753991ae3c88ac9be2e8a22aab784b7e10bd2be481bf8a83daf3b85778
+  metadata.gz: ba515bcbb264eef62d6948840e73b71ef3a68ed947d2e711df04fdf1b04fa4ec
+  data.tar.gz: ba8501df256831e843786ca4f78cc7825e8ad6dca125191beda504de0c1d16e7
 SHA512:
-  metadata.gz: 36dab83e0399bbf5c58f17f3302c865ca4ec92123c97cc6eea1f9bf80a5466e643adfbd3056e46a653c5bbc08fc93f5d804bc9ca4a2e841468b22f09e2a140ec
-  data.tar.gz: f4b9263c27571536fa276eefee5a2c115a9f1f3d070f1abcaf4fba9e5e2cd2f11e04f48d146c870b26d019f6fb8533b3e2b605ff422ab32832f51d1531743515
+  metadata.gz: ac2ff1267b689ba5daf08898a11ff97f1f2554db817f43135a6b1d96bcada94f03d728ddda4050158fcf8a483b8295644457aea810d18b37686d5aa253007917
+  data.tar.gz: 6527bed095e09131e0e8a50f12784d017953f073b4099d710df7fff638f632d03bedba40836adeba6aa33f51d9d4c501f795c364c6e1304ddc8c41225df2c18d

data/Changelog.md

@@ -1,3 +1,58 @@
+### 3.9.3 / 2020-10-23
+[Full Changelog](http://github.com/rspec/rspec-expectations/compare/v3.9.2...v3.9.3)
+
+Bug Fixes:
+
+* Swap the comparison of the delta vs the expected for the `be_within` matcher allowing
+  more complicated oobjects to be compared providing they provide `abs` and other
+  comparison methods. (Kelly Stannard, #1182)
+* Properly format expected in the description of the `be_within` matcher. (Jon Rowe, #1185)
+* Remove warning when using keyword arguments with `be_` and `have_` matchers on 2.7.x
+  (Jon Rowe, #1187)
+* Prevent formatting a single hash as a list of key value pairs in default failure messages
+  for custom matches (fixes formatting in `EnglishPhrasing#list`). (Robert Eshleman, #1193)
+* Prevent errors from causing false positives when using `be <operator>` comparison, e.g.
+  `expect(1).not_to be < 'a'` will now correctly fail rather than pass. (Jon Rowe, #1208)
+
+### 3.9.2 / 2020-05-08
+[Full Changelog](http://github.com/rspec/rspec-expectations/compare/v3.9.1...v3.9.2)
+
+Bug Fixes:
+
+* Issue a proper `ArgumentError` when invalid arguments are given to `yield_control`
+  modifiers such as `at_least` et al. (Marc-André Lafortune, #1167)
+* Prevent Ruby 2.7 keyword arguments warning from being issued by custom
+  matcher definitions. (Jon Rowe, #1176)
+
+### 3.9.1 / 2020-03-13
+[Full Changelog](http://github.com/rspec/rspec-expectations/compare/v3.9.0...v3.9.1)
+
+Bug Fixes:
+
+* Issue an improved warning when using `respond_to(...).with(n).arguments` and ignore
+  the warning when using with `have_attributes(...)`. (Jon Rowe, #1164)
+
+### 3.9.0 / 2019-10-08
+[Full Changelog](http://github.com/rspec/rspec-expectations/compare/v3.8.6...v3.9.0)
+
+Enhancements:
+
+* The `respond_to` matcher now uses the signature from `initialize` to validate checks
+  for `new` (unless `new` is non standard). (Jon Rowe, #1072)
+* Generated descriptions for matchers now use `is expected to` rather than `should` in
+  line with our preferred DSL. (Pete Johns, #1080, rspec/rspec-core#2572)
+* Add the ability to re-raise expectation errors when matching
+  with `match_when_negated` blocks. (Jon Rowe, #1130)
+* Add a warning when an empty diff is produce due to identical inspect output.
+  (Benoit Tigeot, #1126)
+
+### 3.8.6 / 2019-10-07
+
+Bug Fixes:
+
+* Revert #1125 due to the change being incompatible with our semantic versioning
+  policy.
+
 ### 3.8.5 / 2019-10-02
 [Full Changelog](http://github.com/rspec/rspec-expectations/compare/v3.8.4...v3.8.5)
 
@@ -22,7 +77,7 @@ Bug Fixes:
 * Prevent composed `all` matchers from leaking into their siblings leading to duplicate
   failures. (Jamie English, #1086)
 * Prevent objects which change their hash on comparison from failing change checks.
-  (Phil Pirozhkov, #1100)
+  (Phil Pirozhkov, #1110)
 * Issue an `ArgumentError` rather than a `NoMethodError` when `be_an_instance_of` and
   `be_kind_of` matchers encounter objects not supporting those methods.
   (Taichi Ishitani, #1107)

data/README.md

@@ -1,4 +1,4 @@
-# RSpec Expectations [![Build Status](https://secure.travis-ci.org/rspec/rspec-expectations.svg?branch=master)](http://travis-ci.org/rspec/rspec-expectations) [![Code Climate](https://codeclimate.com/github/rspec/rspec-expectations.svg)](https://codeclimate.com/github/rspec/rspec-expectations)
+# RSpec Expectations [![Build Status](https://secure.travis-ci.org/rspec/rspec-expectations.svg?branch=main)](http://travis-ci.org/rspec/rspec-expectations) [![Code Climate](https://codeclimate.com/github/rspec/rspec-expectations.svg)](https://codeclimate.com/github/rspec/rspec-expectations)
 
 RSpec::Expectations lets you express expected outcomes on an object in an
 example.
@@ -15,12 +15,12 @@ rspec-core and rspec-mocks):
 
     gem install rspec
 
-Want to run against the `master` branch? You'll need to include the dependent
+Want to run against the `main` branch? You'll need to include the dependent
 RSpec repos as well. Add the following to your `Gemfile`:
 
 ```ruby
 %w[rspec-core rspec-expectations rspec-mocks rspec-support].each do |lib|
-  gem lib, :git => "https://github.com/rspec/#{lib}.git", :branch => 'master'
+  gem lib, :git => "https://github.com/rspec/#{lib}.git", :branch => 'main'
 end
 ```
 
@@ -175,30 +175,45 @@ expect(1..10).to cover(3)
 ### Collection membership
 
 ```ruby
-expect(actual).to include(expected)
+# exact order, entire collection
+expect(actual).to eq(expected)
+
+# exact order, partial collection (based on an exact position)
 expect(actual).to start_with(expected)
 expect(actual).to end_with(expected)
 
-expect(actual).to contain_exactly(individual, items)
-# ...which is the same as:
-expect(actual).to match_array(expected_array)
+# any order, entire collection
+expect(actual).to match_array(expected)
+
+# You can also express this by passing the expected elements
+# as individual arguments
+expect(actual).to contain_exactly(expected_element1, expected_element2)
+
+ # any order, partial collection
+expect(actual).to include(expected)
 ```
 
 #### Examples
 
 ```ruby
-expect([1, 2, 3]).to include(1)
-expect([1, 2, 3]).to include(1, 2)
-expect([1, 2, 3]).to start_with(1)
-expect([1, 2, 3]).to start_with(1, 2)
-expect([1, 2, 3]).to end_with(3)
-expect([1, 2, 3]).to end_with(2, 3)
-expect({:a => 'b'}).to include(:a => 'b')
-expect("this string").to include("is str")
-expect("this string").to start_with("this")
-expect("this string").to end_with("ring")
-expect([1, 2, 3]).to contain_exactly(2, 3, 1)
-expect([1, 2, 3]).to match_array([3, 2, 1])
+expect([1, 2, 3]).to eq([1, 2, 3])            # Order dependent equality check
+expect([1, 2, 3]).to include(1)               # Exact ordering, partial collection matches
+expect([1, 2, 3]).to include(2, 3)            #
+expect([1, 2, 3]).to start_with(1)            # As above, but from the start of the collection
+expect([1, 2, 3]).to start_with(1, 2)         #
+expect([1, 2, 3]).to end_with(3)              # As above but from the end of the collection
+expect([1, 2, 3]).to end_with(2, 3)           #
+expect({:a => 'b'}).to include(:a => 'b')     # Matching within hashes
+expect("this string").to include("is str")    # Matching within strings
+expect("this string").to start_with("this")   #
+expect("this string").to end_with("ring")     #
+expect([1, 2, 3]).to contain_exactly(2, 3, 1) # Order independent matches
+expect([1, 2, 3]).to match_array([3, 2, 1])   #
+
+# Order dependent compound matchers
+expect(
+  [{:a => 'hash'},{:a => 'another'}]
+).to match([a_hash_including(:a => 'hash'), a_hash_including(:a => 'another')])
 ```
 
 ## `should` syntax
@@ -212,7 +227,7 @@ actual.should be > 3
 [1, 2, 3].should_not include 4
 ```
 
-See [detailed information on the `should` syntax and its usage.](https://github.com/rspec/rspec-expectations/blob/master/Should.md)
+See [detailed information on the `should` syntax and its usage.](https://github.com/rspec/rspec-expectations/blob/main/Should.md)
 
 ## Compound Matcher Expressions
 

data/lib/rspec/expectations/expectation_target.rb

@@ -33,16 +33,16 @@ module RSpec
       end
 
       # @private
-      def self.for(value, &block)
+      def self.for(value, block)
         if UndefinedValue.equal?(value)
-          unless block_given?
+          unless block
             raise ArgumentError, "You must pass either an argument or a block to `expect`."
           end
           BlockExpectationTarget.new(block)
-        elsif block_given?
+        elsif block
           raise ArgumentError, "You cannot pass both an argument and a block to `expect`."
         else
-          ValueExpectationTarget.new(value)
+          new(value)
         end
       end
 
@@ -90,40 +90,6 @@ module RSpec
       include InstanceMethods
     end
 
-    # @private
-    # Validates the provided matcher to ensure it supports block
-    # expectations, in order to avoid user confusion when they
-    # use a block thinking the expectation will be on the return
-    # value of the block rather than the block itself.
-    class ValueExpectationTarget < ExpectationTarget
-      def to(matcher=nil, message=nil, &block)
-        enforce_value_expectation(matcher)
-        super
-      end
-
-      def not_to(matcher=nil, message=nil, &block)
-        enforce_value_expectation(matcher)
-        super
-      end
-
-    private
-
-      def enforce_value_expectation(matcher)
-        return if supports_value_expectations?(matcher)
-
-        raise ExpectationNotMetError, "You must pass a block rather than an argument to `expect` to use the provided " \
-          "block expectation matcher (#{RSpec::Support::ObjectFormatter.format(matcher)})."
-      end
-
-      def supports_value_expectations?(matcher)
-        if matcher.respond_to?(:supports_value_expectations?)
-          matcher.supports_value_expectations?
-        else
-          true
-        end
-      end
-    end
-
     # @private
     # Validates the provided matcher to ensure it supports block
     # expectations, in order to avoid user confusion when they
@@ -152,11 +118,9 @@ module RSpec
       end
 
       def supports_block_expectations?(matcher)
-        if matcher.respond_to?(:supports_block_expectations?)
-          matcher.supports_block_expectations?
-        else
-          false
-        end
+        matcher.supports_block_expectations?
+      rescue NoMethodError
+        false
       end
     end
   end

data/lib/rspec/expectations/handler.rb

@@ -52,7 +52,7 @@ module RSpec
       end
 
       def self.verb
-        "should"
+        'is expected to'
       end
 
       def self.should_method
@@ -82,7 +82,7 @@ module RSpec
       end
 
       def self.verb
-        "should not"
+        'is expected not to'
       end
 
       def self.should_method

data/lib/rspec/expectations/syntax.rb

@@ -70,7 +70,7 @@ module RSpec
 
         syntax_host.module_exec do
           def expect(value=::RSpec::Expectations::ExpectationTarget::UndefinedValue, &block)
-            ::RSpec::Expectations::ExpectationTarget.for(value, &block)
+            ::RSpec::Expectations::ExpectationTarget.for(value, block)
           end
         end
       end

data/lib/rspec/expectations/version.rb

@@ -2,7 +2,7 @@ module RSpec
   module Expectations
     # @private
     module Version
-      STRING = '3.8.5'
+      STRING = '3.9.3'
     end
   end
 end

data/lib/rspec/matchers.rb

@@ -238,7 +238,7 @@ module RSpec
   # best to find a more positive name for the negated form, such as
   # `avoid_changing` rather than `not_change`.
   #
-  module Matchers
+  module Matchers # rubocop:disable Metrics/ModuleLength
     extend ::RSpec::Matchers::DSL
 
     # @!macro [attach] alias_matcher
@@ -953,14 +953,29 @@ module RSpec
     HAS_REGEX = /^(?:have_)(.*)/
     DYNAMIC_MATCHER_REGEX = Regexp.union(BE_PREDICATE_REGEX, HAS_REGEX)
 
-    def method_missing(method, *args, &block)
-      case method.to_s
-      when BE_PREDICATE_REGEX
-        BuiltIn::BePredicate.new(method, *args, &block)
-      when HAS_REGEX
-        BuiltIn::Has.new(method, *args, &block)
-      else
-        super
+    if RSpec::Support::RubyFeatures.kw_args_supported?
+      binding.eval(<<-CODE, __FILE__, __LINE__)
+      def method_missing(method, *args, **kwargs, &block)
+        case method.to_s
+        when BE_PREDICATE_REGEX
+          BuiltIn::BePredicate.new(method, *args, **kwargs, &block)
+        when HAS_REGEX
+          BuiltIn::Has.new(method, *args, **kwargs, &block)
+        else
+          super
+        end
+      end
+      CODE
+    else
+      def method_missing(method, *args, &block)
+        case method.to_s
+        when BE_PREDICATE_REGEX
+          BuiltIn::BePredicate.new(method, *args, &block)
+        when HAS_REGEX
+          BuiltIn::Has.new(method, *args, &block)
+        else
+          super
+        end
       end
     end
 
@@ -1003,31 +1018,35 @@ module RSpec
       is_a_matcher?(obj) && obj.respond_to?(:description)
     end
 
-    if RSpec::Support::Ruby.mri? && RUBY_VERSION[0, 3] == '1.9'
-      # @api private
-      # Note that `included` doesn't work for this because it is triggered
-      # _after_ `RSpec::Matchers` is an ancestor of the inclusion host, rather
-      # than _before_, like `append_features`. It's important we check this before
-      # in order to find the cases where it was already previously included.
-      def self.append_features(mod)
-        return super if mod < self # `mod < self` indicates a re-inclusion.
+    class << self
+      private
+
+      if RSpec::Support::Ruby.mri? && RUBY_VERSION[0, 3] == '1.9'
+        # Note that `included` doesn't work for this because it is triggered
+        # _after_ `RSpec::Matchers` is an ancestor of the inclusion host, rather
+        # than _before_, like `append_features`. It's important we check this before
+        # in order to find the cases where it was already previously included.
+        # @api private
+        def append_features(mod)
+          return super if mod < self # `mod < self` indicates a re-inclusion.
 
-        subclasses = ObjectSpace.each_object(Class).select { |c| c < mod && c < self }
-        return super unless subclasses.any?
+          subclasses = ObjectSpace.each_object(Class).select { |c| c < mod && c < self }
+          return super unless subclasses.any?
 
-        subclasses.reject! { |s| subclasses.any? { |s2| s < s2 } } # Filter to the root ancestor.
-        subclasses = subclasses.map { |s| "`#{s}`" }.join(", ")
+          subclasses.reject! { |s| subclasses.any? { |s2| s < s2 } } # Filter to the root ancestor.
+          subclasses = subclasses.map { |s| "`#{s}`" }.join(", ")
 
-        RSpec.warning "`#{self}` has been included in a superclass (`#{mod}`) " \
-                      "after previously being included in subclasses (#{subclasses}), " \
-                      "which can trigger infinite recursion from `super` due to an MRI 1.9 bug " \
-                      "(https://redmine.ruby-lang.org/issues/3351). To work around this, " \
-                      "either upgrade to MRI 2.0+, include a dup of the module (e.g. " \
-                      "`include #{self}.dup`), or find a way to include `#{self}` in `#{mod}` " \
-                      "before it is included in subclasses (#{subclasses}). See " \
-                      "https://github.com/rspec/rspec-expectations/issues/814 for more info"
+          RSpec.warning "`#{self}` has been included in a superclass (`#{mod}`) " \
+                        "after previously being included in subclasses (#{subclasses}), " \
+                        "which can trigger infinite recursion from `super` due to an MRI 1.9 bug " \
+                        "(https://redmine.ruby-lang.org/issues/3351). To work around this, " \
+                        "either upgrade to MRI 2.0+, include a dup of the module (e.g. " \
+                        "`include #{self}.dup`), or find a way to include `#{self}` in `#{mod}` " \
+                        "before it is included in subclasses (#{subclasses}). See " \
+                        "https://github.com/rspec/rspec-expectations/issues/814 for more info"
 
-        super
+          super
+        end
       end
     end
   end

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

@@ -78,11 +78,6 @@ module RSpec
           false
         end
 
-        # @private
-        def supports_value_expectations?
-          true
-        end
-
         # @api private
         def expects_call_stack_jump?
           false

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

@@ -143,8 +143,13 @@ module RSpec
         end
 
         def matches?(actual)
-          @actual = actual
-          @actual.__send__ @operator, @expected
+          perform_match(actual)
+        rescue ArgumentError, NoMethodError
+          false
+        end
+
+        def does_not_match?(actual)
+          !perform_match(actual)
         rescue ArgumentError, NoMethodError
           false
         end
@@ -173,6 +178,13 @@ module RSpec
         def description
           "be #{@operator} #{expected_to_sentence}#{args_to_sentence}"
         end
+
+      private
+
+        def perform_match(actual)
+          @actual = actual
+          @actual.__send__ @operator, @expected
+        end
       end
 
       # @api private
@@ -181,10 +193,21 @@ module RSpec
       class BePredicate < BaseMatcher
         include BeHelpers
 
-        def initialize(*args, &block)
-          @expected = parse_expected(args.shift)
-          @args = args
-          @block = block
+        if RSpec::Support::RubyFeatures.kw_args_supported?
+          binding.eval(<<-CODE, __FILE__, __LINE__)
+          def initialize(*args, **kwargs, &block)
+            @expected = parse_expected(args.shift)
+            @args = args
+            @kwargs = kwargs
+            @block = block
+          end
+          CODE
+        else
+          def initialize(*args, &block)
+            @expected = parse_expected(args.shift)
+            @args = args
+            @block = block
+          end
         end
 
         def matches?(actual, &block)
@@ -236,9 +259,22 @@ module RSpec
           end
         end
 
-        def predicate_matches?
-          method_name = actual.respond_to?(predicate) ? predicate : present_tense_predicate
-          @predicate_matches = actual.__send__(method_name, *@args, &@block)
+        if RSpec::Support::RubyFeatures.kw_args_supported?
+          binding.eval(<<-CODE, __FILE__, __LINE__)
+          def predicate_matches?
+            method_name = actual.respond_to?(predicate) ? predicate : present_tense_predicate
+            if @kwargs.empty?
+              @predicate_matches = actual.__send__(method_name, *@args, &@block)
+            else
+              @predicate_matches = actual.__send__(method_name, *@args, **@kwargs, &@block)
+            end
+          end
+          CODE
+        else
+          def predicate_matches?
+            method_name = actual.respond_to?(predicate) ? predicate : present_tense_predicate
+            @predicate_matches = actual.__send__(method_name, *@args, &@block)
+          end
         end
 
         def predicate