activerecord 4.1.15 → 4.2.11.3

data/lib/active_record/attribute_methods/write.rb

@@ -26,8 +26,6 @@ module ActiveRecord
         protected
 
         if Module.methods_transplantable?
-          # See define_method_attribute in read.rb for an explanation of
-          # this code.
           def define_method_attribute=(name)
             method = WriterMethodCache[name]
             generated_attribute_methods.module_eval {
@@ -52,14 +50,14 @@ module ActiveRecord
       end
 
       # Updates the attribute identified by <tt>attr_name</tt> with the
-      # specified +value+. Empty strings for fixnum and float columns are
+      # specified +value+. Empty strings for Integer and Float columns are
       # turned into +nil+.
       def write_attribute(attr_name, value)
-        write_attribute_with_type_cast(attr_name, value, :type_cast_attribute_for_write)
+        write_attribute_with_type_cast(attr_name, value, true)
       end
 
       def raw_write_attribute(attr_name, value)
-        write_attribute_with_type_cast(attr_name, value, :raw_type_cast_attribute_for_write)
+        write_attribute_with_type_cast(attr_name, value, false)
       end
 
       private
@@ -68,30 +66,17 @@ module ActiveRecord
         write_attribute(attribute_name, value)
       end
 
-      def type_cast_attribute_for_write(column, value)
-        return value unless column
-
-        column.type_cast_for_write value
-      end
-      alias_method :raw_type_cast_attribute_for_write, :type_cast_attribute_for_write
-
-      def write_attribute_with_type_cast(attr_name, value, type_cast_method)
+      def write_attribute_with_type_cast(attr_name, value, should_type_cast)
         attr_name = attr_name.to_s
         attr_name = self.class.primary_key if attr_name == 'id' && self.class.primary_key
-        @attributes_cache.delete(attr_name)
-        column = column_for_attribute(attr_name)
 
-        # If we're dealing with a binary column, write the data to the cache
-        # so we don't attempt to typecast multiple times.
-        if column && column.binary?
-          @attributes_cache[attr_name] = value
-        end
-
-        if column || @attributes.has_key?(attr_name)
-          @attributes[attr_name] = send(type_cast_method, column, value)
+        if should_type_cast
+          @attributes.write_from_user(attr_name, value)
         else
-          raise ActiveModel::MissingAttributeError, "can't write unknown attribute `#{attr_name}'"
+          @attributes.write_cast_value(attr_name, value)
         end
+
+        value
       end
     end
   end

data/lib/active_record/attribute_set.rb

@@ -0,0 +1,81 @@
+require 'active_record/attribute_set/builder'
+
+module ActiveRecord
+  class AttributeSet # :nodoc:
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def [](name)
+      attributes[name] || Attribute.null(name)
+    end
+
+    def values_before_type_cast
+      attributes.transform_values(&:value_before_type_cast)
+    end
+
+    def to_hash
+      initialized_attributes.transform_values(&:value)
+    end
+    alias_method :to_h, :to_hash
+
+    def key?(name)
+      attributes.key?(name) && self[name].initialized?
+    end
+
+    def keys
+      attributes.initialized_keys
+    end
+
+    def fetch_value(name)
+      self[name].value { |n| yield n if block_given? }
+    end
+
+    def write_from_database(name, value)
+      attributes[name] = self[name].with_value_from_database(value)
+    end
+
+    def write_from_user(name, value)
+      attributes[name] = self[name].with_value_from_user(value)
+    end
+
+    def write_cast_value(name, value)
+      attributes[name] = self[name].with_cast_value(value)
+    end
+
+    def freeze
+      @attributes.freeze
+      super
+    end
+
+    def initialize_dup(_)
+      @attributes = attributes.dup
+      super
+    end
+
+    def initialize_clone(_)
+      @attributes = attributes.clone
+      super
+    end
+
+    def reset(key)
+      if key?(key)
+        write_from_database(key, nil)
+      end
+    end
+
+    def ==(other)
+      attributes == other.attributes
+    end
+
+    protected
+
+    attr_reader :attributes
+
+    private
+
+    def initialized_attributes
+      attributes.select { |_, attr| attr.initialized? }
+    end
+  end
+end

data/lib/active_record/attribute_set/builder.rb

@@ -0,0 +1,106 @@
+require 'active_record/attribute'
+
+module ActiveRecord
+  class AttributeSet # :nodoc:
+    class Builder # :nodoc:
+      attr_reader :types, :always_initialized
+
+      def initialize(types, always_initialized = nil)
+        @types = types
+        @always_initialized = always_initialized
+      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)
+        AttributeSet.new(attributes)
+      end
+    end
+  end
+
+  class LazyAttributeHash # :nodoc:
+    delegate :transform_values, to: :materialize
+
+    def initialize(types, values, additional_types)
+      @types = types
+      @values = values
+      @additional_types = additional_types
+      @materialized = false
+      @delegate_hash = {}
+    end
+
+    def key?(key)
+      delegate_hash.key?(key) || values.key?(key) || types.key?(key)
+    end
+
+    def [](key)
+      delegate_hash[key] || assign_default_value(key)
+    end
+
+    def []=(key, value)
+      if frozen?
+        raise RuntimeError, "Can't modify frozen hash"
+      end
+      delegate_hash[key] = value
+    end
+
+    def initialized_keys
+      delegate_hash.keys | values.keys
+    end
+
+    def initialize_dup(_)
+      @delegate_hash = delegate_hash.transform_values(&:dup)
+      super
+    end
+
+    def select
+      keys = types.keys | values.keys | delegate_hash.keys
+      keys.each_with_object({}) do |key, hash|
+        attribute = self[key]
+        if yield(key, attribute)
+          hash[key] = attribute
+        end
+      end
+    end
+
+    def ==(other)
+      if other.is_a?(LazyAttributeHash)
+        materialize == other.materialize
+      else
+        materialize == other
+      end
+    end
+
+    protected
+
+    attr_reader :types, :values, :additional_types, :delegate_hash
+
+    def materialize
+      unless @materialized
+        values.each_key { |key| self[key] }
+        types.each_key { |key| self[key] }
+        unless frozen?
+          @materialized = true
+        end
+      end
+      delegate_hash
+    end
+
+    private
+
+    def assign_default_value(name)
+      type = additional_types.fetch(name, types[name])
+      value_present = true
+      value = values.fetch(name) { value_present = false }
+
+      if value_present
+        delegate_hash[name] = Attribute.from_database(name, value, type)
+      elsif types.key?(name)
+        delegate_hash[name] = Attribute.uninitialized(name, type)
+      end
+    end
+  end
+end

