memo_wise 0.4.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 634bee32d07ccd97dc7670c67521a4091ebc0df0deae1479cc054aaa7a246e6c
-  data.tar.gz: 59523369b3373389481388962039486b4f0f5cf002d24091ad2244048f100bbc
+  metadata.gz: e4c330faa7d0718ac3b4873dae8fb1933949481747f639fd6fe050724a2ce8dd
+  data.tar.gz: 52777a008d6b5b41a37cec36f1b9fe0198b85df97fb11329d73bac71ad22b600
 SHA512:
-  metadata.gz: 3896bf8b001ad52afda6b14c5170d902d85a88c9faaa60d6c9097a01045e0ef90a379c130834b2a2fcbec356b51346f975fc96493dcb3d3c04943200eb7274a3
-  data.tar.gz: 72718456d986ed21d593a6a99117ee74a0a385f94ba0b1a00fadb38cbad977202cea5d8e32325bdaa2e5eb273808a52ca9d62997cd927a6a98ffd31174bdcc6f
+  metadata.gz: 17a0e939940e73826fbca1876317bcd772e1cd07f16383a9d3e9c973c2545b4b8539c42110de98d8a8c8c4c4a4aa6a666b29cc40c6351001b2b9a7c6964918a3
+  data.tar.gz: fd4a09fe2dab6dbae43fae753c15530982d1cc26c0ef7b47cdff40f0bff603d7c7c9d0c7d0509b7eb98c0e15b2bd2ca7c005900a00d97201e44a9fd49603d4b0

data/.dokaz

@@ -0,0 +1,2 @@
+README.md
+--require ./spec/dokaz_helpers.rb

data/.github/dependabot.yml

@@ -0,0 +1,20 @@
+version: 2
+
+updates:
+  # Maintain dependencies for Ruby's Bundler
+  - package-ecosystem: bundler
+    directory: "/"
+    schedule:
+      interval: daily
+
+  # Maintain dependencies for Ruby's Bundler (for Benchmarks!)
+  - package-ecosystem: bundler
+    directory: "/benchmarks"
+    schedule:
+      interval: daily
+
+  # Maintain dependencies for GitHub Actions
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "daily"

data/.github/workflows/main.yml

@@ -15,26 +15,34 @@ jobs:
         ruby: [jruby, 2.4, 2.5, 2.6, 2.7, 3.0]
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@main
+    - uses: actions/checkout@v2
+
+    # Conditionally configure bundler via environment variables as advised
+    #   * https://github.com/ruby/setup-ruby#bundle-config
+    - name: Set bundler environment variables
+      run: |
+        echo "BUNDLE_WITHOUT=checks:docs" >> $GITHUB_ENV
+      if: matrix.ruby != 3.0
+
+    # Use 'bundler-cache: true' instead of actions/cache as advised:
+    #   * https://github.com/actions/cache/blob/main/examples.md#ruby---bundler
     - uses: ruby/setup-ruby@v1
       with:
         ruby-version: ${{ matrix.ruby }}
-    - uses: actions/cache@v1
-      with:
-        path: vendor/bundle
-        key: ${{ runner.os }}-gems-${{ hashFiles('**/Gemfile.lock') }}
-        restore-keys: |
-          ${{ runner.os }}-gems-
-    - run: bundle config path vendor/bundle
-    - run: bundle config set without 'checks:docs'
-      if: matrix.ruby != 3.0
-    - run: bundle install --jobs 4 --retry 3
+        bundler-cache: true
+
     - run: bundle exec rspec
+
     - run: bundle exec rubocop
       if: matrix.ruby == 3.0
-    - run: bundle exec yard doctest
-      if: matrix.ruby == 3.0
+
     - run: |
+        bundle exec yard doctest
+        bundle exec dokaz
+      if: matrix.ruby == 3.0
+
+    - name: Run benchmarks on Ruby 2.7 or 3.0
+      run: |
         BUNDLE_GEMFILE=benchmarks/Gemfile bundle install --jobs 4 --retry 3
         BUNDLE_GEMFILE=benchmarks/Gemfile bundle exec ruby benchmarks/benchmarks.rb
       if: matrix.ruby == '2.7' || matrix.ruby == '3.0'

data/CHANGELOG.md

@@ -8,6 +8,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 (nothing yet!)
 
+## [1.0.0] - 2021-06-24
+### Added
+- Support for `.preset_memo_wise` on class methods
+- Support for `.reset_memo_wise` on class methods
+### Updated
+- Improved performance for common cases by reducing array allocations
+
 ## [0.4.0] - 2021-04-30
 ### Added
 - Documentation of confusing module test behavior
@@ -54,7 +61,8 @@ 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/v0.4.0...HEAD
+[Unreleased]: https://github.com/panorama-ed/memo_wise/compare/v1.0.0...HEAD
+[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
 [0.3.0]: https://github.com/panorama-ed/memo_wise/compare/v0.2.0...v0.3.0
 [0.2.0]: https://github.com/panorama-ed/memo_wise/compare/v0.1.2...v0.2.0

data/Gemfile

@@ -19,6 +19,7 @@ end
 
 # Excluded from CI except on latest MRI Ruby, to reduce compatibility burden
 group :docs do
+  gem "dokaz"
   gem "redcarpet", "~> 3.5"
   gem "yard", "~> 0.9"
   gem "yard-doctest", "~> 0.1"

data/Gemfile.lock

@@ -1,6 +1,6 @@
 GIT
   remote: https://github.com/panorama-ed/panolint.git
-  revision: e2f76aa2482f02e68826eb8643a41998a09fc7ab
+  revision: 6f38f73dafdc25370ecc367dc87d7e6340ae664d
   branch: main
   specs:
     panolint (0.1.3)
@@ -14,28 +14,33 @@ GIT
 PATH
   remote: .
   specs:
-    memo_wise (0.4.0)
+    memo_wise (1.0.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (5.2.5)
+    activesupport (5.2.6)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
+    ansi (1.5.0)
     ast (2.4.2)
-    brakeman (5.0.0)
+    brakeman (5.0.4)
     codecov (0.5.2)
       simplecov (>= 0.15, < 0.22)
-    concurrent-ruby (1.1.8)
+    concurrent-ruby (1.1.9)
     diff-lcs (1.4.4)
     docile (1.3.5)
+    dokaz (0.0.4)
+      ansi
+      rouge
+      slop (~> 3)
     i18n (1.8.10)
       concurrent-ruby (~> 1.0)
     minitest (5.14.4)
     parallel (1.20.1)
-    parser (3.0.1.0)
+    parser (3.0.1.1)
       ast (~> 2.4.1)
     rack (2.2.3)
     rainbow (3.0.0)
@@ -43,6 +48,7 @@ GEM
     redcarpet (3.5.1)
     regexp_parser (2.1.1)
     rexml (3.2.5)
+    rouge (3.26.0)
     rspec (3.10.0)
       rspec-core (~> 3.10.0)
       rspec-expectations (~> 3.10.0)
@@ -84,6 +90,7 @@ GEM
       docile (~> 1.1)
       simplecov-html (~> 0.11)
     simplecov-html (0.12.3)
+    slop (3.6.0)
     thread_safe (0.3.6)
     tzinfo (1.2.9)
       thread_safe (~> 0.1)
@@ -99,6 +106,7 @@ PLATFORMS
 
 DEPENDENCIES
   codecov
+  dokaz
   memo_wise!
   panolint!
   rake

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2020 Panorama Education
+Copyright (c) 2020-2021 Panorama Education
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -50,6 +50,7 @@ methods:
 ```ruby
 class Example
   prepend MemoWise
+
   def slow_value(x)
     sleep x
     x
@@ -71,7 +72,31 @@ ex.slow_value(3) # => 4 # Returns immediately because the result is memoized
 ex.reset_memo_wise # Resets all memoized results for all methods on ex
 ```
 
-Methods which take implicit or explicit block arguments cannot be memoized.
+The same three methods are exposed for class methods as well:
+
+```ruby
+class Example
+  prepend MemoWise
+
+  def self.class_slow_value(x)
+    sleep x
+    x
+  end
+  memo_wise self: :class_slow_value
+end
+
+Example.class_slow_value(2) # => 2 # Sleeps for 2 seconds before returning
+Example.class_slow_value(2) # => 2 # Returns immediately because the result is memoized
+
+Example.reset_memo_wise(:class_slow_value) # Resets all memoized results for class_slow_value
+
+Example.preset_memo_wise(:class_slow_value, 3) { 4 } # Store 4 as the result for slow_value(3)
+Example.class_slow_value(3) # => 4 # Returns immediately because the result is memoized
+Example.reset_memo_wise # Resets all memoized results for all methods on class
+```
+
+**NOTE:** Methods which take implicit or explicit block arguments cannot be
+memoized.
 
 For more usage details, see our detailed [documentation](#documentation).
 
@@ -79,21 +104,26 @@ For more usage details, see our detailed [documentation](#documentation).
 
 Benchmarks measure memoized value retrieval time using
 [`benchmark-ips`](https://github.com/evanphx/benchmark-ips). All benchmarks are
-run on Ruby 3.0.0, except as indicated below for specific gems. Benchmarks are
+run on Ruby 3.0.1, except as indicated below for specific gems. Benchmarks are
 run in GitHub Actions and updated in every PR that changes code.
 
-|Method arguments|**`memo_wise` (0.1.0)**|`memery` (1.3.0)|`memoist`\* (0.16.2)|`memoized`\* (1.0.2)|`memoizer`\* (1.0.3)|
-|--|--|--|--|--|--|
-|`()` (none)|**baseline**|13.17x slower|2.85x slower|1.30x slower|3.05x slower|
-|`(a, b)`|**baseline**|1.93x slower|2.20x slower|1.97x slower|1.86x slower|
-|`(a:, b:)`|**baseline**|3.05x slower|2.34x slower|2.27x slower|2.14x slower|
-|`(a, b:)`|**baseline**|1.50x slower|1.63x slower|1.56x slower|1.48x slower|
-|`(a, *args)`|**baseline**|1.91x slower|2.13x slower|1.90x slower|1.88x slower|
-|`(a:, **kwargs)`|**baseline**|3.08x slower|2.37x slower|2.24x slower|2.09x slower|
-|`(a, *args, b:, **kwargs)`|**baseline**|1.72x slower|1.61x slower|1.56x slower|1.67x slower|
+**Values >1.00x represent how much _slower_ each gem’s memoized value retrieval
+is than the latest commit of `memo_wise`.**
 
-_\*Indicates a benchmark run on Ruby 2.7.2 because the gem raises errors in Ruby
-3.0.0 due to its incorrect handling of keyword arguments._
+|Method arguments|`memery` (1.4.0)|`memoist`\* (0.16.2)|`memoized`\* (1.0.2)|`memoizer`\* (1.0.3)|
+|--|--|--|--|--|
+|`()` (none)|13.17x|2.64x|1.46x|3.10x|
+|`(a)`|9.76x|15.44x|11.98x|13.12x|
+|`(a, b)`|1.98x|2.25x|1.82x|1.98x|
+|`(a:)`|17.65x|23.64x|20.69x|21.61x|
+|`(a:, b:)`|4.16x|3.94x|3.53x|3.67x|
+|`(a, b:)`|3.96x|3.72x|3.27x|3.42x|
+|`(a, *args)`|1.93x|2.25x|1.93x|1.95x|
+|`(a:, **kwargs)`|3.06x|2.38x|2.10x|2.20x|
+|`(a, *args, b:, **kwargs)`|1.52x|1.79x|1.65x|1.65x|
+
+_\*Indicates a benchmark run on Ruby 2.7.3 because the gem raises errors in Ruby
+3.0.1 due to its incorrect handling of keyword arguments._
 
 You can run benchmarks yourself with:
 
@@ -106,18 +136,6 @@ $ bundle exec ruby benchmarks.rb
 If your results differ from what's posted here,
 [let us know](https://github.com/panorama-ed/memo_wise/issues/new)!
 
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run
-`rake spec` to run the tests. You can also run `bin/console` for an interactive
-prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To
-release a new version, update the version number in `version.rb`, and then run
-`bundle exec rake release`, which will create a git tag for the version, push
-git commits and tags, and push the `.gem` file to
-[rubygems.org](https://rubygems.org).
-
 ## Documentation
 
 ### Documentation is Automatically Generated
@@ -140,6 +158,14 @@ code examples in our YARD documentation. To run `doctest` locally:
 bundle exec yard doctest
 ```
 
+We use [dokaz](https://github.com/zverok/dokaz) to test all code examples in
+this README.md file, and all other non-code documentation. To run `dokaz`
+locally:
+
+```bash
+bundle exec dokaz
+```
+
 ### A Note on Testing
 
 When testing memoized *module* methods, note that some testing setups will
@@ -180,7 +206,7 @@ To make a new release of `MemoWise` to
 dependencies (e.g. `rake`) as follows:
 
 ```shell
-bundle config set --local with 'release'
+bundle config --local with 'release'
 bundle install
 ```
 

data/benchmarks/Gemfile

@@ -4,10 +4,10 @@ source "https://rubygems.org"
 
 ruby ">= 2.7.2"
 
-gem "benchmark-ips", "2.8.4"
+gem "benchmark-ips", "2.9.1"
 
 if RUBY_VERSION > "3"
-  gem "memery", "1.3.0"
+  gem "memery", "1.4.0"
 else
   gem "memoist", "0.16.2"
   gem "memoized", "1.0.2"

data/benchmarks/Gemfile.lock

@@ -1,23 +1,26 @@
 PATH
   remote: ..
   specs:
-    memo_wise (0.3.0)
+    memo_wise (0.4.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    benchmark-ips (2.8.4)
-    memery (1.3.0)
-      ruby2_keywords (~> 0.0.2)
-    ruby2_keywords (0.0.4)
+    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.8.4)
-  memery (= 1.3.0)
+  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

data/benchmarks/benchmarks.rb

@@ -68,11 +68,21 @@ BENCHMARK_GEMS.each do |benchmark_gem|
       end
       #{benchmark_gem.memoization_method} :no_args
 
+      def one_positional_arg(a)
+        100
+      end
+      #{benchmark_gem.memoization_method} :one_positional_arg
+
       def positional_args(a, b)
         100
       end
       #{benchmark_gem.memoization_method} :positional_args
 
+      def one_keyword_arg(a:)
+        100
+      end
+      #{benchmark_gem.memoization_method} :one_keyword_arg
+
       def keyword_args(a:, b:)
         100
       end
@@ -126,6 +136,23 @@ Benchmark.ips do |x|
   x.compare!
 end
 
+Benchmark.ips do |x|
+  x.config(suite: suite)
+  BENCHMARK_GEMS.each do |benchmark_gem|
+    instance = Object.const_get("#{benchmark_gem.klass}Example").new
+
+    # Run once with each set of arguments to memoize the result values, so our
+    # benchmark only tests memoized retrieval time.
+    ARGUMENTS.each { |a, _| instance.one_positional_arg(a) }
+
+    x.report("#{benchmark_gem.benchmark_name}: (a)") do
+      ARGUMENTS.each { |a, _| instance.one_positional_arg(a) }
+    end
+  end
+
+  x.compare!
+end
+
 Benchmark.ips do |x|
   x.config(suite: suite)
   BENCHMARK_GEMS.each do |benchmark_gem|
@@ -143,6 +170,23 @@ Benchmark.ips do |x|
   x.compare!
 end
 
+Benchmark.ips do |x|
+  x.config(suite: suite)
+  BENCHMARK_GEMS.each do |benchmark_gem|
+    instance = Object.const_get("#{benchmark_gem.klass}Example").new
+
+    # Run once with each set of arguments to memoize the result values, so our
+    # benchmark only tests memoized retrieval time.
+    ARGUMENTS.each { |a, _| instance.one_keyword_arg(a: a) }
+
+    x.report("#{benchmark_gem.benchmark_name}: (a:)") do
+      ARGUMENTS.each { |a, _| instance.one_keyword_arg(a: a) }
+    end
+  end
+
+  x.compare!
+end
+
 Benchmark.ips do |x|
   x.config(suite: suite)
   BENCHMARK_GEMS.each do |benchmark_gem|

data/lib/memo_wise.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "memo_wise/internal_api"
 require "memo_wise/version"
 
 # MemoWise is the wise choice for memoization in Ruby.
@@ -57,167 +58,23 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
     # On Ruby 2.7 or greater:
     #
     # def initialize(...)
-    #   MemoWise.create_memo_wise_state!(self)
+    #   MemoWise::InternalAPI.create_memo_wise_state!(self)
     #   super
     # end
     #
     # On Ruby 2.6 or lower:
     #
     # def initialize(*)
-    #   MemoWise.create_memo_wise_state!(self)
+    #   MemoWise::InternalAPI.create_memo_wise_state!(self)
     #   super
     # end
 
     def initialize(#{all_args})
-      MemoWise.create_memo_wise_state!(self)
+      MemoWise::InternalAPI.create_memo_wise_state!(self)
       super
     end
   END_OF_METHOD
 
-  # @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
-    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, {})
-    end
-
-    obj
-  end
-
   # @private
   #
   # Private setup method, called automatically by `prepend MemoWise` in a class.
@@ -248,7 +105,7 @@ 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!
@@ -259,8 +116,8 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
           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
         when Hash
@@ -271,7 +128,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
@@ -284,10 +141,12 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
           raise ArgumentError, "#{method_name.inspect} must be a Symbol"
         end
 
-        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)
 
@@ -308,22 +167,39 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
             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"
+          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
           else
-            args_str = "(**kwargs)"
-            fetch_key = "kwargs"
+            # 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"
+            end
           end
 
           # Note that we don't need to freeze args before using it as a hash key
@@ -343,7 +219,7 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
                 @_memo_wise[:#{method_name}] = {}
               end
               hash.fetch(#{fetch_key}) do
-                hash[#{fetch_key}] = #{original_memo_wised_name}#{args_str}
+                hash[#{fetch_key}] = #{original_memo_wised_name}#{call_str || args_str}
               end
             end
           END_OF_METHOD
@@ -352,6 +228,53 @@ 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)
+        # TODO: Extract this method naming pattern
+        original_memo_wised_name = :"_memo_wise_original_#{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
 
   ##
@@ -392,6 +315,68 @@ 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
+  ##
+
+  # rubocop:disable Layout/LineLength
+  ##
+  # @!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
+  ##
+  # rubocop:enable Layout/LineLength
+
   # Presets the memoized result for the given method to the result of the given
   # block.
   #
@@ -443,14 +428,13 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
   #   ex.method_called_times #=> nil
   #
   def preset_memo_wise(method_name, *args, **kwargs)
-    validate_memo_wised!(method_name)
-
     unless block_given?
       raise ArgumentError,
             "Pass a block as the value to preset for #{method_name}, #{args}"
     end
 
-    validate_params!(method_name, args)
+    api = MemoWise::InternalAPI.new(self)
+    api.validate_memo_wised!(method_name)
 
     if method(method_name).arity.zero?
       @_memo_wise[method_name] = yield
@@ -458,7 +442,7 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
       hash = @_memo_wise.fetch(method_name) do
         @_memo_wise[method_name] = {}
       end
-      hash[fetch_key(method_name, *args, **kwargs)] = yield
+      hash[api.fetch_key(method_name, *args, **kwargs)] = yield
     end
   end
 
@@ -510,7 +494,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
   #
@@ -518,7 +501,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
   #
@@ -550,40 +532,14 @@ module MemoWise # rubocop:disable Metrics/ModuleLength
       raise ArgumentError, "#{method_name} is not a defined method"
     end
 
-    validate_memo_wised!(method_name)
+    api = MemoWise::InternalAPI.new(self)
+    api.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))
+      @_memo_wise[method_name]&.
+        delete(api.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
-    end
-  end
-
-  # TODO: Parameter validation for presetting values
-  def validate_params!(method_name, args); end
 end