spy_rb 2.1.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1fc7717987d2a804c55203a19a3a665d33f96f58
-  data.tar.gz: 517c1723f922c931ff5e745694b491b289798a7e
+  metadata.gz: 17d070307a491deecda090c82e836fdef23ee5cd
+  data.tar.gz: c50f4e881b3a1387ca83918a6f4213ccab5ca7bd
 SHA512:
-  metadata.gz: 75da4d827d5b93e47dfe145321f17d8c8a41fca8f550477e9e3d10c7922c7a7567dcce3a7da3c645a322584079ad810b699d4e9b5ad35aa28505d0af40f4b8fe
-  data.tar.gz: e91d8363fff8c5675af653b778d47447da235db493d6325d1d19fec06b0c4f8e4e8447910bcfc5ad2dd26052a8bce6c9743c9de88f7afd660f00cc93fdb367ad
+  metadata.gz: 28e4f0bc37039af35f5b6a0c75d14cc85148306bb34ddb4dd270c452cd7452864226601a70392620c300f2618ab7d5119520cc8aa0f1f79cbed99fe1aaa7ba11
+  data.tar.gz: 160210e00e62cc3effe46a3130d59bd746d0ca0d280ed9996cd858d2a39a4c9c4855921a15f91ae3e7f41afb28b0f2daf3e0163372f80a5aebed30c318a8fa53

data/lib/spy/api.rb

@@ -1,4 +1,5 @@
 require 'spy/core'
+require 'spy/blueprint'
 
 module Spy
   # The core module that users will interface. `Spy::API` is implemented
@@ -20,7 +21,13 @@ module Spy
     # @param [Symbol] msg - the name of the method to spy on
     # @returns [Spy::Instance]
     def on(target, msg)
-      core.add_spy(target, target.method(msg))
+      if target.methods.include?(msg)
+        core.add_spy(Blueprint.new(target, msg, :method))
+      elsif target.respond_to?(msg)
+        core.add_spy(Blueprint.new(target, msg, :dynamic_delegation))
+      else
+        raise ArgumentError
+      end
     end
 
     # Spies on calls to a method made on any instance of some class or module
@@ -30,7 +37,23 @@ module Spy
     # @returns [Spy::Instance]
     def on_any_instance(target, msg)
       raise ArgumentError unless target.respond_to?(:instance_method)
-      core.add_spy(target, target.instance_method(msg))
+      core.add_spy(Blueprint.new(target, msg, :instance_method))
+    end
+
+    # Spies on all of the calls made to the given object
+    #
+    # @param object - the thing to spy on
+    # @returns [Spy::Multi]
+    def on_object(object)
+      core.add_multi_spy(Blueprint.new(object, :all, :methods))
+    end
+
+    # Spies on all of the calls made to the given class or module
+    #
+    # @param klass - the thing to spy on
+    # @returns [Spy::Multi]
+    def on_class(klass)
+      core.add_multi_spy(Blueprint.new(klass, :all, :instance_methods))
     end
 
     # Stops spying on the method and restores its original functionality
@@ -43,9 +66,9 @@ module Spy
     #
     #   Spy.restore(receiver, msg)
     #
-    # @example stop spying on the given object, message, and method type (e.g. :instance_method)
+    # @example stop spying on the given object, message, and type (e.g. :method, :instance_method, :dynamic_delegation)
     #
-    #   Spy.restore(object, msg, method_type)
+    #   Spy.restore(object, msg, type)
     #
     # @param args - supports multiple signatures
     def restore(*args)
@@ -54,10 +77,10 @@ module Spy
         core.remove_all_spies if args.first == :all
       when 2
         target, msg = *args
-        core.remove_spy(target, target.method(msg))
+        core.remove_spy(Blueprint.new(target, msg, :method))
       when 3
-        target, msg, method_type = *args
-        core.remove_spy(target, target.send(method_type, msg))
+        target, msg, type = *args
+        core.remove_spy(Blueprint.new(target, msg, type))
       else
         raise ArgumentError
       end

data/lib/spy/blueprint.rb

