activerecord 6.1.3.2 → 7.0.0.alpha2

data/lib/active_record/integration.rb

@@ -177,7 +177,7 @@ module ActiveRecord
       def can_use_fast_cache_version?(timestamp)
         timestamp.is_a?(String) &&
           cache_timestamp_format == :usec &&
-          default_timezone == :utc &&
+          ActiveRecord.default_timezone == :utc &&
           !updated_at_came_from_user?
       end
 

data/lib/active_record/internal_metadata.rb

@@ -10,15 +10,13 @@ module ActiveRecord
   # This is enabled by default. To disable this functionality set
   # `use_metadata_table` to false in your database configuration.
   class InternalMetadata < ActiveRecord::Base # :nodoc:
+    self.record_timestamps = true
+
     class << self
       def enabled?
         ActiveRecord::Base.connection.use_metadata_table?
       end
 
-      def _internal?
-        true
-      end
-
       def primary_key
         "key"
       end
@@ -36,7 +34,7 @@ module ActiveRecord
       def [](key)
         return unless enabled?
 
-        where(key: key).pluck(:value).first
+        where(key: key).pick(:value)
       end
 
       # Creates an internal metadata table with columns +key+ and +value+

data/lib/active_record/legacy_yaml_adapter.rb

@@ -10,7 +10,7 @@ module ActiveRecord
       else
         ActiveSupport::Deprecation.warn(<<-MSG.squish)
           YAML loading from legacy format older than Rails 5.0 is deprecated
-          and will be removed in Rails 6.2.
+          and will be removed in Rails 7.0.
         MSG
         if coder["attributes"].is_a?(ActiveModel::AttributeSet)
           Rails420.convert(klass, coder)

data/lib/active_record/locking/optimistic.rb

@@ -56,11 +56,11 @@ module ActiveRecord
         class_attribute :lock_optimistically, instance_writer: false, default: true
       end
 
-      def locking_enabled? #:nodoc:
+      def locking_enabled? # :nodoc:
         self.class.locking_enabled?
       end
 
-      def increment!(*, **) #:nodoc:
+      def increment!(*, **) # :nodoc:
         super.tap do
           if locking_enabled?
             self[self.class.locking_column] += 1
@@ -90,7 +90,9 @@ module ActiveRecord
           begin
             locking_column = self.class.locking_column
             lock_attribute_was = @attributes[locking_column]
-            lock_value_for_database = _lock_value_for_database(locking_column)
+
+            update_constraints = _primary_key_constraints_hash
+            update_constraints[locking_column] = _lock_value_for_database(locking_column)
 
             attribute_names = attribute_names.dup if attribute_names.frozen?
             attribute_names << locking_column
@@ -99,8 +101,7 @@ module ActiveRecord
 
             affected_rows = self.class._update_record(
               attributes_with_values(attribute_names),
-              @primary_key => id_in_database,
-              locking_column => lock_value_for_database
+              update_constraints
             )
 
             if affected_rows != 1
@@ -121,10 +122,10 @@ module ActiveRecord
 
           locking_column = self.class.locking_column
 
-          affected_rows = self.class._delete_record(
-            @primary_key => id_in_database,
-            locking_column => _lock_value_for_database(locking_column)
-          )
+          delete_constraints = _primary_key_constraints_hash
+          delete_constraints[locking_column] = _lock_value_for_database(locking_column)
+
+          affected_rows = self.class._delete_record(delete_constraints)
 
           if affected_rows != 1
             raise ActiveRecord::StaleObjectError.new(self, "destroy")

data/lib/active_record/log_subscriber.rb

@@ -37,7 +37,11 @@ module ActiveRecord
 
       return if IGNORE_PAYLOAD_NAMES.include?(payload[:name])
 
-      name  = "#{payload[:name]} (#{event.duration.round(1)}ms)"
+      name = if payload[:async]
+        "ASYNC #{payload[:name]} (#{payload[:lock_wait].round(1)}ms) (db time #{event.duration.round(1)}ms)"
+      else
+        "#{payload[:name]} (#{event.duration.round(1)}ms)"
+      end
       name  = "CACHE #{name}" if payload[:cached]
       sql   = payload[:sql]
       binds = nil
@@ -115,7 +119,7 @@ module ActiveRecord
       def debug(progname = nil, &block)
         return unless super
 
-        if ActiveRecord::Base.verbose_query_logs
+        if ActiveRecord.verbose_query_logs
           log_query_source
         end
       end

data/lib/active_record/middleware/database_selector/resolver.rb

@@ -50,23 +50,19 @@ module ActiveRecord
 
         private
           def read_from_primary(&blk)
-            ActiveRecord::Base.connected_to(role: ActiveRecord::Base.writing_role, prevent_writes: true) do
-              instrumenter.instrument("database_selector.active_record.read_from_primary") do
-                yield
-              end
+            ActiveRecord::Base.connected_to(role: ActiveRecord.writing_role, prevent_writes: true) do
+              instrumenter.instrument("database_selector.active_record.read_from_primary", &blk)
             end
           end
 
           def read_from_replica(&blk)
-            ActiveRecord::Base.connected_to(role: ActiveRecord::Base.reading_role, prevent_writes: true) do
-              instrumenter.instrument("database_selector.active_record.read_from_replica") do
-                yield
-              end
+            ActiveRecord::Base.connected_to(role: ActiveRecord.reading_role, prevent_writes: true) do
+              instrumenter.instrument("database_selector.active_record.read_from_replica", &blk)
             end
           end
 
-          def write_to_primary(&blk)
-            ActiveRecord::Base.connected_to(role: ActiveRecord::Base.writing_role, prevent_writes: false) do
+          def write_to_primary
+            ActiveRecord::Base.connected_to(role: ActiveRecord.writing_role, prevent_writes: false) do
               instrumenter.instrument("database_selector.active_record.wrote_to_primary") do
                 yield
               ensure

data/lib/active_record/middleware/database_selector.rb

@@ -22,9 +22,14 @@ module ActiveRecord
     # To use the DatabaseSelector in your application with default settings add
     # the following options to your environment config:
     #
-    #   config.active_record.database_selector = { delay: 2.seconds }
-    #   config.active_record.database_resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver
-    #   config.active_record.database_resolver_context = ActiveRecord::Middleware::DatabaseSelector::Resolver::Session
+    #   # This require is only necessary when using `rails new app --minimal`
+    #   require "active_support/core_ext/integer/time"
+    #
+    #   class Application < Rails::Application
+    #     config.active_record.database_selector = { delay: 2.seconds }
+    #     config.active_record.database_resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver
+    #     config.active_record.database_resolver_context = ActiveRecord::Middleware::DatabaseSelector::Resolver::Session
+    #   end
     #
     # New applications will include these lines commented out in the production.rb.
     #

data/lib/active_record/migration/command_recorder.rb

@@ -112,7 +112,7 @@ module ActiveRecord
             record(:"#{method}", args, &block)  #   record(:create_table, args, &block)
           end                                   # end
         EOV
-        ruby2_keywords(method) if respond_to?(:ruby2_keywords, true)
+        ruby2_keywords(method)
       end
       alias :add_belongs_to :add_reference
       alias :remove_belongs_to :remove_reference
@@ -154,9 +154,9 @@ module ActiveRecord
 
         include StraightReversions
 
-        def invert_transaction(args)
+        def invert_transaction(args, &block)
           sub_recorder = CommandRecorder.new(delegate)
-          sub_recorder.revert { yield }
+          sub_recorder.revert(&block)
 
           invertions_proc = proc {
             sub_recorder.replay(self)
@@ -286,7 +286,7 @@ module ActiveRecord
             super
           end
         end
-        ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+        ruby2_keywords(:method_missing)
     end
   end
 end

data/lib/active_record/migration/compatibility.rb

@@ -13,7 +13,77 @@ module ActiveRecord
         const_get(name)
       end
 
-      V6_1 = Current
+      # This file exists to ensure that old migrations run the same way they did before a Rails upgrade.
+      # e.g. if you write a migration on Rails 6.1, then upgrade to Rails 7, the migration should do the same thing to your
+      # database as it did when you were running Rails 6.1
+      #
+      # "Current" is an alias for `ActiveRecord::Migration`, it represents the current Rails version.
+      # New migration functionality that will never be backward compatible should be added directly to `ActiveRecord::Migration`.
+      #
+      # There are classes for each prior Rails version. Each class descends from the *next* Rails version, so:
+      # 6.1 < 7.0
+      # 5.2 < 6.0 < 6.1 < 7.0
+      #
+      # If you are introducing new migration functionality that should only apply from Rails 7 onward, then you should
+      # find the class that immediately precedes it (6.1), and override the relevant migration methods to undo your changes.
+      #
+      # For example, Rails 6 added a default value for the `precision` option on datetime columns. So in this file, the `V5_2`
+      # class sets the value of `precision` to `nil` if it's not explicitly provided. This way, the default value will not apply
+      # for migrations written for 5.2, but will for migrations written for 6.0.
+      V7_0 = Current
+
+      class V6_1 < V7_0
+        class PostgreSQLCompat
+          def self.compatible_timestamp_type(type, connection)
+            if connection.adapter_name == "PostgreSQL"
+              # For Rails <= 6.1, :datetime was aliased to :timestamp
+              # See: https://github.com/rails/rails/blob/v6.1.3.2/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb#L108
+              # From Rails 7 onwards, you can define what :datetime resolves to (the default is still :timestamp)
+              # See `ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.datetime_type`
+              type.to_sym == :datetime ? :timestamp : type
+            else
+              type
+            end
+          end
+        end
+
+        def add_column(table_name, column_name, type, **options)
+          if type == :datetime
+            options[:precision] ||= nil
+          end
+
+          type = PostgreSQLCompat.compatible_timestamp_type(type, connection)
+          super
+        end
+
+        def create_table(table_name, **options)
+          if block_given?
+            super { |t| yield compatible_table_definition(t) }
+          else
+            super
+          end
+        end
+
+        module TableDefinition
+          def new_column_definition(name, type, **options)
+            type = PostgreSQLCompat.compatible_timestamp_type(type, @conn)
+            super
+          end
+
+          def column(name, type, index: nil, **options)
+            options[:precision] ||= nil
+            super
+          end
+        end
+
+        private
+          def compatible_table_definition(t)
+            class << t
+              prepend TableDefinition
+            end
+            t
+          end
+      end
 
       class V6_0 < V6_1
         class ReferenceDefinition < ConnectionAdapters::ReferenceDefinition
@@ -29,6 +99,11 @@ module ActiveRecord
             end
           end
           alias :belongs_to :references
+
+          def column(name, type, index: nil, **options)
+            options[:precision] ||= nil
+            super
+          end
         end
 
         def create_table(table_name, **options)
@@ -76,6 +151,11 @@ module ActiveRecord
             options[:precision] ||= nil
             super
           end
+
+          def column(name, type, index: nil, **options)
+            options[:precision] ||= nil
+            super
+          end
         end
 
         module CommandRecorder
@@ -204,6 +284,8 @@ module ActiveRecord
           if type == :primary_key
             type = :integer
             options[:primary_key] = true
+          elsif type == :datetime
+            options[:precision] ||= nil
           end
           super
         end

data/lib/active_record/migration/join_table.rb

@@ -2,7 +2,7 @@
 
 module ActiveRecord
   class Migration
-    module JoinTable #:nodoc:
+    module JoinTable # :nodoc:
       private
         def find_join_table_name(table_1, table_2, options = {})
           options.delete(:table_name) || join_table_name(table_1, table_2)

data/lib/active_record/migration.rb

@@ -9,7 +9,7 @@ require "active_support/core_ext/module/attribute_accessors"
 require "active_support/actionable_error"
 
 module ActiveRecord
-  class MigrationError < ActiveRecordError #:nodoc:
+  class MigrationError < ActiveRecordError # :nodoc:
     def initialize(message = nil)
       message = "\n\n#{message}\n\n" if message
       super
@@ -20,7 +20,7 @@ module ActiveRecord
   # For example the following migration is not reversible.
   # Rolling back this migration will raise an ActiveRecord::IrreversibleMigration error.
   #
-  #   class IrreversibleMigrationExample < ActiveRecord::Migration[6.0]
+  #   class IrreversibleMigrationExample < ActiveRecord::Migration[7.0]
   #     def change
   #       create_table :distributors do |t|
   #         t.string :zipcode
@@ -38,7 +38,7 @@ module ActiveRecord
   #
   # 1. Define <tt>#up</tt> and <tt>#down</tt> methods instead of <tt>#change</tt>:
   #
-  #  class ReversibleMigrationExample < ActiveRecord::Migration[6.0]
+  #  class ReversibleMigrationExample < ActiveRecord::Migration[7.0]
   #    def up
   #      create_table :distributors do |t|
   #        t.string :zipcode
@@ -63,7 +63,7 @@ module ActiveRecord
   #
   # 2. Use the #reversible method in <tt>#change</tt> method:
   #
-  #   class ReversibleMigrationExample < ActiveRecord::Migration[6.0]
+  #   class ReversibleMigrationExample < ActiveRecord::Migration[7.0]
   #     def change
   #       create_table :distributors do |t|
   #         t.string :zipcode
@@ -90,7 +90,7 @@ module ActiveRecord
   class IrreversibleMigration < MigrationError
   end
 
-  class DuplicateMigrationVersionError < MigrationError #:nodoc:
+  class DuplicateMigrationVersionError < MigrationError # :nodoc:
     def initialize(version = nil)
       if version
         super("Multiple migrations have the version number #{version}.")
@@ -100,7 +100,7 @@ module ActiveRecord
     end
   end
 
-  class DuplicateMigrationNameError < MigrationError #:nodoc:
+  class DuplicateMigrationNameError < MigrationError # :nodoc:
     def initialize(name = nil)
       if name
         super("Multiple migrations have the name #{name}.")
@@ -110,7 +110,7 @@ module ActiveRecord
     end
   end
 
-  class UnknownMigrationVersionError < MigrationError #:nodoc:
+  class UnknownMigrationVersionError < MigrationError # :nodoc:
     def initialize(version = nil)
       if version
         super("No migration with version number #{version}.")
@@ -120,7 +120,7 @@ module ActiveRecord
     end
   end
 
-  class IllegalMigrationNameError < MigrationError #:nodoc:
+  class IllegalMigrationNameError < MigrationError # :nodoc:
     def initialize(name = nil)
       if name
         super("Illegal name for migration file: #{name}\n\t(only lower case letters, numbers, and '_' allowed).")
@@ -130,13 +130,13 @@ module ActiveRecord
     end
   end
 
-  class PendingMigrationError < MigrationError #:nodoc:
+  class PendingMigrationError < MigrationError # :nodoc:
     include ActiveSupport::ActionableError
 
     action "Run pending migrations" do
       ActiveRecord::Tasks::DatabaseTasks.migrate
 
-      if ActiveRecord::Base.dump_schema_after_migration
+      if ActiveRecord.dump_schema_after_migration
         ActiveRecord::Tasks::DatabaseTasks.dump_schema(
           ActiveRecord::Base.connection_db_config
         )
@@ -165,7 +165,7 @@ module ActiveRecord
       end
   end
 
-  class ConcurrentMigrationError < MigrationError #:nodoc:
+  class ConcurrentMigrationError < MigrationError # :nodoc:
     DEFAULT_MESSAGE = "Cannot run migrations because another migration process is currently running."
     RELEASE_LOCK_FAILED_MESSAGE = "Failed to release advisory lock"
 
@@ -174,7 +174,7 @@ module ActiveRecord
     end
   end
 
-  class NoEnvironmentInSchemaError < MigrationError #:nodoc:
+  class NoEnvironmentInSchemaError < MigrationError # :nodoc:
     def initialize
       msg = "Environment data not found in the schema. To resolve this issue, run: \n\n        bin/rails db:environment:set"
       if defined?(Rails.env)
@@ -185,7 +185,7 @@ module ActiveRecord
     end
   end
 
-  class ProtectedEnvironmentError < ActiveRecordError #:nodoc:
+  class ProtectedEnvironmentError < ActiveRecordError # :nodoc:
     def initialize(env = "production")
       msg = +"You are attempting to run a destructive action against your '#{env}' database.\n"
       msg << "If you are sure you want to continue, run the same command with the environment variable:\n"
@@ -228,7 +228,7 @@ module ActiveRecord
   #
   # Example of a simple migration:
   #
-  #   class AddSsl < ActiveRecord::Migration[6.0]
+  #   class AddSsl < ActiveRecord::Migration[7.0]
   #     def up
   #       add_column :accounts, :ssl_enabled, :boolean, default: true
   #     end
@@ -248,7 +248,7 @@ module ActiveRecord
   #
   # Example of a more complex migration that also needs to initialize data:
   #
-  #   class AddSystemSettings < ActiveRecord::Migration[6.0]
+  #   class AddSystemSettings < ActiveRecord::Migration[7.0]
   #     def up
   #       create_table :system_settings do |t|
   #         t.string  :name
@@ -376,7 +376,7 @@ module ActiveRecord
   #   bin/rails generate migration add_fieldname_to_tablename fieldname:string
   #
   # This will generate the file <tt>timestamp_add_fieldname_to_tablename.rb</tt>, which will look like this:
-  #   class AddFieldnameToTablename < ActiveRecord::Migration[6.0]
+  #   class AddFieldnameToTablename < ActiveRecord::Migration[7.0]
   #     def change
   #       add_column :tablenames, :fieldname, :string
   #     end
@@ -402,7 +402,7 @@ module ActiveRecord
   #
   # Not all migrations change the schema. Some just fix the data:
   #
-  #   class RemoveEmptyTags < ActiveRecord::Migration[6.0]
+  #   class RemoveEmptyTags < ActiveRecord::Migration[7.0]
   #     def up
   #       Tag.all.each { |tag| tag.destroy if tag.pages.empty? }
   #     end
@@ -415,7 +415,7 @@ module ActiveRecord
   #
   # Others remove columns when they migrate up instead of down:
   #
-  #   class RemoveUnnecessaryItemAttributes < ActiveRecord::Migration[6.0]
+  #   class RemoveUnnecessaryItemAttributes < ActiveRecord::Migration[7.0]
   #     def up
   #       remove_column :items, :incomplete_items_count
   #       remove_column :items, :completed_items_count
@@ -429,7 +429,7 @@ module ActiveRecord
   #
   # And sometimes you need to do something in SQL not abstracted directly by migrations:
   #
-  #   class MakeJoinUnique < ActiveRecord::Migration[6.0]
+  #   class MakeJoinUnique < ActiveRecord::Migration[7.0]
   #     def up
   #       execute "ALTER TABLE `pages_linked_pages` ADD UNIQUE `page_id_linked_page_id` (`page_id`,`linked_page_id`)"
   #     end
@@ -446,7 +446,7 @@ module ActiveRecord
   # <tt>Base#reset_column_information</tt> in order to ensure that the model has the
   # latest column data from after the new column was added. Example:
   #
-  #   class AddPeopleSalary < ActiveRecord::Migration[6.0]
+  #   class AddPeopleSalary < ActiveRecord::Migration[7.0]
   #     def up
   #       add_column :people, :salary, :integer
   #       Person.reset_column_information
@@ -504,7 +504,7 @@ module ActiveRecord
   # To define a reversible migration, define the +change+ method in your
   # migration like this:
   #
-  #   class TenderloveMigration < ActiveRecord::Migration[6.0]
+  #   class TenderloveMigration < ActiveRecord::Migration[7.0]
   #     def change
   #       create_table(:horses) do |t|
   #         t.column :content, :text
@@ -534,7 +534,7 @@ module ActiveRecord
   # can't execute inside a transaction though, and for these situations
   # you can turn the automatic transactions off.
   #
-  #   class ChangeEnum < ActiveRecord::Migration[6.0]
+  #   class ChangeEnum < ActiveRecord::Migration[7.0]
   #     disable_ddl_transaction!
   #
   #     def up
@@ -550,16 +550,18 @@ module ActiveRecord
     autoload :JoinTable, "active_record/migration/join_table"
 
     # This must be defined before the inherited hook, below
-    class Current < Migration #:nodoc:
+    class Current < Migration # :nodoc:
     end
 
-    def self.inherited(subclass) #:nodoc:
+    def self.inherited(subclass) # :nodoc:
       super
       if subclass.superclass == Migration
+        major = ActiveRecord::VERSION::MAJOR
+        minor = ActiveRecord::VERSION::MINOR
         raise StandardError, "Directly inheriting from ActiveRecord::Migration is not supported. " \
-          "Please specify the Rails release the migration was written for:\n" \
+          "Please specify the Active Record release the migration was written for:\n" \
           "\n" \
-          "  class #{subclass} < ActiveRecord::Migration[4.2]"
+          "  class #{subclass} < ActiveRecord::Migration[#{major}.#{minor}]"
       end
     end
 
@@ -571,7 +573,7 @@ module ActiveRecord
       ActiveRecord::VERSION::STRING.to_f
     end
 
-    MigrationFilenameRegexp = /\A([0-9]+)_([_a-z0-9]*)\.?([_a-z0-9]*)?\.rb\z/ #:nodoc:
+    MigrationFilenameRegexp = /\A([0-9]+)_([_a-z0-9]*)\.?([_a-z0-9]*)?\.rb\z/ # :nodoc:
 
     # This class is used to verify that all migrations have been run before
     # loading a web page if <tt>config.active_record.migration_error</tt> is set to :page_load
@@ -613,10 +615,10 @@ module ActiveRecord
     end
 
     class << self
-      attr_accessor :delegate #:nodoc:
-      attr_accessor :disable_ddl_transaction #:nodoc:
+      attr_accessor :delegate # :nodoc:
+      attr_accessor :disable_ddl_transaction # :nodoc:
 
-      def nearest_delegate #:nodoc:
+      def nearest_delegate # :nodoc:
         delegate || superclass.nearest_delegate
       end
 
@@ -630,7 +632,7 @@ module ActiveRecord
         all_configs = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env)
 
         needs_update = !all_configs.all? do |db_config|
