spy 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa89505674a7286f055ee019988cf29debbdd5cb7e525a022864f551d20ae842
-  data.tar.gz: fa61fa5e78f5aea6fab75bcc471bdcc8032182d8e9c7528e9370b91022ef7ae0
+  metadata.gz: 3906b9e65a981746a6dc4e51106ed64fc925478cb73335eb8a9d46ae9fc31931
+  data.tar.gz: 85e19b544c6ccb98616dd846db8263da3d0e8abcfd2158a5749d8988c5dc32e8
 SHA512:
-  metadata.gz: abb91b0bcef139e03b90cb59f2f1b5d9f0c52c8137beafab301f56a96d44dbcffc203bcf0c69cd7e5376bed68549e0bb9bf407b4f85e07fc91d875d401ce39d0
-  data.tar.gz: 58d355373220b031ba5740b0cfdc2a6d9bb94a7c39166fafae23896342eec3c3b907994f7224e80abc7f2d1ae289048d98cd56a05750569befa62c98f6330a22
+  metadata.gz: 57544c0872ff818dc065037e1e2a10c34b1edb698ad84ebf1e184aa190d24c8663d51d011619bb6a1024c93f1d94a03a8bd6578274605a56f0b0ba06aabf6abc
+  data.tar.gz: 43b7ca82d10759bb6083fdd76b27941425cefbcc63bc2b8a585b34d3c8e2c2659f24c1f4f32843ee1c1b8f3aee1d64c127fb769774430e77a31ea7005aeebbcb

data/lib/spy/subroutine.rb

@@ -33,6 +33,7 @@ module Spy
       @base_object, @method_name = object, method_name
       @singleton_method = singleton_method
       @plan = nil
+      @call_through = false
       reset!
     end
 
@@ -58,14 +59,14 @@ module Spy
 
       if singleton_method
         if base_object.singleton_class.method_defined?(method_name) || base_object.singleton_class.private_method_defined?(method_name)
-          base_object.singleton_class.alias_method(method_name, method_name)
+          base_object.singleton_class.send(:alias_method, method_name, method_name)
         end
         base_object.define_singleton_method(method_name, override_method)
       else
         if base_object.method_defined?(method_name) || base_object.private_method_defined?(method_name)
-          base_object.alias_method(method_name, method_name)
+          base_object.send(:alias_method, method_name, method_name)
         end
-        base_object.define_method(method_name, override_method)
+        base_object.send(:define_method, method_name, override_method)
       end
 
       if [:public, :protected, :private].include? hook_opts[:visibility]
@@ -148,28 +149,7 @@ module Spy
     # tells the spy to call the original method
     # @return [self]
     def and_call_through
-      if @base_object.is_a? Class
-        @plan = Proc.new do |object, *args, &block|
-          if original_method
-            if original_method.is_a? UnboundMethod
-              bound_method = original_method.bind(object)
-              bound_method.call(*args, &block)
-            else
-              original_method.call(*args, &block)
-            end
-          else
-            base_object.send(:method_missing, method_name, *args, &block)
-          end
-        end
-      else
-        @plan = Proc.new do |*args, &block|
-          if original_method
-            original_method.call(*args, &block)
-          else
-            base_object.send(:method_missing, method_name, *args, &block)
-          end
-        end
-      end
+      @call_through = true
 
       self
     end
@@ -232,17 +212,17 @@ module Spy
     def invoke(object, args, block, called_from)
       check_arity!(args.size)
 
-      if base_object.is_a? Class
-        result = if @plan
-                   check_for_too_many_arguments!(@plan)
-                   @plan.call(object, *args, &block)
-                 end
-      else
-        result = if @plan
-                   check_for_too_many_arguments!(@plan)
-                   @plan.call(*args, &block)
-                 end
-      end
+      result =
+        if @call_through
+          call_plan(build_call_through_plan(object), block, *args)
+        elsif @plan
+          check_for_too_many_arguments!(@plan)
+          if base_object.is_a? Class
+            call_plan(@plan, block, object, *args)
+          else
+            call_plan(@plan, block, *args)
+          end
+        end
     ensure
       calls << CallLog.new(object, called_from, args, block, result)
     end
@@ -355,6 +335,39 @@ module Spy
       @method_owner ||= current_method.owner
     end
 
