memo_wise 1.1.0 → 1.5.0

data/lib/memo_wise.rb

@@ -25,7 +25,7 @@ require "memo_wise/version"
 #   - {.memo_wise} for API and usage examples.
 #   - {file:README.md} for general project information.
 #
-module MemoWise # rubocop:disable Metrics/ModuleLength
+module MemoWise
   # Constructor to set up memoization state before
   # [calling the original](https://medium.com/@jeremy_96642/ruby-method-auditing-using-module-prepend-4f4e69aacd95)
   # constructor.
@@ -56,7 +56,7 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
   # :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 # rubocop:disable Metrics/ModuleLength
       MemoWise::InternalAPI.create_memo_wise_state!(self)
       super
     end
-  END_OF_METHOD
+  HEREDOC
 
   # @private
   #
@@ -91,7 +91,7 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
   #     prepend MemoWise
   #   end
   #
-  def self.prepended(target) # rubocop:disable Metrics/PerceivedComplexity
+  def self.prepended(target)
     class << target
       # Allocator to set up memoization state before
       # [calling the original](https://medium.com/@jeremy_96642/ruby-method-auditing-using-module-prepend-4f4e69aacd95)
@@ -111,7 +111,7 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
       end
 
       # NOTE: See YARD docs for {.memo_wise} directly below this method!
-      def memo_wise(method_name_or_hash) # rubocop:disable Metrics/PerceivedComplexity
+      def memo_wise(method_name_or_hash)
         klass = self
         case method_name_or_hash
         when Symbol
@@ -156,100 +156,59 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
           klass = klass.singleton_class
         end
 
-        unless method_name.is_a?(Symbol)
-          raise ArgumentError, "#{method_name.inspect} must be a Symbol"
+        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
 
-        api = MemoWise::InternalAPI.new(klass)
-        visibility = api.method_visibility(method_name)
-        original_memo_wised_name =
-          MemoWise::InternalAPI.original_memo_wised_name(method_name)
+        raise ArgumentError, "#{method_name.inspect} must be a Symbol" unless method_name.is_a?(Symbol)
+
+        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)
 
         klass.send(:alias_method, original_memo_wised_name, method_name)
         klass.send(:private, original_memo_wised_name)
 
-        # Zero-arg methods can use simpler/more performant logic because the
-        # hash key is just the method name.
-        if method.arity.zero?
-          klass.module_eval <<-END_OF_METHOD, __FILE__, __LINE__ + 1
+        method_arguments = MemoWise::InternalAPI.method_arguments(method)
+
+        case method_arguments
+        when MemoWise::InternalAPI::NONE
+          klass.module_eval <<~HEREDOC, __FILE__, __LINE__ + 1
             def #{method_name}
-              output = @_memo_wise[:#{method_name}]
-              if output || @_memo_wise.key?(:#{method_name})
-                output
-              else
+              @_memo_wise.fetch(:#{method_name}) do
                 @_memo_wise[:#{method_name}] = #{original_memo_wised_name}
               end
             end
-          END_OF_METHOD
-        else
-          if MemoWise::InternalAPI.has_only_required_args?(method)
-            args_str = method.parameters.map do |type, name|
-              "#{name}#{':' if type == :keyreq}"
-            end.join(", ")
-            args_str = "(#{args_str})"
-            call_str = method.parameters.map do |type, name|
-              type == :req ? name : "#{name}: #{name}"
-            end.join(", ")
-            call_str = "(#{call_str})"
-            fetch_key_params = method.parameters.map(&:last)
-            if fetch_key_params.size > 1
-              fetch_key_init =
-                "[:#{method_name}, #{fetch_key_params.join(', ')}].hash"
-              use_hashed_key = true
-            else
-              fetch_key = fetch_key_params.first.to_s
-            end
-          else
-            # If our method has arguments, we need to separate out our handling
-            # of normal args vs. keyword args due to the changes in Ruby 3.
-            # See: <link>
-            # By only including logic for *args, **kwargs when they are used in
-            # the method, we can avoid allocating unnecessary arrays and hashes.
-            has_arg = MemoWise::InternalAPI.has_arg?(method)
-
-            if has_arg && MemoWise::InternalAPI.has_kwarg?(method)
-              args_str = "(*args, **kwargs)"
-              fetch_key_init = "[:#{method_name}, args, kwargs].hash"
-              use_hashed_key = true
-            elsif has_arg
-              args_str = "(*args)"
-              fetch_key_init = "args.hash"
-            else
-              args_str = "(**kwargs)"
-              fetch_key_init = "kwargs.hash"
-            end
-          end
-
-          if use_hashed_key
-            klass.module_eval <<-END_OF_METHOD, __FILE__, __LINE__ + 1
-              def #{method_name}#{args_str}
-                key = #{fetch_key_init}
-                output = @_memo_wise[key]
-                if output || @_memo_wise.key?(key)
-                  output
-                else
-                  hashes = (@_memo_wise_hashes[:#{method_name}] ||= Set.new)
-                  hashes << key
-                  @_memo_wise[key] = #{original_memo_wised_name}#{call_str || args_str}
-                end
+          HEREDOC
+        when MemoWise::InternalAPI::ONE_REQUIRED_POSITIONAL, MemoWise::InternalAPI::ONE_REQUIRED_KEYWORD
+          key = method.parameters.first.last
+          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_OF_METHOD
-          else
-            fetch_key ||= "key"
-            klass.module_eval <<-END_OF_METHOD, __FILE__, __LINE__ + 1
-              def #{method_name}#{args_str}
-                hash = (@_memo_wise[:#{method_name}] ||= {})
-                #{"key = #{fetch_key_init}" if fetch_key_init}
-                output = hash[#{fetch_key}]
-                if output || hash.key?(#{fetch_key})
-                  output
-                else
-                  hash[#{fetch_key}] = #{original_memo_wised_name}#{call_str || args_str}
-                end
+            end
+          HEREDOC
+        # MemoWise::InternalAPI::MULTIPLE_REQUIRED, MemoWise::InternalAPI::SPLAT,
+        # MemoWise::InternalAPI::DOUBLE_SPLAT, MemoWise::InternalAPI::SPLAT_AND_DOUBLE_SPLAT
+        else
+          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_OF_METHOD
-          end
+            end
+          HEREDOC
         end
 
         klass.send(visibility, method_name)
@@ -275,8 +234,7 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
       # (`...` or `*args, **kwargs`), making reflection on method parameters
       # useless without this.
       def target.instance_method(symbol)
-        original_memo_wised_name =
-          MemoWise::InternalAPI.original_memo_wised_name(symbol)
+        original_memo_wised_name = MemoWise::InternalAPI.original_memo_wised_name(symbol)
 
         super.tap do |curr_method|
           # Start with calling the original `instance_method` on `symbol`,
@@ -368,7 +326,6 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
   #     Example.method_called_times #=> nil
   ##
 
-  # rubocop:disable Layout/LineLength
   ##
   # @!method self.reset_memo_wise(method_name = nil, *args, **kwargs)
   #   Implementation of {#reset_memo_wise} for class methods.
@@ -402,7 +359,6 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
   #
   #     Example.reset_memo_wise # reset "all methods" mode
   ##
-  # rubocop:enable Layout/LineLength
 
   # Presets the memoized result for the given method to the result of the given
   # block.
@@ -455,26 +411,33 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
   #   ex.method_called_times #=> nil
   #
   def preset_memo_wise(method_name, *args, **kwargs)
-    unless block_given?
-      raise ArgumentError,
-            "Pass a block as the value to preset for #{method_name}, #{args}"
-    end
+    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)
 
-    api = MemoWise::InternalAPI.new(self)
-    api.validate_memo_wised!(method_name)
+    method = method(MemoWise::InternalAPI.original_memo_wised_name(method_name))
+    method_arguments = MemoWise::InternalAPI.method_arguments(method)
 
-    if method(method_name).arity.zero?
+    if method_arguments == MemoWise::InternalAPI::NONE
       @_memo_wise[method_name] = yield
-    else
-      key = api.fetch_key(method_name, *args, **kwargs)
-      if api.use_hashed_key?(method_name)
-        hashes = @_memo_wise_hashes[method_name] ||= []
-        hashes << key
-        @_memo_wise[key] = yield
-      else
-        hash = @_memo_wise[method_name] ||= {}
-        hash[key] = yield
+      return
+    end
+
+    hash = (@_memo_wise[method_name] ||= {})
+
+    case method_arguments
+    when MemoWise::InternalAPI::ONE_REQUIRED_POSITIONAL then hash[args.first] = yield
+    when MemoWise::InternalAPI::ONE_REQUIRED_KEYWORD then hash[kwargs.first.last] = yield
+    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]
       end
+      hash[key] = yield
+    else # MemoWise::InternalAPI::SPLAT_AND_DOUBLE_SPLAT
+      hash[[args, kwargs]] = yield
     end
   end
 
@@ -543,46 +506,41 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
   #
   #   ex.reset_memo_wise # reset "all methods" mode
   #
-  def reset_memo_wise(method_name = nil, *args, **kwargs) # rubocop:disable Metrics/PerceivedComplexity
+  def reset_memo_wise(method_name = nil, *args, **kwargs)
     if method_name.nil?
-      unless args.empty?
-        raise ArgumentError, "Provided args when method_name = nil"
-      end
-
-      unless kwargs.empty?
-        raise ArgumentError, "Provided kwargs when method_name = nil"
-      end
+      raise ArgumentError, "Provided args when method_name = nil" unless args.empty?
+      raise ArgumentError, "Provided kwargs when method_name = nil" unless kwargs.empty?
 
       @_memo_wise.clear
-      @_memo_wise_hashes.clear
       return
     end
 
-    unless method_name.is_a?(Symbol)
-      raise ArgumentError, "#{method_name.inspect} must be a Symbol"
-    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)
 
-    unless respond_to?(method_name, true)
-      raise ArgumentError, "#{method_name} is not a defined method"
-    end
+    MemoWise::InternalAPI.validate_memo_wised!(self, method_name)
 
-    api = MemoWise::InternalAPI.new(self)
-    api.validate_memo_wised!(method_name)
+    method = method(MemoWise::InternalAPI.original_memo_wised_name(method_name))
+    method_arguments = MemoWise::InternalAPI.method_arguments(method)
 
-    if args.empty? && kwargs.empty?
-      @_memo_wise.delete(method_name)
-      @_memo_wise_hashes[method_name]&.each do |hash|
-        @_memo_wise.delete(hash)
-      end
-      @_memo_wise_hashes.delete(method_name)
-    else
-      key = api.fetch_key(method_name, *args, **kwargs)
-      if api.use_hashed_key?(method_name)
-        @_memo_wise_hashes[method_name]&.delete(key)
-        @_memo_wise.delete(key)
-      else
-        @_memo_wise[method_name]&.delete(key)
-      end
+    # 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::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
+      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)
     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.1.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Panorama Education
@@ -11,7 +11,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-07-30 00:00:00.000000000 Z
+date: 2021-12-20 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.3
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: The wise choice for Ruby memoization