rspec-expectations 2.13.0 → 3.0.0

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

@@ -1,131 +1,332 @@
 module RSpec
   module Matchers
     module BuiltIn
+      # @api private
+      # Provides the implementation for `change`.
+      # Not intended to be instantiated directly.
       class Change
-        def initialize(receiver=nil, message=nil, &block)
-          @message = message
-          @value_proc = block || lambda {receiver.__send__(message)}
-          @expected_after = @expected_before = @minimum = @maximum = @expected_delta = nil
-          @eval_before = @eval_after = false
+        include Composable
+
+        # @api public
+        # Specifies the delta of the expected change.
+        def by(expected_delta)
+          ChangeRelatively.new(@change_details, expected_delta, :by) do |actual_delta|
+            values_match?(expected_delta, actual_delta)
+          end
+        end
+
+        # @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|
+            actual_delta >= minimum
+          end
+        end
+
+        # @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|
+            actual_delta <= maximum
+          end
+        end
+
+        # @api public
+        # Specifies the new value you expect.
+        def to(value)
+          ChangeToValue.new(@change_details, value)
+        end
+
+        # @api public
+        # Specifies the original value.
+        def from(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?
+        end
 
-          @actual_before = evaluate_value_proc
-          event_proc.call
-          @actual_after = evaluate_value_proc
+        def does_not_match?(event_proc)
+          raise_block_syntax_error if block_given?
+          !matches?(event_proc) && Proc === event_proc
+        end
 
-          (!change_expected? || changed?) && matches_before? && matches_after? && matches_expected_delta? && matches_min? && matches_max?
+        # @api private
+        # @return [String]
+        def failure_message
+          "expected #{@change_details.message} to have changed, but #{positive_failure_reason}"
         end
-        alias == matches?
 
-        def raise_block_syntax_error
-          raise SyntaxError.new(<<-MESSAGE)
-block passed to should or should_not change must use {} instead of do/end
-MESSAGE
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          "expected #{@change_details.message} not to have changed, but #{negative_failure_reason}"
         end
 
-        def evaluate_value_proc
-          case val = @value_proc.call
-          when Enumerable, String
-            val.dup
-          else
-            val
-          end
+        # @api private
+        # @return [String]
+        def description
+          "change #{@change_details.message}"
         end
 
-        def failure_message_for_should
-          if @eval_before && !expected_matches_actual?(@expected_before, @actual_before)
-            "#{message} should have initially been #{@expected_before.inspect}, but was #{@actual_before.inspect}"
-          elsif @eval_after && !expected_matches_actual?(@expected_after, @actual_after)
-            "#{message} should have been changed to #{@expected_after.inspect}, but is now #{@actual_after.inspect}"
-          elsif @expected_delta
-            "#{message} should have been changed by #{@expected_delta.inspect}, but was changed by #{actual_delta.inspect}"
-          elsif @minimum
-            "#{message} should have been changed by at least #{@minimum.inspect}, but was changed by #{actual_delta.inspect}"
-          elsif @maximum
-            "#{message} should have been changed by at most #{@maximum.inspect}, but was changed by #{actual_delta.inspect}"
-          else
-            "#{message} should have changed, but is still #{@actual_before.inspect}"
-          end
+        # @private
+        def supports_block_expectations?
+          true
         end
 
-        def actual_delta
-          @actual_after - @actual_before
+      private
+
+        def initialize(receiver=nil, message=nil, &block)
+          @change_details = ChangeDetails.new(receiver, message, &block)
         end
 
-        def failure_message_for_should_not
-          "#{message} should not have changed, but did change from #{@actual_before.inspect} to #{@actual_after.inspect}"
+        def raise_block_syntax_error
+          raise SyntaxError,
+            "The block passed to the `change` matcher must use `{ ... }` instead of do/end"
         end
 
-        def by(expected_delta)
-          @expected_delta = expected_delta
-          self
+        def positive_failure_reason
+          return "was not given a block" unless Proc === @event_proc
+          "is still #{description_of @change_details.actual_before}"
         end
 
-        def by_at_least(minimum)
-          @minimum = minimum
-          self
+        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}"
         end
+      end
 
-        def by_at_most(maximum)
-          @maximum = maximum
-          self
+      # Used to specify a relative change.
+      # @api private
+      class ChangeRelatively
+        include Composable
+
+        def initialize(change_details, expected_delta, relativity, &comparer)
+          @change_details = change_details
+          @expected_delta = expected_delta
+          @relativity     = relativity
+          @comparer       = comparer
         end
 
-        def to(to)
-          @eval_after = true
-          @expected_after = to
-          self
+        # @private
+        def failure_message
+          "expected #{@change_details.message} to have changed #{@relativity.to_s.gsub("_", " ")} #{description_of @expected_delta}, but #{failure_reason}"
         end
 
-        def from (before)
-          @eval_before = true
-          @expected_before = before
-          self
+        # @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)
+        end
+
+        # @private
+        def does_not_match?(event_proc)
+          raise NotImplementedError, "`expect { }.not_to change { }.#{@relativity}()` is not supported"
         end
 
+        # @private
         def description
-          "change ##{message}"
+          "change #{@change_details.message} #{@relativity.to_s.gsub("_", " ")} #{description_of @expected_delta}"
+        end
+
+        # @private
+        def supports_block_expectations?
+          true
         end
 
-        private
+      private
 
