Add three new rubocop rules

Style/SpaceBeforeBlockBraces
Style/SpaceInsideBlockBraces
Style/SpaceInsideHashLiteralBraces

Fix all violations in the repository.

93 files changed, 512 insertions, 512 deletions

diff --git a/activerecord/test/cases/adapter_test.rb b/activerecord/test/cases/adapter_test.rb
index b164c12c89..a72981e4d5 100644
--- a/activerecord/test/cases/adapter_test.rb
+++ b/activerecord/test/cases/adapter_test.rb
@@ -248,8 +248,8 @@ module ActiveRecord
       author = Author.create!(name: "john")
       Post.create!(author: author, title: "foo", body: "bar")
       query = author.posts.where(title: "foo").select(:title)
-      assert_equal({"title" => "foo"}, @connection.select_one(query.arel, nil, query.bound_attributes))
-      assert_equal({"title" => "foo"}, @connection.select_one(query))
+      assert_equal({ "title" => "foo" }, @connection.select_one(query.arel, nil, query.bound_attributes))
+      assert_equal({ "title" => "foo" }, @connection.select_one(query))
       assert @connection.select_all(query).is_a?(ActiveRecord::Result)
       assert_equal "foo", @connection.select_value(query)
       assert_equal ["foo"], @connection.select_values(query)
@@ -258,8 +258,8 @@ module ActiveRecord
     def test_select_methods_passing_a_relation
       Post.create!(title: "foo", body: "bar")
       query = Post.where(title: "foo").select(:title)
-      assert_equal({"title" => "foo"}, @connection.select_one(query.arel, nil, query.bound_attributes))
-      assert_equal({"title" => "foo"}, @connection.select_one(query))
+      assert_equal({ "title" => "foo" }, @connection.select_one(query.arel, nil, query.bound_attributes))
+      assert_equal({ "title" => "foo" }, @connection.select_one(query))
       assert @connection.select_all(query).is_a?(ActiveRecord::Result)
       assert_equal "foo", @connection.select_value(query)
       assert_equal ["foo"], @connection.select_values(query)
diff --git a/activerecord/test/cases/adapters/mysql2/active_schema_test.rb b/activerecord/test/cases/adapters/mysql2/active_schema_test.rb
index e7e37cac36..a70eb5a094 100644
--- a/activerecord/test/cases/adapters/mysql2/active_schema_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/active_schema_test.rb
@@ -30,10 +30,10 @@ class Mysql2ActiveSchemaTest < ActiveRecord::Mysql2TestCase
     assert_equal expected, add_index(:people, [:last_name, :first_name], length: 15)
 
     expected = "CREATE  INDEX `index_people_on_last_name_and_first_name`  ON `people` (`last_name`(15), `first_name`) "
-    assert_equal expected, add_index(:people, [:last_name, :first_name], length: {last_name: 15})
+    assert_equal expected, add_index(:people, [:last_name, :first_name], length: { last_name: 15 })
 
     expected = "CREATE  INDEX `index_people_on_last_name_and_first_name`  ON `people` (`last_name`(15), `first_name`(10)) "
-    assert_equal expected, add_index(:people, [:last_name, :first_name], length: {last_name: 15, first_name: 10})
+    assert_equal expected, add_index(:people, [:last_name, :first_name], length: { last_name: 15, first_name: 10 })
 
     %w(SPATIAL FULLTEXT UNIQUE).each do |type|
       expected = "CREATE #{type} INDEX `index_people_on_last_name`  ON `people` (`last_name`) "
diff --git a/activerecord/test/cases/adapters/mysql2/case_sensitivity_test.rb b/activerecord/test/cases/adapters/mysql2/case_sensitivity_test.rb
index 4d81877a9a..50ba9ab831 100644
--- a/activerecord/test/cases/adapters/mysql2/case_sensitivity_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/case_sensitivity_test.rb
@@ -30,7 +30,7 @@ class Mysql2CaseSensitivityTest < ActiveRecord::Mysql2TestCase
     CollationTest.create!(string_cs_column: "A")
     invalid = CollationTest.new(string_cs_column: "a")
     queries = assert_sql { invalid.save }
-    cs_uniqueness_query = queries.detect { |q| q.match(/string_cs_column/)}
+    cs_uniqueness_query = queries.detect { |q| q.match(/string_cs_column/) }
     assert_match(/lower/i, cs_uniqueness_query)
   end
 
diff --git a/activerecord/test/cases/adapters/mysql2/connection_test.rb b/activerecord/test/cases/adapters/mysql2/connection_test.rb
index a3f83e73a6..9ede57d395 100644
--- a/activerecord/test/cases/adapters/mysql2/connection_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/connection_test.rb
@@ -114,7 +114,7 @@ class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
 
   def test_mysql_set_session_variable
     run_without_connection do |orig_connection|
-      ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: {default_week_format: 3}))
+      ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { default_week_format: 3 }))
       session_mode = ActiveRecord::Base.connection.exec_query "SELECT @@SESSION.DEFAULT_WEEK_FORMAT"
       assert_equal 3, session_mode.rows.first.first.to_i
     end
@@ -122,7 +122,7 @@ class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
 
   def test_mysql_set_session_variable_to_default
     run_without_connection do |orig_connection|
-      ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: {default_week_format: :default}))
+      ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { default_week_format: :default }))
       global_mode = ActiveRecord::Base.connection.exec_query "SELECT @@GLOBAL.DEFAULT_WEEK_FORMAT"
       session_mode = ActiveRecord::Base.connection.exec_query "SELECT @@SESSION.DEFAULT_WEEK_FORMAT"
       assert_equal global_mode.rows, session_mode.rows
diff --git a/activerecord/test/cases/adapters/mysql2/json_test.rb b/activerecord/test/cases/adapters/mysql2/json_test.rb
index 2f7dc3f7ef..6b7d259023 100644
--- a/activerecord/test/cases/adapters/mysql2/json_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/json_test.rb
@@ -51,11 +51,11 @@ if ActiveRecord::Base.connection.supports_json?
     end
 
     def test_cast_value_on_write
-      x = JsonDataType.new payload: {"string" => "foo", :symbol => :bar}
-      assert_equal({"string" => "foo", :symbol => :bar}, x.payload_before_type_cast)
-      assert_equal({"string" => "foo", "symbol" => "bar"}, x.payload)
+      x = JsonDataType.new payload: { "string" => "foo", :symbol => :bar }
+      assert_equal({ "string" => "foo", :symbol => :bar }, x.payload_before_type_cast)
+      assert_equal({ "string" => "foo", "symbol" => "bar" }, x.payload)
       x.save
-      assert_equal({"string" => "foo", "symbol" => "bar"}, x.reload.payload)
+      assert_equal({ "string" => "foo", "symbol" => "bar" }, x.reload.payload)
     end
 
     def test_type_cast_json
@@ -63,12 +63,12 @@ if ActiveRecord::Base.connection.supports_json?
 
       data = "{\"a_key\":\"a_value\"}"
       hash = type.deserialize(data)
-      assert_equal({"a_key" => "a_value"}, hash)
-      assert_equal({"a_key" => "a_value"}, type.deserialize(data))
+      assert_equal({ "a_key" => "a_value" }, hash)
+      assert_equal({ "a_key" => "a_value" }, type.deserialize(data))
 
       assert_equal({}, type.deserialize("{}"))
-      assert_equal({"key"=>nil}, type.deserialize('{"key": null}'))
-      assert_equal({"c"=>"}",'"a"'=>'b "a b'}, type.deserialize(%q({"c":"}", "\"a\"":"b \"a b"})))
+      assert_equal({ "key"=>nil }, type.deserialize('{"key": null}'))
+      assert_equal({ "c"=>"}",'"a"'=>'b "a b' }, type.deserialize(%q({"c":"}", "\"a\"":"b \"a b"})))
     end
 
     def test_rewrite
@@ -81,13 +81,13 @@ if ActiveRecord::Base.connection.supports_json?
     def test_select
       @connection.execute "insert into json_data_type (payload) VALUES ('{\"k\":\"v\"}')"
       x = JsonDataType.first
-      assert_equal({"k" => "v"}, x.payload)
+      assert_equal({ "k" => "v" }, x.payload)
     end
 
     def test_select_multikey
       @connection.execute %q|insert into json_data_type (payload) VALUES ('{"k1":"v1", "k2":"v2", "k3":[1,2,3]}')|
       x = JsonDataType.first
-      assert_equal({"k1" => "v1", "k2" => "v2", "k3" => [1,2,3]}, x.payload)
+      assert_equal({ "k1" => "v1", "k2" => "v2", "k3" => [1,2,3] }, x.payload)
     end
 
     def test_null_json
@@ -99,13 +99,13 @@ if ActiveRecord::Base.connection.supports_json?
     def test_select_array_json_value
       @connection.execute %q|insert into json_data_type (payload) VALUES ('["v0",{"k1":"v1"}]')|
       x = JsonDataType.first
-      assert_equal(["v0", {"k1" => "v1"}], x.payload)
+      assert_equal(["v0", { "k1" => "v1" }], x.payload)
     end
 
     def test_rewrite_array_json_value
       @connection.execute %q|insert into json_data_type (payload) VALUES ('["v0",{"k1":"v1"}]')|
       x = JsonDataType.first
-      x.payload = ["v1", {"k2" => "v2"}, "v3"]
+      x.payload = ["v1", { "k2" => "v2" }, "v3"]
       assert x.save!
     end
 
diff --git a/activerecord/test/cases/adapters/mysql2/schema_test.rb b/activerecord/test/cases/adapters/mysql2/schema_test.rb
index 3c08a4ed1f..aea930cfe6 100644
--- a/activerecord/test/cases/adapters/mysql2/schema_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/schema_test.rb
@@ -78,9 +78,9 @@ module ActiveRecord
         indexes = @connection.indexes(table).sort_by(&:name)
         assert_equal 3,indexes.size
 
-        index_a = indexes.select{|i| i.name == index_a_name}[0]
-        index_b = indexes.select{|i| i.name == index_b_name}[0]
-        index_c = indexes.select{|i| i.name == index_c_name}[0]
+        index_a = indexes.select { |i| i.name == index_a_name }[0]
+        index_b = indexes.select { |i| i.name == index_b_name }[0]
+        index_c = indexes.select { |i| i.name == index_c_name }[0]
         assert_equal :btree, index_a.using
         assert_nil index_a.type
         assert_equal :btree, index_b.using
@@ -121,6 +121,6 @@ class Mysql2AnsiQuotesTest < ActiveRecord::Mysql2TestCase
   def test_foreign_keys_method_with_ansi_quotes
     fks = @connection.foreign_keys("lessons_students")
     assert_equal([["lessons_students", "students", :cascade]],
-                 fks.map {|fk| [fk.from_table, fk.to_table, fk.on_delete] })
+                 fks.map { |fk| [fk.from_table, fk.to_table, fk.on_delete] })
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/array_test.rb b/activerecord/test/cases/adapters/postgresql/array_test.rb
index e496960f21..c14745ac1f 100644
--- a/activerecord/test/cases/adapters/postgresql/array_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/array_test.rb
@@ -184,7 +184,7 @@ class PostgresqlArrayTest < ActiveRecord::PostgreSQLTestCase
 
   def test_insert_fixture
     tag_values = ["val1", "val2", "val3_with_'_multiple_quote_'_chars"]
-    @connection.insert_fixture({"tags" => tag_values}, "pg_arrays" )
+    @connection.insert_fixture({ "tags" => tag_values }, "pg_arrays" )
     assert_equal(PgArray.last.tags, tag_values)
   end
 
diff --git a/activerecord/test/cases/adapters/postgresql/connection_test.rb b/activerecord/test/cases/adapters/postgresql/connection_test.rb
index d01f601031..48c82cb7b9 100644
--- a/activerecord/test/cases/adapters/postgresql/connection_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/connection_test.rb
@@ -184,7 +184,7 @@ module ActiveRecord
 
     def test_set_session_variable_true
       run_without_connection do |orig_connection|
-        ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: {debug_print_plan: true}))
+        ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { debug_print_plan: true }))
         set_true = ActiveRecord::Base.connection.exec_query "SHOW DEBUG_PRINT_PLAN"
         assert_equal set_true.rows, [["on"]]
       end
@@ -192,7 +192,7 @@ module ActiveRecord
 
     def test_set_session_variable_false
       run_without_connection do |orig_connection|
-        ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: {debug_print_plan: false}))
+        ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { debug_print_plan: false }))
         set_false = ActiveRecord::Base.connection.exec_query "SHOW DEBUG_PRINT_PLAN"
         assert_equal set_false.rows, [["off"]]
       end
@@ -201,14 +201,14 @@ module ActiveRecord
     def test_set_session_variable_nil
       run_without_connection do |orig_connection|
         # This should be a no-op that does not raise an error
-        ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: {debug_print_plan: nil}))
+        ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { debug_print_plan: nil }))
       end
     end
 
     def test_set_session_variable_default
       run_without_connection do |orig_connection|
         # This should execute a query that does not raise an error
-        ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: {debug_print_plan: :default}))
+        ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { debug_print_plan: :default }))
       end
     end
 
@@ -224,14 +224,14 @@ module ActiveRecord
       got_lock = @connection.get_advisory_lock(lock_id)
       assert got_lock, "get_advisory_lock should have returned true but it didn't"
 
-      advisory_lock = @connection.query(list_advisory_locks).find {|l| l[1] == lock_id}
+      advisory_lock = @connection.query(list_advisory_locks).find { |l| l[1] == lock_id }
       assert advisory_lock,
         "expected to find an advisory lock with lock_id #{lock_id} but there wasn't one"
 
       released_lock = @connection.release_advisory_lock(lock_id)
       assert released_lock, "expected release_advisory_lock to return true but it didn't"
 
-      advisory_locks = @connection.query(list_advisory_locks).select {|l| l[1] == lock_id}
+      advisory_locks = @connection.query(list_advisory_locks).select { |l| l[1] == lock_id }
       assert_empty advisory_locks,
         "expected to have released advisory lock with lock_id #{lock_id} but it was still held"
     end
diff --git a/activerecord/test/cases/adapters/postgresql/hstore_test.rb b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
index 817dfbf705..3a8fcf388a 100644
--- a/activerecord/test/cases/adapters/postgresql/hstore_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
@@ -64,8 +64,8 @@ if ActiveRecord::Base.connection.supports_extensions?
       @connection.add_column "hstores", "permissions", :hstore, default: '"users"=>"read", "articles"=>"write"'
       Hstore.reset_column_information
 
-      assert_equal({"users"=>"read", "articles"=>"write"}, Hstore.column_defaults["permissions"])
-      assert_equal({"users"=>"read", "articles"=>"write"}, Hstore.new.permissions)
+      assert_equal({ "users"=>"read", "articles"=>"write" }, Hstore.column_defaults["permissions"])
+      assert_equal({ "users"=>"read", "articles"=>"write" }, Hstore.new.permissions)
     ensure
       Hstore.reset_column_information
     end
@@ -103,18 +103,18 @@ if ActiveRecord::Base.connection.supports_extensions?
     end
 
     def test_cast_value_on_write
-      x = Hstore.new tags: {"bool" => true, "number" => 5}
-      assert_equal({"bool" => true, "number" => 5}, x.tags_before_type_cast)
-      assert_equal({"bool" => "true", "number" => "5"}, x.tags)
+      x = Hstore.new tags: { "bool" => true, "number" => 5 }
+      assert_equal({ "bool" => true, "number" => 5 }, x.tags_before_type_cast)
+      assert_equal({ "bool" => "true", "number" => "5" }, x.tags)
       x.save
-      assert_equal({"bool" => "true", "number" => "5"}, x.reload.tags)
+      assert_equal({ "bool" => "true", "number" => "5" }, x.reload.tags)
     end
 
     def test_type_cast_hstore
-      assert_equal({"1" => "2"}, @type.deserialize("\"1\"=>\"2\""))
+      assert_equal({ "1" => "2" }, @type.deserialize("\"1\"=>\"2\""))
       assert_equal({}, @type.deserialize(""))
-      assert_equal({"key"=>nil}, @type.deserialize("key => NULL"))
-      assert_equal({"c"=>"}",'"a"'=>'b "a b'}, @type.deserialize(%q(c=>"}", "\"a\""=>"b \"a b")))
+      assert_equal({ "key"=>nil }, @type.deserialize("key => NULL"))
+      assert_equal({ "c"=>"}",'"a"'=>'b "a b' }, @type.deserialize(%q(c=>"}", "\"a\""=>"b \"a b")))
     end
 
     def test_with_store_accessors
@@ -182,31 +182,31 @@ if ActiveRecord::Base.connection.supports_extensions?
     end
 
     def test_parse1
-      assert_equal({"a"=>nil,"b"=>nil,"c"=>"NuLl","null"=>"c"}, @type.deserialize('a=>null,b=>NuLl,c=>"NuLl",null=>c'))
+      assert_equal({ "a"=>nil,"b"=>nil,"c"=>"NuLl","null"=>"c" }, @type.deserialize('a=>null,b=>NuLl,c=>"NuLl",null=>c'))
     end
 
     def test_parse2
-      assert_equal({" " => " "},  @type.deserialize("\\ =>\\ "))
+      assert_equal({ " " => " " },  @type.deserialize("\\ =>\\ "))
     end
 
     def test_parse3
-      assert_equal({"=" => ">"},  @type.deserialize("==>>"))
+      assert_equal({ "=" => ">" },  @type.deserialize("==>>"))
     end
 
     def test_parse4
-      assert_equal({"=a"=>"q=w"},   @type.deserialize('\=a=>q=w'))
+      assert_equal({ "=a"=>"q=w" },   @type.deserialize('\=a=>q=w'))
     end
 
     def test_parse5
-      assert_equal({"=a"=>"q=w"},   @type.deserialize('"=a"=>q\=w'))
+      assert_equal({ "=a"=>"q=w" },   @type.deserialize('"=a"=>q\=w'))
     end
 
     def test_parse6
-      assert_equal({"\"a"=>"q>w"},  @type.deserialize('"\"a"=>q>w'))
+      assert_equal({ "\"a"=>"q>w" },  @type.deserialize('"\"a"=>q>w'))
     end
 
     def test_parse7
-      assert_equal({"\"a"=>"q\"w"}, @type.deserialize('\"a=>q"w'))
+      assert_equal({ "\"a"=>"q\"w" }, @type.deserialize('\"a=>q"w'))
     end
 
     def test_rewrite
@@ -219,19 +219,19 @@ if ActiveRecord::Base.connection.supports_extensions?
     def test_select
       @connection.execute "insert into hstores (tags) VALUES ('1=>2')"
       x = Hstore.first
-      assert_equal({"1" => "2"}, x.tags)
+      assert_equal({ "1" => "2" }, x.tags)
     end
 
     def test_array_cycle
-      assert_array_cycle([{"AA" => "BB", "CC" => "DD"}, {"AA" => nil}])
+      assert_array_cycle([{ "AA" => "BB", "CC" => "DD" }, { "AA" => nil }])
     end
 
     def test_array_strings_with_quotes
-      assert_array_cycle([{"this has" => 'some "s that need to be escaped"'}])
+      assert_array_cycle([{ "this has" => 'some "s that need to be escaped"' }])
     end
 
     def test_array_strings_with_commas
-      assert_array_cycle([{"this,has" => "many,values"}])
+      assert_array_cycle([{ "this,has" => "many,values" }])
     end
 
     def test_array_strings_with_array_delimiters
@@ -239,17 +239,17 @@ if ActiveRecord::Base.connection.supports_extensions?
     end
 
     def test_array_strings_with_null_strings
-      assert_array_cycle([{"NULL" => "NULL"}])
+      assert_array_cycle([{ "NULL" => "NULL" }])
     end
 
     def test_contains_nils
-      assert_array_cycle([{"NULL" => nil}])
+      assert_array_cycle([{ "NULL" => nil }])
     end
 
     def test_select_multikey
       @connection.execute "insert into hstores (tags) VALUES ('1=>2,2=>3')"
       x = Hstore.first
-      assert_equal({"1" => "2", "2" => "3"}, x.tags)
+      assert_equal({ "1" => "2", "2" => "3" }, x.tags)
     end
 
     def test_create
@@ -303,17 +303,17 @@ if ActiveRecord::Base.connection.supports_extensions?
       HstoreWithSerialize.create! tags: TagCollection.new("one" => "two")
       record = HstoreWithSerialize.first
       assert_instance_of TagCollection, record.tags
-      assert_equal({"one" => "two"}, record.tags.to_hash)
+      assert_equal({ "one" => "two" }, record.tags.to_hash)
       record.tags = TagCollection.new("three" => "four")
       record.save!
-      assert_equal({"three" => "four"}, HstoreWithSerialize.first.tags.to_hash)
+      assert_equal({ "three" => "four" }, HstoreWithSerialize.first.tags.to_hash)
     end
 
     def test_clone_hstore_with_serialized_attributes
       HstoreWithSerialize.create! tags: TagCollection.new("one" => "two")
       record = HstoreWithSerialize.first
       dupe = record.dup
-      assert_equal({"one" => "two"}, dupe.tags.to_hash)
+      assert_equal({ "one" => "two" }, dupe.tags.to_hash)
     end
 
     def test_schema_dump_with_shorthand
diff --git a/activerecord/test/cases/adapters/postgresql/json_test.rb b/activerecord/test/cases/adapters/postgresql/json_test.rb
index d0e206ae80..c74f70f251 100644
--- a/activerecord/test/cases/adapters/postgresql/json_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/json_test.rb
@@ -38,11 +38,11 @@ module PostgresqlJSONSharedTestCases
   end
 
   def test_default
-    @connection.add_column "json_data_type", "permissions", column_type, default: {"users": "read", "posts": ["read", "write"]}
+    @connection.add_column "json_data_type", "permissions", column_type, default: { "users": "read", "posts": ["read", "write"] }
     JsonDataType.reset_column_information
 
-    assert_equal({"users"=>"read", "posts"=>["read", "write"]}, JsonDataType.column_defaults["permissions"])
-    assert_equal({"users"=>"read", "posts"=>["read", "write"]}, JsonDataType.new.permissions)
+    assert_equal({ "users"=>"read", "posts"=>["read", "write"] }, JsonDataType.column_defaults["permissions"])
+    assert_equal({ "users"=>"read", "posts"=>["read", "write"] }, JsonDataType.new.permissions)
   ensure
     JsonDataType.reset_column_information
   end
@@ -68,11 +68,11 @@ module PostgresqlJSONSharedTestCases
   end
 
   def test_cast_value_on_write
-    x = JsonDataType.new payload: {"string" => "foo", :symbol => :bar}
-    assert_equal({"string" => "foo", :symbol => :bar}, x.payload_before_type_cast)
-    assert_equal({"string" => "foo", "symbol" => "bar"}, x.payload)
+    x = JsonDataType.new payload: { "string" => "foo", :symbol => :bar }
+    assert_equal({ "string" => "foo", :symbol => :bar }, x.payload_before_type_cast)
+    assert_equal({ "string" => "foo", "symbol" => "bar" }, x.payload)
     x.save
-    assert_equal({"string" => "foo", "symbol" => "bar"}, x.reload.payload)
+    assert_equal({ "string" => "foo", "symbol" => "bar" }, x.reload.payload)
   end
 
   def test_type_cast_json
@@ -80,12 +80,12 @@ module PostgresqlJSONSharedTestCases
 
     data = "{\"a_key\":\"a_value\"}"
     hash = type.deserialize(data)
-    assert_equal({"a_key" => "a_value"}, hash)
-    assert_equal({"a_key" => "a_value"}, type.deserialize(data))
+    assert_equal({ "a_key" => "a_value" }, hash)
+    assert_equal({ "a_key" => "a_value" }, type.deserialize(data))
 
     assert_equal({}, type.deserialize("{}"))
-    assert_equal({"key"=>nil}, type.deserialize('{"key": null}'))
-    assert_equal({"c"=>"}",'"a"'=>'b "a b'}, type.deserialize(%q({"c":"}", "\"a\"":"b \"a b"})))
+    assert_equal({ "key"=>nil }, type.deserialize('{"key": null}'))
+    assert_equal({ "c"=>"}",'"a"'=>'b "a b' }, type.deserialize(%q({"c":"}", "\"a\"":"b \"a b"})))
   end
 
   def test_rewrite
@@ -98,13 +98,13 @@ module PostgresqlJSONSharedTestCases
   def test_select
     @connection.execute "insert into json_data_type (payload) VALUES ('{\"k\":\"v\"}')"
     x = JsonDataType.first
-    assert_equal({"k" => "v"}, x.payload)
+    assert_equal({ "k" => "v" }, x.payload)
   end
 
   def test_select_multikey
     @connection.execute %q|insert into json_data_type (payload) VALUES ('{"k1":"v1", "k2":"v2", "k3":[1,2,3]}')|
     x = JsonDataType.first
-    assert_equal({"k1" => "v1", "k2" => "v2", "k3" => [1,2,3]}, x.payload)
+    assert_equal({ "k1" => "v1", "k2" => "v2", "k3" => [1,2,3] }, x.payload)
   end
 
   def test_null_json
@@ -116,13 +116,13 @@ module PostgresqlJSONSharedTestCases
   def test_select_array_json_value
     @connection.execute %q|insert into json_data_type (payload) VALUES ('["v0",{"k1":"v1"}]')|
     x = JsonDataType.first
-    assert_equal(["v0", {"k1" => "v1"}], x.payload)
+    assert_equal(["v0", { "k1" => "v1" }], x.payload)
   end
 
   def test_rewrite_array_json_value
     @connection.execute %q|insert into json_data_type (payload) VALUES ('["v0",{"k1":"v1"}]')|
     x = JsonDataType.first
-    x.payload = ["v1", {"k2" => "v2"}, "v3"]
+    x.payload = ["v1", { "k2" => "v2" }, "v3"]
     assert x.save!
   end
 
diff --git a/activerecord/test/cases/adapters/postgresql/schema_test.rb b/activerecord/test/cases/adapters/postgresql/schema_test.rb
index d821cbafdf..b0be25de0c 100644
--- a/activerecord/test/cases/adapters/postgresql/schema_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/schema_test.rb
@@ -332,7 +332,7 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
     @connection.execute "CREATE INDEX \"things_Index\" ON #{SCHEMA_NAME}.things (name)"
 
     with_schema_search_path SCHEMA_NAME do
-      assert_nothing_raised { @connection.remove_index "things", name: "things_Index"}
+      assert_nothing_raised { @connection.remove_index "things", name: "things_Index" }
     end
   end
 
diff --git a/activerecord/test/cases/adapters/postgresql/utils_test.rb b/activerecord/test/cases/adapters/postgresql/utils_test.rb
index 70f72dd929..01c597beae 100644
--- a/activerecord/test/cases/adapters/postgresql/utils_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/utils_test.rb
@@ -54,7 +54,7 @@ class PostgreSQLNameTest < ActiveRecord::PostgreSQLTestCase
   end
 
   test "can be used as hash key" do
-    hash = {Name.new("schema", "article_seq") => "success"}
+    hash = { Name.new("schema", "article_seq") => "success" }
     assert_equal "success", hash[Name.new("schema", "article_seq")]
     assert_equal nil, hash[Name.new("schema", "articles")]
     assert_equal nil, hash[Name.new("public", "article_seq")]
diff --git a/activerecord/test/cases/adapters/sqlite3/copy_table_test.rb b/activerecord/test/cases/adapters/sqlite3/copy_table_test.rb
index 70e2f0fec1..8342b05870 100644
--- a/activerecord/test/cases/adapters/sqlite3/copy_table_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/copy_table_test.rb
@@ -11,7 +11,7 @@ class CopyTableTest < ActiveRecord::SQLite3TestCase
   end
 
   def test_copy_table(from = "customers", to = "customers2", options = {})
-    assert_nothing_raised {copy_table(from, to, options)}
+    assert_nothing_raised { copy_table(from, to, options) }
     assert_equal row_count(from), row_count(to)
 
     if block_given?
@@ -25,7 +25,7 @@ class CopyTableTest < ActiveRecord::SQLite3TestCase
 
   def test_copy_table_renaming_column
     test_copy_table("customers", "customers2",
-        rename: {"name" => "person_name"}) do |from, to, options|
+        rename: { "name" => "person_name" }) do |from, to, options|
       expected = column_values(from, "name")
       assert_equal expected, column_values(to, "person_name")
       assert expected.any?, "No values in table: #{expected.inspect}"
@@ -55,8 +55,8 @@ class CopyTableTest < ActiveRecord::SQLite3TestCase
 
   def test_copy_table_with_id_col_that_is_not_primary_key
     test_copy_table("goofy_string_id", "goofy_string_id2") do
-      original_id = @connection.columns("goofy_string_id").detect{|col| col.name == "id" }
-      copied_id = @connection.columns("goofy_string_id2").detect{|col| col.name == "id" }
+      original_id = @connection.columns("goofy_string_id").detect { |col| col.name == "id" }
+      copied_id = @connection.columns("goofy_string_id2").detect { |col| col.name == "id" }
       assert_equal original_id.type, copied_id.type
       assert_equal original_id.sql_type, copied_id.sql_type
       assert_equal original_id.limit, copied_id.limit
@@ -77,15 +77,15 @@ class CopyTableTest < ActiveRecord::SQLite3TestCase
 
 protected
   def copy_table(from, to, options = {})
-    @connection.copy_table(from, to, {temporary: true}.merge(options))
+    @connection.copy_table(from, to, { temporary: true }.merge(options))
   end
 
   def column_names(table)
-    @connection.table_structure(table).map {|column| column["name"]}
+    @connection.table_structure(table).map { |column| column["name"] }
   end
 
   def column_values(table, column)
-    @connection.select_all("SELECT #{column} FROM #{table} ORDER BY id").map {|row| row[column]}
+    @connection.select_all("SELECT #{column} FROM #{table} ORDER BY id").map { |row| row[column] }
   end
 
   def table_indexes_without_name(table)
diff --git a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
index 4800d3d7d5..d2f0710cb2 100644
--- a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
@@ -405,7 +405,7 @@ module ActiveRecord
                                    configurations["arunit"]["database"])
         statement = ::SQLite3::Statement.new(db,
                                            "CREATE TABLE statement_test (number integer not null)")
-        statement.stub(:step, ->{ raise ::SQLite3::BusyException.new("busy") }) do
+        statement.stub(:step, -> { raise ::SQLite3::BusyException.new("busy") }) do
           assert_called(statement, :columns, returns: []) do
             assert_called(statement, :close) do
               ::SQLite3::Statement.stub(:new, statement) do
diff --git a/activerecord/test/cases/associations/belongs_to_associations_test.rb b/activerecord/test/cases/associations/belongs_to_associations_test.rb
index 2413bf0c3a..3f42cb9b9d 100644
--- a/activerecord/test/cases/associations/belongs_to_associations_test.rb
+++ b/activerecord/test/cases/associations/belongs_to_associations_test.rb
@@ -94,7 +94,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
 
     account = model.new
     assert_not account.valid?
-    assert_equal [{error: :blank}], account.errors.details[:company]
+    assert_equal [{ error: :blank }], account.errors.details[:company]
   ensure
     ActiveRecord::Base.belongs_to_required_by_default = original_value
   end
@@ -111,7 +111,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
 
     account = model.new
     assert_not account.valid?
-    assert_equal [{error: :blank}], account.errors.details[:company]
+    assert_equal [{ error: :blank }], account.errors.details[:company]
   ensure
     ActiveRecord::Base.belongs_to_required_by_default = original_value
   end
@@ -203,14 +203,14 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   def test_eager_loading_with_primary_key
     Firm.create("name" => "Apple")
     Client.create("name" => "Citibank", :firm_name => "Apple")
-    citibank_result = Client.all.merge!(where: {name: "Citibank"}, includes: :firm_with_primary_key).first
+    citibank_result = Client.all.merge!(where: { name: "Citibank" }, includes: :firm_with_primary_key).first
     assert citibank_result.association(:firm_with_primary_key).loaded?
   end
 
   def test_eager_loading_with_primary_key_as_symbol
     Firm.create("name" => "Apple")
     Client.create("name" => "Citibank", :firm_name => "Apple")
-    citibank_result = Client.all.merge!(where: {name: "Citibank"}, includes: :firm_with_primary_key_symbols).first
+    citibank_result = Client.all.merge!(where: { name: "Citibank" }, includes: :firm_with_primary_key_symbols).first
     assert citibank_result.association(:firm_with_primary_key_symbols).loaded?
   end
 
@@ -1004,21 +1004,21 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   def test_build_with_block
     client = Client.create(name: "Client Company")
 
-    firm = client.build_firm{ |f| f.name = "Agency Company" }
+    firm = client.build_firm { |f| f.name = "Agency Company" }
     assert_equal "Agency Company", firm.name
   end
 
   def test_create_with_block
     client = Client.create(name: "Client Company")
 
-    firm = client.create_firm{ |f| f.name = "Agency Company" }
+    firm = client.create_firm { |f| f.name = "Agency Company" }
     assert_equal "Agency Company", firm.name
   end
 
   def test_create_bang_with_block
     client = Client.create(name: "Client Company")
 
-    firm = client.create_firm!{ |f| f.name = "Agency Company" }
+    firm = client.create_firm! { |f| f.name = "Agency Company" }
     assert_equal "Agency Company", firm.name
   end
 
diff --git a/activerecord/test/cases/associations/callbacks_test.rb b/activerecord/test/cases/associations/callbacks_test.rb
index 74876c8cf0..c3d560cb56 100644
--- a/activerecord/test/cases/associations/callbacks_test.rb
+++ b/activerecord/test/cases/associations/callbacks_test.rb
@@ -159,7 +159,7 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
       activerecord.reload
       assert activerecord.developers_with_callbacks.size == 2
     end
-    activerecord.developers_with_callbacks.flat_map {|d| ["before_removing#{d.id}","after_removing#{d.id}"]}.sort
+    activerecord.developers_with_callbacks.flat_map { |d| ["before_removing#{d.id}","after_removing#{d.id}"] }.sort
     assert activerecord.developers_with_callbacks.clear
     assert_predicate activerecord.developers_log, :empty?
   end
diff --git a/activerecord/test/cases/associations/cascaded_eager_loading_test.rb b/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
index d79246a6c7..9ae1558dc9 100644
--- a/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
+++ b/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
@@ -16,28 +16,28 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
            :categorizations, :people, :categories, :edges, :vertices
 
   def test_eager_association_loading_with_cascaded_two_levels
-    authors = Author.all.merge!(includes: {posts: :comments}, order: "authors.id").to_a
+    authors = Author.all.merge!(includes: { posts: :comments }, order: "authors.id").to_a
     assert_equal 3, authors.size
     assert_equal 5, authors[0].posts.size
     assert_equal 3, authors[1].posts.size
-    assert_equal 10, authors[0].posts.collect{|post| post.comments.size }.inject(0){|sum,i| sum+i}
+    assert_equal 10, authors[0].posts.collect { |post| post.comments.size }.inject(0) { |sum,i| sum+i }
   end
 
   def test_eager_association_loading_with_cascaded_two_levels_and_one_level
-    authors = Author.all.merge!(includes: [{posts: :comments}, :categorizations], order: "authors.id").to_a
+    authors = Author.all.merge!(includes: [{ posts: :comments }, :categorizations], order: "authors.id").to_a
     assert_equal 3, authors.size
     assert_equal 5, authors[0].posts.size
     assert_equal 3, authors[1].posts.size
-    assert_equal 10, authors[0].posts.collect{|post| post.comments.size }.inject(0){|sum,i| sum+i}
+    assert_equal 10, authors[0].posts.collect { |post| post.comments.size }.inject(0) { |sum,i| sum+i }
     assert_equal 1, authors[0].categorizations.size
     assert_equal 2, authors[1].categorizations.size
   end
 
   def test_eager_association_loading_with_hmt_does_not_table_name_collide_when_joining_associations
     assert_nothing_raised do
-      Author.joins(:posts).eager_load(:comments).where(posts: {tags_count: 1}).to_a
+      Author.joins(:posts).eager_load(:comments).where(posts: { tags_count: 1 }).to_a
     end
-    authors = Author.joins(:posts).eager_load(:comments).where(posts: {tags_count: 1}).to_a
+    authors = Author.joins(:posts).eager_load(:comments).where(posts: { tags_count: 1 }).to_a
     assert_equal 1, assert_no_queries { authors.size }
     assert_equal 10, assert_no_queries { authors[0].comments.size }
   end
@@ -50,7 +50,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_cascaded_eager_association_loading_with_join_for_count
-    categories = Category.joins(:categorizations).includes([{posts: :comments}, :authors])
+    categories = Category.joins(:categorizations).includes([{ posts: :comments }, :authors])
 
     assert_equal 4, categories.count
     assert_equal 4, categories.to_a.count
@@ -82,29 +82,29 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_cascaded_two_levels_with_two_has_many_associations
-    authors = Author.all.merge!(includes: {posts: [:comments, :categorizations]}, order: "authors.id").to_a
+    authors = Author.all.merge!(includes: { posts: [:comments, :categorizations] }, order: "authors.id").to_a
     assert_equal 3, authors.size
     assert_equal 5, authors[0].posts.size
     assert_equal 3, authors[1].posts.size
-    assert_equal 10, authors[0].posts.collect{|post| post.comments.size }.inject(0){|sum,i| sum+i}
+    assert_equal 10, authors[0].posts.collect { |post| post.comments.size }.inject(0) { |sum,i| sum+i }
   end
 
   def test_eager_association_loading_with_cascaded_two_levels_and_self_table_reference
-    authors = Author.all.merge!(includes: {posts: [:comments, :author]}, order: "authors.id").to_a
+    authors = Author.all.merge!(includes: { posts: [:comments, :author] }, order: "authors.id").to_a
     assert_equal 3, authors.size
     assert_equal 5, authors[0].posts.size
     assert_equal authors(:david).name, authors[0].name
-    assert_equal [authors(:david).name], authors[0].posts.collect{|post| post.author.name}.uniq
+    assert_equal [authors(:david).name], authors[0].posts.collect { |post| post.author.name }.uniq
   end
 
   def test_eager_association_loading_with_cascaded_two_levels_with_condition
-    authors = Author.all.merge!(includes: {posts: :comments}, where: "authors.id=1", order: "authors.id").to_a
+    authors = Author.all.merge!(includes: { posts: :comments }, where: "authors.id=1", order: "authors.id").to_a
     assert_equal 1, authors.size
     assert_equal 5, authors[0].posts.size
   end
 
   def test_eager_association_loading_with_cascaded_three_levels_by_ping_pong
-    firms = Firm.all.merge!(includes: {account: {firm: :account}}, order: "companies.id").to_a
+    firms = Firm.all.merge!(includes: { account: { firm: :account } }, order: "companies.id").to_a
     assert_equal 2, firms.size
     assert_equal firms.first.account, firms.first.account.firm.account
     assert_equal companies(:first_firm).account, assert_no_queries { firms.first.account.firm.account }
@@ -158,7 +158,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_where_first_level_returns_nil
-    authors = Author.all.merge!(includes: {post_about_thinking: :comments}, order: "authors.id DESC").to_a
+    authors = Author.all.merge!(includes: { post_about_thinking: :comments }, order: "authors.id DESC").to_a
     assert_equal [authors(:bob), authors(:mary), authors(:david)], authors
     assert_no_queries do
       authors[2].post_about_thinking.comments.first
@@ -166,12 +166,12 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_recursive_cascading_four_levels_has_many_through
-    source = Vertex.all.merge!(includes: {sinks: {sinks: {sinks: :sinks}}}, order: "vertices.id").first
+    source = Vertex.all.merge!(includes: { sinks: { sinks: { sinks: :sinks } } }, order: "vertices.id").first
     assert_equal vertices(:vertex_4), assert_no_queries { source.sinks.first.sinks.first.sinks.first }
   end
 
   def test_eager_association_loading_with_recursive_cascading_four_levels_has_and_belongs_to_many
-    sink = Vertex.all.merge!(includes: {sources: {sources: {sources: :sources}}}, order: "vertices.id DESC").first
+    sink = Vertex.all.merge!(includes: { sources: { sources: { sources: :sources } } }, order: "vertices.id DESC").first
     assert_equal vertices(:vertex_1), assert_no_queries { sink.sources.first.sources.first.sources.first.sources.first }
   end
 
diff --git a/activerecord/test/cases/associations/eager_load_nested_include_test.rb b/activerecord/test/cases/associations/eager_load_nested_include_test.rb
index aebece1b91..a7a8c6a783 100644
--- a/activerecord/test/cases/associations/eager_load_nested_include_test.rb
+++ b/activerecord/test/cases/associations/eager_load_nested_include_test.rb
@@ -117,8 +117,8 @@ class EagerLoadNestedIncludeWithMissingDataTest < ActiveRecord::TestCase
   def test_missing_data_in_a_nested_include_should_not_cause_errors_when_constructing_objects
     assert_nothing_raised do
       # @davey_mcdave doesn't have any author_favorites
-      includes = {posts: :comments, categorizations: :category, author_favorites: :favorite_author }
-      Author.all.merge!(includes: includes, where: {authors: {name: @davey_mcdave.name}}, order: "categories.name").to_a
+      includes = { posts: :comments, categorizations: :category, author_favorites: :favorite_author }
+      Author.all.merge!(includes: includes, where: { authors: { name: @davey_mcdave.name } }, order: "categories.name").to_a
     end
   end
 end
diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index c7c945e33f..2c826acf96 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -109,7 +109,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   def test_duplicate_middle_objects
     comments = Comment.all.merge!(where: "post_id = 1", includes: [post: :author]).to_a
     assert_no_queries do
-      comments.each {|comment| comment.post.author.name}
+      comments.each { |comment| comment.post.author.name }
     end
   end
 
@@ -175,7 +175,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
     popular_post.readers.create!(person: people(:david))
 
     readers = Reader.all.merge!(where: ["post_id = ?", popular_post.id],
-                                includes: {post: :comments}).to_a
+                                includes: { post: :comments }).to_a
     readers.each do |reader|
       assert_equal [comment], reader.post.comments
     end
@@ -188,7 +188,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
     comment = car_post.comments.create!(body: "hmm")
     categories = Category.all.merge!(where: { "posts.id" => car_post.id },
-                                 includes: {posts: :comments}).to_a
+                                 includes: { posts: :comments }).to_a
     categories.each do |category|
       assert_equal [comment], category.posts[0].comments
     end
@@ -206,7 +206,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_finding_with_includes_on_has_many_association_with_same_include_includes_only_once
     author_id = authors(:david).id
-    author = assert_queries(3) { Author.all.merge!(includes: {posts_with_comments: :comments}).find(author_id) } # find the author, then find the posts, then find the comments
+    author = assert_queries(3) { Author.all.merge!(includes: { posts_with_comments: :comments }).find(author_id) } # find the author, then find the posts, then find the comments
     author.posts_with_comments.each do |post_with_comments|
       assert_equal post_with_comments.comments.length, post_with_comments.comments.count
       assert_nil post_with_comments.comments.to_a.uniq!
@@ -217,7 +217,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
     author = authors(:david)
     post = author.post_about_thinking_with_last_comment
     last_comment = post.last_comment
-    author = assert_queries(3) { Author.all.merge!(includes: {post_about_thinking_with_last_comment: :last_comment}).find(author.id)} # find the author, then find the posts, then find the comments
+    author = assert_queries(3) { Author.all.merge!(includes: { post_about_thinking_with_last_comment: :last_comment }).find(author.id) } # find the author, then find the posts, then find the comments
     assert_no_queries do
       assert_equal post, author.post_about_thinking_with_last_comment
       assert_equal last_comment, author.post_about_thinking_with_last_comment.last_comment
@@ -228,7 +228,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
     post = posts(:welcome)
     author = post.author
     author_address = author.author_address
-    post = assert_queries(3) { Post.all.merge!(includes: {author_with_address: :author_address}).find(post.id) } # find the post, then find the author, then find the address
+    post = assert_queries(3) { Post.all.merge!(includes: { author_with_address: :author_address }).find(post.id) } # find the post, then find the author, then find the address
     assert_no_queries do
       assert_equal author, post.author_with_address
       assert_equal author_address, post.author_with_address.author_address
@@ -238,7 +238,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   def test_finding_with_includes_on_null_belongs_to_association_with_same_include_includes_only_once
     post = posts(:welcome)
     post.update!(author: nil)
-    post = assert_queries(1) { Post.all.merge!(includes: {author_with_address: :author_address}).find(post.id) }
+    post = assert_queries(1) { Post.all.merge!(includes: { author_with_address: :author_address }).find(post.id) }
     # find the post, then find the author which is null so no query for the author or address
     assert_no_queries do
       assert_equal nil, post.author_with_address
@@ -284,7 +284,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   # Regression test for 21c75e5
   def test_nested_loading_does_not_raise_exception_when_association_does_not_exist
     assert_nothing_raised do
-      Post.all.merge!(includes: {author: :author_addresss}).find(posts(:authorless).id)
+      Post.all.merge!(includes: { author: :author_addresss }).find(posts(:authorless).id)
     end
   end
 
@@ -292,33 +292,33 @@ class EagerAssociationTest < ActiveRecord::TestCase
     post_id = Comment.where(author_id: nil).where.not(post_id: nil).first.post_id
 
     assert_nothing_raised do
-      Post.preload(comments: [{author: :essays}]).find(post_id)
+      Post.preload(comments: [{ author: :essays }]).find(post_id)
     end
   end
 
   def test_nested_loading_through_has_one_association
-    aa = AuthorAddress.all.merge!(includes: {author: :posts}).find(author_addresses(:david_address).id)
+    aa = AuthorAddress.all.merge!(includes: { author: :posts }).find(author_addresses(:david_address).id)
     assert_equal aa.author.posts.count, aa.author.posts.length
   end
 
   def test_nested_loading_through_has_one_association_with_order
-    aa = AuthorAddress.all.merge!(includes: {author: :posts}, order: "author_addresses.id").find(author_addresses(:david_address).id)
+    aa = AuthorAddress.all.merge!(includes: { author: :posts }, order: "author_addresses.id").find(author_addresses(:david_address).id)
     assert_equal aa.author.posts.count, aa.author.posts.length
   end
 
   def test_nested_loading_through_has_one_association_with_order_on_association
-    aa = AuthorAddress.all.merge!(includes: {author: :posts}, order: "authors.id").find(author_addresses(:david_address).id)
+    aa = AuthorAddress.all.merge!(includes: { author: :posts }, order: "authors.id").find(author_addresses(:david_address).id)
     assert_equal aa.author.posts.count, aa.author.posts.length
   end
 
   def test_nested_loading_through_has_one_association_with_order_on_nested_association
-    aa = AuthorAddress.all.merge!(includes: {author: :posts}, order: "posts.id").find(author_addresses(:david_address).id)
+    aa = AuthorAddress.all.merge!(includes: { author: :posts }, order: "posts.id").find(author_addresses(:david_address).id)
     assert_equal aa.author.posts.count, aa.author.posts.length
   end
 
   def test_nested_loading_through_has_one_association_with_conditions
     aa = AuthorAddress.references(:author_addresses).merge(
-      includes: {author: :posts},
+      includes: { author: :posts },
       where: "author_addresses.id > 0"
     ).find author_addresses(:david_address).id
     assert_equal aa.author.posts.count, aa.author.posts.length
@@ -326,7 +326,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_nested_loading_through_has_one_association_with_conditions_on_association
     aa = AuthorAddress.references(:authors).merge(
-      includes: {author: :posts},
+      includes: { author: :posts },
       where: "authors.id > 0"
     ).find author_addresses(:david_address).id
     assert_equal aa.author.posts.count, aa.author.posts.length
@@ -334,7 +334,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_nested_loading_through_has_one_association_with_conditions_on_nested_association
     aa = AuthorAddress.references(:posts).merge(
-      includes: {author: :posts},
+      includes: { author: :posts },
       where: "posts.id > 0"
     ).find author_addresses(:david_address).id
     assert_equal aa.author.posts.count, aa.author.posts.length
@@ -392,7 +392,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   def test_eager_association_loading_with_belongs_to_and_conditions_hash
     comments = []
     assert_nothing_raised do
-      comments = Comment.all.merge!(includes: :post, where: {posts: {id: 4}}, limit: 3, order: "comments.id").to_a
+      comments = Comment.all.merge!(includes: :post, where: { posts: { id: 4 } }, limit: 3, order: "comments.id").to_a
     end
     assert_equal 3, comments.length
     assert_equal [5,6,7], comments.collect(&:id)
@@ -441,25 +441,25 @@ class EagerAssociationTest < ActiveRecord::TestCase
   def test_eager_load_belongs_to_quotes_table_and_column_names
     job = Job.includes(:ideal_reference).find jobs(:unicyclist).id
     references(:michael_unicyclist)
-    assert_no_queries{ assert_equal references(:michael_unicyclist), job.ideal_reference}
+    assert_no_queries { assert_equal references(:michael_unicyclist), job.ideal_reference }
   end
 
   def test_eager_load_has_one_quotes_table_and_column_names
     michael = Person.all.merge!(includes: :favourite_reference).find(people(:michael).id)
     references(:michael_unicyclist)
-    assert_no_queries{ assert_equal references(:michael_unicyclist), michael.favourite_reference}
+    assert_no_queries { assert_equal references(:michael_unicyclist), michael.favourite_reference }
   end
 
   def test_eager_load_has_many_quotes_table_and_column_names
     michael = Person.all.merge!(includes: :references).find(people(:michael).id)
     references(:michael_magician,:michael_unicyclist)
-    assert_no_queries{ assert_equal references(:michael_magician,:michael_unicyclist), michael.references.sort_by(&:id) }
+    assert_no_queries { assert_equal references(:michael_magician,:michael_unicyclist), michael.references.sort_by(&:id) }
   end
 
   def test_eager_load_has_many_through_quotes_table_and_column_names
     michael = Person.all.merge!(includes: :jobs).find(people(:michael).id)
     jobs(:magician, :unicyclist)
-    assert_no_queries{ assert_equal jobs(:unicyclist, :magician), michael.jobs.sort_by(&:id) }
+    assert_no_queries { assert_equal jobs(:unicyclist, :magician), michael.jobs.sort_by(&:id) }
   end
 
   def test_eager_load_has_many_with_string_keys
@@ -903,8 +903,8 @@ class EagerAssociationTest < ActiveRecord::TestCase
   def test_eager_with_multiple_associations_with_same_table_has_many_and_habtm
     # Eager includes of has many and habtm associations aren't necessarily sorted in the same way
     def assert_equal_after_sort(item1, item2, item3 = nil)
-      assert_equal(item1.sort{|a,b| a.id <=> b.id}, item2.sort{|a,b| a.id <=> b.id})
-      assert_equal(item3.sort{|a,b| a.id <=> b.id}, item2.sort{|a,b| a.id <=> b.id}) if item3
+      assert_equal(item1.sort { |a,b| a.id <=> b.id }, item2.sort { |a,b| a.id <=> b.id })
+      assert_equal(item3.sort { |a,b| a.id <=> b.id }, item2.sort { |a,b| a.id <=> b.id }) if item3
     end
     # Test regular association, association with conditions, association with
     # STI, and association with conditions assured not to be true
@@ -959,12 +959,12 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_preconfigured_includes_with_belongs_to
     author = posts(:welcome).author_with_posts
-    assert_no_queries {assert_equal 5, author.posts.size}
+    assert_no_queries { assert_equal 5, author.posts.size }
   end
 
   def test_preconfigured_includes_with_has_one
     comment = posts(:sti_comments).very_special_comment_with_post
-    assert_no_queries {assert_equal posts(:sti_comments), comment.post}
+    assert_no_queries { assert_equal posts(:sti_comments), comment.post }
   end
 
   def test_eager_association_with_scope_with_joins
@@ -1066,7 +1066,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
       Post.all.merge!(joins: :comments, includes: :author, order: "comments.id DESC").to_a
     end
     assert_equal posts(:eager_other), posts[1]
-    assert_equal authors(:mary), assert_no_queries { posts[1].author}
+    assert_equal authors(:mary), assert_no_queries { posts[1].author }
   end
 
   def test_eager_loading_with_conditions_on_joined_table_preloads
@@ -1074,21 +1074,21 @@ class EagerAssociationTest < ActiveRecord::TestCase
       Post.all.merge!(select: "distinct posts.*", includes: :author, joins: [:comments], where: "comments.body like 'Thank you%'", order: "posts.id").to_a
     end
     assert_equal [posts(:welcome)], posts
-    assert_equal authors(:david), assert_no_queries { posts[0].author}
+    assert_equal authors(:david), assert_no_queries { posts[0].author }
 
     posts = assert_queries(2) do
       Post.all.merge!(select: "distinct posts.*", includes: :author, joins: [:comments], where: "comments.body like 'Thank you%'", order: "posts.id").to_a
     end
     assert_equal [posts(:welcome)], posts
-    assert_equal authors(:david), assert_no_queries { posts[0].author}
+    assert_equal authors(:david), assert_no_queries { posts[0].author }
 
     posts = assert_queries(2) do
-      Post.all.merge!(includes: :author, joins: {taggings: :tag}, where: "tags.name = 'General'", order: "posts.id").to_a
+      Post.all.merge!(includes: :author, joins: { taggings: :tag }, where: "tags.name = 'General'", order: "posts.id").to_a
     end
     assert_equal posts(:welcome, :thinking), posts
 
     posts = assert_queries(2) do
-      Post.all.merge!(includes: :author, joins: {taggings: {tag: :taggings}}, where: "taggings_tags.super_tag_id=2", order: "posts.id").to_a
+      Post.all.merge!(includes: :author, joins: { taggings: { tag: :taggings } }, where: "taggings_tags.super_tag_id=2", order: "posts.id").to_a
     end
     assert_equal posts(:welcome, :thinking), posts
   end
@@ -1110,13 +1110,13 @@ class EagerAssociationTest < ActiveRecord::TestCase
       Post.all.merge!(select: "distinct posts.*", includes: :author, joins: "INNER JOIN comments on comments.post_id = posts.id", where: "comments.body like 'Thank you%'", order: "posts.id").to_a
     end
     assert_equal [posts(:welcome)], posts
-    assert_equal authors(:david), assert_no_queries { posts[0].author}
+    assert_equal authors(:david), assert_no_queries { posts[0].author }
 
     posts = assert_queries(2) do
       Post.all.merge!(select: "distinct posts.*", includes: :author, joins: ["INNER JOIN comments on comments.post_id = posts.id"], where: "comments.body like 'Thank you%'", order: "posts.id").to_a
     end
     assert_equal [posts(:welcome)], posts
-    assert_equal authors(:david), assert_no_queries { posts[0].author}
+    assert_equal authors(:david), assert_no_queries { posts[0].author }
   end
 
   def test_eager_loading_with_select_on_joined_table_preloads
@@ -1124,7 +1124,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
       Post.all.merge!(select: "posts.*, authors.name as author_name", includes: :comments, joins: :author, order: "posts.id").to_a
     end
     assert_equal "David", posts[0].author_name
-    assert_equal posts(:welcome).comments, assert_no_queries { posts[0].comments}
+    assert_equal posts(:welcome).comments, assert_no_queries { posts[0].comments }
   end
 
   def test_eager_loading_with_conditions_on_join_model_preloads
@@ -1139,7 +1139,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
     people = Person.males.merge(includes: :primary_contact).to_a
     assert_not_equal people.length, 0
     people.each do |person|
-      assert_no_queries {assert_not_nil person.primary_contact}
+      assert_no_queries { assert_not_nil person.primary_contact }
       assert_equal Person.find(person.id).primary_contact, person.primary_contact
     end
   end
@@ -1182,7 +1182,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_include_has_one_using_primary_key
     expected = accounts(:signals37)
-    firm = Firm.all.merge!(includes: :account_using_primary_key, order: "accounts.id").to_a.detect {|f| f.id == 1}
+    firm = Firm.all.merge!(includes: :account_using_primary_key, order: "accounts.id").to_a.detect { |f| f.id == 1 }
     assert_no_queries do
       assert_equal expected, firm.account_using_primary_key
     end
@@ -1253,16 +1253,16 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_join_eager_with_empty_order_should_generate_valid_sql
     assert_nothing_raised do
-      Post.includes(:comments).order("").where(comments: {body: "Thank you for the welcome"}).first
+      Post.includes(:comments).order("").where(comments: { body: "Thank you for the welcome" }).first
     end
   end
 
   def test_deep_including_through_habtm
     # warm up habtm cache
-    posts = Post.all.merge!(includes: {categories: :categorizations}, order: "posts.id").to_a
+    posts = Post.all.merge!(includes: { categories: :categorizations }, order: "posts.id").to_a
     posts[0].categories[0].categorizations.length
 
-    posts = Post.all.merge!(includes: {categories: :categorizations}, order: "posts.id").to_a
+    posts = Post.all.merge!(includes: { categories: :categorizations }, order: "posts.id").to_a
     assert_no_queries { assert_equal 2, posts[0].categories[0].categorizations.length }
     assert_no_queries { assert_equal 1, posts[0].categories[1].categorizations.length }
     assert_no_queries { assert_equal 2, posts[1].categories[0].categorizations.length }
@@ -1360,7 +1360,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   test "including associations with where.not adds implicit references" do
     author = assert_queries(2) {
-      Author.includes(:posts).where.not(posts: { title: "Welcome to the weblog"} ).last
+      Author.includes(:posts).where.not(posts: { title: "Welcome to the weblog" } ).last
     }
 
     assert_no_queries {
diff --git a/activerecord/test/cases/associations/extension_test.rb b/activerecord/test/cases/associations/extension_test.rb
index 8f9fc10ba5..cc86e1a16d 100644
--- a/activerecord/test/cases/associations/extension_test.rb
+++ b/activerecord/test/cases/associations/extension_test.rb
@@ -76,6 +76,6 @@ class AssociationsExtensionsTest < ActiveRecord::TestCase
   private
 
     def extend!(model)
-      ActiveRecord::Associations::Builder::HasMany.define_extensions(model, :association_name) { }
+      ActiveRecord::Associations::Builder::HasMany.define_extensions(model, :association_name) {}
     end
 end
diff --git a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
index ec6ae39835..36f541a506 100644
--- a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
@@ -258,7 +258,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   def test_habtm_saving_multiple_relationships
     new_project = Project.new("name" => "Grimetime")
     amount_of_developers = 4
-    developers = (0...amount_of_developers).collect {|i| Developer.create(name: "JME #{i}") }.reverse
+    developers = (0...amount_of_developers).collect { |i| Developer.create(name: "JME #{i}") }.reverse
 
     new_project.developer_ids = [developers[0].id, developers[1].id]
     new_project.developers_with_callback_ids = [developers[2].id, developers[3].id]
@@ -588,7 +588,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_dynamic_find_all_should_respect_readonly_access
-    projects(:active_record).readonly_developers.each { |d| assert_raise(ActiveRecord::ReadOnlyRecord) { d.save!  } if d.valid?}
+    projects(:active_record).readonly_developers.each { |d| assert_raise(ActiveRecord::ReadOnlyRecord) { d.save!  } if d.valid? }
     projects(:active_record).readonly_developers.each(&:readonly?)
   end
 
@@ -700,7 +700,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_equal(
       3,
       Developer.references(:developers_projects_join).merge(
-        includes: {projects: :developers},
+        includes: { projects: :developers },
         where: "projects_developers_projects_join.joined_on IS NOT NULL"
       ).to_a.size
     )
@@ -720,7 +720,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_equal(
       3,
       Developer.references(:developers_projects_join).merge(
-        includes: {projects: :developers}, where: "projects_developers_projects_join.joined_on IS NOT NULL",
+        includes: { projects: :developers }, where: "projects_developers_projects_join.joined_on IS NOT NULL",
         group: group.join(",")
       ).to_a.size
     )
diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index 09692fc3a0..cc4419790c 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -305,7 +305,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   test "building the association with an array" do
     speedometer = Speedometer.new(speedometer_id: "a")
-    data = [{name: "first"}, {name: "second"}]
+    data = [{ name: "first" }, { name: "second" }]
     speedometer.minivans.build(data)
 
     assert_equal 2, speedometer.minivans.size
@@ -487,7 +487,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_finding_array_compatibility
-    assert_equal 3, Firm.order(:id).find{|f| f.id > 0}.clients.length
+    assert_equal 3, Firm.order(:id).find { |f| f.id > 0 }.clients.length
   end
 
   def test_find_many_with_merged_options
@@ -644,7 +644,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert ! firm.clients.loaded?
 
     assert_queries(4) do
-      firm.clients.find_each(batch_size: 1) {|c| assert_equal firm.id, c.firm_id }
+      firm.clients.find_each(batch_size: 1) { |c| assert_equal firm.id, c.firm_id }
     end
 
     assert ! firm.clients.loaded?
@@ -670,7 +670,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
     assert_queries(2) do
       firm.clients.find_in_batches(batch_size: 2) do |clients|
-        clients.each {|c| assert_equal firm.id, c.firm_id }
+        clients.each { |c| assert_equal firm.id, c.firm_id }
       end
     end
 
@@ -701,7 +701,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_find_all_with_include_and_conditions
     assert_nothing_raised do
-      Developer.all.merge!(joins: :audit_logs, where: {"audit_logs.message" => nil, :name => "Smith"}).to_a
+      Developer.all.merge!(joins: :audit_logs, where: { "audit_logs.message" => nil, :name => "Smith" }).to_a
     end
   end
 
@@ -888,7 +888,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_build_many
     company = companies(:first_firm)
-    new_clients = assert_no_queries(ignore_none: false) { company.clients_of_firm.build([{"name" => "Another Client"}, {"name" => "Another Client II"}]) }
+    new_clients = assert_no_queries(ignore_none: false) { company.clients_of_firm.build([{ "name" => "Another Client" }, { "name" => "Another Client II" }]) }
     assert_equal 2, new_clients.size
   end
 
@@ -914,7 +914,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_build_via_block
     company = companies(:first_firm)
-    new_client = assert_no_queries(ignore_none: false) { company.clients_of_firm.build {|client| client.name = "Another Client" } }
+    new_client = assert_no_queries(ignore_none: false) { company.clients_of_firm.build { |client| client.name = "Another Client" } }
     assert !company.clients_of_firm.loaded?
 
     assert_equal "Another Client", new_client.name
@@ -925,7 +925,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_build_many_via_block
     company = companies(:first_firm)
     new_clients = assert_no_queries(ignore_none: false) do
-      company.clients_of_firm.build([{"name" => "Another Client"}, {"name" => "Another Client II"}]) do |client|
+      company.clients_of_firm.build([{ "name" => "Another Client" }, { "name" => "Another Client II" }]) do |client|
         client.name = "changed"
       end
     end
@@ -962,7 +962,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_create_many
-    companies(:first_firm).clients_of_firm.create([{"name" => "Another Client"}, {"name" => "Another Client II"}])
+    companies(:first_firm).clients_of_firm.create([{ "name" => "Another Client" }, { "name" => "Another Client II" }])
     assert_equal 4, companies(:first_firm).clients_of_firm.reload.size
   end
 
@@ -1564,7 +1564,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_restrict_with_error_with_locale
     I18n.backend = I18n::Backend::Simple.new
-    I18n.backend.store_translations "en", activerecord: {attributes: {restricted_with_error_firm: {companies: "client companies"}}}
+    I18n.backend.store_translations "en", activerecord: { attributes: { restricted_with_error_firm: { companies: "client companies" } } }
     firm = RestrictedWithErrorFirm.create!(name: "restrict")
     firm.companies.create(name: "child")
 
@@ -1742,7 +1742,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
       lambda { authors(:mary).comments = [comments(:greetings), comments(:more_greetings)] },
       lambda { authors(:mary).comments << Comment.create!(body: "Yay", post_id: 424242) },
       lambda { authors(:mary).comments.delete(authors(:mary).comments.first) },
-    ].each {|block| assert_raise(ActiveRecord::HasManyThroughCantAssociateThroughHasOneOrManyReflection, &block) }
+    ].each { |block| assert_raise(ActiveRecord::HasManyThroughCantAssociateThroughHasOneOrManyReflection, &block) }
   end
 
   def test_dynamic_find_should_respect_association_order_for_through
diff --git a/activerecord/test/cases/associations/has_many_through_associations_test.rb b/activerecord/test/cases/associations/has_many_through_associations_test.rb
index 90004eb70f..3508793122 100644
--- a/activerecord/test/cases/associations/has_many_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_through_associations_test.rb
@@ -348,7 +348,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_delete_association
-    assert_queries(2){posts(:welcome);people(:michael); }
+    assert_queries(2) { posts(:welcome);people(:michael); }
 
     assert_queries(1) do
       posts(:welcome).people.delete(people(:michael))
@@ -541,7 +541,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_replace_association
-    assert_queries(4){posts(:welcome);people(:david);people(:michael); posts(:welcome).people.reload}
+    assert_queries(4) { posts(:welcome);people(:david);people(:michael); posts(:welcome).people.reload }
 
     # 1 query to delete the existing reader (michael)
     # 1 query to associate the new reader (david)
@@ -549,7 +549,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
       posts(:welcome).people = [people(:david)]
     end
 
-    assert_queries(0){
+    assert_queries(0) {
       assert posts(:welcome).people.include?(people(:david))
       assert !posts(:welcome).people.include?(people(:michael))
     }
@@ -658,7 +658,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_push_with_invalid_join_record
     repair_validations(Contract) do
-      Contract.validate {|r| r.errors[:base] << "Invalid Contract" }
+      Contract.validate { |r| r.errors[:base] << "Invalid Contract" }
 
       firm = companies(:first_firm)
       lifo = Developer.new(name: "lifo")
@@ -812,7 +812,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
       lambda { authors(:david).very_special_comments = [VerySpecialComment.create!(body: "Gorp!", post_id: 1011), VerySpecialComment.create!(body: "Eep!", post_id: 1012)] },
       lambda { authors(:david).very_special_comments << VerySpecialComment.create!(body: "Hoohah!", post_id: 1013) },
       lambda { authors(:david).very_special_comments.delete(authors(:david).very_special_comments.first) },
-    ].each {|block| assert_raise(ActiveRecord::HasManyThroughCantAssociateThroughHasOneOrManyReflection, &block) }
+    ].each { |block| assert_raise(ActiveRecord::HasManyThroughCantAssociateThroughHasOneOrManyReflection, &block) }
   end
 
   def test_has_many_association_through_a_has_many_association_to_self
@@ -886,7 +886,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   def test_collection_singular_ids_setter_raises_exception_when_invalid_ids_set
     company = companies(:rails_core)
     ids =  [Developer.first.id, -9999]
-    assert_raises(ActiveRecord::AssociationTypeMismatch) {company.developer_ids= ids}
+    assert_raises(ActiveRecord::AssociationTypeMismatch) { company.developer_ids= ids }
   end
 
   def test_build_a_model_from_hm_through_association_with_where_clause
diff --git a/activerecord/test/cases/associations/has_one_associations_test.rb b/activerecord/test/cases/associations/has_one_associations_test.rb
index ad0d47920d..1a0e6d2f8e 100644
--- a/activerecord/test/cases/associations/has_one_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_associations_test.rb
@@ -221,7 +221,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
 
   def test_restrict_with_error_with_locale
     I18n.backend = I18n::Backend::Simple.new
-    I18n.backend.store_translations "en", activerecord: {attributes: {restricted_with_error_firm: {account: "firm account"}}}
+    I18n.backend.store_translations "en", activerecord: { attributes: { restricted_with_error_firm: { account: "firm account" } } }
     firm = RestrictedWithErrorFirm.create!(name: "restrict")
     firm.create_account(credit_limit: 10)
 
@@ -539,21 +539,21 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
   def test_build_with_block
     car = Car.create(name: "honda")
 
-    bulb = car.build_bulb{ |b| b.color = "Red" }
+    bulb = car.build_bulb { |b| b.color = "Red" }
     assert_equal "RED!", bulb.color
   end
 
   def test_create_with_block
     car = Car.create(name: "honda")
 
-    bulb = car.create_bulb{ |b| b.color = "Red" }
+    bulb = car.create_bulb { |b| b.color = "Red" }
     assert_equal "RED!", bulb.color
   end
 
   def test_create_bang_with_block
     car = Car.create(name: "honda")
 
-    bulb = car.create_bulb!{ |b| b.color = "Red" }
+    bulb = car.create_bulb! { |b| b.color = "Red" }
     assert_equal "RED!", bulb.color
   end
 
diff --git a/activerecord/test/cases/associations/has_one_through_associations_test.rb b/activerecord/test/cases/associations/has_one_through_associations_test.rb
index 3a7f48fbb7..e95eeb64db 100644
--- a/activerecord/test/cases/associations/has_one_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_through_associations_test.rb
@@ -95,7 +95,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
       Member.all.merge!(includes: :club, where: ["name = ?", "Groucho Marx"]).to_a
     end
     assert_equal 1, members.size
-    assert_not_nil assert_no_queries {members[0].club}
+    assert_not_nil assert_no_queries { members[0].club }
   end
 
   def test_has_one_through_eager_loading_through_polymorphic
@@ -103,7 +103,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
       Member.all.merge!(includes: :sponsor_club, where: ["name = ?", "Groucho Marx"]).to_a
     end
     assert_equal 1, members.size
-    assert_not_nil assert_no_queries {members[0].sponsor_club}
+    assert_not_nil assert_no_queries { members[0].sponsor_club }
   end
 
   def test_has_one_through_with_conditions_eager_loading
@@ -125,7 +125,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   def test_eager_has_one_through_polymorphic_with_source_type
     clubs = Club.all.merge!(includes: :sponsored_member, where: ["name = ?","Moustache and Eyebrow Fancier Club"]).to_a
     # Only the eyebrow fanciers club has a sponsored_member
-    assert_not_nil assert_no_queries {clubs[0].sponsored_member}
+    assert_not_nil assert_no_queries { clubs[0].sponsored_member }
   end
 
   def test_has_one_through_nonpreload_eagerloading
@@ -133,7 +133,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
       Member.all.merge!(includes: :club, where: ["members.name = ?", "Groucho Marx"], order: "clubs.name").to_a #force fallback
     end
     assert_equal 1, members.size
-    assert_not_nil assert_no_queries {members[0].club}
+    assert_not_nil assert_no_queries { members[0].club }
   end
 
   def test_has_one_through_nonpreload_eager_loading_through_polymorphic
@@ -141,7 +141,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
       Member.all.merge!(includes: :sponsor_club, where: ["members.name = ?", "Groucho Marx"], order: "clubs.name").to_a #force fallback
     end
     assert_equal 1, members.size
-    assert_not_nil assert_no_queries {members[0].sponsor_club}
+    assert_not_nil assert_no_queries { members[0].sponsor_club }
   end
 
   def test_has_one_through_nonpreload_eager_loading_through_polymorphic_with_more_than_one_through_record
diff --git a/activerecord/test/cases/associations/inner_join_association_test.rb b/activerecord/test/cases/associations/inner_join_association_test.rb
index be5c8854be..7414869c8f 100644
--- a/activerecord/test/cases/associations/inner_join_association_test.rb
+++ b/activerecord/test/cases/associations/inner_join_association_test.rb
@@ -20,7 +20,7 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
 
   def test_construct_finder_sql_does_not_table_name_collide_on_duplicate_associations
     assert_nothing_raised do
-      sql = Person.joins(agents: {agents: :agents}).joins(agents: {agents: {primary_contact: :agents}}).to_sql
+      sql = Person.joins(agents: { agents: :agents }).joins(agents: { agents: { primary_contact: :agents } }).to_sql
       assert_match(/agents_people_4/i, sql)
     end
   end
@@ -47,7 +47,7 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
   end
 
   def test_join_conditions_allow_nil_associations
-    authors = Author.includes(:essays).where(essays: {id: nil})
+    authors = Author.includes(:essays).where(essays: { id: nil })
     assert_equal 2, authors.count
   end
 
@@ -60,13 +60,13 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
   def test_find_with_implicit_inner_joins_honors_readonly_with_select
     authors = Author.joins(:posts).select("authors.*").to_a
     assert !authors.empty?, "expected authors to be non-empty"
-    assert authors.all? {|a| !a.readonly? }, "expected no authors to be readonly"
+    assert authors.all? { |a| !a.readonly? }, "expected no authors to be readonly"
   end
 
   def test_find_with_implicit_inner_joins_honors_readonly_false
     authors = Author.joins(:posts).readonly(false).to_a
     assert !authors.empty?, "expected authors to be non-empty"
-    assert authors.all? {|a| !a.readonly? }, "expected no authors to be readonly"
+    assert authors.all? { |a| !a.readonly? }, "expected no authors to be readonly"
   end
 
   def test_find_with_implicit_inner_joins_does_not_set_associations
@@ -76,17 +76,17 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
   end
 
   def test_count_honors_implicit_inner_joins
-    real_count = Author.all.to_a.sum{|a| a.posts.count }
+    real_count = Author.all.to_a.sum { |a| a.posts.count }
     assert_equal real_count, Author.joins(:posts).count, "plain inner join count should match the number of referenced posts records"
   end
 
   def test_calculate_honors_implicit_inner_joins
-    real_count = Author.all.to_a.sum{|a| a.posts.count }
+    real_count = Author.all.to_a.sum { |a| a.posts.count }
     assert_equal real_count, Author.joins(:posts).calculate(:count, "authors.id"), "plain inner join count should match the number of referenced posts records"
   end
 
   def test_calculate_honors_implicit_inner_joins_and_distinct_and_conditions
-    real_count = Author.all.to_a.select {|a| a.posts.any? {|p| p.title.start_with?("Welcome")} }.length
+    real_count = Author.all.to_a.select { |a| a.posts.any? { |p| p.title.start_with?("Welcome") } }.length
     authors_with_welcoming_post_titles = Author.all.merge!(joins: :posts, where: "posts.title like 'Welcome%'").distinct.calculate(:count, "authors.id")
     assert_equal real_count, authors_with_welcoming_post_titles, "inner join and conditions should have only returned authors posting titles starting with 'Welcome'"
   end
diff --git a/activerecord/test/cases/associations/inverse_associations_test.rb b/activerecord/test/cases/associations/inverse_associations_test.rb
index 4534cbe664..0b23cea420 100644
--- a/activerecord/test/cases/associations/inverse_associations_test.rb
+++ b/activerecord/test/cases/associations/inverse_associations_test.rb
@@ -227,7 +227,7 @@ class InverseHasOneTests < ActiveRecord::TestCase
   end
 
   def test_parent_instance_should_be_shared_with_eager_loaded_child_on_find
-    m = Man.all.merge!(where: {name: "Gordon"}, includes: :face).first
+    m = Man.all.merge!(where: { name: "Gordon" }, includes: :face).first
     f = m.face
     assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
     m.name = "Bongo"
@@ -235,7 +235,7 @@ class InverseHasOneTests < ActiveRecord::TestCase
     f.man.name = "Mungo"
     assert_equal m.name, f.man.name, "Name of man should be the same after changes to child-owned instance"
 
-    m = Man.all.merge!(where: {name: "Gordon"}, includes: :face, order: "faces.id").first
+    m = Man.all.merge!(where: { name: "Gordon" }, includes: :face, order: "faces.id").first
     f = m.face
     assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
     m.name = "Bongo"
@@ -310,7 +310,7 @@ class InverseHasManyTests < ActiveRecord::TestCase
   end
 
   def test_parent_instance_should_be_shared_with_eager_loaded_children
-    m = Man.all.merge!(where: {name: "Gordon"}, includes: :interests).first
+    m = Man.all.merge!(where: { name: "Gordon" }, includes: :interests).first
     is = m.interests
     is.each do |i|
       assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
@@ -320,7 +320,7 @@ class InverseHasManyTests < ActiveRecord::TestCase
       assert_equal m.name, i.man.name, "Name of man should be the same after changes to child-owned instance"
     end
 
-    m = Man.all.merge!(where: {name: "Gordon"}, includes: :interests, order: "interests.id").first
+    m = Man.all.merge!(where: { name: "Gordon" }, includes: :interests, order: "interests.id").first
     is = m.interests
     is.each do |i|
       assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
@@ -333,7 +333,7 @@ class InverseHasManyTests < ActiveRecord::TestCase
 
   def test_parent_instance_should_be_shared_with_newly_block_style_built_child
     m = Man.first
-    i = m.interests.build {|ii| ii.topic = "Industrial Revolution Re-enactment"}
+    i = m.interests.build { |ii| ii.topic = "Industrial Revolution Re-enactment" }
     assert_not_nil i.topic, "Child attributes supplied to build via blocks should be populated"
     assert_not_nil i.man
     assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
@@ -356,7 +356,7 @@ class InverseHasManyTests < ActiveRecord::TestCase
 
   def test_parent_instance_should_be_shared_with_newly_block_style_created_child
     m = Man.first
-    i = m.interests.create {|ii| ii.topic = "Industrial Revolution Re-enactment"}
+    i = m.interests.create { |ii| ii.topic = "Industrial Revolution Re-enactment" }
     assert_not_nil i.topic, "Child attributes supplied to create via blocks should be populated"
     assert_not_nil i.man
     assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
@@ -510,7 +510,7 @@ class InverseBelongsToTests < ActiveRecord::TestCase
   end
 
   def test_eager_loaded_child_instance_should_be_shared_with_parent_on_find
-    f = Face.all.merge!(includes: :man, where: {description: "trusting"}).first
+    f = Face.all.merge!(includes: :man, where: { description: "trusting" }).first
     m = f.man
     assert_equal f.description, m.face.description, "Description of face should be the same before changes to child instance"
     f.description = "gormless"
@@ -518,7 +518,7 @@ class InverseBelongsToTests < ActiveRecord::TestCase
     m.face.description = "pleasing"
     assert_equal f.description, m.face.description, "Description of face should be the same after changes to parent-owned instance"
 
-    f = Face.all.merge!(includes: :man, order: "men.id", where: {description: "trusting"}).first
+    f = Face.all.merge!(includes: :man, order: "men.id", where: { description: "trusting" }).first
     m = f.man
     assert_equal f.description, m.face.description, "Description of face should be the same before changes to child instance"
     f.description = "gormless"
@@ -553,7 +553,7 @@ class InverseBelongsToTests < ActiveRecord::TestCase
     i = interests(:trainspotting)
     m = i.man
     assert_not_nil m.interests
-    iz = m.interests.detect { |_iz| _iz.id == i.id}
+    iz = m.interests.detect { |_iz| _iz.id == i.id }
     assert_not_nil iz
     assert_equal i.topic, iz.topic, "Interest topics should be the same before changes to child"
     i.topic = "Eating cheese with a spoon"
@@ -583,7 +583,7 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
   fixtures :men, :faces, :interests
 
   def test_child_instance_should_be_shared_with_parent_on_find
-    f = Face.all.merge!(where: {description: "confused"}).first
+    f = Face.all.merge!(where: { description: "confused" }).first
     m = f.polymorphic_man
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same before changes to child instance"
     f.description = "gormless"
@@ -593,7 +593,7 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
   end
 
   def test_eager_loaded_child_instance_should_be_shared_with_parent_on_find
-    f = Face.all.merge!(where: {description: "confused"}, includes: :man).first
+    f = Face.all.merge!(where: { description: "confused" }, includes: :man).first
     m = f.polymorphic_man
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same before changes to child instance"
     f.description = "gormless"
@@ -601,7 +601,7 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
     m.polymorphic_face.description = "pleasing"
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same after changes to parent-owned instance"
 
-    f = Face.all.merge!(where: {description: "confused"}, includes: :man, order: "men.id").first
+    f = Face.all.merge!(where: { description: "confused" }, includes: :man, order: "men.id").first
     m = f.polymorphic_man
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same before changes to child instance"
     f.description = "gormless"
@@ -654,7 +654,7 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
     i = interests(:llama_wrangling)
     m = i.polymorphic_man
     assert_not_nil m.polymorphic_interests
-    iz = m.polymorphic_interests.detect { |_iz| _iz.id == i.id}
+    iz = m.polymorphic_interests.detect { |_iz| _iz.id == i.id }
     assert_not_nil iz
     assert_equal i.topic, iz.topic, "Interest topics should be the same before changes to child"
     i.topic = "Eating cheese with a spoon"
diff --git a/activerecord/test/cases/associations/join_model_test.rb b/activerecord/test/cases/associations/join_model_test.rb
index cf08cc9537..61678ae210 100644
--- a/activerecord/test/cases/associations/join_model_test.rb
+++ b/activerecord/test/cases/associations/join_model_test.rb
@@ -237,7 +237,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     category = categories(:sti_test)
     ernie = category.authors_with_select.create(name: "Ernie")
     assert_nothing_raised do
-      assert_equal ernie, category.authors_with_select.detect {|a| a.name == "Ernie"}
+      assert_equal ernie, category.authors_with_select.detect { |a| a.name == "Ernie" }
     end
   end
 
@@ -642,7 +642,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   def test_polymorphic_has_many
     expected = taggings(:welcome_general)
     p = Post.all.merge!(includes: :taggings).find(posts(:welcome).id)
-    assert_no_queries {assert p.taggings.include?(expected)}
+    assert_no_queries { assert p.taggings.include?(expected) }
     assert posts(:welcome).taggings.include?(taggings(:welcome_general))
   end
 
@@ -650,12 +650,12 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     expected = posts(:welcome)
 
     tagging  = Tagging.all.merge!(includes: :taggable).find(taggings(:welcome_general).id)
-    assert_no_queries { assert_equal expected, tagging.taggable}
+    assert_no_queries { assert_equal expected, tagging.taggable }
   end
 
   def test_polymorphic_belongs_to
-    p = Post.all.merge!(includes: {taggings: :taggable}).find(posts(:welcome).id)
-    assert_no_queries {assert_equal posts(:welcome), p.taggings.first.taggable}
+    p = Post.all.merge!(includes: { taggings: :taggable }).find(posts(:welcome).id)
+    assert_no_queries { assert_equal posts(:welcome), p.taggings.first.taggable }
   end
 
   def test_preload_polymorphic_has_many_through
@@ -748,17 +748,17 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_proper_error_message_for_eager_load_and_includes_association_errors
     includes_error = assert_raises(ActiveRecord::ConfigurationError) {
-      Post.includes(:nonexistent_relation).where(nonexistent_relation: {name: "Rochester"}).find(1)
+      Post.includes(:nonexistent_relation).where(nonexistent_relation: { name: "Rochester" }).find(1)
     }
     assert_equal("Can't join 'Post' to association named 'nonexistent_relation'; perhaps you misspelled it?", includes_error.message)
 
     eager_load_error = assert_raises(ActiveRecord::ConfigurationError) {
-      Post.eager_load(:nonexistent_relation).where(nonexistent_relation: {name: "Rochester"}).find(1)
+      Post.eager_load(:nonexistent_relation).where(nonexistent_relation: { name: "Rochester" }).find(1)
     }
     assert_equal("Can't join 'Post' to association named 'nonexistent_relation'; perhaps you misspelled it?", eager_load_error.message)
 
     includes_and_eager_load_error = assert_raises(ActiveRecord::ConfigurationError) {
-      Post.eager_load(:nonexistent_relation).includes(:nonexistent_relation).where(nonexistent_relation: {name: "Rochester"}).find(1)
+      Post.eager_load(:nonexistent_relation).includes(:nonexistent_relation).where(nonexistent_relation: { name: "Rochester" }).find(1)
     }
     assert_equal("Can't join 'Post' to association named 'nonexistent_relation'; perhaps you misspelled it?", includes_and_eager_load_error.message)
   end
diff --git a/activerecord/test/cases/associations/left_outer_join_association_test.rb b/activerecord/test/cases/associations/left_outer_join_association_test.rb
index 003240bb26..d814229f64 100644
--- a/activerecord/test/cases/associations/left_outer_join_association_test.rb
+++ b/activerecord/test/cases/associations/left_outer_join_association_test.rb
@@ -18,8 +18,8 @@ class LeftOuterJoinAssociationTest < ActiveRecord::TestCase
   def test_construct_finder_sql_does_not_table_name_collide_on_duplicate_associations
     assert_nothing_raised do
       queries = capture_sql do
-        Person.left_outer_joins(agents: {agents: :agents})
-              .left_outer_joins(agents: {agents: {primary_contact: :agents}}).to_a
+        Person.left_outer_joins(agents: { agents: :agents })
+              .left_outer_joins(agents: { agents: { primary_contact: :agents } }).to_a
       end
       assert queries.any? { |sql| /agents_people_4/i.match?(sql) }
     end
@@ -46,7 +46,7 @@ class LeftOuterJoinAssociationTest < ActiveRecord::TestCase
   end
 
   def test_left_outer_joins_forbids_to_use_string_as_argument
-    assert_raise(ArgumentError){ Author.left_outer_joins('LEFT OUTER JOIN "posts" ON "posts"."user_id" = "users"."id"').to_a }
+    assert_raise(ArgumentError) { Author.left_outer_joins('LEFT OUTER JOIN "posts" ON "posts"."user_id" = "users"."id"').to_a }
   end
 
   def test_join_conditions_added_to_join_clause
diff --git a/activerecord/test/cases/associations_test.rb b/activerecord/test/cases/associations_test.rb
index 45aefde3e1..f29a968c07 100644
--- a/activerecord/test/cases/associations_test.rb
+++ b/activerecord/test/cases/associations_test.rb
@@ -57,8 +57,8 @@ class AssociationsTest < ActiveRecord::TestCase
   end
 
   def test_include_with_order_works
-    assert_nothing_raised {Account.all.merge!(order: "id", includes: :firm).first}
-    assert_nothing_raised {Account.all.merge!(order: :id, includes: :firm).first}
+    assert_nothing_raised { Account.all.merge!(order: "id", includes: :firm).first }
+    assert_nothing_raised { Account.all.merge!(order: :id, includes: :firm).first }
   end
 
   def test_bad_collection_keys
@@ -199,13 +199,13 @@ class AssociationProxyTest < ActiveRecord::TestCase
   end
 
   def test_create_via_association_with_block
-    post = authors(:david).posts.create(title: "New on Edge") {|p| p.body = "More cool stuff!"}
+    post = authors(:david).posts.create(title: "New on Edge") { |p| p.body = "More cool stuff!" }
     assert_equal post.title, "New on Edge"
     assert_equal post.body, "More cool stuff!"
   end
 
   def test_create_with_bang_via_association_with_block
-    post = authors(:david).posts.create!(title: "New on Edge") {|p| p.body = "More cool stuff!"}
+    post = authors(:david).posts.create!(title: "New on Edge") { |p| p.body = "More cool stuff!" }
     assert_equal post.title, "New on Edge"
     assert_equal post.body, "More cool stuff!"
   end
diff --git a/activerecord/test/cases/autosave_association_test.rb b/activerecord/test/cases/autosave_association_test.rb
index ae5127cc56..7eae2363f8 100644
--- a/activerecord/test/cases/autosave_association_test.rb
+++ b/activerecord/test/cases/autosave_association_test.rb
@@ -196,21 +196,21 @@ class TestDefaultAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCas
   end
 
   def test_callbacks_firing_order_on_create
-    eye = Eye.create(iris_attributes: {color: "honey"})
+    eye = Eye.create(iris_attributes: { color: "honey" })
     assert_equal [true, false], eye.after_create_callbacks_stack
   end
 
   def test_callbacks_firing_order_on_update
-    eye = Eye.create(iris_attributes: {color: "honey"})
-    eye.update(iris_attributes: {color: "green"})
+    eye = Eye.create(iris_attributes: { color: "honey" })
+    eye.update(iris_attributes: { color: "green" })
     assert_equal [true, false], eye.after_update_callbacks_stack
   end
 
   def test_callbacks_firing_order_on_save
-    eye = Eye.create(iris_attributes: {color: "honey"})
+    eye = Eye.create(iris_attributes: { color: "honey" })
     assert_equal [false, false], eye.after_save_callbacks_stack
 
-    eye.update(iris_attributes: {color: "blue"})
+    eye.update(iris_attributes: { color: "blue" })
     assert_equal [false, false, false, false], eye.after_save_callbacks_stack
   end
 end
@@ -443,7 +443,7 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociationWithAcceptsNestedAttrib
     assert_not invalid_electron.valid?
     assert valid_electron.valid?
     assert_not molecule.valid?
-    assert_equal [{error: :blank}], molecule.errors.details["electrons.name"]
+    assert_equal [{ error: :blank }], molecule.errors.details["electrons.name"]
   end
 
   def test_errors_details_should_be_indexed_when_passed_as_array
@@ -457,7 +457,7 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociationWithAcceptsNestedAttrib
     assert_not tuning_peg_invalid.valid?
     assert tuning_peg_valid.valid?
     assert_not guitar.valid?
-    assert_equal [{error: :not_a_number, value: nil}] , guitar.errors.details["tuning_pegs[1].pitch"]
+    assert_equal [{ error: :not_a_number, value: nil }] , guitar.errors.details["tuning_pegs[1].pitch"]
     assert_equal [], guitar.errors.details["tuning_pegs.pitch"]
   end
 
@@ -474,7 +474,7 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociationWithAcceptsNestedAttrib
     assert_not invalid_electron.valid?
     assert valid_electron.valid?
     assert_not molecule.valid?
-    assert_equal [{error: :blank}], molecule.errors.details["electrons[1].name"]
+    assert_equal [{ error: :blank }], molecule.errors.details["electrons[1].name"]
     assert_equal [], molecule.errors.details["electrons.name"]
   ensure
     ActiveRecord::Base.index_nested_attribute_errors = old_attribute_config
@@ -610,7 +610,7 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
 
   def test_build_many_before_save
     company = companies(:first_firm)
-    assert_no_queries(ignore_none: false) { company.clients_of_firm.build([{"name" => "Another Client"}, {"name" => "Another Client II"}]) }
+    assert_no_queries(ignore_none: false) { company.clients_of_firm.build([{ "name" => "Another Client" }, { "name" => "Another Client II" }]) }
 
     company.name += "-changed"
     assert_queries(3) { assert company.save }
@@ -619,7 +619,7 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
 
   def test_build_via_block_before_save
     company = companies(:first_firm)
-    new_client = assert_no_queries(ignore_none: false) { company.clients_of_firm.build {|client| client.name = "Another Client" } }
+    new_client = assert_no_queries(ignore_none: false) { company.clients_of_firm.build { |client| client.name = "Another Client" } }
     assert !company.clients_of_firm.loaded?
 
     company.name += "-changed"
@@ -631,7 +631,7 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
   def test_build_many_via_block_before_save
     company = companies(:first_firm)
     assert_no_queries(ignore_none: false) do
-      company.clients_of_firm.build([{"name" => "Another Client"}, {"name" => "Another Client II"}]) do |client|
+      company.clients_of_firm.build([{ "name" => "Another Client" }, { "name" => "Another Client II" }]) do |client|
         client.name = "changed"
       end
     end
@@ -1407,9 +1407,9 @@ module AutosaveAssociationOnACollectionAssociationTests
   end
 
   def test_should_default_invalid_error_from_i18n
-    I18n.backend.store_translations(:en, activerecord: {errors: { models:
+    I18n.backend.store_translations(:en, activerecord: { errors: { models:
       { @associated_model_name.to_s.to_sym => { blank: "cannot be blank" } }
-    }})
+    } })
 
     @pirate.send(@association_name).build(name: "")
 
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index bf2c13cfac..c03c3f9546 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -307,7 +307,7 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_create_after_initialize_with_block
-    cb = CustomBulb.create {|c| c.name = "Dude" }
+    cb = CustomBulb.create { |c| c.name = "Dude" }
     assert_equal("Dude", cb.name)
     assert_equal(true, cb.frickinawesome)
   end
@@ -664,7 +664,7 @@ class BasicsTest < ActiveRecord::TestCase
 
       Weird.reset_column_information
 
-      assert_equal ["EUC-JP"], Weird.columns.map {|c| c.name.encoding.name }.uniq
+      assert_equal ["EUC-JP"], Weird.columns.map { |c| c.name.encoding.name }.uniq
     ensure
       silence_warnings { Encoding.default_internal = old_default_internal }
       Weird.reset_column_information
@@ -1278,7 +1278,7 @@ class BasicsTest < ActiveRecord::TestCase
     ActiveSupport::Dependencies.remove_unloadable_constants!
     assert_nil ActiveRecord::Scoping::ScopeRegistry.value_for(:current_scope, klass)
   ensure
-    Object.class_eval{ remove_const :UnloadablePost } if defined?(UnloadablePost)
+    Object.class_eval { remove_const :UnloadablePost } if defined?(UnloadablePost)
   end
 
   def test_marshal_round_trip
diff --git a/activerecord/test/cases/batches_test.rb b/activerecord/test/cases/batches_test.rb
index 077e6d0bc0..f7e21faf0f 100644
--- a/activerecord/test/cases/batches_test.rb
+++ b/activerecord/test/cases/batches_test.rb
@@ -21,7 +21,7 @@ class EachTest < ActiveRecord::TestCase
 
   def test_each_should_not_return_query_chain_and_execute_only_one_query
     assert_queries(1) do
-      result = Post.find_each(batch_size: 100000){ }
+      result = Post.find_each(batch_size: 100000) {}
       assert_nil result
     end
   end
@@ -135,11 +135,11 @@ class EachTest < ActiveRecord::TestCase
 
   def test_find_in_batches_shouldnt_execute_query_unless_needed
     assert_queries(2) do
-      Post.find_in_batches(batch_size: @total) {|batch| assert_kind_of Array, batch }
+      Post.find_in_batches(batch_size: @total) { |batch| assert_kind_of Array, batch }
     end
 
     assert_queries(1) do
-      Post.find_in_batches(batch_size: @total + 1) {|batch| assert_kind_of Array, batch }
+      Post.find_in_batches(batch_size: @total + 1) { |batch| assert_kind_of Array, batch }
     end
   end
 
@@ -156,7 +156,7 @@ class EachTest < ActiveRecord::TestCase
   def test_find_in_batches_should_not_use_records_after_yielding_them_in_case_original_array_is_modified
     not_a_post = "not a post"
     def not_a_post.id; end
-    not_a_post.stub(:id, ->{ raise StandardError.new("not_a_post had #id called on it") }) do
+    not_a_post.stub(:id, -> { raise StandardError.new("not_a_post had #id called on it") }) do
       assert_nothing_raised do
         Post.find_in_batches(batch_size: 1) do |batch|
           assert_kind_of Array, batch
@@ -182,7 +182,7 @@ class EachTest < ActiveRecord::TestCase
 
   def test_find_in_batches_should_error_on_ignore_the_order
     assert_raise(ArgumentError) do
-      PostWithDefaultScope.find_in_batches(error_on_ignore: true){}
+      PostWithDefaultScope.find_in_batches(error_on_ignore: true) {}
     end
   end
 
@@ -191,7 +191,7 @@ class EachTest < ActiveRecord::TestCase
     prev = ActiveRecord::Base.error_on_ignored_order
     ActiveRecord::Base.error_on_ignored_order = true
     assert_nothing_raised do
-      PostWithDefaultScope.find_in_batches(error_on_ignore: false){}
+      PostWithDefaultScope.find_in_batches(error_on_ignore: false) {}
     end
   ensure
     # Set back to default
@@ -203,7 +203,7 @@ class EachTest < ActiveRecord::TestCase
     prev = ActiveRecord::Base.error_on_ignored_order
     ActiveRecord::Base.error_on_ignored_order = true
     assert_raise(ArgumentError) do
-      PostWithDefaultScope.find_in_batches(){}
+      PostWithDefaultScope.find_in_batches() {}
     end
   ensure
     # Set back to default
@@ -212,7 +212,7 @@ class EachTest < ActiveRecord::TestCase
 
   def test_find_in_batches_should_not_error_by_default
     assert_nothing_raised do
-      PostWithDefaultScope.find_in_batches(){}
+      PostWithDefaultScope.find_in_batches() {}
     end
   end
 
@@ -227,7 +227,7 @@ class EachTest < ActiveRecord::TestCase
 
   def test_find_in_batches_should_not_modify_passed_options
     assert_nothing_raised do
-      Post.find_in_batches({ batch_size: 42, start: 1 }.freeze){}
+      Post.find_in_batches({ batch_size: 42, start: 1 }.freeze) {}
     end
   end
 
@@ -445,7 +445,7 @@ class EachTest < ActiveRecord::TestCase
 
   def test_in_batches_should_not_modify_passed_options
     assert_nothing_raised do
-      Post.in_batches({ of: 42, start: 1 }.freeze){}
+      Post.in_batches({ of: 42, start: 1 }.freeze) {}
     end
   end
 
diff --git a/activerecord/test/cases/calculations_test.rb b/activerecord/test/cases/calculations_test.rb
index 13f9a47980..bacf93d275 100644
--- a/activerecord/test/cases/calculations_test.rb
+++ b/activerecord/test/cases/calculations_test.rb
@@ -381,7 +381,7 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_perform_joined_include_when_referencing_included_tables
-    joined_count = Account.includes(:firm).where(companies: {name: "37signals"}).count
+    joined_count = Account.includes(:firm).where(companies: { name: "37signals" }).count
     assert_equal 1, joined_count
   end
 
@@ -604,7 +604,7 @@ class CalculationsTest < ActiveRecord::TestCase
 
   def test_pluck_with_serialization
     t = Topic.create!(content: { foo: :bar })
-    assert_equal [{foo: :bar}], Topic.where(id: t.id).pluck(:content)
+    assert_equal [{ foo: :bar }], Topic.where(id: t.id).pluck(:content)
   end
 
   def test_pluck_with_qualified_column_name
diff --git a/activerecord/test/cases/callbacks_test.rb b/activerecord/test/cases/callbacks_test.rb
index e2352bd9f9..4b517e9d70 100644
--- a/activerecord/test/cases/callbacks_test.rb
+++ b/activerecord/test/cases/callbacks_test.rb
@@ -57,7 +57,7 @@ end
 class ParentDeveloper < ActiveRecord::Base
   self.table_name = "developers"
   attr_accessor :after_save_called
-  before_validation {|record| record.after_save_called = true}
+  before_validation { |record| record.after_save_called = true }
 end
 
 class ChildDeveloper < ParentDeveloper
@@ -95,16 +95,16 @@ class OnCallbacksDeveloper < ActiveRecord::Base
   self.table_name = "developers"
 
   before_validation { history << :before_validation }
-  before_validation(on: :create){ history << :before_validation_on_create }
-  before_validation(on: :update){ history << :before_validation_on_update }
+  before_validation(on: :create) { history << :before_validation_on_create }
+  before_validation(on: :update) { history << :before_validation_on_update }
 
   validate do
     history << :validate
   end
 
   after_validation { history << :after_validation }
-  after_validation(on: :create){ history << :after_validation_on_create }
-  after_validation(on: :update){ history << :after_validation_on_update }
+  after_validation(on: :create) { history << :after_validation_on_create }
+  after_validation(on: :update) { history << :after_validation_on_update }
 
   def history
     @history ||= []
@@ -143,7 +143,7 @@ class CallbackCancellationDeveloper < ActiveRecord::Base
   attr_reader   :after_save_called, :after_create_called, :after_update_called, :after_destroy_called
   attr_accessor :cancel_before_save, :cancel_before_create, :cancel_before_update, :cancel_before_destroy
 
-  before_save    {defined?(@cancel_before_save) ? !@cancel_before_save : false}
+  before_save    { defined?(@cancel_before_save) ? !@cancel_before_save : false }
   before_create  { !@cancel_before_create  }
   before_update  { !@cancel_before_update  }
   before_destroy { !@cancel_before_destroy }
diff --git a/activerecord/test/cases/column_definition_test.rb b/activerecord/test/cases/column_definition_test.rb
index 31e618664f..989beaa5c8 100644
--- a/activerecord/test/cases/column_definition_test.rb
+++ b/activerecord/test/cases/column_definition_test.rb
@@ -6,7 +6,7 @@ module ActiveRecord
       def setup
         @adapter = AbstractAdapter.new(nil)
         def @adapter.native_database_types
-          {string: "varchar"}
+          { string: "varchar" }
         end
         @viz = @adapter.schema_creation
       end
diff --git a/activerecord/test/cases/connection_adapters/connection_handler_test.rb b/activerecord/test/cases/connection_adapters/connection_handler_test.rb
index d9bcc0c130..d5d16e7568 100644
--- a/activerecord/test/cases/connection_adapters/connection_handler_test.rb
+++ b/activerecord/test/cases/connection_adapters/connection_handler_test.rb
@@ -10,7 +10,7 @@ module ActiveRecord
       end
 
       def test_establish_connection_uses_spec_name
-        config = {"readonly" => {"adapter" => "sqlite3"}}
+        config = { "readonly" => { "adapter" => "sqlite3" } }
         resolver = ConnectionAdapters::ConnectionSpecification::Resolver.new(config)
         spec =   resolver.spec(:readonly)
         @handler.establish_connection(spec.to_hash)
diff --git a/activerecord/test/cases/connection_adapters/merge_and_resolve_default_url_config_test.rb b/activerecord/test/cases/connection_adapters/merge_and_resolve_default_url_config_test.rb
index b1ba6f11f2..4bb5c4f2e2 100644
--- a/activerecord/test/cases/connection_adapters/merge_and_resolve_default_url_config_test.rb
+++ b/activerecord/test/cases/connection_adapters/merge_and_resolve_default_url_config_test.rb
@@ -224,7 +224,7 @@ module ActiveRecord
       def test_merge_no_conflicts_with_database_url
         ENV["DATABASE_URL"] = "postgres://localhost/foo"
 
-        config   = {"default_env" => { "pool" => "5" } }
+        config   = { "default_env" => { "pool" => "5" } }
         actual   = resolve_config(config)
         expected = { "default_env" =>
                      { "adapter"  => "postgresql",
@@ -239,7 +239,7 @@ module ActiveRecord
       def test_merge_conflicts_with_database_url
         ENV["DATABASE_URL"] = "postgres://localhost/foo"
 
-        config   = {"default_env" => { "adapter" => "NOT-POSTGRES", "database" => "NOT-FOO", "pool" => "5" } }
+        config   = { "default_env" => { "adapter" => "NOT-POSTGRES", "database" => "NOT-FOO", "pool" => "5" } }
         actual   = resolve_config(config)
         expected = { "default_env" =>
                      { "adapter"  => "postgresql",
diff --git a/activerecord/test/cases/connection_management_test.rb b/activerecord/test/cases/connection_management_test.rb
index 88620f9f09..d1e946d401 100644
--- a/activerecord/test/cases/connection_management_test.rb
+++ b/activerecord/test/cases/connection_management_test.rb
@@ -104,7 +104,7 @@ module ActiveRecord
         def middleware(app)
           lambda do |env|
             a, b, c = executor.wrap { app.call(env) }
-            [a, b, Rack::BodyProxy.new(c) { }]
+            [a, b, Rack::BodyProxy.new(c) {}]
           end
         end
     end
diff --git a/activerecord/test/cases/connection_specification/resolver_test.rb b/activerecord/test/cases/connection_specification/resolver_test.rb
index 4bfec47124..0f62c73f8f 100644
--- a/activerecord/test/cases/connection_specification/resolver_test.rb
+++ b/activerecord/test/cases/connection_specification/resolver_test.rb
@@ -29,27 +29,27 @@ module ActiveRecord
             "adapter"  =>  "abstract",
             "host"     =>  "foo",
             "encoding" => "utf8",
-            "name"     => "production"}, spec)
+            "name"     => "production" }, spec)
         end
 
         def test_url_sub_key
-          spec = resolve :production, "production" => {"url" => "abstract://foo?encoding=utf8"}
+          spec = resolve :production, "production" => { "url" => "abstract://foo?encoding=utf8" }
           assert_equal({
             "adapter"  => "abstract",
             "host"     => "foo",
             "encoding" => "utf8",
-            "name"     => "production"}, spec)
+            "name"     => "production" }, spec)
         end
 
         def test_url_sub_key_merges_correctly
-          hash = {"url" => "abstract://foo?encoding=utf8&", "adapter" => "sqlite3", "host" => "bar", "pool" => "3"}
+          hash = { "url" => "abstract://foo?encoding=utf8&", "adapter" => "sqlite3", "host" => "bar", "pool" => "3" }
           spec = resolve :production, "production" => hash
           assert_equal({
             "adapter"  => "abstract",
             "host"     => "foo",
             "encoding" => "utf8",
             "pool"     => "3",
-            "name"     => "production"}, spec)
+            "name"     => "production" }, spec)
         end
 
         def test_url_host_no_db
@@ -112,16 +112,16 @@ module ActiveRecord
         end
 
         def test_url_sub_key_for_sqlite3
-          spec = resolve :production, "production" => {"url" => "sqlite3:foo?encoding=utf8"}
+          spec = resolve :production, "production" => { "url" => "sqlite3:foo?encoding=utf8" }
           assert_equal({
             "adapter"  => "sqlite3",
             "database" => "foo",
             "encoding" => "utf8",
-            "name"     => "production"}, spec)
+            "name"     => "production" }, spec)
         end
 
         def test_spec_name_on_key_lookup
-          spec = spec(:readonly, "readonly" => {"adapter" => "sqlite3"})
+          spec = spec(:readonly, "readonly" => { "adapter" => "sqlite3" })
           assert_equal "readonly", spec.name
         end
 
diff --git a/activerecord/test/cases/dirty_test.rb b/activerecord/test/cases/dirty_test.rb
index 32df15eef3..6a7d333766 100644
--- a/activerecord/test/cases/dirty_test.rb
+++ b/activerecord/test/cases/dirty_test.rb
@@ -280,7 +280,7 @@ class DirtyTest < ActiveRecord::TestCase
     assert pirate.changed?
     assert_nil pirate.catchphrase_was
     assert_equal %w(catchphrase), pirate.changed
-    assert_equal({"catchphrase" => [nil, "arrr"]}, pirate.changes)
+    assert_equal({ "catchphrase" => [nil, "arrr"] }, pirate.changes)
 
     pirate.save
     assert !pirate.changed?
@@ -314,7 +314,7 @@ class DirtyTest < ActiveRecord::TestCase
     assert !topic.approved_changed?
 
     # Coming from web form.
-    params = {topic: {approved: 1}}
+    params = { topic: { approved: 1 } }
     # In the controller.
     topic.attributes = params[:topic]
     assert topic.approved?
@@ -423,7 +423,7 @@ class DirtyTest < ActiveRecord::TestCase
 
   def test_save_should_store_serialized_attributes_even_with_partial_writes
     with_partial_writes(Topic) do
-      topic = Topic.create!(content: {a: "a"})
+      topic = Topic.create!(content: { a: "a" })
 
       assert_not topic.changed?
 
@@ -444,7 +444,7 @@ class DirtyTest < ActiveRecord::TestCase
 
   def test_save_always_should_update_timestamps_when_serialized_attributes_are_present
     with_partial_writes(Topic) do
-      topic = Topic.create!(content: {a: "a"})
+      topic = Topic.create!(content: { a: "a" })
       topic.save!
 
       updated_at = topic.updated_at
@@ -460,7 +460,7 @@ class DirtyTest < ActiveRecord::TestCase
 
   def test_save_should_not_save_serialized_attribute_with_partial_writes_if_not_present
     with_partial_writes(Topic) do
-      Topic.create!(author_name: "Bill", content: {a: "a"})
+      Topic.create!(author_name: "Bill", content: { a: "a" })
       topic = Topic.select("id, author_name").first
       topic.update_columns author_name: "John"
       topic = Topic.first
diff --git a/activerecord/test/cases/explain_test.rb b/activerecord/test/cases/explain_test.rb
index 43f1d401dd..86fe90ae51 100644
--- a/activerecord/test/cases/explain_test.rb
+++ b/activerecord/test/cases/explain_test.rb
@@ -40,7 +40,7 @@ if ActiveRecord::Base.connection.supports_explain?
       queries = sqls.zip(binds)
 
       stub_explain_for_query_plans do
-        expected = sqls.map {|sql| "EXPLAIN for: #{sql}\nquery plan #{sql}"}.join("\n")
+        expected = sqls.map { |sql| "EXPLAIN for: #{sql}\nquery plan #{sql}" }.join("\n")
         assert_equal expected, base.exec_explain(queries)
       end
     end
@@ -75,7 +75,7 @@ if ActiveRecord::Base.connection.supports_explain?
       def stub_explain_for_query_plans(query_plans = ["query plan foo", "query plan bar"])
         explain_called = 0
 
-        connection.stub(:explain, proc{ explain_called += 1; query_plans[explain_called - 1] }) do
+        connection.stub(:explain, proc { explain_called += 1; query_plans[explain_called - 1] }) do
           yield
         end
       end
diff --git a/activerecord/test/cases/finder_respond_to_test.rb b/activerecord/test/cases/finder_respond_to_test.rb
index a7af8ac0ea..3eaa993d45 100644
--- a/activerecord/test/cases/finder_respond_to_test.rb
+++ b/activerecord/test/cases/finder_respond_to_test.rb
@@ -10,7 +10,7 @@ class FinderRespondToTest < ActiveRecord::TestCase
   end
 
   def test_should_preserve_normal_respond_to_behaviour_and_respond_to_newly_added_method
-    class << Topic; self; end.send(:define_method, :method_added_for_finder_respond_to_test) { }
+    class << Topic; self; end.send(:define_method, :method_added_for_finder_respond_to_test) {}
     assert_respond_to Topic, :method_added_for_finder_respond_to_test
   ensure
     class << Topic; self; end.send(:remove_method, :method_added_for_finder_respond_to_test)
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index bf0ce18bb8..c32fa3b1e2 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -127,7 +127,7 @@ class FinderTest < ActiveRecord::TestCase
     gc_disabled = GC.disable
     Post.where("author_id" => nil)  # warm up
     x = Symbol.all_symbols.count
-    Post.where("title" => {"xxxqqqq" => "bar"})
+    Post.where("title" => { "xxxqqqq" => "bar" })
     assert_equal x, Symbol.all_symbols.count
   ensure
     GC.enable if gc_disabled == false
@@ -627,8 +627,8 @@ class FinderTest < ActiveRecord::TestCase
 
   def test_find_only_some_columns
     topic = Topic.select("author_name").find(1)
-    assert_raise(ActiveModel::MissingAttributeError) {topic.title}
-    assert_raise(ActiveModel::MissingAttributeError) {topic.title?}
+    assert_raise(ActiveModel::MissingAttributeError) { topic.title }
+    assert_raise(ActiveModel::MissingAttributeError) { topic.title? }
     assert_nil topic.read_attribute("title")
     assert_equal "David", topic.author_name
     assert !topic.attribute_present?("title")
@@ -864,7 +864,7 @@ class FinderTest < ActiveRecord::TestCase
 
   def test_named_bind_variables_with_quotes
     Company.create("name" => "37signals' go'es agains")
-    assert Company.where(["name = :name", {name: "37signals' go'es agains"}]).first
+    assert Company.where(["name = :name", { name: "37signals' go'es agains" }]).first
   end
 
   def test_named_bind_variables
@@ -1075,9 +1075,9 @@ class FinderTest < ActiveRecord::TestCase
       [["1", "1", nil, "37signals"],
        ["2", "1", "2", "Summit"],
        ["3", "1", "1", "Microsoft"]],
-      Company.connection.select_rows("SELECT id, firm_id, client_of, name FROM companies WHERE id IN (1,2,3) ORDER BY id").map! {|i| i.map! {|j| j.to_s unless j.nil?}})
+      Company.connection.select_rows("SELECT id, firm_id, client_of, name FROM companies WHERE id IN (1,2,3) ORDER BY id").map! { |i| i.map! { |j| j.to_s unless j.nil? } })
     assert_equal [["1", "37signals"], ["2", "Summit"], ["3", "Microsoft"]],
-      Company.connection.select_rows("SELECT id, name FROM companies WHERE id IN (1,2,3) ORDER BY id").map! {|i| i.map! {|j| j.to_s unless j.nil?}}
+      Company.connection.select_rows("SELECT id, name FROM companies WHERE id IN (1,2,3) ORDER BY id").map! { |i| i.map! { |j| j.to_s unless j.nil? } }
   end
 
   def test_find_with_order_on_included_associations_with_construct_finder_sql_for_association_limiting_and_is_distinct
diff --git a/activerecord/test/cases/fixture_set/file_test.rb b/activerecord/test/cases/fixture_set/file_test.rb
index e69c9f303a..cf2a73595a 100644
--- a/activerecord/test/cases/fixture_set/file_test.rb
+++ b/activerecord/test/cases/fixture_set/file_test.rb
@@ -77,7 +77,7 @@ module ActiveRecord
         yaml = "one:\n  name: <%= fixture_helper %>\n"
         tmp_yaml ["curious", "yml"], yaml do |t|
           golden =
-              [["one", {"name" => "Fixture helper"}]]
+              [["one", { "name" => "Fixture helper" }]]
           assert_equal golden, File.open(t.path) { |fh| fh.to_a }
         end
         ActiveRecord::FixtureSet.context_class.class_eval do
diff --git a/activerecord/test/cases/forbidden_attributes_protection_test.rb b/activerecord/test/cases/forbidden_attributes_protection_test.rb
index b17daafe01..75c3493527 100644
--- a/activerecord/test/cases/forbidden_attributes_protection_test.rb
+++ b/activerecord/test/cases/forbidden_attributes_protection_test.rb
@@ -140,7 +140,7 @@ class ForbiddenAttributesProtectionTest < ActiveRecord::TestCase
   def test_where_not_works_with_permitted_params
     params = ProtectedParams.new(first_name: "Guille").permit!
     Person.create!(params)
-    assert_empty Person.where.not(params).select {|p| p.first_name == "Guille" }
+    assert_empty Person.where.not(params).select { |p| p.first_name == "Guille" }
   end
 
   def test_strong_params_style_objects_work_with_singular_associations
diff --git a/activerecord/test/cases/i18n_test.rb b/activerecord/test/cases/i18n_test.rb
index ab3a1132e8..7f03c5b23d 100644
--- a/activerecord/test/cases/i18n_test.rb
+++ b/activerecord/test/cases/i18n_test.rb
@@ -8,37 +8,37 @@ class ActiveRecordI18nTests < ActiveRecord::TestCase
   end
 
   def test_translated_model_attributes
-    I18n.backend.store_translations "en", activerecord: {attributes: {topic: {title: "topic title attribute"} } }
+    I18n.backend.store_translations "en", activerecord: { attributes: { topic: { title: "topic title attribute" } } }
     assert_equal "topic title attribute", Topic.human_attribute_name("title")
   end
 
   def test_translated_model_attributes_with_symbols
-    I18n.backend.store_translations "en", activerecord: {attributes: {topic: {title: "topic title attribute"} } }
+    I18n.backend.store_translations "en", activerecord: { attributes: { topic: { title: "topic title attribute" } } }
     assert_equal "topic title attribute", Topic.human_attribute_name(:title)
   end
 
   def test_translated_model_attributes_with_sti
-    I18n.backend.store_translations "en", activerecord: {attributes: {reply: {title: "reply title attribute"} } }
+    I18n.backend.store_translations "en", activerecord: { attributes: { reply: { title: "reply title attribute" } } }
     assert_equal "reply title attribute", Reply.human_attribute_name("title")
   end
 
   def test_translated_model_attributes_with_sti_fallback
-    I18n.backend.store_translations "en", activerecord: {attributes: {topic: {title: "topic title attribute"} } }
+    I18n.backend.store_translations "en", activerecord: { attributes: { topic: { title: "topic title attribute" } } }
     assert_equal "topic title attribute", Reply.human_attribute_name("title")
   end
 
   def test_translated_model_names
-    I18n.backend.store_translations "en", activerecord: {models: {topic: "topic model"} }
+    I18n.backend.store_translations "en", activerecord: { models: { topic: "topic model" } }
     assert_equal "topic model", Topic.model_name.human
   end
 
   def test_translated_model_names_with_sti
-    I18n.backend.store_translations "en", activerecord: {models: {reply: "reply model"} }
+    I18n.backend.store_translations "en", activerecord: { models: { reply: "reply model" } }
     assert_equal "reply model", Reply.model_name.human
   end
 
   def test_translated_model_names_with_sti_fallback
-    I18n.backend.store_translations "en", activerecord: {models: {topic: "topic model"} }
+    I18n.backend.store_translations "en", activerecord: { models: { topic: "topic model" } }
     assert_equal "topic model", Reply.model_name.human
   end
 end
diff --git a/activerecord/test/cases/inheritance_test.rb b/activerecord/test/cases/inheritance_test.rb
index 9090184622..9ad4664567 100644
--- a/activerecord/test/cases/inheritance_test.rb
+++ b/activerecord/test/cases/inheritance_test.rb
@@ -70,7 +70,7 @@ class InheritanceTest < ActiveRecord::TestCase
   end
 
   def test_compute_type_no_method_error
-    ActiveSupport::Dependencies.stub(:safe_constantize, proc{ raise NoMethodError }) do
+    ActiveSupport::Dependencies.stub(:safe_constantize, proc { raise NoMethodError }) do
       assert_raises NoMethodError do
         ActiveRecord::Base.send :compute_type, "InvalidModel"
       end
@@ -87,7 +87,7 @@ class InheritanceTest < ActiveRecord::TestCase
       error = e
     end
 
-    ActiveSupport::Dependencies.stub(:safe_constantize, proc{ raise e }) do
+    ActiveSupport::Dependencies.stub(:safe_constantize, proc { raise e }) do
 
       exception = assert_raises NameError do
         ActiveRecord::Base.send :compute_type, "InvalidModel"
@@ -97,7 +97,7 @@ class InheritanceTest < ActiveRecord::TestCase
   end
 
   def test_compute_type_argument_error
-    ActiveSupport::Dependencies.stub(:safe_constantize, proc{ raise ArgumentError }) do
+    ActiveSupport::Dependencies.stub(:safe_constantize, proc { raise ArgumentError }) do
       assert_raises ArgumentError do
         ActiveRecord::Base.send :compute_type, "InvalidModel"
       end
diff --git a/activerecord/test/cases/invertible_migration_test.rb b/activerecord/test/cases/invertible_migration_test.rb
index 81e8b0000a..9d5aace7db 100644
--- a/activerecord/test/cases/invertible_migration_test.rb
+++ b/activerecord/test/cases/invertible_migration_test.rb
@@ -225,7 +225,7 @@ module ActiveRecord
       InvertibleMigration.new.migrate :up
       received = []
       migration = InvertibleByPartsMigration.new
-      migration.test = ->(dir){
+      migration.test = ->(dir) {
         ActiveSupport::Deprecation.silence do
           assert migration.connection.table_exists?("horses")
           assert migration.connection.table_exists?("new_horses")
@@ -305,7 +305,7 @@ module ActiveRecord
     end
 
     def test_revert_order
-      block = Proc.new{|t| t.string :name }
+      block = Proc.new { |t| t.string :name }
       recorder = ActiveRecord::Migration::CommandRecorder.new(ActiveRecord::Base.connection)
       recorder.instance_eval do
         create_table("apples", &block)
diff --git a/activerecord/test/cases/migration/change_schema_test.rb b/activerecord/test/cases/migration/change_schema_test.rb
index 0191c9d03b..bdb90eaa74 100644
--- a/activerecord/test/cases/migration/change_schema_test.rb
+++ b/activerecord/test/cases/migration/change_schema_test.rb
@@ -200,8 +200,8 @@ module ActiveRecord
         end
         created_columns = connection.columns(table_name)
 
-        created_at_column = created_columns.detect {|c| c.name == "created_at" }
-        updated_at_column = created_columns.detect {|c| c.name == "updated_at" }
+        created_at_column = created_columns.detect { |c| c.name == "created_at" }
+        updated_at_column = created_columns.detect { |c| c.name == "updated_at" }
 
         assert !created_at_column.null
         assert !updated_at_column.null
@@ -213,8 +213,8 @@ module ActiveRecord
         end
         created_columns = connection.columns(table_name)
 
-        created_at_column = created_columns.detect {|c| c.name == "created_at" }
-        updated_at_column = created_columns.detect {|c| c.name == "updated_at" }
+        created_at_column = created_columns.detect { |c| c.name == "created_at" }
+        updated_at_column = created_columns.detect { |c| c.name == "updated_at" }
 
         assert created_at_column.null
         assert updated_at_column.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)"
@@ -298,9 +298,9 @@ module ActiveRecord
         assert_equal false, person_klass.columns_hash["wealth"].null
         # Oracle needs primary key value from sequence
         if current_adapter?(:OracleAdapter)
-          assert_nothing_raised {person_klass.connection.execute("insert into testings (id, title) values (testings_seq.nextval, 'tester')")}
+          assert_nothing_raised { person_klass.connection.execute("insert into testings (id, title) values (testings_seq.nextval, 'tester')") }
         else
-          assert_nothing_raised {person_klass.connection.execute("insert into testings (title) values ('tester')")}
+          assert_nothing_raised { person_klass.connection.execute("insert into testings (title) values ('tester')") }
         end
 
         # change column default to see that column doesn't lose its not null definition
@@ -346,9 +346,9 @@ module ActiveRecord
           end
           notnull_migration.new.suppress_messages do
             notnull_migration.migrate(:up)
-            assert_equal false, connection.columns(:testings).find{ |c| c.name == "foo"}.null
+            assert_equal false, connection.columns(:testings).find { |c| c.name == "foo" }.null
             notnull_migration.migrate(:down)
-            assert connection.columns(:testings).find{ |c| c.name == "foo"}.null
+            assert connection.columns(:testings).find { |c| c.name == "foo" }.null
           end
         end
       end
diff --git a/activerecord/test/cases/migration/change_table_test.rb b/activerecord/test/cases/migration/change_table_test.rb
index 87da9c90fe..ec817a579b 100644
--- a/activerecord/test/cases/migration/change_table_test.rb
+++ b/activerecord/test/cases/migration/change_table_test.rb
@@ -157,7 +157,7 @@ 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}]
+          @connection.expect :add_column, nil, [:delete_me, :bar, :integer, { null: false }]
           t.column :bar, :integer, null: false
         end
       end
@@ -171,7 +171,7 @@ module ActiveRecord
 
       def test_index_creates_index_with_options
         with_change_table do |t|
-          @connection.expect :add_index, nil, [:delete_me, :bar, {unique: true}]
+          @connection.expect :add_index, nil, [:delete_me, :bar, { unique: true }]
           t.index :bar, unique: true
         end
       end
@@ -185,7 +185,7 @@ module ActiveRecord
 
       def test_index_exists_with_options
         with_change_table do |t|
-          @connection.expect :index_exists?, nil, [:delete_me, :bar, {unique: true}]
+          @connection.expect :index_exists?, nil, [:delete_me, :bar, { unique: true }]
           t.index_exists?(:bar, unique: true)
         end
       end
@@ -206,7 +206,7 @@ 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}]
+          @connection.expect :change_column, nil, [:delete_me, :bar, :string, { null: true }]
           t.change :bar, :string, null: true
         end
       end
@@ -234,7 +234,7 @@ module ActiveRecord
 
       def test_remove_index_removes_index_with_options
         with_change_table do |t|
-          @connection.expect :remove_index, nil, [:delete_me, {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/command_recorder_test.rb b/activerecord/test/cases/migration/command_recorder_test.rb
index 39f3fd99c7..802a969cb7 100644
--- a/activerecord/test/cases/migration/command_recorder_test.rb
+++ b/activerecord/test/cases/migration/command_recorder_test.rb
@@ -44,7 +44,7 @@ module ActiveRecord
 
       def test_irreversible_commands_raise_exception
         assert_raises(ActiveRecord::IrreversibleMigration) do
-          @recorder.revert{ @recorder.execute "some sql" }
+          @recorder.revert { @recorder.execute "some sql" }
         end
       end
 
@@ -58,12 +58,12 @@ module ActiveRecord
           @recorder.record :create_table, [:hello]
           @recorder.record :create_table, [:world]
         end
-        tables = @recorder.commands.map{|_cmd, args, _block| args}
+        tables = @recorder.commands.map { |_cmd, args, _block| args }
         assert_equal [[:world], [:hello]], tables
       end
 
       def test_revert_order
-        block = Proc.new{|t| t.string :name }
+        block = Proc.new { |t| t.string :name }
         @recorder.instance_eval do
           create_table("apples", &block)
           revert do
@@ -115,13 +115,13 @@ module ActiveRecord
       end
 
       def test_invert_create_table_with_options_and_block
-        block = Proc.new{}
+        block = Proc.new {}
         drop_table = @recorder.inverse_of :create_table, [:people_reminders, id: false], &block
         assert_equal [:drop_table, [:people_reminders, id: false], block], drop_table
       end
 
       def test_invert_drop_table
-        block = Proc.new{}
+        block = Proc.new {}
         create_table = @recorder.inverse_of :drop_table, [:people_reminders, id: false], &block
         assert_equal [:create_table, [:people_reminders, id: false], block], create_table
       end
@@ -143,7 +143,7 @@ module ActiveRecord
       end
 
       def test_invert_drop_join_table
-        block = Proc.new{}
+        block = Proc.new {}
         create_join_table = @recorder.inverse_of :drop_join_table, [:musics, :artists, table_name: :catalog], &block
         assert_equal [:create_join_table, [:musics, :artists, table_name: :catalog], block], create_join_table
       end
@@ -203,17 +203,17 @@ module ActiveRecord
 
       def test_invert_add_index
         remove = @recorder.inverse_of :add_index, [:table, [:one, :two]]
-        assert_equal [:remove_index, [:table, {column: [:one, :two]}]], remove
+        assert_equal [:remove_index, [:table, { column: [:one, :two] }]], remove
       end
 
       def test_invert_add_index_with_name
         remove = @recorder.inverse_of :add_index, [:table, [:one, :two], name: "new_index"]
-        assert_equal [:remove_index, [:table, {name: "new_index"}]], remove
+        assert_equal [:remove_index, [:table, { name: "new_index" }]], remove
       end
 
       def test_invert_add_index_with_no_options
         remove = @recorder.inverse_of :add_index, [:table, [:one, :two]]
-        assert_equal [:remove_index, [:table, {column: [:one, :two]}]], remove
+        assert_equal [:remove_index, [:table, { column: [:one, :two] }]], remove
       end
 
       def test_invert_remove_index
@@ -222,17 +222,17 @@ module ActiveRecord
       end
 
       def test_invert_remove_index_with_column
-        add = @recorder.inverse_of :remove_index, [:table, {column: [:one, :two], options: true}]
+        add = @recorder.inverse_of :remove_index, [:table, { column: [:one, :two], options: true }]
         assert_equal [:add_index, [:table, [:one, :two], options: true]], add
       end
 
       def test_invert_remove_index_with_name
-        add = @recorder.inverse_of :remove_index, [:table, {column: [:one, :two], name: "new_index"}]
+        add = @recorder.inverse_of :remove_index, [:table, { column: [:one, :two], name: "new_index" }]
         assert_equal [:add_index, [:table, [:one, :two], name: "new_index"]], add
       end
 
       def test_invert_remove_index_with_no_special_options
-        add = @recorder.inverse_of :remove_index, [:table, {column: [:one, :two]}]
+        add = @recorder.inverse_of :remove_index, [:table, { column: [:one, :two] }]
         assert_equal [:add_index, [:table, [:one, :two], {}]], add
       end
 
@@ -254,7 +254,7 @@ module ActiveRecord
 
       def test_invert_remove_timestamps
         add = @recorder.inverse_of :remove_timestamps, [:table, { null: true }]
-        assert_equal [:add_timestamps, [:table, {null: true }], nil], add
+        assert_equal [:add_timestamps, [:table, { null: true }], nil], add
       end
 
       def test_invert_add_reference
diff --git a/activerecord/test/cases/migration/create_join_table_test.rb b/activerecord/test/cases/migration/create_join_table_test.rb
index 372ec40a04..f14d68f12b 100644
--- a/activerecord/test/cases/migration/create_join_table_test.rb
+++ b/activerecord/test/cases/migration/create_join_table_test.rb
@@ -61,7 +61,7 @@ module ActiveRecord
       end
 
       def test_create_join_table_with_column_options
-        connection.create_join_table :artists, :musics, column_options: {null: true}
+        connection.create_join_table :artists, :musics, column_options: { null: true }
 
         assert_equal [true, true], connection.columns(:artists_musics).map(&:null)
       end
@@ -116,8 +116,8 @@ module ActiveRecord
       end
 
       def test_drop_join_table_with_column_options
-        connection.create_join_table :artists, :musics, column_options: {null: true}
-        connection.drop_join_table :artists, :musics, column_options: {null: true}
+        connection.create_join_table :artists, :musics, column_options: { null: true }
+        connection.drop_join_table :artists, :musics, column_options: { null: true }
 
         ActiveSupport::Deprecation.silence { assert !connection.table_exists?("artists_musics") }
       end
diff --git a/activerecord/test/cases/migration/index_test.rb b/activerecord/test/cases/migration/index_test.rb
index 85e09986ea..0f975026b8 100644
--- a/activerecord/test/cases/migration/index_test.rb
+++ b/activerecord/test/cases/migration/index_test.rb
@@ -143,7 +143,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
@@ -169,13 +169,13 @@ module ActiveRecord
         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.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)
@@ -186,11 +186,11 @@ module ActiveRecord
 
         # 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.remove_index("testings", ["last_name", "first_name"])
diff --git a/activerecord/test/cases/migration/references_foreign_key_test.rb b/activerecord/test/cases/migration/references_foreign_key_test.rb
index 8436435170..528811db49 100644
--- a/activerecord/test/cases/migration/references_foreign_key_test.rb
+++ b/activerecord/test/cases/migration/references_foreign_key_test.rb
@@ -59,7 +59,7 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
           end
           fks = @connection.foreign_keys("testings")
           assert_equal([["testings", "testing_parents", "parent_id"]],
-                       fks.map {|fk| [fk.from_table, fk.to_table, fk.column] })
+                       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
@@ -186,7 +186,7 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
 
           fks = @connection.foreign_keys("testings")
 
-          fk_definitions = fks.map {|fk| [fk.from_table, fk.to_table, fk.column] }
+          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
diff --git a/activerecord/test/cases/migration/references_index_test.rb b/activerecord/test/cases/migration/references_index_test.rb
index 0d0b0a193b..2866cabab6 100644
--- a/activerecord/test/cases/migration/references_index_test.rb
+++ b/activerecord/test/cases/migration/references_index_test.rb
@@ -41,8 +41,8 @@ module ActiveRecord
 
       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)
diff --git a/activerecord/test/cases/migration_test.rb b/activerecord/test/cases/migration_test.rb
index 5d96569d38..76a4592ac5 100644
--- a/activerecord/test/cases/migration_test.rb
+++ b/activerecord/test/cases/migration_test.rb
@@ -759,7 +759,7 @@ if ActiveRecord::Base.connection.supports_bulk_alter?
   class BulkAlterTableMigrationsTest < ActiveRecord::TestCase
     def setup
       @connection = Person.connection
-      @connection.create_table(:delete_me, force: true) {|t| }
+      @connection.create_table(:delete_me, force: true) { |t| }
       Person.reset_column_information
       Person.reset_sequence_name
     end
@@ -780,7 +780,7 @@ if ActiveRecord::Base.connection.supports_bulk_alter?
       end
 
       assert_equal 8, columns.size
-      [:name, :qualification, :experience].each {|s| assert_equal :string, column(s).type }
+      [:name, :qualification, :experience].each { |s| assert_equal :string, column(s).type }
       assert_equal "0", column(:age).default
     end
 
@@ -789,7 +789,7 @@ if ActiveRecord::Base.connection.supports_bulk_alter?
         t.string :qualification, :experience
       end
 
-      [:qualification, :experience].each {|c| assert column(c) }
+      [:qualification, :experience].each { |c| assert column(c) }
 
       assert_queries(1) do
         with_bulk_change_table do |t|
@@ -798,7 +798,7 @@ if ActiveRecord::Base.connection.supports_bulk_alter?
         end
       end
 
-      [:qualification, :experience].each {|c| assert ! column(c) }
+      [:qualification, :experience].each { |c| assert ! column(c) }
       assert column(:qualification_experience)
     end
 
@@ -882,7 +882,7 @@ if ActiveRecord::Base.connection.supports_bulk_alter?
       end
 
       def column(name)
-        columns.detect {|c| c.name == name.to_s }
+        columns.detect { |c| c.name == name.to_s }
       end
 
       def columns
@@ -890,7 +890,7 @@ if ActiveRecord::Base.connection.supports_bulk_alter?
       end
 
       def index(name)
-        indexes.detect {|i| i.name == name.to_s }
+        indexes.detect { |i| i.name == name.to_s }
       end
 
       def indexes
diff --git a/activerecord/test/cases/modules_test.rb b/activerecord/test/cases/modules_test.rb
index 1b7720e4f8..f8a7bab35f 100644
--- a/activerecord/test/cases/modules_test.rb
+++ b/activerecord/test/cases/modules_test.rb
@@ -73,7 +73,7 @@ class ModulesTest < ActiveRecord::TestCase
     clients = []
 
     assert_nothing_raised do
-      clients << MyApplication::Business::Client.references(:accounts).merge!(includes: {firm: :account}, where: "accounts.id IS NOT NULL").find(3)
+      clients << MyApplication::Business::Client.references(:accounts).merge!(includes: { firm: :account }, where: "accounts.id IS NOT NULL").find(3)
       clients << MyApplication::Business::Client.includes(firm: :account).find(3)
     end
 
diff --git a/activerecord/test/cases/nested_attributes_test.rb b/activerecord/test/cases/nested_attributes_test.rb
index 788277faea..a9c3733c20 100644
--- a/activerecord/test/cases/nested_attributes_test.rb
+++ b/activerecord/test/cases/nested_attributes_test.rb
@@ -31,7 +31,7 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
 
   def test_should_not_build_a_new_record_using_reject_all_even_if_destroy_is_given
     pirate = Pirate.create!(catchphrase: "Don' botharrr talkin' like one, savvy?")
-    pirate.birds_with_reject_all_blank_attributes = [{name: "", color: "", _destroy: "0"}]
+    pirate.birds_with_reject_all_blank_attributes = [{ name: "", color: "", _destroy: "0" }]
     pirate.save!
 
     assert pirate.birds_with_reject_all_blank.empty?
@@ -39,7 +39,7 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
 
   def test_should_not_build_a_new_record_if_reject_all_blank_returns_false
     pirate = Pirate.create!(catchphrase: "Don' botharrr talkin' like one, savvy?")
-    pirate.birds_with_reject_all_blank_attributes = [{name: "", color: ""}]
+    pirate.birds_with_reject_all_blank_attributes = [{ name: "", color: "" }]
     pirate.save!
 
     assert pirate.birds_with_reject_all_blank.empty?
@@ -47,7 +47,7 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
 
   def test_should_build_a_new_record_if_reject_all_blank_does_not_return_false
     pirate = Pirate.create!(catchphrase: "Don' botharrr talkin' like one, savvy?")
-    pirate.birds_with_reject_all_blank_attributes = [{name: "Tweetie", color: ""}]
+    pirate.birds_with_reject_all_blank_attributes = [{ name: "Tweetie", color: "" }]
     pirate.save!
 
     assert_equal 1, pirate.birds_with_reject_all_blank.count
@@ -108,7 +108,7 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
   end
 
   def test_reject_if_with_indifferent_keys
-    Pirate.accepts_nested_attributes_for :ship, reject_if: proc {|attributes| attributes[:name].blank? }
+    Pirate.accepts_nested_attributes_for :ship, reject_if: proc { |attributes| attributes[:name].blank? }
 
     pirate = Pirate.new(catchphrase: "Stop wastin' me time")
     pirate.ship_attributes = { name: "Hello Pearl" }
@@ -116,7 +116,7 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
   end
 
   def test_reject_if_with_a_proc_which_returns_true_always_for_has_one
-    Pirate.accepts_nested_attributes_for :ship, reject_if: proc {|attributes| true }
+    Pirate.accepts_nested_attributes_for :ship, reject_if: proc { |attributes| true }
     pirate = Pirate.new(catchphrase: "Stop wastin' me time")
     ship = pirate.create_ship(name: "s1")
     pirate.update(ship_attributes: { name: "s2", id: ship.id })
@@ -138,7 +138,7 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
   end
 
   def test_reject_if_with_a_proc_which_returns_true_always_for_has_many
-    Man.accepts_nested_attributes_for :interests, reject_if: proc {|attributes| true }
+    Man.accepts_nested_attributes_for :interests, reject_if: proc { |attributes| true }
     man = Man.create(name: "John")
     interest = man.interests.create(topic: "photography")
     man.update(interests_attributes: { topic: "gardening", id: interest.id })
@@ -146,7 +146,7 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
   end
 
   def test_destroy_works_independent_of_reject_if
-    Man.accepts_nested_attributes_for :interests, reject_if: proc {|attributes| true }, allow_destroy: true
+    Man.accepts_nested_attributes_for :interests, reject_if: proc { |attributes| true }, allow_destroy: true
     man = Man.create(name: "Jon")
     interest = man.interests.create(topic: "the ladies")
     man.update(interests_attributes: { _destroy: "1", id: interest.id })
@@ -170,13 +170,13 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
     Man.accepts_nested_attributes_for(:interests)
     man = Man.create(name: "John")
     interest = man.interests.create(topic: "photography")
-    man.update(interests_attributes: {topic: "gardening", id: interest.id})
+    man.update(interests_attributes: { topic: "gardening", id: interest.id })
     assert_equal "gardening", interest.reload.topic
   end
 
   def test_reject_if_with_blank_nested_attributes_id
     # When using a select list to choose an existing 'ship' id, with include_blank: true
-    Pirate.accepts_nested_attributes_for :ship, reject_if: proc {|attributes| attributes[:id].blank? }
+    Pirate.accepts_nested_attributes_for :ship, reject_if: proc { |attributes| attributes[:id].blank? }
 
     pirate = Pirate.new(catchphrase: "Stop wastin' me time")
     pirate.ship_attributes = { id: "" }
@@ -188,7 +188,7 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
     man = Man.create(name: "John")
     interest = man.interests.create topic: "gardening"
     man = Man.find man.id
-    man.interests_attributes = [{id: interest.id, topic: "gardening"}]
+    man.interests_attributes = [{ id: interest.id, topic: "gardening" }]
     assert_equal man.interests.first.topic, man.interests[0].topic
   end
 
@@ -225,7 +225,7 @@ class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
 
   def test_should_raise_argument_error_if_trying_to_build_polymorphic_belongs_to
     exception = assert_raise ArgumentError do
-      Treasure.new(name: "pearl", looter_attributes: {catchphrase: "Arrr"})
+      Treasure.new(name: "pearl", looter_attributes: { catchphrase: "Arrr" })
     end
     assert_equal "Cannot build association `looter'. Are you trying to build a polymorphic one-to-one association?", exception.message
   end
@@ -700,7 +700,7 @@ module NestedAttributesOnACollectionAssociationTests
   def test_should_automatically_build_new_associated_models_for_each_entry_in_a_hash_where_the_id_is_missing
     @pirate.send(@association_name).destroy_all
     @pirate.reload.attributes = {
-      association_getter => { "foo" => { name: "Grace OMalley" }, "bar" => { name: "Privateers Greed" }}
+      association_getter => { "foo" => { name: "Grace OMalley" }, "bar" => { name: "Privateers Greed" } }
     }
 
     assert !@pirate.send(@association_name).first.persisted?
@@ -757,7 +757,7 @@ module NestedAttributesOnACollectionAssociationTests
 
   def test_should_work_with_update_as_well
     @pirate.update(catchphrase: "Arr",
-      association_getter => { "foo" => { id: @child_1.id, name: "Grace OMalley" }})
+      association_getter => { "foo" => { id: @child_1.id, name: "Grace OMalley" } })
 
     assert_equal "Grace OMalley", @child_1.reload.name
   end
@@ -813,7 +813,7 @@ module NestedAttributesOnACollectionAssociationTests
       assert_difference "Man.count" do
         assert_difference "Interest.count", 2 do
           man = Man.create!(name: "John",
-                            interests_attributes: [{topic: "Cars"}, {topic: "Sports"}])
+                            interests_attributes: [{ topic: "Cars" }, { topic: "Sports" }])
           assert_equal 2, man.interests.count
         end
       end
@@ -911,7 +911,7 @@ module NestedAttributesLimitTests
     assert_raises(ActiveRecord::NestedAttributes::TooManyRecords) do
       @pirate.attributes = { parrots_attributes: { "foo" => { name: "Lovely Day" },
                                                       "bar" => { name: "Blown Away" },
-                                                      "car" => { name: "The Happening" }} }
+                                                      "car" => { name: "The Happening" } } }
     end
   end
 end
@@ -971,10 +971,10 @@ class TestNestedAttributesWithNonStandardPrimaryKeys < ActiveRecord::TestCase
   def test_attr_accessor_of_child_should_be_value_provided_during_update
     @owner = owners(:ashley)
     @pet1 = pets(:chew)
-    attributes = {pets_attributes: { "1"=> { id: @pet1.id,
+    attributes = { pets_attributes: { "1"=> { id: @pet1.id,
                                                 name: "Foo2",
                                                 current_user: "John",
-                                                _destroy: true }}}
+                                                _destroy: true } } }
     @owner.update(attributes)
     assert_equal "John", Pet.after_destroy_output
   end
@@ -997,18 +997,18 @@ class TestHasOneAutosaveAssociationWhichItselfHasAutosaveAssociations < ActiveRe
   end
 
   test "when great-grandchild changed via attributes, saving parent should save great-grandchild" do
-    @pirate.attributes = {ship_attributes: {id: @ship.id, parts_attributes: [{id: @part.id, trinkets_attributes: [{id: @trinket.id, name: "changed"}]}]}}
+    @pirate.attributes = { ship_attributes: { id: @ship.id, parts_attributes: [{ id: @part.id, trinkets_attributes: [{ id: @trinket.id, name: "changed" }] }] } }
     @pirate.save
     assert_equal "changed", @trinket.reload.name
   end
 
   test "when great-grandchild marked_for_destruction via attributes, saving parent should destroy great-grandchild" do
-    @pirate.attributes = {ship_attributes: {id: @ship.id, parts_attributes: [{id: @part.id, trinkets_attributes: [{id: @trinket.id, _destroy: true}]}]}}
+    @pirate.attributes = { ship_attributes: { id: @ship.id, parts_attributes: [{ id: @part.id, trinkets_attributes: [{ id: @trinket.id, _destroy: true }] }] } }
     assert_difference("@part.trinkets.count", -1) { @pirate.save }
   end
 
   test "when great-grandchild added via attributes, saving parent should create great-grandchild" do
-    @pirate.attributes = {ship_attributes: {id: @ship.id, parts_attributes: [{id: @part.id, trinkets_attributes: [{name: "created"}]}]}}
+    @pirate.attributes = { ship_attributes: { id: @ship.id, parts_attributes: [{ id: @part.id, trinkets_attributes: [{ name: "created" }] }] } }
     assert_difference("@part.trinkets.count", 1) { @pirate.save }
   end
 
@@ -1030,13 +1030,13 @@ class TestHasManyAutosaveAssociationWhichItselfHasAutosaveAssociations < ActiveR
   end
 
   test "if association is not loaded and association record is saved and then in memory record attributes should be saved" do
-    @ship.parts_attributes=[{id: @part.id,name: "Deck"}]
+    @ship.parts_attributes=[{ id: @part.id,name: "Deck" }]
     assert_equal 1, @ship.association(:parts).target.size
     assert_equal "Deck", @ship.parts[0].name
   end
 
   test "if association is not loaded and child doesn't change and I am saving a grandchild then in memory record should be used" do
-    @ship.parts_attributes=[{id: @part.id,trinkets_attributes: [{id: @trinket.id, name: "Ruby"}]}]
+    @ship.parts_attributes=[{ id: @part.id,trinkets_attributes: [{ id: @trinket.id, name: "Ruby" }] }]
     assert_equal 1, @ship.association(:parts).target.size
     assert_equal "Mast", @ship.parts[0].name
     assert_no_difference("@ship.parts[0].association(:trinkets).target.size") do
@@ -1054,18 +1054,18 @@ class TestHasManyAutosaveAssociationWhichItselfHasAutosaveAssociations < ActiveR
   end
 
   test "when grandchild changed via attributes, saving parent should save grandchild" do
-    @ship.attributes = {parts_attributes: [{id: @part.id, trinkets_attributes: [{id: @trinket.id, name: "changed"}]}]}
+    @ship.attributes = { parts_attributes: [{ id: @part.id, trinkets_attributes: [{ id: @trinket.id, name: "changed" }] }] }
     @ship.save
     assert_equal "changed", @trinket.reload.name
   end
 
   test "when grandchild marked_for_destruction via attributes, saving parent should destroy grandchild" do
-    @ship.attributes = {parts_attributes: [{id: @part.id, trinkets_attributes: [{id: @trinket.id, _destroy: true}]}]}
+    @ship.attributes = { parts_attributes: [{ id: @part.id, trinkets_attributes: [{ id: @trinket.id, _destroy: true }] }] }
     assert_difference("@part.trinkets.count", -1) { @ship.save }
   end
 
   test "when grandchild added via attributes, saving parent should create grandchild" do
-    @ship.attributes = {parts_attributes: [{id: @part.id, trinkets_attributes: [{name: "created"}]}]}
+    @ship.attributes = { parts_attributes: [{ id: @part.id, trinkets_attributes: [{ name: "created" }] }] }
     assert_difference("@part.trinkets.count", 1) { @ship.save }
   end
 
diff --git a/activerecord/test/cases/nested_attributes_with_callbacks_test.rb b/activerecord/test/cases/nested_attributes_with_callbacks_test.rb
index d606a6c12d..8954e8c7e3 100644
--- a/activerecord/test/cases/nested_attributes_with_callbacks_test.rb
+++ b/activerecord/test/cases/nested_attributes_with_callbacks_test.rb
@@ -21,7 +21,7 @@ class NestedAttributesWithCallbacksTest < ActiveRecord::TestCase
     @@add_callback_called = []
     @pirate = Pirate.new.tap do |pirate|
       pirate.catchphrase = "Don't call me!"
-      pirate.birds_attributes = [{name: "Bird1"},{name: "Bird2"}]
+      pirate.birds_attributes = [{ name: "Bird1" },{ name: "Bird2" }]
       pirate.save!
     end
     @birds = @pirate.birds.to_a
@@ -46,17 +46,17 @@ class NestedAttributesWithCallbacksTest < ActiveRecord::TestCase
   end
 
   def new_bird_attributes
-    [{"name" => "New Bird"}]
+    [{ "name" => "New Bird" }]
   end
 
   def destroy_bird_attributes
-    [{"id" => bird_to_destroy.id.to_s, "_destroy" => true}]
+    [{ "id" => bird_to_destroy.id.to_s, "_destroy" => true }]
   end
 
   def update_new_and_destroy_bird_attributes
-    [{"id" => @birds[0].id.to_s, "name" => "New Name"},
-     {"name" => "New Bird"},
-     {"id" => bird_to_destroy.id.to_s, "_destroy" => true}]
+    [{ "id" => @birds[0].id.to_s, "name" => "New Name" },
+     { "name" => "New Bird" },
+     { "id" => bird_to_destroy.id.to_s, "_destroy" => true }]
   end
 
   # Characterizing when :before_add callback is called
@@ -136,9 +136,9 @@ class NestedAttributesWithCallbacksTest < ActiveRecord::TestCase
 
   def assert_assignment_affects_records_in_target(association_name)
     association = @pirate.send(association_name)
-    assert association.detect {|b| b == bird_to_update }.name_changed?,
+    assert association.detect { |b| b == bird_to_update }.name_changed?,
       "Update record not updated"
-    assert association.detect {|b| b == bird_to_destroy }.marked_for_destruction?,
+    assert association.detect { |b| b == bird_to_destroy }.marked_for_destruction?,
       "Destroy record not marked for destruction"
   end
 end
diff --git a/activerecord/test/cases/persistence_test.rb b/activerecord/test/cases/persistence_test.rb
index e293770725..d83360e327 100644
--- a/activerecord/test/cases/persistence_test.rb
+++ b/activerecord/test/cases/persistence_test.rb
@@ -83,7 +83,7 @@ class PersistenceTest < ActiveRecord::TestCase
   end
 
   def test_delete_all_with_joins_and_where_part_is_hash
-    where_args = {toys: {name: "Bone"}}
+    where_args = { toys: { name: "Bone" } }
     count = Pet.joins(:toys).where(where_args).count
 
     assert_equal count, 1
diff --git a/activerecord/test/cases/reflection_test.rb b/activerecord/test/cases/reflection_test.rb
index d71b30af69..cb47237e4b 100644
--- a/activerecord/test/cases/reflection_test.rb
+++ b/activerecord/test/cases/reflection_test.rb
@@ -124,7 +124,7 @@ class ReflectionTest < ActiveRecord::TestCase
     )
 
     reflection_for_gps_location = AggregateReflection.new(
-      :gps_location, nil, { }, Customer
+      :gps_location, nil, {}, Customer
     )
 
     assert Customer.reflect_on_all_aggregations.include?(reflection_for_gps_location)
diff --git a/activerecord/test/cases/relation/mutation_test.rb b/activerecord/test/cases/relation/mutation_test.rb
index ca5d187819..e7dc06c106 100644
--- a/activerecord/test/cases/relation/mutation_test.rb
+++ b/activerecord/test/cases/relation/mutation_test.rb
@@ -140,7 +140,7 @@ module ActiveRecord
 
     test "create_with!" do
       assert relation.create_with!(foo: "bar").equal?(relation)
-      assert_equal({foo: "bar"}, relation.create_with_value)
+      assert_equal({ foo: "bar" }, relation.create_with_value)
     end
 
     test "test_merge!" do
diff --git a/activerecord/test/cases/relation/or_test.rb b/activerecord/test/cases/relation/or_test.rb
index 4efc742d5a..2796595523 100644
--- a/activerecord/test/cases/relation/or_test.rb
+++ b/activerecord/test/cases/relation/or_test.rb
@@ -61,8 +61,8 @@ module ActiveRecord
 
     def test_or_when_grouping
       groups = Post.where("id < 10").group("body").select("body, COUNT(*) AS c")
-      expected = groups.having("COUNT(*) > 1 OR body like 'Such%'").to_a.map {|o| [o.body, o.c] }
-      assert_equal expected, groups.having("COUNT(*) > 1").or(groups.having("body like 'Such%'")).to_a.map {|o| [o.body, o.c] }
+      expected = groups.having("COUNT(*) > 1 OR body like 'Such%'").to_a.map { |o| [o.body, o.c] }
+      assert_equal expected, groups.having("COUNT(*) > 1").or(groups.having("body like 'Such%'")).to_a.map { |o| [o.body, o.c] }
     end
 
     def test_or_with_named_scope
diff --git a/activerecord/test/cases/relation/where_chain_test.rb b/activerecord/test/cases/relation/where_chain_test.rb
index 3d93cb7bce..a96d1ae5b5 100644
--- a/activerecord/test/cases/relation/where_chain_test.rb
+++ b/activerecord/test/cases/relation/where_chain_test.rb
@@ -26,7 +26,7 @@ module ActiveRecord
 
     def test_association_not_eq
       expected = Arel::Nodes::Grouping.new(Comment.arel_table[@name].not_eq(Arel::Nodes::BindParam.new))
-      relation = Post.joins(:comments).where.not(comments: {title: "hello"})
+      relation = Post.joins(:comments).where.not(comments: { title: "hello" })
       assert_equal(expected.to_sql, relation.where_clause.ast.to_sql)
     end
 
diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
index 0802afac5a..951b83e87b 100644
--- a/activerecord/test/cases/relation_test.rb
+++ b/activerecord/test/cases/relation_test.rb
@@ -70,7 +70,7 @@ module ActiveRecord
     def test_has_values
       relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
       relation.where! relation.table[:id].eq(10)
-      assert_equal({id: 10}, relation.where_values_hash)
+      assert_equal({ id: 10 }, relation.where_values_hash)
     end
 
     def test_values_wrong_table
@@ -108,8 +108,8 @@ module ActiveRecord
     def test_create_with_value_with_wheres
       relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
       relation.where! relation.table[:id].eq(10)
-      relation.create_with_value = {hello: "world"}
-      assert_equal({hello: "world", id: 10}, relation.scope_for_create)
+      relation.create_with_value = { hello: "world" }
+      assert_equal({ hello: "world", id: 10 }, relation.scope_for_create)
     end
 
     # FIXME: is this really wanted or expected behavior?
@@ -120,7 +120,7 @@ module ActiveRecord
       relation.where! relation.table[:id].eq(10)
       assert_equal({}, relation.scope_for_create)
 
-      relation.create_with_value = {hello: "world"}
+      relation.create_with_value = { hello: "world" }
       assert_equal({}, relation.scope_for_create)
     end
 
@@ -156,9 +156,9 @@ module ActiveRecord
 
     test "merging a hash into a relation" do
       relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
-      relation = relation.merge where: {name: :lol}, readonly: true
+      relation = relation.merge where: { name: :lol }, readonly: true
 
-      assert_equal({"name"=>:lol}, relation.where_clause.to_h)
+      assert_equal({ "name"=>:lol }, relation.where_clause.to_h)
       assert_equal true, relation.readonly_value
     end
 
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index 8652ef1081..a5bb6e1c51 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -384,7 +384,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_select_with_block
-    even_ids = Developer.all.select {|d| d.id % 2 == 0 }.map(&:id)
+    even_ids = Developer.all.select { |d| d.id % 2 == 0 }.map(&:id)
     assert_equal [2, 4, 6, 8, 10], even_ids.sort
   end
 
@@ -526,7 +526,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_find_on_hash_conditions
-    assert_equal Topic.all.merge!(where: {approved: false}).to_a, Topic.where(approved: false).to_a
+    assert_equal Topic.all.merge!(where: { approved: false }).to_a, Topic.where(approved: false).to_a
   end
 
   def test_joins_with_string_array
@@ -1225,8 +1225,8 @@ class RelationTest < ActiveRecord::TestCase
       assert posts.any? # Uses COUNT()
       assert ! posts.where(id: nil).any?
 
-      assert posts.any? {|p| p.id > 0 }
-      assert ! posts.any? {|p| p.id <= 0 }
+      assert posts.any? { |p| p.id > 0 }
+      assert ! posts.any? { |p| p.id <= 0 }
     end
 
     assert posts.loaded?
@@ -1237,8 +1237,8 @@ class RelationTest < ActiveRecord::TestCase
 
     assert_queries(2) do
       assert posts.many? # Uses COUNT()
-      assert posts.many? {|p| p.id > 0 }
-      assert ! posts.many? {|p| p.id < 2 }
+      assert posts.many? { |p| p.id > 0 }
+      assert ! posts.many? { |p| p.id < 2 }
     end
 
     assert posts.loaded?
@@ -1260,8 +1260,8 @@ class RelationTest < ActiveRecord::TestCase
     assert ! posts.loaded?
 
     assert_queries(1) do
-      assert posts.none? {|p| p.id < 0 }
-      assert ! posts.none? {|p| p.id == 1 }
+      assert posts.none? { |p| p.id < 0 }
+      assert ! posts.none? { |p| p.id == 1 }
     end
 
     assert posts.loaded?
@@ -1276,8 +1276,8 @@ class RelationTest < ActiveRecord::TestCase
     assert ! posts.loaded?
 
     assert_queries(1) do
-      assert ! posts.one? {|p| p.id < 3 }
-      assert posts.one? {|p| p.id == 1 }
+      assert ! posts.one? { |p| p.id < 3 }
+      assert posts.one? { |p| p.id == 1 }
     end
 
     assert posts.loaded?
@@ -1363,11 +1363,11 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_first_or_create_with_array
-    several_green_birds = Bird.where(color: "green").first_or_create([{name: "parrot"}, {name: "parakeet"}])
+    several_green_birds = Bird.where(color: "green").first_or_create([{ name: "parrot" }, { name: "parakeet" }])
     assert_kind_of Array, several_green_birds
     several_green_birds.each { |bird| assert bird.persisted? }
 
-    same_parrot = Bird.where(color: "green").first_or_create([{name: "hummingbird"}, {name: "macaw"}])
+    same_parrot = Bird.where(color: "green").first_or_create([{ name: "hummingbird" }, { name: "macaw" }])
     assert_kind_of Bird, same_parrot
     assert_equal several_green_birds.first, same_parrot
   end
@@ -1411,17 +1411,17 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_first_or_create_with_valid_array
-    several_green_birds = Bird.where(color: "green").first_or_create!([{name: "parrot"}, {name: "parakeet"}])
+    several_green_birds = Bird.where(color: "green").first_or_create!([{ name: "parrot" }, { name: "parakeet" }])
     assert_kind_of Array, several_green_birds
     several_green_birds.each { |bird| assert bird.persisted? }
 
-    same_parrot = Bird.where(color: "green").first_or_create!([{name: "hummingbird"}, {name: "macaw"}])
+    same_parrot = Bird.where(color: "green").first_or_create!([{ name: "hummingbird" }, { name: "macaw" }])
     assert_kind_of Bird, same_parrot
     assert_equal several_green_birds.first, same_parrot
   end
 
   def test_first_or_create_with_invalid_array
-    assert_raises(ActiveRecord::RecordInvalid) { Bird.where(color: "green").first_or_create!([ {name: "parrot"}, {pirate_id: 1} ]) }
+    assert_raises(ActiveRecord::RecordInvalid) { Bird.where(color: "green").first_or_create!([ { name: "parrot" }, { pirate_id: 1 } ]) }
   end
 
   def test_first_or_initialize
@@ -1555,8 +1555,8 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_unscoped_block_style
-    assert_equal "honda", CoolCar.unscoped { CoolCar.order_using_new_style.limit(1).first.name}
-    assert_equal "honda", FastCar.unscoped { FastCar.order_using_new_style.limit(1).first.name}
+    assert_equal "honda", CoolCar.unscoped { CoolCar.order_using_new_style.limit(1).first.name }
+    assert_equal "honda", FastCar.unscoped { FastCar.order_using_new_style.limit(1).first.name }
   end
 
   def test_intersection_with_array
diff --git a/activerecord/test/cases/result_test.rb b/activerecord/test/cases/result_test.rb
index 8bbd4b3bc5..949086fda0 100644
--- a/activerecord/test/cases/result_test.rb
+++ b/activerecord/test/cases/result_test.rb
@@ -16,20 +16,20 @@ module ActiveRecord
 
     test "to_hash returns row_hashes" do
       assert_equal [
-        {"col_1" => "row 1 col 1", "col_2" => "row 1 col 2"},
-        {"col_1" => "row 2 col 1", "col_2" => "row 2 col 2"},
-        {"col_1" => "row 3 col 1", "col_2" => "row 3 col 2"},
+        { "col_1" => "row 1 col 1", "col_2" => "row 1 col 2" },
+        { "col_1" => "row 2 col 1", "col_2" => "row 2 col 2" },
+        { "col_1" => "row 3 col 1", "col_2" => "row 3 col 2" },
       ], result.to_hash
     end
 
     test "first returns first row as a hash" do
       assert_equal(
-        {"col_1" => "row 1 col 1", "col_2" => "row 1 col 2"}, result.first)
+        { "col_1" => "row 1 col 1", "col_2" => "row 1 col 2" }, result.first)
     end
 
     test "last returns last row as a hash" do
       assert_equal(
-        {"col_1" => "row 3 col 1", "col_2" => "row 3 col 2"}, result.last)
+        { "col_1" => "row 3 col 1", "col_2" => "row 3 col 2" }, result.last)
     end
 
     test "each with block returns row hashes" do
diff --git a/activerecord/test/cases/schema_dumper_test.rb b/activerecord/test/cases/schema_dumper_test.rb
index 2ad3da94e4..33baf84ef2 100644
--- a/activerecord/test/cases/schema_dumper_test.rb
+++ b/activerecord/test/cases/schema_dumper_test.rb
@@ -76,11 +76,11 @@ class SchemaDumperTest < ActiveRecord::TestCase
     assert matches.all? if required
     matches.compact!
     return assert(true) if matches.empty?
-    assert_equal 1, matches.map{ |match| match.offset(0).first }.uniq.length
+    assert_equal 1, matches.map { |match| match.offset(0).first }.uniq.length
   end
 
   def column_definition_lines(output = standard_dump)
-    output.scan(/^( *)create_table.*?\n(.*?)^\1end/m).map{ |m| m.last.split(/\n/) }
+    output.scan(/^( *)create_table.*?\n(.*?)^\1end/m).map { |m| m.last.split(/\n/) }
   end
 
   def test_types_line_up
diff --git a/activerecord/test/cases/scoping/default_scoping_test.rb b/activerecord/test/cases/scoping/default_scoping_test.rb
index effecfd294..6cfe4b9581 100644
--- a/activerecord/test/cases/scoping/default_scoping_test.rb
+++ b/activerecord/test/cases/scoping/default_scoping_test.rb
@@ -132,7 +132,7 @@ class DefaultScopingTest < ActiveRecord::TestCase
     assert_equal expected, received
 
     expected_2 = Developer.order("salary DESC").collect(&:name)
-    received_2 = DeveloperOrderedBySalary.select("id").where("name" => "Jamis").unscope({where: :name}, :select).collect(&:name)
+    received_2 = DeveloperOrderedBySalary.select("id").where("name" => "Jamis").unscope({ where: :name }, :select).collect(&:name)
     assert_equal expected_2, received_2
 
     expected_3 = Developer.order("salary DESC").collect(&:name)
diff --git a/activerecord/test/cases/scoping/named_scoping_test.rb b/activerecord/test/cases/scoping/named_scoping_test.rb
index 4e799d6dc0..2f328e6e70 100644
--- a/activerecord/test/cases/scoping/named_scoping_test.rb
+++ b/activerecord/test/cases/scoping/named_scoping_test.rb
@@ -69,9 +69,9 @@ class NamedScopingTest < ActiveRecord::TestCase
   end
 
   def test_scopes_with_options_limit_finds_to_those_matching_the_criteria_specified
-    assert !Topic.all.merge!(where: {approved: true}).to_a.empty?
+    assert !Topic.all.merge!(where: { approved: true }).to_a.empty?
 
-    assert_equal Topic.all.merge!(where: {approved: true}).to_a, Topic.approved
+    assert_equal Topic.all.merge!(where: { approved: true }).to_a, Topic.approved
     assert_equal Topic.where(approved: true).count, Topic.approved.count
   end
 
@@ -82,7 +82,7 @@ class NamedScopingTest < ActiveRecord::TestCase
   end
 
   def test_scopes_are_composable
-    assert_equal((approved = Topic.all.merge!(where: {approved: true}).to_a), Topic.approved)
+    assert_equal((approved = Topic.all.merge!(where: { approved: true }).to_a), Topic.approved)
     assert_equal((replied = Topic.all.merge!(where: "replies_count > 0").to_a), Topic.replied)
     assert !(approved == replied)
     assert !(approved & replied).empty?
@@ -327,12 +327,12 @@ class NamedScopingTest < ActiveRecord::TestCase
 
     conflicts.each do |name|
       e = assert_raises(ArgumentError, "scope `#{name}` should not be allowed") do
-        klass.class_eval { scope name, ->{ where(approved: true) } }
+        klass.class_eval { scope name, -> { where(approved: true) } }
       end
       assert_match(/You tried to define a scope named \"#{name}\" on the model/, e.message)
 
       e = assert_raises(ArgumentError, "scope `#{name}` should not be allowed") do
-        subklass.class_eval { scope name, ->{ where(approved: true) } }
+        subklass.class_eval { scope name, -> { where(approved: true) } }
       end
       assert_match(/You tried to define a scope named \"#{name}\" on the model/, e.message)
     end
@@ -340,12 +340,12 @@ class NamedScopingTest < ActiveRecord::TestCase
     non_conflicts.each do |name|
       assert_nothing_raised do
         silence_warnings do
-          klass.class_eval { scope name, ->{ where(approved: true) } }
+          klass.class_eval { scope name, -> { where(approved: true) } }
         end
       end
 
       assert_nothing_raised do
-        subklass.class_eval { scope name, ->{ where(approved: true) } }
+        subklass.class_eval { scope name, -> { where(approved: true) } }
       end
     end
   end
@@ -431,12 +431,12 @@ class NamedScopingTest < ActiveRecord::TestCase
     assert_equal 4, Topic.approved.count
 
     assert_queries(5) do
-      Topic.approved.find_each(batch_size: 1) {|t| assert t.approved? }
+      Topic.approved.find_each(batch_size: 1) { |t| assert t.approved? }
     end
 
     assert_queries(3) do
       Topic.approved.find_in_batches(batch_size: 2) do |group|
-        group.each {|t| assert t.approved? }
+        group.each { |t| assert t.approved? }
       end
     end
   end
@@ -462,7 +462,7 @@ class NamedScopingTest < ActiveRecord::TestCase
     [:public_method, :protected_method, :private_method].each do |reserved_method|
       assert Topic.respond_to?(reserved_method, true)
       ActiveRecord::Base.logger.expects(:warn)
-      silence_warnings { Topic.scope(reserved_method, -> { }) }
+      silence_warnings { Topic.scope(reserved_method, -> {}) }
     end
   end
 
diff --git a/activerecord/test/cases/suppressor_test.rb b/activerecord/test/cases/suppressor_test.rb
index 64f39d8574..a7d16b7cdb 100644
--- a/activerecord/test/cases/suppressor_test.rb
+++ b/activerecord/test/cases/suppressor_test.rb
@@ -64,7 +64,7 @@ class SuppressorTest < ActiveRecord::TestCase
   def test_suppresses_when_nested_multiple_times
     assert_no_difference -> { Notification.count } do
       Notification.suppress do
-        Notification.suppress { }
+        Notification.suppress {}
         Notification.create
         Notification.create!
         Notification.new.save
diff --git a/activerecord/test/cases/tasks/database_tasks_test.rb b/activerecord/test/cases/tasks/database_tasks_test.rb
index 0519c70ac7..079db3fe8b 100644
--- a/activerecord/test/cases/tasks/database_tasks_test.rb
+++ b/activerecord/test/cases/tasks/database_tasks_test.rb
@@ -64,12 +64,12 @@ module ActiveRecord
       instance.expects(:structure_dump).with("awesome-file.sql")
 
       ActiveRecord::Tasks::DatabaseTasks.register_task(/foo/, klazz)
-      ActiveRecord::Tasks::DatabaseTasks.structure_dump({"adapter" => :foo}, "awesome-file.sql")
+      ActiveRecord::Tasks::DatabaseTasks.structure_dump({ "adapter" => :foo }, "awesome-file.sql")
     end
 
     def test_unregistered_task
       assert_raise(ActiveRecord::Tasks::DatabaseNotSupported) do
-        ActiveRecord::Tasks::DatabaseTasks.structure_dump({"adapter" => :bar}, "awesome-file.sql")
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump({ "adapter" => :bar }, "awesome-file.sql")
       end
     end
   end
@@ -87,7 +87,7 @@ module ActiveRecord
 
   class DatabaseTasksCreateAllTest < ActiveRecord::TestCase
     def setup
-      @configurations = {"development" => {"database" => "my-db"}}
+      @configurations = { "development" => { "database" => "my-db" } }
 
       ActiveRecord::Base.stubs(:configurations).returns(@configurations)
     end
@@ -145,9 +145,9 @@ module ActiveRecord
   class DatabaseTasksCreateCurrentTest < ActiveRecord::TestCase
     def setup
       @configurations = {
-        "development" => {"database" => "dev-db"},
-        "test"        => {"database" => "test-db"},
-        "production"  => {"database" => "prod-db"}
+        "development" => { "database" => "dev-db" },
+        "test"        => { "database" => "test-db" },
+        "production"  => { "database" => "prod-db" }
       }
 
       ActiveRecord::Base.stubs(:configurations).returns(@configurations)
@@ -213,7 +213,7 @@ module ActiveRecord
 
   class DatabaseTasksDropAllTest < ActiveRecord::TestCase
     def setup
-      @configurations = {development: {"database" => "my-db"}}
+      @configurations = { development: { "database" => "my-db" } }
 
       ActiveRecord::Base.stubs(:configurations).returns(@configurations)
     end
@@ -271,9 +271,9 @@ module ActiveRecord
   class DatabaseTasksDropCurrentTest < ActiveRecord::TestCase
     def setup
       @configurations = {
-        "development" => {"database" => "dev-db"},
-        "test"        => {"database" => "test-db"},
-        "production"  => {"database" => "prod-db"}
+        "development" => { "database" => "dev-db" },
+        "test"        => { "database" => "test-db" },
+        "production"  => { "database" => "prod-db" }
       }
 
       ActiveRecord::Base.stubs(:configurations).returns(@configurations)
@@ -358,9 +358,9 @@ module ActiveRecord
   class DatabaseTasksPurgeCurrentTest < ActiveRecord::TestCase
     def test_purges_current_environment_database
       configurations = {
-        "development" => {"database" => "dev-db"},
-        "test"        => {"database" => "test-db"},
-        "production"  => {"database" => "prod-db"}
+        "development" => { "database" => "dev-db" },
+        "test"        => { "database" => "test-db" },
+        "production"  => { "database" => "prod-db" }
       }
       ActiveRecord::Base.stubs(:configurations).returns(configurations)
 
@@ -374,7 +374,7 @@ module ActiveRecord
 
   class DatabaseTasksPurgeAllTest < ActiveRecord::TestCase
     def test_purge_all_local_configurations
-      configurations = {development: {"database" => "my-db"}}
+      configurations = { development: { "database" => "my-db" } }
       ActiveRecord::Base.stubs(:configurations).returns(configurations)
 
       ActiveRecord::Tasks::DatabaseTasks.expects(:purge).
@@ -412,7 +412,7 @@ module ActiveRecord
     ADAPTERS_TASKS.each do |k, v|
       define_method("test_#{k}_structure_dump") do
         eval("@#{v}").expects(:structure_dump).with("awesome-file.sql")
-        ActiveRecord::Tasks::DatabaseTasks.structure_dump({"adapter" => k}, "awesome-file.sql")
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump({ "adapter" => k }, "awesome-file.sql")
       end
     end
   end
@@ -423,7 +423,7 @@ module ActiveRecord
     ADAPTERS_TASKS.each do |k, v|
       define_method("test_#{k}_structure_load") do
         eval("@#{v}").expects(:structure_load).with("awesome-file.sql")
-        ActiveRecord::Tasks::DatabaseTasks.structure_load({"adapter" => k}, "awesome-file.sql")
+        ActiveRecord::Tasks::DatabaseTasks.structure_load({ "adapter" => k }, "awesome-file.sql")
       end
     end
   end
@@ -443,7 +443,7 @@ module ActiveRecord
   end
 
   class DatabaseTasksCheckSchemaFileSpecifiedFormatsTest < ActiveRecord::TestCase
-    {ruby: "schema.rb", sql: "structure.sql"}.each_pair do |fmt, filename|
+    { ruby: "schema.rb", sql: "structure.sql" }.each_pair do |fmt, filename|
       define_method("test_check_schema_file_for_#{fmt}_format") do
         ActiveRecord::Tasks::DatabaseTasks.stubs(:db_dir).returns("/tmp")
         assert_equal "/tmp/#{filename}", ActiveRecord::Tasks::DatabaseTasks.schema_file(fmt)
diff --git a/activerecord/test/cases/test_case.rb b/activerecord/test/cases/test_case.rb
index 7e8746b4f7..60ac3e08a1 100644
--- a/activerecord/test/cases/test_case.rb
+++ b/activerecord/test/cases/test_case.rb
@@ -40,7 +40,7 @@ module ActiveRecord
     ensure
       failed_patterns = []
       patterns_to_match.each do |pattern|
-        failed_patterns << pattern unless SQLCounter.log_all.any?{ |sql| pattern === sql }
+        failed_patterns << pattern unless SQLCounter.log_all.any? { |sql| pattern === sql }
       end
       assert failed_patterns.empty?, "Query pattern(s) #{failed_patterns.map(&:inspect).join(', ')} not found.#{SQLCounter.log.size == 0 ? '' : "\nQueries:\n#{SQLCounter.log.join("\n")}"}"
     end
diff --git a/activerecord/test/cases/transaction_callbacks_test.rb b/activerecord/test/cases/transaction_callbacks_test.rb
index 6a7d48871c..bd50fe55e9 100644
--- a/activerecord/test/cases/transaction_callbacks_test.rb
+++ b/activerecord/test/cases/transaction_callbacks_test.rb
@@ -68,17 +68,17 @@ class TransactionCallbacksTest < ActiveRecord::TestCase
 
     def do_before_commit(on)
       blocks = @before_commit[on] if defined?(@before_commit)
-      blocks.each{|b| b.call(self)} if blocks
+      blocks.each { |b| b.call(self) } if blocks
     end
 
     def do_after_commit(on)
       blocks = @after_commit[on] if defined?(@after_commit)
-      blocks.each{|b| b.call(self)} if blocks
+      blocks.each { |b| b.call(self) } if blocks
     end
 
     def do_after_rollback(on)
       blocks = @after_rollback[on] if defined?(@after_rollback)
-      blocks.each{|b| b.call(self)} if blocks
+      blocks.each { |b| b.call(self) } if blocks
     end
   end
 
@@ -101,8 +101,8 @@ class TransactionCallbacksTest < ActiveRecord::TestCase
   end
 
   def test_call_after_commit_after_transaction_commits
-    @first.after_commit_block{|r| r.history << :after_commit}
-    @first.after_rollback_block{|r| r.history << :after_rollback}
+    @first.after_commit_block { |r| r.history << :after_commit }
+    @first.after_rollback_block { |r| r.history << :after_rollback }
 
     @first.save!
     assert_equal [:after_commit], @first.history
@@ -155,7 +155,7 @@ class TransactionCallbacksTest < ActiveRecord::TestCase
   end
 
   def test_only_call_after_commit_on_top_level_transactions
-    @first.after_commit_block{|r| r.history << :after_commit}
+    @first.after_commit_block { |r| r.history << :after_commit }
     assert @first.history.empty?
 
     @first.transaction do
@@ -168,8 +168,8 @@ class TransactionCallbacksTest < ActiveRecord::TestCase
   end
 
   def test_call_after_rollback_after_transaction_rollsback
-    @first.after_commit_block{|r| r.history << :after_commit}
-    @first.after_rollback_block{|r| r.history << :after_rollback}
+    @first.after_commit_block { |r| r.history << :after_commit }
+    @first.after_rollback_block { |r| r.history << :after_rollback }
 
     Topic.transaction do
       @first.save!
@@ -245,14 +245,14 @@ class TransactionCallbacksTest < ActiveRecord::TestCase
   def test_only_call_after_rollback_on_records_rolled_back_to_a_savepoint
     def @first.rollbacks(i=0); @rollbacks ||= 0; @rollbacks += i if i; end
     def @first.commits(i=0); @commits ||= 0; @commits += i if i; end
-    @first.after_rollback_block{|r| r.rollbacks(1)}
-    @first.after_commit_block{|r| r.commits(1)}
+    @first.after_rollback_block { |r| r.rollbacks(1) }
+    @first.after_commit_block { |r| r.commits(1) }
 
     second = TopicWithCallbacks.find(3)
     def second.rollbacks(i=0); @rollbacks ||= 0; @rollbacks += i if i; end
     def second.commits(i=0); @commits ||= 0; @commits += i if i; end
-    second.after_rollback_block{|r| r.rollbacks(1)}
-    second.after_commit_block{|r| r.commits(1)}
+    second.after_rollback_block { |r| r.rollbacks(1) }
+    second.after_commit_block { |r| r.commits(1) }
 
     Topic.transaction do
       @first.save!
@@ -272,8 +272,8 @@ class TransactionCallbacksTest < ActiveRecord::TestCase
     def @first.rollbacks(i=0); @rollbacks ||= 0; @rollbacks += i if i; end
     def @first.commits(i=0); @commits ||= 0; @commits += i if i; end
 
-    @first.after_rollback_block{|r| r.rollbacks(1)}
-    @first.after_commit_block{|r| r.commits(1)}
+    @first.after_rollback_block { |r| r.rollbacks(1) }
+    @first.after_commit_block { |r| r.commits(1) }
 
     Topic.transaction do
       @first.save
@@ -292,7 +292,7 @@ class TransactionCallbacksTest < ActiveRecord::TestCase
   end
 
   def test_after_commit_callback_should_not_swallow_errors
-    @first.after_commit_block{ fail "boom" }
+    @first.after_commit_block { fail "boom" }
     assert_raises(RuntimeError) do
       Topic.transaction do
         @first.save!
@@ -303,8 +303,8 @@ class TransactionCallbacksTest < ActiveRecord::TestCase
   def test_after_commit_callback_when_raise_should_not_restore_state
     first = TopicWithCallbacks.new
     second = TopicWithCallbacks.new
-    first.after_commit_block{ fail "boom" }
-    second.after_commit_block{ fail "boom" }
+    first.after_commit_block { fail "boom" }
+    second.after_commit_block { fail "boom" }
 
     begin
       Topic.transaction do
@@ -322,7 +322,7 @@ class TransactionCallbacksTest < ActiveRecord::TestCase
 
   def test_after_rollback_callback_should_not_swallow_errors_when_set_to_raise
     error_class = Class.new(StandardError)
-    @first.after_rollback_block{ raise error_class }
+    @first.after_rollback_block { raise error_class }
     assert_raises(error_class) do
       Topic.transaction do
         @first.save!
@@ -336,8 +336,8 @@ class TransactionCallbacksTest < ActiveRecord::TestCase
 
     first = TopicWithCallbacks.new
     second = TopicWithCallbacks.new
-    first.after_rollback_block{ raise error_class }
-    second.after_rollback_block{ raise error_class }
+    first.after_rollback_block { raise error_class }
+    second.after_rollback_block { raise error_class }
 
     begin
       Topic.transaction do
diff --git a/activerecord/test/cases/transaction_isolation_test.rb b/activerecord/test/cases/transaction_isolation_test.rb
index f177f0644a..58abfadaf4 100644
--- a/activerecord/test/cases/transaction_isolation_test.rb
+++ b/activerecord/test/cases/transaction_isolation_test.rb
@@ -9,7 +9,7 @@ unless ActiveRecord::Base.connection.supports_transaction_isolation?
 
     test "setting the isolation level raises an error" do
       assert_raises(ActiveRecord::TransactionIsolationError) do
-        Tag.transaction(isolation: :serializable) { }
+        Tag.transaction(isolation: :serializable) {}
       end
     end
   end
@@ -90,7 +90,7 @@ if ActiveRecord::Base.connection.supports_transaction_isolation?
     test "setting isolation when joining a transaction raises an error" do
       Tag.transaction do
         assert_raises(ActiveRecord::TransactionIsolationError) do
-          Tag.transaction(isolation: :serializable) { }
+          Tag.transaction(isolation: :serializable) {}
         end
       end
     end
@@ -98,7 +98,7 @@ if ActiveRecord::Base.connection.supports_transaction_isolation?
     test "setting isolation when starting a nested transaction raises error" do
       Tag.transaction do
         assert_raises(ActiveRecord::TransactionIsolationError) do
-          Tag.transaction(requires_new: true, isolation: :serializable) { }
+          Tag.transaction(requires_new: true, isolation: :serializable) {}
         end
       end
     end
diff --git a/activerecord/test/cases/transactions_test.rb b/activerecord/test/cases/transactions_test.rb
index c8963ada63..8f0b2bd313 100644
--- a/activerecord/test/cases/transactions_test.rb
+++ b/activerecord/test/cases/transactions_test.rb
@@ -493,7 +493,7 @@ class TransactionTest < ActiveRecord::TestCase
 
   def test_rollback_when_commit_raises
     assert_called(Topic.connection, :begin_db_transaction) do
-      Topic.connection.stub(:commit_db_transaction, ->{ raise("OH NOES") }) do
+      Topic.connection.stub(:commit_db_transaction, -> { raise("OH NOES") }) do
         assert_called(Topic.connection, :rollback_db_transaction) do
 
           e = assert_raise RuntimeError do
@@ -692,7 +692,7 @@ class TransactionTest < ActiveRecord::TestCase
 
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = "transaction_without_primary_keys"
-      after_commit { } # necessary to trigger the has_transactional_callbacks branch
+      after_commit {} # necessary to trigger the has_transactional_callbacks branch
     end
 
     assert_no_difference(-> { klass.count }) do
diff --git a/activerecord/test/cases/validations/i18n_generate_message_validation_test.rb b/activerecord/test/cases/validations/i18n_generate_message_validation_test.rb
index d73d287073..a57065ba75 100644
--- a/activerecord/test/cases/validations/i18n_generate_message_validation_test.rb
+++ b/activerecord/test/cases/validations/i18n_generate_message_validation_test.rb
@@ -47,7 +47,7 @@ class I18nGenerateMessageValidationTest < ActiveRecord::TestCase
 
   test "RecordInvalid exception translation falls back to the :errors namespace" do
     reset_i18n_load_path do
-      I18n.backend.store_translations "en", errors: {messages: {record_invalid: "fallback message"}}
+      I18n.backend.store_translations "en", errors: { messages: { record_invalid: "fallback message" } }
       topic = Topic.new
       topic.errors.add(:title, :blank)
       assert_equal "fallback message", ActiveRecord::RecordInvalid.new(topic).message
@@ -56,28 +56,28 @@ class I18nGenerateMessageValidationTest < ActiveRecord::TestCase
 
   test "translation for 'taken' can be overridden" do
     reset_i18n_load_path do
-      I18n.backend.store_translations "en", errors: {attributes: {title: {taken: "Custom taken message" }}}
+      I18n.backend.store_translations "en", errors: { attributes: { title: { taken: "Custom taken message" } } }
       assert_equal "Custom taken message", @topic.errors.generate_message(:title, :taken, value: "title")
     end
   end
 
   test "translation for 'taken' can be overridden in activerecord scope" do
     reset_i18n_load_path do
-      I18n.backend.store_translations "en", activerecord: {errors: {messages: {taken: "Custom taken message" }}}
+      I18n.backend.store_translations "en", activerecord: { errors: { messages: { taken: "Custom taken message" } } }
       assert_equal "Custom taken message", @topic.errors.generate_message(:title, :taken, value: "title")
     end
   end
 
   test "translation for 'taken' can be overridden in activerecord model scope" do
     reset_i18n_load_path do
-      I18n.backend.store_translations "en", activerecord: {errors: {models: {topic: {taken: "Custom taken message" }}}}
+      I18n.backend.store_translations "en", activerecord: { errors: { models: { topic: { taken: "Custom taken message" } } } }
       assert_equal "Custom taken message", @topic.errors.generate_message(:title, :taken, value: "title")
     end
   end
 
   test "translation for 'taken' can be overridden in activerecord attributes scope" do
     reset_i18n_load_path do
-      I18n.backend.store_translations "en", activerecord: {errors: {models: {topic: {attributes: {title: {taken: "Custom taken message" }}}}}}
+      I18n.backend.store_translations "en", activerecord: { errors: { models: { topic: { attributes: { title: { taken: "Custom taken message" } } } } } }
       assert_equal "Custom taken message", @topic.errors.generate_message(:title, :taken, value: "title")
     end
   end
diff --git a/activerecord/test/cases/validations/i18n_validation_test.rb b/activerecord/test/cases/validations/i18n_validation_test.rb
index cbb5362f3f..bdae806f7c 100644
--- a/activerecord/test/cases/validations/i18n_validation_test.rb
+++ b/activerecord/test/cases/validations/i18n_validation_test.rb
@@ -12,7 +12,7 @@ class I18nValidationTest < ActiveRecord::TestCase
     @old_load_path, @old_backend = I18n.load_path.dup, I18n.backend
     I18n.load_path.clear
     I18n.backend = I18n::Backend::Simple.new
-    I18n.backend.store_translations("en", errors: {messages: {custom: nil}})
+    I18n.backend.store_translations("en", errors: { messages: { custom: nil } })
   end
 
   teardown do
@@ -38,11 +38,11 @@ class I18nValidationTest < ActiveRecord::TestCase
   COMMON_CASES = [
   # [ case,                                validation_options,            generate_message_options]
     [ "given no options",                  {},                            {}],
-    [ "given custom message",              {message: "custom"},        {message: "custom"}],
-    [ "given if condition",                {if: lambda { true }},  {}],
-    [ "given unless condition",            {unless: lambda { false }}, {}],
-    [ "given option that is not reserved", {format: "jpg"},            {format: "jpg" }],
-    [ "given on condition",                {on: [:create, :update] },     {}]
+    [ "given custom message",              { message: "custom" },        { message: "custom" }],
+    [ "given if condition",                { if: lambda { true } },  {}],
+    [ "given unless condition",            { unless: lambda { false } }, {}],
+    [ "given option that is not reserved", { format: "jpg" },            { format: "jpg" }],
+    [ "given on condition",                { on: [:create, :update] },     {}]
   ]
 
   COMMON_CASES.each do |name, validation_options, generate_message_options|
@@ -65,8 +65,8 @@ class I18nValidationTest < ActiveRecord::TestCase
   end
 
   def test_validates_associated_finds_custom_model_key_translation
-    I18n.backend.store_translations "en", activerecord: {errors: {models: {topic: {attributes: {replies: {invalid: "custom message"}}}}}}
-    I18n.backend.store_translations "en", activerecord: {errors: {messages: {invalid: "global message"}}}
+    I18n.backend.store_translations "en", activerecord: { errors: { models: { topic: { attributes: { replies: { invalid: "custom message" } } } } } }
+    I18n.backend.store_translations "en", activerecord: { errors: { messages: { invalid: "global message" } } }
 
     Topic.validates_associated :replies
     replied_topic.valid?
@@ -74,7 +74,7 @@ class I18nValidationTest < ActiveRecord::TestCase
   end
 
   def test_validates_associated_finds_global_default_translation
-    I18n.backend.store_translations "en", activerecord: {errors: {messages: {invalid: "global message"}}}
+    I18n.backend.store_translations "en", activerecord: { errors: { messages: { invalid: "global message" } } }
 
     Topic.validates_associated :replies
     replied_topic.valid?
diff --git a/activerecord/test/cases/validations/length_validation_test.rb b/activerecord/test/cases/validations/length_validation_test.rb
index 4fcb3e2eb6..ba45c6dcc1 100644
--- a/activerecord/test/cases/validations/length_validation_test.rb
+++ b/activerecord/test/cases/validations/length_validation_test.rb
@@ -54,7 +54,7 @@ class LengthValidationTest < ActiveRecord::TestCase
     assert owner.save
 
     pet_count = Pet.count
-    assert_not owner.update_attributes pets_attributes: [ {_destroy: 1, id: pet.id} ]
+    assert_not owner.update_attributes pets_attributes: [ { _destroy: 1, id: pet.id } ]
     assert_not owner.valid?
     assert owner.errors[:pets].any?
     assert_equal pet_count, Pet.count
diff --git a/activerecord/test/cases/view_test.rb b/activerecord/test/cases/view_test.rb
index 5f85c5ff8b..aa3ff6160c 100644
--- a/activerecord/test/cases/view_test.rb
+++ b/activerecord/test/cases/view_test.rb
@@ -60,7 +60,7 @@ module ViewBehavior
   end
 
   def test_attributes
-    assert_equal({"id" => 2, "name" => "Ruby for Rails", "status" => 0},
+    assert_equal({ "id" => 2, "name" => "Ruby for Rails", "status" => 0 },
                  Ebook.first.attributes)
   end
 
@@ -135,7 +135,7 @@ if ActiveRecord::Base.connection.supports_views?
     end
 
     def test_attributes
-      assert_equal({"name" => "Agile Web Development with Rails", "status" => 2},
+      assert_equal({ "name" => "Agile Web Development with Rails", "status" => 2 },
                    Paperback.first.attributes)
     end
 
diff --git a/activerecord/test/cases/yaml_serialization_test.rb b/activerecord/test/cases/yaml_serialization_test.rb
index ade6e6095b..5192e5050a 100644
--- a/activerecord/test/cases/yaml_serialization_test.rb
+++ b/activerecord/test/cases/yaml_serialization_test.rb
@@ -22,8 +22,8 @@ class YamlSerializationTest < ActiveRecord::TestCase
   end
 
   def test_roundtrip_serialized_column
-    topic = Topic.new(content: {omg: :lol})
-    assert_equal({omg: :lol}, YAML.load(YAML.dump(topic)).content)
+    topic = Topic.new(content: { omg: :lol })
+    assert_equal({ omg: :lol }, YAML.load(YAML.dump(topic)).content)
   end
 
   def test_psych_roundtrip
diff --git a/activerecord/test/models/author.rb b/activerecord/test/models/author.rb
index 8633504d54..fab613afd1 100644
--- a/activerecord/test/models/author.rb
+++ b/activerecord/test/models/author.rb
@@ -67,13 +67,13 @@ class Author < ActiveRecord::Base
            before_remove: :log_before_removing,
            after_remove: :log_after_removing
   has_many :posts_with_proc_callbacks, class_name: "Post",
-           before_add: Proc.new {|o, r| o.post_log << "before_adding#{r.id || '<new>'}"},
-           after_add: Proc.new {|o, r| o.post_log << "after_adding#{r.id || '<new>'}"},
-           before_remove: Proc.new {|o, r| o.post_log << "before_removing#{r.id}"},
-           after_remove: Proc.new {|o, r| o.post_log << "after_removing#{r.id}"}
+           before_add: Proc.new { |o, r| o.post_log << "before_adding#{r.id || '<new>'}" },
+           after_add: Proc.new { |o, r| o.post_log << "after_adding#{r.id || '<new>'}" },
+           before_remove: Proc.new { |o, r| o.post_log << "before_removing#{r.id}" },
+           after_remove: Proc.new { |o, r| o.post_log << "after_removing#{r.id}" }
   has_many :posts_with_multiple_callbacks, class_name: "Post",
-           before_add: [:log_before_adding, Proc.new {|o, r| o.post_log << "before_adding_proc#{r.id || '<new>'}"}],
-           after_add: [:log_after_adding,  Proc.new {|o, r| o.post_log << "after_adding_proc#{r.id || '<new>'}"}]
+           before_add: [:log_before_adding, Proc.new { |o, r| o.post_log << "before_adding_proc#{r.id || '<new>'}" }],
+           after_add: [:log_after_adding,  Proc.new { |o, r| o.post_log << "after_adding_proc#{r.id || '<new>'}" }]
   has_many :unchangeable_posts, class_name: "Post", before_add: :raise_exception, after_add: :log_after_adding
 
   has_many :categorizations
diff --git a/activerecord/test/models/book.rb b/activerecord/test/models/book.rb
index edd0281127..4c275fdebb 100644
--- a/activerecord/test/models/book.rb
+++ b/activerecord/test/models/book.rb
@@ -8,7 +8,7 @@ class Book < ActiveRecord::Base
   has_many :subscribers, through: :subscriptions
 
   enum status: [:proposed, :written, :published]
-  enum read_status: {unread: 0, reading: 2, read: 3}
+  enum read_status: { unread: 0, reading: 2, read: 3 }
   enum nullable_status: [:single, :married]
   enum language: [:english, :spanish, :french], _prefix: :in
   enum author_visibility: [:visible, :invisible], _prefix: true
diff --git a/activerecord/test/models/comment.rb b/activerecord/test/models/comment.rb
index 7315a1af8e..a4b81d56e0 100644
--- a/activerecord/test/models/comment.rb
+++ b/activerecord/test/models/comment.rb
@@ -1,5 +1,5 @@
 class Comment < ActiveRecord::Base
-  scope :limit_by, lambda {|l| limit(l) }
+  scope :limit_by, lambda { |l| limit(l) }
   scope :containing_the_letter_e, -> { where("comments.body LIKE '%e%'") }
   scope :not_again, -> { where("comments.body NOT LIKE '%again%'") }
   scope :for_first_post, -> { where(post_id: 1) }
@@ -55,6 +55,6 @@ class CommentThatAutomaticallyAltersPostBody < Comment
 end
 
 class CommentWithDefaultScopeReferencesAssociation < Comment
-  default_scope ->{ includes(:developer).order("developers.name").references(:developer) }
+  default_scope -> { includes(:developer).order("developers.name").references(:developer) }
   belongs_to :developer
 end
diff --git a/activerecord/test/models/customer.rb b/activerecord/test/models/customer.rb
index 71afd0866e..60af7c2247 100644
--- a/activerecord/test/models/customer.rb
+++ b/activerecord/test/models/customer.rb
@@ -5,7 +5,7 @@ class Customer < ActiveRecord::Base
   composed_of :balance, class_name: "Money", mapping: %w(balance amount), converter: Proc.new(&:to_money)
   composed_of :gps_location, allow_nil: true
   composed_of :non_blank_gps_location, class_name: "GpsLocation", allow_nil: true, mapping: %w(gps_location gps_location),
-              converter: lambda { |gps| self.gps_conversion_was_run = true; gps.blank? ? nil : GpsLocation.new(gps)}
+              converter: lambda { |gps| self.gps_conversion_was_run = true; gps.blank? ? nil : GpsLocation.new(gps) }
   composed_of :fullname, mapping: %w(name to_s), constructor: Proc.new { |name| Fullname.parse(name) }, converter: :parse
   composed_of :fullname_no_converter, mapping: %w(name to_s), class_name: "Fullname"
 end
diff --git a/activerecord/test/models/invoice.rb b/activerecord/test/models/invoice.rb
index 44ee717187..4be5a00193 100644
--- a/activerecord/test/models/invoice.rb
+++ b/activerecord/test/models/invoice.rb
@@ -1,4 +1,4 @@
 class Invoice < ActiveRecord::Base
   has_many :line_items, autosave: true
-  before_save {|record| record.balance = record.line_items.map(&:amount).sum }
+  before_save { |record| record.balance = record.line_items.map(&:amount).sum }
 end
diff --git a/activerecord/test/models/member.rb b/activerecord/test/models/member.rb
index 93dfc8253f..36f2461b84 100644
--- a/activerecord/test/models/member.rb
+++ b/activerecord/test/models/member.rb
@@ -5,7 +5,7 @@ class Member < ActiveRecord::Base
   has_one :club, through: :current_membership
   has_one :selected_club, through: :selected_membership, source: :club
   has_one :favourite_club, -> { where "memberships.favourite = ?", true }, through: :membership, source: :club
-  has_one :hairy_club, -> { where clubs: {name: "Moustache and Eyebrow Fancier Club"} }, through: :membership, source: :club
+  has_one :hairy_club, -> { where clubs: { name: "Moustache and Eyebrow Fancier Club" } }, through: :membership, source: :club
   has_one :sponsor, as: :sponsorable
   has_one :sponsor_club, through: :sponsor
   has_one :member_detail, inverse_of: false
diff --git a/activerecord/test/models/pirate.rb b/activerecord/test/models/pirate.rb
index 80a941874b..2dc8f9bd84 100644
--- a/activerecord/test/models/pirate.rb
+++ b/activerecord/test/models/pirate.rb
@@ -9,10 +9,10 @@ class Pirate < ActiveRecord::Base
     before_remove: :log_before_remove,
     after_remove: :log_after_remove
   has_and_belongs_to_many :parrots_with_proc_callbacks, class_name: "Parrot",
-    before_add: proc {|p,pa| p.ship_log << "before_adding_proc_parrot_#{pa.id || '<new>'}"},
-    after_add: proc {|p,pa| p.ship_log << "after_adding_proc_parrot_#{pa.id || '<new>'}"},
-    before_remove: proc {|p,pa| p.ship_log << "before_removing_proc_parrot_#{pa.id}"},
-    after_remove: proc {|p,pa| p.ship_log << "after_removing_proc_parrot_#{pa.id}"}
+    before_add: proc { |p,pa| p.ship_log << "before_adding_proc_parrot_#{pa.id || '<new>'}" },
+    after_add: proc { |p,pa| p.ship_log << "after_adding_proc_parrot_#{pa.id || '<new>'}" },
+    before_remove: proc { |p,pa| p.ship_log << "before_removing_proc_parrot_#{pa.id}" },
+    after_remove: proc { |p,pa| p.ship_log << "after_removing_proc_parrot_#{pa.id}" }
   has_and_belongs_to_many :autosaved_parrots, class_name: "Parrot", autosave: true
 
   has_many :treasures, as: :looter
@@ -28,10 +28,10 @@ class Pirate < ActiveRecord::Base
     before_remove: :log_before_remove,
     after_remove: :log_after_remove
   has_many :birds_with_proc_callbacks, class_name: "Bird",
-    before_add: proc {|p,b| p.ship_log << "before_adding_proc_bird_#{b.id || '<new>'}"},
-    after_add: proc {|p,b| p.ship_log << "after_adding_proc_bird_#{b.id || '<new>'}"},
-    before_remove: proc {|p,b| p.ship_log << "before_removing_proc_bird_#{b.id}"},
-    after_remove: proc {|p,b| p.ship_log << "after_removing_proc_bird_#{b.id}"}
+    before_add: proc { |p,b| p.ship_log << "before_adding_proc_bird_#{b.id || '<new>'}" },
+    after_add: proc { |p,b| p.ship_log << "after_adding_proc_bird_#{b.id || '<new>'}" },
+    before_remove: proc { |p,b| p.ship_log << "before_removing_proc_bird_#{b.id}" },
+    after_remove: proc { |p,b| p.ship_log << "after_removing_proc_bird_#{b.id}" }
   has_many :birds_with_reject_all_blank, class_name: "Bird"
 
   has_one :foo_bulb, -> { where name: "foo" }, foreign_key: :car_id, class_name: "Bulb"
diff --git a/activerecord/test/models/post.rb b/activerecord/test/models/post.rb
index 8bfd79d907..42eff9cff9 100644
--- a/activerecord/test/models/post.rb
+++ b/activerecord/test/models/post.rb
@@ -21,7 +21,7 @@ class Post < ActiveRecord::Base
   scope :titled_with_an_apostrophe, -> { where("title LIKE '%''%'") }
   scope :ranked_by_comments,      -> { order("comments_count DESC") }
 
-  scope :limit_by, lambda {|l| limit(l) }
+  scope :limit_by, lambda { |l| limit(l) }
 
   belongs_to :author
 
@@ -34,8 +34,8 @@ class Post < ActiveRecord::Base
   has_one :first_comment, -> { order("id ASC") }, class_name: "Comment"
   has_one :last_comment, -> { order("id desc") }, class_name: "Comment"
 
-  scope :with_special_comments, -> { joins(:comments).where(comments: {type: "SpecialComment"}) }
-  scope :with_very_special_comments, -> { joins(:comments).where(comments: {type: "VerySpecialComment"}) }
+  scope :with_special_comments, -> { joins(:comments).where(comments: { type: "SpecialComment" }) }
+  scope :with_very_special_comments, -> { joins(:comments).where(comments: { type: "VerySpecialComment" }) }
   scope :with_post, ->(post_id) { joins(:comments).where(comments: { post_id: post_id }) }
 
   scope :with_comments, -> { preload(:comments) }
@@ -141,10 +141,10 @@ class Post < ActiveRecord::Base
   has_many :people, through: :readers
   has_many :single_people, through: :readers
   has_many :people_with_callbacks, source: :person, through: :readers,
-              before_add: lambda {|owner, reader| log(:added,   :before, reader.first_name) },
-              after_add: lambda {|owner, reader| log(:added,   :after,  reader.first_name) },
-              before_remove: lambda {|owner, reader| log(:removed, :before, reader.first_name) },
-              after_remove: lambda {|owner, reader| log(:removed, :after,  reader.first_name) }
+              before_add: lambda { |owner, reader| log(:added,   :before, reader.first_name) },
+              after_add: lambda { |owner, reader| log(:added,   :after,  reader.first_name) },
+              before_remove: lambda { |owner, reader| log(:removed, :before, reader.first_name) },
+              after_remove: lambda { |owner, reader| log(:removed, :after,  reader.first_name) }
   has_many :skimmers, -> { where skimmer: true }, class_name: "Reader"
   has_many :impatient_people, through: :skimmers, source: :person
 
diff --git a/activerecord/test/models/project.rb b/activerecord/test/models/project.rb
index 4d6b269731..5009f8f54b 100644
--- a/activerecord/test/models/project.rb
+++ b/activerecord/test/models/project.rb
@@ -7,10 +7,10 @@ class Project < ActiveRecord::Base
   has_and_belongs_to_many :developers_named_david, -> { where("name = 'David'").distinct }, class_name: "Developer"
   has_and_belongs_to_many :developers_named_david_with_hash_conditions, -> { where(name: "David").distinct }, class_name: "Developer"
   has_and_belongs_to_many :salaried_developers, -> { where "salary > 0" }, class_name: "Developer"
-  has_and_belongs_to_many :developers_with_callbacks, class_name: "Developer", before_add: Proc.new {|o, r| o.developers_log << "before_adding#{r.id || '<new>'}"},
-                            after_add: Proc.new {|o, r| o.developers_log << "after_adding#{r.id || '<new>'}"},
-                            before_remove: Proc.new {|o, r| o.developers_log << "before_removing#{r.id}"},
-                            after_remove: Proc.new {|o, r| o.developers_log << "after_removing#{r.id}"}
+  has_and_belongs_to_many :developers_with_callbacks, class_name: "Developer", before_add: Proc.new { |o, r| o.developers_log << "before_adding#{r.id || '<new>'}" },
+                            after_add: Proc.new { |o, r| o.developers_log << "after_adding#{r.id || '<new>'}" },
+                            before_remove: Proc.new { |o, r| o.developers_log << "before_removing#{r.id}" },
+                            after_remove: Proc.new { |o, r| o.developers_log << "after_removing#{r.id}" }
   has_and_belongs_to_many :well_payed_salary_groups, -> { group("developers.salary").having("SUM(salary) > 10000").select("SUM(salary) as salary") }, class_name: "Developer"
   belongs_to :firm
   has_one :lead_developer, through: :firm, inverse_of: :contracted_projects
diff --git a/activerecord/test/models/sponsor.rb b/activerecord/test/models/sponsor.rb
index 175933ccf1..3f142b25fe 100644
--- a/activerecord/test/models/sponsor.rb
+++ b/activerecord/test/models/sponsor.rb
@@ -2,6 +2,6 @@ class Sponsor < ActiveRecord::Base
   belongs_to :sponsor_club, class_name: "Club", foreign_key: "club_id"
   belongs_to :sponsorable, polymorphic: true
   belongs_to :thing, polymorphic: true, foreign_type: :sponsorable_type, foreign_key: :sponsorable_id
-  belongs_to :sponsorable_with_conditions, -> { where name: "Ernie"}, polymorphic: true,
+  belongs_to :sponsorable_with_conditions, -> { where name: "Ernie" }, polymorphic: true,
              foreign_type: "sponsorable_type", foreign_key: "sponsorable_id"
 end
diff --git a/activerecord/test/schema/schema.rb b/activerecord/test/schema/schema.rb
index 558c21b8d2..9997ddee77 100644
--- a/activerecord/test/schema/schema.rb
+++ b/activerecord/test/schema/schema.rb
@@ -899,7 +899,7 @@ ActiveRecord::Schema.define do
   end
 
   [:circles, :squares, :triangles, :non_poly_ones, :non_poly_twos].each do |t|
-    create_table(t, force: true) { }
+    create_table(t, force: true) {}
   end
 
   # NOTE - the following 4 tables are used by models that have :inverse_of options on the associations