zero_downtime_migrations 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f40fc64c97d9d1b74b7a26d11e3daaf1b2941896
-  data.tar.gz: 7edb2b3a1b277191c2167a9a135c721e5d81ae78
+  metadata.gz: 5c8dfec1a4d2d84e2a9260829418235053eeec0c
+  data.tar.gz: 0568a51dd7990eb896354ed67cfe984a3bcc8f13
 SHA512:
-  metadata.gz: 0f74bd5a1ef14f6664b0f5199bb1d11513cb64d2374fad6ce636e10cacff37ef8734c60f242e27ab931f8ae5dffd3cda3b2a6b72be70a1fee95dfde3a8da2b73
-  data.tar.gz: a6caba1f552ad472dbb78525a11cb2495659ca2cb72be191f98861b1de711f0af8a5d54cb2955ee719a636c578c5e2b7ac8b3688fd5cc34da65ab3c17307832d
+  metadata.gz: 1b0b3503a2749957e5f310bd5c38bcfa3243a3fd2d077f793ca17fff631c384a65f6dc75d247588f52912bb43ee36d2bbbd6d173f33912f34abc357f9e0aa4f6
+  data.tar.gz: 1d2d7bc71333d19ba28b1c6600a99d23cf2094078f9f45dd9df826ce9306b0284b9e9236eae920b3b1224d33cddeb7f8ce020c81567d77448df1d36e62966b3c

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    zero_downtime_migrations (0.0.0)
+    zero_downtime_migrations (0.0.1)
       activerecord
 
 GEM

data/README.md

@@ -1,15 +1,15 @@
-# zero_downtime_migrations
+# ![LendingHome](https://cloud.githubusercontent.com/assets/2419/19467866/7efa93a8-94c8-11e6-93e7-4375dbb8a7bc.png) zero_downtime_migrations
 
 Zero downtime migrations with ActiveRecord and PostgreSQL. Catch problematic migrations at development/test time!
 
-Heavily insprired by the similar projects listed below. Our intent was to target PostgreSQL specific issues and provide clearer instructions on how to perform the migrations the "zero downtime way".
+Heavily inspired by these similar projects:
 
 * https://github.com/ankane/strong_migrations
 * https://github.com/foobarfighter/safe-migrations
 
 ## Installation
 
-Simply add the gem to the project `Gemfile`. Ensure that it's only added to the `development` and `test` groups.
+Simply add the gem to the project `Gemfile`. Ensure that it's only **added to the `development` and `test`** groups.
 
 ```ruby
 gem "zero_downtime_migrations", only: %i(development test)
@@ -17,13 +17,17 @@ gem "zero_downtime_migrations", only: %i(development test)
 
 ## Usage
 
-This gem will automatically raise exceptions when potential database locking migrations are detected. It checks for common things like:
+This gem will automatically **raise exceptions when potential database locking migrations are detected**.
+
+It checks for common things like:
 
 * Adding a column with a default
 * Adding a non-concurrent index
-* Mixing data changes with schema migrations
+* Mixing data changes with index or schema migrations
+* Performing data or schema migrations with the DDL transaction disabled
+* Using `each` instead of `find_each` to loop thru `ActiveRecord` objects
 
-These exceptions display clear instructions of how to perform the same operation the "zero downtime way".
+These exceptions display very clear instructions of how to perform the same operation the "zero downtime way".
 
 ## Disabling exceptions
 
@@ -39,16 +43,29 @@ class AddPublishedToPosts < ActiveRecord::Migration[5.0]
 end
 ```
 
-We can also disable the exceptions by setting `ENV["SAFETY_ASSURED"]` when running migrations.
+We can also mark an entire migration as safe by using the `safety_assured` helper method.
+
+```ruby
+class AddPublishedToPosts < ActiveRecord::Migration[5.0]
+  safety_assured
+  
+  def change
+    add_column :posts, :published, :boolean
+    Post.where("created_at >= ?", 1.day.ago).update_all(published: true)
+  end
+end
+```
+
+Enforcements can be globally disabled by setting `ENV["SAFETY_ASSURED"]` when running migrations.
 
 ```bash
 SAFETY_ASSURED=1 bundle exec rake db:migrate --trace
 ```
 
-These enforcements are automatically disabled by default for the following scenarios:
+These enforcements are **automatically disabled by default for the following scenarios**:
 
