strong_migrations 2.5.2 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c7db529b15ac630f2f6c9e284b185ca5affbdb275c2d34d26e508317f6e2fa4
-  data.tar.gz: 8b00a79a0f4cb787d43de827cbafe495c081b5250db4f08d75a893953778d72a
+  metadata.gz: 33d90fe56d07dcdf864739aeae07dac0c63b6504460299724bc293a43c5aeb7e
+  data.tar.gz: 9e7ea3be4a0d3b8b03bcb2e4e6b5f6b4425057388a4b8ae52a7263d5497d5de8
 SHA512:
-  metadata.gz: 73091c6f13637427c09ed2dc013f804ac1ce91d78844b6dc10b7deb89aeb4d391123c4f16e661b34a1fd9e8013f5c6c50295e2a45824ca042e9418d3c6cd338d
-  data.tar.gz: 96bbd494942e1a9f3a529f2ee7453fb693e9ec61aba22846d6be9c5a986b9213053142f9f06a87dc16dbc9361520ae9ae84e32c72e43654fdd0f2da921590cdb
+  metadata.gz: fe975030ddbdd8bce5f8bc1a18498e67e505627618a47d201e916d6c0ca21f846852ef08dc923e3a8626c2634fdcfa4d38fe9b674bc13b58d7a0c5064a012f0a
+  data.tar.gz: 4e0fe03e8ac9cb3872a7d9179f5902a8044587ffab5b22c02c7bbf63303a9bee48e195c6b77f30491f382ff7435a22cfe9e92c0a6dc53f145cf67d1f21cfb109

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 2.6.0 (2026-04-07)
+
+- Added check for `algorithm: :copy` with MySQL and MariaDB
+- Added check for `lock: :shared` and `lock: :exclusive` with MySQL and MariaDB
+- Dropped support for Ruby < 3.3 and Active Record < 7.2
+
 ## 2.5.2 (2025-12-20)
 
 - Fixed false positive for `add_reference` with `foreign_key: {validate: false}`

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2013 Bob Remeika and David Waller, 2015-2025 Andrew Kane
+Copyright (c) 2013 Bob Remeika and David Waller, 2015-2026 Andrew Kane
 
 MIT License
 

data/README.md

@@ -82,6 +82,11 @@ Postgres-specific checks:
 - [adding a column with a volatile default value](#adding-a-column-with-a-volatile-default-value)
 - [renaming a schema](#renaming-a-schema)
 
+MySQL and MariaDB-specific checks:
+
+- [using the COPY algorithm](#using-the-copy-algorithm)
+- [using shared or exclusive locking](#using-shared-or-exclusive-locking)
+
 Best practices:
 
 - [keeping non-unique indexes to three columns or less](#keeping-non-unique-indexes-to-three-columns-or-less)
@@ -146,14 +151,14 @@ Type | Safe Changes
 --- | ---
 `cidr` | Changing to `inet`
 `citext` | Changing to `text` if not indexed, changing to `string` with no `:limit` if not indexed
-`datetime` | Increasing or removing `:precision`, changing to `timestamptz` when session time zone is UTC in Postgres 12+
+`datetime` | Increasing or removing `:precision`, changing to `timestamptz` when session time zone is UTC
 `decimal` | Increasing `:precision` at same `:scale`, removing `:precision` and `:scale`
 `interval` | Increasing or removing `:precision`
 `numeric` | Increasing `:precision` at same `:scale`, removing `:precision` and `:scale`
 `string` | Increasing or removing `:limit`, changing to `text`, changing `citext` if not indexed
 `text` | Changing to `string` with no `:limit`, changing to `citext` if not indexed
 `time` | Increasing or removing `:precision`
-`timestamptz` | Increasing or removing `:limit`, changing to `datetime` when session time zone is UTC in Postgres 12+
+`timestamptz` | Increasing or removing `:limit`, changing to `datetime` when session time zone is UTC
 
 And some in MySQL and MariaDB:
 
@@ -680,6 +685,58 @@ A safer approach is to:
 5. Stop writing to the old schema
 6. Drop the old schema
 
+### Using the COPY algorithm
+
+#### Bad
+
+In MySQL and MariaDB, using the `COPY` algorithm blocks writes.
+
+```ruby
+class AddSomeIndexToUsers < ActiveRecord::Migration[8.1]
+  def change
+    add_index :users, :some_column, algorithm: :copy
+  end
+end
+```
+
+#### Good
+
+Use the default algorithm.
+
+```ruby
+class AddSomeIndexToUsers < ActiveRecord::Migration[8.1]
+  def change
+    add_index :users, :some_column
+  end
+end
+```
+
+### Using shared or exclusive locking
+
+#### Bad
+
+In MySQL and MariaDB, using shared locking blocks writes, and using exclusive locking blocks reads and writes.
+
+```ruby
+class AddSomeIndexToUsers < ActiveRecord::Migration[8.2]
+  def change
+    add_index :users, :some_column, lock: :shared
+  end
+end
+```
+
+#### Good
+
+Use the default locking or no locking.
+
+```ruby
+class AddSomeIndexToUsers < ActiveRecord::Migration[8.2]
+  def change
+    add_index :users, :some_column
+  end
+end
+```
+
 ### Keeping non-unique indexes to three columns or less
 
 #### Bad
@@ -910,7 +967,7 @@ Use the version from your latest migration.
 If your development database version is different from production, you can specify the production version so the right checks run in development.
 
 ```ruby
-StrongMigrations.target_version = 10 # or 8.0, 10.5, etc
+StrongMigrations.target_version = 16
 ```
 
 The major version works well for Postgres, while the major and minor version is recommended for MySQL and MariaDB.
@@ -920,7 +977,7 @@ For safety, this option only affects development and test environments. In other
 If your app has multiple databases with different versions, you can use:
 
 ```ruby
-StrongMigrations.target_version = {primary: 13, catalog: 15}
+StrongMigrations.target_version = {primary: 16, catalog: 18}
 ```
 
 ## Analyze Tables

data/lib/generators/strong_migrations/install_generator.rb

@@ -24,9 +24,9 @@ module StrongMigrations
         when /mysql|trilogy/
           # could try to connect to database and check for MariaDB
           # but this should be fine
-          "8.0"
+          "8.4"
         else
-          "10"
+          "18"
         end
       end
 

data/lib/strong_migrations/checks.rb

@@ -76,6 +76,11 @@ module StrongMigrations
           rewrite_blocks: adapter.rewrite_blocks,
           append: append
       end
+
+      check_algorithm_option("add_column", *args, **options)
+
+      # not necessarily dangerous, but not necessary
+      check_lock_option("add_column", *args, **options)
     end
 
     def check_add_exclusion_constraint(*args)
@@ -138,6 +143,10 @@ module StrongMigrations
 
         raise_error :add_index, command: command_str("add_index", [table, columns, options.merge(algorithm: :concurrently)])
       end
+
+      check_algorithm_option("add_index", *args, **options)
+
+      check_lock_option("add_index", *args, **options)
     end
 
     def check_add_reference(method, *args)
@@ -155,7 +164,7 @@ module StrongMigrations
 
         if index_unsafe || foreign_key_unsafe
           if index_value.is_a?(Hash)
-            options[:index] = options[:index].merge(algorithm: :concurrently)
+            options = options.merge(index: index_value.merge(algorithm: :concurrently))
           elsif index_value
             options = options.merge(index: {algorithm: :concurrently})
           end
@@ -179,6 +188,41 @@ module StrongMigrations
             append: append
         end
       end
+
+      check_algorithm_option("add_reference", *args, **options)
+
+      # not necessarily dangerous, but not necessary
+      check_lock_option("add_reference", *args, **options)
+
+      if (mysql? || mariadb?) && !new_table?(table)
+        index_value = options[:index]
+        copy_set = index_value.is_a?(Hash) && index_value[:algorithm] == :copy
+        if copy_set
+          index_value = index_value.except(:algorithm)
+          if index_value.empty?
+            options = options.except(:index)
+          else
+            options = options.merge(index: index_value)
+          end
+          raise_error :copy_algorithm, command: command_str("add_reference", args + [options])
+        end
+
+        if ar_version >= 8.2
+          lock = index_value.is_a?(Hash) && index_value[:lock]
+          if [:shared, :exclusive].include?(lock)
+            index_value = index_value.except(:lock)
+            if index_value.empty?
+              options = options.except(:index)
+            else
+              options = options.merge(index: index_value)
+            end
+            raise_error :lock_option,
+              command: command_str(method, args + [options]),
+              lock_type: lock.to_s,
+              lock_blocks: lock == :shared ? "reads" : "reads and writes"
+          end
+        end
+      end
     end
 
     def check_add_unique_constraint(*args)
@@ -190,9 +234,9 @@ module StrongMigrations
       if column && !new_table?(table)
         index_name = connection.index_name(table, {column: column})
         raise_error :add_unique_constraint,
-          index_command: command_str(:add_index, [table, column, {unique: true, algorithm: :concurrently}]),
-          constraint_command: command_str(:add_unique_constraint, [table, {using_index: index_name}]),
-          remove_command: command_str(:remove_unique_constraint, [table, column])
+          index_command: command_str("add_index", [table, column, {unique: true, algorithm: :concurrently}]),
+          constraint_command: command_str("add_unique_constraint", [table, {using_index: index_name}]),
+          remove_command: command_str("remove_unique_constraint", [table, column])
       end
     end
 
@@ -224,16 +268,16 @@ module StrongMigrations
         if constraints.any?
           change_commands = []
           constraints.each do |c|
-            change_commands << command_str(:remove_check_constraint, [table, c.expression, {name: c.name}])
+            change_commands << command_str("remove_check_constraint", [table, c.expression, {name: c.name}])
           end
-          change_commands << command_str(:change_column, args + [options])
+          change_commands << command_str("change_column", args + [options])
           constraints.each do |c|
-            change_commands << command_str(:add_check_constraint, [table, c.expression, {name: c.name, validate: false}])
+            change_commands << command_str("add_check_constraint", [table, c.expression, {name: c.name, validate: false}])
           end
 
           validate_commands = []
           constraints.each do |c|
-            validate_commands << command_str(:validate_check_constraint, [table, {name: c.name}])
+            validate_commands << command_str("validate_check_constraint", [table, {name: c.name}])
           end
 
           raise_error :change_column_constraint,
@@ -241,6 +285,11 @@ module StrongMigrations
             validate_constraint_code: validate_commands.join("\n    ")
         end
       end
+
+      check_algorithm_option("change_column", *args, **options)
+
+      # not necessarily dangerous, but not necessary
+      check_lock_option("change_column", *args, **options)
     end
 
     def check_change_column_default(*args)
@@ -286,12 +335,12 @@ module StrongMigrations
               throw :safe
             end
 
-            add_constraint_code = command_str(:add_check_constraint, add_args)
+            add_constraint_code = command_str("add_check_constraint", add_args)
 
-            up_code = String.new(command_str(:validate_check_constraint, validate_args))
-            up_code << "\n    #{command_str(:change_column_null, change_args)}"
-            up_code << "\n    #{command_str(:remove_check_constraint, remove_args)}"
-            down_code = "#{add_constraint_code}\n    #{command_str(:change_column_null, [table, column, true])}"
+            up_code = String.new(command_str("validate_check_constraint", validate_args))
+            up_code << "\n    #{command_str("change_column_null", change_args)}"
+            up_code << "\n    #{command_str("remove_check_constraint", remove_args)}"
+            down_code = "#{add_constraint_code}\n    #{command_str("change_column_null", [table, column, true])}"
             validate_constraint_code = "def up\n    #{up_code}\n  end\n\n  def down\n    #{down_code}\n  end"
 
             raise_error :change_column_null_postgresql,
@@ -337,6 +386,7 @@ module StrongMigrations
       raise_error :execute, header: "Possibly dangerous operation"
     end
 
+    # supports algorithm and lock options, but always raises
     def check_remove_column(method, *args)
       columns =
         case method
@@ -383,8 +433,14 @@ module StrongMigrations
 
         raise_error :remove_index, command: command_str("remove_index", args + [options.merge(algorithm: :concurrently)])
       end
+
+      check_algorithm_option("remove_index", *args, **options)
+
+      # not necessarily dangerous, but not necessary
+      check_lock_option("remove_index", *args, **options)
     end
 
+    # supports algorithm and lock options, but always raises
     def check_rename_column
       raise_error :rename_column
     end
@@ -442,6 +498,21 @@ module StrongMigrations
       @migration.stop!(message, header: header || "Dangerous operation detected")
     end
 
+    def check_algorithm_option(method, *args, **options)
+      if (mysql? || mariadb?) && options[:algorithm] == :copy && !new_table?(args[0]) && (ar_version >= 8.2 || method == "add_index")
+        raise_error :copy_algorithm, command: command_str(method, args + [options.except(:algorithm)])
+      end
+    end
+
+    def check_lock_option(method, *args, **options)
+      if (mysql? || mariadb?) && [:shared, :exclusive].include?(options[:lock]) && !new_table?(args[0]) && ar_version >= 8.2
+        raise_error :lock_option,
+          command: command_str(method, args + [options.except(:lock)]),
+          lock_type: options[:lock].to_s,
+          lock_blocks: options[:lock] == :shared ? "reads" : "reads and writes"
+      end
+    end
+
     def constraint_str(statement, identifiers)
       # not all identifiers are tables, but this method of quoting should be fine
       statement % identifiers.map { |v| connection.quote_table_name(v) }

data/lib/strong_migrations/error_messages.rb

@@ -281,6 +281,24 @@ class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
   def down
     %{remove_command}
   end
+end",
+
+    copy_algorithm:
+"Using the COPY algorithm blocks writes. Instead, use:
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{command}
+  end
+end",
+
+    lock_option:
+"Using %{lock_type} locking blocks %{lock_blocks}. Instead, use:
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{command}
+  end
 end"
   }
   self.enabled_checks = (error_messages.keys - [:remove_index]).map { |k| [k, {}] }.to_h

data/lib/strong_migrations/version.rb

@@ -1,3 +1,3 @@
 module StrongMigrations
-  VERSION = "2.5.2"
+  VERSION = "2.6.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: strong_migrations
 version: !ruby/object:Gem::Version
-  version: 2.5.2
+  version: 2.6.0
 platform: ruby
 authors:
 - Andrew Kane
@@ -17,14 +17,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '7.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '7.2'
 email:
 - andrew@ankane.org
 - bob.remeika@gmail.com
@@ -65,14 +65,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Catch unsafe migrations in development
 test_files: []