with_advisory_lock 4.6.0 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc4719c3f44e4cf1f219b582d21cf9757274ca1fcca6128c227798f32d4b589e
-  data.tar.gz: c63b8be1ee91b25a519b5a4d7d090ff98172d6d3a476899b55c6cd03bf77eda6
+  metadata.gz: 6918df100f32e829701a38ad6b7dd30db20d7a83635b82cbd8ccc7f3022a88d5
+  data.tar.gz: f231c4fa8b5c403de000054839603e2297215929a64cccc63c21c577bc19ecd7
 SHA512:
-  metadata.gz: be5a906b9740506447bfcdb1928cd5473add67e0a48acd32f8a26ca4671be49b34ca5eca987df2f8e6f29a0a3dbb0bccc3321061d9f1e5827a0ca4ef44341124
-  data.tar.gz: 124358b251ffd9cc066d54aebfeeca97fb0db88ae18293fb7e0169ceb13960d298e72c66e9d5fbd79f0cbda5360d2fdb2e609866ac82eeb26b1eab6ead103daf
+  metadata.gz: 21a2201433600aa26b0f7b0176b3b4e87606a00459b70d9dfb10a385c00a53fa5f0365cd426c2b5793d1b0022fa37e663567b0daf185e4be93d5a59e10695e2e
+  data.tar.gz: b1e707a2115e83cd1667bb6b1842c7150b28da3603bd3ec668fc9918de01553fc10d44e65d89d94a3f7a183489da49b0348d1cc59650487d48482648041445df

data/.github/workflows/ci.yml

@@ -0,0 +1,80 @@
+---
+name: CI
+
+on:
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  minitest:
+    runs-on: ubuntu-latest
+    services:
+      mysql:
+        image: mysql/mysql-server:5.7
+        ports:
+          - "3306:3306"
+        env:
+          MYSQL_ROOT_PASSWORD: root
+          MYSQL_DATABASE: with_advisory_lock_test
+          MYSQL_ROOT_HOST: '%'
+      postgres:
+        image: 'postgres:14-alpine'
+        ports: ['5432:5432']
+        env:
+          POSTGRES_USER: closure_tree
+          POSTGRES_PASSWORD: closure_tree
+          POSTGRES_DB: with_advisory_lock_test
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby:
+          - '3.2'  
+          - '3.1'
+          - '3.0'
+          - '2.7'
+          - 'truffleruby'
+        rails:
+          - activerecord_7.1
+          - activerecord_7.0
+          - activerecord_6.1
+        adapter:
+          - sqlite3:///tmp/test.sqlite3
+          - mysql2://root:root@0/with_advisory_lock_test
+          - trilogy://root:root@0/with_advisory_lock_test
+          - postgres://closure_tree:closure_tree@0/with_advisory_lock_test
+        include:
+          - ruby: jruby
+            rails: activerecord_6.1
+            adapter: jdbcmysql://root:root@0/with_advisory_lock_test
+          - ruby: jruby
+            rails: activerecord_6.1
+            adapter: jdbcsqlite3:///tmp/test.sqlite3
+          - ruby: jruby
+            rails: activerecord_6.1
+            adapter: jdbcpostgresql://closure_tree:closure_tree@0/with_advisory_lock_test
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+          rubygems: latest
+        env:
+          BUNDLE_GEMFILE:  gemfiles/${{ matrix.rails }}.gemfile
+
+      - name: Test
+        env:
+          BUNDLE_GEMFILE: gemfiles/${{ matrix.rails }}.gemfile
+          DATABASE_URL: ${{ matrix.adapter }}
+          WITH_ADVISORY_LOCK_PREFIX: ${{ github.run_id }}
+        run: bundle exec rake

data/.github/workflows/release.yml

@@ -0,0 +1,20 @@
+name: release-please
+
+on:
+  push:
+    branches:
+      - master
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  release-please:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: google-github-actions/release-please-action@v4
+        id: release
+        with:
+          command: manifest

data/.gitignore

@@ -18,3 +18,5 @@ test/tmp
 test/version_tmp
 tmp
 *.iml
+test/sqlite.db
+.env

data/.release-please-manifest.json