-          Tasks::DatabaseTasks.schema_up_to_date?(db_config, ActiveRecord::Base.schema_format)
+          Tasks::DatabaseTasks.schema_up_to_date?(db_config, ActiveRecord.schema_format)
         end
 
         if needs_update
@@ -648,16 +650,16 @@ module ActiveRecord
         check_pending!
       end
 
-      def maintain_test_schema! #:nodoc:
-        if ActiveRecord::Base.maintain_test_schema
+      def maintain_test_schema! # :nodoc:
+        if ActiveRecord.maintain_test_schema
           suppress_messages { load_schema_if_pending! }
         end
       end
 
-      def method_missing(name, *args, &block) #:nodoc:
+      def method_missing(name, *args, &block) # :nodoc:
         nearest_delegate.send(name, *args, &block)
       end
-      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+      ruby2_keywords(:method_missing)
 
       def migrate(direction)
         new.migrate direction
@@ -672,7 +674,7 @@ module ActiveRecord
       end
     end
 
-    def disable_ddl_transaction #:nodoc:
+    def disable_ddl_transaction # :nodoc:
       self.class.disable_ddl_transaction
     end
 
@@ -696,7 +698,7 @@ module ActiveRecord
     # and create the table 'apples' on the way up, and the reverse
     # on the way down.
     #
