modernizes hash syntax in activerecord

8 files changed, 122 insertions, 122 deletions

diff --git a/activerecord/test/cases/migration/change_schema_test.rb b/activerecord/test/cases/migration/change_schema_test.rb
index 974a0ea8e2..7f6364bc57 100644
--- a/activerecord/test/cases/migration/change_schema_test.rb
+++ b/activerecord/test/cases/migration/change_schema_test.rb
@@ -40,7 +40,7 @@ module ActiveRecord
 
       def test_create_table_with_not_null_column
         connection.create_table :testings do |t|
-          t.column :foo, :string, :null => false
+          t.column :foo, :string, null: false
         end
 
         assert_raises(ActiveRecord::StatementInvalid) do
@@ -53,11 +53,11 @@ module ActiveRecord
         mysql = current_adapter?(:Mysql2Adapter)
 
         connection.create_table :testings do |t|
-          t.column :one, :string, :default => "hello"
-          t.column :two, :boolean, :default => true
-          t.column :three, :boolean, :default => false
-          t.column :four, :integer, :default => 1
-          t.column :five, :text, :default => "hello" unless mysql
+          t.column :one, :string, default: "hello"
+          t.column :two, :boolean, default: true
+          t.column :three, :boolean, default: false
+          t.column :four, :integer, default: 1
+          t.column :five, :text, default: "hello" unless mysql
         end
 
         columns = connection.columns(:testings)
@@ -77,7 +77,7 @@ module ActiveRecord
       if current_adapter?(:PostgreSQLAdapter)
         def test_add_column_with_array
           connection.create_table :testings
-          connection.add_column :testings, :foo, :string, :array => true
+          connection.add_column :testings, :foo, :string, array: true
 
           columns = connection.columns(:testings)
           array_column = columns.detect { |c| c.name == "foo" }
@@ -87,7 +87,7 @@ module ActiveRecord
 
         def test_create_table_with_array_column
           connection.create_table :testings do |t|
-            t.string :foo, :array => true
+            t.string :foo, array: true
           end
 
           columns = connection.columns(:testings)
@@ -118,13 +118,13 @@ module ActiveRecord
 
       def test_create_table_with_limits
         connection.create_table :testings do |t|
-          t.column :foo, :string, :limit => 255
+          t.column :foo, :string, limit: 255
 
           t.column :default_int, :integer
 
-          t.column :one_int,    :integer, :limit => 1
-          t.column :four_int,   :integer, :limit => 4
-          t.column :eight_int,  :integer, :limit => 8
+          t.column :one_int,    :integer, limit: 1
+          t.column :four_int,   :integer, limit: 4
+          t.column :eight_int,  :integer, limit: 8
         end
 
         columns = connection.columns(:testings)
@@ -231,7 +231,7 @@ module ActiveRecord
           connection.create_table :testings do |t|
             t.column :foo, :string
           end
-          connection.add_column :testings, :bar, :string, :null => false
+          connection.add_column :testings, :bar, :string, null: false
 
           assert_raise(ActiveRecord::StatementInvalid) do
             connection.execute "insert into testings (foo, bar) values ('hello', NULL)"
@@ -246,7 +246,7 @@ module ActiveRecord
 
         con = connection
         connection.execute "insert into testings (#{con.quote_column_name('id')}, #{con.quote_column_name('foo')}) values (1, 'hello')"
-        assert_nothing_raised {connection.add_column :testings, :bar, :string, :null => false, :default => "default" }
+        assert_nothing_raised {connection.add_column :testings, :bar, :string, null: false, default: "default" }
 
         assert_raises(ActiveRecord::StatementInvalid) do
           connection.execute "insert into testings (#{con.quote_column_name('id')}, #{con.quote_column_name('foo')}, #{con.quote_column_name('bar')}) values (2, 'hello', NULL)"
@@ -275,7 +275,7 @@ module ActiveRecord
           t.column :select, :string
         end
 
-        connection.change_column :testings, :select, :string, :limit => 10
+        connection.change_column :testings, :select, :string, limit: 10
 
         # Oracle needs primary key value from sequence
         if current_adapter?(:OracleAdapter)
@@ -292,7 +292,7 @@ module ActiveRecord
         person_klass = Class.new(ActiveRecord::Base)
         person_klass.table_name = "testings"
 
-        person_klass.connection.add_column "testings", "wealth", :integer, :null => false, :default => 99
+        person_klass.connection.add_column "testings", "wealth", :integer, null: false, default: 99
         person_klass.reset_column_information
         assert_equal 99, person_klass.column_defaults["wealth"]
         assert_equal false, person_klass.columns_hash["wealth"].null
@@ -317,13 +317,13 @@ module ActiveRecord
         assert_equal false, person_klass.columns_hash["money"].null
 
         # change column
-        person_klass.connection.change_column "testings", "money", :integer, :null => false, :default => 1000
+        person_klass.connection.change_column "testings", "money", :integer, null: false, default: 1000
         person_klass.reset_column_information
         assert_equal 1000, person_klass.column_defaults["money"]
         assert_equal false, person_klass.columns_hash["money"].null
 
         # change column, make it nullable and clear default
-        person_klass.connection.change_column "testings", "money", :integer, :null => true, :default => nil
+        person_klass.connection.change_column "testings", "money", :integer, null: true, default: nil
         person_klass.reset_column_information
         assert_nil person_klass.columns_hash["money"].default
         assert_equal true, person_klass.columns_hash["money"].null
@@ -365,7 +365,7 @@ module ActiveRecord
       def test_column_exists_with_type
         connection.create_table :testings do |t|
           t.column :foo, :string
-          t.column :bar, :decimal, :precision => 8, :scale => 2
+          t.column :bar, :decimal, precision: 8, scale: 2
         end
 
         assert connection.column_exists?(:testings, :foo, :string)
@@ -416,7 +416,7 @@ module ActiveRecord
 
       private
       def testing_table_with_only_foo_attribute
-        connection.create_table :testings, :id => false do |t|
+        connection.create_table :testings, id: false do |t|
           t.column :foo, :string
         end
 
diff --git a/activerecord/test/cases/migration/change_table_test.rb b/activerecord/test/cases/migration/change_table_test.rb
index 2f9c50141f..045c18eb3f 100644
--- a/activerecord/test/cases/migration/change_table_test.rb
+++ b/activerecord/test/cases/migration/change_table_test.rb
@@ -157,8 +157,8 @@ module ActiveRecord
 
       def test_column_creates_column_with_options
         with_change_table do |t|
-          @connection.expect :add_column, nil, [:delete_me, :bar, :integer, {:null => false}]
-          t.column :bar, :integer, :null => false
+          @connection.expect :add_column, nil, [:delete_me, :bar, :integer, {null: false}]
+          t.column :bar, :integer, null: false
         end
       end
 
@@ -171,8 +171,8 @@ module ActiveRecord
 
       def test_index_creates_index_with_options
         with_change_table do |t|
-          @connection.expect :add_index, nil, [:delete_me, :bar, {:unique => true}]
-          t.index :bar, :unique => true
+          @connection.expect :add_index, nil, [:delete_me, :bar, {unique: true}]
+          t.index :bar, unique: true
         end
       end
 
@@ -185,8 +185,8 @@ module ActiveRecord
 
       def test_index_exists_with_options
         with_change_table do |t|
-          @connection.expect :index_exists?, nil, [:delete_me, :bar, {:unique => true}]
-          t.index_exists?(:bar, :unique => true)
+          @connection.expect :index_exists?, nil, [:delete_me, :bar, {unique: true}]
+          t.index_exists?(:bar, unique: true)
         end
       end
 
@@ -206,8 +206,8 @@ module ActiveRecord
 
       def test_change_changes_column_with_options
         with_change_table do |t|
-          @connection.expect :change_column, nil, [:delete_me, :bar, :string, {:null => true}]
-          t.change :bar, :string, :null => true
+          @connection.expect :change_column, nil, [:delete_me, :bar, :string, {null: true}]
+          t.change :bar, :string, null: true
         end
       end
 
@@ -234,8 +234,8 @@ module ActiveRecord
 
       def test_remove_index_removes_index_with_options
         with_change_table do |t|
-          @connection.expect :remove_index, nil, [:delete_me, {:unique => true}]
-          t.remove_index :unique => true
+          @connection.expect :remove_index, nil, [:delete_me, {unique: true}]
+          t.remove_index unique: true
         end
       end
 
diff --git a/activerecord/test/cases/migration/column_attributes_test.rb b/activerecord/test/cases/migration/column_attributes_test.rb
index 847000fa0e..ab8229dbae 100644
--- a/activerecord/test/cases/migration/column_attributes_test.rb
+++ b/activerecord/test/cases/migration/column_attributes_test.rb
@@ -9,7 +9,7 @@ module ActiveRecord
 
       def test_add_column_newline_default
         string = "foo\nbar"
-        add_column "test_models", "command", :string, :default => string
+        add_column "test_models", "command", :string, default: string
         TestModel.reset_column_information
 
         assert_equal string, TestModel.new.command
@@ -58,7 +58,7 @@ module ActiveRecord
         def test_native_decimal_insert_manual_vs_automatic
           correct_value = "0012345678901234567890.0123456789".to_d
 
-          connection.add_column "test_models", "wealth", :decimal, :precision => "30", :scale => "10"
+          connection.add_column "test_models", "wealth", :decimal, precision: "30", scale: "10"
 
           # Do a manual insertion
           if current_adapter?(:OracleAdapter)
@@ -82,7 +82,7 @@ module ActiveRecord
           TestModel.delete_all
 
           # Now use the Rails insertion
-          TestModel.create :wealth => BigDecimal.new("12345678901234567890.0123456789")
+          TestModel.create wealth: BigDecimal.new("12345678901234567890.0123456789")
 
           # SELECT
           row = TestModel.first
@@ -94,7 +94,7 @@ module ActiveRecord
       end
 
       def test_add_column_with_precision_and_scale
-        connection.add_column "test_models", "wealth", :decimal, :precision => 9, :scale => 7
+        connection.add_column "test_models", "wealth", :decimal, precision: 9, scale: 7
 
         wealth_column = TestModel.columns_hash["wealth"]
         assert_equal 9, wealth_column.precision
@@ -104,13 +104,13 @@ module ActiveRecord
       if current_adapter?(:SQLite3Adapter)
         def test_change_column_preserve_other_column_precision_and_scale
           connection.add_column "test_models", "last_name", :string
-          connection.add_column "test_models", "wealth", :decimal, :precision => 9, :scale => 7
+          connection.add_column "test_models", "wealth", :decimal, precision: 9, scale: 7
 
           wealth_column = TestModel.columns_hash["wealth"]
           assert_equal 9, wealth_column.precision
           assert_equal 7, wealth_column.scale
 
-          connection.change_column "test_models", "last_name", :string, :null => false
+          connection.change_column "test_models", "last_name", :string, null: false
           TestModel.reset_column_information
 
           wealth_column = TestModel.columns_hash["wealth"]
@@ -126,17 +126,17 @@ module ActiveRecord
           add_column "test_models", "bio", :text
           add_column "test_models", "age", :integer
           add_column "test_models", "height", :float
-          add_column "test_models", "wealth", :decimal, :precision => "30", :scale => "10"
+          add_column "test_models", "wealth", :decimal, precision: "30", scale: "10"
           add_column "test_models", "birthday", :datetime
           add_column "test_models", "favorite_day", :date
           add_column "test_models", "moment_of_truth", :datetime
           add_column "test_models", "male", :boolean
 
-          TestModel.create :first_name => "bob", :last_name => "bobsen",
-            :bio => "I was born ....", :age => 18, :height => 1.78,
-            :wealth => BigDecimal.new("12345678901234567890.0123456789"),
-            :birthday => 18.years.ago, :favorite_day => 10.days.ago,
-            :moment_of_truth => "1782-10-10 21:40:18", :male => true
+          TestModel.create first_name: "bob", last_name: "bobsen",
+            bio: "I was born ....", age: 18, height: 1.78,
+            wealth: BigDecimal.new("12345678901234567890.0123456789"),
+            birthday: 18.years.ago, favorite_day: 10.days.ago,
+            moment_of_truth: "1782-10-10 21:40:18", male: true
 
           bob = TestModel.first
           assert_equal "bob", bob.first_name
@@ -164,10 +164,10 @@ module ActiveRecord
 
       if current_adapter?(:Mysql2Adapter, :PostgreSQLAdapter)
         def test_out_of_range_limit_should_raise
-          assert_raise(ActiveRecordError) { add_column :test_models, :integer_too_big, :integer, :limit => 10 }
+          assert_raise(ActiveRecordError) { add_column :test_models, :integer_too_big, :integer, limit: 10 }
 
           unless current_adapter?(:PostgreSQLAdapter)
