strong_migrations 0.7.9 → 1.4.4

data/lib/strong_migrations/migration.rb

@@ -9,8 +9,13 @@ module StrongMigrations
     def method_missing(method, *args)
       return super if is_a?(ActiveRecord::Schema)
 
-      strong_migrations_checker.perform(method, *args) do
-        super
+      # Active Record 7.0.2+ versioned schema
+      return super if defined?(ActiveRecord::Schema::Definition) && is_a?(ActiveRecord::Schema::Definition)
+
+      catch(:safe) do
+        strong_migrations_checker.perform(method, *args) do
+          super
+        end
       end
     end
     ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)

data/lib/strong_migrations/migrator.rb

@@ -0,0 +1,19 @@
+module StrongMigrations
+  module Migrator
+    def ddl_transaction(migration, *args)
+      return super unless StrongMigrations.lock_timeout_retries > 0 && use_transaction?(migration)
+
+      # handle MigrationProxy class
+      migration = migration.send(:migration) if migration.respond_to?(:migration, true)
+
+      # retry migration since the entire transaction needs to be rerun
+      checker = migration.send(:strong_migrations_checker)
+      checker.retry_lock_timeouts(check_committed: true) do
+        # failed transaction reverts timeout, so need to re-apply
+        checker.timeouts_set = false
+
+        super(migration, *args)
+      end
+    end
+  end
+end

data/lib/strong_migrations/safe_methods.rb

@@ -5,22 +5,22 @@ module StrongMigrations
     end
 
     # TODO check if invalid index with expected name exists and remove if needed
-    def safe_add_index(table, columns, options)
+    def safe_add_index(*args, **options)
       disable_transaction
-      @migration.add_index(table, columns, **options.merge(algorithm: :concurrently))
+      @migration.add_index(*args, **options.merge(algorithm: :concurrently))
     end
 
-    def safe_remove_index(table, options)
+    def safe_remove_index(*args, **options)
       disable_transaction
-      @migration.remove_index(table, **options.merge(algorithm: :concurrently))
+      @migration.remove_index(*args, **options.merge(algorithm: :concurrently))
     end
 
-    def safe_add_reference(table, reference, options)
+    def safe_add_reference(table, reference, *args, **options)
       @migration.reversible do |dir|
         dir.up do
           disable_transaction
           foreign_key = options.delete(:foreign_key)
-          @migration.add_reference(table, reference, **options)
+          @migration.add_reference(table, reference, *args, **options)
           if foreign_key
             # same as Active Record
             name =
@@ -43,50 +43,49 @@ module StrongMigrations
       end
     end
 
-    def safe_add_foreign_key(from_table, to_table, options)
+    def safe_add_foreign_key(from_table, to_table, *args, **options)
       @migration.reversible do |dir|
         dir.up do
-          @migration.add_foreign_key(from_table, to_table, **options.merge(validate: false))
+          @migration.add_foreign_key(from_table, to_table, *args, **options.merge(validate: false))
           disable_transaction
-          @migration.validate_foreign_key(from_table, to_table)
-        end
-        dir.down do
-          @migration.remove_foreign_key(from_table, to_table)
-        end
-      end
-    end
-
-    def safe_add_foreign_key_code(from_table, to_table, add_code, validate_code)
-      @migration.reversible do |dir|
-        dir.up do
-          @migration.safety_assured do
-            @migration.execute(add_code)
-            disable_transaction
-            @migration.execute(validate_code)
+          validate_options = options.slice(:column, :name)
+          if ActiveRecord::VERSION::MAJOR >= 6
+            @migration.validate_foreign_key(from_table, to_table, **validate_options)
+          else
+            @migration.validate_foreign_key(from_table, validate_options.any? ? validate_options : to_table)
           end
         end
         dir.down do
-          @migration.remove_foreign_key(from_table, to_table)
+          remove_options = options.slice(:column, :name)
+          if ActiveRecord::VERSION::MAJOR >= 6
+            @migration.remove_foreign_key(from_table, to_table, **remove_options)
+          else
+            @migration.remove_foreign_key(from_table, remove_options.any? ? remove_options : to_table)
+          end
         end
       end
     end
 
-    def safe_add_check_constraint(table, expression, add_options, validate_options)
+    def safe_add_check_constraint(table, expression, *args, add_options, validate_options)
       @migration.reversible do |dir|
         dir.up do
-          @migration.add_check_constraint(table, expression, **add_options)
+          @migration.add_check_constraint(table, expression, *args, **add_options)
           disable_transaction
           @migration.validate_check_constraint(table, **validate_options)
         end
         dir.down do
-          @migration.remove_check_constraint(table, expression, **add_options)
+          @migration.remove_check_constraint(table, expression, **add_options.except(:validate))
         end
       end
     end
 
-    def safe_change_column_null(add_code, validate_code, change_args, remove_code)
+    def safe_change_column_null(add_code, validate_code, change_args, remove_code, default)
       @migration.reversible do |dir|
         dir.up do
+          unless default.nil?
+            raise Error, "default value not supported yet with safe_by_default"
+          end
+
           @migration.safety_assured do
             @migration.execute(add_code)
             disable_transaction

data/lib/strong_migrations/schema_dumper.rb

@@ -0,0 +1,21 @@
+module StrongMigrations
+  module SchemaDumper
+    def initialize(connection, *args, **options)
+      return super unless StrongMigrations.alphabetize_schema
+
+      super(WrappedConnection.new(connection), *args, **options)
+    end
+  end
+
+  class WrappedConnection
+    delegate_missing_to :@connection
+
+    def initialize(connection)
+      @connection = connection
+    end
+
+    def columns(*args, **options)
+      @connection.columns(*args, **options).sort_by(&:name)
+    end
+  end
+end

data/lib/strong_migrations/version.rb

@@ -1,3 +1,3 @@
 module StrongMigrations
-  VERSION = "0.7.9"
+  VERSION = "1.4.4"
 end

data/lib/strong_migrations.rb

@@ -1,253 +1,59 @@
 # dependencies
 require "active_support"
 
+# adapters
+require_relative "strong_migrations/adapters/abstract_adapter"
+require_relative "strong_migrations/adapters/mysql_adapter"
+require_relative "strong_migrations/adapters/mariadb_adapter"
+require_relative "strong_migrations/adapters/postgresql_adapter"
+
 # modules
-require "strong_migrations/safe_methods"
-require "strong_migrations/checker"
-require "strong_migrations/database_tasks"
-require "strong_migrations/migration"
-require "strong_migrations/version"
+require_relative "strong_migrations/checks"
+require_relative "strong_migrations/safe_methods"
+require_relative "strong_migrations/checker"
+require_relative "strong_migrations/database_tasks"
+require_relative "strong_migrations/migration"
+require_relative "strong_migrations/migrator"
+require_relative "strong_migrations/version"
 
 # integrations
-require "strong_migrations/railtie" if defined?(Rails)
+require_relative "strong_migrations/railtie" if defined?(Rails)
 
 module StrongMigrations
   class Error < StandardError; end
   class UnsafeMigration < Error; end
+  class UnsupportedVersion < Error; end
 
   class << self
     attr_accessor :auto_analyze, :start_after, :checks, :error_messages,
       :target_postgresql_version, :target_mysql_version, :target_mariadb_version,
       :enabled_checks, :lock_timeout, :statement_timeout, :check_down, :target_version,
-      :safe_by_default
+      :safe_by_default, :target_sql_mode, :lock_timeout_retries, :lock_timeout_retry_delay,
+      :alphabetize_schema
     attr_writer :lock_timeout_limit
   end
   self.auto_analyze = false
   self.start_after = 0
+  self.lock_timeout_retries = 0
+  self.lock_timeout_retry_delay = 10 # seconds
   self.checks = []
   self.safe_by_default = false
-  self.error_messages = {
-    add_column_default:
-"Adding a column with a non-null default blocks %{rewrite_blocks} while the entire table is rewritten.
-Instead, add the column without a default value, then change the default.
-
-class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
-  def up
-    %{add_command}
-    %{change_command}
-  end
-
-  def down
-    %{remove_command}
-  end
-end
-
-Then backfill the existing rows in the Rails console or a separate migration with disable_ddl_transaction!.
-
-class Backfill%{migration_name} < ActiveRecord::Migration%{migration_suffix}
-  disable_ddl_transaction!
-
-  def up
-    %{code}
-  end
-end",
-
-    add_column_json:
-"There's no equality operator for the json column type, which can cause errors for
-existing SELECT DISTINCT queries in your application. Use jsonb instead.
-
-class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
-  def change
-    %{command}
-  end
-end",
-
-    change_column:
-"Changing the type of an existing column blocks %{rewrite_blocks}
-while the entire table is rewritten. A safer approach is to:
-
-1. Create a new column
-2. Write to both columns
-3. Backfill data from the old column to the new column
-4. Move reads from the old column to the new column
-5. Stop writing to the old column
-6. Drop the old column",
-
-    change_column_with_not_null:
-"Changing the type is safe, but setting NOT NULL is not.",
-
-    remove_column: "Active Record caches attributes, which causes problems
-when removing columns. Be sure to ignore the column%{column_suffix}:
-
-class %{model} < %{base_model}
-  %{code}
-end
-
-Deploy the code, then wrap this step in a safety_assured { ... } block.
-
-class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
-  def change
-    safety_assured { %{command} }
-  end
-end",
-
-    rename_column:
-"Renaming a column that's in use will cause errors
-in your application. A safer approach is to:
-
-1. Create a new column
-2. Write to both columns
-3. Backfill data from the old column to new column
-4. Move reads from the old column to the new column
-5. Stop writing to the old column
-6. Drop the old column",
-
-    rename_table:
-"Renaming a table that's in use will cause errors
-in your application. A safer approach is to:
-
-1. Create a new table. Don't forget to recreate indexes from the old table
-2. Write to both tables
-3. Backfill data from the old table to new table
-4. Move reads from the old table to the new table
-5. Stop writing to the old table
-6. Drop the old table",
-
-    add_reference:
-"%{headline} Instead, use:
-
-class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
-  disable_ddl_transaction!
-
-  def change
-    %{command}
-  end
-end",
-
-    add_index:
-"Adding an index non-concurrently blocks writes. Instead, use:
-
-class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
-  disable_ddl_transaction!
-
-  def change
-    %{command}
-  end
-end",
-
-    remove_index:
-"Removing an index non-concurrently blocks writes. Instead, use:
-
-class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
-  disable_ddl_transaction!
-
-  def change
-    %{command}
-  end
-end",
-
-    add_index_columns:
-"Adding a non-unique index with more than three columns rarely improves performance.
-Instead, start an index with columns that narrow down the results the most.",
-
-    change_table:
-"Strong Migrations does not support inspecting what happens inside a
-change_table block, so cannot help you here. Please make really sure that what
-you're doing is safe before proceeding, then wrap it in a safety_assured { ... } block.",
-
-    create_table:
-"The force option will destroy existing tables.
-If this is intended, drop the existing table first.
-Otherwise, remove the force option.",
-
-    execute:
-"Strong Migrations does not support inspecting what happens inside an
-execute call, so cannot help you here. Please make really sure that what
-you're doing is safe before proceeding, then wrap it in a safety_assured { ... } block.",
-
-    change_column_null:
-"Passing a default value to change_column_null runs a single UPDATE query,
-which can cause downtime. Instead, backfill the existing rows in the
-Rails console or a separate migration with disable_ddl_transaction!.
-
-class Backfill%{migration_name} < ActiveRecord::Migration%{migration_suffix}
-  disable_ddl_transaction!
-
-  def up
-    %{code}
-  end
-end",
-
-    change_column_null_postgresql:
-"Setting NOT NULL on an existing column blocks reads and writes while every row is checked.
-Instead, add a check constraint and validate it in a separate migration.
-
-class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
-  def change
-    %{add_constraint_code}
-  end
-end
-
-class Validate%{migration_name} < ActiveRecord::Migration%{migration_suffix}
-  def change
-    %{validate_constraint_code}
-  end
-end",
-
-    change_column_null_mysql:
-"Setting NOT NULL on an existing column is not safe with your database engine.",
-
-    add_foreign_key:
-"Adding a foreign key blocks writes on both tables. Instead,
-add the foreign key without validating existing rows,
-then validate them in a separate migration.
-
-class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
-  def change
-    %{add_foreign_key_code}
-  end
-end
-
-class Validate%{migration_name} < ActiveRecord::Migration%{migration_suffix}
-  def change
-    %{validate_foreign_key_code}
-  end
-end",
-
-    validate_foreign_key:
-"Validating a foreign key while writes are blocked is dangerous.
-Use disable_ddl_transaction! or a separate migration.",
-
-    add_check_constraint:
-"Adding a check constraint key blocks reads and writes while every row is checked.
-Instead, add the check constraint without validating existing rows,
-then validate them in a separate migration.
-
-class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
-  def change
-    %{add_check_constraint_code}
-  end
-end
-
-class Validate%{migration_name} < ActiveRecord::Migration%{migration_suffix}
-  def change
-    %{validate_check_constraint_code}
-  end
-end",
-
-    add_check_constraint_mysql:
-"Adding a check constraint to an existing table is not safe with your database engine.",
-
-    validate_check_constraint:
-"Validating a check constraint while writes are blocked is dangerous.
-Use disable_ddl_transaction! or a separate migration."
-  }
-  self.enabled_checks = (error_messages.keys - [:remove_index]).map { |k| [k, {}] }.to_h
   self.check_down = false
