rspec-expectations 3.9.4 → 3.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a7b90c1caeec07d53054eb0536482494c2584e6d7cb0fc9cfd3493ebc6b27a7
-  data.tar.gz: 2eed511b0562ee702eb71bda98058c61d9ddda6c7b0337adde7acd72ddfb81df
+  metadata.gz: e651e80dd869915779a72a9ea43b38d20327f3dbfaf94a4851eff7974d1f3d0a
+  data.tar.gz: e1788055c911b97cbad1b3747fe9b9be005a999e2e97e6c361df4c91fa4fda25
 SHA512:
-  metadata.gz: 7d0ea4666034e2901450f23fe706d1258f0b2c37ac7edd823477e31eae7c6d56e597a0b728cea0fe5f12ab80ee43ac4ed1a5c203ef34f66d180b40713adedf81
-  data.tar.gz: 3b42d8706be59eb0dd511497941c34cebaff7476394f3f1ca80326d26c362bf3b37cca520ae0c6002a8efe167ee3fe7707e41e53072ac000c8c2a89f960fa6c0
+  metadata.gz: ec1b6b68b80fddae764dbf88312817c35c1e76228c29748e2b89d8d9a69d95384aa4fe9daf7b8a650dd307dd32aca13bae590d8960f0989beea67c54f7f6d7d5
+  data.tar.gz: 7a8a129e74ccec6299ab3af1c728cab2754a1cc98911507704c3f52a01c33b321250bfe715deef835b61963e22c66ec878500d10c6fea93d4fda7cc39b101676

data/Changelog.md

