mcmire-rr 1.0.5.rc1

data/lib/rr/double_definitions/strategies/verification/dont_allow.rb

@@ -0,0 +1,31 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Verification
+        # This method sets the Double to have a dont_allow strategy.
+        # A dont_allow strategy sets the default state of the Double
+        # to expect never to be called. The Double's expectations can be
+        # changed.
+        #
+        # The following example sets the expectation that subject.method_name
+        # will never be called with arg1 and arg2.
+        #
+        #   do_not_allow(subject).method_name(arg1, arg2)
+        #
+        # dont_allow also supports a block sytnax.
+        #    dont_allow(subject) do |m|
+        #      m.method1 # Do not allow method1 with any arguments
+        #      m.method2(arg1, arg2) # Do not allow method2 with arguments arg1 and arg2
+        #      m.method3.with_no_args # Do not allow method3 with no arguments
+        #    end        
+        class DontAllow < VerificationStrategy
+          protected
+          def do_call
+            definition.never
+            permissive_argument
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rr/double_definitions/strategies/verification/mock.rb

@@ -0,0 +1,42 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Verification
+        # This method sets the Double to have a mock strategy. A mock strategy
+        # sets the default state of the Double to expect the method call
+        # with arguments exactly one time. The Double's expectations can be
+        # changed.
+        #
+        # This method can be chained with proxy.
+        #   mock.proxy(subject).method_name_1
+        #   or
+        #   proxy.mock(subject).method_name_1
+        #
+        # When passed the subject, a DoubleDefinitionCreateBlankSlate is returned. Passing
+        # a method with arguments to the proxy will set up expectations that
+        # the a call to the subject's method with the arguments will happen,
+        # and return the prescribed value.
+        #   mock(subject).method_name_1 {return_value_1}
+        #   mock(subject).method_name_2(arg1, arg2) {return_value_2}
+        #
+        # When passed the subject and the method_name, this method returns
+        # a mock Double with the method already set.
+        #
+        #   mock(subject, :method_name_1) {return_value_1}
+        #   mock(subject, :method_name_2).with(arg1, arg2) {return_value_2}
+        #
+        # mock also takes a block for definitions.
+        #   mock(subject) do
+        #     method_name_1 {return_value_1}
+        #     method_name_2(arg_1, arg_2) {return_value_2}
+        #   end        
+        class Mock < VerificationStrategy
+          protected
+          def do_call
+            definition.with(*args).once
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rr/double_definitions/strategies/verification/stub.rb

@@ -0,0 +1,43 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Verification
+        # This method sets the Double to have a stub strategy. A stub strategy
+        # sets the default state of the Double to expect the method call
+        # with any arguments any number of times. The Double's
+        # expectations can be changed.
+        #
+        # This method can be chained with proxy.
+        #   stub.proxy(subject).method_name_1
+        #   or
+        #   proxy.stub(subject).method_name_1
+        #
+        # When passed the subject, a DoubleDefinitionCreateBlankSlate is returned. Passing
+        # a method with arguments to the proxy will set up expectations that
+        # the a call to the subject's method with the arguments will happen,
+        # and return the prescribed value.
+        #   stub(subject).method_name_1 {return_value_1}
+        #   stub(subject).method_name_2(arg_1, arg_2) {return_value_2}
+        #
+        # When passed the subject and the method_name, this method returns
+        # a stub Double with the method already set.
+        #
+        #   mock(subject, :method_name_1) {return_value_1}
+        #   mock(subject, :method_name_2).with(arg1, arg2) {return_value_2}
+        #
+        # stub also takes a block for definitions.
+        #   stub(subject) do
+        #     method_name_1 {return_value_1}
+        #     method_name_2(arg_1, arg_2) {return_value_2}
+        #   end        
+        class Stub < VerificationStrategy
+          protected
+          def do_call
+            definition.any_number_of_times
+            permissive_argument
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rr/double_definitions/strategies/verification/verification_strategy.rb

@@ -0,0 +1,10 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Verification
+        class VerificationStrategy < Strategy
+        end
+      end
+    end
+  end
+end

data/lib/rr/double_matches.rb

@@ -0,0 +1,42 @@
+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?
+            if double.terminal?
+              exact_terminal_doubles_to_attempt << double
+            else
+              exact_non_terminal_doubles_to_attempt << double
+            end
+          end
+        elsif double.wildcard_match?(*args)
+          matching_doubles << double
+          if double.attempt?
+            if double.terminal?
+              wildcard_terminal_doubles_to_attempt << double
+            else
+              wildcard_non_terminal_doubles_to_attempt << double
+            end
+          end
+        end
+      end
+      self
+    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
+        @backtrace ||= super
+        original_backtrace = @backtrace
+        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,46 @@
+module RR
+  # TODO: Refactor to a side-effect-free strategy.
+  class HashWithObjectIdKey < ::Hash #:nodoc:
+    def initialize
+      @keys = {}
+      super
+    end
+
+    alias_method :get_with_object_id, :[]
+
+    def [](key)
+      @keys[key.__id__] = key
+      super(key.__id__)
+    end
+
+    def has_key?(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