Merge e2ac7a8 into 4b305ab

README.md

@@ -97,3 +97,5 @@ end
 - record call signatures/return values
 - checking return values
 
+- add exceptions around .on_any_instance
+- clean up tests around when {}, call count, exclusive spying (e.g. one instance/including class and not the other)

lib/spy/api.rb

@@ -10,14 +10,15 @@ module API
     def on(*args)
       case args.length
       when 2
-        return core.add_spy *(args << :method)
+        spied, msg = *args
+        return core.add_spy(spied, spied.method(msg))
       end
       raise ArgumentError
     end
 
     # TODO docs
-    def on_any_instance(mod, msg)
-      core.add_spy(mod, msg, :instance_method)
+    def on_any_instance(spied, msg)
+      core.add_spy(spied, spied.instance_method(msg))
     end
 
     # Stops spying on the method and restores its original functionality
@@ -37,9 +38,11 @@ def restore(*args)
       when 1
         return core.remove_all_spies if args.first == :all
       when 2
-        return core.remove_spy *(args << :method)
+        spied, msg = *args
+        return core.remove_spy(spied, spied.method(msg))
       when 3
-        return core.remove_spy *args
+        spied, msg, method_type = *args
+        return core.remove_spy(spied, spied.send(method_type, msg))
       end
       raise ArgumentError
     end

lib/spy/collection.rb

@@ -31,13 +31,19 @@ def each
     # Add a slicker interface that abstracts away Collection::Entry
     module SpyHelper
       def <<(spy)
-        entry = Collection::Entry.new(spy.receiver, spy.msg, spy.method_type)
+        receiver = spy.original.is_a?(Method) ? spy.original.receiver : nil
+        name = spy.original.name
+        klass = spy.original.class
+        entry = Collection::Entry.new(receiver, name, klass)
         entry.value = spy
         insert entry
       end
 
-      def pop(receiver, msg, method_type)
-        remove Collection::Entry.new(receiver, msg, method_type)
+      def pop(method)
+        receiver = method.is_a?(Method) ? method.receiver : nil
+        name = method.name
+        klass = method.class
+        remove Collection::Entry.new(receiver, name, klass)
       end
     end
 

lib/spy/core.rb

@@ -8,14 +8,14 @@ def spy_collection
       @spy_collection ||= Collection.new
     end
 
-    def add_spy(receiver, msg, method_type)
-      spy = Instance.new(receiver, msg, method_type)
+    def add_spy(spied, method)
+      spy = Instance.new(spied, method)
       spy_collection << spy
       spy.start
     end
 
-    def remove_spy(receiver, msg, method_type)
-      spy = spy_collection.pop(receiver, msg, method_type)
+    def remove_spy(spied, method)
+      spy = spy_collection.pop(method)
       spy.stop
     end
 

lib/spy/instance.rb

@@ -1,48 +1,31 @@
 require 'spy/callbacks/with_args'
 require 'spy/callbacks/when'
+require 'spy/instance/strategy'
 
 # An instance of a spied method
 # - Holds a reference to the original method
 # - Wraps the original method
 # - Provides hooks for callbacks
 module Spy
   class Instance
-    attr_reader :receiver, :method_type, :msg, :original, :call_count, :visibility
+    attr_reader :original, :spied, :strategy, :call_count, :visibility
 
-    def initialize(receiver, msg, method_type)
-      @msg = msg
-      @receiver = receiver
-      @method_type = method_type
+    def initialize(spied, original)
+      @spied = spied
+      @original = original
+      @visibility = extract_visibility
       @before_filters = []
       @call_count = 0
-
-      # Cache the original method for unwrapping later
-      @original = @receiver.send(method_type, msg)
-      @visibility = extract_visibility
+      @strategy = Strategy.factory_build(self)
     end
 
     def start
-      context = self
-      original.owner.instance_eval do
-        define_method context.msg do |*args|
-          context.before_call(*args)
-          if context.original.respond_to? :bind
-            result = context.original.bind(self).call(*args)
-          else
-            result = context.original.call(*args)
-          end
-          result
-        end
-        send(context.visibility, context.msg)
-      end
+      @strategy.apply
       self
     end
 
     def stop
-      context = self
-      original.owner.instance_eval do
-        define_method context.msg, context.original
-      end
+      @strategy.undo
       self
     end
 
@@ -69,11 +52,11 @@ def extract_visibility
       owner = @original.owner
       [:public, :protected, :private].each do |vis|
         query = "#{vis}_method_defined?"
-        if owner.respond_to?(query) && owner.send(query, @msg)
+        if owner.respond_to?(query) && owner.send(query, @original.name)
           return vis
         end
       end
-      raise NoMethodError, "couldn't find method #{@msg} belonging to #{owner}"
+      raise NoMethodError, "couldn't find method #{@original.name} belonging to #{owner}"
     end
   end
 end

lib/spy/instance/strategy.rb

@@ -0,0 +1,26 @@
+require 'spy/instance/strategy/wrap'
+require 'spy/instance/strategy/intercept'
+
+module Spy
+  class Instance
+    module Strategy
+      class << self
+        def factory_build(spy)
+          if spy.original.is_a?(Method)
+            if spy.original.owner == spy.spied.singleton_class
+              Strategy::Wrap.new(spy)
+            else
+              Strategy::Intercept.new(spy, spy.spied.singleton_class)
+            end
+          else
+            if spy.original.owner == spy.spied
+              Strategy::Wrap.new(spy)
+            else
+              Strategy::Intercept.new(spy, spy.spied)
+            end
+          end
+        end
+      end
+    end
+  end
+end

lib/spy/instance/strategy/intercept.rb

@@ -0,0 +1,30 @@
+module Spy
+  class Instance
+    module Strategy
+      class Intercept
+        def initialize(spy, intercept_target)
+          @spy = spy
+          @intercept_target = intercept_target
+        end
+
+        def apply
+          spy = @spy
+          @intercept_target.class_eval do
+            define_method spy.original.name do |*args|
+              spy.before_call(*args)
+              spy.original.call(*args)
+            end
+            send(spy.visibility, spy.original.name)
+          end
+        end
+
+        def undo
+          spy = @spy
+          @intercept_target.class_eval do
+            remove_method spy.original.name
+          end
+        end
+      end
+    end
+  end
+end

lib/spy/instance/strategy/wrap.rb

@@ -0,0 +1,35 @@
+module Spy
+  class Instance
+    module Strategy
+      class Wrap
+        def initialize(spy)
+          @spy = spy
+        end
+
+        def apply
+          spy = @spy
+          spy.original.owner.class_eval do
+            define_method spy.original.name do |*args|
+              spy.before_call(*args)
+              if spy.original.is_a?(UnboundMethod)
+                spy.original.bind(self).call(*args)
+              else
+                spy.original.call(*args)
+              end
+            end
+            send(spy.visibility, spy.original.name)
+          end
+        end
+
+        def undo
+          spy = @spy
+          spy.original.owner.class_eval do
+            remove_method spy.original.name
+            define_method spy.original.name, spy.original
+            send(spy.visibility, spy.original.name)
+          end
+        end
+      end
+    end
+  end
+end