gimme 0.2.0 → 0.3.1

data/lib/gimme.rb

@@ -1,14 +1,21 @@
 require 'gimme/test_double'
 require 'gimme/resolves_methods'
 require 'gimme/errors'
-require 'gimme/gives_class_methods'
 require 'gimme/gives'
+require 'gimme/gives_class_methods'
+require 'gimme/ensures_class_method_restoration'
 require 'gimme/verifies'
+require 'gimme/spies_on_class_methods'
+require 'gimme/verifies_class_methods'
 require 'gimme/matchers'
 require 'gimme/captor'
 require 'gimme/invokes_satisfied_stubbing'
 require 'gimme/reset'
 require 'gimme/dsl'
+require 'gimme/store'
+require 'gimme/stubbing_store'
+require 'gimme/invocation_store'
+require 'gimme/method_store'
 
 require 'gimme/rspec_adapter'
 

data/lib/gimme/dsl.rb

@@ -1,8 +1,8 @@
 module Gimme
   module DSL
-    
+
     # Instantiation
-    
+
     def gimme(cls=nil)
       Gimme::TestDouble.new(cls)
     end
@@ -19,7 +19,7 @@ module Gimme
       double
     end
 
-    
+
     # Stubbing
     def give(double)
       if double.kind_of? Class
@@ -37,7 +37,11 @@ module Gimme
 
     # Verification
     def verify(double,times=1)
-      Gimme::Verifies.new(double,times)
+      if double.kind_of? Class
+        Gimme::VerifiesClassMethods.new(double, times)
+      else
+        Gimme::Verifies.new(double,times)
+      end
     end
 
     def verify!(double,times=1)
@@ -45,6 +49,16 @@ module Gimme
       verify.raises_no_method_error = false
       verify
     end
-    
+
+    # Spying on class methods
+    def spy_on(cls, method)
+      SpiesOnClassMethod.new(cls).spy(method)
+    end
+
+    def spy_on!(cls, method)
+      spies_on = SpiesOnClassMethod.new(cls)
+      spies_on.raises_no_method_error = false
+      spies_on.spy(method)
+    end
   end
 end

data/lib/gimme/ensures_class_method_restoration.rb

@@ -0,0 +1,18 @@
+module Gimme
+  class EnsuresClassMethodRestoration
+    def initialize(cls)
+      @cls = cls
+    end
+
+    def ensure(method)
+      meta_class = (class << @cls; self; end)
+      Gimme.on_reset do
+        if real_method = Gimme.class_methods.get(@cls, method)
+          meta_class.instance_eval { define_method method, real_method }
+        else
+          meta_class.send(:remove_method, method)
+        end
+      end
+    end
+  end
+end

data/lib/gimme/gives.rb

@@ -10,8 +10,7 @@ module Gimme
     def method_missing(sym, *args, &block)
       sym = ResolvesMethods.new(@double.cls,sym,args).resolve(@raises_no_method_error)
 
-      @double.stubbings[sym] ||= {}
-      @double.stubbings[sym][args] = block if block
+      Gimme.stubbings.set(@double, sym, args, block)
     end
   end
 

data/lib/gimme/gives_class_methods.rb

@@ -5,50 +5,26 @@ module Gimme
     def initialize(cls)
       @cls = cls
       @raises_no_method_error = true
-      @@stubbings ||= {}
     end
 
     def method_missing(method, *args, &block)
       cls = @cls
-      meta_class = meta_for(@cls)
+      meta_class = (class << cls; self; end)
       method = ResolvesMethods.new(meta_class,method,args).resolve(@raises_no_method_error)
-      hidden_method_name = hidden_name_for(method)
 
-      if @cls.respond_to?(method) && !@cls.respond_to?(hidden_method_name)
-        meta_class.send(:alias_method, hidden_method_name, method)
-      end
-
-      @@stubbings[cls] ||= {}
-      @@stubbings[cls][method] ||= {}
-      @@stubbings[cls][method][args] = block if block
+      Gimme.class_methods.set(cls, method)
+      Gimme.stubbings.set(cls, method, args, block)
 
       #TODO this will be redundantly overwritten
       meta_class.instance_eval do
         define_method method do |*actual_args|
-          InvokesSatisfiedStubbing.new(@@stubbings[cls]).invoke(method, actual_args)
-        end
-      end
-
-      Gimme.on_reset do
-        if cls.respond_to?(hidden_method_name)
-          meta_class.instance_eval { define_method method, cls.method(hidden_method_name) }
-          meta_class.send(:remove_method, hidden_method_name)
-        else
-          meta_class.send(:remove_method, method)
+          InvokesSatisfiedStubbing.new(Gimme.stubbings.get(cls)).invoke(method, actual_args)
         end
-        @@stubbings.clear
       end
-    end
 
-    private
-
-    def meta_for(cls)
-      (class << cls; self; end)
+      EnsuresClassMethodRestoration.new(@cls).ensure(method)
     end
 
-    def hidden_name_for(method)
-      "__gimme_#{method}"
-    end
   end
 
 end

data/lib/gimme/invocation_store.rb

@@ -0,0 +1,14 @@
+module Gimme
+
+  class InvocationStore < Store
+
+    def increment(double, method, args)
+      set(double, method, args, get(double, method, args).to_i.succ)
+    end
+  end
+
+  def self.invocations
+    @@invocations ||= InvocationStore.new
+  end
+
+end

data/lib/gimme/invokes_satisfied_stubbing.rb

@@ -1,11 +1,24 @@
 module Gimme
   class InvokesSatisfiedStubbing
     def initialize(stubbings)
-      @stubbings = stubbings
+      @stubbings = stubbings || {}
     end
 
     def invoke(method, args)
-      matching_stub_block = nil
+      if @stubbings[method] && blk = find_matching_stubbing(method, args)
+        blk.call
+      elsif method.to_s[-1,1] == '?'
+        false
+      else
+        nil
+      end
+    end
+
+    private
+
+    def find_matching_stubbing(method, args)
+      match = nil
+
       @stubbings[method].each do |stub_args,stub_block|
         matching = args.size == stub_args.size
         args.each_index do |i|
@@ -14,16 +27,11 @@ module Gimme
             break
           end
         end
-        matching_stub_block = stub_block if matching
+        match = stub_block if matching
       end
 
-      if matching_stub_block
-        matching_stub_block.call
-      elsif method.to_s[-1,1] == '?'
-        false
-      else
-        nil
-      end
+      match
     end
+
   end
 end

data/lib/gimme/method_store.rb

@@ -0,0 +1,21 @@
+module Gimme
+
+  class ClassMethodStore < Store
+
+    def set(cls, method_name)
+      id = cls.__id__
+      meta = (class << cls; self; end)
+      @store[id] ||= {}
+
+      if meta.method_defined?(method_name) && !@store[id][method_name]
+        @store[id][method_name] = cls.method(method_name)
+      end
+    end
+
+  end
+
+  def self.class_methods
+    @@class_methods ||= ClassMethodStore.new
+  end
+
+end

data/lib/gimme/reset.rb

@@ -1,14 +1,21 @@
 module Gimme
   @@stuff_to_do_on_reset = []
+  @@stuff_to_do_on_every_reset = []
 
-  def self.on_reset (&blk)
-    @@stuff_to_do_on_reset << blk
+  def self.on_reset (situation = :once, &blk)
+    if situation == :once
+      @@stuff_to_do_on_reset << blk
+    else
+      @@stuff_to_do_on_every_reset << blk
+    end
   end
 
   def self.reset
     @@stuff_to_do_on_reset.delete_if do |stuff|
       stuff.call
-      true
+    end
+    @@stuff_to_do_on_every_reset.each do |stuff|
+      stuff.call
     end
   end
 end

data/lib/gimme/resolves_methods.rb

@@ -1,7 +1,7 @@
 module Gimme
 
   class ResolvesMethods
-    def initialize(cls,sym,args)
+    def initialize(cls, sym, args=[])
       @cls = cls
       @sym = sym
       @args = args

data/lib/gimme/spies_on_class_methods.rb

@@ -0,0 +1,28 @@
+module Gimme
+  class SpiesOnClassMethod
+    attr_accessor :raises_no_method_error
+    def initialize(cls)
+      @cls = cls
+      @raises_no_method_error = true
+    end
+
+    def spy(method)
+      meta_class = (class << @cls; self; end)
+      method = ResolvesMethods.new(meta_class, method).resolve(@raises_no_method_error)
+
+      if meta_class.method_defined? method
+        Gimme.class_methods.set(@cls, method)
+        meta_class.send(:remove_method, method)
+      end
+
+      cls = @cls
+      meta_class.instance_eval do
+        define_method method do |*args|
+          Gimme.invocations.increment(cls, method, args)
+        end
+      end
+
+      EnsuresClassMethodRestoration.new(@cls).ensure(method)
+    end
+  end
+end

