spy_rb 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 62ad15e17abbe8f04e140b6b979a00405fcc9208
-  data.tar.gz: 21ad45535f0a10322498d1f12e7adf1a31b23282
+  metadata.gz: 47b608d05670cc1e49baec91115ecfdf0e87feb6
+  data.tar.gz: a7519779804fa1ac600149a87bfed851cacca168
 SHA512:
-  metadata.gz: f28be3353f3e99e509a9ecb1720d5a6eabd0b469900143089323acb1cc4c2a96db064ec90c360469dcc4d2f295d5e2411dbd824c30a1006c8b0a3539c78f421b
-  data.tar.gz: 7e78f8d5a0a580a1aaaf99f1fef8a95f948c09ebe013c0faf0ac2e75624938a98d2e318d1a2ae869e5c2311072ac46bbb8542041dd9adbe82e8b6207b84789c0
+  metadata.gz: 8a3853df7bcb3ae2440b6585ea519d4466b7130ddb061a2d29db1ba88a9e31a410c1a22adb614782c337a035356d82d8350d9024aeabb1b588ae00c97cc04078
+  data.tar.gz: dc92ea6560aa6b5fbfbc260cdbc9b2cdb2acae4bc92b0662b56b65b40c34dd149c0a195cf18872f41f5a05284dce90eaf514ea9ca973979828ffecbd025e3f47

data/lib/spy/api.rb

@@ -2,23 +2,22 @@ require 'spy/core'
 
 module Spy
   module API
-    # Initializes a new spy instance for the method
+    # Spies on calls to a method made on an object
     #
-    # With two args:
-    # @param receiver - the receiver of the message you want to spy on
-    # @param msg - the message passed to the receiver that you want to spy on
-    def on(*args)
-      case args.length
-      when 2
-        spied, msg = *args
-        return core.add_spy(spied, spied.method(msg))
-      end
-      raise ArgumentError
+    # @param target - the object you want to spy on
+    # @param msg - the name of the method to spy on
+    def on(target, msg)
+      core.add_spy(target, target.method(msg))
     end
 
-    # TODO docs
-    def on_any_instance(spied, msg)
-      core.add_spy(spied, spied.instance_method(msg))
+    # Spies on calls to a method made on any instance of some class or module
+    #
+    # @param target - class or module to spy on
+    # @param msg - name of the method to spy on
+    # @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))
     end
 
     # Stops spying on the method and restores its original functionality
@@ -36,15 +35,16 @@ module Spy
     def restore(*args)
       case args.length
       when 1
-        return core.remove_all_spies if args.first == :all
+        core.remove_all_spies if args.first == :all
       when 2
-        spied, msg = *args
-        return core.remove_spy(spied, spied.method(msg))
+        target, msg = *args
+        core.remove_spy(target, target.method(msg))
       when 3
-        spied, msg, method_type = *args
-        return core.remove_spy(spied, spied.send(method_type, msg))
+        target, msg, method_type = *args
+        core.remove_spy(target, target.send(method_type, msg))
+      else
+        raise ArgumentError
       end
-      raise ArgumentError
     end
 
     private

data/lib/spy/instance.rb

@@ -1,6 +1,5 @@
-require 'spy/callbacks/with_args'
-require 'spy/callbacks/when'
 require 'spy/instance/strategy'
+require 'spy/instance/api/internal'
 
 # An instance of a spied method
 # - Holds a reference to the original method
@@ -8,17 +7,26 @@ require 'spy/instance/strategy'
 # - Provides hooks for callbacks
 module Spy
   class Instance
-    attr_reader :original, :spied, :strategy, :call_count, :visibility
+    include API::Internal
+
+    attr_reader :original, :spied, :strategy, :visibility, :call_history
 
     def initialize(spied, original)
       @spied = spied
       @original = original
       @visibility = extract_visibility
-      @before_filters = []
-      @call_count = 0
+      @conditional_filters = []
+      @before_callbacks = []
+      @after_callbacks = []
+      @around_procs = []
+      @call_history = []
       @strategy = Strategy.factory_build(self)
     end
 
+    def call_count
+      @call_history.size
+    end
+
     def start
       @strategy.apply
       self
@@ -29,25 +37,30 @@ module Spy
       self
     end
 
