zache 0.14.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c247c0f146ef35562b8d56169fdb69ef0a9a02796d0e49dfb6c8ed83094dfd24
-  data.tar.gz: d0b659e1315eee6f19b6c708da5b49073d3e0d9a5d5809a424c9b641d330e992
+  metadata.gz: f2c6bee2ddda59d3ddba9115b7f1eaf2037fe28cc217bec57aa1bc2dfb91b660
+  data.tar.gz: 3b1fafcbe3afd075992c0a36df45ca5b51228bd4d1d9c5e086c7523b462ef343
 SHA512:
-  metadata.gz: 23c14258f92e749ee9876b4fae20274a954d71a34a95b427dafd9bef201d17c91c1731d1733345ed564f9e7d74e340c68d9325127a55ab73e5d654ac8d5cb866
-  data.tar.gz: 9232c93c2027dbe83015974315e5c609f3392216c77a96f465cc13f0ddd309fc11d4147234ff23892037619491bb037bc466e28f0075a8be424ef60c28014327
+  metadata.gz: 24f22827fe4b5ea546ea2e121b8aaf35c2646ecbcc4ec7134b0d27693bfa4345d29829d29db1d417ab7759c556f3c21c8cea151f267fdaa282d45d69b8e53a57
+  data.tar.gz: 2a8a4c661c2424a126c8b309825d8d558206db695359793191caf5c1b3e348a147381149258418e7e7469a3e9bfdab30f0164eedfe59383012ed8173fae5fbdf

data/lib/zache.rb

@@ -46,8 +46,9 @@ class Zache
     end
 
     # Always returns false.
+    # @param [Object] key Ignored
     # @return [Boolean] Always returns false
-    def locked?
+    def locked?(_key)
       false
     end
 
@@ -89,6 +90,7 @@ class Zache
     @sync = sync
     @dirty = dirty
     @mutex = Mutex.new
+    @locks = {}
   end
 
   # Total number of keys currently in cache.
@@ -120,18 +122,18 @@ class Zache
   # @return [Object] The cached value
   def get(key, lifetime: 2**32, dirty: false, placeholder: nil, eager: false, &block)
     if block_given?
-      return @hash[key][:value] if (dirty || @dirty) && locked? && expired?(key) && @hash.key?(key)
+      return @hash[key][:value] if (dirty || @dirty) && locked?(key) && expired?(key) && @hash.key?(key)
       if eager
         return @hash[key][:value] if @hash.key?(key)
         put(key, placeholder, lifetime: 0)
         Thread.new do
-          synchronized do
+          synchronize_one(key) do
             calc(key, lifetime, &block)
           end
         end
         placeholder
       else
-        synchronized do
+        synchronize_one(key) do
           calc(key, lifetime, &block)
         end
       end
@@ -183,11 +185,12 @@ class Zache
     rec.nil? ? Time.now : rec[:start]
   end
 
-  # Is cache currently locked doing something?
+  # Is key currently locked doing something?
   #
+  # @param [Object] key The key to check
   # @return [Boolean] True if the cache is locked
-  def locked?
-    @mutex.locked?
+  def locked?(key)
+    @locks[key]&.locked?
   end
 
   # Put a value into the cache.
@@ -197,7 +200,7 @@ class Zache
   # @param lifetime [Integer] Time in seconds until the key expires (default: never expires)
   # @return [Object] The value stored
   def put(key, value, lifetime: 2**32)
-    synchronized do
+    synchronize_one(key) do
       @hash[key] = {
         value: value,
         start: Time.now,
@@ -213,14 +216,14 @@ 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)
-    synchronized { @hash.delete(key) { yield if block_given? } }
+    synchronize_one(key) { @hash.delete(key) { yield if block_given? } }
   end
 
   # Remove all keys from the cache.
   #
   # @return [Hash] Empty hash
   def remove_all
-    synchronized { @hash = {} }
+    synchronize_all { @hash = {} }
   end
 
   # Remove all keys that match the block.
@@ -229,7 +232,7 @@ class Zache
   # @yieldparam key [Object] The cache key to evaluate
   # @return [Integer] Number of keys removed
   def remove_by
-    synchronized do
+    synchronize_all do
       count = 0
       @hash.each_key do |k|
         if yield(k)
@@ -246,7 +249,7 @@ class Zache
   #
   # @return [Integer] Number of keys removed
   def clean
-    synchronized do
+    synchronize_all do
       size_before = @hash.size
       @hash.delete_if { |key, _value| expired?(key) }
       size_before - @hash.size
@@ -284,11 +287,21 @@ class Zache
   # @param block [Proc] The block to execute
   # @yield The block to execute in a synchronized context
   # @return [Object] The result of the block
-  def synchronized(&block)
-    if @sync
-      @mutex.synchronize(&block)
-    else
-      yield
+  def synchronize_all(&block)
+    return yield unless @sync
+    @mutex.synchronize(&block)
+  end
+
+  # Executes a block within a synchronized context if sync is enabled.
+  # @param key [Object] The object to sync
+  # @param block [Proc] The block to execute
+  # @yield The block to execute in a synchronized context
+  # @return [Object] The result of the block
+  def synchronize_one(key, &block)
+    return yield unless @sync
+    @mutex.synchronize do
+      @locks[key] ||= Mutex.new
     end
+    @locks[key].synchronize(&block)
   end
 end

data/test/test_zache.rb

@@ -19,276 +19,290 @@ Thread.report_on_exception = true
 # License:: MIT
 class ZacheTest < Minitest::Test
   def test_caches
-    cache = Zache.new(sync: false)
-    first = cache.get(:hey, lifetime: 5) { rand }
-    second = cache.get(:hey) { rand }
+    z = Zache.new(sync: false)
+    first = z.get(:hey, lifetime: 5) { rand }
+    second = z.get(:hey) { rand }
     assert_equal(first, second)
-    assert_equal(1, cache.size)
+    assert_equal(1, z.size)
   end
 
   def test_caches_and_expires
-    cache = Zache.new
-    first = cache.get(:hey, lifetime: 0.01) { rand }
+    z = Zache.new
+    first = z.get(:hey, lifetime: 0.01) { rand }
     sleep 0.1
-    second = cache.get(:hey) { rand }
+    second = z.get(:hey) { rand }
     refute_equal(first, second)
   end
 
   def test_calculates_age
-    cache = Zache.new
-    cache.get(:hey) { rand }
+    z = Zache.new
+    z.get(:hey) { rand }
     sleep 0.1
-    assert_operator(cache.mtime(:hey), :<, Time.now - 0.05)
+    assert_operator(z.mtime(:hey), :<, Time.now - 0.05)
   end
 
   def test_caches_in_threads
-    cache = Zache.new
+    z = Zache.new
     Threads.new(10).assert(100) do
-      cache.get(:hey, lifetime: 0.0001) { rand }
+      z.get(:hey, lifetime: 0.0001) { rand }
     end
   end
 
   def test_key_exists
-    cache = Zache.new
-    cache.get(:hey) { rand }
-    exists_result = cache.exists?(:hey)
-    not_exists_result = cache.exists?(:bye)
+    z = Zache.new
+    z.get(:hey) { rand }
+    exists_result = z.exists?(:hey)
+    not_exists_result = z.exists?(:bye)
     assert(exists_result)
     refute(not_exists_result)
   end
 
   def test_put_and_exists
-    cache = Zache.new
-    cache.put(:hey, 'hello', lifetime: 0.1)
+    z = Zache.new
+    z.put(:hey, 'hello', lifetime: 0.1)
     sleep 0.2
-    refute(cache.exists?(:hey))
+    refute(z.exists?(:hey))
   end
 
   def test_remove_key
-    cache = Zache.new
-    cache.get(:hey) { rand }
-    cache.get(:wey) { rand }
-    assert(cache.exists?(:hey))
-    assert(cache.exists?(:wey))
-    cache.remove(:hey)
-    refute(cache.exists?(:hey))
-    assert(cache.exists?(:wey))
+    z = Zache.new
+    z.get(:hey) { rand }
+    z.get(:wey) { rand }
+    assert(z.exists?(:hey))
+    assert(z.exists?(:wey))
+    z.remove(:hey)
+    refute(z.exists?(:hey))
+    assert(z.exists?(:wey))
   end
 
   def test_remove_by_block
-    cache = Zache.new
-    cache.get('first') { rand }
-    cache.get('second') { rand }
-    cache.remove_by { |k| k == 'first' }
-    refute(cache.exists?('first'))
-    assert(cache.exists?('second'))
+    z = Zache.new
+    z.get('first') { rand }
+    z.get('second') { rand }
+    z.remove_by { |k| k == 'first' }
+    refute(z.exists?('first'))
+    assert(z.exists?('second'))
   end
 
   def test_remove_key_with_sync_false
-    cache = Zache.new(sync: false)
-    cache.get(:hey) { rand }
-    cache.get(:wey) { rand }
-    assert(cache.exists?(:hey))
-    assert(cache.exists?(:wey))
-    cache.remove(:hey)
-    refute(cache.exists?(:hey))
-    assert(cache.exists?(:wey))
+    z = Zache.new(sync: false)
+    z.get(:hey) { rand }
+    z.get(:wey) { rand }
+    assert(z.exists?(:hey))
+    assert(z.exists?(:wey))
+    z.remove(:hey)
+    refute(z.exists?(:hey))
+    assert(z.exists?(:wey))
   end
 
   def test_clean_with_threads
-    cache = Zache.new
+    z = Zache.new
     Threads.new(300).assert(3000) do
-      cache.get(:hey) { rand }
-      cache.get(:bye, lifetime: 0.01) { rand }
+      z.get(:hey) { rand }
+      z.get(:bye, lifetime: 0.01) { rand }
       sleep 0.1
-      cache.clean
+      z.clean
     end
-    assert(cache.exists?(:hey))
-    refute(cache.exists?(:bye))
+    assert(z.exists?(:hey))
+    refute(z.exists?(:bye))
   end
 
   def test_clean
-    cache = Zache.new
-    cache.get(:hey) { rand }
-    cache.get(:bye, lifetime: 0.01) { rand }
+    z = Zache.new
+    z.get(:hey) { rand }
+    z.get(:bye, lifetime: 0.01) { rand }
     sleep 0.1
-    cache.clean
-    assert(cache.exists?(:hey))
-    refute(cache.exists?(:bye))
+    z.clean
+    assert(z.exists?(:hey))
+    refute(z.exists?(:bye))
   end
 
   def test_clean_size
-    cache = Zache.new
-    cache.get(:hey, lifetime: 0.01) { rand }
+    z = Zache.new
+    z.get(:hey, lifetime: 0.01) { rand }
     sleep 0.1
-    cache.clean
-    assert_empty(cache)
+    z.clean
+    assert_empty(z)
   end
 
   def test_clean_with_sync_false
-    cache = Zache.new(sync: false)
-    cache.get(:hey) { rand }
-    cache.get(:bye, lifetime: 0.01) { rand }
+    z = Zache.new(sync: false)
+    z.get(:hey) { rand }
+    z.get(:bye, lifetime: 0.01) { rand }
     sleep 0.1
-    cache.clean
-    assert(cache.exists?(:hey))
-    refute(cache.exists?(:bye))
+    z.clean
+    assert(z.exists?(:hey))
+    refute(z.exists?(:bye))
   end
 
   def test_remove_absent_key
-    cache = Zache.new
-    cache.remove(:hey)
+    z = Zache.new
+    z.remove(:hey)
   end
 
   def test_check_and_remove
-    cache = Zache.new
-    cache.get(:hey, lifetime: 0) { rand }
-    refute(cache.exists?(:hey))
+    z = Zache.new
+    z.get(:hey, lifetime: 0) { rand }
+    refute(z.exists?(:hey))
   end
 
   def test_remove_all_with_threads
-    cache = Zache.new
+    z = Zache.new
     Threads.new(10).assert(100) do |i|
-      cache.get(:"hey#{i}") { rand }
-      assert(cache.exists?(:"hey#{i}"))
-      cache.remove_all
+      z.get(:"hey#{i}") { rand }
+      assert(z.exists?(:"hey#{i}"))
+      z.remove_all
     end
     10.times do |i|
-      refute(cache.exists?(:"hey#{i}"))
+      refute(z.exists?(:"hey#{i}"))
     end
   end
 
   def test_remove_all_with_sync
-    cache = Zache.new
-    cache.get(:hey) { rand }
-    cache.get(:bye) { rand }
-    cache.remove_all
-    refute(cache.exists?(:hey))
-    refute(cache.exists?(:bye))
+    z = Zache.new
+    z.get(:hey) { rand }
+    z.get(:bye) { rand }
+    z.remove_all
+    refute(z.exists?(:hey))
+    refute(z.exists?(:bye))
   end
 
   def test_remove_all_without_sync
-    cache = Zache.new(sync: false)
-    cache.get(:hey) { rand }
-    cache.get(:bye) { rand }
-    cache.remove_all
-    refute(cache.exists?(:hey))
-    refute(cache.exists?(:bye))
+    z = Zache.new(sync: false)
+    z.get(:hey) { rand }
+    z.get(:bye) { rand }
+    z.remove_all
+    refute(z.exists?(:hey))
+    refute(z.exists?(:bye))
   end
 
   def test_puts_something_in
-    cache = Zache.new(sync: false)
-    cache.get(:hey) { rand }
-    cache.put(:hey, 123)
-    assert_equal(123, cache.get(:hey))
+    z = Zache.new(sync: false)
+    z.get(:hey) { rand }
+    z.put(:hey, 123)
+    assert_equal(123, z.get(:hey))
   end
 
   def test_sync_zache_is_not_reentrant
-    cache = Zache.new
+    z = Zache.new
     assert_raises ThreadError do
-      cache.get(:first) { cache.get(:second) { 1 } }
+      z.get(:first) { z.get(:first) { 1 } }
     end
   end
 
+  def test_sync_zache_is_reentrant_for_different_keys
+    z = Zache.new
+    z.get(:first) { z.get(:second) { 1 } }
+  end
+
   def test_calculates_only_once
-    cache = Zache.new
+    z = Zache.new
     long = Thread.start do
-      cache.get(:x) do
+      z.get(:x) do
         sleep 0.5
         'first'
       end
     end
     sleep 0.1
-    assert_predicate(cache, :locked?)
-    cache.get(:x) { 'second' }
-    refute_predicate(cache, :locked?)
+    assert(z.locked?(:x))
+    z.get(:x) { 'second' }
+    refute(z.locked?(:x))
     long.kill
   end
 
   def test_checks_locked_status_from_inside
-    cache = Zache.new
-    cache.get(:x) do
-      assert_predicate(cache, :locked?)
+    z = Zache.new
+    z.get(:x) do
+      assert(z.locked?(:x))
       'done'
     end
-    refute_predicate(cache, :locked?)
+    refute(z.locked?(:x))
   end
 
   def test_returns_dirty_result
-    cache = Zache.new(dirty: true)
-    cache.get(:x, lifetime: 0) { 1 }
+    z = Zache.new(dirty: true)
+    z.get(:x, lifetime: 0) { 1 }
     long = Thread.start do
-      cache.get(:x) do
+      z.get(:x) do
         sleep 1000
         2
       end
     end
     sleep 0.1
     Timeout.timeout(1) do
-      assert(cache.exists?(:x))
-      assert(cache.expired?(:x))
-      assert_equal(1, cache.get(:x))
-      assert_equal(1, cache.get(:x) { 2 })
+      assert(z.exists?(:x))
+      assert(z.expired?(:x))
+      assert_equal(1, z.get(:x))
+      assert_equal(1, z.get(:x) { 2 })
     end
     long.kill
   end
 
   def test_returns_dirty_result_when_not_locked
-    cache = Zache.new(dirty: true)
-    cache.get(:x, lifetime: 0) { 1 }
-    assert(cache.exists?(:x))
-    assert_equal(1, cache.get(:x))
-    assert_equal(2, cache.get(:x) { 2 })
+    z = Zache.new(dirty: true)
+    z.get(:x, lifetime: 0) { 1 }
+    assert(z.exists?(:x))
+    assert_equal(1, z.get(:x))
+    assert_equal(2, z.get(:x) { 2 })
   end
 
   def test_fetches_multiple_keys_in_many_threads_in_dirty_mode
-    cache = Zache.new(dirty: true)
+    z = Zache.new(dirty: true)
     set = Concurrent::Set.new
     threads = 50
     barrier = Concurrent::CyclicBarrier.new(threads)
     Threads.new(threads).assert(threads * 2) do |i|
       barrier.wait if i < threads
-      set << cache.get(i, lifetime: 0.001) { i }
+      set << z.get(i, lifetime: 0.001) { i }
     end
     assert_equal(threads, set.size)
   end
 
   def test_fetches_multiple_keys_in_many_threads
-    cache = Zache.new
+    z = Zache.new
     set = Concurrent::Set.new
     threads = 50
     barrier = Concurrent::CyclicBarrier.new(threads)
     Threads.new(threads).assert(threads * 2) do |i|
       barrier.wait if i < threads
-      set << cache.get(i) { i }
+      set << z.get(i) { i }
     end
     assert_equal(threads, set.size)
   end
 
   def test_fake_class_works
-    cache = Zache::Fake.new
-    assert_equal(1, cache.get(:x) { 1 })
+    z = Zache::Fake.new
+    assert_equal(1, z.get(:x) { 1 })
   end
 
   def test_rethrows
-    cache = Zache.new
+    z = Zache.new
     assert_raises RuntimeError do
-      cache.get(:hey) { raise 'intentional' }
+      z.get(:hey) { raise 'intentional' }
     end
   end
 
   def test_returns_placeholder_in_eager_mode
-    cache = Zache.new
-    a = cache.get(:me, placeholder: 42, eager: true) do
+    z = Zache.new
+    a = z.get(:me, placeholder: 42, eager: true) do
       sleep 0.1
       43
     end
     assert_equal(42, a)
     sleep 0.2
-    b = cache.get(:me)
+    b = z.get(:me)
     assert_equal(43, b)
   end
 
+  def test_returns_placeholder_and_releases_lock
+    z = Zache.new
+    z.get(:slow, placeholder: 42, eager: true) do
+      sleep 9999
+    end
+    sleep 0.1
+    assert_equal(555, z.get(:fast) { 555 })
+  end
+
   private
 
   def rand

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.14.0' # Version should be updated before release
+  s.version = '0.15.0' # 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,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: zache
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.15.0
 platform: ruby
 authors:
 - Yegor Bugayenko
 bindir: bin
 cert_chain: []
-date: 2025-04-12 00:00:00.000000000 Z
+date: 2025-04-15 00:00:00.000000000 Z
 dependencies: []
 description: Zero-footprint in-memory thread-safe cache
 email: yegor256@gmail.com