mize 0.6.0 → 0.7.0

data/lib/mize/configure.rb

@@ -1,10 +1,40 @@
+# Configuration helpers mixed in / extended onto the top-level +Mize+ object.
+#
+# Provides the block-based +Mize.configure+ DSL and the +default_cache+
+# accessor so users can swap the global cache backend.
 module Mize::Configure
+  # The global default cache backend.
+  #
+  # Every memoized object that has not been given an explicit cache
+  # instantiates a fresh copy (via +prototype+ / "dup") of this backend.
+  # Reassign it to route all new memoized calls through a different store
+  # (Redis, Memcached, ...).
+  #
+  # @return [Mize::CacheProtocol] The current global default cache backend.
   attr_accessor :default_cache
 
+  # Set the default cache object to +cache+.
+  #
+  # Intended for use inside a +Mize.configure {}+ block.
+  #
+  # @param cache [Mize::CacheProtocol] The backend to install as the default.
+  # @return [Mize::CacheProtocol] The backend now installed.
   def cache(cache)
     self.default_cache = cache
   end
 
+  # Configure Mize by evaluating +block+ in the context of the +Mize+ object.
+  #
+  # Inside the block, +cache+ (and the +default_cache+ accessor) are called
+  # directly on +Mize+, so no receiver is required.
+  #
+  # @example
+  #   Mize.configure do
+  #     cache MyRedisCache.new
+  #   end
+  #
+  # @yield The configuration block, evaluated via +instance_eval+.
+  # @return [Object] The return value of +block+.
   def configure(&block)
     instance_eval(&block)
   end
@@ -14,4 +44,5 @@ module Mize
   extend Mize::Configure
 end
 
+# Install the built-in in-memory backend as the global default.
 Mize.default_cache = Mize::DefaultCache.new

data/lib/mize/default_cache.rb

@@ -1,14 +1,30 @@
-require 'monitor'
-
+# The default in-memory cache backend.
+#
+# A plain +Hash+ wrapper that implements just enough of the Mize cache
+# protocol to back memoization out of the box: +read+ / +write+ /
+# +exist?+ / +delete+ / +clear+ / +each_name+.
+#
+# Individual operations are atomic under the GVL. For multi-step
+# atomicity (e.g. check→compute→write), wrap the call in
+# +Mize.synchronize+.
+#
+# Because it is backed by a plain +Hash+, entries are never evicted until you
+# clear the cache explicitly (or the object is garbage-collected). For
+# persistent or evicting behaviour, swap in a different
+# +Mize::CacheProtocol+ implementation via +Mize.configure+.
 class Mize::DefaultCache
   include Mize::CacheProtocol
-  include MonitorMixin
 
+  # Create an empty cache.
+  #
+  # @return [Mize::DefaultCache] A new, empty cache instance.
   def initialize
     @data = {}
   end
 
-  # Clear the cache by removing all entries from the cache
+  # Clear the cache by removing all entries from the cache.
+  #
+  # @return [self] The receiver, for chaining.
   def clear(options = nil)
     @data.clear
     self
@@ -17,16 +33,18 @@ class Mize::DefaultCache
   # Determine whether a cache entry exists in this cache.
   #
   # @param name [String] The name of the cache entry to check.
+  # @param options [Hash, nil] Optional backend-specific options (ignored).
   # @return [Boolean] Whether or not the cache entry exists.
   def exist?(name, options = nil)
     @data.key?(name)
   end
 
   # Read a value from the cache by name. If the entry does not exist in the
-  # cache, it will return nil.
+  # cache, it will return +nil+.
   #
   # @param name [String] The name of the cache entry to read.
-  # @return [Object] The value stored in the cache for the given name.
+  # @param options [Hash, nil] Optional backend-specific options (ignored).
+  # @return [Object, nil] The value stored in the cache for +name+, or +nil+.
   def read(name, options = nil)
     @data.fetch(name, nil)
   end
@@ -35,34 +53,49 @@ class Mize::DefaultCache
   # exists in the cache, it will be overwritten.
   #
   # @param name [String] The name of the cache entry to write.
-  # @param value [Object] The value to store in the cache for the given name.
-  # @return [Object] The value stored in the chache.
+  # @param value [Object] The value to store in the cache for +name+.
+  # @param options [Hash, nil] Optional backend-specific options (ignored).
+  # @return [Object] The value now stored in the cache.
   def write(name, value, options = nil)
     @data.store(name, value)
   end
 
