memo_wise 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b26ef1a44fd13498359282c6d47923ecf90bdfd4e8ac487d389dd1d5c9c5d59
-  data.tar.gz: 51d2ddc7b1d0e7d770afcf081f566059e67b07867c10803db693fd2ec848f4d1
+  metadata.gz: 9d94c6c36ed049177dffb78f2bc5b0196d06e7b334643770163b7140ee2e77e2
+  data.tar.gz: 2be9bd8578a7357aabe70d9f748cb57fedf50708028ca7c3ed55815814b7ddc2
 SHA512:
-  metadata.gz: ca1c06be2c7d0368e7708349563a0a79f93922d491ffe43448793bd6364938ea063bc3910d67ca7ce04c6cb409d784d23d19d5e97fea6430fcb20ebbb0819ab3
-  data.tar.gz: 93fc8811a80bd7f4d88517e0c3cd21f3b6ef29daea6e0578e734abecdc0067f5f9451261f5c47ad80106332075a4072a4a3e7322fe6181f2d61782d63c42caa0
+  metadata.gz: 848080fdd9596f0a0f477464ddbc2009ab2c5f3caec56d3fa3c97dd275aca7687c94793af8124a7dd567a1c33abcdf3474cb2e13ab6b8b91f47302a0059b6916
+  data.tar.gz: e79de4347bbc5cd0701095574dfb7faafb320dc3f6e1de1cb0978ebd1fcdce5e65ca0c8fa2e0079d72385acabea582caac41a0c6c553078f69d1337006422e0e

data/CHANGELOG.md

@@ -5,10 +5,16 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## Unreleased
 
 - Nothing yet!
 
+## [1.5.0] - 2021-12-17
+
+- Remove optimization for truthy results to fix race condition bugs
+- Switch to a simpler internal data structure to fix several classes of bugs
+  that the previous few versions were unable to sufficiently address
+
 ## [1.4.0] - 2021-12-10
 
 ### Fixed
@@ -110,7 +116,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.4.0...HEAD
+[Unreleased]: https://github.com/panorama-ed/memo_wise/compare/v1.5.0...HEAD
+[1.5.0]: https://github.com/panorama-ed/memo_wise/compare/v1.4.0...v1.5.0
 [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

data/Gemfile.lock

@@ -14,7 +14,7 @@ GIT
 PATH
   remote: .
   specs:
-    memo_wise (1.4.0)
+    memo_wise (1.5.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -21,6 +21,7 @@
   * Support for memoization on frozen objects
   * Support for memoization of class and module methods
   * Support for inheritance of memoized class and instance methods
+  * Documented and tested [thread-safety guarantees](#thread-safety)
   * Full [documentation](https://rubydoc.info/github/panorama-ed/memo_wise/MemoWise) and [test coverage](https://codecov.io/gh/panorama-ed/memo_wise)!
 
 ## Installation
@@ -118,15 +119,15 @@ Results using Ruby 3.0.3:
 
 |Method arguments|`Dry::Core`\* (0.7.1)|`Memery` (1.4.0)|
 |--|--|--|
-|`()` (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|
+|`()` (none)|1.06x|11.96x|
+|`(a)`|1.99x|10.19x|
+|`(a, b)`|0.39x|1.94x|
+|`(a:)`|1.80x|19.36x|
+|`(a:, b:)`|0.43x|4.26x|
+|`(a, b:)`|0.39x|3.97x|
+|`(a, *args)`|0.83x|1.85x|
+|`(a:, **kwargs)`|0.77x|2.94x|
+|`(a, *args, b:, **kwargs)`|0.59x|1.57x|
 
 \* `Dry::Core`
 [may cause incorrect behavior caused by hash collisions](https://github.com/dry-rb/dry-core/issues/63).
@@ -135,15 +136,15 @@ 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)|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|
+|`()` (none)|24.30x|2.57x|1.19x|2.98x|
+|`(a)`|21.68x|14.63x|11.13x|12.71x|
+|`(a, b)`|3.18x|2.36x|1.86x|2.06x|
+|`(a:)`|30.62x|24.52x|21.44x|22.61x|
+|`(a:, b:)`|5.25x|4.40x|3.80x|4.04x|
+|`(a, b:)`|4.91x|4.06x|3.55x|3.83x|
+|`(a, *args)`|3.10x|2.31x|1.96x|1.98x|
+|`(a:, **kwargs)`|2.87x|2.40x|2.09x|2.20x|
+|`(a, *args, b:, **kwargs)`|2.08x|1.82x|1.67x|1.70x|
 
 You can run benchmarks yourself with:
 

data/benchmarks/benchmarks.rb

@@ -64,10 +64,6 @@ BENCHMARK_GEMS = [
 # the same way.
 BENCHMARK_GEMS.each do |benchmark_gem|
   eval <<~HEREDOC, binding, __FILE__, __LINE__ + 1 # rubocop:disable Security/Eval
-    # For these methods, we alternately return truthy and falsey values in
-    # order to benchmark memoization when the result of a method is falsey.
-    #
-    # We do this by checking if the first argument to a method is even.
     class #{benchmark_gem.klass}Example
       #{benchmark_gem.activation_code}
 
@@ -76,168 +72,115 @@ BENCHMARK_GEMS.each do |benchmark_gem|
       end
       #{benchmark_gem.memoization_method} :no_args
 
-      # For the no_args case, we can't depend on arguments to alternate between
-      # returning truthy and falsey values, so instead make two separate
-      # no_args methods
-      def no_args_falsey
-        nil
-      end
-      #{benchmark_gem.memoization_method} :no_args_falsey
-
       def one_positional_arg(a)
-        100 if a.positive?
+        100
       end
       #{benchmark_gem.memoization_method} :one_positional_arg
 
       def positional_args(a, b)
-        100 if a.positive?
+        100
       end
       #{benchmark_gem.memoization_method} :positional_args
 
       def one_keyword_arg(a:)
-        100 if a.positive?
+        100
       end
       #{benchmark_gem.memoization_method} :one_keyword_arg
 
       def keyword_args(a:, b:)
-        100 if a.positive?
+        100
       end
       #{benchmark_gem.memoization_method} :keyword_args
 
       def positional_and_keyword_args(a, b:)
-        100 if a.positive?
+        100
       end
       #{benchmark_gem.memoization_method} :positional_and_keyword_args
 
       def positional_and_splat_args(a, *args)
-        100 if a.positive?
+        100
       end
       #{benchmark_gem.memoization_method} :positional_and_splat_args
 
       def keyword_and_double_splat_args(a:, **kwargs)
-        100 if a.positive?
+        100
       end
       #{benchmark_gem.memoization_method} :keyword_and_double_splat_args
 
       def positional_splat_keyword_and_double_splat_args(a, *args, b:, **kwargs)
-        100 if a.positive?
+        100
       end
       #{benchmark_gem.memoization_method} :positional_splat_keyword_and_double_splat_args
     end
   HEREDOC
 end
 
-# We pre-create argument lists for our memoized methods with arguments, so that
-# our benchmarks are running the exact same inputs for each case.
-#
-# NOTE: The proportion of falsey results is 1/N_UNIQUE_ARGUMENTS (because for
-# the methods with arguments we are truthy for all but the first unique argument
-# set, and for zero-arity methods we manually execute `no_args` N_TRUTHY_RESULTS
-# times per each execution of `no_args_falsey`). This number was selected as the
-# lowest number such that this logic:
-#
-#   output = hash[key]
-#   if output || hash.key?(key)
-#     output
-#   else
-#     hash[key] = _original_method(...)
-#   end
-#
-# is consistently faster for cached lookups than:
-#
-#   hash.fetch(key) do
-#     hash[key] = _original_method(...)
-#   end
-#
-# as a result of `Hash#[]` having less overhead than `Hash#fetch`.
-#
-# We believe this is a reasonable choice because we believe most memoized method
-# results will be truthy, and so that is the case we should most optimize for.
-# However, we do not want to completely remove falsey method results from these
-# benchmarks because we do want to catch performance regressions for that case,
-# since it has its own "hot path."
-N_UNIQUE_ARGUMENTS = 30
-ARGUMENTS = Array.new(N_UNIQUE_ARGUMENTS) { |i| [i, i + 1] }
-N_TRUTHY_RESULTS = N_UNIQUE_ARGUMENTS - 1
 N_RESULT_DECIMAL_DIGITS = 2
 
 # Each method within these benchmarks is initially run once to memoize the
 # result value, so our benchmark only tests memoized retrieval time.
 benchmark_lambdas = [
   lambda do |x, instance, benchmark_gem|
-    instance.no_args_falsey
     instance.no_args
 
     x.report("#{benchmark_gem.benchmark_name}: ()") do
-      instance.no_args_falsey
-      N_TRUTHY_RESULTS.times { instance.no_args }
+      instance.no_args
     end
   end,
   lambda do |x, instance, benchmark_gem|
-    ARGUMENTS.each { |a, _| instance.one_positional_arg(a) }
+    instance.one_positional_arg(1)
 
     x.report("#{benchmark_gem.benchmark_name}: (a)") do
-      ARGUMENTS.each { |a, _| instance.one_positional_arg(a) }
+      instance.one_positional_arg(1)
     end
   end,
   lambda do |x, instance, benchmark_gem|
-    ARGUMENTS.each { |a, b| instance.positional_args(a, b) }
+    instance.positional_args(1, 2)
 
     x.report("#{benchmark_gem.benchmark_name}: (a, b)") do
-      ARGUMENTS.each { |a, b| instance.positional_args(a, b) }
+      instance.positional_args(1, 2)
     end
   end,
   lambda do |x, instance, benchmark_gem|
-    ARGUMENTS.each { |a, _| instance.one_keyword_arg(a: a) }
+    instance.one_keyword_arg(a: 1)
 
     x.report("#{benchmark_gem.benchmark_name}: (a:)") do
-      ARGUMENTS.each { |a, _| instance.one_keyword_arg(a: a) }
+      instance.one_keyword_arg(a: 1)
     end
   end,
   lambda do |x, instance, benchmark_gem|
-    ARGUMENTS.each { |a, b| instance.keyword_args(a: a, b: b) }
+    instance.keyword_args(a: 1, b: 2)
 
     x.report("#{benchmark_gem.benchmark_name}: (a:, b:)") do
-      ARGUMENTS.each { |a, b| instance.keyword_args(a: a, b: b) }
+      instance.keyword_args(a: 1, b: 2)
     end
   end,
   lambda do |x, instance, benchmark_gem|
-    ARGUMENTS.each { |a, b| instance.positional_and_keyword_args(a, b: b) }
+    instance.positional_and_keyword_args(1, b: 2)
 
     x.report("#{benchmark_gem.benchmark_name}: (a, b:)") do
-      ARGUMENTS.each { |a, b| instance.positional_and_keyword_args(a, b: b) }
+      instance.positional_and_keyword_args(1, b: 2)
     end
   end,
   lambda do |x, instance, benchmark_gem|
-    ARGUMENTS.each { |a, b| instance.positional_and_splat_args(a, b) }
+    instance.positional_and_splat_args(1, 2)
 
     x.report("#{benchmark_gem.benchmark_name}: (a, *args)") do
-      ARGUMENTS.each { |a, b| instance.positional_and_splat_args(a, b) }
+      instance.positional_and_splat_args(1, 2)
     end
   end,
   lambda do |x, instance, benchmark_gem|
-    ARGUMENTS.each { |a, b| instance.keyword_and_double_splat_args(a: a, b: b) }
+    instance.keyword_and_double_splat_args(a: 1, b: 2)
 
-    x.report(
-      "#{benchmark_gem.benchmark_name}: (a:, **kwargs)"
-    ) do
-      ARGUMENTS.each do |a, b|
-        instance.keyword_and_double_splat_args(a: a, b: b)
-      end
+    x.report("#{benchmark_gem.benchmark_name}: (a:, **kwargs)") do
+      instance.keyword_and_double_splat_args(a: 1, b: 2)
     end
   end,
   lambda do |x, instance, benchmark_gem|
-    ARGUMENTS.each do |a, b|
-      instance.positional_splat_keyword_and_double_splat_args(a, b, b: b, a: a)
-    end
+    instance.positional_splat_keyword_and_double_splat_args(1, 2, b: 3, a: 4)
 
-    x.report(
-      "#{benchmark_gem.benchmark_name}: (a, *args, b:, **kwargs)"
-    ) do
-      ARGUMENTS.each do |a, b|
-        instance.
-          positional_splat_keyword_and_double_splat_args(a, b, b: b, a: a)
-      end
+    x.report("#{benchmark_gem.benchmark_name}: (a, *args, b:, **kwargs)") do
+      instance.positional_splat_keyword_and_double_splat_args(1, 2, b: 3, a: 4)
     end
   end
 ]

data/lib/memo_wise/internal_api.rb

@@ -10,14 +10,9 @@ module MemoWise
     #
     # @return [Object] the passed-in obj
     def self.create_memo_wise_state!(obj)
-      # `@_memo_wise` stores memoized results of method calls. The structure is
-      # slightly different for different types of methods. It looks like:
-      #   [
-      #     :memoized_result, # For method 0 (which takes no arguments)
-      #     { arg1 => :memoized_result, ... }, # For method 1 (which takes an argument)
-      #     { [arg1, arg2] => :memoized_result, ... } # For method 2 (which takes multiple arguments)
-      #   ]
-      # This is a faster alternative to:
+      # `@_memo_wise` stores memoized results of method calls in a hash keyed on
+      # method name. The structure is slightly different for different types of
+      # methods. It looks like:
       #   {
       #     zero_arg_method_name: :memoized_result,
       #     single_arg_method_name: { arg1 => :memoized_result, ... },
@@ -25,34 +20,7 @@ module MemoWise
       #     # Surprisingly, this is faster than a single top-level hash key of: [:multi_arg_method_name, arg1, arg2]
       #     multi_arg_method_name: { [arg1, arg2] => :memoized_result, ... }
       #   }
-      # because we can give each method its own array index at load time and
-      # perform that array lookup more quickly than a hash lookup by method
-      # name.
-      obj.instance_variable_set(:@_memo_wise, []) unless obj.instance_variable_defined?(:@_memo_wise)
-
-      # For zero-arity methods, memoized values are stored in the `@_memo_wise`
-      # array. Arrays do not differentiate between "unset" and "set to nil" and
-      # so to handle this case we need another array to store sentinels and
-      # store `true` at indexes for which a zero-arity method has been memoized.
-      # `@_memo_wise_sentinels` looks like:
-      #   [
-      #     true, # A zero-arity method's result has been memoized
-      #     nil, # A zero-arity method's result has not been memoized
-      #     nil, # A one-arity method will always correspond to `nil` here
-      #     ...
-      #   ]
-      # NOTE: Because `@_memo_wise` stores memoized values for more than just
-      # zero-arity methods, the `@_memo_wise_sentinels` array can end up being
-      # sparse (see above), even when all methods' memoized values have been
-      # stored. If this becomes an issue we could store a separate index for
-      # zero-arity methods to make every element in `@_memo_wise_sentinels`
-      # correspond to a zero-arity method.
-      # NOTE: Surprisingly, lookups on an array of `true` and `nil` values
-      # appear to outperform even bitwise operators on integers (as of Ruby
-      # 3.0.2), allowing us to avoid more complex sentinel structures.
-      unless obj.instance_variable_defined?(:@_memo_wise_sentinels)
-        obj.instance_variable_set(:@_memo_wise_sentinels, [])
-      end
+      obj.instance_variable_set(:@_memo_wise, {}) unless obj.instance_variable_defined?(:@_memo_wise)
 
       obj
     end
@@ -188,15 +156,6 @@ module MemoWise
       :"_memo_wise_original_#{method_name}"
     end
 
-    # @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 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]
@@ -252,35 +211,5 @@ module MemoWise
       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.4.0"
+  VERSION = "1.5.0"
 end

data/lib/memo_wise.rb

@@ -180,135 +180,35 @@ module MemoWise
 
         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.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
+          klass.module_eval <<~HEREDOC, __FILE__, __LINE__ + 1
+            def #{method_name}
+              @_memo_wise.fetch(:#{method_name}) do
+                @_memo_wise[:#{method_name}] = #{original_memo_wised_name}
               end
-            HEREDOC
-
-            klass.send(visibility, method_name)
-            send(method_name)
-          end
+            end
+          HEREDOC
         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.send(visibility, method_name)
-              send(method_name, *args)
-            end
-            # :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)
+          klass.module_eval <<~HEREDOC, __FILE__, __LINE__ + 1
+            def #{method_name}(#{MemoWise::InternalAPI.args_str(method)})
+              _memo_wise_hash = (@_memo_wise[:#{method_name}] ||= {})
+              _memo_wise_hash.fetch(#{key}) do
+                _memo_wise_hash[#{key}] = #{original_memo_wised_name}(#{MemoWise::InternalAPI.call_str(method)})
+              end
             end
-          end
+          HEREDOC
         # MemoWise::InternalAPI::MULTIPLE_REQUIRED, MemoWise::InternalAPI::SPLAT,
         # MemoWise::InternalAPI::DOUBLE_SPLAT, MemoWise::InternalAPI::SPLAT_AND_DOUBLE_SPLAT
         else
-          # NOTE: When benchmarking this implementation against something like:
-          #
-          #   @_memo_wise.fetch(key) do
-          #     ...
-          #   end
-          #
-          # this implementation may sometimes perform worse than the above. This
-          # is because this case uses a more complex hash key (see
-          # `MemoWise::InternalAPI.key_str`), and hashing that key has less
-          # consistent performance. In general, this should still be faster for
-          # truthy results because `Hash#[]` generally performs hash lookups
-          # faster than `Hash#fetch`.
-          #
-          # 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
-            # :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)
+          klass.module_eval <<~HEREDOC, __FILE__, __LINE__ + 1
+            def #{method_name}(#{MemoWise::InternalAPI.args_str(method)})
+              _memo_wise_hash = (@_memo_wise[:#{method_name}] ||= {})
+              _memo_wise_key = #{MemoWise::InternalAPI.key_str(method)}
+              _memo_wise_hash.fetch(_memo_wise_key) do
+                _memo_wise_hash[_memo_wise_key] = #{original_memo_wised_name}(#{MemoWise::InternalAPI.call_str(method)})
+              end
             end
-          end
+          HEREDOC
         end
 
         klass.send(visibility, method_name)
@@ -511,21 +411,20 @@ module MemoWise
   #   ex.method_called_times #=> nil
   #
   def preset_memo_wise(method_name, *args, **kwargs)
+    raise ArgumentError, "#{method_name.inspect} must be a Symbol" unless method_name.is_a?(Symbol)
     raise ArgumentError, "Pass a block as the value to preset for #{method_name}, #{args}" unless block_given?
 
     MemoWise::InternalAPI.validate_memo_wised!(self, method_name)
 
     method = method(MemoWise::InternalAPI.original_memo_wised_name(method_name))
     method_arguments = MemoWise::InternalAPI.method_arguments(method)
-    index = MemoWise::InternalAPI.index(self, method_name)
 
     if method_arguments == MemoWise::InternalAPI::NONE
-      @_memo_wise_sentinels[index] = true
-      @_memo_wise[index] = yield
+      @_memo_wise[method_name] = yield
       return
     end
 
-    hash = (@_memo_wise[index] ||= {})
+    hash = (@_memo_wise[method_name] ||= {})
 
     case method_arguments
     when MemoWise::InternalAPI::ONE_REQUIRED_POSITIONAL then hash[args.first] = yield
@@ -613,7 +512,6 @@ module MemoWise
       raise ArgumentError, "Provided kwargs when method_name = nil" unless kwargs.empty?
 
       @_memo_wise.clear
-      @_memo_wise_sentinels.clear
       return
     end
 
@@ -624,49 +522,25 @@ module MemoWise
 
     method = method(MemoWise::InternalAPI.original_memo_wised_name(method_name))
     method_arguments = MemoWise::InternalAPI.method_arguments(method)
-    index = MemoWise::InternalAPI.index(self, method_name)
+
+    # method_name == MemoWise::InternalAPI::NONE will be covered by this case.
+    @_memo_wise.delete(method_name) if args.empty? && kwargs.empty?
+    method_hash = @_memo_wise[method_name]
 
     case method_arguments
-    when MemoWise::InternalAPI::NONE
-      @_memo_wise_sentinels[index] = nil
-      @_memo_wise[index] = nil
-    when MemoWise::InternalAPI::ONE_REQUIRED_POSITIONAL
-      if args.empty?
-        @_memo_wise[index]&.clear
-      else
-        @_memo_wise[index]&.delete(args.first)
-      end
-    when MemoWise::InternalAPI::ONE_REQUIRED_KEYWORD
-      if kwargs.empty?
-        @_memo_wise[index]&.clear
-      else
-        @_memo_wise[index]&.delete(kwargs.first.last)
-      end
-    when MemoWise::InternalAPI::SPLAT
-      if args.empty?
-        @_memo_wise[index]&.clear
-      else
-        @_memo_wise[index]&.delete(args)
-      end
-    when MemoWise::InternalAPI::DOUBLE_SPLAT
-      if kwargs.empty?
-        @_memo_wise[index]&.clear
-      else
-        @_memo_wise[index]&.delete(kwargs)
-      end
+    when MemoWise::InternalAPI::ONE_REQUIRED_POSITIONAL then method_hash&.delete(args.first)
+    when MemoWise::InternalAPI::ONE_REQUIRED_KEYWORD then method_hash&.delete(kwargs.first.last)
+    when MemoWise::InternalAPI::SPLAT then method_hash&.delete(args)
+    when MemoWise::InternalAPI::DOUBLE_SPLAT then method_hash&.delete(kwargs)
     else # MemoWise::InternalAPI::MULTIPLE_REQUIRED, MemoWise::InternalAPI::SPLAT_AND_DOUBLE_SPLAT
-      if args.empty? && kwargs.empty?
-        @_memo_wise[index]&.clear
-      else
-        key = if method_arguments == MemoWise::InternalAPI::SPLAT_AND_DOUBLE_SPLAT
-                [args, kwargs]
-              else
-                method.parameters.map.with_index do |(type, name), i|
-                  type == :req ? args[i] : kwargs[name] # rubocop:disable Metrics/BlockNesting
-                end
+      key = if method_arguments == MemoWise::InternalAPI::SPLAT_AND_DOUBLE_SPLAT
+              [args, kwargs]
+            else
+              method.parameters.map.with_index do |(type, name), i|
+                type == :req ? args[i] : kwargs[name]
               end
-        @_memo_wise[index]&.delete(key)
-      end
+            end
+      method_hash&.delete(key)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: memo_wise
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Panorama Education
@@ -11,7 +11,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-10 00:00:00.000000000 Z
+date: 2021-12-20 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -70,7 +70,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: The wise choice for Ruby memoization