rspec-expectations 3.0.0.beta1 → 3.0.0.beta2

data/lib/rspec/matchers/aliased_matcher.rb

@@ -0,0 +1,35 @@
+module RSpec
+  module Matchers
+    # Decorator that wraps a matcher and overrides `description`
+    # using the provided block in order to support an alias
+    # of a matcher. This is intended for use when composing
+    # matchers, so that you can use an expression like
+    # `include( a_value_within(0.1).of(3) )` rather than
+    # `include( be_within(0.1).of(3) )`, and have the corresponding
+    # description read naturally.
+    #
+    # @api private
+    class AliasedMatcher < MatcherDelegator
+      def initialize(base_matcher, description_block)
+        @description_block = description_block
+        super(base_matcher)
+      end
+
+      # Forward messages on to the wrapped matcher.
+      # Since many matchers provide a fluent interface
+      # (e.g. `a_value_within(0.1).of(3)`), we need to wrap
+      # the returned value if it responds to `description`,
+      # so that our override can be applied when it is eventually
+      # used.
+      def method_missing(*)
+        return_val = super
+        return return_val unless return_val.respond_to?(:description)
+        AliasedMatcher.new(return_val, @description_block)
+      end
+
+      def description
+        @description_block.call(super)
+      end
+    end
+  end
+end

data/lib/rspec/matchers/built_in.rb

@@ -1,39 +1,43 @@
+require 'rspec/matchers/built_in/base_matcher'
+
 module RSpec
   module Matchers
     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 :BeTruthy,         'rspec/matchers/built_in/be'
-      autoload :BeFalsey,        '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 :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/built_in/base_matcher.rb

@@ -13,11 +13,14 @@ module RSpec
       # class. If/when this changes, we will announce it and remove this warning.
       class BaseMatcher
         include RSpec::Matchers::Pretty
+        include RSpec::Matchers::Composable
+
+        UNDEFINED = Object.new.freeze
 
         attr_reader :actual, :expected, :rescued_exception
 
-        def initialize(expected = nil)
-          @expected = expected
+        def initialize(expected = UNDEFINED)
+          @expected = expected unless UNDEFINED.equal?(expected)
         end
 
         def matches?(actual)
@@ -35,32 +38,39 @@ module RSpec
           end
         end
 
-        def failure_message_for_should
-          assert_ivars :@actual, :@expected
-          "expected #{@actual.inspect} to #{name_to_sentence}#{expected_to_sentence}"
+        def failure_message
+          assert_ivars :@actual
+          "expected #{@actual.inspect} to #{description}"
         end
 
-        def failure_message_for_should_not
-          assert_ivars :@actual, :@expected
-          "expected #{@actual.inspect} not to #{name_to_sentence}#{expected_to_sentence}"
+        def failure_message_when_negated
+          assert_ivars :@actual
+          "expected #{@actual.inspect} not to #{description}"
         end
 
         def description
-          expected ? "#{name_to_sentence} #{@expected.inspect}" : name_to_sentence
+          return name_to_sentence unless defined?(@expected)
+          "#{name_to_sentence}#{to_sentence @expected}"
         end
 
         def diffable?
           false
         end
 
-        def ==(other)
-          matches?(other)
-        end
+      private
 
-        private
+        def assert_ivars(*expected_ivars)
+          if (expected_ivars - present_ivars).any?
+            raise "#{self.class.name} needs to supply#{to_sentence expected_ivars}"
+          end
+        end
 
-        def assert_ivars *ivars
-          raise "#{self.class.name} needs to supply #{to_sentence ivars}" unless ivars.all? { |v| instance_variables.map(&:intern).include? v }
+        if RUBY_VERSION.to_f < 1.9
+          def present_ivars
+            instance_variables.map { |v| v.to_sym }
+          end
+        else
+          alias present_ivars instance_variables
         end
       end
     end

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

@@ -8,11 +8,11 @@ module RSpec
           !!actual
         end
 
-        def failure_message_for_should
+        def failure_message
           "expected: truthy value\n     got: #{actual.inspect}"
         end
 
-        def failure_message_for_should_not
+        def failure_message_when_negated
           "expected: falsey value\n     got: #{actual.inspect}"
         end
       end
@@ -22,11 +22,11 @@ module RSpec
           !actual
         end
 
-        def failure_message_for_should
+        def failure_message
           "expected: falsey value\n     got: #{actual.inspect}"
         end
 
-        def failure_message_for_should_not
+        def failure_message_when_negated
           "expected: truthy value\n     got: #{actual.inspect}"
         end
       end
@@ -36,11 +36,11 @@ module RSpec
           actual.nil?
         end
 
-        def failure_message_for_should
+        def failure_message
           "expected: nil\n     got: #{actual.inspect}"
         end
 
-        def failure_message_for_should_not
+        def failure_message_when_negated
           "expected: not nil\n     got: nil"
         end
       end
@@ -80,11 +80,11 @@ module RSpec
           !!actual
         end
 
-        def failure_message_for_should
+        def failure_message
           "expected #{@actual.inspect} to evaluate to true"
         end
 
-        def failure_message_for_should_not
+        def failure_message_when_negated
           "expected #{@actual.inspect} to evaluate to false"
         end
 
@@ -95,10 +95,12 @@ module RSpec
         end
       end
 
-      class BeComparedTo < Be
+      class BeComparedTo < BaseMatcher
+        include BeHelpers
+
         def initialize(operand, operator)
           @expected, @operator = operand, operator
-            @args = []
+          @args = []
         end
 
         def matches?(actual)
@@ -106,28 +108,22 @@ module RSpec
           @actual.__send__ @operator, @expected
         end
 
-        def failure_message_for_should
+        def failure_message
           "expected: #{@operator} #{@expected.inspect}\n     got: #{@operator.to_s.gsub(/./, ' ')} #{@actual.inspect}"
         end
 
-        def failure_message_for_should_not
-          message = <<-MESSAGE
-`#{negative_expectation_expression}` not only FAILED,
-it is a bit confusing.
-          MESSAGE
-
-          raise message << ([:===,:==].include?(@operator) ?
-                            "It might be more clearly expressed without the \"be\"?" :
-                            "It might be more clearly expressed in the positive?")
+        def failure_message_when_negated
+          message = "`expect(#{@actual.inspect}).not_to be #{@operator} #{@expected.inspect}`"
+          if [:<, :>, :<=, :>=].include?(@operator)
+            message + " not only FAILED, it is a bit confusing."
+          else
+            message
+          end
         end
 
         def description
           "be #{@operator} #{expected_to_sentence}#{args_to_sentence}"
         end
-
-        def negative_expectation_expression
-          Expectations::Syntax.negative_expression("actual", "be #{@operator} #{@expected}")
-        end
       end
 
       class BePredicate < BaseMatcher
@@ -149,7 +145,6 @@ it is a bit confusing.
           begin
             return @result = actual.__send__(predicate, *@args, &@block)
           rescue NameError => predicate_missing_error
-            "this needs to be here or rcov will not count this branch even though it's executed in a code example"
           end
 
           begin
@@ -159,13 +154,11 @@ it is a bit confusing.
           end
         end
 
-        alias === matches?
-
-        def failure_message_for_should
+        def failure_message
           "expected #{predicate}#{args_to_s} to return true, got #{@result.inspect}"
         end
 
-        def failure_message_for_should_not
+        def failure_message_when_negated
           "expected #{predicate}#{args_to_s} to return false, got #{@result.inspect}"
         end
 
@@ -200,8 +193,7 @@ it is a bit confusing.
         end
 
         def prefix_and_expected(symbol)
-          symbol.to_s =~ /^(be_(an?_)?)(.*)/
-          return $1, $3
+          Matchers::BE_PREDICATE_REGEX.match(symbol.to_s).captures.compact
         end
 
         def prefix_to_sentence

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

@@ -0,0 +1,55 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class BeBetween < BaseMatcher
+        def initialize(min, max)
+          @min, @max = min, max
+          inclusive
+        end
+
+        def inclusive
+          @less_than_operator = :<=
+          @greater_than_operator = :>=
+          @mode = :inclusive
+          self
+        end
+
+        def exclusive
+          @less_than_operator = :<
+          @greater_than_operator = :>
+          @mode = :exclusive
+          self
+        end
+
+        def matches?(actual)
+          @actual = actual
+          comparable? && compare
+        rescue ArgumentError
+          false
+        end
+
+        def failure_message
+          "#{super}#{not_comparable_clause}"
+        end
+
+        def description
+          "be between #{@min.inspect} and #{@max.inspect} (#{@mode})"
+        end
+
+      private
+
+        def comparable?
+          @actual.respond_to?(@less_than_operator) && @actual.respond_to?(@greater_than_operator)
+        end
+
+        def not_comparable_clause
+          ", but it does not respond to `#{@less_than_operator}` and `#{@greater_than_operator}`" unless comparable?
+        end
+
+        def compare
+          @actual.__send__(@greater_than_operator, @min) && @actual.__send__(@less_than_operator, @max)
+        end
+      end
+    end
+  end
+end

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

@@ -2,17 +2,17 @@ module RSpec
   module Matchers
     module BuiltIn
       class BeWithin
+        include Composable
+
         def initialize(delta)
           @delta = delta
         end
 
         def matches?(actual)
           @actual = actual
-          raise needs_expected     unless defined? @expected
-          raise needs_subtractable unless @actual.respond_to? :-
-          (@actual - @expected).abs <= @tolerance
+          raise needs_expected unless defined? @expected
+          numeric? && (@actual - @expected).abs <= @tolerance
         end
-        alias == matches?
 
         def of(expected)
           @expected  = expected
@@ -28,27 +28,31 @@ module RSpec
           self
         end
 
-        def failure_message_for_should
-          "expected #{@actual} to #{description}"
+        def failure_message
+          "expected #{@actual.inspect} to #{description}#{not_numeric_clause}"
         end
 
-        def failure_message_for_should_not
-          "expected #{@actual} not to #{description}"
+        def failure_message_when_negated
+          "expected #{@actual.inspect} not to #{description}"
         end
 
         def description
           "be within #{@delta}#{@unit} of #{@expected}"
         end
 
-        private
+      private
 
-        def needs_subtractable
-          ArgumentError.new "The actual value (#{@actual.inspect}) must respond to `-`"
+        def numeric?
+          @actual.respond_to?(:-)
         end
 
         def needs_expected
           ArgumentError.new "You must set an expected value using #of: be_within(#{@delta}).of(expected_value)"
         end
+
+        def not_numeric_clause
+          ", but it could not be treated as a numeric value" unless numeric?
+        end
       end
     end
   end

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

@@ -1,139 +1,256 @@
 module RSpec
   module Matchers
     module BuiltIn
+      # Describes an expected mutation.
       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
+
+        # 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
+
+        # 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
+
+        # 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
+
+        # Specifies the new value you expect.
+        def to(value)
+          ChangeToValue.new(@change_details, value)
         end
 
