memo_wise 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ff51bfee4fcc634d50588005e79c4a74702fd0d8deb8ab23dd917134cedf42f
-  data.tar.gz: 1cb14df9bcef27a3442b48cf1aee370835bbf9070b1f44bb3d8ec8266158bdab
+  metadata.gz: 3b26ef1a44fd13498359282c6d47923ecf90bdfd4e8ac487d389dd1d5c9c5d59
+  data.tar.gz: 51d2ddc7b1d0e7d770afcf081f566059e67b07867c10803db693fd2ec848f4d1
 SHA512:
-  metadata.gz: 36a3f525833af24f076568ed9bdb43a06e90441788f2f8e8d26c0303ec7e0697a56c8401a3e24c06300cb3f2df199768ae00d8cf95cc90808fb4d9940ab9a931
-  data.tar.gz: f60569c63d693272856137c179b826a598c63a5762fedd76faf630b26fd3301d6ca37756f99cb7940501d5bcfd4c375094176a617610c35fc8788b67580159ce
+  metadata.gz: ca1c06be2c7d0368e7708349563a0a79f93922d491ffe43448793bd6364938ea063bc3910d67ca7ce04c6cb409d784d23d19d5e97fea6430fcb20ebbb0819ab3
+  data.tar.gz: 93fc8811a80bd7f4d88517e0c3cd21f3b6ef29daea6e0578e734abecdc0067f5f9451261f5c47ad80106332075a4072a4a3e7322fe6181f2d61782d63c42caa0

data/.github/workflows/main.yml

@@ -12,7 +12,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [jruby, 2.4, 2.5, 2.6, 2.7, 3.0]
+        ruby: [jruby, 2.4, 2.5, 2.6, 2.7, 3.0, truffleruby-head]
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2

data/.rubocop.yml

@@ -1,5 +1,5 @@
 inherit_gem:
-  panolint: rubocop.yml
+  panolint: panolint-rubocop.yml
 
 Layout/LineLength:
   Max: 120

data/CHANGELOG.md

@@ -9,8 +9,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Nothing yet!
 
