Add three new rubocop rules

Style/SpaceBeforeBlockBraces
Style/SpaceInsideBlockBraces
Style/SpaceInsideHashLiteralBraces

Fix all violations in the repository.

11 files changed, 60 insertions, 60 deletions

diff --git a/activemodel/test/cases/attribute_methods_test.rb b/activemodel/test/cases/attribute_methods_test.rb
index f59180cceb..4767accb7c 100644
--- a/activemodel/test/cases/attribute_methods_test.rb
+++ b/activemodel/test/cases/attribute_methods_test.rb
@@ -48,7 +48,7 @@ class ModelWithAttributesWithSpaces
   include ActiveModel::AttributeMethods
 
   def attributes
-    { 'foo bar': "value of foo bar"}
+    { 'foo bar': "value of foo bar" }
   end
 
 private
diff --git a/activemodel/test/cases/serialization_test.rb b/activemodel/test/cases/serialization_test.rb
index cead0bee22..5ee53285a3 100644
--- a/activemodel/test/cases/serialization_test.rb
+++ b/activemodel/test/cases/serialization_test.rb
@@ -51,32 +51,32 @@ class SerializationTest < ActiveModel::TestCase
   end
 
   def test_method_serializable_hash_should_work
-    expected = {"name"=>"David", "gender"=>"male", "email"=>"david@example.com"}
+    expected = { "name"=>"David", "gender"=>"male", "email"=>"david@example.com" }
     assert_equal expected, @user.serializable_hash
   end
 
   def test_method_serializable_hash_should_work_with_only_option
-    expected = {"name"=>"David"}
+    expected = { "name"=>"David" }
     assert_equal expected, @user.serializable_hash(only: [:name])
   end
 
   def test_method_serializable_hash_should_work_with_except_option
-    expected = {"gender"=>"male", "email"=>"david@example.com"}
+    expected = { "gender"=>"male", "email"=>"david@example.com" }
     assert_equal expected, @user.serializable_hash(except: [:name])
   end
 
   def test_method_serializable_hash_should_work_with_methods_option
-    expected = {"name"=>"David", "gender"=>"male", "foo"=>"i_am_foo", "bar"=>"i_am_bar", "email"=>"david@example.com"}
+    expected = { "name"=>"David", "gender"=>"male", "foo"=>"i_am_foo", "bar"=>"i_am_bar", "email"=>"david@example.com" }
     assert_equal expected, @user.serializable_hash(methods: [:foo, :bar])
   end
 
   def test_method_serializable_hash_should_work_with_only_and_methods
-    expected = {"foo"=>"i_am_foo", "bar"=>"i_am_bar"}
+    expected = { "foo"=>"i_am_foo", "bar"=>"i_am_bar" }
     assert_equal expected, @user.serializable_hash(only: [], methods: [:foo, :bar])
   end
 
   def test_method_serializable_hash_should_work_with_except_and_methods
-    expected = {"gender"=>"male", "foo"=>"i_am_foo", "bar"=>"i_am_bar"}
+    expected = { "gender"=>"male", "foo"=>"i_am_foo", "bar"=>"i_am_bar" }
     assert_equal expected, @user.serializable_hash(except: [:name, :email], methods: [:foo, :bar])
   end
 
@@ -94,21 +94,21 @@ class SerializationTest < ActiveModel::TestCase
   end
 
   def test_include_option_with_singular_association
-    expected = {"name"=>"David", "gender"=>"male", "email"=>"david@example.com",
-                "address"=>{"street"=>"123 Lane", "city"=>"Springfield", "state"=>"CA", "zip"=>11111}}
+    expected = { "name"=>"David", "gender"=>"male", "email"=>"david@example.com",
+                "address"=>{ "street"=>"123 Lane", "city"=>"Springfield", "state"=>"CA", "zip"=>11111 } }
     assert_equal expected, @user.serializable_hash(include: :address)
   end
 
   def test_include_option_with_plural_association
-    expected = {"email"=>"david@example.com", "gender"=>"male", "name"=>"David",
-                "friends"=>[{"name"=>"Joe", "email"=>"joe@example.com", "gender"=>"male"},
-                           {"name"=>"Sue", "email"=>"sue@example.com", "gender"=>"female"}]}
+    expected = { "email"=>"david@example.com", "gender"=>"male", "name"=>"David",
+                "friends"=>[{ "name"=>"Joe", "email"=>"joe@example.com", "gender"=>"male" },
+                           { "name"=>"Sue", "email"=>"sue@example.com", "gender"=>"female" }] }
     assert_equal expected, @user.serializable_hash(include: :friends)
   end
 
   def test_include_option_with_empty_association
     @user.friends = []
