gimme 0.1.8 → 0.2.0

data/lib/gimme.rb

@@ -1,12 +1,16 @@
 require 'gimme/test_double'
-require 'gimme/method_resolver'
+require 'gimme/resolves_methods'
 require 'gimme/errors'
+require 'gimme/gives_class_methods'
 require 'gimme/gives'
 require 'gimme/verifies'
 require 'gimme/matchers'
 require 'gimme/captor'
+require 'gimme/invokes_satisfied_stubbing'
+require 'gimme/reset'
+require 'gimme/dsl'
+
 require 'gimme/rspec_adapter'
 
-include Gimme
 include Gimme::Matchers
-
+include Gimme::DSL

data/lib/gimme/dsl.rb

@@ -0,0 +1,50 @@
+module Gimme
+  module DSL
+    
+    # Instantiation
+    
+    def gimme(cls=nil)
+      Gimme::TestDouble.new(cls)
+    end
+
+    def gimme_next(cls)
+      double = Gimme::TestDouble.new(cls)
+      meta_class = class << cls; self; end
+      real_new = cls.method(:new)
+      meta_class.send(:define_method,:new) do |*args|
+        double.send(:initialize,*args)
+        meta_class.send(:define_method,:new,real_new) #restore :new on the class
+        double
+      end
+      double
+    end
+
+    
+    # Stubbing
+    def give(double)
+      if double.kind_of? Class
+        Gimme::GivesClassMethods.new(double)
+      else
+        Gimme::Gives.new(double)
+      end
+    end
+
+    def give!(double)
+      give = give(double)
+      give.raises_no_method_error = false
+      give
+    end
+
+    # Verification
+    def verify(double,times=1)
+      Gimme::Verifies.new(double,times)
+    end
+
+    def verify!(double,times=1)
+      verify = verify(double,times)
+      verify.raises_no_method_error = false
+      verify
+    end
+    
+  end
+end

data/lib/gimme/gives.rb

@@ -8,20 +8,11 @@ module Gimme
     end
 
     def method_missing(sym, *args, &block)
-      sym = MethodResolver.resolve_sent_method(@double,sym,args,@raises_no_method_error)
+      sym = ResolvesMethods.new(@double.cls,sym,args).resolve(@raises_no_method_error)
 
       @double.stubbings[sym] ||= {}
       @double.stubbings[sym][args] = block if block
     end
   end
 
-  def give(double)
-    Gimme::Gives.new(double)
-  end
-
-  def give!(double)
-    give = give(double)
-    give.raises_no_method_error = false
-    give
-  end
 end

data/lib/gimme/gives_class_methods.rb

@@ -0,0 +1,54 @@
+module Gimme
+
+  class GivesClassMethods < BlankSlate
+    attr_accessor :raises_no_method_error
+    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)
+      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
+
+      #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)
+        end
+        @@stubbings.clear
+      end
+    end
+
+    private
+
+    def meta_for(cls)
+      (class << cls; self; end)
+    end
+
+    def hidden_name_for(method)
+      "__gimme_#{method}"
+    end
+  end
+
+end

data/lib/gimme/invokes_satisfied_stubbing.rb

@@ -0,0 +1,29 @@
+module Gimme
+  class InvokesSatisfiedStubbing
+    def initialize(stubbings)
+      @stubbings = stubbings
+    end
+
+    def invoke(method, args)
+      matching_stub_block = nil
+      @stubbings[method].each do |stub_args,stub_block|
+        matching = args.size == stub_args.size
+        args.each_index do |i|
+          unless args[i] == stub_args[i] || (stub_args[i].respond_to?(:matches?) && stub_args[i].matches?(args[i]))
+            matching = false
+            break
+          end
+        end
+        matching_stub_block = stub_block if matching
+      end
+
+      if matching_stub_block
+        matching_stub_block.call
+      elsif method.to_s[-1,1] == '?'
+        false
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/gimme/reset.rb

@@ -0,0 +1,14 @@
+module Gimme
+  @@stuff_to_do_on_reset = []
+
+  def self.on_reset (&blk)
+    @@stuff_to_do_on_reset << blk
+  end
+
+  def self.reset
+    @@stuff_to_do_on_reset.delete_if do |stuff|
+      stuff.call
+      true
+    end
+  end
+end

data/lib/gimme/resolves_methods.rb

@@ -0,0 +1,40 @@
+module Gimme
+
+  class ResolvesMethods
+    def initialize(cls,sym,args)
+      @cls = cls
+      @sym = sym
+      @args = args
+    end
+
+    def resolve(raises_no_method_error=true)
+      @sym = @args.shift if @sym == :send
+      if @cls && raises_no_method_error
+        if @cls.private_method_defined?(named(@sym))
+          raise NoMethodError.new("#{@sym} is a private method of your #{@cls} test double, so stubbing/verifying it
+            might not be a great idea. If you want to try to stub or verify this method anyway, then you can
+            invoke give! or verify! to suppress this error.")
+        elsif !@cls.instance_methods.include?(named(@sym))
+          raise NoMethodError.new("Your test double of #{@cls} may not know how to respond to the '#{@sym}' method.
+            If you're confident that a real #{@cls} will know how to respond to '#{@sym}', then you can
+            invoke give! or verify! to suppress this error.")
+        end
+      end
+
+      @sym
+    end
+
+    private
+
+    if RUBY_VERSION >= "1.9.2"
+      def named(sym)
+        sym
+      end
+    else
+      def named(sym)
+        sym.to_s
+      end
+    end
+  end
+
+end

data/lib/gimme/rspec_adapter.rb

@@ -7,6 +7,7 @@ module Gimme
     end
 
     def teardown_mocks_for_rspec
+      Gimme.reset
     end
   end
 end

data/lib/gimme/test_double.rb

@@ -18,49 +18,15 @@ module Gimme
     end
 
     def method_missing(sym, *args, &block)
-      sym = MethodResolver.resolve_sent_method(self,sym,args,false)
+      sym = ResolvesMethods.new(self.cls,sym,args).resolve(false)
 
       @invocations[sym] ||= {}
       @stubbings[sym] ||= {}
 
       @invocations[sym][args] = 1 + (@invocations[sym][args]||0)
 
-      matching_stub_block = nil
-      @stubbings[sym].each do |stub_args,stub_block|
-        matching = args.size == stub_args.size
-        args.each_index do |i|
-          unless args[i] == stub_args[i] || (stub_args[i].respond_to?(:matches?) && stub_args[i].matches?(args[i]))
-            matching = false
-            break
-          end
-        end
-        matching_stub_block = stub_block if matching
-      end
-
-      if matching_stub_block
-        matching_stub_block.call
-      elsif sym.to_s[-1,1] == '?'
-        false
-      else
-        nil
-      end
-    end
-  end
-
-  def gimme(cls=nil)
-    Gimme::TestDouble.new(cls)
-  end
-
-  def gimme_next(cls)
-    double = Gimme::TestDouble.new(cls)
-    meta_class = class << cls; self; end
-    real_new = cls.method(:new)
-    meta_class.send(:define_method,:new) do |*args|
-      double.send(:initialize,*args)
-      meta_class.send(:define_method,:new,real_new) #restore :new on the class
-      double
+      InvokesSatisfiedStubbing.new(@stubbings).invoke(sym, args)
     end
-    double
   end
 
 end

data/lib/gimme/verifies.rb

@@ -9,7 +9,7 @@ module Gimme
     end
 
     def method_missing(sym, *args, &block)
-      sym = MethodResolver.resolve_sent_method(@double,sym,args,@raises_no_method_error)
+      sym = ResolvesMethods.new(@double.cls,sym,args).resolve(@raises_no_method_error)
 
       #gosh, this loop sure looks familiar. just like another ugly loop I know. TODO.
       invoked = 0
@@ -41,13 +41,4 @@ module Gimme
     end
   end
 
-  def verify(double,times=1)
-    Gimme::Verifies.new(double,times)
-  end
-
-  def verify!(double,times=1)
-    verify = verify(double,times)
-    verify.raises_no_method_error = false
-    verify
-  end
 end

data/spec/gimme/captor_spec.rb

@@ -1,34 +1,35 @@
 require 'spec_helper'
 
-
-describe Gimme::Captor do
-  describe "#value" do
-    Given(:captor) { Captor.new }
-    When { captor.value = "panda" }
-    Then { captor.value.should == "panda" }
+module Gimme
+  describe Captor do
+    describe "#value" do
+      Given(:captor) { Captor.new }
+      When { captor.value = "panda" }
+      Then { captor.value.should == "panda" }
+    end
   end
-end
 
-describe Gimme::Matchers::Capture do
-  Given(:captor) { Captor.new }
+  describe Matchers::Capture do
+    Given(:captor) { Captor.new }
 
-  shared_examples_for "an argument captor" do
-    describe "#matches?" do
-      When(:result) { a_capture.matches?("anything at all") }
-      Then { result.should == true }
-      Then { captor.value.should == "anything at all" }
+    shared_examples_for "an argument captor" do
+      describe "#matches?" do
+        When(:result) { a_capture.matches?("anything at all") }
+        Then { result.should == true }
+        Then { captor.value.should == "anything at all" }
+      end
     end
-  end
 
-  context "using the class API" do
-    it_behaves_like "an argument captor" do
-      Given(:a_capture) { Capture.new(captor) }
+    context "using the class API" do
+      it_behaves_like "an argument captor" do
+        Given(:a_capture) { Capture.new(captor) }
+      end
     end
-  end
 
-  context "using gimme DSL" do
-    it_behaves_like "an argument captor" do
-      Given(:a_capture) { capture(captor) }
+    context "using gimme DSL" do
+      it_behaves_like "an argument captor" do
+        Given(:a_capture) { capture(captor) }
+      end
     end
   end
 end

data/spec/gimme/errors_spec.rb

@@ -1,5 +1,7 @@
 require 'spec_helper'
 
-describe Gimme::Errors do
-  specify { Gimme::Errors::VerificationFailedError.kind_of? StandardError }
+module Gimme
+  describe Errors do
+    specify { Errors::VerificationFailedError.kind_of? StandardError }
+  end
 end

data/spec/gimme/gives_class_methods_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'gimme/shared_examples/shared_gives_examples'
+
+module Gimme
+  describe GivesClassMethods do
+
+    class Bunny
+      def self.nibble
+      end
+
+      def self.eat(food)
+      end
+    end
+
+    class Rabbit
+      def self.eat(food)
+      end
+    end
+
+    describe "two classes with similar stubbings" do
+      Given { give(Rabbit).eat("carrot") { "yum" } }
+      Given { give(Bunny).eat("carrot") { "yay" } }
+      Then { Rabbit.eat("carrot").should == "yum" }
+      Then { Bunny.eat("carrot").should == "yay" }
+    end
+
+    context "using the class API" do
+      Given(:subject) { Bunny }
+
+      it_behaves_like "a normal stubbing" do
+        Given(:gives) { GivesClassMethods.new(subject) }
+      end
+
+      it_behaves_like "an overridden stubbing" do
+        Given(:gives) { GivesClassMethods.new(subject) }
+      end
+    end
+
+    context "using the gimme DSL" do
+      Given(:subject) { Bunny }
+
+      it_behaves_like "a normal stubbing" do
+        Given(:gives) { give(subject) }
+      end
+
+      it_behaves_like "an overridden stubbing" do
+        Given(:gives) { give!(subject) }
+      end
+    end
+  end
+end

data/spec/gimme/gives_spec.rb

@@ -1,52 +1,39 @@
 require 'spec_helper'
+require 'gimme/shared_examples/shared_gives_examples'
 
-describe Gimme::Gives do
-  class Bunny
-    def nibble
-    end
-  end
+module Gimme
+  describe Gives do
 
-  shared_examples_for "a normal stubbing" do
-    context "stubbing an existing method" do
-      When { gives.nibble() { "nom" } }
-      Then { subject.nibble.should == "nom" }
-    end
-
-    context "stubbing a non-existent method" do
-      When(:stubbing) {  lambda { gives.bark { "woof" } } }
-      Then { stubbing.should raise_error NoMethodError  }
-    end
-  end
+    class Bunny
+      def nibble
+      end
 
-  shared_examples_for "an overridden stubbing" do
-    context "configured to _not_ raise an error when stubbed method does not exist" do
-      Given { gives.raises_no_method_error =false }
-      When { gives.bark { "woof" } }
-      Then { subject.bark.should == "woof" }
+      def eat(food)
+      end
     end
-  end
 
-  context "using the class API" do
-    Given(:subject) { TestDouble.new(Bunny) }
+    context "using the class API" do
+      Given(:subject) { TestDouble.new(Bunny) }
 
-    it_behaves_like "a normal stubbing" do
-      Given(:gives) { Gives.new(subject) }
-    end
+      it_behaves_like "a normal stubbing" do
+        Given(:gives) { Gives.new(subject) }
+      end
 
-    it_behaves_like "an overridden stubbing" do
-      Given(:gives) { Gives.new(subject) }
+      it_behaves_like "an overridden stubbing" do
+        Given(:gives) { Gives.new(subject) }
+      end
     end
-  end
 
-  context "using the gimme DSL" do
-    Given(:subject) { gimme(Bunny) }
+    context "using the gimme DSL" do
+      Given(:subject) { gimme(Bunny) }
 
-    it_behaves_like "a normal stubbing" do
-      Given(:gives) { give(subject) }
-    end
+      it_behaves_like "a normal stubbing" do
+        Given(:gives) { give(subject) }
+      end
 
-    it_behaves_like "an overridden stubbing" do
-      Given(:gives) { give!(subject) }
+      it_behaves_like "an overridden stubbing" do
+        Given(:gives) { give!(subject) }
+      end
     end
   end
-end
+end