rspec-expectations 2.11.3 → 3.11.0

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

@@ -1,74 +1,78 @@
-require 'rspec/matchers/dsl'
-
 module RSpec
   module Matchers
     module BuiltIn
-      class BeTrue < BaseMatcher
-        def match(_, actual)
-          !!actual
+      # @api private
+      # Provides the implementation for `be_truthy`.
+      # Not intended to be instantiated directly.
+      class BeTruthy < BaseMatcher
+        # @api private
+        # @return [String]
+        def failure_message
+          "expected: truthy value\n     got: #{actual_formatted}"
         end
 
-        def failure_message_for_should
-          "expected: true value\n     got: #{actual.inspect}"
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          "expected: falsey value\n     got: #{actual_formatted}"
         end
 
-        def failure_message_for_should_not
-          "expected: non-true value\n     got: #{actual.inspect}"
-        end
-      end
+      private
 
-      class BeFalse < BaseMatcher
         def match(_, actual)
-          !actual
+          !!actual
         end
+      end
 
-        def failure_message_for_should
-          "expected: false value\n     got: #{actual.inspect}"
+      # @api private
+      # Provides the implementation for `be_falsey`.
+      # Not intended to be instantiated directly.
+      class BeFalsey < BaseMatcher
+        # @api private
+        # @return [String]
+        def failure_message
+          "expected: falsey value\n     got: #{actual_formatted}"
         end
 
-        def failure_message_for_should_not
-          "expected: non-false value\n     got: #{actual.inspect}"
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          "expected: truthy value\n     got: #{actual_formatted}"
         end
-      end
 
-      class BeNil < BaseMatcher
+      private
+
         def match(_, actual)
-          actual.nil?
+          !actual
         end
+      end
 
-        def failure_message_for_should
-          "expected: nil\n     got: #{actual.inspect}"
+      # @api private
+      # Provides the implementation for `be_nil`.
+      # Not intended to be instantiated directly.
+      class BeNil < BaseMatcher
+        # @api private
+        # @return [String]
+        def failure_message
+          "expected: nil\n     got: #{actual_formatted}"
         end
 
-        def failure_message_for_should_not
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
           "expected: not nil\n     got: nil"
         end
-      end
 
-      class Be < BaseMatcher
-        def initialize(*args, &block)
-          @args = args
-        end
+      private
 
         def match(_, actual)
-          !!actual
-        end
-
-        def failure_message_for_should
-          "expected #{@actual.inspect} to evaluate to true"
-        end
-
-        def failure_message_for_should_not
-          "expected #{@actual.inspect} to evaluate to false"
-        end
-
-        [:==, :<, :<=, :>=, :>, :===].each do |operator|
-          define_method operator do |operand|
-            BeComparedTo.new(operand, operator)
-          end
+          actual.nil?
         end
+      end
 
-        private
+      # @private
+      module BeHelpers
+      private
 
         def args_to_s
           @args.empty? ? "" : parenthesize(inspected_args.join(', '))
@@ -79,105 +83,107 @@ module RSpec
         end
 
         def inspected_args
-          @args.collect{|a| a.inspect}
+          @args.map { |a| RSpec::Support::ObjectFormatter.format(a) }
         end
 
         def expected_to_sentence
-          split_words(@expected)
+          EnglishPhrasing.split_words(@expected)
         end
 
         def args_to_sentence
-          to_sentence(@args)
+          EnglishPhrasing.list(@args)
         end
       end
 
-      class BeComparedTo < Be
-        def initialize(operand, operator)
-          @expected, @operator = operand, operator
-            @args = []
-        end
-
-        def matches?(actual)
-          @actual = actual
-          @actual.send @operator, @expected
-        end
+      # @api private
+      # Provides the implementation for `be`.
+      # Not intended to be instantiated directly.
+      class Be < BaseMatcher
+        include BeHelpers
 
-        def failure_message_for_should
-          "expected: #{@operator} #{@expected.inspect}\n     got: #{@operator.to_s.gsub(/./, ' ')} #{@actual.inspect}"
+        def initialize(*args)
+          @args = args
         end
 
-        def failure_message_for_should_not
-          message = <<-MESSAGE
-'should_not be #{@operator} #{@expected}' not only FAILED,
-it is a bit confusing.
-          MESSAGE
-
-          raise message << ([:===,:==].include?(@operator) ?
-                            "It might be more clearly expressed without the \"be\"?" :
-                            "It might be more clearly expressed in the positive?")
+        # @api private
+        # @return [String]
+        def failure_message
+          "expected #{actual_formatted} to evaluate to true"
         end
 
-        def description
-          "be #{@operator} #{expected_to_sentence}#{args_to_sentence}"
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          "expected #{actual_formatted} to evaluate to false"
         end
-      end
 
-      class BePredicate < Be
-        def initialize(*args, &block)
-          @expected = parse_expected(args.shift)
-          @args = args
-          @block = block
+        [:==, :<, :<=, :>=, :>, :===, :=~].each do |operator|
+          define_method operator do |operand|
+            BeComparedTo.new(operand, operator)
+          end
         end
 
-        def matches?(actual)
-          @actual = actual
-          begin
-            return @result = actual.__send__(predicate, *@args, &@block)
-          rescue NameError => predicate_missing_error
-            "this needs to be here or rcov will not count this branch even though it's executed in a code example"
-          end
+      private
 
-          begin
-            return @result = actual.__send__(present_tense_predicate, *@args, &@block)
-          rescue NameError
-            raise predicate_missing_error
-          end
+        def match(_, actual)
+          !!actual
         end
+      end
 
-        def failure_message_for_should
-          "expected #{predicate}#{args_to_s} to return true, got #{@result.inspect}"
-        end
+      # @api private
+      # Provides the implementation of `be <operator> value`.
+      # Not intended to be instantiated directly.
+      class BeComparedTo < BaseMatcher
+        include BeHelpers
 
-        def failure_message_for_should_not
-          "expected #{predicate}#{args_to_s} to return false, got #{@result.inspect}"
+        def initialize(operand, operator)
+          @expected = operand
+          @operator = operator
+          @args = []
         end
 
-        def description
-          "#{prefix_to_sentence}#{expected_to_sentence}#{args_to_sentence}"
+        def matches?(actual)
+          perform_match(actual)
+        rescue ArgumentError, NoMethodError
+          false
         end
 
-        private
-
-        def predicate
-          "#{@expected}?".to_sym
+        def does_not_match?(actual)
+          !perform_match(actual)
+        rescue ArgumentError, NoMethodError
+          false
         end
 
-        def present_tense_predicate
-          "#{@expected}s?".to_sym
+        # @api private
+        # @return [String]
+        def failure_message
+          "expected: #{@operator} #{expected_formatted}\n" \
+          "     got: #{@operator.to_s.gsub(/./, ' ')} #{actual_formatted}"
         end
 
-        def parse_expected(expected)
-          @prefix, expected = prefix_and_expected(expected)
-          expected
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          message = "`expect(#{actual_formatted}).not_to " \
+                    "be #{@operator} #{expected_formatted}`"
+          if [:<, :>, :<=, :>=].include?(@operator)
+            message + " not only FAILED, it is a bit confusing."
+          else
+            message
+          end
         end
 
-        def prefix_and_expected(symbol)
-          symbol.to_s =~ /^(be_(an?_)?)(.*)/
-          return $1, $3
+        # @api private
+        # @return [String]
+        def description
+          "be #{@operator} #{expected_to_sentence}#{args_to_sentence}"
         end
 
-        def prefix_to_sentence
-          split_words(@prefix)
+      private
+
+        def perform_match(actual)
+          @actual = actual
+          @actual.__send__ @operator, @expected
         end
       end
     end

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

@@ -0,0 +1,77 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Provides the implementation for `be_between`.
+      # Not intended to be instantiated directly.
+      class BeBetween < BaseMatcher
+        def initialize(min, max)
+          @min, @max = min, max
+          inclusive
+        end
+
+        # @api public
+        # Makes the between comparison inclusive.
+        #
+        # @example
+        #   expect(3).to be_between(2, 3).inclusive
+        #
+        # @note The matcher is inclusive by default; this simply provides
+        #       a way to be more explicit about it.
+        def inclusive
+          @less_than_operator = :<=
+          @greater_than_operator = :>=
+          @mode = :inclusive
+          self
+        end
+
+        # @api public
+        # Makes the between comparison exclusive.
+        #
+        # @example
+        #   expect(3).to be_between(2, 4).exclusive
+        def exclusive
+          @less_than_operator = :<
+          @greater_than_operator = :>
+          @mode = :exclusive
+          self
+        end
+
+        # @api private
+        # @return [Boolean]
+        def matches?(actual)
+          @actual = actual
+          comparable? && compare
+        rescue ArgumentError
+          false
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message
+          "#{super}#{not_comparable_clause}"
+        end
+
+        # @api private
+        # @return [String]
+        def description
+          "be between #{description_of @min} and #{description_of @max} (#{@mode})"
+        end
+
+      private
+
+        def comparable?
+          @actual.respond_to?(@less_than_operator) && @actual.respond_to?(@greater_than_operator)
+        end
+
+        def not_comparable_clause
+          ", but it does not respond to `#{@less_than_operator}` and `#{@greater_than_operator}`" unless comparable?
+        end
+
+        def compare
+          @actual.__send__(@greater_than_operator, @min) && @actual.__send__(@less_than_operator, @max)
+        end
+      end
+    end
+  end
+end

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