@@ -0,0 +1 @@
+{".":"5.1.0"}

data/.tool-versions

@@ -1 +1 @@
-ruby 2.6.4
+ruby 3.0.5

data/Appraisals

@@ -1,29 +1,45 @@
-appraise "activerecord-4.2" do
-  gem "activerecord", "~> 4.2.0"
+# frozen_string_literal: true
+
+appraise 'activerecord-7.1' do
+  gem 'activerecord', '~> 7.1.0'
   platforms :ruby do
-      gem "pg", "~> 0.21"
-      gem "mysql2", "< 0.5"
-      gem "sqlite3", "~> 1.3.6"
+    gem 'sqlite3'
+    gem 'mysql2'
+    gem 'trilogy'
+    gem 'pg'
   end
 end
 
-appraise "activerecord-5.0" do
-  gem "activerecord", "~> 5.0.0"
+appraise 'activerecord-7.0' do
+  gem 'activerecord', '~> 7.0.0'
   platforms :ruby do
-    gem "sqlite3", "~> 1.3.6"
+    gem 'sqlite3'
+    gem 'mysql2'
+    gem 'trilogy'
+    gem "activerecord-trilogy-adapter"
+    gem 'pg'
+  end
+  platforms :jruby do
+    gem "activerecord-jdbcmysql-adapter"
+    gem "activerecord-jdbcpostgresql-adapter"
+    gem "activerecord-jdbcsqlite3-adapter"
   end
 end
 
-appraise "activerecord-5.1" do
-  gem "activerecord", "~> 5.1.0"
-  gem "sqlite3", "~> 1.3.6"
-end
+appraise 'activerecord-6.1' do
+  gem 'activerecord', '~> 6.1.0'
 
-appraise "activerecord-5.2" do
-  gem "activerecord", "~> 5.1.0"
-  gem "sqlite3", "~> 1.3.6"
+  platforms :ruby do
+    gem 'sqlite3'
+    gem 'mysql2'
+    gem 'trilogy'
+    gem "activerecord-trilogy-adapter"
+    gem 'pg'
+  end
+  platforms :jruby do
+    gem "activerecord-jdbcmysql-adapter"
+    gem "activerecord-jdbcpostgresql-adapter"
+    gem "activerecord-jdbcsqlite3-adapter"
+  end
 end
 
-appraise "activerecord-6.0" do
-  gem "activerecord", "~> 6.0.0"
-end

data/CHANGELOG.md

@@ -1,5 +1,36 @@
 ## Changelog
 
