activerecord 4.2.11.3 → 5.0.0.beta1

data/lib/active_record/migration/command_recorder.rb

@@ -5,15 +5,36 @@ module ActiveRecord
     # knows how to invert the following commands:
     #
     # * add_column
+    # * add_foreign_key
     # * add_index
+    # * add_reference
     # * add_timestamps
-    # * create_table
+    # * 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
+      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
@@ -41,7 +62,7 @@ module ActiveRecord
         @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])
@@ -62,7 +83,12 @@ module ActiveRecord
       # invert the +command+.
       def inverse_of(command, args, &block)
         method = :"invert_#{command}"
-        raise IrreversibleMigration unless respond_to?(method, true)
+        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
 
@@ -70,14 +96,7 @@ module ActiveRecord
         super || delegate.respond_to?(*args)
       end
 
-      [: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,
-        :change_column, :execute, :remove_columns, :change_column_null,
-        :add_foreign_key, :remove_foreign_key
-       # irreversible methods need to be here too
-      ].each do |method|
+      ReversibleAndIrreversibleMethods.each do |method|
         class_eval <<-EOV, __FILE__, __LINE__ + 1
           def #{method}(*args, &block)          # def create_table(*args, &block)
             record(:"#{method}", args, &block)  #   record(:create_table, args, &block)
@@ -151,19 +170,31 @@ module ActiveRecord
       end
 
       def invert_remove_index(args)
-        table, options = *args
-
-        unless options && options.is_a?(Hash) && options[:column]
-          raise ActiveRecord::IrreversibleMigration, "remove_index is only reversible if given a :column option."
+        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]]
       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]
@@ -184,6 +215,16 @@ module ActiveRecord
         [: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
+
       # Forwards any missing method call to the \target.
       def method_missing(method, *args, &block)
         if @delegate.respond_to?(method)

data/lib/active_record/migration/compatibility.rb

@@ -0,0 +1,90 @@
+module ActiveRecord
+  class Migration
+    module Compatibility # :nodoc: all
+      V5_0 = Current
+
+      module FourTwoShared
+        module TableDefinition
+          def timestamps(*, **options)
+            options[:null] = true if options[:null].nil?
+            super
+          end
+        end
+
+        def create_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_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.key?(:name).present?
+              options[:name].to_s
+            else
+              index_name(table_name, column: column_names)
+            end
+          super
+        end
+
+        def remove_index(table_name, options = {})
+          index_name = index_name_for_remove(table_name, options)
+          execute "DROP INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)}"
+        end
+
+        private
+
+        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)
+
+              return index_name_without_column if index_name_exists?(table_name, index_name_without_column, false)
+            end
+
+            raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' does not exist"
+          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 run(*)
+          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
+end

data/lib/active_record/model_schema.rb

@@ -50,6 +50,13 @@ module ActiveRecord
       class_attribute :pluralize_table_names, instance_writer: false
       self.pluralize_table_names = true
 
+      ##
+      # :singleton-method:
+      # Accessor for 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.
+      class_attribute :ignored_columns, instance_accessor: false
+      self.ignored_columns = [].freeze
+
       self.inheritance_column = 'type'
 
       delegate :type_for_attribute, to: :class
@@ -111,17 +118,6 @@ module ActiveRecord
       #   class Mouse < ActiveRecord::Base
       #     self.table_name = "mice"
       #   end
-      #
-      # Alternatively, you can override the table_name method to define your
-      # own computation. (Possibly using <tt>super</tt> to manipulate the default
-      # table name.) Example:
-      #
-      #   class Post < ActiveRecord::Base
-      #     def self.table_name
-      #       "special_" + super
-      #     end
-      #   end
-      #   Post.table_name # => "special_posts"
       def table_name
         reset_table_name unless defined?(@table_name)
         @table_name
@@ -132,9 +128,6 @@ module ActiveRecord
       #   class Project < ActiveRecord::Base
       #     self.table_name = "project"
       #   end
-      #
-      # You can also just define your own <tt>self.table_name</tt> method; see
-      # the documentation for ActiveRecord::Base#table_name.
       def table_name=(value)
         value = value && value.to_s
 
@@ -147,7 +140,7 @@ module ActiveRecord
         @quoted_table_name = nil
         @arel_table        = nil
         @sequence_name     = nil unless defined?(@explicit_sequence_name) && @explicit_sequence_name
-        @relation          = Relation.create(self, arel_table)
+        @predicate_builder = nil
       end
 
       # Returns a quoted version of the table name, used to construct SQL statements.
@@ -227,37 +220,46 @@ module ActiveRecord
 
       # Indicates whether the table associated with this class exists
       def table_exists?
-        connection.schema_cache.table_exists?(table_name)
+        connection.schema_cache.data_source_exists?(table_name)
       end
 
       def attributes_builder # :nodoc:
-        @attributes_builder ||= AttributeSet::Builder.new(column_types, primary_key)
+        @attributes_builder ||= AttributeSet::Builder.new(attribute_types, primary_key)
       end
 
-      def column_types # :nodoc:
-        @column_types ||= columns_hash.transform_values(&:cast_type).tap do |h|
-          h.default = Type::Value.new
-        end
+      def columns_hash # :nodoc:
+        load_schema
+        @columns_hash
+      end
+
+      def columns
+        load_schema
+        @columns ||= columns_hash.values
+      end
+
+      def attribute_types # :nodoc:
+        load_schema
+        @attribute_types ||= Hash.new(Type::Value.new)
       end
 
       def type_for_attribute(attr_name) # :nodoc:
-        column_types[attr_name]
+        attribute_types[attr_name]
       end
 
       # Returns a hash where the keys are column names and the values are
-      # default values when instantiating the AR object for this table.
+      # default values when instantiating the Active Record object for this table.
       def column_defaults
-        _default_attributes.dup.to_hash
+        load_schema
+        _default_attributes.to_hash
       end
 
       def _default_attributes # :nodoc:
-        @default_attributes ||= attributes_builder.build_from_database(
-          raw_default_values)
+        @default_attributes ||= AttributeSet.new({})
       end
 
       # Returns an array of column names as strings.
       def column_names
-        @column_names ||= columns.map { |column| column.name }
+        @column_names ||= columns.map(&:name)
       end
 
       # Returns an array of column objects where the primary id, all columns ending in "_id" or "_count",
@@ -273,7 +275,7 @@ module ActiveRecord
       # when just after creating a table you want to populate it with some default
       # values, eg:
       #
-      #  class CreateJobLevels < ActiveRecord::Migration
+      #  class CreateJobLevels < ActiveRecord::Migration[5.0]
       #    def up
       #      create_table :job_levels do |t|
       #        t.integer :id
@@ -295,21 +297,53 @@ module ActiveRecord
       def reset_column_information
         connection.clear_cache!
         undefine_attribute_methods
-        connection.schema_cache.clear_table_cache!(table_name)
+        connection.schema_cache.clear_data_source_cache!(table_name)
 
-        @arel_engine        = nil
-        @column_names       = nil
-        @column_types       = nil
-        @content_columns    = nil
-        @default_attributes = nil
-        @inheritance_column = nil unless defined?(@explicit_inheritance_column) && @explicit_inheritance_column
-        @relation           = nil
-
-        initialize_find_by_cache
+        reload_schema_from_cache
       end
 
       private
 
+      def schema_loaded?
+        defined?(@columns_hash) && @columns_hash
+      end
+
+      def load_schema
+        unless schema_loaded?
+          load_schema!
+        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
+          )
+        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
+        @attribute_names = nil
+        direct_descendants.each do |descendant|
+          descendant.send(:reload_schema_from_cache)
+        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
@@ -334,8 +368,26 @@ module ActiveRecord
         end
       end
 
-      def raw_default_values
-        columns_hash.transform_values(&:default)
+      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"
+          else
+            array_arguments = ""
+          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

data/lib/active_record/nested_attributes.rb

@@ -81,6 +81,9 @@ module ActiveRecord
     #
     # Note that the model will _not_ be destroyed until the parent is saved.
     #
+    # Also note that the model will not be destroyed unless you also specify
+    # its id in the updated hash.
+    #
     # === One-to-many
     #
     # Consider a member that has a number of posts:
@@ -111,7 +114,7 @@ module ActiveRecord
     #   member.posts.first.title # => 'Kari, the awesome Ruby documentation browser!'
     #   member.posts.second.title # => 'The egalitarian assumption of the modern citizen'
     #
-    # You may also set a :reject_if proc to silently ignore any new record
+    # You may also set a +:reject_if+ proc to silently ignore any new record
     # hashes if they fail to pass your criteria. For example, the previous
     # example could be rewritten as:
     #
@@ -133,7 +136,7 @@ module ActiveRecord
     #   member.posts.first.title # => 'Kari, the awesome Ruby documentation browser!'
     #   member.posts.second.title # => 'The egalitarian assumption of the modern citizen'
     #
-    # Alternatively, :reject_if also accepts a symbol for using methods:
+    # Alternatively, +:reject_if+ also accepts a symbol for using methods:
     #
     #   class Member < ActiveRecord::Base
     #     has_many :posts
@@ -144,8 +147,8 @@ module ActiveRecord
     #     has_many :posts
     #     accepts_nested_attributes_for :posts, reject_if: :reject_posts
     #
-    #     def reject_posts(attributed)
-    #       attributed['title'].blank?
+    #     def reject_posts(attributes)
+    #       attributes['title'].blank?
     #     end
     #   end
     #
@@ -163,6 +166,11 @@ module ActiveRecord
     #   member.posts.first.title # => '[UPDATED] An, as of yet, undisclosed awesome Ruby documentation browser!'
     #   member.posts.second.title # => '[UPDATED] other post'
     #
+    # However, the above applies if the parent model is being updated as well.
+    # For example, If you wanted to create a +member+ named _joe_ and wanted to
+    # update the +posts+ at the same time, that would give an
+    # ActiveRecord::RecordNotFound error.
+    #
     # By default the associated records are protected from being destroyed. If
     # you want to destroy any of the associated records through the attributes
     # hash, you have to enable it first using the <tt>:allow_destroy</tt>
@@ -205,20 +213,20 @@ module ActiveRecord
     #
     # Passing attributes for an associated collection in the form of a hash
     # of hashes can be used with hashes generated from HTTP/HTML parameters,
-    # where there maybe no natural way to submit an array of hashes.
+    # where there may be no natural way to submit an array of hashes.
     #
     # === Saving
     #
     # All changes to models, including the destruction of those marked for
     # destruction, are saved and destroyed automatically and atomically when
     # the parent model is saved. This happens inside the transaction initiated
-    # by the parents save method. See ActiveRecord::AutosaveAssociation.
+    # by the parent's save method. See ActiveRecord::AutosaveAssociation.
     #
     # === Validating the presence of a parent model
     #
     # If you want to validate that a child record is associated with a parent
-    # record, you can use <tt>validates_presence_of</tt> and
-    # <tt>inverse_of</tt> as this example illustrates:
+    # record, you can use the +validates_presence_of+ method and the +:inverse_of+
+    # key as this example illustrates:
     #
     #   class Member < ActiveRecord::Base
     #     has_many :posts, inverse_of: :member
@@ -230,7 +238,7 @@ module ActiveRecord
     #     validates_presence_of :member
     #   end
     #
-    # Note that if you do not specify the <tt>inverse_of</tt> option, then
+    # Note that if you do not specify the +:inverse_of+ option, then
     # Active Record will try to automatically guess the inverse association
     # based on heuristics.
     #
@@ -264,29 +272,31 @@ module ActiveRecord
       #   Allows you to specify a Proc or a Symbol pointing to a method
       #   that checks whether a record should be built for a certain attribute
       #   hash. The hash is passed to the supplied Proc or the method
-      #   and it should return either +true+ or +false+. When no :reject_if
+      #   and it should return either +true+ or +false+. When no +:reject_if+
       #   is specified, a record will be built for all attribute hashes that
       #   do not have a <tt>_destroy</tt> value that evaluates to true.
       #   Passing <tt>:all_blank</tt> instead of a Proc will create a proc
       #   that will reject a record where all the attributes are blank excluding
-      #   any value for _destroy.
+      #   any value for +_destroy+.
       # [:limit]
-      #   Allows you to specify the maximum number of the associated records that
-      #   can be processed with the nested attributes. Limit also can be specified as a
-      #   Proc or a Symbol pointing to a method that should return number. If the size of the
-      #   nested attributes array exceeds the specified limit, NestedAttributes::TooManyRecords
-      #   exception is raised. If omitted, any number associations can be processed.
-      #   Note that the :limit option is only applicable to one-to-many associations.
+      #   Allows you to specify the maximum number of associated records that
+      #   can be processed with the nested attributes. Limit also can be specified
+      #   as a Proc or a Symbol pointing to a method that should return a number.
+      #   If the size of the nested attributes array exceeds the specified limit,
+      #   NestedAttributes::TooManyRecords exception is raised. If omitted, any
+      #   number of associations can be processed.
+      #   Note that the +:limit+ option is only applicable to one-to-many
+      #   associations.
       # [:update_only]
       #   For a one-to-one association, this option allows you to specify how
