Add more rubocop rules about whitespaces

13 files changed, 55 insertions, 55 deletions

diff --git a/activerecord/test/cases/adapters/mysql2/connection_test.rb b/activerecord/test/cases/adapters/mysql2/connection_test.rb
index ff012efc5f..9c109d8a24 100644
--- a/activerecord/test/cases/adapters/mysql2/connection_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/connection_test.rb
@@ -122,7 +122,7 @@ class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
   def test_passing_arbitary_flags_to_adapter
     run_without_connection do |orig_connection|
       ActiveRecord::Base.establish_connection(orig_connection.merge(flags: Mysql2::Client::COMPRESS))
-      assert_equal (Mysql2::Client::COMPRESS |  Mysql2::Client::FOUND_ROWS), ActiveRecord::Base.connection.raw_connection.query_options[:flags]
+      assert_equal (Mysql2::Client::COMPRESS | Mysql2::Client::FOUND_ROWS), ActiveRecord::Base.connection.raw_connection.query_options[:flags]
     end
   end
 
diff --git a/activerecord/test/cases/adapters/mysql2/json_test.rb b/activerecord/test/cases/adapters/mysql2/json_test.rb
index 630cdb36a4..5d4db1be91 100644
--- a/activerecord/test/cases/adapters/mysql2/json_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/json_test.rb
@@ -67,8 +67,8 @@ if ActiveRecord::Base.connection.supports_json?
       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
@@ -87,7 +87,7 @@ if ActiveRecord::Base.connection.supports_json?
     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
@@ -104,17 +104,17 @@ if ActiveRecord::Base.connection.supports_json?
 
     def test_select_nil_json_after_create
       json = JsonDataType.create(payload: nil)
-      x = JsonDataType.where(payload:nil).first
+      x = JsonDataType.where(payload: nil).first
       assert_equal(json, x)
     end
 
     def test_select_nil_json_after_update
       json = JsonDataType.create(payload: "foo")
-      x = JsonDataType.where(payload:nil).first
+      x = JsonDataType.where(payload: nil).first
       assert_equal(nil, x)
 
       json.update_attributes payload: nil
-      x = JsonDataType.where(payload:nil).first
+      x = JsonDataType.where(payload: nil).first
       assert_equal(json.reload, x)
     end
 
diff --git a/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb b/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb
index 776549eb7a..b400f4d2f9 100644
--- a/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb
@@ -30,11 +30,11 @@ class Mysql2ReservedWordTest < ActiveRecord::Mysql2TestCase
     # we call execute directly here (and do similar below) because ActiveRecord::Base#create_table()
     # will fail with these table names if these test cases fail
 
-    create_tables_directly "group"=>"id int auto_increment primary key, `order` varchar(255), select_id int",
-      "select"=>"id int auto_increment primary key",
-      "values"=>"id int auto_increment primary key, group_id int",
-      "distinct"=>"id int auto_increment primary key",
-      "distinct_select"=>"distinct_id int, select_id int"
+    create_tables_directly "group" => "id int auto_increment primary key, `order` varchar(255), select_id int",
+      "select" => "id int auto_increment primary key",
+      "values" => "id int auto_increment primary key, group_id int",
+      "distinct" => "id int auto_increment primary key",
+      "distinct_select" => "distinct_id int, select_id int"
   end
 
   teardown do
diff --git a/activerecord/test/cases/adapters/mysql2/schema_test.rb b/activerecord/test/cases/adapters/mysql2/schema_test.rb
index aea930cfe6..1fad5585de 100644
--- a/activerecord/test/cases/adapters/mysql2/schema_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/schema_test.rb
@@ -76,7 +76,7 @@ module ActiveRecord
         table = "key_tests"
 
         indexes = @connection.indexes(table).sort_by(&:name)
-        assert_equal 3,indexes.size
+        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]
diff --git a/activerecord/test/cases/adapters/postgresql/array_test.rb b/activerecord/test/cases/adapters/postgresql/array_test.rb
index 97960b6c51..d741ca4389 100644
--- a/activerecord/test/cases/adapters/postgresql/array_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/array_test.rb
@@ -117,15 +117,15 @@ class PostgresqlArrayTest < ActiveRecord::PostgreSQLTestCase
   def test_select_with_strings
     @connection.execute "insert into pg_arrays (tags) VALUES ('{1,2,3}')"
     x = PgArray.first
-    assert_equal(["1","2","3"], x.tags)
+    assert_equal(["1", "2", "3"], x.tags)
   end
 
   def test_rewrite_with_strings
     @connection.execute "insert into pg_arrays (tags) VALUES ('{1,2,3}')"
     x = PgArray.first
-    x.tags = ["1","2","3","4"]
+    x.tags = ["1", "2", "3", "4"]
     x.save!
-    assert_equal ["1","2","3","4"], x.reload.tags
+    assert_equal ["1", "2", "3", "4"], x.reload.tags
   end
 
   def test_select_with_integers
@@ -163,28 +163,28 @@ class PostgresqlArrayTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_strings_with_quotes
-    assert_cycle(:tags, ["this has",'some "s that need to be escaped"'])
+    assert_cycle(:tags, ["this has", 'some "s that need to be escaped"'])
   end
 
   def test_strings_with_commas
-    assert_cycle(:tags, ["this,has","many,values"])
+    assert_cycle(:tags, ["this,has", "many,values"])
   end
 
   def test_strings_with_array_delimiters
-    assert_cycle(:tags, ["{","}"])
+    assert_cycle(:tags, ["{", "}"])
   end
 
   def test_strings_with_null_strings
-    assert_cycle(:tags, ["NULL","NULL"])
+    assert_cycle(:tags, ["NULL", "NULL"])
   end
 
   def test_contains_nils
-    assert_cycle(:tags, ["1",nil,nil])
+    assert_cycle(:tags, ["1", nil, nil])
   end
 
   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/hstore_test.rb b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
index 9236a67b11..c9982d3705 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
@@ -113,8 +113,8 @@ if ActiveRecord::Base.connection.supports_extensions?
     def test_type_cast_hstore
       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
@@ -166,23 +166,23 @@ if ActiveRecord::Base.connection.supports_extensions?
     end
 
     def test_gen1
-      assert_equal('" "=>""', @type.serialize(" "=>""))
+      assert_equal('" "=>""', @type.serialize(" " => ""))
     end
 
     def test_gen2
-      assert_equal('","=>""', @type.serialize(","=>""))
+      assert_equal('","=>""', @type.serialize("," => ""))
     end
 
     def test_gen3
-      assert_equal('"="=>""', @type.serialize("="=>""))
+      assert_equal('"="=>""', @type.serialize("=" => ""))
     end
 
     def test_gen4
-      assert_equal('">"=>""', @type.serialize(">"=>""))
+      assert_equal('">"=>""', @type.serialize(">" => ""))
     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
@@ -194,19 +194,19 @@ if ActiveRecord::Base.connection.supports_extensions?
     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
diff --git a/activerecord/test/cases/adapters/postgresql/json_test.rb b/activerecord/test/cases/adapters/postgresql/json_test.rb
index 273b2c1c7b..991dedfdf1 100644
--- a/activerecord/test/cases/adapters/postgresql/json_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/json_test.rb
@@ -41,8 +41,8 @@ module PostgresqlJSONSharedTestCases
     @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
@@ -84,8 +84,8 @@ module PostgresqlJSONSharedTestCases
     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
@@ -104,7 +104,7 @@ module PostgresqlJSONSharedTestCases
   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
@@ -115,17 +115,17 @@ module PostgresqlJSONSharedTestCases
 
   def test_select_nil_json_after_create
     json = JsonDataType.create(payload: nil)
-    x = JsonDataType.where(payload:nil).first
+    x = JsonDataType.where(payload: nil).first
     assert_equal(json, x)
   end
 
   def test_select_nil_json_after_update
     json = JsonDataType.create(payload: "foo")
-    x = JsonDataType.where(payload:nil).first
+    x = JsonDataType.where(payload: nil).first
     assert_equal(nil, x)
 
     json.update_attributes payload: nil
-    x = JsonDataType.where(payload:nil).first
+    x = JsonDataType.where(payload: nil).first
     assert_equal(json.reload, x)
   end
 
diff --git a/activerecord/test/cases/adapters/postgresql/quoting_test.rb b/activerecord/test/cases/adapters/postgresql/quoting_test.rb
index 865a3a5098..a9e81ab3d8 100644
--- a/activerecord/test/cases/adapters/postgresql/quoting_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/quoting_test.rb
@@ -18,12 +18,12 @@ module ActiveRecord
         end
 
         def test_quote_float_nan
-          nan = 0.0/0
+          nan = 0.0 / 0
           assert_equal "'NaN'", @conn.quote(nan)
         end
 
         def test_quote_float_infinity
-          infinity = 1.0/0
+          infinity = 1.0 / 0
           assert_equal "'Infinity'", @conn.quote(infinity)
         end
 
diff --git a/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb b/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
index 7193f23880..f6a07da85f 100644
--- a/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
@@ -110,7 +110,7 @@ class SchemaAuthorizationTest < ActiveRecord::PostgreSQLTestCase
 
   private
     def set_session_auth(auth = nil)
-      @connection.session_auth =  auth || "default"
+      @connection.session_auth = auth || "default"
     end
 
     def bind_param(value)
diff --git a/activerecord/test/cases/adapters/postgresql/schema_test.rb b/activerecord/test/cases/adapters/postgresql/schema_test.rb
index 51a2306c59..237e9ff6a5 100644
--- a/activerecord/test/cases/adapters/postgresql/schema_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/schema_test.rb
@@ -383,7 +383,7 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
       pk, seq = @connection.pk_and_sequence_for(given)
       assert_equal "id", pk, "primary key should be found when table referenced as #{given}"
       assert_equal pg_name.new(SCHEMA_NAME, "#{PK_TABLE_NAME}_id_seq"), seq, "sequence name should be found when table referenced as #{given}" if given == %("#{SCHEMA_NAME}"."#{PK_TABLE_NAME}")
-      assert_equal pg_name.new(SCHEMA_NAME, UNMATCHED_SEQUENCE_NAME), seq, "sequence name should be found when table referenced as #{given}" if given ==  %("#{SCHEMA_NAME}"."#{UNMATCHED_PK_TABLE_NAME}")
+      assert_equal pg_name.new(SCHEMA_NAME, UNMATCHED_SEQUENCE_NAME), seq, "sequence name should be found when table referenced as #{given}" if given == %("#{SCHEMA_NAME}"."#{UNMATCHED_PK_TABLE_NAME}")
     end
   end
 
@@ -393,7 +393,7 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
       SCHEMA_NAME                              => SCHEMA_NAME,
       %(#{SCHEMA2_NAME},#{SCHEMA_NAME},public) => SCHEMA2_NAME,
       %(public,#{SCHEMA2_NAME},#{SCHEMA_NAME}) => "public"
-    }.each do |given,expect|
+    }.each do |given, expect|
       with_schema_search_path(given) { assert_equal expect, @connection.current_schema }
     end
   end
@@ -418,7 +418,7 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
       SCHEMA_NAME  => true,
       SCHEMA2_NAME => true,
       "darkside"   => false
-    }.each do |given,expect|
+    }.each do |given, expect|
       assert_equal expect, @connection.schema_exists?(given)
     end
   end
diff --git a/activerecord/test/cases/adapters/postgresql/timestamp_test.rb b/activerecord/test/cases/adapters/postgresql/timestamp_test.rb
index e7c1d97d16..962450aada 100644
--- a/activerecord/test/cases/adapters/postgresql/timestamp_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/timestamp_test.rb
@@ -21,7 +21,7 @@ class PostgresqlTimestampTest < ActiveRecord::PostgreSQLTestCase
       @connection.reconnect!
 
       timestamp = PostgresqlTimestampWithZone.find(1)
-      assert_equal Time.utc(2010,1,1, 11,0,0), timestamp.time
+      assert_equal Time.utc(2010, 1, 1, 11, 0, 0), timestamp.time
       assert_instance_of Time, timestamp.time
     end
   ensure
@@ -35,7 +35,7 @@ class PostgresqlTimestampTest < ActiveRecord::PostgreSQLTestCase
       @connection.execute("SET time zone 'America/Jamaica'", "SCHEMA")
 
       timestamp = PostgresqlTimestampWithZone.find(1)
-      assert_equal Time.utc(2010,1,1, 11,0,0), timestamp.time
+      assert_equal Time.utc(2010, 1, 1, 11, 0, 0), timestamp.time
       assert_instance_of Time, timestamp.time
     end
   ensure
diff --git a/activerecord/test/cases/adapters/postgresql/utils_test.rb b/activerecord/test/cases/adapters/postgresql/utils_test.rb
index 01c597beae..7f6ea3887d 100644
--- a/activerecord/test/cases/adapters/postgresql/utils_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/utils_test.rb
@@ -7,13 +7,13 @@ class PostgreSQLUtilsTest < ActiveRecord::PostgreSQLTestCase
 
   def test_extract_schema_qualified_name
     {
-      %(table_name)            => [nil,"table_name"],
-      %("table.name")          => [nil,"table.name"],
+      %(table_name)            => [nil, "table_name"],
+      %("table.name")          => [nil, "table.name"],
       %(schema.table_name)     => %w{schema table_name},
       %("schema".table_name)   => %w{schema table_name},
       %(schema."table_name")   => %w{schema table_name},
       %("schema"."table_name") => %w{schema table_name},
-      %("even spaces".table)   => ["even spaces","table"],
+      %("even spaces".table)   => ["even spaces", "table"],
       %(schema."table.name")   => ["schema", "table.name"]
     }.each do |given, expect|
       assert_equal Name.new(*expect), extract_schema_qualified_name(given)
diff --git a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
index 66f9349111..0526191952 100644
--- a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
@@ -190,7 +190,7 @@ module ActiveRecord
       end
 
       def test_type_cast_should_not_mutate_encoding
-        name  = "hello".force_encoding(Encoding::ASCII_8BIT)
+        name = "hello".force_encoding(Encoding::ASCII_8BIT)
         Owner.create(name: name)
         assert_equal Encoding::ASCII_8BIT, name.encoding
       ensure