opal-rspec 0.8.0.alpha3 → 1.0.0.alpha1

data/rspec-expectations/upstream/lib/rspec/matchers/built_in/have_attributes.rb

@@ -10,13 +10,21 @@ module RSpec
 
         def initialize(expected)
           @expected = expected
+          @values = {}
           @respond_to_failed = false
+          @negated = false
+        end
+
+        # @private
+        def actual
+          @values
         end
 
         # @api private
         # @return [Boolean]
         def matches?(actual)
           @actual = actual
+          @negated = false
           return false unless respond_to_attributes?
           perform_match(:all?)
         end
@@ -25,6 +33,7 @@ module RSpec
         # @return [Boolean]
         def does_not_match?(actual)
           @actual = actual
+          @negated = true
           return false unless respond_to_attributes?
           perform_match(:none?)
         end
@@ -33,42 +42,58 @@ module RSpec
         # @return [String]
         def description
           described_items = surface_descriptions_in(expected)
-          improve_hash_formatting "have attributes #{described_items.inspect}"
+          improve_hash_formatting "have attributes #{RSpec::Support::ObjectFormatter.format(described_items)}"
+        end
+
+        # @api private
+        # @return [Boolean]
+        def diffable?
+          !@respond_to_failed && !@negated
         end
 
         # @api private
         # @return [String]
         def failure_message
-          respond_to_failure_message_or { super }
+          respond_to_failure_message_or do
+            "expected #{actual_formatted} to #{description} but had attributes #{ formatted_values }"
+          end
         end
 
         # @api private
         # @return [String]
         def failure_message_when_negated
-          respond_to_failure_message_or { super }
+          respond_to_failure_message_or { "expected #{actual_formatted} not to #{description}" }
         end
 
       private
 
+        def cache_all_values
+          @values = {}
+          expected.each do |attribute_key, _attribute_value|
+            actual_value = @actual.__send__(attribute_key)
+            @values[attribute_key] = actual_value
+          end
+        end
+
         def perform_match(predicate)
+          cache_all_values
           expected.__send__(predicate) do |attribute_key, attribute_value|
             actual_has_attribute?(attribute_key, attribute_value)
           end
         end
 
         def actual_has_attribute?(attribute_key, attribute_value)
-          actual_value = actual.__send__(attribute_key)
-          values_match?(attribute_value, actual_value)
+          values_match?(attribute_value, @values.fetch(attribute_key))
         end
 
         def respond_to_attributes?
-          matches = respond_to_matcher.matches?(actual)
+          matches = respond_to_matcher.matches?(@actual)
           @respond_to_failed = !matches
           matches
         end
 
         def respond_to_matcher
-          @respond_to_matcher ||= RespondTo.new(*expected.keys).with(0).arguments
+          @respond_to_matcher ||= RespondTo.new(*expected.keys).with(0).arguments.tap { |m| m.ignoring_method_signature_failure! }
         end
 
         def respond_to_failure_message_or
@@ -78,6 +103,11 @@ module RSpec
             improve_hash_formatting(yield)
           end
         end
+
+        def formatted_values
+          values = RSpec::Support::ObjectFormatter.format(@values)
+          improve_hash_formatting(values)
+        end
       end
     end
   end

data/rspec-expectations/upstream/lib/rspec/matchers/built_in/include.rb

@@ -1,73 +1,136 @@
+require 'rspec/matchers/built_in/count_expectation'
+
 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
+      class Include < BaseMatcher # rubocop:disable Metrics/ClassLength
+        include CountExpectation
+        # @private
+        attr_reader :expecteds
+
+        # @api private
+        def initialize(*expecteds)
+          @expecteds = expecteds
         end
 
         # @api private
         # @return [Boolean]
         def matches?(actual)
-          @actual = actual
-          perform_match(:all?, :all?)
+          check_actual?(actual) &&
+            if check_expected_count?
+              expected_count_matches?(count_inclusions)
+            else
+              perform_match { |v| v }
+            end
         end
 
         # @api private
         # @return [Boolean]
         def does_not_match?(actual)
-          @actual = actual
-          perform_match(:none?, :any?)
+          check_actual?(actual) &&
+            if check_expected_count?
+              !expected_count_matches?(count_inclusions)
+            else
+              perform_match { |v| !v }
+            end
         end
 
         # @api private
         # @return [String]
         def description
-          described_items = surface_descriptions_in(expected)
-          improve_hash_formatting "include#{to_sentence(described_items)}"
+          improve_hash_formatting("include#{readable_list_of(expecteds)}#{count_expectation_description}")
         end
 
         # @api private
         # @return [String]
         def failure_message
-          improve_hash_formatting(super) + invalid_type_message
+          format_failure_message("to") { super }
         end
 
         # @api private
         # @return [String]
         def failure_message_when_negated
-          improve_hash_formatting(super) + invalid_type_message
+          format_failure_message("not to") { super }
         end
 
         # @api private
         # @return [Boolean]
         def diffable?
-          true
+          !diff_would_wrongly_highlight_matched_item?
+        end
+
+        # @api private
+        # @return [Array, Hash]
+        def expected
+          if expecteds.one? && Hash === expecteds.first
+            expecteds.first
+          else
+            expecteds
+          end
         end
 
       private
 
-        def invalid_type_message
-          return '' if actual.respond_to?(:include?)
-          ", but it does not respond to `include?`"
+        def check_actual?(actual)
+          actual = actual.to_hash if convert_to_hash?(actual)
+          @actual = actual
+          @actual.respond_to?(:include?)
+        end
+
+        def check_expected_count?
+          case
+          when !has_expected_count?
+            return false
+          when expecteds.size != 1
+            raise NotImplementedError, 'Count constraint supported only when testing for a single value being included'
+          when actual.is_a?(Hash)
+            raise NotImplementedError, 'Count constraint on hash keys not implemented'
+          end
+          true
+        end
+
+        def format_failure_message(preposition)
+          msg = if actual.respond_to?(:include?)
+                  "expected #{description_of @actual} #{preposition}" \
+                  " include#{readable_list_of @divergent_items}" \
+                  "#{count_failure_reason('it is included') if has_expected_count?}"
+                else
+                  "#{yield}, but it does not respond to `include?`"
+                end
+          improve_hash_formatting(msg)
+        end
+
+        def readable_list_of(items)
+          described_items = surface_descriptions_in(items)
+          if described_items.all? { |item| item.is_a?(Hash) }
+            " #{described_items.inject(:merge).inspect}"
+          else
+            EnglishPhrasing.list(described_items)
+          end
+        end
+
+        def perform_match(&block)
+          @divergent_items = excluded_from_actual(&block)
+          @divergent_items.empty?
         end
 
-        def perform_match(predicate, hash_subset_predicate)
-          return false unless actual.respond_to?(:include?)
+        def excluded_from_actual
+          return [] unless @actual.respond_to?(:include?)
 
-          expected.__send__(predicate) do |expected_item|
+          expecteds.inject([]) do |memo, expected_item|
             if comparing_hash_to_a_subset?(expected_item)
-              expected_item.__send__(hash_subset_predicate) do |(key, value)|
-                actual_hash_includes?(key, value)
+              expected_item.each do |(key, value)|
+                memo << { key => value } unless yield actual_hash_includes?(key, value)
               end
             elsif comparing_hash_keys?(expected_item)
-              actual_hash_has_key?(expected_item)
+              memo << expected_item unless yield actual_hash_has_key?(expected_item)
             else
-              actual_collection_includes?(expected_item)
+              memo << expected_item unless yield actual_collection_includes?(expected_item)
             end
+            memo
           end
         end
 
@@ -76,7 +139,10 @@ module RSpec
         end
 
         def actual_hash_includes?(expected_key, expected_value)
-          actual_value = actual.fetch(expected_key) { return false }
+          actual_value =
+            actual.fetch(expected_key) do
+              actual.find(Proc.new { return false }) { |actual_key, _| values_match?(expected_key, actual_key) }[1]
+            end
           values_match?(expected_value, actual_value)
         end
 
@@ -99,6 +165,41 @@ module RSpec
 
           actual.any? { |value| values_match?(expected_item, value) }
         end
