strong_migrations 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe026b71dc38ab1cc40189ff8eb858baa45ec0778bd4dd640cff57349aa067ea
-  data.tar.gz: 28698d9bc1804389fc4e1fdb9e9a3ae9499cc490b15bda953f312fe434a6aa41
+  metadata.gz: '08eb5f509b5fb98501eb6f83840c414c331c989b7d92bd29825cbaa0e2312177'
+  data.tar.gz: 0fc4b64d44609ff2f6bbbf48d53730e35551654d3a1aaf629b7305ab8ac92caf
 SHA512:
-  metadata.gz: 3fe33582e8f6f4c0aced4f162704a9810e044e11e115ac1813892750474c118a33f0fb2ee19883d4dce98bfc6862786eaaf1c7862b4fd3398c2bb032010316fb
-  data.tar.gz: 0e5bcf7c1a42dcebe09a5f249fd2cb063549c1617d8a161ae915e882ab30e7f9a72b19b38407f5a526b59174cf04bcfa04c790888b7ce069c58c5cf7116faf00
+  metadata.gz: fc5cbfa0dbcdc47b8f5e42c18c64d77cabcc01deac0e92077d9d034bff6a47145354da066c70d2eb2906c60c895f5639de40ee9a1c00e015f80d54242f8bcb4c
+  data.tar.gz: 5dfcdd45c56da317a83509c6f79c3d81b8c35e3f6e8aaf0af32c8144e134b919da481b2f501a87dbb581f4c61db96bccc4103cf285210f7777f0258020e1c6f3

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 0.3.0
+
+- Added support for custom checks
+- Adding a column with a non-null default value is safe in Postgres 11+
+- Added checks for `add_belongs_to`, `remove_belongs_to`, `remove_columns`, and `remove_reference`
+- Customized messages
+
 ## 0.2.3
 
 - Added check for `change_column_null`

data/CONTRIBUTING.md

@@ -2,17 +2,15 @@
 
 First, thanks for wanting to contribute. You’re awesome! :heart:
 
-## Questions
+## Help
 
-Use [Stack Overflow](https://stackoverflow.com/) with the tag `strong-migrations`.
+We’re not able to provide support through GitHub Issues. If you’re looking for help with your code, try posting on [Stack Overflow](https://stackoverflow.com/).
 
-## Feature Requests
+All features should be documented. If you don’t see a feature in the docs, assume it doesn’t exist.
 
-Create an issue. Start the title with `[Idea]`.
+## Bugs
 
-## Issues
-
-Think you’ve discovered an issue?
+Think you’ve discovered a bug?
 
 1. Search existing issues to see if it’s been reported.
 2. Try the `master` branch to make sure it hasn’t been fixed.
@@ -26,6 +24,10 @@ If the above steps don’t help, create an issue. Include:
 - Detailed steps to reproduce
 - Complete backtraces for exceptions
 
+## New Features
+
+If you’d like to discuss a new feature, create an issue and start the title with `[Idea]`.
+
 ## Pull Requests
 
 Fork the project and create a pull request. A few tips:

data/README.md

@@ -16,26 +16,25 @@ gem 'strong_migrations'
 
 ## How It Works
 
-Strong Migrations detects potentially dangerous operations in migrations, prevents them from running by default, and provides instructions on safer ways to do what you want.
+Strong Migrations detects potentially dangerous operations in migrations, prevents them from running by default, and provides instructions on safer ways to do what you want. Here’s an example:
 
 ```
- __          __     _____ _______ _
- \ \        / /\   |_   _|__   __| |
-  \ \  /\  / /  \    | |    | |  | |
-   \ \/  \/ / /\ \   | |    | |  | |
-    \  /\  / ____ \ _| |_   | |  |_|
-     \/  \/_/    \_\_____|  |_|  (_)  #strong_migrations
+=== Dangerous operation detected #strong_migrations ===
 
 ActiveRecord caches attributes which causes problems
 when removing columns. Be sure to ignore the column:
 
 class User < ApplicationRecord
-  self.ignored_columns = %w(some_column)
+  self.ignored_columns = ["some_column"]
 end
 
-Once that's deployed, wrap this step in a safety_assured { ... } block.
+Deploy the code, then wrap this step in a safety_assured { ... } block.
 
-More info: https://github.com/ankane/strong_migrations#removing-a-column
+class RemoveColumn < ActiveRecord::Migration[5.2]
+  def change
+    safety_assured { remove_column :users, :some_column }
+  end
+end
 ```
 
 ## Dangerous Operations
@@ -48,6 +47,7 @@ The following operations can cause downtime or errors:
 - setting a `NOT NULL` constraint with a default value
 - renaming a column
 - renaming a table
+- creating a table with the `force` option
 - adding an index non-concurrently (Postgres only)
 - adding a `json` column to an existing table (Postgres only)
 
@@ -64,7 +64,7 @@ Adding a column with a non-null default causes the entire table to be rewritten.
 Instead, add the column without a default value, then change the default.
 
 ```ruby
-class AddSomeColumnToUsers < ActiveRecord::Migration[5.1]
+class AddSomeColumnToUsers < ActiveRecord::Migration[5.2]
   def up
     add_column :users, :some_column, :text
     change_column_default :users, :some_column, "default_value"
@@ -78,12 +78,14 @@ end
 
 Don’t backfill existing rows in this migration, as it can cause downtime. See the next section for how to do it safely.
 
+> With Postgres, this operation is safe as of Postgres 11
+
 ### Backfilling data
 
 To backfill data, use the Rails console or a separate migration with `disable_ddl_transaction!`. Avoid backfilling in a transaction, especially one that alters a table. See [this great article](https://wework.github.io/data/2015/11/05/add-columns-with-default-values-to-large-tables-in-rails-postgres/) on why.
 
 ```ruby
-class BackfillSomeColumn < ActiveRecord::Migration[5.1]
+class BackfillSomeColumn < ActiveRecord::Migration[5.2]
   disable_ddl_transaction!
 
   def change
@@ -91,8 +93,8 @@ class BackfillSomeColumn < ActiveRecord::Migration[5.1]
     User.in_batches.update_all some_column: "default_value"
 
     # Rails < 5
-    User.find_in_batches do |users|
-      User.where(id: users.map(&:id)).update_all some_column: "default_value"
+    User.find_in_batches do |records|
+      User.where(id: records.map(&:id)).update_all some_column: "default_value"
     end
   end
 end
@@ -107,7 +109,7 @@ ActiveRecord caches database columns at runtime, so if you drop a column, it can
   ```ruby
   # For Rails 5+
   class User < ApplicationRecord
-    self.ignored_columns = %w(some_column)
+    self.ignored_columns = ["some_column"]
   end
 
   # For Rails < 5
@@ -122,7 +124,7 @@ ActiveRecord caches database columns at runtime, so if you drop a column, it can
 3. Write a migration to remove the column (wrap in `safety_assured` block)
 
   ```ruby
-  class RemoveSomeColumnFromUsers < ActiveRecord::Migration[5.1]
+  class RemoveSomeColumnFromUsers < ActiveRecord::Migration[5.2]
     def change
       safety_assured { remove_column :users, :some_column }
     end
@@ -133,7 +135,7 @@ ActiveRecord caches database columns at runtime, so if you drop a column, it can
 
 ### Renaming or changing the type of a column
 
-If you really have to:
+A safer approach is to:
 
 1. Create a new column
 2. Write to both columns
@@ -146,7 +148,7 @@ One exception is changing a `varchar` column to `text`, which is safe in Postgre
 
 ### Renaming a table
 
-If you really have to:
+A safer approach is to:
 
 1. Create a new table
 2. Write to both tables
@@ -160,18 +162,31 @@ If you really have to:
 Add indexes concurrently.
 
 ```ruby
-class AddSomeIndexToUsers < ActiveRecord::Migration[5.1]
+class AddSomeIndexToUsers < ActiveRecord::Migration[5.2]
   disable_ddl_transaction!
 
   def change
-    add_index :users, :some_index, algorithm: :concurrently
+    add_index :users, :some_column, algorithm: :concurrently
   end
 end
 ```
 
-If you forget `disable_ddl_transaction!`, the migration will fail. Also, note that indexes on new tables (those created in the same migration) don’t require this.
+If you forget `disable_ddl_transaction!`, the migration will fail. Also, note that indexes on new tables (those created in the same migration) don’t require this. Check out [gindex](https://github.com/ankane/gindex) to quickly generate index migrations without memorizing the syntax.
+
+Rails 5+ adds an index to references by default. To make sure this happens concurrently, use:
+
+```ruby
+class AddSomeReferenceToUsers < ActiveRecord::Migration[5.2]
+  disable_ddl_transaction!
+
+  def change
+    add_reference :users, :reference, index: false
+    add_index :users, :reference_id, algorithm: :concurrently
+  end
+end
+```
 
-Check out [this gem](https://github.com/ankane/gindex) to quickly generate index migrations without memorizing the syntax.
+For polymorphic references, add a compound index on type and id.
 
 ### Adding a json column (Postgres)
 
@@ -190,7 +205,7 @@ end
 Then add the column:
 
 ```ruby
-class AddJsonColumnToUsers < ActiveRecord::Migration[5.1]
+class AddJsonColumnToUsers < ActiveRecord::Migration[5.2]
   def change
     safety_assured { add_column :users, :some_column, :json }
   end
@@ -202,13 +217,27 @@ end
 To mark a step in the migration as safe, despite using method that might otherwise be dangerous, wrap it in a `safety_assured` block.
 
 ```ruby
-class MySafeMigration < ActiveRecord::Migration[5.1]
+class MySafeMigration < ActiveRecord::Migration[5.2]
   def change
     safety_assured { remove_column :users, :some_column }
   end
 end
 ```
 
+## Custom Checks
+
+Add your own custom checks with:
+
+```ruby
+StrongMigrations.add_check do |method, args|
+  if method == :add_index && args[0].to_s == "users"
+    stop! "No more indexes on the users table"
+  end
+end
+```
+
+Use the `stop!` method to stop migrations.
+
 ## Existing Migrations
 
 To mark migrations as safe that were created before installing this gem, create an initializer with:
@@ -274,7 +303,7 @@ There’s also [a gem](https://github.com/gocardless/activerecord-safer_migratio
 
 ## Bigint Primary Keys (Postgres & MySQL)
 
-Rails 5.1+ uses `bigint` for primary keys to keep you from running out of ids. To get this in earlier versions of Rails, check out [this gem](https://github.com/Shopify/rails-bigint-primarykey).
+Rails 5.1+ uses `bigint` for primary keys to keep you from running out of ids. To get this in earlier versions of Rails, check out [rails-bigint-primarykey](https://github.com/Shopify/rails-bigint-primarykey).
 
 ## Additional Reading
 

data/lib/strong_migrations.rb

@@ -8,45 +8,55 @@ require "strong_migrations/version"
 
 module StrongMigrations
   class << self
-    attr_accessor :auto_analyze, :start_after, :error_messages
+    attr_accessor :auto_analyze, :start_after, :checks, :error_messages
   end
   self.auto_analyze = false
   self.start_after = 0
+  self.checks = []
   self.error_messages = {
     add_column_default:
-"Adding a column with a non-null default causes
-the entire table to be rewritten.
-
-Instead, add the column without a default value,
-then change the default.
+"Adding a column with a non-null default causes the entire table to be rewritten.
+Instead, add the column without a default value, then change the default.
 
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
   def up
-    add_column :users, :some_column, :text
-    change_column_default :users, :some_column, \"default_value\"
+    add_column %{table}, %{column}, %{type}%{options}
+    change_column_default %{table}, %{column}, %{default}
   end
 
   def down
-    remove_column :users, :some_column
+    remove_column %{table}, %{column}
   end
+end
 
-More info: https://github.com/ankane/strong_migrations#adding-a-column-with-a-default-value",
+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 change
+    %{code}
+  end
+end",
 
     add_column_json:
-"Use jsonb instead.",
+"There's no equality operator for the json column type, which
+causes issues for SELECT DISTINCT queries. Use jsonb instead.",
 
     add_column_json_legacy:
-"There's no equality operator for the json column type.
+"There's no equality operator for the json column type, which.
+causes issues for SELECT DISTINCT queries.
 Replace all calls to uniq with a custom scope.
 
-  scope :uniq_on_id, -> { select(\"DISTINCT ON (your_table.id) your_table.*\") }
+class %{model} < %{base_model}
+  scope :uniq_on_id, -> { select('DISTINCT ON (%{table}.id) %{table}.*') }
+end
 
 Once it's deployed, wrap this step in a safety_assured { ... } block.",
 
     change_column:
-"Changing the type of an existing column requires
-the entire table and indexes to be rewritten.
-
-If you really have to:
+"Changing the type of an existing column requires the entire
+table and indexes to be rewritten. A safer approach is to:
 
 1. Create a new column
 2. Write to both columns
@@ -56,18 +66,22 @@ If you really have to:
 6. Drop the old column",
 
     remove_column: "ActiveRecord caches attributes which causes problems
-when removing columns. Be sure to ignore the column:
+when removing columns. Be sure to ignore the column%{column_suffix}:
 
-class User < ApplicationRecord
-  self.ignored_columns = %w(some_column)
+class %{model} < %{base_model}
+  %{code}
 end
 
-Once that's deployed, wrap this step in a safety_assured { ... } block.
+Deploy the code, then wrap this step in a safety_assured { ... } block.
 
-More info: https://github.com/ankane/strong_migrations#removing-a-column",
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    safety_assured { %{command} }
+  end
+end",
 
     rename_column:
-"If you really have to:
+"Renaming a column is dangerous. A safer approach is to:
 
 1. Create a new column
 2. Write to both columns
@@ -77,7 +91,7 @@ More info: https://github.com/ankane/strong_migrations#removing-a-column",
 6. Drop the old column",
 
     rename_table:
-"If you really have to:
+"Renaming a table is dangerous. A safer approach is to:
 
 1. Create a new table
 2. Write to both tables
@@ -89,21 +103,25 @@ More info: https://github.com/ankane/strong_migrations#removing-a-column",
     add_reference:
 "Adding a non-concurrent index locks the table. Instead, use:
 
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
   disable_ddl_transaction!
 
   def change
-    add_reference :users, :reference, index: false
-    add_index :users, :reference_id, algorithm: :concurrently
-  end",
+    %{command} %{table}, %{reference}, index: false%{options}
+    add_index %{table}, %{column}, algorithm: :concurrently
+  end
+end",
 
     add_index:
 "Adding a non-concurrent index locks the table. Instead, use:
 
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
   disable_ddl_transaction!
 
   def change
-    add_index :users, :some_column, algorithm: :concurrently
-  end",
+    add_index %{table}, %{column}, algorithm: :concurrently%{options}
+  end
+end",
 
     add_index_columns:
 "Adding an index with more than three columns only helps on extremely large tables.
@@ -111,46 +129,41 @@ More info: https://github.com/ankane/strong_migrations#removing-a-column",
 If you're sure this is what you want, wrap it in a safety_assured { ... } block.",
 
     change_table:
-"The strong_migrations gem does not support inspecting what happens inside a
+"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 option.",
+Otherwise, remove the force option.",
 
     execute:
-"The strong_migrations gem does not support inspecting what happens inside an
+"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:
-"The last argument replaces existing NULLs with another value.
-This runs a single UPDATE query, which can cause downtime.
-Backfill NULLs manually in batches instead.
+"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!.
 
-More info: https://github.com/ankane/strong_migrations#backfilling-data"
-  }
-end
-
-ActiveSupport.on_load(:active_record) do
-  ActiveRecord::Migration.prepend(StrongMigrations::Migration)
+class Backfill%{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  disable_ddl_transaction!
 
-  if ActiveRecord::VERSION::MAJOR < 5
-    StrongMigrations.error_messages[:remove_column] = "ActiveRecord caches attributes which causes problems
-when removing columns. Be sure to ignore the column:
+  def change
+    %{code}
+  end
+end"
+  }
 
-class User < ActiveRecord::Base
-  def self.columns
-    super.reject { |c| c.name == \"some_column\" }
+  def self.add_check(&block)
+    checks << block
   end
 end
 
-Once that's deployed, wrap this step in a safety_assured { ... } block.
-
-More info: https://github.com/ankane/strong_migrations#removing-a-column"
-  end
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord::Migration.prepend(StrongMigrations::Migration)
 
   if defined?(ActiveRecord::Tasks::DatabaseTasks)
     ActiveRecord::Tasks::DatabaseTasks.singleton_class.prepend(StrongMigrations::DatabaseTasks)

data/lib/strong_migrations/migration.rb

@@ -14,14 +14,50 @@ module StrongMigrations
     end
 
     def method_missing(method, *args, &block)
+      table = args[0].to_s
+
       unless @safe || ENV["SAFETY_ASSURED"] || is_a?(ActiveRecord::Schema) || @direction == :down || version_safe?
+        ar5 = ActiveRecord::VERSION::MAJOR >= 5
+        model = table.classify
+
         case method
-        when :remove_column
-          raise_error :remove_column
-        when :remove_timestamps
-          raise_error :remove_column
+        when :remove_column, :remove_columns, :remove_timestamps, :remove_reference, :remove_belongs_to
+          columns =
+            case method
+            when :remove_timestamps
+              ["created_at", "updated_at"]
+            when :remove_column
+              [args[1].to_s]
+            when :remove_columns
+              args[1..-1].map(&:to_s)
+            else
+              options = args[2] || {}
+              reference = args[1]
+              cols = []
+              cols << "#{reference}_type" if options[:polymorphic]
+              cols << "#{reference}_id"
+              cols
+            end
+
+          code = ar5 ? "self.ignored_columns = #{columns.inspect}" : "def self.columns\n    super.reject { |c| #{columns.inspect}.include?(c.name) }\n  end"
+
+          command = String.new("#{method} #{sym_str(table)}")
+          case method
+          when :remove_column, :remove_reference, :remove_belongs_to
+            command << ", #{sym_str(args[1])}#{options_str(args[2] || {})}"
+          when :remove_columns
+            columns.each do |c|
+              command << ", #{sym_str(c)}"
+            end
+          end
+
+          raise_error :remove_column,
+            model: model,
+            code: code,
+            command: command,
+            column_suffix: columns.size > 1 ? "s" : ""
         when :change_table
-          raise_error :change_table
+          raise_error :change_table, header: "Possibly dangerous operation"
         when :rename_table
           raise_error :rename_table
         when :rename_column
@@ -30,55 +66,85 @@ module StrongMigrations
           columns = args[1]
           options = args[2] || {}
           if columns.is_a?(Array) && columns.size > 3 && !options[:unique]
-            raise_error :add_index_columns
+            raise_error :add_index_columns, header: "Best practice"
           end
-          if postgresql? && options[:algorithm] != :concurrently && !@new_tables.to_a.include?(args[0].to_s)
-            raise_error :add_index
+          if postgresql? && options[:algorithm] != :concurrently && !@new_tables.to_a.include?(table)
+            raise_error :add_index,
+              table: sym_str(table),
+              column: column_str(columns),
+              options: options_str(options.except(:algorithm))
           end
         when :add_column
+          column = args[1]
           type = args[2]
           options = args[3] || {}
-          raise_error :add_column_default unless options[:default].nil?
+          default = options[:default]
+
+          if !default.nil? && !(postgresql? && postgresql_version >= 110000)
+            raise_error :add_column_default,
+              table: sym_str(table),
+              column: sym_str(column),
+              type: sym_str(type),
+              options: options_str(options.except(:default)),
+              default: default.inspect,
+              code: backfill_code(model, column, default)
+          end
+
           if type.to_s == "json" && postgresql?
             if postgresql_version >= 90400
               raise_error :add_column_json
             else
-              raise_error :add_column_json_legacy
+              raise_error :add_column_json_legacy,
+                model: model,
+                table: connection.quote_table_name(table)
             end
           end
         when :change_column
           safe = false
           # assume Postgres 9.1+ since previous versions are EOL
           if postgresql? && args[2].to_s == "text"
-            column = connection.columns(args[0]).find { |c| c.name.to_s == args[1].to_s }
+            column = connection.columns(table).find { |c| c.name.to_s == args[1].to_s }
             safe = column && column.type == :string
           end
           raise_error :change_column unless safe
         when :create_table
           options = args[1] || {}
           raise_error :create_table if options[:force]
-          (@new_tables ||= []) << args[0].to_s
-        when :add_reference
+          (@new_tables ||= []) << table
+        when :add_reference, :add_belongs_to
           options = args[2] || {}
-          index_value = options.fetch(:index, ActiveRecord::VERSION::MAJOR >= 5 ? true : false)
+          index_value = options.fetch(:index, ar5)
           if postgresql? && index_value
-            raise_error :add_reference
+            reference = args[1]
+            columns = []
+            columns << "#{reference}_type" if options[:polymorphic]
+            columns << "#{reference}_id"
+            raise_error :add_reference,
+              command: method,
+              table: sym_str(table),
+              reference: sym_str(reference),
+              column: column_str(columns),
+              options: options_str(options.except(:index))
           end
         when :execute
-          raise_error :execute
+          raise_error :execute, header: "Possibly dangerous operation"
         when :change_column_null
-          null = args[2]
-          default = args[3]
+          _, column, null, default = args
           if !null && !default.nil?
-            raise_error :change_column_null
+            raise_error :change_column_null,
+              code: backfill_code(model, column, default)
           end
         end
+
+        StrongMigrations.checks.each do |check|
+          instance_exec(method, args, &check)
+        end
       end
 
       result = super
 
       if StrongMigrations.auto_analyze && @direction == :up && postgresql? && method == :add_index
-        connection.execute "ANALYZE VERBOSE #{connection.quote_table_name(args[0])}"
+        connection.execute "ANALYZE VERBOSE #{connection.quote_table_name(table)}"
       end
 
       result
@@ -98,18 +164,46 @@ module StrongMigrations
       version && version <= StrongMigrations.start_after
     end
 
-    def raise_error(message_key)
-      wait_message = '
- __          __     _____ _______ _
- \ \        / /\   |_   _|__   __| |
-  \ \  /\  / /  \    | |    | |  | |
-   \ \/  \/ / /\ \   | |    | |  | |
-    \  /\  / ____ \ _| |_   | |  |_|
-     \/  \/_/    \_\_____|  |_|  (_)  #strong_migrations
-
-'
+    def raise_error(message_key, header: nil, **vars)
       message = StrongMigrations.error_messages[message_key] || "Missing message"
-      raise StrongMigrations::UnsafeMigration, "#{wait_message}#{message}\n"
+
+      ar5 = ActiveRecord::VERSION::MAJOR >= 5
+      vars[:migration_name] = self.class.name
+      vars[:migration_suffix] = ar5 ? "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]" : ""
+      vars[:base_model] = ar5 ? "ApplicationRecord" : "ActiveRecord::Base"
+
+      # escape % not followed by {
+      stop!(message.gsub(/%(?!{)/, "%%") % vars, header: header || "Dangerous operation detected")
+    end
+
+    def sym_str(v)
+      v.to_sym.inspect
+    end
+
+    def column_str(columns)
+      columns = Array(columns).map(&:to_sym)
+      columns = columns.first if columns.size == 1
+      columns.inspect
+    end
+
+    def options_str(options)
+      str = String.new("")
+      options.each do |k, v|
+        str << ", #{k}: #{v.inspect}"
+      end
+      str
+    end
+
+    def backfill_code(model, column, default)
+      if ActiveRecord::VERSION::MAJOR >= 5
+        "#{model}.in_batches.update_all #{column}: #{default.inspect}"
+      else
+        "#{model}.find_in_batches do |records|\n      #{model}.where(id: records.map(&:id)).update_all #{column}: #{default.inspect}\n    end"
+      end
+    end
+
+    def stop!(message, header: "Custom check")
+      raise StrongMigrations::UnsafeMigration, "\n=== #{header} #strong_migrations ===\n\n#{message}\n"
     end
   end
 end

data/lib/strong_migrations/version.rb

@@ -1,3 +1,3 @@
 module StrongMigrations
-  VERSION = "0.2.3"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: strong_migrations
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Andrew Kane
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-23 00:00:00.000000000 Z
+date: 2018-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord