zache 0.15.1 → 0.15.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ed02e68e04482b0ac7df8addc19dd0c02683191c53b3f3b391930e9b8ed4842
-  data.tar.gz: ec695943e4b8e9ba6793dd8db9dde826e6bc23cbd2ba92122aae5f52567aace2
+  metadata.gz: e9cc0b6c8fece285753b4a7bc12bc296f9cab08b7adacee09dd888f556263e4c
+  data.tar.gz: 722f973b74565b70225b44f1de8f6c63ddccf18bbb534ba31a9b1c4c24bbb60d
 SHA512:
-  metadata.gz: d8758c5554cc1686ec3b82819977982103754cccebefb4b4e3df38d23b77541d82b13ef36626677b5fc4685ea6c7013e14f6e2da113b8cc6d6af376feb56fef3
-  data.tar.gz: 261616852da299a0376422d7f86bd62c3e89497874e859c620ba71017825f3e6be9db1cc6beca6feeacb091432137d2fac0fe8b79b1bd8a4595c67f322900810
+  metadata.gz: 9ff5b92b44b011b8cb689538e7d4eade3d7d216a89a94b0b85da769bece6610ba9aa27e143f766bbac0b736de65bd7d7faba803b1af4c93876e02913843b819a
+  data.tar.gz: dfb50539962ba04cf80db2ceff76dc01abfa3596fd3dc46a21e7d23cc03219e52098a2c77525d0e1ed35b4ea6b31fed6a5f548c228f1105639d66852c4594ac8

data/Gemfile.lock

@@ -46,7 +46,7 @@ GEM
     racc (1.8.1)
     rainbow (3.1.1)
     rake (13.3.1)
-    rdoc (6.15.1)
+    rdoc (6.16.1)
       erb
       psych (>= 4.0.0)
       tsort

data/Rakefile

@@ -10,7 +10,7 @@ require 'rake'
 require 'rake/clean'
 require 'shellwords'
 
-CLEAN = FileList['coverage']
+CLEAN.include('coverage')
 
 def name
   @name ||= File.basename(Dir['*.gemspec'].first, '.*')
@@ -28,6 +28,9 @@ Rake::TestTask.new(:test) do |test|
   test.libs << 'lib' << 'test'
   test.pattern = 'test/**/test_*.rb'
   test.verbose = false
+  test.options = '--verbose' if ENV['VERBOSE']
+  # Disable minitest plugins on Windows to avoid gem conflicts
+  ENV['MT_NO_PLUGINS'] = '1' if OS.windows?
 end
 
 desc 'Run them via Ruby, one by one'

data/lib/zache.rb

@@ -115,33 +115,11 @@ class Zache
   # @return [Object] The cached value
   def get(key, lifetime: 2**32, dirty: false, placeholder: nil, eager: false, &block)
     if block_given?
-      if (dirty || @dirty) && locked?(key)
-        synchronize_all do
-          return @hash[key][:value] if expired_unsafe?(key) && @hash.key?(key)
-        end
-      end
-      if eager
-        has_key = synchronize_all { @hash.key?(key) }
-        return synchronize_all { @hash[key][:value] } if has_key
-        put(key, placeholder, lifetime: 0)
-        Thread.new do
-          synchronize_one(key) { calc(key, lifetime, &block) }
-        end
-        placeholder
-      else
-        synchronize_one(key) { calc(key, lifetime, &block) }
-      end
+      return get_dirty_value(key) if should_return_dirty?(key, dirty)
+      return get_eager(key, lifetime, placeholder, &block) if eager
+      synchronize_one(key) { calc(key, lifetime, &block) }
     else
-      synchronize_all do
-        rec = @hash[key]
-        if expired_unsafe?(key)
-          return rec[:value] if dirty || @dirty
-          @hash.delete(key)
-          rec = nil
-        end
-        raise 'The key is absent in the cache' if rec.nil?
-        rec[:value]
-      end
+      get_without_block(key, dirty)
     end
   end
 
@@ -215,14 +193,19 @@ class Zache
   # @yield Block to call if the key is not found
   # @return [Object] The removed value or the result of the block
   def remove(key)
-    synchronize_one(key) { @hash.delete(key) { yield if block_given? } }
+    result = synchronize_one(key) { @hash.delete(key) { yield if block_given? } }
+    synchronize_all { @locks.delete(key) }
+    result
   end
 
   # Remove all keys from the cache.
   #
   # @return [Hash] Empty hash
   def remove_all
-    synchronize_all { @hash = {} }
+    synchronize_all do
+      @hash = {}
+      @locks = {}
+    end
   end
 
   # Remove all keys that match the block.
