activerecord 3.2.22.5 → 5.2.8

data/lib/active_record/migration/command_recorder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   class Migration
     # <tt>ActiveRecord::Migration::CommandRecorder</tt> records commands done during
@@ -5,101 +7,234 @@ module ActiveRecord
     # knows how to invert the following commands:
     #
     # * add_column
+    # * add_foreign_key
     # * add_index
+    # * add_reference
     # * add_timestamps
+    # * change_column
+    # * change_column_default (must supply a :from and :to option)
+    # * change_column_null
+    # * create_join_table
     # * create_table
+    # * disable_extension
+    # * drop_join_table
+    # * drop_table (must supply a block)
+    # * enable_extension
+    # * remove_column (must supply a type)
+    # * remove_columns (must specify at least one column name or more)
+    # * remove_foreign_key (must supply a second table)
+    # * remove_index
+    # * remove_reference
     # * remove_timestamps
     # * rename_column
     # * rename_index
     # * rename_table
     class CommandRecorder
-      attr_accessor :commands, :delegate
+      ReversibleAndIrreversibleMethods = [:create_table, :create_join_table, :rename_table, :add_column, :remove_column,
+        :rename_index, :rename_column, :add_index, :remove_index, :add_timestamps, :remove_timestamps,
+        :change_column_default, :add_reference, :remove_reference, :transaction,
+        :drop_join_table, :drop_table, :execute_block, :enable_extension, :disable_extension,
+        :change_column, :execute, :remove_columns, :change_column_null,
+        :add_foreign_key, :remove_foreign_key
+      ]
+      include JoinTable
+
+      attr_accessor :commands, :delegate, :reverting
 
       def initialize(delegate = nil)
         @commands = []
         @delegate = delegate
+        @reverting = false
+      end
+
+      # While executing the given block, the recorded will be in reverting mode.
+      # All commands recorded will end up being recorded reverted
+      # and in reverse order.
+      # For example:
+      #
+      #   recorder.revert{ recorder.record(:rename_table, [:old, :new]) }
+      #   # same effect as recorder.record(:rename_table, [:new, :old])
+      def revert
+        @reverting = !@reverting
+        previous = @commands
+        @commands = []
+        yield
+      ensure
+        @commands = previous.concat(@commands.reverse)
+        @reverting = !@reverting
       end
 
-      # record +command+. +command+ should be a method name and arguments.
+      # Record +command+. +command+ should be a method name and arguments.
       # For example:
       #
       #   recorder.record(:method_name, [:arg1, :arg2])
-      def record(*command)
-        @commands << command
+      def record(*command, &block)
+        if @reverting
+          @commands << inverse_of(*command, &block)
+        else
+          @commands << (command << block)
+        end
       end
 
-      # Returns a list that represents commands that are the inverse of the
-      # commands stored in +commands+. For example:
+      # Returns the inverse of the given command. For example:
       #
-      #   recorder.record(:rename_table, [:old, :new])
-      #   recorder.inverse # => [:rename_table, [:new, :old]]
+      #   recorder.inverse_of(:rename_table, [:old, :new])
+      #   # => [:rename_table, [:new, :old]]
       #
       # This method will raise an +IrreversibleMigration+ exception if it cannot
-      # invert the +commands+.
-      def inverse
-        @commands.reverse.map { |name, args|
-          method = :"invert_#{name}"
-          raise IrreversibleMigration unless respond_to?(method, true)
-          send(method, args)
-        }
+      # invert the +command+.
+      def inverse_of(command, args, &block)
+        method = :"invert_#{command}"
+        raise IrreversibleMigration, <<-MSG.strip_heredoc unless respond_to?(method, true)
+          This migration uses #{command}, which is not automatically reversible.
+          To make the migration reversible you can either:
+          1. Define #up and #down methods in place of the #change method.
+          2. Use the #reversible method to define reversible behavior.
+        MSG
+        send(method, args, &block)
       end
 
-      def respond_to?(*args) # :nodoc:
-        super || delegate.respond_to?(*args)
-      end
-
-      [:create_table, :change_table, :rename_table, :add_column, :remove_column, :rename_index, :rename_column, :add_index, :remove_index, :add_timestamps, :remove_timestamps, :change_column, :change_column_default].each do |method|
+      ReversibleAndIrreversibleMethods.each do |method|
         class_eval <<-EOV, __FILE__, __LINE__ + 1
-          def #{method}(*args)          # def create_table(*args)
-            record(:"#{method}", args)  #   record(:create_table, args)
-          end                           # end
+          def #{method}(*args, &block)          # def create_table(*args, &block)
+            record(:"#{method}", args, &block)  #   record(:create_table, args, &block)
+          end                                   # end
         EOV
       end
+      alias :add_belongs_to :add_reference
+      alias :remove_belongs_to :remove_reference
 
-      private
-
-      def invert_create_table(args)
-        [:drop_table, [args.first]]
+      def change_table(table_name, options = {}) # :nodoc:
+        yield delegate.update_table_definition(table_name, self)
       end
 
-      def invert_rename_table(args)
-        [:rename_table, args.reverse]
-      end
-
-      def invert_add_column(args)
-        [:remove_column, args.first(2)]
-      end
-
-      def invert_rename_index(args)
-        [:rename_index, [args.first] + args.last(2).reverse]
-      end
-
-      def invert_rename_column(args)
-        [:rename_column, [args.first] + args.last(2).reverse]
-      end
-
-      def invert_add_index(args)
-        table, columns, options = *args
-        index_name = options.try(:[], :name)
-        options_hash =  index_name ? {:name => index_name} : {:column => columns}
-        [:remove_index, [table, options_hash]]
-      end
-
-      def invert_remove_timestamps(args)
-        [:add_timestamps, args]
-      end
-
-      def invert_add_timestamps(args)
-        [:remove_timestamps, args]
-      end
-
-      # Forwards any missing method call to the \target.
-      def method_missing(method, *args, &block)
-        @delegate.send(method, *args, &block)
-      rescue NoMethodError => e
-        raise e, e.message.sub(/ for #<.*$/, " via proxy for #{@delegate}")
-      end
+      private
 
+        module StraightReversions # :nodoc:
+          private
+            { transaction:       :transaction,
+              execute_block:     :execute_block,
+              create_table:      :drop_table,
+              create_join_table: :drop_join_table,
+              add_column:        :remove_column,
+              add_timestamps:    :remove_timestamps,
+              add_reference:     :remove_reference,
+              enable_extension:  :disable_extension
+            }.each do |cmd, inv|
+              [[inv, cmd], [cmd, inv]].uniq.each do |method, inverse|
+                class_eval <<-EOV, __FILE__, __LINE__ + 1
+                  def invert_#{method}(args, &block)    # def invert_create_table(args, &block)
+                    [:#{inverse}, args, block]          #   [:drop_table, args, block]
+                  end                                   # end
+                EOV
+              end
+            end
+        end
+
+        include StraightReversions
+
+        def invert_drop_table(args, &block)
+          if args.size == 1 && block == nil
+            raise ActiveRecord::IrreversibleMigration, "To avoid mistakes, drop_table is only reversible if given options or a block (can be empty)."
+          end
+          super
+        end
+
+        def invert_rename_table(args)
+          [:rename_table, args.reverse]
+        end
+
+        def invert_remove_column(args)
+          raise ActiveRecord::IrreversibleMigration, "remove_column is only reversible if given a type." if args.size <= 2
+          super
+        end
+
+        def invert_rename_index(args)
+          [:rename_index, [args.first] + args.last(2).reverse]
+        end
+
+        def invert_rename_column(args)
+          [:rename_column, [args.first] + args.last(2).reverse]
+        end
+
+        def invert_add_index(args)
+          table, columns, options = *args
+          options ||= {}
+
+          options_hash = options.slice(:name, :algorithm)
+          options_hash[:column] = columns if !options_hash[:name]
+
+          [:remove_index, [table, options_hash]]
+        end
+
+        def invert_remove_index(args)
+          table, options_or_column = *args
+          if (options = options_or_column).is_a?(Hash)
+            unless options[:column]
+              raise ActiveRecord::IrreversibleMigration, "remove_index is only reversible if given a :column option."
+            end
+            options = options.dup
+            [:add_index, [table, options.delete(:column), options]]
+          elsif (column = options_or_column).present?
+            [:add_index, [table, column]]
+          end
+        end
+
+        alias :invert_add_belongs_to :invert_add_reference
+        alias :invert_remove_belongs_to :invert_remove_reference
+
+        def invert_change_column_default(args)
+          table, column, options = *args
+
+          unless options && options.is_a?(Hash) && options.has_key?(:from) && options.has_key?(:to)
+            raise ActiveRecord::IrreversibleMigration, "change_column_default is only reversible if given a :from and :to option."
+          end
+
+          [:change_column_default, [table, column, from: options[:to], to: options[:from]]]
+        end
+
+        def invert_change_column_null(args)
+          args[2] = !args[2]
+          [:change_column_null, args]
+        end
+
+        def invert_add_foreign_key(args)
+          from_table, to_table, add_options = args
+          add_options ||= {}
+
+          if add_options[:name]
+            options = { name: add_options[:name] }
+          elsif add_options[:column]
+            options = { column: add_options[:column] }
+          else
+            options = to_table
+          end
+
+          [:remove_foreign_key, [from_table, options]]
+        end
+
+        def invert_remove_foreign_key(args)
+          from_table, to_table, remove_options = args
+          raise ActiveRecord::IrreversibleMigration, "remove_foreign_key is only reversible if given a second table" if to_table.nil? || to_table.is_a?(Hash)
+
+          reversed_args = [from_table, to_table]
+          reversed_args << remove_options if remove_options
+
+          [:add_foreign_key, reversed_args]
+        end
+
+        def respond_to_missing?(method, _)
+          super || delegate.respond_to?(method)
+        end
+
+        # Forwards any missing method call to the \target.
+        def method_missing(method, *args, &block)
+          if delegate.respond_to?(method)
+            delegate.public_send(method, *args, &block)
+          else
+            super
+          end
+        end
     end
   end
 end

data/lib/active_record/migration/compatibility.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class Migration
+    module Compatibility # :nodoc: all
+      def self.find(version)
+        version = version.to_s
+        name = "V#{version.tr('.', '_')}"
+        unless const_defined?(name)
+          versions = constants.grep(/\AV[0-9_]+\z/).map { |s| s.to_s.delete("V").tr("_", ".").inspect }
+          raise ArgumentError, "Unknown migration version #{version.inspect}; expected one of #{versions.sort.join(', ')}"
+        end
+        const_get(name)
+      end
+
+      V5_2 = Current
+
+      class V5_1 < V5_2
+        def change_column(table_name, column_name, type, options = {})
+          if connection.adapter_name == "PostgreSQL"
+            super(table_name, column_name, type, options.except(:default, :null, :comment))
+            connection.change_column_default(table_name, column_name, options[:default]) if options.key?(:default)
+            connection.change_column_null(table_name, column_name, options[:null], options[:default]) if options.key?(:null)
+            connection.change_column_comment(table_name, column_name, options[:comment]) if options.key?(:comment)
+          else
+            super
+          end
+        end
+
+        def create_table(table_name, options = {})
+          if connection.adapter_name == "Mysql2"
+            super(table_name, options: "ENGINE=InnoDB", **options)
+          else
+            super
+          end
+        end
+      end
+
+      class V5_0 < V5_1
+        module TableDefinition
+          def primary_key(name, type = :primary_key, **options)
+            type = :integer if type == :primary_key
+            super
+          end
+
+          def references(*args, **options)
+            super(*args, type: :integer, **options)
+          end
+          alias :belongs_to :references
+        end
+
+        def create_table(table_name, options = {})
+          if connection.adapter_name == "PostgreSQL"
+            if options[:id] == :uuid && !options.key?(:default)
+              options[:default] = "uuid_generate_v4()"
+            end
+          end
+
+          unless connection.adapter_name == "Mysql2" && options[:id] == :bigint
+            if [:integer, :bigint].include?(options[:id]) && !options.key?(:default)
+              options[:default] = nil
+            end
+          end
+
+          # Since 5.1 PostgreSQL adapter uses bigserial type for primary
+          # keys by default and MySQL uses bigint. This compat layer makes old migrations utilize
+          # serial/int type instead -- the way it used to work before 5.1.
+          unless options.key?(:id)
+            options[:id] = :integer
+          end
+
+          if block_given?
+            super do |t|
+              yield compatible_table_definition(t)
+            end
+          else
+            super
+          end
+        end
+
+        def change_table(table_name, options = {})
+          if block_given?
+            super do |t|
+              yield compatible_table_definition(t)
+            end
+          else
+            super
+          end
+        end
+
+        def create_join_table(table_1, table_2, column_options: {}, **options)
+          column_options.reverse_merge!(type: :integer)
+
+          if block_given?
+            super do |t|
+              yield compatible_table_definition(t)
+            end
+          else
+            super
+          end
+        end
+
+        def add_column(table_name, column_name, type, options = {})
+          if type == :primary_key
+            type = :integer
+            options[:primary_key] = true
+          end
+          super
+        end
+
+        def add_reference(table_name, ref_name, **options)
+          super(table_name, ref_name, type: :integer, **options)
+        end
+        alias :add_belongs_to :add_reference
+
+        private
+          def compatible_table_definition(t)
+            class << t
+              prepend TableDefinition
+            end
+            t
+          end
+      end
+
+      class V4_2 < V5_0
+        module TableDefinition
+          def references(*, **options)
+            options[:index] ||= false
+            super
+          end
+          alias :belongs_to :references
+
+          def timestamps(**options)
+            options[:null] = true if options[:null].nil?
+            super
+          end
+        end
+
+        def create_table(table_name, options = {})
+          if block_given?
+            super do |t|
+              yield compatible_table_definition(t)
+            end
+          else
+            super
+          end
+        end
+
+        def change_table(table_name, options = {})
+          if block_given?
+            super do |t|
+              yield compatible_table_definition(t)
+            end
+          else
+            super
+          end
+        end
+
+        def add_reference(*, **options)
+          options[:index] ||= false
+          super
+        end
+        alias :add_belongs_to :add_reference
+
+        def add_timestamps(_, **options)
+          options[:null] = true if options[:null].nil?
+          super
+        end
+
+        def index_exists?(table_name, column_name, options = {})
+          column_names = Array(column_name).map(&:to_s)
+          options[:name] =
+            if options[:name].present?
+              options[:name].to_s
+            else
+              connection.index_name(table_name, column: column_names)
+            end
+          super
+        end
+
+        def remove_index(table_name, options = {})
+          options = { column: options } unless options.is_a?(Hash)
+          options[:name] = index_name_for_remove(table_name, options)
+          super(table_name, options)
+        end
+
+        private
+          def compatible_table_definition(t)
+            class << t
+              prepend TableDefinition
+            end
+            super
+          end
+
+          def index_name_for_remove(table_name, options = {})
+            index_name = connection.index_name(table_name, options)
+
+            unless connection.index_name_exists?(table_name, index_name)
+              if options.is_a?(Hash) && options.has_key?(:name)
+                options_without_column = options.dup
+                options_without_column.delete :column
+                index_name_without_column = connection.index_name(table_name, options_without_column)
+
+                if connection.index_name_exists?(table_name, index_name_without_column)
+                  return index_name_without_column
+                end
+              end
+
+              raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' does not exist"
+            end
+
+            index_name
+          end
+      end
+    end
+  end
+end

data/lib/active_record/migration/join_table.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class Migration
+    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)
+        end
+
+        def join_table_name(table_1, table_2)
+          ModelSchema.derive_join_table_name(table_1, table_2).to_sym
+        end
+    end
+  end
+end