activerecord 4.2.6 → 5.0.0

data/lib/active_record/attribute/user_provided_default.rb

@@ -0,0 +1,28 @@
+require 'active_record/attribute'
+
+module ActiveRecord
+  class Attribute # :nodoc:
+    class UserProvidedDefault < FromUser # :nodoc:
+      def initialize(name, value, type, database_default)
+        @user_provided_value = value
+        super(name, value, type, database_default)
+      end
+
+      def value_before_type_cast
+        if user_provided_value.is_a?(Proc)
+          @memoized_value_before_type_cast ||= user_provided_value.call
+        else
+          @user_provided_value
+        end
+      end
+
+      def with_type(type)
+        self.class.new(name, user_provided_value, type, original_attribute)
+      end
+
+      protected
+
+      attr_reader :user_provided_value
+    end
+  end
+end

data/lib/active_record/attribute.rb

@@ -5,8 +5,8 @@ module ActiveRecord
         FromDatabase.new(name, value, type)
       end
 
-      def from_user(name, value, type)
-        FromUser.new(name, value, type)
+      def from_user(name, value, type, original_attribute = nil)
+        FromUser.new(name, value, type, original_attribute)
       end
 
       def with_cast_value(name, value, type)
@@ -26,36 +26,46 @@ module ActiveRecord
 
     # This method should not be called directly.
     # Use #from_database or #from_user
-    def initialize(name, value_before_type_cast, type)
+    def initialize(name, value_before_type_cast, type, original_attribute = nil)
       @name = name
       @value_before_type_cast = value_before_type_cast
       @type = type
+      @original_attribute = original_attribute
     end
 
     def value
       # `defined?` is cheaper than `||=` when we get back falsy values
-      @value = original_value unless defined?(@value)
+      @value = type_cast(value_before_type_cast) unless defined?(@value)
       @value
     end
 
     def original_value
-      type_cast(value_before_type_cast)
+      if assigned?
+        original_attribute.original_value
+      else
+        type_cast(value_before_type_cast)
+      end
     end
 
     def value_for_database
-      type.type_cast_for_database(value)
+      type.serialize(value)
+    end
+
+    def changed?
+      changed_from_assignment? || changed_in_place?
     end
 
-    def changed_from?(old_value)
-      type.changed?(old_value, value, value_before_type_cast)
+    def changed_in_place?
+      has_been_read? && type.changed_in_place?(original_value_for_database, value)
     end
 
-    def changed_in_place_from?(old_value)
-      has_been_read? && type.changed_in_place?(old_value, value)
+    def forgetting_assignment
+      with_value_from_database(value_for_database)
     end
 
     def with_value_from_user(value)
-      self.class.from_user(name, value, type)
+      type.assert_valid_value(value)
+      self.class.from_user(name, value, type, self)
     end
 
     def with_value_from_database(value)
@@ -66,6 +76,10 @@ module ActiveRecord
       self.class.with_cast_value(name, value, type)
     end
 
+    def with_type(type)
+      self.class.new(name, value_before_type_cast, type, original_attribute)
+    end
+
     def type_cast(*)
       raise NotImplementedError
     end
@@ -78,36 +92,62 @@ module ActiveRecord
       false
     end
 
+    def has_been_read?
+      defined?(@value)
+    end
+
     def ==(other)
       self.class == other.class &&
         name == other.name &&
         value_before_type_cast == other.value_before_type_cast &&
         type == other.type
     end
+    alias eql? ==
+
+    def hash
+      [self.class, name, value_before_type_cast, type].hash
+    end
 
     protected
 
+    attr_reader :original_attribute
+    alias_method :assigned?, :original_attribute
+
     def initialize_dup(other)
       if defined?(@value) && @value.duplicable?
         @value = @value.dup
       end
     end
 
-    private
+    def changed_from_assignment?
+      assigned? && type.changed?(original_value, value, value_before_type_cast)
+    end
+
+    def original_value_for_database
+      if assigned?
+        original_attribute.original_value_for_database
+      else
+        _original_value_for_database
+      end
+    end
 
-    def has_been_read?
-      defined?(@value)
+    def _original_value_for_database
+      value_for_database
     end
 
     class FromDatabase < Attribute # :nodoc:
       def type_cast(value)
-        type.type_cast_from_database(value)
+        type.deserialize(value)
+      end
+
+      def _original_value_for_database
+        value_before_type_cast
       end
     end
 
     class FromUser < Attribute # :nodoc:
       def type_cast(value)
-        type.type_cast_from_user(value)
+        type.cast(value)
       end
 
       def came_from_user?
@@ -130,10 +170,14 @@ module ActiveRecord
         super(name, nil, Type::Value.new)
       end
 
-      def value
+      def type_cast(*)
         nil
       end
 
+      def with_type(type)
+        self.class.with_cast_value(name, nil, type)
+      end
+
       def with_value_from_database(value)
         raise ActiveModel::MissingAttributeError, "can't write unknown attribute `#{name}`"
       end
@@ -141,6 +185,8 @@ module ActiveRecord
     end
 
     class Uninitialized < Attribute # :nodoc:
+      UNINITIALIZED_ORIGINAL_VALUE = Object.new
+
       def initialize(name, type)
         super(name, nil, type)
       end
@@ -151,6 +197,10 @@ module ActiveRecord
         end
       end
 
+      def original_value
+        UNINITIALIZED_ORIGINAL_VALUE
+      end
+
       def value_for_database
       end
 
@@ -158,6 +208,6 @@ module ActiveRecord
         false
       end
     end
-    private_constant :FromDatabase, :FromUser, :Null, :Uninitialized
+    private_constant :FromDatabase, :FromUser, :Null, :Uninitialized, :WithCastValue
   end
 end

data/lib/active_record/attribute_assignment.rb

@@ -3,63 +3,32 @@ require 'active_model/forbidden_attributes_protection'
 module ActiveRecord
   module AttributeAssignment
     extend ActiveSupport::Concern
-    include ActiveModel::ForbiddenAttributesProtection
+    include ActiveModel::AttributeAssignment
 
-    # Allows you to set all the attributes by passing in a hash of attributes with
-    # keys matching the attribute names (which again matches the column names).
-    #
-    # If the passed hash responds to <tt>permitted?</tt> method and the return value
-    # of this method is +false+ an <tt>ActiveModel::ForbiddenAttributesError</tt>
-    # exception is raised.
-    #
-    #   cat = Cat.new(name: "Gorby", status: "yawning")
-    #   cat.attributes # =>  { "name" => "Gorby", "status" => "yawning", "created_at" => nil, "updated_at" => nil}
-    #   cat.assign_attributes(status: "sleeping")
-    #   cat.attributes # =>  { "name" => "Gorby", "status" => "sleeping", "created_at" => nil, "updated_at" => nil }
-    #
-    # New attributes will be persisted in the database when the object is saved.
-    #
-    # Aliased to <tt>attributes=</tt>.
-    def assign_attributes(new_attributes)
-      if !new_attributes.respond_to?(:stringify_keys)
-        raise ArgumentError, "When assigning attributes, you must pass a hash as an argument."
-      end
-      return if new_attributes.blank?
+    # Alias for ActiveModel::AttributeAssignment#assign_attributes. See ActiveModel::AttributeAssignment.
+    def attributes=(attributes)
+      assign_attributes(attributes)
+    end
 
-      attributes                  = new_attributes.stringify_keys
-      multi_parameter_attributes  = []
-      nested_parameter_attributes = []
+    private
 
-      attributes = sanitize_for_mass_assignment(attributes)
+    def _assign_attributes(attributes) # :nodoc:
+      multi_parameter_attributes  = {}
+      nested_parameter_attributes = {}
 
       attributes.each do |k, v|
         if k.include?("(")
-          multi_parameter_attributes << [ k, v ]
+          multi_parameter_attributes[k] = attributes.delete(k)
         elsif v.is_a?(Hash)
-          nested_parameter_attributes << [ k, v ]
-        else
-          _assign_attribute(k, v)
+          nested_parameter_attributes[k] = attributes.delete(k)
         end
       end
+      super(attributes)
 
       assign_nested_parameter_attributes(nested_parameter_attributes) unless nested_parameter_attributes.empty?
       assign_multiparameter_attributes(multi_parameter_attributes) unless multi_parameter_attributes.empty?
     end
 
-    alias attributes= assign_attributes
-
-    private
-
-    def _assign_attribute(k, v)
-      public_send("#{k}=", v)
-    rescue NoMethodError, NameError
-      if respond_to?("#{k}=")
-        raise
-      else
-        raise UnknownAttributeError.new(self, k)
-      end
-    end
-
     # Assign any deferred nested attributes after the base attributes have been set.
     def assign_nested_parameter_attributes(pairs)
       pairs.each { |k, v| _assign_attribute(k, v) }
