spy 0.2.3 → 0.2.4

data/README.md

@@ -32,7 +32,7 @@ Fail faster, code faster.
 ## Why not to use this
 
 * mocking null objects is not supported(yet)
-* no argument matchers for Spy::Method#has\_been\_called\_with
+* no argument matchers for `Spy::Subroutine#has_been_called_with`
 * cannot watch all calls to an object to check order in which they are called
 * cannot transfer nested constants when stubbing a constant
   * i don't think anybody uses this anyway
@@ -78,7 +78,8 @@ You can force the creation of a stub on method that didn't exist but it really i
 Spy.new(book, :flamethrower).hook(force:true).and_return("burnninante")
 ```
 
-You can also stub instance methods of Classes and Modules
+You can also stub instance methods of Classes and Modules. This is equivalent to
+rspec-mock's `Module#any_instance`
 
 ```ruby
 Spy.on_instance_method(Book, :title).and_return("Cannery Row")
@@ -105,7 +106,7 @@ Spy.double("book", title: "Grapes of Wrath", author: "John Steinbeck")
 
 ### Arbitrary Handling
 
-If you need to have a custom method based in the method inputs just send a block to #and\_return
+If you need to have a custom method based in the method inputs just send a block to `#and_return`
 
 ```ruby
 Spy.on(book, :read_page).and_return do |page, &block|
@@ -142,13 +143,13 @@ Spy.get(validator, :validate)
 ```
 
 ### Calling through
-If you just want to make sure if a method is called and not override the output you can just use the and\_call\_through method
+If you just want to make sure if a method is called and not override the output you can just use the `#and_call_through` method
 
 ```ruby
 Spy.on(book, :read_page).and_call_through
 ```
 
-By if the original method never existed it will call #method\_missing on the spied object.
+By if the original method never existed it will call `#method_missing` on the spied object.
 
 ### Call Logs
 
@@ -170,6 +171,8 @@ first_call.called_from #=> "file_name.rb:line_number"
 
 ### MiniTest
 
+In `test_helper.rb`
+
 ```ruby
 require "spy"
 MiniTest::TestCase.add_teardown_hook { Spy.teardown }
@@ -177,7 +180,7 @@ MiniTest::TestCase.add_teardown_hook { Spy.teardown }
 
 ### Rspec
 
-In spec\_helper.rb
+In `spec_helper.rb`
 
 ```ruby
 require "rspec/autorun"

data/lib/spy/subroutine.rb

@@ -6,17 +6,23 @@ module Spy
     # @!attribute [r] method_name
     #   @return [Symbol] the name of the method that is being watched
     #
+    # @!attribute [r] singleton_method
+    #   @return [Boolean] if the spied method is a singleton_method or not
+    #
     # @!attribute [r] calls
     #   @return [Array<CallLog>] the messages that have been sent to the method
     #
     # @!attribute [r] original_method
     #   @return [Method] the original method that was hooked if it existed
     #
+    # @!attribute [r] original_method_visibility
+    #   @return [Method] the original visibility of the method that was hooked if it existed
+    #
     # @!attribute [r] hook_opts
     #   @return [Hash] the options that were sent when it was hooked
 
 
-    attr_reader :base_object, :method_name, :calls, :original_method, :hook_opts
+    attr_reader :base_object, :method_name, :singleton_method, :calls, :original_method, :original_method_visibility, :hook_opts
 
     # set what object and method the spy should watch
     # @param object
@@ -34,16 +40,18 @@ module Spy
     # @option opts [Symbol<:public, :protected, :private>] visibility overrides visibility with whatever method is given
     # @return [self]
     def hook(opts = {})
-      @hook_opts = opts
       raise "#{base_object} method '#{method_name}' has already been hooked" if hooked?
 
-      hook_opts[:force] ||= base_object.is_a?(Double)
+      @hook_opts = opts
+      @original_method_visibility = method_visibility_of(method_name)
       hook_opts[:visibility] ||= original_method_visibility
+      hook_opts[:force] ||= base_object.is_a?(Double)
 
       if original_method_visibility || !hook_opts[:force]
         @original_method = current_method
       end
 
+      define_method_with = singleton_method ? :define_singleton_method : :define_method
       base_object.send(define_method_with, method_name, override_method)
 
       if [:public, :protected, :private].include? hook_opts[:visibility]
