rspec-expectations 3.9.1 → 3.10.1

data/lib/rspec/matchers/built_in.rb

@@ -16,8 +16,9 @@ module RSpec
       autoload :Be,                      'rspec/matchers/built_in/be'
       autoload :BeComparedTo,            'rspec/matchers/built_in/be'
       autoload :BeFalsey,                'rspec/matchers/built_in/be'
+      autoload :BeHelpers,               'rspec/matchers/built_in/be'
       autoload :BeNil,                   'rspec/matchers/built_in/be'
-      autoload :BePredicate,             'rspec/matchers/built_in/be'
+      autoload :BePredicate,             'rspec/matchers/built_in/has'
       autoload :BeTruthy,                'rspec/matchers/built_in/be'
       autoload :BeWithin,                'rspec/matchers/built_in/be_within'
       autoload :Change,                  'rspec/matchers/built_in/change'

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,114 +178,12 @@ module RSpec
         def description
           "be #{@operator} #{expected_to_sentence}#{args_to_sentence}"
         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
-
-        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
+        def perform_match(actual)
+          @actual = actual
+          @actual.__send__ @operator, @expected
         end
       end
     end

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

@@ -23,7 +23,7 @@ module RSpec
         # a percent comparison.
         def percent_of(expected)
           @expected  = expected
-          @tolerance = @delta * @expected.abs / 100.0
+          @tolerance = @expected.abs * @delta / 100.0
           @unit      = '%'
           self
         end
@@ -50,7 +50,7 @@ module RSpec
         # @api private
         # @return [String]
         def description
-          "be within #{@delta}#{@unit} of #{@expected}"
+          "be within #{@delta}#{@unit} of #{expected_formatted}"
         end
 
       private

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

@@ -0,0 +1,169 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Asbtract class to implement `once`, `at_least` and other
+      # count constraints.
+      module CountExpectation
+        # @api public
+        # Specifies that the method is expected to match once.
+        def once
+          exactly(1)
+        end
+
+        # @api public
+        # Specifies that the method is expected to match twice.
+        def twice
+          exactly(2)
+        end
+
+        # @api public
+        # Specifies that the method is expected to match thrice.
+        def thrice
+          exactly(3)
+        end
+
+        # @api public
+        # Specifies that the method is expected to match the given number of times.
+        def exactly(number)
+          set_expected_count(:==, number)
+          self
+        end
+
+        # @api public
+        # Specifies the maximum number of times the method is expected to match
+        def at_most(number)
+          set_expected_count(:<=, number)
+          self
+        end
+
+        # @api public
+        # Specifies the minimum number of times the method is expected to match
+        def at_least(number)
+          set_expected_count(:>=, number)
+          self
+        end
+
+        # @api public
+        # No-op. Provides syntactic sugar.
+        def times
+          self
+        end
+
+      protected
+        # @api private
+        attr_reader :count_expectation_type, :expected_count
+
+      private
+
+        if RUBY_VERSION.to_f > 1.8
+          def cover?(count, number)
+            count.cover?(number)
+          end
+        else
+          def cover?(count, number)
+            number >= count.first && number <= count.last
+          end
+        end
+
+        def expected_count_matches?(actual_count)
+          @actual_count = actual_count
+          return @actual_count > 0 unless count_expectation_type
+          return cover?(expected_count, actual_count) if count_expectation_type == :<=>
+
+          @actual_count.__send__(count_expectation_type, expected_count)
+        end
+
+        def has_expected_count?
+          !!count_expectation_type
+        end
+
+        def set_expected_count(relativity, n)
+          raise_unsupported_count_expectation if unsupported_count_expectation?(relativity)
+
+          count = count_constraint_to_number(n)
+
+          if count_expectation_type == :<= && relativity == :>=
+            raise_impossible_count_expectation(count) if count > expected_count
+            @count_expectation_type = :<=>
+            @expected_count = count..expected_count
+          elsif count_expectation_type == :>= && relativity == :<=
+            raise_impossible_count_expectation(count) if count < expected_count
+            @count_expectation_type = :<=>
+            @expected_count = expected_count..count
+          else
+            @count_expectation_type = relativity
+            @expected_count = count
+          end
+        end
+
+        def raise_impossible_count_expectation(count)
+          text =
+            case count_expectation_type
+            when :<= then "at_least(#{count}).at_most(#{expected_count})"
+            when :>= then "at_least(#{expected_count}).at_most(#{count})"
+            end
+          raise ArgumentError, "The constraint #{text} is not possible"
+        end
+
+        def raise_unsupported_count_expectation
+          text =
+            case count_expectation_type
+            when :<= then "at_least"
+            when :>= then "at_most"
+            when :<=> then "at_least/at_most combination"
+            else "count"
+            end
+          raise ArgumentError, "Multiple #{text} constraints are not supported"
+        end
+
+        def count_constraint_to_number(n)
+          case n
+          when Numeric then n
+          when :once then 1
+          when :twice then 2
+          when :thrice then 3
+          else
+            raise ArgumentError, "Expected a number, :once, :twice or :thrice," \
+              " but got #{n}"
+          end
+        end
+
+        def unsupported_count_expectation?(relativity)
+          return true if count_expectation_type == :==
+          return true if count_expectation_type == :<=>
+          (count_expectation_type == :<= && relativity == :<=) ||
+            (count_expectation_type == :>= && relativity == :>=)
+        end
+
+        def count_expectation_description
+          "#{human_readable_expectation_type}#{human_readable_count(expected_count)}"
+        end
+
+        def count_failure_reason(action)
+          "#{count_expectation_description}" \
+          " but #{action}#{human_readable_count(@actual_count)}"
+        end
+
+        def human_readable_expectation_type
+          case count_expectation_type
+          when :<= then ' at most'
+          when :>= then ' at least'
+          when :<=> then ' between'
+          else ''
+          end
+        end
+
+        def human_readable_count(count)
+          case count
+          when Range then " #{count.first} and #{count.last} times"
+          when nil then ''
+          when 1 then ' once'
+          when 2 then ' twice'
+          else " #{count} times"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,12 +2,15 @@ module RSpec
   module Matchers
     module BuiltIn
       # @api private
