activerecord 4.2.11.3 → 5.0.0.beta1

data/lib/active_record/integration.rb

@@ -10,12 +10,12 @@ module ActiveRecord
       # Indicates the format used to generate the timestamp in the cache key.
       # Accepts any of the symbols in <tt>Time::DATE_FORMATS</tt>.
       #
-      # This is +:nsec+, by default.
+      # This is +:usec+, by default.
       class_attribute :cache_timestamp_format, :instance_writer => false
-      self.cache_timestamp_format = :nsec
+      self.cache_timestamp_format = :usec
     end
 
-    # Returns a String, which Action Pack uses for constructing an URL to this
+    # Returns a String, which Action Pack uses for constructing a URL to this
     # object. The default implementation returns this record's id as a String,
     # or nil if this record's unsaved.
     #
@@ -84,7 +84,7 @@ module ActiveRecord
       # Values longer than 20 characters will be truncated. The value
       # is truncated word by word.
       #
-      #   user = User.find_by(name: 'David HeinemeierHansson')
+      #   user = User.find_by(name: 'David Heinemeier Hansson')
       #   user.id         # => 125
       #   user_path(user) # => "/users/125-david"
       #

data/lib/active_record/legacy_yaml_adapter.rb

@@ -4,16 +4,32 @@ module ActiveRecord
       return coder unless coder.is_a?(Psych::Coder)
 
       case coder["active_record_yaml_version"]
-      when 0 then coder
+      when 1 then coder
       else
         if coder["attributes"].is_a?(AttributeSet)
-          coder
+          Rails420.convert(klass, coder)
         else
           Rails41.convert(klass, coder)
         end
       end
     end
 
+    module Rails420
+      def self.convert(klass, coder)
+        attribute_set = coder["attributes"]
+
+        klass.attribute_names.each do |attr_name|
+          attribute = attribute_set[attr_name]
+          if attribute.type.is_a?(Delegator)
+            type_from_klass = klass.type_for_attribute(attr_name)
+            attribute_set[attr_name] = attribute.with_type(type_from_klass)
+          end
+        end
+
+        coder
+      end
+    end
+
     module Rails41
       def self.convert(klass, coder)
         attributes = klass.attributes_builder

data/lib/active_record/locale/en.yml

@@ -7,6 +7,7 @@ en:
   # Default error messages
   errors:
     messages:
+      required: "must exist"
       taken: "has already been taken"
 
   # Active Record models configuration
@@ -15,8 +16,8 @@ en:
       messages:
         record_invalid: "Validation failed: %{errors}"
         restrict_dependent_destroy:
-          one: "Cannot delete record because a dependent %{record} exists"
-          many: "Cannot delete record because dependent %{record} exist"
+          has_one: "Cannot delete record because a dependent %{record} exists"
+          has_many: "Cannot delete record because dependent %{record} exist"
         # Append your own errors here or at the model/attributes scope.
 
       # You can define own errors for models or model attributes.

data/lib/active_record/locking/optimistic.rb

@@ -11,7 +11,7 @@ module ActiveRecord
     #
     # == Usage
     #
-    # Active Records support optimistic locking if the field +lock_version+ is present. Each update to the
+    # Active Record supports optimistic locking if the +lock_version+ field is present. Each update to the
     # record increments the +lock_version+ column and the locking facilities ensure that records instantiated twice
     # will let the last one saved raise a +StaleObjectError+ if the first was also updated. Example:
     #
@@ -22,7 +22,7 @@ module ActiveRecord
     #   p1.save
     #
     #   p2.first_name = "should fail"
-    #   p2.save # Raises a ActiveRecord::StaleObjectError
+    #   p2.save # Raises an ActiveRecord::StaleObjectError
     #
     # Optimistic locking will also check for stale data when objects are destroyed. Example:
     #
@@ -32,7 +32,7 @@ module ActiveRecord
     #   p1.first_name = "Michael"
     #   p1.save
     #
-    #   p2.destroy # Raises a ActiveRecord::StaleObjectError
+    #   p2.destroy # Raises an ActiveRecord::StaleObjectError
     #
     # You're then responsible for dealing with the conflict by rescuing the exception and either rolling back, merging,
     # or otherwise apply the business logic needed to resolve the conflict.
@@ -93,9 +93,9 @@ module ActiveRecord
               self.class.primary_key => id,
               lock_col => previous_lock_value,
             ).update_all(
-              Hash[attributes_for_update(attribute_names).map do |name|
+              attributes_for_update(attribute_names).map do |name|
                 [name, _read_attribute(name)]
-              end]
+              end.to_h
             )
 
             unless affected_rows == 1
@@ -125,12 +125,8 @@ module ActiveRecord
           relation = super
 
           if locking_enabled?
