grift 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dfb5ff564a491305f0eccd4e3098fb3c132fca4b70fef6f07ff05fd5a087fe12
-  data.tar.gz: bf327e20c122bc67ac490cce8409f80fb7e03fbeb81aca5e7443a2bad9b61c93
+  metadata.gz: 62cac26275a4af88278a38985c4edc2e3d001954fe68e491e242add325e49576
+  data.tar.gz: 03ddad7645f758c5708e353e8780001cfd4ce7b478cee2a4c5d60ae7a180cb80
 SHA512:
-  metadata.gz: ebe31625bd0ecf33c2d5e0cfbadba80ac634cfaee932d0e54cb915c94720b538ab6748c56f311ece69177c078a8ce4394c39ae1b4c431bc78293d0c34b2e95d6
-  data.tar.gz: 4779c67321958fe366269a293308c145e2402cb6a169a651a94e6ebdccd678b1b96154edd1170c5c5eeae84ddbe57f5ce769b41280dd9158a51f37beff679d0c
+  metadata.gz: 8df483db6759b17e6c8d7d6f05a81ed3b507b4be7d9a3d5b0f0adaa70bc8fec798d8d3e750d6f512a586e128ca0f492288d5b32a6e772a8ca6e2a67903116f41
+  data.tar.gz: c6460882f099ec2622fe92b99882e52b54df86c5aaf86311f86104326a94455235890ca5cc161448f8b7d5ab60d6853c1d65287764b8516eeebb5fd53ba3c8e3

data/.github/dependabot.yml

@@ -4,8 +4,10 @@ updates:
   - directory: /
     open-pull-requests-limit: 10
     package-ecosystem: bundler
-    target-branch: develop
+    target-branch: main
     schedule:
       interval: weekly
     labels:
       - dependencies
+    assignees:
+      - clarkedb

data/.github/workflows/ci.yml

@@ -3,6 +3,7 @@ name: CI
 on: push
 
 env:
+  CI: true
   GIT_COMMIT_SHA: ${{ github.sha }}
   GIT_BRANCH: ${{ github.ref }}
 
@@ -26,13 +27,13 @@ jobs:
         run: bundle exec rubocop --format progress
 
   build:
-    needs: [ linting ]
+    needs: [linting]
     runs-on: ubuntu-latest
     name: build (ruby v${{ matrix.ruby }})
     strategy:
       fail-fast: false
       matrix:
-        ruby: [ '2.5', '2.6', '2.7', '3.0' ]
+        ruby: ["2.7", "3.0", "3.1"]
 
     steps:
       - uses: actions/checkout@v2
@@ -44,3 +45,12 @@ jobs:
       - name: Test
         continue-on-error: ${{ matrix.experimental }}
         run: bundle exec rake test
+
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v2
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          files: ./coverage/.resultset.json
+          name: codecov-umbrella
+          verbose: true
+          fail_ci_if_error: true

data/.overcommit.yml

@@ -0,0 +1,8 @@
+PreCommit:
+  RuboCop:
+    enabled: true
+    on_warn: fail # Treat all warnings as failures
+
+CommitMsg:
+  ALL:
+    enabled: false

data/.rubocop.yml

@@ -9,6 +9,11 @@
 #
 # See https://docs.rubocop.org/rubocop/configuration
 
+require:
+  - rubocop-minitest
+  - rubocop-packaging
+  - rubocop-performance
+
 # General
 AllCops:
   NewCops: enable
@@ -119,6 +124,16 @@ Metrics/MethodLength:
   Exclude:
     - "test/**/*"
 
+# Minitest
+Minitest/AssertPredicate:
+  Enabled: false
+
+Minitest/MultipleAssertions:
+  Max: 10
+
+Minitest/RefutePredicate:
+  Enabled: false
+
 # Naming
 Naming/InclusiveLanguage:
   Enabled: true

data/CHANGELOG.md

@@ -6,20 +6,53 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ## Unreleased
 
-N/A
+None
 
-## [1.0.1](https://github.com/clarkedb/grift/releases/tag/v1.0.1) - 2021-11-10
+## [2.0.0](https://github.com/clarkedb/grift/releases/tag/v2.0.0) - 2022-03-14
 
-This version fixes a bug that prevented most mocking features in Grift from functioning as expected.
+### Changed
+
+* Dropped support for Ruby 2.5 ([#69](https://github.com/clarkedb/grift/pull/69))
+* Dropped support for Ruby 2.6 ([#72](https://github.com/clarkedb/grift/pull/72))
+* To support keyword arguments, records of call arguments are no longer stored in simple arrays but in a custom Enumerable ([#72](https://github.com/clarkedb/grift/pull/72))
+  + This changes the way that your tests will interact with mock calls
+  + When before `calls` returned an array, it returns a `Grift::MockMethod::MockExecutions::MockArguments` object
+  + Migrating to maintain previous behavior just requires appending `.args` to `calls`
+
+### Added
+
+* Support for mocking private instance and class methods ([#68](https://github.com/clarkedb/grift/pull/68))
+* Support for mocking methods that take positional and keyword arguments ([#72](https://github.com/clarkedb/grift/pull/72))
 
 ### Fixed
 
-* Uses relative path for yaml config files
+* When mocking protected methods, the method now remains protected while mocked and after unmocking ([#68](https://github.com/clarkedb/grift/pull/68))
+* When mocking inherited methods, the method goes back to the ancestor's definition after unmocking ([#69](https://github.com/clarkedb/grift/pull/69))
+* When mocking methods with keyword arugments in Ruby 3.x, no error is thrown ([#72](https://github.com/clarkedb/grift/pull/72))
+
+## [1.1.0](https://github.com/clarkedb/grift/releases/tag/v1.1.0) - 2022-02-03
+
+This version adds support for Ruby 3.1 and updates various dependencies.
+
+### Added
+
+* Support Ruby 3.1 ([#52](https://github.com/clarkedb/grift/pull/52))
 
-### Updated
+## [1.0.2](https://github.com/clarkedb/grift/releases/tag/v1.0.2) - 2021-11-11
+
+This version fixes a bug that prevented the mocking of methods defined by a class's super class.
+
+### Fixed
+
+* Allow mocks of inherited methods ([#34](https://github.com/clarkedb/grift/pull/34))
+
+## [1.0.1](https://github.com/clarkedb/grift/releases/tag/v1.0.1) - 2021-11-10
+
+This version fixes a bug that prevented most mocking features in Grift from functioning as expected.
+
+### Fixed
 
-* Updates `rubocop-performance`
-* Updates `rake`
+* Uses relative path for yaml config files ([#28](https://github.com/clarkedb/grift/pull/28))
 
 ## [1.0.0](https://github.com/clarkedb/grift/releases/tag/v1.0.0) - 2021-11-06
 
@@ -27,12 +60,12 @@ The first major version of Grift! 100% documentation and 100% code coverage.
 
 ### Added
 
-* Spying on method
-* Mocking method return values
-* Mocking method implementation
-* Restricted methods that cannot be mocked
-* MiniTest Plugin to use hooks and clean up after tests
-* Documentation!
+* Spying on method ([#9](https://github.com/clarkedb/grift/pull/9))
+* Mocking method return values ([#9](https://github.com/clarkedb/grift/pull/9))
+* Mocking method implementation ([#13](https://github.com/clarkedb/grift/pull/13))
+* Restricted methods that cannot be mocked ([#20](https://github.com/clarkedb/grift/pull/20))
+* MiniTest Plugin to use hooks and clean up after tests ([#17](https://github.com/clarkedb/grift/pull/17))
+* Documentation! ([#23](https://github.com/clarkedb/grift/pull/23))
 
 ## [0.1.0](https://github.com/clarkedb/grift/releases/tag/v0.1.0) - 2021-10-12
 

data/Gemfile

@@ -8,12 +8,14 @@ gemspec
 gem 'rake', '>= 12.0'
 
 group :development, :test do
+  gem 'codecov'
   gem 'minitest', '>= 5.0'
   gem 'minitest-reporters', '>= 1.4.3'
   gem 'simplecov', '>= 0.21.2'
 end
 
 group :development, :lint do
+  gem 'overcommit'
   gem 'rubocop'
   gem 'rubocop-minitest'
   gem 'rubocop-packaging', '>= 0.5'

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    grift (1.0.1)
+    grift (2.0.0)
 
 GEM
   remote: https://rubygems.org/
@@ -9,36 +9,44 @@ GEM
     ansi (1.5.0)
     ast (2.4.2)
     builder (3.2.4)
+    childprocess (4.1.0)
+    codecov (0.6.0)
+      simplecov (>= 0.15, < 0.22)
     docile (1.4.0)
-    minitest (5.14.4)
-    minitest-reporters (1.4.3)
+    iniparse (1.5.0)
+    minitest (5.15.0)
+    minitest-reporters (1.5.0)
       ansi
       builder
       minitest (>= 5.0)
       ruby-progressbar
+    overcommit (0.58.0)
+      childprocess (>= 0.6.3, < 5)
+      iniparse (~> 1.4)
+      rexml (~> 3.2)
     parallel (1.21.0)
-    parser (3.0.2.0)
+    parser (3.1.1.0)
       ast (~> 2.4.1)
-    rainbow (3.0.0)
+    rainbow (3.1.1)
     rake (13.0.6)
-    regexp_parser (2.1.1)
+    regexp_parser (2.2.1)
     rexml (3.2.5)
-    rubocop (1.22.3)
+    rubocop (1.26.0)
       parallel (~> 1.10)
-      parser (>= 3.0.0.0)
+      parser (>= 3.1.0.0)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml
-      rubocop-ast (>= 1.12.0, < 2.0)
+      rubocop-ast (>= 1.16.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.12.0)
-      parser (>= 3.0.1.1)
-    rubocop-minitest (0.15.2)
+    rubocop-ast (1.16.0)
+      parser (>= 3.1.1.0)
+    rubocop-minitest (0.18.0)
       rubocop (>= 0.90, < 2.0)
     rubocop-packaging (0.5.1)
       rubocop (>= 0.89, < 2.0)
-    rubocop-performance (1.12.0)
+    rubocop-performance (1.13.3)
       rubocop (>= 1.7.0, < 2.0)
       rubocop-ast (>= 0.4.0)
     ruby-progressbar (1.11.0)
@@ -54,9 +62,11 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  codecov
   grift!
   minitest (>= 5.0)
   minitest-reporters (>= 1.4.3)
+  overcommit
   rake (>= 12.0)
   rubocop
   rubocop-minitest

data/README.md

@@ -3,6 +3,7 @@
 [![gem version](https://badge.fury.io/rb/grift.svg)](https://rubygems.org/gems/grift)
 [![downloads](https://ruby-gem-downloads-badge.herokuapp.com/grift)](https://rubygems.org/gems/grift)
 [![build](https://github.com/clarkedb/grift/actions/workflows/ci.yml/badge.svg)](https://github.com/clarkedb/grift/actions?query=workflow%3ACI)
+[![codecov](https://codecov.io/gh/clarkedb/grift/branch/main/graph/badge.svg)](https://codecov.io/gh/clarkedb/grift)
 
 Mocking and spying in Ruby's MiniTest framework
 
@@ -36,6 +37,14 @@ class Minitest::Test
 end
 ```
 
+Or for Ruby on Rails:
+
+```ruby
+class ActiveSupport::TestCase
+  include Grift::MinitestPlugin
+end
+```
+
 ## Usage
 
 For complete usage guide, see the [docs](https://clarkedb.github.io/grift/).
@@ -69,13 +78,22 @@ my_spy.mock_implementation do |arg1, arg2|
 end
 ```
 
+or for a method taking keyword arguments:
+
+```ruby
+my_spy = Grift.spy_on(MyClass, :my_method)
+my_spy.mock_implementation do |arg1, arg2, **kwargs|
+    x = do_something(arg1, arg2, kwargs[:arg3], kwargs[:arg4])
+    do_something_else(x) # the last line will be returned
+end
+
 ### Chaining
 
 You can chain `mock_return_value` and `mock_implementation` after initializing the mock.
 
 ```ruby
-my_mock = Grift.spy_on(MyClass, :my_method).mock_implementation do |*args|
-    do_something(*args)
+my_mock = Grift.spy_on(MyClass, :my_method).mock_implementation do |*args, **kwargs|
+    do_something(*args, **kwargs)
 end
 #=> Grift::MockMethod object is returned
 ```
@@ -90,19 +108,31 @@ my_mock.mock.count
 #=> 2
 
 # get args for each call to the method while mocked
-my_mock.mock.calls
-#=> [['first_arg1', 'second_arg1'], ['first_arg2', 'second_arg2']]
+my_mock.mock.calls[0].args
+#=> ['first_arg1', 'second_arg1']
+
+# get kwargs for each call to the method while mocked
+my_mock.mock.calls[0].kwargs
+#=> { first_arg1: 'value' }
 
 # get results (return value) for each call to the method while mocked
 my_mock.mock.results
 #=> ['result1', 'result2']
 ```
 
+## Requirements
+
+Grift supports all Ruby versions >= 2.7 (including 3.1).
+
 ## Development
 
 After forking the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-When developing, to install Grift whith your changes onto your local machine, run `bundle exec rake install` . To release a new version, update the version number in `version.rb` , and then run `bundle exec rake release` , which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+When developing, to install Grift whith your changes onto your local machine, run `bundle exec rake install` . For those with write access: to release a new version, update the version number in `version.rb` , and then run `bundle exec rake release` , which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+### Docs
+
+The docs are generated using YARD. To build the docs, first `gem install yard` . Then run `yardoc` to build the new docs. This is always done before a release to update the docs that get published and made available with the gem.
 
 ## Contributing
 

data/grift.gemspec

@@ -12,20 +12,21 @@ Gem::Specification.new do |spec|
   spec.description   = "A gem for simple mocking and spying in Ruby's MiniTest framework."
   spec.homepage      = 'https://github.com/clarkedb/grift'
   spec.license       = 'MIT'
-  spec.required_ruby_version = Gem::Requirement.new('>= 2.5.0')
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.7.0')
 
   spec.metadata = {
     'bug_tracker_uri' => "#{spec.homepage}/issues",
     'changelog_uri' => "#{spec.homepage}/blob/main/CHANGELOG.md",
     'documentation_uri' => spec.homepage.to_s,
     'homepage_uri' => spec.homepage.to_s,
+    'rubygems_mfa_required' => 'true',
     'source_code_uri' => spec.homepage.to_s
   }
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|docs|spec|features)/}) }
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|docs|spec|features)/}) } # rubocop:disable Packaging/GemspecGit
   end
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }

data/lib/grift/mock_method/mock_executions/mock_arguments.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Grift
+  class MockMethod
+    class MockExecutions
+      ##
+      # An immutable Enumerable that stores the arguments used in a call for {Grift::MockMethod::MockExecutions}.
+      #
+      class MockArguments
+        include Enumerable
+
+        attr_reader :args, :kwargs
+
+        ##
+        # A new instance of MockArguments.
+        #
+        # @return [Grift::MockMethod::MockExecutions::MockArguments]
+        #
+        def initialize(args: [], kwargs: {})
+          @args = args.freeze
+          @kwargs = kwargs.freeze
+        end
+
+        ##
+        # Retrieves a stored argument by an accessor. For positional arguments this would be an integer
+        # corresponding to the arguments position in the method call signature. For keyword arguments
+        # this would be the key / parameter name as a symbol or string.
+        #
+        # @example
+        #   my_mock = Grift.mock(Request, :new)
+        #   request = Request.new('/users', method: 'GET')
+        #   #=> <Request object>
+        #   my_mock.mock.calls.last[0] # integer access for positional
+        #   #=> '/users'
+        #   my_mock.mock.calls.last[:method] # key access for keyword
+        #   #=> 'GET'
+        #
+        # @param index [Integer, Symbol, String] the accessor for the desired argument
+        #
+        # @raise [Grift::Error] exception if accessor is not a supported type
+        #
+        # @return the specified value
+        #
+        def [](index)
+          if index.instance_of?(Integer)
+            @args[index]
+          elsif index.instance_of?(Symbol)
+            @kwargs[index]
+          elsif index.instance_of?(String)
+            @kwargs[index.to_sym]
+          else
+            raise(Grift::Error, "Cannot access by type '#{index.class}'. Expected an Integer, Symbol, or String")
+          end
+        end
+
+        ##
+        # Calls the given block once for each argument value, passing that value
+        # as a parameter.
+        #
+        # @return [void]
+        #
+        def each(&block)
+          @args.each(&block)
+          @kwargs.each_value(&block)
+        end
+
+        ##
+        # @see Enumerable#first
+        #
+        # Returns the last argument passed in the call.
+        #
+        # @example
+        #   my_mock = Grift.mock(Request, :new)
+        #   request = Request.new('/users', method: 'GET')
+        #   #=> <Request object>
+        #   my_mock.mock.calls.last.last
+        #   #=> 'GET'
+        #
+        # @return [Any]
+        #
+        def last
+          @args.last || @kwargs.values.last
+        end
+
+        ##
+        # Returns the number of arguments passed in the call.
+        #
+        # @example
+        #   arr = [1, 2, 3]
+        #   my_mock = Grift.mock(Array, :count)
+        #   arr.count
+        #   #=> 3
+        #   my_mock.mock.calls.last.length
+        #   #=> 0
+        #   arr.count(3)
+        #   #=> 1
+        #   my_mock.mock.calls.last.length
+        #   #=> 1
+        #
+        # @return [Integer]
+        #
+        def length
+          @args.length + @kwargs.length
+        end
+
+        ##
+        # Returns true if the call included no arguments.
+        #
+        # @example
+        #   arr = [1, 2, 3]
+        #   my_mock = Grift.mock(Array, :count)
+        #   arr.count
+        #   #=> 3
+        #   my_mock.mock.calls.last.empty?
+        #   #=> true
+        #   arr.count(2)
+        #   #=> 1
+        #   my_mock.mock.calls.last.empty?
+        #   #=> false
+        #
+        # @return [Boolean] true if the no arguments were used
+        #
+        def empty?
+          @args.empty? && @kwargs.empty?
+        end
+
+        ##
+        # Returns the keyword parameter keys passed in the call.
+        #
+        # To get the values, use {Grift::MockMethod::MockExecutions::MockArguments#values}.
+        #
+        # @example
+        #   my_mock = Grift.mock(Request, :new)
+        #   request = Request.new('/users', method: 'GET')
+        #   #=> <Request object>
+        #   my_mock.mock.calls.last.keys
+        #   #=> [:method]
+        #
+        # @return [Array<Symbol>] the parameter keys
+        #
+        def keys
+          @kwargs.keys
+        end
+
+        ##
+        # Returns the arguments passed in the call.
+        #
+        # If a keyword argument was used, then only the value will be returned.
+        # To get the keys, use {Grift::MockMethod::MockExecutions::MockArguments#keys}.
+        #
+        # @example
+        #   my_mock = Grift.mock(Request, :new)
+        #   request = Request.new('/users', method: 'GET')
+        #   #=> <Request object>
+        #   my_mock.mock.calls.last.keys
+        #   #=> [:method]
+        #
+        # @return [Array] the argument values
+        #
+        def values
+          @args + @kwargs.values
+        end
+      end
+    end
+  end
+end

data/lib/grift/mock_method/mock_executions.rb

@@ -9,7 +9,7 @@ module Grift
       ##
       # A new instance of MockExecutions.
       #
-      # @return [Grift::MockMethod::MockExectuions]
+      # @return [Grift::MockMethod::MockExecutions]
       #
       def initialize
         @executions = []
@@ -21,14 +21,14 @@ module Grift
       # @example
       #   my_mock = Grift.spy_on(Number, :+)
       #   x = (3 + 4) + 5
-      #   my_mock.mock.calls
+      #   my_mock.mock.calls.map(&:values)
       #   #=> [[4], [5]]
       #
-      # @return [Array<Array>] an array of arrays of args
+      # @return [Array<Grift::MockMethod::MockExecutions::MockArguments>] an array of MockArguments
       #
       def calls
         @executions.map do |exec|
-          exec[:args]
+          exec[:arguments]
         end
       end
 
@@ -89,13 +89,17 @@ module Grift
       # Stores an args and result pair to the executions array.
       #
       # @example
-      #   mock_store = Grift::MockMethod::MockExecutions.new
-      #   mock_store.store([1, 1], [2])
+      #   mock_executions = Grift::MockMethod::MockExecutions.new
+      #   mock_executions.store(args: [1, 1], kwargs: { test: true }, result: 2)
       #
-      # @return [Array] an array of results
+      # @param args [Array] the postitional args to store
+      # @param kwargs [Hash] the keyword args to store
+      # @param result the method result to store
+      #
+      # @return [Array] an updated array of executions
       #
-      def store(args, result)
-        @executions.push({ args: args, result: result })
+      def store(args: [], kwargs: {}, result: nil)
+        @executions.push({ arguments: MockArguments.new(args: args, kwargs: kwargs), result: result })
       end
     end
   end

data/lib/grift/mock_method.rb

@@ -6,7 +6,7 @@ module Grift
   # usually returns a {Grift::MockMethod}.
   #
   class MockMethod
-    attr_reader :true_method_cached, :klass, :method_name
+    attr_reader :true_method_cached, :klass, :method_name, :method_access
 
     CACHE_METHOD_PREFIX = 'grift_cache'
     private_constant :CACHE_METHOD_PREFIX
@@ -29,7 +29,7 @@ module Grift
     #
     def initialize(klass, method_name, watch: true)
       if Grift.restricted_method?(klass, method_name)
-        raise(Grift::Error, "Cannont mock restricted method #{method_name} for class #{klass}")
+        raise(Grift::Error, "Cannot mock restricted method #{method_name} for class #{klass}")
       end
 
       @klass = klass
@@ -39,13 +39,13 @@ module Grift
       @cache_method_name = "#{CACHE_METHOD_PREFIX}_#{method_name}".to_sym
 
       # class methods are really instance methods of the singleton class
-      @class_method = klass.singleton_class.instance_methods(true).include?(method_name)
+      @class_method = klass.singleton_class.method_defined?(method_name, true) ||
+        klass.singleton_class.private_method_defined?(method_name, true)
 
-      unless class_instance.instance_methods(true).include?(method_name)
-        raise(Grift::Error, "Cannont mock unknown method #{method_name} for class #{klass}")
-      end
+      @method_access, @inherited = method_access_definition
+      raise(Grift::Error, "Cannot mock unknown method #{method_name} for class #{klass}") unless @method_access
 
-      if class_instance.instance_methods.include?(@cache_method_name)
+      if class_instance.method_defined?(@cache_method_name)
         raise(Grift::Error, "Cannot mock already mocked method #{method_name} for class #{klass}")
       end
 
@@ -125,26 +125,27 @@ module Grift
     #   #=> '7'
     #
     # @example
-    #   my_mock = Grift.spy_on(MyClass, :my_method).mock_implementation do |first, second|
-    #       [second, first]
+    #   my_mock = Grift.spy_on(MyClass, :my_method).mock_implementation do |first, second, **kwargs|
+    #       [second, kwargs[:third], first]
     #   end
-    #   MyClass.my_method(1, 2)
-    #   #=> [2, 1]
+    #   MyClass.my_method(1, 2, third: 3)
+    #   #=> [2, 3, 1]
     #
-    # @return [Grift::MockMethod] the mock itself
+    # @return [self] the mock itself
     #
-    def mock_implementation(&block)
+    def mock_implementation(*)
       premock_setup
       mock_executions = @mock_executions # required to access inside class instance block
 
-      class_instance.remove_method(@method_name)
-      class_instance.define_method @method_name do |*args|
-        return_value = block.call(*args)
+      class_instance.remove_method(@method_name) if !@inherited && method_defined?
+      class_instance.define_method @method_name do |*args, **kwargs|
+        return_value = yield(*args, **kwargs)
 
         # record the args passed in the call to the method and the result
-        mock_executions.store(args, return_value)
+        mock_executions.store(args: args, result: return_value)
         return return_value
       end
+      class_instance.send(@method_access, @method_name)
 
       self
     end
@@ -162,18 +163,19 @@ module Grift
     #
     # @param return_value the value to return from the method
     #
-    # @return [Grift::MockMethod] the mock itself
+    # @return [self] the mock itself
     #
     def mock_return_value(return_value = nil)
       premock_setup
       mock_executions = @mock_executions # required to access inside class instance block
 
-      class_instance.remove_method(@method_name)
-      class_instance.define_method @method_name do |*args|
+      class_instance.remove_method(@method_name) if !@inherited && method_defined?
+      class_instance.define_method @method_name do |*args, **kwargs|
         # record the args passed in the call to the method and the result
-        mock_executions.store(args, return_value)
+        mock_executions.store(args: args, kwargs: kwargs, result: return_value)
         return return_value
       end
+      class_instance.send(@method_access, @method_name)
 
       self
     end
@@ -210,21 +212,22 @@ module Grift
     ##
     # Watches the method without mocking its impelementation or return value.
     #
-    # @return [Grift::MockMethod] the mock itself
+    # @return [self] the mock itself
     #
     def watch_method
       premock_setup
       mock_executions = @mock_executions # required to access inside class instance block
       cache_method_name = @cache_method_name
 
-      class_instance.remove_method(@method_name)
-      class_instance.define_method @method_name do |*args|
-        return_value = send(cache_method_name, *args)
+      class_instance.remove_method(@method_name) if !@inherited && method_defined?
+      class_instance.define_method @method_name do |*args, **kwargs|
+        return_value = send(cache_method_name, *args, **kwargs)
 
         # record the args passed in the call to the method and the result
-        mock_executions.store(args, return_value)
+        mock_executions.store(args: args, kwargs: kwargs, result: return_value)
         return return_value
       end
+      class_instance.send(@method_access, @method_name)
 
       self
     end
@@ -237,8 +240,8 @@ module Grift
     def unmock_method
       raise(Grift::Error, 'Method is not cached') unless @true_method_cached
 
-      class_instance.remove_method(@method_name)
-      class_instance.alias_method(@method_name, @cache_method_name)
+      class_instance.remove_method(@method_name) if method_defined?
+      class_instance.alias_method(@method_name, @cache_method_name) unless @inherited
       class_instance.remove_method(@cache_method_name)
 
       @true_method_cached = false
@@ -280,5 +283,35 @@ module Grift
     def class_instance
       @class_method ? @klass.singleton_class : @klass
     end
+
+    ##
+    # Checks if the method is defined on the class instance. If the method is
+    # inherited from the super class and has not been mocked yet, this will
+    # return false because the super class defined the method.
+    #
+    # @return [Boolean]
+    #
+    def method_defined?
+      class_instance.instance_methods(false).include?(@method_name) ||
+        class_instance.private_instance_methods(false).include?(@method_name)
+    end
+
+    ##
+    # Checks for the original access of the method (public, protected, private),
+    # and if that definition is inherited from an ancestor (super) class.
+    # Returns `nil` if no definition for the method is found.
+    #
+    # @return [Symbol] the method access
+    # @return [Boolean] true if the method is inherited
+    #
+    def method_access_definition
+      if class_instance.public_method_defined?(@method_name, true)
+        [:public, !class_instance.public_method_defined?(@method_name, false)]
+      elsif class_instance.protected_method_defined?(@method_name, true)
+        [:protected, !class_instance.protected_method_defined?(@method_name, false)]
+      elsif class_instance.private_method_defined?(@method_name, true)
+        [:private, !class_instance.private_method_defined?(@method_name, false)]
+      end
+    end
   end
 end

data/lib/grift/version.rb

@@ -2,6 +2,6 @@
 
 module Grift
   # gem version
-  VERSION = '1.0.1'
+  VERSION = '2.0.0'
   public_constant :VERSION
 end

data/lib/grift.rb

@@ -5,6 +5,7 @@ require 'grift/error'
 require 'grift/minitest_plugin'
 require 'grift/mock_method'
 require 'grift/mock_method/mock_executions'
+require 'grift/mock_method/mock_executions/mock_arguments'
 require 'grift/mock_store'
 require 'grift/version'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grift
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Clark Brown
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-11-11 00:00:00.000000000 Z
+date: 2022-03-15 00:00:00.000000000 Z
 dependencies: []
 description: A gem for simple mocking and spying in Ruby's MiniTest framework.
 email:
@@ -22,6 +22,7 @@ files:
 - ".github/dependabot.yml"
 - ".github/workflows/ci.yml"
 - ".gitignore"
+- ".overcommit.yml"
 - ".rubocop.yml"
 - ".yardopts"
 - CHANGELOG.md
@@ -40,6 +41,7 @@ files:
 - lib/grift/minitest_plugin.rb
 - lib/grift/mock_method.rb
 - lib/grift/mock_method/mock_executions.rb
+- lib/grift/mock_method/mock_executions/mock_arguments.rb
 - lib/grift/mock_store.rb
 - lib/grift/version.rb
 homepage: https://github.com/clarkedb/grift
@@ -50,6 +52,7 @@ metadata:
   changelog_uri: https://github.com/clarkedb/grift/blob/main/CHANGELOG.md
   documentation_uri: https://github.com/clarkedb/grift
   homepage_uri: https://github.com/clarkedb/grift
+  rubygems_mfa_required: 'true'
   source_code_uri: https://github.com/clarkedb/grift
 post_install_message:
 rdoc_options: []
@@ -59,14 +62,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: Mocking and spying in MiniTest