redinger-rr 0.10.3

data/lib/rr/double_injection.rb

@@ -0,0 +1,180 @@
+module RR
+  # RR::DoubleInjection is the binding of an subject and a method.
+  # A double_injection has 0 to many Double objects. Each Double
+  # has Argument Expectations and Times called Expectations.
+  class DoubleInjection
+    include Space::Reader
+
+    MethodArguments = Struct.new(:arguments, :block)
+    attr_reader :subject, :method_name, :doubles, :subject_class
+
+    def initialize(subject, method_name, subject_class)
+      @subject = subject
+      @subject_class = subject_class
+      @method_name = method_name.to_sym
+      @doubles = []
+    end
+
+    # RR::DoubleInjection#register_double adds the passed in Double
+    # into this DoubleInjection's list of Double objects.
+    def register_double(double)
+      @doubles << double
+    end
+
+    # RR::DoubleInjection#bind injects a method that acts as a dispatcher
+    # that dispatches to the matching Double when the method
+    # is called.
+    def bind
+      if subject_respond_to_method?(method_name)
+        if subject_has_method_defined?(method_name)
+          bind_method_with_alias
+        else
+          me = self
+
+          subject_class.__send__(:alias_method, original_method_missing_alias_name, :method_missing)
+          bind_method_missing
+
+          subject_class.__send__(:alias_method, original_singleton_method_added_alias_name, :singleton_method_added)
+          subject_class.__send__(:define_method, :singleton_method_added) do |method_name_arg|
+            if method_name_arg.to_sym == me.method_name.to_sym
+              me.send(:deferred_bind_method)
+            end
+            send(me.send(:original_singleton_method_added_alias_name), method_name_arg)
+          end
+          @deferred_bind = true
+        end
+      else
+        bind_method
+      end
+      self
+    end
+
+    # RR::DoubleInjection#verify verifies each Double
+    # TimesCalledExpectation are met.
+    def verify
+      @doubles.each do |double|
+        double.verify
+      end
+    end
+
+    # RR::DoubleInjection#reset removes the injected dispatcher method.
+    # It binds the original method implementation on the subject
+    # if one exists.
+    def reset
+      reset_bound_method
+      reset_method_missing
+      reset_singleton_method_added
+    end
+
+    def reset_bound_method
+      if subject_has_original_method?
+        subject_class.__send__(:alias_method, method_name, original_method_alias_name)
+        subject_class.__send__(:remove_method, original_method_alias_name)
+      else
+        if subject_has_method_defined?(method_name)
+          subject_class.__send__(:remove_method, method_name)
+        end
+      end
+    end
+
+    def reset_method_missing
+      if subject_has_method_defined?(original_method_missing_alias_name)
+        me = self
+        subject_class.class_eval do
+          alias_method :method_missing, me.send(:original_method_missing_alias_name)
+          remove_method me.send(:original_method_missing_alias_name)
+        end
+      end
+    end
+
+    def reset_singleton_method_added
+      if @deferred_bind
+        me = self
+        subject_class.class_eval do
+          alias_method :singleton_method_added, me.send(:original_singleton_method_added_alias_name)
+          remove_method me.send(:original_singleton_method_added_alias_name)
+        end
+      end
+    end
+
+    def dispatch_method(args, block)
+      dispatch = MethodDispatches::MethodDispatch.new(self, args, block)
+      if @bypass_bound_method
+        dispatch.call_original_method
+      else
+        dispatch.call
+      end
+    end
+
+    def dispatch_method_missing(method_name, args, block)
+      MethodDispatches::MethodMissingDispatch.new(self, method_name, args, block).call
+    end
+
+    def subject_has_original_method?
+      subject_respond_to_method?(original_method_alias_name)
+    end
+
+    def subject_has_original_method_missing?
+      subject_respond_to_method?(original_method_missing_alias_name)
+    end
+
+    def original_method_alias_name
+      "__rr__original_#{@method_name}"
+    end
+
+    def original_method_missing_alias_name
+      "__rr__original_method_missing"
+    end
+
+    def subject_has_method_defined?(method_name)
+      @subject.methods.include?(method_name.to_s) || @subject.protected_methods.include?(method_name.to_s) || @subject.private_methods.include?(method_name.to_s)
+    end
+
+    def bypass_bound_method
+      @bypass_bound_method = true
+      yield
+    ensure
+      @bypass_bound_method = nil
+    end
+
+    protected
+    def deferred_bind_method
+      unless subject_has_method_defined?(original_method_alias_name)
+        bind_method_with_alias
+      end
+      @performed_deferred_bind = true
+    end
+
+    def bind_method_with_alias
+      subject_class.__send__(:alias_method, original_method_alias_name, method_name)
+      bind_method
+    end
+
+    def bind_method
+      returns_method = <<-METHOD
+        def #{@method_name}(*args, &block)
+          arguments = MethodArguments.new(args, block)
+          RR::Space.double_injection(self, :#{@method_name}).dispatch_method(arguments.arguments, arguments.block)
+        end
+      METHOD
+      subject_class.class_eval(returns_method, __FILE__, __LINE__ - 5)
+    end
+
+    def bind_method_missing
+      returns_method = <<-METHOD
+        def method_missing(method_name, *args, &block)
+          RR::Space.double_injection(self, :#{@method_name}).dispatch_method_missing(method_name, args, block)
+        end
+      METHOD
+      subject_class.class_eval(returns_method, __FILE__, __LINE__ - 4)
+    end
+
+    def original_singleton_method_added_alias_name
+      "__rr__original_singleton_method_added"
+    end
+
+    def subject_respond_to_method?(method_name)
+      subject_has_method_defined?(method_name) || @subject.respond_to?(method_name)
+    end
+  end
+end

data/lib/rr/double_matches.rb

@@ -0,0 +1,51 @@
+module RR
+  class DoubleMatches
+    attr_reader :matching_doubles,
+                :exact_terminal_doubles_to_attempt,
+                :exact_non_terminal_doubles_to_attempt,
+                :wildcard_terminal_doubles_to_attempt,
+                :wildcard_non_terminal_doubles_to_attempt
+    def initialize(doubles) #:nodoc:
+      @doubles = doubles
+      @matching_doubles = []
+      @exact_terminal_doubles_to_attempt = []
+      @exact_non_terminal_doubles_to_attempt = []
+      @wildcard_terminal_doubles_to_attempt = []
+      @wildcard_non_terminal_doubles_to_attempt = []
+    end
+
+    def find_all_matches(args)
+      @doubles.each do |double|
+        if double.exact_match?(*args)
+          matching_doubles << double
+          if double.attempt?
+            exact_double_is_terminal_or_non_terminal double
+          end
+        elsif double.wildcard_match?(*args)
+          matching_doubles << double
+          if double.attempt?
+            wildcard_double_is_terminal_or_non_terminal double
+          end
+        end
+      end
+      self
+    end
+
+    protected
+    def exact_double_is_terminal_or_non_terminal(double)
+      if double.terminal?
+        exact_terminal_doubles_to_attempt << double
+      else
+        exact_non_terminal_doubles_to_attempt << double
+      end
+    end
+
+    def wildcard_double_is_terminal_or_non_terminal(double)
+      if double.terminal?
+        wildcard_terminal_doubles_to_attempt << double
+      else
+        wildcard_non_terminal_doubles_to_attempt << double
+      end
+    end
+  end
+end

data/lib/rr/errors/argument_equality_error.rb

@@ -0,0 +1,6 @@
+module RR
+  module Errors
+    class ArgumentEqualityError < RRError
+    end
+  end
+end

data/lib/rr/errors/double_definition_error.rb

@@ -0,0 +1,6 @@
+module RR
+  module Errors
+    class DoubleDefinitionError < RRError
+    end
+  end
+end

data/lib/rr/errors/double_not_found_error.rb

@@ -0,0 +1,6 @@
+module RR
+  module Errors
+    class DoubleNotFoundError < RRError
+    end
+  end
+end

data/lib/rr/errors/double_order_error.rb

@@ -0,0 +1,6 @@
+module RR
+  module Errors
+    class DoubleOrderError < RRError
+    end
+  end
+end

data/lib/rr/errors/rr_error.rb

@@ -0,0 +1,20 @@
+module RR
+  module Errors
+    BACKTRACE_IDENTIFIER = Regexp.new("/lib/rr")
+
+    class RRError < RuntimeError
+      attr_writer :backtrace
+      def backtrace
+        original_backtrace = (@backtrace) ? @backtrace : super
+        return original_backtrace unless RR.trim_backtrace
+
+        return original_backtrace unless original_backtrace.respond_to?(:each)
+        new_backtrace = []
+        original_backtrace.each do |line|
+          new_backtrace << line unless line =~ BACKTRACE_IDENTIFIER
+        end
+        new_backtrace
+      end
+    end
+  end
+end

data/lib/rr/errors/spy_verification_errors/double_injection_not_found_error.rb

@@ -0,0 +1,8 @@
+module RR
+  module Errors
+    module SpyVerificationErrors
+      class DoubleInjectionNotFoundError < SpyVerificationError
+      end      
+    end
+  end
+end

data/lib/rr/errors/spy_verification_errors/invocation_count_error.rb

@@ -0,0 +1,8 @@
+module RR
+  module Errors
+    module SpyVerificationErrors
+      class InvocationCountError < SpyVerificationError
+      end
+    end
+  end
+end

data/lib/rr/errors/spy_verification_errors/spy_verification_error.rb

@@ -0,0 +1,8 @@
+module RR
+  module Errors
+    module SpyVerificationErrors
+      class SpyVerificationError < RRError
+      end
+    end
+  end
+end

data/lib/rr/errors/subject_does_not_implement_method_error.rb

@@ -0,0 +1,6 @@
+module RR
+  module Errors
+    class SubjectDoesNotImplementMethodError < RRError
+    end
+  end
+end

data/lib/rr/errors/subject_has_different_arity_error.rb

@@ -0,0 +1,6 @@
+module RR
+  module Errors
+    class SubjectHasDifferentArityError < RRError
+    end
+  end
+end

data/lib/rr/errors/times_called_error.rb

@@ -0,0 +1,6 @@
+module RR
+  module Errors
+    class TimesCalledError < RRError
+    end
+  end
+end

data/lib/rr/expectations/any_argument_expectation.rb

@@ -0,0 +1,21 @@
+module RR
+  module Expectations
+    class AnyArgumentExpectation < ArgumentEqualityExpectation #:nodoc:
+      def initialize
+        super
+      end
+
+      def exact_match?(*arguments)
+        false
+      end
+
+      def wildcard_match?(*arguments)
+        true
+      end
+
+      def ==(other)
+        other.is_a?(self.class)
+      end
+    end
+  end
+end

data/lib/rr/expectations/argument_equality_expectation.rb

@@ -0,0 +1,41 @@
+module RR
+  module Expectations
+    class ArgumentEqualityExpectation #:nodoc:
+      attr_reader :expected_arguments
+
+      def initialize(*expected_arguments)
+        @expected_arguments = expected_arguments
+      end
+
+      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)
+        end
+        true
+      end
+
+      def wildcard_match?(*arguments)
+        return false unless arguments.length == expected_arguments.length
+        arguments.each_with_index do |arg, index|
+          expected_argument = expected_arguments[index]
+          if expected_argument.respond_to?(:wildcard_match?)
+            return false unless expected_argument.wildcard_match?(arg)
+          else
+            return false unless equality_match(expected_argument, arg)
+          end
+        end
+        true
+      end
+
+      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

@@ -0,0 +1,57 @@
+module RR
+  module Expectations
+    class TimesCalledExpectation #:nodoc:
+      attr_reader :double, :times_called
+
+      def initialize(double)
+        @double = double
+        @times_called = 0
+        @verify_backtrace = caller[1..-1]
+      end
+
+      def attempt?
+        times_matcher.attempt?(@times_called)
+      end
+
+      def attempt
+        @times_called += 1
+        verify_input_error unless times_matcher.possible_match?(@times_called)
+        return
+      end
+
+      def verify
+        return false unless times_matcher.is_a?(TimesCalledMatchers::TimesCalledMatcher)
+        return times_matcher.matches?(@times_called)
+      end
+
+      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
+        end
+      end
+
+      def terminal?
+        times_matcher.terminal?
+      end
+
+      protected
+      def times_matcher
+        double.definition.times_matcher
+      end
+
+      def verify_input_error
+        raise Errors::TimesCalledError, error_message
+      end
+
+      def error_message
+        "#{double.formatted_name}\n#{times_matcher.error_message(@times_called)}"
+      end
+    end
+  end
+end