Add more rubocop rules about whitespaces

97 files changed, 356 insertions, 356 deletions

diff --git a/activerecord/Rakefile b/activerecord/Rakefile
index e077d345d6..ec28df8fea 100644
--- a/activerecord/Rakefile
+++ b/activerecord/Rakefile
@@ -50,7 +50,7 @@ end
     Rake::TestTask.new(adapter => "#{adapter}:env") { |t|
       adapter_short = adapter == "db2" ? adapter : adapter[/^[a-z0-9]+/]
       t.libs << "test"
-      t.test_files = (Dir.glob( "test/cases/**/*_test.rb" ).reject {
+      t.test_files = (Dir.glob("test/cases/**/*_test.rb").reject {
         |x| x.include?("/adapters/")
       } + Dir.glob("test/cases/adapters/#{adapter_short}/**/*_test.rb"))
 
@@ -66,7 +66,7 @@ end
         (Dir["test/cases/**/*_test.rb"].reject {
           |x| x.include?("/adapters/")
         } + Dir["test/cases/adapters/#{adapter_short}/**/*_test.rb"]).all? do |file|
-          sh(Gem.ruby, "-w" ,"-Itest", file)
+          sh(Gem.ruby, "-w" , "-Itest", file)
         end || raise("Failures")
       end
     end
diff --git a/activerecord/examples/performance.rb b/activerecord/examples/performance.rb
index f2fe8875b9..3257dd4ad7 100644
--- a/activerecord/examples/performance.rb
+++ b/activerecord/examples/performance.rb
@@ -2,7 +2,7 @@ require "active_record"
 require "benchmark/ips"
 
 TIME    = (ENV["BENCHMARK_TIME"] || 20).to_i
-RECORDS = (ENV["BENCHMARK_RECORDS"] || TIME*1000).to_i
+RECORDS = (ENV["BENCHMARK_RECORDS"] || TIME * 1000).to_i
 
 conn = { adapter: "sqlite3", database: ":memory:" }
 
@@ -42,7 +42,7 @@ class Exhibit < ActiveRecord::Base
   def self.feel(exhibits) exhibits.each(&:feel) end
 end
 
-def progress_bar(int); print "." if (int%100).zero? ; end
+def progress_bar(int); print "." if (int % 100).zero? ; end
 
 puts "Generating data..."
 
diff --git a/activerecord/lib/active_record/associations/join_dependency.rb b/activerecord/lib/active_record/associations/join_dependency.rb
index c26c469c1e..4cd1e64c3d 100644
--- a/activerecord/lib/active_record/associations/join_dependency.rb
+++ b/activerecord/lib/active_record/associations/join_dependency.rb
@@ -7,12 +7,12 @@ module ActiveRecord
       class Aliases # :nodoc:
         def initialize(tables)
           @tables = tables
-          @alias_cache = tables.each_with_object({}) { |table,h|
-            h[table.node] = table.columns.each_with_object({}) { |column,i|
+          @alias_cache = tables.each_with_object({}) { |table, h|
+            h[table.node] = table.columns.each_with_object({}) { |column, i|
               i[column.name] = column.alias
             }
           }
-          @name_and_alias_cache = tables.each_with_object({}) { |table,h|
+          @name_and_alias_cache = tables.each_with_object({}) { |table, h|
             h[table.node] = table.columns.map { |column|
               [column.name, column.alias]
             }
@@ -62,7 +62,7 @@ module ActiveRecord
             walk_tree assoc, hash
           end
         when Hash
-          associations.each do |k,v|
+          associations.each do |k, v|
             cache = hash[k] ||= {}
             walk_tree v, cache
           end
@@ -126,8 +126,8 @@ module ActiveRecord
       end
 
       def aliases
-        Aliases.new join_root.each_with_index.map { |join_part,i|
-          columns = join_part.column_names.each_with_index.map { |column_name,j|
+        Aliases.new join_root.each_with_index.map { |join_part, i|
+          columns = join_part.column_names.each_with_index.map { |column_name, j|
             Aliases::Column.new column_name, "t#{i}_r#{j}"
           }
           Aliases::Table.new(join_part, columns)
@@ -143,7 +143,7 @@ module ActiveRecord
           }
         }
 
-        model_cache = Hash.new { |h,klass| h[klass] = {} }
+        model_cache = Hash.new { |h, klass| h[klass] = {} }
         parents = model_cache[join_root]
         column_aliases = aliases.column_aliases join_root
 
@@ -223,8 +223,8 @@ module ActiveRecord
             [left.children.find { |node2| node1.match? node2 }, node1]
           }.partition(&:first)
 
-          ojs = missing.flat_map { |_,n| make_outer_joins left, n }
-          intersection.flat_map { |l,r| walk l, r }.concat ojs
+          ojs = missing.flat_map { |_, n| make_outer_joins left, n }
+          intersection.flat_map { |l, r| walk l, r }.concat ojs
         end
 
         def find_reflection(klass, name)
diff --git a/activerecord/lib/active_record/associations/preloader/association.rb b/activerecord/lib/active_record/associations/preloader/association.rb
index c79efca920..4072d19380 100644
--- a/activerecord/lib/active_record/associations/preloader/association.rb
+++ b/activerecord/lib/active_record/associations/preloader/association.rb
@@ -113,7 +113,7 @@ module ActiveRecord
             return {} if owner_keys.empty?
             # Some databases impose a limit on the number of ids in a list (in Oracle it's 1000)
             # Make several smaller queries if necessary or make one query if the adapter supports it
-            slices  = owner_keys.each_slice(klass.connection.in_clause_length || owner_keys.size)
+            slices = owner_keys.each_slice(klass.connection.in_clause_length || owner_keys.size)
             @preloaded_records = slices.flat_map do |slice|
               records_for(slice).load(&block)
             end
diff --git a/activerecord/lib/active_record/associations/preloader/through_association.rb b/activerecord/lib/active_record/associations/preloader/through_association.rb
index be9dfe7686..9d44a02021 100644
--- a/activerecord/lib/active_record/associations/preloader/through_association.rb
+++ b/activerecord/lib/active_record/associations/preloader/through_association.rb
@@ -24,7 +24,7 @@ module ActiveRecord
 
           reset_association owners, through_reflection.name
 
-          middle_records = through_records.flat_map { |(_,rec)| rec }
+          middle_records = through_records.flat_map { |(_, rec)| rec }
 
           preloaders = preloader.preload(middle_records,
                                          source_reflection.name,
@@ -32,13 +32,13 @@ module ActiveRecord
 
           @preloaded_records = preloaders.flat_map(&:preloaded_records)
 
-          middle_to_pl = preloaders.each_with_object({}) do |pl,h|
+          middle_to_pl = preloaders.each_with_object({}) do |pl, h|
             pl.owners.each { |middle|
               h[middle] = pl
             }
           end
 
-          through_records.each_with_object({}) do |(lhs,center), records_by_owner|
+          through_records.each_with_object({}) do |(lhs, center), records_by_owner|
             pl_to_middle = center.group_by { |record| middle_to_pl[record] }
 
             records_by_owner[lhs] = pl_to_middle.flat_map do |pl, middles|
diff --git a/activerecord/lib/active_record/autosave_association.rb b/activerecord/lib/active_record/autosave_association.rb
index d3e0dee731..d3901f6efe 100644
--- a/activerecord/lib/active_record/autosave_association.rb
+++ b/activerecord/lib/active_record/autosave_association.rb
@@ -154,10 +154,10 @@ module ActiveRecord
             # Loop prevention for validation of associations
             unless @_already_called[name]
               begin
-                @_already_called[name]=true
+                @_already_called[name] = true
                 result = instance_eval(&block)
               ensure
-                @_already_called[name]=false
+                @_already_called[name] = false
               end
             end
 
@@ -325,7 +325,7 @@ module ActiveRecord
       # Returns whether or not the association is valid and applies any errors to
       # the parent, <tt>self</tt>, if it wasn't. Skips any <tt>:autosave</tt>
       # enabled records if they're marked_for_destruction? or destroyed.
-      def association_valid?(reflection, record, index=nil)
+      def association_valid?(reflection, record, index = nil)
         return true if record.destroyed? || (reflection.options[:autosave] && record.marked_for_destruction?)
 
         validation_context = self.validation_context unless [:create, :update].include?(self.validation_context)
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb b/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
index 2d62fd8d50..e9ecb78e27 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
@@ -833,7 +833,7 @@ module ActiveRecord
     class ConnectionHandler
       def initialize
         # These caches are keyed by spec.name (ConnectionSpecification#name).
-        @owner_to_pool = Concurrent::Map.new(initial_capacity: 2) do |h,k|
+        @owner_to_pool = Concurrent::Map.new(initial_capacity: 2) do |h, k|
           h[k] = Concurrent::Map.new(initial_capacity: 2)
         end
       end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb b/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb
index 2f8a89e88e..376fbca74f 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb
@@ -22,7 +22,7 @@ module ActiveRecord
 
       def initialize(*)
         super
-        @query_cache         = Hash.new { |h,sql| h[sql] = {} }
+        @query_cache         = Hash.new { |h, sql| h[sql] = {} }
         @query_cache_enabled = false
       end
 
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/schema_dumper.rb b/activerecord/lib/active_record/connection_adapters/abstract/schema_dumper.rb
index 06c89ca072..dabccc00bb 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_dumper.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_dumper.rb
@@ -35,7 +35,7 @@ module ActiveRecord
         end
 
         default = schema_default(column) if column.has_default?
-        spec[:default]   = default unless default.nil?
+        spec[:default] = default unless default.nil?
 
         spec[:null] = "false" unless column.null
 
diff --git a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
index 0c7197a002..135421819c 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
@@ -106,7 +106,7 @@ module ActiveRecord
         @pool                = nil
         @schema_cache        = SchemaCache.new self
         @quoted_column_names, @quoted_table_names = {}, {}
-        @visitor             = arel_visitor
+        @visitor = arel_visitor
 
         if self.class.type_cast_config_to_boolean(config.fetch(:prepared_statements) { true })
           @prepared_statements = true
diff --git a/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
index 3bee0e2c62..6f334f5c8d 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
@@ -890,7 +890,7 @@ module ActiveRecord
           end.compact.join(", ")
 
           # ...and send them all in one query
-          @connection.query  "SET #{encoding} #{sql_mode_assignment} #{variable_assignments}"
+          @connection.query "SET #{encoding} #{sql_mode_assignment} #{variable_assignments}"
         end
 
         def column_definitions(table_name) # :nodoc:
diff --git a/activerecord/lib/active_record/connection_adapters/connection_specification.rb b/activerecord/lib/active_record/connection_adapters/connection_specification.rb
index 849130ba43..dcf56997db 100644
--- a/activerecord/lib/active_record/connection_adapters/connection_specification.rb
+++ b/activerecord/lib/active_record/connection_adapters/connection_specification.rb
@@ -48,8 +48,8 @@ module ActiveRecord
 
         # Converts the given URL to a full connection hash.
         def to_hash
-          config = raw_config.reject { |_,value| value.blank? }
-          config.map { |key,value| config[key] = uri_parser.unescape(value) if value.is_a? String }
+          config = raw_config.reject { |_, value| value.blank? }
+          config.map { |key, value| config[key] = uri_parser.unescape(value) if value.is_a? String }
           config
         end
 
diff --git a/activerecord/lib/active_record/connection_adapters/mysql/explain_pretty_printer.rb b/activerecord/lib/active_record/connection_adapters/mysql/explain_pretty_printer.rb
index 925555703d..9691060cd3 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql/explain_pretty_printer.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql/explain_pretty_printer.rb
@@ -47,7 +47,7 @@ module ActiveRecord
 
           def build_separator(widths)
             padding = 1
-            "+" + widths.map { |w| "-" * (w + (padding*2)) }.join("+") + "+"
+            "+" + widths.map { |w| "-" * (w + (padding * 2)) }.join("+") + "+"
           end
 
           def build_cells(items, widths)
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/hstore.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/hstore.rb
index 2d3e6a925d..a74a044a3a 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/hstore.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/hstore.rb
@@ -12,8 +12,8 @@ module ActiveRecord
           def deserialize(value)
             if value.is_a?(::String)
               ::Hash[value.scan(HstorePair).map { |k, v|
-                v = v.upcase == "NULL" ? nil : v.gsub(/\A"(.*)"\Z/m,'\1').gsub(/\\(.)/, '\1')
-                k = k.gsub(/\A"(.*)"\Z/m,'\1').gsub(/\\(.)/, '\1')
+                v = v.upcase == "NULL" ? nil : v.gsub(/\A"(.*)"\Z/m, '\1').gsub(/\\(.)/, '\1')
+                k = k.gsub(/\A"(.*)"\Z/m, '\1').gsub(/\\(.)/, '\1')
                 [k, v]
               }]
             else
diff --git a/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb b/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
index a473c5d67d..2c50321048 100644
--- a/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
@@ -194,9 +194,9 @@ module ActiveRecord
           ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
             # Don't cache statements if they are not prepared
             unless prepare
-              stmt    = @connection.prepare(sql)
+              stmt = @connection.prepare(sql)
               begin
-                cols    = stmt.columns
+                cols = stmt.columns
                 unless without_prepared_statement?(binds)
                   stmt.bind_params(type_casted_binds)
                 end
@@ -239,15 +239,15 @@ module ActiveRecord
       end
 
       def begin_db_transaction #:nodoc:
-        log("begin transaction",nil) { @connection.transaction }
+        log("begin transaction", nil) { @connection.transaction }
       end
 
       def commit_db_transaction #:nodoc:
-        log("commit transaction",nil) { @connection.commit }
+        log("commit transaction", nil) { @connection.commit }
       end
 
       def exec_rollback_db_transaction #:nodoc:
-        log("rollback transaction",nil) { @connection.rollback }
+        log("rollback transaction", nil) { @connection.rollback }
       end
 
       # SCHEMA STATEMENTS ========================================
@@ -416,7 +416,7 @@ module ActiveRecord
             self.default = options[:default] if include_default
             self.null    = options[:null] if options.include?(:null)
             self.precision = options[:precision] if options.include?(:precision)
-            self.scale   = options[:scale] if options.include?(:scale)
+            self.scale = options[:scale] if options.include?(:scale)
             self.collation = options[:collation] if options.include?(:collation)
           end
         end
diff --git a/activerecord/lib/active_record/connection_adapters/statement_pool.rb b/activerecord/lib/active_record/connection_adapters/statement_pool.rb
index 273b1b0b5c..790db56185 100644
--- a/activerecord/lib/active_record/connection_adapters/statement_pool.rb
+++ b/activerecord/lib/active_record/connection_adapters/statement_pool.rb
@@ -6,7 +6,7 @@ module ActiveRecord
       DEFAULT_STATEMENT_LIMIT = 1000
 
       def initialize(statement_limit = nil)
-        @cache = Hash.new { |h,pid| h[pid] = {} }
+        @cache = Hash.new { |h, pid| h[pid] = {} }
         @statement_limit = statement_limit || DEFAULT_STATEMENT_LIMIT
       end
 
diff --git a/activerecord/lib/active_record/core.rb b/activerecord/lib/active_record/core.rb
index 622df0cfc1..d24bd4efa8 100644
--- a/activerecord/lib/active_record/core.rb
+++ b/activerecord/lib/active_record/core.rb
@@ -174,7 +174,7 @@ module ActiveRecord
                         columns_hash.include?(inheritance_column) ||
                         ids.first.kind_of?(Array)
 
-        id  = ids.first
+        id = ids.first
         if ActiveRecord::Base === id
           id = id.id
           ActiveSupport::Deprecation.warn(<<-MSG.squish)
diff --git a/activerecord/lib/active_record/fixtures.rb b/activerecord/lib/active_record/fixtures.rb
index 8b47fbdbe4..0eaee05056 100644
--- a/activerecord/lib/active_record/fixtures.rb
+++ b/activerecord/lib/active_record/fixtures.rb
@@ -415,9 +415,9 @@ module ActiveRecord
     # possibly in a folder with the same name.
     #++
 
-    MAX_ID = 2 ** 30 - 1
+    MAX_ID = 2**30 - 1
 
-    @@all_cached_fixtures = Hash.new { |h,k| h[k] = {} }
+    @@all_cached_fixtures = Hash.new { |h, k| h[k] = {} }
 
     def self.default_fixture_model_name(fixture_set_name, config = ActiveRecord::Base) # :nodoc:
       config.pluralize_table_names ?
@@ -597,18 +597,18 @@ module ActiveRecord
 
       @fixtures = read_fixture_files(path)
 
-      @connection  = connection
+      @connection = connection
 
-      @table_name = ( model_class.respond_to?(:table_name) ?
+      @table_name = (model_class.respond_to?(:table_name) ?
                       model_class.table_name :
-                      self.class.default_fixture_table_name(name, config) )
+                      self.class.default_fixture_table_name(name, config))
     end
 
     def [](x)
       fixtures[x]
     end
 
-    def []=(k,v)
+    def []=(k, v)
       fixtures[k] = v
     end
 
@@ -629,7 +629,7 @@ module ActiveRecord
       fixtures.delete("DEFAULTS")
 
       # track any join tables we need to insert later
-      rows = Hash.new { |h,table| h[table] = [] }
+      rows = Hash.new { |h, table| h[table] = [] }
 
       rows[table_name] = fixtures.map do |label, fixture|
         row = fixture.to_hash
diff --git a/activerecord/lib/active_record/migration.rb b/activerecord/lib/active_record/migration.rb
index 9c3901e736..cc6bc17b9d 100644
--- a/activerecord/lib/active_record/migration.rb
+++ b/activerecord/lib/active_record/migration.rb
@@ -769,7 +769,7 @@ module ActiveRecord
       when :down then announce "reverting"
       end
 
-      time   = nil
+      time = nil
       ActiveRecord::Base.connection_pool.with_connection do |conn|
         time = Benchmark.measure do
           exec_migration(conn, direction)
@@ -797,7 +797,7 @@ module ActiveRecord
       @connection = nil
     end
 
-    def write(text="")
+    def write(text = "")
       puts(text) if verbose
     end
 
@@ -807,7 +807,7 @@ module ActiveRecord
       write "== %s %s" % [text, "=" * length]
     end
 
-    def say(message, subitem=false)
+    def say(message, subitem = false)
       write "#{subitem ? "   ->" : "--"} #{message}"
     end
 
@@ -991,11 +991,11 @@ module ActiveRecord
         end
       end
 
-      def rollback(migrations_paths, steps=1)
+      def rollback(migrations_paths, steps = 1)
         move(:down, migrations_paths, steps)
       end
 
-      def forward(migrations_paths, steps=1)
+      def forward(migrations_paths, steps = 1)
         move(:up, migrations_paths, steps)
       end
 
@@ -1232,10 +1232,10 @@ module ActiveRecord
       end
 
       def validate(migrations)
-        name ,= migrations.group_by(&:name).find { |_,v| v.length > 1 }
+        name , = migrations.group_by(&:name).find { |_, v| v.length > 1 }
         raise DuplicateMigrationNameError.new(name) if name
 
-        version ,= migrations.group_by(&:version).find { |_,v| v.length > 1 }
+        version , = migrations.group_by(&:version).find { |_, v| v.length > 1 }
         raise DuplicateMigrationVersionError.new(version) if version
       end
 
diff --git a/activerecord/lib/active_record/railtie.rb b/activerecord/lib/active_record/railtie.rb
index 989d23bc37..7ce10df6d4 100644
--- a/activerecord/lib/active_record/railtie.rb
+++ b/activerecord/lib/active_record/railtie.rb
@@ -108,7 +108,7 @@ module ActiveRecord
 
     initializer "active_record.set_configs" do |app|
       ActiveSupport.on_load(:active_record) do
-        app.config.active_record.each do |k,v|
+        app.config.active_record.each do |k, v|
           send "#{k}=", v
         end
       end
diff --git a/activerecord/lib/active_record/reflection.rb b/activerecord/lib/active_record/reflection.rb
index ce70c29093..e912f97d63 100644
--- a/activerecord/lib/active_record/reflection.rb
+++ b/activerecord/lib/active_record/reflection.rb
@@ -712,7 +712,7 @@ module ActiveRecord
 
       def initialize(delegate_reflection)
         @delegate_reflection = delegate_reflection
-        @klass         = delegate_reflection.options[:anonymous_class]
+        @klass = delegate_reflection.options[:anonymous_class]
         @source_reflection_name = delegate_reflection.options[:source]
       end
 
diff --git a/activerecord/lib/active_record/relation/batches/batch_enumerator.rb b/activerecord/lib/active_record/relation/batches/batch_enumerator.rb
index 333b3a63cf..3555779ec2 100644
--- a/activerecord/lib/active_record/relation/batches/batch_enumerator.rb
+++ b/activerecord/lib/active_record/relation/batches/batch_enumerator.rb
@@ -7,7 +7,7 @@ module ActiveRecord
         @of       = of
         @relation = relation
         @start = start
-        @finish   = finish
+        @finish = finish
       end
 
       # Looping through a collection of records from the database (using the
diff --git a/activerecord/lib/active_record/schema.rb b/activerecord/lib/active_record/schema.rb
index 784a02d2c3..99e54a8b24 100644
--- a/activerecord/lib/active_record/schema.rb
+++ b/activerecord/lib/active_record/schema.rb
@@ -40,7 +40,7 @@ module ActiveRecord
     #   ActiveRecord::Schema.define(version: 20380119000001) do
     #     ...
     #   end
-    def self.define(info={}, &block)
+    def self.define(info = {}, &block)
       new.define(info, &block)
     end
 
diff --git a/activerecord/lib/active_record/schema_dumper.rb b/activerecord/lib/active_record/schema_dumper.rb
index c1c6519cfa..12289511b7 100644
--- a/activerecord/lib/active_record/schema_dumper.rb
+++ b/activerecord/lib/active_record/schema_dumper.rb
@@ -17,7 +17,7 @@ module ActiveRecord
     @@ignore_tables = []
 
     class << self
-      def dump(connection=ActiveRecord::Base.connection, stream=STDOUT, config = ActiveRecord::Base)
+      def dump(connection = ActiveRecord::Base.connection, stream = STDOUT, config = ActiveRecord::Base)
         new(connection, generate_options(config)).dump(stream)
         stream
       end
@@ -162,7 +162,7 @@ HEADER
         if (indexes = @connection.indexes(table)).any?
           add_index_statements = indexes.map do |index|
             table_name = remove_prefix_and_suffix(index.table).inspect
-            "  add_index #{([table_name]+index_parts(index)).join(', ')}"
+            "  add_index #{([table_name] + index_parts(index)).join(', ')}"
           end
 
           stream.puts add_index_statements.sort.join("\n")
diff --git a/activerecord/lib/active_record/scoping.rb b/activerecord/lib/active_record/scoping.rb
index d1bd1cd89a..7c00e7e4ed 100644
--- a/activerecord/lib/active_record/scoping.rb
+++ b/activerecord/lib/active_record/scoping.rb
@@ -33,7 +33,7 @@ module ActiveRecord
     def populate_with_current_scope_attributes # :nodoc:
       return unless self.class.scope_attributes?
 
-      self.class.scope_attributes.each do |att,value|
+      self.class.scope_attributes.each do |att, value|
         send("#{att}=", value) if respond_to?("#{att}=")
       end
     end
diff --git a/activerecord/lib/active_record/statement_cache.rb b/activerecord/lib/active_record/statement_cache.rb
index 691940ab70..1877489e55 100644
--- a/activerecord/lib/active_record/statement_cache.rb
+++ b/activerecord/lib/active_record/statement_cache.rb
@@ -41,7 +41,7 @@ module ActiveRecord
     class PartialQuery < Query # :nodoc:
       def initialize(values)
         @values = values
-        @indexes = values.each_with_index.find_all { |thing,i|
+        @indexes = values.each_with_index.find_all { |thing, i|
           Arel::Nodes::BindParam === thing
         }.map(&:last)
       end
@@ -68,7 +68,7 @@ module ActiveRecord
 
     class BindMap # :nodoc:
       def initialize(bound_attributes)
-        @indexes   = []
+        @indexes = []
         @bound_attributes = bound_attributes
 
         bound_attributes.each_with_index do |attr, i|
@@ -80,7 +80,7 @@ module ActiveRecord
 
       def bind(values)
         bas = @bound_attributes.dup
-        @indexes.each_with_index { |offset,i| bas[offset] = bas[offset].with_cast_value(values[i]) }
+        @indexes.each_with_index { |offset, i| bas[offset] = bas[offset].with_cast_value(values[i]) }
         bas
       end
     end
diff --git a/activerecord/lib/active_record/tasks/database_tasks.rb b/activerecord/lib/active_record/tasks/database_tasks.rb
index a19913f2a8..c6204ac36f 100644
--- a/activerecord/lib/active_record/tasks/database_tasks.rb
+++ b/activerecord/lib/active_record/tasks/database_tasks.rb
@@ -40,7 +40,7 @@ module ActiveRecord
       attr_writer :current_config, :db_dir, :migrations_paths, :fixtures_path, :root, :env, :seed_loader
       attr_accessor :database_configuration
 
-      LOCAL_HOSTS    = ["127.0.0.1", "localhost"]
+      LOCAL_HOSTS = ["127.0.0.1", "localhost"]
 
       def check_protected_environments!
         unless ENV["DISABLE_DATABASE_ENVIRONMENT_CHECK"]
diff --git a/activerecord/lib/active_record/tasks/postgresql_database_tasks.rb b/activerecord/lib/active_record/tasks/postgresql_database_tasks.rb
index 03d3049001..4e9897f7b0 100644
--- a/activerecord/lib/active_record/tasks/postgresql_database_tasks.rb
+++ b/activerecord/lib/active_record/tasks/postgresql_database_tasks.rb
@@ -70,7 +70,7 @@ module ActiveRecord
       def structure_load(filename)
         set_psql_env
         args = [ "-v", ON_ERROR_STOP_1, "-q", "-f", filename, configuration["database"] ]
-        run_cmd("psql", args, "loading" )
+        run_cmd("psql", args, "loading")
       end
 
       private
diff --git a/activerecord/lib/active_record/validations.rb b/activerecord/lib/active_record/validations.rb
index ecaf04e39e..c013a4518f 100644
--- a/activerecord/lib/active_record/validations.rb
+++ b/activerecord/lib/active_record/validations.rb
@@ -40,13 +40,13 @@ module ActiveRecord
     # The validation process on save can be skipped by passing <tt>validate: false</tt>.
     # The regular {ActiveRecord::Base#save}[rdoc-ref:Persistence#save] method is replaced
     # with this when the validations module is mixed in, which it is by default.
-    def save(options={})
+    def save(options = {})
       perform_validations(options) ? super : false
     end
 
     # Attempts to save the record just like {ActiveRecord::Base#save}[rdoc-ref:Base#save] but
     # will raise an ActiveRecord::RecordInvalid exception instead of returning +false+ if the record is not valid.
-    def save!(options={})
+    def save!(options = {})
       perform_validations(options) ? super : raise_validation_error
     end
 
@@ -78,7 +78,7 @@ module ActiveRecord
       raise(RecordInvalid.new(self))
     end
 
-    def perform_validations(options={}) # :nodoc:
+    def perform_validations(options = {}) # :nodoc:
       options[:validate] == false || valid?(options[:context])
     end
   end
diff --git a/activerecord/test/active_record/connection_adapters/fake_adapter.rb b/activerecord/test/active_record/connection_adapters/fake_adapter.rb
index 43c817e057..b0d8050721 100644
--- a/activerecord/test/active_record/connection_adapters/fake_adapter.rb
+++ b/activerecord/test/active_record/connection_adapters/fake_adapter.rb
@@ -9,7 +9,7 @@ module ActiveRecord
     class FakeAdapter < AbstractAdapter
       attr_accessor :data_sources, :primary_keys
 
-      @columns = Hash.new { |h,k| h[k] = [] }
+      @columns = Hash.new { |h, k| h[k] = [] }
       class << self
         attr_reader :columns
       end
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
diff --git a/activerecord/test/cases/ar_schema_test.rb b/activerecord/test/cases/ar_schema_test.rb
index e3eccad71f..397ac599b9 100644
--- a/activerecord/test/cases/ar_schema_test.rb
+++ b/activerecord/test/cases/ar_schema_test.rb
@@ -54,7 +54,7 @@ if ActiveRecord::Base.connection.supports_migrations?
     def test_schema_define_w_table_name_prefix
       table_name = ActiveRecord::SchemaMigration.table_name
       old_table_name_prefix = ActiveRecord::Base.table_name_prefix
-      ActiveRecord::Base.table_name_prefix  = "nep_"
+      ActiveRecord::Base.table_name_prefix = "nep_"
       ActiveRecord::SchemaMigration.table_name = "nep_#{table_name}"
       ActiveRecord::Schema.define(version: 7) do
         create_table :fruits do |t|
@@ -66,7 +66,7 @@ if ActiveRecord::Base.connection.supports_migrations?
       end
       assert_equal 7, ActiveRecord::Migrator::current_version
     ensure
-      ActiveRecord::Base.table_name_prefix  = old_table_name_prefix
+      ActiveRecord::Base.table_name_prefix = old_table_name_prefix
       ActiveRecord::SchemaMigration.table_name = table_name
     end
 
diff --git a/activerecord/test/cases/associations/belongs_to_associations_test.rb b/activerecord/test/cases/associations/belongs_to_associations_test.rb
index 2418346d1b..6b7e4fee56 100644
--- a/activerecord/test/cases/associations/belongs_to_associations_test.rb
+++ b/activerecord/test/cases/associations/belongs_to_associations_test.rb
@@ -285,7 +285,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_failing_create!
-    client  = Client.create!(name: "Jimmy")
+    client = Client.create!(name: "Jimmy")
     assert_raise(ActiveRecord::RecordInvalid) { client.create_account! }
     assert_not_nil client.account
     assert client.account.new_record?
@@ -346,7 +346,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
 
   def test_with_select
     assert_equal 1, Company.find(2).firm_with_select.attributes.size
-    assert_equal 1, Company.all.merge!(includes: :firm_with_select ).find(2).firm_with_select.attributes.size
+    assert_equal 1, Company.all.merge!(includes: :firm_with_select).find(2).firm_with_select.attributes.size
   end
 
   def test_belongs_to_without_counter_cache_option
diff --git a/activerecord/test/cases/associations/callbacks_test.rb b/activerecord/test/cases/associations/callbacks_test.rb
index 2f62d0367e..5fd2411f6f 100644
--- a/activerecord/test/cases/associations/callbacks_test.rb
+++ b/activerecord/test/cases/associations/callbacks_test.rb
@@ -109,7 +109,7 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
       def self.name; Project.name; end
       has_and_belongs_to_many :developers_with_callbacks,
                                 class_name: "Developer",
-                                before_add: lambda { |o,r|
+                                before_add: lambda { |o, r|
         dev     = r
         new_dev = r.new_record?
       }
@@ -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 e87431bf32..ddb5c7a4aa 100644
--- a/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
+++ b/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
@@ -20,7 +20,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
     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
@@ -28,7 +28,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
     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
@@ -86,7 +86,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
     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
@@ -183,6 +183,6 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
     assert_equal 1, authors[1].comments.size
     assert_equal 5, authors[0].posts.size
     assert_equal 3, authors[1].posts.size
-    assert_equal 3, authors[0].posts.collect { |post| post.categorizations.size }.inject(0) { |sum, i| sum+i }
+    assert_equal 3, authors[0].posts.collect { |post| post.categorizations.size }.inject(0) { |sum, i| sum + i }
   end
 end
diff --git a/activerecord/test/cases/associations/eager_load_includes_full_sti_class_test.rb b/activerecord/test/cases/associations/eager_load_includes_full_sti_class_test.rb
index aa82b9dd2a..4f0fe3236e 100644
--- a/activerecord/test/cases/associations/eager_load_includes_full_sti_class_test.rb
+++ b/activerecord/test/cases/associations/eager_load_includes_full_sti_class_test.rb
@@ -15,8 +15,8 @@ class EagerLoadIncludeFullStiClassNamesTest < ActiveRecord::TestCase
   end
 
   def generate_test_objects
-    post = Namespaced::Post.create( title: "Great stuff", body: "This is not", author_id: 1 )
-    Tagging.create( taggable: post )
+    post = Namespaced::Post.create(title: "Great stuff", body: "This is not", author_id: 1)
+    Tagging.create(taggable: post)
   end
 
   def test_class_names
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 a7a8c6a783..ed1b0f5226 100644
--- a/activerecord/test/cases/associations/eager_load_nested_include_test.rb
+++ b/activerecord/test/cases/associations/eager_load_nested_include_test.rb
@@ -39,7 +39,7 @@ class Triangle < ActiveRecord::Base
   has_many :shape_expressions, as: :shape
   include Remembered
 end
-class PaintColor  < ActiveRecord::Base
+class PaintColor < ActiveRecord::Base
   has_many   :shape_expressions, as: :paint
   belongs_to :non_poly, foreign_key: "non_poly_one_id", class_name: "NonPolyOne"
   include Remembered
diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index d1c4c1cef8..dc04ccdccc 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -356,31 +356,31 @@ class EagerAssociationTest < ActiveRecord::TestCase
   def test_eager_association_loading_with_belongs_to_and_limit
     comments = Comment.all.merge!(includes: :post, limit: 5, order: "comments.id").to_a
     assert_equal 5, comments.length
-    assert_equal [1,2,3,5,6], comments.collect(&:id)
+    assert_equal [1, 2, 3, 5, 6], comments.collect(&:id)
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit_and_conditions
     comments = Comment.all.merge!(includes: :post, where: "post_id = 4", limit: 3, order: "comments.id").to_a
     assert_equal 3, comments.length
-    assert_equal [5,6,7], comments.collect(&:id)
+    assert_equal [5, 6, 7], comments.collect(&:id)
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit_and_offset
     comments = Comment.all.merge!(includes: :post, limit: 3, offset: 2, order: "comments.id").to_a
     assert_equal 3, comments.length
-    assert_equal [3,5,6], comments.collect(&:id)
+    assert_equal [3, 5, 6], comments.collect(&:id)
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit_and_offset_and_conditions
     comments = Comment.all.merge!(includes: :post, where: "post_id = 4", limit: 3, offset: 1, order: "comments.id").to_a
     assert_equal 3, comments.length
-    assert_equal [6,7,8], comments.collect(&:id)
+    assert_equal [6, 7, 8], comments.collect(&:id)
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit_and_offset_and_conditions_array
-    comments = Comment.all.merge!(includes: :post, where: ["post_id = ?",4], limit: 3, offset: 1, order: "comments.id").to_a
+    comments = Comment.all.merge!(includes: :post, where: ["post_id = ?", 4], limit: 3, offset: 1, order: "comments.id").to_a
     assert_equal 3, comments.length
-    assert_equal [6,7,8], comments.collect(&:id)
+    assert_equal [6, 7, 8], comments.collect(&:id)
   end
 
   def test_eager_association_loading_with_belongs_to_and_conditions_string_with_unquoted_table_name
@@ -395,14 +395,14 @@ class EagerAssociationTest < ActiveRecord::TestCase
       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)
+    assert_equal [5, 6, 7], comments.collect(&:id)
     assert_no_queries do
       comments.first.post
     end
   end
 
   def test_eager_association_loading_with_belongs_to_and_conditions_string_with_quoted_table_name
-    quoted_posts_id= Comment.connection.quote_table_name("posts") + "." + Comment.connection.quote_column_name("id")
+    quoted_posts_id = Comment.connection.quote_table_name("posts") + "." + Comment.connection.quote_column_name("id")
     assert_nothing_raised do
       Comment.includes(:post).references(:posts).where("#{quoted_posts_id} = ?", 4)
     end
@@ -415,7 +415,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_belongs_to_and_order_string_with_quoted_table_name
-    quoted_posts_id= Comment.connection.quote_table_name("posts") + "." + Comment.connection.quote_column_name("id")
+    quoted_posts_id = Comment.connection.quote_table_name("posts") + "." + Comment.connection.quote_column_name("id")
     assert_nothing_raised do
       Comment.includes(:post).references(:posts).order(quoted_posts_id)
     end
@@ -452,8 +452,8 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   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) }
+    references(:michael_magician, :michael_unicyclist)
+    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
@@ -464,7 +464,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_eager_load_has_many_with_string_keys
     subscriptions = subscriptions(:webster_awdr, :webster_rfr)
-    subscriber =Subscriber.all.merge!(includes: :subscriptions).find(subscribers(:second).id)
+    subscriber = Subscriber.all.merge!(includes: :subscriptions).find(subscribers(:second).id)
     assert_equal subscriptions, subscriber.subscriptions.sort_by(&:id)
   end
 
@@ -563,13 +563,13 @@ class EagerAssociationTest < ActiveRecord::TestCase
   def test_eager_with_has_many_and_limit_and_conditions
     posts = Post.all.merge!(includes: [ :author, :comments ], limit: 2, where: "posts.body = 'hello'", order: "posts.id").to_a
     assert_equal 2, posts.size
-    assert_equal [4,5], posts.collect(&:id)
+    assert_equal [4, 5], posts.collect(&:id)
   end
 
   def test_eager_with_has_many_and_limit_and_conditions_array
     posts = Post.all.merge!(includes: [ :author, :comments ], limit: 2, where: [ "posts.body = ?", "hello" ], order: "posts.id").to_a
     assert_equal 2, posts.size
-    assert_equal [4,5], posts.collect(&:id)
+    assert_equal [4, 5], posts.collect(&:id)
   end
 
   def test_eager_with_has_many_and_limit_and_conditions_array_on_the_eagers
@@ -740,7 +740,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_eager_with_invalid_association_reference
     assert_raise(ActiveRecord::AssociationNotFoundError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys") {
-      Post.all.merge!(includes: :monkeys ).find(6)
+      Post.all.merge!(includes: :monkeys).find(6)
     }
     assert_raise(ActiveRecord::AssociationNotFoundError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys") {
       Post.all.merge!(includes: [ :monkeys ]).find(6)
@@ -844,7 +844,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
     end
   end
 
-  def find_all_ordered(className, include=nil)
+  def find_all_ordered(className, include = nil)
     className.all.merge!(order: "#{className.table_name}.#{className.primary_key}", includes: include).to_a
   end
 
@@ -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
@@ -1163,7 +1163,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
     expected = Firm.find(1).clients_using_primary_key.sort_by(&:name)
     # Oracle adapter truncates alias to 30 characters
     if current_adapter?(:OracleAdapter)
-      firm = Firm.all.merge!(includes: :clients_using_primary_key, order: "clients_using_primary_keys_companies"[0,30]+".name").find(1)
+      firm = Firm.all.merge!(includes: :clients_using_primary_key, order: "clients_using_primary_keys_companies"[0, 30] + ".name").find(1)
     else
       firm = Firm.all.merge!(includes: :clients_using_primary_key, order: "clients_using_primary_keys_companies.name").find(1)
     end
@@ -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 cc86e1a16d..974a3080d4 100644
--- a/activerecord/test/cases/associations/extension_test.rb
+++ b/activerecord/test/cases/associations/extension_test.rb
@@ -45,7 +45,7 @@ class AssociationsExtensionsTest < ActiveRecord::TestCase
     # Marshaling an association shouldn't make it unusable by wiping its reflection.
     assert_not_nil david.association(:projects).reflection
 
-    david_too  = Marshal.load(marshalled)
+    david_too = Marshal.load(marshalled)
     assert_equal projects(:action_controller), david_too.projects.find_most_recent
   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 6bded77eb2..4902792eee 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
@@ -253,8 +253,8 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert !p.persisted?
     assert aredridel.save
     assert aredridel.persisted?
-    assert_equal no_of_devels+1, Developer.count
-    assert_equal no_of_projects+1, Project.count
+    assert_equal no_of_devels + 1, Developer.count
+    assert_equal no_of_projects + 1, Project.count
     assert_equal 2, aredridel.projects.size
     assert_equal 2, aredridel.projects.reload.size
   end
diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index c1e04714fb..7eb04b1ffd 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -84,7 +84,7 @@ class HasManyAssociationsTestPrimaryKeys < ActiveRecord::TestCase
     david = people(:david)
 
     assert_equal ["A Modest Proposal"], david.essays.map(&:name)
-    david.essays = [Essay.create!(name: "Remote Work" )]
+    david.essays = [Essay.create!(name: "Remote Work")]
     assert_equal ["Remote Work"], david.essays.map(&:name)
   end
 
@@ -528,7 +528,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_find_should_append_to_association_order
-    ordered_clients =  companies(:first_firm).clients_sorted_desc.order("companies.id")
+    ordered_clients = companies(:first_firm).clients_sorted_desc.order("companies.id")
     assert_equal ["id DESC", "companies.id"], ordered_clients.order_values
   end
 
@@ -990,7 +990,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_create_without_loading_association
-    first_firm  = companies(:first_firm)
+    first_firm = companies(:first_firm)
     Firm.column_names
     Client.column_names
 
@@ -2298,7 +2298,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   test "does not duplicate associations when used with natural primary keys" do
     speedometer = Speedometer.create!(id: "4")
-    speedometer.minivans.create!(minivan_id: "a-van-red" ,name: "a van", color: "red")
+    speedometer.minivans.create!(minivan_id: "a-van-red" , name: "a van", color: "red")
 
     assert_equal 1, speedometer.minivans.to_a.size, "Only one association should be present:\n#{speedometer.minivans.to_a}"
     assert_equal 1, speedometer.reload.minivans.to_a.size
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 9f716d7820..c2239ac03a 100644
--- a/activerecord/test/cases/associations/has_many_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_through_associations_test.rb
@@ -75,7 +75,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     posts = person_prime.includes(:posts).first.posts
 
     assert_operator posts.length, :>, 1
-    posts.each_cons(2) do |left,right|
+    posts.each_cons(2) do |left, right|
       assert_operator left.id, :>, right.id
     end
   end
@@ -702,7 +702,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
       [:added, :after, "Bob"],
       [:added, :before, "Lary"],
       [:added, :after, "Lary"]
-    ],log.last(6)
+    ], log.last(6)
 
     post.people_with_callbacks.build(first_name: "Ted")
     assert_equal [
@@ -716,7 +716,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
       [:added, :after, "Sam"]
     ], log.last(2)
 
-    post.people_with_callbacks = [people(:michael),people(:david), Person.new(first_name: "Julian"), Person.create!(first_name: "Roger")]
+    post.people_with_callbacks = [people(:michael), people(:david), Person.new(first_name: "Julian"), Person.create!(first_name: "Roger")]
     assert_equal((%w(Ted Bob Sam Lary) * 2).sort, log[-12..-5].collect(&:last).sort)
     assert_equal [
       [:added, :before, "Julian"],
@@ -885,8 +885,8 @@ 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 }
+    ids = [Developer.first.id, -9999]
+    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 1a0e6d2f8e..483d1162bc 100644
--- a/activerecord/test/cases/associations/has_one_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_associations_test.rb
@@ -675,6 +675,6 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
     book = SpecialBook.create!(status: "published")
     author.book = book
 
-    refute_equal 0, SpecialAuthor.joins(:book).where(books: { status: "published" } ).count
+    refute_equal 0, SpecialAuthor.joins(:book).where(books: { status: "published" }).count
   end
 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 b2f47d2daf..6ba062a248 100644
--- a/activerecord/test/cases/associations/has_one_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_through_associations_test.rb
@@ -123,7 +123,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   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
+    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 }
   end
diff --git a/activerecord/test/cases/associations/join_model_test.rb b/activerecord/test/cases/associations/join_model_test.rb
index 15a7ae941a..15446c6dc7 100644
--- a/activerecord/test/cases/associations/join_model_test.rb
+++ b/activerecord/test/cases/associations/join_model_test.rb
@@ -155,21 +155,21 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     old_count = posts(:welcome).taggings.count
     tagging = posts(:welcome).taggings.create(tag: tags(:misc))
     assert_equal "Post", tagging.taggable_type
-    assert_equal old_count+1, posts(:welcome).taggings.count
+    assert_equal old_count + 1, posts(:welcome).taggings.count
   end
 
   def test_create_bang_polymorphic_with_has_many_scope
     old_count = posts(:welcome).taggings.count
     tagging = posts(:welcome).taggings.create!(tag: tags(:misc))
     assert_equal "Post", tagging.taggable_type
-    assert_equal old_count+1, posts(:welcome).taggings.count
+    assert_equal old_count + 1, posts(:welcome).taggings.count
   end
 
   def test_create_polymorphic_has_one_with_scope
     old_count = Tagging.count
     tagging = posts(:welcome).create_tagging(tag: tags(:misc))
     assert_equal "Post", tagging.taggable_type
-    assert_equal old_count+1, Tagging.count
+    assert_equal old_count + 1, Tagging.count
   end
 
   def test_delete_polymorphic_has_many_with_delete_all
@@ -179,7 +179,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
     old_count = Tagging.count
     post.destroy
-    assert_equal old_count-1, Tagging.count
+    assert_equal old_count - 1, Tagging.count
     assert_equal 0, posts(:welcome).taggings.count
   end
 
@@ -190,7 +190,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
     old_count = Tagging.count
     post.destroy
-    assert_equal old_count-1, Tagging.count
+    assert_equal old_count - 1, Tagging.count
     assert_equal 0, posts(:welcome).taggings.count
   end
 
@@ -212,7 +212,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
     old_count = Tagging.count
     post.destroy
-    assert_equal old_count-1, Tagging.count
+    assert_equal old_count - 1, Tagging.count
     posts(:welcome).association(:tagging).reload
     assert_nil posts(:welcome).tagging
   end
@@ -402,7 +402,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_has_many_through_polymorphic_has_one
-    assert_equal Tagging.find(1,2).sort_by(&:id), authors(:david).taggings_2
+    assert_equal Tagging.find(1, 2).sort_by(&:id), authors(:david).taggings_2
   end
 
   def test_has_many_through_polymorphic_has_many
@@ -421,7 +421,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     author = Author.all.merge!(where: ["name = ?", "David"], includes: :comments, order: "comments.id").first
     SpecialComment.new; VerySpecialComment.new
     assert_no_queries do
-      assert_equal [1,2,3,5,6,7,8,9,10,12], author.comments.collect(&:id)
+      assert_equal [1, 2, 3, 5, 6, 7, 8, 9, 10, 12], author.comments.collect(&:id)
     end
   end
 
@@ -493,25 +493,25 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     push = Tag.create!(name: "pushme")
     post_thinking = posts(:thinking)
     assert_nothing_raised { post_thinking.tags << push }
-    assert_nil( wrong = post_thinking.tags.detect { |t| t.class != Tag },
+    assert_nil(wrong = post_thinking.tags.detect { |t| t.class != Tag },
                 message = "Expected a Tag in tags collection, got #{wrong.class}.")
-    assert_nil( wrong = post_thinking.taggings.detect { |t| t.class != Tagging },
+    assert_nil(wrong = post_thinking.taggings.detect { |t| t.class != Tagging },
                 message = "Expected a Tagging in taggings collection, got #{wrong.class}.")
     assert_equal(count + 1, post_thinking.reload.tags.size)
     assert_equal(count + 1, post_thinking.tags.reload.size)
 
     assert_kind_of Tag, post_thinking.tags.create!(name: "foo")
-    assert_nil( wrong = post_thinking.tags.detect { |t| t.class != Tag },
+    assert_nil(wrong = post_thinking.tags.detect { |t| t.class != Tag },
                 message = "Expected a Tag in tags collection, got #{wrong.class}.")
-    assert_nil( wrong = post_thinking.taggings.detect { |t| t.class != Tagging },
+    assert_nil(wrong = post_thinking.taggings.detect { |t| t.class != Tagging },
                 message = "Expected a Tagging in taggings collection, got #{wrong.class}.")
     assert_equal(count + 2, post_thinking.reload.tags.size)
     assert_equal(count + 2, post_thinking.tags.reload.size)
 
     assert_nothing_raised { post_thinking.tags.concat(Tag.create!(name: "abc"), Tag.create!(name: "def")) }
-    assert_nil( wrong = post_thinking.tags.detect { |t| t.class != Tag },
+    assert_nil(wrong = post_thinking.tags.detect { |t| t.class != Tag },
                 message = "Expected a Tag in tags collection, got #{wrong.class}.")
-    assert_nil( wrong = post_thinking.taggings.detect { |t| t.class != Tagging },
+    assert_nil(wrong = post_thinking.taggings.detect { |t| t.class != Tagging },
                 message = "Expected a Tagging in taggings collection, got #{wrong.class}.")
     assert_equal(count + 4, post_thinking.reload.tags.size)
     assert_equal(count + 4, post_thinking.tags.reload.size)
diff --git a/activerecord/test/cases/attribute_methods_test.rb b/activerecord/test/cases/attribute_methods_test.rb
index 4c77ecab7c..ba6877a6a6 100644
--- a/activerecord/test/cases/attribute_methods_test.rb
+++ b/activerecord/test/cases/attribute_methods_test.rb
@@ -294,7 +294,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     topic = Topic.new(new_topic)
     assert_equal new_topic[:title], topic.title
 
-    topic.attributes= new_topic_values
+    topic.attributes = new_topic_values
     assert_equal new_topic_values[:title], topic.title
   end
 
@@ -609,7 +609,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     utc_time = Time.utc(2008, 1, 1)
     cst_time = utc_time.in_time_zone("Central Time (US & Canada)")
     in_time_zone "Pacific Time (US & Canada)" do
-      record   = @target.new
+      record = @target.new
       record.written_on = cst_time
       assert_equal utc_time, record.written_on
       assert_equal ActiveSupport::TimeZone["Pacific Time (US & Canada)"], record.written_on.time_zone
@@ -633,7 +633,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     (-11..13).each do |timezone_offset|
       time_string = utc_time.in_time_zone(timezone_offset).to_s
       in_time_zone "Pacific Time (US & Canada)" do
-        record   = @target.new
+        record = @target.new
         record.written_on = time_string
         assert_equal Time.zone.parse(time_string), record.written_on
         assert_equal ActiveSupport::TimeZone["Pacific Time (US & Canada)"], record.written_on.time_zone
@@ -654,7 +654,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
 
   test "setting a time zone-aware attribute to a blank string returns nil" do
     in_time_zone "Pacific Time (US & Canada)" do
-      record   = @target.new
+      record = @target.new
       record.written_on = " "
       assert_nil record.written_on
       assert_nil record[:written_on]
@@ -665,7 +665,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     time_string = "Tue Jan 01 00:00:00 2008"
     (-11..13).each do |timezone_offset|
       in_time_zone timezone_offset do
-        record   = @target.new
+        record = @target.new
         record.written_on = time_string
         assert_equal Time.zone.parse(time_string), record.written_on
         assert_equal ActiveSupport::TimeZone[timezone_offset], record.written_on.time_zone
@@ -677,7 +677,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
   test "setting a time zone-aware datetime in the current time zone" do
     utc_time = Time.utc(2008, 1, 1)
     in_time_zone "Pacific Time (US & Canada)" do
-      record   = @target.new
+      record = @target.new
       record.written_on = utc_time.in_time_zone
       assert_equal utc_time, record.written_on
       assert_equal ActiveSupport::TimeZone["Pacific Time (US & Canada)"], record.written_on.time_zone
diff --git a/activerecord/test/cases/autosave_association_test.rb b/activerecord/test/cases/autosave_association_test.rb
index c24d7b8835..80e76caaaa 100644
--- a/activerecord/test/cases/autosave_association_test.rb
+++ b/activerecord/test/cases/autosave_association_test.rb
@@ -1130,7 +1130,7 @@ class TestAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCase
     assert_queries(0) { @ship.save! }
 
     @parrot = @pirate.parrots.create(name: "some_name")
-    @parrot.name="changed_name"
+    @parrot.name = "changed_name"
     assert_queries(1) { @ship.save! }
     assert_queries(0) { @ship.save! }
   end
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index fafa144c6f..4dc6059d96 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -494,12 +494,12 @@ class BasicsTest < ActiveRecord::TestCase
 
     def test_utc_as_time_zone_and_new
       with_timezone_config default: :utc do
-        attributes = { "bonus_time(1i)"=>"2000",
-          "bonus_time(2i)"=>"1",
-          "bonus_time(3i)"=>"1",
-          "bonus_time(4i)"=>"10",
-          "bonus_time(5i)"=>"35",
-          "bonus_time(6i)"=>"50" }
+        attributes = { "bonus_time(1i)" => "2000",
+          "bonus_time(2i)" => "1",
+          "bonus_time(3i)" => "1",
+          "bonus_time(4i)" => "10",
+          "bonus_time(5i)" => "35",
+          "bonus_time(6i)" => "50" }
         topic = Topic.new(attributes)
         assert_equal Time.utc(2000, 1, 1, 10, 35, 50), topic.bonus_time
       end
@@ -898,7 +898,7 @@ class BasicsTest < ActiveRecord::TestCase
 
         # fixed dates / times
         assert_equal Date.new(2004, 1, 1), default.fixed_date
-        assert_equal Time.local(2004, 1,1,0,0,0,0), default.fixed_time
+        assert_equal Time.local(2004, 1, 1, 0, 0, 0, 0), default.fixed_time
 
         # char types
         assert_equal "Y", default.char1
@@ -1109,7 +1109,7 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_set_table_name_with_inheritance
-    k = Class.new( ActiveRecord::Base )
+    k = Class.new(ActiveRecord::Base)
     def k.name; "Foo"; end
     def k.table_name; super + "ks"; end
     assert_equal "foosks", k.table_name
@@ -1160,7 +1160,7 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_find_last
-    last  = Developer.last
+    last = Developer.last
     assert_equal last, Developer.all.merge!(order: "id desc").first
   end
 
@@ -1179,17 +1179,17 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_find_ordered_last
-    last  = Developer.all.merge!(order: "developers.salary ASC").last
+    last = Developer.all.merge!(order: "developers.salary ASC").last
     assert_equal last, Developer.all.merge!(order: "developers.salary ASC").to_a.last
   end
 
   def test_find_reverse_ordered_last
-    last  = Developer.all.merge!(order: "developers.salary DESC").last
+    last = Developer.all.merge!(order: "developers.salary DESC").last
     assert_equal last, Developer.all.merge!(order: "developers.salary DESC").to_a.last
   end
 
   def test_find_multiple_ordered_last
-    last  = Developer.all.merge!(order: "developers.name, developers.salary DESC").last
+    last = Developer.all.merge!(order: "developers.name, developers.salary DESC").last
     assert_equal last, Developer.all.merge!(order: "developers.name, developers.salary DESC").to_a.last
   end
 
@@ -1204,7 +1204,7 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_find_symbol_ordered_last
-    last  = Developer.all.merge!(order: :salary).last
+    last = Developer.all.merge!(order: :salary).last
     assert_equal last, Developer.all.merge!(order: :salary).to_a.last
   end
 
@@ -1284,7 +1284,7 @@ class BasicsTest < ActiveRecord::TestCase
   def test_marshal_round_trip
     expected = posts(:welcome)
     marshalled = Marshal.dump(expected)
-    actual   = Marshal.load(marshalled)
+    actual = Marshal.load(marshalled)
 
     assert_equal expected.attributes, actual.attributes
   end
diff --git a/activerecord/test/cases/calculations_test.rb b/activerecord/test/cases/calculations_test.rb
index db2871d383..87e99fb25c 100644
--- a/activerecord/test/cases/calculations_test.rb
+++ b/activerecord/test/cases/calculations_test.rb
@@ -92,14 +92,14 @@ class CalculationsTest < ActiveRecord::TestCase
 
   def test_should_group_by_field
     c = Account.group(:firm_id).sum(:credit_limit)
-    [1,6,2].each do |firm_id|
+    [1, 6, 2].each do |firm_id|
       assert_includes c.keys, firm_id, "Group #{c.inspect} does not contain firm_id #{firm_id}"
     end
   end
 
   def test_should_group_by_arel_attribute
     c = Account.group(Account.arel_table[:firm_id]).sum(:credit_limit)
-    [1,6,2].each do |firm_id|
+    [1, 6, 2].each do |firm_id|
       assert_includes c.keys, firm_id, "Group #{c.inspect} does not contain firm_id #{firm_id}"
     end
   end
@@ -453,7 +453,7 @@ class CalculationsTest < ActiveRecord::TestCase
   def test_should_count_field_in_joined_table_with_group_by
     c = Account.group("accounts.firm_id").joins(:firm).count("companies.id")
 
-    [1,6,2,9].each { |firm_id| assert_includes c.keys, firm_id }
+    [1, 6, 2, 9].each { |firm_id| assert_includes c.keys, firm_id }
   end
 
   def test_should_count_field_of_root_table_with_conflicting_group_by_column
@@ -572,7 +572,7 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_pluck
-    assert_equal [1,2,3,4,5], Topic.order(:id).pluck(:id)
+    assert_equal [1, 2, 3, 4, 5], Topic.order(:id).pluck(:id)
   end
 
   def test_pluck_without_column_names
@@ -608,7 +608,7 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_pluck_with_qualified_column_name
-    assert_equal [1,2,3,4,5], Topic.order(:id).pluck("topics.id")
+    assert_equal [1, 2, 3, 4, 5], Topic.order(:id).pluck("topics.id")
   end
 
   def test_pluck_auto_table_name_prefix
@@ -688,7 +688,7 @@ class CalculationsTest < ActiveRecord::TestCase
 
   def test_pluck_replaces_select_clause
     taks_relation = Topic.select(:approved, :id).order(:id)
-    assert_equal [1,2,3,4,5], taks_relation.pluck(:id)
+    assert_equal [1, 2, 3, 4, 5], taks_relation.pluck(:id)
     assert_equal [false, true, true, true, true], taks_relation.pluck(:approved)
   end
 
diff --git a/activerecord/test/cases/collection_cache_key_test.rb b/activerecord/test/cases/collection_cache_key_test.rb
index a2874438c1..381a78a8e2 100644
--- a/activerecord/test/cases/collection_cache_key_test.rb
+++ b/activerecord/test/cases/collection_cache_key_test.rb
@@ -28,20 +28,20 @@ module ActiveRecord
     end
 
     test "it triggers at most one query" do
-      developers =  Developer.where(name: "David")
+      developers = Developer.where(name: "David")
 
       assert_queries(1) { developers.cache_key }
       assert_queries(0) { developers.cache_key }
     end
 
     test "it doesn't trigger any query if the relation is already loaded" do
-      developers =  Developer.where(name: "David").load
+      developers = Developer.where(name: "David").load
       assert_queries(0) { developers.cache_key }
     end
 
     test "relation cache_key changes when the sql query changes" do
       developers = Developer.where(name: "David")
-      other_relation =  Developer.where(name: "David").where("1 = 1")
+      other_relation = Developer.where(name: "David").where("1 = 1")
 
       assert_not_equal developers.cache_key, other_relation.cache_key
     end
diff --git a/activerecord/test/cases/connection_adapters/connection_handler_test.rb b/activerecord/test/cases/connection_adapters/connection_handler_test.rb
index d5d16e7568..2c33bf22ab 100644
--- a/activerecord/test/cases/connection_adapters/connection_handler_test.rb
+++ b/activerecord/test/cases/connection_adapters/connection_handler_test.rb
@@ -6,7 +6,7 @@ module ActiveRecord
       def setup
         @handler = ConnectionHandler.new
         @spec_name = "primary"
-        @pool    = @handler.establish_connection(ActiveRecord::Base.configurations["arunit"])
+        @pool = @handler.establish_connection(ActiveRecord::Base.configurations["arunit"])
       end
 
       def test_establish_connection_uses_spec_name
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 4bb5c4f2e2..a8955152c3 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
@@ -27,7 +27,7 @@ module ActiveRecord
         ENV["DATABASE_URL"] = "postgres://localhost/foo"
         config   = { "not_production" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
         actual   = resolve_spec(:default_env, config)
-        expected = { "adapter"=>"postgresql", "database"=>"foo", "host"=>"localhost", "name"=>"default_env" }
+        expected = { "adapter" => "postgresql", "database" => "foo", "host" => "localhost", "name" => "default_env" }
         assert_equal expected, actual
       end
 
@@ -37,7 +37,7 @@ module ActiveRecord
 
         config   = { "not_production" => { "adapter" => "not_postgres", "database" => "not_foo" } }
         actual   = resolve_spec(:foo, config)
-        expected = { "adapter" => "postgresql", "database" => "foo", "host" => "localhost","name"=>"foo" }
+        expected = { "adapter" => "postgresql", "database" => "foo", "host" => "localhost", "name" => "foo" }
         assert_equal expected, actual
       end
 
@@ -47,7 +47,7 @@ module ActiveRecord
 
         config   = { "not_production" => { "adapter" => "not_postgres", "database" => "not_foo" } }
         actual   = resolve_spec(:foo, config)
-        expected = { "adapter" => "postgresql", "database" => "foo", "host" => "localhost","name"=>"foo" }
+        expected = { "adapter" => "postgresql", "database" => "foo", "host" => "localhost", "name" => "foo" }
         assert_equal expected, actual
       end
 
@@ -55,13 +55,13 @@ module ActiveRecord
         ENV["DATABASE_URL"] = "postgres://localhost/foo"
         config   = { "production" => { "adapter" => "not_postgres", "database" => "not_foo", "host" => "localhost" } }
         actual   = resolve_spec(:production, config)
-        expected = { "adapter"=>"not_postgres", "database"=>"not_foo", "host"=>"localhost", "name"=>"production" }
+        expected = { "adapter" => "not_postgres", "database" => "not_foo", "host" => "localhost", "name" => "production" }
         assert_equal expected, actual
       end
 
       def test_resolver_with_database_uri_and_unknown_symbol_key
         ENV["DATABASE_URL"] = "postgres://localhost/foo"
-        config   = { "not_production" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
+        config = { "not_production" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
         assert_raises AdapterNotSpecified do
           resolve_spec(:production, config)
         end
@@ -71,7 +71,7 @@ module ActiveRecord
         ENV["DATABASE_URL"] = "not-postgres://not-localhost/not_foo"
         config   = { "production" => {  "adapter" => "also_not_postgres", "database" => "also_not_foo" } }
         actual   = resolve_spec("postgres://localhost/foo", config)
-        expected = { "adapter"=>"postgresql", "database"=>"foo", "host"=>"localhost" }
+        expected = { "adapter" => "postgresql", "database" => "foo", "host" => "localhost" }
         assert_equal expected, actual
       end
 
@@ -85,7 +85,7 @@ module ActiveRecord
         ENV["DATABASE_URL"] = "postgres://localhost/foo"
         config      = { "not_default_env" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
         actual      = resolve_config(config)
-        expect_prod = { "adapter"=>"postgresql", "database"=>"foo", "host"=>"localhost" }
+        expect_prod = { "adapter" => "postgresql", "database" => "foo", "host" => "localhost" }
         assert_equal expect_prod, actual["default_env"]
       end
 
@@ -93,7 +93,7 @@ module ActiveRecord
         ENV["DATABASE_URL"] = "ibm-db://localhost/foo"
         config   = { "default_env" => { "adapter" => "not_postgres", "database" => "not_foo", "host" => "localhost" } }
         actual   = resolve_spec(:default_env, config)
-        expected = { "adapter"=>"ibm_db", "database"=>"foo", "host"=>"localhost", "name"=>"default_env" }
+        expected = { "adapter" => "ibm_db", "database" => "foo", "host" => "localhost", "name" => "default_env" }
         assert_equal expected, actual
       end
 
@@ -213,7 +213,7 @@ module ActiveRecord
         config   = { "default_env" => { "url" => "postgres://localhost/foo" } }
         actual   = resolve_config(config)
         expected = { "default_env" =>
-                    { "adapter"  => "postgresql",
+                    { "adapter" => "postgresql",
                        "database" => "foo",
                        "host"     => "localhost"
                       }
diff --git a/activerecord/test/cases/connection_specification/resolver_test.rb b/activerecord/test/cases/connection_specification/resolver_test.rb
index 0f62c73f8f..13b5bae13c 100644
--- a/activerecord/test/cases/connection_specification/resolver_test.rb
+++ b/activerecord/test/cases/connection_specification/resolver_test.rb
@@ -4,11 +4,11 @@ module ActiveRecord
   module ConnectionAdapters
     class ConnectionSpecification
       class ResolverTest < ActiveRecord::TestCase
-        def resolve(spec, config={})
+        def resolve(spec, config = {})
           Resolver.new(config).resolve(spec)
         end
 
-        def spec(spec, config={})
+        def spec(spec, config = {})
           Resolver.new(config).spec(spec)
         end
 
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index 51563b347c..7eaf31aa24 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -49,22 +49,22 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_with_ids_returning_ordered
-    records = Topic.find([4,2,5])
+    records = Topic.find([4, 2, 5])
     assert_equal "The Fourth Topic of the day", records[0].title
     assert_equal "The Second Topic of the day", records[1].title
     assert_equal "The Fifth Topic of the day", records[2].title
 
-    records = Topic.find(4,2,5)
+    records = Topic.find(4, 2, 5)
     assert_equal "The Fourth Topic of the day", records[0].title
     assert_equal "The Second Topic of the day", records[1].title
     assert_equal "The Fifth Topic of the day", records[2].title
 
-    records = Topic.find(["4","2","5"])
+    records = Topic.find(["4", "2", "5"])
     assert_equal "The Fourth Topic of the day", records[0].title
     assert_equal "The Second Topic of the day", records[1].title
     assert_equal "The Fifth Topic of the day", records[2].title
 
-    records = Topic.find("4","2","5")
+    records = Topic.find("4", "2", "5")
     assert_equal "The Fourth Topic of the day", records[0].title
     assert_equal "The Second Topic of the day", records[1].title
     assert_equal "The Fifth Topic of the day", records[2].title
@@ -72,12 +72,12 @@ class FinderTest < ActiveRecord::TestCase
 
   def test_find_with_ids_and_order_clause
     # The order clause takes precedence over the informed ids
-    records = Topic.order(:author_name).find([5,3,1])
+    records = Topic.order(:author_name).find([5, 3, 1])
     assert_equal "The Third Topic of the day", records[0].title
     assert_equal "The First Topic",            records[1].title
     assert_equal "The Fifth Topic of the day", records[2].title
 
-    records = Topic.order(:id).find([5,3,1])
+    records = Topic.order(:id).find([5, 3, 1])
     assert_equal "The First Topic",            records[0].title
     assert_equal "The Third Topic of the day", records[1].title
     assert_equal "The Fifth Topic of the day", records[2].title
@@ -85,14 +85,14 @@ class FinderTest < ActiveRecord::TestCase
 
   def test_find_with_ids_with_limit_and_order_clause
     # The order clause takes precedence over the informed ids
-    records = Topic.limit(2).order(:id).find([5,3,1])
+    records = Topic.limit(2).order(:id).find([5, 3, 1])
     assert_equal 2, records.size
     assert_equal "The First Topic",            records[0].title
     assert_equal "The Third Topic of the day", records[1].title
   end
 
   def test_find_with_ids_and_limit
-    records = Topic.limit(3).find([3,2,5,1,4])
+    records = Topic.limit(3).find([3, 2, 5, 1, 4])
     assert_equal 3, records.size
     assert_equal "The Third Topic of the day",  records[0].title
     assert_equal "The Second Topic of the day", records[1].title
@@ -102,7 +102,7 @@ class FinderTest < ActiveRecord::TestCase
   def test_find_with_ids_where_and_limit
     # Please note that Topic 1 is the only not approved so
     # if it were among the first 3 it would raise an ActiveRecord::RecordNotFound
-    records = Topic.where(approved: true).limit(3).find([3,2,5,1,4])
+    records = Topic.where(approved: true).limit(3).find([3, 2, 5, 1, 4])
     assert_equal 3, records.size
     assert_equal "The Third Topic of the day",  records[0].title
     assert_equal "The Second Topic of the day", records[1].title
@@ -110,7 +110,7 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_with_ids_and_offset
-    records = Topic.offset(2).find([3,2,5,1,4])
+    records = Topic.offset(2).find([3, 2, 5, 1, 4])
     assert_equal 3, records.size
     assert_equal "The Fifth Topic of the day",  records[0].title
     assert_equal "The First Topic",             records[1].title
@@ -136,7 +136,7 @@ class FinderTest < ActiveRecord::TestCase
   # find should handle strings that come from URLs
   # (example: Category.find(params[:id]))
   def test_find_with_string
-    assert_equal(Topic.find(1).title,Topic.find("1").title)
+    assert_equal(Topic.find(1).title, Topic.find("1").title)
   end
 
   def test_exists
@@ -151,7 +151,7 @@ class FinderTest < ActiveRecord::TestCase
     assert_equal false, Topic.exists?(45)
     assert_equal false, Topic.exists?(Topic.new.id)
 
-    assert_raise(NoMethodError) { Topic.exists?([1,2]) }
+    assert_raise(NoMethodError) { Topic.exists?([1, 2]) }
   end
 
   def test_exists_with_polymorphic_relation
@@ -175,7 +175,7 @@ class FinderTest < ActiveRecord::TestCase
 
   def test_exists_returns_false_when_parameter_has_invalid_type
     assert_equal false, Topic.exists?("foo")
-    assert_equal false, Topic.exists?(("9"*53).to_i) # number that's bigger than int
+    assert_equal false, Topic.exists?(("9" * 53).to_i) # number that's bigger than int
   end
 
   def test_exists_does_not_select_columns_without_alias
@@ -258,8 +258,8 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_by_ids_with_limit_and_offset
-    assert_equal 2, Entrant.limit(2).find([1,3,2]).size
-    entrants = Entrant.limit(3).offset(2).find([1,3,2])
+    assert_equal 2, Entrant.limit(2).find([1, 3, 2]).size
+    entrants = Entrant.limit(3).offset(2).find([1, 3, 2])
     assert_equal 1, entrants.size
     assert_equal "Ruby Guru", entrants.first.name
 
@@ -584,7 +584,7 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_last_on_loaded_relation_should_not_use_sql
-    relation  = Topic.limit(10).load
+    relation = Topic.limit(10).load
     assert_no_queries do
       relation.last
       relation.last(2)
@@ -693,27 +693,27 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_on_hash_conditions_with_range
-    assert_equal [1,2], Topic.where(id: 1..2).to_a.map(&:id).sort
+    assert_equal [1, 2], Topic.where(id: 1..2).to_a.map(&:id).sort
     assert_raise(ActiveRecord::RecordNotFound) { Topic.where(id: 2..3).find(1) }
   end
 
   def test_find_on_hash_conditions_with_end_exclusive_range
-    assert_equal [1,2,3], Topic.where(id: 1..3).to_a.map(&:id).sort
-    assert_equal [1,2], Topic.where(id: 1...3).to_a.map(&:id).sort
+    assert_equal [1, 2, 3], Topic.where(id: 1..3).to_a.map(&:id).sort
+    assert_equal [1, 2], Topic.where(id: 1...3).to_a.map(&:id).sort
     assert_raise(ActiveRecord::RecordNotFound) { Topic.where(id: 2...3).find(3) }
   end
 
   def test_find_on_hash_conditions_with_multiple_ranges
-    assert_equal [1,2,3], Comment.where(id: 1..3, post_id: 1..2).to_a.map(&:id).sort
+    assert_equal [1, 2, 3], Comment.where(id: 1..3, post_id: 1..2).to_a.map(&:id).sort
     assert_equal [1], Comment.where(id: 1..1, post_id: 1..10).to_a.map(&:id).sort
   end
 
   def test_find_on_hash_conditions_with_array_of_integers_and_ranges
-    assert_equal [1,2,3,5,6,7,8,9], Comment.where(id: [1..2, 3, 5, 6..8, 9]).to_a.map(&:id).sort
+    assert_equal [1, 2, 3, 5, 6, 7, 8, 9], Comment.where(id: [1..2, 3, 5, 6..8, 9]).to_a.map(&:id).sort
   end
 
   def test_find_on_hash_conditions_with_array_of_ranges
-    assert_equal [1,2,6,7,8], Comment.where(id: [1..2, 6..8]).to_a.map(&:id).sort
+    assert_equal [1, 2, 6, 7, 8], Comment.where(id: [1..2, 6..8]).to_a.map(&:id).sort
   end
 
   def test_find_on_multiple_hash_conditions
@@ -1029,7 +1029,7 @@ class FinderTest < ActiveRecord::TestCase
 
   def test_find_by_id_with_conditions_with_or
     assert_nothing_raised do
-      Post.where("posts.id <= 3 OR posts.#{QUOTED_TYPE} = 'Post'").find([1,2,3])
+      Post.where("posts.id <= 3 OR posts.#{QUOTED_TYPE} = 'Post'").find([1, 2, 3])
     end
   end
 
@@ -1061,8 +1061,8 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_select_values
-    assert_equal ["1","2","3","4","5","6","7","8","9", "10", "11"], Company.connection.select_values("SELECT id FROM companies ORDER BY id").map!(&:to_s)
-    assert_equal ["37signals","Summit","Microsoft", "Flamboyant Software", "Ex Nihilo", "RailsCore", "Leetsoft", "Jadedpixel", "Odegy", "Ex Nihilo Part Deux", "Apex"], Company.connection.select_values("SELECT name FROM companies ORDER BY id")
+    assert_equal ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11"], Company.connection.select_values("SELECT id FROM companies ORDER BY id").map!(&:to_s)
+    assert_equal ["37signals", "Summit", "Microsoft", "Flamboyant Software", "Ex Nihilo", "RailsCore", "Leetsoft", "Jadedpixel", "Odegy", "Ex Nihilo Part Deux", "Apex"], Company.connection.select_values("SELECT name FROM companies ORDER BY id")
   end
 
   def test_select_rows
@@ -1172,7 +1172,7 @@ class FinderTest < ActiveRecord::TestCase
 
   test "find_by with associations" do
     assert_equal authors(:david), Post.find_by(author: authors(:david)).author
-    assert_equal authors(:mary) , Post.find_by(author: authors(:mary) ).author
+    assert_equal authors(:mary) , Post.find_by(author: authors(:mary)).author
   end
 
   test "find_by doesn't have implicit ordering" do
diff --git a/activerecord/test/cases/fixture_set/file_test.rb b/activerecord/test/cases/fixture_set/file_test.rb
index cf2a73595a..533edcc2e0 100644
--- a/activerecord/test/cases/fixture_set/file_test.rb
+++ b/activerecord/test/cases/fixture_set/file_test.rb
@@ -31,7 +31,7 @@ module ActiveRecord
 
       def test_values
         File.open(::File.join(FIXTURES_ROOT, "accounts.yml")) do |fh|
-          assert_equal [1,2,3,4,5,6].sort, fh.to_a.map(&:last).map { |x|
+          assert_equal [1, 2, 3, 4, 5, 6].sort, fh.to_a.map(&:last).map { |x|
             x["id"]
           }.sort
         end
diff --git a/activerecord/test/cases/fixtures_test.rb b/activerecord/test/cases/fixtures_test.rb
index 3f111447ff..f3d0e4a1b1 100644
--- a/activerecord/test/cases/fixtures_test.rb
+++ b/activerecord/test/cases/fixtures_test.rb
@@ -192,27 +192,27 @@ class FixturesTest < ActiveRecord::TestCase
   end
 
   def test_empty_yaml_fixture
-    assert_not_nil ActiveRecord::FixtureSet.new( Account.connection, "accounts", Account, FIXTURES_ROOT + "/naked/yml/accounts")
+    assert_not_nil ActiveRecord::FixtureSet.new(Account.connection, "accounts", Account, FIXTURES_ROOT + "/naked/yml/accounts")
   end
 
   def test_empty_yaml_fixture_with_a_comment_in_it
-    assert_not_nil ActiveRecord::FixtureSet.new( Account.connection, "companies", Company, FIXTURES_ROOT + "/naked/yml/companies")
+    assert_not_nil ActiveRecord::FixtureSet.new(Account.connection, "companies", Company, FIXTURES_ROOT + "/naked/yml/companies")
   end
 
   def test_nonexistent_fixture_file
     nonexistent_fixture_path = FIXTURES_ROOT + "/imnothere"
 
     #sanity check to make sure that this file never exists
-    assert Dir[nonexistent_fixture_path+"*"].empty?
+    assert Dir[nonexistent_fixture_path + "*"].empty?
 
     assert_raise(Errno::ENOENT) do
-      ActiveRecord::FixtureSet.new( Account.connection, "companies", Company, nonexistent_fixture_path)
+      ActiveRecord::FixtureSet.new(Account.connection, "companies", Company, nonexistent_fixture_path)
     end
   end
 
   def test_dirty_dirty_yaml_file
     assert_raise(ActiveRecord::Fixture::FormatError) do
-      ActiveRecord::FixtureSet.new( Account.connection, "courses", Course, FIXTURES_ROOT + "/naked/yml/courses")
+      ActiveRecord::FixtureSet.new(Account.connection, "courses", Course, FIXTURES_ROOT + "/naked/yml/courses")
     end
   end
 
@@ -948,7 +948,7 @@ end
 class CustomNameForFixtureOrModelTest < ActiveRecord::TestCase
   ActiveRecord::FixtureSet.reset_cache
 
-  set_fixture_class :randomly_named_a9         =>
+  set_fixture_class :randomly_named_a9 =>
                         ClassNameThatDoesNotFollowCONVENTIONS,
                     :'admin/randomly_named_a9' =>
                         Admin::ClassNameThatDoesNotFollowCONVENTIONS1,
diff --git a/activerecord/test/cases/forbidden_attributes_protection_test.rb b/activerecord/test/cases/forbidden_attributes_protection_test.rb
index 75c3493527..ffa3f63e0d 100644
--- a/activerecord/test/cases/forbidden_attributes_protection_test.rb
+++ b/activerecord/test/cases/forbidden_attributes_protection_test.rb
@@ -144,7 +144,7 @@ class ForbiddenAttributesProtectionTest < ActiveRecord::TestCase
   end
 
   def test_strong_params_style_objects_work_with_singular_associations
-    params = ProtectedParams.new( name: "Stern", ship_attributes: ProtectedParams.new(name: "The Black Rock").permit!).permit!
+    params = ProtectedParams.new(name: "Stern", ship_attributes: ProtectedParams.new(name: "The Black Rock").permit!).permit!
     part = ShipPart.new(params)
 
     assert_equal "Stern", part.name
@@ -155,7 +155,7 @@ class ForbiddenAttributesProtectionTest < ActiveRecord::TestCase
     params = ProtectedParams.new(
       trinkets_attributes: ProtectedParams.new(
         "0" => ProtectedParams.new(name: "Necklace").permit!,
-        "1" => ProtectedParams.new(name: "Spoon").permit! ) ).permit!
+        "1" => ProtectedParams.new(name: "Spoon").permit!)).permit!
     part = ShipPart.new(params)
 
     assert_equal "Necklace", part.trinkets[0].name
diff --git a/activerecord/test/cases/json_serialization_test.rb b/activerecord/test/cases/json_serialization_test.rb
index b06fed4f0d..a2150483f3 100644
--- a/activerecord/test/cases/json_serialization_test.rb
+++ b/activerecord/test/cases/json_serialization_test.rb
@@ -102,7 +102,7 @@ class JsonSerializationTest < ActiveRecord::TestCase
   end
 
   def test_uses_serializable_hash_with_only_option
-    def @contact.serializable_hash(options=nil)
+    def @contact.serializable_hash(options = nil)
       super(only: %w(name))
     end
 
@@ -113,7 +113,7 @@ class JsonSerializationTest < ActiveRecord::TestCase
   end
 
   def test_uses_serializable_hash_with_except_option
-    def @contact.serializable_hash(options=nil)
+    def @contact.serializable_hash(options = nil)
       super(except: %w(age))
     end
 
@@ -137,7 +137,7 @@ class JsonSerializationTest < ActiveRecord::TestCase
     @contact = ContactSti.new(@contact.attributes)
     assert_equal "ContactSti", @contact.type
 
-    def @contact.serializable_hash(options={})
+    def @contact.serializable_hash(options = {})
       super({ except: %w(age) }.merge!(options))
     end
 
diff --git a/activerecord/test/cases/locking_test.rb b/activerecord/test/cases/locking_test.rb
index 0579df0a07..9b0ec54aa7 100644
--- a/activerecord/test/cases/locking_test.rb
+++ b/activerecord/test/cases/locking_test.rb
@@ -470,7 +470,7 @@ class OptimisticLockingWithSchemaChangeTest < ActiveRecord::TestCase
 
   private
 
-    def add_counter_column_to(model, col="test_count")
+    def add_counter_column_to(model, col = "test_count")
       model.connection.add_column model.table_name, col, :integer, null: false, default: 0
       model.reset_column_information
     end
diff --git a/activerecord/test/cases/migration/references_statements_test.rb b/activerecord/test/cases/migration/references_statements_test.rb
index 8fbe60f24e..df15d7cb45 100644
--- a/activerecord/test/cases/migration/references_statements_test.rb
+++ b/activerecord/test/cases/migration/references_statements_test.rb
@@ -57,7 +57,7 @@ module ActiveRecord
 
       def test_creates_named_unique_index
         add_reference table_name, :tag, index: { name: "index_taggings_on_tag_id", unique: true }
-        assert index_exists?(table_name, :tag_id, name: "index_taggings_on_tag_id", unique: true )
+        assert index_exists?(table_name, :tag_id, name: "index_taggings_on_tag_id", unique: true)
       end
 
       def test_creates_reference_id_with_specified_type
diff --git a/activerecord/test/cases/migration_test.rb b/activerecord/test/cases/migration_test.rb
index 151f3c8efd..22484ad678 100644
--- a/activerecord/test/cases/migration_test.rb
+++ b/activerecord/test/cases/migration_test.rb
@@ -388,7 +388,7 @@ class MigrationTest < ActiveRecord::TestCase
     original_rails_env  = ENV["RAILS_ENV"]
     original_rack_env   = ENV["RACK_ENV"]
     ENV["RAILS_ENV"]    = ENV["RACK_ENV"] = "foofoo"
-    new_env     = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+    new_env = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
 
     refute_equal current_env, new_env
 
@@ -413,7 +413,7 @@ class MigrationTest < ActiveRecord::TestCase
     original_rails_env  = ENV["RAILS_ENV"]
     original_rack_env   = ENV["RACK_ENV"]
     ENV["RAILS_ENV"]    = ENV["RACK_ENV"] = "foofoo"
-    new_env     = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+    new_env = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
 
     refute_equal current_env, new_env
 
@@ -429,14 +429,14 @@ class MigrationTest < ActiveRecord::TestCase
 
   def test_internal_metadata_stores_environment_when_other_data_exists
     ActiveRecord::InternalMetadata.delete_all
-    ActiveRecord::InternalMetadata[:foo]  = "bar"
+    ActiveRecord::InternalMetadata[:foo] = "bar"
 
     current_env     = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
     migrations_path = MIGRATIONS_ROOT + "/valid"
     old_path        = ActiveRecord::Migrator.migrations_paths
     ActiveRecord::Migrator.migrations_paths = migrations_path
 
-    current_env     = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+    current_env = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
     ActiveRecord::Migrator.up(migrations_path)
     assert_equal current_env, ActiveRecord::InternalMetadata[:environment]
     assert_equal "bar", ActiveRecord::InternalMetadata[:foo]
diff --git a/activerecord/test/cases/migrator_test.rb b/activerecord/test/cases/migrator_test.rb
index 1ba18bc9c2..b775bf0492 100644
--- a/activerecord/test/cases/migrator_test.rb
+++ b/activerecord/test/cases/migrator_test.rb
@@ -11,7 +11,7 @@ class MigratorTest < ActiveRecord::TestCase
 
     def initialize(name = self.class.name, version = nil)
       super
-      @went_up  = false
+      @went_up = false
       @went_down = false
     end
 
@@ -344,10 +344,10 @@ class MigratorTest < ActiveRecord::TestCase
     _, migrator = migrator_class(3)
 
     migrator.migrate("valid")
-    assert_equal([1,2,3], ActiveRecord::Migrator.get_all_versions)
+    assert_equal([1, 2, 3], ActiveRecord::Migrator.get_all_versions)
 
     migrator.rollback("valid")
-    assert_equal([1,2], ActiveRecord::Migrator.get_all_versions)
+    assert_equal([1, 2], ActiveRecord::Migrator.get_all_versions)
 
     migrator.rollback("valid")
     assert_equal([1], ActiveRecord::Migrator.get_all_versions)
@@ -368,7 +368,7 @@ class MigratorTest < ActiveRecord::TestCase
     def sensors(count)
       calls = []
       migrations = count.times.map { |i|
-        m(nil, i + 1) { |c,migration|
+        m(nil, i + 1) { |c, migration|
           calls << [c, migration.version]
         }
       }
diff --git a/activerecord/test/cases/multiparameter_attributes_test.rb b/activerecord/test/cases/multiparameter_attributes_test.rb
index b2f76398df..18ecc67f0b 100644
--- a/activerecord/test/cases/multiparameter_attributes_test.rb
+++ b/activerecord/test/cases/multiparameter_attributes_test.rb
@@ -280,14 +280,14 @@ class MultiParameterAttributeTest < ActiveRecord::TestCase
 
   unless current_adapter? :OracleAdapter
     def test_multiparameter_attributes_setting_time_attribute
-      topic = Topic.new( "bonus_time(4i)"=> "01", "bonus_time(5i)" => "05" )
+      topic = Topic.new("bonus_time(4i)" => "01", "bonus_time(5i)" => "05")
       assert_equal 1, topic.bonus_time.hour
       assert_equal 5, topic.bonus_time.min
     end
   end
 
   def test_multiparameter_attributes_setting_date_attribute
-    topic = Topic.new( "written_on(1i)" => "1952", "written_on(2i)" => "3", "written_on(3i)" => "11" )
+    topic = Topic.new("written_on(1i)" => "1952", "written_on(2i)" => "3", "written_on(3i)" => "11")
     assert_equal 1952, topic.written_on.year
     assert_equal 3, topic.written_on.month
     assert_equal 11, topic.written_on.day
@@ -308,8 +308,8 @@ class MultiParameterAttributeTest < ActiveRecord::TestCase
   end
 
   def test_multiparameter_attributes_setting_time_but_not_date_on_date_field
-    assert_raise( ActiveRecord::MultiparameterAssignmentErrors ) do
-      Topic.new( "written_on(4i)" => "13", "written_on(5i)" => "55" )
+    assert_raise(ActiveRecord::MultiparameterAssignmentErrors) do
+      Topic.new("written_on(4i)" => "13", "written_on(5i)" => "55")
     end
   end
 
diff --git a/activerecord/test/cases/nested_attributes_test.rb b/activerecord/test/cases/nested_attributes_test.rb
index a9c3733c20..b87419d203 100644
--- a/activerecord/test/cases/nested_attributes_test.rb
+++ b/activerecord/test/cases/nested_attributes_test.rb
@@ -971,7 +971,7 @@ 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 } } }
@@ -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
diff --git a/activerecord/test/cases/nested_attributes_with_callbacks_test.rb b/activerecord/test/cases/nested_attributes_with_callbacks_test.rb
index 8954e8c7e3..350a966d40 100644
--- a/activerecord/test/cases/nested_attributes_with_callbacks_test.rb
+++ b/activerecord/test/cases/nested_attributes_with_callbacks_test.rb
@@ -5,13 +5,13 @@ require "models/bird"
 class NestedAttributesWithCallbacksTest < ActiveRecord::TestCase
   Pirate.has_many(:birds_with_add_load,
                   class_name: "Bird",
-                  before_add: proc { |p,b|
+                  before_add: proc { |p, b|
                     @@add_callback_called << b
                     p.birds_with_add_load.to_a
                   })
   Pirate.has_many(:birds_with_add,
                   class_name: "Bird",
-                  before_add: proc { |p,b| @@add_callback_called << b })
+                  before_add: proc { |p, b| @@add_callback_called << b })
 
   Pirate.accepts_nested_attributes_for(:birds_with_add_load,
                                        :birds_with_add,
@@ -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
@@ -37,7 +37,7 @@ class NestedAttributesWithCallbacksTest < ActiveRecord::TestCase
 
   def existing_birds_attributes
     @birds.map do |bird|
-      bird.attributes.slice("id","name")
+      bird.attributes.slice("id", "name")
     end
   end
 
diff --git a/activerecord/test/cases/persistence_test.rb b/activerecord/test/cases/persistence_test.rb
index 688c3ed2b1..f667e9b055 100644
--- a/activerecord/test/cases/persistence_test.rb
+++ b/activerecord/test/cases/persistence_test.rb
@@ -967,7 +967,7 @@ class PersistenceTest < ActiveRecord::TestCase
         self.table_name = :widgets
       end
 
-      instance  = widget.create!(
+      instance = widget.create!(
         name: "Bob",
         created_at: 1.day.ago,
         updated_at: 1.day.ago)
diff --git a/activerecord/test/cases/primary_keys_test.rb b/activerecord/test/cases/primary_keys_test.rb
index 31d612abd1..eaaf50d14f 100644
--- a/activerecord/test/cases/primary_keys_test.rb
+++ b/activerecord/test/cases/primary_keys_test.rb
@@ -120,7 +120,7 @@ class PrimaryKeysTest < ActiveRecord::TestCase
     assert_nothing_raised { MixedCaseMonkey.find(1) }
   end
   def test_find_with_multiple_ids_should_quote_pkey
-    assert_nothing_raised { MixedCaseMonkey.find([1,2]) }
+    assert_nothing_raised { MixedCaseMonkey.find([1, 2]) }
   end
   def test_instance_update_should_quote_pkey
     assert_nothing_raised { MixedCaseMonkey.find(1).save }
@@ -154,7 +154,7 @@ class PrimaryKeysTest < ActiveRecord::TestCase
   end
 
   def test_quoted_primary_key_after_set_primary_key
-    k = Class.new( ActiveRecord::Base )
+    k = Class.new(ActiveRecord::Base)
     assert_equal k.connection.quote_column_name("id"), k.quoted_primary_key
     k.primary_key = "foo"
     assert_equal k.connection.quote_column_name("foo"), k.quoted_primary_key
diff --git a/activerecord/test/cases/relation/where_test.rb b/activerecord/test/cases/relation/where_test.rb
index 925af49ffe..ed8ffddcf5 100644
--- a/activerecord/test/cases/relation/where_test.rb
+++ b/activerecord/test/cases/relation/where_test.rb
@@ -64,12 +64,12 @@ module ActiveRecord
     end
 
     def test_belongs_to_array_value_where
-      assert_equal Post.where(author_id: [1,2]).to_sql, Post.where(author: [1,2]).to_sql
+      assert_equal Post.where(author_id: [1, 2]).to_sql, Post.where(author: [1, 2]).to_sql
     end
 
     def test_belongs_to_nested_relation_where
-      expected = Post.where(author_id: Author.where(id: [1,2])).to_sql
-      actual   = Post.where(author:    Author.where(id: [1,2])).to_sql
+      expected = Post.where(author_id: Author.where(id: [1, 2])).to_sql
+      actual   = Post.where(author:    Author.where(id: [1, 2])).to_sql
 
       assert_equal expected, actual
     end
@@ -87,7 +87,7 @@ module ActiveRecord
     def test_belongs_to_nested_where_with_relation
       author = authors(:david)
 
-      expected = Author.where(id: author ).joins(:posts)
+      expected = Author.where(id: author).joins(:posts)
       actual   = Author.where(posts: { author_id: Author.where(id: author.id) }).joins(:posts)
 
       assert_equal expected.to_a, actual.to_a
@@ -127,8 +127,8 @@ module ActiveRecord
     end
 
     def test_polymorphic_nested_relation_where
-      expected = PriceEstimate.where(estimate_of_type: "Treasure", estimate_of_id: Treasure.where(id: [1,2]))
-      actual   = PriceEstimate.where(estimate_of: Treasure.where(id: [1,2]))
+      expected = PriceEstimate.where(estimate_of_type: "Treasure", estimate_of_id: Treasure.where(id: [1, 2]))
+      actual   = PriceEstimate.where(estimate_of: Treasure.where(id: [1, 2]))
 
       assert_equal expected.to_sql, actual.to_sql
     end
diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
index 23d27ab90a..d5af0cc9a5 100644
--- a/activerecord/test/cases/relation_test.rb
+++ b/activerecord/test/cases/relation_test.rb
@@ -159,7 +159,7 @@ module ActiveRecord
       relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
       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
 
@@ -224,7 +224,7 @@ module ActiveRecord
     def test_relation_merging_with_merged_joins_as_symbols
       special_comments_with_ratings = SpecialComment.joins(:ratings)
       posts_with_special_comments_with_ratings = Post.group("posts.id").joins(:special_comments).merge(special_comments_with_ratings)
-      assert_equal({ 2=>1, 4=>3, 5=>1 }, authors(:david).posts.merge(posts_with_special_comments_with_ratings).count)
+      assert_equal({ 2 => 1, 4 => 3, 5 => 1 }, authors(:david).posts.merge(posts_with_special_comments_with_ratings).count)
     end
 
     def test_relation_merging_with_joins_as_join_dependency_pick_proper_parent
@@ -274,7 +274,7 @@ module ActiveRecord
       join_string = "LEFT OUTER JOIN #{Rating.quoted_table_name} ON #{SpecialComment.quoted_table_name}.id = #{Rating.quoted_table_name}.comment_id"
       special_comments_with_ratings = SpecialComment.joins join_string
       posts_with_special_comments_with_ratings = Post.group("posts.id").joins(:special_comments).merge(special_comments_with_ratings)
-      assert_equal({ 2=>1, 4=>3, 5=>1 }, authors(:david).posts.merge(posts_with_special_comments_with_ratings).count)
+      assert_equal({ 2 => 1, 4 => 3, 5 => 1 }, authors(:david).posts.merge(posts_with_special_comments_with_ratings).count)
     end
 
     class EnsureRoundTripTypeCasting < ActiveRecord::Type::Value
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index 2e18c43b1b..0501514ba9 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -184,14 +184,14 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_select_with_subquery_in_from_does_not_use_original_table_name
     relation = Comment.group(:type).select("COUNT(post_id) AS post_count, type")
-    subquery = Comment.from(relation).select("type","post_count")
-    assert_equal(relation.map(&:post_count).sort,subquery.map(&:post_count).sort)
+    subquery = Comment.from(relation).select("type", "post_count")
+    assert_equal(relation.map(&:post_count).sort, subquery.map(&:post_count).sort)
   end
 
   def test_group_with_subquery_in_from_does_not_use_original_table_name
     relation = Comment.group(:type).select("COUNT(post_id) AS post_count,type")
     subquery = Comment.from(relation).group("type").average("post_count")
-    assert_equal(relation.map(&:post_count).sort,subquery.values.sort)
+    assert_equal(relation.map(&:post_count).sort, subquery.values.sort)
   end
 
   def test_finding_with_conditions
@@ -291,7 +291,7 @@ class RelationTest < ActiveRecord::TestCase
     assert_includes Topic.order(id: "DESC").to_sql, "DESC"
     assert_includes Topic.order(id: "desc").to_sql, "DESC"
     assert_includes Topic.order(id: :DESC).to_sql, "DESC"
-    assert_includes Topic.order(id: :desc).to_sql,"DESC"
+    assert_includes Topic.order(id: :desc).to_sql, "DESC"
   end
 
   def test_raising_exception_on_invalid_hash_params
@@ -365,7 +365,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_finding_with_sanitized_order
-    query = Tag.order(["field(id, ?)", [1,3,2]]).to_sql
+    query = Tag.order(["field(id, ?)", [1, 3, 2]]).to_sql
     assert_match(/field\(id, 1,3,2\)/, query)
 
     query = Tag.order(["field(id, ?)", []]).to_sql
@@ -458,55 +458,55 @@ class RelationTest < ActiveRecord::TestCase
   def test_null_relation_sum
     ac = Aircraft.new
     assert_equal Hash.new, ac.engines.group(:id).sum(:id)
-    assert_equal        0, ac.engines.count
+    assert_equal 0, ac.engines.count
     ac.save
     assert_equal Hash.new, ac.engines.group(:id).sum(:id)
-    assert_equal        0, ac.engines.count
+    assert_equal 0, ac.engines.count
   end
 
   def test_null_relation_count
     ac = Aircraft.new
     assert_equal Hash.new, ac.engines.group(:id).count
-    assert_equal        0, ac.engines.count
+    assert_equal 0, ac.engines.count
     ac.save
     assert_equal Hash.new, ac.engines.group(:id).count
-    assert_equal        0, ac.engines.count
+    assert_equal 0, ac.engines.count
   end
 
   def test_null_relation_size
     ac = Aircraft.new
     assert_equal Hash.new, ac.engines.group(:id).size
-    assert_equal        0, ac.engines.size
+    assert_equal 0, ac.engines.size
     ac.save
     assert_equal Hash.new, ac.engines.group(:id).size
-    assert_equal        0, ac.engines.size
+    assert_equal 0, ac.engines.size
   end
 
   def test_null_relation_average
     ac = Aircraft.new
     assert_equal Hash.new, ac.engines.group(:car_id).average(:id)
-    assert_equal        nil, ac.engines.average(:id)
+    assert_equal nil, ac.engines.average(:id)
     ac.save
     assert_equal Hash.new, ac.engines.group(:car_id).average(:id)
-    assert_equal        nil, ac.engines.average(:id)
+    assert_equal nil, ac.engines.average(:id)
   end
 
   def test_null_relation_minimum
     ac = Aircraft.new
     assert_equal Hash.new, ac.engines.group(:car_id).minimum(:id)
-    assert_equal        nil, ac.engines.minimum(:id)
+    assert_equal nil, ac.engines.minimum(:id)
     ac.save
     assert_equal Hash.new, ac.engines.group(:car_id).minimum(:id)
-    assert_equal        nil, ac.engines.minimum(:id)
+    assert_equal nil, ac.engines.minimum(:id)
   end
 
   def test_null_relation_maximum
     ac = Aircraft.new
     assert_equal Hash.new, ac.engines.group(:car_id).maximum(:id)
-    assert_equal        nil, ac.engines.maximum(:id)
+    assert_equal nil, ac.engines.maximum(:id)
     ac.save
     assert_equal Hash.new, ac.engines.group(:car_id).maximum(:id)
-    assert_equal        nil, ac.engines.maximum(:id)
+    assert_equal nil, ac.engines.maximum(:id)
   end
 
   def test_null_relation_in_where_condition
@@ -979,7 +979,7 @@ class RelationTest < ActiveRecord::TestCase
     assert ! davids.exists?(42)
     assert ! davids.exists?(davids.new.id)
 
-    fake  = Author.where(name: "fake author")
+    fake = Author.where(name: "fake author")
     assert ! fake.exists?
     assert ! fake.exists?(authors(:david).id)
   end
@@ -1964,7 +1964,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_unscope_removes_binds
-    left  = Post.where(id: Arel::Nodes::BindParam.new)
+    left = Post.where(id: Arel::Nodes::BindParam.new)
     column = Post.columns_hash["id"]
     left.bind_values += [[column, 20]]
 
@@ -1973,8 +1973,8 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_merging_removes_rhs_bind_parameters
-    left  = Post.where(id: 20)
-    right   = Post.where(id: [1,2,3,4])
+    left = Post.where(id: 20)
+    right = Post.where(id: [1, 2, 3, 4])
 
     merged = left.merge(right)
     assert_equal [], merged.bind_values
diff --git a/activerecord/test/cases/sanitize_test.rb b/activerecord/test/cases/sanitize_test.rb
index 464bb12ccb..23bcb0af1e 100644
--- a/activerecord/test/cases/sanitize_test.rb
+++ b/activerecord/test/cases/sanitize_test.rb
@@ -12,8 +12,8 @@ class SanitizeTest < ActiveRecord::TestCase
     assert_equal "name='#{quoted_bambi}'", Binary.send(:sanitize_sql_array, ["name='%s'", "Bambi"])
     assert_equal "name='#{quoted_bambi}'", Binary.send(:sanitize_sql_array, ["name='%s'", "Bambi".mb_chars])
     quoted_bambi_and_thumper = ActiveRecord::Base.connection.quote_string("Bambi\nand\nThumper")
-    assert_equal "name='#{quoted_bambi_and_thumper}'",Binary.send(:sanitize_sql_array, ["name='%s'", "Bambi\nand\nThumper"])
-    assert_equal "name='#{quoted_bambi_and_thumper}'",Binary.send(:sanitize_sql_array, ["name='%s'", "Bambi\nand\nThumper".mb_chars])
+    assert_equal "name='#{quoted_bambi_and_thumper}'", Binary.send(:sanitize_sql_array, ["name='%s'", "Bambi\nand\nThumper"])
+    assert_equal "name='#{quoted_bambi_and_thumper}'", Binary.send(:sanitize_sql_array, ["name='%s'", "Bambi\nand\nThumper".mb_chars])
   end
 
   def test_sanitize_sql_array_handles_bind_variables
diff --git a/activerecord/test/cases/schema_dumper_test.rb b/activerecord/test/cases/schema_dumper_test.rb
index ae3a5651a1..007f976f2e 100644
--- a/activerecord/test/cases/schema_dumper_test.rb
+++ b/activerecord/test/cases/schema_dumper_test.rb
@@ -451,7 +451,7 @@ class SchemaDumperDefaultsTest < ActiveRecord::TestCase
 
   def test_schema_dump_with_float_column_infinity_default
     skip unless current_adapter?(:PostgreSQLAdapter)
-    output = dump_table_schema('infinity_defaults')
+    output = dump_table_schema("infinity_defaults")
     assert_match %r{t\.float\s+"float_with_inf_default",\s+default: ::Float::INFINITY}, output
     assert_match %r{t\.float\s+"float_with_nan_default",\s+default: ::Float::NAN}, output
   end
diff --git a/activerecord/test/cases/schema_loading_test.rb b/activerecord/test/cases/schema_loading_test.rb
index 3d92a5e104..362370ac61 100644
--- a/activerecord/test/cases/schema_loading_test.rb
+++ b/activerecord/test/cases/schema_loading_test.rb
@@ -8,7 +8,7 @@ module SchemaLoadCounter
 
     def load_schema!
       self.load_schema_calls ||= 0
-      self.load_schema_calls +=1
+      self.load_schema_calls += 1
       super
     end
   end
diff --git a/activerecord/test/cases/scoping/named_scoping_test.rb b/activerecord/test/cases/scoping/named_scoping_test.rb
index 58e1310ab0..995ff4dfc5 100644
--- a/activerecord/test/cases/scoping/named_scoping_test.rb
+++ b/activerecord/test/cases/scoping/named_scoping_test.rb
@@ -119,8 +119,8 @@ class NamedScopingTest < ActiveRecord::TestCase
   end
 
   def test_scope_with_STI
-    assert_equal 3,Post.containing_the_letter_a.count
-    assert_equal 1,SpecialPost.containing_the_letter_a.count
+    assert_equal 3, Post.containing_the_letter_a.count
+    assert_equal 1, SpecialPost.containing_the_letter_a.count
   end
 
   def test_has_many_through_associations_have_access_to_scopes
diff --git a/activerecord/test/cases/scoping/relation_scoping_test.rb b/activerecord/test/cases/scoping/relation_scoping_test.rb
index 27b4583457..47310a151e 100644
--- a/activerecord/test/cases/scoping/relation_scoping_test.rb
+++ b/activerecord/test/cases/scoping/relation_scoping_test.rb
@@ -28,7 +28,7 @@ class RelationScopingTest < ActiveRecord::TestCase
   def test_scope_breaks_caching_on_collections
     author = authors :david
     ids = author.reload.special_posts_with_default_scope.map(&:id)
-    assert_equal [1,5,6], ids.sort
+    assert_equal [1, 5, 6], ids.sort
     scoped_posts = SpecialPostWithDefaultScope.unscoped do
       author = authors :david
       author.reload.special_posts_with_default_scope.to_a
diff --git a/activerecord/test/cases/serialized_attribute_test.rb b/activerecord/test/cases/serialized_attribute_test.rb
index bebd856faf..1ccbf3ed4a 100644
--- a/activerecord/test/cases/serialized_attribute_test.rb
+++ b/activerecord/test/cases/serialized_attribute_test.rb
@@ -107,7 +107,7 @@ class SerializedAttributeTest < ActiveRecord::TestCase
   end
 
   def test_serialized_time_attribute
-    myobj = Time.local(2008,1,1,1,0)
+    myobj = Time.local(2008, 1, 1, 1, 0)
     topic = Topic.create("content" => myobj).reload
     assert_equal(myobj, topic.content)
   end
diff --git a/activerecord/test/cases/tasks/database_tasks_test.rb b/activerecord/test/cases/tasks/database_tasks_test.rb
index d847a02679..d03231e711 100644
--- a/activerecord/test/cases/tasks/database_tasks_test.rb
+++ b/activerecord/test/cases/tasks/database_tasks_test.rb
@@ -24,7 +24,7 @@ module ActiveRecord
     sqlite3:    :sqlite_tasks
   }
 
-  class DatabaseTasksUtilsTask< ActiveRecord::TestCase
+  class DatabaseTasksUtilsTask < ActiveRecord::TestCase
     def test_raises_an_error_when_called_with_protected_environment
       ActiveRecord::Migrator.stubs(:current_version).returns(1)
 
diff --git a/activerecord/test/cases/test_case.rb b/activerecord/test/cases/test_case.rb
index a4fc69fcd3..31b11c19f7 100644
--- a/activerecord/test/cases/test_case.rb
+++ b/activerecord/test/cases/test_case.rb
@@ -63,11 +63,11 @@ module ActiveRecord
       assert_queries(0, options, &block)
     end
 
-    def assert_column(model, column_name, msg=nil)
+    def assert_column(model, column_name, msg = nil)
       assert has_column?(model, column_name), msg
     end
 
-    def assert_no_column(model, column_name, msg=nil)
+    def assert_no_column(model, column_name, msg = nil)
       assert_not has_column?(model, column_name), msg
     end
 
diff --git a/activerecord/test/cases/transaction_callbacks_test.rb b/activerecord/test/cases/transaction_callbacks_test.rb
index bd50fe55e9..dba100f5c9 100644
--- a/activerecord/test/cases/transaction_callbacks_test.rb
+++ b/activerecord/test/cases/transaction_callbacks_test.rb
@@ -243,14 +243,14 @@ class TransactionCallbacksTest < ActiveRecord::TestCase
   end
 
   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
+    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) }
 
     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
+    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) }
 
@@ -269,8 +269,8 @@ class TransactionCallbacksTest < ActiveRecord::TestCase
   end
 
   def test_only_call_after_rollback_on_records_rolled_back_to_a_savepoint_when_release_savepoint_fails
-    def @first.rollbacks(i=0); @rollbacks ||= 0; @rollbacks += i if i; end
-    def @first.commits(i=0); @commits ||= 0; @commits += i if i; end
+    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) }
diff --git a/activerecord/test/cases/transactions_test.rb b/activerecord/test/cases/transactions_test.rb
index 834365660f..9b1cca8583 100644
--- a/activerecord/test/cases/transactions_test.rb
+++ b/activerecord/test/cases/transactions_test.rb
@@ -98,7 +98,7 @@ class TransactionTest < ActiveRecord::TestCase
     end
 
     Topic.transaction do
-      @first.approved  = true
+      @first.approved = true
       @first.save!
     end
 
@@ -160,7 +160,7 @@ class TransactionTest < ActiveRecord::TestCase
     assert !@first.approved
 
     Topic.transaction do
-      @first.approved  = true
+      @first.approved = true
       @first.save!
     end
     assert !Topic.find(@first.id).approved?, "Should not commit the approved flag"
@@ -443,16 +443,16 @@ class TransactionTest < ActiveRecord::TestCase
 
   def test_using_named_savepoints
     Topic.transaction do
-      @first.approved  = true
+      @first.approved = true
       @first.save!
       Topic.connection.create_savepoint("first")
 
-      @first.approved  = false
+      @first.approved = false
       @first.save!
       Topic.connection.rollback_to_savepoint("first")
       assert @first.reload.approved?
 
-      @first.approved  = false
+      @first.approved = false
       @first.save!
       Topic.connection.release_savepoint("first")
       assert_not @first.reload.approved?
diff --git a/activerecord/test/cases/validations/association_validation_test.rb b/activerecord/test/cases/validations/association_validation_test.rb
index 66d6ecb928..f5ceb27d97 100644
--- a/activerecord/test/cases/validations/association_validation_test.rb
+++ b/activerecord/test/cases/validations/association_validation_test.rb
@@ -26,7 +26,7 @@ class AssociationValidationTest < ActiveRecord::TestCase
 
   def test_validates_associated_one
     Reply.validates :topic, associated: true
-    Topic.validates_presence_of( :content )
+    Topic.validates_presence_of(:content)
     r = Reply.new("title" => "A reply", "content" => "with content!")
     r.topic = Topic.create("title" => "uhohuhoh")
     assert !r.valid?
diff --git a/activerecord/test/models/admin/user.rb b/activerecord/test/models/admin/user.rb
index 2e703f6219..a76e4b6795 100644
--- a/activerecord/test/models/admin/user.rb
+++ b/activerecord/test/models/admin/user.rb
@@ -22,11 +22,11 @@ class Admin::User < ActiveRecord::Base
   store :json_data_empty, accessors: [ :is_a_good_guy ], coder: Coder.new
 
   def phone_number
-    read_store_attribute(:settings, :phone_number).gsub(/(\d{3})(\d{3})(\d{4})/,'(\1) \2-\3')
+    read_store_attribute(:settings, :phone_number).gsub(/(\d{3})(\d{3})(\d{4})/, '(\1) \2-\3')
   end
 
   def phone_number=(value)
-    write_store_attribute(:settings, :phone_number, value && value.gsub(/[^\d]/,""))
+    write_store_attribute(:settings, :phone_number, value && value.gsub(/[^\d]/, ""))
   end
 
   def color
diff --git a/activerecord/test/models/company.rb b/activerecord/test/models/company.rb
index 025630087c..4561b3132b 100644
--- a/activerecord/test/models/company.rb
+++ b/activerecord/test/models/company.rb
@@ -151,7 +151,7 @@ class Client < Company
   # is calling client.destroy, deleting from the database, or setting
   # foreign keys to NULL.
   def self.destroyed_client_ids
-    @destroyed_client_ids ||= Hash.new { |h,k| h[k] = [] }
+    @destroyed_client_ids ||= Hash.new { |h, k| h[k] = [] }
   end
 
   before_destroy do |client|
@@ -199,7 +199,7 @@ class Account < ActiveRecord::Base
   alias_attribute :available_credit, :credit_limit
 
   def self.destroyed_account_ids
-    @destroyed_account_ids ||= Hash.new { |h,k| h[k] = [] }
+    @destroyed_account_ids ||= Hash.new { |h, k| h[k] = [] }
   end
 
   # Test private kernel method through collection proxy using has_many.
diff --git a/activerecord/test/models/pirate.rb b/activerecord/test/models/pirate.rb
index 2dc8f9bd84..c532ab426e 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 66a99cbcda..e74aedb814 100644
--- a/activerecord/test/models/post.rb
+++ b/activerecord/test/models/post.rb
@@ -47,7 +47,7 @@ class Post < ActiveRecord::Base
 
   scope :typographically_interesting, -> { containing_the_letter_a.or(titled_with_an_apostrophe) }
 
-  has_many   :comments do
+  has_many :comments do
     def find_most_recent
       order("id DESC").first
     end
@@ -168,7 +168,7 @@ class Post < ActiveRecord::Base
     @log = []
   end
 
-  def self.log(message=nil, side=nil, new_record=nil)
+  def self.log(message = nil, side = nil, new_record = nil)
     return @log if message.nil?
     @log << [message, side, new_record]
   end
@@ -231,7 +231,7 @@ end
 class SpecialPostWithDefaultScope < ActiveRecord::Base
   self.inheritance_column = :disabled
   self.table_name = "posts"
-  default_scope { where(id: [1, 5,6]) }
+  default_scope { where(id: [1, 5, 6]) }
 end
 
 class PostThatLoadsCommentsInAnAfterSaveHook < ActiveRecord::Base