activerecord 4.2.11.3 → 5.0.7.2

data/lib/active_record/attribute_set/builder.rb

@@ -3,33 +3,30 @@ require 'active_record/attribute'
 module ActiveRecord
   class AttributeSet # :nodoc:
     class Builder # :nodoc:
-      attr_reader :types, :always_initialized
+      attr_reader :types, :default_attributes
 
-      def initialize(types, always_initialized = nil)
+      def initialize(types, default_attributes = {})
         @types = types
-        @always_initialized = always_initialized
+        @default_attributes = default_attributes
       end
 
       def build_from_database(values = {}, additional_types = {})
-        if always_initialized && !values.key?(always_initialized)
-          values[always_initialized] = nil
-        end
-
-        attributes = LazyAttributeHash.new(types, values, additional_types)
+        attributes = LazyAttributeHash.new(types, values, additional_types, default_attributes)
         AttributeSet.new(attributes)
       end
     end
   end
 
   class LazyAttributeHash # :nodoc:
-    delegate :transform_values, to: :materialize
+    delegate :transform_values, :each_key, :fetch, :except, to: :materialize
 
-    def initialize(types, values, additional_types)
+    def initialize(types, values, additional_types, default_attributes, delegate_hash = {})
       @types = types
       @values = values
       @additional_types = additional_types
       @materialized = false
-      @delegate_hash = {}
+      @delegate_hash = delegate_hash
+      @default_attributes = default_attributes
     end
 
     def key?(key)
@@ -47,12 +44,14 @@ module ActiveRecord
       delegate_hash[key] = value
     end
 
-    def initialized_keys
-      delegate_hash.keys | values.keys
+    def deep_dup
+      dup.tap do |copy|
+        copy.instance_variable_set(:@delegate_hash, delegate_hash.transform_values(&:dup))
+      end
     end
 
     def initialize_dup(_)
-      @delegate_hash = delegate_hash.transform_values(&:dup)
+      @delegate_hash = Hash[delegate_hash]
       super
     end
 
@@ -74,9 +73,31 @@ module ActiveRecord
       end
     end
 
+    def marshal_dump
+      [@types, @values, @additional_types, @default_attributes, @delegate_hash]
+    end
+
+    def marshal_load(values)
+      if values.is_a?(Hash)
+        empty_hash = {}.freeze
+        initialize(empty_hash, empty_hash, empty_hash, empty_hash, values)
+        @materialized = true
+      else
+        initialize(*values)
+      end
+    end
+
+    def encode_with(coder)
+      coder["delegate_hash"] = materialize
+    end
+
+    def init_with(coder)
+      marshal_load(coder["delegate_hash"])
+    end
+
     protected
 
-    attr_reader :types, :values, :additional_types, :delegate_hash
+    attr_reader :types, :values, :additional_types, :delegate_hash, :default_attributes
 
     def materialize
       unless @materialized
@@ -99,7 +120,12 @@ module ActiveRecord
       if value_present
         delegate_hash[name] = Attribute.from_database(name, value, type)
       elsif types.key?(name)
-        delegate_hash[name] = Attribute.uninitialized(name, type)
+        attr = default_attributes[name]
+        if attr
+          delegate_hash[name] = attr.dup
+        else
+          delegate_hash[name] = Attribute.uninitialized(name, type)
+        end
       end
     end
   end

data/lib/active_record/attributes.rb

@@ -1,33 +1,44 @@
+require 'active_record/attribute/user_provided_default'
+
 module ActiveRecord
-  module Attributes # :nodoc:
+  # See ActiveRecord::Attributes::ClassMethods for documentation
+  module Attributes
     extend ActiveSupport::Concern
 
-    Type = ActiveRecord::Type
-
     included do
