opal-rspec 0.8.0.alpha3 → 1.0.0.alpha1

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

@@ -8,7 +8,7 @@ module RSpec
         # @api public
         # Specifies the delta of the expected change.
         def by(expected_delta)
-          ChangeRelatively.new(@change_details, expected_delta, :by) do |actual_delta|
+          ChangeRelatively.new(change_details, expected_delta, :by) do |actual_delta|
             values_match?(expected_delta, actual_delta)
           end
         end
@@ -16,7 +16,7 @@ module RSpec
         # @api public
         # Specifies a minimum delta of the expected change.
         def by_at_least(minimum)
-          ChangeRelatively.new(@change_details, minimum, :by_at_least) do |actual_delta|
+          ChangeRelatively.new(change_details, minimum, :by_at_least) do |actual_delta|
             actual_delta >= minimum
           end
         end
@@ -24,7 +24,7 @@ module RSpec
         # @api public
         # Specifies a maximum delta of the expected change.
         def by_at_most(maximum)
-          ChangeRelatively.new(@change_details, maximum, :by_at_most) do |actual_delta|
+          ChangeRelatively.new(change_details, maximum, :by_at_most) do |actual_delta|
             actual_delta <= maximum
           end
         end
@@ -32,45 +32,44 @@ module RSpec
         # @api public
         # Specifies the new value you expect.
         def to(value)
-          ChangeToValue.new(@change_details, value)
+          ChangeToValue.new(change_details, value)
         end
 
         # @api public
         # Specifies the original value.
         def from(value)
-          ChangeFromValue.new(@change_details, value)
+          ChangeFromValue.new(change_details, value)
         end
 
         # @private
         def matches?(event_proc)
-          @event_proc = event_proc
-          return false unless Proc === event_proc
           raise_block_syntax_error if block_given?
-          @change_details.perform_change(event_proc)
-          @change_details.changed?
+          perform_change(event_proc) && change_details.changed?
         end
 
         def does_not_match?(event_proc)
           raise_block_syntax_error if block_given?
-          !matches?(event_proc) && Proc === event_proc
+          perform_change(event_proc) && !change_details.changed?
         end
 
         # @api private
         # @return [String]
         def failure_message
-          "expected #{@change_details.message} to have changed, but #{positive_failure_reason}"
+          "expected #{change_details.value_representation} to have changed, " \
+          "but #{positive_failure_reason}"
         end
 
         # @api private
         # @return [String]
         def failure_message_when_negated
-          "expected #{@change_details.message} not to have changed, but #{negative_failure_reason}"
+          "expected #{change_details.value_representation} not to have changed, " \
+          "but #{negative_failure_reason}"
         end
 
         # @api private
         # @return [String]
         def description
-          "change #{@change_details.message}"
+          "change #{change_details.value_representation}"
         end
 
         # @private
@@ -78,25 +77,49 @@ module RSpec
           true
         end
 
+        # @private
+        def supports_value_expectations?
+          false
+        end
+
       private
 
         def initialize(receiver=nil, message=nil, &block)
-          @change_details = ChangeDetails.new(receiver, message, &block)
+          @receiver = receiver
+          @message = message
+          @block = block
+        end
+
+        def change_details
+          @change_details ||= ChangeDetails.new(matcher_name, @receiver, @message, &@block)
+        end
+
+        def perform_change(event_proc)
+          @event_proc = event_proc
+          change_details.perform_change(event_proc) do |actual_before|
+            # pre-compute values derived from the `before` value before the
+            # mutation is applied, in case the specified mutation is mutation
+            # of a single object (rather than a changing what object a method
+            # returns). We need to cache these values before the `before` value
+            # they are based on potentially gets mutated.
+            @actual_before_description = description_of(actual_before)
+          end
         end
 
         def raise_block_syntax_error
-          raise SyntaxError, "The block passed to the `change` matcher must " \
-            "use `{ ... }` instead of do/end"
+          raise SyntaxError, "Block not received by the `change` matcher. " \
+          "Perhaps you want to use `{ ... }` instead of do/end?"
         end
 
         def positive_failure_reason
           return "was not given a block" unless Proc === @event_proc
-          "is still #{description_of @change_details.actual_before}"
+          "is still #{@actual_before_description}"
         end
 
         def negative_failure_reason
           return "was not given a block" unless Proc === @event_proc
-          "did change from #{description_of @change_details.actual_before} to #{description_of @change_details.actual_after}"
+          "did change from #{@actual_before_description} " \
+          "to #{description_of change_details.actual_after}"
         end
       end
 
@@ -112,25 +135,27 @@ module RSpec
 
         # @private
         def failure_message
-          "expected #{@change_details.message} to have changed #{@relativity.to_s.gsub("_", " ")} #{description_of @expected_delta}, but #{failure_reason}"
+          "expected #{@change_details.value_representation} to have changed " \
+          "#{@relativity.to_s.tr('_', ' ')} " \
+          "#{description_of @expected_delta}, but #{failure_reason}"
         end
 
         # @private
         def matches?(event_proc)
           @event_proc = event_proc
-          return false unless Proc === event_proc
-          @change_details.perform_change(event_proc)
-          @comparer.call(@change_details.actual_delta)
+          @change_details.perform_change(event_proc) && @comparer.call(@change_details.actual_delta)
         end
 
         # @private
         def does_not_match?(_event_proc)
-          raise NotImplementedError, "`expect { }.not_to change { }.#{@relativity}()` is not supported"
+          raise NotImplementedError, "`expect { }.not_to change " \
+            "{ }.#{@relativity}()` is not supported"
         end
 
         # @private
         def description
-          "change #{@change_details.message} #{@relativity.to_s.gsub("_", " ")} #{description_of @expected_delta}"
+          "change #{@change_details.value_representation} " \
+          "#{@relativity.to_s.tr('_', ' ')} #{description_of @expected_delta}"
         end
 
         # @private
@@ -138,6 +163,11 @@ module RSpec
           true
         end
 
+        # @private
+        def supports_value_expectations?
+          false
+        end
+
       private
 
         def failure_reason
@@ -160,21 +190,18 @@ module RSpec
 
         # @private
         def matches?(event_proc)
-          @event_proc = event_proc
-          return false unless Proc === event_proc
-          @change_details.perform_change(event_proc)
-          @change_details.changed? && matches_before? && matches_after?
+          perform_change(event_proc) && @change_details.changed? && @matches_before && matches_after?
         end
 
         # @private
         def description
-          "change #{@change_details.message} #{change_description}"
+          "change #{@change_details.value_representation} #{change_description}"
         end
 
         # @private
         def failure_message
           return not_given_a_block_failure unless Proc === @event_proc
-          return before_value_failure      unless matches_before?
+          return before_value_failure      unless @matches_before
           return did_not_change_failure    unless @change_details.changed?
           after_value_failure
         end
@@ -184,10 +211,24 @@ module RSpec
           true
         end
 
+        # @private
+        def supports_value_expectations?
+          false
+        end
+
       private
 
-        def matches_before?
-          values_match?(@expected_before, @change_details.actual_before)
+        def perform_change(event_proc)
+          @event_proc = event_proc
+          @change_details.perform_change(event_proc) do |actual_before|
+            # pre-compute values derived from the `before` value before the
+            # mutation is applied, in case the specified mutation is mutation
+            # of a single object (rather than a changing what object a method
+            # returns). We need to cache these values before the `before` value
+            # they are based on potentially gets mutated.
+            @matches_before = values_match?(@expected_before, actual_before)
+            @actual_before_description = description_of(actual_before)
+          end
         end
 
         def matches_after?
@@ -195,23 +236,31 @@ module RSpec
         end
 
         def before_value_failure
-          "expected #{@change_details.message} to have initially been #{description_of @expected_before}, but was #{description_of @change_details.actual_before}"
+          "expected #{@change_details.value_representation} " \
+          "to have initially been #{description_of @expected_before}, " \
+          "but was #{@actual_before_description}"
         end
 
         def after_value_failure
-          "expected #{@change_details.message} to have changed to #{description_of @expected_after}, but is now #{description_of @change_details.actual_after}"
+          "expected #{@change_details.value_representation} " \
+          "to have changed to #{description_of @expected_after}, " \
+          "but is now #{description_of @change_details.actual_after}"
         end
 
         def did_not_change_failure
-          "expected #{@change_details.message} to have changed #{change_description}, but did not change"
+          "expected #{@change_details.value_representation} " \
+          "to have changed #{change_description}, but did not change"
         end
 
         def did_change_failure
-          "expected #{@change_details.message} not to have changed, but did change from #{description_of @change_details.actual_before} to #{description_of @change_details.actual_after}"
+          "expected #{@change_details.value_representation} not to have changed, but " \
+          "did change from #{@actual_before_description} " \
+          "to #{description_of @change_details.actual_after}"
         end
 
         def not_given_a_block_failure