-    #   class FixTLMigration < ActiveRecord::Migration[6.0]
+    #   class FixTLMigration < ActiveRecord::Migration[7.0]
     #     def change
     #       revert do
     #         create_table(:horses) do |t|
@@ -715,7 +717,7 @@ module ActiveRecord
     #
     #   require_relative "20121212123456_tenderlove_migration"
     #
-    #   class FixupTLMigration < ActiveRecord::Migration[6.0]
+    #   class FixupTLMigration < ActiveRecord::Migration[7.0]
     #     def change
     #       revert TenderloveMigration
     #
@@ -726,16 +728,16 @@ module ActiveRecord
     #   end
     #
     # This command can be nested.
-    def revert(*migration_classes)
+    def revert(*migration_classes, &block)
       run(*migration_classes.reverse, revert: true) unless migration_classes.empty?
       if block_given?
         if connection.respond_to? :revert
-          connection.revert { yield }
+          connection.revert(&block)
         else
           recorder = command_recorder
           @connection = recorder
           suppress_messages do
-            connection.revert { yield }
+            connection.revert(&block)
           end
           @connection = recorder.delegate
           recorder.replay(self)
@@ -747,7 +749,7 @@ module ActiveRecord
       connection.respond_to?(:reverting) && connection.reverting
     end
 
