rspec-expectations 3.0.0.beta1 → 3.0.0.beta2

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

@@ -0,0 +1,106 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      # Base class for `and` and `or` compound matchers.
+      # @api private
+      class Compound < BaseMatcher
+        attr_reader :matcher_1, :matcher_2
+
+        def initialize(matcher_1, matcher_2)
+          @matcher_1 = matcher_1
+          @matcher_2 = matcher_2
+        end
+
+        def does_not_match?(actual)
+          raise NotImplementedError,
+            "`expect(...).not_to matcher.#{conjunction} matcher` is not supported"
+        end
+
+        def description
+          singleline_message(matcher_1.description, matcher_2.description)
+        end
+
+      private
+
+        def indent_multiline_message(message)
+          message.lines.map do |line|
+            line =~ /\S/ ? '   ' + line : line
+          end.join
+        end
+
+        def compound_failure_message
+          message_1 = matcher_1.failure_message
+          message_2 = matcher_2.failure_message
+
+          if multiline?(message_1) || multiline?(message_2)
+            multiline_message(message_1, message_2)
+          else
+            singleline_message(message_1, message_2)
+          end
+        end
+
+        def multiline_message(message_1, message_2)
+          [
+            indent_multiline_message(message_1.sub(/\n+\z/, '')),
+            "...#{conjunction}:",
+            indent_multiline_message(message_2.sub(/\A\n+/, ''))
+          ].join("\n\n")
+        end
+
+        def multiline?(message)
+          message.lines.count > 1
+        end
+
+        def singleline_message(message_1, message_2)
+          [message_1, conjunction, message_2].join(' ')
+        end
+
+        # Matcher used to represent a compound `and` expectation.
+        # @api public
+        class And < self
+          def failure_message
+            if @matcher_1_matches
+              matcher_2.failure_message
+            elsif @matcher_2_matches
+              matcher_1.failure_message
+            else
+              compound_failure_message
+            end
+          end
+
+        private
+
+          def match(expected, actual)
+            @matcher_1_matches = matcher_1.matches?(actual)
+            @matcher_2_matches = matcher_2.matches?(actual)
+
+            @matcher_1_matches && @matcher_2_matches
+          end
+
+          def conjunction
+            "and"
+          end
+        end
+
+        # Matcher used to represent a compound `or` expectation.
+        # @api public
+        class Or < self
+          def failure_message
+            compound_failure_message
+          end
+
+        private
+
+          def match(expected, actual)
+            matcher_1.matches?(actual) || matcher_2.matches?(actual)
+          end
+
+          def conjunction
+            "or"
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,245 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class ContainExactly < BaseMatcher
+        def match(expected, actual)
+          convert_actual_to_an_array or return false
+          match_when_sorted? || (extra_items.empty? && missing_items.empty?)
+        end
+
+        def failure_message
+          if Array === actual
+            message  = "expected collection contained:  #{safe_sort(surface_descriptions_in expected).inspect}\n"
+            message += "actual collection contained:    #{safe_sort(actual).inspect}\n"
+            message += "the missing elements were:      #{safe_sort(surface_descriptions_in missing_items).inspect}\n" unless missing_items.empty?
+            message += "the extra elements were:        #{safe_sort(extra_items).inspect}\n" unless extra_items.empty?
+            message
+          else
+            "expected a collection that can be converted to an array with " +
+            "`#to_ary` or `#to_a`, but got #{actual.inspect}"
+          end
+        end
+
+        def failure_message_when_negated
+          "`contain_exactly` does not support negation"
+        end
+
+        def description
+          "contain exactly #{_pretty_print(surface_descriptions_in expected)}"
+        end
+
+      private
+
+        # This cannot always work (e.g. when dealing with unsortable items,
+        # or matchers as expected items), but it's practically free compared to
+        # the slowness of the full matching algorithm, and in common cases this
+        # works, so it's worth a try.
+        def match_when_sorted?
+          values_match?(safe_sort(expected), safe_sort(actual))
+        end
+
+        def convert_actual_to_an_array
+          if actual.respond_to?(:to_ary)
+            @actual = actual.to_ary
+          elsif enumerable?(actual) && actual.respond_to?(:to_a)
+            @actual = actual.to_a
+          else
+            return false
+          end
+        end
+
+        def safe_sort(array)
+          array.sort rescue array
+        end
+
+        def missing_items
+          @missing_items ||= best_solution.unmatched_expected_indexes.map do |index|
+            expected[index]
+          end
+        end
+
+        def extra_items
+          @extra_items ||= best_solution.unmatched_actual_indexes.map do |index|
+            actual[index]
+          end
+        end
+
+        def best_solution
+          @best_solution ||= pairings_maximizer.find_best_solution
+        end
+
+        def pairings_maximizer
+          @pairings_maximizer ||= begin
+            expected_matches = {}
+            actual_matches   = {}
+
+            expected.each_with_index do |e, ei|
+              expected_matches[ei] ||= []
+
+              actual.each_with_index do |a, ai|
+                actual_matches[ai] ||= []
+
+                # Normally we'd call `values_match?(e, a)` here but that contains
+                # some extra checks we don't need (e.g. to support nested data
+                # structures), and given that it's called N*M times here, it helps
+                # perf significantly to implement the matching bit ourselves.
+                if (e === a || a == e)
+                  expected_matches[ei] << ai
+                  actual_matches[ai] << ei
+                end
+              end
+            end
+
+            PairingsMaximizer.new(expected_matches, actual_matches)
+          end
+        end
+
+        # Once we started supporting composing matchers, the algorithm for this matcher got
+        # much more complicated. Consider this expression:
+        #
+        #   expect(["fool", "food"]).to contain_exactly(/foo/, /fool/)
+        #
+        # This should pass (because we can pair /fool/ with "fool" and /foo/ with "food"), but
+        # the original algorithm used by this matcher would pair the first elements it could
+        # (/foo/ with "fool"), which would leave /fool/ and "food" unmatched.  When we have
+        # an expected elements which is a matcher that matches a superset of actual items
+        # compared to another expected element matcher, we need to consider every possible pairing.
+        #
+        # This class is designed to maximize the number of actual/expected pairings -- or,
+        # conversely, to minimize the number of unpaired items. It's essentially a brute
+        # force solution, but with a few heuristics applied to reduce the size of the
+        # problem space:
+        #
+        #   * Any items which match none of the items in the other list are immediately
+        #     placed into the `unmatched_expected_indexes` or `unmatched_actual_indexes` array.
+        #     The extra items and missing items in the matcher failure message are derived
+        #     from these arrays.
+        #   * Any items which reciprocally match only each other are paired up and not
+        #     considered further.
+        #
+        # What's left is only the items which match multiple items from the other list
+        # (or vice versa). From here, it performs a brute-force depth-first search,
+        # looking for a solution which pairs all elements in both lists, or, barring that,
+        # that produces the fewest unmatched items.
+        #
+        # @private
+        class PairingsMaximizer
+          Solution = Struct.new(:unmatched_expected_indexes,     :unmatched_actual_indexes,
+                                :indeterminate_expected_indexes, :indeterminate_actual_indexes) do
+            def worse_than?(other)
+              unmatched_item_count > other.unmatched_item_count
+            end
+
+            def candidate?
+              indeterminate_expected_indexes.empty? &&
+              indeterminate_actual_indexes.empty?
+            end
+
+            def ideal?
+              candidate? && (
+                unmatched_expected_indexes.empty? ||
+                unmatched_actual_indexes.empty?
+              )
+            end
+
+            def unmatched_item_count
+              unmatched_expected_indexes.count + unmatched_actual_indexes.count
+            end
+
+            def +(derived_candidate_solution)
+              self.class.new(
+                unmatched_expected_indexes + derived_candidate_solution.unmatched_expected_indexes,
+                unmatched_actual_indexes   + derived_candidate_solution.unmatched_actual_indexes,
+                # Ignore the indeterminate indexes: by the time we get here,
+                # we've dealt with all indeterminates.
+                [], []
+              )
+            end
+          end
+
+          attr_reader :expected_to_actual_matched_indexes, :actual_to_expected_matched_indexes, :solution
+
+          def initialize(expected_to_actual_matched_indexes, actual_to_expected_matched_indexes)
+            @expected_to_actual_matched_indexes = expected_to_actual_matched_indexes
+            @actual_to_expected_matched_indexes = actual_to_expected_matched_indexes
+
+            unmatched_expected_indexes, indeterminate_expected_indexes =
+              categorize_indexes(expected_to_actual_matched_indexes, actual_to_expected_matched_indexes)
+
+            unmatched_actual_indexes, indeterminate_actual_indexes =
+              categorize_indexes(actual_to_expected_matched_indexes, expected_to_actual_matched_indexes)
+
+            @solution = Solution.new(unmatched_expected_indexes,     unmatched_actual_indexes,
+                                     indeterminate_expected_indexes, indeterminate_actual_indexes)
+          end
+
+          def find_best_solution
+            return solution if solution.candidate?
+            best_solution_so_far = NullSolution
+
+            expected_index = solution.indeterminate_expected_indexes.first
+            actuals = expected_to_actual_matched_indexes[expected_index]
+
+            actuals.each do |actual_index|
+              solution = best_solution_for_pairing(expected_index, actual_index)
+              return solution if solution.ideal?
+              best_solution_so_far = solution if best_solution_so_far.worse_than?(solution)
+            end
+
+            best_solution_so_far
+          end
+
+        private
+
+          # Starting solution that is worse than any other real solution.
+          NullSolution = Class.new do
+            def self.worse_than?(other); true; end
+          end
+
+          def categorize_indexes(indexes_to_categorize, other_indexes)
+            unmatched     = []
+            indeterminate = []
+
+            indexes_to_categorize.each_pair do |index, matches|
+              if matches.empty?
+                unmatched << index
+              elsif !reciprocal_single_match?(matches, index, other_indexes)
+                indeterminate << index
+              end
+            end
+
+            return unmatched, indeterminate
+          end
+
+          def reciprocal_single_match?(matches, index, other_list)
+            return false unless matches.one?
+            other_list[matches.first] == [index]
+          end
+
+          def best_solution_for_pairing(expected_index, actual_index)
+            modified_expecteds = apply_pairing_to(
+              solution.indeterminate_expected_indexes,
+              expected_to_actual_matched_indexes, actual_index)
+
+            modified_expecteds.delete(expected_index)
+
+            modified_actuals   = apply_pairing_to(
+              solution.indeterminate_actual_indexes,
+              actual_to_expected_matched_indexes, expected_index)
+
+            modified_actuals.delete(actual_index)
+
+            solution + self.class.new(modified_expecteds, modified_actuals).find_best_solution
+          end
+
+          def apply_pairing_to(indeterminates, original_matches, other_list_index)
+            indeterminates.inject({}) do |accum, index|
+              accum[index] = original_matches[index] - [other_list_index]
+              accum
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,15 +6,54 @@ module RSpec
           actual == expected
         end
 
-        def failure_message_for_should
-          "\nexpected: #{expected.inspect}\n     got: #{actual.inspect}\n\n(compared using ==)\n"
+        def failure_message
+          "\nexpected: #{format_object(expected)}\n     got: #{format_object(actual)}\n\n(compared using ==)\n"
         end
 
-        def failure_message_for_should_not
-          "\nexpected: value != #{expected.inspect}\n     got: #{actual.inspect}\n\n(compared using ==)\n"
+        def failure_message_when_negated
+          "\nexpected: value != #{format_object(expected)}\n     got: #{format_object(actual)}\n\n(compared using ==)\n"
+        end
+
+        def description
+          "#{name_to_sentence} #{@expected.inspect}"
         end
 
         def diffable?; true; end
+
+      private
+
+        def format_object(object)
+          if Time === object
+            format_time(object)
+          elsif defined?(DateTime) && DateTime === object
+            format_date_time(object)
+          else
+            object.inspect
+          end
+        end
+
+        TIME_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+        if Time.method_defined?(:nsec)
+          def format_time(time)
+            time.strftime("#{TIME_FORMAT}.#{"%09d" % time.nsec} %z")
+          end
+        else # for 1.8.7
+          def format_time(time)
+            time.strftime("#{TIME_FORMAT}.#{"%06d" % time.usec} %z")
+          end
+        end
+
+        DATE_TIME_FORMAT = "%a, %d %b %Y %H:%M:%S.%N %z"
+        # ActiveSupport sometimes overrides inspect. If `ActiveSupport` is
+        # defined use a custom format string that includes more time precision.
+        def format_date_time(date_time)
+          if defined?(ActiveSupport)
+            date_time.strftime(DATE_TIME_FORMAT)
+          else
+            date_time.inspect
+          end
+        end
       end
     end
   end

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

