activerecord 4.2.11.2 → 6.0.0

data/lib/active_record/associations/through_association.rb

@@ -1,11 +1,27 @@
+# frozen_string_literal: true
+
 module ActiveRecord
-  # = Active Record Through Association
   module Associations
+    # = Active Record Through Association
     module ThroughAssociation #:nodoc:
+      delegate :source_reflection, to: :reflection
+
+      private
+        def through_reflection
+          @through_reflection ||= begin
+            refl = reflection.through_reflection
 
-      delegate :source_reflection, :through_reflection, :to => :reflection
+            while refl.through_reflection?
+              refl = refl.through_reflection
+            end
+
+            refl
+          end
+        end
 
-      protected
+        def through_association
+          @through_association ||= owner.association(through_reflection.name)
+        end
 
         # We merge in these scopes for two reasons:
         #
@@ -14,7 +30,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)
             )
@@ -22,12 +38,10 @@ module ActiveRecord
           scope
         end
 
-      private
-
         # 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.
@@ -39,24 +53,22 @@ module ActiveRecord
         def construct_join_attributes(*records)
           ensure_mutable
 
-          if source_reflection.association_primary_key(reflection.klass) == reflection.klass.primary_key
+          association_primary_key = source_reflection.association_primary_key(reflection.klass)
+
+          if association_primary_key == reflection.klass.primary_key && !options[:source_type]
             join_attributes = { source_reflection.name => records }
           else
             join_attributes = {
-              source_reflection.foreign_key =>
-                records.map { |record|
-                  record.send(source_reflection.association_primary_key(reflection.klass))
-                }
+              source_reflection.foreign_key => records.map(&association_primary_key.to_sym)
             }
           end
 
           if options[:source_type]
-            join_attributes[source_reflection.foreign_type] =
-              records.map { |record| record.class.base_class.name }
+            join_attributes[source_reflection.foreign_type] = [ options[:source_type] ]
           end
 
           if records.count == 1
-            Hash[join_attributes.map { |k, v| [k, v.first] }]
+            join_attributes.transform_values!(&:first)
           else
             join_attributes
           end
@@ -76,13 +88,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
 
@@ -94,7 +114,7 @@ module ActiveRecord
             attributes[inverse.foreign_key] = target.id
           end
 
-          super(attributes)
+          super
         end
     end
   end

data/lib/active_record/attribute_assignment.rb

@@ -1,212 +1,85 @@
-require 'active_model/forbidden_attributes_protection'
+# frozen_string_literal: true
+
+require "active_model/forbidden_attributes_protection"
 
 module ActiveRecord
   module AttributeAssignment
-    extend ActiveSupport::Concern
-    include ActiveModel::ForbiddenAttributesProtection
-
-    # 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?
-
-      attributes                  = new_attributes.stringify_keys
-      multi_parameter_attributes  = []
-      nested_parameter_attributes = []
-
-      attributes = sanitize_for_mass_assignment(attributes)
-
-      attributes.each do |k, v|
-        if k.include?("(")
-          multi_parameter_attributes << [ k, v ]
-        elsif v.is_a?(Hash)
-          nested_parameter_attributes << [ k, v ]
-        else
-          _assign_attribute(k, v)
-        end
-      end
-
-      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
+    include ActiveModel::AttributeAssignment
 
     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
+      def _assign_attributes(attributes)
+        multi_parameter_attributes  = {}
+        nested_parameter_attributes = {}
 
-    # 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) }
-    end
-
-    # Instantiates objects for all attribute classes that needs more than one constructor parameter. This is done
-    # 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 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(
-        extract_callstack_for_multiparameter_attributes(pairs)
-      )
-    end
-
-    def execute_callstack_for_multiparameter_attributes(callstack)
-      errors = []
-      callstack.each do |name, values_with_empty_parameters|
-        begin
-          send("#{name}=", MultiparameterAttribute.new(self, name, values_with_empty_parameters).read_value)
-        rescue => ex
-          errors << AttributeAssignmentError.new("error on assignment #{values_with_empty_parameters.values.inspect} to #{name} (#{ex.message})", ex, name)
+        attributes.each do |k, v|
+          if k.include?("(")
+            multi_parameter_attributes[k] = attributes.delete(k)
+          elsif v.is_a?(Hash)
+            nested_parameter_attributes[k] = attributes.delete(k)
+          end
         end
-      end
-      unless errors.empty?
-        error_descriptions = errors.map { |ex| ex.message }.join(",")
-        raise MultiparameterAssignmentErrors.new(errors), "#{errors.size} error(s) on assignment of multiparameter attributes [#{error_descriptions}]"
-      end
-    end
-
-    def extract_callstack_for_multiparameter_attributes(pairs)
-      attributes = {}
+        super(attributes)
 
-      pairs.each do |(multiparameter_name, value)|
-        attribute_name = multiparameter_name.split("(").first
-        attributes[attribute_name] ||= {}
-
-        parameter_value = value.empty? ? nil : type_cast_attribute_value(multiparameter_name, value)
-        attributes[attribute_name][find_parameter_position(multiparameter_name)] ||= parameter_value
+        assign_nested_parameter_attributes(nested_parameter_attributes) unless nested_parameter_attributes.empty?
+        assign_multiparameter_attributes(multi_parameter_attributes) unless multi_parameter_attributes.empty?
       end
 
-      attributes
-    end
-
-    def type_cast_attribute_value(multiparameter_name, value)
-      multiparameter_name =~ /\([0-9]*([if])\)/ ? value.send("to_" + $1) : value
-    end
-
-    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
+      # 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) }
       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
+      # Instantiates objects for all attribute classes that needs more than one constructor parameter. This is done
+      # 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 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(
+          extract_callstack_for_multiparameter_attributes(pairs)
+        )
       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
+      def execute_callstack_for_multiparameter_attributes(callstack)
+        errors = []
+        callstack.each do |name, values_with_empty_parameters|
+          if values_with_empty_parameters.each_value.all?(&:nil?)
+            values = nil
+          else
+            values = values_with_empty_parameters
           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?
+          send("#{name}=", values)
+        rescue => ex
+          errors << AttributeAssignmentError.new("error on assignment #{values_with_empty_parameters.values.inspect} to #{name} (#{ex.message})", ex, name)
         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
+        unless errors.empty?
+          error_descriptions = errors.map(&:message).join(",")
+          raise MultiparameterAssignmentErrors.new(errors), "#{errors.size} error(s) on assignment of multiparameter attributes [#{error_descriptions}]"
         end
       end
 
-      def read_other
-        max_position = extract_max_param
-        positions    = (1..max_position)
-        validate_required_parameters!(positions)
+      def extract_callstack_for_multiparameter_attributes(pairs)
+        attributes = {}
 
-        values.slice(*positions)
-      end
+        pairs.each do |(multiparameter_name, value)|
+          attribute_name = multiparameter_name.split("(").first
+          attributes[attribute_name] ||= {}
 
-      # 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? }
+          parameter_value = value.empty? ? nil : type_cast_attribute_value(multiparameter_name, value)
+          attributes[attribute_name][find_parameter_position(multiparameter_name)] ||= parameter_value
+        end
+
+        attributes
       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
+      def type_cast_attribute_value(multiparameter_name, value)
+        multiparameter_name =~ /\([0-9]*([if])\)/ ? value.send("to_" + $1) : value
       end
 
-      def extract_max_param(upper_cap = 100)
-        [values.keys.max, upper_cap].min
+      def find_parameter_position(multiparameter_name)
+        multiparameter_name.scan(/\(([0-9]*).*\)/).first.first.to_i
       end
-    end
   end
 end

data/lib/active_record/attribute_decorators.rb

@@ -1,21 +1,44 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module AttributeDecorators # :nodoc:
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :attribute_type_decorations, instance_accessor: false # :internal:
-      self.attribute_type_decorations = TypeDecorator.new
+      class_attribute :attribute_type_decorations, instance_accessor: false, default: TypeDecorator.new # :internal:
     end
 
     module ClassMethods # :nodoc:
+      # This method is an internal API used to create class macros such as
+      # +serialize+, and features like time zone aware attributes.
+      #
+      # Used to wrap the type of an attribute in a new type.
+      # When the schema for a model is loaded, attributes with the same name as
+      # +column_name+ will have their type yielded to the given block. The
+      # return value of that block will be used instead.
+      #
+      # Subsequent calls where +column_name+ and +decorator_name+ are the same
+      # will override the previous decorator, not decorate twice. This can be
+      # used to create idempotent class macros like +serialize+
       def decorate_attribute_type(column_name, decorator_name, &block)
         matcher = ->(name, _) { name == column_name.to_s }
         key = "_#{column_name}_#{decorator_name}"
         decorate_matching_attribute_types(matcher, key, &block)
       end
 
+      # This method is an internal API used to create higher level features like
+      # time zone aware attributes.
+      #
+      # When the schema for a model is loaded, +matcher+ will be called for each
+      # attribute with its name and type. If the matcher returns a truthy value,
+      # the type will then be yielded to the given block, and the return value
+      # of that block will replace the type.
+      #
+      # Subsequent calls to this method with the same value for +decorator_name+
+      # will replace the previous decorator, not decorate twice. This can be
+      # used to ensure that class macros are idempotent.
       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,12 +47,13 @@ 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
     end
 
     class TypeDecorator # :nodoc:
@@ -52,15 +76,15 @@ module ActiveRecord
 
       private
 
-      def decorators_for(name, type)
-        matching(name, type).map(&:last)
-      end
+        def decorators_for(name, type)
+          matching(name, type).map(&:last)
+        end
 
-      def matching(name, type)
-        @decorations.values.select do |(matcher, _)|
-          matcher.call(name, type)
+        def matching(name, type)
+          @decorations.values.select do |(matcher, _)|
+            matcher.call(name, type)
+          end
         end
-      end
     end
   end
 end