-      #   nested attributes are to be used when an associated record already
+      #   nested attributes are going to be used when an associated record already
       #   exists. In general, an existing record may either be updated with the
       #   new set of attribute values or be replaced by a wholly new record
-      #   containing those values. By default the :update_only option is +false+
+      #   containing those values. By default the +:update_only+ option is +false+
       #   and the nested attributes are used to update the existing record only
       #   if they include the record's <tt>:id</tt> value. Otherwise a new
       #   record will be instantiated and used to replace the existing one.
-      #   However if the :update_only option is +true+, the nested attributes
+      #   However if the +:update_only+ option is +true+, the nested attributes
       #   are used to update the record's attributes always, regardless of
       #   whether the <tt>:id</tt> is present. The option is ignored for collection
       #   associations.
@@ -376,6 +386,9 @@ module ActiveRecord
     # then the existing record will be marked for destruction.
     def assign_nested_attributes_for_one_to_one_association(association_name, attributes)
       options = self.nested_attributes_options[association_name]
+      if attributes.respond_to?(:permitted?)
+        attributes = attributes.to_h
+      end
       attributes = attributes.with_indifferent_access
       existing_record = send(association_name)
 
@@ -432,6 +445,9 @@ module ActiveRecord
     #   ])
     def assign_nested_attributes_for_collection_association(association_name, attributes_collection)
       options = self.nested_attributes_options[association_name]
+      if attributes_collection.respond_to?(:permitted?)
+        attributes_collection = attributes_collection.to_h
+      end
 
       unless attributes_collection.is_a?(Hash) || attributes_collection.is_a?(Array)
         raise ArgumentError, "Hash or Array expected, got #{attributes_collection.class.name} (#{attributes_collection.inspect})"
@@ -458,6 +474,9 @@ module ActiveRecord
       end
 
       attributes_collection.each do |attributes|
+        if attributes.respond_to?(:permitted?)
+          attributes = attributes.to_h
+        end
         attributes = attributes.with_indifferent_access
 
         if attributes['id'].blank?
@@ -516,14 +535,14 @@ module ActiveRecord
 
     # Determines if a hash contains a truthy _destroy key.
     def has_destroy_flag?(hash)
-      Type::Boolean.new.type_cast_from_user(hash['_destroy'])
+      Type::Boolean.new.cast(hash['_destroy'])
     end
 
     # Determines if a new record should be rejected by checking
     # has_destroy_flag? or if a <tt>:reject_if</tt> proc exists for this
     # association and evaluates to +true+.
     def reject_new_record?(association_name, attributes)
-      will_be_destroyed?(association_name, attributes) || call_reject_if(association_name, attributes)
+      has_destroy_flag?(attributes) || call_reject_if(association_name, attributes)
     end
 
     # Determines if a record with the particular +attributes+ should be
@@ -532,8 +551,7 @@ module ActiveRecord
     #
     # Returns false if there is a +destroy_flag+ on the attributes.
     def call_reject_if(association_name, attributes)
-      return false if will_be_destroyed?(association_name, attributes)
-
+      return false if has_destroy_flag?(attributes)
       case callback = self.nested_attributes_options[association_name][:reject_if]
       when Symbol
         method(callback).arity == 0 ? send(callback) : send(callback, attributes)
@@ -542,17 +560,10 @@ module ActiveRecord
       end
     end
 
-    # Only take into account the destroy flag if <tt>:allow_destroy</tt> is true
-    def will_be_destroyed?(association_name, attributes)
-      allow_destroy?(association_name) && has_destroy_flag?(attributes)
-    end
-
-    def allow_destroy?(association_name)
-      self.nested_attributes_options[association_name][:allow_destroy]
-    end
-
     def raise_nested_attributes_record_not_found!(association_name, record_id)
-      raise RecordNotFound, "Couldn't find #{self.class._reflect_on_association(association_name).klass.name} with ID=#{record_id} for #{self.class.name} with ID=#{id}"
+      model = self.class._reflect_on_association(association_name).klass.name
+      raise RecordNotFound.new("Couldn't find #{model} with ID=#{record_id} for #{self.class.name} with ID=#{id}",
+                               model, 'id', record_id)
     end
   end
 end