data/lib/gimme/store.rb

@@ -0,0 +1,38 @@
+module Gimme
+  class Store
+    @store = {}
+
+    def initialize
+      @store = {}
+      Gimme.on_reset(:each) do
+        @store.clear
+      end
+    end
+
+    def reset
+      @store = {}
+    end
+
+    def set(double, method, args, content)
+      id = double.__id__
+      @store[id] ||= {}
+      @store[id][method] ||= {}
+      @store[id][method][args] = content
+    end
+
+    def get(double, method=nil, args=nil)
+      id = double.__id__
+      if !method
+        @store[id]
+      elsif @store[id] && !args
+        @store[id][method]
+      elsif @store[id] && @store[id][method]
+        @store[id][method][args]
+      end
+    end
+
+    def clear
+      @store.clear
+    end
+  end
+end

data/lib/gimme/stubbing_store.rb

@@ -0,0 +1,17 @@
+module Gimme
+
+  class StubbingStore < Store
+
+    def invoke(double, method, args)
+      if stubbing = get(double, method, args)
+        stubbing.call
+      end
+    end
+
+  end
+
+  def self.stubbings
+    @@stubbings ||= StubbingStore.new
+  end
+
+end

data/lib/gimme/test_double.rb

@@ -8,24 +8,27 @@ module Gimme
 
   class TestDouble < BlankSlate
     attr_accessor :cls
-    attr_accessor :stubbings
-    attr_reader :invocations
 
     def initialize(cls=nil)
       @cls = cls
-      @stubbings = {}
-      @invocations = {}
     end
 
-    def method_missing(sym, *args, &block)
-      sym = ResolvesMethods.new(self.cls,sym,args).resolve(false)
+    def method_missing(method, *args, &block)
+      method = ResolvesMethods.new(self.cls, method, args).resolve(false)
+      Gimme.invocations.increment(self, method, args)
+      InvokesSatisfiedStubbing.new(Gimme.stubbings.get(self)).invoke(method, args)
+    end
 
-      @invocations[sym] ||= {}
-      @stubbings[sym] ||= {}
+    def hash
+      __id__
+    end
 
-      @invocations[sym][args] = 1 + (@invocations[sym][args]||0)
+    def eql?(other)
+      __id__ == other.__id__
+    end
 
-      InvokesSatisfiedStubbing.new(@stubbings).invoke(sym, args)
+    def ==(other)
+      eql?(other)
     end
   end
 

data/lib/gimme/verifies.rb

@@ -8,13 +8,17 @@ module Gimme
       @raises_no_method_error = true
     end
 
+    def __gimme__cls
+      @double.cls
+    end
+
     def method_missing(sym, *args, &block)
-      sym = ResolvesMethods.new(@double.cls,sym,args).resolve(@raises_no_method_error)
+      sym = ResolvesMethods.new(__gimme__cls,sym,args).resolve(@raises_no_method_error)
 
       #gosh, this loop sure looks familiar. just like another ugly loop I know. TODO.
       invoked = 0
-      if @double.invocations[sym]
-         @double.invocations[sym].each do |invoke_args,count|
+      if Gimme.invocations.get(@double, sym)
+         Gimme.invocations.get(@double, sym).each do |invoke_args,count|
            matching = args.size == invoke_args.size
            invoke_args.each_index do |i|
              unless invoke_args[i] == args[i]  || (args[i].respond_to?(:matches?) && args[i].matches?(invoke_args[i]))
@@ -27,11 +31,11 @@ module Gimme
       end
 
       if invoked != @times
-        msg = "expected #{@double.cls.to_s}##{sym} to have been called with arguments #{args}"
-        if !@double.invocations[sym] || @double.invocations[sym].empty?
+        msg = "expected #{__gimme__cls.to_s}##{sym} to have been called with arguments #{args}"
+        if !Gimme.invocations.get(@double, sym) || Gimme.invocations.get(@double, sym).empty?
           msg << "\n  but was never called"
         else
-          msg = @double.invocations[sym].inject msg do |memo, actual|
+          msg = Gimme.invocations.get(@double, sym).inject msg do |memo, actual|
             memo + "\n  was actually called #{actual[1]} times with arguments #{actual[0]}"
           end
         end

data/lib/gimme/verifies_class_methods.rb

@@ -0,0 +1,8 @@
+module Gimme
+
+  class VerifiesClassMethods < Verifies
+    def __gimme__cls
+      (class << @double; self; end)
+    end
+  end
+end