activerecord 5.0.7.2 → 5.1.0.beta1

data/lib/active_record/migration/command_recorder.rb

@@ -92,7 +92,7 @@ module ActiveRecord
         send(method, args, &block)
       end
 
-      def respond_to?(*args) # :nodoc:
+      def respond_to_missing?(*args) # :nodoc:
         super || delegate.respond_to?(*args)
       end
 
@@ -112,127 +112,127 @@ module ActiveRecord
 
       private
 
-      module StraightReversions
-        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
+        module StraightReversions
+          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
-      end
 
-      include StraightReversions
+        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)."
+        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
-        super
-      end
 
-      def invert_rename_table(args)
-        [:rename_table, args.reverse]
-      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_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_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_rename_column(args)
+          [:rename_column, [args.first] + args.last(2).reverse]
+        end
 
-      def invert_add_index(args)
-        table, columns, options = *args
-        options ||= {}
+        def invert_add_index(args)
+          table, columns, options = *args
+          options ||= {}
 
-        index_name = options[:name]
-        options_hash = index_name ? { name: index_name } : { column: columns }
+          index_name = options[:name]
+          options_hash = index_name ? { name: index_name } : { column: columns }
 
-        [:remove_index, [table, options_hash]]
-      end
+          [: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."
+        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
-          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
+        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
 
-      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
 
-        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."
+          [:change_column_default, [table, column, from: options[:to], to: options[:from]]]
         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_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 ||= {}
 
-      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
 
-        if add_options[:name]
-          options = { name: add_options[:name] }
-        elsif add_options[:column]
-          options = { column: add_options[:column] }
-        else
-          options = to_table
+          [:remove_foreign_key, [from_table, options]]
         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)
+        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
+          reversed_args = [from_table, to_table]
+          reversed_args << remove_options if remove_options
 
-        [:add_foreign_key, reversed_args]
-      end
+          [:add_foreign_key, reversed_args]
+        end
 
-      # Forwards any missing method call to the \target.
-      def method_missing(method, *args, &block)
-        if @delegate.respond_to?(method)
-          @delegate.send(method, *args, &block)
-        else
-          super
+        # Forwards any missing method call to the \target.
+        def method_missing(method, *args, &block)
+          if @delegate.respond_to?(method)
+            @delegate.send(method, *args, &block)
+          else
+            super
+          end
         end
-      end
     end
   end
 end

data/lib/active_record/migration/compatibility.rb

@@ -5,15 +5,74 @@ module ActiveRecord
         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 }
+          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_0 = Current
+      V5_1 = Current
 
-      module FourTwoShared
+      class V5_0 < V5_1
+        module TableDefinition
+          def references(*args, **options)
+            super(*args, type: :integer, **options)
+          end
+          alias :belongs_to :references
+        end
+
+        def create_table(table_name, options = {})
+          if adapter_name == "PostgreSQL"
+            if options[:id] == :uuid && !options.key?(:default)
+              options[:default] = "uuid_generate_v4()"
+            end
+          end
+
+          unless adapter_name == "Mysql2" && options[:id] == :bigint
+            if [:integer, :bigint].include?(options[:id]) && !options.key?(:default)
+              options[:default] = nil
+            end
+          end
+
+          # Since 5.1 Postgres 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(table_name, options) do |t|
+              class << t
+                prepend TableDefinition
+              end
+              yield t
+            end
+          else
+            super
+          end
+        end
+
+        def change_table(table_name, options = {})
+          if block_given?
+            super(table_name, options) do |t|
+              class << t
+                prepend TableDefinition
+              end
+              yield t
+            end
+          else
+            super
+          end
+        end
+
+        def add_reference(table_name, ref_name, **options)
+          super(table_name, ref_name, type: :integer, **options)
+        end
+        alias :add_belongs_to :add_reference
+      end
+
+      class V4_2 < V5_0
         module TableDefinition
           def references(*, **options)
             options[:index] ||= false
@@ -21,7 +80,7 @@ module ActiveRecord
           end
           alias :belongs_to :references
 
-          def timestamps(*, **options)
+          def timestamps(**options)
             options[:null] = true if options[:null].nil?
             super
           end
@@ -59,7 +118,7 @@ module ActiveRecord
         end
         alias :add_belongs_to :add_reference
 
-        def add_timestamps(*, **options)
+        def add_timestamps(_, **options)
           options[:null] = true if options[:null].nil?
           super
         end
@@ -83,43 +142,23 @@ module ActiveRecord
 
         private
 
-        def index_name_for_remove(table_name, options = {})
-          index_name = index_name(table_name, options)
+          def index_name_for_remove(table_name, options = {})
+            index_name = index_name(table_name, options)
 
-          unless index_name_exists?(table_name, index_name, true)
-            if options.is_a?(Hash) && options.has_key?(:name)
-              options_without_column = options.dup
-              options_without_column.delete :column
-              index_name_without_column = index_name(table_name, options_without_column)
+            unless 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 = index_name(table_name, options_without_column)
+
+                return index_name_without_column if index_name_exists?(table_name, index_name_without_column)
+              end
 
-              return index_name_without_column if index_name_exists?(table_name, index_name_without_column, false)
+              raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' does not exist"
             end
 
-            raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' does not exist"
+            index_name
           end
-
-          index_name
-        end
-      end
-
-      class V4_2 < V5_0
-        # 4.2 is defined as a module because it needs to be shared with
-        # Legacy. When the time comes, V5_0 should be defined straight
-        # in its class.
-        include FourTwoShared
-      end
-
-      module Legacy
-        include FourTwoShared
-
-        def migrate(*)
-          ActiveSupport::Deprecation.warn \
-            "Directly inheriting from ActiveRecord::Migration is deprecated. " \
-            "Please specify the Rails release the migration was written for:\n" \
-            "\n" \
-            "  class #{self.class.name} < ActiveRecord::Migration[4.2]"
-          super
-        end
       end
     end
   end

data/lib/active_record/migration/join_table.rb

@@ -3,13 +3,13 @@ module ActiveRecord
     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 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
+        def join_table_name(table_1, table_2)
+          ModelSchema.derive_join_table_name(table_1, table_2).to_sym
+        end
     end
   end
 end

data/lib/active_record/model_schema.rb

@@ -1,5 +1,3 @@
-require "monitor"
-
 module ActiveRecord
   module ModelSchema
     extend ActiveSupport::Concern
@@ -113,6 +111,20 @@ module ActiveRecord
     # If true, the default table name for a Product class will be "products". If false, it would just be "product".
     # See table_name for the full rules on table/class naming. This is true, by default.
 
+    ##
+    # :singleton-method: ignored_columns
+    # :call-seq: ignored_columns
+    #
+    # The list of columns names the model should ignore. Ignored columns won't have attribute
+    # accessors defined, and won't be referenced in SQL queries.
+
+    ##
+    # :singleton-method: ignored_columns=
+    # :call-seq: ignored_columns=(columns)
+    #
+    # Sets the columns names the model should ignore. Ignored columns won't have attribute
+    # accessors defined, and won't be referenced in SQL queries.
+
     included do
       mattr_accessor :primary_key_prefix_type, instance_writer: false
 
@@ -134,12 +146,12 @@ module ActiveRecord
       class_attribute :pluralize_table_names, instance_writer: false
       self.pluralize_table_names = true
 
-      self.inheritance_column = 'type'
+      class_attribute :ignored_columns, instance_accessor: false
       self.ignored_columns = [].freeze
 
-      delegate :type_for_attribute, to: :class
+      self.inheritance_column = "type"
 
-      initialize_load_schema_monitor
+      delegate :type_for_attribute, to: :class
     end
 
     # Derives the join table name for +first_table+ and +second_table+. The
@@ -240,11 +252,11 @@ module ActiveRecord
       end
 
       def full_table_name_prefix #:nodoc:
-        (parents.detect{ |p| p.respond_to?(:table_name_prefix) } || self).table_name_prefix
+        (parents.detect { |p| p.respond_to?(:table_name_prefix) } || self).table_name_prefix
       end
 
       def full_table_name_suffix #:nodoc:
