rr 1.0.5 → 1.1.0.rc1

data/lib/rr/core_ext/array.rb

@@ -0,0 +1,12 @@
+class Array
+  def wildcard_match?(other)
+    return false unless other.is_a?(Array)
+    each_with_index do |value, i|
+      if value.respond_to?(:wildcard_match?)
+        return false unless value.wildcard_match?(other[i])
+      else
+        return false unless value == other[i]
+      end
+    end
+  end
+end

data/lib/rr/core_ext/enumerable.rb

@@ -0,0 +1,16 @@
+module Enumerable
+  def wildcard_match?(other)
+    if is_a?(String)
+      return RR::Expectations::ArgumentEqualityExpectation.recursive_safe_eq(self, other)
+    end
+    return false unless other.is_a?(Enumerable)
+    other_entries = other.entries
+    each_with_index do |value, i|
+      if value.respond_to?(:wildcard_match?)
+        return false unless value.wildcard_match?(other_entries[i])
+      else
+        return false unless value == other_entries[i]
+      end
+    end
+  end
+end

data/lib/rr/core_ext/hash.rb

@@ -0,0 +1,20 @@
+class Hash
+  def wildcard_match?(other)
+    return false unless other.is_a?(Hash)
+
+    other_keys = other.keys
+    other_values = other.values
+    each_with_index do |(key, value), i|
+      if key.respond_to?(:wildcard_match?)
+        return false unless key.wildcard_match?(other_keys[i])
+      else
+        return false unless key == other_keys[i]
+      end
+      if value.respond_to?(:wildcard_match?)
+        return false unless value.wildcard_match?(other_values[i])
+      else
+        return false unless value == other_values[i]
+      end
+    end
+  end
+end

data/lib/rr/core_ext/range.rb

@@ -0,0 +1,8 @@
+class Range
+  def wildcard_match?(other)
+    self == other ||
+    (other.is_a?(Numeric) && include?(other))
+  end
+
+  alias_method :eql, :==
+end

data/lib/rr/core_ext/regexp.rb

@@ -0,0 +1,8 @@
+class Regexp
+  def wildcard_match?(other)
+    self == other ||
+    !!(other.is_a?(String) && other =~ self)
+  end
+
+  alias_method :eql?, :==
+end

data/lib/rr/double.rb

@@ -106,21 +106,21 @@ module RR
 
     def verify_times_matcher_is_set
       unless definition.times_matcher
-        raise RR::Errors::DoubleDefinitionError, "#definition.times_matcher is not set"
+        raise RR::Errors.build_error(:DoubleDefinitionError, "#definition.times_matcher is not set")
       end
     end
 
     def verify_argument_expectation_is_set
       unless definition.argument_expectation
-        raise RR::Errors::DoubleDefinitionError, "#definition.argument_expectation is not set"
+        raise RR::Errors.build_error(:DoubleDefinitionError, "#definition.argument_expectation is not set")
       end
     end
 
     def verify_method_signature
       unless double_injection.subject_has_original_method?
-        raise RR::Errors::SubjectDoesNotImplementMethodError
+        raise RR::Errors.build_error(:SubjectDoesNotImplementMethodError)
       end
-      raise RR::Errors::SubjectHasDifferentArityError unless arity_matches?
+      raise RR::Errors.build_error(:SubjectHasDifferentArityError) unless arity_matches?
     end
 
     def subject_arity

data/lib/rr/double_definitions/double_definition.rb

@@ -299,17 +299,23 @@ module RR
         end
 
         def exact_match?(*arguments)
-          raise(Errors::DoubleDefinitionError, "#argument_expectation must be defined on #{inspect}") unless @argument_expectation
+          unless @argument_expectation
+            raise RR::Errors.build_error(:DoubleDefinitionError, "#argument_expectation must be defined on #{inspect}")
+          end
           @argument_expectation.exact_match?(*arguments)
         end
 
         def wildcard_match?(*arguments)
-          raise(Errors::DoubleDefinitionError, "#argument_expectation must be defined on #{inspect}") unless @argument_expectation
+          unless @argument_expectation
+            raise RR::Errors.build_error(:DoubleDefinitionError, "#argument_expectation must be defined on #{inspect}")
+          end
           @argument_expectation.wildcard_match?(*arguments)
         end
 
         def terminal?
-          raise(Errors::DoubleDefinitionError, "#argument_expectation must be defined on #{inspect}") unless @times_matcher
+          unless @times_matcher
+            raise RR::Errors.build_error(:DoubleDefinitionError, "#argument_expectation must be defined on #{inspect}")
+          end
           @times_matcher.terminal?
         end
 

data/lib/rr/errors.rb

@@ -0,0 +1,21 @@
+module RR
+  class << self
+    attr_accessor :overridden_error_class
+  end
+
+  module Errors
+    def self.build_error(given_error, message = nil, backtrace = nil)
+      error_class = self.error_class(given_error)
+      error = message ? error_class.new(message) : error_class.new
+      error.backtrace = backtrace if error_class < RR::Errors::RRError
+      error
+    end
+
+    def self.error_class(given_error)
+      RR.overridden_error_class ||
+      (given_error.is_a?(Symbol) ?
+        RR::Errors.const_get(given_error) :
+        given_error)
+    end
+  end
+end

data/lib/rr/expectations/argument_equality_expectation.rb

@@ -1,6 +1,14 @@
 module RR
   module Expectations
     class ArgumentEqualityExpectation #:nodoc:
+      def self.recursive_safe_eq(arg1, arg2)
+        if arg1.respond_to?(:'__rr__original_==')
+          arg1.__send__(:'__rr__original_==', arg2)
+        else
+          arg1 == arg2
+        end
+      end
+
       attr_reader :expected_arguments
 
       def initialize(*expected_arguments)
@@ -10,7 +18,7 @@ module RR
       def exact_match?(*arguments)
         return false unless arguments.length == expected_arguments.length
         arguments.each_with_index do |arg, index|
-          return false unless equality_match(expected_arguments[index], arg)
+          return false unless self.class.recursive_safe_eq(expected_arguments[index], arg)
         end
         true
       end
@@ -22,7 +30,7 @@ module RR
           if expected_argument.respond_to?(:wildcard_match?)
             return false unless expected_argument.wildcard_match?(arg)
           else
-            return false unless equality_match(expected_argument, arg)
+            return false unless self.class.recursive_safe_eq(expected_argument, arg)
           end
         end
         true
@@ -31,11 +39,6 @@ module RR
       def ==(other)
         expected_arguments == other.expected_arguments
       end
-
-    protected
-      def equality_match(arg1, arg2)
-        arg1.respond_to?(:'__rr__original_==') ? arg1.__send__(:'__rr__original_==', arg2) : arg1 == arg2
-      end
     end
   end
 end

data/lib/rr/expectations/times_called_expectation.rb

@@ -26,13 +26,7 @@ module RR
 
       def verify!
         unless verify
-          if @verify_backtrace
-            error = Errors::TimesCalledError.new(error_message)
-            error.backtrace = @verify_backtrace
-            raise error
-          else
-            raise Errors::TimesCalledError, error_message
-          end
+          raise RR::Errors.build_error(:TimesCalledError, error_message, @verify_backtrace)
         end
       end
 
@@ -46,7 +40,7 @@ module RR
       end
 
       def verify_input_error
-        raise Errors::TimesCalledError, error_message
+        raise RR::Errors.build_error(:TimesCalledError, error_message)
       end
 
       def error_message

data/lib/rr/injections/double_injection.rb

@@ -145,7 +145,7 @@ module RR
           def #{method_name}(*args, &block)
             arguments = MethodArguments.new(args, block)
             obj = ::RR::Injections::DoubleInjection::BoundObjects[#{id}]
-            RR::Injections::DoubleInjection.dispatch_method(self, obj, :#{method_name}, arguments.arguments, arguments.block)
+            ::RR::Injections::DoubleInjection.dispatch_method(self, obj, :#{method_name}, arguments.arguments, arguments.block)
           end
         RUBY
         self

data/lib/rr/method_dispatches/base_method_dispatch.rb

@@ -73,7 +73,7 @@ module RR
           "  #{Double.formatted_name(method_name, args)}\n" <<
           "expected invocations:\n" <<
           Double.list_message_part(doubles)
-        raise Errors::DoubleNotFoundError, message
+        raise RR::Errors.build_error(:DoubleNotFoundError, message)
       end
 
       def_delegators :definition, :after_call_proc

data/lib/rr/recorded_calls.rb

@@ -6,26 +6,26 @@ module RR
       @recorded_calls = recorded_calls
       @ordered_index = 0
     end
-  
+
     attr_reader :recorded_calls
-  
+
     def clear
       self.ordered_index = 0
       recorded_calls.clear
     end
-  
+
     def <<(recorded_call)
       recorded_calls << recorded_call
     end
-  
+
     def any?(&block)
       recorded_calls.any?(&block)
     end
-  
+
     def ==(other)
       recorded_calls == other.recorded_calls
     end
-  
+
     def match_error(spy_verification)
       double_injection_exists_error(spy_verification) || begin
         if spy_verification.ordered?
@@ -35,20 +35,20 @@ module RR
         end
       end
     end
-  
+
   protected
     attr_accessor :ordered_index
 
     def double_injection_exists_error(spy_verification)
       unless Injections::DoubleInjection.exists_by_subject?(spy_verification.subject, spy_verification.method_name)
-        RR::Errors::SpyVerificationErrors::DoubleInjectionNotFoundError.new(
+        RR::Errors.build_error(RR::Errors::SpyVerificationErrors::DoubleInjectionNotFoundError,
           "A Double Injection for the subject and method call:\n" <<
           "#{spy_verification.subject.inspect}\n" <<
           "#{spy_verification.method_name}\ndoes not exist in:\n" <<
           "\t#{recorded_calls.map {|call| call.inspect}.join("\n\t")}"
         )
       end
-    end    
+    end
 
     def ordered_match_error(spy_verification)
       memoized_matching_recorded_calls = matching_recorded_calls(spy_verification)
@@ -63,7 +63,7 @@ module RR
 
     def unordered_match_error(spy_verification)
       memoized_matching_recorded_calls = matching_recorded_calls(spy_verification)
-      
+
       spy_verification.times_matcher.matches?(
         memoized_matching_recorded_calls.size
       ) ? nil : invocation_count_error(spy_verification, memoized_matching_recorded_calls)
@@ -90,7 +90,7 @@ module RR
     end
 
     def invocation_count_error(spy_verification, matching_recorded_calls)
-      RR::Errors::SpyVerificationErrors::InvocationCountError.new(
+      RR::Errors.build_error(RR::Errors::SpyVerificationErrors::InvocationCountError,
         "On subject #{spy_verification.subject.inspect}\n" <<
         "Expected #{Double.formatted_name(spy_verification.method_name, spy_verification.argument_expectation.expected_arguments)}\n" <<
         "to be called #{spy_verification.times_matcher.expected_times_message},\n" <<
@@ -100,4 +100,4 @@ module RR
       )
     end
   end
-end
+end

data/lib/rr/space.rb

@@ -37,14 +37,14 @@ module RR
     # in the correct position.
     def verify_ordered_double(double)
       unless double.terminal?
-        raise Errors::DoubleOrderError,
-              "Ordered Doubles cannot have a NonTerminal TimesCalledExpectation"
+        raise RR::Errors.build_error(:DoubleOrderError,
+          "Ordered Doubles cannot have a NonTerminal TimesCalledExpectation")
       end
       unless @ordered_doubles.first == double
         message = Double.formatted_name(double.method_name, double.expected_arguments)
         message << " called out of order in list\n"
         message << Double.list_message_part(@ordered_doubles)
-        raise Errors::DoubleOrderError, message
+        raise RR::Errors.build_error(:DoubleOrderError, message)
       end
       @ordered_doubles.shift unless double.attempt?
       double
@@ -59,6 +59,8 @@ module RR
 
     # Resets the registered Doubles and ordered Doubles
     def reset
+      RR.trim_backtrace = false
+      RR.overridden_error_class = nil
       reset_ordered_doubles
       Injections::DoubleInjection.reset
       reset_method_missing_injections

data/lib/rr/times_called_matchers/never_matcher.rb

@@ -16,8 +16,8 @@ module RR
       end
 
       def attempt?(times_called)
-        raise RR::Errors::TimesCalledError, error_message(1)
+        raise RR::Errors.build_error(:TimesCalledError, error_message(1))
       end
     end
   end
-end
+end

data/lib/rr/wildcard_matchers/anything.rb

@@ -8,11 +8,11 @@ module RR
       def ==(other)
         other.is_a?(self.class)
       end
-      alias_method :eql?, :==
+      alias :eql? :==
 
       def inspect
         'anything'
       end
     end
   end
-end
+end

data/lib/rr/wildcard_matchers/boolean.rb

@@ -2,22 +2,18 @@ module RR
   module WildcardMatchers
     class Boolean
       def wildcard_match?(other)
-        self == other || is_a_boolean?(other)
+        self == other ||
+        other.equal?(true) || other.equal?(false)
       end
 
       def ==(other)
         other.is_a?(self.class)
       end
-      alias_method :eql?, :==
+      alias :eql? :==
 
       def inspect
         'boolean'
       end
-
-    protected
-      def is_a_boolean?(subject)
-        subject.is_a?(TrueClass) || subject.is_a?(FalseClass)
-      end
     end
   end
 end

data/lib/rr/wildcard_matchers/duck_type.rb

@@ -8,25 +8,21 @@ module RR
       end
 
       def wildcard_match?(other)
-        return true if self == other
-        required_methods.each do |m|
-          return false unless other.respond_to?(m)
-        end
-        return true
+        self == other ||
+        required_methods.all? {|m| other.respond_to?(m) }
       end
 
-      def inspect
-        formatted_required_methods = required_methods.collect do |method_name|
-          method_name.inspect
-        end.join(', ')
-        "duck_type(#{formatted_required_methods})"
+      def ==(other)
+        other.is_a?(self.class) &&
+        other.required_methods == self.required_methods
       end
+      alias :eql? :==
 
-      def ==(other)
-        return false unless other.is_a?(self.class)
-        self.required_methods == other.required_methods
+      def inspect
+        formatted_required_methods =
+          required_methods.map { |method_name| method_name.inspect }.join(', ')
+        "duck_type(#{formatted_required_methods})"
       end
-      alias_method :eql?, :==
     end
   end
-end
+end

data/lib/rr/wildcard_matchers/hash_including.rb

@@ -4,26 +4,27 @@ module RR
       attr_reader :expected_hash
 
       def initialize(expected_hash)
-        @expected_hash = expected_hash.clone
+        @expected_hash = expected_hash.dup
       end
 
       def wildcard_match?(other)
-        return true if self == other
-        expected_hash.each_pair do |key, value|
-          return false unless other.has_key?(key) && other[key] == expected_hash[key]
-        end
-        return true
+        self == other || (
+          other.is_a?(Hash) &&
+          expected_hash.all? { |k, v|
+            other.key?(k) && other[k] == expected_hash[k]
+          }
+        )
       end
 
-      def inspect
-        "hash_including(#{expected_hash.inspect})"
+      def ==(other)
+        other.is_a?(self.class) &&
+        other.expected_hash == self.expected_hash
       end
+      alias :eql? :==
 
-      def ==(other)
-        return false unless other.is_a?(self.class)
-        self.expected_hash == other.expected_hash
+      def inspect
+        "hash_including(#{expected_hash.inspect})"
       end
-      alias_method :eql?, :==
     end
   end
-end
+end