rspec-expectations 2.14.5 → 2.99.0

data/lib/rspec/expectations/deprecation.rb

@@ -1,27 +1,23 @@
+require 'rspec/expectations/caller_filter' unless defined?(::RSpec::CallerFilter)
+
 module RSpec
   module Expectations
     module Deprecation
-     RSPEC_LIBS = %w[
-        core
-        mocks
-        expectations
-        matchers
-        rails
-      ]
-
-      ADDITIONAL_TOP_LEVEL_FILES = %w[ autorun ]
-
-      LIB_REGEX = %r{/lib/rspec/(#{(RSPEC_LIBS + ADDITIONAL_TOP_LEVEL_FILES).join('|')})(\.rb|/)}
-
       # @private
       #
       # Used internally to print deprecation warnings
       def deprecate(deprecated, options={})
-        call_site = caller.find { |line| line !~ LIB_REGEX }
-
         message = "DEPRECATION: #{deprecated} is deprecated."
         message << " Use #{options[:replacement]} instead." if options[:replacement]
-        message << " Called from #{call_site}."
+        message << " Called from #{CallerFilter.first_non_rspec_line}."
+        warn message
+      end
+
+      # @private
+      #
+      # Used internally to print deprecation warnings
+      def warn_deprecation(warning)
+        message = "\nDEPRECATION: #{warning}\n"
         warn message
       end
     end

data/lib/rspec/expectations/expectation_target.rb

@@ -1,23 +1,48 @@
 module RSpec
   module Expectations
     # Wraps the target of an expectation.
+    #
     # @example
-    #   expect(something) # => ExpectationTarget wrapping something
+    #   expect(something)       # => ExpectationTarget wrapping something
+    #   expect { do_something } # => ExpectationTarget wrapping the block
     #
     #   # used with `to`
     #   expect(actual).to eq(3)
     #
     #   # with `not_to`
     #   expect(actual).not_to eq(3)
+    #
+    # @note `ExpectationTarget` is not intended to be instantiated
+    #   directly by users. Use `expect` instead.
     class ExpectationTarget
       class << self
         attr_accessor :deprecated_should_enabled
         alias deprecated_should_enabled? deprecated_should_enabled
       end
 
+      # @private
+      # Used as a sentinel value to be able to tell when the user
+      # did not pass an argument. We can't use `nil` for that because
+      # `nil` is a valid value to pass.
+      UndefinedValue = Module.new
+
       # @api private
-      def initialize(target)
-        @target = target
+      def initialize(value)
+        @target = value
+      end
+
+      # @private
+      def self.for(value, block)
+        if UndefinedValue.equal?(value)
+          unless block
+            raise ArgumentError, "You must pass either an argument or a block to `expect`."
+          end
+          BlockExpectationTarget.new(block)
+        elsif block
+          raise ArgumentError, "You cannot pass both an argument and a block to `expect`."
+        else
+          new(value)
+        end
       end
 
       # Runs the given expectation, passing if `matcher` returns true.
@@ -30,7 +55,7 @@ module RSpec
       # @return [Boolean] true if the expectation succeeds (else raises)
       # @see RSpec::Matchers
       def to(matcher=nil, message=nil, &block)
-        prevent_operator_matchers(:to, matcher)
+        prevent_operator_matchers(:to) unless matcher
         RSpec::Expectations::PositiveExpectationHandler.handle_matcher(@target, matcher, message, &block)
       end
 
@@ -43,7 +68,7 @@ module RSpec
       # @return [Boolean] false if the negative expectation succeeds (else raises)
       # @see RSpec::Matchers
       def not_to(matcher=nil, message=nil, &block)
-        prevent_operator_matchers(:not_to, matcher)
+        prevent_operator_matchers(:not_to) unless matcher
         RSpec::Expectations::NegativeExpectationHandler.handle_matcher(@target, matcher, message, &block)
       end
       alias to_not not_to
@@ -75,13 +100,55 @@ module RSpec
 
     private
 
-      def prevent_operator_matchers(verb, matcher)
-        return if matcher
-
+      def prevent_operator_matchers(verb)
         raise ArgumentError, "The expect syntax does not support operator matchers, " +
                              "so you must pass a matcher to `##{verb}`."
       end
     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 BlockExpectationTarget < ExpectationTarget
+      def to(matcher, message=nil, &block)
+        enforce_block_expectation(matcher)
+        super
+      end
+
+      def not_to(matcher, message=nil, &block)
+        enforce_block_expectation(matcher)
+        super
+      end
+      alias to_not not_to
+
+    private
+
+      def enforce_block_expectation(matcher)
+        return if supports_block_expectations?(matcher)
+
+        RSpec.deprecate("Using a matcher in a block expectation expression " +
+                        "(e.g. `expect { }.to matcher`) that does not implement " +
+                        "`supports_block_expectations?`",
+                        :replacement => "a value expectation expression " +
+                        "(e.g. `expect(value).to matcher`) or implement " +
+                        "`supports_block_expectations?` on the provided matcher " +
+                        "(#{description_of matcher})")
+      end
+
+      def supports_block_expectations?(matcher)
+        matcher.supports_block_expectations?
+      rescue NoMethodError
+        false
+      end
+
+      def description_of(matcher)
+        matcher.description
+      rescue NoMethodError
+        matcher.inspect
+      end
+    end
   end
 end
 

data/lib/rspec/expectations/handler.rb

@@ -31,7 +31,11 @@ module RSpec
                     matcher.failure_message
 
         if matcher.respond_to?(:diffable?) && matcher.diffable?
-          ::RSpec::Expectations.fail_with message, matcher.expected, matcher.actual
+          if RSpec::Matchers::DSL::Matcher === matcher
+            ::RSpec::Expectations.fail_with message, matcher.expected_as_array, matcher.actual
+          else
+            ::RSpec::Expectations.fail_with message, matcher.expected, matcher.actual
+          end
         else
           ::RSpec::Expectations.fail_with message
         end

data/lib/rspec/expectations/syntax.rb

@@ -79,11 +79,9 @@ module RSpec
       def enable_expect(syntax_host = ::RSpec::Matchers)
         return if expect_enabled?(syntax_host)
 
-        syntax_host.module_eval do
-          def expect(*target, &target_block)
-            target << target_block if block_given?
-            raise ArgumentError.new("You must pass an argument or a block to #expect but not both.") unless target.size == 1
-            ::RSpec::Expectations::ExpectationTarget.new(target.first)
+        syntax_host.module_exec do
+          def expect(value=::RSpec::Expectations::ExpectationTarget::UndefinedValue, &block)
+            ::RSpec::Expectations::ExpectationTarget.for(value, block)
           end
         end
 

data/lib/rspec/expectations/version.rb

@@ -2,8 +2,7 @@ module RSpec
   module Expectations
     # @private
     module Version
-      STRING = '2.14.5'
+      STRING = '2.99.0'
     end
   end
 end
-

data/lib/rspec/expectations.rb

@@ -1,7 +1,7 @@
 require 'rspec/expectations/extensions'
 require 'rspec/matchers'
 require 'rspec/expectations/expectation_target'
-require 'rspec/matchers/configuration'
+require 'rspec/expectations/configuration'
 require 'rspec/expectations/fail_with'
 require 'rspec/expectations/errors'
 require 'rspec/expectations/deprecation'

data/lib/rspec/matchers/be_close.rb

@@ -2,7 +2,10 @@ module RSpec
   module Matchers
     # @deprecated use +be_within+ instead.
     def be_close(expected, delta)
-      RSpec.deprecate("be_close(#{expected}, #{delta})", :replacement => "be_within(#{delta}).of(#{expected})")
+      RSpec.deprecate("be_close(#{expected}, #{delta})",
+        :replacement => "be_within(#{delta}).of(#{expected})",
+        :type        => 'the be_close matcher'
+      )
       be_within(delta).of(expected)
     end
   end

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

@@ -13,6 +13,7 @@ module RSpec
       # class. If/when this changes, we will announce it and remove this warning.
       class BaseMatcher
         include RSpec::Matchers::Pretty
+        include RSpec::Matchers::MatchAliases
 
         UNDEFINED = Object.new.freeze
 
@@ -39,12 +40,12 @@ module RSpec
 
         def failure_message_for_should
           assert_ivars :@actual
-          "expected #{@actual.inspect} to #{name_to_sentence}#{expected_to_sentence}"
+          "expected #{@actual.inspect} to #{name_to_sentence}#{to_sentence expected}"
         end
 
         def failure_message_for_should_not
           assert_ivars :@actual
-          "expected #{@actual.inspect} not to #{name_to_sentence}#{expected_to_sentence}"
+          "expected #{@actual.inspect} not to #{name_to_sentence}#{to_sentence expected}"
         end
 
         def description
@@ -55,11 +56,15 @@ module RSpec
           false
         end
 
-        def ==(other)
-          matches?(other)
+        # @api private
+        # Most matchers are value matchers (i.e. meant to work with `expect(value)`)
+        # rather than block matchers (i.e. meant to work with `expect { }`), so
+        # this defaults to false. Block matchers must override this to return true.
+        def supports_block_expectations?
+          false
         end
 
-        private
+      private
 
         def assert_ivars *ivars
           raise "#{self.class.name} needs to supply #{to_sentence ivars}" unless ivars.all? { |v| instance_variables.map(&:intern).include? v }

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

@@ -3,31 +3,31 @@ require 'rspec/matchers/dsl'
 module RSpec
   module Matchers
     module BuiltIn
-      class BeTrue < BaseMatcher
+      class BeTruthy < BaseMatcher
         def match(_, actual)
           !!actual
         end
 
         def failure_message_for_should
-          "expected: true value\n     got: #{actual.inspect}"
+          "expected: truthy value\n     got: #{actual.inspect}"
         end
 
         def failure_message_for_should_not
-          "expected: non-true value\n     got: #{actual.inspect}"
+          "expected: falsey value\n     got: #{actual.inspect}"
         end
       end
 
-      class BeFalse < BaseMatcher
+      class BeFalsey < BaseMatcher
         def match(_, actual)
           !actual
         end
 
         def failure_message_for_should
-          "expected: false value\n     got: #{actual.inspect}"
+          "expected: falsey value\n     got: #{actual.inspect}"
         end
 
         def failure_message_for_should_not
-          "expected: non-false value\n     got: #{actual.inspect}"
+          "expected: truthy value\n     got: #{actual.inspect}"
         end
       end
 
@@ -141,14 +141,25 @@ it is a bit confusing.
 
         def matches?(actual)
           @actual = actual
+
+          if is_private_on?( @actual )
+            RSpec.deprecate "matching with be_#{predicate.to_s.gsub(/\?$/,'')} on private method #{predicate}",
+              :replacement => "`expect(object.send(#{predicate.inspect})).to be_true` or change the method's visibility to public",
+              :call_site => caller(0)[3]
+          end
+
           begin
-            return @result = actual.__send__(predicate, *@args, &@block)
+            @result = actual.__send__(predicate, *@args, &@block)
+            check_respond_to(predicate)
+            return @result
           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
 
           begin
-            return @result = actual.__send__(present_tense_predicate, *@args, &@block)
+            @result = actual.__send__(present_tense_predicate, *@args, &@block)
+            check_respond_to(present_tense_predicate)
+            return @result
           rescue NameError
             raise predicate_missing_error
           end
@@ -168,7 +179,18 @@ it is a bit confusing.
           "#{prefix_to_sentence}#{expected_to_sentence}#{args_to_sentence}"
         end
 
-        private
+      private
+
+        # support 1.8.7
+        if String === methods.first
+          def is_private_on? actual
+            actual.private_methods.include? predicate.to_s
+          end
+        else
+          def is_private_on? actual
+            actual.private_methods.include? predicate
+          end
+        end
 
         def predicate
           "#{@expected}?".to_sym
@@ -191,6 +213,13 @@ it is a bit confusing.
         def prefix_to_sentence
           split_words(@prefix)
         end
+
+        def check_respond_to(method)
+          RSpec.deprecate(
+            "Matching with #{@prefix}#{@expected} on an object that doesn't respond to `#{method}`",
+            :replacement => "`respond_to_missing?` or `respond_to?` on your object"
+          ) unless actual.respond_to?(method)
+        end
       end
     end
   end

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

@@ -2,6 +2,8 @@ module RSpec
   module Matchers
     module BuiltIn
       class BeWithin
+        include MatchAliases
+
         def initialize(delta)
           @delta = delta
         end
@@ -12,7 +14,6 @@ module RSpec
           raise needs_subtractable unless @actual.respond_to? :-
           (@actual - @expected).abs <= @tolerance
         end
-        alias == matches?
 
         def of(expected)
           @expected  = expected
@@ -40,7 +41,12 @@ module RSpec
           "be within #{@delta}#{@unit} of #{@expected}"
         end
 
-        private
+        # @private
+        def supports_block_expectations?
+          false
+        end
+
+      private
 
         def needs_subtractable
           ArgumentError.new "The actual value (#{@actual.inspect}) must respond to `-`"

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

@@ -2,6 +2,8 @@ module RSpec
   module Matchers
     module BuiltIn
       class Change
+        include MatchAliases
+
         def initialize(receiver=nil, message=nil, &block)
           @message = message
           @value_proc = block || lambda {receiver.__send__(message)}
@@ -18,7 +20,39 @@ module RSpec
 
           (!change_expected? || changed?) && matches_before? && matches_after? && matches_expected_delta? && matches_min? && matches_max?
         end
-        alias == matches?
+
+        def does_not_match?(event_proc, &block)
+          expression = if @expected_delta
+            "by()"
+          elsif @minimum
+            "by_at_least()"
+          elsif @maximum
+            "by_at_most()"
+          elsif @eval_after
+            "to()"
+          end
+
+          if expression
+            RSpec.deprecate("`expect { }.not_to change { }.#{expression}`")
+          end
+
+          matched_positively = matches?(event_proc, &block)
+
+          unless matches_before?
+            RSpec.warn_deprecation(<<-EOS.gsub(/^\s+\|/, ''))
+              |The semantics of `expect { }.not_to change { }.from()` are changing
+              |in RSpec 3. In RSpec 2.x, this would pass if the value changed but
+              |the starting value was not what you specified with `from()`. In
+              |RSpec 3, this will only pass if the starting value matches your
+              |`from()` value _and_ it has not changed.
+              |
+              |You have an expectation that relies upon the old RSpec 2.x semantics
+              |at: #{CallerFilter.first_non_rspec_line}"
+            EOS
+          end
+
+          !matched_positively
+        end
 
         def raise_block_syntax_error
           raise SyntaxError.new(<<-MESSAGE)
@@ -90,6 +124,10 @@ MESSAGE
           "change ##{message}"
         end
 
+        def supports_block_expectations?
+          true
+        end
+
         private
 
         def failure_message_for_expected_after

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

@@ -2,31 +2,57 @@ module RSpec
   module Matchers
     module BuiltIn
       class Has
+        include MatchAliases
+
         def initialize(expected, *args)
           @expected, @args = expected, args
         end
 
         def matches?(actual)
-          actual.__send__(predicate(@expected), *@args)
+          method = predicate
+
+          if is_private_on?(actual)
+            RSpec.deprecate "matching with #{@expected} on private method #{predicate}",
+              :replacement => "`expect(object.send(#{predicate.inspect})).to be_true` or change the method's visibility to public"
+          end
+
+          result = actual.__send__(method, *@args)
+          check_respond_to(actual, method)
+          result
         end
-        alias == matches?
 
         def failure_message_for_should
-          "expected ##{predicate(@expected)}#{failure_message_args_description} to return true, got false"
+          "expected ##{predicate}#{failure_message_args_description} to return true, got false"
         end
 
         def failure_message_for_should_not
-          "expected ##{predicate(@expected)}#{failure_message_args_description} to return false, got true"
+          "expected ##{predicate}#{failure_message_args_description} to return false, got true"
         end
 
         def description
           [method_description(@expected), args_description].compact.join(' ')
         end
 
-        private
+        # @private
+        def supports_block_expectations?
+          false
+        end
+
+      private
 
-        def predicate(sym)
-          "#{sym.to_s.sub("have_","has_")}?".to_sym
+        # support 1.8.7
+        if String === methods.first
+          def is_private_on? actual
+            actual.private_methods.include? predicate.to_s
+          end
+        else
+          def is_private_on? actual
+            actual.private_methods.include? predicate
+          end
+        end
+
+        def predicate
+          "#{@expected.to_s.sub("have_","has_")}?".to_sym
         end
 
         def method_description(method)
@@ -42,6 +68,13 @@ module RSpec
           desc = args_description
           "(#{desc})" if desc
         end
+
+        def check_respond_to(actual, method)
+          RSpec.deprecate(
+            "Matching with #{@expected} on an object that doesn't respond to `#{method}`",
+            :replacement => "`respond_to_missing?` or `respond_to?` on your object"
+          ) unless actual.respond_to?(method)
+        end
       end
     end
   end