-        def message
-          @message || "result"
+        def failure_reason
+          return "was not given a block" unless Proc === @event_proc
+          "was changed by #{description_of @change_details.actual_delta}"
         end
+      end
 
-        def change_expected?
-          @expected_delta != 0
+      # @api private
+      # Base class for specifying a change from and/or to specific values.
+      class SpecificValuesChange
+        include Composable
+        # @private
+        MATCH_ANYTHING = ::Object.ancestors.last
+
+        def initialize(change_details, from, to)
+          @change_details  = change_details
+          @expected_before = from
+          @expected_after  = to
         end
 
-        def changed?
-          @actual_before != @actual_after
+        # @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?
+        end
+
+        # @private
+        def description
+          "change #{@change_details.message} #{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 did_not_change_failure    unless @change_details.changed?
+          after_value_failure
+        end
+
+        # @private
+        def supports_block_expectations?
+          true
+        end
+
+      private
+
         def matches_before?
-          @eval_before ? expected_matches_actual?(@expected_before, @actual_before) : true
+          values_match?(@expected_before, @change_details.actual_before)
         end
 
         def matches_after?
-          @eval_after ? expected_matches_actual?(@expected_after, @actual_after) : true
+          values_match?(@expected_after, @change_details.actual_after)
+        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}"
+        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}"
+        end
+
+        def did_not_change_failure
+          "expected #{@change_details.message} 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}"
+        end
+
+        def not_given_a_block_failure
+          "expected #{@change_details.message} to have changed #{change_description}, but was not given a block"
+        end
+      end
+
+      # @api private
+      # Used to specify a change from a specific value
+      # (and, optionally, to a specific value).
+      class ChangeFromValue < SpecificValuesChange
+        def initialize(change_details, expected_before)
+          @description_suffix = nil
+          super(change_details, expected_before, MATCH_ANYTHING)
+        end
+
+        # @api public
+        # Specifies the new value you expect.
+        def to(value)
+          @expected_after     = value
+          @description_suffix = " to #{description_of value}"
+          self
+        end
+
+        # @private
+        def does_not_match?(event_proc)
+          if @description_suffix
+            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?
+        end
+
+        # @private
+        def failure_message_when_negated
+          return not_given_a_block_failure unless Proc === @event_proc
+          return before_value_failure unless matches_before?
+          did_change_failure
+        end
+
+      private
+
+        def change_description
+          "from #{description_of @expected_before}#{@description_suffix}"
+        end
+      end
+
+      # @api private
+      # Used to specify a change to a specific value
+      # (and, optionally, from a specific value).
+      class ChangeToValue < SpecificValuesChange
+        def initialize(change_details, expected_after)
+          @description_suffix = nil
+          super(change_details, MATCH_ANYTHING, expected_after)
+        end
+
+        # @api public
+        # Specifies the original value.
+        def from(value)
+          @expected_before    = value
+          @description_suffix = " from #{description_of value}"
+          self
+        end
+
+        # @private
+        def does_not_match?(event_proc)
+          raise NotImplementedError, "`expect { }.not_to change { }.to()` is not supported"
         end
 
-        def matches_expected_delta?
-          @expected_delta ? (@actual_before + @expected_delta == @actual_after) : true
+      private
+
+        def change_description
+          "to #{description_of @expected_after}#{@description_suffix}"
         end
+      end
+
+      # @private
+      # Encapsulates the details of the before/after values.
+      class ChangeDetails
+        attr_reader :message, :actual_before, :actual_after
 
-        def matches_min?
-          @minimum ? (@actual_after - @actual_before >= @minimum) : true
+        def initialize(receiver=nil, message=nil, &block)
+          @message    = message ? "##{message}" : "result"
+          @value_proc = block || lambda { receiver.__send__(message) }
         end
 
-        def matches_max?
-          @maximum ? (@actual_after - @actual_before <= @maximum) : true
+        def perform_change(event_proc)
+          @actual_before = evaluate_value_proc
+          event_proc.call
+          @actual_after = evaluate_value_proc
         end
 
-        def expected_matches_actual?(expected, actual)
-          expected === actual
+        def changed?
+          @actual_before != @actual_after
+        end
+
+        def actual_delta
+          @actual_after - @actual_before
+        end
+
+      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
+          else
+            val
+          end
         end
       end
     end

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

@@ -0,0 +1,122 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Base class for `and` and `or` compound matchers.
+      class Compound < BaseMatcher
+        # @private
+        attr_reader :matcher_1, :matcher_2
+
+        def initialize(matcher_1, matcher_2)
+          @matcher_1 = matcher_1
+          @matcher_2 = matcher_2
+        end
+
+        # @private
+        def does_not_match?(actual)
+          raise NotImplementedError,
+            "`expect(...).not_to matcher.#{conjunction} matcher` is not supported"
+        end
+
+        # @api private
+        # @return [String]
+        def description
+          singleline_message(matcher_1.description, matcher_2.description)
+        end
+
+      private
+
+        def initialize_copy(other)
+          @matcher_1 = @matcher_1.clone
+          @matcher_2 = @matcher_2.clone
+          super
+        end
+
+        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
+
+        # @api public
+        # Matcher used to represent a compound `and` expectation.
+        class And < self
+
+          # @api private
+          # @return [String]
+          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
+
+        # @api public
+        # Matcher used to represent a compound `or` expectation.
+        class Or < self
+
+          # @api private
+          # @return [String]
+          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
+