redinger-rr 0.10.3

data/lib/rr/hash_with_object_id_key.rb

@@ -0,0 +1,44 @@
+module RR
+  # TODO: Refactor to a side-effect-free strategy.
+  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

data/lib/rr/method_dispatches/base_method_dispatch.rb

@@ -0,0 +1,108 @@
+module RR
+  module MethodDispatches
+    class BaseMethodDispatch
+      include Space::Reader
+
+      attr_reader :double_injection, :args, :block, :double
+
+      def call
+        raise NotImplementedError
+      end
+
+      protected
+      def find_double_to_attempt
+        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 call_yields
+        if definition.yields_value
+          if block
+            block.call(*definition.yields_value)
+          else
+            raise ArgumentError, "A Block must be passed into the method call when using yields"
+          end
+        end
+      end
+
+      def call_implementation
+        if implementation_is_original_method?
+          call_original_method
+        else
+          if implementation
+            if implementation.is_a?(Method)
+              implementation.call(*args, &block)
+            else
+              call_args = block ? args + [ProcFromBlock.new(&block)] : args
+              implementation.call(*call_args)
+            end
+          else
+            nil
+          end
+        end
+      end
+
+      def call_original_method_missing
+        subject.__send__(original_method_missing_alias_name, method_name, *args, &block)
+      end
+
+      def implementation_is_original_method?
+        double.implementation_is_original_method?
+      end
+
+      def extract_subject_from_return_value(return_value)
+        case return_value
+          when DoubleDefinitions::DoubleDefinition
+            return_value.root_subject
+          when DoubleDefinitions::DoubleDefinitionCreatorProxy
+            return_value.__creator__.root_subject
+          else
+            return_value
+        end
+      end
+
+      def double_not_found_error
+        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 after_call_proc
+        definition.after_call_proc
+      end
+
+      def definition
+        double.definition
+      end
+
+      def doubles
+        double_injection.doubles
+      end
+    end
+  end
+end

data/lib/rr/method_dispatches/method_dispatch.rb

@@ -0,0 +1,61 @@
+module RR
+  module MethodDispatches
+    class MethodDispatch < BaseMethodDispatch
+      def initialize(double_injection, args, block)
+        @double_injection, @args, @block = double_injection, args, block
+        @double = find_double_to_attempt
+      end
+
+      def call
+        space.record_call(subject, method_name, args, block)
+        if double
+          double.method_call(args)
+          call_yields
+          return_value = extract_subject_from_return_value(call_implementation)
+          if after_call_proc
+            extract_subject_from_return_value(after_call_proc.call(return_value))
+          else
+            return_value
+          end
+        else
+          double_not_found_error
+        end
+      end
+
+      def call_original_method
+        if subject_has_original_method?
+          subject.__send__(original_method_alias_name, *args, &block)
+        elsif subject_has_original_method_missing?
+          call_original_method_missing
+        else
+          subject.__send__(:method_missing, method_name, *args, &block)
+        end
+      end
+
+      protected
+      def implementation
+        definition.implementation
+      end
+
+      def subject_has_original_method?
+        double_injection.subject_has_original_method?
+      end
+
+      def subject_has_original_method_missing?
+        double_injection.subject_has_original_method_missing?
+      end
+
+      def subject
+        double_injection.subject
+      end
+
+      def method_name
+        double_injection.method_name
+      end
+
+      def original_method_alias_name
+        double_injection.original_method_alias_name
+      end
+    end
+  end
+end

data/lib/rr/method_dispatches/method_missing_dispatch.rb

@@ -0,0 +1,49 @@
+module RR
+  module MethodDispatches
+    class MethodMissingDispatch < BaseMethodDispatch
+      attr_reader :method_name
+      def initialize(double_injection, method_name, args, block)
+        @double_injection, @args, @block = double_injection, args, block
+        @method_name = method_name
+      end
+
+      def call
+        if double_injection.method_name == method_name
+          space.record_call(subject, method_name, args, block)
+          @double = find_double_to_attempt
+
+          if double
+            double.method_call(args)
+            call_yields
+            return_value = extract_subject_from_return_value(call_implementation)
+            if after_call_proc
+              extract_subject_from_return_value(after_call_proc.call(return_value))
+            else
+              return_value
+            end
+          else
+            double_not_found_error
+          end
+        else
+          call_original_method
+        end
+      end
+
+      def call_original_method
+        double_injection.bypass_bound_method do
+          call_original_method_missing
+        end
+      end
+
+      protected
+
+      def original_method_missing_alias_name
+        double_injection.original_method_missing_alias_name
+      end
+
+      def subject
+        double_injection.subject
+      end
+    end
+  end
+end

data/lib/rr/proc_from_block.rb

@@ -0,0 +1,7 @@
+module RR
+  class ProcFromBlock < Proc
+    def ==(other)
+      Proc.new(&self) == other
+    end
+  end
+end

data/lib/rr/recorded_calls.rb

@@ -0,0 +1,103 @@
+module RR
+  class RecordedCalls
+    include RR::Space::Reader
+
+    def initialize(recorded_calls=[])
+      @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?
+          ordered_match_error(spy_verification)
+        else
+          unordered_match_error(spy_verification)
+        end
+      end
+    end
+  
+  protected
+    attr_accessor :ordered_index
+
+    def double_injection_exists_error(spy_verification)
+      unless space.double_injection_exists?(spy_verification.subject, spy_verification.method_name)
+        RR::Errors::SpyVerificationErrors::DoubleInjectionNotFoundError.new(
+          "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    
+
+    def ordered_match_error(spy_verification)
+      memoized_matching_recorded_calls = matching_recorded_calls(spy_verification)
+
+      if memoized_matching_recorded_calls.last
+        self.ordered_index = recorded_calls.index(memoized_matching_recorded_calls.last)
+      end
+      (0..memoized_matching_recorded_calls.size).to_a.any? do |i|
+        spy_verification.times_matcher.matches?(i)
+      end ? nil : invocation_count_error(spy_verification, memoized_matching_recorded_calls)
+    end
+
+    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)
+    end
+
+    def matching_recorded_calls(spy_verification)
+      recorded_calls[ordered_index..-1].
+        select(&match_double_injection(spy_verification)).
+        select(&match_argument_expectation(spy_verification))
+    end
+
+    def match_double_injection(spy_verification)
+      lambda do |recorded_call|
+        recorded_call[0] == spy_verification.subject &&
+        recorded_call[1] == spy_verification.method_name
+      end
+    end
+
+    def match_argument_expectation(spy_verification)
+      lambda do |recorded_call|
+        spy_verification.argument_expectation.exact_match?(*recorded_call[2]) ||
+        spy_verification.argument_expectation.wildcard_match?(*recorded_call[2])
+      end
+    end
+
+    def invocation_count_error(spy_verification, matching_recorded_calls)
+      RR::Errors::SpyVerificationErrors::InvocationCountError.new(
+        "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" <<
+        "but was called #{matching_recorded_calls.size} times.\n" <<
+        "All of the method calls related to Doubles are:\n" <<
+        "\t#{recorded_calls.map {|call| call.inspect}.join("\n\t")}"
+      )
+    end
+  end
+end

data/lib/rr/space.rb

@@ -0,0 +1,123 @@
+module RR
+  # RR::Space.instance is the global state subject for the RR framework.
+  class Space
+    module Reader
+      def space
+        RR::Space.instance
+      end
+    end
+
+    class << self
+      def instance
+        @instance ||= new
+      end
+      attr_writer :instance
+
+      protected
+      def method_missing(method_name, *args, &block)
+        instance.__send__(method_name, *args, &block)
+      end
+    end
+
+    attr_reader :double_injections, :ordered_doubles, :recorded_calls
+    attr_accessor :trim_backtrace
+    def initialize
+      @double_injections = HashWithObjectIdKey.new
+      @ordered_doubles = []
+      @trim_backtrace = false
+      @recorded_calls = RR::RecordedCalls.new
+    end
+
+    # Reuses or creates, if none exists, a DoubleInjection for the passed
+    # in subject and method_name.
+    # When a DoubleInjection is created, it binds the dispatcher to the
+    # subject.
+    def double_injection(subject, method_name)
+      @double_injections[subject][method_name.to_sym] ||= begin
+        DoubleInjection.new(subject, method_name.to_sym, (class << subject; self; end)).bind
+      end
+    end
+
+    def double_injection_exists?(subject, method_name)
+      @double_injections.include?(subject) && @double_injections[subject].include?(method_name.to_sym)
+    end
+
+    # Registers the ordered Double to be verified.
+    def register_ordered_double(double)
+      @ordered_doubles << double unless ordered_doubles.include?(double)
+    end
+
+    # Verifies that the passed in ordered Double is being called
+    # in the correct position.
+    def verify_ordered_double(double)
+      unless double.terminal?
+        raise Errors::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
+      end
+      @ordered_doubles.shift unless double.attempt?
+      double
+    end
+
+    # Verifies all the DoubleInjection objects have met their
+    # TimesCalledExpectations.
+    def verify_doubles(*objects)
+      objects = @double_injections.keys if objects.empty?
+      objects.each do |subject|
+        @double_injections[subject].keys.each do |method_name|
+          verify_double(subject, method_name)
+        end
+      end
+    end
+    alias_method :verify, :verify_doubles
+
+    # Resets the registered Doubles and ordered Doubles
+    def reset
+      reset_ordered_doubles
+      reset_double_injections
+      reset_recorded_calls
+    end
+
+    # Verifies the DoubleInjection for the passed in subject and method_name.
+    def verify_double(subject, method_name)
+      @double_injections[subject][method_name].verify
+    ensure
+      reset_double subject, method_name
+    end
+
+    # Resets the DoubleInjection for the passed in subject and method_name.
+    def reset_double(subject, method_name)
+      double_injection = @double_injections[subject].delete(method_name)
+      @double_injections.delete(subject) if @double_injections[subject].empty?
+      double_injection.reset
+    end
+    
+    def record_call(subject, method_name, arguments, block)
+      @recorded_calls << [subject, method_name, arguments, block]
+    end
+
+    protected
+    # Removes the ordered Doubles from the list
+    def reset_ordered_doubles
+      @ordered_doubles.clear
+    end
+
+    # Resets the registered Doubles for the next test run.
+    def reset_double_injections
+      @double_injections.each do |subject, method_double_map|
+        method_double_map.keys.each do |method_name|
+          reset_double(subject, method_name)
+        end
+      end
+    end  
+    
+    def reset_recorded_calls
+      @recorded_calls.clear
+    end
+  end
+end