+
+        if RUBY_VERSION < '1.9'
+          def count_enumerable(expected_item)
+            actual.select { |value| values_match?(expected_item, value) }.size
+          end
+        else
+          def count_enumerable(expected_item)
+            actual.count { |value| values_match?(expected_item, value) }
+          end
+        end
+
+        def count_inclusions
+          @divergent_items = expected
+          case actual
+          when String
+            actual.scan(expected.first).length
+          when Enumerable
+            count_enumerable(Hash === expected ? expected : expected.first)
+          else
+            raise NotImplementedError, 'Count constraints are implemented for Enumerable and String values only'
+          end
+        end
+
+        def diff_would_wrongly_highlight_matched_item?
+          return false unless actual.is_a?(String) && expected.is_a?(Array)
+
+          lines = actual.split("\n")
+          expected.any? do |str|
+            actual.include?(str) && lines.none? { |line| line == str }
+          end
+        end
+
+        def convert_to_hash?(obj)
+          !obj.respond_to?(:include?) && obj.respond_to?(:to_hash)
+        end
       end
     end
   end

data/rspec-expectations/upstream/lib/rspec/matchers/built_in/match.rb

@@ -5,10 +5,19 @@ module RSpec
       # Provides the implementation for `match`.
       # Not intended to be instantiated directly.
       class Match < BaseMatcher
+        def initialize(expected)
+          super(expected)
+
+          @expected_captures = nil
+        end
         # @api private
         # @return [String]
         def description
-          "match #{surface_descriptions_in(expected).inspect}"
+          if @expected_captures && @expected.match(actual)
+            "match #{surface_descriptions_in(expected).inspect} with captures #{surface_descriptions_in(@expected_captures).inspect}"
+          else
+            "match #{surface_descriptions_in(expected).inspect}"
+          end
         end
 
         # @api private
@@ -17,12 +26,80 @@ module RSpec
           true
         end
 
+        # Used to specify the captures we match against
+        # @return [self]
+        def with_captures(*captures)
+          @expected_captures = captures
+          self
+        end
+
       private
 
         def match(expected, actual)
+          return match_captures(expected, actual) if @expected_captures
           return true if values_match?(expected, actual)
-          actual.match(expected) if actual.respond_to?(:match)
+          return false unless can_safely_call_match?(expected, actual)
+          actual.match(expected)
+        end
+
+        def can_safely_call_match?(expected, actual)
+          return false unless actual.respond_to?(:match)
+
+          !(RSpec::Matchers.is_a_matcher?(expected) &&
+            (String === actual || Regexp === actual))
+        end
+
+        def match_captures(expected, actual)
+          match = actual.match(expected)
+          if match
+            match = ReliableMatchData.new(match)
+            if match.names.empty?
+              values_match?(@expected_captures, match.captures)
+            else
+              expected_matcher = @expected_captures.last
+              values_match?(expected_matcher, Hash[match.names.zip(match.captures)]) ||
+                values_match?(expected_matcher, Hash[match.names.map(&:to_sym).zip(match.captures)]) ||
+                values_match?(@expected_captures, match.captures)
+            end
+          else
+            false
+          end
+        end
+      end
+
+      # @api private
+      # Used to wrap match data and make it reliable for 1.8.7
+      class ReliableMatchData
+        def initialize(match_data)
+          @match_data = match_data
+        end
+
+        if RUBY_VERSION == "1.8.7"
+          # @api private
+          # Returns match data names for named captures
+          # @return Array
+          def names
+            []
+          end
+        else
+          # @api private
+          # Returns match data names for named captures
+          # @return Array
+          def names
+            match_data.names
+          end
         end
+
+        # @api private
+        # returns an array of captures from the match data
+        # @return Array
+        def captures
+          match_data.captures
+        end
+
+      protected
+
+        attr_reader :match_data
       end
     end
   end

data/rspec-expectations/upstream/lib/rspec/matchers/built_in/operators.rb

@@ -74,7 +74,7 @@ module RSpec
         # @api private
         # @return [String]
         def description
-          "#{@operator} #{@expected.inspect}"
+          "#{@operator} #{RSpec::Support::ObjectFormatter.format(@expected)}"
         end
 
       private
@@ -98,10 +98,15 @@ module RSpec
         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}")
+            expected_formatted = RSpec::Support::ObjectFormatter.format(expected)
+            actual_formatted   = RSpec::Support::ObjectFormatter.format(actual)
+
+            if ['==', '===', '=~'].include?(operator)
+              fail_with_message("expected: #{expected_formatted}\n     got: #{actual_formatted} (using #{operator})")
+            else
+              fail_with_message("expected: #{operator} #{expected_formatted}\n     got: #{operator.gsub(/./, ' ')} #{actual_formatted}")
+            end
           end
         end
       end
@@ -111,7 +116,11 @@ module RSpec
       class NegativeOperatorMatcher < OperatorMatcher
         def __delegate_operator(actual, operator, expected)
           return false unless actual.__send__(operator, expected)
-          fail_with_message("expected not: #{operator} #{expected.inspect}\n         got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
+
+          expected_formatted = RSpec::Support::ObjectFormatter.format(expected)
+          actual_formatted   = RSpec::Support::ObjectFormatter.format(actual)
+
+          fail_with_message("expected not: #{operator} #{expected_formatted}\n         got: #{operator.gsub(/./, ' ')} #{actual_formatted}")
         end
       end
     end

data/rspec-expectations/upstream/lib/rspec/matchers/built_in/output.rb

@@ -27,6 +27,7 @@ module RSpec
 
         # @api public
         # Tells the matcher to match against stdout.
+        # Works only when the main Ruby process prints to stdout
         def to_stdout
           @stream_capturer = CaptureStdout
           self
@@ -34,11 +35,30 @@ module RSpec
 
         # @api public
         # Tells the matcher to match against stderr.
+        # Works only when the main Ruby process prints to stderr
         def to_stderr
           @stream_capturer = CaptureStderr
           self
         end
 
+        # @api public
+        # Tells the matcher to match against stdout.
+        # Works when subprocesses print to stdout as well.
+        # This is significantly (~30x) slower than `to_stdout`
+        def to_stdout_from_any_process
+          @stream_capturer = CaptureStreamToTempfile.new("stdout", $stdout)
+          self
+        end
+
+        # @api public
+        # Tells the matcher to match against stderr.
+        # Works when subprocesses print to stderr as well.
+        # This is significantly (~30x) slower than `to_stderr`
+        def to_stderr_from_any_process
+          @stream_capturer = CaptureStreamToTempfile.new("stderr", $stderr)
+          self
+        end
+
         # @api private
         # @return [String]
         def failure_message
@@ -74,6 +94,13 @@ module RSpec
           true
         end
 
+        # @api private
+        # Indicates this matcher matches against a block only.
+        # @return [False]
+        def supports_value_expectations?
+          false
+        end
+
       private
 
         def captured?
@@ -93,7 +120,7 @@ module RSpec
 
         def actual_output_description
           return "nothing" unless captured?
-          @actual.inspect
+          actual_formatted
         end
       end
 
@@ -147,6 +174,34 @@ module RSpec
           $stderr = original_stream
         end
       end
+
+      # @private
+      class CaptureStreamToTempfile < Struct.new(:name, :stream)
+        def capture(block)
+          # We delay loading tempfile until it is actually needed because
+          # we want to minimize stdlibs loaded so that users who use a
+          # portion of the stdlib can't have passing specs while forgetting
+          # to load it themselves. `CaptureStreamToTempfile` is rarely used
+          # and `tempfile` pulls in a bunch of things (delegate, tmpdir,
+          # thread, fileutils, etc), so it's worth delaying it until this point.
+          require 'tempfile'
+
+          original_stream = stream.clone
+          captured_stream = Tempfile.new(name)
+
+          begin
+            captured_stream.sync = true
+            stream.reopen(captured_stream)
+            block.call
+            captured_stream.rewind
+            captured_stream.read
+          ensure
+            stream.reopen(original_stream)
+            captured_stream.close
+            captured_stream.unlink
+          end
+        end
+      end
     end
   end
 end