Add three new rubocop rules

Style/SpaceBeforeBlockBraces
Style/SpaceInsideBlockBraces
Style/SpaceInsideHashLiteralBraces

Fix all violations in the repository.

13 files changed, 102 insertions, 102 deletions

diff --git a/activesupport/test/core_ext/duration_test.rb b/activesupport/test/core_ext/duration_test.rb
index 64b5bca151..1a2dcba760 100644
--- a/activesupport/test/core_ext/duration_test.rb
+++ b/activesupport/test/core_ext/duration_test.rb
@@ -194,7 +194,7 @@ class DurationTest < ActiveSupport::TestCase
   def test_delegation_with_block_works
     counter = 0
     assert_nothing_raised do
-      1.minute.times {counter += 1}
+      1.minute.times { counter += 1 }
     end
     assert_equal counter, 60
   end
diff --git a/activesupport/test/core_ext/enumerable_test.rb b/activesupport/test/core_ext/enumerable_test.rb
index 3d63a5fbb6..9072957e0e 100644
--- a/activesupport/test/core_ext/enumerable_test.rb
+++ b/activesupport/test/core_ext/enumerable_test.rb
@@ -75,7 +75,7 @@ class EnumerableTests < ActiveSupport::TestCase
     assert_typed_equal(2.0, sum.real, Float)
     assert_typed_equal(3.0, sum.imag, Float)
 
-    sum = GenericEnumerable.new([1, 2]).sum(10) {|v| v * 2 }
+    sum = GenericEnumerable.new([1, 2]).sum(10) { |v| v * 2 }
     assert_typed_equal(16, sum, Integer)
   end
 
@@ -162,7 +162,7 @@ class EnumerableTests < ActiveSupport::TestCase
     assert_typed_equal(2.0, sum.real, Float)
     assert_typed_equal(3.0, sum.imag, Float)
 
-    sum = [1, 2].sum(10) {|v| v * 2 }
+    sum = [1, 2].sum(10) { |v| v * 2 }
     assert_typed_equal(16, sum, Integer)
   end
 
@@ -184,17 +184,17 @@ class EnumerableTests < ActiveSupport::TestCase
     assert_equal false, GenericEnumerable.new([ 1 ]      ).many?
     assert_equal true,  GenericEnumerable.new([ 1, 2 ]   ).many?
 
-    assert_equal false, GenericEnumerable.new([]         ).many? {|x| x > 1 }
-    assert_equal false, GenericEnumerable.new([ 2 ]      ).many? {|x| x > 1 }
-    assert_equal false, GenericEnumerable.new([ 1, 2 ]   ).many? {|x| x > 1 }
-    assert_equal true,  GenericEnumerable.new([ 1, 2, 2 ]).many? {|x| x > 1 }
+    assert_equal false, GenericEnumerable.new([]         ).many? { |x| x > 1 }
+    assert_equal false, GenericEnumerable.new([ 2 ]      ).many? { |x| x > 1 }
+    assert_equal false, GenericEnumerable.new([ 1, 2 ]   ).many? { |x| x > 1 }
+    assert_equal true,  GenericEnumerable.new([ 1, 2, 2 ]).many? { |x| x > 1 }
   end
 
   def test_many_iterates_only_on_what_is_needed
     infinity = 1.0/0.0
     very_long_enum = 0..infinity
     assert_equal true, very_long_enum.many?
-    assert_equal true, very_long_enum.many?{|x| x > 100}
+    assert_equal true, very_long_enum.many? { |x| x > 100 }
   end
 
   def test_exclude?
@@ -206,7 +206,7 @@ class EnumerableTests < ActiveSupport::TestCase
     assert_equal [1, 2, 4], GenericEnumerable.new((1..5).to_a).without(3, 5)
     assert_equal [1, 2, 4], (1..5).to_a.without(3, 5)
     assert_equal [1, 2, 4], (1..5).to_set.without(3, 5)
-    assert_equal({foo: 1, baz: 3}, {foo: 1, bar: 2, baz: 3}.without(:bar))
+    assert_equal({ foo: 1, baz: 3 }, { foo: 1, bar: 2, baz: 3 }.without(:bar))
   end
 
   def test_pluck
diff --git a/activesupport/test/core_ext/hash/transform_keys_test.rb b/activesupport/test/core_ext/hash/transform_keys_test.rb
index ea34a47b3d..7a11d827f8 100644
--- a/activesupport/test/core_ext/hash/transform_keys_test.rb
+++ b/activesupport/test/core_ext/hash/transform_keys_test.rb
@@ -48,7 +48,7 @@ class TransformKeysTest < ActiveSupport::TestCase
     class HashDescendant < ::Hash
       def initialize(elements = nil)
         super(elements)
-        (elements || {}).each_pair{ |key, value| self[key] = value }
+        (elements || {}).each_pair { |key, value| self[key] = value }
       end
     end
 
