memo_wise 1.0.0 → 1.4.0

data/lib/memo_wise.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "set"
+
 require "memo_wise/internal_api"
 require "memo_wise/version"
 
@@ -23,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.
@@ -54,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(...)
@@ -73,7 +75,7 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
       MemoWise::InternalAPI.create_memo_wise_state!(self)
       super
     end
-  END_OF_METHOD
+  HEREDOC
 
   # @private
   #
@@ -89,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)
@@ -109,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
@@ -120,6 +122,23 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
               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,
@@ -137,92 +156,159 @@ 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
-            # 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}
+        method_arguments = MemoWise::InternalAPI.method_arguments(method)
+
+        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.send(:define_method, method_name) do # Ruby 2.4's `define_method` is private in some cases
+            index = MemoWise::InternalAPI.index(self, method_name)
+            klass.module_eval <<~HEREDOC, __FILE__, __LINE__ + 1
+              def #{method_name}
+                if @_memo_wise_sentinels[#{index}]
+                  @_memo_wise[#{index}]
+                else
+                  ret = @_memo_wise[#{index}] = #{original_memo_wised_name}
+                  @_memo_wise_sentinels[#{index}] = true
+                  ret
+                end
               end
+            HEREDOC
+
+            klass.send(visibility, method_name)
+            send(method_name)
+          end
+        when MemoWise::InternalAPI::ONE_REQUIRED_POSITIONAL, MemoWise::InternalAPI::ONE_REQUIRED_KEYWORD
+          key = method.parameters.first.last
+          # NOTE: Ruby 2.6 and below, and TruffleRuby 3.0, break when we use
+          # `define_method(...) do |*args, **kwargs|`. Instead we must use the
+          # simpler `|*args|` pattern. We can't just do this always though
+          # because Ruby 2.7 and above require `|*args, **kwargs|` to work
+          # correctly.
+          # See: https://blog.saeloun.com/2019/10/07/ruby-2-7-keyword-arguments-redesign.html#ruby-26
+          # :nocov:
+          if RUBY_VERSION < "2.7" || RUBY_ENGINE == "truffleruby"
+            klass.send(:define_method, method_name) do |*args| # Ruby 2.4's `define_method` is private in some cases
+              index = MemoWise::InternalAPI.index(self, method_name)
+              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[#{key}] = #{original_memo_wised_name}(#{MemoWise::InternalAPI.call_str(method)})
+                  end
+                end
+              HEREDOC
+
+              klass.send(visibility, method_name)
+              send(method_name, *args)
             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 = method.parameters.map(&:last)
-            fetch_key = if fetch_key.size > 1
-                          "[#{fetch_key.join(', ')}].freeze"
-                        else
-                          fetch_key.first.to_s
-                        end
+            # :nocov:
           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 = "[args, kwargs].freeze"
-            elsif has_arg
-              args_str = "(*args)"
-              fetch_key = "args"
-            else
-              args_str = "(**kwargs)"
-              fetch_key = "kwargs"
+            klass.define_method(method_name) do |*args, **kwargs|
+              index = MemoWise::InternalAPI.index(self, method_name)
+              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[#{key}] = #{original_memo_wised_name}(#{MemoWise::InternalAPI.call_str(method)})
+                  end
+                end
+              HEREDOC
+
+              klass.send(visibility, method_name)
+              send(method_name, *args, **kwargs)
             end
           end
-
-          # 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.fetch(:foo) do
-            #     @_memo_wise[:foo] = {}
-            #   end
-            #   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.fetch(:#{method_name}) do
-                @_memo_wise[:#{method_name}] = {}
-              end
-              hash.fetch(#{fetch_key}) do
-                hash[#{fetch_key}] = #{original_memo_wised_name}#{call_str || args_str}
-              end
+        # 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`.
+          #
+          # NOTE: Ruby 2.6 and below, and TruffleRuby 3.0, break when we use
+          # `define_method(...) do |*args, **kwargs|`. Instead we must use the
+          # simpler `|*args|` pattern. We can't just do this always though
+          # because Ruby 2.7 and above require `|*args, **kwargs|` to work
+          # correctly.
+          # See: https://blog.saeloun.com/2019/10/07/ruby-2-7-keyword-arguments-redesign.html#ruby-26
+          # :nocov:
+          if RUBY_VERSION < "2.7" || RUBY_ENGINE == "truffleruby"
+            klass.send(:define_method, method_name) do |*args| # Ruby 2.4's `define_method` is private in some cases
+              index = MemoWise::InternalAPI.index(self, method_name)
+              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)}
+                  _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
+              HEREDOC
+
+              klass.send(visibility, method_name)
+              send(method_name, *args)
+            end
+            # :nocov:
+          else # Ruby 2.7 and above break with (*args)
+            klass.define_method(method_name) do |*args, **kwargs|
+              index = MemoWise::InternalAPI.index(self, method_name)
+              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)}
+                  _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
+              HEREDOC
+
+              klass.send(visibility, method_name)
+              send(method_name, *args, **kwargs)
             end
-          END_OF_METHOD
+          end
         end
 
         klass.send(visibility, method_name)
@@ -248,8 +334,7 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
       # (`...` or `*args, **kwargs`), making reflection on method parameters
       # useless without this.
       def target.instance_method(symbol)
-        # TODO: Extract this method naming pattern
-        original_memo_wised_name = :"_memo_wise_original_#{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`,
@@ -341,7 +426,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.
@@ -375,7 +459,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.
@@ -428,21 +511,34 @@ 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}"
+    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)
+
+    method = method(MemoWise::InternalAPI.original_memo_wised_name(method_name))
+    method_arguments = MemoWise::InternalAPI.method_arguments(method)
+    index = MemoWise::InternalAPI.index(self, method_name)
+
+    if method_arguments == MemoWise::InternalAPI::NONE
+      @_memo_wise_sentinels[index] = true
+      @_memo_wise[index] = yield
+      return
     end
 
-    api = MemoWise::InternalAPI.new(self)
-    api.validate_memo_wised!(method_name)
+    hash = (@_memo_wise[index] ||= {})
 
-    if method(method_name).arity.zero?
-      @_memo_wise[method_name] = yield
-    else
-      hash = @_memo_wise.fetch(method_name) do
-        @_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[api.fetch_key(method_name, *args, **kwargs)] = yield
+      hash[key] = yield
+    else # MemoWise::InternalAPI::SPLAT_AND_DOUBLE_SPLAT
+      hash[[args, kwargs]] = yield
     end
   end
 
@@ -513,33 +609,64 @@ 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
+      raise ArgumentError, "Provided args when method_name = nil" unless args.empty?
+      raise ArgumentError, "Provided kwargs when method_name = nil" unless kwargs.empty?
 
-      unless kwargs.empty?
-        raise ArgumentError, "Provided kwargs when method_name = nil"
-      end
-
-      return @_memo_wise.clear
+      @_memo_wise.clear
+      @_memo_wise_sentinels.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)
+    index = MemoWise::InternalAPI.index(self, method_name)
 
-    if args.empty? && kwargs.empty?
-      @_memo_wise.delete(method_name)
-    else
-      @_memo_wise[method_name]&.
-        delete(api.fetch_key(method_name, *args, **kwargs))
+    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
 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.0.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Panorama Education
@@ -11,7 +11,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-06-24 00:00:00.000000000 Z
+date: 2021-12-10 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -39,9 +39,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- benchmarks/.ruby-version
 - benchmarks/Gemfile
-- benchmarks/Gemfile.lock
 - benchmarks/benchmarks.rb
 - bin/console
 - bin/setup
@@ -54,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:

data/benchmarks/.ruby-version

@@ -1 +0,0 @@
-3.0.0

data/benchmarks/Gemfile.lock

@@ -1,29 +0,0 @@
-PATH
-  remote: ..
-  specs:
-    memo_wise (0.4.0)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    benchmark-ips (2.9.1)
-    memoist (0.16.2)
-    memoized (1.0.2)
-    memoizer (1.0.3)
-
-PLATFORMS
-  x86_64-darwin-19
-  x86_64-linux
-
-DEPENDENCIES
-  benchmark-ips (= 2.9.1)
-  memo_wise!
-  memoist (= 0.16.2)
-  memoized (= 1.0.2)
-  memoizer (= 1.0.3)
-
-RUBY VERSION
-   ruby 3.0.0p0
-
-BUNDLED WITH
-   2.2.3