zache 0.13.2 → 0.15.0

data/test/test_zache.rb

@@ -1,296 +1,311 @@
 # frozen_string_literal: true
 
-# (The MIT License)
-#
-# Copyright (c) 2018-2024 Yegor Bugayenko
-#
-# 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.
+# SPDX-FileCopyrightText: Copyright (c) 2018-2025 Yegor Bugayenko
+# SPDX-License-Identifier: MIT
 
+require 'concurrent'
 require 'minitest/autorun'
+require 'securerandom'
 require 'threads'
 require 'timeout'
-require 'concurrent'
 require_relative '../lib/zache'
+require_relative 'test__helper'
 
 Thread.report_on_exception = true
 
 # Cache test.
 # Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2018-2024 Yegor Bugayenko
+# Copyright:: Copyright (c) 2018-2025 Yegor Bugayenko
 # License:: MIT
 class ZacheTest < Minitest::Test
   def test_caches
-    cache = Zache.new(sync: false)
-    first = cache.get(:hey, lifetime: 5) { Random.rand }
-    second = cache.get(:hey) { Random.rand }
-    assert(first == second)
-    assert_equal(1, cache.size)
+    z = Zache.new(sync: false)
+    first = z.get(:hey, lifetime: 5) { rand }
+    second = z.get(:hey) { rand }
+    assert_equal(first, second)
+    assert_equal(1, z.size)
   end
 
   def test_caches_and_expires
-    cache = Zache.new
-    first = cache.get(:hey, lifetime: 0.01) { Random.rand }
+    z = Zache.new
+    first = z.get(:hey, lifetime: 0.01) { rand }
     sleep 0.1
-    second = cache.get(:hey) { Random.rand }
-    assert(first != second)
+    second = z.get(:hey) { rand }
+    refute_equal(first, second)
   end
 
   def test_calculates_age
-    cache = Zache.new
-    cache.get(:hey) { Random.rand }
+    z = Zache.new
+    z.get(:hey) { rand }
     sleep 0.1
-    assert(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) { Random.rand }
+      z.get(:hey, lifetime: 0.0001) { rand }
     end
   end
 
   def test_key_exists
-    cache = Zache.new
-    cache.get(:hey) { Random.rand }
-    exists_result = cache.exists?(:hey)
-    not_exists_result = cache.exists?(:bye)
-    assert(exists_result == true)
-    assert(not_exists_result == false)
+    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
-    assert(!cache.exists?(:hey))
+    refute(z.exists?(:hey))
   end
 
   def test_remove_key
-    cache = Zache.new
-    cache.get(:hey) { Random.rand }
-    cache.get(:wey) { Random.rand }
-    assert(cache.exists?(:hey) == true)
-    assert(cache.exists?(:wey) == true)
-    cache.remove(:hey)
-    assert(cache.exists?(:hey) == false)
-    assert(cache.exists?(:wey) == true)
+    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') { Random.rand }
-    cache.get('second') { Random.rand }
-    cache.remove_by { |k| k == 'first' }
-    assert(cache.exists?('first') == false)
-    assert(cache.exists?('second') == true)
+    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) { Random.rand }
-    cache.get(:wey) { Random.rand }
-    assert(cache.exists?(:hey) == true)
-    assert(cache.exists?(:wey) == true)
-    cache.remove(:hey)
-    assert(cache.exists?(:hey) == false)
-    assert(cache.exists?(:wey) == true)
+    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) { Random.rand }
-      cache.get(:bye, lifetime: 0.01) { Random.rand }
+      z.get(:hey) { rand }
+      z.get(:bye, lifetime: 0.01) { rand }
       sleep 0.1
-      cache.clean
+      z.clean
     end
-    assert(cache.exists?(:hey) == true)
-    assert(cache.exists?(:bye) == false)
+    assert(z.exists?(:hey))
+    refute(z.exists?(:bye))
   end
 
   def test_clean
-    cache = Zache.new
-    cache.get(:hey) { Random.rand }
-    cache.get(:bye, lifetime: 0.01) { Random.rand }
+    z = Zache.new
+    z.get(:hey) { rand }
+    z.get(:bye, lifetime: 0.01) { rand }
     sleep 0.1
-    cache.clean
-    assert(cache.exists?(:hey) == true)
-    assert(cache.exists?(:bye) == false)
+    z.clean
+    assert(z.exists?(:hey))
+    refute(z.exists?(:bye))
   end
 
   def test_clean_size
-    cache = Zache.new
-    cache.get(:hey, lifetime: 0.01) { Random.rand }
+    z = Zache.new
+    z.get(:hey, lifetime: 0.01) { rand }
     sleep 0.1
-    cache.clean
-    assert(cache.empty?)
+    z.clean
+    assert_empty(z)
   end
 
   def test_clean_with_sync_false
-    cache = Zache.new(sync: false)
-    cache.get(:hey) { Random.rand }
-    cache.get(:bye, lifetime: 0.01) { Random.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) == true)
-    assert(cache.exists?(:bye) == false)
+    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) { Random.rand }
-    assert(!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}") { Random.rand }
-      assert(cache.exists?(:"hey#{i}") == true)
-      cache.remove_all
+      z.get(:"hey#{i}") { rand }
+      assert(z.exists?(:"hey#{i}"))
+      z.remove_all
     end
     10.times do |i|
-      assert(cache.exists?(:"hey#{i}") == false)
+      refute(z.exists?(:"hey#{i}"))
     end
   end
 
   def test_remove_all_with_sync
-    cache = Zache.new
-    cache.get(:hey) { Random.rand }
-    cache.get(:bye) { Random.rand }
-    cache.remove_all
-    assert(cache.exists?(:hey) == false)
-    assert(cache.exists?(:bye) == false)
+    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) { Random.rand }
-    cache.get(:bye) { Random.rand }
-    cache.remove_all
-    assert(cache.exists?(:hey) == false)
-    assert(cache.exists?(:bye) == false)
+    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) { Random.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(cache.locked?)
-    cache.get(:x) { 'second' }
-    assert(!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(cache.locked?)
+    z = Zache.new
+    z.get(:x) do
+      assert(z.locked?(:x))
       'done'
     end
-    assert(!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
+    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 = 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
+    SecureRandom.uuid
   end
 end

data/zache.gemspec

@@ -1,39 +1,20 @@
 # frozen_string_literal: true
 
-# (The MIT License)
-#
-# Copyright (c) 2018-2024 Yegor Bugayenko
-#
-# 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.
+# SPDX-FileCopyrightText: Copyright (c) 2018-2025 Yegor Bugayenko
+# SPDX-License-Identifier: MIT
 
 require 'English'
 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.required_ruby_version = '>= 2.5'
   s.name = 'zache'
-  s.version = '0.13.2'
+  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'
   s.authors = ['Yegor Bugayenko']
   s.email = 'yegor256@gmail.com'
-  s.homepage = 'http://github.com/yegor256/zache'
+  s.homepage = 'https://github.com/yegor256/zache'
   s.files = `git ls-files`.split($RS)
   s.rdoc_options = ['--charset=UTF-8']
   s.extra_rdoc_files = ['README.md']

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: zache
 version: !ruby/object:Gem::Version
-  version: 0.13.2
+  version: 0.15.0
 platform: ruby
 authors:
 - Yegor Bugayenko
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-07-18 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
@@ -25,6 +24,7 @@ files:
 - ".github/workflows/markdown-lint.yml"
 - ".github/workflows/pdd.yml"
 - ".github/workflows/rake.yml"
+- ".github/workflows/reuse.yml"
 - ".github/workflows/xcop.yml"
 - ".github/workflows/yamllint.yml"
 - ".gitignore"
@@ -34,7 +34,9 @@ files:
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
+- LICENSES/MIT.txt
 - README.md
+- REUSE.toml
 - Rakefile
 - lib/zache.rb
 - logo.svg
@@ -42,12 +44,11 @@ files:
 - test/test__helper.rb
 - test/test_zache.rb
 - zache.gemspec
-homepage: http://github.com/yegor256/zache
+homepage: https://github.com/yegor256/zache
 licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message: 
 rdoc_options:
 - "--charset=UTF-8"
 require_paths:
@@ -63,8 +64,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key: 
+rubygems_version: 3.6.2
 specification_version: 4
 summary: In-memory Cache
 test_files: []