-            assert_raise(ActiveRecordError) { add_column :test_models, :text_too_big, :integer, :limit => 0xfffffffff }
+            assert_raise(ActiveRecordError) { add_column :test_models, :text_too_big, :integer, limit: 0xfffffffff }
           end
         end
       end
diff --git a/activerecord/test/cases/migration/column_positioning_test.rb b/activerecord/test/cases/migration/column_positioning_test.rb
index 0a4215fa78..f2162d91b1 100644
--- a/activerecord/test/cases/migration/column_positioning_test.rb
+++ b/activerecord/test/cases/migration/column_positioning_test.rb
@@ -11,7 +11,7 @@ module ActiveRecord
 
         @connection = ActiveRecord::Base.connection
 
-        connection.create_table :testings, :id => false do |t|
+        connection.create_table :testings, id: false do |t|
           t.column :first, :integer
           t.column :second, :integer
           t.column :third, :integer
@@ -34,20 +34,20 @@ module ActiveRecord
         end
 
         def test_add_column_with_positioning_first
-          conn.add_column :testings, :new_col, :integer, :first => true
+          conn.add_column :testings, :new_col, :integer, first: true
           assert_equal %w(new_col first second third), conn.columns(:testings).map(&:name)
         end
 
         def test_add_column_with_positioning_after
-          conn.add_column :testings, :new_col, :integer, :after => :first
+          conn.add_column :testings, :new_col, :integer, after: :first
           assert_equal %w(first new_col second third), conn.columns(:testings).map(&:name)
         end
 
         def test_change_column_with_positioning
-          conn.change_column :testings, :second, :integer, :first => true
+          conn.change_column :testings, :second, :integer, first: true
           assert_equal %w(second first third), conn.columns(:testings).map(&:name)
 
-          conn.change_column :testings, :second, :integer, :after => :third
+          conn.change_column :testings, :second, :integer, after: :third
           assert_equal %w(first third second), conn.columns(:testings).map(&:name)
         end
       end
diff --git a/activerecord/test/cases/migration/columns_test.rb b/activerecord/test/cases/migration/columns_test.rb
index 7098eb1d2c..95c3f51539 100644
--- a/activerecord/test/cases/migration/columns_test.rb
+++ b/activerecord/test/cases/migration/columns_test.rb
@@ -13,7 +13,7 @@ module ActiveRecord
         add_column "test_models", "girlfriend", :string
         TestModel.reset_column_information
 
-        TestModel.create :girlfriend => "bobette"
+        TestModel.create girlfriend: "bobette"
 
         rename_column "test_models", "girlfriend", "exgirlfriend"
 
@@ -28,7 +28,7 @@ module ActiveRecord
       def test_rename_column_using_symbol_arguments
         add_column :test_models, :first_name, :string
 
-        TestModel.create :first_name => "foo"
+        TestModel.create first_name: "foo"
 
         rename_column :test_models, :first_name, :nick_name
         TestModel.reset_column_information
@@ -41,7 +41,7 @@ module ActiveRecord
       def test_rename_column
         add_column "test_models", "first_name", "string"
 
-        TestModel.create :first_name => "foo"
+        TestModel.create first_name: "foo"
 
         rename_column "test_models", "first_name", "nick_name"
         TestModel.reset_column_information
@@ -50,7 +50,7 @@ module ActiveRecord
       end
 
       def test_rename_column_preserves_default_value_not_null
-        add_column "test_models", "salary", :integer, :default => 70000
+        add_column "test_models", "salary", :integer, default: 70000
 
         default_before = connection.columns("test_models").find { |c| c.name == "salary" }.default
         assert_equal "70000", default_before
@@ -122,7 +122,7 @@ module ActiveRecord
 
       def test_rename_column_does_not_rename_custom_named_index
         add_column "test_models", :hat_name, :string
-        add_index :test_models, :hat_name, :name => "idx_hat_name"
+        add_index :test_models, :hat_name, name: "idx_hat_name"
 
         assert_equal 1, connection.indexes("test_models").size
         rename_column "test_models", "hat_name", "name"
@@ -140,8 +140,8 @@ module ActiveRecord
 
       def test_remove_column_with_multi_column_index
         add_column "test_models", :hat_size, :integer
-        add_column "test_models", :hat_style, :string, :limit => 100
-        add_index "test_models", ["hat_style", "hat_size"], :unique => true
+        add_column "test_models", :hat_style, :string, limit: 100
+        add_index "test_models", ["hat_style", "hat_size"], unique: true
 
         assert_equal 1, connection.indexes("test_models").size
         remove_column("test_models", "hat_size")
