omg-activerecord 8.0.0.alpha1

data/lib/active_record/associations/has_many_through_association.rb

@@ -0,0 +1,232 @@
+# 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 = {}.compare_by_identity
+      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] ||= begin
+            ensure_mutable
+
+            attributes = through_scope_attributes
+            attributes[source_reflection.name] = record
+
+            through_association.build(attributes).tap do |new_record|
+              new_record.send("#{source_reflection.foreign_type}=", options[:source_type]) if options[:source_type]
+            end
+          end
+        end
+
+        attr_reader :through_scope
+
+        def through_scope_attributes
+          scope = through_scope || self.scope
+          attributes = scope.where_values_hash(through_association.reflection.klass.table_name)
+          except_keys = [
+            *Array(through_association.reflection.foreign_key),
+            through_association.reflection.klass.inheritance_column
+          ]
+          attributes.except!(*except_keys)
+        end
+
+        def save_through_record(record)
+          association = build_through_record(record)
+          if association.changed?
+            association.save!
+          end
+        ensure
+          @through_records.delete(record)
+        end
+
+        def build_record(attributes)
+          ensure_not_nested
+
+          @through_scope = scope
+          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
+        ensure
+          @through_scope = nil
+        end
+
+        def remove_records(existing_records, records, method)
+          super
+          delete_through_records(records)
+        end
+
+        def target_reflection_has_associated_record?
+          !(through_reflection.belongs_to? && Array(through_reflection.foreign_key).all? { |foreign_key_column| owner[foreign_key_column].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.model.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)
+          end
+        end
+
+        def find_target(async: false)
+          raise NotImplementedError, "No async loading for HasManyThroughAssociation yet" if async
+          return [] unless target_reflection_has_associated_record?
+          return scope.to_a if disable_joins
+          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,142 @@
+# 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 :destroy_async
+            if target.class.query_constraints_list
+              primary_key_column = target.class.query_constraints_list
+              id = primary_key_column.map { |col| target.public_send(col) }
+            else
+              primary_key_column = target.class.primary_key
+              id = target.public_send(primary_key_column)
+            end
+
+            enqueue_destroy_association(
+              owner_model_name: owner.class.to_s,
+              owner_id: owner.id,
+              association_class: reflection.klass.to_s,
+              association_ids: [id],
+              association_primary_key_column: primary_key_column,
+              ensuring_owner_was_method: options.fetch(:ensuring_owner_was, nil)
+            )
+          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.new("Failed to save the new associated #{reflection.name}.", record)
+                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
+            if target.persisted?
+              target.destroy
+            end
+          else
+            nullify_owner_attributes(target)
+            remove_inverse_instance(target)
+
+            if target.persisted? && owner.persisted? && !target.save
+              set_owner_attributes(target)
+              raise RecordNotSaved.new(
+                "Failed to remove the existing associated #{reflection.name}. " \
+                "The record failed to save after its foreign key was set to nil.",
+                target
+              )
+            end
+          end
+        end
+
+        def nullify_owner_attributes(record)
+          Array(reflection.foreign_key).each do |foreign_key_column|
+            record[foreign_key_column] = nil unless foreign_key_column.in?(Array(record.class.primary_key))
+          end
+        end
+
+        def transaction_if(value, &block)
+          if value
+            reflection.klass.transaction(&block)
+          else
+            yield
+          end
+        end
+
+        def _create_record(attributes, raise_error = false, &block)
+          unless owner.persisted?
+            raise ActiveRecord::RecordNotSaved.new("You cannot call create unless the parent is saved", owner)
+          end
+
+          super
+        end
+    end
+  end
+end

data/lib/active_record/associations/has_one_through_association.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Associations
+    # = Active Record Has One Through Association
+    class HasOneThroughAssociation < HasOneAssociation # :nodoc:
+      include ThroughAssociation
+
+      private
+        def replace(record, save = true)
+          create_through_record(record, save)
+          self.target = record
+        end
+
+        def create_through_record(record, save)
+          ensure_not_nested
+
+          through_proxy  = through_association
+          through_record = through_proxy.load_target
+
+          if through_record && !record
+            through_record.destroy
+          elsif record
+            attributes = construct_join_attributes(record)
+
+            if through_record && through_record.destroyed?
+              through_record = through_proxy.tap(&:reload).target
+            end
+
+            if through_record
+              if through_record.new_record?
+                through_record.assign_attributes(attributes)
+              else
+                through_record.update(attributes)
+              end
+            elsif owner.new_record? || !save
+              through_proxy.build(attributes)
+            else
+              through_proxy.create(attributes)
+            end
+          end
+        end
+    end
+  end
+end

data/lib/active_record/associations/join_dependency/join_association.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "active_record/associations/join_dependency/join_part"
+require "active_support/core_ext/array/extract"
+
+module ActiveRecord
+  module Associations
+    class JoinDependency # :nodoc:
+      class JoinAssociation < JoinPart # :nodoc:
+        attr_reader :reflection, :tables
+        attr_accessor :table
+
+        def initialize(reflection, children)
+          super(reflection.klass, children)
+
+          @reflection = reflection
+        end
+
+        def match?(other)
+          return true if self == other
+          super && reflection == other.reflection
+        end
+
+        def join_constraints(foreign_table, foreign_klass, join_type, alias_tracker)
+          joins = []
+          chain = []
+
+          reflection_chain = reflection.chain
+          reflection_chain.each_with_index do |reflection, index|
+            table, terminated = yield reflection, reflection_chain[index..]
+            @table ||= table
+
+            if terminated
+              foreign_table, foreign_klass = table, reflection.klass
+              break
+            end
+
+            chain << [reflection, table]
+          end
+
+          base_klass.with_connection do |connection|
+            # The chain starts with the target table, but we want to end with it here (makes
+            # more sense in this context), so we reverse
+            chain.reverse_each do |reflection, table|
+              klass = reflection.klass
+
+              scope = reflection.join_scope(table, foreign_table, foreign_klass)
+
+              unless scope.references_values.empty?
+                associations = scope.eager_load_values | scope.includes_values
+
+                unless associations.empty?
+                  scope.joins! scope.construct_join_dependency(associations, Arel::Nodes::OuterJoin)
+                end
+              end
+
+              arel = scope.arel(alias_tracker.aliases)
+              nodes = arel.constraints.first
+
+              if nodes.is_a?(Arel::Nodes::And)
+                others = nodes.children.extract! do |node|
+                  !Arel.fetch_attribute(node) { |attr| attr.relation.name == table.name }
+                end
+              end
+
+              joins << join_type.new(table, Arel::Nodes::On.new(nodes))
+
+              if others && !others.empty?
+                joins.concat arel.join_sources
+                append_constraints(connection, joins.last, others)
+              end
+
+              # The current table in this iteration becomes the foreign table in the next
+              foreign_table, foreign_klass = table, klass
+            end
+          end
+
+          joins
+        end
+
+        def readonly?
+          return @readonly if defined?(@readonly)
+
+          @readonly = reflection.scope && reflection.scope_for(base_klass.unscoped).readonly_value
+        end
+
+        def strict_loading?
+          return @strict_loading if defined?(@strict_loading)
+
+          @strict_loading = reflection.scope && reflection.scope_for(base_klass.unscoped).strict_loading_value
+        end
+
+        private
+          def append_constraints(connection, join, constraints)
+            if join.is_a?(Arel::Nodes::StringJoin)
+              join_string = Arel::Nodes::And.new(constraints.unshift join.left)
+              join.left = Arel.sql(connection.visitor.compile(join_string))
+            else
+              right = join.right
+              right.expr = Arel::Nodes::And.new(constraints.unshift right.expr)
+            end
+          end
+      end
+    end
+  end
+end

data/lib/active_record/associations/join_dependency/join_base.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "active_record/associations/join_dependency/join_part"
+
+module ActiveRecord
+  module Associations
+    class JoinDependency # :nodoc:
+      class JoinBase < JoinPart # :nodoc:
+        attr_reader :table
+
+        def initialize(base_klass, table, children)
+          super(base_klass, children)
+          @table = table
+        end
+
+        def match?(other)
+          return true if self == other
+          super && base_klass == other.base_klass
+        end
+      end
+    end
+  end
+end

data/lib/active_record/associations/join_dependency/join_part.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Associations
+    class JoinDependency # :nodoc:
+      # A JoinPart represents a part of a JoinDependency. It is inherited
+      # by JoinBase and JoinAssociation. A JoinBase represents the Active Record which
+      # everything else is being joined onto. A JoinAssociation represents an association which
+      # is joining to the base. A JoinAssociation may result in more than one actual join
+      # operations (for example a has_and_belongs_to_many JoinAssociation would result in
+      # two; one for the join table and one for the target table).
+      class JoinPart # :nodoc:
+        include Enumerable
+
+        # The Active Record class which this join part is associated 'about'; for a JoinBase
+        # this is the actual base model, for a JoinAssociation this is the target model of the
+        # association.
+        attr_reader :base_klass, :children
+
+        delegate :table_name, :column_names, :primary_key, :attribute_types, to: :base_klass
+
+        def initialize(base_klass, children)
+          @base_klass = base_klass
+          @children = children
+        end
+
+        def match?(other)
+          self.class == other.class
+        end
+
+        def each(&block)
+          yield self
+          children.each { |child| child.each(&block) }
+        end
+
+        def each_children(&block)
+          children.each do |child|
+            yield self, child
+            child.each_children(&block)
+          end
+        end
+
+        # An Arel::Table for the active_record
+        def table
+          raise NotImplementedError
+        end
+
+        def extract_record(row, column_names_with_alias)
+          # This code is performance critical as it is called per row.
+          # see: https://github.com/rails/rails/pull/12185
+          hash = {}
+
+          index = 0
+          length = column_names_with_alias.length
+
+          while index < length
+            column = column_names_with_alias[index]
+            hash[column.name] = row[column.alias]
+            index += 1
+          end
+
+          hash
+        end
+
+        def instantiate(row, aliases, column_types = {}, &block)
+          base_klass.instantiate(extract_record(row, aliases), column_types, &block)
+        end
+      end
+    end
+  end
+end