sin_lru_redux 2.0.0 → 2.1.0

data/lib/lru_redux/ttl/cache.rb

@@ -8,12 +8,13 @@ module LruRedux
       def initialize(*args)
         max_size, ttl, ignore_nil = args
 
+        max_size ||= 1000
         ttl ||= :none
         ignore_nil ||= false
 
-        raise ArgumentError.new(:max_size) unless valid_max_size?(max_size)
-        raise ArgumentError.new(:ttl) unless valid_ttl?(ttl)
-        raise ArgumentError.new(:ignore_nil) unless valid_ignore_nil?(ignore_nil)
+        validate_max_size!(max_size)
+        validate_ttl!(ttl)
+        validate_ignore_nil!(ignore_nil)
 
         @max_size = max_size
         @ttl = ttl
@@ -22,64 +23,59 @@ module LruRedux
         @data_ttl = {}
       end
 
-      def max_size=(max_size)
-        max_size ||= @max_size
+      def max_size=(new_max_size)
+        new_max_size ||= @max_size
 
-        raise ArgumentError.new(:max_size) unless valid_max_size?(max_size)
-
-        @max_size = max_size
+        validate_max_size!(new_max_size)
 
+        @max_size = new_max_size
         resize
       end
 
-      def ttl=(ttl)
-        ttl ||= @ttl
-        raise ArgumentError.new(:ttl) unless valid_ttl?(ttl)
+      def ttl=(new_ttl)
+        new_ttl ||= @ttl
 
-        @ttl = ttl
+        validate_ttl!(new_ttl)
 
-        ttl_evict
+        @ttl = new_ttl
+        evict_expired
       end
 
-      def ignore_nil=(ignore_nil)
-        ignore_nil ||= @ignore_nil
-        raise ArgumentError.new(:ignore_nil) unless valid_ignore_nil?(ignore_nil)
+      def ignore_nil=(new_ignore_nil)
+        new_ignore_nil ||= @ignore_nil
 
-        @ignore_nil = ignore_nil
+        validate_ignore_nil!(new_ignore_nil)
+
+        @ignore_nil = new_ignore_nil
+        evict_nil
       end
 
       def getset(key)
-        ttl_evict
+        evict_expired
+
+        key_found = true
+        value = @data_lru.delete(key) { key_found = false }
 
-        found = true
-        value = @data_lru.delete(key) { found = false }
-        if found
+        if key_found
+          @data_ttl.delete(key)
+          @data_ttl[key] = Time.now.to_f
           @data_lru[key] = value
         else
           result = yield
-
-          if !result.nil? || !@ignore_nil
-            @data_lru[key] = result
-            @data_ttl[key] = Time.now.to_f
-
-            if @data_lru.size > @max_size
-              key, _ = @data_lru.first
-
-              @data_ttl.delete(key)
-              @data_lru.delete(key)
-            end
-          end
-
+          store_item(key, result)
           result
         end
       end
 
       def fetch(key)
-        ttl_evict
+        evict_expired
 
-        found = true
-        value = @data_lru.delete(key) { found = false }
-        if found
+        key_found = true
+        value = @data_lru.delete(key) { key_found = false }
+
+        if key_found
+          @data_ttl.delete(key)
+          @data_ttl[key] = Time.now.to_f
           @data_lru[key] = value
         else
           yield if block_given? # rubocop:disable Style/IfInsideElse
@@ -87,71 +83,55 @@ module LruRedux
       end
 
       def [](key)
-        ttl_evict
+        evict_expired
 
-        found = true
-        value = @data_lru.delete(key) { found = false }
-        @data_lru[key] = value if found
-      end
+        key_found = true
+        value = @data_lru.delete(key) { key_found = false }
+        return unless key_found
 
-      def []=(key, val)
-        ttl_evict
-
-        @data_lru.delete(key)
         @data_ttl.delete(key)
-
-        @data_lru[key] = val
         @data_ttl[key] = Time.now.to_f
+        @data_lru[key] = value
+      end
 
-        if @data_lru.size > @max_size
-          key, _ = @data_lru.first
-
-          @data_ttl.delete(key)
-          @data_lru.delete(key)
-        end
+      def []=(key, val)
+        evict_expired
 
-        val # rubocop:disable Lint/Void
+        store_item(key, val)
       end
 
       def each(&block)
-        ttl_evict
+        evict_expired
 
-        array = @data_lru.to_a
-        array.reverse!.each(&block)
+        @data_lru.to_a.reverse_each(&block)
       end
-
-      # used further up the chain, non thread safe each
       alias_method :each_unsafe, :each
 
       def to_a
-        ttl_evict
+        evict_expired
 
-        array = @data_lru.to_a
-        array.reverse!
+        @data_lru.to_a.reverse
       end
 
       def values
-        ttl_evict
+        evict_expired
 
-        vals = @data_lru.values
-        vals.reverse!
+        @data_lru.values.reverse
       end
 
       def delete(key)
-        ttl_evict
+        evict_expired
 
         @data_ttl.delete(key)
         @data_lru.delete(key)
       end
-
       alias_method :evict, :delete
 
       def key?(key)
-        ttl_evict
+        evict_expired
 
         @data_lru.key?(key)
       end
-
       alias_method :has_key?, :key?
 
       def clear
@@ -159,63 +139,110 @@ module LruRedux
         @data_lru.clear
       end
 
-      def expire
-        ttl_evict
-      end
-
       def count
         @data_lru.size
       end
 
-      protected
+      def expire
+        evict_expired
+      end
 
-      def valid_max_size?(max_size)
-        return true if max_size.is_a?(Integer) && max_size >= 1
+      private
 
-        false
+      # For cache validation only, ensure all is valid
+      def valid?
+        @data_lru.size == @data_ttl.size
       end
 
-      def valid_ttl?(ttl)
-        return true if ttl == :none
-        return true if ttl.is_a?(Numeric) && ttl >= 0
+      def validate_max_size!(max_size)
+        unless max_size.is_a?(Numeric)
+          raise ArgumentError.new(<<~ERROR)
+            Invalid max_size: #{max_size.inspect}
+            max_size must be a number.
+          ERROR
+        end
+        return if max_size >= 1
 
-        false
+        raise ArgumentError.new(<<~ERROR)
+          Invalid max_size: #{max_size.inspect}
+          max_size must be greater than or equal to 1.
+        ERROR
       end
 
-      def valid_ignore_nil?(ignore_nil)
-        return true if [true, false].include?(ignore_nil)
+      def validate_ttl!(ttl)
+        return if ttl == :none
+
+        unless ttl.is_a?(Numeric)
+          raise ArgumentError.new(<<~ERROR)
+            Invalid ttl: #{ttl.inspect}
+            ttl must be a number.
+          ERROR
+        end
+        return if ttl >= 0
 
-        false
+        raise ArgumentError.new(<<~ERROR)
+          Invalid ttl: #{ttl.inspect}
+          ttl must be greater than or equal to 0.
+        ERROR
       end
 
-      # for cache validation only, ensures all is sound
-      def valid?
-        @data_lru.size == @data_ttl.size
+      def validate_ignore_nil!(ignore_nil)
+        return if [true, false].include?(ignore_nil)
+
+        raise ArgumentError.new("Invalid ignore_nil: #{ignore_nil.inspect}")
+      end
+
+      def resize
+        evict_expired
+        evict_if_exceeded
       end
 
-      def ttl_evict
+      def evict_expired
         return if @ttl == :none
 
-        ttl_horizon = Time.now.to_f - @ttl
+        expiration_threshold = Time.now.to_f - @ttl
         key, time = @data_ttl.first
-
-        until time.nil? || time > ttl_horizon
-          @data_ttl.delete(key)
+        until time.nil? || time > expiration_threshold
           @data_lru.delete(key)
-
+          @data_ttl.delete(key)
           key, time = @data_ttl.first
         end
       end
 
-      def resize
-        ttl_evict
+      def evict_if_exceeded
+        evict_least_recently_used while @data_lru.size > @max_size
+      end
 
-        while @data_lru.size > @max_size
-          key, _ = @data_lru.first
+      def evict_least_recently_used
+        return if @data_lru.empty?
 
-          @data_ttl.delete(key)
-          @data_lru.delete(key)
+        oldest_key, _value = @data_lru.first
+        @data_lru.delete(oldest_key)
+        @data_ttl.delete(oldest_key)
+      end
+
+      def evict_nil
+        return unless @ignore_nil
+
+        @data_lru.reject! do |key, value|
+          if value.nil?
+            @data_ttl.delete(key)
+            true
+          else
+            false
+          end
+        end
+      end
+
+      def store_item(key, value)
+        @data_lru.delete(key)
+        @data_ttl.delete(key)
+        if !value.nil? || !@ignore_nil
+          @data_lru[key] = value
+          @data_ttl[key] = Time.now.to_f
         end
+        evict_if_exceeded
+        value
       end
     end
   end

data/lib/lru_redux/util/safe_sync.rb

@@ -107,6 +107,8 @@ module LruRedux
         end
       end
 
+      private
+
       def valid?
         synchronize do
           super

data/lib/lru_redux/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LruRedux
-  VERSION = '2.0.0'
+  VERSION = '2.1.0'
 end

metadata

@@ -1,32 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: sin_lru_redux
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Masahiro
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2024-12-28 00:00:00.000000000 Z
+date: 2024-12-30 00:00:00.000000000 Z
 dependencies: []
-description: An efficient implementation of an lru cache
+description: |
+  Efficient and thread-safe LRU cache.
+  Forked from LruRedux.
 email:
 - watanabe@cadenza-tech.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".github/workflows/lint.yml"
-- ".github/workflows/test.yml"
-- ".gitignore"
 - ".rubocop.yml"
-- Gemfile
-- Guardfile
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
 - LICENSE.txt
 - README.md
 - Rakefile
-- bench/bench.rb
-- bench/bench_ttl.rb
 - lib/lru_redux.rb
 - lib/lru_redux/cache.rb
 - lib/lru_redux/thread_safe_cache.rb
@@ -36,20 +33,15 @@ files:
 - lib/lru_redux/util.rb
 - lib/lru_redux/util/safe_sync.rb
 - lib/lru_redux/version.rb
-- sin_lru_redux.gemspec
-- test/cache_test.rb
-- test/thread_safe_cache_test.rb
-- test/ttl/cache_test.rb
-- test/ttl/thread_safe_cache_test.rb
-homepage: https://github.com/cadenza-tech/sin_lru_redux/tree/2.0.0/sin_lru_redux
+homepage: https://github.com/cadenza-tech/sin_lru_redux/tree/v2.1.0
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/cadenza-tech/sin_lru_redux/tree/2.0.0/sin_lru_redux
-  source_code_uri: https://github.com/cadenza-tech/sin_lru_redux/tree/2.0.0/sin_lru_redux
-  changelog_uri: https://github.com/cadenza-tech/sin_lru_redux/blob/2.0.0#changelog
+  homepage_uri: https://github.com/cadenza-tech/sin_lru_redux/tree/v2.1.0
+  source_code_uri: https://github.com/cadenza-tech/sin_lru_redux/tree/v2.1.0
+  changelog_uri: https://github.com/cadenza-tech/sin_lru_redux/blob/v2.1.0/CHANGELOG.md
   bug_tracker_uri: https://github.com/cadenza-tech/sin_lru_redux/issues
-  documentation_uri: https://rubydoc.info/gems/sin_lru_redux/2.0.0
+  documentation_uri: https://rubydoc.info/gems/sin_lru_redux/2.1.0
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -67,5 +59,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.2
 specification_version: 4
-summary: An efficient implementation of an lru cache
+summary: Efficient and thread-safe LRU cache.
 test_files: []

data/.github/workflows/lint.yml

@@ -1,18 +0,0 @@
-name: Lint
-on:
-  pull_request:
-    paths:
-      - '**/*.rb'
-permissions:
-  contents: read
-jobs:
-  lint:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Set up Ruby
-        uses: ruby/setup-ruby@v1
-        with:
-          bundler-cache: true
-      - name: RuboCop
-        run: bundle exec rake rubocop

data/.github/workflows/test.yml

@@ -1,21 +0,0 @@
-name: Test
-on:
-  pull_request:
-permissions:
-  contents: read
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        ruby-version: [2.3, 2.4, 2.5, 2.6, 2.7, 3.0, 3.1, 3.2, 3.3, 3.4]
-    steps:
-      - uses: actions/checkout@v4
-      - name: Set up Ruby
-        uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: ${{ matrix.ruby-version }}
-          bundler-cache: true
-      - name: Run tests
-        run: bundle exec rake test

data/.gitignore

@@ -1,19 +0,0 @@
-*.gem
-*.rbc
-*.swp
-.bundle
-.config
-.vscode
-.yardoc
-_yardoc
-coverage
-doc/
-Gemfile.lock
-InstalledFiles
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp

data/Gemfile

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-source 'https://rubygems.org'
-
-gemspec
-
-group :development, :test do
-  gem 'bundler'
-  gem 'guard'
-  gem 'guard-minitest'
-  gem 'minitest'
-  gem 'rake'
-  gem 'rb-inotify'
-  gem 'rubocop'
-  gem 'rubocop-minitest'
-  gem 'rubocop-performance'
-  gem 'rubocop-rake'
-  gem 'timecop'
-end

data/Guardfile

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-guard 'minitest', focus_on_failed: true do
-  watch(%r{^test/.+_test\.rb$})
-  watch(%r{^lib/lru_redux/(.+)\.rb$}) { |m| "test/#{m[1]}_test.rb" }
-end

data/bench/bench.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler'
-require 'benchmark'
-require 'lru'
-require 'lru_cache'
-require 'threadsafe-lru'
-
-Bundler.require
-
-# Lru
-lru = Cache::LRU.new(max_elements: 1_000)
-
-# LruCache
-lru_cache = LRUCache.new(1_000)
-
-# ThreadSafeLru
-thread_safe_lru = ThreadSafeLru::LruCache.new(1_000)
-
-# LruRedux
-redux = LruRedux::Cache.new(1_000)
-redux_thread_safe = LruRedux::ThreadSafeCache.new(1_000)
-
-puts '** LRU Benchmarks **'
-
-Benchmark.bmbm do |bm|
-  bm.report 'ThreadSafeLru' do
-    1_000_000.times { thread_safe_lru.get(rand(2_000)) { :value } }
-  end
-
-  bm.report 'LRU' do
-    1_000_000.times { lru[rand(2_000)] ||= :value }
-  end
-
-  bm.report 'LRUCache' do
-    1_000_000.times { lru_cache[rand(2_000)] ||= :value }
-  end
-
-  bm.report 'LruRedux::Cache' do
-    1_000_000.times { redux.getset(rand(2_000)) { :value } }
-  end
-
-  bm.report 'LruRedux::ThreadSafeCache' do
-    1_000_000.times { redux_thread_safe.getset(rand(2_000)) { :value } }
-  end
-end

data/bench/bench_ttl.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler'
-require 'benchmark'
-require 'fast_cache'
-
-Bundler.require
-
-# FastCache
-fast_cache = FastCache::Cache.new(1_000, 5 * 60)
-
-# LruRedux
-redux_ttl = LruRedux::TTL::Cache.new(1_000, 5 * 60)
-redux_ttl_thread_safe = LruRedux::TTL::ThreadSafeCache.new(1_000, 5 * 60)
-redux_ttl_disabled = LruRedux::TTL::Cache.new(1_000, :none)
-
-puts '** TTL Benchmarks **'
-
-Benchmark.bmbm do |bm|
-  bm.report 'FastCache' do
-    1_000_000.times { fast_cache.fetch(rand(2_000)) { :value } } # rubocop:disable Style/RedundantFetchBlock
-  end
-
-  bm.report 'LruRedux::TTL::Cache' do
-    1_000_000.times { redux_ttl.getset(rand(2_000)) { :value } }
-  end
-
-  bm.report 'LruRedux::TTL::ThreadSafeCache' do
-    1_000_000.times { redux_ttl_thread_safe.getset(rand(2_000)) { :value } }
-  end
-
-  bm.report 'LruRedux::TTL::Cache (TTL disabled)' do
-    1_000_000.times { redux_ttl_disabled.getset(rand(2_000)) { :value } }
-  end
-end

data/sin_lru_redux.gemspec

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-lib = File.expand_path('lib', __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'lru_redux/version'
-
-Gem::Specification.new do |spec|
-  spec.name = 'sin_lru_redux'
-  spec.version = LruRedux::VERSION
-  spec.description = 'An efficient implementation of an lru cache'
-  spec.summary = 'An efficient implementation of an lru cache'
-  spec.authors = ['Masahiro']
-  spec.email = ['watanabe@cadenza-tech.com']
-  spec.license = 'MIT'
-
-  github_root_uri = 'https://github.com/cadenza-tech/sin_lru_redux'
-  spec.homepage = "#{github_root_uri}/tree/#{spec.version}/#{spec.name}"
-  spec.metadata = {
-    'homepage_uri' => spec.homepage,
-    'source_code_uri' => spec.homepage,
-    'changelog_uri' => "#{github_root_uri}/blob/#{spec.version}#changelog",
-    'bug_tracker_uri' => "#{github_root_uri}/issues",
-    'documentation_uri' => "https://rubydoc.info/gems/#{spec.name}/#{spec.version}",
-    'rubygems_mfa_required' => 'true'
-  }
-
-  spec.required_ruby_version = '>= 2.3.0'
-
-  spec.files = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
-  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
-end