memo_wise 1.6.0 → 1.8.0

data/lib/memo_wise.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require "set"
+# Disable RuboCop here because Ruby < 3.2 does not load `set` by default.
+require "set" # rubocop:disable Lint/RedundantRequireStatement
 
 require "memo_wise/internal_api"
 require "memo_wise/version"
@@ -30,12 +31,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.1.0/Module.html#method-i-prepend)
+  # - **Q:** Why is [Module#prepend](https://ruby-doc.org/3.2.1/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.1.0/Object.html#method-i-freeze).
+  #          [Object#freeze](https://ruby-doc.org/3.2.1/Object.html#method-i-freeze).
   #
   # This approach supports memoization on frozen (immutable) objects -- for
   # example, classes created by the
@@ -84,7 +85,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.1.0/Module.html#method-i-prepended
+  # @see https://ruby-doc.org/3.2.1/Module.html#method-i-prepend
   #
   # @example
   #   class Example
@@ -99,7 +100,7 @@ module MemoWise
       #
       # This is necessary in addition to the `#initialize` method definition
       # above because
-      # [`Class#allocate`](https://ruby-doc.org/core-3.1.0/Class.html#method-i-allocate)
+      # [`Class#allocate`](https://ruby-doc.org/3.2.1/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
@@ -195,9 +196,40 @@ module MemoWise
               end
             end
           HEREDOC
-        # MemoWise::InternalAPI::MULTIPLE_REQUIRED, MemoWise::InternalAPI::SPLAT,
-        # MemoWise::InternalAPI::DOUBLE_SPLAT, MemoWise::InternalAPI::SPLAT_AND_DOUBLE_SPLAT
-        else
+        when MemoWise::InternalAPI::MULTIPLE_REQUIRED
+          # When we have multiple required params, we store the memoized values in a deeply nested hash, like:
+          # { method_name: { arg1 => { arg2 => { arg3 => memoized_value } } } }
+          last_index = method.parameters.size
+          layers = method.parameters.map.with_index(1) do |(_, name), index|
+            prev_hash = "_memo_wise_hash#{index - 1 if index > 1}"
+            fallback = if index == last_index
+                         "#{original_memo_wised_name}(#{MemoWise::InternalAPI.call_str(method)})"
+                       else
+                         "{}"
+                       end
+            "_memo_wise_hash#{index} = #{prev_hash}.fetch(#{name}) { #{prev_hash}[#{name}] = #{fallback} }"
+          end
+          klass.module_eval <<~HEREDOC, __FILE__, __LINE__ + 1
+            def #{method_name}(#{MemoWise::InternalAPI.args_str(method)})
+              _memo_wise_hash = (@_memo_wise[:#{method_name}] ||= {})
+              #{layers.join("\n  ")}
+            end
+          HEREDOC
+        when MemoWise::InternalAPI::SPLAT_AND_DOUBLE_SPLAT
+          # When we have both *args and **kwargs, we store the memoized values in a deeply nested hash, like:
+          # { method_name: { args => { kwargs => memoized_value } } }
+          klass.module_eval <<~HEREDOC, __FILE__, __LINE__ + 1
+            def #{method_name}(*args, **kwargs)
+              _memo_wise_hash = (@_memo_wise[:#{method_name}] ||= {})
+              _memo_wise_kwargs_hash = _memo_wise_hash.fetch(args) do
+                _memo_wise_hash[args] = {}
+              end
+              _memo_wise_kwargs_hash.fetch(kwargs) do
+                _memo_wise_kwargs_hash[kwargs] = #{original_memo_wised_name}(#{MemoWise::InternalAPI.call_str(method)})
+              end
+            end
+          HEREDOC
+        else # MemoWise::InternalAPI::SPLAT, MemoWise::InternalAPI::DOUBLE_SPLAT
           klass.module_eval <<~HEREDOC, __FILE__, __LINE__ + 1
             def #{method_name}(#{MemoWise::InternalAPI.args_str(method)})
               _memo_wise_hash = (@_memo_wise[:#{method_name}] ||= {})
@@ -223,7 +255,7 @@ module MemoWise
         )
       end
 
-      # Override [Module#instance_method](https://ruby-doc.org/core-3.1.0/Module.html#method-i-instance_method)
+      # Override [Module#instance_method](https://ruby-doc.org/3.2.1/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,
@@ -430,12 +462,23 @@ module MemoWise
     when MemoWise::InternalAPI::SPLAT then hash[args] = yield
     when MemoWise::InternalAPI::DOUBLE_SPLAT then hash[kwargs] = yield
     when MemoWise::InternalAPI::MULTIPLE_REQUIRED
-      key = method.parameters.map.with_index do |(type, name), idx|
-        type == :req ? args[idx] : kwargs[name]
+      n_parameters = method.parameters.size
+      method.parameters.each_with_index do |(type, name), index|
+        val = type == :req ? args[index] : kwargs[name]
+
+        # Walk through the layers of nested hashes. When we get to the final
+        # layer, yield to the block to set its value.
+        if index < n_parameters - 1
+          hash = (hash[val] ||= {})
+        else
+          hash[val] = yield
+        end
       end
-      hash[key] = yield
     else # MemoWise::InternalAPI::SPLAT_AND_DOUBLE_SPLAT
-      hash[[args, kwargs]] = yield
+      # When we have both *args and **kwargs, we store the memoized values like:
+      #   { method_name: { args => { kwargs => memoized_value } } }
+      # so we need to initialize `hash[args]`` if it does not already exist.
+      (hash[args] ||= {})[kwargs] = yield
     end
   end
 
@@ -530,15 +573,26 @@ module MemoWise
     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
-      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
-            end
-      method_hash&.delete(key)
+    when MemoWise::InternalAPI::SPLAT_AND_DOUBLE_SPLAT
+      # Here, memoized values are stored like:
+      #   { method_name: { args => { kwargs => memoized_value } } }
+      # so we need to delete the innermost value (because the same args array
+      # may have multiple memoized values for different kwargs hashes).
+      method_hash&.[](args)&.delete(kwargs)
+    else # MemoWise::InternalAPI::MULTIPLE_REQUIRED
+      n_parameters = method.parameters.size
+      method.parameters.each_with_index do |(type, name), index|
+        val = type == :req ? args[index] : kwargs[name]
+
+        # Walk through the layers of nested hashes. When we get to the final
+        # layer, delete its value. We use the safe navigation operator to
+        # gracefully handle any layer not yet existing.
+        if index < n_parameters - 1
+          method_hash = method_hash&.[](val)
+        else
+          method_hash&.delete(val)
+        end
+      end
     end
   end
 end

data/memo_wise.gemspec

@@ -2,7 +2,7 @@
 
 require_relative "lib/memo_wise/version"
 
-Gem::Specification.new do |spec| # rubocop:disable Metrics/BlockLength
+Gem::Specification.new do |spec|
   spec.name     = "memo_wise"
   spec.version  = MemoWise::VERSION
   spec.summary  = "The wise choice for Ruby memoization"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: memo_wise
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.8.0
 platform: ruby
 authors:
 - Panorama Education
@@ -11,7 +11,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-24 00:00:00.000000000 Z
+date: 2023-10-30 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -26,6 +26,7 @@ files:
 - ".dokaz"
 - ".github/PULL_REQUEST_TEMPLATE.md"
 - ".github/dependabot.yml"
+- ".github/workflows/dependency-review.yml"
 - ".github/workflows/main.yml"
 - ".gitignore"
 - ".rspec"
@@ -70,7 +71,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.4.6
 signing_key:
 specification_version: 4
 summary: The wise choice for Ruby memoization