@@ -69,7 +38,7 @@ module ActiveRecord
     # by calling new on the column type or aggregation type (through composed_of) object with these parameters.
     # So having the pairs written_on(1) = "2004", written_on(2) = "6", written_on(3) = "24", will instantiate
     # written_on (a date type) with Date.new("2004", "6", "24"). You can also specify a typecast character in the
-    # parentheses to have the parameters typecasted before they're used in the constructor. Use i for Fixnum and
+    # parentheses to have the parameters typecasted before they're used in the constructor. Use i for Integer and
     # f for Float. If all the values for a given attribute are empty, the attribute will be set to +nil+.
     def assign_multiparameter_attributes(pairs)
       execute_callstack_for_multiparameter_attributes(
@@ -81,13 +50,18 @@ module ActiveRecord
       errors = []
       callstack.each do |name, values_with_empty_parameters|
         begin
-          send("#{name}=", MultiparameterAttribute.new(self, name, values_with_empty_parameters).read_value)
+          if values_with_empty_parameters.each_value.all?(&:nil?)
+            values = nil
+          else
+            values = values_with_empty_parameters
+          end
+          send("#{name}=", values)
         rescue => ex
           errors << AttributeAssignmentError.new("error on assignment #{values_with_empty_parameters.values.inspect} to #{name} (#{ex.message})", ex, name)
         end
       end
       unless errors.empty?
-        error_descriptions = errors.map { |ex| ex.message }.join(",")
+        error_descriptions = errors.map(&:message).join(",")
         raise MultiparameterAssignmentErrors.new(errors), "#{errors.size} error(s) on assignment of multiparameter attributes [#{error_descriptions}]"
       end
     end
@@ -113,100 +87,5 @@ module ActiveRecord
     def find_parameter_position(multiparameter_name)
       multiparameter_name.scan(/\(([0-9]*).*\)/).first.first.to_i
     end
-
-    class MultiparameterAttribute #:nodoc:
-      attr_reader :object, :name, :values, :cast_type
-
-      def initialize(object, name, values)
-        @object = object
-        @name   = name
-        @values = values
-      end
-
-      def read_value
-        return if values.values.compact.empty?
-
-        @cast_type = object.type_for_attribute(name)
-        klass = cast_type.klass
-
-        if klass == Time
-          read_time
-        elsif klass == Date
-          read_date
-        else
-          read_other
-        end
-      end
-
-      private
-
-      def instantiate_time_object(set_values)
-        if object.class.send(:create_time_zone_conversion_attribute?, name, cast_type)
-          Time.zone.local(*set_values)
-        else
-          Time.send(object.class.default_timezone, *set_values)
-        end
-      end
-
-      def read_time
-        # If column is a :time (and not :date or :datetime) there is no need to validate if
-        # there are year/month/day fields
-        if cast_type.type == :time
-          # if the column is a time set the values to their defaults as January 1, 1970, but only if they're nil
-          { 1 => 1970, 2 => 1, 3 => 1 }.each do |key,value|
-            values[key] ||= value
-          end
-        else
-          # else column is a timestamp, so if Date bits were not provided, error
-          validate_required_parameters!([1,2,3])
-
-          # If Date bits were provided but blank, then return nil
-          return if blank_date_parameter?
-        end
-
-        max_position = extract_max_param(6)
-        set_values   = values.values_at(*(1..max_position))
-        # If Time bits are not there, then default to 0
-        (3..5).each { |i| set_values[i] = set_values[i].presence || 0 }
-        instantiate_time_object(set_values)
-      end
-
-      def read_date
-        return if blank_date_parameter?
-        set_values = values.values_at(1,2,3)
-        begin
-          Date.new(*set_values)
-        rescue ArgumentError # if Date.new raises an exception on an invalid date
-          instantiate_time_object(set_values).to_date # we instantiate Time object and convert it back to a date thus using Time's logic in handling invalid dates
-        end
-      end
-
-      def read_other
-        max_position = extract_max_param
-        positions    = (1..max_position)
-        validate_required_parameters!(positions)
-
-        values.slice(*positions)
-      end
-
-      # Checks whether some blank date parameter exists. Note that this is different
-      # than the validate_required_parameters! method, since it just checks for blank
-      # positions instead of missing ones, and does not raise in case one blank position
-      # exists. The caller is responsible to handle the case of this returning true.
-      def blank_date_parameter?
-        (1..3).any? { |position| values[position].blank? }
-      end
-
-      # If some position is not provided, it errors out a missing parameter exception.
-      def validate_required_parameters!(positions)
-        if missing_parameter = positions.detect { |position| !values.key?(position) }
-          raise ArgumentError.new("Missing Parameter - #{name}(#{missing_parameter})")
-        end
-      end
-
-      def extract_max_param(upper_cap = 100)
-        [values.keys.max, upper_cap].min
-      end
-    end
   end
 end

data/lib/active_record/attribute_decorators.rb

@@ -15,7 +15,7 @@ module ActiveRecord
       end
 
       def decorate_matching_attribute_types(matcher, decorator_name, &block)
-        clear_caches_calculated_from_columns
+        reload_schema_from_cache
         decorator_name = decorator_name.to_s
 
         # Create new hashes so we don't modify parent classes
@@ -24,10 +24,11 @@ module ActiveRecord
 
       private
 
-      def add_user_provided_columns(*)
-        super.map do |column|
-          decorated_type = attribute_type_decorations.apply(column.name, column.cast_type)
-          column.with_type(decorated_type)
+      def load_schema!
+        super
+        attribute_types.each do |name, type|
+          decorated_type = attribute_type_decorations.apply(name, type)
+          define_attribute(name, decorated_type)
         end
       end
     end

data/lib/active_record/attribute_methods/before_type_cast.rb

@@ -2,7 +2,7 @@ module ActiveRecord
   module AttributeMethods
     # = Active Record Attribute Methods Before Type Cast
     #
-    # <tt>ActiveRecord::AttributeMethods::BeforeTypeCast</tt> provides a way to
+    # ActiveRecord::AttributeMethods::BeforeTypeCast provides a way to
     # read the value of the attributes before typecasting and deserialization.
     #
     #   class Task < ActiveRecord::Base

data/lib/active_record/attribute_methods/dirty.rb

@@ -1,4 +1,5 @@
 require 'active_support/core_ext/module/attribute_accessors'
+require 'active_record/attribute_mutation_tracker'
 
 module ActiveRecord
   module AttributeMethods
@@ -34,24 +35,43 @@ module ActiveRecord
       # <tt>reload</tt> the record and clears changed attributes.
       def reload(*)
         super.tap do
-          clear_changes_information
+          @mutation_tracker = nil
+          @previous_mutation_tracker = nil
+          @changed_attributes = HashWithIndifferentAccess.new
         end
       end
 
       def initialize_dup(other) # :nodoc:
         super
-        @original_raw_attributes = nil
-        calculate_changes_from_defaults
+        @attributes = self.class._default_attributes.map do |attr|
+          attr.with_value_from_user(@attributes.fetch_value(attr.name))
+        end
+        @mutation_tracker = nil
       end
 
       def changes_applied
-        super
-        store_original_raw_attributes
+        @previous_mutation_tracker = mutation_tracker
+        @changed_attributes = HashWithIndifferentAccess.new
+        store_original_attributes
       end
 
       def clear_changes_information
+        @previous_mutation_tracker = nil
+        @changed_attributes = HashWithIndifferentAccess.new
+        store_original_attributes
+      end
+
+      def raw_write_attribute(attr_name, *)
+        result = super
+        clear_attribute_change(attr_name)
+        result
+      end
+
+      def clear_attribute_changes(attr_names)
         super
-        original_raw_attributes.clear
+        attr_names.each do |attr_name|
+          clear_attribute_change(attr_name)
+        end
       end
 
       def changed_attributes
@@ -60,7 +80,7 @@ module ActiveRecord
         if defined?(@cached_changed_attributes)
           @cached_changed_attributes
         else
-          super.reverse_merge(attributes_changed_in_place).freeze
+          super.reverse_merge(mutation_tracker.changed_values).freeze
         end
       end
 
@@ -70,59 +90,29 @@ module ActiveRecord
         end
       end
 
+      def previous_changes
+        previous_mutation_tracker.changes
+      end
+
       def attribute_changed_in_place?(attr_name)
-        old_value = original_raw_attribute(attr_name)
-        @attributes[attr_name].changed_in_place_from?(old_value)
+        mutation_tracker.changed_in_place?(attr_name)
       end
 
       private
 
-      def changes_include?(attr_name)
-        super || attribute_changed_in_place?(attr_name)
-      end
-
-      def calculate_changes_from_defaults
-        @changed_attributes = nil
-        self.class.column_defaults.each do |attr, orig_value|
-          set_attribute_was(attr, orig_value) if _field_changed?(attr, orig_value)
+      def mutation_tracker
+        unless defined?(@mutation_tracker)
+          @mutation_tracker = nil
         end
+        @mutation_tracker ||= AttributeMutationTracker.new(@attributes)
       end
 
-      # Wrap write_attribute to remember original attribute value.
-      def write_attribute(attr, value)
-        attr = attr.to_s
-
-        old_value = old_attribute_value(attr)
-
-        result = super
-        store_original_raw_attribute(attr)
-        save_changed_attribute(attr, old_value)
-        result
-      end
-
-      def raw_write_attribute(attr, value)
-        attr = attr.to_s
-
-        result = super
-        original_raw_attributes[attr] = value
-        result
+      def changes_include?(attr_name)
+        super || mutation_tracker.changed?(attr_name)
       end
 
-      def save_changed_attribute(attr, old_value)
-        clear_changed_attributes_cache
-        if attribute_changed_by_setter?(attr)
-          clear_attribute_changes(attr) unless _field_changed?(attr, old_value)
-        else
-          set_attribute_was(attr, old_value) if _field_changed?(attr, old_value)
-        end
-      end
-
-      def old_attribute_value(attr)
-        if attribute_changed?(attr)
-          changed_attributes[attr]
-        else
-          clone_attribute_value(:_read_attribute, attr)
-        end
+      def clear_attribute_change(attr_name)
+        mutation_tracker.forget_change(attr_name)
       end
 
       def _update_record(*)
@@ -133,47 +123,17 @@ module ActiveRecord
         partial_writes? ? super(keys_for_partial_write) : super
       end
 
-      # Serialized attributes should always be written in case they've been
-      # changed in place.
       def keys_for_partial_write
-        changed & persistable_attribute_names
-      end
-
-      def _field_changed?(attr, old_value)
-        @attributes[attr].changed_from?(old_value)
-      end
-
-      def attributes_changed_in_place
-        changed_in_place.each_with_object({}) do |attr_name, h|
-          orig = @attributes[attr_name].original_value
-          h[attr_name] = orig
-        end
-      end
-
-      def changed_in_place
-        self.class.attribute_names.select do |attr_name|
-          attribute_changed_in_place?(attr_name)
-        end
+        changed & self.class.column_names
       end
 
-      def original_raw_attribute(attr_name)
-        original_raw_attributes.fetch(attr_name) do
-          read_attribute_before_type_cast(attr_name)
-        end
+      def store_original_attributes
+        @attributes = @attributes.map(&:forgetting_assignment)
+        @mutation_tracker = nil
       end
 
-      def original_raw_attributes
-        @original_raw_attributes ||= {}
-      end
-
-      def store_original_raw_attribute(attr_name)
-        original_raw_attributes[attr_name] = @attributes[attr_name].value_for_database rescue nil
-      end
-
-      def store_original_raw_attributes
-        attribute_names.each do |attr|
-          store_original_raw_attribute(attr)
-        end
+      def previous_mutation_tracker
+        @previous_mutation_tracker ||= NullMutationTracker.instance
       end
 
       def cache_changed_attributes

data/lib/active_record/attribute_methods/primary_key.rb

@@ -5,7 +5,7 @@ module ActiveRecord
     module PrimaryKey
       extend ActiveSupport::Concern
 
-      # Returns this record's primary key value wrapped in an Array if one is
+      # Returns this record's primary key value wrapped in an array if one is
       # available.
       def to_key
         sync_with_transaction_state
@@ -108,7 +108,7 @@ module ActiveRecord
         #     self.primary_key = 'sysid'
         #   end
         #
-        # You can also define the +primary_key+ method yourself:
+        # You can also define the #primary_key method yourself:
         #
         #   class Project < ActiveRecord::Base
         #     def self.primary_key

data/lib/active_record/attribute_methods/query.rb

@@ -19,10 +19,10 @@ module ActiveRecord
             if Numeric === value || value !~ /[^0-9]/
               !value.to_i.zero?
             else
-              return false if ActiveRecord::ConnectionAdapters::Column::FALSE_VALUES.include?(value)
+              return false if ActiveModel::Type::Boolean::FALSE_VALUES.include?(value)
               !value.blank?
             end
-          elsif column.number?
+          elsif value.respond_to?(:zero?)
             !value.zero?
           else
             !value.blank?