@@ -0,0 +1,22 @@
+module Spy
+  class Blueprint
+    attr_reader :target, :msg, :type
+
+    def initialize(target, msg, type)
+      @target = target
+      @msg = msg
+      @type = type
+      @caller = _caller
+    end
+
+    alias :_caller :caller
+
+    def caller
+      @caller
+    end
+
+    def to_s
+      [@target.object_id, @msg, @type].join("|")
+    end
+  end
+end

data/lib/spy/core.rb

@@ -1,5 +1,6 @@
 require 'spy/instance'
 require 'spy/registry'
+require 'spy/multi'
 require 'spy/errors'
 
 module Spy
@@ -9,43 +10,60 @@ module Spy
   # Syntactic sugar (like `Spy.restore(object, msg)` vs `Spy.restore(:all)`)
   # should be handled in `Spy::API` and utilize `Spy::Core`
   class Core
+    UNSAFE_METHODS = [:object_id, :__send__, :__id__, :method, :singleton_class]
+
+    def initialize
+      @registry = Registry.new
+    end
+
     # Start spying on the given object and method
     #
-    # @param [Object] object - the object to spy on
-    # @param [Method, UnboundMethod] method - the method to spy on
+    # @param [Spy::Blueprint] blueprint - data for building the spy
     # @returns [Spy::Instance]
     # @raises [Spy::Errors::AlreadySpiedError] if the method is already
     #   being spied on
-    def add_spy(object, method)
-      raise Errors::AlreadySpiedError if registry.include?(object, method)
-      spy = Instance.new(object, method)
-      registry.insert(object, method, spy)
+    def add_spy(blueprint)
+      if prev = @registry.get(blueprint)
+        raise Errors::AlreadySpiedError.new("Already spied on here:\n\t#{prev[0].caller.join("\n\t")}")
+      end
+      spy = Instance.new(blueprint)
+      @registry.insert(blueprint, spy)
       spy.start
     end
 
+    # Start spying on all of the given objects and methods
+    #
+    # @param [Spy::Blueprint] blueprint - data for building the spy
+    # @returns [Spy::Multi]
+    def add_multi_spy(multi_blueprint)
+      target = multi_blueprint.target
+      type = multi_blueprint.type
+      methods = target.public_send(type).reject(&method(:unsafe_method?))
+      spies = methods.map do |method_name|
+        singular_type = type.to_s.sub(/s$/, '').to_sym
+        add_spy(Blueprint.new(multi_blueprint.target, method_name, singular_type))
+      end
+      Multi.new(spies)
+    end
+
     # Stop spying on the given object and method
     #
-    # @param [Object] object - the object being spied on
-    # @param [Method, UnboundMethod] method - the method to stop spying on
     # @raises [Spy::Errors::MethodNotSpiedError] if the method is not already
     #   being spied on
-    def remove_spy(object, method)
-      spy = registry.remove(object, method)
+    def remove_spy(blueprint)
+      spy = @registry.remove(blueprint)
       spy.stop
     end
 
     # Stops spying on all objects and methods
-    #
-    # @raises [Spy::Errors::UnableToEmptySpyRegistryError] if for some reason
-    #   a spy was not removed
     def remove_all_spies
-      registry.remove_all(&:stop)
+      @registry.remove_all.each(&:stop)
     end
 
     private
 
-    def registry
-      @registry ||= Registry.new
+    def unsafe_method?(name)
+      UNSAFE_METHODS.include?(name)
     end
   end
 end

data/lib/spy/determine_visibility.rb

@@ -0,0 +1,16 @@
+module Spy
+  module DetermineVisibility
+    # @param [Method, UnboundMethod] method
+    # @returns [Symbol] whether the method is public, private, or protected
+    def self.call(method)
+      owner = method.owner
+      %w(public private protected).each do |vis|
+        query = "#{vis}_method_defined?"
+        if owner.respond_to?(query) && owner.send(query, method.name)
+          return vis
+        end
+      end
+      raise NoMethodError, "couldn't find method #{method.name} belonging to #{owner}"
+    end
+  end
+end

data/lib/spy/errors.rb

@@ -1,7 +1,7 @@
 module Spy
   module Errors
-    MethodNotSpiedError           = Class.new(StandardError)
-    AlreadySpiedError             = Class.new(StandardError)
-    UnableToEmptySpyRegistryError = Class.new(StandardError)
+    Error = Class.new(StandardError)
+    MethodNotSpiedError = Class.new(Spy::Errors::Error)
+    AlreadySpiedError = Class.new(Spy::Errors::Error)
   end
 end

data/lib/spy/fake_method.rb

@@ -0,0 +1,14 @@
+module Spy
+  class FakeMethod
+    attr_reader :name
+
+    def initialize(name, &block)
+      @name = name
+      @block = block
+    end
+
+    def call(*args, &block)
+      @block.call(*args, &block)
+    end
+  end
+end

data/lib/spy/instance.rb

@@ -1,5 +1,6 @@
-require 'spy/instance/strategy'
-require 'spy/instance/api/internal'
+require 'spy/fake_method'
+require 'spy/strategy/wrap'
+require 'spy/strategy/intercept'
 
 # An instance of a spied method
 # - Holds a reference to the original method
@@ -7,21 +8,30 @@ require 'spy/instance/api/internal'
 # - Provides hooks for callbacks
 module Spy
   class Instance
-    include API::Internal
+    attr_reader :original, :spied, :strategy, :call_history
 
-    attr_reader :original, :spied, :strategy, :visibility, :call_history
+    def initialize(blueprint)
+      original =
+        case blueprint.type
+        when :dynamic_delegation
+          FakeMethod.new(blueprint.msg) { |*args, &block| blueprint.target.method_missing(blueprint.msg, *args, &block) }
+        when :instance_method
+          blueprint.target.instance_method(blueprint.msg)
+        else
+          blueprint.target.method(blueprint.msg)
+        end
 
-    def initialize(spied, original)
-      @spied = spied
       @original = original
-      @visibility = extract_visibility
-      @conditional_filters = []
-      @before_callbacks = []
-      @after_callbacks = []
-      @around_procs = []
+      @spied = blueprint.target
+      @strategy = choose_strategy(blueprint)
       @call_history = []
-      @strategy = Strategy.factory_build(self)
-      @instead = nil
+
+      @internal = {}
+      @internal[:conditional_filters] = []
+      @internal[:before_callbacks] = []
+      @internal[:after_callbacks]= []
+      @internal[:around_procs] = []
+      @internal[:instead]= nil
     end
 
     def name
@@ -47,42 +57,42 @@ module Spy
     end
 
     def when(&block)
-      @conditional_filters << block
+      @internal[:conditional_filters] << block
       self
     end
 
     # Expect block to yield. Call the rest of the chain
     # when it does
     def wrap(&block)
-      @around_procs << block
+      @internal[:around_procs] << block
       self
     end
 
     def before(&block)
-      @before_callbacks << block
+      @internal[:before_callbacks] << block
       self
     end
 
     def after(&block)
-      @after_callbacks << block
+      @internal[:after_callbacks] << block
       self
     end
 
     def instead(&block)
-      @instead = block
+      @internal[:instead] = block
+      self
     end
 
     private
 
-    def extract_visibility
-      owner = @original.owner
-      [:public, :protected, :private].each do |vis|
-        query = "#{vis}_method_defined?"
-        if owner.respond_to?(query) && owner.send(query, @original.name)
-          return vis
-        end
+    def choose_strategy(blueprint)
+      if blueprint.type == :dynamic_delegation
+        Strategy::Intercept.new(self)
+      elsif @original.owner == @spied || @original.owner == @spied.singleton_class
+        Strategy::Wrap.new(self)
+      else
+        Strategy::Intercept.new(self)
       end
-      raise NoMethodError, "couldn't find method #{@original.name} belonging to #{owner}"
     end
   end
 end

data/lib/spy/method_call.rb

@@ -1,14 +1,15 @@
 module Spy
   class MethodCall
-    attr_reader :name, :receiver, :args, :block
+    attr_reader :name, :receiver, :caller, :args, :block
     attr_accessor :result
 
-    def initialize(replayer, name, receiver, *args)
+    def initialize(replayer, name, receiver, method_caller, *args)
       @replayer = replayer
       @name     = name
       @receiver = receiver
       @args     = args
-      @block    = proc { receiver.instance_eval &Proc.new } if block_given?
+      @caller   = method_caller
+      @block    = proc { receiver.instance_eval(&Proc.new) } if block_given?
     end
 
     def replay

data/lib/spy/multi.rb

@@ -0,0 +1,21 @@
+module Spy
+  class Multi
+    attr_reader :spies
+
+    def initialize(spies)
+      @spies = spies
+    end
+
+    def call_count
+      @spies.map(&:call_count).reduce(&:+)
+    end
+
+    def [](name)
+      @spies.find { |spy| spy.name == name }
+    end
+
+    def uncalled
+      @spies.select { |spy| spy.call_count == 0 }
+    end
+  end
+end

data/lib/spy/registry.rb

@@ -1,56 +1,44 @@
 require 'spy/errors'
-require 'spy/registry_store'
-require 'spy/registry_entry'
 
 module Spy
   # Responsible for managing the top-level state of which spies exist.
   class Registry
+    def initialize
+      @store = {}
+    end
+
     # Keeps track of the spy for later management. Ensures spy uniqueness
     #
-    # @param [Object] spied - the object being spied on
-    # @param [Method, UnboundMethod] method - the method being spied on
+    # @param [Spy::Blueprint]
     # @param [Spy::Instance] spy - the instantiated spy
     # @raises [Spy::Errors::AlreadySpiedError] if the spy is already being
     #   tracked
-    def insert(spied, method, spy)
-      entry = RegistryEntry.new(spied, method, spy)
-      raise Errors::AlreadySpiedError if store.include? entry
-      store.insert(entry)
+    def insert(blueprint, spy)
+      key = blueprint.to_s
+      raise Errors::AlreadySpiedError if @store[key]
+      @store[key] = [blueprint, spy]
     end
 
     # Stops tracking the spy
     #
-    # @param [Object] spied - the object being spied on
-    # @param [Method, UnboundMethod] method - the method being spied on
+    # @param [Spy::Blueprint]
     # @raises [Spy::Errors::MethodNotSpiedError] if the spy isn't being tracked
-    def remove(spied, method)
-      entry = RegistryEntry.new(spied, method, nil)
-      raise Errors::MethodNotSpiedError unless store.include? entry
-      store.remove(entry).spy
+    def remove(blueprint)
+      key = blueprint.to_s
+      raise Errors::MethodNotSpiedError unless @store[key]
+      @store.delete(key)[1]
     end
 
     # Stops tracking all spies
-    #
-    # @raises [Spy::Errors::UnableToEmptySpyRegistryError] if any spies were
-    #   still being tracked after removing all of the spies
     def remove_all
-      store.map { |e| yield remove(e.spied, e.method) }
-      raise Errors::UnableToEmptySpyRegistryError unless store.empty?
+      store = @store
+      @store = {}
+      store.values.map(&:last)
     end
 
-    # Returns whether or not the object and method are already being spied on
-    #
-    # @returns [Boolean] whether or not the object and method are already being
-    #   spied on
-    def include?(spied, method)
-      entry = RegistryEntry.new(spied, method)
-      store.include? entry
-    end
-
-    private
-
-    def store
-      @store ||= RegistryStore.new
+    def get(blueprint)
+      key = blueprint.to_s
+      @store[key]
     end
   end
 end

data/lib/spy/strategy/base.rb