@@ -61,11 +69,12 @@ module Spy
       raise "'#{method_name}' method has not been hooked" unless hooked?
 
       if original_method && method_owner == original_method.owner
-        original_method.owner.send(:define_method, method_name, original_method)
-        original_method.owner.send(original_method_visibility, method_name) if original_method_visibility
+        method_owner.send(:define_method, method_name, original_method)
+        method_owner.send(original_method_visibility, method_name) if original_method_visibility
       else
         method_owner.send(:remove_method, method_name)
       end
+
       clear_method!
       Agency.instance.retire(self)
       self
@@ -74,7 +83,7 @@ module Spy
     # is the spy hooked?
     # @return [Boolean]
     def hooked?
-      self == self.class.get(base_object, method_name, @singleton_method)
+      self == self.class.get(base_object, method_name, singleton_method)
     end
 
     # @overload and_return(value)
@@ -82,10 +91,29 @@ module Spy
     #
     # Tells the spy to return a value when the method is called.
     #
+    # If a block is sent it will execute the block when the method is called.
+    # The airty of the block will be checked against the original method when
+    # you first call `and_return` and when the method is called.
+    #
+    # If you want to disable the arity checking just pass `{force: true}` to the
+    # value
+    #
+    # @example
+    #   spy.and_return(true)
+    #   spy.and_return { true }
+    #   spy.and_return(force: true) { |invalid_arity| true }
+    #
     # @return [self]
     def and_return(value = nil)
-      raise ArgumentError.new("value and block conflict. Choose one") if !(value.nil? || value.is_a?(Hash) && value.has_key?(:force)) && block_given?
+      @do_not_check_plan_arity = false
+
       if block_given?
+        if value.is_a?(Hash) && value.has_key?(:force)
+          @do_not_check_plan_arity = !!value[:force]
+        elsif !value.nil?
+          raise ArgumentError.new("value and block conflict. Choose one")
+        end
+
         @plan = Proc.new
         check_for_too_many_arguments!(@plan)
       else
@@ -192,6 +220,9 @@ module Spy
 
     private
 
+    # this returns a lambda that calls the spy object.
+    # we use eval to set the spy object id as a parameter so it can be extracted
+    # and looked up later using `Method#parameters`
     def override_method
       eval <<-METHOD, binding, __FILE__, __LINE__ + 1
       __method_spy__ = self
@@ -202,16 +233,12 @@ module Spy
     end
 
     def clear_method!
-      @hooked = false
+      @hooked = @do_not_check_plan_arity = false
       @hook_opts = @original_method = @arity_range = @original_method_visibility = @method_owner= nil
     end
 
-    def original_method_visibility
-      @original_method_visibility ||= method_visibility_of(method_name)
-    end
-
     def method_visibility_of(method_name, all = true)
-      if @singleton_method
+      if singleton_method
         if base_object.public_methods(all).include?(method_name)
           :public
         elsif base_object.protected_methods(all).include?(method_name)
@@ -230,10 +257,6 @@ module Spy
       end
     end
 
-    def define_method_with
-      @singleton_method ? :define_singleton_method : :define_method
-    end
-
     def check_arity!(arity)
       return unless arity_range
       if arity < arity_range.min
@@ -241,10 +264,11 @@ module Spy
       elsif arity > arity_range.max
         raise ArgumentError.new("wrong number of arguments (#{arity} for #{arity_range.max})")
       end
+      true
     end
 
     def check_for_too_many_arguments!(block)
-      return unless arity_range
+      return if @do_not_check_plan_arity || arity_range.nil?
       min_arity = block.arity
       min_arity = min_arity.abs - 1 if min_arity < 0
 
@@ -273,7 +297,7 @@ module Spy
     end
 
     def current_method
-      @singleton_method ? base_object.method(method_name) : base_object.instance_method(method_name)
+      singleton_method ? base_object.method(method_name) : base_object.instance_method(method_name)
     end
 
     def method_owner

data/lib/spy/version.rb

@@ -1,3 +1,3 @@
 module Spy
-  VERSION = "0.2.3"
+  VERSION = "0.2.4"
 end

data/test/spy/test_subroutine.rb

@@ -107,6 +107,9 @@ module Spy
         write_spy.and_return do |string, b|
         end
       end
+
+      write_spy.and_return(force: true) do |string, b|
+      end
     end
 
     def test_spy_and_return_can_call_a_block_that_recieves_a_block

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spy
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
   prerelease: 
 platform: ruby
 authors: