strong_migrations 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4a27bb71eb7436386540b0f86fb17d3bf82f2e100eff8e836acb842d22ffab6
-  data.tar.gz: 81b1f63c48a92599e7d421adbbd22411e26a467c052520dd1ee0982d2e150f6a
+  metadata.gz: bce49483e36caa343a3496771d052e4cc7d4db1e72c0ca23d80be1339bcb4dae
+  data.tar.gz: e15a13f2c41a610c8a6825a209581b2b66d28584ecc41fcc6c46f2f0d69ff293
 SHA512:
-  metadata.gz: 27f6188cf4fdb6391a3f5e7926e292029c9ae47260010349ee93fa908d7abd74a40b2ac6d9bc7970f1e9c0b35c85c60b0c8719b125ee32dac3903190823483cf
-  data.tar.gz: 5682113d7f4a56a11cf9c9dfe3bcefb373c101737bf8073970f1a56eb87efeb79e0a648c6908d7f8f77adf3ed68690a7b4523a43abef149ef09b8cff945ea8e2
+  metadata.gz: 68f4b5e294502c361c23cf17bf921310a285b27b4f5112c115ac26683af0f3841bf2815229bf793feab85ae71cac93e3e4e76f6928aa47cfe913669d2c3219ce
+  data.tar.gz: 2dc364a36b8aa88408554a5671d8380cc6d27ab17321542181cebac3568cc5bcc4ea61d14508e6c59a9641e41e074ee0120d7f4098648c1f6508be1d479289c5

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.4.1
+
+- Added `target_postgresql_version`
+- Added `unscoped` to backfill instructions
+
 ## 0.4.0
 
 - Added check for `add_foreign_key`

data/README.md

@@ -1,6 +1,6 @@
 # Strong Migrations
 
-Catch unsafe migrations at dev time
+Catch unsafe migrations in development
 
 :tangerine: Battle-tested at [Instacart](https://www.instacart.com/opensource)
 
@@ -25,7 +25,7 @@ Strong Migrations detects potentially dangerous operations in migrations, preven
 The following operations can cause downtime or errors:
 
 - [[+]](#removing-a-column) removing a column
-- [[+]](#adding-a-column-with-a-default-value) adding a column with a non-null default value to an existing table
+- [[+]](#adding-a-column-with-a-default-value) adding a column with a default value
 - [[+]](#backfilling-data) backfilling data
 - [[+]](#adding-an-index) adding an index non-concurrently
 - [[+]](#adding-a-reference) adding a reference
@@ -39,7 +39,7 @@ The following operations can cause downtime or errors:
 
 Also checks for best practices:
 
-- [[+]](#) keeping non-unique indexes to three columns or less
+- [[+]](#keeping-non-unique-indexes-to-three-columns-or-less) keeping non-unique indexes to three columns or less
 
 ## The Zero Downtime Way
 
@@ -84,7 +84,7 @@ end
 
 #### Bad
 
-Adding a column with a non-null default causes the entire table to be rewritten.
+Adding a column with a default value to an existing table causes the entire table to be rewritten.
 
 ```ruby
 class AddSomeColumnToUsers < ActiveRecord::Migration[5.2]
@@ -141,7 +141,7 @@ class BackfillSomeColumn < ActiveRecord::Migration[5.2]
   disable_ddl_transaction!
 
   def change
-    User.in_batches do |relation|
+    User.unscoped.in_batches do |relation|
       relation.update_all some_column: "default_value"
       sleep(0.1) # throttle
     end
@@ -153,7 +153,7 @@ end
 
 #### Bad
 
-In Postgres, adding a non-concurrent indexes lock the table.
+In Postgres, adding a non-concurrent index locks the table.
 
 ```ruby
 class AddSomeIndexToUsers < ActiveRecord::Migration[5.2]
@@ -330,7 +330,7 @@ A safer approach is to:
 5. Stop writing to the old table
 6. Drop the old table
 
-### Creating a table with the `force` option
+### Creating a table with the force option
 
 #### Bad
 
@@ -360,7 +360,7 @@ class CreateUsers < ActiveRecord::Migration[5.2]
 end
 ```
 
-### Using `change_column_null` with a default value
+### Using change_column_null with a default value
 
 #### Bad
 
@@ -418,7 +418,7 @@ end
 
 #### Bad
 
-Adding an index with more than three columns only helps on extremely large tables.
+Adding a non-unique index with more than three columns rarely improves performance.
 
 ```ruby
 class AddSomeIndexToUsers < ActiveRecord::Migration[5.2]
@@ -430,10 +430,12 @@ end
 
 #### Good
 
+Instead, start an index with columns that narrow down the results the most.
+
 ```ruby
 class AddSomeIndexToUsers < ActiveRecord::Migration[5.2]
   def change
-    add_index :users, [:a, :b, :c]
+    add_index :users, [:b, :d]
   end
 end
 ```
@@ -482,10 +484,10 @@ Use the version from your latest migration.
 
 ## Dangerous Tasks
 
-For safety, dangerous rake tasks are disabled in production - `db:drop`, `db:reset`, `db:schema:load`, and `db:structure:load`. To get around this, use:
+For safety, dangerous database tasks are disabled in production - `db:drop`, `db:reset`, `db:schema:load`, and `db:structure:load`. To get around this, use:
 
 ```sh
-SAFETY_ASSURED=1 rake db:drop
+SAFETY_ASSURED=1 rails db:drop
 ```
 
 ## Faster Migrations
@@ -515,7 +517,9 @@ StrongMigrations.error_messages[:add_column_default] = "Your custom instructions
 
 Check the [source code](https://github.com/ankane/strong_migrations/blob/master/lib/strong_migrations.rb) for the list of keys.
 
-## Analyze Tables (Postgres)
+## Postgres-Specific Features
+
+### Analyze Tables
 
 Analyze tables automatically (to update planner statistics) after an index is added. Create an initializer with:
 
@@ -523,7 +527,7 @@ Analyze tables automatically (to update planner statistics) after an index is ad
 StrongMigrations.auto_analyze = true
 ```
 
-## Lock Timeout (Postgres)
+### Lock Timeout
 
 It’s a good idea to set a lock timeout for the database user that runs migrations. This way, if migrations can’t acquire a lock in a timely manner, other statements won’t be stuck behind it. Here’s a great explanation of [how lock queues work](https://www.citusdata.com/blog/2018/02/15/when-postgresql-blocks/).
 
@@ -533,14 +537,20 @@ ALTER ROLE myuser SET lock_timeout = '10s';
 
 There’s also [a gem](https://github.com/gocardless/activerecord-safer_migrations) you can use for this.
 
-## Bigint Primary Keys (Postgres & MySQL)
+### Target Version
+
+If your development database version is different from production, you can specify the production version so the right checks are run in development.
+
+```ruby
+StrongMigrations.target_postgresql_version = 10 # or 9.6, etc
+```
 
-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).
+For safety, this option only affects development and test environments. In other environments, the actual server version is always used.
 
 ## Additional Reading
 
 - [Rails Migrations with No Downtime](https://pedro.herokuapp.com/past/2011/7/13/rails_migrations_with_no_downtime/)
-- [Safe Operations For High Volume PostgreSQL](https://www.braintreepayments.com/blog/safe-operations-for-high-volume-postgresql/)
+- [PostgreSQL at Scale: Database Schema Changes Without Downtime](https://medium.com/braintree-product-technology/postgresql-at-scale-database-schema-changes-without-downtime-20d3749ed680)
 
 ## Credits
 

data/lib/strong_migrations.rb

@@ -1,5 +1,6 @@
 require "active_support"
 
+require "strong_migrations/checker"
 require "strong_migrations/database_tasks"
 require "strong_migrations/migration"
 require "strong_migrations/railtie" if defined?(Rails)
@@ -8,7 +9,7 @@ require "strong_migrations/version"
 
 module StrongMigrations
   class << self
-    attr_accessor :auto_analyze, :start_after, :checks, :error_messages
+    attr_accessor :auto_analyze, :start_after, :checks, :error_messages, :target_postgresql_version
   end
   self.auto_analyze = false
   self.start_after = 0
@@ -113,9 +114,8 @@ class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
 end",
 
     add_index_columns:
-"Adding an index with more than three columns only helps on extremely large tables.
-
-If you're sure this is what you want, wrap it in a safety_assured { ... } block.",
+"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

data/lib/strong_migrations/checker.rb

@@ -0,0 +1,253 @@
+module StrongMigrations
+  class Checker
+    attr_accessor :direction
+
+    def initialize(migration)
+      @migration = migration
+      @new_tables = []
+      @safe = false
+    end
+
+    def safety_assured
+      previous_value = @safe
+      begin
+        @safe = true
+        yield
+      ensure
+        @safe = previous_value
+      end
+    end
+
+    def perform(method, *args)
+      unless safe?
+        case method
+        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 = "self.ignored_columns = #{columns.inspect}"
+
+          raise_error :remove_column,
+            model: args[0].to_s.classify,
+            code: code,
+            command: command_str(method, args),
+            column_suffix: columns.size > 1 ? "s" : ""
+        when :change_table
+          raise_error :change_table, header: "Possibly dangerous operation"
+        when :rename_table
+          raise_error :rename_table
+        when :rename_column
+          raise_error :rename_column
+        when :add_index
+          table, columns, options = args
+          options ||= {}
+
+          if columns.is_a?(Array) && columns.size > 3 && !options[:unique]
+            raise_error :add_index_columns, header: "Best practice"
+          end
+          if postgresql? && options[:algorithm] != :concurrently && !@new_tables.include?(table.to_s)
+            raise_error :add_index, command: command_str("add_index", [table, columns, options.merge(algorithm: :concurrently)])
+          end
+        when :add_column
+          table, column, type, options = args
+          options ||= {}
+          default = options[:default]
+
+          if !default.nil? && !(postgresql? && postgresql_version >= 110000)
+
+            if options[:null] == false
+              options = options.except(:null)
+              append = "
+
+Then add the NOT NULL constraint.
+
+class %{migration_name}NotNull < ActiveRecord::Migration%{migration_suffix}
+  def change
+    #{command_str("change_column_null", [table, column, false])}
+  end
+end"
+            end
+
+            raise_error :add_column_default,
+              add_command: command_str("add_column", [table, column, type, options.except(:default)]),
+              change_command: command_str("change_column_default", [table, column, default]),
+              remove_command: command_str("remove_column", [table, column]),
+              code: backfill_code(table, column, default),
+              append: append
+          end
+
+          if type.to_s == "json" && postgresql?
+            raise_error :add_column_json
+          end
+        when :change_column
+          table, column, type = args
+
+          safe = false
+          # assume Postgres 9.1+ since previous versions are EOL
+          if postgresql? && type.to_s == "text"
+            found_column = connection.columns(table).find { |c| c.name.to_s == column.to_s }
+            safe = found_column && found_column.type == :string
+          end
+          raise_error :change_column unless safe
+        when :create_table
+          table, options = args
+          options ||= {}
+
+          raise_error :create_table if options[:force]
+
+          # keep track of new tables of add_index check
+          @new_tables << table.to_s
+        when :add_reference, :add_belongs_to
+          table, reference, options = args
+          options ||= {}
+
+          index_value = options.fetch(:index, true)
+          if postgresql? && index_value
+            columns = options[:polymorphic] ? [:"#{reference}_type", :"#{reference}_id"] : :"#{reference}_id"
+
+            raise_error :add_reference,
+              reference_command: command_str(method, [table, reference, options.merge(index: false)]),
+              index_command: command_str("add_index", [table, columns, {algorithm: :concurrently}])
+          end
+        when :execute
+          raise_error :execute, header: "Possibly dangerous operation"
+        when :change_column_null
+          table, column, null, default = args
+          if !null && !default.nil?
+            raise_error :change_column_null,
+              code: backfill_code(table, column, default)
+          end
+        when :add_foreign_key
+          from_table, to_table, options = args
+          options ||= {}
+          validate = options.fetch(:validate, true)
+
+          if postgresql?
+            if ActiveRecord::VERSION::STRING >= "5.2"
+              if validate
+                raise_error :add_foreign_key,
+                  add_foreign_key_code: command_str("add_foreign_key", [from_table, to_table, options.merge(validate: false)]),
+                  validate_foreign_key_code: command_str("validate_foreign_key", [from_table, to_table])
+              end
+            else
+              # always validated before 5.2
+
+              # fk name logic from rails
+              primary_key = options[:primary_key] || "id"
+              column = options[:column] || "#{to_table.to_s.singularize}_id"
+              hashed_identifier = Digest::SHA256.hexdigest("#{from_table}_#{column}_fk").first(10)
+              fk_name = options[:name] || "fk_rails_#{hashed_identifier}"
+
+              raise_error :add_foreign_key,
+                add_foreign_key_code: foreign_key_str("ALTER TABLE %s ADD CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s (%s) NOT VALID", [from_table, fk_name, column, to_table, primary_key]),
+                validate_foreign_key_code: foreign_key_str("ALTER TABLE %s VALIDATE CONSTRAINT %s", [from_table, fk_name])
+            end
+          end
+        end
+
+        StrongMigrations.checks.each do |check|
+          @migration.instance_exec(method, args, &check)
+        end
+      end
+
+      result = yield
+
+      if StrongMigrations.auto_analyze && direction == :up && postgresql? && method == :add_index
+        connection.execute "ANALYZE VERBOSE #{connection.quote_table_name(args[0].to_s)}"
+      end
+
+      result
+    end
+
+    private
+
+    def connection
+      @migration.connection
+    end
+
+    def version
+      @migration.version
+    end
+
+    def safe?
+      @safe || ENV["SAFETY_ASSURED"] || @migration.is_a?(ActiveRecord::Schema) || direction == :down || version_safe?
+    end
+
+    def version_safe?
+      version && version <= StrongMigrations.start_after
+    end
+
+    def postgresql?
+      %w(PostgreSQL PostGIS).include?(connection.adapter_name)
+    end
+
+    def postgresql_version
+      @postgresql_version ||= begin
+        target_version = StrongMigrations.target_postgresql_version
+        if target_version && defined?(Rails) && (Rails.env.development? || Rails.env.test?)
+          # we only need major version right now
+          target_version.to_i * 10000
+        else
+          connection.execute("SHOW server_version_num").first["server_version_num"].to_i
+        end
+      end
+    end
+
+    def raise_error(message_key, header: nil, **vars)
+      message = StrongMigrations.error_messages[message_key] || "Missing message"
+
+      vars[:migration_name] = self.class.name
+      vars[:migration_suffix] = "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      vars[:base_model] = "ApplicationRecord"
+
+      # interpolate variables in appended code
+      if vars[:append]
+        vars[:append] = vars[:append].gsub(/%(?!{)/, "%%") % vars
+      end
+
+      # escape % not followed by {
+      @migration.stop!(message.gsub(/%(?!{)/, "%%") % vars, header: header || "Dangerous operation detected")
+    end
+
+    def foreign_key_str(statement, identifiers)
+      # not all identifiers are tables, but this method of quoting should be fine
+      code = statement % identifiers.map { |v| connection.quote_table_name(v) }
+      "safety_assured do\n      execute '#{code}' \n    end"
+    end
+
+    def command_str(command, args)
+      str_args = args[0..-2].map { |a| a.inspect }
+
+      # prettier last arg
+      last_arg = args[-1]
+      if last_arg.is_a?(Hash)
+        if last_arg.any?
+          str_args << last_arg.map { |k, v| "#{k}: #{v.inspect}" }.join(", ")
+        end
+      else
+        str_args << last_arg.inspect
+      end
+
+      "#{command} #{str_args.join(", ")}"
+    end
+
+    def backfill_code(table, column, default)
+      model = table.to_s.classify
+      "#{model}.unscoped.in_batches do |relation| \n      relation.update_all #{column}: #{default.inspect}\n      sleep(0.1)\n    end"
+    end
+  end
+end

data/lib/strong_migrations/migration.rb

@@ -1,228 +1,25 @@
 module StrongMigrations
   module Migration
-    def safety_assured
-      previous_value = @safe
-      @safe = true
-      yield
-    ensure
-      @safe = previous_value
+    def initialize(*args)
+      super
+      @checker = StrongMigrations::Checker.new(self)
     end
 
     def migrate(direction)
-      @direction = direction
+      @checker.direction = direction
       super
     end
 
-    def method_missing(method, *args, &block)
-      unless @safe || ENV["SAFETY_ASSURED"] || is_a?(ActiveRecord::Schema) || @direction == :down || version_safe?
-        case method
-        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 = "self.ignored_columns = #{columns.inspect}"
-
-          raise_error :remove_column,
-            model: args[0].to_s.classify,
-            code: code,
-            command: command_str(method, args),
-            column_suffix: columns.size > 1 ? "s" : ""
-        when :change_table
-          raise_error :change_table, header: "Possibly dangerous operation"
-        when :rename_table
-          raise_error :rename_table
-        when :rename_column
-          raise_error :rename_column
-        when :add_index
-          table, columns, options = args
-          options ||= {}
-
-          if columns.is_a?(Array) && columns.size > 3 && !options[:unique]
-            raise_error :add_index_columns, header: "Best practice"
-          end
-          if postgresql? && options[:algorithm] != :concurrently && !@new_tables.to_a.include?(table.to_s)
-            raise_error :add_index, command: command_str("add_index", [table, columns, options.merge(algorithm: :concurrently)])
-          end
-        when :add_column
-          table, column, type, options = args
-          options ||= {}
-          default = options[:default]
-
-          if !default.nil? && !(postgresql? && postgresql_version >= 110000)
-
-            if options[:null] == false
-              options = options.except(:null)
-              append = "
-
-Then add the NOT NULL constraint.
-
-class %{migration_name}NotNull < ActiveRecord::Migration%{migration_suffix}
-  def change
-    #{command_str("change_column_null", [table, column, false])}
-  end
-end"
-            end
-
-            raise_error :add_column_default,
-              add_command: command_str("add_column", [table, column, type, options.except(:default)]),
-              change_command: command_str("change_column_default", [table, column, default]),
-              remove_command: command_str("remove_column", [table, column]),
-              code: backfill_code(table, column, default),
-              append: append
-          end
-
-          if type.to_s == "json" && postgresql?
-            raise_error :add_column_json
-          end
-        when :change_column
-          table, column, type = args
-
-          safe = false
-          # assume Postgres 9.1+ since previous versions are EOL
-          if postgresql? && type.to_s == "text"
-            found_column = connection.columns(table).find { |c| c.name.to_s == column.to_s }
-            safe = found_column && found_column.type == :string
-          end
-          raise_error :change_column unless safe
-        when :create_table
-          table, options = args
-          options ||= {}
-
-          raise_error :create_table if options[:force]
-
-          # keep track of new tables of add_index check
-          (@new_tables ||= []) << table.to_s
-        when :add_reference, :add_belongs_to
-          table, reference, options = args
-          options ||= {}
-
-          index_value = options.fetch(:index, true)
-          if postgresql? && index_value
-            columns = options[:polymorphic] ? [:"#{reference}_type", :"#{reference}_id"] : :"#{reference}_id"
-
-            raise_error :add_reference,
-              reference_command: command_str(method, [table, reference, options.merge(index: false)]),
-              index_command: command_str("add_index", [table, columns, {algorithm: :concurrently}])
-          end
-        when :execute
-          raise_error :execute, header: "Possibly dangerous operation"
-        when :change_column_null
-          table, column, null, default = args
-          if !null && !default.nil?
-            raise_error :change_column_null,
-              code: backfill_code(table, column, default)
-          end
-        when :add_foreign_key
-          from_table, to_table, options = args
-          options ||= {}
-          validate = options.fetch(:validate, true)
-
-          if postgresql?
-            if ActiveRecord::VERSION::STRING >= "5.2"
-              if validate
-                raise_error :add_foreign_key,
-                  add_foreign_key_code: command_str("add_foreign_key", [from_table, to_table, options.merge(validate: false)]),
-                  validate_foreign_key_code: command_str("validate_foreign_key", [from_table, to_table])
-              end
-            else
-              # always validated before 5.2
-
-              # fk name logic from rails
-              primary_key = options[:primary_key] || "id"
-              column = options[:column] || "#{to_table.to_s.singularize}_id"
-              hashed_identifier = Digest::SHA256.hexdigest("#{from_table}_#{column}_fk").first(10)
-              fk_name = options[:name] || "fk_rails_#{hashed_identifier}"
-
-              raise_error :add_foreign_key,
-                add_foreign_key_code: foreign_key_str("ALTER TABLE %s ADD CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s (%s) NOT VALID", [from_table, fk_name, column, to_table, primary_key]),
-                validate_foreign_key_code: foreign_key_str("ALTER TABLE %s VALIDATE CONSTRAINT %s", [from_table, fk_name])
-            end
-          end
-        end
-
-        StrongMigrations.checks.each do |check|
-          instance_exec(method, args, &check)
-        end
+    def method_missing(method, *args)
+      @checker.perform(method, *args) do
+        super
       end
-
-      result = super
-
-      if StrongMigrations.auto_analyze && @direction == :up && postgresql? && method == :add_index
-        connection.execute "ANALYZE VERBOSE #{connection.quote_table_name(args[0].to_s)}"
-      end
-
-      result
-    end
-
-    private
-
-    def postgresql?
-      %w(PostgreSQL PostGIS).include?(connection.adapter_name)
-    end
-
-    def postgresql_version
-      @postgresql_version ||= connection.execute("SHOW server_version_num").first["server_version_num"].to_i
-    end
-
-    def version_safe?
-      version && version <= StrongMigrations.start_after
-    end
-
-    def raise_error(message_key, header: nil, **vars)
-      message = StrongMigrations.error_messages[message_key] || "Missing message"
-
-      vars[:migration_name] = self.class.name
-      vars[:migration_suffix] = "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
-      vars[:base_model] = "ApplicationRecord"
-
-      # interpolate variables in appended code
-      if vars[:append]
-        vars[:append] = vars[:append].gsub(/%(?!{)/, "%%") % vars
-      end
-
-      # escape % not followed by {
-      stop!(message.gsub(/%(?!{)/, "%%") % vars, header: header || "Dangerous operation detected")
-    end
-
-    def foreign_key_str(statement, identifiers)
-      # not all identifiers are tables, but this method of quoting should be fine
-      code = statement % identifiers.map { |v| connection.quote_table_name(v) }
-      "safety_assured do\n      execute '#{code}' \n    end"
     end
 
-    def command_str(command, args)
-      str_args = args[0..-2].map { |a| a.inspect }
-
-      # prettier last arg
-      last_arg = args[-1]
-      if last_arg.is_a?(Hash)
-        if last_arg.any?
-          str_args << last_arg.map { |k, v| "#{k}: #{v.inspect}" }.join(", ")
-        end
-      else
-        str_args << last_arg.inspect
+    def safety_assured
+      @checker.safety_assured do
+        yield
       end
-
-      "#{command} #{str_args.join(", ")}"
-    end
-
-    def backfill_code(table, column, default)
-      model = table.to_s.classify
-      "#{model}.in_batches do |relation| \n      relation.update_all #{column}: #{default.inspect}\n      sleep(0.1)\n    end"
     end
 
     def stop!(message, header: "Custom check")

data/lib/strong_migrations/version.rb

@@ -1,3 +1,3 @@
 module StrongMigrations
-  VERSION = "0.4.0"
+  VERSION = "0.4.1"
 end

data/lib/tasks/strong_migrations.rake

@@ -1,4 +1,4 @@
-# http://nithinbekal.com/posts/safe-rake-tasks
+# https://nithinbekal.com/posts/safe-rake-tasks
 
 namespace :strong_migrations do
   task safety_assured: :environment do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: strong_migrations
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Andrew Kane
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-27 00:00:00.000000000 Z
+date: 2019-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -96,6 +96,7 @@ files:
 - README.md
 - lib/strong_migrations.rb
 - lib/strong_migrations/alphabetize_columns.rb
+- lib/strong_migrations/checker.rb
 - lib/strong_migrations/database_tasks.rb
 - lib/strong_migrations/migration.rb
 - lib/strong_migrations/railtie.rb
@@ -121,8 +122,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.4
 signing_key: 
 specification_version: 4
-summary: Catch unsafe migrations at dev time
+summary: Catch unsafe migrations in development
 test_files: []