@@ -234,10 +217,10 @@ class Zache
     synchronize_all do
       count = 0
       @hash.each_key do |k|
-        if yield(k)
-          @hash.delete(k)
-          count += 1
-        end
+        next unless yield(k)
+        @hash.delete(k)
+        @locks.delete(k)
+        count += 1
       end
       count
     end
@@ -250,7 +233,11 @@ class Zache
   def clean
     synchronize_all do
       size_before = @hash.size
-      @hash.delete_if { |key, _value| expired_unsafe?(key) }
+      @hash.delete_if do |key, _value|
+        expired = expired_unsafe?(key)
+        @locks.delete(key) if expired
+        expired
+      end
       size_before - @hash.size
     end
   end
@@ -264,6 +251,84 @@ class Zache
 
   private
 
+  # Checks if dirty value should be returned for a locked key
+  # @param key [Object] The key to check
+  # @param dirty [Boolean] Whether dirty reads are allowed
+  # @return [Boolean] True if dirty value should be returned
+  def should_return_dirty?(key, dirty)
+    (dirty || @dirty) && locked?(key) && expired_value?(key)
+  end
+
+  # Checks if key has an expired value in cache
+  # @param key [Object] The key to check
+  # @return [Boolean] True if key exists and is expired
+  def expired_value?(key)
+    synchronize_all do
+      rec = @hash[key]
+      !rec.nil? && expired_unsafe?(key)
+    end
+  end
+
+  # Gets the dirty cached value without recalculation
+  # @param key [Object] The key to retrieve
+  # @return [Object] The cached value
+  def get_dirty_value(key)
+    synchronize_all { @hash[key][:value] }
+  end
+
+  # Handles eager mode get operation
+  # @param key [Object] The key to retrieve
+  # @param lifetime [Integer] Time in seconds until the key expires
+  # @param placeholder [Object] The placeholder to return immediately
+  # @yield Block that provides the value
+  # @return [Object] The placeholder value
+  def get_eager(key, lifetime, placeholder, &block)
+    return synchronize_all { @hash[key][:value] } if synchronize_all { @hash.key?(key) }
+
+    put(key, placeholder, lifetime: 0)
+    spawn_calculation_thread(key, lifetime, &block)
+    placeholder
+  end
+
+  # Spawns a background thread to calculate the value
+  # @param key [Object] The key to calculate for
+  # @param lifetime [Integer] Time in seconds until the key expires
+  # @yield Block that provides the value
+  def spawn_calculation_thread(key, lifetime, &block)
+    Thread.new do
+      synchronize_one(key) { calc(key, lifetime, &block) }
+    rescue StandardError => e
+      cleanup_failed_key(key)
+      raise e
+    end
+  end
+
+  # Cleans up a key after calculation failure
+  # @param key [Object] The key to clean up
+  def cleanup_failed_key(key)
+    synchronize_all do
+      @hash.delete(key)
+      @locks.delete(key)
+    end
+  end
+
+  # Gets value without a block (retrieval only mode)
+  # @param key [Object] The key to retrieve
+  # @param dirty [Boolean] Whether to return expired values
+  # @return [Object] The cached value
+  def get_without_block(key, dirty)
+    synchronize_all do
+      rec = @hash[key]
+      if expired_unsafe?(key)
+        return rec[:value] if dirty || @dirty
+        @hash.delete(key)
+        rec = nil
+      end
+      raise 'The key is absent in the cache' if rec.nil?
+      rec[:value]
+    end
+  end
+
   # Calculates or retrieves a cached value for the given key.
   # @param key [Object] The key to store the value under
   # @param lifetime [Integer] Time in seconds until the key expires
@@ -308,9 +373,9 @@ class Zache
   # @return [Object] The result of the block
   def synchronize_one(key, &block)
     return yield unless @sync
-    @mutex.synchronize do
+    mtx = @mutex.synchronize do
       @locks[key] ||= Mutex.new
     end
-    @locks[key].synchronize(&block)
+    mtx.synchronize(&block)
   end
 end

data/zache.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = Gem::Requirement.new('>= 0') if s.respond_to? :required_rubygems_version=
   s.required_ruby_version = '>= 2.5'
   s.name = 'zache'
-  s.version = '0.15.1' # Version should be updated before release
+  s.version = '0.15.2' # Version should be updated before release
   s.license = 'MIT'
   s.summary = 'In-memory Cache'
   s.description = 'Zero-footprint in-memory thread-safe cache'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zache
 version: !ruby/object:Gem::Version
-  version: 0.15.1
+  version: 0.15.2
 platform: ruby
 authors:
 - Yegor Bugayenko