transaction_isolation_continued 1.0.5 → 1.1.1

data/lib/transaction_isolation/active_record/connection_adapters/mysql2_adapter.rb

@@ -1,11 +1,12 @@
-if defined?( ActiveRecord::ConnectionAdapters::Mysql2Adapter )
+# frozen_string_literal: true
+
+if defined?(ActiveRecord::ConnectionAdapters::Mysql2Adapter)
 
   module TransactionIsolation
     module ActiveRecord
       module ConnectionAdapters # :nodoc:
         module Mysql2Adapter
-
-          def self.included( base )
+          def self.included(base)
             base.class_eval do
               alias_method :translate_exception_without_transaction_isolation_conflict, :translate_exception
               alias_method :translate_exception, :translate_exception_with_transaction_isolation_conflict
@@ -17,18 +18,18 @@ if defined?( ActiveRecord::ConnectionAdapters::Mysql2Adapter )
           end
 
           VENDOR_ISOLATION_LEVEL = {
-              :read_uncommitted => 'READ UNCOMMITTED',
-              :read_committed => 'READ COMMITTED',
-              :repeatable_read => 'REPEATABLE READ',
-              :serializable => 'SERIALIZABLE'
-          }
+            read_uncommitted: 'READ UNCOMMITTED',
+            read_committed: 'READ COMMITTED',
+            repeatable_read: 'REPEATABLE READ',
+            serializable: 'SERIALIZABLE'
+          }.freeze
 
           ANSI_ISOLATION_LEVEL = {
-              'READ UNCOMMITTED' => :read_uncommitted,
-              'READ COMMITTED' => :read_committed,
-              'REPEATABLE READ' => :repeatable_read,
-              'SERIALIZABLE' => :serializable
-          }
+            'READ UNCOMMITTED' => :read_uncommitted,
+            'READ COMMITTED' => :read_committed,
+            'REPEATABLE READ' => :repeatable_read,
+            'SERIALIZABLE' => :serializable
+          }.freeze
 
           def current_isolation_level
             ANSI_ISOLATION_LEVEL[current_vendor_isolation_level]
@@ -37,28 +38,30 @@ if defined?( ActiveRecord::ConnectionAdapters::Mysql2Adapter )
           # transaction_isolation was added in MySQL 5.7.20 as an alias for tx_isolation, which is now deprecated and is removed in MySQL 8.0. Applications should be adjusted to use transaction_isolation in preference to tx_isolation.
           def current_vendor_isolation_level
             isolation_variable = TransactionIsolation.config.mysql_isolation_variable
-            select_value( "SELECT @@session.#{isolation_variable}" ).gsub( '-', ' ' )
+            select_value("SELECT @@session.#{isolation_variable}").gsub('-', ' ')
           end
 
-          def isolation_level( level )
-            validate_isolation_level( level )
+          def isolation_level(level)
+            validate_isolation_level(level)
 
             original_vendor_isolation_level = current_vendor_isolation_level if block_given?
 
-            execute( "SET SESSION TRANSACTION ISOLATION LEVEL #{VENDOR_ISOLATION_LEVEL[level]}" )
+            execute("SET SESSION TRANSACTION ISOLATION LEVEL #{VENDOR_ISOLATION_LEVEL[level]}")
+
+            return unless block_given?
 
             begin
               yield
             ensure
               execute "SET SESSION TRANSACTION ISOLATION LEVEL #{original_vendor_isolation_level}"
-            end if block_given?
+            end
           end
 
           def translate_exception_with_transaction_isolation_conflict(*args)
             exception = args.first
 
-            if isolation_conflict?( exception )
-              ::ActiveRecord::TransactionIsolationConflict.new( "Transaction isolation conflict detected: #{exception.message}" )
+            if isolation_conflict?(exception)
+              ::ActiveRecord::TransactionIsolationConflict.new("Transaction isolation conflict detected: #{exception.message}")
             else
               translate_exception_without_transaction_isolation_conflict(*args)
             end
@@ -66,18 +69,17 @@ if defined?( ActiveRecord::ConnectionAdapters::Mysql2Adapter )
 
           ruby2_keywords :translate_exception_with_transaction_isolation_conflict if respond_to?(:ruby2_keywords, true)
 
-          def isolation_conflict?( exception )
-            [ "Deadlock found when trying to get lock",
-              "Lock wait timeout exceeded"].any? do |error_message|
-              exception.message =~ /#{Regexp.escape( error_message )}/i
+          def isolation_conflict?(exception)
+            ['Deadlock found when trying to get lock',
+             'Lock wait timeout exceeded'].any? do |error_message|
+              exception.message =~ /#{Regexp.escape(error_message)}/i
             end
           end
-
         end
       end
     end
   end
 
-  ActiveRecord::ConnectionAdapters::Mysql2Adapter.send( :include, TransactionIsolation::ActiveRecord::ConnectionAdapters::Mysql2Adapter )
+  ActiveRecord::ConnectionAdapters::Mysql2Adapter.include TransactionIsolation::ActiveRecord::ConnectionAdapters::Mysql2Adapter
 
-end
+end

data/lib/transaction_isolation/active_record/connection_adapters/postgresql_adapter.rb

@@ -1,11 +1,12 @@
-if defined?( ActiveRecord::ConnectionAdapters::PostgreSQLAdapter )
+# frozen_string_literal: true
+
+if defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
 
   module TransactionIsolation
     module ActiveRecord
       module ConnectionAdapters # :nodoc:
         module PostgreSQLAdapter
-
-          def self.included( base )
+          def self.included(base)
             base.class_eval do
               alias_method :translate_exception_without_transaction_isolation_conflict, :translate_exception
               alias_method :translate_exception, :translate_exception_with_transaction_isolation_conflict
@@ -17,39 +18,41 @@ if defined?( ActiveRecord::ConnectionAdapters::PostgreSQLAdapter )
           end
 
           VENDOR_ISOLATION_LEVEL = {
-              :read_uncommitted => 'READ UNCOMMITTED',
-              :read_committed => 'READ COMMITTED',
-              :repeatable_read => 'REPEATABLE READ',
-              :serializable => 'SERIALIZABLE'
-          }
+            read_uncommitted: 'READ UNCOMMITTED',
+            read_committed: 'READ COMMITTED',
+            repeatable_read: 'REPEATABLE READ',
+            serializable: 'SERIALIZABLE'
+          }.freeze
 
           ANSI_ISOLATION_LEVEL = {
-              'READ UNCOMMITTED' => :read_uncommitted,
-              'READ COMMITTED' => :read_committed,
-              'REPEATABLE READ' => :repeatable_read,
-              'SERIALIZABLE' => :serializable
-          }
+            'READ UNCOMMITTED' => :read_uncommitted,
+            'READ COMMITTED' => :read_committed,
+            'REPEATABLE READ' => :repeatable_read,
+            'SERIALIZABLE' => :serializable
+          }.freeze
 
           def current_isolation_level
             ANSI_ISOLATION_LEVEL[current_vendor_isolation_level]
           end
 
           def current_vendor_isolation_level
-            select_value( "SHOW TRANSACTION ISOLATION LEVEL" ).upcase
+            select_value('SHOW TRANSACTION ISOLATION LEVEL').upcase
           end
 
-          def isolation_level( level )
-            validate_isolation_level( level )
+          def isolation_level(level)
+            validate_isolation_level(level)
 
             original_vendor_isolation_level = current_vendor_isolation_level if block_given?
 
             execute "SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL #{VENDOR_ISOLATION_LEVEL[level]}"
 
+            return unless block_given?
+
             begin
               yield
             ensure
               execute "SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL #{original_vendor_isolation_level}"
-            end if block_given?
+            end
           end
 
           def translate_exception_with_transaction_isolation_conflict(*args)
@@ -64,18 +67,17 @@ if defined?( ActiveRecord::ConnectionAdapters::PostgreSQLAdapter )
 
           ruby2_keywords :translate_exception_with_transaction_isolation_conflict if respond_to?(:ruby2_keywords, true)
 
-          def isolation_conflict?( exception )
-            [ "deadlock detected",
-              "could not serialize access" ].any? do |error_message|
-              exception.message =~ /#{Regexp.escape( error_message )}/i
+          def isolation_conflict?(exception)
+            ['deadlock detected',
+             'could not serialize access'].any? do |error_message|
+              exception.message =~ /#{Regexp.escape(error_message)}/i
             end
           end
-
         end
       end
     end
   end
 
-  ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send( :include, TransactionIsolation::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter )
+  ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.include TransactionIsolation::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
 
-end
+end

data/lib/transaction_isolation/active_record/connection_adapters/sqlite3_adapter.rb

@@ -1,11 +1,12 @@
-if defined?( ActiveRecord::ConnectionAdapters::SQLite3Adapter )
+# frozen_string_literal: true
+
+if defined?(ActiveRecord::ConnectionAdapters::SQLite3Adapter)
 
   module TransactionIsolation
     module ActiveRecord
       module ConnectionAdapters # :nodoc:
         module SQLite3Adapter
-
-          def self.included( base )
+          def self.included(base)
             base.class_eval do
               alias_method :translate_exception_without_transaction_isolation_conflict, :translate_exception
               alias_method :translate_exception, :translate_exception_with_transaction_isolation_conflict
@@ -17,37 +18,39 @@ if defined?( ActiveRecord::ConnectionAdapters::SQLite3Adapter )
           end
 
           VENDOR_ISOLATION_LEVEL = {
-              :read_uncommitted => 'read_uncommitted = 1',
-              :read_committed => 'read_uncommitted = 0',
-              :repeatable_read => 'read_uncommitted = 0',
-              :serializable => 'read_uncommitted = 0'
-          }
+            read_uncommitted: 'read_uncommitted = 1',
+            read_committed: 'read_uncommitted = 0',
+            repeatable_read: 'read_uncommitted = 0',
+            serializable: 'read_uncommitted = 0'
+          }.freeze
 
           ANSI_ISOLATION_LEVEL = {
-              'read_uncommitted = 1' => :read_uncommitted,
-              'read_uncommitted = 0' => :serializable
-          }
+            'read_uncommitted = 1' => :read_uncommitted,
+            'read_uncommitted = 0' => :serializable
+          }.freeze
 
           def current_isolation_level
             ANSI_ISOLATION_LEVEL[current_vendor_isolation_level]
           end
 
           def current_vendor_isolation_level
-            "read_uncommitted = #{select_value( "PRAGMA read_uncommitted" )}"
+            "read_uncommitted = #{select_value('PRAGMA read_uncommitted')}"
           end
 
-          def isolation_level( level )
-            validate_isolation_level( level )
+          def isolation_level(level)
+            validate_isolation_level(level)
 
             original_vendor_isolation_level = current_vendor_isolation_level if block_given?
 
             execute "PRAGMA #{VENDOR_ISOLATION_LEVEL[level]}"
 
+            return unless block_given?
+
             begin
               yield
             ensure
               execute "PRAGMA #{original_vendor_isolation_level}"
-            end if block_given?
+            end
           end
 
           def translate_exception_with_transaction_isolation_conflict(*args)
@@ -63,11 +66,11 @@ if defined?( ActiveRecord::ConnectionAdapters::SQLite3Adapter )
           ruby2_keywords :translate_exception_with_transaction_isolation_conflict if respond_to?(:ruby2_keywords, true)
 
           # http://www.sqlite.org/c3ref/c_abort.html
-          def isolation_conflict?( exception )
-            [ "The database file is locked",
-              "A table in the database is locked",
-              "Database lock protocol error"].any? do |error_message|
-              exception.message =~ /#{Regexp.escape( error_message )}/i
+          def isolation_conflict?(exception)
+            ['The database file is locked',
+             'A table in the database is locked',
+             'Database lock protocol error'].any? do |error_message|
+              exception.message =~ /#{Regexp.escape(error_message)}/i
             end
           end
         end
@@ -75,6 +78,6 @@ if defined?( ActiveRecord::ConnectionAdapters::SQLite3Adapter )
     end
   end
 
-  ActiveRecord::ConnectionAdapters::SQLite3Adapter.send( :include, TransactionIsolation::ActiveRecord::ConnectionAdapters::SQLite3Adapter )
+  ActiveRecord::ConnectionAdapters::SQLite3Adapter.include TransactionIsolation::ActiveRecord::ConnectionAdapters::SQLite3Adapter
 
 end

data/lib/transaction_isolation/active_record/errors.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_record/errors'
 
 module ActiveRecord

data/lib/transaction_isolation/configuration.rb

@@ -1,16 +1,18 @@
+# frozen_string_literal: true
+
 module TransactionIsolation
   class Configuration
-    attr_accessor :mysql_isolation_variable
-    attr_accessor :detect_mysql_isolation_variable
+    attr_accessor :mysql_isolation_variable, :detect_mysql_isolation_variable
 
     def initialize
       @mysql_isolation_variable = 'tx_isolation'
       @detect_mysql_isolation_variable = true
     end
 
-    def mysql_isolation_variable=( value )
+    def mysql_isolation_variable=(value)
       unless value.in? %w[transaction_isolation tx_isolation]
-        raise ArgumentError, "Invalid MySQL isolation variable '#{value}'. Supported variables include 'transaction_isolation' and 'tx_isolation'."
+        raise ArgumentError,
+              "Invalid MySQL isolation variable '#{value}'. Supported variables include 'transaction_isolation' and 'tx_isolation'."
       end
 
       @mysql_isolation_variable = value

data/lib/transaction_isolation/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module TransactionIsolation
-  VERSION = "1.0.5"
+  VERSION = '1.1.1'
 end

data/lib/transaction_isolation.rb

@@ -1,9 +1,10 @@
-require "active_record"
+# frozen_string_literal: true
+
+require 'active_record'
 require_relative 'transaction_isolation/version'
 require_relative 'transaction_isolation/configuration'
 
 module TransactionIsolation
-
   # Must be called after ActiveRecord established a connection.
   # Only then we know which connection adapter is actually loaded and can be enhanced.
   # Please note ActiveRecord does not load unused adapters.
@@ -31,21 +32,25 @@ module TransactionIsolation
     config
   end
 
-  if defined?( ::Rails )
+  if defined?(::Rails)
     # Setup applying the patch after Rails is initialized.
     class Railtie < ::Rails::Railtie
       config.after_initialize do
-        if ActiveRecord::Base.connection.adapter_name == 'Mysql2' && TransactionIsolation.config.detect_mysql_isolation_variable
-          mysql_version = ActiveRecord::Base.connection.select_value('SELECT version()')
-          if mysql_version >= '8'
-            TransactionIsolation.config.mysql_isolation_variable = 'transaction_isolation'
-          else
-            TransactionIsolation.config.mysql_isolation_variable = 'tx_isolation'
+        begin
+          if TransactionIsolation.config.detect_mysql_isolation_variable && ActiveRecord::Base.connection.adapter_name == 'Mysql2'
+            mysql_version = ActiveRecord::Base.connection.select_value('SELECT version()')
+            TransactionIsolation.config.mysql_isolation_variable = if mysql_version >= '8'
+                                                                     'transaction_isolation'
+                                                                   else
+                                                                     'tx_isolation'
+                                                                   end
           end
+
+          TransactionIsolation.apply_activerecord_patch
+        rescue ActiveRecord::NoDatabaseError
+          # This is expected when running rake db:create
         end
-        TransactionIsolation.apply_activerecord_patch
       end
     end
   end
-
 end

data/lib/transaction_isolation_continued.rb

@@ -0,0 +1 @@
+require 'transaction_isolation'

data/spec/gem_template_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+RSpec.describe GemTemplate do
+  it "has a version number" do
+    expect(GemTemplate::VERSION).not_to be nil
+  end
+
+  it "does something useful" do
+    expect(false).to eq(true)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "gem_template"
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/test/db/all.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_record'
 require_relative 'db'
 require_relative 'migrations'

data/test/db/db.rb

@@ -1,37 +1,37 @@
+# frozen_string_literal: true
+
 require 'fileutils'
 
 module TransactionIsolation
   module Test
     module Db
-
       def self.connect_to_mysql2
         ::ActiveRecord::Base.establish_connection(
-          :adapter => "mysql2",
-          :database => ENV['MYSQL_DB_NAME'],
-          :host => ENV['MYSQL_DB_HOST'],
-          :user => 'root',
-          :password => ENV['MYSQL_DB_PASS']
+          adapter: 'mysql2',
+          database: ENV['MYSQL_DB_NAME'],
+          host: ENV['MYSQL_DB_HOST'],
+          user: 'root',
+          password: ENV['MYSQL_DB_PASS']
         )
       end
 
       def self.connect_to_postgresql
         ::ActiveRecord::Base.establish_connection(
-          :adapter => "postgresql",
-          :database => ENV['POSTGRESQL_DB_NAME'],
-          :host => ENV['POSTGRESQL_DB_HOST'],
-          :user => ENV['POSTGRESQL_DB_USER'],
-          :password => ENV['POSTGRESQL_DB_PASS']
+          adapter: 'postgresql',
+          database: ENV['POSTGRESQL_DB_NAME'],
+          host: ENV['POSTGRESQL_DB_HOST'],
+          user: ENV['POSTGRESQL_DB_USER'],
+          password: ENV['POSTGRESQL_DB_PASS']
         )
       end
 
       def self.connect_to_sqlite3
         ActiveRecord::Base.establish_connection(
-          :adapter => "sqlite3",
-          :database => ":memory:",
-          :verbosity => "silent"
+          adapter: 'sqlite3',
+          database: ':memory:',
+          verbosity: 'silent'
         )
       end
-
     end
   end
 end

data/test/db/migrations.rb

@@ -1,20 +1,19 @@
+# frozen_string_literal: true
+
 module TransactionIsolation
   module Test
     module Migrations
-
       def self.run!
         c = ::ActiveRecord::Base.connection
 
         # Queued Jobs
-        
-        c.create_table "queued_jobs", :force => true do |t|
-          t.text     "job",                               :null => false
-          t.integer  "status",     :default => 0,         :null => false
+
+        c.create_table 'queued_jobs', force: true do |t|
+          t.text     'job', null: false
+          t.integer  'status', default: 0, null: false
           t.timestamps
         end
-
       end
-
     end
   end
 end

data/test/db/queued_job.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class QueuedJob < ActiveRecord::Base
 end

data/test/integration/active_record/base/isolation_level_test.rb

@@ -1,23 +1,17 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
 
 require 'test_helper'
 
 class ActiveRecordTest < Minitest::Test
-
   class BaseTest < Minitest::Test
-
     class IsolationLevelTest < Minitest::Test
-
       def test_wraps_connection_isolation_level
-        ActiveRecord::Base.isolation_level( :serializable ) do
+        ActiveRecord::Base.isolation_level(:serializable) do
           ActiveRecord::Base.transaction do
-            assert_equal( :serializable, ActiveRecord::Base.connection.current_isolation_level )
+            assert_equal(:serializable, ActiveRecord::Base.connection.current_isolation_level)
           end
         end
       end
-
     end
-
   end
-
 end

data/test/integration/active_record/connection_adapters/any_adapter/current_isolation_level_test.rb

@@ -1,33 +1,25 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
 
 require 'test_helper'
 
 class ActiveRecordTest < Minitest::Test
-
   class ConnectionAdaptersTest < Minitest::Test
-
     class AnyAdapterTest < Minitest::Test
-
       class CurrentIsolationLevelTest < Minitest::Test
-
         def test_returns_correct_default_isolation_level
-          if defined?( ActiveRecord::ConnectionAdapters::Mysql2Adapter )
-            assert_equal( :repeatable_read, ActiveRecord::Base.connection.current_isolation_level )
+          if defined?(ActiveRecord::ConnectionAdapters::Mysql2Adapter)
+            assert_equal(:repeatable_read, ActiveRecord::Base.connection.current_isolation_level)
           end
 
-          if defined?( ActiveRecord::ConnectionAdapters::PostgreSQLAdapter )
-            assert_equal( :read_committed, ActiveRecord::Base.connection.current_isolation_level )
+          if defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
+            assert_equal(:read_committed, ActiveRecord::Base.connection.current_isolation_level)
           end
 
-          if defined?( ActiveRecord::ConnectionAdapters::SQLite3Adapter )
-            assert_equal( :serializable, ActiveRecord::Base.connection.current_isolation_level )
-          end
-        end
+          return unless defined?(ActiveRecord::ConnectionAdapters::SQLite3Adapter)
 
+          assert_equal(:serializable, ActiveRecord::Base.connection.current_isolation_level)
+        end
       end
-
     end
-
   end
-
 end

data/test/integration/active_record/connection_adapters/any_adapter/current_vendor_isolation_level_test.rb

@@ -1,33 +1,25 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
 
 require 'test_helper'
 
 class ActiveRecordTest < Minitest::Test
-
   class ConnectionAdaptersTest < Minitest::Test
-
     class AnyAdapterTest < Minitest::Test
-
       class CurrentVendorIsolationLevelTest < Minitest::Test
-
         def test_returns_correct_default_vendor_isolation_level
-          if defined?( ActiveRecord::ConnectionAdapters::Mysql2Adapter )
-            assert_equal( 'REPEATABLE READ', ActiveRecord::Base.connection.current_vendor_isolation_level )
+          if defined?(ActiveRecord::ConnectionAdapters::Mysql2Adapter)
+            assert_equal('REPEATABLE READ', ActiveRecord::Base.connection.current_vendor_isolation_level)
           end
 
-          if defined?( ActiveRecord::ConnectionAdapters::PostgreSQLAdapter )
-            assert_equal( 'READ COMMITTED', ActiveRecord::Base.connection.current_vendor_isolation_level )
+          if defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
+            assert_equal('READ COMMITTED', ActiveRecord::Base.connection.current_vendor_isolation_level)
           end
 
-          if defined?( ActiveRecord::ConnectionAdapters::SQLite3Adapter )
-            assert_equal( 'read_uncommitted = 0', ActiveRecord::Base.connection.current_vendor_isolation_level )
-          end
-        end
+          return unless defined?(ActiveRecord::ConnectionAdapters::SQLite3Adapter)
 
+          assert_equal('read_uncommitted = 0', ActiveRecord::Base.connection.current_vendor_isolation_level)
+        end
       end
-
     end
-
   end
-
 end