-* We're loading the database schema with `rake db:schema:load` instead of `db:migrate`
-* We're migrating down (reverting a migration)
+* The database schema is being loaded with `rake db:schema:load` instead of `db:migrate`
+* The current migration is a reverse (down) migration
 
 ## Validations
 
@@ -117,14 +134,122 @@ class IndexUsersOnEmail < ActiveRecord::Migration[5.0]
 end
 ```
 
+### Mixing data/index/schema migrations
+
+#### Bad
+
+```ruby
+class AddPublishedToPosts < ActiveRecord::Migration[5.0]
+  def change
+    add_column :posts, :published, :boolean
+    Post.update_all(published: true)
+    add_index :posts, :published
+  end
+end
+```
+
+#### Good
+
+```ruby
+class AddPublishedToPosts < ActiveRecord::Migration[5.0]
+  def change
+    add_column :posts, :published, :boolean
+  end
+end
+```
+
+```ruby
+class BackportPublishedOnPosts < ActiveRecord::Migration[5.0]
+  def change
+    Post.update_all(published: true)
+  end
+end
+```
+
+```ruby
+class IndexPublishedOnPosts < ActiveRecord::Migration[5.0]
+  disable_ddl_transaction!
+
+  def change
+    add_index :posts, :published, algorithm: :concurrently
+  end
+end
+```
+
+### Disabling the DDL transaction
+
+#### Bad
+
+```ruby
+class AddPublishedToPosts < ActiveRecord::Migration[5.0]
+  disable_ddl_transaction!
+
+  def change
+    add_column :posts, :published, :boolean
+  end
+end
+```
+
+```ruby
+class UpdatePublishedOnPosts < ActiveRecord::Migration[5.0]
+  disable_ddl_transaction!
+
+  def change
+    Post.update_all(published: true)
+  end
+end
+```
+
+#### Good
+
+```ruby
+class AddPublishedToPosts < ActiveRecord::Migration[5.0]
+  def change
+    add_column :posts, :published, :boolean
+  end
+end
+```
+
+```ruby
+class UpdatePublishedOnPosts < ActiveRecord::Migration[5.0]
+  def change
+    Post.update_all(published: true)
+  end
+end
+```
+
+### Looping thru `ActiveRecord::Base` objects
+
+#### Bad
+
+```ruby
+class BackportPublishedDefaultOnPosts < ActiveRecord::Migration[5.0]
+  def change
+    Post.all.each do |post|
+      post.update_attribute(published: true)
+    end
+  end
+end
+```
+
+#### Good
+
+```ruby
+class BackportPublishedDefaultOnPosts < ActiveRecord::Migration[5.0]
+  def change
+    Post.all.find_each do |post|
+      post.update_attribute(published: true)
+    end
+  end
+end
+```
+
 ### TODO
 
 * Changing a column type
 * Removing a column
 * Renaming a column
 * Renaming a table
-* Mixing data changes with schema or index migrations
-* Performing schema changes with the DDL transaction disabled
 
 ## Testing
 

data/lib/zero_downtime_migrations/data.rb

@@ -0,0 +1,8 @@
+module ZeroDowntimeMigrations
+  module Data
+    def initialize(*)
+      Migration.data = true
+      super
+    end
+  end
+end

data/lib/zero_downtime_migrations/dsl.rb

@@ -0,0 +1,37 @@
+module ZeroDowntimeMigrations
+  module DSL
+    attr_accessor :data, :ddl, :index, :migrating, :safe
+
+    def data?
+      !!@data
+    end
+
+    def ddl?
+      !!@ddl
+    end
+
+    def index?
+      !!@index
+    end
+
+    def migrating?
+      !!@migrating
+    end
+
+    def mixed?
+      [data?, ddl?, index?].select(&:itself).size > 1
+    end
+
+    def safe?
+      !!@safe || ENV["SAFETY_ASSURED"].presence
+    end
+
+    def safety_assured
+      Migration.safe = true
+    end
+
+    def unsafe?
+      !safe?
+    end
+  end
+end

data/lib/zero_downtime_migrations/migration.rb

@@ -1,31 +1,80 @@
 module ZeroDowntimeMigrations
   module Migration
+    extend DSL
+
+    def self.prepended(mod)
+      mod.singleton_class.prepend(DSL)
+    end
+
     def ddl_disabled?
       !!disable_ddl_transaction
     end
 
+    def define(*)
+      Migration.migrating = true
+      Migration.safe = true
+      super
+    end
+
     def migrate(direction)
       @direction = direction
-      super
+
+      Migration.data = false
+      Migration.ddl = false
+      Migration.index = false
+      Migration.migrating = true
+      Migration.safe ||= reverse_migration? || rollup_migration?
+
+      super.tap do
+        validate(:ddl_migration)
+        validate(:mixed_migration)
+        Migration.migrating = false
+        Migration.safe = false
+      end
     end
 
     private
 
-    def loading_schema?
-      is_a?(ActiveRecord::Schema)
+    def ddl_method?(method)
+      %i(
+        add_belongs_to
+        add_column
+        add_foreign_key
+        add_reference
+        add_timestamps
+        change_column
+        change_column_default
+        change_column_null
+        change_table
+        create_join_table
+        create_table
+        drop_join_table
+        drop_table
+        remove_belongs_to
+        remove_column
+        remove_columns
+        remove_foreign_key
+        remove_index
+        remove_index!
+        remove_reference
+        remove_timestamps
+        rename_column
+        rename_column_indexes
+        rename_index
+        rename_table
+        rename_table_indexes
+      ).include?(method)
     end
 
-    def method_missing(method, *args)
-      unless loading_schema? || reverse_migration? || rollup_migration? || safe?
-        validator = "#{namespace}::#{method.to_s.classify}".safe_constantize
-        validator.new(self, args).validate! if validator
-      end
-
-      super
+    def index_method?(method)
+      %i(add_index).include?(method)
     end
 
-    def namespace
-      Module.nesting.last
+    def method_missing(method, *args)
+      Migration.ddl = true if ddl_method?(method)
+      Migration.index = true if index_method?(method)
+      validate(method, *args)
+      super
     end
 
     def reverse_migration?
@@ -37,15 +86,15 @@ module ZeroDowntimeMigrations
     end
 
     def safety_assured
-      safe = @safe
-      @safe = true
+      safe = Migration.safe
+      Migration.safe = true
       yield
     ensure
-      @safe = safe
+      Migration.safe = safe
     end
 
-    def safe?
-      !!(@safe || ENV["SAFE_MIGRATION"].presence)
+    def validate(type, *args)
+      Validation.validate!(type, self, *args) if Migration.unsafe?
     end
   end
 end

data/lib/zero_downtime_migrations/relation.rb

@@ -0,0 +1,12 @@
+module ZeroDowntimeMigrations
+  module Relation
+    prepend Data
+
+    def each(*)
+      return super unless Migration.migrating? && Migration.unsafe?
+      error = "Using ActiveRecord::Relation#each is unsafe!"
+      correction = "Instead, let's use the find_each method to query in batches."
+      raise UnsafeMigrationError.new(error, correction)
+    end
+  end
+end

data/lib/zero_downtime_migrations/validation/add_column.rb

@@ -0,0 +1,93 @@
+module ZeroDowntimeMigrations
+  class Validation
+    class AddColumn < Validation
+      def validate!
+        return if options[:default].nil? # only nil is safe
+        message = "Adding a column with a default is unsafe!"
+        error!(message, correction)
+      end
+
+      private
+
+      def correction
+        <<-MESSAGE.strip_heredoc
+          This action can potentially lock your database table!
+
+          Instead, let's first add the column without a default.
+
+            class Add#{column_title}To#{table_title} < ActiveRecord::Migration
+              def change
+                add_column :#{table}, :#{column}, :#{column_type}
+              end
+            end
+
+          Then set the new column default in a separate migration. Note that
+          this does not update any existing data.
+
+            class AddDefault#{column_title}To#{table_title} < ActiveRecord::Migration
+              def change
+                change_column_default :#{table}, :#{column}, #{column_default}
+              end
+            end
+
+          If necessary then backport the default value for existing data in batches.
+          This should be done in its own migration as well.
+
+            class BackportDefault#{column_title}To#{table_title} < ActiveRecord::Migration
+              def change
+                #{table_model}.select(:id).find_in_batches.with_index do |records, index|
+                  puts "Processing batch \#{index + 1}\\r"
+                  #{table_model}.where(id: records).update_all(#{column}: #{column_default})
+                end
+              end
+            end
+
+          Note that in some cases it may not even be necessary to backport a default value.
+
+            class #{table_model} < ActiveRecord::Base
+              def #{column}
+                self["#{column}"] ||= #{column_default}
+              end
+            end
+
+          If you're 100% positive that this migration is already safe, then wrap the
+          call to `add_column` in a `safety_assured` block.
+
+            class Add#{column_title}To#{table_title} < ActiveRecord::Migration
+              def change
+                safety_assured { add_column :#{table}, :#{column}, :#{column_type}, default: #{column_default} }
+              end
+            end
+        MESSAGE
+      end
+
+      def column
+        args[1]
+      end
+
+      def column_default
+        options[:default].inspect
+      end
+
+      def column_title
+        column.to_s.camelize
+      end
+
+      def column_type
+        args[2]
+      end
+
+      def table
+        args[0]
+      end
+
+      def table_model
+        table_title.singularize
+      end
+
+      def table_title
+        table.to_s.camelize
+      end
+    end
+  end
+end

data/lib/zero_downtime_migrations/validation/add_index.rb

@@ -0,0 +1,59 @@
+module ZeroDowntimeMigrations
+  class Validation
+    class AddIndex < Validation
+      def validate!
+        return if concurrent? && migration.ddl_disabled?
+        message = "Adding a non-concurrent index is unsafe!"
+        error!(message, correction)
+      end
+
+      private
+
+      def correction
+        <<-MESSAGE.strip_heredoc
+          This action can potentially lock your database table!
+
+          Instead, let's add the index concurrently in its own migration with
+          the DDL transaction disabled.
+
+            class Index#{table_title}On#{column_title} < ActiveRecord::Migration
+              disable_ddl_transaction!
+
+              def change
+                add_index :#{table}, #{column.inspect}, algorithm: :concurrently
+              end
+            end
+
+          If you're 100% positive that this migration is already safe, then wrap the
+          call to `add_index` in a `safety_assured` block.
+
+            class Index#{table_title}On#{column_title} < ActiveRecord::Migration
+              def change
+                safety_assured { add_index :#{table}, #{column.inspect} }
+              end
+            end
+        MESSAGE
+      end
+
+      def concurrent?
+        options[:algorithm] == :concurrently
+      end
+
+      def column
+        args[1]
+      end
+
+      def column_title
+        Array(column).map(&:to_s).join("_and_").camelize
+      end
+
+      def table
+        args[0]
+      end
+
+      def table_title
+        table.to_s.camelize
+      end
+    end
+  end
+end

data/lib/zero_downtime_migrations/validation/ddl_migration.rb

@@ -0,0 +1,22 @@
+module ZeroDowntimeMigrations
+  class Validation
+    class DdlMigration < Validation
+      def validate!
+        return unless migration.ddl_disabled? && !Migration.index?
+        message = "Disabling the DDL transaction is unsafe!"
+        error!(message, correction)
+      end
+
+      private
+
+      def correction
+        <<-MESSAGE.strip_heredoc
+          The DDL transaction should only be disabled for migrations that add indexes.
+
+          Any other data or schema changes must live in their own migration files with
+          the DDL transaction enabled just in case they need to be rolled back.
+        MESSAGE
+      end
+    end
+  end
+end

data/lib/zero_downtime_migrations/validation/mixed_migration.rb

@@ -0,0 +1,23 @@
+module ZeroDowntimeMigrations
+  class Validation
+    class MixedMigration < Validation
+      def validate!
+        return unless Migration.mixed?
+        message = "Mixing data/index/schema changes in the same migration is unsafe!"
+        error!(message, correction)
+      end
+
+      private
+
+      def correction
+        <<-MESSAGE.strip_heredoc
+          Instead, let's split apart these types of migrations into separate files.
+
+          * Introduce schema changes with methods like `create_table` or `add_column` in one file.
+          * Update data with methods like `update_all` or `save` in another file.
+          * Add indexes concurrently within their own file as well.
+        MESSAGE
+      end
+    end
+  end
+end

data/lib/zero_downtime_migrations/validation.rb

@@ -1,8 +1,14 @@
 module ZeroDowntimeMigrations
   class Validation
+    def self.validate!(type, migration, *args)
+      validator = type.to_s.classify
+      validator = const_get(validator) if const_defined?(validator)
+      validator.new(migration, *args).validate! if validator
+    end
+
     attr_reader :migration, :args
 
-    def initialize(migration, args)
+    def initialize(migration, *args)
       @migration = migration
       @args = args
     end

data/lib/zero_downtime_migrations.rb

@@ -1,19 +1,27 @@
 require "active_record"
-require "pathname"
 
+require_relative "zero_downtime_migrations/data"
+require_relative "zero_downtime_migrations/dsl"
 require_relative "zero_downtime_migrations/migration"
+require_relative "zero_downtime_migrations/relation"
 require_relative "zero_downtime_migrations/validation"
+require_relative "zero_downtime_migrations/validation/add_column"
+require_relative "zero_downtime_migrations/validation/add_index"
+require_relative "zero_downtime_migrations/validation/ddl_migration"
+require_relative "zero_downtime_migrations/validation/mixed_migration"
 require_relative "zero_downtime_migrations/unsafe_migration_error"
 
-require_relative "zero_downtime_migrations/add_column"
-require_relative "zero_downtime_migrations/add_index"
-
+ActiveRecord::Base.send(:prepend, ZeroDowntimeMigrations::Data)
 ActiveRecord::Migration.send(:prepend, ZeroDowntimeMigrations::Migration)
+ActiveRecord::Relation.send(:prepend, ZeroDowntimeMigrations::Relation)
+ActiveRecord::Schema.send(:prepend, ZeroDowntimeMigrations::Migration)
 
 module ZeroDowntimeMigrations
+  GEMSPEC = name.underscore.concat(".gemspec")
+
   class << self
     def gemspec
-      @gemspec ||= Gem::Specification.load(root.join("zero_downtime_migrations.gemspec").to_s)
+      @gemspec ||= Gem::Specification.load(root.join(GEMSPEC).to_s)
     end
 
     def root

data/spec/internal/app/models/post.rb

@@ -0,0 +1,2 @@
+class Post < ActiveRecord::Base
+end

data/spec/internal/app/models/user.rb

@@ -0,0 +1,2 @@
+class User < ActiveRecord::Base
+end

data/spec/internal/db/migrate/20161012223255_safe_add_index_with_env.rb

@@ -1,7 +1,7 @@
 class SafeAddIndexWithEnv < ActiveRecord::Migration[5.0]
   def change
-    ENV["SAFE_MIGRATION"] = "1"
+    ENV["SAFETY_ASSURED"] = "1"
     add_index :users, :created_at
-    ENV.delete("SAFE_MIGRATION")
+    ENV.delete("SAFETY_ASSURED")
   end
 end

data/spec/internal/db/migrate/20161012223256_safe_add_index_with_dsl.rb

@@ -0,0 +1,7 @@
+class SafeAddIndexWithDsl < ActiveRecord::Migration[5.0]
+  safety_assured
+
+  def change
+    add_index :posts, :created_at
+  end
+end

data/spec/zero_downtime_migrations/relation_spec.rb

@@ -0,0 +1,53 @@
+RSpec.describe ZeroDowntimeMigrations::Relation do
+  let(:error) { ZeroDowntimeMigrations::UnsafeMigrationError }
+
+  context "with data migrations using each" do
+    let(:migration) do
+      Class.new(ActiveRecord::Migration[5.0]) do
+        def change
+          User.all.each
+        end
+      end
+    end
+
+    it "raises an unsafe migration error" do
+      expect { migration.migrate(:up) }.to raise_error(error)
+    end
+  end
+
+  context "with data migrations using each within safety_assured" do
+    let(:migration) do
+      Class.new(ActiveRecord::Migration[5.0]) do
+        def change
+          safety_assured do
+            User.all.each
+          end
+        end
+      end
+    end
+
+    it "does not raise an unsafe migration error" do
+      expect { migration.migrate(:up) }.not_to raise_error(error)
+    end
+  end
+
+  context "with data migrations using find_each" do
+    let(:migration) do
+      Class.new(ActiveRecord::Migration[5.0]) do
+        def change
+          User.all.find_each
+        end
+      end
+    end
+
+    it "does not raise an unsafe migration error" do
+      expect { migration.migrate(:up) }.not_to raise_error(error)
+    end
+  end
+
+  context "outside of a migration" do
+    it "does not raise an unsafe migration error" do
+      expect { User.all.each }.not_to raise_error(error)
+    end
+  end
+end

data/spec/zero_downtime_migrations/{add_column_spec.rb → validation/add_column_spec.rb}

@@ -1,4 +1,4 @@
-RSpec.describe ZeroDowntimeMigrations::AddColumn do
+RSpec.describe ZeroDowntimeMigrations::Validation::AddColumn do
   let(:error) { ZeroDowntimeMigrations::UnsafeMigrationError }
 
   context "with a default" do

data/spec/zero_downtime_migrations/{add_index_spec.rb → validation/add_index_spec.rb}

@@ -1,4 +1,4 @@
-RSpec.describe ZeroDowntimeMigrations::AddIndex do
+RSpec.describe ZeroDowntimeMigrations::Validation::AddIndex do
   let(:error) { ZeroDowntimeMigrations::UnsafeMigrationError }
 
   context "with ddl transaction enabled" do

data/spec/zero_downtime_migrations/validation/ddl_migration_spec.rb

@@ -0,0 +1,68 @@
+RSpec.describe ZeroDowntimeMigrations::Validation::DdlMigration do
+  let(:error) { ZeroDowntimeMigrations::UnsafeMigrationError }
+
+  context "with a migration that adds a column with ddl disabled" do
+    let(:migration) do
+      Class.new(ActiveRecord::Migration[5.0]) do
+        disable_ddl_transaction!
+
+        def change
+          add_column :users, :active, :boolean
+        end
+      end
+    end
+
+    it "raises an unsafe migration error" do
+      expect { migration.migrate(:up) }.to raise_error(error)
+    end
+  end
+
+  context "with a migration that queries data with ddl disabled" do
+    let(:migration) do
+      Class.new(ActiveRecord::Migration[5.0]) do
+        disable_ddl_transaction!
+
+        def change
+          User.find_in_batches
+        end
+      end
+    end
+
+    it "raises an unsafe migration error" do
+      expect { migration.migrate(:up) }.to raise_error(error)
+    end
+  end
+
+  context "with a migration that updates data with ddl disabled" do
+    let(:migration) do
+      Class.new(ActiveRecord::Migration[5.0]) do
+        disable_ddl_transaction!
+
+        def change
+          add_column :users, :active, :boolean
+          User.update_all(active: true)
+        end
+      end
+    end
+
+    it "raises an unsafe migration error" do
+      expect { migration.migrate(:up) }.to raise_error(error)
+    end
+  end
+
+  context "with a migration that creates data with ddl disabled" do
+    let(:migration) do
+      Class.new(ActiveRecord::Migration[5.0]) do
+        disable_ddl_transaction!
+
+        def change
+          User.new(email: "test").save!
+        end
+      end
+    end
+
+    it "raises an unsafe migration error" do
+      expect { migration.migrate(:up) }.to raise_error(error)
+    end
+  end
+end

data/spec/zero_downtime_migrations/validation/mixed_migration_spec.rb

@@ -0,0 +1,78 @@
+RSpec.describe ZeroDowntimeMigrations::Validation::MixedMigration do
+  let(:error) { ZeroDowntimeMigrations::UnsafeMigrationError }
+
+  context "with a migration that adds a column and index" do
+    let(:migration) do
+      Class.new(ActiveRecord::Migration[5.0]) do
+        def change
+          add_column :users, :active, :boolean
+          add_index :users, :active
+        end
+      end
+    end
+
+    it "raises an unsafe migration error" do
+      expect { migration.migrate(:up) }.to raise_error(error)
+    end
+  end
+
+  context "with a migration that adds a column and queries data" do
+    let(:migration) do
+      Class.new(ActiveRecord::Migration[5.0]) do
+        def change
+          add_column :users, :active, :boolean
+          User.find_in_batches
+        end
+      end
+    end
+
+    it "raises an unsafe migration error" do
+      expect { migration.migrate(:up) }.to raise_error(error)
+    end
+  end
+
+  context "with a migration that adds a column and updates data" do
+    let(:migration) do
+      Class.new(ActiveRecord::Migration[5.0]) do
+        def change
+          add_column :users, :active, :boolean
+          User.update_all(active: true)
+        end
+      end
+    end
+
+    it "raises an unsafe migration error" do
+      expect { migration.migrate(:up) }.to raise_error(error)
+    end
+  end
+
+  context "with a migration that adds an index and updates data" do
+    let(:migration) do
+      Class.new(ActiveRecord::Migration[5.0]) do
+        def change
+          User.where(email: nil).delete_all
+          add_index :users, :created_at
+        end
+      end
+    end
+
+    it "raises an unsafe migration error" do
+      expect { migration.migrate(:up) }.to raise_error(error)
+    end
+  end
+
+  context "with a migration that adds a column and creates data" do
+    let(:migration) do
+      Class.new(ActiveRecord::Migration[5.0]) do
+        def change
+          add_column :users, :active, :boolean
+          User.new(email: "test").save!
+        end
+      end
+    end
+
+    it "raises an unsafe migration error" do
+      expect { migration.migrate(:up) }.to raise_error(error)
+    end
+  end
+end

data/spec/zero_downtime_migrations/validation_spec.rb

@@ -1,8 +1,8 @@
 RSpec.describe ZeroDowntimeMigrations::Validation do
-  subject { described_class.new(migration, args) }
+  subject { described_class.new(migration, *args) }
 
   let(:migration) { double("migration") }
-  let(:args) { double("args") }
+  let(:args) { [] }
 
   describe "#args" do
     it "returns the initialized args" do

data/zero_downtime_migrations.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |s|
   s.required_ruby_version = ">= 2.0.0"
   s.summary               = "Zero downtime migrations with ActiveRecord and PostgreSQL"
   s.test_files            = `git ls-files -- spec/*`.split("\n")
-  s.version               = "0.0.0"
+  s.version               = "0.0.1"
 
   s.add_dependency "activerecord"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zero_downtime_migrations
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors:
 - LendingHome
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-17 00:00:00.000000000 Z
+date: 2016-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -44,22 +44,33 @@ files:
 - bin/test
 - docker-compose.yml
 - lib/zero_downtime_migrations.rb
-- lib/zero_downtime_migrations/add_column.rb
-- lib/zero_downtime_migrations/add_index.rb
+- lib/zero_downtime_migrations/data.rb
+- lib/zero_downtime_migrations/dsl.rb
 - lib/zero_downtime_migrations/migration.rb
+- lib/zero_downtime_migrations/relation.rb
 - lib/zero_downtime_migrations/unsafe_migration_error.rb
 - lib/zero_downtime_migrations/validation.rb
+- lib/zero_downtime_migrations/validation/add_column.rb
+- lib/zero_downtime_migrations/validation/add_index.rb
+- lib/zero_downtime_migrations/validation/ddl_migration.rb
+- lib/zero_downtime_migrations/validation/mixed_migration.rb
+- spec/internal/app/models/post.rb
+- spec/internal/app/models/user.rb
 - spec/internal/config/database.yml
 - spec/internal/db/migrate/20161012223252_rollup_migrations.rb
 - spec/internal/db/migrate/20161012223253_safe_add_column_with_default.rb
 - spec/internal/db/migrate/20161012223254_safe_add_index.rb
 - spec/internal/db/migrate/20161012223255_safe_add_index_with_env.rb
-- spec/internal/db/migrate/20161012223256_add_index_concurrently.rb
+- spec/internal/db/migrate/20161012223256_safe_add_index_with_dsl.rb
+- spec/internal/db/migrate/20161012223257_add_index_concurrently.rb
 - spec/internal/db/schema.rb
 - spec/internal/log/.gitignore
 - spec/spec_helper.rb
-- spec/zero_downtime_migrations/add_column_spec.rb
-- spec/zero_downtime_migrations/add_index_spec.rb
+- spec/zero_downtime_migrations/relation_spec.rb
+- spec/zero_downtime_migrations/validation/add_column_spec.rb
+- spec/zero_downtime_migrations/validation/add_index_spec.rb
+- spec/zero_downtime_migrations/validation/ddl_migration_spec.rb
+- spec/zero_downtime_migrations/validation/mixed_migration_spec.rb
 - spec/zero_downtime_migrations/validation_spec.rb
 - spec/zero_downtime_migrations_spec.rb
 - zero_downtime_migrations.gemspec
@@ -93,16 +104,22 @@ signing_key:
 specification_version: 4
 summary: Zero downtime migrations with ActiveRecord and PostgreSQL
 test_files:
+- spec/internal/app/models/post.rb
+- spec/internal/app/models/user.rb
 - spec/internal/config/database.yml
 - spec/internal/db/migrate/20161012223252_rollup_migrations.rb
 - spec/internal/db/migrate/20161012223253_safe_add_column_with_default.rb
 - spec/internal/db/migrate/20161012223254_safe_add_index.rb
 - spec/internal/db/migrate/20161012223255_safe_add_index_with_env.rb
-- spec/internal/db/migrate/20161012223256_add_index_concurrently.rb
+- spec/internal/db/migrate/20161012223256_safe_add_index_with_dsl.rb
+- spec/internal/db/migrate/20161012223257_add_index_concurrently.rb
 - spec/internal/db/schema.rb
 - spec/internal/log/.gitignore
 - spec/spec_helper.rb
-- spec/zero_downtime_migrations/add_column_spec.rb
-- spec/zero_downtime_migrations/add_index_spec.rb
+- spec/zero_downtime_migrations/relation_spec.rb
+- spec/zero_downtime_migrations/validation/add_column_spec.rb
+- spec/zero_downtime_migrations/validation/add_index_spec.rb
+- spec/zero_downtime_migrations/validation/ddl_migration_spec.rb
+- spec/zero_downtime_migrations/validation/mixed_migration_spec.rb
 - spec/zero_downtime_migrations/validation_spec.rb
 - spec/zero_downtime_migrations_spec.rb

data/lib/zero_downtime_migrations/add_column.rb

@@ -1,91 +0,0 @@
-module ZeroDowntimeMigrations
-  class AddColumn < Validation
-    def validate!
-      return if options[:default].nil? # only nil is safe
-      message = "Adding a column with a default is unsafe!"
-      error!(message, correction)
-    end
-
-    private
-
-    def correction
-      <<-MESSAGE.strip_heredoc
-        This action can potentially lock your database table!
-
-        Instead, let's first add the column without a default.
-
-          class Add#{column_title}To#{table_title} < ActiveRecord::Migration
-            def change
-              add_column :#{table}, :#{column}, :#{column_type}
-            end
-          end
-
-        Then set the new column default in a separate migration. Note that
-        this does not update any existing data.
-
-          class AddDefault#{column_title}To#{table_title} < ActiveRecord::Migration
-            def change
-              change_column_default :#{table}, :#{column}, #{column_default}
-            end
-          end
-
-        If necessary then backport the default value for existing data in batches.
-        This should be done in its own migration as well.
-
-          class BackportDefault#{column_title}To#{table_title} < ActiveRecord::Migration
-            def change
-              #{table_model}.select(:id).find_in_batches.with_index do |records, index|
-                puts "Processing batch \#{index + 1}\\r"
-                #{table_model}.where(id: records).update_all(#{column}: #{column_default})
-              end
-            end
-          end
-
-        Note that in some cases it may not even be necessary to backport a default value.
-
-          class #{table_model} < ActiveRecord::Base
-            def #{column}
-              self["#{column}"] ||= #{column_default}
-            end
-          end
-
-        If you're 100% positive that this migration is already safe, then wrap the
-        call to `add_column` in a `safety_assured` block.
-
-          class Add#{column_title}To#{table_title} < ActiveRecord::Migration
-            def change
-              safety_assured { add_column :#{table}, :#{column}, :#{column_type}, default: #{column_default} }
-            end
-          end
-      MESSAGE
-    end
-
-    def column
-      args[1]
-    end
-
-    def column_default
-      options[:default].inspect
-    end
-
-    def column_title
-      column.to_s.camelize
-    end
-
-    def column_type
-      args[2]
-    end
-
-    def table
-      args[0]
-    end
-
-    def table_model
-      table_title.singularize
-    end
-
-    def table_title
-      table.to_s.camelize
-    end
-  end
-end

data/lib/zero_downtime_migrations/add_index.rb

@@ -1,57 +0,0 @@
-module ZeroDowntimeMigrations
-  class AddIndex < Validation
-    def validate!
-      return if concurrent? && migration.ddl_disabled?
-      message = "Adding a non-concurrent index is unsafe!"
-      error!(message, correction)
-    end
-
-    private
-
-    def correction
-      <<-MESSAGE.strip_heredoc
-        This action can potentially lock your database table!
-
-        Instead, let's add the index concurrently in its own migration with
-        the DDL transaction disabled.
-
-          class Index#{table_title}On#{column_title} < ActiveRecord::Migration
-            disable_ddl_transaction!
-
-            def change
-              add_index :#{table}, #{column.inspect}, algorithm: :concurrently
-            end
-          end
-
-        If you're 100% positive that this migration is already safe, then wrap the
-        call to `add_index` in a `safety_assured` block.
-
-          class Index#{table_title}On#{column_title} < ActiveRecord::Migration
-            def change
-              safety_assured { add_index :#{table}, #{column.inspect} }
-            end
-          end
-      MESSAGE
-    end
-
-    def concurrent?
-      options[:algorithm] == :concurrently
-    end
-
-    def column
-      args[1]
-    end
-
-    def column_title
-      Array(column).map(&:to_s).join("_and_").camelize
-    end
-
-    def table
-      args[0]
-    end
-
-    def table_title
-      table.to_s.camelize
-    end
-  end
-end