with_advisory_lock 7.5.0 → 7.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1b30155d5acce8e77bf5fa733d0b4f257d34d3ccf4a40a3f2112314a34b83d9
-  data.tar.gz: 6c844c642c330044dd1e05355678fb862a5549ce9173fb794ee1d269cbe0cde9
+  metadata.gz: b73961f538d06e085eda202c9acac95b86e248dfc368cefa5267947ed8f988a2
+  data.tar.gz: c6b025af1bc1f16ea12b104da20fcfbd6586347eb23b72de47eafd09b8c4e9f0
 SHA512:
-  metadata.gz: bb0d2c8836c60963bc5c6dab3aaf3d7831ee1a2c8e86346970b77bf0de64779e0a5cef6a8965d89c0674a5daf0e892584d64116d9825e0e1bb9983d3e5698910
-  data.tar.gz: cc763d1ff02720ece882a9c9d0973818ac72f8774538c8d91848b4f0f9eac943b125fbecc01e9ca9d24a033977740ac189988e8225b878ad2010ac70a02826d7
+  metadata.gz: b11f600e41ed75fe00f7314d2cc090547e941ef4a9562c98e4573e892a15d3429b6609a1475f170a20f2d5197aba6dac153596e58181d6092db0d05c0adcc4fc
+  data.tar.gz: 24e45f293e0d2d653cc58e772b11f70d8d9691aac66a4d4be64cc81d67f322e6e00520e83d23613c0a176b74ca7137d60c5de8036b837a1b67b39eab3cad221e

data/.release-please-manifest.json

@@ -1 +1 @@
-{".":"7.5.0"}
+{".":"7.6.0"}

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 ## Changelog
 
+## [7.6.0](https://github.com/ClosureTree/with_advisory_lock/compare/with_advisory_lock/v7.5.0...with_advisory_lock/v7.6.0) (2026-08-05)
+
+
+### Features
+
+* honor timeout_seconds with blocking: true on PostgreSQL ([88abf06](https://github.com/ClosureTree/with_advisory_lock/commit/88abf0689b2ac7045c1617fe5fcac0bedff61adf)), closes [#147](https://github.com/ClosureTree/with_advisory_lock/issues/147)
+
+
+### Bug Fixes
+
+* Remove ruby-version files ([#145](https://github.com/ClosureTree/with_advisory_lock/issues/145)) ([681fd66](https://github.com/ClosureTree/with_advisory_lock/commit/681fd66f1d45800897f2d77ac8905474910a90ff))
+* scope advisory lock stack per connection ([8c39439](https://github.com/ClosureTree/with_advisory_lock/commit/8c394392872f0d9d6ab6b83d1185eeb291de2409))
+
 ## [7.5.0](https://github.com/ClosureTree/with_advisory_lock/compare/with_advisory_lock/v7.0.2...with_advisory_lock/v7.5.0) (2026-01-21)
 
 
@@ -72,7 +85,7 @@
 
 ### Features
 
-* use current connnection instead of the one in ActiveRecord::Base ([#90](https://github.com/ClosureTree/with_advisory_lock/issues/90)) ([c28a172](https://github.com/ClosureTree/with_advisory_lock/commit/c28a172a5a64594448b6090501fc0b8cbace06f6))
+* use current connection instead of the one in ActiveRecord::Base ([#90](https://github.com/ClosureTree/with_advisory_lock/issues/90)) ([c28a172](https://github.com/ClosureTree/with_advisory_lock/commit/c28a172a5a64594448b6090501fc0b8cbace06f6))
 
 
 ### Bug Fixes

data/README.md

@@ -52,7 +52,7 @@ called.
 > If a non-nil value is provided for `timeout_seconds`, the block will
 *not* be invoked if the lock cannot be acquired within that time-frame. In this case, `with_advisory_lock` will return `false`, while `with_advisory_lock!` will raise a `WithAdvisoryLock::FailedToAcquireLock` error.
 
-For backwards compatability, the timeout value can be specified directly as the
+For backwards compatibility, the timeout value can be specified directly as the
 second parameter.
 
 ### Shared locks
@@ -95,9 +95,31 @@ end
 - When you need PostgreSQL to detect and break circular lock dependencies
 - When you want to avoid Ruby-level polling overhead
 
+**Combining with a timeout:** `blocking: true` together with `timeout_seconds`
+bounds the database-level wait using a transaction-scoped
+`SET LOCAL lock_timeout`, returning `false` if the lock cannot be acquired in
+time. The setting never leaks to the session, and a timeout inside an enclosing
+transaction rolls back to a savepoint instead of aborting your transaction.
+A `timeout_seconds` of `0` degrades to the non-blocking try path.
+
+```ruby
+User.with_advisory_lock("lock_name", blocking: true, timeout_seconds: 5) do
+  # waits up to 5 seconds at the database level, no Ruby polling
+end
+```
+
 **Note:** MySQL ignores this option since `GET_LOCK` already provides native
 timeout and deadlock detection via the MDL subsystem.
 
+### Connection poolers (PgBouncer)
+
+Session-level advisory locks bind to the PostgreSQL backend connection, so they
+are incompatible with PgBouncer in *transaction pooling* mode: statements
+outside a transaction may run on different backends, stranding or leaking
+locks. Under transaction pooling, use `transaction: true` locks, which stay
+pinned to one backend for the duration of the transaction. Session pooling and
+direct connections are unaffected.
+
 ### Return values
 
 The return value of `with_advisory_lock_result` is a `WithAdvisoryLock::Result`
@@ -194,4 +216,3 @@ You will want to wrap your block within a transaction to ensure consistency.
 ### Is clustered MySQL supported?
 
 [No.](https://github.com/ClosureTree/with_advisory_lock/issues/16)
-

data/docker-compose.yml

@@ -2,16 +2,16 @@ services:
   pg:
     image: postgres:17-alpine
     environment:
-      POSTGRES_USER: test
-      POSTGRES_PASSWORD: test
+      POSTGRES_USER: with_advisory
+      POSTGRES_PASSWORD: with_advisory_pass
       POSTGRES_DB: with_advisory_lock_test
     ports:
       - "5433:5432"
   mysql:
     image: mysql:8
     environment:
-      MYSQL_USER: test
-      MYSQL_PASSWORD: test
+      MYSQL_USER: with_advisory
+      MYSQL_PASSWORD: with_advisory_pass
       MYSQL_DATABASE: with_advisory_lock_test
       MYSQL_RANDOM_ROOT_PASSWORD: "yes"
       MYSQL_ROOT_HOST: '%'
@@ -20,9 +20,9 @@ services:
   mariadb:
     image: mariadb:12
     environment:
-      MARIADB_USER: test
-      MARIADB_PASSWORD: test
-      MARIADB_DATABASE: with_advisory_lock_test_trilogy
+      MARIADB_USER: with_advisory
+      MARIADB_PASSWORD: with_advisory_pass
+      MARIADB_DATABASE: with_advisory_lock_trilogy_test
       MARIADB_RANDOM_ROOT_PASSWORD: "yes"
       MARIADB_ROOT_HOST: '%'
     ports:

data/lib/with_advisory_lock/concern.rb

@@ -24,22 +24,22 @@ module WithAdvisoryLock
         end
       end
 
-      def advisory_lock_exists?(lock_name)
+      def advisory_lock_exists?(lock_name, shared: false)
         with_connection do |conn|
           lock_str = "#{ENV.fetch(CoreAdvisory::LOCK_PREFIX_ENV, nil)}#{lock_name}"
-          lock_stack_item = LockStackItem.new(lock_str, false)
+          lock_stack_item = LockStackItem.new(lock_str, shared)
 
           if conn.advisory_lock_stack.include?(lock_stack_item)
             true
           else
-            # For PostgreSQL, try non-blocking query first to avoid race conditions
+            # Prefer the adapter's non-blocking existence check
             if conn.respond_to?(:advisory_lock_exists_for?)
-              query_result = conn.advisory_lock_exists_for?(lock_name)
+              query_result = conn.advisory_lock_exists_for?(lock_name, shared: shared)
               return query_result unless query_result.nil?
             end
 
             # Fall back to the original implementation
-            result = conn.with_advisory_lock_if_needed(lock_name, { timeout_seconds: 0 })
+            result = conn.with_advisory_lock_if_needed(lock_name, { timeout_seconds: 0, shared: shared })
             !result.lock_was_acquired?
           end
         end

data/lib/with_advisory_lock/core_advisory.rb

@@ -8,9 +8,9 @@ module WithAdvisoryLock
 
     LOCK_PREFIX_ENV = 'WITH_ADVISORY_LOCK_PREFIX'
 
-    # Thread-local lock stack management
+    # Per-connection lock stack management
     def advisory_lock_stack
-      Thread.current[:with_advisory_lock_stack] ||= []
+      @advisory_lock_stack ||= []
     end
 
     def with_advisory_lock_if_needed(lock_name, options = {}, &block)
@@ -57,6 +57,8 @@ module WithAdvisoryLock
       shared = options.fetch(:shared, false)
       transaction = options.fetch(:transaction, false)
       blocking = options.fetch(:blocking, false)
+      # An explicit zero timeout means try-once, so blocking degrades to the try path
+      blocking = false if timeout_seconds&.zero?
 
       lock_keys = lock_keys_for(lock_name)
 

data/lib/with_advisory_lock/mysql_advisory.rb

@@ -6,8 +6,6 @@ module WithAdvisoryLock
   module MySQLAdvisory
     extend ActiveSupport::Concern
 
-    LOCK_PREFIX_ENV = 'WITH_ADVISORY_LOCK_PREFIX'
-
     def try_advisory_lock(lock_keys, lock_name:, shared:, transaction:, timeout_seconds: nil, blocking: false)
       raise ArgumentError, 'shared locks are not supported on MySQL' if shared
       raise ArgumentError, 'transaction level locks are not supported on MySQL' if transaction
@@ -46,22 +44,11 @@ module WithAdvisoryLock
     rescue ActiveRecord::StatementInvalid => e
       # If the connection is broken, the lock is automatically released by MySQL
       # No need to fail the release operation
-      connection_lost = case e.cause
-                        when defined?(Mysql2::Error::ConnectionError) && Mysql2::Error::ConnectionError
-                          true
-                        when defined?(Trilogy::ConnectionError) && Trilogy::ConnectionError
-                          true
-                        else
-                          e.message =~ /Lost connection|MySQL server has gone away|Connection refused/i
-                        end
-
-      return if connection_lost
-
-      raise
+      raise unless connection_lost_error?(e)
     end
 
     def lock_keys_for(lock_name)
-      lock_str = "#{ENV.fetch(LOCK_PREFIX_ENV, nil)}#{lock_name}"
+      lock_str = "#{ENV.fetch(CoreAdvisory::LOCK_PREFIX_ENV, nil)}#{lock_name}"
       [lock_str]
     end
 
@@ -69,8 +56,26 @@ module WithAdvisoryLock
       true
     end
 
+    # Non-blocking check via IS_USED_LOCK, no lock is acquired as a side effect
+    def advisory_lock_exists_for?(lock_name, shared: false)
+      raise ArgumentError, 'shared locks are not supported on MySQL' if shared
+
+      lock_keys = lock_keys_for(lock_name)
+      !query_value("SELECT IS_USED_LOCK(#{quote(lock_keys.first)})").nil?
+    rescue ActiveRecord::StatementInvalid
+      nil
+    end
+
     private
 
+    def connection_lost_error?(error)
+      cause = error.cause
+      return true if defined?(Mysql2::Error::ConnectionError) && cause.is_a?(Mysql2::Error::ConnectionError)
+      return true if defined?(Trilogy::ConnectionError) && cause.is_a?(Trilogy::ConnectionError)
+
+      error.message.match?(/Lost connection|MySQL server has gone away|Connection refused/i)
+    end
+
     def execute_successful?(mysql_function)
       query_value("SELECT #{mysql_function}") == 1
     end

data/lib/with_advisory_lock/postgresql_advisory.rb

@@ -6,19 +6,21 @@ module WithAdvisoryLock
   module PostgreSQLAdvisory
     extend ActiveSupport::Concern
 
-    LOCK_PREFIX_ENV = 'WITH_ADVISORY_LOCK_PREFIX'
     LOCK_RESULT_VALUES = ['t', true].freeze
     ERROR_MESSAGE_REGEX = / ERROR: +current transaction is aborted,/
 
     def try_advisory_lock(lock_keys, lock_name:, shared:, transaction:, timeout_seconds: nil, blocking: false)
-      # timeout_seconds is accepted for compatibility but ignored - PostgreSQL doesn't support
-      # native timeouts with pg_try_advisory_lock, requiring Ruby-level polling instead
       function = if blocking
                    advisory_lock_function(transaction, shared)
                  else
                    advisory_try_lock_function(transaction, shared)
                  end
-      execute_advisory(function, lock_keys, lock_name, blocking: blocking)
+
+      if blocking && timeout_seconds&.positive?
+        blocking_lock_with_timeout(function, lock_keys, lock_name, timeout_seconds)
+      else
+        execute_advisory(function, lock_keys, lock_name, blocking: blocking)
+      end
     rescue ActiveRecord::Deadlocked
       # Rails 8.2+ raises ActiveRecord::Deadlocked directly for PostgreSQL deadlocks
       # When using blocking locks, treat deadlocks as lock acquisition failure
@@ -40,37 +42,36 @@ module WithAdvisoryLock
     end
 
     def release_advisory_lock(*args)
-      # Handle both signatures - ActiveRecord's built-in and ours
-      if args.length == 1 && args[0].is_a?(Integer)
-        # ActiveRecord's built-in signature: release_advisory_lock(lock_id)
-        super
-      else
-        # Our signature: release_advisory_lock(lock_keys, lock_name:, shared:, transaction:)
-        lock_keys, options = args
-        return if options[:transaction]
-
-        function = advisory_unlock_function(options[:shared])
-        execute_advisory(function, lock_keys, options[:lock_name])
-      end
-    rescue ActiveRecord::StatementInvalid => e
-      # If the connection is broken, the lock is automatically released by PostgreSQL
-      # No need to fail the release operation
-      return if e.cause.is_a?(PG::ConnectionBad) || e.message =~ /PG::ConnectionBad/
+      # ActiveRecord's built-in signature: release_advisory_lock(lock_id)
+      return super if args.length == 1 && args[0].is_a?(Integer)
 
-      raise unless e.message =~ ERROR_MESSAGE_REGEX
+      # Our signature: release_advisory_lock(lock_keys, lock_name:, shared:, transaction:)
+      lock_keys, options = args
+      return if options[:transaction]
 
+      function = advisory_unlock_function(options[:shared])
       begin
-        rollback_db_transaction
         execute_advisory(function, lock_keys, options[:lock_name])
-      ensure
-        begin_db_transaction
+      rescue ActiveRecord::StatementInvalid => e
+        # If the connection is broken, the lock is automatically released by PostgreSQL
+        # No need to fail the release operation
+        return if e.cause.is_a?(PG::ConnectionBad) || e.message =~ /PG::ConnectionBad/
+
+        raise unless e.message =~ ERROR_MESSAGE_REGEX
+
+        begin
+          rollback_db_transaction
+          execute_advisory(function, lock_keys, options[:lock_name])
+        ensure
+          begin_db_transaction
+        end
       end
     end
 
     def lock_keys_for(lock_name)
       [
         stable_hashcode(lock_name),
-        ENV.fetch(LOCK_PREFIX_ENV, nil)
+        ENV.fetch(CoreAdvisory::LOCK_PREFIX_ENV, nil)
       ].map { |ea| ea.to_i & 0x7fffffff }
     end
 
@@ -90,6 +91,7 @@ module WithAdvisoryLock
           AND classid = #{lock_keys.first}
           AND objid = #{lock_keys.last}
           AND mode = '#{shared ? 'ShareLock' : 'ExclusiveLock'}'
+          AND granted
         LIMIT 1
       SQL
 
@@ -101,6 +103,23 @@ module WithAdvisoryLock
 
     private
 
+    # Bounded blocking acquisition via SET LOCAL lock_timeout. The setting is
+    # transaction-scoped so it never leaks to the session (pooler-safe), and
+    # the savepoint keeps a timeout from aborting an enclosing transaction.
+    # Session-level locks acquired here survive the wrapping COMMIT.
+    def blocking_lock_with_timeout(function, lock_keys, lock_name, timeout_seconds)
+      transaction(requires_new: true) do
+        previous_timeout = query_value('SHOW lock_timeout')
+        execute("SET LOCAL lock_timeout = '#{(timeout_seconds * 1000).to_i}ms'")
+        execute_advisory(function, lock_keys, lock_name, blocking: true)
+        # SET LOCAL survives a released savepoint, so restore the outer value
+        execute("SET LOCAL lock_timeout = #{quote(previous_timeout)}")
+        true
+      end
+    rescue ActiveRecord::LockWaitTimeout
+      false
+    end
+
     def advisory_try_lock_function(transaction_scope, shared)
       [
         'pg_try_advisory',

data/lib/with_advisory_lock/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module WithAdvisoryLock
-  VERSION = Gem::Version.new('7.5.0')
+  VERSION = Gem::Version.new('7.6.0')
 end

data/test/with_advisory_lock/blocking_test.rb

@@ -128,6 +128,80 @@ if GemTestCase.trilogy_available?
   end
 end
 
+# Requires non-transactional mode: transactional tests pin all threads to a
+# single shared connection, so a "holder" thread would share the session
+class PostgreSQLBlockingTimeoutTest < GemTestCase
+  self.use_transactional_tests = false
+
+  setup do
+    @lock_name = 'blocking_timeout_lock'
+    @release = false
+  end
+
+  teardown do
+    @release = true
+    @holder&.join
+  end
+
+  def hold_lock_elsewhere
+    locked = false
+    @holder = Thread.new do
+      Tag.connection_pool.with_connection do
+        Tag.with_advisory_lock(@lock_name, timeout_seconds: 0) do
+          locked = true
+          sleep 0.05 until @release
+        end
+      end
+    end
+    sleep 0.01 until locked
+  end
+
+  test 'blocking lock with timeout returns false when lock is held elsewhere' do
+    hold_lock_elsewhere
+
+    elapsed = Benchmark.realtime do
+      result = Tag.with_advisory_lock(@lock_name, blocking: true, timeout_seconds: 1) { 'unreachable' }
+      assert_equal false, result
+    end
+    assert elapsed >= 0.9, "expected to wait for the timeout, waited #{elapsed}s"
+    assert elapsed < 5.0, "expected timeout after ~1s, waited #{elapsed}s"
+  end
+
+  test 'blocking lock with timeout acquires when lock is free' do
+    result = Tag.with_advisory_lock(@lock_name, blocking: true, timeout_seconds: 1) { 'acquired' }
+    assert_equal 'acquired', result
+  end
+
+  test 'blocking lock with timeout does not leak lock_timeout' do
+    Tag.with_connection do |conn|
+      previous = conn.query_value('SHOW lock_timeout')
+      conn.with_advisory_lock_if_needed(@lock_name, { blocking: true, timeout_seconds: 1 }) { 'x' }
+      assert_equal previous, conn.query_value('SHOW lock_timeout')
+    end
+  end
+
+  test 'blocking lock with timeout failure does not abort enclosing transaction' do
+    hold_lock_elsewhere
+
+    Tag.transaction do
+      result = Tag.with_advisory_lock(@lock_name, blocking: true, timeout_seconds: 1) { 'unreachable' }
+      assert_equal false, result
+      # The savepoint rollback must leave the transaction usable
+      assert Tag.count >= 0
+    end
+  end
+
+  test 'blocking lock with zero timeout uses the try path' do
+    hold_lock_elsewhere
+
+    elapsed = Benchmark.realtime do
+      result = Tag.with_advisory_lock(@lock_name, blocking: true, timeout_seconds: 0) { 'unreachable' }
+      assert_equal false, result
+    end
+    assert elapsed < 1.0, "expected immediate return, waited #{elapsed}s"
+  end
+end
+
 # Deadlock test requires non-transactional mode to work properly
 class PostgreSQLDeadlockTest < GemTestCase
   self.use_transactional_tests = false

data/test/with_advisory_lock/multi_adapter_test.rb

@@ -2,45 +2,89 @@
 
 require 'test_helper'
 
+# Database-level assertions so these tests cannot pass without real lock acquisition
+module AdapterLockAssertions
+  def assert_mysql_lock_held(model, lock_name)
+    model.with_connection do |conn|
+      key = conn.lock_keys_for(lock_name).first
+      assert_not_nil conn.query_value("SELECT IS_USED_LOCK(#{conn.quote(key)})"),
+                     "#{model.name} should hold GET_LOCK(#{key.inspect}) at the database level"
+    end
+  end
+
+  def assert_pg_lock_held(model, lock_name)
+    model.with_connection do |conn|
+      assert conn.advisory_lock_exists_for?(lock_name),
+             "#{model.name} should hold the advisory lock in pg_locks"
+    end
+  end
+end
+
 class MultiAdapterIsolationTest < GemTestCase
+  include AdapterLockAssertions
+
   test 'postgresql and mysql adapters do not overlap' do
     lock_name = 'multi-adapter-lock'
 
     # PostgreSQL lock doesn't block MySQL
     Tag.with_advisory_lock(lock_name) do
-      assert MysqlTag.with_advisory_lock(lock_name, timeout_seconds: 0) { true }
+      acquired = MysqlTag.with_advisory_lock(lock_name, timeout_seconds: 0) do
+        assert_mysql_lock_held(MysqlTag, lock_name)
+        true
+      end
+      assert acquired
     end
 
     # MySQL lock doesn't block PostgreSQL
     MysqlTag.with_advisory_lock(lock_name) do
-      assert Tag.with_advisory_lock(lock_name, timeout_seconds: 0) { true }
+      acquired = Tag.with_advisory_lock(lock_name, timeout_seconds: 0) do
+        assert_pg_lock_held(Tag, lock_name)
+        true
+      end
+      assert acquired
     end
   end
 end
 
 if GemTestCase.trilogy_available?
   class TrilogyMultiAdapterIsolationTest < GemTestCase
+    include AdapterLockAssertions
     test 'trilogy adapter does not overlap with postgresql or mysql' do
       lock_name = 'multi-adapter-lock'
 
       # PostgreSQL lock doesn't block Trilogy
       Tag.with_advisory_lock(lock_name) do
-        assert TrilogyTag.with_advisory_lock(lock_name, timeout_seconds: 0) { true }
+        acquired = TrilogyTag.with_advisory_lock(lock_name, timeout_seconds: 0) do
+          assert_mysql_lock_held(TrilogyTag, lock_name)
+          true
+        end
+        assert acquired
       end
 
       # Trilogy lock doesn't block PostgreSQL
       TrilogyTag.with_advisory_lock(lock_name) do
-        assert Tag.with_advisory_lock(lock_name, timeout_seconds: 0) { true }
+        acquired = Tag.with_advisory_lock(lock_name, timeout_seconds: 0) do
+          assert_pg_lock_held(Tag, lock_name)
+          true
+        end
+        assert acquired
       end
 
       # MySQL lock doesn't block Trilogy
       MysqlTag.with_advisory_lock(lock_name) do
-        assert TrilogyTag.with_advisory_lock(lock_name, timeout_seconds: 0) { true }
+        acquired = TrilogyTag.with_advisory_lock(lock_name, timeout_seconds: 0) do
+          assert_mysql_lock_held(TrilogyTag, lock_name)
+          true
+        end
+        assert acquired
       end
 
-      # Trilogy lock doesn't block MySQL
       TrilogyTag.with_advisory_lock(lock_name) do
-        assert MysqlTag.with_advisory_lock(lock_name, timeout_seconds: 0) { true }
+        acquired = MysqlTag.with_advisory_lock(lock_name, timeout_seconds: 0) do
+          assert_mysql_lock_held(MysqlTag, lock_name)
+          true
+        end
+        assert acquired
       end
     end
   end

data/with_advisory_lock.gemspec

@@ -24,7 +24,6 @@ Gem::Specification.new do |spec|
   spec.metadata['changelog_uri'] = 'https://github.com/ClosureTree/with_advisory_lock/blob/master/CHANGELOG.md'
 
   spec.add_dependency 'activerecord', '>= 7.2'
-  spec.add_dependency 'zeitwerk', '>= 2.7'
 
   spec.add_development_dependency 'maxitest', '6.2.0'
   spec.add_development_dependency 'minitest-reporters'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: with_advisory_lock
 version: !ruby/object:Gem::Version
-  version: 7.5.0
+  version: 7.6.0
 platform: ruby
 authors:
 - Matthew McEachen
@@ -24,20 +24,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '7.2'
-- !ruby/object:Gem::Dependency
-  name: zeitwerk
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.7'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.7'
 - !ruby/object:Gem::Dependency
   name: maxitest
   requirement: !ruby/object:Gem::Requirement
@@ -106,8 +92,6 @@ files:
 - ".github/workflows/release.yml"
 - ".gitignore"
 - ".release-please-manifest.json"
-- ".ruby-version"
-- ".tool-versions"
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
@@ -193,7 +177,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Advisory locking for ActiveRecord
 test_files: []

data/.ruby-version

@@ -1,2 +0,0 @@
-3.4.4
-

data/.tool-versions

@@ -1 +0,0 @@
-ruby 4.0.1