memo_wise 1.2.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a2fbbb2a403502d6a492068a9a0c8c103f717ea5b32e5029ba1a0aebab61db6
-  data.tar.gz: c2c8118caa1621670b6cd666f92147eb5c3f069c7b910062ed0f635568764dd7
+  metadata.gz: aee2439aaa86140659e102e2269e4d773e34a933e73ff604b449918948b9cd29
+  data.tar.gz: bff512646d578b936d45267408be8681479c7316fa7ae16c683fc3b47261577a
 SHA512:
-  metadata.gz: 699415e3445e60bf6037fdb6887a064a4d082159be15c8c52a0711be5b3b233e3a7caa974f6d31df769d9bd0c3825d7a9f11b17b1e3b98ec9202ee8224801204
-  data.tar.gz: f6f377da39902d30310e7304e0caa7195e372c5fe0666e05ea30d2c2f936f3cc7d00c3588e453d5ab4ba7393a4f747f5c328acd4f4024cfa126ecb5f683fd24c
+  metadata.gz: a820daf7cbc735f0bc586cc7e2b73c507f01592f8666ed3837b83584537466b4d06aee3202aa7c31b4545558f3e24a45ccc4063e315479fbbc4f3ece1606f7d8
+  data.tar.gz: 6349b73c2cec18df74259b79dceef15f7f9303001deffb94146c00abcc5e9f0d6be9ab82c0aa0adab0dc528dd75de4e5c8450df389f64c88c24bea50dead15ce

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, 3.1, truffleruby-head]
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2
@@ -22,7 +22,7 @@ jobs:
     - name: Set bundler environment variables
       run: |
         echo "BUNDLE_WITHOUT=checks:docs" >> $GITHUB_ENV
-      if: matrix.ruby != 3.0
+      if: matrix.ruby != 3.1
 
     # Use 'bundler-cache: true' instead of actions/cache as advised:
     #   * https://github.com/actions/cache/blob/main/examples.md#ruby---bundler
@@ -34,15 +34,15 @@ jobs:
     - run: bundle exec rspec
 
     - run: bundle exec rubocop
-      if: matrix.ruby == 3.0
+      if: matrix.ruby == 3.1
 
     - run: |
         bundle exec yard doctest
         bundle exec dokaz
-      if: matrix.ruby == 3.0
+      if: matrix.ruby == 3.1
 
-    - name: Run benchmarks on Ruby 2.7 or 3.0
+    - name: Run benchmarks on Ruby 2.7 or 3.1
       run: |
         BUNDLE_GEMFILE=benchmarks/Gemfile bundle install --jobs 4 --retry 3
         BUNDLE_GEMFILE=benchmarks/Gemfile bundle exec ruby benchmarks/benchmarks.rb
-      if: matrix.ruby == '2.7' || matrix.ruby == '3.0'
+      if: matrix.ruby == '2.7' || matrix.ruby == '3.1'

data/.rubocop.yml

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

data/.ruby-version

@@ -1 +1 @@
-3.0.0
+3.1.0

data/CHANGELOG.md

@@ -6,7 +6,45 @@ 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
-- Nothing yet!
+
+Nothing yet!
+
+## [1.6.0] - 2022-01-24
+
+### Fixed
+
+- Fixed a bug relating to inheritance of classes which include module which
+  prepends MemoWise ([#265](https://github.com/panorama-ed/memo_wise/pull/265))
+
+### Updated
+
+- Update official test coverage to support Ruby 3.1
+
+## [1.5.0] - 2021-12-17
+
+### Fixed
+
+- Remove optimization for truthy results to fix thread safety race condition
+  bugs
+- Switch to a simpler internal data structure to fix several classes of bugs
+  related to inheritance that the previous few versions were unable to
+  sufficiently address
+
+## [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
+  `MemoWise`
 
 ## [1.2.0] - 2021-11-10
 
@@ -93,7 +131,12 @@ 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.1.0...HEAD
+[Unreleased]: https://github.com/panorama-ed/memo_wise/compare/v1.6.0...HEAD
+[1.6.0]: https://github.com/panorama-ed/memo_wise/compare/v1.5.0...v1.6.0
+[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
 [1.1.0]: https://github.com/panorama-ed/memo_wise/compare/v1.0.0...v1.1.0
 [1.0.0]: https://github.com/panorama-ed/memo_wise/compare/v0.4.0...v1.0.0
 [0.4.0]: https://github.com/panorama-ed/memo_wise/compare/v0.3.0...v0.4.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.2.0)
+    memo_wise (1.6.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,17 +37,17 @@ 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.1.0.0)
       ast (~> 2.4.1)
     rack (2.2.3)
     rainbow (3.0.0)
     rake (13.0.6)
     redcarpet (3.5.1)
-    regexp_parser (2.1.1)
+    regexp_parser (2.2.0)
     rexml (3.2.5)
     rouge (3.26.0)
     rspec (3.10.0)
@@ -62,44 +63,45 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.10.0)
     rspec-support (3.10.0)
-    rubocop (1.12.1)
+    rubocop (1.24.1)
       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.15.1, < 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.15.1)
+      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)
+    webrick (1.7.0)
+    yard (0.9.27)
+      webrick (~> 1.7.0)
     yard-doctest (0.1.17)
       minitest
       yard
