normalizes indentation and whitespace across the project

6 files changed, 402 insertions, 402 deletions

diff --git a/activerecord/test/cases/migration/change_schema_test.rb b/activerecord/test/cases/migration/change_schema_test.rb
index 7f6364bc57..0191c9d03b 100644
--- a/activerecord/test/cases/migration/change_schema_test.rb
+++ b/activerecord/test/cases/migration/change_schema_test.rb
@@ -415,13 +415,13 @@ module ActiveRecord
       end
 
       private
-      def testing_table_with_only_foo_attribute
-        connection.create_table :testings, id: false do |t|
-          t.column :foo, :string
-        end
+        def testing_table_with_only_foo_attribute
+          connection.create_table :testings, id: false do |t|
+            t.column :foo, :string
+          end
 
-        yield
-      end
+          yield
+        end
     end
 
     if ActiveRecord::Base.connection.supports_foreign_keys?
diff --git a/activerecord/test/cases/migration/columns_test.rb b/activerecord/test/cases/migration/columns_test.rb
index 95c3f51539..baf0a0eb9f 100644
--- a/activerecord/test/cases/migration/columns_test.rb
+++ b/activerecord/test/cases/migration/columns_test.rb
@@ -74,7 +74,7 @@ module ActiveRecord
 
       def test_rename_nonexistent_column
         exception = if current_adapter?(:PostgreSQLAdapter, :OracleAdapter)
-                      ActiveRecord::StatementInvalid
+          ActiveRecord::StatementInvalid
                     else
                       ActiveRecord::ActiveRecordError
                     end
diff --git a/activerecord/test/cases/migration/foreign_key_test.rb b/activerecord/test/cases/migration/foreign_key_test.rb
index b47df24b13..a9a3885e32 100644
--- a/activerecord/test/cases/migration/foreign_key_test.rb
+++ b/activerecord/test/cases/migration/foreign_key_test.rb
@@ -3,315 +3,315 @@ require "support/ddl_helper"
 require "support/schema_dumping_helper"
 
 if ActiveRecord::Base.connection.supports_foreign_keys?
-module ActiveRecord
-  class Migration
-    class ForeignKeyTest < ActiveRecord::TestCase
-      include DdlHelper
-      include SchemaDumpingHelper
-      include ActiveSupport::Testing::Stream
-
-      class Rocket < ActiveRecord::Base
-      end
-
-      class Astronaut < ActiveRecord::Base
-      end
-
-      setup do
-        @connection = ActiveRecord::Base.connection
-        @connection.create_table "rockets", force: true do |t|
-          t.string :name
+  module ActiveRecord
+    class Migration
+      class ForeignKeyTest < ActiveRecord::TestCase
+        include DdlHelper
+        include SchemaDumpingHelper
+        include ActiveSupport::Testing::Stream
+
+        class Rocket < ActiveRecord::Base
         end
 
-        @connection.create_table "astronauts", force: true do |t|
-          t.string :name
-          t.references :rocket
+        class Astronaut < ActiveRecord::Base
         end
-      end
 
-      teardown do
-        if defined?(@connection)
-          @connection.drop_table "astronauts", if_exists: true
-          @connection.drop_table "rockets", if_exists: true
-        end
-      end
-
-      def test_foreign_keys
-        foreign_keys = @connection.foreign_keys("fk_test_has_fk")
-        assert_equal 1, foreign_keys.size
+        setup do
+          @connection = ActiveRecord::Base.connection
+          @connection.create_table "rockets", force: true do |t|
+            t.string :name
+          end
 
-        fk = foreign_keys.first
-        assert_equal "fk_test_has_fk", fk.from_table
-        assert_equal "fk_test_has_pk", fk.to_table
-        assert_equal "fk_id", fk.column
-        assert_equal "pk_id", fk.primary_key
-        assert_equal "fk_name", fk.name
-      end
+          @connection.create_table "astronauts", force: true do |t|
+            t.string :name
+            t.references :rocket
+          end
+        end
 
-      def test_add_foreign_key_inferes_column
-        @connection.add_foreign_key :astronauts, :rockets
+        teardown do
+          if defined?(@connection)
+            @connection.drop_table "astronauts", if_exists: true
+            @connection.drop_table "rockets", if_exists: true
+          end
+        end
 
-        foreign_keys = @connection.foreign_keys("astronauts")
-        assert_equal 1, foreign_keys.size
+        def test_foreign_keys
+          foreign_keys = @connection.foreign_keys("fk_test_has_fk")
+          assert_equal 1, foreign_keys.size
 
-        fk = foreign_keys.first
-        assert_equal "astronauts", fk.from_table
-        assert_equal "rockets", fk.to_table
-        assert_equal "rocket_id", fk.column
-        assert_equal "id", fk.primary_key
-        assert_equal("fk_rails_78146ddd2e", fk.name)
-      end
+          fk = foreign_keys.first
+          assert_equal "fk_test_has_fk", fk.from_table
+          assert_equal "fk_test_has_pk", fk.to_table
+          assert_equal "fk_id", fk.column
+          assert_equal "pk_id", fk.primary_key
+          assert_equal "fk_name", fk.name
+        end
 
-      def test_add_foreign_key_with_column
-        @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id"
+        def test_add_foreign_key_inferes_column
+          @connection.add_foreign_key :astronauts, :rockets
 
-        foreign_keys = @connection.foreign_keys("astronauts")
-        assert_equal 1, foreign_keys.size
+          foreign_keys = @connection.foreign_keys("astronauts")
+          assert_equal 1, foreign_keys.size
 
-        fk = foreign_keys.first
-        assert_equal "astronauts", fk.from_table
-        assert_equal "rockets", fk.to_table
-        assert_equal "rocket_id", fk.column
-        assert_equal "id", fk.primary_key
-        assert_equal("fk_rails_78146ddd2e", fk.name)
-      end
+          fk = foreign_keys.first
+          assert_equal "astronauts", fk.from_table
+          assert_equal "rockets", fk.to_table
+          assert_equal "rocket_id", fk.column
+          assert_equal "id", fk.primary_key
+          assert_equal("fk_rails_78146ddd2e", fk.name)
+        end
 
-      def test_add_foreign_key_with_non_standard_primary_key
-        with_example_table @connection, "space_shuttles", "pk integer PRIMARY KEY" do
-          @connection.add_foreign_key(:astronauts, :space_shuttles,
-                                      column: "rocket_id", primary_key: "pk", name: "custom_pk")
+        def test_add_foreign_key_with_column
+          @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id"
 
           foreign_keys = @connection.foreign_keys("astronauts")
           assert_equal 1, foreign_keys.size
 
           fk = foreign_keys.first
           assert_equal "astronauts", fk.from_table
-          assert_equal "space_shuttles", fk.to_table
-          assert_equal "pk", fk.primary_key
-
-          @connection.remove_foreign_key :astronauts, name: "custom_pk"
+          assert_equal "rockets", fk.to_table
+          assert_equal "rocket_id", fk.column
+          assert_equal "id", fk.primary_key
+          assert_equal("fk_rails_78146ddd2e", fk.name)
         end
-      end
 
-      def test_add_on_delete_restrict_foreign_key
-        @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_delete: :restrict
+        def test_add_foreign_key_with_non_standard_primary_key
+          with_example_table @connection, "space_shuttles", "pk integer PRIMARY KEY" do
+            @connection.add_foreign_key(:astronauts, :space_shuttles,
+                                        column: "rocket_id", primary_key: "pk", name: "custom_pk")
+
+            foreign_keys = @connection.foreign_keys("astronauts")
+            assert_equal 1, foreign_keys.size
 
-        foreign_keys = @connection.foreign_keys("astronauts")
-        assert_equal 1, foreign_keys.size
+            fk = foreign_keys.first
+            assert_equal "astronauts", fk.from_table
+            assert_equal "space_shuttles", fk.to_table
+            assert_equal "pk", fk.primary_key
 
-        fk = foreign_keys.first
-        if current_adapter?(:Mysql2Adapter)
-          # ON DELETE RESTRICT is the default on MySQL
-          assert_equal nil, fk.on_delete
-        else
-          assert_equal :restrict, fk.on_delete
+            @connection.remove_foreign_key :astronauts, name: "custom_pk"
+          end
         end
-      end
 
-      def test_add_on_delete_cascade_foreign_key
-        @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_delete: :cascade
+        def test_add_on_delete_restrict_foreign_key
+          @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_delete: :restrict
 
-        foreign_keys = @connection.foreign_keys("astronauts")
-        assert_equal 1, foreign_keys.size
+          foreign_keys = @connection.foreign_keys("astronauts")
+          assert_equal 1, foreign_keys.size
 
-        fk = foreign_keys.first
-        assert_equal :cascade, fk.on_delete
-      end
+          fk = foreign_keys.first
+          if current_adapter?(:Mysql2Adapter)
+            # ON DELETE RESTRICT is the default on MySQL
+            assert_equal nil, fk.on_delete
+          else
+            assert_equal :restrict, fk.on_delete
+          end
+        end
 
-      def test_add_on_delete_nullify_foreign_key
-        @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_delete: :nullify
+        def test_add_on_delete_cascade_foreign_key
+          @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_delete: :cascade
 
-        foreign_keys = @connection.foreign_keys("astronauts")
-        assert_equal 1, foreign_keys.size
+          foreign_keys = @connection.foreign_keys("astronauts")
+          assert_equal 1, foreign_keys.size
 
-        fk = foreign_keys.first
-        assert_equal :nullify, fk.on_delete
-      end
+          fk = foreign_keys.first
+          assert_equal :cascade, fk.on_delete
+        end
+
+        def test_add_on_delete_nullify_foreign_key
+          @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_delete: :nullify
+
+          foreign_keys = @connection.foreign_keys("astronauts")
+          assert_equal 1, foreign_keys.size
 
-      def test_on_update_and_on_delete_raises_with_invalid_values
-        assert_raises ArgumentError do
-          @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_delete: :invalid
+          fk = foreign_keys.first
+          assert_equal :nullify, fk.on_delete
         end
 
-        assert_raises ArgumentError do
-          @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_update: :invalid
+        def test_on_update_and_on_delete_raises_with_invalid_values
+          assert_raises ArgumentError do
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_delete: :invalid
+          end
+
+          assert_raises ArgumentError do
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_update: :invalid
+          end
         end
-      end
 
-      def test_add_foreign_key_with_on_update
-        @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_update: :nullify
+        def test_add_foreign_key_with_on_update
+          @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_update: :nullify
+
+          foreign_keys = @connection.foreign_keys("astronauts")
+          assert_equal 1, foreign_keys.size
 
-        foreign_keys = @connection.foreign_keys("astronauts")
-        assert_equal 1, foreign_keys.size
+          fk = foreign_keys.first
+          assert_equal :nullify, fk.on_update
+        end
 
-        fk = foreign_keys.first
-        assert_equal :nullify, fk.on_update
-      end
+        def test_foreign_key_exists
+          @connection.add_foreign_key :astronauts, :rockets
 
-      def test_foreign_key_exists
-        @connection.add_foreign_key :astronauts, :rockets
+          assert @connection.foreign_key_exists?(:astronauts, :rockets)
+          assert_not @connection.foreign_key_exists?(:astronauts, :stars)
+        end
 
-        assert @connection.foreign_key_exists?(:astronauts, :rockets)
-        assert_not @connection.foreign_key_exists?(:astronauts, :stars)
-      end
+        def test_foreign_key_exists_by_column
+          @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id"
 
-      def test_foreign_key_exists_by_column
-        @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id"
+          assert @connection.foreign_key_exists?(:astronauts, column: "rocket_id")
+          assert_not @connection.foreign_key_exists?(:astronauts, column: "star_id")
+        end
 
-        assert @connection.foreign_key_exists?(:astronauts, column: "rocket_id")
-        assert_not @connection.foreign_key_exists?(:astronauts, column: "star_id")
-      end
+        def test_foreign_key_exists_by_name
+          @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", name: "fancy_named_fk"
 
-      def test_foreign_key_exists_by_name
-        @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", name: "fancy_named_fk"
+          assert @connection.foreign_key_exists?(:astronauts, name: "fancy_named_fk")
+          assert_not @connection.foreign_key_exists?(:astronauts, name: "other_fancy_named_fk")
+        end
 
-        assert @connection.foreign_key_exists?(:astronauts, name: "fancy_named_fk")
-        assert_not @connection.foreign_key_exists?(:astronauts, name: "other_fancy_named_fk")
-      end
+        def test_remove_foreign_key_inferes_column
+          @connection.add_foreign_key :astronauts, :rockets
 
-      def test_remove_foreign_key_inferes_column
-        @connection.add_foreign_key :astronauts, :rockets
+          assert_equal 1, @connection.foreign_keys("astronauts").size
+          @connection.remove_foreign_key :astronauts, :rockets
+          assert_equal [], @connection.foreign_keys("astronauts")
+        end
 
-        assert_equal 1, @connection.foreign_keys("astronauts").size
-        @connection.remove_foreign_key :astronauts, :rockets
-        assert_equal [], @connection.foreign_keys("astronauts")
-      end
+        def test_remove_foreign_key_by_column
+          @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id"
 
-      def test_remove_foreign_key_by_column
-        @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id"
+          assert_equal 1, @connection.foreign_keys("astronauts").size
+          @connection.remove_foreign_key :astronauts, column: "rocket_id"
+          assert_equal [], @connection.foreign_keys("astronauts")
+        end
 
-        assert_equal 1, @connection.foreign_keys("astronauts").size
-        @connection.remove_foreign_key :astronauts, column: "rocket_id"
-        assert_equal [], @connection.foreign_keys("astronauts")
-      end
+        def test_remove_foreign_key_by_symbol_column
+          @connection.add_foreign_key :astronauts, :rockets, column: :rocket_id
 
-      def test_remove_foreign_key_by_symbol_column
-        @connection.add_foreign_key :astronauts, :rockets, column: :rocket_id
+          assert_equal 1, @connection.foreign_keys("astronauts").size
+          @connection.remove_foreign_key :astronauts, column: :rocket_id
+          assert_equal [], @connection.foreign_keys("astronauts")
+        end
 
-        assert_equal 1, @connection.foreign_keys("astronauts").size
-        @connection.remove_foreign_key :astronauts, column: :rocket_id
-        assert_equal [], @connection.foreign_keys("astronauts")
-      end
+        def test_remove_foreign_key_by_name
+          @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", name: "fancy_named_fk"
 
-      def test_remove_foreign_key_by_name
-        @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", name: "fancy_named_fk"
+          assert_equal 1, @connection.foreign_keys("astronauts").size
+          @connection.remove_foreign_key :astronauts, name: "fancy_named_fk"
+          assert_equal [], @connection.foreign_keys("astronauts")
+        end
 
-        assert_equal 1, @connection.foreign_keys("astronauts").size
-        @connection.remove_foreign_key :astronauts, name: "fancy_named_fk"
-        assert_equal [], @connection.foreign_keys("astronauts")
-      end
+        def test_remove_foreign_non_existing_foreign_key_raises
+          assert_raises ArgumentError do
+            @connection.remove_foreign_key :astronauts, :rockets
+          end
+        end
 
-      def test_remove_foreign_non_existing_foreign_key_raises
-        assert_raises ArgumentError do
-          @connection.remove_foreign_key :astronauts, :rockets
+        def test_schema_dumping
+          @connection.add_foreign_key :astronauts, :rockets
+          output = dump_table_schema "astronauts"
+          assert_match %r{\s+add_foreign_key "astronauts", "rockets"$}, output
         end
-      end
 
-      def test_schema_dumping
-        @connection.add_foreign_key :astronauts, :rockets
-        output = dump_table_schema "astronauts"
-        assert_match %r{\s+add_foreign_key "astronauts", "rockets"$}, output
-      end
+        def test_schema_dumping_with_options
+          output = dump_table_schema "fk_test_has_fk"
+          assert_match %r{\s+add_foreign_key "fk_test_has_fk", "fk_test_has_pk", column: "fk_id", primary_key: "pk_id", name: "fk_name"$}, output
+        end
 
-      def test_schema_dumping_with_options
-        output = dump_table_schema "fk_test_has_fk"
-        assert_match %r{\s+add_foreign_key "fk_test_has_fk", "fk_test_has_pk", column: "fk_id", primary_key: "pk_id", name: "fk_name"$}, output
-      end
+        def test_schema_dumping_on_delete_and_on_update_options
+          @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_delete: :nullify, on_update: :cascade
 
-      def test_schema_dumping_on_delete_and_on_update_options
-        @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_delete: :nullify, on_update: :cascade
+          output = dump_table_schema "astronauts"
+          assert_match %r{\s+add_foreign_key "astronauts",.+on_update: :cascade,.+on_delete: :nullify$}, output
+        end
 
-        output = dump_table_schema "astronauts"
-        assert_match %r{\s+add_foreign_key "astronauts",.+on_update: :cascade,.+on_delete: :nullify$}, output
-      end
+        class CreateCitiesAndHousesMigration < ActiveRecord::Migration::Current
+          def change
+            create_table("cities") { |t| }
 
-      class CreateCitiesAndHousesMigration < ActiveRecord::Migration::Current
-        def change
-          create_table("cities") { |t| }
+            create_table("houses") do |t|
+              t.column :city_id, :integer
+            end
+            add_foreign_key :houses, :cities, column: "city_id"
 
-          create_table("houses") do |t|
-            t.column :city_id, :integer
+            # remove and re-add to test that schema is updated and not accidentally cached
+            remove_foreign_key :houses, :cities
+            add_foreign_key :houses, :cities, column: "city_id", on_delete: :cascade
           end
-          add_foreign_key :houses, :cities, column: "city_id"
-
-          # remove and re-add to test that schema is updated and not accidentally cached
-          remove_foreign_key :houses, :cities
-          add_foreign_key :houses, :cities, column: "city_id", on_delete: :cascade
         end
-      end
 
-      def test_add_foreign_key_is_reversible
-        migration = CreateCitiesAndHousesMigration.new
-        silence_stream($stdout) { migration.migrate(:up) }
-        assert_equal 1, @connection.foreign_keys("houses").size
-      ensure
-        silence_stream($stdout) { migration.migrate(:down) }
-      end
+        def test_add_foreign_key_is_reversible
+          migration = CreateCitiesAndHousesMigration.new
+          silence_stream($stdout) { migration.migrate(:up) }
+          assert_equal 1, @connection.foreign_keys("houses").size
+        ensure
+          silence_stream($stdout) { migration.migrate(:down) }
+        end
 
-      def test_foreign_key_constraint_is_not_cached_incorrectly
-        migration = CreateCitiesAndHousesMigration.new
-        silence_stream($stdout) { migration.migrate(:up) }
-        output = dump_table_schema "houses"
-        assert_match %r{\s+add_foreign_key "houses",.+on_delete: :cascade$}, output
-      ensure
-        silence_stream($stdout) { migration.migrate(:down) }
-      end
+        def test_foreign_key_constraint_is_not_cached_incorrectly
+          migration = CreateCitiesAndHousesMigration.new
+          silence_stream($stdout) { migration.migrate(:up) }
+          output = dump_table_schema "houses"
+          assert_match %r{\s+add_foreign_key "houses",.+on_delete: :cascade$}, output
+        ensure
+          silence_stream($stdout) { migration.migrate(:down) }
+        end
 
-      class CreateSchoolsAndClassesMigration < ActiveRecord::Migration::Current
-        def change
-          create_table(:schools)
+        class CreateSchoolsAndClassesMigration < ActiveRecord::Migration::Current
+          def change
+            create_table(:schools)
 
-          create_table(:classes) do |t|
-            t.column :school_id, :integer
+            create_table(:classes) do |t|
+              t.column :school_id, :integer
+            end
+            add_foreign_key :classes, :schools
           end
-          add_foreign_key :classes, :schools
         end
-      end
 
-      def test_add_foreign_key_with_prefix
-        ActiveRecord::Base.table_name_prefix = "p_"
-        migration = CreateSchoolsAndClassesMigration.new
-        silence_stream($stdout) { migration.migrate(:up) }
-        assert_equal 1, @connection.foreign_keys("p_classes").size
-      ensure
-        silence_stream($stdout) { migration.migrate(:down) }
-        ActiveRecord::Base.table_name_prefix = nil
-      end
+        def test_add_foreign_key_with_prefix
+          ActiveRecord::Base.table_name_prefix = "p_"
+          migration = CreateSchoolsAndClassesMigration.new
+          silence_stream($stdout) { migration.migrate(:up) }
+          assert_equal 1, @connection.foreign_keys("p_classes").size
+        ensure
+          silence_stream($stdout) { migration.migrate(:down) }
+          ActiveRecord::Base.table_name_prefix = nil
+        end
 
-      def test_add_foreign_key_with_suffix
-        ActiveRecord::Base.table_name_suffix = "_s"
-        migration = CreateSchoolsAndClassesMigration.new
-        silence_stream($stdout) { migration.migrate(:up) }
-        assert_equal 1, @connection.foreign_keys("classes_s").size
-      ensure
-        silence_stream($stdout) { migration.migrate(:down) }
-        ActiveRecord::Base.table_name_suffix = nil
-      end
+        def test_add_foreign_key_with_suffix
+          ActiveRecord::Base.table_name_suffix = "_s"
+          migration = CreateSchoolsAndClassesMigration.new
+          silence_stream($stdout) { migration.migrate(:up) }
+          assert_equal 1, @connection.foreign_keys("classes_s").size
+        ensure
+          silence_stream($stdout) { migration.migrate(:down) }
+          ActiveRecord::Base.table_name_suffix = nil
+        end
 
+      end
     end
   end
-end
 else
-module ActiveRecord
-  class Migration
-    class NoForeignKeySupportTest < ActiveRecord::TestCase
-      setup do
-        @connection = ActiveRecord::Base.connection
-      end
+  module ActiveRecord
+    class Migration
+      class NoForeignKeySupportTest < ActiveRecord::TestCase
+        setup do
+          @connection = ActiveRecord::Base.connection
+        end
 
-      def test_add_foreign_key_should_be_noop
-        @connection.add_foreign_key :clubs, :categories
-      end
+        def test_add_foreign_key_should_be_noop
+          @connection.add_foreign_key :clubs, :categories
+        end
 
-      def test_remove_foreign_key_should_be_noop
-        @connection.remove_foreign_key :clubs, :categories
-      end
+        def test_remove_foreign_key_should_be_noop
+          @connection.remove_foreign_key :clubs, :categories
+        end
 
-      def test_foreign_keys_should_raise_not_implemented
-        assert_raises NotImplementedError do
-          @connection.foreign_keys("clubs")
+        def test_foreign_keys_should_raise_not_implemented
+          assert_raises NotImplementedError do
+            @connection.foreign_keys("clubs")
+          end
         end
       end
     end
   end
 end
-end
diff --git a/activerecord/test/cases/migration/helper.rb b/activerecord/test/cases/migration/helper.rb
index ad85684c0b..9c0fa7339d 100644
--- a/activerecord/test/cases/migration/helper.rb
+++ b/activerecord/test/cases/migration/helper.rb
@@ -33,7 +33,7 @@ module ActiveRecord
 
       private
 
-      delegate(*CONNECTION_METHODS, to: :connection)
+        delegate(*CONNECTION_METHODS, to: :connection)
     end
   end
 end
diff --git a/activerecord/test/cases/migration/references_foreign_key_test.rb b/activerecord/test/cases/migration/references_foreign_key_test.rb
index 992d003e7e..8436435170 100644
--- a/activerecord/test/cases/migration/references_foreign_key_test.rb
+++ b/activerecord/test/cases/migration/references_foreign_key_test.rb
@@ -1,216 +1,216 @@
 require "cases/helper"
 
 if ActiveRecord::Base.connection.supports_foreign_keys?
-module ActiveRecord
-  class Migration
-    class ReferencesForeignKeyTest < ActiveRecord::TestCase
-      setup do
-        @connection = ActiveRecord::Base.connection
-        @connection.create_table(:testing_parents, force: true)
-      end
-
-      teardown do
-        @connection.drop_table "testings", if_exists: true
-        @connection.drop_table "testing_parents", if_exists: true
-      end
+  module ActiveRecord
+    class Migration
+      class ReferencesForeignKeyTest < ActiveRecord::TestCase
+        setup do
+          @connection = ActiveRecord::Base.connection
+          @connection.create_table(:testing_parents, force: true)
+        end
 
-      test "foreign keys can be created with the table" do
-        @connection.create_table :testings do |t|
-          t.references :testing_parent, foreign_key: true
+        teardown do
+          @connection.drop_table "testings", if_exists: true
+          @connection.drop_table "testing_parents", if_exists: true
         end
 
-        fk = @connection.foreign_keys("testings").first
-        assert_equal "testings", fk.from_table
-        assert_equal "testing_parents", fk.to_table
-      end
+        test "foreign keys can be created with the table" do
+          @connection.create_table :testings do |t|
+            t.references :testing_parent, foreign_key: true
+          end
 
-      test "no foreign key is created by default" do
-        @connection.create_table :testings do |t|
-          t.references :testing_parent
+          fk = @connection.foreign_keys("testings").first
+          assert_equal "testings", fk.from_table
+          assert_equal "testing_parents", fk.to_table
         end
 
-        assert_equal [], @connection.foreign_keys("testings")
-      end
-
-      test "foreign keys can be created in one query when index is not added" do
-        assert_queries(1) do
+        test "no foreign key is created by default" do
           @connection.create_table :testings do |t|
-            t.references :testing_parent, foreign_key: true, index: false
+            t.references :testing_parent
           end
-        end
-      end
 
-      test "options hash can be passed" do
-        @connection.change_table :testing_parents do |t|
-          t.integer :other_id
-          t.index :other_id, unique: true
+          assert_equal [], @connection.foreign_keys("testings")
         end
-        @connection.create_table :testings do |t|
-          t.references :testing_parent, foreign_key: { primary_key: :other_id }
+
+        test "foreign keys can be created in one query when index is not added" do
+          assert_queries(1) do
+            @connection.create_table :testings do |t|
+              t.references :testing_parent, foreign_key: true, index: false
+            end
+          end
         end
 
-        fk = @connection.foreign_keys("testings").find { |k| k.to_table == "testing_parents" }
-        assert_equal "other_id", fk.primary_key
-      end
+        test "options hash can be passed" do
+          @connection.change_table :testing_parents do |t|
+            t.integer :other_id
+            t.index :other_id, unique: true
+          end
+          @connection.create_table :testings do |t|
+            t.references :testing_parent, foreign_key: { primary_key: :other_id }
+          end
 
-      test "to_table option can be passed" do
-        @connection.create_table :testings do |t|
-          t.references :parent, foreign_key: { to_table: :testing_parents }
+          fk = @connection.foreign_keys("testings").find { |k| k.to_table == "testing_parents" }
+          assert_equal "other_id", fk.primary_key
         end
-        fks = @connection.foreign_keys("testings")
-        assert_equal([["testings", "testing_parents", "parent_id"]],
-                     fks.map {|fk| [fk.from_table, fk.to_table, fk.column] })
-      end
 
-      test "foreign keys cannot be added to polymorphic relations when creating the table" do
-        @connection.create_table :testings do |t|
-          assert_raises(ArgumentError) do
-            t.references :testing_parent, polymorphic: true, foreign_key: true
+        test "to_table option can be passed" do
+          @connection.create_table :testings do |t|
+            t.references :parent, foreign_key: { to_table: :testing_parents }
           end
+          fks = @connection.foreign_keys("testings")
+          assert_equal([["testings", "testing_parents", "parent_id"]],
+                       fks.map {|fk| [fk.from_table, fk.to_table, fk.column] })
         end
-      end
 
-      test "foreign keys can be created while changing the table" do
-        @connection.create_table :testings
-        @connection.change_table :testings do |t|
-          t.references :testing_parent, foreign_key: true
+        test "foreign keys cannot be added to polymorphic relations when creating the table" do
+          @connection.create_table :testings do |t|
+            assert_raises(ArgumentError) do
+              t.references :testing_parent, polymorphic: true, foreign_key: true
+            end
+          end
         end
 
-        fk = @connection.foreign_keys("testings").first
-        assert_equal "testings", fk.from_table
-        assert_equal "testing_parents", fk.to_table
-      end
+        test "foreign keys can be created while changing the table" do
+          @connection.create_table :testings
+          @connection.change_table :testings do |t|
+            t.references :testing_parent, foreign_key: true
+          end
 
-      test "foreign keys are not added by default when changing the table" do
-        @connection.create_table :testings
-        @connection.change_table :testings do |t|
-          t.references :testing_parent
+          fk = @connection.foreign_keys("testings").first
+          assert_equal "testings", fk.from_table
+          assert_equal "testing_parents", fk.to_table
         end
 
-        assert_equal [], @connection.foreign_keys("testings")
-      end
+        test "foreign keys are not added by default when changing the table" do
+          @connection.create_table :testings
+          @connection.change_table :testings do |t|
+            t.references :testing_parent
+          end
 
-      test "foreign keys accept options when changing the table" do
-        @connection.change_table :testing_parents do |t|
-          t.integer :other_id
-          t.index :other_id, unique: true
-        end
-        @connection.create_table :testings
-        @connection.change_table :testings do |t|
-          t.references :testing_parent, foreign_key: { primary_key: :other_id }
+          assert_equal [], @connection.foreign_keys("testings")
         end
 
-        fk = @connection.foreign_keys("testings").find { |k| k.to_table == "testing_parents" }
-        assert_equal "other_id", fk.primary_key
-      end
-
-      test "foreign keys cannot be added to polymorphic relations when changing the table" do
-        @connection.create_table :testings
-        @connection.change_table :testings do |t|
-          assert_raises(ArgumentError) do
-            t.references :testing_parent, polymorphic: true, foreign_key: true
+        test "foreign keys accept options when changing the table" do
+          @connection.change_table :testing_parents do |t|
+            t.integer :other_id
+            t.index :other_id, unique: true
+          end
+          @connection.create_table :testings
+          @connection.change_table :testings do |t|
+            t.references :testing_parent, foreign_key: { primary_key: :other_id }
           end
-        end
-      end
 
-      test "foreign key column can be removed" do
-        @connection.create_table :testings do |t|
-          t.references :testing_parent, index: true, foreign_key: true
+          fk = @connection.foreign_keys("testings").find { |k| k.to_table == "testing_parents" }
+          assert_equal "other_id", fk.primary_key
         end
 
-        assert_difference "@connection.foreign_keys('testings').size", -1 do
-          @connection.remove_reference :testings, :testing_parent, foreign_key: true
+        test "foreign keys cannot be added to polymorphic relations when changing the table" do
+          @connection.create_table :testings
+          @connection.change_table :testings do |t|
+            assert_raises(ArgumentError) do
+              t.references :testing_parent, polymorphic: true, foreign_key: true
+            end
+          end
         end
-      end
 
-      test "foreign key methods respect pluralize_table_names" do
-        begin
-          original_pluralize_table_names = ActiveRecord::Base.pluralize_table_names
-          ActiveRecord::Base.pluralize_table_names = false
-          @connection.create_table :testing
-          @connection.change_table :testing_parents do |t|
-            t.references :testing, foreign_key: true
+        test "foreign key column can be removed" do
+          @connection.create_table :testings do |t|
+            t.references :testing_parent, index: true, foreign_key: true
           end
 
-          fk = @connection.foreign_keys("testing_parents").first
-          assert_equal "testing_parents", fk.from_table
-          assert_equal "testing", fk.to_table
+          assert_difference "@connection.foreign_keys('testings').size", -1 do
+            @connection.remove_reference :testings, :testing_parent, foreign_key: true
+          end
+        end
 
-          assert_difference "@connection.foreign_keys('testing_parents').size", -1 do
-            @connection.remove_reference :testing_parents, :testing, foreign_key: true
+        test "foreign key methods respect pluralize_table_names" do
+          begin
+            original_pluralize_table_names = ActiveRecord::Base.pluralize_table_names
+            ActiveRecord::Base.pluralize_table_names = false
+            @connection.create_table :testing
+            @connection.change_table :testing_parents do |t|
+              t.references :testing, foreign_key: true
+            end
+
+            fk = @connection.foreign_keys("testing_parents").first
+            assert_equal "testing_parents", fk.from_table
+            assert_equal "testing", fk.to_table
+
+            assert_difference "@connection.foreign_keys('testing_parents').size", -1 do
+              @connection.remove_reference :testing_parents, :testing, foreign_key: true
+            end
+          ensure
+            ActiveRecord::Base.pluralize_table_names = original_pluralize_table_names
+            @connection.drop_table "testing", if_exists: true
           end
-        ensure
-          ActiveRecord::Base.pluralize_table_names = original_pluralize_table_names
-          @connection.drop_table "testing", if_exists: true
         end
-      end
 
-      class CreateDogsMigration < ActiveRecord::Migration::Current
-        def change
-          create_table :dog_owners
+        class CreateDogsMigration < ActiveRecord::Migration::Current
+          def change
+            create_table :dog_owners
 
-          create_table :dogs do |t|
-            t.references :dog_owner, foreign_key: true
+            create_table :dogs do |t|
+              t.references :dog_owner, foreign_key: true
+            end
           end
         end
-      end
 
-      def test_references_foreign_key_with_prefix
-        ActiveRecord::Base.table_name_prefix = "p_"
-        migration = CreateDogsMigration.new
-        silence_stream($stdout) { migration.migrate(:up) }
-        assert_equal 1, @connection.foreign_keys("p_dogs").size
-      ensure
-        silence_stream($stdout) { migration.migrate(:down) }
-        ActiveRecord::Base.table_name_prefix = nil
-      end
+        def test_references_foreign_key_with_prefix
+          ActiveRecord::Base.table_name_prefix = "p_"
+          migration = CreateDogsMigration.new
+          silence_stream($stdout) { migration.migrate(:up) }
+          assert_equal 1, @connection.foreign_keys("p_dogs").size
+        ensure
+          silence_stream($stdout) { migration.migrate(:down) }
+          ActiveRecord::Base.table_name_prefix = nil
+        end
 
-      def test_references_foreign_key_with_suffix
-        ActiveRecord::Base.table_name_suffix = "_s"
-        migration = CreateDogsMigration.new
-        silence_stream($stdout) { migration.migrate(:up) }
-        assert_equal 1, @connection.foreign_keys("dogs_s").size
-      ensure
-        silence_stream($stdout) { migration.migrate(:down) }
-        ActiveRecord::Base.table_name_suffix = nil
-      end
+        def test_references_foreign_key_with_suffix
+          ActiveRecord::Base.table_name_suffix = "_s"
+          migration = CreateDogsMigration.new
+          silence_stream($stdout) { migration.migrate(:up) }
+          assert_equal 1, @connection.foreign_keys("dogs_s").size
+        ensure
+          silence_stream($stdout) { migration.migrate(:down) }
+          ActiveRecord::Base.table_name_suffix = nil
+        end
 
-      test "multiple foreign keys can be added to the same table" do
-        @connection.create_table :testings do |t|
-          t.integer :col_1
-          t.integer :col_2
+        test "multiple foreign keys can be added to the same table" do
+          @connection.create_table :testings do |t|
+            t.integer :col_1
+            t.integer :col_2
 
-          t.foreign_key :testing_parents, column: :col_1
-          t.foreign_key :testing_parents, column: :col_2
-        end
+            t.foreign_key :testing_parents, column: :col_1
+            t.foreign_key :testing_parents, column: :col_2
+          end
 
-        fks = @connection.foreign_keys("testings")
+          fks = @connection.foreign_keys("testings")
 
-        fk_definitions = fks.map {|fk| [fk.from_table, fk.to_table, fk.column] }
-        assert_equal([["testings", "testing_parents", "col_1"],
-                      ["testings", "testing_parents", "col_2"]], fk_definitions)
+          fk_definitions = fks.map {|fk| [fk.from_table, fk.to_table, fk.column] }
+          assert_equal([["testings", "testing_parents", "col_1"],
+                        ["testings", "testing_parents", "col_2"]], fk_definitions)
+        end
       end
     end
   end
-end
 else
-class ReferencesWithoutForeignKeySupportTest < ActiveRecord::TestCase
-  setup do
-    @connection = ActiveRecord::Base.connection
-    @connection.create_table(:testing_parents, force: true)
-  end
-
-  teardown do
-    @connection.drop_table("testings", if_exists: true)
-    @connection.drop_table("testing_parents", if_exists: true)
-  end
+  class ReferencesWithoutForeignKeySupportTest < ActiveRecord::TestCase
+    setup do
+      @connection = ActiveRecord::Base.connection
+      @connection.create_table(:testing_parents, force: true)
+    end
 
-  test "ignores foreign keys defined with the table" do
-    @connection.create_table :testings do |t|
-      t.references :testing_parent, foreign_key: true
+    teardown do
+      @connection.drop_table("testings", if_exists: true)
+      @connection.drop_table("testing_parents", if_exists: true)
     end
 
-    assert_includes @connection.data_sources, "testings"
+    test "ignores foreign keys defined with the table" do
+      @connection.create_table :testings do |t|
+        t.references :testing_parent, foreign_key: true
+      end
+
+      assert_includes @connection.data_sources, "testings"
+    end
   end
 end
-end
diff --git a/activerecord/test/cases/migration/references_statements_test.rb b/activerecord/test/cases/migration/references_statements_test.rb
index 8d0acaaa6e..8fbe60f24e 100644
--- a/activerecord/test/cases/migration/references_statements_test.rb
+++ b/activerecord/test/cases/migration/references_statements_test.rb
@@ -110,12 +110,12 @@ module ActiveRecord
 
       private
 
-      def with_polymorphic_column
-        add_column table_name, :supplier_type, :string
-        add_index table_name, [:supplier_id, :supplier_type]
+        def with_polymorphic_column
+          add_column table_name, :supplier_type, :string
+          add_index table_name, [:supplier_id, :supplier_type]
 
-        yield
-      end
+          yield
+        end
     end
   end
 end