-            column_name = self.class.locking_column
-            column      = self.class.columns_hash[column_name]
-            substitute  = self.class.connection.substitute_at(column)
-
-            relation = relation.where(self.class.arel_table[column_name].eq(substitute))
-            relation.bind_values << [column, self[column_name].to_i]
+            locking_column = self.class.locking_column
+            relation = relation.where(locking_column => _read_attribute(locking_column))
           end
 
           relation
@@ -148,7 +144,7 @@ module ActiveRecord
 
         # Set the column to use for optimistic locking. Defaults to +lock_version+.
         def locking_column=(value)
-          clear_caches_calculated_from_columns
+          reload_schema_from_cache
           @locking_column = value.to_s
         end
 
@@ -188,8 +184,8 @@ module ActiveRecord
       end
     end
 
-    class LockingType < SimpleDelegator # :nodoc:
-      def type_cast_from_database(value)
+    class LockingType < DelegateClass(Type::Value) # :nodoc:
+      def deserialize(value)
         # `nil` *should* be changed to 0
         super.to_i
       end

data/lib/active_record/locking/pessimistic.rb

@@ -51,7 +51,7 @@ module ActiveRecord
     #   end
     #
     # Database-specific information on row locking:
-    #   MySQL: http://dev.mysql.com/doc/refman/5.1/en/innodb-locking-reads.html
+    #   MySQL: http://dev.mysql.com/doc/refman/5.7/en/innodb-locking-reads.html
     #   PostgreSQL: http://www.postgresql.org/docs/current/interactive/sql-select.html#SQL-FOR-UPDATE-SHARE
     module Pessimistic
       # Obtain a row lock on this record. Reloads the record to obtain the requested

data/lib/active_record/log_subscriber.rb

@@ -20,24 +20,21 @@ module ActiveRecord
       @odd = false
     end
 
-    def render_bind(column, value)
-      if column
-        if column.binary?
-          # This specifically deals with the PG adapter that casts bytea columns into a Hash.
-          value = value[:value] if value.is_a?(Hash)
-          value = value ? "<#{value.bytesize} bytes of binary data>" : "<NULL binary data>"
-        end
-
-        [column.name, value]
+    def render_bind(attribute)
+      value = if attribute.type.binary? && attribute.value
+        "<#{attribute.value.bytesize} bytes of binary data>"
       else
-        [nil, value]
+        attribute.value_for_database
       end
+
+      [attribute.name, value]
     end
 
     def sql(event)
-      self.class.runtime += event.duration
       return unless logger.debug?
 
+      self.class.runtime += event.duration
+
       payload = event.payload
 
       return if IGNORE_PAYLOAD_NAMES.include?(payload[:name])
@@ -47,23 +44,44 @@ module ActiveRecord
       binds = nil
 
       unless (payload[:binds] || []).empty?
-        binds = "  " + payload[:binds].map { |col,v|
-          render_bind(col, v)
-        }.inspect
+        binds = "  " + payload[:binds].map { |attr| render_bind(attr) }.inspect
       end
 
-      if odd?
-        name = color(name, CYAN, true)
-        sql  = color(sql, nil, true)
-      else
-        name = color(name, MAGENTA, true)
-      end
+      name = colorize_payload_name(name, payload[:name])
+      sql  = color(sql, sql_color(sql), true)
 
       debug "  #{name}  #{sql}#{binds}"
     end
 
-    def odd?
-      @odd = !@odd
+    private
+
+    def colorize_payload_name(name, payload_name)
+      if payload_name.blank? || payload_name == "SQL" # SQL vs Model Load/Exists
+        color(name, MAGENTA, true)
+      else
+        color(name, CYAN, true)
+      end
+    end
+
+    def sql_color(sql)
+      case sql
+        when /\A\s*rollback/mi
+          RED
+        when /\s*.*?select .*for update/mi, /\A\s*lock/mi
+          WHITE
+        when /\A\s*select/i
+          BLUE
+        when /\A\s*insert/i
+          GREEN
+        when /\A\s*update/i
+          YELLOW
+        when /\A\s*delete/i
+          RED
+        when /transaction\s*\Z/i
+          CYAN
+        else
+          MAGENTA
+      end
     end
 
     def logger

data/lib/active_record/migration.rb

@@ -9,44 +9,140 @@ module ActiveRecord
     end
   end
 
-  # Exception that can be raised to stop migrations from going backwards.
+  # Exception that can be raised to stop migrations from being rolled back.
+  # For example the following migration is not reversible.
+  # Rolling back this migration will raise an ActiveRecord::IrreversibleMigration error.
+  #
+  #   class IrreversibleMigrationExample < ActiveRecord::Migration[5.0]
+  #     def change
+  #       create_table :distributors do |t|
+  #         t.string :zipcode
+  #       end
+  #
+  #       execute <<-SQL
+  #         ALTER TABLE distributors
+  #           ADD CONSTRAINT zipchk
+  #             CHECK (char_length(zipcode) = 5) NO INHERIT;
+  #       SQL
+  #     end
+  #   end
+  #
+  # There are two ways to mitigate this problem.
+  #
+  # 1. Define <tt>#up</tt> and <tt>#down</tt> methods instead of <tt>#change</tt>:
+  #
+  #  class ReversibleMigrationExample < ActiveRecord::Migration[5.0]
+  #    def up
+  #      create_table :distributors do |t|
+  #        t.string :zipcode
+  #      end
+  #
+  #      execute <<-SQL
+  #        ALTER TABLE distributors
+  #          ADD CONSTRAINT zipchk
+  #            CHECK (char_length(zipcode) = 5) NO INHERIT;
+  #      SQL
+  #    end
+  #
+  #    def down
+  #      execute <<-SQL
+  #        ALTER TABLE distributors
+  #          DROP CONSTRAINT zipchk
+  #      SQL
+  #
+  #      drop_table :distributors
+  #    end
+  #  end
+  #
+  # 2. Use the #reversible method in <tt>#change</tt> method:
+  #
+  #   class ReversibleMigrationExample < ActiveRecord::Migration[5.0]
+  #     def change
+  #       create_table :distributors do |t|
+  #         t.string :zipcode
+  #       end
+  #
+  #       reversible do |dir|
+  #         dir.up do
+  #           execute <<-SQL
+  #             ALTER TABLE distributors
+  #               ADD CONSTRAINT zipchk
+  #                 CHECK (char_length(zipcode) = 5) NO INHERIT;
+  #           SQL
+  #         end
+  #
+  #         dir.down do
+  #           execute <<-SQL
+  #             ALTER TABLE distributors
+  #               DROP CONSTRAINT zipchk
+  #           SQL
+  #         end
+  #       end
+  #     end
+  #   end
   class IrreversibleMigration < MigrationError
   end
 
   class DuplicateMigrationVersionError < MigrationError#:nodoc:
-    def initialize(version)
-      super("Multiple migrations have the version number #{version}")
+    def initialize(version = nil)
+      if version
+        super("Multiple migrations have the version number #{version}.")
+      else
+        super("Duplicate migration version error.")
+      end
     end
   end
 
   class DuplicateMigrationNameError < MigrationError#:nodoc:
-    def initialize(name)
-      super("Multiple migrations have the name #{name}")
+    def initialize(name = nil)
+      if name
+        super("Multiple migrations have the name #{name}.")
+      else
+        super("Duplicate migration name.")
+      end
     end
   end
 
   class UnknownMigrationVersionError < MigrationError #:nodoc:
-    def initialize(version)
-      super("No migration with version number #{version}")
+    def initialize(version = nil)
+      if version
+        super("No migration with version number #{version}.")
+      else
+        super("Unknown migration version.")
+      end
     end
   end
 
   class IllegalMigrationNameError < MigrationError#:nodoc:
-    def initialize(name)
-      super("Illegal name for migration file: #{name}\n\t(only lower case letters, numbers, and '_' allowed)")
+    def initialize(name = nil)
+      if name
+        super("Illegal name for migration file: #{name}\n\t(only lower case letters, numbers, and '_' allowed).")
+      else
+        super("Illegal name for migration.")
+      end
     end
   end
 
   class PendingMigrationError < MigrationError#:nodoc:
-    def initialize
-      if defined?(Rails.env)
-        super("Migrations are pending. To resolve this issue, run:\n\n\tbin/rake db:migrate RAILS_ENV=#{::Rails.env}")
+    def initialize(message = nil)
+      if !message && defined?(Rails.env)
+        super("Migrations are pending. To resolve this issue, run:\n\n\tbin/rails db:migrate RAILS_ENV=#{::Rails.env}.")
+      elsif !message
+        super("Migrations are pending. To resolve this issue, run:\n\n\tbin/rails db:migrate.")
       else
-        super("Migrations are pending. To resolve this issue, run:\n\n\tbin/rake db:migrate")
+        super
       end
     end
   end
 
+  class ConcurrentMigrationError < MigrationError #:nodoc:
+    DEFAULT_MESSAGE = "Cannot run migrations because another migration process is currently running.".freeze
+
+    def initialize(message = DEFAULT_MESSAGE)
+      super
+    end
+  end
+
   # = Active Record Migrations
   #
   # Migrations can manage the evolution of a schema used by several physical
@@ -59,7 +155,7 @@ module ActiveRecord
   #
   # Example of a simple migration:
   #
-  #   class AddSsl < ActiveRecord::Migration
+  #   class AddSsl < ActiveRecord::Migration[5.0]
   #     def up
   #       add_column :accounts, :ssl_enabled, :boolean, default: true
   #     end
