spy_rb 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fb54969a1052380817f46a078bf3ebafe57acb2c
-  data.tar.gz: e29c5522dfd48423fe78b387fc06ce29e005d16d
+  metadata.gz: fb161a2c4eabb953bcc5eefefba4927bb7159a56
+  data.tar.gz: 569fda1c72a9b7a80d3efde9f9c3980623c10f3d
 SHA512:
-  metadata.gz: e415ad43572895dc1e3d94f25e61690b2b143fc32ac6fcdc581258b218db44eef37425afd44e0c05ea0ee5ab6e87e03e938ee4ced101eacb592ed625ffe2089f
-  data.tar.gz: ff2432d2149adacf34bd528f6b5ea62464eff36dc6d5eeb429431d254977893079062cb74b9f322f0230098df1e96fc3846053a42398f834bd495298b23a2b1b
+  metadata.gz: bf682739d04fb7f083606dba03ea4be0d24482be2ab9bfd413fbcef9e1488ac2887d5d7bde04d44d2462416a34b0adece5a6a11f7eca259716c2b9d2b928c23e
+  data.tar.gz: 2b75eacf01aa6781efea38a9efb23dd2b8f9a88d831d26ace9a8e8af20e079cf8497c0b460d9b8b888bafac967bc24834c90cbc5bb238017677025dc3e618b72

data/lib/spy.rb

@@ -1,6 +1,11 @@
 require 'spy/version'
 require 'spy/api'
 
+# Top-level module that implements the Spy::API
+#
+# Spy::API was pulled out to make it easy to create multiple
+# different modules that implement Spy::API (which effectively
+# namespaces the spies)
 module Spy
   extend API
 end

data/lib/spy/api.rb

@@ -1,11 +1,24 @@
 require 'spy/core'
 
 module Spy
+  # The core module that users will interface. `Spy::API` is implemented
+  # in a module via `::extend`:
+  #
+  #   MySpy.exted Spy::API
+  #   spy = MySpy.on(Object, :name)
+  #
+  # By default `Spy` implements `Spy::API`
+  #
+  # `Spy::API` is primarily responsible for maps user arguments into
+  # a format that `Spy::Core` can understand
+  #
+  # See `Spy::Instance` for the API for interacting with individual spies
   module API
-    # Spies on calls to a method made on an object
+    # Spies on calls to a method made on a target object
     #
-    # @param target - the object you want to spy on
-    # @param msg - the name of the method to spy on
+    # @param [Object] target - the object you want to spy on
+    # @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))
     end
@@ -22,16 +35,19 @@ module Spy
 
     # Stops spying on the method and restores its original functionality
     #
-    # @param args - supports multiple signatures
+    # @example stop spying on every spied message
     #
     #   Spy.restore(:all)
-    #       => stops spying on every spied message
+    #
+    # @example stop spying on the given receiver and message
     #
     #   Spy.restore(receiver, msg)
-    #       => stops spying on the given receiver and message (assumes :method)
     #
-    #   Spy.restore(reciever, msg, method_type)
-    #       =>  stops spying on the given receiver and message of method_type
+    # @example stop spying on the given object, message, and method type (e.g. :instance_method)
+    #
+    #   Spy.restore(object, msg, method_type)
+    #
+    # @param args - supports multiple signatures
     def restore(*args)
       case args.length
       when 1

data/lib/spy/core.rb

@@ -1,31 +1,51 @@
 require 'spy/instance'
-require 'spy/collection'
+require 'spy/registry'
 require 'spy/errors'
 
 module Spy
+  # The main internal API. This is used directly by `Spy::API` and
+  # is the primary control center for creating and removing spies.
+  #
+  # Syntactic sugar (like `Spy.restore(object, msg)` vs `Spy.restore(:all)`)
+  # should be handled in `Spy::API` and utilize `Spy::Core`
   class Core
-    def add_spy(spied, method)
-      if collection.include?(spied, method)
-        raise Errors::AlreadySpiedError
-      end
-      spy = Instance.new(spied, method)
-      collection.insert(spied, method, spy)
+    # 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
+    # @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)
       spy.start
     end
 
-    def remove_spy(spied, method)
-      spy = collection.remove(spied, method)
+    # 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)
       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
-      collection.remove_all { |spy| spy.stop }
+      registry.remove_all(&:stop)
     end
 
     private
 
-    def collection
-      @collection ||= Collection.new
+    def registry
+      @registry ||= Registry.new
     end
   end
 end

data/lib/spy/errors.rb

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

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

@@ -30,16 +30,16 @@ module Spy
           #   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)}
+                        @conditional_filters.all? { |f| f.call(mc) }
                       else
                         true
                       end
 
-          return call_original(receiver, *args, &block) if !is_active
+          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)}
+            @before_callbacks.each { |f| f.call(mc) }
           end
 
           if @around_procs.any?