diff --git a/activesupport/test/core_ext/hash_ext_test.rb b/activesupport/test/core_ext/hash_ext_test.rb
index 6a65f999fd..e457cb866d 100644
--- a/activesupport/test/core_ext/hash_ext_test.rb
+++ b/activesupport/test/core_ext/hash_ext_test.rb
@@ -41,9 +41,9 @@ class HashExtTest < ActiveSupport::TestCase
     @mixed = { :a => 1, "b" => 2 }
     @nested_mixed = { "a" => { b: { "c" => 3 } } }
     @integers = { 0 => 1, 1 => 2 }
-    @nested_integers = { 0 => { 1 => { 2 => 3} } }
+    @nested_integers = { 0 => { 1 => { 2 => 3 } } }
     @illegal_symbols = { [] => 3 }
-    @nested_illegal_symbols = { [] => { [] => 3} }
+    @nested_illegal_symbols = { [] => { [] => 3 } }
     @upcase_strings = { "A" => 1, "B" => 2 }
     @nested_upcase_strings = { "A" => { "B" => { "C" => 3 } } }
     @string_array_of_hashes = { "a" => [ { "b" => 2 }, { "c" => 3 }, 4 ] }
@@ -75,57 +75,57 @@ class HashExtTest < ActiveSupport::TestCase
   end
 
   def test_transform_keys
-    assert_equal @upcase_strings, @strings.transform_keys{ |key| key.to_s.upcase }
-    assert_equal @upcase_strings, @symbols.transform_keys{ |key| key.to_s.upcase }
-    assert_equal @upcase_strings, @mixed.transform_keys{ |key| key.to_s.upcase }
+    assert_equal @upcase_strings, @strings.transform_keys { |key| key.to_s.upcase }
+    assert_equal @upcase_strings, @symbols.transform_keys { |key| key.to_s.upcase }
+    assert_equal @upcase_strings, @mixed.transform_keys { |key| key.to_s.upcase }
   end
 
   def test_transform_keys_not_mutates
     transformed_hash = @mixed.dup
-    transformed_hash.transform_keys{ |key| key.to_s.upcase }
+    transformed_hash.transform_keys { |key| key.to_s.upcase }
     assert_equal @mixed, transformed_hash
   end
 
   def test_deep_transform_keys
-    assert_equal @nested_upcase_strings, @nested_symbols.deep_transform_keys{ |key| key.to_s.upcase }
-    assert_equal @nested_upcase_strings, @nested_strings.deep_transform_keys{ |key| key.to_s.upcase }
-    assert_equal @nested_upcase_strings, @nested_mixed.deep_transform_keys{ |key| key.to_s.upcase }
-    assert_equal @upcase_array_of_hashes, @string_array_of_hashes.deep_transform_keys{ |key| key.to_s.upcase }
-    assert_equal @upcase_array_of_hashes, @symbol_array_of_hashes.deep_transform_keys{ |key| key.to_s.upcase }
-    assert_equal @upcase_array_of_hashes, @mixed_array_of_hashes.deep_transform_keys{ |key| key.to_s.upcase }
+    assert_equal @nested_upcase_strings, @nested_symbols.deep_transform_keys { |key| key.to_s.upcase }
+    assert_equal @nested_upcase_strings, @nested_strings.deep_transform_keys { |key| key.to_s.upcase }
+    assert_equal @nested_upcase_strings, @nested_mixed.deep_transform_keys { |key| key.to_s.upcase }
+    assert_equal @upcase_array_of_hashes, @string_array_of_hashes.deep_transform_keys { |key| key.to_s.upcase }
+    assert_equal @upcase_array_of_hashes, @symbol_array_of_hashes.deep_transform_keys { |key| key.to_s.upcase }
+    assert_equal @upcase_array_of_hashes, @mixed_array_of_hashes.deep_transform_keys { |key| key.to_s.upcase }
   end
 
   def test_deep_transform_keys_not_mutates
     transformed_hash = @nested_mixed.deep_dup
-    transformed_hash.deep_transform_keys{ |key| key.to_s.upcase }
+    transformed_hash.deep_transform_keys { |key| key.to_s.upcase }
     assert_equal @nested_mixed, transformed_hash
   end
 
   def test_transform_keys!
-    assert_equal @upcase_strings, @symbols.dup.transform_keys!{ |key| key.to_s.upcase }
-    assert_equal @upcase_strings, @strings.dup.transform_keys!{ |key| key.to_s.upcase }
-    assert_equal @upcase_strings, @mixed.dup.transform_keys!{ |key| key.to_s.upcase }
+    assert_equal @upcase_strings, @symbols.dup.transform_keys! { |key| key.to_s.upcase }
+    assert_equal @upcase_strings, @strings.dup.transform_keys! { |key| key.to_s.upcase }
+    assert_equal @upcase_strings, @mixed.dup.transform_keys! { |key| key.to_s.upcase }
   end
 
   def test_transform_keys_with_bang_mutates
     transformed_hash = @mixed.dup
-    transformed_hash.transform_keys!{ |key| key.to_s.upcase }
+    transformed_hash.transform_keys! { |key| key.to_s.upcase }
     assert_equal @upcase_strings, transformed_hash
     assert_equal @mixed, :a => 1, "b" => 2
   end
 
   def test_deep_transform_keys!
-    assert_equal @nested_upcase_strings, @nested_symbols.deep_dup.deep_transform_keys!{ |key| key.to_s.upcase }
-    assert_equal @nested_upcase_strings, @nested_strings.deep_dup.deep_transform_keys!{ |key| key.to_s.upcase }
-    assert_equal @nested_upcase_strings, @nested_mixed.deep_dup.deep_transform_keys!{ |key| key.to_s.upcase }
-    assert_equal @upcase_array_of_hashes, @string_array_of_hashes.deep_dup.deep_transform_keys!{ |key| key.to_s.upcase }
-    assert_equal @upcase_array_of_hashes, @symbol_array_of_hashes.deep_dup.deep_transform_keys!{ |key| key.to_s.upcase }
-    assert_equal @upcase_array_of_hashes, @mixed_array_of_hashes.deep_dup.deep_transform_keys!{ |key| key.to_s.upcase }
+    assert_equal @nested_upcase_strings, @nested_symbols.deep_dup.deep_transform_keys! { |key| key.to_s.upcase }
+    assert_equal @nested_upcase_strings, @nested_strings.deep_dup.deep_transform_keys! { |key| key.to_s.upcase }
+    assert_equal @nested_upcase_strings, @nested_mixed.deep_dup.deep_transform_keys! { |key| key.to_s.upcase }
+    assert_equal @upcase_array_of_hashes, @string_array_of_hashes.deep_dup.deep_transform_keys! { |key| key.to_s.upcase }
+    assert_equal @upcase_array_of_hashes, @symbol_array_of_hashes.deep_dup.deep_transform_keys! { |key| key.to_s.upcase }
+    assert_equal @upcase_array_of_hashes, @mixed_array_of_hashes.deep_dup.deep_transform_keys! { |key| key.to_s.upcase }
   end
 
   def test_deep_transform_keys_with_bang_mutates
     transformed_hash = @nested_mixed.deep_dup
-    transformed_hash.deep_transform_keys!{ |key| key.to_s.upcase }
+    transformed_hash.deep_transform_keys! { |key| key.to_s.upcase }
     assert_equal @nested_upcase_strings, transformed_hash
     assert_equal @nested_mixed, "a" => { b: { "c" => 3 } }
   end
@@ -534,7 +534,7 @@ class HashExtTest < ActiveSupport::TestCase
   end
 
   def test_indifferent_deleting
-    get_hash = proc{ { a: "foo" }.with_indifferent_access }
+    get_hash = proc { { a: "foo" }.with_indifferent_access }
     hash = get_hash.call
     assert_equal hash.delete(:a), "foo"
     assert_equal hash.delete(:a), nil
@@ -544,7 +544,7 @@ class HashExtTest < ActiveSupport::TestCase
   end
 
   def test_indifferent_select
-    hash = ActiveSupport::HashWithIndifferentAccess.new(@strings).select {|k,v| v == 1}
+    hash = ActiveSupport::HashWithIndifferentAccess.new(@strings).select { |k,v| v == 1 }
 
     assert_equal({ "a" => 1 }, hash)
     assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
@@ -556,21 +556,21 @@ class HashExtTest < ActiveSupport::TestCase
   end
 
   def test_indifferent_select_returns_a_hash_when_unchanged
-    hash = ActiveSupport::HashWithIndifferentAccess.new(@strings).select {|k,v| true}
+    hash = ActiveSupport::HashWithIndifferentAccess.new(@strings).select { |k,v| true }
 
     assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
   end
 
   def test_indifferent_select_bang
     indifferent_strings = ActiveSupport::HashWithIndifferentAccess.new(@strings)
-    indifferent_strings.select! {|k,v| v == 1}
+    indifferent_strings.select! { |k,v| v == 1 }
 
     assert_equal({ "a" => 1 }, indifferent_strings)
     assert_instance_of ActiveSupport::HashWithIndifferentAccess, indifferent_strings
   end
 
   def test_indifferent_reject
-    hash = ActiveSupport::HashWithIndifferentAccess.new(@strings).reject {|k,v| v != 1}
+    hash = ActiveSupport::HashWithIndifferentAccess.new(@strings).reject { |k,v| v != 1 }
 
     assert_equal({ "a" => 1 }, hash)
     assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
@@ -583,7 +583,7 @@ class HashExtTest < ActiveSupport::TestCase
 
   def test_indifferent_reject_bang
     indifferent_strings = ActiveSupport::HashWithIndifferentAccess.new(@strings)
-    indifferent_strings.reject! {|k,v| v != 1}
+    indifferent_strings.reject! { |k,v| v != 1 }
 
     assert_equal({ "a" => 1 }, indifferent_strings)
     assert_instance_of ActiveSupport::HashWithIndifferentAccess, indifferent_strings
@@ -608,21 +608,21 @@ class HashExtTest < ActiveSupport::TestCase
   end
 
   def test_lookup_returns_the_same_object_that_is_stored_in_hash_indifferent_access
-    hash = HashWithIndifferentAccess.new {|h, k| h[k] = []}
+    hash = HashWithIndifferentAccess.new { |h, k| h[k] = [] }
     hash[:a] << 1
 
     assert_equal [1], hash[:a]
   end
 
   def test_with_indifferent_access_has_no_side_effects_on_existing_hash
-    hash = {content: [{:foo => :bar, "bar" => "baz"}]}
+    hash = { content: [{ :foo => :bar, "bar" => "baz" }] }
     hash.with_indifferent_access
 
     assert_equal [:foo, "bar"], hash[:content].first.keys
   end
 
   def test_indifferent_hash_with_array_of_hashes
-    hash = { "urls" => { "url" => [ { "address" => "1" }, { "address" => "2" } ] }}.with_indifferent_access
+    hash = { "urls" => { "url" => [ { "address" => "1" }, { "address" => "2" } ] } }.with_indifferent_access
     assert_equal "1", hash[:urls][:url].first[:address]
 
     hash = hash.to_hash
@@ -634,14 +634,14 @@ class HashExtTest < ActiveSupport::TestCase
   def test_should_preserve_array_subclass_when_value_is_array
     array = SubclassingArray.new
     array << { "address" => "1" }
-    hash = { "urls" => { "url" => array }}.with_indifferent_access
+    hash = { "urls" => { "url" => array } }.with_indifferent_access
     assert_equal SubclassingArray, hash[:urls][:url].class
   end
 
   def test_should_preserve_array_class_when_hash_value_is_frozen_array
     array = SubclassingArray.new
     array << { "address" => "1" }
-    hash = { "urls" => { "url" => array.freeze }}.with_indifferent_access
+    hash = { "urls" => { "url" => array.freeze } }.with_indifferent_access
     assert_equal SubclassingArray, hash[:urls][:url].class
   end
 
@@ -683,11 +683,11 @@ class HashExtTest < ActiveSupport::TestCase
   end
 
   def test_indifferent_sub_hashes
-    h = {"user" => {"id" => 5}}.with_indifferent_access
-    ["user", :user].each {|user| [:id, "id"].each {|id| assert_equal 5, h[user][id], "h[#{user.inspect}][#{id.inspect}] should be 5"}}
+    h = { "user" => { "id" => 5 } }.with_indifferent_access
+    ["user", :user].each { |user| [:id, "id"].each { |id| assert_equal 5, h[user][id], "h[#{user.inspect}][#{id.inspect}] should be 5" } }
 
-    h = {user: {id: 5}}.with_indifferent_access
-    ["user", :user].each {|user| [:id, "id"].each {|id| assert_equal 5, h[user][id], "h[#{user.inspect}][#{id.inspect}] should be 5"}}
+    h = { user: { id: 5 } }.with_indifferent_access
+    ["user", :user].each { |user| [:id, "id"].each { |id| assert_equal 5, h[user][id], "h[#{user.inspect}][#{id.inspect}] should be 5" } }
   end
 
   def test_indifferent_duplication
@@ -703,7 +703,7 @@ class HashExtTest < ActiveSupport::TestCase
 
   def test_nested_dig_indifferent_access
     skip if RUBY_VERSION < "2.3.0"
-    data = {"this" => {"views" => 1234}}.with_indifferent_access
+    data = { "this" => { "views" => 1234 } }.with_indifferent_access
     assert_equal 1234, data.dig(:this, :views)
   end
 
@@ -740,9 +740,9 @@ class HashExtTest < ActiveSupport::TestCase
   end
 
   def test_assorted_keys_not_stringified
-    original = {Object.new => 2, 1 => 2, [] => true}
+    original = { Object.new => 2, 1 => 2, [] => true }
     indiff = original.with_indifferent_access
-    assert(!indiff.keys.any? {|k| k.kind_of? String}, "A key was converted to a string!")
+    assert(!indiff.keys.any? { |k| k.kind_of? String }, "A key was converted to a string!")
   end
 
   def test_deep_merge
@@ -891,7 +891,7 @@ class HashExtTest < ActiveSupport::TestCase
   end
 
   def test_indifferent_slice_access_with_symbols
-    original = {"login" => "bender", "password" => "shiny", "stuff" => "foo"}
+    original = { "login" => "bender", "password" => "shiny", "stuff" => "foo" }
     original = original.with_indifferent_access
 
     slice = original.slice(:login, :password)
@@ -919,17 +919,17 @@ class HashExtTest < ActiveSupport::TestCase
   end
 
   def test_extract
-    original = {a: 1, b: 2, c: 3, d: 4}
-    expected = {a: 1, b: 2}
-    remaining = {c: 3, d: 4}
+    original = { a: 1, b: 2, c: 3, d: 4 }
+    expected = { a: 1, b: 2 }
+    remaining = { c: 3, d: 4 }
 
     assert_equal expected, original.extract!(:a, :b, :x)
     assert_equal remaining, original
   end
 
   def test_extract_nils
-    original = {a: nil, b: nil}
-    expected = {a: nil}
+    original = { a: nil, b: nil }
+    expected = { a: nil }
     extracted = original.extract!(:a, :x)
 
     assert_equal expected, extracted
@@ -938,9 +938,9 @@ class HashExtTest < ActiveSupport::TestCase
   end
 
   def test_indifferent_extract
-    original = {:a => 1, "b" => 2, :c => 3, "d" => 4}.with_indifferent_access
-    expected = {a: 1, b: 2}.with_indifferent_access
-    remaining = {c: 3, d: 4}.with_indifferent_access
+    original = { :a => 1, "b" => 2, :c => 3, "d" => 4 }.with_indifferent_access
+    expected = { a: 1, b: 2 }.with_indifferent_access
+    remaining = { c: 3, d: 4 }.with_indifferent_access
 
     [["a", "b"], [:a, :b]].each do |keys|
       copy = original.dup
@@ -1099,15 +1099,15 @@ class HashExtToParamTests < ActiveSupport::TestCase
     assert_equal "", {}.to_param
     assert_equal "hello=world", { hello: "world" }.to_param
     assert_equal "hello=10", { "hello" => 10 }.to_param
-    assert_equal "hello=world&say_bye=true", {:hello => "world", "say_bye" => true}.to_param
+    assert_equal "hello=world&say_bye=true", { :hello => "world", "say_bye" => true }.to_param
   end
 
   def test_number_hash
-    assert_equal "10=20&30=40&50=60", {10 => 20, 30 => 40, 50 => 60}.to_param
+    assert_equal "10=20&30=40&50=60", { 10 => 20, 30 => 40, 50 => 60 }.to_param
   end
 
   def test_to_param_hash
-    assert_equal "custom-1=param-1&custom2-1=param2-1", {ToParam.new("custom") => ToParam.new("param"), ToParam.new("custom2") => ToParam.new("param2")}.to_param
+    assert_equal "custom-1=param-1&custom2-1=param2-1", { ToParam.new("custom") => ToParam.new("param"), ToParam.new("custom2") => ToParam.new("param2") }.to_param
   end
 
   def test_to_param_hash_escapes_its_keys_and_values
@@ -1437,7 +1437,7 @@ class HashToXmlTest < ActiveSupport::TestCase
         <posts type="array"></posts>
       </blog>
     XML
-    expected_blog_hash = {"blog" => {"posts" => []}}
+    expected_blog_hash = { "blog" => { "posts" => [] } }
     assert_equal expected_blog_hash, Hash.from_xml(blog_xml)
   end
 
@@ -1448,7 +1448,7 @@ class HashToXmlTest < ActiveSupport::TestCase
         </posts>
       </blog>
     XML
-    expected_blog_hash = {"blog" => {"posts" => []}}
+    expected_blog_hash = { "blog" => { "posts" => [] } }
     assert_equal expected_blog_hash, Hash.from_xml(blog_xml)
   end
 
@@ -1460,7 +1460,7 @@ class HashToXmlTest < ActiveSupport::TestCase
         </posts>
       </blog>
     XML
-    expected_blog_hash = {"blog" => {"posts" => ["a post"]}}
+    expected_blog_hash = { "blog" => { "posts" => ["a post"] } }
     assert_equal expected_blog_hash, Hash.from_xml(blog_xml)
   end
 
@@ -1473,7 +1473,7 @@ class HashToXmlTest < ActiveSupport::TestCase
         </posts>
       </blog>
     XML
-    expected_blog_hash = {"blog" => {"posts" => ["a post", "another post"]}}
+    expected_blog_hash = { "blog" => { "posts" => ["a post", "another post"] } }
     assert_equal expected_blog_hash, Hash.from_xml(blog_xml)
   end
 
@@ -1557,7 +1557,7 @@ class HashToXmlTest < ActiveSupport::TestCase
 
     expected_product_hash = {
       weight: 0.5,
-      image: {"type" => "ProductImage", "filename" => "image.gif" },
+      image: { "type" => "ProductImage", "filename" => "image.gif" },
     }.stringify_keys
 
     assert_equal expected_product_hash, Hash.from_xml(product_xml)["product"]
@@ -1580,17 +1580,17 @@ class HashToXmlTest < ActiveSupport::TestCase
   end
 
   def test_from_xml_array_one
-    expected = { "numbers" => { "type" => "Array", "value" => "1" }}
+    expected = { "numbers" => { "type" => "Array", "value" => "1" } }
     assert_equal expected, Hash.from_xml('<numbers type="Array"><value>1</value></numbers>')
   end
 
   def test_from_xml_array_many
-    expected = { "numbers" => { "type" => "Array", "value" => [ "1", "2" ] }}
+    expected = { "numbers" => { "type" => "Array", "value" => [ "1", "2" ] } }
     assert_equal expected, Hash.from_xml('<numbers type="Array"><value>1</value><value>2</value></numbers>')
   end
 
   def test_from_trusted_xml_allows_symbol_and_yaml_types
-    expected = { "product" => { "name" => :value }}
+    expected = { "product" => { "name" => :value } }
     assert_equal expected, Hash.from_trusted_xml('<product><name type="symbol">value</name></product>')
     assert_equal expected, Hash.from_trusted_xml('<product><name type="yaml">:value</name></product>')
   end
@@ -1734,10 +1734,10 @@ class HashToXmlTest < ActiveSupport::TestCase
   end
 
   def test_to_xml_dups_options
-    options = {skip_instruct: true}
+    options = { skip_instruct: true }
     {}.to_xml(options)
     # :builder, etc, shouldn't be added to options
-    assert_equal({skip_instruct: true}, options)
+    assert_equal({ skip_instruct: true }, options)
   end
 
   def test_expansion_count_is_limited
diff --git a/activesupport/test/core_ext/marshal_test.rb b/activesupport/test/core_ext/marshal_test.rb
index 275002b8a1..a899f98705 100644
--- a/activesupport/test/core_ext/marshal_test.rb
+++ b/activesupport/test/core_ext/marshal_test.rb
@@ -12,7 +12,7 @@ class MarshalTest < ActiveSupport::TestCase
   end
 
   test "that Marshal#load still works" do
-    sanity_data = ["test", [1, 2, 3], {a: [1, 2, 3]}, ActiveSupport::TestCase]
+    sanity_data = ["test", [1, 2, 3], { a: [1, 2, 3] }, ActiveSupport::TestCase]
     sanity_data.each do |obj|
       dumped = Marshal.dump(obj)
       assert_equal Marshal.method(:load).super_method.call(dumped), Marshal.load(dumped)
diff --git a/activesupport/test/core_ext/module/attribute_accessor_test.rb b/activesupport/test/core_ext/module/attribute_accessor_test.rb
index fea6806b9b..464a000d59 100644
--- a/activesupport/test/core_ext/module/attribute_accessor_test.rb
+++ b/activesupport/test/core_ext/module/attribute_accessor_test.rb
@@ -93,7 +93,7 @@ class ModuleAttributeAccessorTest < ActiveSupport::TestCase
 
   def test_should_not_invoke_default_value_block_multiple_times
     count = 0
-    @module.cattr_accessor(:defcount){ count += 1 }
+    @module.cattr_accessor(:defcount) { count += 1 }
     assert_equal 1, count
   end
 end
diff --git a/activesupport/test/core_ext/module/concerning_test.rb b/activesupport/test/core_ext/module/concerning_test.rb
index 45178e477d..038cbf1f2f 100644
--- a/activesupport/test/core_ext/module/concerning_test.rb
+++ b/activesupport/test/core_ext/module/concerning_test.rb
@@ -3,7 +3,7 @@ require "active_support/core_ext/module/concerning"
 
 class ModuleConcerningTest < ActiveSupport::TestCase
   def test_concerning_declares_a_concern_and_includes_it_immediately
-    klass = Class.new { concerning(:Foo) { } }
+    klass = Class.new { concerning(:Foo) {} }
     assert klass.ancestors.include?(klass::Foo), klass.ancestors.inspect
   end
 end
diff --git a/activesupport/test/core_ext/module/qualified_const_test.rb b/activesupport/test/core_ext/module/qualified_const_test.rb
index dcfac4ced1..418bc80ab9 100644
--- a/activesupport/test/core_ext/module/qualified_const_test.rb
+++ b/activesupport/test/core_ext/module/qualified_const_test.rb
@@ -68,7 +68,7 @@ class QualifiedConstTest < ActiveSupport::TestCase
       assert_equal 1, QualifiedConstTestMod.qualified_const_get("N::X")
       assert_equal 2, QualifiedConstTestMod.qualified_const_get("M::C::X")
 
-      assert_raise(NameError) { QualifiedConstTestMod.qualified_const_get("M::C::Y")}
+      assert_raise(NameError) { QualifiedConstTestMod.qualified_const_get("M::C::Y") }
     end
   end
 
@@ -98,14 +98,14 @@ class QualifiedConstTest < ActiveSupport::TestCase
 
   test "reject absolute paths" do
     assert_deprecated do
-      assert_raise_with_message(NameError, "wrong constant name ::X") { Object.qualified_const_defined?("::X")}
-      assert_raise_with_message(NameError, "wrong constant name ::X") { Object.qualified_const_defined?("::X::Y")}
+      assert_raise_with_message(NameError, "wrong constant name ::X") { Object.qualified_const_defined?("::X") }
+      assert_raise_with_message(NameError, "wrong constant name ::X") { Object.qualified_const_defined?("::X::Y") }
 
