caricature 0.7.6 → 0.7.7

data/lib/caricature/messenger.rb

@@ -1,68 +1,68 @@
-module Caricature
-
-  # A base class to encapsulate method invocation
-  class Messenger
-
-    # contains the recorder for recording method calls
-    attr_accessor :recorder
-
-    # the real instance of the isolated subject
-    # used to forward calls in partial mocks
-    attr_reader :instance
-
-    # the expecations that have been set for the isolation
-    attr_reader :expectations
-
-    # creates a new instance of this messaging strategy
-    def initialize(expectations, instance=nil)
-      @instance, @expectations = instance, expectations
-    end
-
-    # deliver the message to the receiving isolation
-    def deliver(method_name, return_type, *args, &b)
-      
-      internal_deliver(:instance, method_name, return_type, *args, &b)
-    end
-
-    # deliver the message to class of the receiving isolation
-    def deliver_to_class(method_name, return_type, *args, &b)
-      internal_deliver(:class, method_name, return_type, *args, &b)
-    end
-
-    protected
-
-      # template method for looking up the expectation and/or returning a value
-      def internal_deliver(mode, method_name, return_type, *args, &b)
-        raise NotImplementedError.new("Override in an implementing class")
-      end
-    
-    private
-    def record_call(method_name, mode, expectation, *args, &b)
-      recorder.record_call method_name, mode, expectation, *args, &b if recorder
-    end
-
-  end
-
-  # Encapsulates sending messages to Ruby isolations
-  class RubyMessenger < Messenger
-
-    protected
-
-      # implementation of the template method for looking up the expectation and/or returning a value
-      def internal_deliver(mode, method_name, return_type, *args, &b)   
-        exp = expectations.find(method_name, mode, *args)
-        bl = record_call(method_name, mode, exp, *args, &b)
-        if exp     
-          block = exp.block || b
-          res = instance.__send__(method_name, *args, &block) if exp.super_before?
-          res = exp.execute *args, &bl
-          res = instance.__send__(method_name, *args, &block) if !exp.super_before? and exp.call_super?
-          res
-        else
-          nil
-        end
-      end
-
-  end
-
+module Caricature
+
+  # A base class to encapsulate method invocation
+  class Messenger
+
+    # contains the recorder for recording method calls
+    attr_accessor :recorder
+
+    # the real instance of the isolated subject
+    # used to forward calls in partial mocks
+    attr_reader :instance
+
+    # the expecations that have been set for the isolation
+    attr_reader :expectations
+
+    # creates a new instance of this messaging strategy
+    def initialize(expectations, instance=nil)
+      @instance, @expectations = instance, expectations
+    end
+
+    # deliver the message to the receiving isolation
+    def deliver(method_name, return_type, *args, &b)
+      
+      internal_deliver(:instance, method_name, return_type, *args, &b)
+    end
+
+    # deliver the message to class of the receiving isolation
+    def deliver_to_class(method_name, return_type, *args, &b)
+      internal_deliver(:class, method_name, return_type, *args, &b)
+    end
+
+    protected
+
+      # template method for looking up the expectation and/or returning a value
+      def internal_deliver(mode, method_name, return_type, *args, &b)
+        raise NotImplementedError.new("Override in an implementing class")
+      end
+    
+    private
+    def record_call(method_name, mode, expectation, *args, &b)
+      recorder.record_call method_name, mode, expectation, *args, &b if recorder
+    end
+
+  end
+
+  # Encapsulates sending messages to Ruby isolations
+  class RubyMessenger < Messenger
+
+    protected
+
+      # implementation of the template method for looking up the expectation and/or returning a value
+      def internal_deliver(mode, method_name, return_type, *args, &b)   
+        exp = expectations.find(method_name, mode, *args)
+        bl = record_call(method_name, mode, exp, *args, &b)
+        if exp     
+          block = exp.block || b
+          res = instance.__send__(method_name, *args, &block) if exp.super_before?
+          res = exp.execute *args, &bl
+          res = instance.__send__(method_name, *args, &block) if !exp.super_before? and exp.call_super?
+          res
+        else
+          nil
+        end
+      end
+
+  end
+
 end

data/lib/caricature/method_call_recorder.rb