@@ -0,0 +1,89 @@
+require 'spy/method_call'
+
+module Spy
+  module Strategy
+    module Base
+      class << self
+        def call(spy, receiver, *args, &block)
+          spy.instance_eval do
+            # TODO - abstract the method call into an object and cache this in
+            #   method using an instance variable instead of a local variable.
+            #   This will let us be a bit more elegant about how we do before/after
+            #   callbacks. We can also merge MethodCall with this responsibility so
+            #   it isn't just a data struct
+            is_active = if @internal[:conditional_filters].any?
+                          mc = Spy::Strategy::Base._build_method_call(spy, receiver, *args, &block)
+                          @internal[:conditional_filters].all? { |f| f.call(mc) }
+                        else
+                          true
+                        end
+
+            return Spy::Strategy::Base._call_original(spy, receiver, *args, &block) unless is_active
+
+            if @internal[:before_callbacks].any?
+              mc = Spy::Strategy::Base._build_method_call(spy, receiver, *args, &block)
+              @internal[:before_callbacks].each { |f| f.call(mc) }
+            end
+
+            if @internal[:around_procs].any?
+              mc = Spy::Strategy::Base._build_method_call(spy, receiver, *args, &block)
+
+              # Procify the original call
+              # Still return the result from it
+              result = nil
+              original_proc = proc do
+                result = Spy::Strategy::Base._call_and_record(spy, receiver, args, { :record => mc }, &block)
+              end
+
+              # Keep wrapping the original proc with each around_proc
+              @internal[:around_procs].reduce(original_proc) do |p, wrapper|
+                proc { wrapper.call(mc, &p) }
+              end.call
+            else
+              result = Spy::Strategy::Base._call_and_record(spy, receiver, args, &block)
+            end
+
+            if @internal[:after_callbacks].any?
+              mc = @call_history.last
+              @internal[:after_callbacks].each { |f| f.call(mc) }
+            end
+
+            result
+          end
+        end
+
+        def _build_method_call(spy, receiver, *args, &block)
+          Spy::MethodCall.new(
+            proc { Spy::Strategy::Base._call_original(spy, receiver, *args, &block) },
+            spy.original.name,
+            receiver,
+            caller[7..-1],
+            *args,
+            &block)
+        end
+
+        def _call_and_record(spy, receiver, args, opts = {}, &block)
+          spy.instance_eval do
+            if @internal[:instead]
+              @internal[:instead].call(Spy::Strategy::Base._build_method_call(spy, receiver, *args, &block))
+            else
+              record = opts[:record] || Spy::Strategy::Base._build_method_call(spy, receiver, *args, &block)
+              @call_history << record
+
+              result = Spy::Strategy::Base._call_original(spy, receiver, *args, &block)
+              record.result = result
+            end
+          end
+        end
+
+        def _call_original(spy, receiver, *args, &block)
+          if spy.original.is_a?(UnboundMethod)
+            spy.original.bind(receiver).call(*args, &block)
+          else
+            spy.original.call(*args, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spy/strategy/intercept.rb

@@ -0,0 +1,44 @@
+require 'spy/determine_visibility'
+require 'spy/strategy/base'
+
+module Spy
+  module Strategy
+    class Intercept
+      def initialize(spy)
+        @spy = spy
+        @target =
+          case spy.original
+          when Method
+            spy.spied.singleton_class
+          when UnboundMethod
+            spy.spied
+          when FakeMethod
+            spy.spied.singleton_class
+          end
+      end
+
+      def apply
+        spy = @spy
+        @target.class_eval do
+          # Add the spy to the intercept target
+          define_method spy.original.name do |*args, &block|
+            Spy::Strategy::Base.call(spy, self, *args, &block)
+          end
+
+          # Make the visibility of the spy match the spied original
+          unless spy.original.is_a?(FakeMethod)
+            visibility = DetermineVisibility.call(spy.original)
+            send(visibility, spy.original.name)
+          end
+        end
+      end
+
+      def undo
+        spy = @spy
+        @target.class_eval do
+          remove_method spy.original.name
+        end
+      end
+    end
+  end
+end

data/lib/spy/strategy/wrap.rb

@@ -0,0 +1,39 @@
+require 'spy/determine_visibility'
+require 'spy/strategy/base'
+
+module Spy
+  module Strategy
+    class Wrap
+      def initialize(spy)
+        @spy = spy
+        @visibility = DetermineVisibility.call(spy.original)
+      end
+
+      def apply
+        spy = @spy
+        visibility = @visibility
+        @spy.original.owner.class_eval do
+          undef_method spy.original.name
+
+          # Replace the method with the spy
+          define_method spy.original.name do |*args, &block|
+            Spy::Strategy::Base.call(spy, self, *args, &block)
+          end
+
+          # Make the visibility of the spy match the spied original
+          send(visibility, spy.original.name)
+        end
+      end
+
+      def undo
+        spy = @spy
+        visibility = @visibility
+        spy.original.owner.class_eval do
+          remove_method spy.original.name
+          define_method spy.original.name, spy.original
+          send(visibility, spy.original.name)
+        end
+      end
+    end
+  end
+end

data/lib/spy/version.rb

@@ -1,3 +1,3 @@
 module Spy
-  VERSION = '2.1.0'
+  VERSION = '3.0.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spy_rb
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Josh Bodah
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-01 00:00:00.000000000 Z
+date: 2018-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -38,24 +38,10 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: minitest-tagz
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-description: Spy brings everything that's great about Sinon.JS to Ruby. Mocking frameworks
-  work by stubbing out functionality. Spy works by listening in on functionality and
-  allowing it to run in the background. Spy is designed to be lightweight and work
-  alongside Mocking frameworks instead of trying to replace them entirely.
+description: Mocking frameworks work by stubbing out functionality. Spy works by listening
+  in on functionality and allowing it to run in the background. Spy is designed to
+  be lightweight and work alongside Mocking frameworks instead of trying to replace
+  them entirely.
 email: jb3689@yahoo.com
 executables: []
 extensions: []
@@ -63,17 +49,18 @@ extra_rdoc_files: []
 files:
 - lib/spy.rb
 - lib/spy/api.rb
+- lib/spy/blueprint.rb
 - lib/spy/core.rb
+- lib/spy/determine_visibility.rb
 - lib/spy/errors.rb
+- lib/spy/fake_method.rb
 - lib/spy/instance.rb
-- lib/spy/instance/api/internal.rb
-- lib/spy/instance/strategy.rb
-- lib/spy/instance/strategy/intercept.rb
-- lib/spy/instance/strategy/wrap.rb
 - lib/spy/method_call.rb
+- lib/spy/multi.rb
 - lib/spy/registry.rb
-- lib/spy/registry_entry.rb
-- lib/spy/registry_store.rb
+- lib/spy/strategy/base.rb
+- lib/spy/strategy/intercept.rb
+- lib/spy/strategy/wrap.rb
 - lib/spy/version.rb
 homepage: https://github.com/jbodah/spy_rb
 licenses:
@@ -95,8 +82,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
-summary: SinonJS-style Test Spies for Ruby
+summary: Test Spies for Ruby
 test_files: []

data/lib/spy/instance/api/internal.rb

@@ -1,104 +0,0 @@
-require 'spy/method_call'
-
-module Spy
-  class Instance
-    module API
-      # The API we expose internally to our collaborators
-      module Internal
-        # TODO: Not sure if this is the best place for this
-        #
-        # Defines the spy on the target object
-        def attach_to(target)
-          spy = self
-          target.class_eval do
-            define_method spy.original.name do |*args, &block|
-              spy.call(self, *args, &block)
-            end
-            send(spy.visibility, spy.original.name)
-          end
-        end
-
-        # Call the spied method using the given receiver and arguments.
-        #
-        # receiver is required to allow calling of UnboundMethods such as
-        # instance methods defined on a Class
-        def call(receiver, *args, &block)
-          # TODO - abstract the method call into an object and cache this in
-          #   method using an instance variable instead of a local variable.
-          #   This will let us be a bit more elegant about how we do before/after
-          #   callbacks. We can also merge MethodCall with this responsibility so
-          #   it isn't just a data struct
-          is_active = if @conditional_filters.any?
-                        mc = build_method_call(receiver, *args, &block)
-                        @conditional_filters.all? { |f| f.call(mc) }
-                      else
-                        true
-                      end
-
-          return call_original(receiver, *args, &block) unless is_active
-
-          if @before_callbacks.any?
-            mc = build_method_call(receiver, *args, &block)
-            @before_callbacks.each { |f| f.call(mc) }
-          end
-
-          if @around_procs.any?
-            mc = build_method_call(receiver, *args, &block)
-
-            # Procify the original call
-            # Still return the result from it
-            result = nil
-            original_proc = proc do
-              result = call_and_record(receiver, args, { :record => mc }, &block)
-            end
-
-            # Keep wrapping the original proc with each around_proc
-            @around_procs.reduce(original_proc) do |p, wrapper|
-              proc { wrapper.call(mc, &p) }
-            end.call
-          else
-            result = call_and_record(receiver, args, &block)
-          end
-
-          if @after_callbacks.any?
-            mc = @call_history.last
-            @after_callbacks.each { |f| f.call(mc) }
-          end
-
-          result
-        end
-
-        private
-
-        def build_method_call(receiver, *args, &block)
-          Spy::MethodCall.new(
-            proc { call_original(receiver, *args, &block) },
-            original.name,
-            receiver,
-            *args,
-            &block)
-        end
-
-        def call_and_record(receiver, args, opts = {}, &block)
-          if @instead
-            @instead.call build_method_call(receiver, *args, &block)
-          else
-            record = opts[:record] || build_method_call(receiver, *args, &block)
-            @call_history << record
-
-            result = call_original(receiver, *args, &block)
-            record.result = result
-          end
-        end
-
-        def call_original(receiver, *args, &block)
-          if original.is_a?(UnboundMethod)
-            original.bind(receiver).call(*args, &block)
-          else
-            original.call(*args, &block)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/spy/instance/strategy/intercept.rb

@@ -1,23 +0,0 @@
-module Spy
-  class Instance
-    module Strategy
-      class Intercept
-        def initialize(spy, intercept_target)
-          @spy = spy
-          @intercept_target = intercept_target
-        end
-
-        def apply
-          @spy.attach_to(@intercept_target)
-        end
-
-        def undo
-          spy = @spy
-          @intercept_target.class_eval do
-            remove_method spy.original.name
-          end
-        end
-      end
-    end
-  end
-end

data/lib/spy/instance/strategy/wrap.rb

@@ -1,24 +0,0 @@
-module Spy
-  class Instance
-    module Strategy
-      class Wrap
-        def initialize(spy)
-          @spy = spy
-        end
-
-        def apply
-          @spy.attach_to(@spy.original.owner)
-        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

data/lib/spy/instance/strategy.rb

@@ -1,33 +0,0 @@
-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)
-            pick_strategy(spy, spy.spied.singleton_class)
-          else
-            pick_strategy(spy, spy.spied)
-          end
-        end
-
-        private
-
-        def pick_strategy(spy, spied_on)
-          if spy.original.owner == spied_on
-            # If the object we're spying on is the owner of
-            # the method under spy then we need to wrap that
-            # method
-            Strategy::Wrap.new(spy)
-          else
-            # Otherwise we can intercept it by abusing the
-            # inheritance hierarchy
-            Strategy::Intercept.new(spy, spied_on)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/spy/registry_entry.rb

@@ -1,13 +0,0 @@
-module Spy
-  # Isolates the format we serialize spies in when we track them
-  class RegistryEntry < Struct.new(:spied, :method, :spy)
-    def key
-      receiver = method.is_a?(Method) ? method.receiver : nil
-      "#{receiver.object_id}|#{method.name}|#{method.class}"
-    end
-
-    def ==(other)
-      key == other.key
-    end
-  end
-end

data/lib/spy/registry_store.rb

@@ -1,28 +0,0 @@
-module Spy
-  # Works with RegistryEntry abstractions to allow the
-  # store data structure to be easily swapped
-  class RegistryStore
-    include Enumerable
-
-    def initialize
-      @internal = {}
-    end
-
-    def insert(entry)
-      @internal[entry.key] = entry
-    end
-
-    def remove(entry)
-      @internal.delete(entry.key)
-    end
-
-    def each
-      return to_enum unless block_given?
-      @internal.values.each { |v| yield v }
-    end
-
-    def empty?
-      none?
-    end
-  end
-end