spy_rb 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 47b608d05670cc1e49baec91115ecfdf0e87feb6
-  data.tar.gz: a7519779804fa1ac600149a87bfed851cacca168
+  metadata.gz: 96ccd939b58cbad0c0ab01af781177fb2d974e14
+  data.tar.gz: 352f27f11583dd07e856ce6522cd89dbe8d4d0bb
 SHA512:
-  metadata.gz: 8a3853df7bcb3ae2440b6585ea519d4466b7130ddb061a2d29db1ba88a9e31a410c1a22adb614782c337a035356d82d8350d9024aeabb1b588ae00c97cc04078
-  data.tar.gz: dc92ea6560aa6b5fbfbc260cdbc9b2cdb2acae4bc92b0662b56b65b40c34dd149c0a195cf18872f41f5a05284dce90eaf514ea9ca973979828ffecbd025e3f47
+  metadata.gz: f459c3813f339b9f5c7a6a59ba934e1f47f68b1a25a1ec609550e435190415827b6407858a5865bb120d17d7e221d9477b4ff67c1d965dedb573837fcb35ba95
+  data.tar.gz: 50c0d68b2043f6f91646f983c24ac4acabdd8baab4d97e71a7f1dbeade9c56a9677274fa29025351536686f2e106f47474cb046bc5480a07871ff269df7f1bcd

data/lib/spy/collection/entry.rb

@@ -1,36 +1,15 @@
 module Spy
   class Collection
-    class Entry < Struct.new(:receiver, :msg, :method_type)
-      attr_accessor :value
-
+    # Abstraction to isolate domain logic
+    class Entry < Struct.new(:spied, :method, :spy)
       def key
-        "#{receiver.object_id}|#{msg}|#{method_type}"
+        receiver = method.is_a?(Method) ? method.receiver : nil
+        "#{receiver.object_id}|#{method.name}|#{method.class}"
       end
 
       def ==(other)
         key == other.key
       end
-
-      module ClassMethods
-        def parse(key)
-          new *parse_key(key)
-        end
-
-        def parse_key(key)
-          parts = key.split('|')
-          parts[0] = find_object(parts[0].to_i)
-          parts[1] = parts[1].to_sym
-          parts[2] = parts[2].to_sym
-          parts
-        end
-
-        # Looks up an object in the global ObjectSpace
-        def find_object(object_id)
-          ObjectSpace._id2ref(object_id)
-        end
-      end
-
-      extend ClassMethods
     end
   end
 end

data/lib/spy/collection/store.rb

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

data/lib/spy/collection.rb

@@ -1,52 +1,42 @@
+require 'spy/errors'
+require 'spy/collection/store'
 require 'spy/collection/entry'
 
 module Spy
+  # Responsible for error handling and mapping to Entry
   class Collection
-    include Enumerable
-
-    def initialize
-      @store = {}
-    end
-
-    def insert(entry)
-      raise Errors::AlreadySpiedError if include?(entry)
-      @store[entry.key] = entry
+    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(entry)
-      raise Errors::MethodNotSpiedError unless include?(entry)
-      @store.delete(entry.key).value
+    def remove(spied, method)
+      entry = Entry.new(spied, method, nil)
+      if !store.include? entry
+        raise Errors::MethodNotSpiedError
+      end
+      store.remove(entry).spy
     end
 
-    # Removes each element from the collection and calls the block
-    # with each deleted element
     def remove_all
-      map {|e| yield remove(e)}
+      store.map {|e| yield remove(e.spied, e.method)}
+      if !store.empty?
+        raise Errors::UnableToEmptySpyCollectionError
+      end
     end
 
-    def each
-      @store.keys.each {|k| yield Entry.parse(k)}
+    def include?(spied, method)
+      entry = Entry.new(spied, method)
+      store.include? entry
     end
 
-    # Add a slicker interface that abstracts away Collection::Entry
-    module SpyHelper
-      def <<(spy)
-        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
+    private
 
-      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
+    def store
+      @store ||= Store.new
     end
-
-    include SpyHelper
   end
 end

data/lib/spy/core.rb

@@ -4,23 +4,28 @@ require 'spy/errors'
 
 module Spy
   class Core
-    def spy_collection
-      @spy_collection ||= Collection.new
-    end
-
     def add_spy(spied, method)
+      if collection.include?(spied, method)
+        raise Errors::AlreadySpiedError
+      end
       spy = Instance.new(spied, method)
-      spy_collection << spy
+      collection.insert(spied, method, spy)
       spy.start
     end
 
     def remove_spy(spied, method)
-      spy = spy_collection.pop(method)
+      spy = collection.remove(spied, method)
       spy.stop
     end
 
     def remove_all_spies
-      spy_collection.remove_all { |spy| spy.stop }
+      collection.remove_all { |spy| spy.stop }
+    end
+
+    private
+
+    def collection
+      @collection ||= Collection.new
     end
   end
 end

data/lib/spy/errors.rb

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

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

@@ -11,62 +11,72 @@ module Spy
         def attach_to(target)
           spy = self
           target.class_eval do
-            define_method spy.original.name do |*args|
-              spy.call(self, *args)
+            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 context and arguments.
+        # Call the spied method using the given receiver and arguments.
         #
-        # Context is required for calling UnboundMethods such as
+        # receiver is required to allow calling of UnboundMethods such as
         # instance methods defined on a Class
-        def call(context, *args)
+        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 = @conditional_filters.all? {|f| f.call(*args)}
 
-          if is_active
+          if !is_active
+            call_original(receiver, *args, &block)
+          else
             @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
+            if @around_procs.any?
+              # Procify the original call
+              # Still return the result from it
+              result = nil
+              original_proc = Proc.new do
+                result = call_and_record(receiver, *args, &block)
+              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
+              # Keep wrapping the original proc with each around_proc
+              @around_procs.reduce(original_proc) do |p, wrapper|
+                Proc.new { wrapper.call receiver, *args, &p }
+              end.call
+            else
+              result = call_and_record(receiver, *args, &block)
+            end
 
-          if is_active
             @after_callbacks.each {|f| f.call(*args)}
-          end
 
-          result
+            result
+          end
         end
 
         private
 
-        def track_call(context, *args)
-          record = Spy::MethodCall.new(context, *args)
+        def call_and_record(receiver, *args, &block)
+          record = track_call(receiver, *args, &block)
+          result = call_original(receiver, *args, &block)
+          record.result = result
+        end
+
+        def track_call(receiver, *args, &block)
+          replayer = proc { call_original(receiver, *args, &block) }
+          record = Spy::MethodCall.new(replayer, original.name, receiver, *args, &block)
           @call_history << record
           record
         end
 
-        def call_original(context, *args)
+        def call_original(receiver, *args, &block)
           if original.is_a?(UnboundMethod)
-            original.bind(context).call(*args)
+            original.bind(receiver).call(*args, &block)
           else
-            original.call(*args)
+            original.call(*args, &block)
           end
         end
       end

data/lib/spy/instance.rb

@@ -27,6 +27,10 @@ module Spy
       @call_history.size
     end
 
+    def replay_all
+      @call_history.map(&:replay)
+    end
+
     def start
       @strategy.apply
       self

data/lib/spy/method_call.rb

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

data/lib/spy/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spy_rb
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Josh Bodah
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-20 00:00:00.000000000 Z
+date: 2015-06-18 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
@@ -23,6 +23,7 @@ files:
 - 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