-      class_attribute :user_provided_columns, instance_accessor: false # :internal:
-      class_attribute :user_provided_defaults, instance_accessor: false # :internal:
-      self.user_provided_columns = {}
-      self.user_provided_defaults = {}
-
-      delegate :persistable_attribute_names, to: :class
+      class_attribute :attributes_to_define_after_schema_loads, instance_accessor: false # :internal:
+      self.attributes_to_define_after_schema_loads = {}
     end
 
-    module ClassMethods # :nodoc:
-      # Defines or overrides a attribute on this model. This allows customization of
-      # Active Record's type casting behavior, as well as adding support for user defined
-      # types.
+    module ClassMethods
+      # Defines an attribute with a type on this model. It will override the
+      # type of existing attributes if needed. This allows control over how
+      # values are converted to and from SQL when assigned to a model. It also
+      # changes the behavior of values passed to
+      # {ActiveRecord::Base.where}[rdoc-ref:QueryMethods#where]. This will let you use
+      # your domain objects across much of Active Record, without having to
+      # rely on implementation details or monkey patching.
       #
-      # +name+ The name of the methods to define attribute methods for, and the column which
-      # this will persist to.
+      # +name+ The name of the methods to define attribute methods for, and the
+      # column which this will persist to.
       #
-      # +cast_type+ A type object that contains information about how to type cast the value.
-      # See the examples section for more information.
+      # +cast_type+ A symbol such as +:string+ or +:integer+, or a type object
+      # to be used for this attribute. See the examples below for more
+      # information about providing custom type objects.
       #
       # ==== Options
-      # The options hash accepts the following options:
       #
-      # +default+ is the default value that the column should use on a new record.
+      # The following options are accepted:
+      #
+      # +default+ The default value to use when no value is provided. If this option
+      # is not passed, the previous default value (if any) will be used.
+      # Otherwise, the default will be +nil+.
+      #
+      # +array+ (PostgreSQL only) specifies that the type should be an array (see the
+      # examples below).
+      #
+      # +range+ (PostgreSQL only) specifies that the type should be a range (see the
+      # examples below).
       #
       # ==== Examples
       #
@@ -48,99 +59,206 @@ module ActiveRecord
       #   store_listing.price_in_cents # => BigDecimal.new(10.1)
       #
       #   class StoreListing < ActiveRecord::Base
-      #     attribute :price_in_cents, Type::Integer.new
+      #     attribute :price_in_cents, :integer
       #   end
       #
       #   # after
       #   store_listing.price_in_cents # => 10
       #
-      # Users may also define their own custom types, as long as they respond to the methods
-      # defined on the value type. The `type_cast` method on your type object will be called
-      # with values both from the database, and from your controllers. See
-      # `ActiveRecord::Attributes::Type::Value` for the expected API. It is recommended that your
-      # type objects inherit from an existing type, or the base value type.
+      # A default can also be provided.
+      #
+      #   # db/schema.rb
+      #   create_table :store_listings, force: true do |t|
+      #     t.string :my_string, default: "original default"
+      #   end
+      #
+      #   StoreListing.new.my_string # => "original default"
+      #
+      #   # app/models/store_listing.rb
+      #   class StoreListing < ActiveRecord::Base
+      #     attribute :my_string, :string, default: "new default"
+      #   end
+      #
+      #   StoreListing.new.my_string # => "new default"
+      #
+      #   class Product < ActiveRecord::Base
+      #     attribute :my_default_proc, :datetime, default: -> { Time.now }
+      #   end
+      #
+      #   Product.new.my_default_proc # => 2015-05-30 11:04:48 -0600
+      #   sleep 1
+      #   Product.new.my_default_proc # => 2015-05-30 11:04:49 -0600
+      #
+      # \Attributes do not need to be backed by a database column.
+      #
+      #   # app/models/my_model.rb
+      #   class MyModel < ActiveRecord::Base
+      #     attribute :my_string, :string
+      #     attribute :my_int_array, :integer, array: true
+      #     attribute :my_float_range, :float, range: true
+      #   end
+      #
+      #   model = MyModel.new(
+      #     my_string: "string",
+      #     my_int_array: ["1", "2", "3"],
+      #     my_float_range: "[1,3.5]",
+      #   )
+      #   model.attributes
+      #   # =>
+      #     {
+      #       my_string: "string",
+      #       my_int_array: [1, 2, 3],
+      #       my_float_range: 1.0..3.5
+      #     }
+      #
+      # ==== Creating Custom Types
+      #
+      # Users may also define their own custom types, as long as they respond
+      # to the methods defined on the value type. The method +deserialize+ or
+      # +cast+ will be called on your type object, with raw input from the
+      # database or from your controllers. See ActiveRecord::Type::Value for the
+      # expected API. It is recommended that your type objects inherit from an
+      # existing type, or from ActiveRecord::Type::Value
       #
       #   class MoneyType < ActiveRecord::Type::Integer
-      #     def type_cast(value)
-      #       if value.include?('$')
+      #     def cast(value)
+      #       if !value.kind_of?(Numeric) && value.include?('$')
       #         price_in_dollars = value.gsub(/\$/, '').to_f
-      #         price_in_dollars * 100
+      #         super(price_in_dollars * 100)
       #       else
-      #         value.to_i
+      #         super
       #       end
       #     end
       #   end
       #
+      #   # config/initializers/types.rb
+      #   ActiveRecord::Type.register(:money, MoneyType)
+      #
+      #   # app/models/store_listing.rb
       #   class StoreListing < ActiveRecord::Base
-      #     attribute :price_in_cents, MoneyType.new
+      #     attribute :price_in_cents, :money
       #   end
       #
       #   store_listing = StoreListing.new(price_in_cents: '$10.00')
       #   store_listing.price_in_cents # => 1000
-      def attribute(name, cast_type, options = {})
+      #
+      # For more details on creating custom types, see the documentation for
+      # ActiveRecord::Type::Value. For more details on registering your types
+      # to be referenced by a symbol, see ActiveRecord::Type.register. You can
+      # also pass a type object directly, in place of a symbol.
+      #
+      # ==== \Querying
+      #
+      # When {ActiveRecord::Base.where}[rdoc-ref:QueryMethods#where] is called, it will
+      # use the type defined by the model class to convert the value to SQL,
+      # calling +serialize+ on your type object. For example:
+      #
+      #   class Money < Struct.new(:amount, :currency)
+      #   end
+      #
+      #   class MoneyType < Type::Value
+      #     def initialize(currency_converter:)
+      #       @currency_converter = currency_converter
+      #     end
+      #
+      #     # value will be the result of +deserialize+ or
+      #     # +cast+. Assumed to be an instance of +Money+ in
+      #     # this case.
+      #     def serialize(value)
+      #       value_in_bitcoins = @currency_converter.convert_to_bitcoins(value)
+      #       value_in_bitcoins.amount
+      #     end
+      #   end
+      #
+      #   # config/initializers/types.rb
+      #   ActiveRecord::Type.register(:money, MoneyType)
+      #
+      #   # app/models/product.rb
+      #   class Product < ActiveRecord::Base
+      #     currency_converter = ConversionRatesFromTheInternet.new
+      #     attribute :price_in_bitcoins, :money, currency_converter: currency_converter
+      #   end
+      #
+      #   Product.where(price_in_bitcoins: Money.new(5, "USD"))
+      #   # => SELECT * FROM products WHERE price_in_bitcoins = 0.02230
+      #
+      #   Product.where(price_in_bitcoins: Money.new(5, "GBP"))
+      #   # => SELECT * FROM products WHERE price_in_bitcoins = 0.03412
+      #
+      # ==== Dirty Tracking
+      #
+      # The type of an attribute is given the opportunity to change how dirty
+      # tracking is performed. The methods +changed?+ and +changed_in_place?+
+      # will be called from ActiveModel::Dirty. See the documentation for those
+      # methods in ActiveRecord::Type::Value for more details.
+      def attribute(name, cast_type, **options)
         name = name.to_s
-        clear_caches_calculated_from_columns
-        # Assign a new hash to ensure that subclasses do not share a hash
-        self.user_provided_columns = user_provided_columns.merge(name => cast_type)
+        reload_schema_from_cache
 
-        if options.key?(:default)
-          self.user_provided_defaults = user_provided_defaults.merge(name => options[:default])
-        end
-      end
-
-      # Returns an array of column objects for the table associated with this class.
-      def columns
-        @columns ||= add_user_provided_columns(connection.schema_cache.columns(table_name))
+        self.attributes_to_define_after_schema_loads =
+          attributes_to_define_after_schema_loads.merge(
+            name => [cast_type, options]
+          )
       end
 
-      # Returns a hash of column objects for the table associated with this class.
-      def columns_hash
-        @columns_hash ||= Hash[columns.map { |c| [c.name, c] }]
-      end
-
-      def persistable_attribute_names # :nodoc:
-        @persistable_attribute_names ||= connection.schema_cache.columns_hash(table_name).keys
+      # This is the low level API which sits beneath +attribute+. It only
+      # accepts type objects, and will do its work immediately instead of
+      # waiting for the schema to load. Automatic schema detection and
+      # ClassMethods#attribute both call this under the hood. While this method
+      # is provided so it can be used by plugin authors, application code
+      # should probably use ClassMethods#attribute.
+      #
+      # +name+ The name of the attribute being defined. Expected to be a +String+.
+      #
+      # +cast_type+ The type object to use for this attribute.
+      #
+      # +default+ The default value to use when no value is provided. If this option
+      # is not passed, the previous default value (if any) will be used.
+      # Otherwise, the default will be +nil+. A proc can also be passed, and
+      # will be called once each time a new value is needed.
+      #
+      # +user_provided_default+ Whether the default value should be cast using
+      # +cast+ or +deserialize+.
+      def define_attribute(
+        name,
+        cast_type,
+        default: NO_DEFAULT_PROVIDED,
+        user_provided_default: true
+      )
+        attribute_types[name] = cast_type
+        define_default_attribute(name, default, cast_type, from_user: user_provided_default)
       end
 
-      def reset_column_information # :nodoc:
+      def load_schema! # :nodoc:
         super
-        clear_caches_calculated_from_columns
-      end
-
-      private
-
-      def add_user_provided_columns(schema_columns)
-        existing_columns = schema_columns.map do |column|
-          new_type = user_provided_columns[column.name]
-          if new_type
-            column.with_type(new_type)
-          else
-            column
+        attributes_to_define_after_schema_loads.each do |name, (type, options)|
+          if type.is_a?(Symbol)
+            type = ActiveRecord::Type.lookup(type, **options.except(:default))
           end
-        end
 
-        existing_column_names = existing_columns.map(&:name)
-        new_columns = user_provided_columns.except(*existing_column_names).map do |(name, type)|
-          connection.new_column(name, nil, type)
+          define_attribute(name, type, **options.slice(:default))
         end
-
-        existing_columns + new_columns
       end
 
-      def clear_caches_calculated_from_columns
-        @attributes_builder = nil
-        @column_names = nil
-        @column_types = nil
-        @columns = nil
-        @columns_hash = nil
-        @content_columns = nil
-        @default_attributes = nil
-        @persistable_attribute_names = nil
-        @attribute_names = nil
-      end
+      private
+
+      NO_DEFAULT_PROVIDED = Object.new # :nodoc:
+      private_constant :NO_DEFAULT_PROVIDED
 
-      def raw_default_values
-        super.merge(user_provided_defaults)
+      def define_default_attribute(name, value, type, from_user:)
+        if value == NO_DEFAULT_PROVIDED
+          default_attribute = _default_attributes[name].with_type(type)
+        elsif from_user
+          default_attribute = Attribute::UserProvidedDefault.new(
+            name,
+            value,
+            type,
+            _default_attributes.fetch(name.to_s) { nil },
+          )
+        else
+          default_attribute = Attribute.from_database(name, value, type)
+        end
+        _default_attributes[name] = default_attribute
       end
     end
   end

data/lib/active_record/autosave_association.rb

@@ -1,10 +1,10 @@
 module ActiveRecord
   # = Active Record Autosave Association
   #
-  # +AutosaveAssociation+ is a module that takes care of automatically saving
+  # AutosaveAssociation is a module that takes care of automatically saving
   # associated records when their parent is saved. In addition to saving, it
   # also destroys any associated records that were marked for destruction.
-  # (See +mark_for_destruction+ and <tt>marked_for_destruction?</tt>).
+  # (See #mark_for_destruction and #marked_for_destruction?).
   #
   # Saving of the parent, its associations, and the destruction of marked
   # associations, all happen inside a transaction. This should never leave the
@@ -22,7 +22,7 @@ module ActiveRecord
   #
   # == Validation
   #
-  # Children records are validated unless <tt>:validate</tt> is +false+.
+  # Child records are validated unless <tt>:validate</tt> is +false+.
   #
   # == Callbacks
   #
@@ -125,7 +125,6 @@ module ActiveRecord
   # Now it _is_ removed from the database:
   #
   #   Comment.find_by(id: id).nil? # => true
-
   module AutosaveAssociation
     extend ActiveSupport::Concern
 
@@ -141,9 +140,11 @@ module ActiveRecord
 
     included do
       Associations::Builder::Association.extensions << AssociationBuilderExtension
+      mattr_accessor :index_nested_attribute_errors, instance_writer: false
+      self.index_nested_attribute_errors = false
     end
 
-    module ClassMethods
+    module ClassMethods # :nodoc:
       private
 
         def define_non_cyclic_method(name, &block)
@@ -198,7 +199,7 @@ module ActiveRecord
             after_create save_method
             after_update save_method
           else
-            define_non_cyclic_method(save_method) { save_belongs_to_association(reflection) }
+            define_non_cyclic_method(save_method) { throw(:abort) if save_belongs_to_association(reflection) == false }
             before_save save_method
           end
 
@@ -214,8 +215,15 @@ module ActiveRecord
               method = :validate_single_association
             end
 
-            define_non_cyclic_method(validation_method) { send(method, reflection) }
+            define_non_cyclic_method(validation_method) do
+              send(method, reflection)
+              # TODO: remove the following line as soon as the return value of
+              # callbacks is ignored, that is, returning `false` does not
+              # display a deprecation warning or halts the callback chain.
+              true
+            end
             validate validation_method
+            after_validation :_ensure_no_duplicate_errors
           end
         end
     end
@@ -227,7 +235,7 @@ module ActiveRecord
       super
     end
 
-    # Marks this record to be destroyed as part of the parents save transaction.
+    # Marks this record to be destroyed as part of the parent's save transaction.
     # This does _not_ actually destroy the record instantly, rather child record will be destroyed
     # when <tt>parent.save</tt> is called.
     #
@@ -236,7 +244,7 @@ module ActiveRecord
       @marked_for_destruction = true
     end
 
-    # Returns whether or not this record will be destroyed as part of the parents save transaction.
+    # Returns whether or not this record will be destroyed as part of the parent's save transaction.
     #
     # Only useful if the <tt>:autosave</tt> option on the parent is enabled for this associated model.
     def marked_for_destruction?
@@ -271,9 +279,9 @@ module ActiveRecord
         if new_record
           association && association.target
         elsif autosave
-          association.target.find_all { |record| record.changed_for_autosave? }
+          association.target.find_all(&:changed_for_autosave?)
         else
-          association.target.find_all { |record| record.new_record? }
+          association.target.find_all(&:new_record?)
         end
       end
 
@@ -309,7 +317,7 @@ module ActiveRecord
       def validate_collection_association(reflection)
         if association = association_instance_get(reflection.name)
           if records = associated_records_to_validate_or_save(association, new_record?, reflection.options[:autosave])
-            records.each { |record| association_valid?(reflection, record) }
+            records.each_with_index { |record, index| association_valid?(reflection, record, index) }
           end
         end
       end
@@ -317,17 +325,30 @@ module ActiveRecord
       # Returns whether or not the association is valid and applies any errors to
       # the parent, <tt>self</tt>, if it wasn't. Skips any <tt>:autosave</tt>
       # enabled records if they're marked_for_destruction? or destroyed.
-      def association_valid?(reflection, record)
+      def association_valid?(reflection, record, index=nil)
         return true if record.destroyed? || (reflection.options[:autosave] && record.marked_for_destruction?)
 
         validation_context = self.validation_context unless [:create, :update].include?(self.validation_context)
+
         unless valid = record.valid?(validation_context)
           if reflection.options[:autosave]
+            indexed_attribute = !index.nil? && (reflection.options[:index_errors] || ActiveRecord::Base.index_nested_attribute_errors)
+
             record.errors.each do |attribute, message|
-              attribute = "#{reflection.name}.#{attribute}"
+              attribute = normalize_reflection_attribute(indexed_attribute, reflection, index, attribute)
               errors[attribute] << message
               errors[attribute].uniq!
             end
+
+            record.errors.details.each_key do |attribute|
+              reflection_attribute =
+                normalize_reflection_attribute(indexed_attribute, reflection, index, attribute).to_sym
+
+              record.errors.details[attribute].each do |error|
+                errors.details[reflection_attribute] << error
+                errors.details[reflection_attribute].uniq!
+              end
+            end
           else
             errors.add(reflection.name)
           end
@@ -335,6 +356,14 @@ module ActiveRecord
         valid
       end
 
+      def normalize_reflection_attribute(indexed_attribute, reflection, index, attribute)
+        if indexed_attribute
+          "#{reflection.name}[#{index}].#{attribute}"
+        else
+          "#{reflection.name}.#{attribute}"
+        end
+      end
+
       # Is used as a before_save callback to check while saving a collection
       # association whether or not the parent was a new record before saving.
       def before_save_collection_association
@@ -346,7 +375,7 @@ module ActiveRecord
       # <tt>:autosave</tt> is enabled on the association.
       #
       # In addition, it destroys all children that were marked for destruction
-      # with mark_for_destruction.
+      # with #mark_for_destruction.
       #
       # This all happens inside a transaction, _if_ the Transactions module is included into
       # ActiveRecord::Base after the AutosaveAssociation module, which it does by default.
@@ -389,7 +418,7 @@ module ActiveRecord
       # on the association.
       #
       # In addition, it will destroy the association if it was marked for
-      # destruction with mark_for_destruction.
+      # destruction with #mark_for_destruction.
       #
       # This all happens inside a transaction, _if_ the Transactions module is included into
       # ActiveRecord::Base after the AutosaveAssociation module, which it does by default.
@@ -430,7 +459,9 @@ module ActiveRecord
       # In addition, it will destroy the association if it was marked for destruction.
       def save_belongs_to_association(reflection)
         association = association_instance_get(reflection.name)
-        record      = association && association.load_target
+        return unless association && association.loaded? && !association.stale_target?
+
+        record = association.load_target
         if record && !record.destroyed?
           autosave = reflection.options[:autosave]
 
@@ -450,5 +481,11 @@ module ActiveRecord
           end
         end
       end
+
+      def _ensure_no_duplicate_errors
+        errors.messages.each_key do |attribute|
+          errors[attribute].uniq!
+        end
+      end
   end
 end