+  self.alphabetize_schema = false
 
   # private
   def self.developer_env?
-    defined?(Rails) && (Rails.env.development? || Rails.env.test?)
+    env == "development" || env == "test"
+  end
+
+  # private
+  def self.env
+    if defined?(Rails.env)
+      Rails.env
+    else
+      # default to production for safety
+      ENV["RACK_ENV"] || "production"
+    end
   end
 
   def self.lock_timeout_limit
@@ -279,10 +85,17 @@ Use disable_ddl_transaction! or a separate migration."
   end
 end
 
+# load error messages
+require_relative "strong_migrations/error_messages"
+
 ActiveSupport.on_load(:active_record) do
   ActiveRecord::Migration.prepend(StrongMigrations::Migration)
+  ActiveRecord::Migrator.prepend(StrongMigrations::Migrator)
 
   if defined?(ActiveRecord::Tasks::DatabaseTasks)
     ActiveRecord::Tasks::DatabaseTasks.singleton_class.prepend(StrongMigrations::DatabaseTasks)
   end
+
+  require_relative "strong_migrations/schema_dumper"
+  ActiveRecord::SchemaDumper.prepend(StrongMigrations::SchemaDumper)
 end

data/lib/tasks/strong_migrations.rake

@@ -1,14 +1,9 @@
 namespace :strong_migrations do
-  # https://www.pgrs.net/2008/03/13/alphabetize-schema-rb-columns/
+  # https://www.pgrs.net/2008/03/12/alphabetize-schema-rb-columns/
   task :alphabetize_columns do
     $stderr.puts "Dumping schema"
     ActiveRecord::Base.logger.level = Logger::INFO
 
-    require "strong_migrations/alphabetize_columns"
-    ActiveRecord::Base.connection.class.prepend StrongMigrations::AlphabetizeColumns
-    if ActiveRecord::ConnectionAdapters.const_defined?('PostGISAdapter')
-      ActiveRecord::ConnectionAdapters::PostGISAdapter.prepend StrongMigrations::AlphabetizeColumns
-    end
-    ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend StrongMigrations::AlphabetizeColumns
+    StrongMigrations.alphabetize_schema = true
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: strong_migrations
 version: !ruby/object:Gem::Version
-  version: 0.7.9
+  version: 1.4.4
 platform: ruby
 authors:
 - Andrew Kane
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-16 00:00:00.000000000 Z
+date: 2023-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -18,14 +18,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5'
+        version: '5.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5'
+        version: '5.2'
 description:
 email:
 - andrew@ankane.org
@@ -41,12 +41,19 @@ files:
 - lib/generators/strong_migrations/install_generator.rb
 - lib/generators/strong_migrations/templates/initializer.rb.tt
 - lib/strong_migrations.rb
-- lib/strong_migrations/alphabetize_columns.rb
+- lib/strong_migrations/adapters/abstract_adapter.rb
+- lib/strong_migrations/adapters/mariadb_adapter.rb
+- lib/strong_migrations/adapters/mysql_adapter.rb
+- lib/strong_migrations/adapters/postgresql_adapter.rb
 - lib/strong_migrations/checker.rb
+- lib/strong_migrations/checks.rb
 - lib/strong_migrations/database_tasks.rb
+- lib/strong_migrations/error_messages.rb
 - lib/strong_migrations/migration.rb
+- lib/strong_migrations/migrator.rb
 - lib/strong_migrations/railtie.rb
 - lib/strong_migrations/safe_methods.rb
+- lib/strong_migrations/schema_dumper.rb
 - lib/strong_migrations/version.rb
 - lib/tasks/strong_migrations.rake
 homepage: https://github.com/ankane/strong_migrations
@@ -61,14 +68,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.4'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.4.6
 signing_key:
 specification_version: 4
 summary: Catch unsafe migrations in development

data/lib/strong_migrations/alphabetize_columns.rb

@@ -1,11 +0,0 @@
-module StrongMigrations
-  module AlphabetizeColumns
-    def columns(*args)
-      super.sort_by(&:name)
-    end
-
-    def extensions(*args)
-      super.sort
-    end
-  end
-end