caricature 0.7.6 → 0.7.7

data/lib/caricature/isolation.rb

@@ -1,144 +1,144 @@
-require File.dirname(__FILE__) + '/isolator'
-require File.dirname(__FILE__) + '/method_call_recorder'
-require File.dirname(__FILE__) + '/expectation'
-require File.dirname(__FILE__) + '/verification'
-
-# Caricature - Bringing simple mocking to the DLR
-# ===============================================
-#
-# This project aims to make interop between IronRuby objects and .NET objects easier.
-# The idea is that it integrates nicely with bacon and later rspec and that it transparently lets you mock ironruby ojbects
-# as well as CLR objects/interfaces.
-# Caricature handles interfaces, interface inheritance, CLR objects, CLR object instances, Ruby classes and instances of Ruby classes.
-#
-# From the start I wanted to do away with names like mock, stub, record, replay, verify etc.
-# Instead I took the advice from Roy Osherhove and went with a name of Isolation for creating a mock.
-#
-# An Isolation will create what in Rhino.Mocks would be called a DynamicMock (but can be a partial too) :)
-# In Moq it would be the Loose mocking strategy.
-#
-# The naming of the methods for creating mocks is the one that JP Boodhoo proposed WhenToldTo and WasToldTo.
-# To specify a stub/expectation on an isolation you have one and only one way of doing that with the method called when_receiving.
-# Then only if you're interested in asserting if a method has been called you can use the did_receive? method for this.
-#
-#
-#     isolation = Isolation.for(Ninja)
-#     isolation.when_receiving(:attack) do |exp|
-#       exp.with(:shuriken)
-#       exp.return(3)
-#     end
-#
-#     Battle.new(mock)
-#     battle.combat
-#
-#     isolation.did_receive?(:attack).should.be.true?
-#
-#
-# It may be very important to note that when you're going to be isolating CLR classes to be used in other CLR classes
-# you still need to obide by the CLR rules. That means if you want to redefine a method you'll need to make sure it's
-# marked as virtual. Static types are still governed by static type rules.  I'm working on a solution around those
-# problems but for the time being this is how it has to be.
-module Caricature
-
-  # The context for an isolator. This contains the +subject+, +recorder+, +expectations+ and +messenger+
-  IsolatorContext = Struct.new(:subject, :recorder, :expectations, :messenger)
-
-  # Instead of using confusing terms like Mocking and Stubbing which is basically the same. Caricature tries
-  # to unify those concepts by using a term of *Isolation*.
-  # When you're testing you typically want to be in control of what you're testing. To do that you isolate
-  # dependencies and possibly define return values for methods on them.
-  # At a later stage you might be interested in which method was called, maybe even with which parameters
-  # or you might be interested in the amount of times it has been called.
-  class Isolation
-
-    # the real instance of the isolated subject
-    # used to forward calls in partial mocks
-    attr_accessor :instance
-
-    # the method call recorder
-    attr_reader :recorder
-
-    # the expecations set for this isolation
-    attr_reader :expectations
-
-    # Initializes a new instance of this isolation.
-    def initialize(isolator, context)
-      @instance = isolator.subject
-      @messenger = context.messenger
-      @messenger.recorder = @recorder = context.recorder
-      @expectations = context.expectations
-      @proxy = isolator.isolation
-      isolator.isolation.class.instance_variable_set("@___context___", self)
-    end
-
-    # record and send the message to the isolation.
-    # takes care of following expectations rules when sending messages.
-    def send_message(method_name, return_type, *args, &b)
-      @messenger.deliver(method_name, return_type, *args, &b)
-    end
-
-    # record and send the message to the isolation.
-    # takes care of following expectations rules when sending messages.
-    def send_class_message(method_name, return_type, *args, &b)
-      @messenger.deliver_to_class(method_name, return_type, *args, &b)
-    end
-
-    # builds up an expectation for an instance method, allows for overriding the result returned by the method
-    def create_override(method_name, &block)
-      internal_create_override method_name, :instance, &block
-    end
-
-    # builds up an expectation for a class method, allows for overriding the result returned by the class method
-    def create_class_override(method_name, &block)
-      internal_create_override method_name, :class, &block      
-    end
-
-    # asserts whether the method has been called for the specified configuration
-    def verify(method_name, &block)
-      internal_verify method_name, :instance, &block
-    end
-
-    # asserts whether the method has been called for the specified configuration
-    def class_verify(method_name, &block)
-      internal_verify method_name, :class, &block
-    end
-
-    class << self
-
-      # Creates an isolation object complete with proxy and method call recorder
-      # It works out which isolation it needs to create and provide and initializes the
-      # method call recorder
-      def for(subject, recorder = MethodCallRecorder.new, expectations = Expectations.new)
-        context = IsolatorContext.new subject, recorder, expectations
-
-        isolator = RubyIsolator.for context
-        isolation = new(isolator, context)
-        isolator.isolation
-      end
-            
-    end
-
-    protected
-
-    def internal_create_override(method_name, mode=:instance, &block)
-      builder = ExpectationBuilder.new method_name
-      block.call builder unless block.nil?
-      exp = builder.build           
-      expectations.add_expectation exp, mode
-      exp
-    end
-
-    def internal_verify(method_name, mode=:instance, &block)
-      verification = Verification.new(method_name, recorder, mode)
-      block.call verification unless block.nil?
-      verification
-    end
-  end
-
-  # +Mock+ is a synonym for +Isolation+ so you can still use it if you're that way inclined
-  Mock = Isolation unless defined? Mock
-
-  # +Stub+ is a synonym for +Isolation+ so you can still use it if you're that way inclined
-  Stub = Isolation unless defined? Stub
-
+require File.dirname(__FILE__) + '/isolator'
+require File.dirname(__FILE__) + '/method_call_recorder'
+require File.dirname(__FILE__) + '/expectation'
+require File.dirname(__FILE__) + '/verification'
+
+# Caricature - Bringing simple mocking to the DLR
+# ===============================================
+#
+# This project aims to make interop between IronRuby objects and .NET objects easier.
+# The idea is that it integrates nicely with bacon and later rspec and that it transparently lets you mock ironruby ojbects
+# as well as CLR objects/interfaces.
+# Caricature handles interfaces, interface inheritance, CLR objects, CLR object instances, Ruby classes and instances of Ruby classes.
+#
+# From the start I wanted to do away with names like mock, stub, record, replay, verify etc.
+# Instead I took the advice from Roy Osherhove and went with a name of Isolation for creating a mock.
+#
+# An Isolation will create what in Rhino.Mocks would be called a DynamicMock (but can be a partial too) :)
+# In Moq it would be the Loose mocking strategy.
+#
+# The naming of the methods for creating mocks is the one that JP Boodhoo proposed WhenToldTo and WasToldTo.
+# To specify a stub/expectation on an isolation you have one and only one way of doing that with the method called when_receiving.
+# Then only if you're interested in asserting if a method has been called you can use the did_receive? method for this.
+#
+#
+#     isolation = Isolation.for(Ninja)
+#     isolation.when_receiving(:attack) do |exp|
+#       exp.with(:shuriken)
+#       exp.return(3)
+#     end
+#
+#     Battle.new(mock)
+#     battle.combat
+#
+#     isolation.did_receive?(:attack).should.be.true?
+#
+#
+# It may be very important to note that when you're going to be isolating CLR classes to be used in other CLR classes
+# you still need to obide by the CLR rules. That means if you want to redefine a method you'll need to make sure it's
+# marked as virtual. Static types are still governed by static type rules.  I'm working on a solution around those
+# problems but for the time being this is how it has to be.
+module Caricature
+
+  # The context for an isolator. This contains the +subject+, +recorder+, +expectations+ and +messenger+
+  IsolatorContext = Struct.new(:subject, :recorder, :expectations, :messenger)
+
+  # Instead of using confusing terms like Mocking and Stubbing which is basically the same. Caricature tries
+  # to unify those concepts by using a term of *Isolation*.
+  # When you're testing you typically want to be in control of what you're testing. To do that you isolate
+  # dependencies and possibly define return values for methods on them.
+  # At a later stage you might be interested in which method was called, maybe even with which parameters
+  # or you might be interested in the amount of times it has been called.
+  class Isolation
+
+    # the real instance of the isolated subject
+    # used to forward calls in partial mocks
+    attr_accessor :instance
+
+    # the method call recorder
+    attr_reader :recorder
+
+    # the expecations set for this isolation
+    attr_reader :expectations
+
+    # Initializes a new instance of this isolation.
+    def initialize(isolator, context)
+      @instance = isolator.subject
+      @messenger = context.messenger
+      @messenger.recorder = @recorder = context.recorder
+      @expectations = context.expectations
+      @proxy = isolator.isolation
+      isolator.isolation.class.instance_variable_set("@___context___", self)
+    end
+
+    # record and send the message to the isolation.
+    # takes care of following expectations rules when sending messages.
+    def send_message(method_name, return_type, *args, &b)
+      @messenger.deliver(method_name, return_type, *args, &b)
+    end
+
+    # record and send the message to the isolation.
+    # takes care of following expectations rules when sending messages.
+    def send_class_message(method_name, return_type, *args, &b)
+      @messenger.deliver_to_class(method_name, return_type, *args, &b)
+    end
+
+    # builds up an expectation for an instance method, allows for overriding the result returned by the method
+    def create_override(method_name, &block)
+      internal_create_override method_name, :instance, &block
+    end
+
+    # builds up an expectation for a class method, allows for overriding the result returned by the class method
+    def create_class_override(method_name, &block)
+      internal_create_override method_name, :class, &block      
+    end
+
+    # asserts whether the method has been called for the specified configuration
+    def verify(method_name, &block)
+      internal_verify method_name, :instance, &block
+    end
+
+    # asserts whether the method has been called for the specified configuration
+    def class_verify(method_name, &block)
+      internal_verify method_name, :class, &block
+    end
+
+    class << self
+
+      # Creates an isolation object complete with proxy and method call recorder
+      # It works out which isolation it needs to create and provide and initializes the
+      # method call recorder
+      def for(subject, recorder = MethodCallRecorder.new, expectations = Expectations.new)
+        context = IsolatorContext.new subject, recorder, expectations
+
+        isolator = RubyIsolator.for context
+        isolation = new(isolator, context)
+        isolation
+      end
+            
+    end
+
+    protected
+
+    def internal_create_override(method_name, mode=:instance, &block)
+      builder = ExpectationBuilder.new method_name
+      block.call builder if block
+      exp = builder.build
+      expectations.add_expectation exp, mode
+      exp
+    end
+
+    def internal_verify(method_name, mode=:instance, &block)
+      verification = Verification.new(method_name, recorder, mode)
+      block.call verification unless block.nil?
+      verification
+    end
+  end
+
+  # +Mock+ is a synonym for +Isolation+ so you can still use it if you're that way inclined
+  Mock = Isolation unless defined? Mock
+
+  # +Stub+ is a synonym for +Isolation+ so you can still use it if you're that way inclined
+  Stub = Isolation unless defined? Stub
+
 end

data/lib/caricature/isolator.rb

@@ -1,303 +1,303 @@
-require 'rubygems'
-require 'uuidtools'
-require File.dirname(__FILE__) + '/messenger'
-require File.dirname(__FILE__) + '/descriptor'
-
-module Caricature
-
-  # Groups the methods for interception together
-  # this is a mix-in for the created isolations for classes
-  module Interception
-
-    # the class methods of this intercepting object
-    module ClassMethods
-
-      # the context of this isolation instance.
-      # this context takes care of responding to method calls etc.
-      def isolation_context
-        @___context___
-      end
-
-      # Replaces the call to the proxy with the one you create with this method.
-      # You can specify more specific criteria in the block to configure the expectation.
-      #
-      # Example:
-      #
-      #     an_isolation.class.when_receiving(:a_method) do |method_call|
-      #       method_call.with(3, "a").return(5)
-      #     end
-      #
-      # is equivalent to:
-      #
-      #     an_isolation.class.when_receiving(:a_method).with(3, "a").return(5)
-      #
-      # You will most likely use this method when you want your stubs to return something else than +nil+
-      # when they get called during the run of the test they are defined in.
-      def when_receiving(method_name, &block)
-        isolation_context.create_class_override method_name, &block
-      end
-
-      # Verifies whether the specified method has been called
-      # You can specify constraints in the block
-      #
-      # The most complex configuration you can make currently is one that is constrained by arguments.
-      # This is most likely to be extended in the future to allow for more complex verifications.
-      #
-      # Example:
-      #
-      #     an_isolation.class.did_receive?(:a_method) do |method_call|
-      #       method_call.with(3, "a")
-      #     end.should.be.successful
-      #
-      # is equivalent to:
-      #
-      #     an_isolation.class.did_receive?(:a_method).with(3, "a").should.be.successful
-      #
-      # You will probably be using this method only when you're interested in whether a method has been called
-      # during the course of the test you're running.
-      def did_receive?(method_name, &block)
-        isolation_context.class_verify method_name, &block
-      end
-
-    end
-
-    # mixes in the class methods of this module when it gets included in a class.
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    # the context of this isolation instance.
-    # this context takes care of responding to method calls etc.
-    def isolation_context
-      self.class.isolation_context
-    end
-
-    # Replaces the call to the proxy with the one you create with this method.
-    # You can specify more specific criteria in the block to configure the expectation.
-    #
-    # Example:
-    #
-    #     an_isolation.when_receiving(:a_method) do |method_call|
-    #       method_call.with(3, "a").return(5)
-    #     end
-    #
-    # is equivalent to:
-    #
-    #     an_isolation.when_receiving(:a_method).with(3, "a").return(5)
-    #
-    # You will most likely use this method when you want your stubs to return something else than +nil+
-    # when they get called during the run of the test they are defined in.
-    def when_receiving(method_name, &block)
-      isolation_context.create_override method_name, &block
-    end
-
-    # Replaces the call to the class of the proxy with the one you create with this method.
-    # You can specify more specific criteria in the block to configure the expectation.
-    #
-    # Example:
-    #
-    #     an_isolation.when_class_receives(:a_method) do |method_call|
-    #       method_call.with(3, "a").return(5)
-    #     end
-    #
-    # is equivalent to:
-    #
-    #     an_isolation.when_class_receives(:a_method).with(3, "a").return(5)
-    #
-    # You will most likely use this method when you want your stubs to return something else than +nil+
-    # when they get called during the run of the test they are defined in.
-    def when_class_receives(method_name, &block)
-      self.class.when_receiving method_name, &block
-    end
-
-    # Verifies whether the specified method has been called
-    # You can specify constraints in the block
-    #
-    # The most complex configuration you can make currently is one that is constrained by arguments.
-    # This is most likely to be extended in the future to allow for more complex verifications.
-    #
-    # Example:
-    #
-    #     an_isolation.did_receive?(:a_method) do |method_call|
-    #       method_call.with(3, "a")
-    #     end.should.be.successful
-    #
-    # is equivalent to:
-    #
-    #     an_isolation.did_receive?(:a_method).with(3, "a").should.be.successful
-    #
-    # You will probably be using this method only when you're interested in whether a method has been called
-    # during the course of the test you're running.
-    def did_receive?(method_name, &block)
-      isolation_context.verify method_name, &block
-    end
-
-    # Verifies whether the specified class method has been called
-    # You can specify constraints in the block
-    #
-    # The most complex configuration you can make currently is one that is constrained by arguments.
-    # This is likely to be extended in the future to allow for more complex verifications.
-    #
-    # Example:
-    #
-    #     an_isolation.did_class_receive?(:a_method) do |method_call|
-    #       method_call.with(3, "a")
-    #     end.should.be.successful
-    #
-    # is equivalent to:
-    #
-    #     an_isolation.did_class_receive?(:a_method).with(3, "a").should.be.successful
-    #
-    # You will probably be using this method only when you're interested in whether a method has been called
-    # during the course of the test you're running.
-    def did_class_receive?(method_name, &block)
-      self.class.did_receive?(method_name, &block)
-    end    
-    
-    # Initializes the underlying subject
-    # It expects the constructor parameters if they are needed.
-    def with_subject(*args, &b)
-      isolation_context.instance = self.class.superclass.new *args 
-      b.call self if b
-      self
-    end
-
-  end
-
-  # A base class for +Isolator+ objects
-  # to stick with the +Isolation+ nomenclature the strategies for creating isolations
-  # are called isolators.
-  # An isolator functions as a barrier between the code in your test and the
-  # underlying type/instance. It allows you to take control over the value
-  # that is returned from a specific method, if you want to pass the method call along to
-  # the underlying instance etc.  It also contains the ability to verify if a method
-  # was called, with which arguments etc.
-  class Isolator
-
-    # holds the isolation created by this isolator
-    attr_reader :isolation
-
-    # holds the subject of this isolator
-    attr_reader :subject
-
-    # holds the descriptor for this type of object
-    attr_reader :descriptor
-
-    # creates a new instance of an isolator
-    def initialize(context)
-      @context = context
-    end
-
-    # builds up the isolation class instance
-    def build_isolation(klass, inst=nil)
-      pxy = create_isolation_for klass
-      @isolation = pxy.new
-      @subject = inst
-      initialize_messenger
-    end
-
-    # initializes the messaging strategy for the isolator
-    def initialize_messenger
-      raise NotImplementedError
-    end
-
-    # Creates the new class name for the isolation
-    def class_name(subj)
-      nm = subj.respond_to?(:class_eval) ? subj.demodulize : subj.class.demodulize
-      @class_name = "#{nm}#{UUIDTools::UUID.random_create.to_s.gsub /-/, ''}"
-      @class_name
-    end
-
-    # Sets up the necessary instance variables for the isolation
-    def initialize_isolation(klass, context)
-      pxy = klass.new
-      pxy.instance_variable_set("@___context___", context)
-      pxy
-    end
- 
-
-    class << self
-
-      # Creates the actual proxy object for the +subject+ and initializes it with a
-      # +recorder+ and +expectations+
-      # This is the actual isolation that will be used to in your tests.
-      # It implements all the methods of the +subject+ so as long as you're in Ruby
-      # and just need to isolate out some classes defined in a statically compiled language
-      # it should get you all the way there for public instance methods at this point.
-      # when you're going to isolation for usage within a statically compiled language type
-      # then  you're bound to most of their rules. So you need to either isolate interfaces
-      # or mark the methods you want to isolate as virtual in your implementing classes.
-      def for(context)
-        context.recorder ||= MethodCallRecorder.new
-        context.expectations ||= Expectations.new
-        new(context)
-      end
-    end
-  end
-
-  # A proxy to Ruby objects that records method calls
-  # this implements all the instance methods that are defined on the class.
-  class RubyIsolator < Isolator
-
-    # implemented template method for creating Ruby isolations
-    def initialize(context)
-      super
-      klass = @context.subject.respond_to?(:class_eval) ? @context.subject : @context.subject.class
-      inst = @context.subject.respond_to?(:class_eval) ? nil : @context.subject
-      # inst = @context.subject.respond_to?(:class_eval) ? @context.subject.new : @context.subject            
-      @descriptor = RubyObjectDescriptor.new klass
-      build_isolation klass, inst
-    end
-
-    # initializes the messaging strategy for the isolator
-    def initialize_messenger
-      @context.messenger = RubyMessenger.new @context.expectations, @subject
-    end
-
-    # creates the ruby isolator for the specified subject
-    def create_isolation_for(subj)
-      imembers = @descriptor.instance_members
-      cmembers = @descriptor.class_members
-
-      klass = Object.const_set(class_name(subj), Class.new(subj))
-      klass.class_eval do
-
-        include Interception
-
-        # access to the proxied subject
-        def ___super___
-          isolation_context.instance
-        end
-
-        imembers.each do |mn|
-          mn = mn.name.to_s.to_sym
-          define_method mn do |*args|
-            b = nil
-            b = Proc.new { yield } if block_given?  
-            isolation_context.send_message(mn, nil, *args, &b)
-          end
-        end  
-        
-        def initialize(*args)  
-          self                      
-        end 
-        
-        cmembers.each do |mn|
-          mn = mn.name.to_s.to_sym
-          define_cmethod mn do |*args|        
-            return if mn.to_s =~ /$(singleton_)?method_added/ and args.first.to_s =~ /$(singleton_)?method_added/
-            b = nil
-            b = Proc.new { yield } if block_given?  
-            isolation_context.send_class_message(mn, nil, *args, &b)
-          end
-        end   
-
-      end
-
-      klass
-    end
-
-
-  end
-
+require 'rubygems'
+require 'uuidtools'
+require File.dirname(__FILE__) + '/messenger'
+require File.dirname(__FILE__) + '/descriptor'
+
+module Caricature
+
+  # Groups the methods for interception together
+  # this is a mix-in for the created isolations for classes
+  module Interception
+
+    # the class methods of this intercepting object
+    module ClassMethods
+
+      # the context of this isolation instance.
+      # this context takes care of responding to method calls etc.
+      def isolation_context
+        @___context___
+      end
+
+      # Replaces the call to the proxy with the one you create with this method.
+      # You can specify more specific criteria in the block to configure the expectation.
+      #
+      # Example:
+      #
+      #     an_isolation.class.when_receiving(:a_method) do |method_call|
+      #       method_call.with(3, "a").return(5)
+      #     end
+      #
+      # is equivalent to:
+      #
+      #     an_isolation.class.when_receiving(:a_method).with(3, "a").return(5)
+      #
+      # You will most likely use this method when you want your stubs to return something else than +nil+
+      # when they get called during the run of the test they are defined in.
+      def when_receiving(method_name, &block)
+        isolation_context.create_class_override method_name, &block
+      end
+
+      # Verifies whether the specified method has been called
+      # You can specify constraints in the block
+      #
+      # The most complex configuration you can make currently is one that is constrained by arguments.
+      # This is most likely to be extended in the future to allow for more complex verifications.
+      #
+      # Example:
+      #
+      #     an_isolation.class.did_receive?(:a_method) do |method_call|
+      #       method_call.with(3, "a")
+      #     end.should.be.successful
+      #
+      # is equivalent to:
+      #
+      #     an_isolation.class.did_receive?(:a_method).with(3, "a").should.be.successful
+      #
+      # You will probably be using this method only when you're interested in whether a method has been called
+      # during the course of the test you're running.
+      def did_receive?(method_name, &block)
+        isolation_context.class_verify method_name, &block
+      end
+
+    end
+
+    # mixes in the class methods of this module when it gets included in a class.
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    # the context of this isolation instance.
+    # this context takes care of responding to method calls etc.
+    def isolation_context
+      self.class.isolation_context
+    end
+
+    # Replaces the call to the proxy with the one you create with this method.
+    # You can specify more specific criteria in the block to configure the expectation.
+    #
+    # Example:
+    #
+    #     an_isolation.when_receiving(:a_method) do |method_call|
+    #       method_call.with(3, "a").return(5)
+    #     end
+    #
+    # is equivalent to:
+    #
+    #     an_isolation.when_receiving(:a_method).with(3, "a").return(5)
+    #
+    # You will most likely use this method when you want your stubs to return something else than +nil+
+    # when they get called during the run of the test they are defined in.
+    def when_receiving(method_name, &block)
+      isolation_context.create_override method_name, &block
+    end
+
+    # Replaces the call to the class of the proxy with the one you create with this method.
+    # You can specify more specific criteria in the block to configure the expectation.
+    #
+    # Example:
+    #
+    #     an_isolation.when_class_receives(:a_method) do |method_call|
+    #       method_call.with(3, "a").return(5)
+    #     end
+    #
+    # is equivalent to:
+    #
+    #     an_isolation.when_class_receives(:a_method).with(3, "a").return(5)
+    #
+    # You will most likely use this method when you want your stubs to return something else than +nil+
+    # when they get called during the run of the test they are defined in.
+    def when_class_receives(method_name, &block)
+      self.class.when_receiving method_name, &block
+    end
+
+    # Verifies whether the specified method has been called
+    # You can specify constraints in the block
+    #
+    # The most complex configuration you can make currently is one that is constrained by arguments.
+    # This is most likely to be extended in the future to allow for more complex verifications.
+    #
+    # Example:
+    #
+    #     an_isolation.did_receive?(:a_method) do |method_call|
+    #       method_call.with(3, "a")
+    #     end.should.be.successful
+    #
+    # is equivalent to:
+    #
+    #     an_isolation.did_receive?(:a_method).with(3, "a").should.be.successful
+    #
+    # You will probably be using this method only when you're interested in whether a method has been called
+    # during the course of the test you're running.
+    def did_receive?(method_name, &block)
+      isolation_context.verify method_name, &block
+    end
+
+    # Verifies whether the specified class method has been called
+    # You can specify constraints in the block
+    #
+    # The most complex configuration you can make currently is one that is constrained by arguments.
+    # This is likely to be extended in the future to allow for more complex verifications.
+    #
+    # Example:
+    #
+    #     an_isolation.did_class_receive?(:a_method) do |method_call|
+    #       method_call.with(3, "a")
+    #     end.should.be.successful
+    #
+    # is equivalent to:
+    #
+    #     an_isolation.did_class_receive?(:a_method).with(3, "a").should.be.successful
+    #
+    # You will probably be using this method only when you're interested in whether a method has been called
+    # during the course of the test you're running.
+    def did_class_receive?(method_name, &block)
+      self.class.did_receive?(method_name, &block)
+    end    
+    
+    # Initializes the underlying subject
+    # It expects the constructor parameters if they are needed.
+    def with_subject(*args, &b)
+      isolation_context.instance = self.class.superclass.new *args 
+      b.call self if b
+      self
+    end
+
+  end
+
+  # A base class for +Isolator+ objects
+  # to stick with the +Isolation+ nomenclature the strategies for creating isolations
+  # are called isolators.
+  # An isolator functions as a barrier between the code in your test and the
+  # underlying type/instance. It allows you to take control over the value
+  # that is returned from a specific method, if you want to pass the method call along to
+  # the underlying instance etc.  It also contains the ability to verify if a method
+  # was called, with which arguments etc.
+  class Isolator
+
+    # holds the isolation created by this isolator
+    attr_reader :isolation
+
+    # holds the subject of this isolator
+    attr_reader :subject
+
+    # holds the descriptor for this type of object
+    attr_reader :descriptor
+
+    # creates a new instance of an isolator
+    def initialize(context)
+      @context = context
+    end
+
+    # builds up the isolation class instance
+    def build_isolation(klass, inst=nil)
+      pxy = create_isolation_for klass
+      @isolation = pxy.new
+      @subject = inst
+      initialize_messenger
+    end
+
+    # initializes the messaging strategy for the isolator
+    def initialize_messenger
+      raise NotImplementedError
+    end
+
+    # Creates the new class name for the isolation
+    def class_name(subj)
+      nm = subj.respond_to?(:class_eval) ? subj.demodulize : subj.class.demodulize
+      @class_name = "#{nm}#{UUIDTools::UUID.random_create.to_s.gsub /-/, ''}"
+      @class_name
+    end
+
+    # Sets up the necessary instance variables for the isolation
+    def initialize_isolation(klass, context)
+      pxy = klass.new
+      pxy.instance_variable_set("@___context___", context)
+      pxy
+    end
+ 
+
+    class << self
+
+      # Creates the actual proxy object for the +subject+ and initializes it with a
+      # +recorder+ and +expectations+
+      # This is the actual isolation that will be used to in your tests.
+      # It implements all the methods of the +subject+ so as long as you're in Ruby
+      # and just need to isolate out some classes defined in a statically compiled language
+      # it should get you all the way there for public instance methods at this point.
+      # when you're going to isolation for usage within a statically compiled language type
+      # then  you're bound to most of their rules. So you need to either isolate interfaces
+      # or mark the methods you want to isolate as virtual in your implementing classes.
+      def for(context)
+        context.recorder ||= MethodCallRecorder.new
+        context.expectations ||= Expectations.new
+        new(context)
+      end
+    end
+  end
+
+  # A proxy to Ruby objects that records method calls
+  # this implements all the instance methods that are defined on the class.
+  class RubyIsolator < Isolator
+
+    # implemented template method for creating Ruby isolations
+    def initialize(context)
+      super
+      klass = @context.subject.respond_to?(:class_eval) ? @context.subject : @context.subject.class
+      inst = @context.subject.respond_to?(:class_eval) ? nil : @context.subject
+      # inst = @context.subject.respond_to?(:class_eval) ? @context.subject.new : @context.subject            
+      @descriptor = RubyObjectDescriptor.new klass
+      build_isolation klass, inst
+    end
+
+    # initializes the messaging strategy for the isolator
+    def initialize_messenger
+      @context.messenger = RubyMessenger.new @context.expectations, @subject
+    end
+
+    # creates the ruby isolator for the specified subject
+    def create_isolation_for(subj)
+      imembers = @descriptor.instance_members
+      cmembers = @descriptor.class_members
+
+      klass = Object.const_set(class_name(subj), Class.new(subj))
+      klass.class_eval do
+
+        include Interception
+
+        # access to the proxied subject
+        def ___super___
+          isolation_context.instance
+        end
+
+        imembers.each do |mn|
+          mn = mn.name.to_s.to_sym
+          define_method mn do |*args|
+            b = nil
+            b = Proc.new { yield } if block_given?  
+            isolation_context.send_message(mn, nil, *args, &b)
+          end
+        end  
+        
+        def initialize(*args)  
+          self                      
+        end 
+        
+        cmembers.each do |mn|
+          mn = mn.name.to_s.to_sym
+          define_cmethod mn do |*args|        
+            return if mn.to_s =~ /$(singleton_)?method_added/ and args.first.to_s =~ /$(singleton_)?method_added/
+            b = nil
+            b = Proc.new { yield } if block_given?  
+            isolation_context.send_class_message(mn, nil, *args, &b)
+          end
+        end   
+
+      end
+
+      klass
+    end
+
+
+  end
+
 end