spy 0.4.3 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 60daeb7dc9a4b41de1284dcc4353bcf278ddce75
-  data.tar.gz: 93534dcf719a49ac1907e585d6633cd561cd2546
+SHA256:
+  metadata.gz: 3906b9e65a981746a6dc4e51106ed64fc925478cb73335eb8a9d46ae9fc31931
+  data.tar.gz: 85e19b544c6ccb98616dd846db8263da3d0e8abcfd2158a5749d8988c5dc32e8
 SHA512:
-  metadata.gz: c4177bc16ff8d22aa2236bdcfa35c79248bf73ef93117c91a75d0c7515a71d2a833304df1abf893905992f4765bf4b92c530fd7807f6421ea18ec4bead99e75a
-  data.tar.gz: 2d803b1a5ddac06a0f218a963cf01e0be05a9d4bb835f3ff86e7edb49e4dd22b88844ebe4ca65348e85def83ef1c125220a52ed31a9536d4a5fa8fa54f52a63e
+  metadata.gz: 57544c0872ff818dc065037e1e2a10c34b1edb698ad84ebf1e184aa190d24c8663d51d011619bb6a1024c93f1d94a03a8bd6578274605a56f0b0ba06aabf6abc
+  data.tar.gz: 43b7ca82d10759bb6083fdd76b27941425cefbcc63bc2b8a585b34d3c8e2c2659f24c1f4f32843ee1c1b8f3aee1d64c127fb769774430e77a31ea7005aeebbcb

data/.tool-versions

@@ -0,0 +1 @@
+ruby 2.7.0

data/.travis.yml

@@ -1,11 +1,13 @@
 language: ruby
 rvm:
-  - 1.9.3
-  - 2.0.0
-  - jruby-19mode
+  - '2.1'
+  - '2.5'
+  - '2.7'
+  - jruby
   - ruby-head
-  - rbx-19mode
+  - rbx-3
 matrix:
   allow_failures:
       - rvm: ruby-head
-      - rvm: rbx-19mode
+      - rvm: rbx-3
+      - rvm: jruby

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## Spy 1.0.1 (August 20th, 2020) ##
+
+*   Fix call_through w/ instance methods (@lreeves)
+*   Replace implicit Proc.new by explicit given block reference (@Hugo-Hache)
+*   Remove 2.7 warnings (@byroot)
+
+## Spy 1.0.0 (October 10, 2018) ##
+
+*   drop support for ruby 1.9.3, 2.0. Only support 2.1+ (@dylanahsmith)
+*   support named arguments (@dylanahsmith)
+*   Fix readme (@ignat-z)
+
 ## Spy 0.4.3 (April 14, 2016) ##
 
 *   Double performance of spy lookups (@BlakeMesdag)

data/README.md

@@ -9,7 +9,8 @@
 
 Spy is a lightweight stubbing framework with support for method spies, constant stubs, and object mocks.
 
-Spy was designed for 1.9.3+.
+Spy supports ruby 2.1.0+.
+For versions less than 2.1 use v0.4.5
 
 Spy features that were completed were tested against the rspec-mocks tests so it covers all cases that rspec-mocks does.
 
@@ -197,7 +198,7 @@ In your test file
 ```ruby
   def test_title
     book = Book.new
-    title_spy = Spy.on(book, title)
+    title_spy = Spy.on(book, :title)
     book.title
     book.title
 

data/Rakefile

@@ -3,7 +3,7 @@ require 'rake/testtask'
 
 Rake::TestTask.new do |t|
   t.libs << "test"
-  t.test_files = FileList['test/**/test*.rb']
+  t.test_files = FileList['test/**/test_*.rb']
   t.verbose = true
 end
 

data/lib/spy/api.rb

@@ -36,8 +36,8 @@ module Spy
         end
       end
 
-      def with(*args)
-        @with = block_given? ? Proc.new : args
+      def with(*args, &block)
+        @with = block_given? ? block : args
         self
       end
 

data/lib/spy/subroutine.rb

@@ -32,6 +32,8 @@ module Spy
     def initialize(object, method_name, singleton_method = true)
       @base_object, @method_name = object, method_name
       @singleton_method = singleton_method
+      @plan = nil
+      @call_through = false
       reset!
     end
 
@@ -51,8 +53,21 @@ module Spy
         @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 original_method && original_method.owner == base_object
+        original_method.owner.send(:remove_method, method_name)
+      end
+
+      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.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.send(:alias_method, method_name, method_name)
+        end
+        base_object.send(:define_method, method_name, override_method)
+      end
 
       if [:public, :protected, :private].include? hook_opts[:visibility]
         method_owner.send(hook_opts[:visibility], method_name)
@@ -68,11 +83,10 @@ module Spy
     def unhook
       raise NeverHookedError, "'#{method_name}' method has not been hooked" unless hooked?
 
+      method_owner.send(:remove_method, method_name)
       if original_method && method_owner == original_method.owner
-        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)
+        original_method.owner.send(:define_method, method_name, original_method)
+        original_method.owner.send(original_method_visibility, method_name) if original_method_visibility
       end
 
       clear_method!
@@ -104,7 +118,7 @@ module Spy
     #   spy.and_return(force: true) { |invalid_arity| true }
     #
     # @return [self]
-    def and_return(value = nil)
+    def and_return(value = nil, &block)
       @do_not_check_plan_arity = false
 
       if block_given?
@@ -114,7 +128,7 @@ module Spy
           raise ArgumentError, "value and block conflict. Choose one"
         end
 
-        @plan = Proc.new
+        @plan = block
         check_for_too_many_arguments!(@plan)
       else
         @plan = Proc.new { value }
@@ -135,13 +149,8 @@ module Spy
     # tells the spy to call the original method
     # @return [self]
     def and_call_through
-      @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
+      @call_through = true
+
       self
     end
 
@@ -167,6 +176,7 @@ module Spy
       end
 
       @plan = Proc.new { raise exception }
+      self
     end
 
     # @overload and_throw(symbol)
@@ -191,9 +201,9 @@ module Spy
     # check if the method was called with the exact arguments
     # @param args Arguments that should have been sent to the method
     # @return [Boolean]
-    def has_been_called_with?(*args)
+    def has_been_called_with?(*args, &block)
       raise NeverHookedError unless @was_hooked
-      match = block_given? ? Proc.new : proc { |call| call.args == args }
+      match = block_given? ? block : proc { |call| call.args == args }
       calls.any?(&match)
     end
 
@@ -201,10 +211,18 @@ module Spy
     # method.
     def invoke(object, args, block, called_from)
       check_arity!(args.size)
-      result = if @plan
-                 check_for_too_many_arguments!(@plan)
-                 @plan.call(*args, &block)
-               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
@@ -272,6 +290,8 @@ module Spy
       min_arity = block.arity
       min_arity = min_arity.abs - 1 if min_arity < 0
 
+      min_arity -=1 if base_object.is_a? Class # Instance-method procs take an extra param for receiving object
+
       if min_arity > arity_range.max
         raise ArgumentError.new("block requires #{min_arity} arguments while original_method require a maximum of #{arity_range.max}")
       end
@@ -281,6 +301,8 @@ module Spy
       @arity_range ||=
         if original_method
           min = max = 0
+          key_args = false
+          opt_keys = false
           original_method.parameters.each do |type,_|
             case type
             when :req
@@ -290,8 +312,17 @@ module Spy
               max += 1
             when :rest
               max = Float::INFINITY
+            when :keyreq
+              key_args = true
+            when :keyrest, :key
+              key_args = true
+              opt_keys = true
             end
           end
+          if key_args
+            max += 1
+            min += 1 unless opt_keys
+          end
           (min..max)
         end
     end
@@ -304,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 = "0.4.3"
+  VERSION = "1.0.2"
 end

data/lib/spy.rb

@@ -34,8 +34,6 @@ module Spy
         spy = Subroutine.get(base_object, method_name)
         if spy
           spy.unhook
-        else
-          raise NoSpyError, "#{method_name} was not hooked on #{base_object.inspect}."
         end
       end
 

data/spy.gemspec

@@ -6,12 +6,12 @@ require 'spy/version'
 Gem::Specification.new do |gem|
   gem.name          = "spy"
   gem.version       = Spy::VERSION
-  gem.required_ruby_version = '>= 1.9.3'
+  gem.required_ruby_version = '>= 2.1.0'
   gem.license       = 'MIT'
   gem.authors       = ["Ryan Ong"]
   gem.email         = ["ryanong@gmail.com"]
   gem.summary       = %q{A simple modern mocking library that uses the spy pattern and checks method's existence and arity.}
-  gem.description   = %q{Spy is a mocking library that was made for the modern age. It supports only 1.9.3+. Spy by default will raise an error if you attempt to stub a method that doesn't exist or call the stubbed method with the wrong arity.}
+  gem.description   = %q{Spy is a mocking library that was made for the modern age. It supports only 2.1.0+. Spy by default will raise an error if you attempt to stub a method that doesn't exist or call the stubbed method with the wrong arity.}
   gem.homepage      = "https://github.com/ryanong/spy"
 
   gem.files         = `git ls-files`.split($/)
@@ -19,8 +19,9 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
   gem.add_development_dependency('pry')
-  gem.add_development_dependency('pry-nav')
+  gem.add_development_dependency('pry-byebug')
   gem.add_development_dependency('minitest', '>= 4.5.0')
+  gem.add_development_dependency('minitest-reporters')
   gem.add_development_dependency('rspec-core')
   gem.add_development_dependency('rspec-expectations')
   gem.add_development_dependency('coveralls')

data/test/integration/test_constant_spying.rb

@@ -30,7 +30,7 @@ class TestConstantSpying < Minitest::Test
     assert_equal "hello world", Foo.hello
 
     spy = Spy.on_const(Foo, :HELLO)
-    assert_equal nil, Foo.hello
+    assert_nil Foo.hello
     spy.and_return("awesome")
     assert_equal "awesome", Foo.hello
 
@@ -39,7 +39,7 @@ class TestConstantSpying < Minitest::Test
 
     assert_equal "hello world", Foo::Bar.hello
     spy = Spy.on_const(Foo, :HELLO)
-    assert_equal nil, Foo::Bar.hello
+    assert_nil Foo::Bar.hello
     spy.and_return("awesome")
     assert_equal "awesome", Foo::Bar.hello
 
@@ -48,7 +48,7 @@ class TestConstantSpying < Minitest::Test
 
     assert_equal "hello world", ChildFoo.hello
     spy = Spy.on_const(Foo, :HELLO)
-    assert_equal nil, ChildFoo.hello
+    assert_nil ChildFoo.hello
     spy.and_return("awesome")
     assert_equal "awesome", ChildFoo.hello
 

data/test/integration/test_instance_method.rb

@@ -17,6 +17,12 @@ class TestAnyInstanceOf < Minitest::Test
     Spy::Agency.instance.dissolve!
   end
 
+  def test_call_through_with_instance_method
+    Spy.on_instance_method(Foo, :bar).and_call_through
+    assert_equal "foobar", Foo.new.bar
+    Spy.off_instance_method(Foo, :bar)
+  end
+
   def test_it_overides_all_methods
     assert_equal Foo.new.bar, "foobar"
     spy = Spy.on_instance_method(Foo, bar: "timshel")

data/test/integration/test_subroutine_spying.rb

@@ -16,12 +16,12 @@ class TestSpy < Minitest::Test
 
     assert_kind_of Spy::Subroutine, pen_write_spy
     assert_kind_of Spy::Subroutine, pen_write_hello_spy
-    assert_equal [pen_write_spy, pen_write_hello_spy], Spy::Agency.instance.subroutines
+    assert_equal [pen_write_spy, pen_write_hello_spy], Spy::Agency.instance.spies
     assert pen_write_spy.has_been_called?
     assert pen_write_hello_spy.has_been_called?
   end
 
-  def test_spy_on_hooks_and_saves_spy_with_array
+  def test_spy_on_hooks_and_saves_spy_with_hash
     pen_write_spy, pen_write_hello_spy = Spy.on(@pen, write: "hello", write_hello: "world")
     assert_equal "hello", @pen.write(nil)
     assert_equal "world", @pen.write_hello

data/test/spy/test_mock.rb

@@ -68,6 +68,7 @@ module Spy
       end
     end
 
+    BUGGY_METHODS = %i(tap pretty_print_inspect trust untrust untrusted? debugger byebug taint untaint tainted?)
     def test_mocked_methods
       pen_methods = Pen.public_instance_methods(false) +
         Pen.protected_instance_methods(false) +
@@ -76,8 +77,7 @@ module Spy
       assert_equal pen_methods.sort, @pen_mock.mocked_methods.sort
     end
 
-    buggy_methods = [:tap, :pretty_print_inspect]
-    methods_to_test = Object.instance_methods - buggy_methods
+    methods_to_test = Object.instance_methods - BUGGY_METHODS
     methods_to_test.each do |method_name|
       object_method = Object.instance_method(method_name)
       if object_method.arity == 0 || (RUBY_ENGINE != "jruby" && object_method.parameters == [])

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
@@ -40,13 +44,13 @@ module Spy
     end
 
     def test_spy_can_hook_and_record_a_meta_method_call_on_a_constant
-      assert_equal "meta_method", Pen.meta_method
-      meta_spy = spy_on(Pen, :meta_method)
+      assert_equal "meta_class_method", Pen.meta_class_method
+      meta_spy = spy_on(Pen, :meta_class_method)
       refute meta_spy.has_been_called?
-      assert_nil Pen.meta_method
+      assert_nil Pen.meta_class_method
       assert meta_spy.has_been_called?
       meta_spy.unhook
-      assert_equal "meta_method", Pen.meta_method
+      assert_equal "meta_class_method", Pen.meta_class_method
     end
 
     def test_spy_can_hook_record_and_unhook_a_meta_method
@@ -86,6 +90,18 @@ module Spy
       assert_equal result, @pen.write(nil)
     end
 
+    def test_spy_and_raise_raises_the_set_exception
+      pen_write_spy = spy_on(@pen, :write).and_raise(ArgumentError, "problems!")
+      assert_kind_of Subroutine, pen_write_spy
+      assert_equal [pen_write_spy], Agency.instance.spies
+
+      e = assert_raises ArgumentError do
+        @pen.write(nil)
+      end
+      assert_equal "problems!", e.message
+      assert pen_write_spy.has_been_called?
+    end
+
     def test_spy_and_return_can_call_a_block
       result = "hello world"
 
@@ -97,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|
@@ -125,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
@@ -145,7 +237,7 @@ module Spy
       assert pen_write_spy.has_been_called_with?("hello")
     end
 
-    def test_spy_hook_records_number_of_calls
+    def test_spy_hook_records_number_of_calls2
       args = ["hello world"]
       block = Proc.new {}
       pen_write_spy = spy_on(@pen, :write)
@@ -187,6 +279,38 @@ module Spy
       end
     end
 
+    def test_that_method_spy_keeps_arity_with_optional_keyword_args
+      spy_on(@pen, :opt_kwargs)
+      @pen.opt_kwargs(:pos1)
+      @pen.opt_kwargs(:pos1, opt: 1, opt2: 2)
+      assert_raises ArgumentError do
+        @pen.opt_kwargs
+      end
+      assert_raises ArgumentError do
+        @pen.opt_kwargs(:pos1, :pos2, opt: 1)
+      end
+    end
+
+    def test_that_method_spy_keeps_arity_with_keyword_splat
+      spy_on(@pen, :keyrest)
+      @pen.keyrest
+      @pen.keyrest(a: 1, b: 2)
+      assert_raises ArgumentError do
+        @pen.keyrest(:pos1, :pos2)
+      end
+    end
+
+    def test_that_method_spy_keeps_arity_with_required_keyword_args
+      spy_on(@pen, :req_kwargs)
+      @pen.req_kwargs(req1: 1, req2: 2)
+      assert_raises ArgumentError do
+        @pen.req_kwargs
+      end
+      assert_raises ArgumentError do
+        @pen.req_kwargs(:pos1, :pos2)
+      end
+    end
+
     def test_hook_mimics_public_visibility
       spy_on(@pen, :public_method)
       assert @pen.singleton_class.public_method_defined? :public_method

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
@@ -38,6 +44,18 @@ class Pen
     "another"
   end
 
+  def opt_kwargs(required, opt: nil, opt2: nil)
+    [required, opt: opt, opt2: opt2]
+  end
+
+  def keyrest(**kwargs)
+    kwargs
+  end
+
+  def req_kwargs(req1:, req2:)
+    [req1, req2]
+  end
+
   protected
   def protected_method
   end
@@ -65,13 +83,11 @@ class Pen
   end
 end
 
-another = "meta_method"
-
-Pen.define_singleton_method(:meta_method) do
-  another
+Pen.define_singleton_method(:meta_class_method) do
+  "meta_class_method".freeze
 end
 
 Pen.send(:define_method, :meta_method) do
-  another
+  "meta_method".freeze
 end
 

data/test/test_helper.rb

@@ -1,9 +1,11 @@
 require 'bundler/setup'
-require 'minitest/autorun'
 require 'pry'
-require 'pry-nav'
+require 'pry-byebug'
+require 'minitest/autorun'
+require "minitest/reporters"
 require 'coveralls'
 Coveralls.wear!
+Minitest::Reporters.use!
 
 require 'spy'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spy
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 1.0.2
 platform: ruby
 authors:
 - Ryan Ong
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-04-14 00:00:00.000000000 Z
+date: 2022-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry-nav
+  name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 4.5.0
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec-core
   requirement: !ruby/object:Gem::Requirement
@@ -95,7 +109,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: Spy is a mocking library that was made for the modern age. It supports
-  only 1.9.3+. Spy by default will raise an error if you attempt to stub a method
+  only 2.1.0+. Spy by default will raise an error if you attempt to stub a method
   that doesn't exist or call the stubbed method with the wrong arity.
 email:
 - ryanong@gmail.com
@@ -104,6 +118,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".tool-versions"
 - ".travis.yml"
 - ".yardopts"
 - CHANGELOG.md
@@ -154,7 +169,7 @@ homepage: https://github.com/ryanong/spy
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -162,16 +177,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.1
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: A simple modern mocking library that uses the spy pattern and checks method's
   existence and arity.
@@ -201,4 +215,3 @@ test_files:
 - test/spy/test_subroutine.rb
 - test/support/pen.rb
 - test/test_helper.rb
-has_rdoc: