rspec-expectations 2.14.0 → 3.0.0

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

@@ -1,10 +1,15 @@
 module RSpec
   module Matchers
     module BuiltIn
+      # @private
+      # Object that is yielded to `expect` when one of the
+      # yield matchers is used. Provides information about
+      # the yield behavior of the object-under-test.
       class YieldProbe
         def self.probe(block)
-          probe = new
-          assert_valid_expect_block!(block)
+          probe = new(block)
+          return probe unless probe.has_block?
+          probe.assert_valid_expect_block!
           block.call(probe)
           probe.assert_used!
           probe
@@ -12,11 +17,16 @@ module RSpec
 
         attr_accessor :num_yields, :yielded_args
 
-        def initialize
+        def initialize(block)
+          @block = block
           @used = false
           self.num_yields, self.yielded_args = 0, []
         end
 
+        def has_block?
+          Proc === @block
+        end
+
         def to_proc
           @used = true
 
@@ -24,6 +34,7 @@ module RSpec
           Proc.new do |*args|
             probe.num_yields += 1
             probe.yielded_args << args
+            nil # to indicate the block does not return a meaningful value
           end
         end
 
@@ -57,71 +68,98 @@ module RSpec
                 "are."
         end
 
-        def self.assert_valid_expect_block!(block)
-          return if block.arity == 1
+        def assert_valid_expect_block!
+          return if @block.arity == 1
           raise "Your expect block must accept an argument to be used with this " +
                 "matcher. Pass the argument as a block on to the method you are testing."
         end
       end
 
+      # @api private
+      # Provides the implementation for `yield_control`.
+      # Not intended to be instantiated directly.
       class YieldControl < BaseMatcher
         def initialize
           @expectation_type = nil
           @expected_yields_count = nil
         end
 
-        def matches?(block)
-          probe = YieldProbe.probe(block)
-
-          if @expectation_type
-            probe.num_yields.send(@expectation_type, @expected_yields_count)
-          else
-            probe.yielded_once?(:yield_control)
-          end
-        end
-
+        # @api public
+        # Specifies that the method is expected to yield once.
         def once
           exactly(1)
           self
         end
 
+        # @api public
+        # Specifies that the method is expected to yield once.
         def twice
           exactly(2)
           self
         end
 
+        # @api public
+        # Specifies that the method is expected to yield the given number of times.
         def exactly(number)
           set_expected_yields_count(:==, number)
           self
         end
 
+        # @api public
+        # Specifies the maximum number of times the method is expected to yield
         def at_most(number)
           set_expected_yields_count(:<=, number)
           self
         end
 
+        # @api public
+        # Specifies the minimum number of times the method is expected to yield
         def at_least(number)
           set_expected_yields_count(:>=, number)
           self
         end
 
+        # @api public
+        # No-op. Provides syntactic sugar.
         def times
           self
         end
 
-        def failure_message_for_should
-          'expected given block to yield control'.tap do |failure_message|
-            failure_message << relativity_failure_message
+        # @private
+        def matches?(block)
+          @probe = YieldProbe.probe(block)
+          return false unless @probe.has_block?
+
+          if @expectation_type
+            @probe.num_yields.__send__(@expectation_type, @expected_yields_count)
+          else
+            @probe.yielded_once?(:yield_control)
           end
         end
 
-        def failure_message_for_should_not
-          'expected given block not to yield control'.tap do |failure_message|
-            failure_message << relativity_failure_message
-          end
+        # @private
+        def does_not_match?(block)
+          !matches?(block) && @probe.has_block?
         end
 
-        private
+        # @api private
+        # @return [String]
+        def failure_message
+          'expected given block to yield control' + failure_reason
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          'expected given block not to yield control' + failure_reason
+        end
+
+        # @private
+        def supports_block_expectations?
+          true
+        end
+
+      private
 
         def set_expected_yields_count(relativity, n)
           @expectation_type = relativity
@@ -132,7 +170,8 @@ module RSpec
                                    end
         end
 
-        def relativity_failure_message
+        def failure_reason
+          return " but was not a block" unless @probe.has_block?
           return '' unless @expected_yields_count
           " #{human_readable_expecation_type}#{human_readable_count}"
         end
@@ -154,73 +193,115 @@ module RSpec
         end
       end
 
+      # @api private
+      # Provides the implementation for `yield_with_no_args`.
+      # Not intended to be instantiated directly.
       class YieldWithNoArgs < BaseMatcher
-
+        # @private
         def matches?(block)
           @probe = YieldProbe.probe(block)
+          return false unless @probe.has_block?
           @probe.yielded_once?(:yield_with_no_args) && @probe.single_yield_args.empty?
         end
 
-        def failure_message_for_should
-          "expected given block to yield with no arguments, but #{failure_reason}"
+        # @private
+        def does_not_match?(block)
+          !matches?(block) && @probe.has_block?
+        end
+
+        # @private
+        def failure_message
+          "expected given block to yield with no arguments, but #{positive_failure_reason}"
         end
 
-        def failure_message_for_should_not
-          "expected given block not to yield with no arguments, but did"
+        # @private
+        def failure_message_when_negated
+          "expected given block not to yield with no arguments, but #{negative_failure_reason}"
+        end
+
+        # @private
+        def supports_block_expectations?
+          true
         end
 
       private
 
-        def failure_reason
-          if @probe.num_yields.zero?
-            "did not yield"
-          else
-            "yielded with arguments: #{@probe.single_yield_args.inspect}"
-          end
+        def positive_failure_reason
+          return "was not a block" unless @probe.has_block?
+          return "did not yield" if @probe.num_yields.zero?
+          "yielded with arguments: #{@probe.single_yield_args.inspect}"
+        end
+
+        def negative_failure_reason
+          return "was not a block" unless @probe.has_block?
+          "did"
         end
       end
 
+      # @api private
+      # Provides the implementation for `yield_with_args`.
+      # Not intended to be instantiated directly.
       class YieldWithArgs
+        include Composable
+
         def initialize(*args)
           @expected = args
         end
 
+        # @private
         def matches?(block)
           @probe = YieldProbe.probe(block)
+          return false unless @probe.has_block?
           @actual = @probe.single_yield_args
           @probe.yielded_once?(:yield_with_args) && args_match?
         end
-        alias == matches?
 
-        def failure_message_for_should
+        # @private
+        def does_not_match?(block)
+          !matches?(block) && @probe.has_block?
+        end
+
+        # @private
+        def failure_message
           "expected given block to yield with arguments, but #{positive_failure_reason}"
         end
 
-        def failure_message_for_should_not
+        # @private
+        def failure_message_when_negated
           "expected given block not to yield with arguments, but #{negative_failure_reason}"
         end
 
+        # @private
         def description
           desc = "yield with args"
-          desc << "(" + @expected.map { |e| e.inspect }.join(", ") + ")" unless @expected.empty?
+          desc << "(#{expected_arg_description})" unless @expected.empty?
           desc
         end
 
+        # @private
+        def supports_block_expectations?
+          true
+        end
+
       private
 
         def positive_failure_reason
-          if @probe.num_yields.zero?
-            "did not yield"
-          else
-            @positive_args_failure
-          end
+          return "was not a block" unless @probe.has_block?
+          return "did not yield" if @probe.num_yields.zero?
+          @positive_args_failure
+        end
+
+        def expected_arg_description
+          @expected.map { |e| description_of e }.join(", ")
         end
 
         def negative_failure_reason
-          if all_args_match?
+          if !@probe.has_block?
+            "was not a block"
+          elsif all_args_match?
             "yielded with expected arguments" +
-              "\nexpected not: #{@expected.inspect}" +
-              "\n         got: #{@actual.inspect} (compared using === and ==)"
+              "\nexpected not: #{surface_descriptions_in(@expected).inspect}" +
+              "\n         got: #{@actual.inspect}"
           else
             "did"
           end
@@ -234,60 +315,86 @@ module RSpec
 
           unless match = all_args_match?
             @positive_args_failure = "yielded with unexpected arguments" +
-              "\nexpected: #{@expected.inspect}" +
-              "\n     got: #{@actual.inspect} (compared using === and ==)"
+              "\nexpected: #{surface_descriptions_in(@expected).inspect}" +
+              "\n     got: #{@actual.inspect}"
           end
 
           match
         end
 
         def all_args_match?
-          return false if @expected.size != @actual.size
-
-          @expected.zip(@actual).all? do |expected, actual|
-            expected === actual || actual == expected
-          end
+          values_match?(@expected, @actual)
         end
       end
 
+      # @api private
+      # Provides the implementation for `yield_successive_args`.
+      # Not intended to be instantiated directly.
       class YieldSuccessiveArgs
+        include Composable
+
         def initialize(*args)
           @expected = args
         end
 
+        # @private
         def matches?(block)
           @probe = YieldProbe.probe(block)
+          return false unless @probe.has_block?
           @actual = @probe.successive_yield_args
           args_match?
         end
-        alias == matches?
 
-        def failure_message_for_should
-          "expected given block to yield successively with arguments, but yielded with unexpected arguments" +
-            "\nexpected: #{@expected.inspect}" +
-            "\n     got: #{@actual.inspect} (compared using === and ==)"
+        def does_not_match?(block)
+          !matches?(block) && @probe.has_block?
+        end
+
+        # @private
+        def failure_message
+          "expected given block to yield successively with arguments, but #{positive_failure_reason}"
         end
 
-        def failure_message_for_should_not
-          "expected given block not to yield successively with arguments, but yielded with expected arguments" +
-              "\nexpected not: #{@expected.inspect}" +
-              "\n         got: #{@actual.inspect} (compared using === and ==)"
+        # @private
+        def failure_message_when_negated
+          "expected given block not to yield successively with arguments, but #{negative_failure_reason}"
         end
 
+        # @private
         def description
           desc = "yield successive args"
-          desc << "(" + @expected.map { |e| e.inspect }.join(", ") + ")"
+          desc << "(#{expected_arg_description})"
           desc
         end
 
+        # @private
+        def supports_block_expectations?
+          true
+        end
+
       private
 
         def args_match?
-          return false if @expected.size != @actual.size
+          values_match?(@expected, @actual)
+        end
 
-          @expected.zip(@actual).all? do |expected, actual|
-            expected === actual || actual == expected
-          end
+        def expected_arg_description
+          @expected.map { |e| description_of e }.join(", ")
+        end
+
+        def positive_failure_reason
+          return "was not a block" unless @probe.has_block?
+
+          "yielded with unexpected arguments" +
+          "\nexpected: #{surface_descriptions_in(@expected).inspect}" +
+          "\n     got: #{@actual.inspect}"
+        end
+
+        def negative_failure_reason
+          return "was not a block" unless @probe.has_block?
+
+          "yielded with expected arguments" +
+          "\nexpected not: #{surface_descriptions_in(@expected).inspect}" +
+          "\n         got: #{@actual.inspect}"
         end
       end
     end

data/lib/rspec/matchers/built_in.rb

@@ -1,39 +1,51 @@
+RSpec::Support.require_rspec_matchers "built_in/base_matcher"
+
 module RSpec
   module Matchers
+    # Container module for all built-in matchers. The matcher classes are here
+    # (rather than directly under `RSpec::Matchers`) in order to prevent name
+    # collisions, since `RSpec::Matchers` gets included into the user's namespace.
+    #
+    # Autoloading is used to delay when the matcher classes get loaded, allowing
+    # rspec-matchers to boot faster, and avoiding loading matchers the user is
+    # not using.
     module BuiltIn
-      require 'rspec/matchers/built_in/base_matcher'
-      autoload :BeAnInstanceOf, 'rspec/matchers/built_in/be_instance_of'
-      autoload :Be,             'rspec/matchers/built_in/be'
-      autoload :BeTrue,         'rspec/matchers/built_in/be'
-      autoload :BeFalse,        'rspec/matchers/built_in/be'
-      autoload :BeNil,          'rspec/matchers/built_in/be'
-      autoload :BeComparedTo,   'rspec/matchers/built_in/be'
-      autoload :BePredicate,    'rspec/matchers/built_in/be'
-      autoload :BeAKindOf,      'rspec/matchers/built_in/be_kind_of'
-      autoload :BeWithin,       'rspec/matchers/built_in/be_within'
-      autoload :Change,         'rspec/matchers/built_in/change'
-      autoload :Cover,          'rspec/matchers/built_in/cover' if (1..2).respond_to?(:cover?)
-      autoload :Eq,             'rspec/matchers/built_in/eq'
-      autoload :Eql,            'rspec/matchers/built_in/eql'
-      autoload :Equal,          'rspec/matchers/built_in/equal'
-      autoload :Exist,          'rspec/matchers/built_in/exist'
-      autoload :Has,            'rspec/matchers/built_in/has'
-      autoload :Have,           'rspec/matchers/built_in/have'
-      autoload :Include,        'rspec/matchers/built_in/include'
-      autoload :Match,          'rspec/matchers/built_in/match'
-      autoload :MatchArray,     'rspec/matchers/built_in/match_array'
-      autoload :RaiseError,     'rspec/matchers/built_in/raise_error'
-      autoload :RespondTo,      'rspec/matchers/built_in/respond_to'
-      autoload :StartWith,      'rspec/matchers/built_in/start_and_end_with'
-      autoload :EndWith,        'rspec/matchers/built_in/start_and_end_with'
-      autoload :Satisfy,        'rspec/matchers/built_in/satisfy'
-      autoload :ThrowSymbol,    'rspec/matchers/built_in/throw_symbol'
-      autoload :YieldControl,   'rspec/matchers/built_in/yield'
-      autoload :YieldWithArgs,  'rspec/matchers/built_in/yield'
-      autoload :YieldWithNoArgs, 'rspec/matchers/built_in/yield'
-      autoload :YieldSuccessiveArgs, 'rspec/matchers/built_in/yield'
+      autoload :BeAKindOf,               'rspec/matchers/built_in/be_kind_of'
+      autoload :BeAnInstanceOf,          'rspec/matchers/built_in/be_instance_of'
+      autoload :BeBetween,               'rspec/matchers/built_in/be_between'
+      autoload :Be,                      'rspec/matchers/built_in/be'
+      autoload :BeComparedTo,            'rspec/matchers/built_in/be'
+      autoload :BeFalsey,                'rspec/matchers/built_in/be'
+      autoload :BeNil,                   'rspec/matchers/built_in/be'
+      autoload :BePredicate,             'rspec/matchers/built_in/be'
+      autoload :BeTruthy,                'rspec/matchers/built_in/be'
+      autoload :BeWithin,                'rspec/matchers/built_in/be_within'
+      autoload :Change,                  'rspec/matchers/built_in/change'
+      autoload :Compound,                'rspec/matchers/built_in/compound'
+      autoload :ContainExactly,          'rspec/matchers/built_in/contain_exactly'
+      autoload :Cover,                   'rspec/matchers/built_in/cover'
+      autoload :EndWith,                 'rspec/matchers/built_in/start_and_end_with'
+      autoload :Eq,                      'rspec/matchers/built_in/eq'
+      autoload :Eql,                     'rspec/matchers/built_in/eql'
+      autoload :Equal,                   'rspec/matchers/built_in/equal'
+      autoload :Exist,                   'rspec/matchers/built_in/exist'
+      autoload :Has,                     'rspec/matchers/built_in/has'
+      autoload :Include,                 'rspec/matchers/built_in/include'
+      autoload :All,                     'rspec/matchers/built_in/all'
+      autoload :Match,                   'rspec/matchers/built_in/match'
+      autoload :NegativeOperatorMatcher, 'rspec/matchers/built_in/operators'
+      autoload :OperatorMatcher,         'rspec/matchers/built_in/operators'
+      autoload :Output,                  'rspec/matchers/built_in/output'
+      autoload :PositiveOperatorMatcher, 'rspec/matchers/built_in/operators'
+      autoload :RaiseError,              'rspec/matchers/built_in/raise_error'
+      autoload :RespondTo,               'rspec/matchers/built_in/respond_to'
+      autoload :Satisfy,                 'rspec/matchers/built_in/satisfy'
+      autoload :StartWith,               'rspec/matchers/built_in/start_and_end_with'
+      autoload :ThrowSymbol,             'rspec/matchers/built_in/throw_symbol'
+      autoload :YieldControl,            'rspec/matchers/built_in/yield'
+      autoload :YieldSuccessiveArgs,     'rspec/matchers/built_in/yield'
+      autoload :YieldWithArgs,           'rspec/matchers/built_in/yield'
+      autoload :YieldWithNoArgs,         'rspec/matchers/built_in/yield'
     end
   end
 end
-
-

data/lib/rspec/matchers/composable.rb

@@ -0,0 +1,179 @@
+RSpec::Support.require_rspec_support "fuzzy_matcher"
+
+module RSpec
+  module Matchers
+    # Mixin designed to support the composable matcher features
+    # of RSpec 3+. Mix it into your custom matcher classes to
+    # allow them to be used in a composable fashion.
+    #
+    # @api public
+    module Composable
+      # Creates a compound `and` expectation. The matcher will
+      # only pass if both sub-matchers pass.
+      # This can be chained together to form an arbitrarily long
+      # chain of matchers.
+      #
+      # @example
+      #   expect(alphabet).to start_with("a").and end_with("z")
+      #   expect(alphabet).to start_with("a") & end_with("z")
+      #
+      # @note The negative form (`expect(...).not_to matcher.and other`)
+      #   is not supported at this time.
+      def and(matcher)
+        BuiltIn::Compound::And.new self, matcher
+      end
+      alias & and
+
+      # Creates a compound `or` expectation. The matcher will
+      # pass if either sub-matcher passes.
+      # This can be chained together to form an arbitrarily long
+      # chain of matchers.
+      #
+      # @example
+      #   expect(stoplight.color).to eq("red").or eq("green").or eq("yellow")
+      #   expect(stoplight.color).to eq("red") | eq("green") | eq("yellow")
+      #
+      # @note The negative form (`expect(...).not_to matcher.or other`)
+      #   is not supported at this time.
+      def or(matcher)
+        BuiltIn::Compound::Or.new self, matcher
+      end
+      alias | or
+
+      # Delegates to `#matches?`. Allows matchers to be used in composable
+      # fashion and also supports using matchers in case statements.
+      def ===(value)
+        matches?(value)
+      end
+
+    private
+
+      # This provides a generic way to fuzzy-match an expected value against
+      # an actual value. It understands nested data structures (e.g. hashes
+      # and arrays) and is able to match against a matcher being used as
+      # the expected value or within the expected value at any level of
+      # nesting.
+      #
+      # Within a custom matcher you are encouraged to use this whenever your
+      # matcher needs to match two values, unless it needs more precise semantics.
+      # For example, the `eq` matcher _does not_ use this as it is meant to
+      # use `==` (and only `==`) for matching.
+      #
+      # @param expected [Object] what is expected
+      # @param actual [Object] the actual value
+      #
+      # @!visibility public
+      def values_match?(expected, actual)
+        expected = with_matchers_cloned(expected)
+        Support::FuzzyMatcher.values_match?(expected, actual)
+      end
+
+      # Returns the description of the given object in a way that is
+      # aware of composed matchers. If the object is a matcher with
+      # a `description` method, returns the description; otherwise
+      # returns `object.inspect`.
+      #
+      # You are encouraged to use this in your custom matcher's
+      # `description`, `failure_message` or
+      # `failure_message_when_negated` implementation if you are
+      # supporting matcher arguments.
+      #
+      # @!visibility public
+      def description_of(object)
+        return object.description if Matchers.is_a_describable_matcher?(object)
+        object.inspect
+      end
+
+      # Transforms the given data structue (typically a hash or array)
+      # into a new data structure that, when `#inspect` is called on it,
+      # will provide descriptions of any contained matchers rather than
+      # the normal `#inspect` output.
+      #
+      # You are encouraged to use this in your custom matcher's
+      # `description`, `failure_message` or
+      # `failure_message_when_negated` implementation if you are
+      # supporting any arguments which may be a data structure
+      # containing matchers.
+      #
+      # @!visibility public
+      def surface_descriptions_in(item)
+        if Matchers.is_a_describable_matcher?(item)
+          DescribableItem.new(item)
+        elsif Hash === item
+          Hash[ surface_descriptions_in(item.to_a) ]
+        elsif enumerable?(item)
+          begin
+            item.map { |subitem| surface_descriptions_in(subitem) }
+          rescue IOError # STDOUT is enumerable but `map` raises an error
+            item.inspect
+          end
+        else
+          item
+        end
+      end
+
+      # @private
+      # Historically, a single matcher instance was only checked
+      # against a single value. Given that the matcher was only
+      # used once, it's been common to memoize some intermediate
+      # calculation that is derived from the `actual` value in
+      # order to reuse that intermediate result in the failure
+      # message.
+      #
+      # This can cause a problem when using such a matcher as an
+      # argument to another matcher in a composed matcher expression,
+      # since the matcher instance may be checked against multiple
+      # values and produce invalid results due to the memoization.
+      #
+      # To deal with this, we clone any matchers in `expected` via
+      # this method when using `values_match?`, so that any memoization
+      # does not "leak" between checks.
+      def with_matchers_cloned(object)
+        if Matchers.is_a_matcher?(object)
+          object.clone
+        elsif Hash === object
+          Hash[ with_matchers_cloned(object.to_a) ]
+        elsif enumerable?(object)
+          begin
+            object.map { |subobject| with_matchers_cloned(subobject) }
+          rescue IOError # STDOUT is enumerable but `map` raises an error
+            object
+          end
+        else
+          object
+        end
+      end
+
+      if String.ancestors.include?(Enumerable) # 1.8.7
+        # Strings are not enumerable on 1.9, and on 1.8 they are an infinitely
+        # nested enumerable: since ruby lacks a character class, it yields
+        # 1-character strings, which are themselves enumerable, composed of a
+        # a single 1-character string, which is an enumerable, etc.
+        #
+        # @api private
+        def enumerable?(item)
+          return false if String === item
+          Enumerable === item
+        end
+      else
+        # @api private
+        def enumerable?(item)
+          Enumerable === item
+        end
+      end
+      module_function :surface_descriptions_in, :enumerable?
+
+      # Wraps an item in order to surface its `description` via `inspect`.
+      # @api private
+      DescribableItem = Struct.new(:item) do
+        def inspect
+          "(#{item.description})"
+        end
+
+        def pretty_print(pp)
+          pp.text "(#{item.description})"
+        end
+      end
+    end
+  end
+end