data/lib/active_record/attributes.rb

@@ -0,0 +1,147 @@
+module ActiveRecord
+  module Attributes # :nodoc:
+    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
+    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.
+      #
+      # +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.
+      #
+      # ==== Options
+      # The options hash accepts the following options:
+      #
+      # +default+ is the default value that the column should use on a new record.
+      #
+      # ==== Examples
+      #
+      # The type detected by Active Record can be overridden.
+      #
+      #   # db/schema.rb
+      #   create_table :store_listings, force: true do |t|
+      #     t.decimal :price_in_cents
+      #   end
+      #
+      #   # app/models/store_listing.rb
+      #   class StoreListing < ActiveRecord::Base
+      #   end
+      #
+      #   store_listing = StoreListing.new(price_in_cents: '10.1')
+      #
+      #   # before
+      #   store_listing.price_in_cents # => BigDecimal.new(10.1)
+      #
+      #   class StoreListing < ActiveRecord::Base
+      #     attribute :price_in_cents, Type::Integer.new
+      #   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.
+      #
+      #   class MoneyType < ActiveRecord::Type::Integer
+      #     def type_cast(value)
+      #       if value.include?('$')
+      #         price_in_dollars = value.gsub(/\$/, '').to_f
+      #         price_in_dollars * 100
+      #       else
+      #         value.to_i
+      #       end
+      #     end
+      #   end
+      #
+      #   class StoreListing < ActiveRecord::Base
+      #     attribute :price_in_cents, MoneyType.new
+      #   end
+      #
+      #   store_listing = StoreListing.new(price_in_cents: '$10.00')
+      #   store_listing.price_in_cents # => 1000
+      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)
+
+        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))
+      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
+      end
+
+      def reset_column_information # :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
+          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)
+        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
+
+      def raw_default_values
+        super.merge(user_provided_defaults)
+      end
+    end
+  end
+end

data/lib/active_record/autosave_association.rb

@@ -185,7 +185,7 @@ module ActiveRecord
             # Doesn't use after_save as that would save associations added in after_create/after_update twice
             after_create save_method
             after_update save_method
-          elsif reflection.macro == :has_one
+          elsif reflection.has_one?
             define_method(save_method) { save_has_one_association(reflection) } unless method_defined?(save_method)
             # Configures two callbacks instead of a single after_save so that
             # the model may rely on their execution order relative to its
@@ -214,10 +214,7 @@ module ActiveRecord
               method = :validate_single_association
             end
 
-            define_non_cyclic_method(validation_method) do
-              send(method, reflection)
-              true
-            end
+            define_non_cyclic_method(validation_method) { send(method, reflection) }
             validate validation_method
           end
         end
@@ -283,11 +280,18 @@ module ActiveRecord
       # go through nested autosave associations that are loaded in memory (without loading
       # any new ones), and return true if is changed for autosave
       def nested_records_changed_for_autosave?
-        self.class._reflections.values.any? do |reflection|
-          if reflection.options[:autosave]
-            association = association_instance_get(reflection.name)
-            association && Array.wrap(association.target).any? { |a| a.changed_for_autosave? }
+        @_nested_records_changed_for_autosave_already_called ||= false
+        return false if @_nested_records_changed_for_autosave_already_called
+        begin
+          @_nested_records_changed_for_autosave_already_called = true
+          self.class._reflections.values.any? do |reflection|
+            if reflection.options[:autosave]
+              association = association_instance_get(reflection.name)
+              association && Array.wrap(association.target).any?(&:changed_for_autosave?)
+            end
           end
+        ensure
+          @_nested_records_changed_for_autosave_already_called = false
         end
       end
 
@@ -314,9 +318,10 @@ module ActiveRecord
       # 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)
-        return true if record.destroyed? || record.marked_for_destruction?
+        return true if record.destroyed? || (reflection.options[:autosave] && record.marked_for_destruction?)
 
-        unless valid = record.valid?
+        validation_context = self.validation_context unless [:create, :update].include?(self.validation_context)
+        unless valid = record.valid?(validation_context)
           if reflection.options[:autosave]
             record.errors.each do |attribute, message|
               attribute = "#{reflection.name}.#{attribute}"
@@ -415,7 +420,9 @@ module ActiveRecord
 
       # If the record is new or it has changed, returns true.
       def record_changed?(reflection, record, key)
-        record.new_record? || record[reflection.foreign_key] != key || record.attribute_changed?(reflection.foreign_key)
+        record.new_record? ||
+          (record.has_attribute?(reflection.foreign_key) && record[reflection.foreign_key] != key) ||
+          record.attribute_changed?(reflection.foreign_key)
       end
 
       # Saves the associated record if it's new or <tt>:autosave</tt> is enabled.