+## [1.4.0] - 2021-12-10
+
+### Fixed
+
+- Fix several bugs related to classes inheriting memoized methods
+  from multiple modules or a parent class ([#241](https://github.com/panorama-ed/memo_wise/pull/241))
+
 ## [1.3.0] - 2021-11-22
 
+### Fixed
+
 - Fix thread-safety issue in concurrent calls to zero-arg method in unmemoized
   state which resulted in a `nil` value being accidentally returned in one thread
 - Fix bugs related to child classes inheriting from parent classes that use
@@ -101,7 +110,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Panolint
 - Dependabot setup
 
-[Unreleased]: https://github.com/panorama-ed/memo_wise/compare/v1.3.0...HEAD
+[Unreleased]: https://github.com/panorama-ed/memo_wise/compare/v1.4.0...HEAD
+[1.4.0]: https://github.com/panorama-ed/memo_wise/compare/v1.3.0...v1.4.0
 [1.3.0]: https://github.com/panorama-ed/memo_wise/compare/v1.2.0...v1.3.0
 [1.2.0]: https://github.com/panorama-ed/memo_wise/compare/v1.1.0...v1.2.0
 [1.1.0]: https://github.com/panorama-ed/memo_wise/compare/v1.0.0...v1.1.0

data/Gemfile.lock

@@ -1,9 +1,9 @@
 GIT
   remote: https://github.com/panorama-ed/panolint.git
-  revision: c709ebcc5fd9593db959df4a92c12cae1d1fb9af
+  revision: 5850a218b96da7dd196438fb65d41169cd6747e5
   branch: main
   specs:
-    panolint (0.1.3)
+    panolint (0.1.4)
       brakeman (>= 4.8, < 6.0)
       rubocop (>= 0.83, < 2.0)
       rubocop-performance (~> 1.5)
@@ -14,19 +14,20 @@ GIT
 PATH
   remote: .
   specs:
-    memo_wise (1.3.0)
+    memo_wise (1.4.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (5.2.6)
+    activesupport (6.1.4.1)
       concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
     ansi (1.5.0)
     ast (2.4.2)
-    brakeman (5.1.1)
+    brakeman (5.1.2)
     codecov (0.6.0)
       simplecov (>= 0.15, < 0.22)
     concurrent-ruby (1.1.9)
@@ -36,11 +37,11 @@ GEM
       ansi
       rouge
       slop (~> 3)
-    i18n (1.8.10)
+    i18n (1.8.11)
       concurrent-ruby (~> 1.0)
     minitest (5.14.4)
-    parallel (1.20.1)
-    parser (3.0.2.0)
+    parallel (1.21.0)
+    parser (3.0.3.1)
       ast (~> 2.4.1)
     rack (2.2.3)
     rainbow (3.0.0)
@@ -62,44 +63,43 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.10.0)
     rspec-support (3.10.0)
-    rubocop (1.12.1)
+    rubocop (1.23.0)
       parallel (~> 1.10)
       parser (>= 3.0.0.0)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml
-      rubocop-ast (>= 1.2.0, < 2.0)
+      rubocop-ast (>= 1.12.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.4.1)
-      parser (>= 2.7.1.5)
-    rubocop-performance (1.10.2)
-      rubocop (>= 0.90.0, < 2.0)
+    rubocop-ast (1.13.0)
+      parser (>= 3.0.1.1)
+    rubocop-performance (1.12.0)
+      rubocop (>= 1.7.0, < 2.0)
       rubocop-ast (>= 0.4.0)
-    rubocop-rails (2.9.1)
+    rubocop-rails (2.12.4)
       activesupport (>= 4.2.0)
       rack (>= 1.1)
-      rubocop (>= 0.90.0, < 2.0)
-    rubocop-rake (0.5.1)
-      rubocop
-    rubocop-rspec (2.2.0)
+      rubocop (>= 1.7.0, < 2.0)
+    rubocop-rake (0.6.0)
       rubocop (~> 1.0)
-      rubocop-ast (>= 1.1.0)
+    rubocop-rspec (2.6.0)
+      rubocop (~> 1.19)
     ruby-progressbar (1.11.0)
     simplecov (0.18.5)
       docile (~> 1.1)
       simplecov-html (~> 0.11)
     simplecov-html (0.12.3)
     slop (3.6.0)
-    thread_safe (0.3.6)
-    tzinfo (1.2.9)
-      thread_safe (~> 0.1)
-    unicode-display_width (2.0.0)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.1.0)
     values (1.8.0)
     yard (0.9.26)
     yard-doctest (0.1.17)
       minitest
       yard
+    zeitwerk (2.5.1)
 
 PLATFORMS
   ruby
@@ -117,4 +117,4 @@ DEPENDENCIES
   yard-doctest (~> 0.1)
 
 BUNDLED WITH
-   2.2.28
+   2.2.32

data/README.md

@@ -112,38 +112,38 @@ For more usage details, see our detailed [documentation](#documentation).
 
 ## Benchmarks
 
-Benchmarks are run in GitHub Actions, and the tables below are updated with every code change. **Values >1.00x represent how much _slower_ each gem’s memoized value retrieval is than the latest commit of `MemoWise`**, according to [`benchmark-ips`](https://github.com/evanphx/benchmark-ips) (2.9.1).
+Benchmarks are run in GitHub Actions, and the tables below are updated with every code change. **Values >1.00x represent how much _slower_ each gem’s memoized value retrieval is than the latest commit of `MemoWise`**, according to [`benchmark-ips`](https://github.com/evanphx/benchmark-ips) (2.9.2).
 
-Results using Ruby 3.0.2:
+Results using Ruby 3.0.3:
 
 |Method arguments|`Dry::Core`\* (0.7.1)|`Memery` (1.4.0)|
 |--|--|--|
-|`()` (none)|1.42x|17.84x|
-|`(a)`|2.48x|11.48x|
-|`(a, b)`|0.46x|2.05x|
-|`(a:)`|2.18x|20.50x|
-|`(a:, b:)`|0.48x|4.22x|
-|`(a, b:)`|0.48x|4.08x|
-|`(a, *args)`|0.90x|1.97x|
-|`(a:, **kwargs)`|0.80x|3.02x|
-|`(a, *args, b:, **kwargs)`|0.61x|1.54x|
+|`()` (none)|1.36x|19.42x|
+|`(a)`|2.47x|11.39x|
+|`(a, b)`|0.44x|2.16x|
+|`(a:)`|2.30x|22.89x|
+|`(a:, b:)`|0.47x|4.54x|
+|`(a, b:)`|0.47x|4.33x|
+|`(a, *args)`|0.83x|2.09x|
+|`(a:, **kwargs)`|0.76x|2.85x|
+|`(a, *args, b:, **kwargs)`|0.61x|1.55x|
 
 \* `Dry::Core`
 [may cause incorrect behavior caused by hash collisions](https://github.com/dry-rb/dry-core/issues/63).
 
-Results using Ruby 2.7.4 (because these gems raise errors in Ruby 3.x):
+Results using Ruby 2.7.5 (because these gems raise errors in Ruby 3.x):
 
 |Method arguments|`DDMemoize` (1.0.0)|`Memoist` (0.16.2)|`Memoized` (1.0.2)|`Memoizer` (1.0.3)|
 |--|--|--|--|--|
-|`()` (none)|33.90x|3.44x|1.56x|4.03x|
-|`(a)`|24.56x|17.02x|12.94x|14.91x|
-|`(a, b)`|3.14x|2.35x|1.84x|2.03x|
-|`(a:)`|34.42x|28.14x|23.83x|25.26x|
-|`(a:, b:)`|5.13x|4.28x|3.77x|3.97x|
-|`(a, b:)`|4.83x|4.08x|3.50x|3.66x|
-|`(a, *args)`|3.03x|2.25x|1.95x|1.95x|
-|`(a:, **kwargs)`|2.90x|2.44x|2.14x|2.24x|
-|`(a, *args, b:, **kwargs)`|2.05x|1.77x|1.65x|1.64x|
+|`()` (none)|36.84x|3.56x|1.68x|4.19x|
+|`(a)`|27.50x|18.85x|13.97x|15.99x|
+|`(a, b)`|3.27x|2.34x|1.85x|2.05x|
+|`(a:)`|37.22x|30.09x|25.57x|27.28x|
+|`(a:, b:)`|5.25x|4.38x|3.80x|4.02x|
+|`(a, b:)`|5.08x|4.15x|3.56x|3.78x|
+|`(a, *args)`|3.17x|2.32x|1.96x|2.01x|
+|`(a:, **kwargs)`|2.87x|2.42x|2.10x|2.21x|
+|`(a, *args, b:, **kwargs)`|2.05x|1.76x|1.63x|1.65x|
 
 You can run benchmarks yourself with:
 
@@ -156,6 +156,24 @@ $ bundle exec ruby benchmarks.rb
 If your results differ from what's posted here,
 [let us know](https://github.com/panorama-ed/memo_wise/issues/new)!
 
+## Thread Safety
+
+MemoWise makes the following **thread safety** guarantees on all supported Ruby
+versions:
+
+1. **Before** a value has been memoized
+
+   * Contended calls from multiple threads...
+      * May each call the original method
+      * May return different valid results (when the method is nondeterministic,
+        like `rand`)
+      * Will memoize exactly one valid return value
+
+2. **After** a value has been memoized
+
+   * Contended calls from multiple threads...
+     * Always return the same memoized value
+
 ## Documentation
 
 ### Documentation is Automatically Generated
@@ -250,10 +268,12 @@ Then carry out these steps:
    - Add an entry for the upcoming version _x.y.z_
    - Add a link for this version's comparison to the bottom of `CHANGELOG.md`
    - Move content from _Unreleased_ to the upcoming version _x.y.z_
+   - Change _Unreleased_ section to say `- Nothing yet!`
    - Commit with title `Update CHANGELOG.md for x.y.z`
 
 2. Update `lib/memo_wise/version.rb`
    - Replace with upcoming version _x.y.z_
+   - Run `bundle install` to update `Gemfile.lock`
    - Commit with title `Bump version to x.y.z`
 
 3. `bundle exec rake release`

data/benchmarks/Gemfile

@@ -2,9 +2,9 @@
 
 source "https://rubygems.org"
 
-ruby ">= 2.7.4"
+ruby ">= 2.7.5"
 
-gem "benchmark-ips", "2.9.1"
+gem "benchmark-ips", "2.9.2"
 
 if RUBY_VERSION > "3"
   gem "dry-core", "0.7.1"

data/lib/memo_wise/internal_api.rb

@@ -175,58 +175,6 @@ module MemoWise
       end
     end
 
-    # Increment the class's method index counter, and return an index to use for
-    # the given method name.
-    #
-    # @param klass [Class]
-    #   Original class on which a method is being memoized
-    #
-    # @param method_name [Symbol]
-    #   The name of the method being memoized
-    #
-    # @return [Integer]
-    #   The index within `@_memo_wise` to store the method's memoized results
-    def self.next_index!(klass, method_name)
-      # `@_memo_wise_indices` stores the `@_memo_wise` indices of different
-      # method names. We only use this data structure when resetting or
-      # presetting memoization. It looks like:
-      #   {
-      #     single_arg_method_name: 0,
-      #     other_single_arg_method_name: 1
-      #   }
-      memo_wise_indices = klass.instance_variable_get(:@_memo_wise_indices)
-      memo_wise_indices ||= klass.instance_variable_set(:@_memo_wise_indices, {})
-
-      # When a parent and child class both use `class << self` to define
-      # memoized class methods, the child class' singleton is not considered a
-      # descendent of the parent class' singleton. Because we store the index
-      # counter as a class variable that can be shared up the inheritance chain,
-      # we want to detect this case and store it on the original class instead
-      # of the singleton to make the counter shared correctly.
-      counter_class = klass.singleton_class? ? original_class_from_singleton(klass) : klass
-
-      # We use a class variable for tracking the index to make this work with
-      # inheritance structures. When a parent and child class both use
-      # MemoWise, we want the child class's index to not "reset" back to 0 and
-      # overwrite the behavior of a memoized parent method. Using a class
-      # variable will share the index data between parent and child classes.
-      #
-      # However, we don't use a class variable for `@_memo_wise_indices`
-      # because we want to allow instance and class methods with the same name
-      # to both be memoized, and using a class variable would share that index
-      # data between them.
-      index = if counter_class.class_variable_defined?(:@@_memo_wise_index_counter)
-                counter_class.class_variable_get(:@@_memo_wise_index_counter)
-              else
-                0
-              end
-
-      memo_wise_indices[method_name] = index
-      counter_class.class_variable_set(:@@_memo_wise_index_counter, index + 1) # rubocop:disable Style/ClassVars
-
-      index
-    end
-
     # Convention we use for renaming the original method when we replace with
     # the memoized version in {MemoWise.memo_wise}.
     #
@@ -240,25 +188,20 @@ module MemoWise
       :"_memo_wise_original_#{method_name}"
     end
 
-    # @param target [Class, Module]
-    #   The class to which we are prepending MemoWise to provide memoization;
-    #   the `InternalAPI` *instance* methods will refer to this `target` class.
-    def initialize(target)
-      @target = target
-    end
-
-    # @return [Class, Module]
-    attr_reader :target
-
     # @param method_name [Symbol] the name of the memoized method
     # @return [Integer] the array index in `@_memo_wise_indices` to use to find
     #   the memoization data for the given method
-    def index(method_name)
-      target_class.instance_variable_get(:@_memo_wise_indices)[method_name]
+    def self.index(target, method_name)
+      klass = target_class(target)
+      indices = klass.instance_variable_get(:@_memo_wise_indices)
+      indices&.[](method_name) || next_index!(klass, method_name)
     end
 
     # Returns visibility of an instance method defined on class `target`.
     #
+    # @param target [Class, Module]
+    #   The class to which we are prepending MemoWise to provide memoization.
+    #
     # @param method_name [Symbol]
     #   Name of existing *instance* method find the visibility of.
     #
@@ -269,7 +212,7 @@ module MemoWise
     #   Raises `ArgumentError` unless `method_name` is a `Symbol` corresponding
     #   to an existing **instance** method defined on `klass`.
     #
-    def method_visibility(method_name)
+    def self.method_visibility(target, method_name)
       if target.private_method_defined?(method_name)
         :private
       elsif target.protected_method_defined?(method_name)
@@ -283,20 +226,23 @@ module MemoWise
 
     # Validates that {.memo_wise} has already been called on `method_name`.
     #
+    # @param target [Class, Module]
+    #   The class to which we are prepending MemoWise to provide memoization.
+    #
     # @param method_name [Symbol]
     #   Name of method to validate has already been setup with {.memo_wise}
-    def validate_memo_wised!(method_name)
-      original_name = self.class.original_memo_wised_name(method_name)
+    def self.validate_memo_wised!(target, method_name)
+      original_name = original_memo_wised_name(method_name)
 
-      unless target_class.private_method_defined?(original_name)
+      unless target_class(target).private_method_defined?(original_name)
         raise ArgumentError, "#{method_name} is not a memo_wised method"
       end
     end
 
-    private
-
+    # @param target [Class, Module]
+    #   The class to which we are prepending MemoWise to provide memoization.
     # @return [Class] where we look for method definitions
-    def target_class
+    def self.target_class(target)
       if target.instance_of?(Class)
         # A class's methods are defined in its singleton class
         target.singleton_class
@@ -305,5 +251,36 @@ module MemoWise
         target.class
       end
     end
+    private_class_method :target_class
+
+    # Increment the class's method index counter, and return an index to use for
+    # the given method name.
+    #
+    # @param klass [Class]
+    #   Original class on which a method is being memoized
+    #
+    # @param method_name [Symbol]
+    #   The name of the method being memoized
+    #
+    # @return [Integer]
+    #   The index within `@_memo_wise` to store the method's memoized results
+    def self.next_index!(klass, method_name)
+      # `@_memo_wise_indices` stores the `@_memo_wise` indices of different
+      # method names. We only use this data structure when resetting or
+      # presetting memoization. It looks like:
+      #   {
+      #     single_arg_method_name: 0,
+      #     other_single_arg_method_name: 1
+      #   }
+      memo_wise_indices = klass.instance_variable_get(:@_memo_wise_indices)
+      memo_wise_indices ||= klass.instance_variable_set(:@_memo_wise_indices, {})
+
+      index = klass.instance_variable_get(:@_memo_wise_index_counter) || 0
+      memo_wise_indices[method_name] = index
+      klass.instance_variable_set(:@_memo_wise_index_counter, index + 1)
+
+      index
+    end
+    private_class_method :next_index!
   end
 end

data/lib/memo_wise/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MemoWise
-  VERSION = "1.3.0"
+  VERSION = "1.4.0"
 end

data/lib/memo_wise.rb

@@ -169,8 +169,7 @@ module MemoWise
 
         raise ArgumentError, "#{method_name.inspect} must be a Symbol" unless method_name.is_a?(Symbol)
 
-        api = MemoWise::InternalAPI.new(klass)
-        visibility = api.method_visibility(method_name)
+        visibility = MemoWise::InternalAPI.method_visibility(klass, method_name)
         original_memo_wised_name = MemoWise::InternalAPI.original_memo_wised_name(method_name)
         method = klass.instance_method(method_name)
 
@@ -178,37 +177,75 @@ module MemoWise
         klass.send(:private, original_memo_wised_name)
 
         method_arguments = MemoWise::InternalAPI.method_arguments(method)
-        index = MemoWise::InternalAPI.next_index!(klass, method_name)
 
         case method_arguments
         when MemoWise::InternalAPI::NONE
           # Zero-arg methods can use simpler/more performant logic because the
           # hash key is just the method name.
-          klass.module_eval <<~HEREDOC, __FILE__, __LINE__ + 1
-            def #{method_name}
-              if @_memo_wise_sentinels[#{index}]
-                @_memo_wise[#{index}]
-              else
-                ret = @_memo_wise[#{index}] = #{original_memo_wised_name}
-                @_memo_wise_sentinels[#{index}] = true
-                ret
+          klass.send(:define_method, method_name) do # Ruby 2.4's `define_method` is private in some cases
+            index = MemoWise::InternalAPI.index(self, method_name)
+            klass.module_eval <<~HEREDOC, __FILE__, __LINE__ + 1
+              def #{method_name}
+                if @_memo_wise_sentinels[#{index}]
+                  @_memo_wise[#{index}]
+                else
+                  ret = @_memo_wise[#{index}] = #{original_memo_wised_name}
+                  @_memo_wise_sentinels[#{index}] = true
+                  ret
+                end
               end
-            end
-          HEREDOC
+            HEREDOC
+
+            klass.send(visibility, method_name)
+            send(method_name)
+          end
         when MemoWise::InternalAPI::ONE_REQUIRED_POSITIONAL, MemoWise::InternalAPI::ONE_REQUIRED_KEYWORD
           key = method.parameters.first.last
+          # NOTE: Ruby 2.6 and below, and TruffleRuby 3.0, break when we use
+          # `define_method(...) do |*args, **kwargs|`. Instead we must use the
+          # simpler `|*args|` pattern. We can't just do this always though
+          # because Ruby 2.7 and above require `|*args, **kwargs|` to work
+          # correctly.
+          # See: https://blog.saeloun.com/2019/10/07/ruby-2-7-keyword-arguments-redesign.html#ruby-26
+          # :nocov:
+          if RUBY_VERSION < "2.7" || RUBY_ENGINE == "truffleruby"
+            klass.send(:define_method, method_name) do |*args| # Ruby 2.4's `define_method` is private in some cases
+              index = MemoWise::InternalAPI.index(self, method_name)
+              klass.module_eval <<~HEREDOC, __FILE__, __LINE__ + 1
+                def #{method_name}(#{MemoWise::InternalAPI.args_str(method)})
+                  _memo_wise_hash = (@_memo_wise[#{index}] ||= {})
+                  _memo_wise_output = _memo_wise_hash[#{key}]
+                  if _memo_wise_output || _memo_wise_hash.key?(#{key})
+                    _memo_wise_output
+                  else
+                    _memo_wise_hash[#{key}] = #{original_memo_wised_name}(#{MemoWise::InternalAPI.call_str(method)})
+                  end
+                end
+              HEREDOC
 
-          klass.module_eval <<~HEREDOC, __FILE__, __LINE__ + 1
-            def #{method_name}(#{MemoWise::InternalAPI.args_str(method)})
-              _memo_wise_hash = (@_memo_wise[#{index}] ||= {})
-              _memo_wise_output = _memo_wise_hash[#{key}]
-              if _memo_wise_output || _memo_wise_hash.key?(#{key})
-                _memo_wise_output
-              else
-                _memo_wise_hash[#{key}] = #{original_memo_wised_name}(#{MemoWise::InternalAPI.call_str(method)})
-              end
+              klass.send(visibility, method_name)
+              send(method_name, *args)
             end
-          HEREDOC
+            # :nocov:
+          else
+            klass.define_method(method_name) do |*args, **kwargs|
+              index = MemoWise::InternalAPI.index(self, method_name)
+              klass.module_eval <<~HEREDOC, __FILE__, __LINE__ + 1
+                def #{method_name}(#{MemoWise::InternalAPI.args_str(method)})
+                  _memo_wise_hash = (@_memo_wise[#{index}] ||= {})
+                  _memo_wise_output = _memo_wise_hash[#{key}]
+                  if _memo_wise_output || _memo_wise_hash.key?(#{key})
+                    _memo_wise_output
+                  else
+                    _memo_wise_hash[#{key}] = #{original_memo_wised_name}(#{MemoWise::InternalAPI.call_str(method)})
+                  end
+                end
+              HEREDOC
+
+              klass.send(visibility, method_name)
+              send(method_name, *args, **kwargs)
+            end
+          end
         # MemoWise::InternalAPI::MULTIPLE_REQUIRED, MemoWise::InternalAPI::SPLAT,
         # MemoWise::InternalAPI::DOUBLE_SPLAT, MemoWise::InternalAPI::SPLAT_AND_DOUBLE_SPLAT
         else
@@ -224,18 +261,54 @@ module MemoWise
           # consistent performance. In general, this should still be faster for
           # truthy results because `Hash#[]` generally performs hash lookups
           # faster than `Hash#fetch`.
-          klass.module_eval <<~HEREDOC, __FILE__, __LINE__ + 1
-            def #{method_name}(#{MemoWise::InternalAPI.args_str(method)})
-              _memo_wise_hash = (@_memo_wise[#{index}] ||= {})
-              _memo_wise_key = #{MemoWise::InternalAPI.key_str(method)}
-              _memo_wise_output = _memo_wise_hash[_memo_wise_key]
-              if _memo_wise_output || _memo_wise_hash.key?(_memo_wise_key)
-                _memo_wise_output
-              else
-                _memo_wise_hash[_memo_wise_key] = #{original_memo_wised_name}(#{MemoWise::InternalAPI.call_str(method)})
-              end
+          #
+          # NOTE: Ruby 2.6 and below, and TruffleRuby 3.0, break when we use
+          # `define_method(...) do |*args, **kwargs|`. Instead we must use the
+          # simpler `|*args|` pattern. We can't just do this always though
+          # because Ruby 2.7 and above require `|*args, **kwargs|` to work
+          # correctly.
+          # See: https://blog.saeloun.com/2019/10/07/ruby-2-7-keyword-arguments-redesign.html#ruby-26
+          # :nocov:
+          if RUBY_VERSION < "2.7" || RUBY_ENGINE == "truffleruby"
+            klass.send(:define_method, method_name) do |*args| # Ruby 2.4's `define_method` is private in some cases
+              index = MemoWise::InternalAPI.index(self, method_name)
+              klass.module_eval <<~HEREDOC, __FILE__, __LINE__ + 1
+                def #{method_name}(#{MemoWise::InternalAPI.args_str(method)})
+                  _memo_wise_hash = (@_memo_wise[#{index}] ||= {})
+                  _memo_wise_key = #{MemoWise::InternalAPI.key_str(method)}
+                  _memo_wise_output = _memo_wise_hash[_memo_wise_key]
+                  if _memo_wise_output || _memo_wise_hash.key?(_memo_wise_key)
+                    _memo_wise_output
+                  else
+                    _memo_wise_hash[_memo_wise_key] = #{original_memo_wised_name}(#{MemoWise::InternalAPI.call_str(method)})
+                  end
+                end
+              HEREDOC
+
+              klass.send(visibility, method_name)
+              send(method_name, *args)
             end
-          HEREDOC
+            # :nocov:
+          else # Ruby 2.7 and above break with (*args)
+            klass.define_method(method_name) do |*args, **kwargs|
+              index = MemoWise::InternalAPI.index(self, method_name)
+              klass.module_eval <<~HEREDOC, __FILE__, __LINE__ + 1
+                def #{method_name}(#{MemoWise::InternalAPI.args_str(method)})
+                  _memo_wise_hash = (@_memo_wise[#{index}] ||= {})
+                  _memo_wise_key = #{MemoWise::InternalAPI.key_str(method)}
+                  _memo_wise_output = _memo_wise_hash[_memo_wise_key]
+                  if _memo_wise_output || _memo_wise_hash.key?(_memo_wise_key)
+                    _memo_wise_output
+                  else
+                    _memo_wise_hash[_memo_wise_key] = #{original_memo_wised_name}(#{MemoWise::InternalAPI.call_str(method)})
+                  end
+                end
+              HEREDOC
+
+              klass.send(visibility, method_name)
+              send(method_name, *args, **kwargs)
+            end
+          end
         end
 
         klass.send(visibility, method_name)
@@ -440,12 +513,11 @@ module MemoWise
   def preset_memo_wise(method_name, *args, **kwargs)
     raise ArgumentError, "Pass a block as the value to preset for #{method_name}, #{args}" unless block_given?
 
-    api = MemoWise::InternalAPI.new(self)
-    api.validate_memo_wised!(method_name)
+    MemoWise::InternalAPI.validate_memo_wised!(self, method_name)
 
-    method = method(method_name)
+    method = method(MemoWise::InternalAPI.original_memo_wised_name(method_name))
     method_arguments = MemoWise::InternalAPI.method_arguments(method)
-    index = api.index(method_name)
+    index = MemoWise::InternalAPI.index(self, method_name)
 
     if method_arguments == MemoWise::InternalAPI::NONE
       @_memo_wise_sentinels[index] = true
@@ -548,12 +620,11 @@ module MemoWise
     raise ArgumentError, "#{method_name.inspect} must be a Symbol" unless method_name.is_a?(Symbol)
     raise ArgumentError, "#{method_name} is not a defined method" unless respond_to?(method_name, true)
 
-    api = MemoWise::InternalAPI.new(self)
-    api.validate_memo_wised!(method_name)
+    MemoWise::InternalAPI.validate_memo_wised!(self, method_name)
 
-    method = method(method_name)
+    method = method(MemoWise::InternalAPI.original_memo_wised_name(method_name))
     method_arguments = MemoWise::InternalAPI.method_arguments(method)
-    index = api.index(method_name)
+    index = MemoWise::InternalAPI.index(self, method_name)
 
     case method_arguments
     when MemoWise::InternalAPI::NONE

data/memo_wise.gemspec

@@ -36,6 +36,7 @@ Gem::Specification.new do |spec| # rubocop:disable Metrics/BlockLength
   spec.require_paths = ["lib"]
 
   spec.metadata = {
+    "rubygems_mfa_required" => "true",
     "changelog_uri" => "https://github.com/panorama-ed/memo_wise/blob/main/CHANGELOG.md",
     "source_code_uri" => "https://github.com/panorama-ed/memo_wise"
   }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: memo_wise
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Panorama Education
@@ -11,7 +11,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-23 00:00:00.000000000 Z
+date: 2021-12-10 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -52,6 +52,7 @@ homepage: https://github.com/panorama-ed/memo_wise
 licenses:
 - MIT
 metadata:
+  rubygems_mfa_required: 'true'
   changelog_uri: https://github.com/panorama-ed/memo_wise/blob/main/CHANGELOG.md
   source_code_uri: https://github.com/panorama-ed/memo_wise
 post_install_message:
@@ -69,7 +70,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.2.3
 signing_key:
 specification_version: 4
 summary: The wise choice for Ruby memoization