-  # Delete a cache entry by name. If the entry does not exist in the cache, it
+  # Delete a cache entry by name. If an entry does not exist in the cache, it
   # will do nothing.
   #
   # @param name [String] The name of the cache entry to delete.
-  # @return [Object] The value stored in the chache before deletion.
+  # @param options [Hash, nil] Optional backend-specific options (ignored).
+  # @return [Object, nil] The value stored in the cache before deletion, or
+  #   +nil+ if the entry was absent.
   def delete(name, options = nil)
     @data.delete(name)
   end
 
   # Each name of the cache is yielded to the block.
-  # @return [self]
+  #
+  # @yieldparam name [String] Each cache entry name, in turn.
+  # @return [self] The receiver, for chaining.
   def each_name(&block)
     @data.each_key(&block)
     self
   end
 
   # Initialize a duplicate of this cache.
-  # @param other [Mize::DefaultCache] The other cache to initialize a duplicate of.
+  #
+  # The underlying store is shallow-copied so the original and the duplicate
+  # diverge immediately (this is what +prototype+ relies on to hand each
+  # memoized object its own independent cache).
+  #
+  # @param other [Mize::DefaultCache] The cache to initialize a duplicate of.
+  # @return [Mize::DefaultCache] +self+, now a copy of +other+.
   def initialize_dup(other)
     super
     other.instance_variable_set :@data, @data.dup
   end
 
+  # Create a shallow copy of this cache; the public name for +dup+.
+  #
+  # @return [Mize::DefaultCache] A new cache with an independent copy of the
+  #   entries.
   alias prototype dup
 end

data/lib/mize/global_clear.rb

@@ -2,14 +2,28 @@ module Mize
   class << self
 
     # Clear all memoization caches at once.
+    #
+    # Walks every live +Mize::CacheProtocol+ instance in the process (see
+    # +each_cache+) and invokes +clear+ on each, inside +Mize.synchronize+ so
+    # the sweep is atomic with respect to concurrent reads/writes.
+    #
+    # @return [Mize] The +Mize+ module itself.
     def cache_clear
       each_cache(&:clear)
     end
 
     private
 
+    # Yield every live +Mize::CacheProtocol+ object to the block.
+    #
+    # The sweep runs under +Mize.synchronize+ so it cannot observe a
+    # half-cleared cache. Objects only appear here because they
+    # +include Mize::CacheProtocol+.
+    #
+    # @yield [cache] Yields each live cache backend in turn.
+    # @return [Mize] The +Mize+ module itself.
     def each_cache
-      Mize::MUTEX.synchronize do
+      Mize.synchronize do
         for cache in ObjectSpace.each_object(Mize::CacheProtocol)
           yield cache
         end

data/lib/mize/memoize.rb

@@ -2,18 +2,43 @@ require 'mize/cache_methods'
 require 'mize/reload'
 
 module Mize
+  # Memoization entry point, prepended into every +::Module+ by +mize.rb+.
+  #
+  # Including this module (or relying on the global +prepend+) exposes
+  # +memoize+, +mize_cache_clear+ and +mize_cache_clear_name+ on the
+  # receiver. The heavy lifting is delegated to +Mize::CacheMethods+ for
+  # key/state management and +Mize::Reload+ for cache invalidation.
   module Memoize
     include CacheMethods
 
-    # Memoize either a +method+ or a +function+. In the former case the
-    # memoized results do NOT ONLY depend on the arguments, but ALSO on the
-    # object the method is called on. In the latter the memoized results ONLY
-    # depend on the arguments given to the function. If the +freeze+ argument
-    # is true, the result is frozen if possible to make it immutable. If the
-    # store_nil argument is false do not store nil results and always recompute
-    # otherwise don't which is the default.
+    # Memoize either a +method+ or a +function+.
+    #
+    # In the +method+ case the memoized results do NOT ONLY depend on the
+    # arguments, but ALSO on the object the method is called on (each object
+    # keeps its own cache). In the +function+ case the memoized results ONLY
+    # depend on the arguments, and a single shared cache backs every call.
+    #
+    # You must specify exactly one of +method:+ or +function:+; passing both
+    # or neither raises +ArgumentError+.
+    #
+    # @param method [String, Symbol, nil] The instance method to wrap.
+    # @param function [String, Symbol, nil] The bare/stateless function to wrap.
+    # @param freeze [true, false] When true, successfully computed results are
+    #   frozen (if they respond to +freeze+) to make them immutable.
+    # @param store_nil [true, false] When false, +nil+ results are not stored
+    #   and are recomputed every call; defaults to +true+ (store +nil+).
+    # @raise [ArgumentError] If both or neither of +method:+/+function:+ are
+    #   given.
+    # @return [Symbol] The (stringified) symbol of the wrapped method id.
+    # @example Memoizing an instance method
+    #   class Foo
+    #     include Mize::Memoize
+    #
+    #     def expensive(x) x * 2 end
+    #     memoize method: :expensive, freeze: true
+    #   end
     def memoize(method: nil, function: nil, freeze: false, store_nil: true)