@@ -1,9 +1,24 @@
 module RSpec
   module Matchers
     module BuiltIn
+      # @api private
+      # Provides the implementation for `be_an_instance_of`.
+      # Not intended to be instantiated directly.
       class BeAnInstanceOf < BaseMatcher
+        # @api private
+        # @return [String]
+        def description
+          "be an instance of #{expected}"
+        end
+
+      private
+
         def match(expected, actual)
-          actual.instance_of? expected
+          actual.instance_of?(expected)
+        rescue NoMethodError
+          raise ::ArgumentError, "The #{matcher_name} matcher requires that " \
+                                 "the actual object responds to #instance_of? method " \
+                                 "but a `NoMethodError` was encountered instead."
         end
       end
     end

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

@@ -1,9 +1,18 @@
 module RSpec
   module Matchers
     module BuiltIn
+      # @api private
+      # Provides the implementation for `be_a_kind_of`.
+      # Not intended to be instantiated directly.
       class BeAKindOf < BaseMatcher
+      private
+
         def match(expected, actual)
-          actual.kind_of? expected
+          actual.kind_of?(expected)
+        rescue NoMethodError
+          raise ::ArgumentError, "The #{matcher_name} matcher requires that " \
+                                 "the actual object responds to #kind_of? method " \
+                                 "but a `NoMethodError` was encountered instead."
         end
       end
     end

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

@@ -1,45 +1,71 @@
 module RSpec
   module Matchers
     module BuiltIn
-      class BeWithin
+      # @api private
+      # Provides the implementation for `be_within`.
+      # Not intended to be instantiated directly.
+      class BeWithin < BaseMatcher
         def initialize(delta)
           @delta = delta
         end
 
-        def matches?(actual)
-          @actual = actual
-          raise needs_expected     unless defined? @expected 
-          raise needs_subtractable unless @actual.respond_to? :-
-          (@actual - @expected).abs <= @delta
+        # @api public
+        # Sets the expected value.
+        def of(expected)
+          @expected  = expected
+          @tolerance = @delta
+          @unit      = ''
+          self
         end
-        alias == matches?
 
-        def of(expected)
-          @expected = expected
+        # @api public
+        # Sets the expected value, and makes the matcher do
+        # a percent comparison.
+        def percent_of(expected)
+          @expected  = expected
+          @tolerance = @expected.abs * @delta / 100.0
+          @unit      = '%'
           self
         end
 
-        def failure_message_for_should
-          "expected #{@actual} to #{description}"
+        # @private
+        def matches?(actual)
+          @actual = actual
+          raise needs_expected unless defined? @expected
+          numeric? && (@actual - @expected).abs <= @tolerance
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message
+          "expected #{actual_formatted} to #{description}#{not_numeric_clause}"
         end
 
-        def failure_message_for_should_not
-          "expected #{@actual} not to #{description}"
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          "expected #{actual_formatted} not to #{description}"
         end
 
+        # @api private
+        # @return [String]
         def description
-          "be within #{@delta} of #{@expected}"
+          "be within #{@delta}#{@unit} of #{expected_formatted}"
         end
 
-        private
+      private
 
-        def needs_subtractable
-          ArgumentError.new "The actual value (#{@actual.inspect}) must respond to `-`"
+        def numeric?
+          @actual.respond_to?(:-)
         end
 
         def needs_expected
           ArgumentError.new "You must set an expected value using #of: be_within(#{@delta}).of(expected_value)"
         end
+
+        def not_numeric_clause
+          ", but it could not be treated as a numeric value" unless numeric?
+        end
       end
     end
   end