@@ -1,3 +1,58 @@
+### Development
+[Full Changelog](http://github.com/rspec/rspec-expectations/compare/v3.11.0...3-11-maintenance)
+
+### 3.11.0 / 2022-02-09
+[Full Changelog](http://github.com/rspec/rspec-expectations/compare/v3.10.2...v3.11.0)
+
+Enhancements:
+
+* Return `true` from `aggregate_failures` when no exception occurs. (Jon Rowe, #1225)
+
+Deprecations:
+
+* Print a deprecation message when using the implicit block expectation syntax.
+  (Phil Pirozhkov, #1139)
+
+### 3.10.2 / 2022-01-14
+[Full Changelog](http://github.com/rspec/rspec-expectations/compare/v3.10.1...v3.10.2)
+
+Bug Fixes:
+
+* Fix support for dynamic matchers for expectation target checks (Phil Pirozhkov, #1294)
+* Fix `expect(array).to include(hash).times`, previously this would fail due to
+  matching the entire array as a single hash, rather than a member of the hash.
+  (Slava Kardakov, #1322)
+* Ensure `raise_error` matches works with the `error_highlight` option from Ruby 3.1.
+  (Peter Goldstein, #1339)
+
+### 3.10.1 / 2020-12-27
+[Full Changelog](http://github.com/rspec/rspec-expectations/compare/v3.10.0...v3.10.1)
+
+Bug Fixes:
+
+* Allow JRuby 9.2.x.x to generate backtraces normally rather than via our
+  backfill workaround. (#1230, Jon Rowe)
+
+### 3.10.0 / 2020-10-30
+[Full Changelog](http://github.com/rspec/rspec-expectations/compare/v3.9.3...v3.10.0)
+
+Enhancements:
+
+* Allow `include` matcher to be chained with `once`, `at_least`, etc. for simple cases.
+  (Marc-André Lafortune, #1168)
+* Add an explicit warning when `nil` is passed to `raise_error`. (Phil Pirozhkov, #1143)
+* Improve `include` matcher's composability. (Phil Pirozhkov, #1155)
+* Mocks expectations can now set a custom failure message.
+  (Benoit Tigeot and Nicolas Zermati, #1156)
+* `aggregate_failures` now shows the backtrace line for each failure. (Fabricio Bedin, #1163)
+* Support multiple combinations of `yield_control` modifiers like `at_least`, `at_most`.
+  (Jon Rowe, #1169)
+* Dynamic `have_<n>` matchers now have output consistent with other dynamic matchers.
+  (Marc-André Lafortune, #1195)
+* New config option `strict_predicate_matchers` allows predicate matcher to be strict
+  (i.e. match for `true` or `false`) instead of the default (match truthy vs `false` or `nil`).
+  (Marc-André Lafortune, #1196)
+
 ### 3.9.4 / 2020-10-29
 [Full Changelog](http://github.com/rspec/rspec-expectations/compare/v3.9.3...v3.9.4)
 
@@ -7,7 +62,6 @@ Bug Fixes:
   were they would act like keywords and be cast to a hash. (Jon Rowe, #1222)
 
 ### 3.9.3 / 2020-10-23
-[Full Changelog](http://github.com/rspec/rspec-expectations/compare/v3.9.2...v3.9.3)
 
 Bug Fixes:
 
@@ -22,6 +76,7 @@ Bug Fixes:
 * 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)
 
@@ -85,7 +140,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, #1110)
+  (Phil Pirozhkov, #1100)
 * 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=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 [![Build Status](https://github.com/rspec/rspec-expectations/workflows/RSpec%20CI/badge.svg)](https://github.com/rspec/rspec-expectations/actions) [![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.

data/lib/rspec/expectations/configuration.rb

@@ -28,6 +28,7 @@ module RSpec
 
       def initialize
         @on_potential_false_positives = :warn
+        @strict_predicate_matchers = false
       end
 
       # Configures the supported syntax.
@@ -185,6 +186,20 @@ module RSpec
         @on_potential_false_positives = behavior
       end
 
+      # Configures RSpec to check predicate matchers to `be(true)` / `be(false)` (strict),
+      # or `be_truthy` / `be_falsey` (not strict).
+      # Historically, the default was `false`, but `true` is recommended.
+      def strict_predicate_matchers=(flag)
+        raise ArgumentError, "Pass `true` or `false`" unless flag == true || flag == false
+        @strict_predicate_matchers = flag
+      end
+
+      attr_reader :strict_predicate_matchers
+
+      def strict_predicate_matchers?
+        @strict_predicate_matchers
+      end
+
       # Indicates what RSpec will do about matcher use which will
       # potentially cause false positives in tests, generally you want to
       # avoid such scenarios so this defaults to `true`.

data/lib/rspec/expectations/expectation_target.rb

@@ -42,7 +42,7 @@ module RSpec
         elsif block
           raise ArgumentError, "You cannot pass both an argument and a block to `expect`."
         else
-          new(value)
+          ValueExpectationTarget.new(value)
         end
       end
 
@@ -57,7 +57,7 @@ module RSpec
         #   expect { perform }.to raise_error
         # @param [Matcher]
         #   matcher
-        # @param [String or Proc] message optional message to display when the expectation fails
+        # @param [String, Proc] message optional message to display when the expectation fails
         # @return [Boolean] true if the expectation succeeds (else raises)
         # @see RSpec::Matchers
         def to(matcher=nil, message=nil, &block)
@@ -70,7 +70,7 @@ module RSpec
         #   expect(value).not_to eq(5)
         # @param [Matcher]
         #   matcher
-        # @param [String or Proc] message optional message to display when the expectation fails
+        # @param [String, Proc] message optional message to display when the expectation fails
         # @return [Boolean] false if the negative expectation succeeds (else raises)
         # @see RSpec::Matchers
         def not_to(matcher=nil, message=nil, &block)
@@ -90,6 +90,44 @@ 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)
+
+        RSpec.deprecate(
+          "expect(value).to #{RSpec::Support::ObjectFormatter.format(matcher)}",
+          :message =>
+            "The implicit block expectation syntax is deprecated, you should pass " \
+            "a block rather than an argument to `expect` to use the provided " \
+            "block expectation matcher or the matcher must implement " \
+            "`supports_value_expectations?`. e.g  `expect { value }.to " \
+            "#{RSpec::Support::ObjectFormatter.format(matcher)}` not " \
+            "`expect(value).to #{RSpec::Support::ObjectFormatter.format(matcher)}`"
+        )
+      end
+
+      def supports_value_expectations?(matcher)
+        !matcher.respond_to?(:supports_value_expectations?) || matcher.supports_value_expectations?
+      end
+    end
+
     # @private
     # Validates the provided matcher to ensure it supports block
     # expectations, in order to avoid user confusion when they
@@ -118,9 +156,7 @@ module RSpec
       end
 
       def supports_block_expectations?(matcher)
-        matcher.supports_block_expectations?
-      rescue NoMethodError
-        false
+        matcher.respond_to?(:supports_block_expectations?) && matcher.supports_block_expectations?
       end
     end
   end

data/lib/rspec/expectations/failure_aggregator.rb

@@ -52,10 +52,10 @@ module RSpec
 
     private
 
-      if RSpec::Support::Ruby.jruby?
-        # On JRuby, `caller` and `raise` produce different backtraces with regards to `.java`
-        # stack frames. It's important that we use `raise` for JRuby to produce a backtrace
-        # that has a continuous common section with the raised `MultipleExpectationsNotMetError`,
+      if RSpec::Support::Ruby.jruby? && RSpec::Support::Ruby.jruby_version < '9.2.0.0'
+        # On JRuby 9.1.x.x and before, `caller` and `raise` produce different backtraces with
+        # regards to `.java` stack frames. It's important that we use `raise` for JRuby to produce
+        # a backtrace that has a continuous common section with the raised `MultipleExpectationsNotMetError`,
         # so that rspec-core's truncation logic can work properly on it to list the backtrace
         # relative to the `aggregate_failures` block.
         def assign_backtrace(failure)
@@ -80,7 +80,7 @@ module RSpec
         all_errors = failures + other_errors
 
         case all_errors.size
-        when 0 then return nil
+        when 0 then return true
         when 1 then RSpec::Support.notify_failure all_errors.first
         else RSpec::Support.notify_failure MultipleExpectationsNotMetError.new(self)
         end
@@ -150,11 +150,29 @@ module RSpec
       def enumerated(exceptions, index_offset)
         exceptions.each_with_index.map do |exception, index|
           index += index_offset
-          formatted_message = yield exception
+          formatted_message = "#{yield exception}\n#{format_backtrace(exception.backtrace).first}"
           "#{index_label index}#{indented formatted_message, index}"
         end
       end
 
+      def exclusion_patterns
+        patterns = %w[/lib\d*/ruby/ bin/ exe/rspec /lib/bundler/ /exe/bundle:]
+        patterns << "org/jruby/" if RSpec::Support::Ruby.jruby?
+        patterns.map! { |s| Regexp.new(s.gsub('/', File::SEPARATOR)) }
+      end
+
+      def format_backtrace(backtrace)
+        backtrace.map { |l| backtrace_line(l) }.compact.tap { |filtered| filtered.concat backtrace if filtered.empty? }
+      end
+
+      def backtrace_line(line)
+        return if [Regexp.union(RSpec::CallerFilter::IGNORE_REGEX, *exclusion_patterns)].any? { |p| line =~ p }
+
+        # It changes the current path that is relative to
+        # system root to be relative to the project root.
+        line.sub(/(\A|\s)#{File.expand_path('.')}(#{File::SEPARATOR}|\s|\Z)/, '\\1.\\2'.freeze).sub(/\A([^:]+:\d+)$/, '\\1'.freeze)
+      end
+
       def enumerated_failures
         enumerated(failures, 0, &:message)
       end

data/lib/rspec/expectations/handler.rb

@@ -44,10 +44,16 @@ module RSpec
 
     # @private
     class PositiveExpectationHandler
-      def self.handle_matcher(actual, initial_matcher, message=nil, &block)
-        ExpectationHelper.with_matcher(self, initial_matcher, message) do |matcher|
+      def self.handle_matcher(actual, initial_matcher, custom_message=nil, &block)
+        ExpectationHelper.with_matcher(self, initial_matcher, custom_message) do |matcher|
           return ::RSpec::Matchers::BuiltIn::PositiveOperatorMatcher.new(actual) unless initial_matcher
-          matcher.matches?(actual, &block) || ExpectationHelper.handle_failure(matcher, message, :failure_message)
+
+          match_result = matcher.matches?(actual, &block)
+          if custom_message && match_result.respond_to?(:error_generator)
+            match_result.error_generator.opts[:message] = custom_message
+          end
+
+          match_result || ExpectationHelper.handle_failure(matcher, custom_message, :failure_message)
         end
       end
 
@@ -66,10 +72,16 @@ module RSpec
 
     # @private
     class NegativeExpectationHandler
-      def self.handle_matcher(actual, initial_matcher, message=nil, &block)
-        ExpectationHelper.with_matcher(self, initial_matcher, message) do |matcher|
+      def self.handle_matcher(actual, initial_matcher, custom_message=nil, &block)
+        ExpectationHelper.with_matcher(self, initial_matcher, custom_message) do |matcher|
           return ::RSpec::Matchers::BuiltIn::NegativeOperatorMatcher.new(actual) unless initial_matcher
-          does_not_match?(matcher, actual, &block) || ExpectationHelper.handle_failure(matcher, message, :failure_message_when_negated)
+
+          negated_match_result = does_not_match?(matcher, actual, &block)
+          if custom_message && negated_match_result.respond_to?(:error_generator)
+            negated_match_result.error_generator.opts[:message] = custom_message
+          end
+
+          negated_match_result || ExpectationHelper.handle_failure(matcher, custom_message, :failure_message_when_negated)
         end
       end
 

data/lib/rspec/expectations/version.rb

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

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

@@ -78,6 +78,11 @@ 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

@@ -186,116 +186,6 @@ module RSpec
           @actual.__send__ @operator, @expected
         end
       end
-
-      # @api private
-      # Provides the implementation of `be_<predicate>`.
-      # Not intended to be instantiated directly.
-      class BePredicate < BaseMatcher
-        include BeHelpers
-
-        def initialize(*args, &block)
-          @expected = parse_expected(args.shift)
-          @args = args
-          @block = block
-        end
-        ruby2_keywords :initialize if respond_to?(:ruby2_keywords, true)
-
-        def matches?(actual, &block)
-          @actual  = actual
-          @block ||= block
-          predicate_accessible? && predicate_matches?
-        end
-
-        def does_not_match?(actual, &block)
-          @actual  = actual
-          @block ||= block
-          predicate_accessible? && !predicate_matches?
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          failure_message_expecting(true)
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          failure_message_expecting(false)
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          "#{prefix_to_sentence}#{expected_to_sentence}#{args_to_sentence}"
-        end
-
-      private
-
-        def predicate_accessible?
-          actual.respond_to?(predicate) || actual.respond_to?(present_tense_predicate)
-        end
-
-        # support 1.8.7, evaluate once at load time for performance
-        if String === methods.first
-          # :nocov:
-          def private_predicate?
-            @actual.private_methods.include? predicate.to_s
-          end
-          # :nocov:
-        else
-          def private_predicate?
-            @actual.private_methods.include? predicate
-          end
-        end
-
-        def predicate_matches?
-          method_name = actual.respond_to?(predicate) ? predicate : present_tense_predicate
-          @predicate_matches = actual.__send__(method_name, *@args, &@block)
-        end
-
-        def predicate
-          :"#{@expected}?"
-        end
-
-        def present_tense_predicate
-          :"#{@expected}s?"
-        end
-
-        def parse_expected(expected)
-          @prefix, expected = prefix_and_expected(expected)
-          expected
-        end
-
-        def prefix_and_expected(symbol)
-          Matchers::BE_PREDICATE_REGEX.match(symbol.to_s).captures.compact
-        end
-
-        def prefix_to_sentence
-          EnglishPhrasing.split_words(@prefix)
-        end
-
-        def failure_message_expecting(value)
-          validity_message ||
-            "expected `#{actual_formatted}.#{predicate}#{args_to_s}` to return #{value}, got #{description_of @predicate_matches}"
-        end
-
-        def validity_message
-          return nil if predicate_accessible?
-
-          msg = "expected #{actual_formatted} to respond to `#{predicate}`".dup
-
-          if private_predicate?
-            msg << " but `#{predicate}` is a private method"
-          elsif predicate == :true?
-            msg << " or perhaps you meant `be true` or `be_truthy`"
-          elsif predicate == :false?
-            msg << " or perhaps you meant `be false` or `be_falsey`"
-          end
-
-          msg
-        end
-      end
     end
   end
 end

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

@@ -77,6 +77,11 @@ module RSpec
           true
         end
 
+        # @private
+        def supports_value_expectations?
+          false
+        end
+
       private
 
         def initialize(receiver=nil, message=nil, &block)
@@ -158,6 +163,11 @@ module RSpec
           true
         end
 
+        # @private
+        def supports_value_expectations?
+          false
+        end
+
       private
 
         def failure_reason
@@ -201,6 +211,11 @@ module RSpec
           true
         end
 
+        # @private
+        def supports_value_expectations?
+          false
+        end
+
       private
 
         def perform_change(event_proc)
@@ -337,6 +352,8 @@ module RSpec
       class ChangeDetails
         attr_reader :actual_after
 
+        UNDEFINED = Module.new.freeze
+
         def initialize(matcher_name, receiver=nil, message=nil, &block)
           if receiver && !message
             raise(
@@ -351,6 +368,11 @@ module RSpec
           @receiver = receiver
           @message = message
           @value_proc = block
+          # TODO: temporary measure to mute warning of access to an initialized
+          # instance variable when a deprecated implicit block expectation
+          # syntax is used. This may be removed once `fail` is used, and the
+          # matcher never issues this warning.
+          @actual_after = UNDEFINED
         end
 
         def value_representation

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

@@ -26,11 +26,19 @@ module RSpec
           "#{matcher_1.description} #{conjunction} #{matcher_2.description}"
         end
 
+        # @api private
         def supports_block_expectations?
           matcher_supports_block_expectations?(matcher_1) &&
           matcher_supports_block_expectations?(matcher_2)
         end
 
+        # @api private
+        def supports_value_expectations?
+          matcher_supports_value_expectations?(matcher_1) &&
+          matcher_supports_value_expectations?(matcher_2)
+        end
+
+        # @api private
         def expects_call_stack_jump?
           NestedEvaluator.matcher_expects_call_stack_jump?(matcher_1) ||
           NestedEvaluator.matcher_expects_call_stack_jump?(matcher_2)
@@ -102,6 +110,12 @@ module RSpec
           false
         end
 
+        def matcher_supports_value_expectations?(matcher)
+          matcher.supports_value_expectations?
+        rescue NoMethodError
+          true
+        end
+
         def matcher_is_diffable?(matcher)
           matcher.diffable?
         rescue NoMethodError