-      assert_raise_with_message(NameError, "wrong constant name ::X") { Object.qualified_const_get("::X")}
-      assert_raise_with_message(NameError, "wrong constant name ::X") { Object.qualified_const_get("::X::Y")}
+      assert_raise_with_message(NameError, "wrong constant name ::X") { Object.qualified_const_get("::X") }
+      assert_raise_with_message(NameError, "wrong constant name ::X") { Object.qualified_const_get("::X::Y") }
 
-      assert_raise_with_message(NameError, "wrong constant name ::X") { Object.qualified_const_set("::X", nil)}
-      assert_raise_with_message(NameError, "wrong constant name ::X") { Object.qualified_const_set("::X::Y", nil)}
+      assert_raise_with_message(NameError, "wrong constant name ::X") { Object.qualified_const_set("::X", nil) }
+      assert_raise_with_message(NameError, "wrong constant name ::X") { Object.qualified_const_set("::X::Y", nil) }
     end
   end
 
diff --git a/activesupport/test/core_ext/module_test.rb b/activesupport/test/core_ext/module_test.rb
index 104082b777..36073b28b7 100644
--- a/activesupport/test/core_ext/module_test.rb
+++ b/activesupport/test/core_ext/module_test.rb
@@ -117,7 +117,7 @@ class ParameterSet
   delegate :[], :[]=, to: :@params
 
   def initialize
-    @params = {foo: "bar"}
+    @params = { foo: "bar" }
   end
 end
 
@@ -312,7 +312,7 @@ class ModuleTest < ActiveSupport::TestCase
   rescue NoMethodError => e
     file_and_line = "#{__FILE__}:#{Someone::FAILED_DELEGATE_LINE}"
     # We can't simply check the first line of the backtrace, because JRuby reports the call to __send__ in the backtrace.
-    assert e.backtrace.any?{|a| a.include?(file_and_line)},
+    assert e.backtrace.any? { |a| a.include?(file_and_line) },
            "[#{e.backtrace.inspect}] did not include [#{file_and_line}]"
   end
 
@@ -322,7 +322,7 @@ class ModuleTest < ActiveSupport::TestCase
   rescue NoMethodError => e
     file_and_line = "#{__FILE__}:#{Someone::FAILED_DELEGATE_LINE_2}"
     # We can't simply check the first line of the backtrace, because JRuby reports the call to __send__ in the backtrace.
-    assert e.backtrace.any?{|a| a.include?(file_and_line)},
+    assert e.backtrace.any? { |a| a.include?(file_and_line) },
            "[#{e.backtrace.inspect}] did not include [#{file_and_line}]"
   end
 
diff --git a/activesupport/test/core_ext/numeric_ext_test.rb b/activesupport/test/core_ext/numeric_ext_test.rb
index b99217a1b3..5e824747ed 100644
--- a/activesupport/test/core_ext/numeric_ext_test.rb
+++ b/activesupport/test/core_ext/numeric_ext_test.rb
@@ -348,13 +348,13 @@ class NumericExtFormattingTest < ActiveSupport::TestCase
 
   def test_number_to_human_with_custom_units
     #Only integers
-    volume = {unit: "ml", thousand: "lt", million: "m3"}
+    volume = { unit: "ml", thousand: "lt", million: "m3" }
     assert_equal "123 lt", 123456.to_s(:human, units: volume)
     assert_equal "12 ml", 12.to_s(:human, units: volume)
     assert_equal "1.23 m3", 1234567.to_s(:human, units: volume)
 
     #Including fractionals
-    distance = {mili: "mm", centi: "cm", deci: "dm", unit: "m", ten: "dam", hundred: "hm", thousand: "km"}
+    distance = { mili: "mm", centi: "cm", deci: "dm", unit: "m", ten: "dam", hundred: "hm", thousand: "km" }
     assert_equal "1.23 mm", 0.00123.to_s(:human, units: distance)
     assert_equal "1.23 cm", 0.0123.to_s(:human, units: distance)
     assert_equal "1.23 dm", 0.123.to_s(:human, units: distance)
@@ -367,20 +367,20 @@ class NumericExtFormattingTest < ActiveSupport::TestCase
     assert_equal "12.3 km", 12300.to_s(:human, units: distance)
 
     #The quantifiers don't need to be a continuous sequence
-    gangster = {hundred: "hundred bucks", million: "thousand quids"}
+    gangster = { hundred: "hundred bucks", million: "thousand quids" }
     assert_equal "1 hundred bucks", 100.to_s(:human, units: gangster)
     assert_equal "25 hundred bucks", 2500.to_s(:human, units: gangster)
     assert_equal "25 thousand quids", 25000000.to_s(:human, units: gangster)
     assert_equal "12300 thousand quids", 12345000000.to_s(:human, units: gangster)
 
     #Spaces are stripped from the resulting string
-    assert_equal "4", 4.to_s(:human, units: {unit: "", ten: "tens "})
-    assert_equal "4.5  tens", 45.to_s(:human, units: {unit: "", ten: " tens   "})
+    assert_equal "4", 4.to_s(:human, units: { unit: "", ten: "tens " })
+    assert_equal "4.5  tens", 45.to_s(:human, units: { unit: "", ten: " tens   " })
   end
 
   def test_number_to_human_with_custom_format
     assert_equal "123 times Thousand", 123456.to_s(:human, format: "%n times %u")
-    volume = {unit: "ml", thousand: "lt", million: "m3"}
+    volume = { unit: "ml", thousand: "lt", million: "m3" }
     assert_equal "123.lt", 123456.to_s(:human, units: volume, format: "%n.%u")
   end
 
diff --git a/activesupport/test/core_ext/object/instance_variables_test.rb b/activesupport/test/core_ext/object/instance_variables_test.rb
index 510352595a..5bdb2fbc35 100644
--- a/activesupport/test/core_ext/object/instance_variables_test.rb
+++ b/activesupport/test/core_ext/object/instance_variables_test.rb
@@ -13,7 +13,7 @@ class ObjectInstanceVariableTest < ActiveSupport::TestCase
   end
 
   def test_instance_values
-    assert_equal({"bar" => "bar", "baz" => "baz"}, @source.instance_values)
+    assert_equal({ "bar" => "bar", "baz" => "baz" }, @source.instance_values)
   end
 
   def test_instance_exec_passes_arguments_to_block
diff --git a/activesupport/test/core_ext/object/to_query_test.rb b/activesupport/test/core_ext/object/to_query_test.rb
index 2eff475274..298c8bf373 100644
--- a/activesupport/test/core_ext/object/to_query_test.rb
+++ b/activesupport/test/core_ext/object/to_query_test.rb
@@ -33,17 +33,17 @@ class ToQueryTest < ActiveSupport::TestCase
 
   def test_multiple_nested
     assert_query_equal "account%5Bperson%5D%5Bid%5D=20&person%5Bid%5D=10",
-      Hash[:account, {person: {id: 20}}, :person, {id: 10}]
+      Hash[:account, { person: { id: 20 } }, :person, { id: 10 }]
   end
 
   def test_array_values
     assert_query_equal "person%5Bid%5D%5B%5D=10&person%5Bid%5D%5B%5D=20",
-      person: {id: [10, 20]}
+      person: { id: [10, 20] }
   end
 
   def test_array_values_are_not_sorted
     assert_query_equal "person%5Bid%5D%5B%5D=20&person%5Bid%5D%5B%5D=10",
-      person: {id: [20, 10]}
+      person: { id: [20, 10] }
   end
 
   def test_empty_array
@@ -56,7 +56,7 @@ class ToQueryTest < ActiveSupport::TestCase
     assert_query_equal "a=1&b%5Bc%5D=3",
       a: 1, b: { c: 3, d: {} }
     assert_query_equal "",
-      a: {b: {c: {}}}
+      a: { b: { c: {} } }
     assert_query_equal "b%5Bc%5D=false&b%5Be%5D=&b%5Bf%5D=&p=12",
       p: 12, b: { c: false, e: nil, f: "" }
     assert_query_equal "b%5Bc%5D=3&b%5Bf%5D=",
diff --git a/activesupport/test/core_ext/time_with_zone_test.rb b/activesupport/test/core_ext/time_with_zone_test.rb
index 773d2c0fb7..6ab1368e53 100644
--- a/activesupport/test/core_ext/time_with_zone_test.rb
+++ b/activesupport/test/core_ext/time_with_zone_test.rb
@@ -1014,7 +1014,7 @@ class TimeWithZoneMethodsForTimeAndDateTimeTest < ActiveSupport::TestCase
   def test_use_zone_raises_on_invalid_timezone
     Time.zone = "Alaska"
     assert_raise ArgumentError do
-      Time.use_zone("No such timezone exists") { }
+      Time.use_zone("No such timezone exists") {}
     end
     assert_equal ActiveSupport::TimeZone["Alaska"], Time.zone
   end
@@ -1072,9 +1072,9 @@ class TimeWithZoneMethodsForTimeAndDateTimeTest < ActiveSupport::TestCase
   end
 
   def test_time_zone_setter_with_invalid_zone
-    assert_raise(ArgumentError){ Time.zone = "No such timezone exists" }
-    assert_raise(ArgumentError){ Time.zone = -15.hours }
-    assert_raise(ArgumentError){ Time.zone = Object.new }
+    assert_raise(ArgumentError) { Time.zone = "No such timezone exists" }
+    assert_raise(ArgumentError) { Time.zone = -15.hours }
+    assert_raise(ArgumentError) { Time.zone = Object.new }
   end
 
   def test_find_zone_without_bang_returns_nil_if_time_zone_can_not_be_found