@@ -79,7 +175,7 @@ module ActiveRecord
   #
   # Example of a more complex migration that also needs to initialize data:
   #
-  #   class AddSystemSettings < ActiveRecord::Migration
+  #   class AddSystemSettings < ActiveRecord::Migration[5.0]
   #     def up
   #       create_table :system_settings do |t|
   #         t.string  :name
@@ -106,17 +202,18 @@ module ActiveRecord
   #
   # == Available transformations
   #
+  # === Creation
+  #
+  # * <tt>create_join_table(table_1, table_2, options)</tt>: Creates a join
+  #   table having its name as the lexical order of the first two
+  #   arguments. See
+  #   ActiveRecord::ConnectionAdapters::SchemaStatements#create_join_table for
+  #   details.
   # * <tt>create_table(name, options)</tt>: Creates a table called +name+ and
   #   makes the table object available to a block that can then add columns to it,
   #   following the same format as +add_column+. See example above. The options hash
   #   is for fragments like "DEFAULT CHARSET=UTF-8" that are appended to the create
   #   table definition.
-  # * <tt>drop_table(name)</tt>: Drops the table called +name+.
-  # * <tt>change_table(name, options)</tt>: Allows to make column alterations to
-  #   the table called +name+. It makes the table object available to a block that
-  #   can then add/remove columns, indexes or foreign keys to it.
-  # * <tt>rename_table(old_name, new_name)</tt>: Renames the table called +old_name+
-  #   to +new_name+.
   # * <tt>add_column(table_name, column_name, type, options)</tt>: Adds a new column
   #   to the table called +table_name+
   #   named +column_name+ specified to be one of the following types:
@@ -127,21 +224,59 @@ module ActiveRecord
   #   Other options include <tt>:limit</tt> and <tt>:null</tt> (e.g.
   #   <tt>{ limit: 50, null: false }</tt>) -- see
   #   ActiveRecord::ConnectionAdapters::TableDefinition#column for details.
-  # * <tt>rename_column(table_name, column_name, new_column_name)</tt>: Renames
-  #   a column but keeps the type and content.
-  # * <tt>change_column(table_name, column_name, type, options)</tt>:  Changes
-  #   the column to a different type using the same parameters as add_column.
-  # * <tt>remove_column(table_name, column_name, type, options)</tt>: Removes the column
-  #   named +column_name+ from the table called +table_name+.
+  # * <tt>add_foreign_key(from_table, to_table, options)</tt>: Adds a new
+  #   foreign key. +from_table+ is the table with the key column, +to_table+ contains
+  #   the referenced primary key.
   # * <tt>add_index(table_name, column_names, options)</tt>: Adds a new index
   #   with the name of the column. Other options include
   #   <tt>:name</tt>, <tt>:unique</tt> (e.g.
   #   <tt>{ name: 'users_name_index', unique: true }</tt>) and <tt>:order</tt>
   #   (e.g. <tt>{ order: { name: :desc } }</tt>).
-  # * <tt>remove_index(table_name, column: column_name)</tt>: Removes the index
-  #   specified by +column_name+.
+  # * <tt>add_reference(:table_name, :reference_name)</tt>: Adds a new column
+  #   +reference_name_id+ by default an integer. See
+  #   ActiveRecord::ConnectionAdapters::SchemaStatements#add_reference for details.
+  # * <tt>add_timestamps(table_name, options)</tt>: Adds timestamps (+created_at+
+  #   and +updated_at+) columns to +table_name+.
+  #
+  # === Modification
+  #
+  # * <tt>change_column(table_name, column_name, type, options)</tt>:  Changes
+  #   the column to a different type using the same parameters as add_column.
+  # * <tt>change_column_default(table_name, column_name, default)</tt>: Sets a
+  #   default value for +column_name+ definded by +default+ on +table_name+.
+  # * <tt>change_column_null(table_name, column_name, null, default = nil)</tt>:
+  #   Sets or removes a +NOT NULL+ constraint on +column_name+. The +null+ flag
+  #   indicates whether the value can be +NULL+. See
+  #   ActiveRecord::ConnectionAdapters::SchemaStatements#change_column_null for
+  #   details.
+  # * <tt>change_table(name, options)</tt>: Allows to make column alterations to
+  #   the table called +name+. It makes the table object available to a block that
+  #   can then add/remove columns, indexes or foreign keys to it.
+  # * <tt>rename_column(table_name, column_name, new_column_name)</tt>: Renames
+  #   a column but keeps the type and content.
+  # * <tt>rename_index(table_name, old_name, new_name)</tt>: Renames an index.
+  # * <tt>rename_table(old_name, new_name)</tt>: Renames the table called +old_name+
+  #   to +new_name+.
+  #
+  # === Deletion
+  #
+  # * <tt>drop_table(name)</tt>: Drops the table called +name+.
+  # * <tt>drop_join_table(table_1, table_2, options)</tt>: Drops the join table
+  #   specified by the given arguments.
+  # * <tt>remove_column(table_name, column_name, type, options)</tt>: Removes the column
+  #   named +column_name+ from the table called +table_name+.
+  # * <tt>remove_columns(table_name, *column_names)</tt>: Removes the given
+  #   columns from the table definition.
+  # * <tt>remove_foreign_key(from_table, options_or_to_table)</tt>: Removes the
+  #   given foreign key from the table called +table_name+.
+  # * <tt>remove_index(table_name, column: column_names)</tt>: Removes the index
+  #   specified by +column_names+.
   # * <tt>remove_index(table_name, name: index_name)</tt>: Removes the index
   #   specified by +index_name+.
+  # * <tt>remove_reference(table_name, ref_name, options)</tt>: Removes the
+  #   reference(s) on +table_name+ specified by +ref_name+.
+  # * <tt>remove_timestamps(table_name, options)</tt>: Removes the timestamp
+  #   columns (+created_at+ and +updated_at+) from the table definition.
   #
   # == Irreversible transformations
   #
@@ -165,24 +300,24 @@ module ActiveRecord
   #
   #   rails generate migration add_fieldname_to_tablename fieldname:string
   #
-  # This will generate the file <tt>timestamp_add_fieldname_to_tablename</tt>, which will look like this:
-  #   class AddFieldnameToTablename < ActiveRecord::Migration
+  # This will generate the file <tt>timestamp_add_fieldname_to_tablename.rb</tt>, which will look like this:
+  #   class AddFieldnameToTablename < ActiveRecord::Migration[5.0]
   #     def change
-  #       add_column :tablenames, :field, :string
+  #       add_column :tablenames, :fieldname, :string
   #     end
   #   end
   #
   # To run migrations against the currently configured database, use
-  # <tt>rake db:migrate</tt>. This will update the database by running all of the
+  # <tt>rails db:migrate</tt>. This will update the database by running all of the
   # pending migrations, creating the <tt>schema_migrations</tt> table
   # (see "About the schema_migrations table" section below) if missing. It will also
   # invoke the db:schema:dump task, which will update your db/schema.rb file
   # to match the structure of your database.
   #
   # To roll the database back to a previous migration version, use
-  # <tt>rake db:migrate VERSION=X</tt> where <tt>X</tt> is the version to which
+  # <tt>rails db:migrate VERSION=X</tt> where <tt>X</tt> is the version to which
   # you wish to downgrade. Alternatively, you can also use the STEP option if you
-  # wish to rollback last few migrations. <tt>rake db:migrate STEP=2</tt> will rollback
+  # wish to rollback last few migrations. <tt>rails db:migrate STEP=2</tt> will rollback
   # the latest two migrations.
   #
   # If any of the migrations throw an <tt>ActiveRecord::IrreversibleMigration</tt> exception,
@@ -197,7 +332,7 @@ module ActiveRecord
   #
   # Not all migrations change the schema. Some just fix the data:
   #
-  #   class RemoveEmptyTags < ActiveRecord::Migration
+  #   class RemoveEmptyTags < ActiveRecord::Migration[5.0]
   #     def up
   #       Tag.all.each { |tag| tag.destroy if tag.pages.empty? }
   #     end
@@ -210,7 +345,7 @@ module ActiveRecord
   #
   # Others remove columns when they migrate up instead of down:
   #
-  #   class RemoveUnnecessaryItemAttributes < ActiveRecord::Migration
+  #   class RemoveUnnecessaryItemAttributes < ActiveRecord::Migration[5.0]
   #     def up
   #       remove_column :items, :incomplete_items_count
   #       remove_column :items, :completed_items_count
@@ -224,7 +359,7 @@ module ActiveRecord
   #
   # And sometimes you need to do something in SQL not abstracted directly by migrations:
   #
-  #   class MakeJoinUnique < ActiveRecord::Migration
+  #   class MakeJoinUnique < ActiveRecord::Migration[5.0]
   #     def up
   #       execute "ALTER TABLE `pages_linked_pages` ADD UNIQUE `page_id_linked_page_id` (`page_id`,`linked_page_id`)"
   #     end
@@ -241,7 +376,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
+  #   class AddPeopleSalary < ActiveRecord::Migration[5.0]
   #     def up
   #       add_column :people, :salary, :integer
   #       Person.reset_column_information
@@ -275,21 +410,6 @@ module ActiveRecord
   # The phrase "Updating salaries..." would then be printed, along with the
   # benchmark for the block when the block completes.
   #