-        (parents.detect {|p| p.respond_to?(:table_name_suffix) } || self).table_name_suffix
+        (parents.detect { |p| p.respond_to?(:table_name_suffix) } || self).table_name_suffix
       end
 
       # Defines the name of the table column which will store the class name on single-table
@@ -266,22 +278,6 @@ module ActiveRecord
         @explicit_inheritance_column = true
       end
 
-      # The list of columns names the model should ignore. Ignored columns won't have attribute
-      # accessors defined, and won't be referenced in SQL queries.
-      def ignored_columns
-        if defined?(@ignored_columns)
-          @ignored_columns
-        else
-          superclass.ignored_columns
-        end
-      end
-
-      # Sets the columns names the model should ignore. Ignored columns won't have attribute
-      # accessors defined, and won't be referenced in SQL queries.
-      def ignored_columns=(columns)
-        @ignored_columns = columns.map(&:to_s)
-      end
-
       def sequence_name
         if base_class == self
           @sequence_name ||= reset_sequence_name
@@ -296,7 +292,7 @@ module ActiveRecord
       end
 
       # Sets the name of the sequence to use when generating ids to the given
-      # value, or (if the value is nil or false) to the value returned by the
+      # value, or (if the value is +nil+ or +false+) to the value returned by the
       # given block. This is required for Oracle and is useful for any
       # database which relies on sequences for primary key generation.
       #
@@ -332,11 +328,11 @@ module ActiveRecord
       end
 
       def attributes_builder # :nodoc:
-        unless defined?(@attributes_builder) && @attributes_builder
-          defaults = _default_attributes.except(*(column_names - [primary_key]))
-          @attributes_builder = AttributeSet::Builder.new(attribute_types, defaults)
+        @attributes_builder ||= AttributeSet::Builder.new(attribute_types, primary_key) do |name|
+          unless columns_hash.key?(name)
+            _default_attributes[name].dup
+          end
         end
-        @attributes_builder
       end
 
       def columns_hash # :nodoc:
@@ -351,7 +347,11 @@ module ActiveRecord
 
       def attribute_types # :nodoc:
         load_schema
-        @attribute_types ||= Hash.new(Type::Value.new)
+        @attribute_types ||= Hash.new(Type.default_value)
+      end
+
+      def yaml_encoder # :nodoc:
+        @yaml_encoder ||= AttributeSet::YAMLEncoder.new(attribute_types)
       end
 
       # Returns the type of the attribute with the given name, after applying
@@ -392,7 +392,12 @@ module ActiveRecord
       # Returns an array of column objects where the primary id, all columns ending in "_id" or "_count",
       # and columns used for single table inheritance have been removed.
       def content_columns
-        @content_columns ||= columns.reject { |c| c.name == primary_key || c.name =~ /(_id|_count)$/ || c.name == inheritance_column }
+        @content_columns ||= columns.reject do |c|
+          c.name == primary_key ||
+          c.name == inheritance_column ||
+          c.name.end_with?("_id") ||
+          c.name.end_with?("_count")
+        end
       end
 
       # Resets all the cached information about columns, which will cause them
@@ -430,110 +435,71 @@ module ActiveRecord
         initialize_find_by_cache
       end
 
-      protected
-
-      def initialize_load_schema_monitor
-        @load_schema_monitor = Monitor.new
-      end
-
       private
 
-      def inherited(child_class)
-        super
-        child_class.initialize_load_schema_monitor
-      end
-
-      def schema_loaded?
-        defined?(@schema_loaded) && @schema_loaded
-      end
-
-      def load_schema
-        return if schema_loaded?
-        @load_schema_monitor.synchronize do
-          return if defined?(@columns_hash) && @columns_hash
-
-          load_schema!
-
-          @schema_loaded = true
+        def schema_loaded?
+          defined?(@columns_hash) && @columns_hash
         end
-      end
 
-      def load_schema!
-        @columns_hash = connection.schema_cache.columns_hash(table_name).except(*ignored_columns)
-        @columns_hash.each do |name, column|
-          warn_if_deprecated_type(column)
-          define_attribute(
-            name,
-            connection.lookup_cast_type_from_column(column),
-            default: column.default,
-            user_provided_default: false
-          )
+        def load_schema
+          unless schema_loaded?
+            load_schema!
+          end
         end
-      end
 
-      def reload_schema_from_cache
-        @arel_engine = nil
-        @arel_table = nil
-        @column_names = nil
-        @attribute_types = nil
-        @content_columns = nil
-        @default_attributes = nil
-        @inheritance_column = nil unless defined?(@explicit_inheritance_column) && @explicit_inheritance_column
-        @attributes_builder = nil
-        @columns = nil
-        @columns_hash = nil
-        @schema_loaded = false
-        @attribute_names = nil
-        direct_descendants.each do |descendant|
-          descendant.send(:reload_schema_from_cache)
+        def load_schema!
+          @columns_hash = connection.schema_cache.columns_hash(table_name).except(*ignored_columns)
+          @columns_hash.each do |name, column|
+            define_attribute(
+              name,
+              connection.lookup_cast_type_from_column(column),
+              default: column.default,
+              user_provided_default: false
+            )
+          end
         end
-      end
-
-      # Guesses the table name, but does not decorate it with prefix and suffix information.
-      def undecorated_table_name(class_name = base_class.name)
-        table_name = class_name.to_s.demodulize.underscore
-        pluralize_table_names ? table_name.pluralize : table_name
-      end
 
-      # Computes and returns a table name according to default conventions.
-      def compute_table_name
-        base = base_class
-        if self == base
-          # Nested classes are prefixed with singular parent table name.
-          if parent < Base && !parent.abstract_class?
-            contained = parent.table_name
-            contained = contained.singularize if parent.pluralize_table_names
-            contained += '_'
+        def reload_schema_from_cache
+          @arel_engine = nil
+          @arel_table = nil
+          @column_names = nil
+          @attribute_types = nil
+          @content_columns = nil
+          @default_attributes = nil
+          @inheritance_column = nil unless defined?(@explicit_inheritance_column) && @explicit_inheritance_column
+          @attributes_builder = nil
+          @columns = nil
+          @columns_hash = nil
+          @attribute_names = nil
+          @yaml_encoder = nil
+          direct_descendants.each do |descendant|
+            descendant.send(:reload_schema_from_cache)
           end
+        end
 
-          "#{full_table_name_prefix}#{contained}#{undecorated_table_name(name)}#{full_table_name_suffix}"
-        else
-          # STI subclasses always use their superclass' table.
-          base.table_name
+        # Guesses the table name, but does not decorate it with prefix and suffix information.
+        def undecorated_table_name(class_name = base_class.name)
+          table_name = class_name.to_s.demodulize.underscore
+          pluralize_table_names ? table_name.pluralize : table_name
         end
-      end
 
-      def warn_if_deprecated_type(column)
-        return if attributes_to_define_after_schema_loads.key?(column.name)
-        if column.respond_to?(:oid) && column.sql_type.start_with?("point")
-          if column.array?
-            array_arguments = ", array: true"
+        # Computes and returns a table name according to default conventions.
+        def compute_table_name
+          base = base_class
+          if self == base
+            # Nested classes are prefixed with singular parent table name.
+            if parent < Base && !parent.abstract_class?
+              contained = parent.table_name
+              contained = contained.singularize if parent.pluralize_table_names
+              contained += "_"
+            end
+
+            "#{full_table_name_prefix}#{contained}#{undecorated_table_name(name)}#{full_table_name_suffix}"
           else
-            array_arguments = ""
+            # STI subclasses always use their superclass' table.
+            base.table_name
           end
-          ActiveSupport::Deprecation.warn(<<-WARNING.strip_heredoc)
-            The behavior of the `:point` type will be changing in Rails 5.1 to
-            return a `Point` object, rather than an `Array`. If you'd like to
-            keep the old behavior, you can add this line to #{self.name}:
-
-              attribute :#{column.name}, :legacy_point#{array_arguments}
-
-            If you'd like the new behavior today, you can add this line:
-
-              attribute :#{column.name}, :point#{array_arguments}
-          WARNING
         end
-      end
     end
   end
 end