strong_migrations 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '04239dfae50098f46f93b7d09d8fa8ab767372f9b52a58db25902eb88e449e56'
-  data.tar.gz: 5a7c529bde98344e6277dc6ab4b915f14c445468c0936998dab0da3376a6b953
+  metadata.gz: 858552e31803f119fa4df371348a710c20db26107ad55f66a553192fddefac47
+  data.tar.gz: a7646d2969c0051e9362103b037f6e46d0a878d521aa63e7811b5b23818cdb64
 SHA512:
-  metadata.gz: adc856d7c80a2ecf601efac5170ce365269c6ac474fb33b390f00362e9068c676221b29c065b791d8730dd4c44937b12ab0c13f65b8bd92656a47182dd1cbf2a
-  data.tar.gz: 838d682a173a8d69da91702f9373d21d8d769179fc5520b6b2a18ab55f91e2970584022cbdfe1492b8cc5f33e9602f9fd6d445ae4a2b17f4b25d3a629225de45
+  metadata.gz: 3127959b63c1f846a3bd4caf213fa1edc52ad3dc5fdec3d45fde1ffb8028f5e0a2c5b3fb4db2a696ffb26862262d2e866acc2ccb1eba80600fea2e5c16b43f22
+  data.tar.gz: 14a4fc2f946cfa05bfe86b2fcc390633691c354495f83eb9382ec8a0dfad7be0b72c1fdf813ea76522981b73336d2cd3cf15d2b3bd5a8004eed3d87d5b7e0327

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 0.6.0 (2020-01-24)
+
+- Added `statement_timeout` and `lock_timeout`
+- Adding a column with a non-null default value is safe in MySQL 8.0.12+ and MariaDB 10.3.2+
+- Added `change_column_null` check for MySQL and MariaDB
+- Added `auto_analyze` for MySQL and MariaDB
+- Added `target_mysql_version` and `target_mariadb_version`
+- Switched to `up` for backfilling
+
 ## 0.5.1 (2019-12-17)
 
 - Fixed migration name in error messages

data/README.md

@@ -2,6 +2,8 @@
 
 Catch unsafe migrations in development
 
+Supports for PostgreSQL, MySQL, and MariaDB
+
 :tangerine: Battle-tested at [Instacart](https://www.instacart.com/opensource)
 
 [![Build Status](https://travis-ci.org/ankane/strong_migrations.svg?branch=master)](https://travis-ci.org/ankane/strong_migrations)
@@ -86,7 +88,7 @@ end
 
 ### Adding a column with a default value
 
-Note: This operation is safe in Postgres 11+.
+Note: This operation is safe in Postgres 11+, MySQL 8.0.12+, and MariaDB 10.3.2+
 
 #### Bad
 
@@ -144,10 +146,10 @@ There are three keys to backfilling safely: batching, throttling, and running it
 class BackfillSomeColumn < ActiveRecord::Migration[6.0]
   disable_ddl_transaction!
 
-  def change
+  def up
     User.unscoped.in_batches do |relation|
       relation.update_all some_column: "default_value"
-      sleep(0.1) # throttle
+      sleep(0.01) # throttle
     end
   end
 end
@@ -181,7 +183,13 @@ class AddSomeIndexToUsers < ActiveRecord::Migration[6.0]
 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. Check out [gindex](https://github.com/ankane/gindex) to quickly generate index migrations without memorizing the syntax.
+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.
+
+With [gindex](https://github.com/ankane/gindex), you can generate an index migration instantly with:
+
+```sh
+rails g index table column
+```
 
 ### Adding a reference
 
@@ -614,9 +622,7 @@ 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.
 
-## Postgres-Specific Features
-
-### Analyze Tables
+## Analyze Tables
 
 Analyze tables automatically (to update planner statistics) after an index is added. Create an initializer with:
 
@@ -624,25 +630,41 @@ Analyze tables automatically (to update planner statistics) after an index is ad
 StrongMigrations.auto_analyze = true
 ```
 
-### Lock Timeout
+## Target Version
 
-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/).
+If your development database version is different from production, you can specify the production version so the right checks are run in development.
 
-```sql
-ALTER ROLE myuser SET lock_timeout = '10s';
+```ruby
+StrongMigrations.target_postgresql_version = "10"
+StrongMigrations.target_mysql_version = "8.0.12"
+StrongMigrations.target_mariadb_version = "10.3.2"
 ```
 
-There’s also [a gem](https://github.com/gocardless/activerecord-safer_migrations) you can use for this.
+For safety, this option only affects development and test environments. In other environments, the actual server version is always used.
 
-### Target Version
+## Timeouts
 
-If your development database version is different from production, you can specify the production version so the right checks are run in development.
+It’s a good idea to set a long statement timeout and a short lock timeout for migrations. This way, migrations can run for a while, and if a migration can’t acquire a lock in a timely manner, other statements won’t be stuck behind it.
+
+You can use:
 
 ```ruby
-StrongMigrations.target_postgresql_version = 10 # or 9.6, etc
+StrongMigrations.statement_timeout = 1.hour
+StrongMigrations.lock_timeout = 10.seconds
 ```
 
-For safety, this option only affects development and test environments. In other environments, the actual server version is always used.
+Or set the timeouts directly on the database user that runs migrations. For Postgres, use:
+
+```sql
+ALTER ROLE myuser SET statement_timeout = '1h';
+ALTER ROLE myuser SET lock_timeout = '10s';
+```
+
+Note: If you use PgBouncer in transaction mode, you must set timeouts on the database user.
+
+## Permissions
+
+We recommend using a [separate database user](https://ankane.org/postgres-users) for migrations when possible so you don’t need to grant your app user permission to alter tables.
 
 ## Additional Reading
 
@@ -662,7 +684,7 @@ Everyone is encouraged to help improve this project. Here are a few ways you can
 - Write, clarify, or fix documentation
 - Suggest or add new features
 
-To get started with development and testing:
+To get started with development:
 
 ```sh
 git clone https://github.com/ankane/strong_migrations.git

data/lib/strong_migrations.rb

@@ -1,15 +1,24 @@
+# dependencies
 require "active_support"
 
+# modules
 require "strong_migrations/checker"
 require "strong_migrations/database_tasks"
 require "strong_migrations/migration"
-require "strong_migrations/railtie" if defined?(Rails)
-require "strong_migrations/unsafe_migration"
+require "strong_migrations/migration_helpers"
 require "strong_migrations/version"
 
+# integrations
+require "strong_migrations/railtie" if defined?(Rails)
+
 module StrongMigrations
+  class Error < StandardError; end
+  class UnsafeMigration < Error; end
+
   class << self
-    attr_accessor :auto_analyze, :start_after, :checks, :error_messages, :target_postgresql_version, :enabled_checks
+    attr_accessor :auto_analyze, :start_after, :checks, :error_messages,
+      :target_postgresql_version, :target_mysql_version, :target_mariadb_version,
+      :enabled_checks, :lock_timeout, :statement_timeout, :helpers
   end
   self.auto_analyze = false
   self.start_after = 0
@@ -35,7 +44,7 @@ Then backfill the existing rows in the Rails console or a separate migration wit
 class Backfill%{migration_name} < ActiveRecord::Migration%{migration_suffix}
   disable_ddl_transaction!
 
-  def change
+  def up
     %{code}
   end
 end%{append}",
@@ -55,7 +64,7 @@ table and indexes to be rewritten. A safer approach is to:
 5. Stop writing to the old column
 6. Drop the old column",
 
-    remove_column: "ActiveRecord caches attributes which causes problems
+    remove_column: "Active Record caches attributes which causes problems
 when removing columns. Be sure to ignore the column%{column_suffix}:
 
 class %{model} < %{base_model}
@@ -150,7 +159,7 @@ Rails console or a separate migration with disable_ddl_transaction!.
 class Backfill%{migration_name} < ActiveRecord::Migration%{migration_suffix}
   disable_ddl_transaction!
 
-  def change
+  def up
     %{code}
   end
 end",
@@ -172,6 +181,22 @@ class Validate%{migration_name} < ActiveRecord::Migration%{migration_suffix}
   end
 end",
 
+    change_column_null_postgresql_helper:
+"Setting NOT NULL on a column requires an AccessExclusiveLock,
+which is expensive on large tables. Instead, we can use a constraint and
+validate it in a separate step with a more agreeable RowShareLock.
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  disable_ddl_transaction!
+
+  def change
+    %{command}
+  end
+end",
+
+    change_column_null_mysql:
+"Setting NOT NULL on an existing column is not safe with your database engine.",
+
     add_foreign_key:
 "New foreign keys are validated by default. This acquires an AccessExclusiveLock,
 which is expensive on large tables. Instead, validate it in a separate migration
@@ -188,8 +213,22 @@ class Validate%{migration_name} < ActiveRecord::Migration%{migration_suffix}
     %{validate_foreign_key_code}
   end
 end",
+
+    add_foreign_key_helper:
+"New foreign keys are validated by default. This acquires an AccessExclusiveLock,
+which is expensive on large tables. Instead, we can validate it in a separate step
+with a more agreeable RowShareLock.
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  disable_ddl_transaction!
+
+  def change
+    %{command}
+  end
+end",
   }
   self.enabled_checks = (error_messages.keys - [:remove_index]).map { |k| [k, {}] }.to_h
+  self.helpers = false
 
   def self.add_check(&block)
     checks << block
@@ -211,6 +250,13 @@ end",
       false
     end
   end
+
+  # def self.enable_helpers
+  #   unless helpers
+  #     ActiveRecord::Migration.include(StrongMigrations::MigrationHelpers)
+  #     self.helpers = true
+  #   end
+  # end
 end
 
 ActiveSupport.on_load(:active_record) do

data/lib/strong_migrations/checker.rb

@@ -6,6 +6,7 @@ module StrongMigrations
       @migration = migration
       @new_tables = []
       @safe = false
+      @timeouts_set = false
     end
 
     def safety_assured
@@ -19,6 +20,8 @@ module StrongMigrations
     end
 
     def perform(method, *args)
+      set_timeouts
+
       unless safe?
         case method
         when :remove_column, :remove_columns, :remove_timestamps, :remove_reference, :remove_belongs_to
@@ -77,7 +80,7 @@ module StrongMigrations
           options ||= {}
           default = options[:default]
 
-          if !default.nil? && !(postgresql? && postgresql_version >= 110000)
+          if !default.nil? && !((postgresql? && postgresql_version >= Gem::Version.new("11")) || (mysql? && mysql_version >= Gem::Version.new("8.0.12")) || (mariadb? && mariadb_version >= Gem::Version.new("10.3.2")))
 
             if options[:null] == false
               options = options.except(:null)
@@ -139,12 +142,19 @@ Then add the NOT NULL constraint."
           table, column, null, default = args
           if !null
             if postgresql?
-              # match https://github.com/nullobject/rein
-              constraint_name = "#{table}_#{column}_null"
-
-              raise_error :change_column_null_postgresql,
-                add_constraint_code: constraint_str("ALTER TABLE %s ADD CONSTRAINT %s CHECK (%s IS NOT NULL) NOT VALID", [table, constraint_name, column]),
-                validate_constraint_code: constraint_str("ALTER TABLE %s VALIDATE CONSTRAINT %s", [table, constraint_name])
+              if helpers?
+                raise_error :change_column_null_postgresql_helper,
+                  command: command_str(:add_null_constraint_safely, [table, column])
+              else
+                # match https://github.com/nullobject/rein
+                constraint_name = "#{table}_#{column}_null"
+
+                raise_error :change_column_null_postgresql,
+                  add_constraint_code: constraint_str("ALTER TABLE %s ADD CONSTRAINT %s CHECK (%s IS NOT NULL) NOT VALID", [table, constraint_name, column]),
+                  validate_constraint_code: constraint_str("ALTER TABLE %s VALIDATE CONSTRAINT %s", [table, constraint_name])
+              end
+            elsif mysql? || mariadb?
+              raise_error :change_column_null_mysql
             elsif !default.nil?
               raise_error :change_column_null,
                 code: backfill_code(table, column, default)
@@ -153,18 +163,15 @@ Then add the NOT NULL constraint."
         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
 
+          # always validated before 5.2
+          validate = options.fetch(:validate, true) || ActiveRecord::VERSION::STRING < "5.2"
+
+          if postgresql? && validate
+            if helpers?
+              raise_error :add_foreign_key_helper,
+                command: command_str(:add_foreign_key_safely, [from_table, to_table, options])
+            elsif ActiveRecord::VERSION::STRING < "5.2"
               # fk name logic from rails
               primary_key = options[:primary_key] || "id"
               column = options[:column] || "#{to_table.to_s.singularize}_id"
@@ -174,6 +181,10 @@ Then add the NOT NULL constraint."
               raise_error :add_foreign_key,
                 add_foreign_key_code: constraint_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: constraint_str("ALTER TABLE %s VALIDATE CONSTRAINT %s", [from_table, fk_name])
+            else
+              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
           end
         end
@@ -185,13 +196,51 @@ Then add the NOT NULL constraint."
 
       result = yield
 
-      if StrongMigrations.auto_analyze && direction == :up && postgresql? && method == :add_index
-        connection.execute "ANALYZE VERBOSE #{connection.quote_table_name(args[0].to_s)}"
+      if StrongMigrations.auto_analyze && direction == :up && method == :add_index
+        if postgresql?
+          connection.execute "ANALYZE VERBOSE #{connection.quote_table_name(args[0].to_s)}"
+        elsif mariadb? || mysql?
+          connection.execute "ANALYZE TABLE #{connection.quote_table_name(args[0].to_s)}"
+        end
       end
 
       result
     end
 
+    def set_timeouts
+      if !@timeouts_set
+        if StrongMigrations.statement_timeout
+          statement =
+            if postgresql?
+              "SET statement_timeout TO #{connection.quote(StrongMigrations.statement_timeout)}"
+            elsif mysql?
+              "SET max_execution_time = #{connection.quote(StrongMigrations.statement_timeout.to_i * 1000)}"
+            elsif mariadb?
+              "SET max_statement_time = #{connection.quote(StrongMigrations.statement_timeout)}"
+            else
+              raise StrongMigrations::Error, "Statement timeout not supported for this database"
+            end
+
+          connection.select_all(statement)
+        end
+
+        if StrongMigrations.lock_timeout
+          statement =
+            if postgresql?
+              "SET lock_timeout TO #{connection.quote(StrongMigrations.lock_timeout)}"
+            elsif mysql? || mariadb?
+              "SET lock_wait_timeout = #{connection.quote(StrongMigrations.lock_timeout)}"
+            else
+              raise StrongMigrations::Error, "Lock timeout not supported for this database"
+            end
+
+          connection.select_all(statement)
+        end
+
+        @timeouts_set = true
+      end
+    end
+
     private
 
     def connection
@@ -211,19 +260,53 @@ Then add the NOT NULL constraint."
     end
 
     def postgresql?
-      %w(PostgreSQL PostGIS).include?(connection.adapter_name)
+      connection.adapter_name =~ /postg/i # PostgreSQL, PostGIS
     end
 
     def postgresql_version
       @postgresql_version ||= begin
-        target_version = StrongMigrations.target_postgresql_version
+        target_version(StrongMigrations.target_postgresql_version) do
+          connection.select_all("SHOW server_version").first["server_version"]
+        end
+      end
+    end
+
+    def mysql?
+      connection.adapter_name =~ /mysql/i && !connection.try(:mariadb?)
+    end
+
+    def mysql_version
+      @mysql_version ||= begin
+        target_version(StrongMigrations.target_mysql_version) do
+          connection.select_all("SELECT VERSION()").first["VERSION()"].split("-").first
+        end
+      end
+    end
+
+    def mariadb?
+      connection.adapter_name =~ /mysql/i && connection.try(:mariadb?)
+    end
+
+    def mariadb_version
+      @mariadb_version ||= begin
+        target_version(StrongMigrations.target_mariadb_version) do
+          connection.select_all("SELECT VERSION()").first["VERSION()"].split("-").first
+        end
+      end
+    end
+
+    def target_version(target_version)
+      version =
         if target_version && defined?(Rails) && (Rails.env.development? || Rails.env.test?)
-          # we only need major version right now
-          target_version.to_i * 10000
+          target_version.to_s
         else
-          connection.execute("SHOW server_version_num").first["server_version_num"].to_i
+          yield
         end
-      end
+      Gem::Version.new(version)
+    end
+
+    def helpers?
+      StrongMigrations.helpers
     end
 
     def raise_error(message_key, header: nil, **vars)
@@ -275,7 +358,7 @@ Then add the NOT NULL constraint."
 
     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"
+      "#{model}.unscoped.in_batches do |relation| \n      relation.update_all #{column}: #{default.inspect}\n      sleep(0.01)\n    end"
     end
 
     def new_table?(table)

data/lib/strong_migrations/database_tasks.rb

@@ -3,7 +3,7 @@ module StrongMigrations
     def migrate
       super
     rescue => e
-      if e.cause.is_a?(StrongMigrations::UnsafeMigration)
+      if e.cause.is_a?(StrongMigrations::Error)
         # strip cause and clean backtrace
         def e.cause
           nil

data/lib/strong_migrations/migration_helpers.rb

@@ -0,0 +1,117 @@
+module StrongMigrations
+  module MigrationHelpers
+    def add_foreign_key_safely(from_table, to_table, **options)
+      ensure_postgresql(__method__)
+      ensure_not_in_transaction(__method__)
+
+      reversible do |dir|
+        dir.up do
+          if ActiveRecord::VERSION::STRING >= "5.2"
+            add_foreign_key(from_table, to_table, options.merge(validate: false))
+            validate_foreign_key(from_table, to_table)
+          else
+            options = connection.foreign_key_options(from_table, to_table, options)
+            fk_name, column, primary_key = options.values_at(:name, :column, :primary_key)
+            primary_key ||= "id"
+
+            statement = ["ALTER TABLE %s ADD CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s (%s)"]
+            statement << on_delete_update_statement(:delete, options[:on_delete]) if options[:on_delete]
+            statement << on_delete_update_statement(:update, options[:on_update]) if options[:on_update]
+            statement << "NOT VALID"
+
+            safety_assured do
+              execute quote_identifiers(statement.join(" "), [from_table, fk_name, column, to_table, primary_key])
+              execute quote_identifiers("ALTER TABLE %s VALIDATE CONSTRAINT %s", [from_table, fk_name])
+            end
+          end
+        end
+
+        dir.down do
+          remove_foreign_key(from_table, to_table)
+        end
+      end
+    end
+
+    def add_null_constraint_safely(table_name, column_name, name: nil)
+      ensure_postgresql(__method__)
+      ensure_not_in_transaction(__method__)
+
+      reversible do |dir|
+        dir.up do
+          name ||= null_constraint_name(table_name, column_name)
+
+          safety_assured do
+            execute quote_identifiers("ALTER TABLE %s ADD CONSTRAINT %s CHECK (%s IS NOT NULL) NOT VALID", [table_name, name, column_name])
+            execute quote_identifiers("ALTER TABLE %s VALIDATE CONSTRAINT %s", [table_name, name])
+          end
+        end
+
+        dir.down do
+          remove_null_constraint_safely(table_name, column_name)
+        end
+      end
+    end
+
+    # removing constraints is safe, but this method is safe to reverse as well
+    def remove_null_constraint_safely(table_name, column_name, name: nil)
+      # could also ensure in transaction so it can be reversed
+      # but that's more of a concern for a reversible migrations check
+      ensure_postgresql(__method__)
+
+      reversible do |dir|
+        dir.up do
+          name ||= null_constraint_name(table_name, column_name)
+
+          safety_assured do
+            execute quote_identifiers("ALTER TABLE %s DROP CONSTRAINT %s", [table_name, name])
+          end
+        end
+
+        dir.down do
+          add_null_constraint_safely(table_name, column_name)
+        end
+      end
+    end
+
+    private
+
+    def ensure_postgresql(method_name)
+      raise StrongMigrations::Error, "`#{method_name}` is intended for Postgres only" unless postgresql?
+    end
+
+    def postgresql?
+      %w(PostgreSQL PostGIS).include?(connection.adapter_name)
+    end
+
+    def ensure_not_in_transaction(method_name)
+      if connection.transaction_open?
+        raise StrongMigrations::Error, "Cannot run `#{method_name}` inside a transaction. Use `disable_ddl_transaction` to disable the transaction."
+      end
+    end
+
+    # match https://github.com/nullobject/rein
+    def null_constraint_name(table_name, column_name)
+      "#{table_name}_#{column_name}_null"
+    end
+
+    def on_delete_update_statement(delete_or_update, action)
+      on = delete_or_update.to_s.upcase
+
+      case action
+      when :nullify
+        "ON #{on} SET NULL"
+      when :cascade
+        "ON #{on} CASCADE"
+      when :restrict
+        "ON #{on} RESTRICT"
+      else
+        # same error message as Active Record
+        raise "'#{action}' is not supported for :on_update or :on_delete.\nSupported values are: :nullify, :cascade, :restrict"
+      end
+    end
+
+    def quote_identifiers(statement, identifiers)
+      statement % identifiers.map { |v| connection.quote_table_name(v) }
+    end
+  end
+end

data/lib/strong_migrations/version.rb

@@ -1,3 +1,3 @@
 module StrongMigrations
-  VERSION = "0.5.1"
+  VERSION = "0.6.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: strong_migrations
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Andrew Kane
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-18 00:00:00.000000000 Z
+date: 2020-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -99,8 +99,8 @@ files:
 - lib/strong_migrations/checker.rb
 - lib/strong_migrations/database_tasks.rb
 - lib/strong_migrations/migration.rb
+- lib/strong_migrations/migration_helpers.rb
 - lib/strong_migrations/railtie.rb
-- lib/strong_migrations/unsafe_migration.rb
 - lib/strong_migrations/version.rb
 - lib/tasks/strong_migrations.rake
 homepage: https://github.com/ankane/strong_migrations
@@ -122,7 +122,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Catch unsafe migrations in development

data/lib/strong_migrations/unsafe_migration.rb

@@ -1,4 +0,0 @@
-module StrongMigrations
-  class UnsafeMigration < StandardError
-  end
-end