@@ -1,229 +1,229 @@
-module Caricature
-
-  class BlockCallRecording
-    attr_accessor :call_number
-    attr_reader :args
-
-    def initialize(*args)
-      @call_number = 1
-      @args = args
-    end
-
-    # compares one block variation to another.
-    # Also takes an array as an argument
-    def ==(other)
-      other = self.class.new(other) if other.respond_to?(:each)
-      return true if other.args.first.is_a?(Symbol) and other.args.first == :any
-      other.args == args
-    end
-
-  end
-
-  # A recording of an argument variation.
-  # Every time a method is called with different arguments
-  # the method call recorder will create an ArgumentVariation
-  # these variations are used later in the assertion
-  # to verify against specific argument values
-  class ArgumentRecording
-
-    # contains the arguments of the recorded parameters
-    attr_accessor :args
-
-    # contains the block for the recorded parameters
-    attr_accessor :block
-
-    # the number of the call that has the following parameters
-    attr_accessor :call_number
-
-    # the collection of block calls variations on this argument variation 
-    attr_reader :blocks
-
-    # initializes a new instance of an argument recording.
-    # configures it with 1 call count and the args as an +Array+
-    def initialize(args=[], call_number=1, block=nil)
-      @args = args
-      @block = block
-      @blocks = []
-      @call_number = call_number
-    end
-
-    def add_block_variation(*args)
-      bv = find_block_variation(*args)
-      if bv.empty?
-        blocks << BlockCallRecording.new(*args)
-      else
-        bv.first.call_number += 1
-      end
-    end
-
-    def find_block_variation(*args)
-      return @blocks if args.last.is_a?(Symbol) and args.last == :any
-      @blocks.select { |bv| bv.args == args }
-    end
-
-    # compares one argument variation to another.
-    # Also takes an array as an argument
-    def ==(other)
-      other = self.class.new(other) if other.respond_to?(:each)
-      return true if other.args.first.is_a?(Symbol) and other.args.first == :any 
-      other.args == args
-    end   
-    
-    def to_s
-      "<ArgumentRecording @args=#{args}, @block= #{block}, @call_number=#{call_number}"
-    end
-    alias_method :inspect, :to_s
-  end
-
-  # A recording that represents a method call
-  # it contains argument variations that can be matched too
-  class MethodCallRecording
-
-    # gets or sets the method name
-    attr_accessor :method_name
-
-    # gets or sets the amount of times the method was called
-    attr_accessor :count
-
-    # gets or sets the arguments for this method call
-    attr_accessor :args
-
-    # gets or sets the block for this method call
-    attr_accessor :block
-
-    # Initializes a new instance of a method call recording
-    # every time a method gets called in an isolated object
-    # this gets stored in the method call recorder
-    # It expects a +method_name+ at the very least.
-    def initialize(method_name, count=0)
-      @method_name = method_name
-      @count = count
-      @variations = []
-    end
-
-    # add args
-    def args
-      @variations
-    end
-
-    # indicates if it has an argument variation
-    def has_argument_variations?
-      @variations.size > 1
-    end
-
-    # add an argument variation
-    def add_argument_variation(args, block)
-      variation = find_argument_variations args, nil
-      if variation.empty?
-        @variations << ArgumentRecording.new(args, @variations.size+1, block) if variation == []
-      else
-        variation.first.call_number += 1
-      end
-    end
-
-    # finds an argument variation that matches the provided +args+
-    def find_argument_variations(args, block_args)
-      return @variations if args.first.is_a?(Symbol) and args.last == :any
-      return match_hash(args, block_args) if args.size == 1 and args.last.is_a?(Hash)
-      return @variations.select { |ar| ar.args == args } if block_args.nil? 
-      return @variations.select { |ar| ar.args == args and ar.block } if block_args.last == :any
-      return @variations.select do |ar|
-        av = ar.args == args
-        # idx = 0
-        #         ags = ar.args
-        #         av = args.all? do |ag| 
-        #           rag = ags[idx]
-        #           res = if ag.is_a?(Hash) and rag.is_a?(Hash)
-        #             ag.all? { |k, v| ar.args[idx][k] == v  }
-        #           else
-        #             ag == rag
-        #           end
-        #           idx += 1
-        #           res
-        #         end
-        av and not ar.find_block_variation(*block_args).empty?
-      end
-    end
-    
-    def match_hash(args, block_args)
-      @variations.select do |ar| 
-        ags = ar.args.last
-        args.last.all? { |k, v| ags[k] == v }  
-      end
-    end
-  end
-
-  # The recorder that will collect method calls and provides an interface for finding those recordings
-  class MethodCallRecorder
-
-    # gets the collection of method calls. This is a hash with the method name as key
-    attr_reader :method_calls
-
-
-    # Initializes a new instance of a method call recorder
-    # every time a method gets called in an isolated object
-    # this gets stored in the method call recorder
-    def initialize
-      @method_calls = {:instance => {}, :class => {} }      
-    end
-
-    # records a method call or increments the count of how many times this method was called.
-    def record_call(method_name, mode=:instance, expectation=nil, *args, &block)
-      mn_sym = method_name.to_s.underscore.to_sym
-      method_calls[mode][mn_sym] ||= MethodCallRecording.new mn_sym.to_s
-      mc = method_calls[mode][mn_sym]
-      mc.count += 1
-      agc = mc.add_argument_variation args, block
-      b = (expectation && expectation.block) ? (expectation.block||block) : block
-      expectation.block = lambda do |*ags|
-        res = nil
-        res = b.call *ags if b
-        agc.first.add_block_variation *ags
-        res
-      end if expectation
-      block.nil? ? nil : (lambda { |*ags|
-        res = nil
-        res = block.call *ags if block
-        agc.first.add_block_variation *ags
-        res
-      })
-    end
-    
-
-    def error
-      @error
-    end
-
-    # returns whether the method was actually called with the specified constraints
-    def was_called?(method_name, block_args, mode=:instance, *args)
-      mc = method_calls[mode][method_name.to_s.underscore.to_sym]
-      if mc
-        vari = mc.find_argument_variations(args, block_args)
-        result = vari.any? { |agv| agv == args }
-        return result if result
-        if args.size == 1 and args.last.is_a?(Hash)
-          result = vari.any? do |agv|
-            agv.args.last.is_a?(Hash) and args.last.all? { |k, v| agv.args.last[k] == v }
-          end
-        end
-        @error = "Arguments don't match.\nYou expected:\n#{args.join(", ")}.\nI did find the following variations:\n#{mc.args.collect {|ar| ar.args.join(', ') }.join("\nand\n")}" unless result
-        result
-      else
-        @error = "Couldn't find a method with name #{method_name}"
-        return !!mc
-      end
-    end
-
-#    # indexer that gives you access to the recorded method by method name
-#    def [](method_name)
-#      method_calls[:instance][method_name.to_s.to_sym]
-#    end
-
-    # returns the number of different methods that has been recorderd
-    def size
-      @method_calls.size
-    end
-  end
-
-
+module Caricature
+
+  class BlockCallRecording
+    attr_accessor :call_number
+    attr_reader :args
+
+    def initialize(*args)
+      @call_number = 1
+      @args = args
+    end
+
+    # compares one block variation to another.
+    # Also takes an array as an argument
+    def ==(other)
+      other = self.class.new(other) if other.respond_to?(:each)
+      return true if other.args.first.is_a?(Symbol) and other.args.first == :any
+      other.args == args
+    end
+
+  end
+
+  # A recording of an argument variation.
+  # Every time a method is called with different arguments
+  # the method call recorder will create an ArgumentVariation
+  # these variations are used later in the assertion
+  # to verify against specific argument values
+  class ArgumentRecording
+
+    # contains the arguments of the recorded parameters
+    attr_accessor :args
+
+    # contains the block for the recorded parameters
+    attr_accessor :block
+
+    # the number of the call that has the following parameters
+    attr_accessor :call_number
+
+    # the collection of block calls variations on this argument variation 
+    attr_reader :blocks
+
+    # initializes a new instance of an argument recording.
+    # configures it with 1 call count and the args as an +Array+
+    def initialize(args=[], call_number=1, block=nil)
+      @args = args
+      @block = block
+      @blocks = []
+      @call_number = call_number
+    end
+
+    def add_block_variation(*args)
+      bv = find_block_variation(*args)
+      if bv.empty?
+        blocks << BlockCallRecording.new(*args)
+      else
+        bv.first.call_number += 1
+      end
+    end
+
+    def find_block_variation(*args)
+      return @blocks if args.last.is_a?(Symbol) and args.last == :any
+      @blocks.select { |bv| bv.args == args }
+    end
+
+    # compares one argument variation to another.
+    # Also takes an array as an argument
+    def ==(other)
+      other = self.class.new(other) if other.respond_to?(:each)
+      return true if other.args.first.is_a?(Symbol) and other.args.first == :any 
+      other.args == args
+    end   
+    
+    def to_s
+      "<ArgumentRecording @args=#{args}, @block= #{block}, @call_number=#{call_number}"
+    end
+    alias_method :inspect, :to_s
+  end
+
+  # A recording that represents a method call
+  # it contains argument variations that can be matched too
+  class MethodCallRecording
+
+    # gets or sets the method name
+    attr_accessor :method_name
+
+    # gets or sets the amount of times the method was called
+    attr_accessor :count
+
+    # gets or sets the arguments for this method call
+    attr_accessor :args
+
+    # gets or sets the block for this method call
+    attr_accessor :block
+
+    # Initializes a new instance of a method call recording
+    # every time a method gets called in an isolated object
+    # this gets stored in the method call recorder
+    # It expects a +method_name+ at the very least.
+    def initialize(method_name, count=0)
+      @method_name = method_name
+      @count = count
+      @variations = []
+    end
+
+    # add args
+    def args
+      @variations
+    end
+
+    # indicates if it has an argument variation
+    def has_argument_variations?
+      @variations.size > 1
+    end
+
+    # add an argument variation
+    def add_argument_variation(args, block)
+      variation = find_argument_variations args, nil
+      if variation.empty?
+        @variations << ArgumentRecording.new(args, @variations.size+1, block) if variation == []
+      else
+        variation.first.call_number += 1
+      end
+    end
+
+    # finds an argument variation that matches the provided +args+
+    def find_argument_variations(args, block_args)
+      return @variations if args.first.is_a?(Symbol) and args.last == :any
+      return match_hash(args, block_args) if args.size == 1 and args.last.is_a?(Hash)
+      return @variations.select { |ar| ar.args == args } if block_args.nil? 
+      return @variations.select { |ar| ar.args == args and ar.block } if block_args.last == :any
+      return @variations.select do |ar|
+        av = ar.args == args
+        # idx = 0
+        #         ags = ar.args
+        #         av = args.all? do |ag| 
+        #           rag = ags[idx]
+        #           res = if ag.is_a?(Hash) and rag.is_a?(Hash)
+        #             ag.all? { |k, v| ar.args[idx][k] == v  }
+        #           else
+        #             ag == rag
+        #           end
+        #           idx += 1
+        #           res
+        #         end
+        av and not ar.find_block_variation(*block_args).empty?
+      end
+    end
+    
+    def match_hash(args, block_args)
+      @variations.select do |ar| 
+        ags = ar.args.last
+        args.last.all? { |k, v| ags[k] == v }  
+      end
+    end
+  end
+
+  # The recorder that will collect method calls and provides an interface for finding those recordings
+  class MethodCallRecorder
+
+    # gets the collection of method calls. This is a hash with the method name as key
+    attr_reader :method_calls
+
+
+    # Initializes a new instance of a method call recorder
+    # every time a method gets called in an isolated object
+    # this gets stored in the method call recorder
+    def initialize
+      @method_calls = {:instance => {}, :class => {} }      
+    end
+
+    # records a method call or increments the count of how many times this method was called.
+    def record_call(method_name, mode=:instance, expectation=nil, *args, &block)
+      mn_sym = method_name.to_s.underscore.to_sym
+      method_calls[mode][mn_sym] ||= MethodCallRecording.new mn_sym.to_s
+      mc = method_calls[mode][mn_sym]
+      mc.count += 1
+      agc = mc.add_argument_variation args, block
+      b = (expectation && expectation.block) ? (expectation.block||block) : block
+      expectation.block = lambda do |*ags|
+        res = nil
+        res = b.call *ags if b
+        agc.first.add_block_variation *ags
+        res
+      end if expectation
+      block.nil? ? nil : (lambda { |*ags|
+        res = nil
+        res = block.call *ags if block
+        agc.first.add_block_variation *ags
+        res
+      })
+    end
+    
+
+    def error
+      @error
+    end
+
+    # returns whether the method was actually called with the specified constraints
+    def was_called?(method_name, block_args, mode=:instance, *args)
+      mc = method_calls[mode][method_name.to_s.underscore.to_sym]
+      if mc
+        vari = mc.find_argument_variations(args, block_args)
+        result = vari.any? { |agv| agv == args }
+        return result if result
+        if args.size == 1 and args.last.is_a?(Hash)
+          result = vari.any? do |agv|
+            agv.args.last.is_a?(Hash) and args.last.all? { |k, v| agv.args.last[k] == v }
+          end
+        end
+        @error = "Arguments don't match.\nYou expected:\n#{args.join(", ")}.\nI did find the following variations:\n#{mc.args.collect {|ar| ar.args.join(', ') }.join("\nand\n")}" unless result
+        result
+      else
+        @error = "Couldn't find a method with name #{method_name}"
+        return !!mc
+      end
+    end
+
+#    # indexer that gives you access to the recorded method by method name
+#    def [](method_name)
+#      method_calls[:instance][method_name.to_s.to_sym]
+#    end
+
+    # returns the number of different methods that has been recorderd
+    def size
+      @method_calls.size
+    end
+  end
+
+
 end