activerecord 6.0.0

data/lib/active_record/associations/foreign_association.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ActiveRecord::Associations
+  module ForeignAssociation # :nodoc:
+    def foreign_key_present?
+      if reflection.klass.primary_key
+        owner.attribute_present?(reflection.active_record_primary_key)
+      else
+        false
+      end
+    end
+
+    def nullified_owner_attributes
+      Hash.new.tap do |attrs|
+        attrs[reflection.foreign_key] = nil
+        attrs[reflection.type] = nil if reflection.type.present?
+      end
+    end
+  end
+end

data/lib/active_record/associations/has_many_association.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Associations
+    # = Active Record Has Many Association
+    # This is the proxy that handles a has many association.
+    #
+    # If the association has a <tt>:through</tt> option further specialization
+    # is provided by its child HasManyThroughAssociation.
+    class HasManyAssociation < CollectionAssociation #:nodoc:
+      include ForeignAssociation
+
+      def handle_dependency
+        case options[:dependent]
+        when :restrict_with_exception
+          raise ActiveRecord::DeleteRestrictionError.new(reflection.name) unless empty?
+
+        when :restrict_with_error
+          unless empty?
+            record = owner.class.human_attribute_name(reflection.name).downcase
+            owner.errors.add(:base, :'restrict_dependent_destroy.has_many', record: record)
+            throw(:abort)
+          end
+
+        when :destroy
+          # No point in executing the counter update since we're going to destroy the parent anyway
+          load_target.each { |t| t.destroyed_by_association = reflection }
+          destroy_all
+        else
+          delete_all
+        end
+      end
+
+      def insert_record(record, validate = true, raise = false)
+        set_owner_attributes(record)
+        super
+      end
+
+      private
+
+        # Returns the number of records in this collection.
+        #
+        # If the association has a counter cache it gets that value. Otherwise
+        # it will attempt to do a count via SQL, bounded to <tt>:limit</tt> if
+        # there's one. Some configuration options like :group make it impossible
+        # to do an SQL count, in those cases the array count will be used.
+        #
+        # That does not depend on whether the collection has already been loaded
+        # or not. The +size+ method is the one that takes the loaded flag into
+        # account and delegates to +count_records+ if needed.
+        #
+        # If the collection is empty the target is set to an empty array and
+        # the loaded flag is set to true as well.
+        def count_records
+          count = if reflection.has_cached_counter?
+            owner._read_attribute(reflection.counter_cache_column).to_i
+          else
+            scope.count(:all)
+          end
+
+          # If there's nothing in the database and @target has no new records
+          # we are certain the current target is an empty array. This is a
+          # documented side-effect of the method that may avoid an extra SELECT.
+          loaded! if count == 0
+
+          [association_scope.limit_value, count].compact.min
+        end
+
+        def update_counter(difference, reflection = reflection())
+          if reflection.has_cached_counter?
+            owner.increment!(reflection.counter_cache_column, difference)
+          end
+        end
+
+        def update_counter_in_memory(difference, reflection = reflection())
+          if reflection.counter_must_be_updated_by_has_many?
+            counter = reflection.counter_cache_column
+            owner.increment(counter, difference)
+            owner.send(:clear_attribute_change, counter) # eww
+          end
+        end
+
+        def delete_count(method, scope)
+          if method == :delete_all
+            scope.delete_all
+          else
+            scope.update_all(nullified_owner_attributes)
+          end
+        end
+
+        def delete_or_nullify_all_records(method)
+          count = delete_count(method, scope)
+          update_counter(-count)
+          count
+        end
+
+        # Deletes the records according to the <tt>:dependent</tt> option.
+        def delete_records(records, method)
+          if method == :destroy
+            records.each(&:destroy!)
+            update_counter(-records.length) unless reflection.inverse_updates_counter_cache?
+          else
+            scope = self.scope.where(reflection.klass.primary_key => records)
+            update_counter(-delete_count(method, scope))
+          end
+        end
+
+        def concat_records(records, *)
+          update_counter_if_success(super, records.length)
+        end
+
+        def _create_record(attributes, *)
+          if attributes.is_a?(Array)
+            super
+          else
+            update_counter_if_success(super, 1)
+          end
+        end
+
+        def update_counter_if_success(saved_successfully, difference)
+          if saved_successfully
+            update_counter_in_memory(difference)
+          end
+          saved_successfully
+        end
+
+        def difference(a, b)
+          a - b
+        end
+
+        def intersection(a, b)
+          a & b
+        end
+    end
+  end
+end

data/lib/active_record/associations/has_many_through_association.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Associations
+    # = Active Record Has Many Through Association
+    class HasManyThroughAssociation < HasManyAssociation #:nodoc:
+      include ThroughAssociation
+
+      def initialize(owner, reflection)
+        super
+        @through_records = {}
+      end
+
+      def concat(*records)
+        unless owner.new_record?
+          records.flatten.each do |record|
+            raise_on_type_mismatch!(record)
+          end
+        end
+
+        super
+      end
+
+      def insert_record(record, validate = true, raise = false)
+        ensure_not_nested
+
+        if record.new_record? || record.has_changes_to_save?
+          return unless super
+        end
+
+        save_through_record(record)
+
+        record
+      end
+
+      private
+        def concat_records(records)
+          ensure_not_nested
+
+          records = super(records, true)
+
+          if owner.new_record? && records
+            records.flatten.each do |record|
+              build_through_record(record)
+            end
+          end
+
+          records
+        end
+
+        # The through record (built with build_record) is temporarily cached
+        # so that it may be reused if insert_record is subsequently called.
+        #
+        # However, after insert_record has been called, the cache is cleared in
+        # order to allow multiple instances of the same record in an association.
+        def build_through_record(record)
+          @through_records[record.object_id] ||= begin
+            ensure_mutable
+
+            attributes = through_scope_attributes
+            attributes[source_reflection.name] = record
+            attributes[source_reflection.foreign_type] = options[:source_type] if options[:source_type]
+
+            through_association.build(attributes)
+          end
+        end
+
+        def through_scope_attributes
+          scope.where_values_hash(through_association.reflection.name.to_s).
+            except!(through_association.reflection.foreign_key,
+                    through_association.reflection.klass.inheritance_column)
+        end
+
+        def save_through_record(record)
+          association = build_through_record(record)
+          if association.changed?
+            association.save!
+          end
+        ensure
+          @through_records.delete(record.object_id)
+        end
+
+        def build_record(attributes)
+          ensure_not_nested
+
+          record = super
+
+          inverse = source_reflection.inverse_of
+          if inverse
+            if inverse.collection?
+              record.send(inverse.name) << build_through_record(record)
+            elsif inverse.has_one?
+              record.send("#{inverse.name}=", build_through_record(record))
+            end
+          end
+
+          record
+        end
+
+        def remove_records(existing_records, records, method)
+          super
+          delete_through_records(records)
+        end
+
+        def target_reflection_has_associated_record?
+          !(through_reflection.belongs_to? && owner[through_reflection.foreign_key].blank?)
+        end
+
+        def update_through_counter?(method)
+          case method
+          when :destroy
+            !through_reflection.inverse_updates_counter_cache?
+          when :nullify
+            false
+          else
+            true
+          end
+        end
+
+        def delete_or_nullify_all_records(method)
+          delete_records(load_target, method)
+        end
+
+        def delete_records(records, method)
+          ensure_not_nested
+
+          scope = through_association.scope
+          scope.where! construct_join_attributes(*records)
+          scope = scope.where(through_scope_attributes)
+
+          case method
+          when :destroy
+            if scope.klass.primary_key
+              count = scope.destroy_all.count(&:destroyed?)
+            else
+              scope.each(&:_run_destroy_callbacks)
+              count = scope.delete_all
+            end
+          when :nullify
+            count = scope.update_all(source_reflection.foreign_key => nil)
+          else
+            count = scope.delete_all
+          end
+
+          delete_through_records(records)
+
+          if source_reflection.options[:counter_cache] && method != :destroy
+            counter = source_reflection.counter_cache_column
+            klass.decrement_counter counter, records.map(&:id)
+          end
+
+          if through_reflection.collection? && update_through_counter?(method)
+            update_counter(-count, through_reflection)
+          else
+            update_counter(-count)
+          end
+
+          count
+        end
+
+        def difference(a, b)
+          distribution = distribution(b)
+
+          a.reject { |record| mark_occurrence(distribution, record) }
+        end
+
+        def intersection(a, b)
+          distribution = distribution(b)
+
+          a.select { |record| mark_occurrence(distribution, record) }
+        end
+
+        def mark_occurrence(distribution, record)
+          distribution[record] > 0 && distribution[record] -= 1
+        end
+
+        def distribution(array)
+          array.each_with_object(Hash.new(0)) do |record, distribution|
+            distribution[record] += 1
+          end
+        end
+
+        def through_records_for(record)
+          attributes = construct_join_attributes(record)
+          candidates = Array.wrap(through_association.target)
+          candidates.find_all do |c|
+            attributes.all? do |key, value|
+              c.public_send(key) == value
+            end
+          end
+        end
+
+        def delete_through_records(records)
+          records.each do |record|
+            through_records = through_records_for(record)
+
+            if through_reflection.collection?
+              through_records.each { |r| through_association.target.delete(r) }
+            else
+              if through_records.include?(through_association.target)
+                through_association.target = nil
+              end
+            end
+
+            @through_records.delete(record.object_id)
+          end
+        end
+
+        def find_target
+          return [] unless target_reflection_has_associated_record?
+          super
+        end
+
+        # NOTE - not sure that we can actually cope with inverses here
+        def invertible_for?(record)
+          false
+        end
+    end
+  end
+end

data/lib/active_record/associations/has_one_association.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Associations
+    # = Active Record Has One Association
+    class HasOneAssociation < SingularAssociation #:nodoc:
+      include ForeignAssociation
+
+      def handle_dependency
+        case options[:dependent]
+        when :restrict_with_exception
+          raise ActiveRecord::DeleteRestrictionError.new(reflection.name) if load_target
+
+        when :restrict_with_error
+          if load_target
+            record = owner.class.human_attribute_name(reflection.name).downcase
+            owner.errors.add(:base, :'restrict_dependent_destroy.has_one', record: record)
+            throw(:abort)
+          end
+
+        else
+          delete
+        end
+      end
+
+      def delete(method = options[:dependent])
+        if load_target
+          case method
+          when :delete
+            target.delete
+          when :destroy
+            target.destroyed_by_association = reflection
+            target.destroy
+            throw(:abort) unless target.destroyed?
+          when :nullify
+            target.update_columns(nullified_owner_attributes) if target.persisted?
+          end
+        end
+      end
+
+      private
+        def replace(record, save = true)
+          raise_on_type_mismatch!(record) if record
+
+          return target unless load_target || record
+
+          assigning_another_record = target != record
+          if assigning_another_record || record.has_changes_to_save?
+            save &&= owner.persisted?
+
+            transaction_if(save) do
+              remove_target!(options[:dependent]) if target && !target.destroyed? && assigning_another_record
+
+              if record
+                set_owner_attributes(record)
+                set_inverse_instance(record)
+
+                if save && !record.save
+                  nullify_owner_attributes(record)
+                  set_owner_attributes(target) if target
+                  raise RecordNotSaved, "Failed to save the new associated #{reflection.name}."
+                end
+              end
+            end
+          end
+
+          self.target = record
+        end
+
+        # The reason that the save param for replace is false, if for create (not just build),
+        # is because the setting of the foreign keys is actually handled by the scoping when
+        # the record is instantiated, and so they are set straight away and do not need to be
+        # updated within replace.
+        def set_new_record(record)
+          replace(record, false)
+        end
+
+        def remove_target!(method)
+          case method
+          when :delete
+            target.delete
+          when :destroy
+            target.destroyed_by_association = reflection
+            target.destroy
+          else
+            nullify_owner_attributes(target)
+            remove_inverse_instance(target)
+
+            if target.persisted? && owner.persisted? && !target.save
+              set_owner_attributes(target)
+              raise RecordNotSaved, "Failed to remove the existing associated #{reflection.name}. " \
+                                    "The record failed to save after its foreign key was set to nil."
+            end
+          end
+        end
+
+        def nullify_owner_attributes(record)
+          record[reflection.foreign_key] = nil
+        end
+
+        def transaction_if(value)
+          if value
+            reflection.klass.transaction { yield }
+          else
+            yield
+          end
+        end
+
+        def _create_record(attributes, raise_error = false, &block)
+          unless owner.persisted?
+            raise ActiveRecord::RecordNotSaved, "You cannot call create unless the parent is saved"
+          end
+
+          super
+        end
+    end
+  end
+end