@@ -156,32 +156,32 @@ module ActiveRecord
       end
 
       def test_change_type_of_not_null_column
-        change_column "test_models", "updated_at", :datetime, :null => false
-        change_column "test_models", "updated_at", :datetime, :null => false
+        change_column "test_models", "updated_at", :datetime, null: false
+        change_column "test_models", "updated_at", :datetime, null: false
 
         TestModel.reset_column_information
         assert_equal false, TestModel.columns_hash["updated_at"].null
       ensure
-        change_column "test_models", "updated_at", :datetime, :null => true
+        change_column "test_models", "updated_at", :datetime, null: true
       end
 
       def test_change_column_nullability
         add_column "test_models", "funny", :boolean
         assert TestModel.columns_hash["funny"].null, "Column 'funny' must initially allow nulls"
 
-        change_column "test_models", "funny", :boolean, :null => false, :default => true
+        change_column "test_models", "funny", :boolean, null: false, default: true
 
         TestModel.reset_column_information
         assert_not TestModel.columns_hash["funny"].null, "Column 'funny' must *not* allow nulls at this point"
 
-        change_column "test_models", "funny", :boolean, :null => true
+        change_column "test_models", "funny", :boolean, null: true
         TestModel.reset_column_information
         assert TestModel.columns_hash["funny"].null, "Column 'funny' must allow nulls again at this point"
       end
 
       def test_change_column
         add_column "test_models", "age", :integer
-        add_column "test_models", "approved", :boolean, :default => true
+        add_column "test_models", "approved", :boolean, default: true
 
         old_columns = connection.columns(TestModel.table_name)
 
@@ -200,7 +200,7 @@ module ActiveRecord
           c.name == "approved" && c.type == :boolean && default == true
         }
 
-        change_column :test_models, :approved, :boolean, :default => false
+        change_column :test_models, :approved, :boolean, default: false
         new_columns = connection.columns(TestModel.table_name)
 
         assert_not new_columns.find { |c|
@@ -211,24 +211,24 @@ module ActiveRecord
           default = connection.lookup_cast_type_from_column(c).deserialize(c.default)
           c.name == "approved" and c.type == :boolean and default == false
         }
-        change_column :test_models, :approved, :boolean, :default => true
+        change_column :test_models, :approved, :boolean, default: true
       end
 
       def test_change_column_with_nil_default
-        add_column "test_models", "contributor", :boolean, :default => true
+        add_column "test_models", "contributor", :boolean, default: true
         assert TestModel.new.contributor?
 
-        change_column "test_models", "contributor", :boolean, :default => nil
+        change_column "test_models", "contributor", :boolean, default: nil
         TestModel.reset_column_information
         assert_not TestModel.new.contributor?
         assert_nil TestModel.new.contributor
       end
 
       def test_change_column_with_new_default
-        add_column "test_models", "administrator", :boolean, :default => true
+        add_column "test_models", "administrator", :boolean, default: true
         assert TestModel.new.administrator?
 
-        change_column "test_models", "administrator", :boolean, :default => false
+        change_column "test_models", "administrator", :boolean, default: false
         TestModel.reset_column_information
         assert_not TestModel.new.administrator?
       end
diff --git a/activerecord/test/cases/migration/compatibility_test.rb b/activerecord/test/cases/migration/compatibility_test.rb
index bb249e5deb..0a4b604601 100644
--- a/activerecord/test/cases/migration/compatibility_test.rb
+++ b/activerecord/test/cases/migration/compatibility_test.rb
@@ -13,8 +13,8 @@ module ActiveRecord
         ActiveRecord::Migration.verbose = false
 
         connection.create_table :testings do |t|
-          t.column :foo, :string, :limit => 100
-          t.column :bar, :string, :limit => 100
+          t.column :foo, :string, limit: 100
+          t.column :bar, :string, limit: 100
         end
       end
 
@@ -25,7 +25,7 @@ module ActiveRecord
       end
 
       def test_migration_doesnt_remove_named_index
-        connection.add_index :testings, :foo, :name => "custom_index_name"
+        connection.add_index :testings, :foo, name: "custom_index_name"
 
         migration = Class.new(ActiveRecord::Migration[4.2]) {
           def version; 101 end
diff --git a/activerecord/test/cases/migration/index_test.rb b/activerecord/test/cases/migration/index_test.rb
index d9b2bc9957..f59aec040f 100644
--- a/activerecord/test/cases/migration/index_test.rb
+++ b/activerecord/test/cases/migration/index_test.rb
@@ -11,12 +11,12 @@ module ActiveRecord
         @table_name = :testings
 
         connection.create_table table_name do |t|
-          t.column :foo, :string, :limit => 100
-          t.column :bar, :string, :limit => 100
+          t.column :foo, :string, limit: 100
+          t.column :bar, :string, limit: 100
 
           t.string :first_name
-          t.string :last_name, :limit => 100
-          t.string :key,       :limit => 100
+          t.string :last_name, limit: 100
+          t.string :key,       limit: 100
           t.boolean :administrator
         end
       end
@@ -28,7 +28,7 @@ module ActiveRecord
 
       def test_rename_index
         # keep the names short to make Oracle and similar behave
-        connection.add_index(table_name, [:foo], :name => "old_idx")
+        connection.add_index(table_name, [:foo], name: "old_idx")
         connection.rename_index(table_name, "old_idx", "new_idx")
 
         # if the adapter doesn't support the indexes call, pick defaults that let the test pass
@@ -39,7 +39,7 @@ module ActiveRecord
       def test_rename_index_too_long
         too_long_index_name = good_index_name + "x"
         # keep the names short to make Oracle and similar behave
-        connection.add_index(table_name, [:foo], :name => "old_idx")
+        connection.add_index(table_name, [:foo], name: "old_idx")
         e = assert_raises(ArgumentError) {
           connection.rename_index(table_name, "old_idx", too_long_index_name)
         }
@@ -51,9 +51,9 @@ module ActiveRecord
 
 
       def test_double_add_index
-        connection.add_index(table_name, [:foo], :name => "some_idx")
+        connection.add_index(table_name, [:foo], name: "some_idx")
         assert_raises(ArgumentError) {
-          connection.add_index(table_name, [:foo], :name => "some_idx")
+          connection.add_index(table_name, [:foo], name: "some_idx")
         }
       end
 
@@ -77,7 +77,7 @@ module ActiveRecord
         assert_match(/too long; the limit is #{connection.allowed_index_name_length} characters/, e.message)
 
         assert_not connection.index_name_exists?(table_name, too_long_index_name, false)
-        connection.add_index(table_name, "foo", :name => good_index_name)
+        connection.add_index(table_name, "foo", name: good_index_name)
       end
 
       def test_internal_index_with_name_matching_database_limit
@@ -89,11 +89,11 @@ module ActiveRecord
       end
 
       def test_index_symbol_names
-        connection.add_index table_name, :foo, :name => :symbol_index_name
-        assert connection.index_exists?(table_name, :foo, :name => :symbol_index_name)
+        connection.add_index table_name, :foo, name: :symbol_index_name
+        assert connection.index_exists?(table_name, :foo, name: :symbol_index_name)
 
-        connection.remove_index table_name, :name => :symbol_index_name
-        assert_not connection.index_exists?(table_name, :foo, :name => :symbol_index_name)
+        connection.remove_index table_name, name: :symbol_index_name
+        assert_not connection.index_exists?(table_name, :foo, name: :symbol_index_name)
       end
 
       def test_index_exists
@@ -122,21 +122,21 @@ module ActiveRecord
       end
 
       def test_unique_index_exists
-        connection.add_index :testings, :foo, :unique => true
+        connection.add_index :testings, :foo, unique: true
 
-        assert connection.index_exists?(:testings, :foo, :unique => true)
+        assert connection.index_exists?(:testings, :foo, unique: true)
       end
 
       def test_named_index_exists
-        connection.add_index :testings, :foo, :name => "custom_index_name"
+        connection.add_index :testings, :foo, name: "custom_index_name"
 
         assert connection.index_exists?(:testings, :foo)
-        assert connection.index_exists?(:testings, :foo, :name => "custom_index_name")
-        assert !connection.index_exists?(:testings, :foo, :name => "other_index_name")
+        assert connection.index_exists?(:testings, :foo, name: "custom_index_name")
+        assert !connection.index_exists?(:testings, :foo, name: "other_index_name")
       end
 
       def test_remove_named_index
-        connection.add_index :testings, :foo, :name => "custom_index_name"
+        connection.add_index :testings, :foo, name: "custom_index_name"
 
         assert connection.index_exists?(:testings, :foo)
         connection.remove_index :testings, :foo
@@ -144,7 +144,7 @@ module ActiveRecord
       end
 
       def test_add_index_attribute_length_limit
-        connection.add_index :testings, [:foo, :bar], :length => {:foo => 10, :bar => nil}
+        connection.add_index :testings, [:foo, :bar], length: {foo: 10, bar: nil}
 
         assert connection.index_exists?(:testings, [:foo, :bar])
       end
@@ -154,53 +154,53 @@ module ActiveRecord
         connection.remove_index("testings", "last_name")
 
         connection.add_index("testings", ["last_name", "first_name"])
-        connection.remove_index("testings", :column => ["last_name", "first_name"])
+        connection.remove_index("testings", column: ["last_name", "first_name"])
 
         # Oracle adapter cannot have specified index name larger than 30 characters
         # Oracle adapter is shortening index name when just column list is given
         unless current_adapter?(:OracleAdapter)
           connection.add_index("testings", ["last_name", "first_name"])
-          connection.remove_index("testings", :name => :index_testings_on_last_name_and_first_name)
+          connection.remove_index("testings", name: :index_testings_on_last_name_and_first_name)
           connection.add_index("testings", ["last_name", "first_name"])
           connection.remove_index("testings", "last_name_and_first_name")
         end
         connection.add_index("testings", ["last_name", "first_name"])
         connection.remove_index("testings", ["last_name", "first_name"])
 
-        connection.add_index("testings", ["last_name"], :length => 10)
+        connection.add_index("testings", ["last_name"], length: 10)
         connection.remove_index("testings", "last_name")
 
-        connection.add_index("testings", ["last_name"], :length => {:last_name => 10})
+        connection.add_index("testings", ["last_name"], length: {last_name: 10})
         connection.remove_index("testings", ["last_name"])
 
-        connection.add_index("testings", ["last_name", "first_name"], :length => 10)
+        connection.add_index("testings", ["last_name", "first_name"], length: 10)
         connection.remove_index("testings", ["last_name", "first_name"])
 
-        connection.add_index("testings", ["last_name", "first_name"], :length => {:last_name => 10, :first_name => 20})
+        connection.add_index("testings", ["last_name", "first_name"], length: {last_name: 10, first_name: 20})
         connection.remove_index("testings", ["last_name", "first_name"])
 
-        connection.add_index("testings", ["key"], :name => "key_idx", :unique => true)
-        connection.remove_index("testings", :name => "key_idx", :unique => true)
+        connection.add_index("testings", ["key"], name: "key_idx", unique: true)
+        connection.remove_index("testings", name: "key_idx", unique: true)
 
-        connection.add_index("testings", %w(last_name first_name administrator), :name => "named_admin")
-        connection.remove_index("testings", :name => "named_admin")
+        connection.add_index("testings", %w(last_name first_name administrator), name: "named_admin")
+        connection.remove_index("testings", name: "named_admin")
 
         # Selected adapters support index sort order
         if current_adapter?(:SQLite3Adapter, :Mysql2Adapter, :PostgreSQLAdapter)
-          connection.add_index("testings", ["last_name"], :order => {:last_name => :desc})
+          connection.add_index("testings", ["last_name"], order: {last_name: :desc})
           connection.remove_index("testings", ["last_name"])
-          connection.add_index("testings", ["last_name", "first_name"], :order => {:last_name => :desc})
+          connection.add_index("testings", ["last_name", "first_name"], order: {last_name: :desc})
           connection.remove_index("testings", ["last_name", "first_name"])
-          connection.add_index("testings", ["last_name", "first_name"], :order => {:last_name => :desc, :first_name => :asc})
+          connection.add_index("testings", ["last_name", "first_name"], order: {last_name: :desc, first_name: :asc})
           connection.remove_index("testings", ["last_name", "first_name"])
-          connection.add_index("testings", ["last_name", "first_name"], :order => :desc)
+          connection.add_index("testings", ["last_name", "first_name"], order: :desc)
           connection.remove_index("testings", ["last_name", "first_name"])
         end
       end
 
       if current_adapter?(:PostgreSQLAdapter)
         def test_add_partial_index
-          connection.add_index("testings", "last_name", :where => "first_name = 'john doe'")
+          connection.add_index("testings", "last_name", where: "first_name = 'john doe'")
           assert connection.index_exists?("testings", "last_name")
 
           connection.remove_index("testings", "last_name")
diff --git a/activerecord/test/cases/migration/references_index_test.rb b/activerecord/test/cases/migration/references_index_test.rb
index 481fe42a8b..0d0b0a193b 100644
--- a/activerecord/test/cases/migration/references_index_test.rb
+++ b/activerecord/test/cases/migration/references_index_test.rb
@@ -17,10 +17,10 @@ module ActiveRecord
 
       def test_creates_index
         connection.create_table table_name do |t|
-          t.references :foo, :index => true
+          t.references :foo, index: true
         end
 
-        assert connection.index_exists?(table_name, :foo_id, :name => :index_testings_on_foo_id)
+        assert connection.index_exists?(table_name, :foo_id, name: :index_testings_on_foo_id)
       end
 
       def test_creates_index_by_default_even_if_index_option_is_not_passed
@@ -28,31 +28,31 @@ module ActiveRecord
           t.references :foo
         end
 
-        assert connection.index_exists?(table_name, :foo_id, :name => :index_testings_on_foo_id)
+        assert connection.index_exists?(table_name, :foo_id, name: :index_testings_on_foo_id)
       end
 
       def test_does_not_create_index_explicit
         connection.create_table table_name do |t|
-          t.references :foo, :index => false
+          t.references :foo, index: false
         end
 
-        assert_not connection.index_exists?(table_name, :foo_id, :name => :index_testings_on_foo_id)
+        assert_not connection.index_exists?(table_name, :foo_id, name: :index_testings_on_foo_id)
       end
 
       def test_creates_index_with_options
         connection.create_table table_name do |t|
-          t.references :foo, :index => {:name => :index_testings_on_yo_momma}
-          t.references :bar, :index => {:unique => true}
+          t.references :foo, index: {name: :index_testings_on_yo_momma}
+          t.references :bar, index: {unique: true}
         end
 
-        assert connection.index_exists?(table_name, :foo_id, :name => :index_testings_on_yo_momma)
-        assert connection.index_exists?(table_name, :bar_id, :name => :index_testings_on_bar_id, :unique => true)
+        assert connection.index_exists?(table_name, :foo_id, name: :index_testings_on_yo_momma)
+        assert connection.index_exists?(table_name, :bar_id, name: :index_testings_on_bar_id, unique: true)
       end
 
       unless current_adapter? :OracleAdapter
         def test_creates_polymorphic_index
           connection.create_table table_name do |t|
-            t.references :foo, :polymorphic => true, :index => true
+            t.references :foo, polymorphic: true, index: true
           end
 
           assert connection.index_exists?(table_name, [:foo_type, :foo_id], name: :index_testings_on_foo_type_and_foo_id)
@@ -62,10 +62,10 @@ module ActiveRecord
       def test_creates_index_for_existing_table
         connection.create_table table_name
         connection.change_table table_name do |t|
-          t.references :foo, :index => true
+          t.references :foo, index: true
         end
 
-        assert connection.index_exists?(table_name, :foo_id, :name => :index_testings_on_foo_id)
+        assert connection.index_exists?(table_name, :foo_id, name: :index_testings_on_foo_id)
       end
 
       def test_creates_index_for_existing_table_even_if_index_option_is_not_passed
@@ -74,23 +74,23 @@ module ActiveRecord
           t.references :foo
         end
 
-        assert connection.index_exists?(table_name, :foo_id, :name => :index_testings_on_foo_id)
+        assert connection.index_exists?(table_name, :foo_id, name: :index_testings_on_foo_id)
       end
 
       def test_does_not_create_index_for_existing_table_explicit
         connection.create_table table_name
         connection.change_table table_name do |t|
-          t.references :foo, :index => false
+          t.references :foo, index: false
         end
 
-        assert_not connection.index_exists?(table_name, :foo_id, :name => :index_testings_on_foo_id)
+        assert_not connection.index_exists?(table_name, :foo_id, name: :index_testings_on_foo_id)
       end
 
       unless current_adapter? :OracleAdapter
         def test_creates_polymorphic_index_for_existing_table
           connection.create_table table_name
           connection.change_table table_name do |t|
-            t.references :foo, :polymorphic => true, :index => true
+            t.references :foo, polymorphic: true, index: true
           end
 
           assert connection.index_exists?(table_name, [:foo_type, :foo_id], name: :index_testings_on_foo_type_and_foo_id)