-    ReversibleBlockHelper = Struct.new(:reverting) do #:nodoc:
+    ReversibleBlockHelper = Struct.new(:reverting) do # :nodoc:
       def up
         yield unless reverting
       end
@@ -766,7 +768,7 @@ module ActiveRecord
     # when the three columns 'first_name', 'last_name' and 'full_name' exist,
     # even when migrating down:
     #
-    #    class SplitNameMigration < ActiveRecord::Migration[6.0]
+    #    class SplitNameMigration < ActiveRecord::Migration[7.0]
     #      def change
     #        add_column :users, :first_name, :string
     #        add_column :users, :last_name, :string
@@ -794,7 +796,7 @@ module ActiveRecord
     # In the following example, the new column +published+ will be given
     # the value +true+ for all existing records.
     #
-    #    class AddPublishedToPosts < ActiveRecord::Migration[6.0]
+    #    class AddPublishedToPosts < ActiveRecord::Migration[7.0]
     #      def change
     #        add_column :posts, :published, :boolean, default: false
     #        up_only do
@@ -802,8 +804,8 @@ module ActiveRecord
     #        end
     #      end
     #    end
-    def up_only
-      execute_block { yield } unless reverting?
+    def up_only(&block)
+      execute_block(&block) unless reverting?
     end
 
     # Runs the given migration classes.
@@ -919,7 +921,7 @@ module ActiveRecord
         unless connection.respond_to? :revert
           unless arguments.empty? || [:execute, :enable_extension, :disable_extension].include?(method)
             arguments[0] = proper_table_name(arguments.first, table_name_options)
-            if [:rename_table, :add_foreign_key].include?(method) ||
+            if method == :rename_table ||
               (method == :remove_foreign_key && !arguments.second.is_a?(Hash))
               arguments[1] = proper_table_name(arguments.second, table_name_options)
             end
@@ -929,7 +931,7 @@ module ActiveRecord
         connection.send(method, *arguments, &block)
       end
     end
-    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+    ruby2_keywords(:method_missing)
 
     def copy(destination, sources, options = {})
       copied = []
@@ -955,6 +957,12 @@ module ActiveRecord
               magic_comments << magic_comment; ""
             end || break
           end
+
+          if !magic_comments.empty? && source.start_with?("\n")
+            magic_comments << "\n"
+            source = source[1..-1]
+          end
+
           source = "#{magic_comments}#{inserted_comment}#{source}"
 
           if duplicate = destination_migrations.detect { |m| m.name == migration.name }
@@ -992,7 +1000,7 @@ module ActiveRecord
 
     # Determines the version number of the next migration.
     def next_migration_number(number)
-      if ActiveRecord::Base.timestamped_migrations
+      if ActiveRecord.timestamped_migrations
         [Time.now.utc.strftime("%Y%m%d%H%M%S"), "%.14d" % number].max
       else
         SchemaMigration.normalize_migration_number(number)
@@ -1001,7 +1009,7 @@ module ActiveRecord
 
     # Builds a hash for use in ActiveRecord::Migration#proper_table_name using
     # the Active Record object's table_name prefix and suffix