-          "expected #{@change_details.message} to have changed #{change_description}, but was not given a block"
+          "expected #{@change_details.value_representation} to have changed " \
+          "#{change_description}, but was not given a block"
         end
       end
 
@@ -235,19 +284,17 @@ module RSpec
         # @private
         def does_not_match?(event_proc)
           if @description_suffix
-            raise NotImplementedError, "`expect { }.not_to change { }.to()` is not supported"
+            raise NotImplementedError, "`expect { }.not_to change { }.to()` " \
+              "is not supported"
           end
 
-          @event_proc = event_proc
-          return false unless Proc === event_proc
-          @change_details.perform_change(event_proc)
-          !@change_details.changed? && matches_before?
+          perform_change(event_proc) && !@change_details.changed? && @matches_before
         end
 
         # @private
         def failure_message_when_negated
           return not_given_a_block_failure unless Proc === @event_proc
-          return before_value_failure unless matches_before?
+          return before_value_failure unless @matches_before
           did_change_failure
         end
 
@@ -277,7 +324,8 @@ module RSpec
 
         # @private
         def does_not_match?(_event_proc)
-          raise NotImplementedError, "`expect { }.not_to change { }.to()` is not supported"
+          raise NotImplementedError, "`expect { }.not_to change { }.to()` " \
+            "is not supported"
         end
 
       private
@@ -289,10 +337,24 @@ module RSpec
 
       # @private
       # Encapsulates the details of the before/after values.
+      #
+      # Note that this class exposes the `actual_after` value, to allow the
+      # matchers above to derive failure messages, etc from the value on demand
+      # as needed, but it intentionally does _not_ expose the `actual_before`
+      # value. Some usages of the `change` matcher mutate a specific object
+      # returned by the value proc, which means that failure message snippets,
+      # etc, which are derived from the `before` value may not be accurate if
+      # they are lazily computed as needed. We must pre-compute them before
+      # applying the change in the `expect` block. To ensure that all `change`
+      # matchers do that properly, we do not expose the `actual_before` value.
+      # Instead, matchers must pass a block to `perform_change`, which yields
+      # the `actual_before` value before applying the change.
       class ChangeDetails
-        attr_reader :message, :actual_before, :actual_after
+        attr_reader :actual_after
 
-        def initialize(receiver=nil, message=nil, &block)
+        UNDEFINED = Module.new.freeze
+
+        def initialize(matcher_name, receiver=nil, message=nil, &block)
           if receiver && !message
             raise(
               ArgumentError,
@@ -301,18 +363,56 @@ module RSpec
               "You passed an object but no message."
             )
           end
-          @message    = message ? "##{message}" : "result"
-          @value_proc = block || lambda { receiver.__send__(message) }
+
+          @matcher_name = matcher_name
+          @receiver = receiver
+          @message = message
+          @value_proc = block
+          # TODO: temporary measure to mute warning of access to an initialized
+          # instance variable when a deprecated implicit block expectation
+          # syntax is used. This may be removed once `fail` is used, and the
+          # matcher never issues this warning.
+          @actual_after = UNDEFINED
+        end
+
+        def value_representation
+          @value_representation ||=
+            if @message
+              "`#{message_notation(@receiver, @message)}`"
+            elsif (value_block_snippet = extract_value_block_snippet)
+              "`#{value_block_snippet}`"
+            else
+              'result'
+            end
         end
 
         def perform_change(event_proc)
           @actual_before = evaluate_value_proc
+          @before_hash = @actual_before.hash
+          yield @actual_before if block_given?
+
+          return false unless Proc === event_proc
           event_proc.call
+
           @actual_after = evaluate_value_proc
+          @actual_hash = @actual_after.hash
+          true
         end
 
         def changed?
-          @actual_before != @actual_after
+          # Consider it changed if either:
+          #
+          # - The before/after values are unequal
+          # - The before/after values have different hash values
+          #
+          # The latter case specifically handles the case when the value proc
+          # returns the exact same object, but it has been mutated.
+          #
+          # Note that it is not sufficient to only check the hashes; it is
+          # possible for two values to be unequal (and of different classes)
+          # but to return the same hash value. Also, some objects may change
+          # their hash after being compared with `==`/`!=`.
+          @actual_before != @actual_after || @before_hash != @actual_hash
         end
 
         def actual_delta
@@ -322,13 +422,26 @@ module RSpec
       private
 
         def evaluate_value_proc