+        # Specifies the original value.
+        def from(value)
+          ChangeFromValue.new(@change_details, value)
+        end
+
+        # @api private
         def matches?(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
+        # @api private
+        def failure_message
+          "expected #{@change_details.message} to have changed, but is still #{description_of @change_details.actual_before}"
+        end
 
-          (!change_expected? || changed?) && matches_before? && matches_after? && matches_expected_delta? && matches_min? && matches_max?
+        # @api private
+        def failure_message_when_negated
+          "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
-        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
+        def description
+          "change #{@change_details.message}"
         end
 
-        def evaluate_value_proc
-          case val = @value_proc.call
-          when Enumerable, String
-            val.dup
-          else
-            val
-          end
+      private
+
+        def initialize(receiver=nil, message=nil, &block)
+          @change_details = ChangeDetails.new(receiver, message, &block)
         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 #{failure_message_for_expected_after}, 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
+        def raise_block_syntax_error
+          raise SyntaxError,
+            "The block passed to the `change` matcher must use `{ ... }` instead of do/end"
         end
+      end
 
-        def actual_delta
-          @actual_after - @actual_before
+      # 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 failure_message_for_should_not
-          "#{message} should not have changed, but did change from #{@actual_before.inspect} to #{@actual_after.inspect}"
+        def failure_message
+          "expected #{@change_details.message} to have changed #{@relativity.to_s.gsub("_", " ")} #{description_of @expected_delta}, " +
+          "but was changed by #{description_of @change_details.actual_delta}"
         end
 
-        def by(expected_delta)
-          @expected_delta = expected_delta
-          self
+        def matches?(event_proc)
+          @change_details.perform_change(event_proc)
+          @comparer.call(@change_details.actual_delta)
         end
 
-        def by_at_least(minimum)
-          @minimum = minimum
-          self
+        def does_not_match?(event_proc)
+          raise NotImplementedError, "`expect { }.not_to change { }.#{@relativity}()` is not supported"
         end
 
-        def by_at_most(maximum)
-          @maximum = maximum
-          self
+        # @api private
+        def description
+          "change #{@change_details.message} #{@relativity.to_s.gsub("_", " ")} #{description_of @expected_delta}"
         end
+      end
 
-        def to(to)
-          @eval_after = true
-          @expected_after = to
-          self
+      # Base class for specifying a change from and/or to specific values.
+      # @api private
+      class SpecificValuesChange
+        include Composable
+        MATCH_ANYTHING = ::Object.ancestors.last
+
+        def initialize(change_details, from, to)
+          @change_details  = change_details
+          @expected_before = from
+          @expected_after  = to
         end
 
-        def from (before)
-          @eval_before = true
-          @expected_before = before
-          self
+        def matches?(event_proc)
+          @change_details.perform_change(event_proc)
+          @change_details.changed? && matches_before? && matches_after?
         end
 
         def description
-          "change ##{message}"
+          "change #{@change_details.message} #{change_description}"
         end
 
-        private
+        def failure_message
+          return before_value_failure   unless matches_before?
+          return did_not_change_failure unless @change_details.changed?
+          after_value_failure
+        end
 
-        def failure_message_for_expected_after
-          if RSpec::Matchers.is_a_matcher?(@expected_after)
-            @expected_after.description
-          else
-            @expected_after.inspect
+      private
+
+        def matches_before?
+          values_match?(@expected_before, @change_details.actual_before)
+        end
+
+        def matches_after?
+          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
+      end
+
+      # Used to specify a change from a specific value
+      # (and, optionally, to a specific value).
+      # @api private
+      class ChangeFromValue < SpecificValuesChange
+        def initialize(change_details, expected_before)
+          @description_suffix = nil
+          super(change_details, expected_before, MATCH_ANYTHING)
+        end
+
+        def to(value)
+          @expected_after     = value
+          @description_suffix = " to #{description_of value}"
+          self
+        end
+
+        def does_not_match?(event_proc)
+          if @description_suffix
+            raise NotImplementedError, "`expect { }.not_to change { }.to()` is not supported"
           end
+
+          @change_details.perform_change(event_proc)
+          !@change_details.changed? && matches_before?
         end
 
-        def message
-          @message || "result"
+        def failure_message_when_negated
+          return before_value_failure unless matches_before?
+          did_change_failure
         end
 
-        def change_expected?
-          @expected_delta != 0
+      private
+
+        def change_description
+          "from #{description_of @expected_before}#{@description_suffix}"
         end
+      end
 
-        def changed?
-          @actual_before != @actual_after
+      # Used to specify a change to a specific value
+      # (and, optionally, from a specific value).
+      # @api private
+      class ChangeToValue < SpecificValuesChange
+        def initialize(change_details, expected_after)
+          @description_suffix = nil
+          super(change_details, MATCH_ANYTHING, expected_after)
         end
 
-        def matches_before?
-          @eval_before ? expected_matches_actual?(@expected_before, @actual_before) : true
+        def from(value)
+          @expected_before    = value
+          @description_suffix = " from #{description_of value}"
+          self
         end
 
-        def matches_after?
-          @eval_after ? expected_matches_actual?(@expected_after, @actual_after) : true
+        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
+
+      # Encapsulates the details of the before/after values.
+      # @api private
+      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 || actual == expected
+        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 Enumerable, String
+            val.dup
+          else
+            val
+          end
         end
       end
     end