-    def table_name_options(config = ActiveRecord::Base) #:nodoc:
+    def table_name_options(config = ActiveRecord::Base) # :nodoc:
       {
         table_name_prefix: config.table_name_prefix,
         table_name_suffix: config.table_name_suffix
@@ -1042,19 +1050,41 @@ module ActiveRecord
       end
 
       def load_migration
-        require(File.expand_path(filename))
+        Object.send(:remove_const, name) rescue nil
+
+        load(File.expand_path(filename))
         name.constantize.new(name, version)
       end
   end
 
-  class MigrationContext #:nodoc:
+  # MigrationContext sets the context in which a migration is run.
+  #
+  # A migration context requires the path to the migrations is set
+  # in the +migrations_paths+ parameter. Optionally a +schema_migration+
+  # class can be provided. For most applications, +SchemaMigration+ is
+  # sufficient. Multiple database applications need a +SchemaMigration+
+  # per primary database.
+  class MigrationContext
     attr_reader :migrations_paths, :schema_migration
 
-    def initialize(migrations_paths, schema_migration)
+    def initialize(migrations_paths, schema_migration = SchemaMigration)
       @migrations_paths = migrations_paths
       @schema_migration = schema_migration
     end
 
+    # Runs the migrations in the +migrations_path+.
+    #
+    # If +target_version+ is +nil+, +migrate+ will run +up+.
+    #
+    # If the +current_version+ and +target_version+ are both
+    # 0 then an empty array will be returned and no migrations
+    # will be run.
+    #
+    # If the +current_version+ in the schema is less than
+    # the +target_version+, then +down+ will be run.
+    #
+    # If none of the conditions are met, +up+ will be run with
+    # the +target_version+.
     def migrate(target_version = nil, &block)
       case
       when target_version.nil?
@@ -1068,17 +1098,17 @@ module ActiveRecord
       end
     end
 
-    def rollback(steps = 1)
+    def rollback(steps = 1) # :nodoc:
       move(:down, steps)
     end
 
-    def forward(steps = 1)
+    def forward(steps = 1) # :nodoc:
       move(:up, steps)
     end
 
-    def up(target_version = nil)
+    def up(target_version = nil, &block) # :nodoc:
       selected_migrations = if block_given?
-        migrations.select { |m| yield m }
+        migrations.select(&block)
       else
         migrations
       end
@@ -1086,9 +1116,9 @@ module ActiveRecord
       Migrator.new(:up, selected_migrations, schema_migration, target_version).migrate
     end
 
-    def down(target_version = nil)
+    def down(target_version = nil, &block) # :nodoc:
       selected_migrations = if block_given?
-        migrations.select { |m| yield m }
+        migrations.select(&block)
       else
         migrations
       end
@@ -1096,15 +1126,15 @@ module ActiveRecord
       Migrator.new(:down, selected_migrations, schema_migration, target_version).migrate
     end
 
-    def run(direction, target_version)
+    def run(direction, target_version) # :nodoc:
       Migrator.new(direction, migrations, schema_migration, target_version).run
     end
 
-    def open
+    def open # :nodoc:
       Migrator.new(:up, migrations, schema_migration)
     end
 
-    def get_all_versions
+    def get_all_versions # :nodoc:
       if schema_migration.table_exists?
         schema_migration.all_versions.map(&:to_i)
       else
@@ -1112,20 +1142,20 @@ module ActiveRecord
       end
     end
 
-    def current_version
+    def current_version # :nodoc:
       get_all_versions.max || 0
     rescue ActiveRecord::NoDatabaseError
     end
 
-    def needs_migration?
-      (migrations.collect(&:version) - get_all_versions).size > 0
+    def needs_migration? # :nodoc:
+      pending_migration_versions.size > 0
     end
 
-    def any_migrations?
-      migrations.any?
+    def pending_migration_versions # :nodoc:
+      migrations.collect(&:version) - get_all_versions
     end
 
-    def migrations
+    def migrations # :nodoc:
       migrations = migration_files.map do |file|
         version, name, scope = parse_migration_filename(file)
         raise IllegalMigrationNameError.new(file) unless version
@@ -1138,33 +1168,33 @@ module ActiveRecord
       migrations.sort_by(&:version)
     end
 
-    def migrations_status
+    def migrations_status # :nodoc:
       db_list = schema_migration.normalized_versions
 
-      file_list = migration_files.map do |file|
+      file_list = migration_files.filter_map do |file|
         version, name, scope = parse_migration_filename(file)
         raise IllegalMigrationNameError.new(file) unless version
         version = schema_migration.normalize_migration_number(version)
         status = db_list.delete(version) ? "up" : "down"
         [status, version, (name + scope).humanize]
-      end.compact
+      end
 
       db_list.map! do |version|
         ["up", version, "********** NO FILE **********"]
       end
 
-      (db_list + file_list).sort_by { |_, version, _| version }
+      (db_list + file_list).sort_by { |_, version, _| version.to_i }
     end
 
-    def current_environment
+    def current_environment # :nodoc:
       ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
     end
 
-    def protected_environment?
+    def protected_environment? # :nodoc:
       ActiveRecord::Base.protected_environments.include?(last_stored_environment) if last_stored_environment
     end
 
-    def last_stored_environment
+    def last_stored_environment # :nodoc:
       return nil unless ActiveRecord::InternalMetadata.enabled?
       return nil if current_version == 0
       raise NoEnvironmentInSchemaError unless ActiveRecord::InternalMetadata.table_exists?
@@ -1375,9 +1405,9 @@ module ActiveRecord
       end
 
       # Wrap the migration in a transaction only if supported by the adapter.
-      def ddl_transaction(migration)
+      def ddl_transaction(migration, &block)
         if use_transaction?(migration)
-          Base.transaction { yield }
+          Base.transaction(&block)
         else
           yield
         end
@@ -1408,12 +1438,12 @@ module ActiveRecord
         end
       end
 
-      def with_advisory_lock_connection
+      def with_advisory_lock_connection(&block)
         pool = ActiveRecord::ConnectionAdapters::ConnectionHandler.new.establish_connection(
           ActiveRecord::Base.connection_db_config
         )
 
-        pool.with_connection { |connection| yield(connection) }
+        pool.with_connection(&block)
       ensure
         pool&.disconnect!
       end