memo_wise 0.3.0 → 1.2.0

data/lib/memo_wise.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "set"
+
+require "memo_wise/internal_api"
 require "memo_wise/version"
 
 # MemoWise is the wise choice for memoization in Ruby.
@@ -22,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.
@@ -39,157 +42,40 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
   # [Values](https://github.com/tcrayford/Values)
   # [gem](https://rubygems.org/gems/values).
   #
-  def initialize(*)
-    MemoWise.create_memo_wise_state!(self)
-    super
-  end
-
-  # @private
-  #
-  # Determine whether `method` takes any *positional* args.
-  #
-  # These are the types of positional args:
-  #
-  #   * *Required* -- ex: `def foo(a)`
-  #   * *Optional* -- ex: `def foo(b=1)`
-  #   * *Splatted* -- ex: `def foo(*c)`
-  #
-  # @param method [Method, UnboundMethod]
-  #   Arguments of this method will be checked
-  #
-  # @return [Boolean]
-  #   Return `true` if `method` accepts one or more positional arguments
-  #
-  # @example
-  #   class Example
-  #     def no_args
-  #     end
-  #
-  #     def position_arg(a)
-  #     end
-  #   end
-  #
-  #   MemoWise.has_arg?(Example.instance_method(:no_args)) #=> false
-  #
-  #   MemoWise.has_arg?(Example.instance_method(:position_arg)) #=> true
-  #
-  def self.has_arg?(method) # rubocop:disable Naming/PredicateName
-    method.parameters.any? do |(param, _)|
-      param == :req || param == :opt || param == :rest # rubocop:disable Style/MultipleComparison
+  # To support syntax differences with keyword and positional arguments starting
+  # with ruby 2.7, we have to set up the initializer with some slightly
+  # different syntax for the different versions.  This variance in syntax is not
+  # included in coverage reports since the branch chosen will never differ
+  # within a single ruby version.  This means it is impossible for us to get
+  # 100% coverage of this line within a single CI run.
+  #
+  # See
+  # [this article](https://www.ruby-lang.org/en/news/2019/12/12/separation-of-positional-and-keyword-arguments-in-ruby-3-0/)
+  # for more information.
+  #
+  # :nocov:
+  all_args = RUBY_VERSION < "2.7" ? "*" : "..."
+  # :nocov:
+  class_eval <<-END_OF_METHOD, __FILE__, __LINE__ + 1
+    # On Ruby 2.7 or greater:
+    #
+    # def initialize(...)
+    #   MemoWise::InternalAPI.create_memo_wise_state!(self)
+    #   super
+    # end
+    #
+    # On Ruby 2.6 or lower:
+    #
+    # def initialize(*)
+    #   MemoWise::InternalAPI.create_memo_wise_state!(self)
+    #   super
+    # end
+
+    def initialize(#{all_args})
+      MemoWise::InternalAPI.create_memo_wise_state!(self)
+      super
     end
-  end
-
-  # @private
-  #
-  # Determine whether `method` takes any *keyword* args.
-  #
-  # These are the types of keyword args:
-  #
-  #   * *Keyword Required* -- ex: `def foo(a:)`
-  #   * *Keyword Optional* -- ex: `def foo(b: 1)`
-  #   * *Keyword Splatted* -- ex: `def foo(**c)`
-  #
-  # @param method [Method, UnboundMethod]
-  #   Arguments of this method will be checked
-  #
-  # @return [Boolean]
-  #   Return `true` if `method` accepts one or more keyword arguments
-  #
-  # @example
-  #   class Example
-  #     def position_args(a, b=1)
-  #     end
-  #
-  #     def keyword_args(a:, b: 1)
-  #     end
-  #   end
-  #
-  #   MemoWise.has_kwarg?(Example.instance_method(:position_args)) #=> false
-  #
-  #   MemoWise.has_kwarg?(Example.instance_method(:keyword_args)) #=> true
-  #
-  def self.has_kwarg?(method) # rubocop:disable Naming/PredicateName
-    method.parameters.any? do |(param, _)|
-      param == :keyreq || param == :key || param == :keyrest # rubocop:disable Style/MultipleComparison
-    end
-  end
-
-  # @private
-  #
-  # Returns visibility of an instance method defined on a class.
-  #
-  # @param klass [Class]
-  #   Class in which to find the visibility of an existing *instance* method.
-  #
-  # @param method_name [Symbol]
-  #   Name of existing *instance* method find the visibility of.
-  #
-  # @return [:private, :protected, :public]
-  #   Visibility of existing instance method of the class.
-  #
-  # @raise ArgumentError
-  #   Raises `ArgumentError` unless `method_name` is a `Symbol` corresponding
-  #   to an existing **instance** method defined on `klass`.
-  #
-  def self.method_visibility(klass, method_name)
-    if klass.private_method_defined?(method_name)
-      :private
-    elsif klass.protected_method_defined?(method_name)
-      :protected
-    elsif klass.public_method_defined?(method_name)
-      :public
-    else
-      raise ArgumentError, "#{method_name.inspect} must be a method on #{klass}"
-    end
-  end
-
-  # @private
-  #
-  # Find the original class for which the given class is the corresponding
-  # "singleton class".
-  #
-  # See https://stackoverflow.com/questions/54531270/retrieve-a-ruby-object-from-its-singleton-class
-  #
-  # @param klass [Class]
-  #   Singleton class to find the original class of
-  #
-  # @return Class
-  #   Original class for which `klass` is the singleton class.
-  #
-  # @raise ArgumentError
-  #   Raises if `klass` is not a singleton class.
-  #
-  def self.original_class_from_singleton(klass)
-    unless klass.singleton_class?
-      raise ArgumentError, "Must be a singleton class: #{klass.inspect}"
-    end
-
-    # 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(Class).find { |cls| cls.singleton_class == klass }
-  end
-
-  # @private
-  #
-  # Create initial mutable state to store memoized values if it doesn't
-  # already exist
-  #
-  # @param [Object] obj
-  #   Object in which to create mutable state to store future memoized values
-  #
-  # @return [Object] the passed-in obj
-  def self.create_memo_wise_state!(obj)
-    unless obj.instance_variables.include?(:@_memo_wise)
-      obj.instance_variable_set(
-        :@_memo_wise,
-        Hash.new { |h, k| h[k] = {} }
-      )
-    end
-
-    obj
-  end
+  END_OF_METHOD
 
   # @private
   #
@@ -205,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)
@@ -221,21 +107,38 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
       # `Class#allocate`, so we need to override both.
       #
       def allocate
-        MemoWise.create_memo_wise_state!(super)
+        MemoWise::InternalAPI.create_memo_wise_state!(super)
       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
           method_name = method_name_or_hash
 
           if klass.singleton_class?
-            MemoWise.create_memo_wise_state!(
-              MemoWise.original_class_from_singleton(klass)
+            MemoWise::InternalAPI.create_memo_wise_state!(
+              MemoWise::InternalAPI.original_class_from_singleton(klass)
             )
           end
+
+          # Ensures a module extended by another class/module still works
+          # e.g. rails `ClassMethods` module
+          if klass.is_a?(Module) && !klass.is_a?(Class)
+            # Using `extended` without `included` & `prepended`
+            # As a call to `create_memo_wise_state!` is already included in
+            # `.allocate`/`#initialize`
+            #
+            # But a module/class extending another module with memo_wise
+            # would not call `.allocate`/`#initialize` before calling methods
+            #
+            # On method call `@_memo_wise` would still be `nil`
+            # causing error when fetching cache from `@_memo_wise`
+            def klass.extended(base)
+              MemoWise::InternalAPI.create_memo_wise_state!(base)
+            end
+          end
         when Hash
           unless method_name_or_hash.keys == [:self]
             raise ArgumentError,
@@ -244,7 +147,7 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
 
           method_name = method_name_or_hash[:self]
 
-          MemoWise.create_memo_wise_state!(self)
+          MemoWise::InternalAPI.create_memo_wise_state!(self)
 
           # In Ruby, "class methods" are implemented as normal instance methods
           # on the "singleton class" of a given Class object, found via
@@ -253,66 +156,84 @@ 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"
-        end
+        raise ArgumentError, "#{method_name.inspect} must be a Symbol" unless method_name.is_a?(Symbol)
 
-        visibility = MemoWise.method_visibility(klass, method_name)
+        api = MemoWise::InternalAPI.new(klass)
+        visibility = api.method_visibility(method_name)
+        original_memo_wised_name = MemoWise::InternalAPI.original_memo_wised_name(method_name)
         method = klass.instance_method(method_name)
 
-        original_memo_wised_name = :"_memo_wise_original_#{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?
+        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
-            # def foo
-            #   @_memo_wise.fetch(:foo}) do
-            #     @_memo_wise[:foo] = _memo_wise_original_foo
-            #   end
-            # end
-
             def #{method_name}
-              @_memo_wise.fetch(:#{method_name}) do
-                @_memo_wise[:#{method_name}] = #{original_memo_wised_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}
               end
             end
           END_OF_METHOD
-        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 or **kwargs when they are used in
-          # the method, we can avoid allocating unnecessary arrays and hashes.
-          has_arg = MemoWise.has_arg?(method)
-
-          if has_arg && MemoWise.has_kwarg?(method)
-            args_str = "(*args, **kwargs)"
-            fetch_key = "[args, kwargs].freeze"
-          elsif has_arg
-            args_str = "(*args)"
-            fetch_key = "args"
-          else
-            args_str = "(**kwargs)"
-            fetch_key = "kwargs"
-          end
+        when MemoWise::InternalAPI::ONE_REQUIRED_POSITIONAL, MemoWise::InternalAPI::ONE_REQUIRED_KEYWORD
+          key = method.parameters.first.last
 
-          # Note that we don't need to freeze args before using it as a hash key
-          # because Ruby always copies argument arrays when splatted.
           klass.module_eval <<-END_OF_METHOD, __FILE__, __LINE__ + 1
-            # def foo(*args, **kwargs)
-            #   hash = @_memo_wise[:foo]
-            #   hash.fetch([args, kwargs].freeze) do
-            #     hash[[args, kwargs].freeze] = _memo_wise_original_foo(*args, **kwargs)
-            #   end
-            # end
-
-            def #{method_name}#{args_str}
-              hash = @_memo_wise[:#{method_name}]
-              hash.fetch(#{fetch_key}) do
-                hash[#{fetch_key}] = #{original_memo_wised_name}#{args_str}
+            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
+          END_OF_METHOD
+        # 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
+            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
           END_OF_METHOD
@@ -321,6 +242,52 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
         klass.send(visibility, method_name)
       end
     end
+
+    unless target.singleton_class?
+      # Create class methods to implement .preset_memo_wise and .reset_memo_wise
+      %i[preset_memo_wise reset_memo_wise].each do |method_name|
+        # Like calling 'module_function', but original method stays public
+        target.define_singleton_method(
+          method_name,
+          MemoWise.instance_method(method_name)
+        )
+      end
+
+      # Override [Module#instance_method](https://ruby-doc.org/core-3.0.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,
+      # because our overridden `#initialize` method, and in some cases the
+      # generated memoized methods, will have a generic set of parameters
+      # (`...` 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)
+
+        super.tap do |curr_method|
+          # Start with calling the original `instance_method` on `symbol`,
+          # which returns an `UnboundMethod`.
+          #   IF it was replaced by MemoWise,
+          #   THEN find the original method's parameters, and modify current
+          #        `UnboundMethod#parameters` to return them.
+          if symbol == :initialize
+            # For `#initialize` - because `prepend MemoWise` overrides the same
+            # method in the module ancestors, use `UnboundMethod#super_method`
+            # to find the original method.
+            orig_method = curr_method.super_method
+            orig_params = orig_method.parameters
+            curr_method.define_singleton_method(:parameters) { orig_params }
+          elsif private_method_defined?(original_memo_wised_name)
+            # For any memoized method - because the original method was renamed,
+            # call the original `instance_method` again to find the renamed
+            # original method.
+            orig_method = super(original_memo_wised_name)
+            orig_params = orig_method.parameters
+            curr_method.define_singleton_method(:parameters) { orig_params }
+          end
+        end
+      end
+    end
   end
 
   ##
@@ -361,6 +328,66 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
   #     ex.method_to_memoize("b") #=> 2
   ##
 
+  ##
+  # @!method self.preset_memo_wise(method_name, *args, **kwargs)
+  #   Implementation of {#preset_memo_wise} for class methods.
+  #
+  #   @example
+  #     class Example
+  #       prepend MemoWise
+  #
+  #       def self.method_called_times
+  #         @method_called_times
+  #       end
+  #
+  #       def self.method_to_preset
+  #         @method_called_times = (@method_called_times || 0) + 1
+  #         "A"
+  #       end
+  #       memo_wise self: :method_to_preset
+  #     end
+  #
+  #     Example.preset_memo_wise(:method_to_preset) { "B" }
+  #
+  #     Example.method_to_preset #=> "B"
+  #
+  #     Example.method_called_times #=> nil
+  ##
+
+  ##
+  # @!method self.reset_memo_wise(method_name = nil, *args, **kwargs)
+  #   Implementation of {#reset_memo_wise} for class methods.
+  #
+  #   @example
+  #     class Example
+  #       prepend MemoWise
+  #
+  #       def self.method_to_reset(x)
+  #         @method_called_times = (@method_called_times || 0) + 1
+  #       end
+  #       memo_wise self: :method_to_reset
+  #     end
+  #
+  #     Example.method_to_reset("a") #=> 1
+  #     Example.method_to_reset("a") #=> 1
+  #     Example.method_to_reset("b") #=> 2
+  #     Example.method_to_reset("b") #=> 2
+  #
+  #     Example.reset_memo_wise(:method_to_reset, "a") # reset "method + args" mode
+  #
+  #     Example.method_to_reset("a") #=> 3
+  #     Example.method_to_reset("a") #=> 3
+  #     Example.method_to_reset("b") #=> 2
+  #     Example.method_to_reset("b") #=> 2
+  #
+  #     Example.reset_memo_wise(:method_to_reset) # reset "method" (any args) mode
+  #
+  #     Example.method_to_reset("a") #=> 4
+  #     Example.method_to_reset("b") #=> 5
+  #
+  #     Example.reset_memo_wise # reset "all methods" mode
+  ##
+
   # Presets the memoized result for the given method to the result of the given
   # block.
   #
@@ -373,7 +400,7 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
   # valid for the given method.
   #
   # @param method_name [Symbol]
-  #   Name of a method previously setup with `#memo_wise`.
+  #   Name of a method previously set up with `#memo_wise`.
   #
   # @param args [Array]
   #   (Optional) If the method takes positional args, these are the values of
@@ -412,19 +439,35 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
   #   ex.method_called_times #=> nil
   #
   def preset_memo_wise(method_name, *args, **kwargs)
-    validate_memo_wised!(method_name)
+    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)
 
-    unless block_given?
-      raise ArgumentError,
-            "Pass a block as the value to preset for #{method_name}, #{args}"
+    method = method(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
+      return
     end
 
-    validate_params!(method_name, args)
+    hash = (@_memo_wise[index] ||= {})
 
-    if method(method_name).arity.zero?
-      @_memo_wise[method_name] = yield
-    else
-      @_memo_wise[method_name][fetch_key(method_name, *args, **kwargs)] = yield
+    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
 
@@ -449,7 +492,7 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
   # - Resets all memoized results of calling *all methods*.
   #
   # @param method_name [Symbol, nil]
-  #   (Optional) Name of a method previously setup with `#memo_wise`. If not
+  #   (Optional) Name of a method previously set up with `#memo_wise`. If not
   #   given, will reset *all* memoized results for *all* methods.
   #
   # @param args [Array]
@@ -476,7 +519,6 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
   #
   #   ex.method_to_reset("a") #=> 1
   #   ex.method_to_reset("a") #=> 1
-  #
   #   ex.method_to_reset("b") #=> 2
   #   ex.method_to_reset("b") #=> 2
   #
@@ -484,7 +526,6 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
   #
   #   ex.method_to_reset("a") #=> 3
   #   ex.method_to_reset("a") #=> 3
-  #
   #   ex.method_to_reset("b") #=> 2
   #   ex.method_to_reset("b") #=> 2
   #
@@ -497,59 +538,65 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
   #
   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
-
-      return @_memo_wise.clear
-    end
+      raise ArgumentError, "Provided args when method_name = nil" unless args.empty?
+      raise ArgumentError, "Provided kwargs when method_name = nil" unless kwargs.empty?
 
-    unless method_name.is_a?(Symbol)
-      raise ArgumentError, "#{method_name.inspect} must be a Symbol"
+      @_memo_wise.clear
+      @_memo_wise_sentinels.clear
+      return
     end
 
-    unless respond_to?(method_name, true)
-      raise ArgumentError, "#{method_name} is not a defined method"
-    end
-
-    validate_memo_wised!(method_name)
-
-    if args.empty? && kwargs.empty?
-      @_memo_wise.delete(method_name)
-    else
-      @_memo_wise[method_name].delete(fetch_key(method_name, *args, **kwargs))
-    end
-  end
-
-  private
-
-  # Validates that {.memo_wise} has already been called on `method_name`.
-  def validate_memo_wised!(method_name)
-    original_memo_wised_name = :"_memo_wise_original_#{method_name}"
-
-    unless self.class.private_method_defined?(original_memo_wised_name)
-      raise ArgumentError, "#{method_name} is not a memo_wised method"
-    end
-  end
-
-  # Returns arguments key to lookup memoized results for given `method_name`.
-  def fetch_key(method_name, *args, **kwargs)
-    method = self.class.instance_method(method_name)
-    has_arg = MemoWise.has_arg?(method)
-
-    if has_arg && MemoWise.has_kwarg?(method)
-      [args, kwargs].freeze
-    elsif has_arg
-      args
-    else
-      kwargs
+    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)
+
+    method = method(method_name)
+    method_arguments = MemoWise::InternalAPI.method_arguments(method)
+    index = api.index(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
+    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
+              end
+        @_memo_wise[index]&.delete(key)
+      end
     end
   end
-
-  # TODO: Parameter validation for presetting values
-  def validate_params!(method_name, args); end
 end