-    def before_call(*args)
-      @call_count += 1 if @before_filters.all? {|f| f.before_call(*args)}
+    def when(&block)
+      @conditional_filters << block
+      self
     end
 
-    def with_args(*args)
-      add_before_filter Callbacks::WithArgs.new(*args)
+    # Expect block to yield. Call the rest of the chain
+    # when it does
+    def wrap(&block)
+      @around_procs << block
+      self
     end
 
-    def when(&block)
-      add_before_filter Callbacks::When.new(block)
+    def before(&block)
+      @before_callbacks << block
+      self
     end
 
-    private
-
-    def add_before_filter(filter)
-      @before_filters << filter
+    def after(&block)
+      @after_callbacks << block
       self
     end
 
+    private
+
     def extract_visibility
       owner = @original.owner
       [:public, :protected, :private].each do |vis|

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

@@ -0,0 +1,75 @@
+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|
+              spy.call(self, *args)
+            end
+            send(spy.visibility, spy.original.name)
+          end
+        end
+
+        # Call the spied method using the given context and arguments.
+        #
+        # Context is required for calling UnboundMethods such as
+        # instance methods defined on a Class
+        def call(context, *args)
+          is_active = @conditional_filters.all? {|f| f.call(*args)}
+
+          if is_active
+            @before_callbacks.each {|f| f.call(*args)}
+          end
+
+          if @around_procs.any?
+            # Procify the original call
+            original_proc = Proc.new do
+              record = track_call(context, *args) if is_active
+              result = call_original(context, *args)
+              record.result = result if is_active
+            end
+
+            # Keep wrapping the original proc with each around_proc
+            @around_procs.reduce(original_proc) do |p, wrapper|
+              Proc.new { wrapper.call context, *args, &p }
+            end.call
+          else
+            record = track_call(context, *args) if is_active
+            result = call_original(context, *args)
+            record.result = result if is_active
+          end
+
+          if is_active
+            @after_callbacks.each {|f| f.call(*args)}
+          end
+
+          result
+        end
+
+        private
+
+        def track_call(context, *args)
+          record = Spy::MethodCall.new(context, *args)
+          @call_history << record
+          record
+        end
+
+        def call_original(context, *args)
+          if original.is_a?(UnboundMethod)
+            original.bind(context).call(*args)
+          else
+            original.call(*args)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,18 +8,7 @@ module Spy
         end
 
         def apply
-          spy = @spy
-          @intercept_target.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
+          @spy.attach_to(@intercept_target)
         end
 
         def undo

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

@@ -7,18 +7,7 @@ module 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
+          @spy.attach_to(@spy.original.owner)
         end
 
         def undo

data/lib/spy/method_call.rb

@@ -0,0 +1,11 @@
+module Spy
+  class MethodCall
+    attr_reader :context, :args
+    attr_accessor :result
+
+    def initialize(context, *args)
+      @context = context
+      @args = args
+    end
+  end
+end

data/lib/spy/version.rb

@@ -1,3 +1,3 @@
 module Spy
-  VERSION = '0.2.2'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spy_rb
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Josh Bodah
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-27 00:00:00.000000000 Z
+date: 2015-05-20 00:00:00.000000000 Z
 dependencies: []
 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
@@ -21,16 +21,16 @@ extra_rdoc_files: []
 files:
 - lib/spy.rb
 - lib/spy/api.rb
-- lib/spy/callbacks/when.rb
-- lib/spy/callbacks/with_args.rb
 - lib/spy/collection.rb
 - lib/spy/collection/entry.rb
 - lib/spy/core.rb
 - lib/spy/errors.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/version.rb
 homepage: https://github.com/jbodah/spy_rb
 licenses:

data/lib/spy/callbacks/when.rb

@@ -1,13 +0,0 @@
-module Spy
-  module Callbacks
-    class When
-      def initialize(filter)
-        @filter = filter
-      end
-
-      def before_call(*args)
-        @filter.call(*args)
-      end
-    end
-  end
-end

data/lib/spy/callbacks/with_args.rb

@@ -1,14 +0,0 @@
-module Spy
-  module Callbacks
-    class WithArgs
-      def initialize(*args)
-        puts 'Spy::Callbacks::WithArgs is deprecated; use Spy::Callbacks::When instead'
-        @match_args = args
-      end
-
-      def before_call(*args)
-        @match_args == args
-      end
-    end
-  end
-end