activerecord 4.2.11.3 → 5.0.7.2

data/lib/active_record/associations/through_association.rb

@@ -14,7 +14,7 @@ module ActiveRecord
         def target_scope
           scope = super
           reflection.chain.drop(1).each do |reflection|
-            relation = reflection.klass.all
+            relation = reflection.klass.scope_for_association
             scope.merge!(
               relation.except(:select, :create_with, :includes, :preload, :joins, :eager_load)
             )
@@ -27,7 +27,7 @@ module ActiveRecord
         # Construct attributes for :through pointing to owner and associate. This is used by the
         # methods which create and delete records on the association.
         #
-        # We only support indirectly modifying through associations which has a belongs_to source.
+        # We only support indirectly modifying through associations which have a belongs_to source.
         # This is the "has_many :tags, through: :taggings" situation, where the join model
         # typically has a belongs_to on both side. In other words, associations which could also
         # be represented as has_and_belongs_to_many associations.
@@ -76,13 +76,21 @@ module ActiveRecord
 
         def ensure_mutable
           unless source_reflection.belongs_to?
-            raise HasManyThroughCantAssociateThroughHasOneOrManyReflection.new(owner, reflection)
+            if reflection.has_one?
+              raise HasOneThroughCantAssociateThroughHasOneOrManyReflection.new(owner, reflection)
+            else
+              raise HasManyThroughCantAssociateThroughHasOneOrManyReflection.new(owner, reflection)
+            end
           end
         end
 
         def ensure_not_nested
           if reflection.nested?
-            raise HasManyThroughNestedAssociationsAreReadonly.new(owner, reflection)
+            if reflection.has_one?
+              raise HasOneThroughNestedAssociationsAreReadonly.new(owner, reflection)
+            else
+              raise HasManyThroughNestedAssociationsAreReadonly.new(owner, reflection)
+            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, original_attribute || 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
+      type.serialize(original_value)
     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?
@@ -120,7 +160,7 @@ module ActiveRecord
         value
       end
 
-      def changed_in_place_from?(old_value)
+      def changed_in_place?
         false
       end
     end
@@ -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/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_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) }
@@ -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