+    zeitwerk (2.5.1)
 
 PLATFORMS
   ruby
@@ -117,4 +119,4 @@ DEPENDENCIES
   yard-doctest (~> 0.1)
 
 BUNDLED WITH
-   2.2.28
+   2.2.32

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2020-2021 Panorama Education
+Copyright (c) 2020-2022 Panorama Education
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -20,6 +20,8 @@
   * Support for [resetting](https://rubydoc.info/github/panorama-ed/memo_wise/MemoWise#reset_memo_wise-instance_method) and [presetting](https://rubydoc.info/github/panorama-ed/memo_wise/MemoWise#preset_memo_wise-instance_method) memoized values
   * 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
@@ -56,9 +58,9 @@ class Example
     x
   end
   memo_wise :slow_value
-  
+
   private
-  
+
   # maintains privacy of the memoized method
   def private_slow_method(x)
     sleep x
@@ -111,38 +113,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.1.0:
 
-|Method arguments|`Dry::Core`\* (0.7.1)|`Memery` (1.4.0)|
+|Method arguments|`Dry::Core` (0.7.1)|`Memery` (1.4.0)|
 |--|--|--|
-|`()` (none)|1.51x|19.82x|
-|`(a)`|2.30x|11.38x|
-|`(a, b)`|0.45x|2.10x|
-|`(a:)`|2.20x|22.83x|
-|`(a:, b:)`|0.49x|4.53x|
-|`(a, b:)`|0.46x|4.35x|
-|`(a, *args)`|0.89x|2.03x|
-|`(a:, **kwargs)`|0.82x|3.18x|
-|`(a, *args, b:, **kwargs)`|0.60x|1.62x|
+|`()` (none)|1.09x|11.80x|
+|`(a)`|1.64x|9.74x|
+|`(a, b)`|0.34x|2.00x|
+|`(a:)`|1.49x|18.84x|
+|`(a:, b:)`|0.35x|4.26x|
+|`(a, b:)`|0.35x|4.18x|
+|`(a, *args)`|0.83x|1.89x|
+|`(a:, **kwargs)`|0.84x|3.30x|
+|`(a, *args, b:, **kwargs)`|0.54x|1.47x|
 
 \* `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)|35.29x|3.46x|1.67x|4.27x|
-|`(a)`|25.04x|16.96x|12.83x|14.68x|
-|`(a, b)`|3.20x|2.28x|1.84x|2.04x|
-|`(a:)`|34.17x|27.77x|24.07x|25.39x|
-|`(a:, b:)`|5.22x|4.29x|3.74x|4.00x|
-|`(a, b:)`|4.81x|3.99x|3.49x|3.66x|
-|`(a, *args)`|3.21x|2.30x|1.97x|2.00x|
-|`(a:, **kwargs)`|2.84x|2.39x|2.12x|2.19x|
-|`(a, *args, b:, **kwargs)`|2.10x|1.80x|1.67x|1.66x|
+|`()` (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:
 
@@ -155,6 +157,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
@@ -206,7 +226,13 @@ after(:each) { helper.reset_memo_wise }
 
 ## Further Reading
 
-We've written more about MemoWise in a series of blog posts:
+We presented at RubyConf 2021:
+
+- Achieving Fast Method Metaprogramming: Lessons from `MemoWise`
+  ([slides](https://docs.google.com/presentation/d/1XgERQ0YHplwJKM3wNQwZn584d_9szYZp2WsDEXoY_7Y/edit?usp=sharing) /
+  [benchmarks](https://gist.github.com/JacobEvelyn/17b7b000e50151c30eaea928f1fcdc11))
+
+And we've written more about `MemoWise` in a series of blog posts:
 
 - [Introducing: MemoWise](https://medium.com/building-panorama-education/introducing-memowise-51a5f0523489)
 - [Optimizing MemoWise Performance](https://ja.cob.land/optimizing-memowise-performance)
@@ -241,11 +267,14 @@ Then carry out these steps:
 
 1. Update `CHANGELOG.md`:
    - 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/benchmarks/benchmarks.rb

@@ -63,12 +63,7 @@ BENCHMARK_GEMS = [
 # Use metaprogramming to ensure that each class is created in exactly the
 # the same way.
 BENCHMARK_GEMS.each do |benchmark_gem|
-  # rubocop:disable Security/Eval
-  eval <<-CLASS, binding, __FILE__, __LINE__ + 1
-    # 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.
+  eval <<~HEREDOC, binding, __FILE__, __LINE__ + 1 # rubocop:disable Security/Eval
     class #{benchmark_gem.klass}Example
       #{benchmark_gem.activation_code}
 
@@ -77,169 +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
-  CLASS
-  # rubocop:enable Security/Eval
+  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
 ]
@@ -250,7 +191,7 @@ benchmark_lambdas.map do |benchmark|
   json_file = Tempfile.new
 
   Benchmark.ips do |x|
-    x.config(suite: suite)
+    x.config(suite: suite) # rubocop:disable Style/HashSyntax
     BENCHMARK_GEMS.each do |benchmark_gem|
       instance = Object.const_get("#{benchmark_gem.klass}Example").new
 

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
@@ -161,11 +129,16 @@ module MemoWise
     def self.original_class_from_singleton(klass)
       raise ArgumentError, "Must be a singleton class: #{klass.inspect}" unless klass.singleton_class?
 
+      # Since we call this method a lot, we memoize the results. This can have a
+      # huge impact; for example, in our test suite this drops our test times
+      # from over five minutes to just a few seconds.
+      @original_class_from_singleton ||= {}
+
       # Search ObjectSpace
       #   * 1:1 relationship of singleton class to original class is documented
       #   * Performance concern: searches all Class objects
-      #     But, only runs at load time
-      ObjectSpace.each_object(Module).find do |cls|
+      #     But, only runs at load time and results are memoized
+      @original_class_from_singleton[klass] ||= ObjectSpace.each_object(Module).find do |cls|
         cls.singleton_class == klass
       end
     end
@@ -183,25 +156,11 @@ 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]
-    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.
     #
@@ -212,7 +171,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)
@@ -226,20 +185,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
@@ -248,5 +210,6 @@ module MemoWise
         target.class
       end
     end
+    private_class_method :target_class
   end
 end

data/lib/memo_wise/version.rb

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

data/lib/memo_wise.rb

@@ -30,12 +30,12 @@ module MemoWise
   # [calling the original](https://medium.com/@jeremy_96642/ruby-method-auditing-using-module-prepend-4f4e69aacd95)
   # constructor.
   #
-  # - **Q:** Why is [Module#prepend](https://ruby-doc.org/core-3.0.0/Module.html#method-i-prepend)
+  # - **Q:** Why is [Module#prepend](https://ruby-doc.org/core-3.1.0/Module.html#method-i-prepend)
   #          important here
   #          ([more info](https://medium.com/@leo_hetsch/ruby-modules-include-vs-prepend-vs-extend-f09837a5b073))?
   # - **A:** To set up *mutable state* inside the instance, even if the original
   #          constructor will then call
-  #          [Object#freeze](https://ruby-doc.org/core-3.0.0/Object.html#method-i-freeze).
+  #          [Object#freeze](https://ruby-doc.org/core-3.1.0/Object.html#method-i-freeze).
   #
   # This approach supports memoization on frozen (immutable) objects -- for
   # example, classes created by the
@@ -56,7 +56,7 @@ module MemoWise
   # :nocov:
   all_args = RUBY_VERSION < "2.7" ? "*" : "..."
   # :nocov:
-  class_eval <<-END_OF_METHOD, __FILE__, __LINE__ + 1
+  class_eval <<~HEREDOC, __FILE__, __LINE__ + 1
     # On Ruby 2.7 or greater:
     #
     # def initialize(...)
@@ -75,7 +75,7 @@ module MemoWise
       MemoWise::InternalAPI.create_memo_wise_state!(self)
       super
     end
-  END_OF_METHOD
+  HEREDOC
 
   # @private
   #
@@ -84,7 +84,7 @@ module MemoWise
   # @param target [Class]
   #   The `Class` into to prepend the MemoWise methods e.g. `memo_wise`
   #
-  # @see https://ruby-doc.org/core-3.0.0/Module.html#method-i-prepended
+  # @see https://ruby-doc.org/core-3.1.0/Module.html#method-i-prepended
   #
   # @example
   #   class Example
@@ -99,7 +99,7 @@ module MemoWise
       #
       # This is necessary in addition to the `#initialize` method definition
       # above because
-      # [`Class#allocate`](https://ruby-doc.org/core-3.0.0/Class.html#method-i-allocate)
+      # [`Class#allocate`](https://ruby-doc.org/core-3.1.0/Class.html#method-i-allocate)
       # bypasses `#initialize`, and when it's used (e.g.,
       # [in ActiveRecord](https://github.com/rails/rails/blob/a395c3a6af1e079740e7a28994d77c8baadd2a9d/activerecord/lib/active_record/persistence.rb#L411))
       # we still need to be able to access MemoWise's instance variable. Despite
@@ -156,10 +156,18 @@ module MemoWise
           klass = klass.singleton_class
         end
 
+        # This ensures that a memoized method defined on a parent class can
+        # still be used in a child class.
+        klass.module_eval <<~HEREDOC, __FILE__, __LINE__ + 1
+          def inherited(subclass)
+            super
+            MemoWise::InternalAPI.create_memo_wise_state!(subclass)
+          end
+        HEREDOC
+
         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)
 
@@ -167,76 +175,38 @@ module MemoWise
         klass.send(:private, original_memo_wised_name)
 
         method_arguments = MemoWise::InternalAPI.method_arguments(method)
-        # `@_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)
 
         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 <<-END_OF_METHOD, __FILE__, __LINE__ + 1
+          klass.module_eval <<~HEREDOC, __FILE__, __LINE__ + 1
             def #{method_name}
-              _memo_wise_output = @_memo_wise[#{index}]
-              if _memo_wise_output || @_memo_wise_sentinels[#{index}]
-                _memo_wise_output
-              else
-                @_memo_wise_sentinels[#{index}] = true
-                @_memo_wise[#{index}] = #{original_memo_wised_name}
+              @_memo_wise.fetch(:#{method_name}) do
+                @_memo_wise[:#{method_name}] = #{original_memo_wised_name}
               end
             end
-          END_OF_METHOD
+          HEREDOC
         when MemoWise::InternalAPI::ONE_REQUIRED_POSITIONAL, MemoWise::InternalAPI::ONE_REQUIRED_KEYWORD
           key = method.parameters.first.last
-
-          klass.module_eval <<-END_OF_METHOD, __FILE__, __LINE__ + 1
+          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 = (@_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_OF_METHOD
+          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`.
-          klass.module_eval <<-END_OF_METHOD, __FILE__, __LINE__ + 1
+          klass.module_eval <<~HEREDOC, __FILE__, __LINE__ + 1
             def #{method_name}(#{MemoWise::InternalAPI.args_str(method)})
-              _memo_wise_hash = (@_memo_wise[#{index}] ||= {})
+              _memo_wise_hash = (@_memo_wise[:#{method_name}] ||= {})
               _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.fetch(_memo_wise_key) do
                 _memo_wise_hash[_memo_wise_key] = #{original_memo_wised_name}(#{MemoWise::InternalAPI.call_str(method)})
               end
             end
-          END_OF_METHOD
+          HEREDOC
         end
 
         klass.send(visibility, method_name)
@@ -253,7 +223,7 @@ module MemoWise
         )
       end
 
-      # Override [Module#instance_method](https://ruby-doc.org/core-3.0.0/Module.html#method-i-instance_method)
+      # Override [Module#instance_method](https://ruby-doc.org/core-3.1.0/Module.html#method-i-instance_method)
       # to proxy the original `UnboundMethod#parameters` results. We want the
       # parameters to reflect the original method in order to support callers
       # who want to use Ruby reflection to process the method parameters,
@@ -439,22 +409,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?
 
-    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)
 
     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
@@ -542,61 +510,35 @@ module MemoWise
       raise ArgumentError, "Provided kwargs when method_name = nil" unless kwargs.empty?
 
       @_memo_wise.clear
-      @_memo_wise_sentinels.clear
       return
     end
 
     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)
+
+    # 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

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.2.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Panorama Education
@@ -11,7 +11,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-10 00:00:00.000000000 Z
+date: 2022-01-24 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.3.3
 signing_key:
 specification_version: 4
 summary: The wise choice for Ruby memoization