rspec-expectations 3.0.0.beta1 → 3.0.0.beta2

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

@@ -2,35 +2,36 @@ module RSpec
   module Matchers
     module BuiltIn
       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
 
-        def matches?(actual)
-          actual.__send__(predicate(@expected), *@args)
+        def matches?(actual, &block)
+          actual.__send__(predicate, *@args, &(@block || block))
         end
-        alias == matches?
 
-        def failure_message_for_should
-          "expected ##{predicate(@expected)}#{failure_message_args_description} to return true, got false"
+        def failure_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"
+        def failure_message_when_negated
+          "expected ##{predicate}#{failure_message_args_description} to return false, got true"
         end
 
         def description
-          [method_description(@expected), args_description].compact.join(' ')
+          [method_description, args_description].compact.join(' ')
         end
 
-        private
+      private
 
-        def predicate(sym)
-          "#{sym.to_s.sub("have_","has_")}?".to_sym
+        def predicate
+          @predicate ||= :"has_#{@method_name.to_s.match(Matchers::HAS_REGEX).captures.first}?"
         end
 
-        def method_description(method)
-          method.to_s.gsub('_', ' ')
+        def method_description
+          @method_name.to_s.gsub('_', ' ')
         end
 
         def args_description

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

@@ -8,52 +8,74 @@ module RSpec
 
         def matches?(actual)
           @actual = actual
-          perform_match(:all?, :all?, @actual, @expected)
+          perform_match(:all?, :all?)
         end
 
         def does_not_match?(actual)
           @actual = actual
-          perform_match(:none?, :any?, @actual, @expected)
+          perform_match(:none?, :any?)
         end
 
         def description
-          "include#{expected_to_sentence}"
+          described_items = surface_descriptions_in(expected)
+          improve_hash_formatting "include#{to_sentence(described_items)}"
+        end
+
+        def failure_message
+          improve_hash_formatting(super)
+        end
+
+        def failure_message_when_negated
+          improve_hash_formatting(super)
         end
 
         def diffable?
-          # Matchers do not diff well, since diff uses their inspect
-          # output, which includes their instance variables and such.
-          @expected.none? { |e| RSpec::Matchers.is_a_matcher?(e) }
+          true
         end
 
         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 actual_hash_includes?(expected_key, expected_value)
+          actual_value = actual.fetch(expected_key) { return false }
+          values_match?(expected_value, actual_value)
+        end
+
+        def comparing_hash_keys?(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_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 comparing_with_matcher?(actual, expected)
-          actual.is_a?(Array) && RSpec::Matchers.is_a_matcher?(expected)
+        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?)
+
+          actual.any? { |value| values_match?(expected_item, value) }
         end
       end
     end

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

@@ -2,15 +2,18 @@ module RSpec
   module Matchers
     module BuiltIn
       class Match < BaseMatcher
-
         def match(expected, actual)
-          actual.match expected
+          return true if values_match?(expected, actual)
+          actual.match(expected) if actual.respond_to?(:match)
+        end
+
+        def description
+          "match #{surface_descriptions_in(expected).inspect}"
         end
 
         def diffable?
           true
         end
-
       end
     end
   end

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

@@ -0,0 +1,103 @@
+require 'rspec/support'
+
+module RSpec
+  module Matchers
+    module BuiltIn
+      class OperatorMatcher
+        class << self
+          def registry
+            @registry ||= {}
+          end
+
+          def register(klass, operator, matcher)
+            registry[klass] ||= {}
+            registry[klass][operator] = matcher
+          end
+
+          def unregister(klass, operator)
+            registry[klass] && registry[klass].delete(operator)
+          end
+
+          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
+
+        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
+
+        def fail_with_message(message)
+          RSpec::Expectations.fail_with(message, @expected, @actual)
+        end
+
+        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
+
+      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
+
+      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,108 @@
+require 'stringio'
+
+module RSpec
+  module Matchers
+    module BuiltIn
+      class Output < BaseMatcher
+        def initialize(expected)
+          @expected = expected
+          @stream_capturer = NullCapture
+        end
+
+        def matches?(block)
+          @actual = @stream_capturer.capture(block)
+
+          @expected ? values_match?(@expected, @actual) : captured?
+        end
+
+        def to_stdout
+          @stream_capturer = CaptureStdout
+          self
+        end
+
+        def to_stderr
+          @stream_capturer = CaptureStderr
+          self
+        end
+
+        def failure_message
+          "expected block to #{description}, #{actual_description}"
+        end
+
+        def failure_message_when_negated
+          "expected block to not #{description}, but did"
+        end
+
+        def description
+          if @expected
+            "output #{description_of @expected} to #{@stream_capturer.name}"
+          else
+            "output to #{@stream_capturer.name}"
+          end
+        end
+
+        def diffable?
+          true
+        end
+
+      private
+
+        def captured?
+          @actual.length > 0
+        end
+
+        def actual_description
+          @expected ? "but output #{captured? ? @actual.inspect : 'nothing'}" : "but did not"
+        end
+      end
+
+      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
+
+      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
+
+      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

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

@@ -2,6 +2,8 @@ module RSpec
   module Matchers
     module BuiltIn
       class RaiseError
+        include Composable
+
         def initialize(expected_error_or_message=Exception, expected_message=nil, &block)
           @block = block
           @actual_error = nil
@@ -34,7 +36,7 @@ module RSpec
           begin
             given_proc.call
           rescue Exception => @actual_error
-            if @actual_error == @expected_error || @expected_error === @actual_error
+            if values_match?(@expected_error, @actual_error)
               @raised_expected_error = true
               @with_expected_message = verify_message
             end
@@ -47,8 +49,6 @@ module RSpec
           expectation_matched?
         end
 
-        alias == matches?
-
         def expectation_matched?
           error_and_message_match? && block_matches?
         end
@@ -77,21 +77,15 @@ module RSpec
         end
 
         def verify_message
-          case @expected_message
-          when nil
-            true
-          when Regexp
-            @expected_message =~ @actual_error.message
-          else
-            @expected_message == @actual_error.message
-          end
+          return true if @expected_message.nil?
+          values_match?(@expected_message, @actual_error.message)
         end
 
-        def failure_message_for_should
+        def failure_message
           @eval_block ? @actual_error.message : "expected #{expected_error}#{given_error}"
         end
 
-        def failure_message_for_should_not
+        def failure_message_when_negated
           "expected no #{expected_error}#{given_error}"
         end
 
@@ -118,11 +112,11 @@ module RSpec
         def expected_error
           case @expected_message
           when nil
-            @expected_error.inspect
+            description_of(@expected_error)
           when Regexp
             "#{@expected_error} with message matching #{@expected_message.inspect}"
           else
-            "#{@expected_error} with #{@expected_message.inspect}"
+            "#{@expected_error} with #{description_of @expected_message}"
           end
         end