memo_ttl 0.9.21

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6ba7210c4b45af27a52d7a6b86053ca2bdfc97929d2968803af7e15abfaa73c0
+  data.tar.gz: 4306221408051fdd1308972bb553d4577d2c9ae41c28e47e1526ce391fb3f1dc
+SHA512:
+  metadata.gz: 236d78b10240f22e4d77773103aa38d02cc5ebe647bbb81166189df066bf28b3418a2ef5fb6720bee38336918f4b44e9f6cd4c63bcb7c445940d6d10ee1948b5
+  data.tar.gz: 3bab4d3842a2ee8b22476080360a3c003e00dacbc95bcce88aa29e3463cc5f8d85eb41725742184f455396faca513e774c1224418799eb075e09ab50be40f01e

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rspec_status

@@ -0,0 +1,18 @@
+example_id                     | status | run_time        |
+------------------------------ | ------ | --------------- |
+./spec/cache_spec.rb[1:1]      | passed | 0.00056 seconds |
+./spec/cache_spec.rb[1:2]      | passed | 0.00072 seconds |
+./spec/cache_spec.rb[1:3]      | passed | 0.00006 seconds |
+./spec/cache_spec.rb[1:4]      | passed | 0.00007 seconds |
+./spec/cache_spec.rb[1:5]      | passed | 0.00007 seconds |
+./spec/cache_spec.rb[1:6]      | passed | 0.00014 seconds |
+./spec/cache_spec.rb[1:7]      | passed | 0.00009 seconds |
+./spec/memo_ttl_spec.rb[1:1:1] | passed | 0.00317 seconds |
+./spec/memo_ttl_spec.rb[1:1:2] | passed | 0.00008 seconds |
+./spec/memo_ttl_spec.rb[1:1:3] | passed | 0.00008 seconds |
+./spec/memo_ttl_spec.rb[1:2:1] | passed | 0.0001 seconds  |
+./spec/memo_ttl_spec.rb[1:2:2] | passed | 0.00009 seconds |
+./spec/memo_ttl_spec.rb[1:3:1] | passed | 0.00012 seconds |
+./spec/memo_ttl_spec.rb[1:3:2] | passed | 0.00008 seconds |
+./spec/memo_ttl_spec.rb[1:3:3] | passed | 0.0001 seconds  |
+./spec/memo_ttl_spec.rb[1:3:4] | passed | 0.00029 seconds |

data/.rubocop.yml

@@ -0,0 +1,14 @@
+AllCops:
+  TargetRubyVersion: 3.1
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Metrics/MethodLength:
+  Max: 64
+
+Metrics/BlockLength:
+  Max: 96

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-04-21
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mishal Zaman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Mishal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,104 @@
+# MemoTTL
+
+**MemoTTL** is a thread-safe memoization utility for Ruby that supports TTL (Time-To-Live) and LRU (Least Recently Used) eviction. It's designed for scenarios where memoized values should expire after a period and memory usage must be constrained.
+
+## Features
+
+- Memoize method results with expiration (TTL)
+- Built-in LRU eviction to limit memory usage
+- Thread-safe with Monitor
+- Easy integration via `include MemoTTL`
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "memo_ttl"
+```
+
+Afterwards:
+
+```ruby
+bundle install
+```
+
+## Usage
+
+```ruby
+require "memo_ttl"
+
+class Calculator
+  include MemoTTL
+
+  def a_method_that_does_something(x)
+    sleep(2) # simulate slow process
+    x * 2
+  end
+
+  # use at the bottom due to Ruby's top-down evalation of methods
+  memoize :a_method_that_does_something, ttl: 60, max_size: 100
+end
+
+calc = Calculator.new
+calc.a_method_that_does_something(5) # takes 2 seconds
+calc.a_method_that_does_something(5) # returns instantly from cache
+```
+
+To clear the cache:
+
+```ruby
+calc.clear_memoized_method(:a_method_that_does_something)
+calc.clear_all_memoized_methods
+calc.cleanup_memoized_methods
+```
+
+### Rails Example
+
+```ruby
+require 'memo_ttl'
+
+class TestController < ApplicationController
+  include MemoTTL
+
+  def index
+    result1 = test_method(1, 2)
+    result2 = test_method(1, 2)
+    result3 = test_method(5, 2)
+    result4 = test_method(1, 2)
+    result5 = test_method(1, 2)
+    result6 = test_method(3, 4)
+
+    render plain: <<~TEXT
+      Result 1: #{result1}
+      Result 2: #{result2}
+      Result 3: #{result3}
+      Result 4: #{result4}
+      Result 5: #{result5}
+      Result 6: #{result6}
+    TEXT
+  end
+
+  def test_method(x, y)
+    puts "Calling test_method(#{x}, #{y})"
+    x + y
+  end
+
+  def clean_up
+    clear_memoized_method(:test_method)
+    clear_all_memoized_methods
+    cleanup_memoized_methods
+  end
+
+  memoize :test_method, ttl: 10, max_size: 10
+end
+```
+
+Output in Rails console:
+
+```
+Processing by TestController#index as HTML
+Calling test_method(1, 2)
+Calling test_method(5, 2)
+Calling test_method(3, 4)
+```

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/memo_ttl/cache.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module MemoTTL
+  # Internal cache with TTL (time-to-live) and max size enforcement.
+  class Cache
+    # Special object used to represent `nil` values safely.
+    NULL_OBJECT = Object.new.freeze
+
+    # Structure to hold a cached value and its expiration timestamp.
+    Entry = Struct.new(:value, :expires_at)
+
+    # Initializes a new Cache.
+    #
+    # @param max_size [Integer] maximum number of entries to keep
+    # @param ttl [Integer] time-to-live in seconds for each entry
+    # @raise [ArgumentError] if max_size or ttl are not positive integers
+    def initialize(max_size: 100, ttl: 60)
+      raise ArgumentError, "max_size must be a positive integer" unless max_size.is_a?(Integer) && max_size.positive?
+      raise ArgumentError, "ttl must be a positive integer" unless ttl.is_a?(Integer) && ttl.positive?
+
+      @max_size = max_size
+      @ttl = ttl
+      @store = {}
+      @order = []
+      @lock = Monitor.new
+    end
+
+    # Retrieves the cached value for a key, or nil if not present or expired.
+    #
+    # @param key [Object] the key to retrieve
+    # @return [Object, nil] the cached value or nil
+    # @raise [CacheOperationError] if there's an issue accessing the cache
+    def get(key)
+      @lock.synchronize do
+        entry = @store[key]
+        return nil unless entry
+
+        if entry.expires_at && Time.now > entry.expires_at
+          delete(key)
+          return nil
+        end
+        touch(key)
+        entry.value == NULL_OBJECT ? nil : entry.value
+      rescue StandardError => e
+        raise CacheOperationError, "Failed to get key #{key}: #{e.message}"
+      end
+    end
+
+    # Stores a value in the cache under the given key.
+    #
+    # @param key [Object] the key to store under
+    # @param value [Object, nil] the value to store
+    # @return [Object] the value that was stored
+    # @raise [CacheOperationError] if there's an issue storing in the cache
+    def set(key, value)
+      @lock.synchronize do
+        evict if !@store.key?(key) && @store.size >= @max_size
+        delete(key) if @store.key?(key)
+        stored_value = value.nil? ? NULL_OBJECT : value
+        @store[key] = Entry.new(stored_value, Time.now + @ttl)
+        @order.unshift(key)
+        value
+      rescue StandardError => e
+        raise CacheOperationError, "Failed to set key #{key}: #{e.message}"
+      end
+    end
+
+    # Removes all expired entries from the cache.
+    #
+    # @return [Integer] number of entries removed
+    # @raise [CacheOperationError] if there's an issue during cleanup
+    def cleanup
+      @lock.synchronize do
+        now = Time.now
+        expired_keys = @store.select { |_key, entry| entry.expires_at && now > entry.expires_at }.keys
+        expired_keys.each { |key| delete(key) }
+        expired_keys.size
+      rescue StandardError => e
+        raise CacheOperationError, "Failed during cache cleanup: #{e.message}"
+      end
+    end
+
+    # Checks if a key exists in the cache, regardless of its value.
+    #
+    # @param key [Object] the key to check
+    # @return [Boolean] true if the key exists, false otherwise
+    def key?(key)
+      @lock.synchronize { @store.key?(key) }
+    end
+
+    # Returns the number of current entries in the cache.
+    #
+    # @return [Integer]
+    def size
+      @lock.synchronize { @store.size }
+    end
+
+    private
+
+    # Deletes an entry by key.
+    #
+    # @param key [Object] the key to remove
+    def delete(key)
+      @store.delete(key)
+      @order.delete(key)
+    end
+
+    # Removes the least recently used entry.
+    #
+    # @return [void]
+    def evict
+      oldest_key = @order.pop
+      @store.delete(oldest_key)
+    end
+
+    # Marks a key as most recently used.
+    #
+    # @param key [Object] the key to touch
+    def touch(key)
+      @order.delete(key)
+      @order.unshift(key) unless @order.first == key
+    end
+  end
+end

data/lib/memo_ttl/class_methods.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "cache"
+
+module MemoTTL
+  # Adds class-level method memoization.
+  module ClassMethods
+    # Memoizes an instance method with TTL and max size.
+    #
+    # @param method_name [Symbol] the name of the method to memoize
+    # @param ttl [Integer] time-to-live in seconds for the memoized result
+    # @param max_size [Integer] maximum number of memoized results to keep
+    # @raise [NameError] if the method doesn't exist
+    # @raise [ArgumentError] if ttl or max_size are invalid
+    def memoize(method_name, ttl: 60, max_size: 100)
+      raise ArgumentError, "ttl must be positive" unless ttl.is_a?(Numeric) && ttl.positive?
+      raise ArgumentError, "max_size must be positive" unless max_size.is_a?(Integer) && max_size.positive?
+
+      unless method_defined?(method_name) || private_method_defined?(method_name)
+        raise NameError, "Method '#{method_name}' not defined in #{self}"
+      end
+
+      original_method = instance_method(method_name)
+      cache_var = "@__memo_ttl_cache__#{method_name}"
+
+      define_memoized_method(method_name, cache_var, original_method, ttl, max_size)
+    end
+
+    private
+
+    def define_memoized_method(method_name, cache_var, original_method, ttl, max_size)
+      warn "Redefining memoized method: #{method_name}" if instance_variable_defined?(cache_var)
+
+      define_method(method_name) do |*args, &block|
+        cache = fetch_or_create_cache(cache_var, ttl, max_size)
+        key = build_cache_key(method_name, args, block)
+        fetch_or_compute_result(cache, key, original_method, args, block)
+      rescue MemoTTL::KeyGenerationError, MemoTTL::MethodBindingError, MemoTTL::CacheOperationError => e
+        raise e
+      rescue StandardError => e
+        raise MemoTTL::Error, "Failed to execute memoized method '#{method_name}': #{e.message}"
+      end
+    end
+  end
+end

data/lib/memo_ttl/instance_methods.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module MemoTTL
+  # Provides instance-level methods to manage memoized caches.
+  module InstanceMethods
+    # Clears the cache for a specific memoized method.
+    #
+    # @param method_name [Symbol] the method whose cache to clear
+    # @return [Boolean] true if cache was cleared, false if not found
+    def clear_memoized_method(method_name)
+      cache_var = "@__memo_ttl_cache__#{method_name}"
+      if instance_variable_defined?(cache_var)
+        remove_instance_variable(cache_var)
+        memo_registry.delete(method_name)
+        true
+      else
+        false
+      end
+    end
+
+    # Clears all memoized method caches for the current instance.
+    #
+    # @return [Integer] number of caches cleared
+    def clear_all_memoized_methods
+      return 0 unless defined?(@memo_registry)
+
+      @memo_registry.each do |method_name|
+        cache_var = "@__memo_ttl_cache__#{method_name}"
+        remove_instance_variable(cache_var) if instance_variable_defined?(cache_var)
+      end
+
+      count = @memo_registry.size
+      @memo_registry.clear
+      count
+    end
+
+    # Cleans up expired entries in all memoized caches.
+    #
+    # @return [Hash] results of cleanup operation for each cache
+    def cleanup_memoized_methods
+      results = {}
+      return results unless defined?(@memo_registry)
+
+      @memo_registry.each do |method_name|
+        cache_var = "@__memo_ttl_cache__#{method_name}"
+        next unless instance_variable_defined?(cache_var)
+
+        cache = instance_variable_get(cache_var)
+
+        begin
+          cache.cleanup
+          results[method_name] = :success
+        rescue MemoTTL::CacheOperationError => e
+          results[method_name] = e.message
+        end
+      end
+      results
+    end
+
+    # Checks if a memoized cache exists for a given method.
+    #
+    # @param method_name [Symbol]
+    # @return [Boolean]
+    def memoized?(method_name)
+      instance_variable_defined?("@__memo_ttl_cache__#{method_name}")
+    end
+
+    private
+
+    def memo_registry
+      @memo_registry ||= Set.new
+    end
+
+    def fetch_or_create_cache(cache_var, ttl, max_size)
+      return instance_variable_get(cache_var) if instance_variable_defined?(cache_var)
+
+      begin
+        cache = Cache.new(ttl: ttl, max_size: max_size)
+        instance_variable_set(cache_var, cache)
+        method_name = cache_var.to_s.sub("@__memo_ttl_cache__", "").to_sym
+        memo_registry << method_name
+        cache
+      rescue ArgumentError => e
+        raise MemoTTL::Error, "Failed to create cache: #{e.message}"
+      end
+    end
+
+    def build_cache_key(method_name, args, block)
+      block_hash =
+        if block.nil?
+          "no_block"
+        else
+          Digest::SHA256.hexdigest(block.source_location.inspect)
+        end
+
+      raw_key = [method_name, args, block_hash]
+      Digest::SHA256.hexdigest(Marshal.dump(raw_key))
+    rescue StandardError => e
+      raise KeyGenerationError, "Failed to generate cache key: #{e.message}"
+    end
+
+    def fetch_or_compute_result(cache, key, original_method, args, block)
+      result = cache.get(key)
+      return result unless result.nil? && !cache.key?(key)
+
+      begin
+        result = original_method.bind(self).call(*args, &block)
+      rescue NoMethodError => e
+        raise MethodBindingError, "Failed to bind method: #{e.message}"
+      rescue StandardError => e
+        raise e
+      end
+
+      cache.set(key, result)
+      result
+    end
+  end
+end

data/lib/memo_ttl/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MemoTtl
+  VERSION = "0.9.21"
+end

data/lib/memo_ttl.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "memo_ttl/version"
+require_relative "memo_ttl/class_methods"
+require_relative "memo_ttl/instance_methods"
+
+# MemoTTL is a thread-safe memoization utility with TTL and LRU eviction.
+module MemoTTL
+  class Error < StandardError; end
+  class KeyGenerationError < Error; end
+  class MethodBindingError < Error; end
+  class CacheOperationError < Error; end
+
+  # Hook that wires ClassMethods and InstanceMethods when the module is included.
+  #
+  # @param base [Class] the class including MemoTTL
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.include(InstanceMethods)
+  end
+end

data/sig/memo_ttl.rbs

@@ -0,0 +1,4 @@
+module MemoTtl
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: memo_ttl
+version: !ruby/object:Gem::Version
+  version: 0.9.21
+platform: ruby
+authors:
+- Mishal Zaman
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Adds memoization to methods with optional time-to-live and LRU eviction
+email:
+- mishalzaman@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rspec_status"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/memo_ttl.rb
+- lib/memo_ttl/cache.rb
+- lib/memo_ttl/class_methods.rb
+- lib/memo_ttl/instance_methods.rb
+- lib/memo_ttl/version.rb
+- sig/memo_ttl.rbs
+homepage: https://github.com/mishalzaman/memo_ttl
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/mishalzaman/memo_ttl
+  source_code_uri: https://github.com/mishalzaman/memo_ttl
+  changelog_uri: https://github.com/mishalzaman/memo_ttl/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Memoization with LRU and TTL
+test_files: []