-      Mize::MUTEX.synchronize do
+      Mize.synchronize do
         if method && function
           raise ArgumentError, 'memoize a method xor a function'
         elsif method
@@ -31,6 +56,19 @@ module Mize
     class << self
       private
 
+      # Compute the real result of a memoized call.
+      #
+      # Binds +orig_method+ to +context+ and invokes it with +args+; when
+      # running under +$DEBUG+ a diagnostic line is emitted to +STDERR+.
+      #
+      # @param method_id [Symbol] The wrapped method name (diagnostics only).
+      # @param orig_method [UnboundMethod] The original, unwrapped method.
+      # @param key [String] The cache key for this call (diagnostics only).
+      # @param context [Object] The object the method is bound to.
+      # @param args [Array] The positional arguments.
+      # @param kargs [Hash] The keyword arguments.
+      # @param freeze [true, false] Whether to freeze the resulting value.
+      # @return [Object] The (possibly frozen) computed result.
       def compute_result(method_id, orig_method, key, context, args, kargs, freeze)
         result = orig_method.bind(context).call(*args)
         if $DEBUG
@@ -43,7 +81,25 @@ module Mize
       end
     end
 
-    def wrap_method(method_id, freeze: false, function: false, store_nil: true)
+      # Wrap +method_id+ with a memoizing closure.
+      #
+      # Idempotency: a +[self, method_id, function]+ target already present in
+      # +Mize.wrapped+ with identical +freeze+ / +store_nil+ options is a
+      # no-op; conflicting options raise +ArgumentError+.
+      #
+      # For instance methods (+function: false+) the receiver gets its own
+      # per-object cache via +Mize::CacheMethods+ and +Mize::Reload+ is
+      # prepended so +reload+ invalidates entries. For bare functions a single
+      # shared cache is used instead.
+      #
+      # @param method_id [String, Symbol] The name of the method to wrap.
+      # @param freeze [true, false] Forwarded to the wrapper's result handling.
+      # @param function [true, false] Whether +method_id+ is a bare function.
+      # @param store_nil [true, false] Whether +nil+ results should be cached.
+      # @raise [ArgumentError] If the target is already wrapped with different
+      #   +freeze+ / +store_nil+ options.
+      # @return [Symbol] The stringified symbol of the wrapped method id.
+      def wrap_method(method_id, freeze: false, function: false, store_nil: true)
       verbose, $VERBOSE = $VERBOSE, nil
       if already_wrapped = Mize.wrapped[ [ self, method_id, function ] ]
         if already_wrapped == [ freeze, store_nil ]

data/lib/mize/railtie.rb

@@ -1,4 +1,11 @@
 module Mize
+  # Rails integration.
+  #
+  # Hooks into the Rails preparation lifecycle so that every code reload
+  # clears all Mize caches via +Mize.cache_clear+, preventing stale memoized
+  # results from surviving a development-environment class reload.
+  #
+  # Loaded automatically by +mize.rb+ only when +Rails+ is defined.
   class Railtie < Rails::Railtie
     config.to_prepare do
       Mize.cache_clear

data/lib/mize/reload.rb

@@ -1,8 +1,21 @@
+# Reload/invalidation hook, prepended into any module that memoizes an
+# instance method.
+#
+# When a class defines (or inherits) its own +reload+, Mize wraps it so the
+# cache is guaranteed to be cleared alongside whatever the user's +reload+
+# does, keeping memoized state consistent after a full object reload.
 module Mize::Reload
