jferris-rr 0.7.1.0.1239654108

data/lib/rr/double_injection.rb

@@ -0,0 +1,143 @@
+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
+
+    def initialize(subject, method_name)
+      @subject = subject
+      @method_name = method_name.to_sym
+      if object_has_method?(method_name)
+        begin
+          meta.__send__(:alias_method, original_method_name, method_name)
+        rescue NameError => e
+          subject.send(method_name)
+          meta.__send__(:alias_method, original_method_name, method_name)
+        end
+      end
+      @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
+      define_implementation_placeholder
+      returns_method = <<-METHOD
+        def #{@method_name}(*args, &block)
+          arguments = MethodArguments.new(args, block)
+          __send__('#{placeholder_name}', arguments)
+        end
+      METHOD
+      meta.class_eval(returns_method, __FILE__, __LINE__ - 5)
+      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
+      meta.__send__(:remove_method, placeholder_name)
+      if object_has_original_method?
+        meta.__send__(:alias_method, @method_name, original_method_name)
+        meta.__send__(:remove_method, original_method_name)
+      else
+        meta.__send__(:remove_method, @method_name)
+      end
+    end
+
+    def call_original_method(*args, &block)
+      @subject.__send__(original_method_name, *args, &block)
+    end
+
+    def object_has_original_method?
+      object_has_method?(original_method_name)
+    end
+
+    protected
+    def define_implementation_placeholder
+      me = self
+      meta.__send__(:define_method, placeholder_name) do |arguments|
+        me.__send__(:call_method, arguments.arguments, arguments.block)
+      end
+    end
+
+    def call_method(args, block)
+      space.record_call(subject, method_name, args, block)
+      if double = find_double_to_attempt(args)
+        double.call(self, *args, &block)
+      else
+        double_not_found_error(*args)
+      end
+    end
+
+    def find_double_to_attempt(args)
+      matches = DoubleMatches.new(@doubles).find_all_matches(args)
+
+      unless matches.exact_terminal_doubles_to_attempt.empty?
+        return matches.exact_terminal_doubles_to_attempt.first
+      end
+
+      unless matches.exact_non_terminal_doubles_to_attempt.empty?
+        return matches.exact_non_terminal_doubles_to_attempt.last
+      end
+
+      unless matches.wildcard_terminal_doubles_to_attempt.empty?
+        return matches.wildcard_terminal_doubles_to_attempt.first
+      end
+
+      unless matches.wildcard_non_terminal_doubles_to_attempt.empty?
+        return matches.wildcard_non_terminal_doubles_to_attempt.last
+      end
+
+      unless matches.matching_doubles.empty?
+        return matches.matching_doubles.first # This will raise a TimesCalledError
+      end
+
+      return nil
+    end
+
+    def double_not_found_error(*args)
+      message =
+        "On subject #{subject},\n" <<
+        "unexpected method invocation:\n" <<
+        "  #{Double.formatted_name(@method_name, args)}\n" <<
+        "expected invocations:\n" <<
+        Double.list_message_part(@doubles)
+      raise Errors::DoubleNotFoundError, message
+    end
+
+    def placeholder_name
+      "__rr__#{@method_name}"
+    end
+
+    def original_method_name
+      "__rr__original_#{@method_name}"
+    end
+
+    def object_has_method?(method_name)
+      @subject.methods.include?(method_name.to_s) || @subject.respond_to?(method_name)
+    end
+
+    def meta
+      (class << @subject; self; end)
+    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

data/lib/rr/hash_with_object_id_key.rb

@@ -0,0 +1,41 @@
+module RR
+class HashWithObjectIdKey < ::Hash #:nodoc:
+  def initialize
+    @keys = {}
+    super do |hash, subject_object|
+      hash.set_with_object_id(subject_object, {})
+    end
+  end
+
+  alias_method :get_with_object_id, :[]
+  def [](key)
+    @keys[key.__id__] = key
+    super(key.__id__)
+  end
+
+  alias_method :set_with_object_id, :[]=
+  def []=(key, value)
+    @keys[key.__id__] = key
+    super(key.__id__, value)
+  end
+
+  def each
+    super do |object_id, value|
+      yield @keys[object_id], value
+    end
+  end
+
+  def delete(key)
+    @keys.delete(key.__id__)
+    super(key.__id__)
+  end
+
+  def keys
+    @keys.values
+  end
+
+  def include?(key)
+    super(key.__id__)
+  end
+end
+end