memo_wise 0.4.0 → 1.0.0

data/lib/memo_wise/internal_api.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+module MemoWise
+  class InternalAPI
+    # 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
+
+    # 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::InternalAPI.
+    #     has_arg?(Example.instance_method(:no_args)) #=> false
+    #
+    #   MemoWise::InternalAPI.
+    #     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
+
+    # 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::InternalAPI.
+    #     has_kwarg?(Example.instance_method(:position_args)) #=> false
+    #
+    #   MemoWise::InternalAPI.
+    #     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
+
+    # Determine whether `method` takes only *required* args.
+    #
+    # These are the types of required args:
+    #
+    #   * *Required* -- ex: `def foo(a)`
+    #   * *Keyword Required* -- ex: `def foo(a:)`
+    #
+    # @param method [Method, UnboundMethod]
+    #   Arguments of this method will be checked
+    #
+    # @return [Boolean]
+    #   Return `true` if `method` accepts only required arguments
+    #
+    # @example
+    #   class Ex
+    #     def optional_args(a=1, b: 1)
+    #     end
+    #
+    #     def required_args(a, b:)
+    #     end
+    #   end
+    #
+    #   MemoWise::InternalAPI.
+    #     has_only_required_args?(Ex.instance_method(:optional_args))
+    #     #=> false
+    #
+    #   MemoWise::InternalAPI.
+    #     has_only_required_args?(Ex.instance_method(:required_args))
+    #     #=> true
+    def self.has_only_required_args?(method) # rubocop:disable Naming/PredicateName
+      method.parameters.all? { |type, _| type == :req || type == :keyreq } # rubocop:disable Style/MultipleComparison
+    end
+
+    # 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
+
+    # Convention we use for renaming the original method when we replace with
+    # the memoized version in {MemoWise.memo_wise}.
+    #
+    # @param method_name [Symbol]
+    #   Name for which to return the renaming for the original method
+    #
+    # @return [Symbol]
+    #   Renamed method to use for the original method with name `method_name`
+    #
+    def self.original_memo_wised_name(method_name)
+      :"_memo_wise_original_#{method_name}"
+    end
+
+    # @param target [Class, Module]
+    #   The class to which we are prepending MemoWise to provide memoization;
+    #   the `InternalAPI` *instance* methods will refer to this `target` class.
+    def initialize(target)
+      @target = target
+    end
+
+    # @return [Class, Module]
+    attr_reader :target
+
+    # Returns the "fetch key" for the given `method_name` and parameters, to be
+    # used to lookup the memoized results specifically for this method and these
+    # parameters.
+    #
+    # @param method_name [Symbol]
+    #   Name of method to derive the "fetch key" for, with given parameters.
+    # @param args [Array]
+    #   Zero or more positional parameters
+    # @param kwargs [Hash]
+    #   Zero or more keyword parameters
+    #
+    # @return [Array, Hash, Object]
+    #   Returns one of:
+    #     - An `Array` if only positional parameters.
+    #     - A nested `Array<Array, Hash>` if *both* positional and keyword.
+    #     - A `Hash` if only keyword parameters.
+    #     - A single object if there is only a single parameter.
+    def fetch_key(method_name, *args, **kwargs)
+      method = target_class.instance_method(method_name)
+
+      if MemoWise::InternalAPI.has_only_required_args?(method)
+        key = method.parameters.map.with_index do |(type, name), index|
+          type == :req ? args[index] : kwargs[name]
+        end
+        key.size == 1 ? key.first : key
+      else
+        has_arg = MemoWise::InternalAPI.has_arg?(method)
+
+        if has_arg && MemoWise::InternalAPI.has_kwarg?(method)
+          [args, kwargs].freeze
+        elsif has_arg
+          args
+        else
+          kwargs
+        end
+      end
+    end
+
+    # Returns visibility of an instance method defined on class `target`.
+    #
+    # @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 method_visibility(method_name)
+      if target.private_method_defined?(method_name)
+        :private
+      elsif target.protected_method_defined?(method_name)
+        :protected
+      elsif target.public_method_defined?(method_name)
+        :public
+      else
+        raise ArgumentError,
+              "#{method_name.inspect} must be a method on #{target}"
+      end
+    end
+
+    # Validates that {.memo_wise} has already been called on `method_name`.
+    #
+    # @param method_name [Symbol]
+    #   Name of method to validate has already been setup with {.memo_wise}
+    def validate_memo_wised!(method_name)
+      original_name = self.class.original_memo_wised_name(method_name)
+
+      unless target_class.private_method_defined?(original_name)
+        raise ArgumentError, "#{method_name} is not a memo_wised method"
+      end
+    end
+
+    # @return [Class] where we look for method definitions
+    def target_class
+      if target.instance_of?(Class)
+        # A class's methods are defined in its singleton class
+        target.singleton_class
+      else
+        # An object's methods are defined in its class
+        target.class
+      end
+    end
+  end
+end

data/lib/memo_wise/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MemoWise
-  VERSION = "0.4.0"
+  VERSION = "1.0.0"
 end

data/memo_wise.gemspec

@@ -2,7 +2,7 @@
 
 require_relative "lib/memo_wise/version"
 
-Gem::Specification.new do |spec|
+Gem::Specification.new do |spec| # rubocop:disable Metrics/BlockLength
   spec.name     = "memo_wise"
   spec.version  = MemoWise::VERSION
   spec.summary  = "The wise choice for Ruby memoization"
@@ -34,4 +34,9 @@ Gem::Specification.new do |spec|
     end
   end
   spec.require_paths = ["lib"]
+
+  spec.metadata = {
+    "changelog_uri" => "https://github.com/panorama-ed/memo_wise/blob/main/CHANGELOG.md",
+    "source_code_uri" => "https://github.com/panorama-ed/memo_wise"
+  }
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: memo_wise
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Panorama Education
@@ -11,7 +11,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-30 00:00:00.000000000 Z
+date: 2021-06-24 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -23,11 +23,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".dependabot/config.yml"
+- ".dokaz"
 - ".github/PULL_REQUEST_TEMPLATE.md"
-- ".github/workflows/auto-approve-dependabot.yml"
+- ".github/dependabot.yml"
 - ".github/workflows/main.yml"
-- ".github/workflows/remove-needs-qa.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
@@ -47,13 +46,16 @@ files:
 - bin/console
 - bin/setup
 - lib/memo_wise.rb
+- lib/memo_wise/internal_api.rb
 - lib/memo_wise/version.rb
 - logo/logo.png
 - memo_wise.gemspec
 homepage: https://github.com/panorama-ed/memo_wise
 licenses:
 - MIT
-metadata: {}
+metadata:
+  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:
 rdoc_options: []
 require_paths:
@@ -69,7 +71,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.3
 signing_key:
 specification_version: 4
 summary: The wise choice for Ruby memoization

data/.dependabot/config.yml

@@ -1,13 +0,0 @@
-# Reference: https://dependabot.com/docs/config-file/
-version: 1
-update_configs:
-  - package_manager: "ruby:bundler"
-    directory: "/"
-    update_schedule: "live"
-    automerged_updates:
-      - match:
-          dependency_type: "development"
-          update_type: "all"
-  - package_manager: "ruby:bundler"
-    directory: "/benchmarks"
-    update_schedule: "live"

data/.github/workflows/auto-approve-dependabot.yml

@@ -1,26 +0,0 @@
-# This workflow auto-approves pull-requests when the github actor is a
-# dependabot user and it is opening a new pull request.
-#
-# The problem that this workflow solves is that we have branch protection on
-# our repositories that prevent PRs from merging unless there is an
-# approval present. The problem is that this will block PRs that dependabot
-# may want to merge automatically. Auto-approving dependabot PRs will allow
-# the automatic merge to complete. We control what gets automerged through
-# the dependabot configuration.
-#
-# This is a known issue: https://github.com/dependabot/feedback/issues/852
-name: Auto-approve dependabot pull requests
-on:
-  pull_request:
-    types: [opened]
-
-jobs:
-  dependabot-triage:
-    runs-on: ubuntu-latest
-    if: (github.actor == 'dependabot[bot]' || github.actor == 'dependabot-preview[bot]')
-
-    steps:
-      - name: Auto-approve for dependabot
-        uses: hmarr/auto-approve-action@v2.0.0
-        with:
-          github-token: "${{ secrets.GITHUB_TOKEN }}"

data/.github/workflows/remove-needs-qa.yml

@@ -1,35 +0,0 @@
-# This workflow removes a "Needs QA" label from a PR when the actor is the
-# dependabot user merging a PR.
-#
-# We need this mechanism to allow for automerging whitelisted dependencies while
-# also allowing for blocking a merge to main for deployment (in the way that
-# our other PRs work). When the automerge script runs in henchman, it looks
-# for `Needs QA` on github pull requests, and if the label is present,
-# blocks the commit from merging.
-name: Remove 'Needs QA' label for auto-merged PRs.
-on:
-  pull_request:
-    types: [closed]
-
-jobs:
-  remove-label:
-    runs-on: ubuntu-latest
-    if: >
-      (github.actor == 'dependabot[bot]' || github.actor == 'dependabot-preview[bot]')
-      && github.event.pull_request.merged
-
-    steps:
-      # Our triage workflow adds 'Needs QA' to the PR in order to block it from
-      # merging to production. This removes that label when dependabot is doing
-      # the merging.
-      - name: Remove QA Label
-        uses: actions/github-script@0.4.0
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          script: |
-            github.issues.removeLabel({
-              issue_number: context.issue.number,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              name: 'Needs QA'
-            })