sin_lru_redux 2.0.1 → 2.2.0

data/lib/lru_redux/cache.rb

@@ -1,56 +1,58 @@
 # frozen_string_literal: true
 
 class LruRedux::Cache
+  attr_reader :max_size, :ignore_nil
+
   def initialize(*args)
     max_size, ignore_nil, _ = args
 
+    max_size ||= 1000
     ignore_nil ||= false
 
-    raise ArgumentError.new(:max_size) unless valid_max_size?(max_size)
-    raise ArgumentError.new(:ignore_nil) unless valid_ignore_nil?(ignore_nil)
+    validate_max_size!(max_size)
+    validate_ignore_nil!(ignore_nil)
 
     @max_size = max_size
     @ignore_nil = ignore_nil
     @data = {}
   end
 
-  def max_size=(max_size)
-    max_size ||= @max_size
-
-    raise ArgumentError.new(:max_size) unless valid_max_size?(max_size)
-
-    @max_size = max_size
+  def max_size=(new_max_size)
+    validate_max_size!(new_max_size)
 
-    @data.shift while @data.size > @max_size
+    @max_size = new_max_size
+    evict_excess
   end
 
   def ttl=(_)
     nil
   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)
+    validate_ignore_nil!(new_ignore_nil)
 
-    @ignore_nil = ignore_nil
+    @ignore_nil = new_ignore_nil
+    evict_nil
   end
 
   def getset(key)
-    found = true
-    value = @data.delete(key) { found = false }
-    if found
+    key_found = true
+    value = @data.delete(key) { key_found = false }
+
+    if key_found
       @data[key] = value
     else
-      result = @data[key] = yield
-      @data.shift if @data.length > @max_size
+      result = yield
+      store_item(key, result)
       result
     end
   end
 
   def fetch(key)
-    found = true
-    value = @data.delete(key) { found = false }
-    if found
+    key_found = true
+    value = @data.delete(key) { key_found = false }
+
+    if key_found
       @data[key] = value
     else
       yield if block_given? # rubocop:disable Style/IfInsideElse
@@ -58,46 +60,39 @@ class LruRedux::Cache
   end
 
   def [](key)
-    found = true
-    value = @data.delete(key) { found = false }
-    @data[key] = value if found
+    key_found = true
+    value = @data.delete(key) { key_found = false }
+    return unless key_found
+
+    @data[key] = value
   end
 
   def []=(key, val)
-    @data.delete(key)
-    @data[key] = val
-    @data.shift if @data.length > @max_size
-    val # rubocop:disable Lint/Void
+    store_item(key, val)
   end
 
   def each(&block)
-    array = @data.to_a
-    array.reverse!.each(&block)
+    @data.to_a.reverse_each(&block)
   end
-
-  # used further up the chain, non thread safe each
+  # Used further up the chain, non thread safe each
   alias_method :each_unsafe, :each
 
   def to_a
-    array = @data.to_a
-    array.reverse!
+    @data.to_a.reverse
   end
 
   def values
-    vals = @data.values
-    vals.reverse!
+    @data.values.reverse
   end
 
   def delete(key)
     @data.delete(key)
   end
-
   alias_method :evict, :delete
 
   def key?(key)
     @data.key?(key)
   end
-
   alias_method :has_key?, :key?
 
   def clear
@@ -108,24 +103,59 @@ class LruRedux::Cache
     @data.size
   end
 
-  protected
+  private
 
-  # for cache validation only, ensures all is sound
+  # For cache validation only, ensure all is valid
   def valid?
     true
   end
 
-  private
+  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
+
+    raise ArgumentError.new(<<~ERROR)
+      Invalid max_size: #{max_size.inspect}
+      max_size must be greater than or equal to 1.
+    ERROR
+  end
 
-  def valid_max_size?(max_size)
-    return true if max_size.is_a?(Integer) && max_size >= 1
+  def validate_ignore_nil!(ignore_nil)
+    return if [true, false].include?(ignore_nil)
 
-    false
+    raise ArgumentError.new(<<~ERROR)
+      Invalid ignore_nil: #{ignore_nil.inspect}
+      ignore_nil must be a boolean value.
+    ERROR
+  end
+
+  def evict_excess
+    @data.shift while @data.size > @max_size
   end
 
-  def valid_ignore_nil?(ignore_nil)
-    return true if [true, false].include?(ignore_nil)
+  if RUBY_VERSION >= '2.6.0'
+    def evict_nil
+      return unless @ignore_nil
 
-    false
+      @data.compact!
+    end
+  else
+    def evict_nil
+      return unless @ignore_nil
+
+      @data.reject! { |_key, value| value.nil? }
+    end
+  end
+
+  def store_item(key, val)
+    @data.delete(key)
+    @data[key] = val if !val.nil? || !@ignore_nil
+    evict_excess
+    val
   end
 end

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,54 @@ module LruRedux
         @data_ttl = {}
       end
 
-      def max_size=(max_size)
-        max_size ||= @max_size
+      def max_size=(new_max_size)
+        validate_max_size!(new_max_size)
 
-        raise ArgumentError.new(:max_size) unless valid_max_size?(max_size)
-
-        @max_size = max_size
-
-        resize
+        @max_size = new_max_size
+        evict_expired
+        evict_excess
       end
 
-      def ttl=(ttl)
-        ttl ||= @ttl
-        raise ArgumentError.new(:ttl) unless valid_ttl?(ttl)
-
-        @ttl = ttl
+      def ttl=(new_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)
+        validate_ignore_nil!(new_ignore_nil)
 
-        @ignore_nil = ignore_nil
+        @ignore_nil = new_ignore_nil
+        evict_nil
       end
 
       def getset(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
           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
+
+        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
           yield if block_given? # rubocop:disable Style/IfInsideElse
@@ -87,71 +78,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
-
-      def []=(key, val)
-        ttl_evict
+        key_found = true
+        value = @data_lru.delete(key) { key_found = false }
+        return unless key_found
 
-        @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,65 +134,105 @@ module LruRedux
         @data_lru.clear
       end
 
-      def expire
-        ttl_evict
-      end
-
       def count
         @data_lru.size
       end
 
-      protected
+      def expire
+        evict_expired
+      end
+
+      private
 
-      # for cache validation only, ensures all is sound
+      # For cache validation only, ensure all is valid
       def valid?
         @data_lru.size == @data_ttl.size
       end
 
-      def ttl_evict
-        return if @ttl == :none
+      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
 
-        ttl_horizon = Time.now.to_f - @ttl
-        key, time = @data_ttl.first
+        raise ArgumentError.new(<<~ERROR)
+          Invalid max_size: #{max_size.inspect}
+          max_size must be greater than or equal to 1.
+        ERROR
+      end
 
-        until time.nil? || time > ttl_horizon
-          @data_ttl.delete(key)
-          @data_lru.delete(key)
+      def validate_ttl!(ttl)
+        return if ttl == :none
 
-          key, time = @data_ttl.first
+        unless ttl.is_a?(Numeric)
+          raise ArgumentError.new(<<~ERROR)
+            Invalid ttl: #{ttl.inspect}
+            ttl must be a number.
+          ERROR
         end
+        return if ttl >= 0
+
+        raise ArgumentError.new(<<~ERROR)
+          Invalid ttl: #{ttl.inspect}
+          ttl must be greater than or equal to 0.
+        ERROR
       end
 
-      def resize
-        ttl_evict
+      def validate_ignore_nil!(ignore_nil)
+        return if [true, false].include?(ignore_nil)
+
+        raise ArgumentError.new("Invalid ignore_nil: #{ignore_nil.inspect}")
+      end
 
-        while @data_lru.size > @max_size
-          key, _ = @data_lru.first
+      def evict_expired
+        return if @ttl == :none
 
-          @data_ttl.delete(key)
+        expiration_threshold = Time.now.to_f - @ttl
+        key, time = @data_ttl.first
+        until time.nil? || time > expiration_threshold
           @data_lru.delete(key)
+          @data_ttl.delete(key)
+          key, time = @data_ttl.first
         end
       end
 
-      private
+      def evict_excess
+        evict_least_recently_used while @data_lru.size > @max_size
+      end
 
-      def valid_max_size?(max_size)
-        return true if max_size.is_a?(Integer) && max_size >= 1
+      def evict_least_recently_used
+        return if @data_lru.empty?
 
-        false
+        oldest_key, _value = @data_lru.first
+        @data_lru.delete(oldest_key)
+        @data_ttl.delete(oldest_key)
       end
 
-      def valid_ttl?(ttl)
-        return true if ttl == :none
-        return true if ttl.is_a?(Numeric) && ttl >= 0
+      def evict_nil
+        return unless @ignore_nil
 
-        false
+        @data_lru.reject! do |key, value|
+          if value.nil?
+            @data_ttl.delete(key)
+            true
+          else
+            false
+          end
+        end
       end
 
-      def valid_ignore_nil?(ignore_nil)
-        return true if [true, false].include?(ignore_nil)
-
-        false
+      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_excess
+        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.1'
+  VERSION = '2.2.0'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: sin_lru_redux
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.2.0
 platform: ruby
 authors:
 - Masahiro
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2024-12-28 00:00:00.000000000 Z
+date: 2024-12-31 00:00:00.000000000 Z
 dependencies: []
 description: |
   Efficient and thread-safe LRU cache.
@@ -18,17 +18,12 @@ 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
@@ -38,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/v2.0.1
+homepage: https://github.com/cadenza-tech/sin_lru_redux/tree/v2.2.0
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/cadenza-tech/sin_lru_redux/tree/v2.0.1
-  source_code_uri: https://github.com/cadenza-tech/sin_lru_redux/tree/v2.0.1
-  changelog_uri: https://github.com/cadenza-tech/sin_lru_redux/blob/2.0.1#changelog
+  homepage_uri: https://github.com/cadenza-tech/sin_lru_redux/tree/v2.2.0
+  source_code_uri: https://github.com/cadenza-tech/sin_lru_redux/tree/v2.2.0
+  changelog_uri: https://github.com/cadenza-tech/sin_lru_redux/blob/v2.2.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.1
+  documentation_uri: https://rubydoc.info/gems/sin_lru_redux/2.2.0
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:

data/.github/workflows/lint.yml

@@ -1,19 +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:
-          ruby-version: 3.4
-          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