spy_rb 3.3.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9c273641c4e1545c5b41bca19c98f20a5bc1fcac
-  data.tar.gz: 766f1883942aa7fbee3ccc76815b2c21a2d5fba0
+  metadata.gz: 53c61d7800f4dfd159fc081d34ad780b225cc5b1
+  data.tar.gz: 68c92a4fbadef7bf61acfcb1aa84d5405e16e41a
 SHA512:
-  metadata.gz: 0df0382a994eae8fe1d650713c7239d4daf0d2c9545eae5636c58bd07c249f744726978922cabe21cc42202070137f8c05046b44f8d15821d0d86345c175694b
-  data.tar.gz: 67000b046fa2d28f5159d9f8c13e48625f05fa620007367a979e9c1cbd4eb730d7f098f081fe60b7c06f93caf3769f95f1e01d09b4bcf6276e4cc899c35fd5de
+  metadata.gz: ccd3238f674765a9d9ee84f5fad2fd66f9c336118f8bf1a5698b927a719bec36257da6c4792522a5ae917faf75e7c5f2c7bb03ee3d98246ac58043ac2c91740f
+  data.tar.gz: '0984f22b7e030d699c503319e18701931398632255c6ddc487e0e285fe6c3949b1d08e45327e476dbcc0aa05a204822f65a554bf0081df2a915f857b93e07fde'

data/lib/spy/instance.rb

@@ -87,8 +87,69 @@ module Spy
       @call_history.any?
     end
 
+    # @private
+    def call_original(*args)
+      if original.is_a?(UnboundMethod)
+        call_original_unbound_method(*args)
+      else
+        call_original_method(*args)
+      end
+    end
+
+    # @private
+    def apply(method_call)
+      return method_call.call_original unless passes_all_conditions?(method_call)
+
+      run_before_callbacks(method_call)
+
+      result = nil
+      runner =
+        if @internal[:instead]
+          proc do
+            result = @internal[:instead].call(method_call)
+          end
+        else
+          proc do
+            @call_history << method_call
+            result = method_call.call_original(true)
+          end
+        end
+
+      if @internal[:around_procs].any?
+        runner = @internal[:around_procs].reduce(runner) do |p, wrapper|
+          proc { wrapper[method_call, &p] }
+        end
+      end
+
+      runner.call
+
+      run_after_callbacks(method_call)
+
+      result
+    end
+
     private
 
+    def passes_all_conditions?(method_call)
+      @internal[:conditional_filters].all? { |f| f[method_call] }
+    end
+
+    def run_before_callbacks(method_call)
+      @internal[:before_callbacks].each { |f| f[method_call] }
+    end
+
+    def run_after_callbacks(method_call)
+      @internal[:after_callbacks].each { |f| f[method_call] }
+    end
+
+    def call_original_unbound_method(receiver, args, block)
+      original.bind(receiver).call(*args, &block)
+    end
+
+    def call_original_method(_receiver, args, block)
+      original.call(*args, &block)
+    end
+
     def choose_strategy(blueprint)
       if blueprint.type == :dynamic_delegation
         Strategy::Intercept.new(self)

data/lib/spy/method_call.rb

@@ -1,21 +1,26 @@
 module Spy
   class MethodCall
-    attr_reader :name, :receiver, :caller, :args, :block
-    attr_accessor :result
+    attr_reader :receiver, :backtrace, :args, :block, :result
 
-    def initialize(replayer, name, receiver, method_caller, *args)
-      @replayer = replayer
-      @name     = name
+    def initialize(spy, receiver, args, block, backtrace)
+      @spy = spy
       @receiver = receiver
-      @args     = args
-      @caller   = method_caller
-      @block    = Proc.new if block_given?
+      @args = args
+      @block = block
+      @backtrace = backtrace
     end
 
-    def replay
-      @replayer.call
+    def name
+      @spy.original.name
     end
 
-    alias call_original replay
+    def call_original(persist_result = false)
+      result = @spy.call_original(@receiver, @args, @block)
+      @result = result if persist_result
+      result
+    end
+
+    alias replay call_original
+    alias caller backtrace
   end
 end

data/lib/spy/replace_method.rb

@@ -0,0 +1,28 @@
+require 'spy/method_call'
+
+module Spy
+  module ReplaceMethod
+    def self.call(klass, spy, mode: nil, remove_existing: false)
+      klass.class_eval do
+        name = spy.original.name
+
+        remove_method(name) if remove_existing
+
+        case mode
+        when :stub
+          define_method(name, ReplaceMethod.impl(spy))
+        when :restore
+          define_method(name, spy.original)
+        end
+      end
+    end
+
+    def self.impl(spy)
+      proc do |*args, &block|
+        backtrace = caller.drop_while { |path| path =~ /lib\/spy\/replace_method\.rb$/ }
+        method_call = MethodCall.new(spy, self, args, block, backtrace)
+        spy.apply(method_call)
+      end
+    end
+  end
+end

data/lib/spy/strategy/intercept.rb

@@ -1,5 +1,4 @@
-require 'spy/determine_visibility'
-require 'spy/strategy/base'
+require 'spy/replace_method'
 
 module Spy
   module Strategy
@@ -18,26 +17,11 @@ module Spy
       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
+        ReplaceMethod.call(@target, @spy, mode: :stub)
       end
 
       def undo
-        spy = @spy
-        @target.class_eval do
-          remove_method spy.original.name
-        end
+        ReplaceMethod.call(@target, @spy, remove_existing: true)
       end
     end
   end

data/lib/spy/strategy/wrap.rb

@@ -1,38 +1,18 @@
-require 'spy/determine_visibility'
-require 'spy/strategy/base'
+require 'spy/replace_method'
 
 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
+        ReplaceMethod.call(@spy.original.owner, @spy, mode: :stub)
       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
+        ReplaceMethod.call(@spy.original.owner, @spy, mode: :restore)
       end
     end
   end

data/lib/spy/version.rb

@@ -1,3 +1,3 @@
 module Spy
-  VERSION = '3.3.0'
+  VERSION = '4.0.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spy_rb
 version: !ruby/object:Gem::Version
-  version: 3.3.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Josh Bodah
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-28 00:00:00.000000000 Z
+date: 2019-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -51,14 +51,13 @@ files:
 - 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/method_call.rb
 - lib/spy/multi.rb
 - lib/spy/registry.rb
-- lib/spy/strategy/base.rb
+- lib/spy/replace_method.rb
 - lib/spy/strategy/intercept.rb
 - lib/spy/strategy/wrap.rb
 - lib/spy/version.rb

data/lib/spy/determine_visibility.rb

@@ -1,16 +0,0 @@
-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/strategy/base.rb

@@ -1,89 +0,0 @@
-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.drop_while { |path| path =~ /lib\/spy\/strategy/ },
-            *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