+    def build_call_through_plan(object)
+      if original_method
+        if @base_object.is_a?(Class) && original_method.is_a?(UnboundMethod)
+          original_method.bind(object)
+        else
+          original_method
+        end
+      else
+        Proc.new do |*args, &block|
+          base_object.send(:method_missing, method_name, *args, &block)
+        end
+      end
+    end
+
+    def call_plan(plan, block, *args)
+      if ruby_27_last_arg_hash?(args)
+        *prefix, last = args
+        plan.call(*prefix, **last, &block)
+      else
+        plan.call(*args, &block)
+      end
+    end
+
+    # Ruby 2.7 gives a deprecation warning about passing hash as last argument for a method
+    # with a double-splat operator (**), and Ruby 3 raises an ArgumentError exception.
+    # This checks if args has a hash as last element to extract it and pass it with double-splat to avoid an exception.
+    def ruby_27_last_arg_hash?(args)
+      last = args.last
+      last.instance_of?(Hash) &&
+        !last.empty? &&
+        Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.7.0")
+    end
+
     class << self
 
       # retrieve the method spy from an object or create a new one

data/lib/spy/version.rb

@@ -1,3 +1,3 @@
 module Spy
-  VERSION = "1.0.1"
+  VERSION = "1.0.2"
 end

data/test/spy/test_subroutine.rb

@@ -6,6 +6,10 @@ module Spy
       Subroutine.new(base_object, method_name).hook
     end
 
+    def spy_on_instance_method(base_object, method_name)
+      Subroutine.new(base_object, method_name, false).hook
+    end
+
     def setup
       @pen = Pen.new
     end
@@ -109,6 +113,15 @@ module Spy
       assert_empty @pen.written
     end
 
+    def test_spy_and_return_can_call_a_block_with_hash
+      result = "hello world"
+
+      spy_on(@pen, :write_hash).and_return { |**opts| opts[:test] }
+
+      assert_equal result, @pen.write_hash(test: result)
+      assert_empty @pen.written
+    end
+
     def test_spy_and_return_can_call_a_block_raises_when_there_is_an_arity_mismatch
       write_spy = spy_on(@pen, :write)
       write_spy.and_return do |*args|
@@ -137,6 +150,73 @@ module Spy
       assert_equal string, result
     end
 
+    def test_spy_and_call_through_returns_original_method_result
+      string = "hello world"
+
+      write_spy = spy_on(@pen, :write).and_call_through
+      another_spy = spy_on(@pen, :another).and_call_through
+
+      result = @pen.write(string)
+
+      assert_equal string, result
+      assert write_spy.has_been_called?
+      assert_equal 'another', @pen.another
+      assert another_spy.has_been_called?
+    end
+
+    def test_spy_and_call_through_with_hash_original_method
+      string = 'test:hello world'
+
+      write_spy = spy_on(@pen, :write_hash).and_call_through
+
+      @pen.write_hash(test: 'hello world')
+      assert_equal string, @pen.written.last
+      assert write_spy.has_been_called?
+    end
+
+    def test_spy_on_instance_and_call_through_returns_original_method_result
+      string = "hello world"
+
+      inst_write_spy = spy_on_instance_method(Pen, :write).and_call_through
+      inst_another_spy = spy_on_instance_method(Pen, :another).and_call_through
+
+      result = @pen.write(string)
+
+      assert_equal string, result
+      assert inst_write_spy.has_been_called?
+      assert_equal 'another', @pen.another
+      assert inst_another_spy.has_been_called?
+    end
+
+    def test_spy_on_instance_and_call_through_with_hash
+      string = 'test:hello world'
+
+      inst_write_spy = spy_on_instance_method(Pen, :write_hash).and_call_through
+
+      @pen.write_hash(test: 'hello world')
+
+      assert_equal string, @pen.written.last
+      assert inst_write_spy.has_been_called?
+    end
+
+    def test_spy_on_instance_and_call_through_to_aryable
+      to_aryable = Class.new do
+        def hello
+          'hello'
+        end
+
+        def to_ary
+          [1]
+        end
+      end
+
+      inst_hello_spy = spy_on_instance_method(to_aryable, :hello).and_call_through
+      inst = to_aryable.new
+
+      assert_equal 'hello', inst.hello
+      assert inst_hello_spy.has_been_called?
+    end
+
     def test_spy_hook_records_number_of_calls
       pen_write_spy = spy_on(@pen, :write)
       assert_equal 0, pen_write_spy.calls.size

data/test/support/pen.rb

@@ -27,6 +27,12 @@ class Pen
     end
   end
 
+  def write_hash(**params)
+    params.each do |p|
+      write(p.join(':'))
+    end
+  end
+
   def greet(hello = "hello", name)
     write("#{hello} #{name}")
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spy
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Ryan Ong
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-08-20 00:00:00.000000000 Z
+date: 2022-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -169,7 +169,7 @@ homepage: https://github.com/ryanong/spy
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -185,7 +185,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.2
-signing_key: 
+signing_key:
 specification_version: 4
 summary: A simple modern mocking library that uses the spy pattern and checks method's
   existence and arity.