adva 0.0.1

data/test/rr/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/test/rr/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

data/test/rr/lib/rr/invocation_matcher.rb

@@ -0,0 +1,27 @@
+module RR
+  class InvocationMatcher < SpyVerificationProxy
+    attr_reader :failure_message
+
+    def initialize(method = nil)
+      method_missing(method) if method
+    end
+
+    def matches?(subject)
+      @verification.subject = subject
+      RR::Space.instance.recorded_calls.matches?(@verification)
+    end
+
+    def nil?
+      false
+    end
+    
+    def method_missing(method_name, *args, &block)
+      if @verification
+        @verification.send(method_name, *args)
+      else
+        @verification = super
+      end
+      self
+    end
+  end
+end

data/test/rr/lib/rr/recorded_calls.rb

@@ -0,0 +1,72 @@
+module RR
+  class RecordedCalls
+    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 matches?(spy_verification)
+      if spy_verification.ordered?
+        ordered_matches?(spy_verification)
+      else
+        spy_verification.times_matcher.matches?(times_called(spy_verification))
+      end
+    end
+  
+    def ordered_matches?(spy_verification)
+      matched_count = 0
+      index = ordered_index
+      while index < recorded_calls.size
+        matched_count += 1 if matches_recorded_call?(recorded_calls[index],spy_verification)
+        index = index + 1
+        if spy_verification.times_matcher.matches?(matched_count)
+          self.ordered_index = index
+          return true
+        end
+      end
+      false
+    end
+  
+  protected
+    attr_accessor :ordered_index
+
+    def times_called(spy_verification)
+      matching_calls = recorded_calls.select do |recorded_call|
+        matches_recorded_call?(recorded_call, spy_verification)
+      end
+      matching_calls.size
+    end
+
+    def matches_recorded_call?(recorded_call, spy_verification)
+#      puts "#{__FILE__}:#{__LINE__}"
+#      p recorded_call[0] == spy_verification.subject
+#      p recorded_call[1] == spy_verification.method_name
+#      p spy_verification.argument_expectation
+#      p spy_verification.argument_expectation.exact_match?(*recorded_call[2])
+#      p spy_verification.argument_expectation.wildcard_match?(*recorded_call[2])
+      recorded_call[0] == spy_verification.subject &&
+      recorded_call[1] == spy_verification.method_name && 
+      ( spy_verification.argument_expectation.exact_match?(*recorded_call[2]) ||
+        spy_verification.argument_expectation.wildcard_match?(*recorded_call[2]))
+    end
+  end
+end

data/test/rr/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_injection = @double_injections[subject][method_name.to_sym]
+      return double_injection if double_injection
+
+      double_injection = DoubleInjection.new(subject, method_name.to_sym)
+      @double_injections[subject][method_name.to_sym] = double_injection
+      double_injection.bind
+      double_injection
+    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

data/test/rr/lib/rr/spy_verification.rb

@@ -0,0 +1,38 @@
+module RR
+  class SpyVerification
+    def initialize(subject, method_name, args)
+      @subject = subject
+      @method_name = method_name.to_sym
+      set_argument_expectation_for_args(args)
+      @ordered = false
+      once
+    end
+
+    attr_reader :argument_expectation, :method_name, :times_matcher
+    attr_accessor :subject
+  
+    include RR::DoubleDefinitions::DoubleDefinition::TimesDefinitionConstructionMethods
+    include RR::DoubleDefinitions::DoubleDefinition::ArgumentDefinitionConstructionMethods
+  
+    def ordered
+      @ordered = true
+      self
+    end
+  
+    def ordered?
+      @ordered
+    end
+  
+  protected
+    attr_writer :times_matcher
+  
+    def set_argument_expectation_for_args(args)
+      # with_no_args and with actually set @argument_expectation
+      args.empty? ? with_no_args : with(*args)
+    end
+  
+    def install_method_callback(return_value_block)
+      # Do nothing. This is to support DefinitionConstructionMethods
+    end
+  end
+end

data/test/rr/lib/rr/spy_verification_proxy.rb

@@ -0,0 +1,18 @@
+module RR
+  class SpyVerificationProxy
+    instance_methods.each do |m|
+      unless m =~ /^_/ || m.to_s == 'object_id' || m.to_s == "instance_eval" || m.to_s == 'respond_to?'
+        alias_method "__blank_slated_#{m}", m
+        undef_method m
+      end
+    end
+
+    def initialize(subject)
+      @subject = subject
+    end
+  
+    def method_missing(method_name, *args, &block)
+      SpyVerification.new(@subject, method_name, args)
+    end  
+  end
+end

data/test/rr/lib/rr/times_called_matchers/any_times_matcher.rb

@@ -0,0 +1,19 @@
+module RR
+  module TimesCalledMatchers #:nodoc:
+    class AnyTimesMatcher < TimesCalledMatcher
+      include NonTerminal
+
+      def initialize
+      end
+
+      def matches?(times_called)
+        true
+      end
+
+      protected
+      def expected_message_part
+        "Expected any number of times."
+      end
+    end
+  end
+end

data/test/rr/lib/rr/times_called_matchers/at_least_matcher.rb

@@ -0,0 +1,16 @@
+module RR
+  module TimesCalledMatchers #:nodoc:
+    class AtLeastMatcher < TimesCalledMatcher
+      include NonTerminal
+
+      def matches?(times_called)
+        times_called >= @times
+      end
+
+      protected
+      def expected_message_part
+        "Expected at least #{@times.inspect} times."
+      end
+    end
+  end
+end

data/test/rr/lib/rr/times_called_matchers/at_most_matcher.rb

@@ -0,0 +1,24 @@
+module RR
+  module TimesCalledMatchers #:nodoc:
+    class AtMostMatcher < TimesCalledMatcher
+      include Terminal
+
+      def possible_match?(times_called)
+        times_called <= @times
+      end
+
+      def matches?(times_called)
+        times_called <= @times
+      end
+
+      def attempt?(times_called)
+        times_called < @times
+      end
+
+      protected
+      def expected_message_part
+        "Expected at most #{@times.inspect} times."
+      end
+    end
+  end
+end