-    expected = {"email"=>"david@example.com", "gender"=>"male", "name"=>"David", "friends"=>[]}
+    expected = { "email"=>"david@example.com", "gender"=>"male", "name"=>"David", "friends"=>[] }
     assert_equal expected, @user.serializable_hash(include: :friends)
   end
 
@@ -124,52 +124,52 @@ class SerializationTest < ActiveModel::TestCase
 
   def test_include_option_with_ary
     @user.friends = FriendList.new(@user.friends)
-    expected = {"email"=>"david@example.com", "gender"=>"male", "name"=>"David",
-                "friends"=>[{"name"=>"Joe", "email"=>"joe@example.com", "gender"=>"male"},
-                           {"name"=>"Sue", "email"=>"sue@example.com", "gender"=>"female"}]}
+    expected = { "email"=>"david@example.com", "gender"=>"male", "name"=>"David",
+                "friends"=>[{ "name"=>"Joe", "email"=>"joe@example.com", "gender"=>"male" },
+                           { "name"=>"Sue", "email"=>"sue@example.com", "gender"=>"female" }] }
     assert_equal expected, @user.serializable_hash(include: :friends)
   end
 
   def test_multiple_includes
-    expected = {"email"=>"david@example.com", "gender"=>"male", "name"=>"David",
-                "address"=>{"street"=>"123 Lane", "city"=>"Springfield", "state"=>"CA", "zip"=>11111},
-                "friends"=>[{"name"=>"Joe", "email"=>"joe@example.com", "gender"=>"male"},
-                           {"name"=>"Sue", "email"=>"sue@example.com", "gender"=>"female"}]}
+    expected = { "email"=>"david@example.com", "gender"=>"male", "name"=>"David",
+                "address"=>{ "street"=>"123 Lane", "city"=>"Springfield", "state"=>"CA", "zip"=>11111 },
+                "friends"=>[{ "name"=>"Joe", "email"=>"joe@example.com", "gender"=>"male" },
+                           { "name"=>"Sue", "email"=>"sue@example.com", "gender"=>"female" }] }
     assert_equal expected, @user.serializable_hash(include: [:address, :friends])
   end
 
   def test_include_with_options
-    expected = {"email"=>"david@example.com", "gender"=>"male", "name"=>"David",
-                "address"=>{"street"=>"123 Lane"}}
+    expected = { "email"=>"david@example.com", "gender"=>"male", "name"=>"David",
+                "address"=>{ "street"=>"123 Lane" } }
     assert_equal expected, @user.serializable_hash(include: { address: { only: "street" } })
   end
 
   def test_nested_include
     @user.friends.first.friends = [@user]
-    expected = {"email"=>"david@example.com", "gender"=>"male", "name"=>"David",
-                "friends"=>[{"name"=>"Joe", "email"=>"joe@example.com", "gender"=>"male",
-                            "friends"=> [{"email"=>"david@example.com", "gender"=>"male", "name"=>"David"}]},
-                            {"name"=>"Sue", "email"=>"sue@example.com", "gender"=>"female", "friends"=> []}]}
+    expected = { "email"=>"david@example.com", "gender"=>"male", "name"=>"David",
+                "friends"=>[{ "name"=>"Joe", "email"=>"joe@example.com", "gender"=>"male",
+                            "friends"=> [{ "email"=>"david@example.com", "gender"=>"male", "name"=>"David" }] },
+                            { "name"=>"Sue", "email"=>"sue@example.com", "gender"=>"female", "friends"=> [] }] }
     assert_equal expected, @user.serializable_hash(include: { friends: { include: :friends } })
   end
 
   def test_only_include
-    expected = {"name"=>"David", "friends" => [{"name" => "Joe"}, {"name" => "Sue"}]}
+    expected = { "name"=>"David", "friends" => [{ "name" => "Joe" }, { "name" => "Sue" }] }
     assert_equal expected, @user.serializable_hash(only: :name, include: { friends: { only: :name } })
   end
 
   def test_except_include
-    expected = {"name"=>"David", "email"=>"david@example.com",
-                "friends"=> [{"name" => "Joe", "email" => "joe@example.com"},
-                             {"name" => "Sue", "email" => "sue@example.com"}]}
+    expected = { "name"=>"David", "email"=>"david@example.com",
+                "friends"=> [{ "name" => "Joe", "email" => "joe@example.com" },
+                             { "name" => "Sue", "email" => "sue@example.com" }] }
     assert_equal expected, @user.serializable_hash(except: :gender, include: { friends: { except: :gender } })
   end
 
   def test_multiple_includes_with_options
-    expected = {"email"=>"david@example.com", "gender"=>"male", "name"=>"David",
-                "address"=>{"street"=>"123 Lane"},
-                "friends"=>[{"name"=>"Joe", "email"=>"joe@example.com", "gender"=>"male"},
-                           {"name"=>"Sue", "email"=>"sue@example.com", "gender"=>"female"}]}
-    assert_equal expected, @user.serializable_hash(include: [{ address: {only: "street" } }, :friends])
+    expected = { "email"=>"david@example.com", "gender"=>"male", "name"=>"David",
+                "address"=>{ "street"=>"123 Lane" },
+                "friends"=>[{ "name"=>"Joe", "email"=>"joe@example.com", "gender"=>"male" },
+                           { "name"=>"Sue", "email"=>"sue@example.com", "gender"=>"female" }] }
+    assert_equal expected, @user.serializable_hash(include: [{ address: { only: "street" } }, :friends])
   end
 end
diff --git a/activemodel/test/cases/translation_test.rb b/activemodel/test/cases/translation_test.rb
index 1717e0c7ce..9972f9daea 100644
--- a/activemodel/test/cases/translation_test.rb
+++ b/activemodel/test/cases/translation_test.rb
@@ -38,23 +38,23 @@ class ActiveModelI18nTests < ActiveModel::TestCase
   end
 
   def test_translated_model_attributes_with_symbols
-    I18n.backend.store_translations "en", activemodel: { attributes: { person: { name: "person name attribute"} } }
+    I18n.backend.store_translations "en", activemodel: { attributes: { person: { name: "person name attribute" } } }
     assert_equal "person name attribute", Person.human_attribute_name(:name)
   end
 
   def test_translated_model_attributes_with_ancestor
-    I18n.backend.store_translations "en", activemodel: { attributes: { child: { name: "child name attribute"} } }
+    I18n.backend.store_translations "en", activemodel: { attributes: { child: { name: "child name attribute" } } }
     assert_equal "child name attribute", Child.human_attribute_name("name")
   end
 
   def test_translated_model_attributes_with_ancestors_fallback
-    I18n.backend.store_translations "en", activemodel: { attributes: { person: { name: "person name attribute"} } }
+    I18n.backend.store_translations "en", activemodel: { attributes: { person: { name: "person name attribute" } } }
     assert_equal "person name attribute", Child.human_attribute_name("name")
   end
 
   def test_translated_model_attributes_with_attribute_matching_namespaced_model_name
     I18n.backend.store_translations "en", activemodel: { attributes: {
-      person: { gender: "person gender"},
+      person: { gender: "person gender" },
       "person/gender": { attribute: "person gender attribute" }
     } }
 
diff --git a/activemodel/test/cases/validations/conditional_validation_test.rb b/activemodel/test/cases/validations/conditional_validation_test.rb
index 8c2f656838..5e81083b63 100644
--- a/activemodel/test/cases/validations/conditional_validation_test.rb
+++ b/activemodel/test/cases/validations/conditional_validation_test.rb
@@ -97,7 +97,7 @@ class ConditionalValidationTest < ActiveModel::TestCase
   def test_if_validation_using_block_false
     # When the block returns false
     Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}",
-      if: Proc.new { |r| r.title != "uhohuhoh"})
+      if: Proc.new { |r| r.title != "uhohuhoh" })
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
     assert t.valid?
     assert_empty t.errors[:title]
@@ -106,7 +106,7 @@ class ConditionalValidationTest < ActiveModel::TestCase
   def test_unless_validation_using_block_false
     # When the block returns false
     Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}",
-      unless: Proc.new { |r| r.title != "uhohuhoh"} )
+      unless: Proc.new { |r| r.title != "uhohuhoh" } )
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
     assert t.invalid?
     assert t.errors[:title].any?
diff --git a/activemodel/test/cases/validations/confirmation_validation_test.rb b/activemodel/test/cases/validations/confirmation_validation_test.rb
index c13017d825..b88e1c4ca4 100644
--- a/activemodel/test/cases/validations/confirmation_validation_test.rb
+++ b/activemodel/test/cases/validations/confirmation_validation_test.rb
@@ -57,7 +57,7 @@ class ConfirmationValidationTest < ActiveModel::TestCase
       I18n.backend = I18n::Backend::Simple.new
       I18n.backend.store_translations("en",
         errors: { messages: { confirmation: "doesn't match %{attribute}" } },
-        activemodel: { attributes: { topic: { title: "Test Title"} } })
+        activemodel: { attributes: { topic: { title: "Test Title" } } })
 
       Topic.validates_confirmation_of(:title)
 
diff --git a/activemodel/test/cases/validations/i18n_validation_test.rb b/activemodel/test/cases/validations/i18n_validation_test.rb
index 9c0071fad7..85212a80fc 100644
--- a/activemodel/test/cases/validations/i18n_validation_test.rb
+++ b/activemodel/test/cases/validations/i18n_validation_test.rb
@@ -49,8 +49,8 @@ class I18nValidationTest < ActiveModel::TestCase
   # [ 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 if condition",                { if:                          lambda { true } },  {}],
+    [ "given unless condition",            { unless:                      lambda { false } }, {}],
     [ "given option that is not reserved", { format: "jpg" },             { format: "jpg" }]
   ]
 
@@ -225,7 +225,7 @@ class I18nValidationTest < ActiveModel::TestCase
 
     test "#{validation} finds custom model key translation when #{error_type}" do
       I18n.backend.store_translations "en", activemodel: { errors: { models: { person: { attributes: { attribute => { error_type => "custom message" } } } } } }
-      I18n.backend.store_translations "en", errors: { messages: { error_type => "global message"}}
+      I18n.backend.store_translations "en", errors: { messages: { error_type => "global message" } }
 
       yield(@person, {})
       @person.valid?
@@ -234,7 +234,7 @@ class I18nValidationTest < ActiveModel::TestCase
 
     test "#{validation} finds custom model key translation with interpolation when #{error_type}" do
       I18n.backend.store_translations "en", activemodel: { errors: { models: { person: { attributes: { attribute => { error_type => "custom message with %{extra}" } } } } } }
-      I18n.backend.store_translations "en", errors: { messages: {error_type => "global message"} }
+      I18n.backend.store_translations "en", errors: { messages: { error_type => "global message" } }
 
       yield(@person, { extra: "extra information" })
       @person.valid?
@@ -242,7 +242,7 @@ class I18nValidationTest < ActiveModel::TestCase
     end
 
     test "#{validation} finds global default key translation when #{error_type}" do
-      I18n.backend.store_translations "en", errors: { messages: {error_type => "global message"} }
+      I18n.backend.store_translations "en", errors: { messages: { error_type => "global message" } }
 
       yield(@person, {})
       @person.valid?
diff --git a/activemodel/test/cases/validations/inclusion_validation_test.rb b/activemodel/test/cases/validations/inclusion_validation_test.rb
index 732a8d362a..5aa43ea4a9 100644
--- a/activemodel/test/cases/validations/inclusion_validation_test.rb
+++ b/activemodel/test/cases/validations/inclusion_validation_test.rb
@@ -121,7 +121,7 @@ class InclusionValidationTest < ActiveModel::TestCase
   end
 
   def test_validates_inclusion_of_with_lambda
-    Topic.validates_inclusion_of :title, in: lambda{ |topic| topic.author_name == "sikachu" ? %w( monkey elephant ) : %w( abe wasabi ) }
+    Topic.validates_inclusion_of :title, in: lambda { |topic| topic.author_name == "sikachu" ? %w( monkey elephant ) : %w( abe wasabi ) }
 
     t = Topic.new
     t.title = "wasabi"
diff --git a/activemodel/test/cases/validations/length_validation_test.rb b/activemodel/test/cases/validations/length_validation_test.rb
index 63326aca69..ade185c179 100644
--- a/activemodel/test/cases/validations/length_validation_test.rb
+++ b/activemodel/test/cases/validations/length_validation_test.rb
@@ -324,7 +324,7 @@ class LengthValidationTest < ActiveModel::TestCase
         :content,
         minimum: 5,
         too_short: "Your essay must be at least %{count} words.",
-        tokenizer: lambda {|str| str.scan(/\w+/) },
+        tokenizer: lambda { |str| str.scan(/\w+/) },
       )
     end
     t = Topic.new(content: "this content should be long enough")
diff --git a/activemodel/test/cases/validations/numericality_validation_test.rb b/activemodel/test/cases/validations/numericality_validation_test.rb
index 71ef449503..84ed430d2a 100644
--- a/activemodel/test/cases/validations/numericality_validation_test.rb
+++ b/activemodel/test/cases/validations/numericality_validation_test.rb
@@ -254,11 +254,11 @@ class NumericalityValidationTest < ActiveModel::TestCase
   end
 
   def test_validates_numericality_with_invalid_args
-    assert_raise(ArgumentError){ Topic.validates_numericality_of :approved, greater_than_or_equal_to: "foo" }
-    assert_raise(ArgumentError){ Topic.validates_numericality_of :approved, less_than_or_equal_to: "foo" }
-    assert_raise(ArgumentError){ Topic.validates_numericality_of :approved, greater_than: "foo" }
-    assert_raise(ArgumentError){ Topic.validates_numericality_of :approved, less_than: "foo" }
-    assert_raise(ArgumentError){ Topic.validates_numericality_of :approved, equal_to: "foo" }
+    assert_raise(ArgumentError) { Topic.validates_numericality_of :approved, greater_than_or_equal_to: "foo" }
+    assert_raise(ArgumentError) { Topic.validates_numericality_of :approved, less_than_or_equal_to: "foo" }
+    assert_raise(ArgumentError) { Topic.validates_numericality_of :approved, greater_than: "foo" }
+    assert_raise(ArgumentError) { Topic.validates_numericality_of :approved, less_than: "foo" }
+    assert_raise(ArgumentError) { Topic.validates_numericality_of :approved, equal_to: "foo" }
   end
 
   private
diff --git a/activemodel/test/cases/validations/with_validation_test.rb b/activemodel/test/cases/validations/with_validation_test.rb
index 6b2c998ba4..7af51c5cc5 100644
--- a/activemodel/test/cases/validations/with_validation_test.rb
+++ b/activemodel/test/cases/validations/with_validation_test.rb
@@ -97,7 +97,7 @@ class ValidatesWithTest < ActiveModel::TestCase
   test "passes all configuration options to the validator class" do
     topic = Topic.new
     validator = Minitest::Mock.new
-    validator.expect(:new, validator, [{foo: :bar, if: "1 == 1", class: Topic}])
+    validator.expect(:new, validator, [{ foo: :bar, if: "1 == 1", class: Topic }])
     validator.expect(:validate, nil, [topic])
     validator.expect(:is_a?, false, [Symbol])
     validator.expect(:is_a?, false, [String])
diff --git a/activemodel/test/cases/validations_test.rb b/activemodel/test/cases/validations_test.rb
index 51607ba955..7aaafc428e 100644
--- a/activemodel/test/cases/validations_test.rb
+++ b/activemodel/test/cases/validations_test.rb
@@ -51,7 +51,7 @@ class ValidationsTest < ActiveModel::TestCase
     r = Reply.new
     r.valid?
 
-    errors = r.errors.collect {|attr, messages| [attr.to_s, messages]}
+    errors = r.errors.collect { |attr, messages| [attr.to_s, messages] }
 
     assert errors.include?(["title", "is Empty"])
     assert errors.include?(["content", "is Empty"])
@@ -198,9 +198,9 @@ class ValidationsTest < ActiveModel::TestCase
     end
 
     assert_nothing_raised do
-      klass.validate :validator_a, if: ->{ true }
+      klass.validate :validator_a, if: -> { true }
       klass.validate :validator_b, prepend: true
-      klass.validate :validator_c, unless: ->{ true }
+      klass.validate :validator_c, unless: -> { true }
     end
 
     t = klass.new
@@ -233,7 +233,7 @@ class ValidationsTest < ActiveModel::TestCase
     assert t.invalid?
     assert_equal "can't be blank", t.errors["title"].first
     Topic.validates_presence_of :title, :author_name
-    Topic.validate {errors.add("author_email_address", "will never be valid")}
+    Topic.validate { errors.add("author_email_address", "will never be valid") }
     Topic.validates_length_of :title, :content, minimum: 2
 
     t = Topic.new title: ""
@@ -251,7 +251,7 @@ class ValidationsTest < ActiveModel::TestCase
   end
 
   def test_validation_with_if_and_on
-    Topic.validates_presence_of :title, if: Proc.new{|x| x.author_name = "bad"; true }, on: :update
+    Topic.validates_presence_of :title, if: Proc.new { |x| x.author_name = "bad"; true }, on: :update
 
     t = Topic.new(title: "")