-          case val = @value_proc.call
-          when IO # enumerable, but we don't want to dup it.
-            val
-          when Enumerable, String
-            val.dup
+          @value_proc ? @value_proc.call : @receiver.__send__(@message)
+        end
+
+        def message_notation(receiver, message)
+          case receiver
+          when Module
+            "#{receiver}.#{message}"
           else
-            val
+            "#{Support.class_of(receiver)}##{message}"
+          end
+        end
+
+        if RSpec::Support::RubyFeatures.ripper_supported?
+          def extract_value_block_snippet
+            return nil unless @value_proc
+            Expectations::BlockSnippetExtractor.try_extracting_single_line_body_of(@value_proc, @matcher_name)
+          end
+        else
+          def extract_value_block_snippet
+            nil
           end
         end
       end

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

@@ -5,7 +5,7 @@ module RSpec
       # Base class for `and` and `or` compound matchers.
       class Compound < BaseMatcher
         # @private
-        attr_reader :matcher_1, :matcher_2
+        attr_reader :matcher_1, :matcher_2, :evaluator
 
         def initialize(matcher_1, matcher_2)
           @matcher_1 = matcher_1
@@ -23,19 +23,49 @@ module RSpec
         # @api private
         # @return [String]
         def description
-          singleline_message(matcher_1.description, matcher_2.description)
+          "#{matcher_1.description} #{conjunction} #{matcher_2.description}"
         end
 
+        # @api private
         def supports_block_expectations?
           matcher_supports_block_expectations?(matcher_1) &&
           matcher_supports_block_expectations?(matcher_2)
         end
 
+        # @api private
+        def supports_value_expectations?
+          matcher_supports_value_expectations?(matcher_1) &&
+          matcher_supports_value_expectations?(matcher_2)
+        end
+
+        # @api private
         def expects_call_stack_jump?
           NestedEvaluator.matcher_expects_call_stack_jump?(matcher_1) ||
           NestedEvaluator.matcher_expects_call_stack_jump?(matcher_2)
         end
 
+        # @api private
+        # @return [Boolean]
+        def diffable?
+          matcher_is_diffable?(matcher_1) || matcher_is_diffable?(matcher_2)
+        end
+
+        # @api private
+        # @return [RSpec::Matchers::ExpectedsForMultipleDiffs]
+        def expected
+          return nil unless evaluator
+          ::RSpec::Matchers::ExpectedsForMultipleDiffs.for_many_matchers(diffable_matcher_list)
+        end
+
+      protected
+
+        def diffable_matcher_list
+          list = []
+          list.concat(diffable_matcher_list_for(matcher_1)) unless matcher_1_matches?
+          list.concat(diffable_matcher_list_for(matcher_2)) unless matcher_2_matches?
+          list
+        end
+
       private
 
         def initialize_copy(other)
@@ -61,38 +91,17 @@ module RSpec
         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(' ')
+          "#{indent_multiline_message(matcher_1.failure_message.sub(/\n+\z/, ''))}" \
+          "\n\n...#{conjunction}:" \
+          "\n\n#{indent_multiline_message(matcher_2.failure_message.sub(/\A\n+/, ''))}"
         end
 
         def matcher_1_matches?
-          @evaluator.matcher_matches?(matcher_1)
+          evaluator.matcher_matches?(matcher_1)
         end
 
         def matcher_2_matches?
-          @evaluator.matcher_matches?(matcher_2)
+          evaluator.matcher_matches?(matcher_2)
         end
 
         def matcher_supports_block_expectations?(matcher)
@@ -101,6 +110,24 @@ module RSpec
           false
         end
 
+        def matcher_supports_value_expectations?(matcher)
+          matcher.supports_value_expectations?
+        rescue NoMethodError
+          true
+        end
+
+        def matcher_is_diffable?(matcher)
+          matcher.diffable?
+        rescue NoMethodError
+          false
+        end
+
+        def diffable_matcher_list_for(matcher)
+          return [] unless matcher_is_diffable?(matcher)
+          return matcher.diffable_matcher_list if Compound === matcher
+          [matcher]
+        end
+
         # For value expectations, we can evaluate the matchers sequentially.
         class SequentialEvaluator
           def initialize(actual, *)
@@ -141,7 +168,12 @@ module RSpec
           end
 
           def matcher_matches?(matcher)
-            @match_results.fetch(matcher)
+            @match_results.fetch(matcher) do
+              raise ArgumentError, "Your #{matcher.description} has no match " \
+               "results, this can occur when an unexpected call stack or " \
+               "local jump occurs. Prehaps one of your matchers needs to " \
+               "declare `expects_call_stack_jump?` as `true`?"
+            end
           end
 
         private