-      # Provides the implementation for `has_<predicate>`.
-      # Not intended to be instantiated directly.
-      class Has < BaseMatcher
+      # Provides the implementation for dynamic predicate matchers.
+      # Not intended to be inherited directly.
+      class DynamicPredicate < BaseMatcher
+        include BeHelpers
+
         def initialize(method_name, *args, &block)
           @method_name, @args, @block = method_name, args, block
         end
+        ruby2_keywords :initialize if respond_to?(:ruby2_keywords, true)
 
         # @private
         def matches?(actual, &block)
@@ -20,31 +23,31 @@ module RSpec
         def does_not_match?(actual, &block)
           @actual = actual
           @block ||= block
-          predicate_accessible? && !predicate_matches?
+          predicate_accessible? && predicate_matches?(false)
         end
 
         # @api private
         # @return [String]
         def failure_message
-          validity_message || "expected ##{predicate}#{failure_message_args_description} to return true, got false"
+          failure_message_expecting(true)
         end
 
         # @api private
         # @return [String]
         def failure_message_when_negated
-          validity_message || "expected ##{predicate}#{failure_message_args_description} to return false, got true"
+          failure_message_expecting(false)
         end
 
         # @api private
         # @return [String]
         def description
-          [method_description, args_description].compact.join(' ')
+          "#{method_description}#{args_to_sentence}"
         end
 
       private
 
         def predicate_accessible?
-          !private_predicate? && predicate_exists?
+          @actual.respond_to? predicate
         end
 
         # support 1.8.7, evaluate once at load time for performance
@@ -60,44 +63,105 @@ module RSpec
           end
         end
 
-        def predicate_exists?
-          @actual.respond_to? predicate
+        def predicate_result
+          @predicate_result = actual.__send__(predicate_method_name, *@args, &@block)
         end
 
-        def predicate_matches?
-          @actual.__send__(predicate, *@args, &@block)
+        def predicate_method_name
+          predicate
         end
 
-        def predicate
+        def predicate_matches?(value=true)
+          if RSpec::Expectations.configuration.strict_predicate_matchers?
+            value == predicate_result
+          else
+            value == !!predicate_result
+          end
+        end
+
+        def root
           # On 1.9, there appears to be a bug where String#match can return `false`
           # rather than the match data object. Changing to Regex#match appears to
           # work around this bug. For an example of this bug, see:
           # https://travis-ci.org/rspec/rspec-expectations/jobs/27549635
-          @predicate ||= :"has_#{Matchers::HAS_REGEX.match(@method_name.to_s).captures.first}?"
+          self.class::REGEX.match(@method_name.to_s).captures.first
         end
 
         def method_description
-          @method_name.to_s.tr('_', ' ')
+          EnglishPhrasing.split_words(@method_name)
         end
 
-        def args_description
-          return nil if @args.empty?
-          @args.map { |arg| RSpec::Support::ObjectFormatter.format(arg) }.join(', ')
+        def failure_message_expecting(value)
+          validity_message ||
+            "expected `#{actual_formatted}.#{predicate}#{args_to_s}` to #{expectation_of value}, got #{description_of @predicate_result}"
         end
 
-        def failure_message_args_description
-          desc = args_description
-          "(#{desc})" if desc
+        def expectation_of(value)
+          if RSpec::Expectations.configuration.strict_predicate_matchers?
+            "return #{value}"
+          elsif value
+            "be truthy"
+          else
+            "be falsey"
+          end
         end
 
         def validity_message
+          return nil if predicate_accessible?
+
+          "expected #{actual_formatted} to respond to `#{predicate}`#{failure_to_respond_explanation}"
+        end
+
+        def failure_to_respond_explanation
           if private_predicate?
-            "expected #{@actual} to respond to `#{predicate}` but `#{predicate}` is a private method"
-          elsif !predicate_exists?
-            "expected #{@actual} to respond to `#{predicate}`"
+            " but `#{predicate}` is a private method"
           end
         end
       end
+
+      # @api private
+      # Provides the implementation for `has_<predicate>`.
+      # Not intended to be instantiated directly.
+      class Has < DynamicPredicate
+        # :nodoc:
+        REGEX = Matchers::HAS_REGEX
+      private
+        def predicate
+          @predicate ||= :"has_#{root}?"
+        end
+      end
+
+      # @api private
+      # Provides the implementation of `be_<predicate>`.
+      # Not intended to be instantiated directly.
+      class BePredicate < DynamicPredicate
+        # :nodoc:
+        REGEX = Matchers::BE_PREDICATE_REGEX
+      private
+        def predicate
+          @predicate ||= :"#{root}?"
+        end
+
+        def predicate_method_name
+          actual.respond_to?(predicate) ? predicate : present_tense_predicate
+        end
+
+        def failure_to_respond_explanation
+          super || if predicate == :true?
+                     " or perhaps you meant `be true` or `be_truthy`"
+                   elsif predicate == :false?
+                     " or perhaps you meant `be false` or `be_falsey`"
+                   end
+        end
+
+        def predicate_accessible?
+          super || actual.respond_to?(present_tense_predicate)
+        end
+
+        def present_tense_predicate
+          :"#{root}s?"
+        end
+      end
     end
   end
 end