-  # Reload this object if a #reload method was provided up somewhere in the
-  # inheritance tree, afterwards clear the memoization cache and return self.
+  # Run the parent +reload+ (if any), then clear Mize's bookkeeping and the
+  # object's memoization cache.
+  #
+  # The whole sequence is serialized on +Mize.synchronize+. +Mize.wrapped+ is
+  # reset so a re-memoization with different options is allowed, and
+  # +mize_cache_clear+ drops every cached value for this object.
+  #
+  # @return [Object] The result of the parent +reload+ if one was defined,
+  #   otherwise +self+.
   def reload(*)
-    Mize::MUTEX.synchronize do
+    Mize.synchronize do
       result = self
       if defined? super
         result = super

data/lib/mize/version.rb

@@ -1,6 +1,11 @@
+# Version information for the Mize gem.
+#
+# This module is auto-generated by GemHadar and exposes the
+# current release version as a set of constants. Do not edit it
+# by hand; it is rewritten on every `rake version` invocation.
 module Mize
-  # Mize version
-  VERSION         = '0.6.0'
+  # The current version of the Mize gem as a String.
+  VERSION         = '0.7.0'
   VERSION_ARRAY   = VERSION.split('.').map(&:to_i) # :nodoc:
   VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
   VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:

data/lib/mize.rb

@@ -1,10 +1,71 @@
 require 'thread'
 
+# Mize — a minimal, dependency-free memoization toolkit for Ruby.
+#
+# Mize lets you wrap any method (or a bare, stateless "function") so that its
+# result is cached and reused for identical arguments. It ships with an
+# in-memory +Mize::DefaultCache+ but accepts any object that includes
+# +Mize::CacheProtocol+, so you can plug in Redis, Memcached, and friends.
+#
+# @example Wrapping a method
+#   class Greeter
+#     include Mize::Memoize
+#
+#     def expensive(name)
+#       # ...
+#     end
+#     memoize method: :expensive
+#   end
 module Mize
+  # Process-wide lock guarding all cache and wrapping mutations.
+  #
+  # Every operation that mutates shared Mize state (+memoize+,
+  # +Mize.cache_clear+, +Mize::Reload#reload+) serialises on this mutex, so
+  # the toolkit is safe to use from multiple threads.
   MUTEX = Mutex.new
 
   class << self
+    # Bookkeeping of already-wrapped targets.
+    #
+    # Maps +[module, method_id, function]+ => +[freeze, store_nil]+ so that
+    # duplicate +memoize+ calls can be detected and conflicting options
+    # rejected. Cleared on +Mize::Reload#reload+.
     attr_accessor :wrapped
+
+    # Acquire the global Mize mutex for the duration of +block+.
+    #
+    # Exposes the internal +MUTEX+ under a stable API so callers can make
+    # a sequence of memoized calls atomic with respect to other threads:
+    #
+    # @example
+    #   Mize.synchronize do
+    #     obj.foo(42)
+    #     obj.bar(42)
+    #   end
+    #
+    # The hot path (individual memoized calls) is lock-free by design; use
+    # this when you need the check→compute→write cycle to be indivisible.
+    #
+    # MRI forbids +Mutex#synchronize+ from a trap context (signal handlers
+    # and GC finalizers), raising +ThreadError: can't be called from trap
+    # context+. This is an intentional, still-current design decision (see
+    # DevMeeting-2025-07-10 on
+    # https://bugs.ruby-lang.org/issues/19473), not a bug being patched, so
+    # this method rescues that specific error and runs +block+ without the
+    # lock rather than raising into a finalizer. Other +ThreadError+s (e.g.
+    # recursive locking) are re-raised.
+    #
+    # @yield Executes the block while holding the mutex.
+    # @return [Object] The return value of +block+.
+    def synchronize(&block)
+      MUTEX.synchronize(&block)
+    rescue ThreadError => e
+      if e.message.include?("trap context")
+        block.()
+      else
+        raise e
+      end
+    end
   end
   self.wrapped = {}
 end
@@ -15,6 +76,8 @@ require 'mize/configure'
 require 'mize/global_clear'
 require 'mize/railtie' if defined? Rails
 
+# Inject +memoize+ into every module so any class can opt in with a single
+# +include Mize::Memoize+.
 class ::Module
   prepend Mize::Memoize
 end

data/mize.gemspec

@@ -1,32 +1,34 @@
 # -*- encoding: utf-8 -*-
-# stub: mize 0.6.0 ruby lib
+# stub: mize 0.7.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "mize".freeze
-  s.version = "0.6.0".freeze
+  s.version = "0.7.0".freeze
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.metadata = { "source_code_uri" => "https://github.com/flori/mize" } if s.respond_to? :metadata=
   s.require_paths = ["lib".freeze]
   s.authors = ["Florian Frank".freeze]
-  s.date = "2024-07-25"
-  s.description = "Library that provides memoziation for methods and functions for Ruby.".freeze
+  s.date = "1980-01-02"
+  s.description = "Library that provides memoization for methods and functions for Ruby.".freeze
   s.email = "flori@ping.de".freeze
   s.extra_rdoc_files = ["README.md".freeze, "lib/mize.rb".freeze, "lib/mize/cache_methods.rb".freeze, "lib/mize/cache_protocol.rb".freeze, "lib/mize/configure.rb".freeze, "lib/mize/default_cache.rb".freeze, "lib/mize/global_clear.rb".freeze, "lib/mize/memoize.rb".freeze, "lib/mize/railtie.rb".freeze, "lib/mize/reload.rb".freeze, "lib/mize/version.rb".freeze]
-  s.files = [".all_images.yml".freeze, ".gitignore".freeze, ".rspec".freeze, ".tool-versions".freeze, ".travis.yml".freeze, ".utilsrc".freeze, "Gemfile".freeze, "README.md".freeze, "Rakefile".freeze, "VERSION".freeze, "config/broken_config.yml".freeze, "config/config.yml".freeze, "lib/mize.rb".freeze, "lib/mize/cache_methods.rb".freeze, "lib/mize/cache_protocol.rb".freeze, "lib/mize/configure.rb".freeze, "lib/mize/default_cache.rb".freeze, "lib/mize/global_clear.rb".freeze, "lib/mize/memoize.rb".freeze, "lib/mize/railtie.rb".freeze, "lib/mize/reload.rb".freeze, "lib/mize/version.rb".freeze, "mize.gemspec".freeze, "spec/mize/global_clear_spec.rb".freeze, "spec/mize/memoize_method_spec.rb".freeze, "spec/mize/memoize_reload_spec.rb".freeze, "spec/mize/version_spec.rb".freeze, "spec/spec_helper.rb".freeze]
+  s.files = [".all_images.yml".freeze, ".github/workflows/static.yml".freeze, ".gitignore".freeze, ".rspec".freeze, ".travis.yml".freeze, "CHANGES.md".freeze, "Gemfile".freeze, "LICENSE".freeze, "README.md".freeze, "Rakefile".freeze, "VERSION".freeze, "lib/mize.rb".freeze, "lib/mize/cache_methods.rb".freeze, "lib/mize/cache_protocol.rb".freeze, "lib/mize/configure.rb".freeze, "lib/mize/default_cache.rb".freeze, "lib/mize/global_clear.rb".freeze, "lib/mize/memoize.rb".freeze, "lib/mize/railtie.rb".freeze, "lib/mize/reload.rb".freeze, "lib/mize/version.rb".freeze, "mize.gemspec".freeze, "spec/mize/global_clear_spec.rb".freeze, "spec/mize/memoize_method_spec.rb".freeze, "spec/mize/memoize_reload_spec.rb".freeze, "spec/mize/version_spec.rb".freeze, "spec/mize_spec.rb".freeze, "spec/spec_helper.rb".freeze]
   s.homepage = "https://github.com/flori/mize".freeze
   s.licenses = ["MIT".freeze]
-  s.rdoc_options = ["--title".freeze, "Mize - Library that provides memoziation for methods and functions".freeze, "--main".freeze, "README.md".freeze]
+  s.rdoc_options = ["--title".freeze, "Mize - Library that provides memoization for methods and functions".freeze, "--main".freeze, "README.md".freeze]
   s.required_ruby_version = Gem::Requirement.new(">= 2".freeze)
-  s.rubygems_version = "3.5.16".freeze
-  s.summary = "Library that provides memoziation for methods and functions".freeze
-  s.test_files = ["spec/mize/global_clear_spec.rb".freeze, "spec/mize/memoize_method_spec.rb".freeze, "spec/mize/memoize_reload_spec.rb".freeze, "spec/mize/version_spec.rb".freeze, "spec/spec_helper.rb".freeze]
+  s.rubygems_version = "4.0.22".freeze
+  s.summary = "Library that provides memoization for methods and functions".freeze
+  s.test_files = ["spec/mize/global_clear_spec.rb".freeze, "spec/mize/memoize_method_spec.rb".freeze, "spec/mize/memoize_reload_spec.rb".freeze, "spec/mize/version_spec.rb".freeze, "spec/mize_spec.rb".freeze, "spec/spec_helper.rb".freeze]
 
   s.specification_version = 4
 
-  s.add_development_dependency(%q<gem_hadar>.freeze, ["~> 1.16.1".freeze])
+  s.add_development_dependency(%q<gem_hadar>.freeze, [">= 2.20.1".freeze])
   s.add_development_dependency(%q<rake>.freeze, [">= 0".freeze])
   s.add_development_dependency(%q<simplecov>.freeze, [">= 0".freeze])
   s.add_development_dependency(%q<rspec>.freeze, [">= 0".freeze])
   s.add_development_dependency(%q<yard>.freeze, [">= 0".freeze])
   s.add_development_dependency(%q<all_images>.freeze, [">= 0".freeze])
+  s.add_development_dependency(%q<debug>.freeze, [">= 0".freeze])
 end

data/spec/mize/global_clear_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 class Foo
   def self.reset
     @@foo = nil

data/spec/mize/memoize_method_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 class FooBar
   class << self
     def reset

data/spec/mize/memoize_reload_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 class Foo
   def self.reset
     @@foo = nil

data/spec/mize/version_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 describe 'Mize::VERSION' do
   it 'has a version' do
     expect(Mize::VERSION).to be_a String

data/spec/mize_spec.rb

@@ -0,0 +1,13 @@
+describe Mize do
+  describe '.synchronize' do
+    it 'executes the block and returns its value' do
+      expect(described_class.synchronize { 42 }).to eq(42)
+    end
+
+    it 'is the same lock object as Mize::MUTEX' do
+      expect {
+        Mize::MUTEX.synchronize { Mize.synchronize { :x } }
+      }.to raise_error(ThreadError)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,12 +1,7 @@
-if ENV['START_SIMPLECOV'].to_i == 1
-  require 'simplecov'
-  SimpleCov.start do
-    add_filter "#{File.basename(File.dirname(__FILE__))}/"
-  end
-end
-require 'rspec'
 begin
-  require 'byebug'
+  require 'gem_hadar/simplecov'
+  GemHadar::SimpleCov.start
 rescue LoadError
 end
+require 'rspec'
 require 'mize'

metadata

@@ -1,29 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: mize
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Florian Frank
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-25 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gem_hadar
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.16.1
+        version: 2.20.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.16.1
+        version: 2.20.1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -94,7 +93,21 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Library that provides memoziation for methods and functions for Ruby.
+- !ruby/object:Gem::Dependency
+  name: debug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Library that provides memoization for methods and functions for Ruby.
 email: flori@ping.de
 executables: []
 extensions: []
@@ -112,17 +125,16 @@ extra_rdoc_files:
 - lib/mize/version.rb
 files:
 - ".all_images.yml"
+- ".github/workflows/static.yml"
 - ".gitignore"
 - ".rspec"
-- ".tool-versions"
 - ".travis.yml"
-- ".utilsrc"
+- CHANGES.md
 - Gemfile
+- LICENSE
 - README.md
 - Rakefile
 - VERSION
-- config/broken_config.yml
-- config/config.yml
 - lib/mize.rb
 - lib/mize/cache_methods.rb
 - lib/mize/cache_protocol.rb
@@ -138,15 +150,16 @@ files:
 - spec/mize/memoize_method_spec.rb
 - spec/mize/memoize_reload_spec.rb
 - spec/mize/version_spec.rb
+- spec/mize_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/flori/mize
 licenses:
 - MIT
-metadata: {}
-post_install_message:
+metadata:
+  source_code_uri: https://github.com/flori/mize
 rdoc_options:
 - "--title"
-- Mize - Library that provides memoziation for methods and functions
+- Mize - Library that provides memoization for methods and functions
 - "--main"
 - README.md
 require_paths:
@@ -162,13 +175,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
-signing_key:
+rubygems_version: 4.0.22
 specification_version: 4
-summary: Library that provides memoziation for methods and functions
+summary: Library that provides memoization for methods and functions
 test_files:
 - spec/mize/global_clear_spec.rb
 - spec/mize/memoize_method_spec.rb
 - spec/mize/memoize_reload_spec.rb
 - spec/mize/version_spec.rb
+- spec/mize_spec.rb
 - spec/spec_helper.rb

data/.tool-versions

@@ -1 +0,0 @@
-ruby 3.3.4