-  # == About the schema_migrations table
-  #
-  # Rails versions 2.0 and prior used to create a table called
-  # <tt>schema_info</tt> when using migrations. This table contained the
-  # version of the schema as of the last applied migration.
-  #
-  # Starting with Rails 2.1, the <tt>schema_info</tt> table is
-  # (automatically) replaced by the <tt>schema_migrations</tt> table, which
-  # contains the version numbers of all the migrations applied.
-  #
-  # As a result, it is now possible to add migration files that are numbered
-  # lower than the current schema version: when migrating up, those
-  # never-applied "interleaved" migrations will be automatically applied, and
-  # when migrating down, never-applied "interleaved" migrations will be skipped.
-  #
   # == Timestamped Migrations
   #
   # By default, Rails generates migrations that look like:
@@ -314,7 +434,7 @@ module ActiveRecord
   # To define a reversible migration, define the +change+ method in your
   # migration like this:
   #
-  #   class TenderloveMigration < ActiveRecord::Migration
+  #   class TenderloveMigration < ActiveRecord::Migration[5.0]
   #     def change
   #       create_table(:horses) do |t|
   #         t.column :content, :text
@@ -344,7 +464,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
+  #   class ChangeEnum < ActiveRecord::Migration[5.0]
   #     disable_ddl_transaction!
   #
   #     def up
@@ -356,7 +476,34 @@ module ActiveRecord
   # are in a Migration with <tt>self.disable_ddl_transaction!</tt>.
   class Migration
     autoload :CommandRecorder, 'active_record/migration/command_recorder'
+    autoload :Compatibility, 'active_record/migration/compatibility'
+
+    # This must be defined before the inherited hook, below
+    class Current < Migration # :nodoc:
+    end
+
+    def self.inherited(subclass) # :nodoc:
+      super
+      if subclass.superclass == Migration
+        subclass.include Compatibility::Legacy
+      end
+    end
+
+    def self.[](version)
+      version = version.to_s
+      name = "V#{version.tr('.', '_')}"
+      unless Compatibility.const_defined?(name)
+        versions = Compatibility.constants.grep(/\AV[0-9_]+\z/).map { |s| s.to_s.delete('V').tr('_', '.').inspect }
+        raise "Unknown migration version #{version.inspect}; expected one of #{versions.sort.join(', ')}"
+      end
+      Compatibility.const_get(name)
+    end
 
+    def self.current_version
+      Rails.version.to_f
+    end
+
+    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 config.active_record.migration_error is set to :page_load
@@ -388,17 +535,22 @@ module ActiveRecord
       attr_accessor :delegate # :nodoc:
       attr_accessor :disable_ddl_transaction # :nodoc:
 
+      def nearest_delegate # :nodoc:
+        delegate || superclass.nearest_delegate
+      end
+
+      # Raises <tt>ActiveRecord::PendingMigrationError</tt> error if any migrations are pending.
       def check_pending!(connection = Base.connection)
         raise ActiveRecord::PendingMigrationError if ActiveRecord::Migrator.needs_migration?(connection)
       end
 
       def load_schema_if_pending!
         if ActiveRecord::Migrator.needs_migration? || !ActiveRecord::Migrator.any_migrations?
-          # Roundrip to Rake to allow plugins to hook into database initialization.
+          # Roundtrip to Rake to allow plugins to hook into database initialization.
           FileUtils.cd Rails.root do
             current_config = Base.connection_config
             Base.clear_all_connections!
-            system("bin/rake db:test:prepare")
+            system("bin/rails db:test:prepare")
             # Establish a new connection, the old database may be gone (db:test:prepare uses purge)
             Base.establish_connection(current_config)
           end
@@ -413,7 +565,7 @@ module ActiveRecord
       end
 
       def method_missing(name, *args, &block) # :nodoc:
-        (delegate || superclass.delegate).send(name, *args, &block)
+        nearest_delegate.send(name, *args, &block)
       end
 
       def migrate(direction)
@@ -453,7 +605,7 @@ module ActiveRecord
     # and create the table 'apples' on the way up, and the reverse
     # on the way down.
     #
-    #   class FixTLMigration < ActiveRecord::Migration
+    #   class FixTLMigration < ActiveRecord::Migration[5.0]
     #     def change
     #       revert do
     #         create_table(:horses) do |t|
@@ -470,9 +622,9 @@ module ActiveRecord
     # Or equivalently, if +TenderloveMigration+ is defined as in the
     # documentation for Migration:
     #
-    #   require_relative '2012121212_tenderlove_migration'
+    #   require_relative '20121212123456_tenderlove_migration'
     #
-    #   class FixupTLMigration < ActiveRecord::Migration
+    #   class FixupTLMigration < ActiveRecord::Migration[5.0]
     #     def change
     #       revert TenderloveMigration
     #
@@ -486,13 +638,13 @@ module ActiveRecord
     def revert(*migration_classes)
       run(*migration_classes.reverse, revert: true) unless migration_classes.empty?
       if block_given?
