memo_wise 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a2fbbb2a403502d6a492068a9a0c8c103f717ea5b32e5029ba1a0aebab61db6
-  data.tar.gz: c2c8118caa1621670b6cd666f92147eb5c3f069c7b910062ed0f635568764dd7
+  metadata.gz: 4ff51bfee4fcc634d50588005e79c4a74702fd0d8deb8ab23dd917134cedf42f
+  data.tar.gz: 1cb14df9bcef27a3442b48cf1aee370835bbf9070b1f44bb3d8ec8266158bdab
 SHA512:
-  metadata.gz: 699415e3445e60bf6037fdb6887a064a4d082159be15c8c52a0711be5b3b233e3a7caa974f6d31df769d9bd0c3825d7a9f11b17b1e3b98ec9202ee8224801204
-  data.tar.gz: f6f377da39902d30310e7304e0caa7195e372c5fe0666e05ea30d2c2f936f3cc7d00c3588e453d5ab4ba7393a4f747f5c328acd4f4024cfa126ecb5f683fd24c
+  metadata.gz: 36a3f525833af24f076568ed9bdb43a06e90441788f2f8e8d26c0303ec7e0697a56c8401a3e24c06300cb3f2df199768ae00d8cf95cc90808fb4d9940ab9a931
+  data.tar.gz: f60569c63d693272856137c179b826a598c63a5762fedd76faf630b26fd3301d6ca37756f99cb7940501d5bcfd4c375094176a617610c35fc8788b67580159ce

data/CHANGELOG.md

@@ -5,9 +5,17 @@ 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.3.0] - 2021-11-22
+
+- 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
 
 ### Updated
@@ -93,7 +101,9 @@ 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.3.0...HEAD
+[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

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

data/README.md

@@ -20,6 +20,7 @@
   * 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
   * 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 +57,9 @@ class Example
     x
   end
   memo_wise :slow_value
-  
+
   private
-  
+
   # maintains privacy of the memoized method
   def private_slow_method(x)
     sleep x
@@ -117,15 +118,15 @@ Results using Ruby 3.0.2:
 
 |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.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|
 
 \* `Dry::Core`
 [may cause incorrect behavior caused by hash collisions](https://github.com/dry-rb/dry-core/issues/63).
@@ -134,15 +135,15 @@ Results using Ruby 2.7.4 (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)|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|
 
 You can run benchmarks yourself with:
 
@@ -206,7 +207,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,6 +248,7 @@ 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_
    - Commit with title `Update CHANGELOG.md for x.y.z`
 

data/benchmarks/benchmarks.rb

@@ -63,8 +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
+  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.
     #
@@ -125,8 +124,7 @@ BENCHMARK_GEMS.each do |benchmark_gem|
       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

data/lib/memo_wise/internal_api.rb

@@ -161,15 +161,72 @@ 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
 
+    # 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}.
     #

data/lib/memo_wise/version.rb

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

data/lib/memo_wise.rb

@@ -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
   #
@@ -156,6 +156,17 @@ module MemoWise
           klass = klass.singleton_class
         end
 
+        if klass.singleton_class?
+          # 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
+        end
+
         raise ArgumentError, "#{method_name.inspect} must be a Symbol" unless method_name.is_a?(Symbol)
 
         api = MemoWise::InternalAPI.new(klass)
@@ -167,39 +178,27 @@ 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)
+        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 <<-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
+              if @_memo_wise_sentinels[#{index}]
+                @_memo_wise[#{index}]
               else
+                ret = @_memo_wise[#{index}] = #{original_memo_wised_name}
                 @_memo_wise_sentinels[#{index}] = true
-                @_memo_wise[#{index}] = #{original_memo_wised_name}
+                ret
               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}]
@@ -209,7 +208,7 @@ module MemoWise
                 _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
@@ -225,7 +224,7 @@ 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 <<-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_key = #{MemoWise::InternalAPI.key_str(method)}
@@ -236,7 +235,7 @@ module MemoWise
                 _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)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: memo_wise
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.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: 2021-11-23 00:00:00.000000000 Z
 dependencies: []
 description:
 email: