memoizable 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 52f96afbe10c6933ec55bedc8651f82d139973ef
-  data.tar.gz: 5d58b63d4c60c5b36e43b4ff0b54fc85e99bbce7
+SHA256:
+  metadata.gz: 9b9efbfc2d856bca857e97e84678b1e49977e2b1f4d0a0d93a239cacea9b95ef
+  data.tar.gz: 93a3c69fb399accdc6a8f684c315284c46450af48c5df0d4eb05117af1e2ea2e
 SHA512:
-  metadata.gz: f55779f1f1c4a4bcf7414e93ffb3026835effb12c96e5c3551ed03262f7d9f3b876bd96ef36f06412ee16c9e6337b66606199e790903470cf1340161b337b2d9
-  data.tar.gz: 89f74377d9561f723d17d3cc7d85b5d2c932b3162f47a14f9a10c668d8de1ad9629ecd46ac3bf82782d0e1bd2d225c5ba9c3160187030820ace7f25d5080b518
+  metadata.gz: de5d824ac3bd2b23970c50463cc27ba3a83b2f102d0293475edde45b1cebcccb87e5fac3411b6d509ce8866307d8f6eb213b8dc2c81eb17874df162c93329797
+  data.tar.gz: 5ae626655e57e079b0a6ea42d9a194e300fc681ec0b3403d1e7c08dea362075a1678041133df583ce296011baaa28da72c1f6e67bab47b067aa633146580658b

data/CHANGELOG.md

@@ -0,0 +1,100 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.5.0] - 2026-02-09
+
+### Added
+
+- `Memory#delete` method to remove a specific memoized value from cache
+- `Memory#clear` method to remove all memoized values from cache
+- `Memory#fetch` now accepts an optional default argument
+- Steep for static type checking
+- Mutant for mutation testing
+- RuboCop and Standard Ruby for linting
+- YARD and Yardstick for documentation coverage
+- GitHub Actions CI pipeline (replacing Travis CI)
+- GitHub Actions workflow for publishing gems to RubyGems with Sigstore attestation
+
+### Changed
+
+- Renamed `Memory#[]=` to `Memory#store`
+- `ModuleMethods#memoize` now raises `ArgumentError` when method is already memoized
+- Memoization cache now uses composite keys `[class, method_name]` to support inheritance ([#13](https://github.com/dkubb/memoizable/issues/13))
+- Replaced `thread_safe` gem dependency with Ruby's built-in `Monitor`
+
+### Removed
+
+- `Memory#key?` method
+- `ModuleMethods#memoized?` method
+- `ModuleMethods#included` method
+- `thread_safe` gem dependency
+
+## [0.4.2] - 2014-03-27
+
+### Changed
+
+- Updated `thread_safe` dependency to use semantic versioning compatible version
+
+## [0.4.1] - 2014-03-04
+
+### Added
+
+- Support for Ruby 2.1.0
+
+### Changed
+
+- Updated `thread_safe` dependency to ~> 0.2.0
+
+## [0.4.0] - 2013-12-24
+
+### Added
+
+- `Memory#marshal_dump` and `Memory#marshal_load` methods for Marshal serialization support ([#10](https://github.com/dkubb/memoizable/issues/10))
+
+## [0.3.1] - 2013-12-18
+
+### Changed
+
+- Added double-checked locking to `Memory#fetch` for improved thread safety
+
+### Removed
+
+- Unnecessary `Memory#set` method
+
+## [0.3.0] - 2013-12-15
+
+### Added
+
+- Thread-safe memory operations using `thread_safe` gem
+- `BlockNotAllowedError` raised when passing a block to memoized methods
+- `ModuleMethods#included` to allow module methods to be memoized
+
+### Changed
+
+- Memory is now shallowly frozen after initialization
+
+## [0.2.0] - 2013-11-18
+
+### Added
+
+- Core memoization functionality
+- `Memoizable::MethodBuilder` for memoized method creation
+- `InstanceMethods#memoize` to manually set memoized values
+- `InstanceMethods#freeze` support for frozen objects
+- `ModuleMethods#unmemoized_instance_method` to access original method
+- Thread-safe cache using `ThreadSafe::Cache`
+
+[Unreleased]: https://github.com/dkubb/memoizable/compare/v0.5.0...HEAD
+[0.5.0]: https://github.com/dkubb/memoizable/compare/v0.4.2...v0.5.0
+[0.4.2]: https://github.com/dkubb/memoizable/compare/v0.4.1...v0.4.2
+[0.4.1]: https://github.com/dkubb/memoizable/compare/v0.4.0...v0.4.1
+[0.4.0]: https://github.com/dkubb/memoizable/compare/v0.3.1...v0.4.0
+[0.3.1]: https://github.com/dkubb/memoizable/compare/v0.3.0...v0.3.1
+[0.3.0]: https://github.com/dkubb/memoizable/compare/v0.2.0...v0.3.0
+[0.2.0]: https://github.com/dkubb/memoizable/compare/v0.0.0...v0.2.0

data/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright (c) 2013 Dan Kubb, Erik Michaels-Ober
+Copyright (c) 2013-2026 Dan Kubb, Erik Berlin
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,19 +1,25 @@
 # Memoizable
 
 [![Gem Version](http://img.shields.io/gem/v/memoizable.svg)][gem]
-[![Build Status](http://img.shields.io/travis/dkubb/memoizable.svg)][travis]
-[![Dependency Status](http://img.shields.io/gemnasium/dkubb/memoizable.svg)][gemnasium]
-[![Code Climate](http://img.shields.io/codeclimate/github/dkubb/memoizable.svg)][codeclimate]
-[![Coverage Status](http://img.shields.io/coveralls/dkubb/memoizable.svg)][coveralls]
+[![Test](https://github.com/dkubb/memoizable/actions/workflows/test.yml/badge.svg)][test]
+[![Lint](https://github.com/dkubb/memoizable/actions/workflows/lint.yml/badge.svg)][lint]
+[![Mutant](https://github.com/dkubb/memoizable/actions/workflows/mutant.yml/badge.svg)][mutant]
+[![Docs](https://github.com/dkubb/memoizable/actions/workflows/docs.yml/badge.svg)][docs]
+[![Steep](https://github.com/dkubb/memoizable/actions/workflows/steep.yml/badge.svg)][steep]
 
 [gem]: https://rubygems.org/gems/memoizable
-[travis]: https://travis-ci.org/dkubb/memoizable
-[gemnasium]: https://gemnasium.com/dkubb/memoizable
-[codeclimate]: https://codeclimate.com/github/dkubb/memoizable
-[coveralls]: https://coveralls.io/r/dkubb/memoizable
+[test]: https://github.com/dkubb/memoizable/actions/workflows/test.yml
+[lint]: https://github.com/dkubb/memoizable/actions/workflows/lint.yml
+[mutant]: https://github.com/dkubb/memoizable/actions/workflows/mutant.yml
+[docs]: https://github.com/dkubb/memoizable/actions/workflows/docs.yml
+[steep]: https://github.com/dkubb/memoizable/actions/workflows/steep.yml
 
 Memoize method return values
 
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for details.
+
 ## Contributing
 
 See [CONTRIBUTING.md](CONTRIBUTING.md) for details.
@@ -76,36 +82,15 @@ result. Please keep this in mind when considering which methods to memoize.
 Supported Ruby Versions
 -----------------------
 
-This library aims to support and is [tested against][travis] the following Ruby
-implementations:
-
-* Ruby 1.8.7
-* Ruby 1.9.2
-* Ruby 1.9.3
-* Ruby 2.0.0
-* Ruby 2.1.0
-* [JRuby][]
-* [Rubinius][]
-* [Ruby Enterprise Edition][ree]
+This library aims to support and is tested against the following Ruby versions:
 
-[jruby]: http://jruby.org/
-[rubinius]: http://rubini.us/
-[ree]: http://www.rubyenterpriseedition.com/
+* Ruby 3.2
+* Ruby 3.3
+* Ruby 3.4
+* Ruby 4.0
 
 If something doesn't work on one of these versions, it's a bug.
 
-This library may inadvertently work (or seem to work) on other Ruby versions or
-implementations, however support will only be provided for the implementations
-listed above.
-
-If you would like this library to support another Ruby version or
-implementation, you may volunteer to be a maintainer. Being a maintainer
-entails making sure all tests run and pass on that implementation. When
-something breaks on your implementation, you will be responsible for providing
-patches in a timely fashion. If critical issues for a particular implementation
-exist at the time of a major release, support for that Ruby version may be
-dropped.
-
 ## Copyright
 
-Copyright © 2013 Dan Kubb, Erik Michaels-Ober. See LICENSE for details.
+Copyright © 2013-2026 Dan Kubb, Erik Berlin. See LICENSE for details.

data/lib/memoizable/instance_methods.rb

@@ -1,10 +1,8 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module Memoizable
-
   # Methods mixed in to memoizable instances
   module InstanceMethods
-
     # Freeze the object
     #
     # @example
@@ -14,7 +12,7 @@ module Memoizable
     #
     # @api public
     def freeze
-      memoized_method_cache  # initialize method cache
+      memoized_method_cache # initialize method cache
       super
     end
 
@@ -30,11 +28,11 @@ module Memoizable
     #
     # @api public
     def memoize(data)
-      data.each { |name, value| memoized_method_cache[name] = value }
+      data.each { |name, value| memoized_method_cache.store([self.class, name], value) }
       self
     end
 
-  private
+    private
 
     # The memoized method results
     #
@@ -42,8 +40,7 @@ module Memoizable
     #
     # @api private
     def memoized_method_cache
-      @_memoized_method_cache ||= Memory.new
+      @_memoized_method_cache ||= Memory.new({}) # rubocop:disable Naming/MemoizedInstanceVariableName
     end
-
-  end # InstanceMethods
-end # Memoizable
+  end
+end

data/lib/memoizable/memory.rb

@@ -1,94 +1,169 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module Memoizable
-
   # Storage for memoized methods
   class Memory
-
     # Initialize the memory storage for memoized methods
     #
-    # @param [ThreadSafe::Cache] memory
+    # @param [Hash] memory
     #
     # @return [undefined]
     #
     # @api private
-    def initialize
-      @memory  = ThreadSafe::Cache.new
+    def initialize(memory)
+      @memory = memory
       @monitor = Monitor.new
       freeze
     end
 
     # Get the value from memory
     #
+    # @example
+    #
+    #   memory = Memoizable::Memory.new(foo: 1)
+    #   memory[:foo]  # => 1
+    #
     # @param [Symbol] name
     #
     # @return [Object]
     #
     # @api public
     def [](name)
-      @memory.fetch(name) do
-        fail NameError, "No method #{name} is memoized"
+      fetch(name) do
+        raise NameError, "No method #{name} is memoized"
       end
     end
 
     # Store the value in memory
     #
+    # @example
+    #   memory = Memoizable::Memory.new(foo: 1)
+    #   memory.store(:foo, 2)
+    #   memory[:foo]  # => 2
+    #
     # @param [Symbol] name
     # @param [Object] value
     #
     # @return [undefined]
     #
     # @api public
-    def []=(name, value)
-      memoized = true
-      @memory.compute_if_absent(name) do
-        memoized = false
-        value
+    def store(name, value)
+      @monitor.synchronize do
+        raise ArgumentError, "The method #{name} is already memoized" if @memory.key?(name)
+
+        @memory[name] = value
       end
-      fail ArgumentError, "The method #{name} is already memoized" if memoized
     end
 
     # Fetch the value from memory, or store it if it does not exist
     #
+    # @example
+    #   memory = Memoizable::Memory.new(foo: 1)
+    #   memory.fetch(:foo) { 2 }  # => 1
+    #   memory.fetch(:bar) { 2 }  # => 2
+    #   memory[:bar]              # => 2
+    #   memory.fetch(:baz, 3)     # => 3
+    #
     # @param [Symbol] name
+    # @param [Object] default
+    #   optional default value to return if the key is not found
     #
     # @yieldreturn [Object]
     #   the value to memoize
     #
+    # @return [Object]
+    #
     # @api public
-    def fetch(name)
+    def fetch(name, default = (no_default = true), &block)
       @memory.fetch(name) do       # check for the key
         @monitor.synchronize do    # acquire a lock if the key is not found
           @memory.fetch(name) do   # recheck under lock
-            self[name] = yield     # set the value
+            @memory[name] = resolve_fetch_value(name, no_default, default, &block)
           end
         end
       end
     end
 
-    # Test if the name has a value in memory
+    private
+
+    # Resolve the value for a fetch operation
     #
     # @param [Symbol] name
+    # @param [Boolean] no_default
+    # @param [Object] default
     #
-    # @return [Boolean]
+    # @yieldreturn [Object]
+    #
+    # @return [Object]
+    #
+    # @api private
+    def resolve_fetch_value(name, no_default, default)
+      if block_given?
+        yield
+      elsif no_default
+        raise KeyError, "key not found: #{name.inspect}"
+      else
+        default
+      end
+    end
+
+    public
+
+    # Remove a specific value from memory
+    #
+    # @example
+    #   memory = Memoizable::Memory.new(foo: 1)
+    #   memory.delete(:foo)
+    #
+    # @param [Symbol] name
+    #
+    # @return [Object]
     #
     # @api public
-    def key?(name)
-      @memory.key?(name)
+    def delete(name)
+      @monitor.synchronize do
+        @memory.delete(name)
+      end
+    end
+
+    # Remove all values from memory
+    #
+    # @example
+    #   memory = Memoizable::Memory.new(foo: 1)
+    #   memory.clear  # => memory
+    #
+    # @return [self]
+    #
+    # @api public
+    def clear
+      @monitor.synchronize do
+        @memory.clear
+      end
+      self
     end
 
     # A hook that allows Marshal to dump the object
     #
+    # @example
+    #   memory = Memoizable::Memory.new(foo: 1)
+    #   Marshal.dump(memory)
+    #   # => "\x04\bU:\x17Memoizable::Memory{\x06:\bfooi\x06"
+    #
     # @return [Hash]
     #   A hash used to populate the internal memory
     #
     # @api public
     def marshal_dump
-      @memory.marshal_dump
+      @memory
     end
 
     # A hook that allows Marshal to load the object
     #
+    # @example
+    #   memory = Memoizable::Memory.new(foo: 1)
+    #   Marshal.load(Marshal.dump(memory))
+    #   # => #<Memoizable::Memory:0x007f9c2a8b6b20 @memory={:foo=>1}>
+    #
     # @param [Hash] hash
     #   A hash used to populate the internal memory
     #
@@ -96,9 +171,7 @@ module Memoizable
     #
     # @api public
     def marshal_load(hash)
-      initialize
-      @memory.marshal_load(hash)
+      initialize(hash)
     end
-
-  end # Memory
-end # Memoizable
+  end
+end

data/lib/memoizable/method_builder.rb

@@ -1,13 +1,10 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module Memoizable
-
   # Build the memoized method
   class MethodBuilder
-
     # Raised when the method arity is invalid
     class InvalidArityError < ArgumentError
-
       # Initialize an invalid arity exception
       #
       # @param [Module] descendant
@@ -18,12 +15,10 @@ module Memoizable
       def initialize(descendant, method, arity)
         super("Cannot memoize #{descendant}##{method}, its arity is #{arity}")
       end
-
-    end # InvalidArityError
+    end
 
     # Raised when a block is passed to a memoized method
     class BlockNotAllowedError < ArgumentError
-
       # Initialize a block not allowed exception
       #
       # @param [Module] descendant
@@ -33,11 +28,13 @@ module Memoizable
       def initialize(descendant, method)
         super("Cannot pass a block to #{descendant}##{method}, it is memoized")
       end
-
-    end # BlockNotAllowedError
+    end
 
     # The original method before memoization
     #
+    # @example
+    #    method_builder.original_method  # => :foo
+    #
     # @return [UnboundMethod]
     #
     # @api public
@@ -53,12 +50,12 @@ module Memoizable
     #
     # @api private
     def initialize(descendant, method_name, freezer)
-      @descendant          = descendant
-      @method_name         = method_name
-      @freezer             = freezer
+      @descendant = descendant
+      @method_name = method_name
+      @freezer = freezer
       @original_visibility = visibility
-      @original_method     = @descendant.instance_method(@method_name)
-      assert_arity(@original_method.arity)
+      @original_method = descendant.instance_method(@method_name)
+      assert_arity(original_method.arity)
     end
 
     # Build a new memoized method
@@ -76,7 +73,7 @@ module Memoizable
       self
     end
 
-  private
+    private
 
     # Assert the method arity is zero
     #
@@ -88,9 +85,9 @@ module Memoizable
     #
     # @api private
     def assert_arity(arity)
-      if arity.nonzero?
-        fail InvalidArityError.new(@descendant, @method_name, arity)
-      end
+      return unless arity.nonzero?
+
+      raise InvalidArityError.new(@descendant, @method_name, arity)
     end
 
     # Remove the original method
@@ -109,13 +106,15 @@ module Memoizable
     #
     # @api private
     def create_memoized_method
-      name, method, freezer = @method_name, @original_method, @freezer
-      @descendant.module_eval do
-        define_method(name) do |&block|
-          fail BlockNotAllowedError.new(self.class, name) if block
-          memoized_method_cache.fetch(name) do
-            freezer.call(method.bind(self).call)
-          end
+      name = @method_name
+      method = @original_method
+      freezer = @freezer
+      descendant = @descendant
+      @descendant.define_method(name) do |&block|
+        raise BlockNotAllowedError.new(self.class, name) if block # steep:ignore NoMethod
+
+        memoized_method_cache.fetch([descendant, name]) do # steep:ignore NoMethod
+          freezer.call(method.bind_call(self))
         end
       end
     end
@@ -126,7 +125,7 @@ module Memoizable
     #
     # @api private
     def set_method_visibility
-      @descendant.send(@original_visibility, @method_name)
+      @descendant.__send__(@original_visibility, @method_name)
     end
 
     # Get the visibility of the original method
@@ -135,11 +134,10 @@ module Memoizable
     #
     # @api private
     def visibility
-      if    @descendant.private_method_defined?(@method_name)   then :private
+      if @descendant.private_method_defined?(@method_name) then :private
       elsif @descendant.protected_method_defined?(@method_name) then :protected
-      else                                                           :public
+      else :public
       end
     end
-
-  end # MethodBuilder
-end # Memoizable
+  end
+end

data/lib/memoizable/module_methods.rb

@@ -1,9 +1,9 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module Memoizable
-
   # Methods mixed in to memoizable singleton classes
   module ModuleMethods
+    include Memoizable
 
     # Return default deep freezer
     #
@@ -26,34 +26,10 @@ module Memoizable
     #
     # @api public
     def memoize(*methods)
-      methods.each(&method(:memoize_method))
+      methods.each { |method| memoize_method(method) }
       self
     end
 
-    # Test if an instance method is memoized
-    #
-    # @example
-    #   class Foo
-    #     include Memoizable
-    #
-    #     def bar
-    #     end
-    #     memoize :bar
-    #   end
-    #
-    #   Foo.memoized?(:bar)  # true
-    #   Foo.memoized?(:baz)  # false
-    #
-    # @param [Symbol] name
-    #
-    # @return [Boolean]
-    #   true if method is memoized, false if not
-    #
-    # @api private
-    def memoized?(name)
-      memoized_methods.key?(name)
-    end
-
     # Return unmemoized instance method
     #
     # @example
@@ -81,20 +57,7 @@ module Memoizable
       memoized_methods[name].original_method
     end
 
-  private
-
-    # Hook called when module is included
-    #
-    # @param [Module] descendant
-    #   the module including ModuleMethods
-    #
-    # @return [self]
-    #
-    # @api private
-    def included(descendant)
-      super
-      descendant.module_eval { include Memoizable }
-    end
+    private
 
     # Memoize the named method
     #
@@ -105,6 +68,8 @@ module Memoizable
     #
     # @api private
     def memoize_method(method_name)
+      raise ArgumentError, "The method #{method_name} is already memoized" if memoized_methods.key?(method_name)
+
       memoized_methods[method_name] = MethodBuilder.new(
         self,
         method_name,
@@ -118,8 +83,7 @@ module Memoizable
     #
     # @api private
     def memoized_methods
-      @_memoized_methods ||= Memory.new
+      @memoized_methods ||= {}
     end
-
-  end # ModuleMethods
-end # Memoizable
+  end
+end

data/lib/memoizable/version.rb

@@ -1,8 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module Memoizable
-
   # Gem version
-  VERSION = '0.4.1'.freeze
-
-end # Memoizable
+  VERSION = "0.5.0"
+end