@@ -48,13 +48,13 @@ module Spy
             # Procify the original call
             # Still return the result from it
             result = nil
-            original_proc = Proc.new do
+            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.new { wrapper.call(mc, &p) }
+              proc { wrapper.call(mc, &p) }
             end.call
           else
             result = call_and_record(receiver, args, &block)
@@ -62,7 +62,7 @@ module Spy
 
           if @after_callbacks.any?
             mc = @call_history.last
-            @after_callbacks.each {|f| f.call(mc)}
+            @after_callbacks.each { |f| f.call(mc) }
           end
 
           result

data/lib/spy/instance/strategy.rb

@@ -7,17 +7,24 @@ module Spy
       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
+            pick_strategy(spy, spy.spied.singleton_class)
           else
-            if spy.original.owner == spy.spied
-              Strategy::Wrap.new(spy)
-            else
-              Strategy::Intercept.new(spy, spy.spied)
-            end
+            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

data/lib/spy/method_call.rb

@@ -5,13 +5,10 @@ module Spy
 
     def initialize(replayer, name, receiver, *args)
       @replayer = replayer
-      @name = name
+      @name     = name
       @receiver = receiver
-      @args = args
-
-      if block_given?
-        @block = proc { receiver.instance_eval &Proc.new }
-      end
+      @args     = args
+      @block    = proc { receiver.instance_eval &Proc.new } if block_given?
     end
 
     def replay

data/lib/spy/registry.rb

@@ -0,0 +1,56 @@
+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
+    # 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::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)
+    end
+
+    # Stops tracking the spy
+    #
+    # @param [Object] spied - the object being spied on
+    # @param [Method, UnboundMethod] method - the method being spied on
+    # @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
+    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?
+    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
+    end
+  end
+end

data/lib/spy/registry_entry.rb

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,28 @@
+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

data/lib/spy/version.rb

@@ -1,3 +1,3 @@
 module Spy
-  VERSION = '1.0.0'
+  VERSION = '2.0.0'
 end

metadata

@@ -1,15 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: spy_rb
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Josh Bodah
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-10 00:00:00.000000000 Z
-dependencies: []
+date: 2016-07-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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'
+- !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
@@ -21,9 +63,6 @@ extra_rdoc_files: []
 files:
 - lib/spy.rb
 - lib/spy/api.rb
-- lib/spy/collection.rb
-- lib/spy/collection/entry.rb
-- lib/spy/collection/store.rb
 - lib/spy/core.rb
 - lib/spy/errors.rb
 - lib/spy/instance.rb
@@ -32,6 +71,9 @@ files:
 - lib/spy/instance/strategy/intercept.rb
 - lib/spy/instance/strategy/wrap.rb
 - lib/spy/method_call.rb
+- lib/spy/registry.rb
+- lib/spy/registry_entry.rb
+- lib/spy/registry_store.rb
 - lib/spy/version.rb
 homepage: https://github.com/jbodah/spy_rb
 licenses:

data/lib/spy/collection.rb

@@ -1,42 +0,0 @@
-require 'spy/errors'
-require 'spy/collection/store'
-require 'spy/collection/entry'
-
-module Spy
-  # Responsible for error handling and mapping to Entry
-  class Collection
-    def insert(spied, method, spy)
-      entry = Entry.new(spied, method, spy)
-      if store.include? entry
-        raise Errors::AlreadySpiedError
-      end
-      store.insert(entry)
-    end
-
-    def remove(spied, method)
-      entry = Entry.new(spied, method, nil)
-      if !store.include? entry
-        raise Errors::MethodNotSpiedError
-      end
-      store.remove(entry).spy
-    end
-
-    def remove_all
-      store.map {|e| yield remove(e.spied, e.method)}
-      if !store.empty?
-        raise Errors::UnableToEmptySpyCollectionError
-      end
-    end
-
-    def include?(spied, method)
-      entry = Entry.new(spied, method)
-      store.include? entry
-    end
-
-    private
-
-    def store
-      @store ||= Store.new
-    end
-  end
-end

data/lib/spy/collection/entry.rb

@@ -1,15 +0,0 @@
-module Spy
-  class Collection
-    # Abstraction to isolate domain logic
-    class Entry < 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
-end

data/lib/spy/collection/store.rb

@@ -1,32 +0,0 @@
-module Spy
-  class Collection
-    # Works with Entry abstractions to allow the
-    # store data structure to be easily swapped
-    class Store
-      include Enumerable
-
-      def initialize
-        @internal = {}
-      end
-
-      def insert(entry)
-        @internal[entry.key] = entry
-      end
-
-      def remove(entry)
-        @internal.delete(entry.key)
-      end
-
-      def each
-        e = Enumerator.new do |y|
-          @internal.values.each {|v| y << v}
-        end
-        block_given? ? e.each(&Proc.new) : e
-      end
-
-      def empty?
-        none?
-      end
-    end
-  end
-end