+## [5.1.0](https://github.com/ClosureTree/with_advisory_lock/compare/with_advisory_lock/v5.0.1...with_advisory_lock/v5.1.0) (2024-01-21)
+
+
+### Features
+
+* use zeitwerk loader instead of ActiveSupport::Autoload ([b5082fd](https://github.com/ClosureTree/with_advisory_lock/commit/b5082fddacacacff48139f5bf509601a37945a0e))
+
+## 5.0.1 (2024-01-21)
+
+
+### Features
+
+* add release workflow ([5d32520](https://github.com/ClosureTree/with_advisory_lock/commit/5d325201c82974991381a9fbc4d1714c9739dc4f))
+* add ruby 3.1 test/support ([#60](https://github.com/ClosureTree/with_advisory_lock/issues/60)) ([514f042](https://github.com/ClosureTree/with_advisory_lock/commit/514f0420d957ef30911a00d54685385bec5867c3))
+* Add testing for activerecord 7.1 and support for trilogy adapter ([#77](https://github.com/ClosureTree/with_advisory_lock/issues/77)) ([69c23fe](https://github.com/ClosureTree/with_advisory_lock/commit/69c23fe09887fc5d97ac7b0194825c21efe244a5))
+* add truffleruby support ([#62](https://github.com/ClosureTree/with_advisory_lock/issues/62)) ([ec34bd4](https://github.com/ClosureTree/with_advisory_lock/commit/ec34bd448e3505e5df631daaf47bb83f2f5316dc))
+
+
+### Bug Fixes
+
+* User may sometimes pass in non-strings, such as integers ([#55](https://github.com/ClosureTree/with_advisory_lock/issues/55)) ([9885597](https://github.com/ClosureTree/with_advisory_lock/commit/988559747363ef00958fcf782317e76c40ffa2a3))
+
+### 5.0.0
+- Drop support for EOL rubies and activerecord (ruby below 2.7 and activerecord below 6.1).
+- Allow lock name to be integer
+- Jruby support
+- Truffleruby support
+- Add `with_advisory_lock!`, which raises an error if the lock acquisition fails
+- Add `disable_query_cache` option to `with_advisory_lock`
+- Drop support for mysql < 5.7.5
+
 ### 4.6.0
 
 - Support for ActiveRecord 6

data/Gemfile

@@ -1,15 +1,3 @@
 source 'https://rubygems.org'
 
 gemspec
-
-platforms :ruby do
-  gem 'mysql2'
-  gem 'pg'
-  gem 'sqlite3'
-end
-
-platforms :jruby do
-  gem 'activerecord-jdbcmysql-adapter'
-  gem 'activerecord-jdbcpostgresql-adapter'
-  gem 'activerecord-jdbcsqlite3-adapter'
-end

data/README.md

@@ -1,14 +1,13 @@
 # with_advisory_lock
 
-Adds advisory locking (mutexes) to ActiveRecord 4.2, 5.x and 6.0, with ruby
-2.4, 2.5 and 2.6, when used with
+Adds advisory locking (mutexes) to ActiveRecord  6.0+, with ruby 2.7+, jruby or truffleruby, when used with
 [MySQL](https://dev.mysql.com/doc/refman/8.0/en/miscellaneous-functions.html#function_get-lock)
 or
 [PostgreSQL](https://www.postgresql.org/docs/current/static/functions-admin.html#FUNCTIONS-ADVISORY-LOCKS).
 SQLite resorts to file locking.
 
-[![Build Status](https://api.travis-ci.org/ClosureTree/with_advisory_lock.svg?branch=master)](https://travis-ci.org/ClosureTree/with_advisory_lock)
 [![Gem Version](https://badge.fury.io/rb/with_advisory_lock.svg)](https://badge.fury.io/rb/with_advisory_lock)
+[![CI](https://github.com/ClosureTree/with_advisory_lock/actions/workflows/ci.yml/badge.svg)](https://github.com/ClosureTree/with_advisory_lock/actions/workflows/ci.yml)
 
 ## What's an "Advisory Lock"?
 
@@ -45,8 +44,10 @@ A value of zero will try the lock only once. If the lock is acquired, the block
 will be yielded to. If the lock is currently being held, the block will not be
 called.
 
-Note that 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.
+> **Note**
+> 
+> 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
 second parameter.
@@ -80,6 +81,8 @@ block, if the lock was able to be acquired and the block yielded, or `false`, if
 you provided a timeout_seconds value and the lock was not able to be acquired in
 time.
 
+`with_advisory_lock!` is similar to `with_advisory_lock`, but raises a `WithAdvisoryLock::FailedToAcquireLock` error if the lock was not able to be acquired in time. 
+
 ### Testing for the current lock status
 
 If you needed to check if the advisory lock is currently being held, you can
@@ -91,6 +94,14 @@ If you want to see if the current Thread is holding a lock, you can call
 `Tag.current_advisory_lock` which will return the name of the current lock. If
 no lock is currently held, `.current_advisory_lock` returns `nil`.
 
+### ActiveRecord Query Cache
+
+You can optionally pass `disable_query_cache: true` to the options hash of
+`with_advisory_lock` in order to disable ActiveRecord's query cache. This can
+prevent problems when you query the database from within the lock and it returns
+stale results. More info on why this can be a problem can be
+[found here](https://github.com/ClosureTree/with_advisory_lock/issues/52)
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -123,7 +134,7 @@ row-level locks prevent concurrent modification to a given model.
 
 **If you're building a
 [CRUD](http://en.wikipedia.org/wiki/Create,_read,_update_and_delete)
-application, this will be your most commonly used lock.**
+application, this will be 2.4, 2.5 and  your most commonly used lock.**
 
 ### Table-level locks
 

data/gemfiles/{activerecord_6.0.gemfile → activerecord_6.1.gemfile}

@@ -2,12 +2,14 @@
 
 source "https://rubygems.org"
 
-gem "activerecord", "~> 6.0.0"
+gem "activerecord", "~> 6.1.0"
 
 platforms :ruby do
+  gem "sqlite3"
   gem "mysql2"
+  gem "trilogy"
+  gem "activerecord-trilogy-adapter"
   gem "pg"
-  gem "sqlite3"
 end
 
 platforms :jruby do

data/gemfiles/{activerecord_5.2.gemfile → activerecord_7.0.gemfile}

@@ -2,12 +2,14 @@
 
 source "https://rubygems.org"
 
-gem "activerecord", "~> 5.1.0"
+gem "activerecord", "~> 7.0.0"
 
 platforms :ruby do
+  gem "sqlite3"
   gem "mysql2"
+  gem "trilogy"
+  gem "activerecord-trilogy-adapter"
   gem "pg"
-  gem "sqlite3", "~> 1.3.6"
 end
 
 platforms :jruby do

data/gemfiles/activerecord_7.1.gemfile

@@ -0,0 +1,14 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 7.1.0"
+
+platforms :ruby do
+  gem "sqlite3"
+  gem "mysql2"
+  gem "trilogy"
+  gem "pg"
+end
+
+gemspec path: "../"

data/lib/with_advisory_lock/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'zlib'
 
 module WithAdvisoryLock
@@ -19,17 +21,18 @@ module WithAdvisoryLock
   LockStackItem = Struct.new(:name, :shared)
 
   class Base
-    attr_reader :connection, :lock_name, :timeout_seconds, :shared, :transaction
+    attr_reader :connection, :lock_name, :timeout_seconds, :shared, :transaction, :disable_query_cache
 
     def initialize(connection, lock_name, options)
       options = { timeout_seconds: options } unless options.respond_to?(:fetch)
-      options.assert_valid_keys :timeout_seconds, :shared, :transaction
+      options.assert_valid_keys :timeout_seconds, :shared, :transaction, :disable_query_cache
 
       @connection = connection
       @lock_name = lock_name
       @timeout_seconds = options.fetch(:timeout_seconds, nil)
       @shared = options.fetch(:shared, false)
       @transaction = options.fetch(:transaction, false)
+      @disable_query_cache = options.fetch(:disable_query_cache, false)
     end
 
     def lock_str
@@ -51,6 +54,16 @@ module WithAdvisoryLock
     end
 
     def with_advisory_lock_if_needed(&block)
+      if disable_query_cache
+        return lock_and_yield do
+          ActiveRecord::Base.uncached(&block)
+        end
+      end
+
+      lock_and_yield(&block)
+    end
+
+    def lock_and_yield(&block)
       if already_locked?
         Result.new(true, yield)
       elsif timeout_seconds == 0
@@ -66,7 +79,7 @@ module WithAdvisoryLock
       else
         # Ruby MRI's String#hash is randomly seeded as of Ruby 1.9 so
         # make sure we use a deterministic hash.
-        Zlib.crc32(input.to_s)
+        Zlib.crc32(input.to_s, 0)
       end
     end
 
@@ -75,6 +88,7 @@ module WithAdvisoryLock
       while @timeout_seconds.nil? || Time.now < give_up_at
         r = yield_with_lock(&block)
         return r if r.lock_was_acquired?
+
         # Randomizing sleep time may help reduce contention.
         sleep(rand(0.05..0.15))
       end

data/lib/with_advisory_lock/concern.rb

@@ -1,19 +1,25 @@
-require 'active_support/concern'
+# frozen_string_literal: true
 
 module WithAdvisoryLock
   module Concern
     extend ActiveSupport::Concern
-    delegate :with_advisory_lock, :advisory_lock_exists?, to: 'self.class'
+    delegate :with_advisory_lock, :with_advisory_lock!, :advisory_lock_exists?, to: 'self.class'
 
-    module ClassMethods
+    class_methods do
       def with_advisory_lock(lock_name, options = {}, &block)
         result = with_advisory_lock_result(lock_name, options, &block)
         result.lock_was_acquired? ? result.result : false
       end
 
+      def with_advisory_lock!(lock_name, options = {}, &block)
+        result = with_advisory_lock_result(lock_name, options, &block)
+        raise WithAdvisoryLock::FailedToAcquireLock, lock_name unless result.lock_was_acquired?
+
+        result.result
+      end
+
       def with_advisory_lock_result(lock_name, options = {}, &block)
-        class_options = options.extract!(:force_nested_lock_support) if options.respond_to?(:fetch)
-        impl = impl_class(class_options).new(connection, lock_name, options)
+        impl = impl_class.new(connection, lock_name, options)
         impl.with_advisory_lock_if_needed(&block)
       end
 
@@ -29,22 +35,12 @@ module WithAdvisoryLock
 
       private
 
-      def impl_class(options = nil)
+      def impl_class
         adapter = WithAdvisoryLock::DatabaseAdapterSupport.new(connection)
         if adapter.postgresql?
           WithAdvisoryLock::PostgreSQL
         elsif adapter.mysql?
-          nested_lock = if options.respond_to?(:fetch) && [true, false].include?(options.fetch(:force_nested_lock_support, nil))
-                          options.fetch(:force_nested_lock_support)
-                        else
-                          adapter.mysql_nested_lock_support?
-                        end
-
-          if nested_lock
-            WithAdvisoryLock::MySQL
-          else
-            WithAdvisoryLock::MySQLNoNesting
-          end
+          WithAdvisoryLock::MySQL
         else
           WithAdvisoryLock::Flock
         end

data/lib/with_advisory_lock/database_adapter_support.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module WithAdvisoryLock
   class DatabaseAdapterSupport
     # Caches nested lock support by MySQL reported version
@@ -10,46 +12,7 @@ module WithAdvisoryLock
     end
 
     def mysql?
-      %i[mysql mysql2].include? @sym_name
-    end
-
-    # Nested lock support for MySQL was introduced in 5.7.5
-    # Checking by version number is complicated by MySQL compatible DBs (like MariaDB) having their own versioning schemes
-    # Therefore, we check for nested lock support by simply trying a nested lock, then testing and caching the outcome
-    def mysql_nested_lock_support?
-      return false unless mysql?
-
-      # We select the MySQL version this way and cache on it, as MySQL will report versions like "5.7.5", and MariaDB will
-      # report versions like "10.3.8-MariaDB", which allow us to cache on features without introducing problems.
-      version = @connection.select_value("SELECT version()")
-
-      @@mysql_nl_cache_mutex.synchronize do
-        return @@mysql_nl_cache[version] if @@mysql_nl_cache.keys.include?(version)
-
-        lock_1 = "\"nested-test-1-#{SecureRandom.hex}\""
-        lock_2 = "\"nested-test-2-#{SecureRandom.hex}\""
-
-        get_1  = @connection.select_value("SELECT GET_LOCK(#{lock_1}, 0) AS t#{SecureRandom.hex}")
-        get_2  = @connection.select_value("SELECT GET_LOCK(#{lock_2}, 0) AS t#{SecureRandom.hex}")
-
-        # Both locks should succeed in old and new MySQL versions with "1"
-        raise RuntimeError, "Unexpected nested lock acquire result #{get_1}, #{get_2}" unless [get_1, get_2] == [1, 1]
-
-        release_1 = @connection.select_value("SELECT RELEASE_LOCK(#{lock_1}) AS t#{SecureRandom.hex}")
-        release_2 = @connection.select_value("SELECT RELEASE_LOCK(#{lock_2}) AS t#{SecureRandom.hex}")
-
-        # In MySQL <  5.7.5 release_1 will return  nil (not currently locked) and release_2 will return 1 (successfully unlocked)
-        # In MySQL >= 5.7.5 release_1 and release_2 will return 1 (both successfully unlocked)
-        # See https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html#function_get-lock for more
-        @@mysql_nl_cache[version] = case [release_1, release_2]
-                                    when [1, 1]
-                                      true
-                                    when [nil, 1]
-                                      false
-                                    else
-                                      raise RuntimeError, "Unexpected nested lock release result #{release_1}, #{release_2}"
-                                    end
-      end
+      %i[mysql2 trilogy].include? @sym_name
     end
 
     def postgresql?
@@ -57,7 +20,7 @@ module WithAdvisoryLock
     end
 
     def sqlite?
-      :sqlite3 == @sym_name
+      @sym_name == :sqlite3
     end
   end
 end

data/lib/with_advisory_lock/failed_to_acquire_lock.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module WithAdvisoryLock
+  class FailedToAcquireLock < StandardError
+    def initialize(lock_name)
+      super("Failed to acquire lock #{lock_name}")
+    end
+  end
+end

data/lib/with_advisory_lock/flock.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'fileutils'
 
 module WithAdvisoryLock
@@ -19,9 +21,8 @@ module WithAdvisoryLock
     end
 
     def try_lock
-      if transaction
-        raise ArgumentError, 'transaction level locks are not supported on SQLite'
-      end
+      raise ArgumentError, 'transaction level locks are not supported on SQLite' if transaction
+
       0 == file_io.flock((shared ? File::LOCK_SH : File::LOCK_EX) | File::LOCK_NB)
     end
 

data/lib/with_advisory_lock/mysql.rb

@@ -1,12 +1,12 @@
+# frozen_string_literal: true
+
 module WithAdvisoryLock
-  # MySQL > 5.7.5 supports nested locks
   class MySQL < Base
     # See https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html#function_get-lock
     def try_lock
       raise ArgumentError, 'shared locks are not supported on MySQL' if shared
-      if transaction
-        raise ArgumentError, 'transaction level locks are not supported on MySQL'
-      end
+      raise ArgumentError, 'transaction level locks are not supported on MySQL' if transaction
+
       execute_successful?("GET_LOCK(#{quoted_lock_str}, 0)")
     end
 
@@ -16,7 +16,7 @@ module WithAdvisoryLock
 
     def execute_successful?(mysql_function)
       sql = "SELECT #{mysql_function} AS #{unique_column_name}"
-      connection.select_value(sql).to_i > 0
+      connection.select_value(sql).to_i.positive?
     end
 
     # MySQL wants a string as the lock key.

data/lib/with_advisory_lock/postgresql.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module WithAdvisoryLock
   class PostgreSQL < Base
     # See http://www.postgresql.org/docs/9.1/static/functions-admin.html#FUNCTIONS-ADVISORY-LOCKS
@@ -8,10 +10,12 @@ module WithAdvisoryLock
 
     def release_lock
       return if transaction
+
       pg_function = "pg_advisory_unlock#{shared ? '_shared' : ''}"
       execute_successful?(pg_function)
     rescue ActiveRecord::StatementInvalid => e
       raise unless e.message =~ / ERROR: +current transaction is aborted,/
+
       begin
         connection.rollback_db_transaction
         execute_successful?(pg_function)
@@ -21,20 +25,18 @@ module WithAdvisoryLock
     end
 
     def execute_successful?(pg_function)
-      comment = lock_name.gsub(/(\/\*)|(\*\/)/, '--')
+      comment = lock_name.to_s.gsub(%r{(/\*)|(\*/)}, '--')
       sql = "SELECT #{pg_function}(#{lock_keys.join(',')}) AS #{unique_column_name} /* #{comment} */"
       result = connection.select_value(sql)
       # MRI returns 't', jruby returns true. YAY!
-      (result == 't' || result == true)
+      ['t', true].include?(result)
     end
 
     # PostgreSQL wants 2 32bit integers as the lock key.
     def lock_keys
-      @lock_keys ||= begin
-        [stable_hashcode(lock_name), ENV['WITH_ADVISORY_LOCK_PREFIX']].map do |ea|
-          # pg advisory args must be 31 bit ints
-          ea.to_i & 0x7fffffff
-        end
+      @lock_keys ||= [stable_hashcode(lock_name), ENV['WITH_ADVISORY_LOCK_PREFIX']].map do |ea|
+        # pg advisory args must be 31 bit ints
+        ea.to_i & 0x7fffffff
       end
     end
   end

data/lib/with_advisory_lock/version.rb

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