@@ -6,11 +6,11 @@ module RSpec
           actual.eql? expected
         end
 
-        def failure_message_for_should
+        def failure_message
           "\nexpected: #{expected.inspect}\n     got: #{actual.inspect}\n\n(compared using eql?)\n"
         end
 
-        def failure_message_for_should_not
+        def failure_message_when_negated
           "\nexpected: value != #{expected.inspect}\n     got: #{actual.inspect}\n\n(compared using eql?)\n"
         end
 

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

@@ -6,21 +6,15 @@ module RSpec
           actual.equal? expected
         end
 
-        def failure_message_for_should
-          return <<-MESSAGE
-
-expected #{inspect_object(expected)}
-     got #{inspect_object(actual)}
-
-Compared using equal?, which compares object identity,
-but expected and actual are not the same object. Use
-`#{eq_expression}` if you don't care about
-object identity in this example.
-
-MESSAGE
+        def failure_message
+          if expected_is_a_literal_singleton?
+            simple_failure_message
+          else
+            detailed_failure_message
+          end
         end
 
-        def failure_message_for_should_not
+        def failure_message_when_negated
           return <<-MESSAGE
 
 expected not #{inspect_object(actual)}
@@ -31,16 +25,39 @@ Compared using equal?, which compares object identity.
 MESSAGE
         end
 
-        def diffable?; true; end
+        def diffable?
+          !expected_is_a_literal_singleton?
+        end
 
         private
 
-        def inspect_object(o)
-          "#<#{o.class}:#{o.object_id}> => #{o.inspect}"
+        LITERAL_SINGLETONS = [true, false, nil]
+
+        def expected_is_a_literal_singleton?
+          LITERAL_SINGLETONS.include?(expected)
+        end
+
+        def simple_failure_message
+          "\nexpected #{expected.inspect}\n     got #{inspect_object(actual)}\n"
         end
 
-        def eq_expression
-          Expectations::Syntax.positive_expression("actual", "eq(expected)")
+        def detailed_failure_message
+          return <<-MESSAGE
+
+expected #{inspect_object(expected)}
+     got #{inspect_object(actual)}
+
+Compared using equal?, which compares object identity,
+but expected and actual are not the same object. Use
+`expect(actual).to eq(expected)` if you don't care about
+object identity in this example.
+
+MESSAGE
+        end
+
+
+        def inspect_object(o)
+          "#<#{o.class}:#{o.object_id}> => #{o.inspect}"
         end
       end
     end