rspec-expectations 3.0.0.beta1 → 3.0.0.beta2

data/lib/rspec/expectations/encoded_string.rb

@@ -0,0 +1,56 @@
+require "delegate"
+
+module RSpec
+  module Expectations
+    class EncodedString < SimpleDelegator
+
+      def initialize(string, encoding = nil)
+        @encoding = encoding
+        @source_encoding = detect_source_encoding(string)
+        @string = matching_encoding(string)
+        super(@string)
+      end
+      attr_reader :source_encoding
+
+      def <<(string)
+        @string << matching_encoding(string)
+      end
+
+      def split(regex_or_string)
+        @string.split(matching_encoding(regex_or_string))
+      end
+
+    private
+
+      if String.method_defined?(:encoding)
+        def matching_encoding(string)
+          string.encode(@encoding)
+        rescue Encoding::UndefinedConversionError, Encoding::InvalidByteSequenceError
+          normalize_missing(string.encode(@encoding, :invalid => :replace, :undef => :replace))
+        rescue Encoding::ConverterNotFoundError
+          normalize_missing(string.force_encoding(@encoding).encode(:invalid => :replace))
+        end
+
+        def normalize_missing(string)
+          if @encoding.to_s == "UTF-8"
+            string.gsub("\xEF\xBF\xBD".force_encoding(@encoding), "?")
+          else
+            string
+          end
+        end
+
+        def detect_source_encoding(string)
+          string.encoding
+        end
+      else
+        def matching_encoding(string)
+          string
+        end
+
+        def detect_source_encoding(string)
+          'US-ASCII'
+        end
+      end
+    end
+  end
+end

data/lib/rspec/expectations/expectation_target.rb

@@ -10,11 +10,6 @@ module RSpec
     #   # with `not_to`
     #   expect(actual).not_to eq(3)
     class ExpectationTarget
-      class << self
-        attr_accessor :deprecated_should_enabled
-        alias deprecated_should_enabled? deprecated_should_enabled
-      end
-
       # @api private
       def initialize(target)
         @target = target
@@ -48,31 +43,6 @@ module RSpec
       end
       alias to_not not_to
 
-      def self.enable_deprecated_should
-        return if deprecated_should_enabled?
-
-        def should(*args)
-          RSpec.deprecate "`expect { }.should`", :replacement => "`expect { }.to`"
-          @target.should(*args)
-        end
-
-        def should_not(*args)
-          RSpec.deprecate "`expect { }.should_not`", :replacement => "`expect { }.not_to`"
-          @target.should_not(*args)
-        end
-
-        self.deprecated_should_enabled = true
-      end
-
-      def self.disable_deprecated_should
-        return unless deprecated_should_enabled?
-
-        remove_method :should
-        remove_method :should_not
-
-        self.deprecated_should_enabled = false
-      end
-
     private
 
       def prevent_operator_matchers(verb, matcher)

data/lib/rspec/expectations/fail_with.rb

@@ -3,7 +3,7 @@ module RSpec
     class << self
       # @private
       def differ
-        @differ ||= Differ.new
+        DiffPresenter.new
       end
 
       # Raises an RSpec::Expectations::ExpectationNotMetError with message.
@@ -16,7 +16,7 @@ module RSpec
       def fail_with(message, expected=nil, actual=nil)
         if !message
           raise ArgumentError, "Failure message is nil. Does your matcher define the " +
-                               "appropriate failure_message_for_* method to return a string?"
+                               "appropriate failure_message[_when_negated] method to return a string?"
         end
 
         if actual && expected

data/lib/rspec/expectations/handler.rb

@@ -1,7 +1,8 @@
 module RSpec
   module Expectations
 
-    class ExpectationHandler
+    # @api private
+    class ExpectationHelper
       def self.check_message(msg)
         unless msg.nil? || msg.respond_to?(:to_str) || msg.respond_to?(:call)
           ::Kernel.warn [
@@ -11,24 +12,25 @@ module RSpec
           ].join
         end
       end
-    end
 
-    class PositiveExpectationHandler < ExpectationHandler
+      # Returns an RSpec-3+ compatible matcher, wrapping a legacy one
+      # in an adapter if necessary.
+      #
+      # @api private
+      def self.modern_matcher_from(matcher)
+        LegacyMacherAdapter::RSpec2.wrap(matcher) ||
+        LegacyMacherAdapter::RSpec1.wrap(matcher) || matcher
+      end
 
-      def self.handle_matcher(actual, matcher, message=nil, &block)
+      def self.setup(handler, matcher, message)
         check_message(message)
-        ::RSpec::Matchers.last_should = :should
-        ::RSpec::Matchers.last_matcher = matcher
-        return ::RSpec::Matchers::BuiltIn::PositiveOperatorMatcher.new(actual) if matcher.nil?
-
-        match = matcher.matches?(actual, &block)
-        return match if match
+        ::RSpec::Matchers.last_expectation_handler = handler
+        ::RSpec::Matchers.last_matcher = modern_matcher_from(matcher)
+      end
 
+      def self.handle_failure(matcher, message, failure_message_method)
         message = message.call if message.respond_to?(:call)
-
-        message ||= matcher.respond_to?(:failure_message_for_should) ?
-                    matcher.failure_message_for_should :
-                    matcher.failure_message
+        message ||= matcher.__send__(failure_message_method)
 
         if matcher.respond_to?(:diffable?) && matcher.diffable?
           ::RSpec::Expectations.fail_with message, matcher.expected, matcher.actual
@@ -38,28 +40,123 @@ module RSpec
       end
     end
 
-    class NegativeExpectationHandler < ExpectationHandler
-      def self.handle_matcher(actual, matcher, message=nil, &block)
-        check_message(message)
-        ::RSpec::Matchers.last_should = :should_not
-        ::RSpec::Matchers.last_matcher = matcher
-        return ::RSpec::Matchers::BuiltIn::NegativeOperatorMatcher.new(actual) if matcher.nil?
+    # @api private
+    class PositiveExpectationHandler
+      def self.handle_matcher(actual, initial_matcher, message=nil, &block)
+        matcher = ExpectationHelper.setup(self, initial_matcher, message)
 
-        match = matcher.respond_to?(:does_not_match?) ?
-                !matcher.does_not_match?(actual, &block) :
-                matcher.matches?(actual, &block)
-        return match unless match
+        return ::RSpec::Matchers::BuiltIn::PositiveOperatorMatcher.new(actual) unless initial_matcher
+        matcher.matches?(actual, &block) or ExpectationHelper.handle_failure(matcher, message, :failure_message)
+      end
 
-        message = message.call if message.respond_to?(:call)
+      def self.verb
+        "should"
+      end
 
-        message ||= matcher.respond_to?(:failure_message_for_should_not) ?
-                    matcher.failure_message_for_should_not :
-                    matcher.negative_failure_message
+      def self.should_method
+        :should
+      end
 
-        if matcher.respond_to?(:diffable?) && matcher.diffable?
-          ::RSpec::Expectations.fail_with message, matcher.expected, matcher.actual
+      def self.opposite_should_method
+        :should_not
+      end
+    end
+
+    # @api private
+    class NegativeExpectationHandler
+      def self.handle_matcher(actual, initial_matcher, message=nil, &block)
+        matcher = ExpectationHelper.setup(self, initial_matcher, message)
+
+        return ::RSpec::Matchers::BuiltIn::NegativeOperatorMatcher.new(actual) unless initial_matcher
+        !(does_not_match?(matcher, actual, &block) or ExpectationHelper.handle_failure(matcher, message, :failure_message_when_negated))
+      end
+
+      def self.does_not_match?(matcher, actual, &block)
+        if matcher.respond_to?(:does_not_match?)
+          matcher.does_not_match?(actual, &block)
         else
-          ::RSpec::Expectations.fail_with message
+          !matcher.matches?(actual, &block)
+        end
+      end
+
+      def self.verb
+        "should not"
+      end
+
+      def self.should_method
+        :should_not
+      end
+
+      def self.opposite_should_method
+        :should
+      end
+    end
+
+    # Wraps a matcher written against one of the legacy protocols in
+    # order to present the current protocol.
+    #
+    # @api private
+    class LegacyMacherAdapter < Matchers::MatcherDelegator
+      def initialize(matcher)
+        super
+        ::RSpec.warn_deprecation(<<-EOS.gsub(/^\s+\|/, ''))
+          |--------------------------------------------------------------------------
+          |#{matcher.class.name || matcher.inspect} implements a legacy RSpec matcher
+          |protocol. For the current protocol you should expose the failure messages
+          |via the `failure_message` and `failure_message_when_negated` methods.
+          |(Used from #{CallerFilter.first_non_rspec_line})
+          |--------------------------------------------------------------------------
+        EOS
+      end
+
+      def self.wrap(matcher)
+        new(matcher) if interface_matches?(matcher)
+      end
+
+      # Starting in RSpec 1.2 (and continuing through all 2.x releases),
+      # the failure message protocol was:
+      #   * `failure_message_for_should`
+      #   * `failure_message_for_should_not`
+      # @api private
+      class RSpec2 < self
+        def failure_message
+          base_matcher.failure_message_for_should
+        end
+
+        def failure_message_when_negated
+          base_matcher.failure_message_for_should_not
+        end
+
+        def self.interface_matches?(matcher)
+          (
+            !matcher.respond_to?(:failure_message) &&
+            matcher.respond_to?(:failure_message_for_should)
+          ) || (
+            !matcher.respond_to?(:failure_message_when_negated) &&
+            matcher.respond_to?(:failure_message_for_should_not)
+          )
+        end
+      end
+
+      # Before RSpec 1.2, the failure message protocol was:
+      #   * `failure_message`
+      #   * `negative_failure_message`
+      # @api private
+      class RSpec1 < self
+        def failure_message
+          base_matcher.failure_message
+        end
+
+        def failure_message_when_negated
+          base_matcher.negative_failure_message
+        end
+
+        # Note: `failure_message` is part of the RSpec 3 protocol
+        # (paired with `failure_message_when_negated`), so we don't check
+        # for `failure_message` here.
+        def self.interface_matches?(matcher)
+          !matcher.respond_to?(:failure_message_when_negated) &&
+          matcher.respond_to?(:negative_failure_message)
         end
       end
     end

data/lib/rspec/expectations/minitest_integration.rb

@@ -0,0 +1,16 @@
+require 'rspec/expectations'
+
+Minitest::Test.class_eval do
+  include ::RSpec::Matchers
+
+  def expect(*a, &b)
+    assert(true) # so each expectation gets counted in minitest's assertion stats
+    super
+  end
+end
+
+module RSpec::Expectations
+  remove_const :ExpectationNotMetError
+  ExpectationNotMetError = ::Minitest::Assertion
+end
+

data/lib/rspec/expectations/syntax.rb

@@ -4,7 +4,7 @@ module RSpec
     # Provides methods for enabling and disabling the available
     # syntaxes provided by rspec-expectations.
     module Syntax
-      extend self
+      module_function
 
       # @method should
       # Passes if `matcher` returns true.  Available on every `Object`.
@@ -43,11 +43,11 @@ module RSpec
         @default_should_host ||= ::Object.ancestors.last
       end
 
-      def self.warn_about_should!
+      def warn_about_should!
         @warn_about_should = true
       end
 
-      def self.warn_about_should_unless_configured(method_name)
+      def warn_about_should_unless_configured(method_name)
         if @warn_about_should
           RSpec.deprecate(
             "Using `#{method_name}` from rspec-expectations' old `:should` syntax without explicitly enabling the syntax",
@@ -61,7 +61,7 @@ module RSpec
       # @api private
       # Enables the `should` syntax.
       def enable_should(syntax_host = default_should_host)
-        @warn_about_should = false
+        @warn_about_should = false if syntax_host == default_should_host
         return if should_enabled?(syntax_host)
 
         syntax_host.module_exec do
@@ -75,8 +75,6 @@ module RSpec
             ::RSpec::Expectations::NegativeExpectationHandler.handle_matcher(self, matcher, message, &block)
           end
         end
-
-        ::RSpec::Expectations::ExpectationTarget.enable_deprecated_should if expect_enabled?
       end
 
       # @api private
@@ -88,8 +86,6 @@ module RSpec
           undef should
           undef should_not
         end
-
-        ::RSpec::Expectations::ExpectationTarget.disable_deprecated_should
       end
 
       # @api private
@@ -104,8 +100,6 @@ module RSpec
             ::RSpec::Expectations::ExpectationTarget.new(target.first)
           end
         end
-
-        ::RSpec::Expectations::ExpectationTarget.enable_deprecated_should if should_enabled?
       end
 
       # @api private
@@ -116,8 +110,6 @@ module RSpec
         syntax_host.module_exec do
           undef expect
         end
-
-        ::RSpec::Expectations::ExpectationTarget.disable_deprecated_should
       end
 
       # @api private
@@ -131,52 +123,6 @@ module RSpec
       def expect_enabled?(syntax_host = ::RSpec::Matchers)
         syntax_host.method_defined?(:expect)
       end
-
-      # @api private
-      # Generates a positive expectation expression.
-      def positive_expression(target_expression, matcher_expression)
-        expression_generator.positive_expression(target_expression, matcher_expression)
-      end
-
-      # @api private
-      # Generates a negative expectation expression.
-      def negative_expression(target_expression, matcher_expression)
-        expression_generator.negative_expression(target_expression, matcher_expression)
-      end
-
-      # @api private
-      # Selects which expression generator to use based on the configured syntax.
-      def expression_generator
-        if expect_enabled?
-          ExpectExpressionGenerator
-        else
-          ShouldExpressionGenerator
-        end
-      end
-
-      # @api private
-      # Generates expectation expressions for the `should` syntax.
-      module ShouldExpressionGenerator
-        def self.positive_expression(target_expression, matcher_expression)
-          "#{target_expression}.should #{matcher_expression}"
-        end
-
-        def self.negative_expression(target_expression, matcher_expression)
-          "#{target_expression}.should_not #{matcher_expression}"
-        end
-      end
-
-      # @api private
-      # Generates expectation expressions for the `expect` syntax.
-      module ExpectExpressionGenerator
-        def self.positive_expression(target_expression, matcher_expression)
-          "expect(#{target_expression}).to #{matcher_expression}"
-        end
-
-        def self.negative_expression(target_expression, matcher_expression)
-          "expect(#{target_expression}).not_to #{matcher_expression}"
-        end
-      end
     end
   end
 end

data/lib/rspec/expectations/version.rb

@@ -2,7 +2,7 @@ module RSpec
   module Expectations
     # @private
     module Version
-      STRING = '3.0.0.beta1'
+      STRING = '3.0.0.beta2'
     end
   end
 end