rspec-expectations 2.13.0 → 3.0.0

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

@@ -1,36 +1,84 @@
 module RSpec
   module Matchers
     module BuiltIn
+      # @api private
+      # Provides the implementation for `has_<predicate>`.
+      # Not intended to be instantiated directly.
       class Has
-        def initialize(expected, *args)
-          @expected, @args = expected, args
+        include Composable
+
+        def initialize(method_name, *args, &block)
+          @method_name, @args, @block = method_name, args, block
+        end
+
+        # @private
+        def matches?(actual, &block)
+          @actual = actual
+          @block ||= block
+          predicate_accessible? && predicate_matches?
         end
 
-        def matches?(actual)
-          actual.__send__(predicate(@expected), *@args)
+        # @private
+        def does_not_match?(actual, &block)
+          @actual = actual
+          @block ||= block
+          predicate_accessible? && !predicate_matches?
         end
-        alias == matches?
 
-        def failure_message_for_should
-          "expected ##{predicate(@expected)}#{failure_message_args_description} to return true, got false"
+        # @api private
+        # @return [String]
+        def failure_message
+          validity_message || "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"
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          validity_message || "expected ##{predicate}#{failure_message_args_description} to return false, got true"
         end
 
+        # @api private
+        # @return [String]
         def description
-          [method_description(@expected), args_description].compact.join(' ')
+          [method_description, args_description].compact.join(' ')
+        end
+
+        # @private
+        def supports_block_expectations?
+          false
         end
 
-        private
+      private
+
+        def predicate_accessible?
+          !private_predicate? && predicate_exists?
+        end
 
-        def predicate(sym)
-          "#{sym.to_s.sub("have_","has_")}?".to_sym
+        # support 1.8.7, evaluate once at load time for performance
+        if String === methods.first
+          def private_predicate?
+            @actual.private_methods.include? predicate.to_s
+          end
+        else
+          def private_predicate?
+            @actual.private_methods.include? predicate
+          end
         end
 
-        def method_description(method)
-          method.to_s.gsub('_', ' ')
+        def predicate_exists?
+          @actual.respond_to? predicate
+        end
+
+        def predicate_matches?
+          @actual.__send__(predicate, *@args, &@block)
+        end
+
+        def predicate
+          @predicate ||= :"has_#{@method_name.to_s.match(Matchers::HAS_REGEX).captures.first}?"
+        end
+
+        def method_description
+          @method_name.to_s.gsub('_', ' ')
         end
 
         def args_description
@@ -42,6 +90,14 @@ module RSpec
           desc = args_description
           "(#{desc})" if desc
         end
+
+        def validity_message
+          if private_predicate?
+            "expected #{@actual} to respond to `#{predicate}` but `#{predicate}` is a private method"
+          elsif !predicate_exists?
+            "expected #{@actual} to respond to `#{predicate}`"
+          end
+        end
       end
     end
   end

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

@@ -1,67 +1,96 @@
 module RSpec
   module Matchers
     module BuiltIn
+      # @api private
+      # Provides the implementation for `include`.
+      # Not intended to be instantiated directly.
       class Include < BaseMatcher
         def initialize(*expected)
           @expected = expected
         end
 
+        # @api private
+        # @return [Boolean]
         def matches?(actual)
           @actual = actual
-          perform_match(:all?, :all?, @actual, @expected)
+          perform_match(:all?, :all?)
         end
 
+        # @api private
+        # @return [Boolean]
         def does_not_match?(actual)
           @actual = actual
-          perform_match(:none?, :any?, @actual, @expected)
+          perform_match(:none?, :any?)
         end
 
+        # @api private
+        # @return [String]
         def description
-          "include#{expected_to_sentence}"
+          described_items = surface_descriptions_in(expected)
+          improve_hash_formatting "include#{to_sentence(described_items)}"
         end
 
+        # @api private
+        # @return [String]
+        def failure_message
+          improve_hash_formatting(super)
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          improve_hash_formatting(super)
+        end
+
+        # @api private
+        # @return [Boolean]
         def diffable?
-          # Matchers do not diff well, since diff uses their inspect
-          # output, which includes their instance variables and such.
-          @expected.none? { |e| is_a_matcher?(e) }
+          true
         end
 
-        private
+      private
 
-        def perform_match(predicate, hash_predicate, actuals, expecteds)
-          expecteds.__send__(predicate) do |expected|
-            if comparing_hash_values?(actuals, expected)
-              expected.__send__(hash_predicate) { |k,v|
-                actuals.has_key?(k) && actuals[k] == v
-              }
-            elsif comparing_hash_keys?(actuals, expected)
-              actuals.has_key?(expected)
-            elsif comparing_with_matcher?(actual, expected)
-              actual.any? { |value| expected.matches?(value) }
+        def perform_match(predicate, hash_subset_predicate)
+          expected.__send__(predicate) do |expected_item|
+            if comparing_hash_to_a_subset?(expected_item)
+              expected_item.__send__(hash_subset_predicate) do |(key, value)|
+                actual_hash_includes?(key, value)
+              end
+            elsif comparing_hash_keys?(expected_item)
+              actual_hash_has_key?(expected_item)
             else
-              actuals.include?(expected)
+              actual_collection_includes?(expected_item)
             end
           end
         end
 
-        def comparing_hash_keys?(actual, expected)
-          actual.is_a?(Hash) && !expected.is_a?(Hash)
+        def comparing_hash_to_a_subset?(expected_item)
+          actual.is_a?(Hash) && expected_item.is_a?(Hash)
         end
 
-        def comparing_hash_values?(actual, expected)
-          actual.is_a?(Hash) && expected.is_a?(Hash)
+        def actual_hash_includes?(expected_key, expected_value)
+          actual_value = actual.fetch(expected_key) { return false }
+          values_match?(expected_value, actual_value)
         end
 
-        def comparing_with_matcher?(actual, expected)
-          actual.is_a?(Array) && is_a_matcher?(expected)
+        def comparing_hash_keys?(expected_item)
+          actual.is_a?(Hash) && !expected_item.is_a?(Hash)
         end
 
-        def is_a_matcher?(object)
-          return false if object.respond_to?(:i_respond_to_everything_so_im_not_really_a_matcher)
+        def actual_hash_has_key?(expected_key)
+          # We check `has_key?` first for perf:
+          # has_key? is O(1), but `any?` is O(N).
+          actual.has_key?(expected_key) ||
+          actual.keys.any? { |key| values_match?(expected_key, key) }
+        end
+
+        def actual_collection_includes?(expected_item)
+          return true if actual.include?(expected_item)
+
+          # String lacks an `any?` method...
+          return false unless actual.respond_to?(:any?)
 
-          [:failure_message_for_should, :failure_message].any? do |msg|
-            object.respond_to?(msg)
-          end && object.respond_to?(:matches?)
+          actual.any? { |value| values_match?(expected_item, value) }
         end
       end
     end

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

@@ -1,10 +1,28 @@
 module RSpec
   module Matchers
     module BuiltIn
+      # @api private
+      # Provides the implementation for `match`.
+      # Not intended to be instantiated directly.
       class Match < BaseMatcher
 
+        # @api private
+        # @return [String]
+        def description
+          "match #{surface_descriptions_in(expected).inspect}"
+        end
+
+        # @api private
+        # @return [Boolean]
+        def diffable?
+          true
+        end
+
+      private
+
         def match(expected, actual)
-          actual.match expected
+          return true if values_match?(expected, actual)
+          actual.match(expected) if actual.respond_to?(:match)
         end
       end
     end

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

@@ -0,0 +1,119 @@
+require 'rspec/support'
+
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Provides the implementation for operator matchers.
+      # Not intended to be instantiated directly.
+      # Only available for use with `should`.
+      class OperatorMatcher
+        class << self
+          # @private
+          def registry
+            @registry ||= {}
+          end
+
+          # @private
+          def register(klass, operator, matcher)
+            registry[klass] ||= {}
+            registry[klass][operator] = matcher
+          end
+
+          # @private
+          def unregister(klass, operator)
+            registry[klass] && registry[klass].delete(operator)
+          end
+
+          # @private
+          def get(klass, operator)
+            klass.ancestors.each { |ancestor|
+              matcher = registry[ancestor] && registry[ancestor][operator]
+              return matcher if matcher
+            }
+
+            nil
+          end
+        end
+
+        register Enumerable, '=~', BuiltIn::ContainExactly
+
+        def initialize(actual)
+          @actual = actual
+        end
+
+        # @private
+        def self.use_custom_matcher_or_delegate(operator)
+          define_method(operator) do |expected|
+            if uses_generic_implementation_of?(operator) && matcher = OperatorMatcher.get(@actual.class, operator)
+              @actual.__send__(::RSpec::Matchers.last_expectation_handler.should_method, matcher.new(expected))
+            else
+              eval_match(@actual, operator, expected)
+            end
+          end
+
+          negative_operator = operator.sub(/^=/, '!')
+          if negative_operator != operator && respond_to?(negative_operator)
+            define_method(negative_operator) do |expected|
+              opposite_should = ::RSpec::Matchers.last_expectation_handler.opposite_should_method
+              raise "RSpec does not support `#{::RSpec::Matchers.last_expectation_handler.should_method} #{negative_operator} expected`.  " +
+                "Use `#{opposite_should} #{operator} expected` instead."
+            end
+          end
+        end
+
+        ['==', '===', '=~', '>', '>=', '<', '<='].each do |operator|
+          use_custom_matcher_or_delegate operator
+        end
+
+        # @private
+        def fail_with_message(message)
+          RSpec::Expectations.fail_with(message, @expected, @actual)
+        end
+
+        # @api private
+        # @return [String]
+        def description
+          "#{@operator} #{@expected.inspect}"
+        end
+
+      private
+
+        def uses_generic_implementation_of?(op)
+          Support.method_handle_for(@actual, op).owner == ::Kernel
+        rescue NameError
+          false
+        end
+
+        def eval_match(actual, operator, expected)
+          ::RSpec::Matchers.last_matcher = self
+          @operator, @expected = operator, expected
+          __delegate_operator(actual, operator, expected)
+        end
+      end
+
+      # @private
+      # Handles operator matcher for `should`.
+      class PositiveOperatorMatcher < OperatorMatcher
+        def __delegate_operator(actual, operator, expected)
+          if actual.__send__(operator, expected)
+            true
+          elsif ['==','===', '=~'].include?(operator)
+            fail_with_message("expected: #{expected.inspect}\n     got: #{actual.inspect} (using #{operator})")
+          else
+            fail_with_message("expected: #{operator} #{expected.inspect}\n     got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
+          end
+        end
+      end
+
+      # @private
+      # Handles operator matcher for `should_not`.
+      class NegativeOperatorMatcher < OperatorMatcher
+        def __delegate_operator(actual, operator, expected)
+          return false unless actual.__send__(operator, expected)
+          return fail_with_message("expected not: #{operator} #{expected.inspect}\n         got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,150 @@
+require 'stringio'
+
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Provides the implementation for `output`.
+      # Not intended to be instantiated directly.
+      class Output < BaseMatcher
+        def initialize(expected)
+          @expected = expected
+          @stream_capturer = NullCapture
+        end
+
+        def matches?(block)
+          @block = block
+          return false unless Proc === block
+          @actual = @stream_capturer.capture(block)
+          @expected ? values_match?(@expected, @actual) : captured?
+        end
+
+        def does_not_match?(block)
+          !matches?(block) && Proc === block
+        end
+
+        # @api public
+        # Tells the matcher to match against stdout.
+        def to_stdout
+          @stream_capturer = CaptureStdout
+          self
+        end
+
+        # @api public
+        # Tells the matcher to match against stderr.
+        def to_stderr
+          @stream_capturer = CaptureStderr
+          self
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message
+          "expected block to #{description}, but #{positive_failure_reason}"
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          "expected block to not #{description}, but #{negative_failure_reason}"
+        end
+
+        # @api private
+        # @return [String]
+        def description
+          if @expected
+            "output #{description_of @expected} to #{@stream_capturer.name}"
+          else
+            "output to #{@stream_capturer.name}"
+          end
+        end
+
+        # @api private
+        # @return [Boolean]
+        def diffable?
+          true
+        end
+
+        # @api private
+        # Indicates this matcher matches against a block.
+        # @return [True]
+        def supports_block_expectations?
+          true
+        end
+
+      private
+
+        def captured?
+          @actual.length > 0
+        end
+
+        def positive_failure_reason
+          return "was not a block" unless Proc === @block
+          return "output #{actual_output_description}" if @expected
+          "did not"
+        end
+
+        def negative_failure_reason
+          return "was not a block" unless Proc === @block
+          "output #{actual_output_description}"
+        end
+
+        def actual_output_description
+          return "nothing" unless captured?
+          @actual.inspect
+        end
+      end
+
+      # @private
+      module NullCapture
+        def self.name
+          "some stream"
+        end
+
+        def self.capture(block)
+          raise "You must chain `to_stdout` or `to_stderr` off of the `output(...)` matcher."
+        end
+      end
+
+      # @private
+      module CaptureStdout
+        def self.name
+          'stdout'
+        end
+
+        def self.capture(block)
+          captured_stream = StringIO.new
+
+          original_stream = $stdout
+          $stdout = captured_stream
+
+          block.call
+
+          captured_stream.string
+        ensure
+          $stdout = original_stream
+        end
+      end
+
+      # @private
+      module CaptureStderr
+        def self.name
+          'stderr'
+        end
+
+        def self.capture(block)
+          captured_stream = StringIO.new
+
+          original_stream = $stderr
+          $stderr = captured_stream
+
+          block.call
+
+          captured_stream.string
+        ensure
+          $stderr = original_stream
+        end
+      end
+    end
+  end
+end