-        if @connection.respond_to? :revert
-          @connection.revert { yield }
+        if connection.respond_to? :revert
+          connection.revert { yield }
         else
-          recorder = CommandRecorder.new(@connection)
+          recorder = CommandRecorder.new(connection)
           @connection = recorder
           suppress_messages do
-            @connection.revert { yield }
+            connection.revert { yield }
           end
           @connection = recorder.delegate
           recorder.commands.each do |cmd, args, block|
@@ -503,7 +655,7 @@ module ActiveRecord
     end
 
     def reverting?
-      @connection.respond_to?(:reverting) && @connection.reverting
+      connection.respond_to?(:reverting) && connection.reverting
     end
 
     class ReversibleBlockHelper < Struct.new(:reverting) # :nodoc:
@@ -525,7 +677,7 @@ module ActiveRecord
     # when the three columns 'first_name', 'last_name' and 'full_name' exist,
     # even when migrating down:
     #
-    #    class SplitNameMigration < ActiveRecord::Migration
+    #    class SplitNameMigration < ActiveRecord::Migration[5.0]
     #      def change
     #        add_column :users, :first_name, :string
     #        add_column :users, :last_name, :string
@@ -560,7 +712,7 @@ module ActiveRecord
         revert { run(*migration_classes, direction: dir, revert: true) }
       else
         migration_classes.each do |migration_class|
-          migration_class.new.exec_migration(@connection, dir)
+          migration_class.new.exec_migration(connection, dir)
         end
       end
     end
@@ -649,10 +801,10 @@ module ActiveRecord
     end
 
     def method_missing(method, *arguments, &block)
-      arg_list = arguments.map{ |a| a.inspect } * ', '
+      arg_list = arguments.map(&:inspect) * ', '
 
       say_with_time "#{method}(#{arg_list})" do
-        unless @connection.respond_to? :revert
+        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) ||
@@ -731,7 +883,9 @@ module ActiveRecord
       end
     end
 
-    def table_name_options(config = ActiveRecord::Base)
+    # 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:
       {
         table_name_prefix: config.table_name_prefix,
         table_name_suffix: config.table_name_suffix
@@ -823,7 +977,7 @@ module ActiveRecord
         new(:up, migrations, target_version).migrate
       end
 
-      def down(migrations_paths, target_version = nil, &block)
+      def down(migrations_paths, target_version = nil)
         migrations = migrations(migrations_paths)
         migrations.select! { |m| yield m } if block_given?
 
@@ -843,10 +997,12 @@ module ActiveRecord
       end
 
       def get_all_versions(connection = Base.connection)
-        if connection.table_exists?(schema_migrations_table_name)
-          SchemaMigration.all.map { |x| x.version.to_i }.sort
-        else
-          []
+        ActiveSupport::Deprecation.silence do
+          if connection.table_exists?(schema_migrations_table_name)
+            SchemaMigration.all.map { |x| x.version.to_i }.sort
+          else
+            []
+          end
         end
       end
 
@@ -862,32 +1018,30 @@ module ActiveRecord
         migrations(migrations_paths).any?
       end
 
-      def last_version
-        last_migration.version
-      end
-
       def last_migration #:nodoc:
         migrations(migrations_paths).last || NullMigration.new
       end
 
       def migrations_paths
         @migrations_paths ||= ['db/migrate']
-        # just to not break things if someone uses: migration_path = some_string
+        # just to not break things if someone uses: migrations_path = some_string
         Array(@migrations_paths)
       end
 
-      def migrations_path
-        migrations_paths.first
+      def match_to_migration_filename?(filename) # :nodoc:
+        File.basename(filename) =~ Migration::MigrationFilenameRegexp
       end
 
       def parse_migration_filename(filename) # :nodoc:
-        File.basename(filename).scan(/\A([0-9]+)_([_a-z0-9]*)\.?([_a-z0-9]*)?\.rb\z/).first
+        File.basename(filename).scan(Migration::MigrationFilenameRegexp).first
       end
 
       def migrations(paths)
         paths = Array(paths)
 
-        migrations = migration_files(paths).map do |file|
+        files = Dir[*paths.map { |p| "#{p}/**/[0-9]*_*.rb" }]
+
+        migrations = files.map do |file|
           version, name, scope = parse_migration_filename(file)
           raise IllegalMigrationNameError.new(file) unless version
           version = version.to_i
@@ -899,30 +1053,6 @@ module ActiveRecord
         migrations.sort_by(&:version)
       end
 
-      def migrations_status(paths)
-        paths = Array(paths)
-
-        db_list = ActiveRecord::SchemaMigration.normalized_versions
-
-        file_list = migration_files(paths).map do |file|
-          version, name, scope = parse_migration_filename(file)
-          raise IllegalMigrationNameError.new(file) unless version
-          version = ActiveRecord::SchemaMigration.normalize_migration_number(version)
-          status = db_list.delete(version) ? "up" : "down"
-          [status, version, (name + scope).humanize]
-        end.compact
-
-        db_list.map! do |version|
-          ["up", version, "********** NO FILE **********"]
-        end
-
-        (db_list + file_list).sort_by { |_, version, _| version }
-      end
-
-      def migration_files(paths)
-        Dir[*paths.flat_map { |path| "#{path}/**/[0-9]*_*.rb" }]
-      end
-
       private
 
       def move(direction, migrations_paths, steps)
@@ -960,32 +1090,18 @@ module ActiveRecord
     alias :current :current_migration
 
     def run
-      migration = migrations.detect { |m| m.version == @target_version }
-      raise UnknownMigrationVersionError.new(@target_version) if migration.nil?
-      unless (up? && migrated.include?(migration.version.to_i)) || (down? && !migrated.include?(migration.version.to_i))
-        begin
-          execute_migration_in_transaction(migration, @direction)
-        rescue => e
-          canceled_msg = use_transaction?(migration) ? ", this migration was canceled" : ""
-          raise StandardError, "An error has occurred#{canceled_msg}:\n\n#{e}", e.backtrace
-        end
+      if use_advisory_lock?
+        with_advisory_lock { run_without_lock }
+      else
+        run_without_lock
       end
     end
 
     def migrate
-      if !target && @target_version && @target_version > 0
-        raise UnknownMigrationVersionError.new(@target_version)
-      end
-
-      runnable.each do |migration|
-        Base.logger.info "Migrating to #{migration.name} (#{migration.version})" if Base.logger
-
-        begin
-          execute_migration_in_transaction(migration, @direction)
-        rescue => e
-          canceled_msg = use_transaction?(migration) ? "this and " : ""
-          raise StandardError, "An error has occurred, #{canceled_msg}all later migrations canceled:\n\n#{e}", e.backtrace
-        end
+      if use_advisory_lock?
+        with_advisory_lock { migrate_without_lock }
+      else
+        migrate_without_lock
       end
     end
 
@@ -1010,10 +1126,45 @@ module ActiveRecord
     end
 
     def migrated
-      @migrated_versions ||= Set.new(self.class.get_all_versions)
+      @migrated_versions || load_migrated
+    end
+
+    def load_migrated
+      @migrated_versions = Set.new(self.class.get_all_versions)
     end
 
     private
+
+    def run_without_lock
+      migration = migrations.detect { |m| m.version == @target_version }
+      raise UnknownMigrationVersionError.new(@target_version) if migration.nil?
+      unless (up? && migrated.include?(migration.version.to_i)) || (down? && !migrated.include?(migration.version.to_i))
+        begin
+          execute_migration_in_transaction(migration, @direction)
+        rescue => e
+          canceled_msg = use_transaction?(migration) ? ", this migration was canceled" : ""
+          raise StandardError, "An error has occurred#{canceled_msg}:\n\n#{e}", e.backtrace
+        end
+      end
+    end
+
+    def migrate_without_lock
+      if !target && @target_version && @target_version > 0
+        raise UnknownMigrationVersionError.new(@target_version)
+      end
+
+      runnable.each do |migration|
+        Base.logger.info "Migrating to #{migration.name} (#{migration.version})" if Base.logger
+
+        begin
+          execute_migration_in_transaction(migration, @direction)
+        rescue => e
+          canceled_msg = use_transaction?(migration) ? "this and " : ""
+          raise StandardError, "An error has occurred, #{canceled_msg}all later migrations canceled:\n\n#{e}", e.backtrace
+        end
+      end
+    end
+
     def ran?(migration)
       migrated.include?(migration.version.to_i)
     end
@@ -1075,5 +1226,25 @@ module ActiveRecord
     def use_transaction?(migration)
       !migration.disable_ddl_transaction && Base.connection.supports_ddl_transactions?
     end
+
+    def use_advisory_lock?
+      Base.connection.supports_advisory_locks?
+    end
+
+    def with_advisory_lock
+      lock_id = generate_migrator_advisory_lock_id
+      got_lock = Base.connection.get_advisory_lock(lock_id)
+      raise ConcurrentMigrationError unless got_lock
+      load_migrated # reload schema_migrations to be sure it wasn't changed by another process before we got the lock
+      yield
+    ensure
+      Base.connection.release_advisory_lock(lock_id) if got_lock
+    end
+
+    MIGRATOR_SALT = 2053462845
+    def generate_migrator_advisory_lock_id
+      db_name_hash = Zlib.crc32(Base.connection.current_database)
+      MIGRATOR_SALT * db_name_hash
+    end
   end
 end