verifies dsl next

lib/gimme/dsl.rb

@@ -51,5 +51,10 @@ 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

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

lib/gimme/spies_on_class_methods.rb

@@ -1,17 +1,24 @@
 module Gimme
   class SpiesOnClassMethod
+    attr_accessor :raises_no_method_error
     def initialize(cls)
       @cls = cls
+      @raises_no_method_error = true
     end
 
     def spy(method)
-      Gimme.class_methods.set(@cls, method)
       meta_class = (class << @cls; self; end)
-      meta_class.send(:remove_method, method)
+      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)
+          Gimme.invocations.increment(cls, method, args)
         end
       end
 

lib/gimme/verifies.rb

@@ -8,8 +8,12 @@ def initialize(double,times=1)
       @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
@@ -27,7 +31,7 @@ def method_missing(sym, *args, &block)
       end
 
       if invoked != @times
-        msg = "expected #{@double.cls.to_s}##{sym} to have been called with arguments #{args}"
+        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

lib/gimme/verifies_class_methods.rb

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

spec/gimme/shared_examples/shared_verifies_examples.rb

@@ -11,7 +11,7 @@ module Gimme
       When(:result) { lambda { verifier.ferment } }
       Then { result.should raise_error Errors::VerificationFailedError }
       Then do result.should raise_error Errors::VerificationFailedError,
-        "expected Gimme::Natto#ferment to have been called with arguments #{[]}\n"+
+        "expected #{double_name}#ferment to have been called with arguments #{[]}\n"+
         "  but was never called"
       end
     end
@@ -20,7 +20,7 @@ module Gimme
       Given { test_double.ferment(5) }
       When(:result) { lambda { verifier.ferment(4) } }
       Then do result.should raise_error Errors::VerificationFailedError,
-        "expected Gimme::Natto#ferment to have been called with arguments #{[4]}\n"+
+        "expected #{double_name}#ferment to have been called with arguments #{[4]}\n"+
         "  was actually called 1 times with arguments #{[5]}"
       end
     end
@@ -39,14 +39,14 @@ module Gimme
     end
 
     context "invoked too few times" do
-      Given(:verifier) { Verifies.new(test_double,3) }
+      Given(:verifier) { verifier_class.new(test_double,3) }
       Given { 2.times { test_double.ferment } }
       When(:result) { lambda { verifier.ferment } }
       Then { result.should raise_error Errors::VerificationFailedError }
     end
 
     context "juggling multiple verifiers for the same method" do
-      Given(:multi_verifier) { Verifies.new(test_double,2) }
+      Given(:multi_verifier) { verifier_class.new(test_double,2) }
       Given { test_double.ferment(:panda,:sauce) }
       Given { 2.times { test_double.ferment(2,3) } }
       When(:result) do

spec/gimme/spies_on_class_method_spec.rb

@@ -15,24 +15,41 @@ def self.destroy
 
   describe SpiesOnClassMethod do
     shared_examples_for "it spies on class methods" do
-      Given(:invocation) { lambda { ChairFactory.build } }
-      Then { invocation.should_not raise_error }
+      describe "normal class method spy" do
+        Given(:invocation) { lambda { ChairFactory.build } }
+        Then { invocation.should_not raise_error }
 
-      context "upon reset" do
-        When { Gimme.reset }
-        Then { invocation.should raise_error }
+        context "upon reset" do
+          When { Gimme.reset }
+          Then { invocation.should raise_error }
+        end
+
+      end
+
+      describe "imaginary class method spy" do
+        Given(:invocation) { lambda { ChairFactory.fantasy } }
+        Then { invocation.should_not raise_error }
+
+        context "upon reset" do
+          When { Gimme.reset }
+          Then { invocation.should raise_error }
+        end
       end
     end
 
     context "classical API" do
       it_behaves_like "it spies on class methods" do
-        Given { SpiesOnClassMethod.new(ChairFactory).spy(:build) }
+        subject { SpiesOnClassMethod.new(ChairFactory) }
+        Given { subject.spy(:build) }
+        Given { subject.raises_no_method_error = false }
+        Given { subject.spy(:fantasy) }
       end
     end
 
     context "gimme DSL" do
       it_behaves_like "it spies on class methods" do
         Given { spy_on(ChairFactory, :build) }
+        Given { spy_on!(ChairFactory, :fantasy) }
       end
     end
 

spec/gimme/verifies_class_methods_spec.rb

@@ -10,23 +10,36 @@ def self.ferment(beans=nil,time=nil)
     end
 
     Given(:test_double) { Natto }
+    Given(:double_name) { "#<Class:Gimme::Natto>" }
+    Given(:verifier_class) { VerifiesClassMethods }
 
     context "class API" do
+      Given { SpiesOnClassMethod.new(Natto).spy(:ferment) }
+
       Given(:verifier) { VerifiesClassMethods.new(test_double) }
+
       it_behaves_like "a verifier"
+
       it_behaves_like "an overridden verifier" do
+        Given do
+          s = SpiesOnClassMethod.new(Natto)
+          s.raises_no_method_error = false
+          s.spy(:eat)
+        end
         Given { verifier.raises_no_method_error = false }
       end
     end
 
-    context "gimme DSL" do
-      it_behaves_like "a verifier" do
-        Given(:verifier) { verify(test_double) }
-      end
-
-      it_behaves_like "an overridden verifier" do
-        Given(:verifier) { verify!(test_double) }
-      end
-    end
+    # context "gimme DSL" do
+    #   Given { spy_on(Natto, :ferment)}
+    #
+    #   it_behaves_like "a verifier" do
+    #     Given(:verifier) { verify(test_double) }
+    #   end
+    #
+    #   it_behaves_like "an overridden verifier" do
+    #     Given(:verifier) { verify!(test_double) }
+    #   end
+    # end
   end
 end

spec/gimme/verifies_spec.rb

@@ -10,6 +10,8 @@ def ferment(beans=nil,time=nil)
     end
 
     Given(:test_double) { gimme(Natto) }
+    Given(:double_name) { "Gimme::Natto" }
+    Given(:verifier_class) { Verifies }
 
     context "class API" do
       Given(:verifier) { Verifies.new(test_double) }