omg-activerecord 8.0.0.alpha1

data/lib/active_record/associations/belongs_to_association.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Associations
+    # = Active Record Belongs To Association
+    class BelongsToAssociation < SingularAssociation # :nodoc:
+      def handle_dependency
+        return unless load_target
+
+        case options[:dependent]
+        when :destroy
+          raise ActiveRecord::Rollback unless target.destroy
+        when :destroy_async
+          if reflection.foreign_key.is_a?(Array)
+            primary_key_column = reflection.active_record_primary_key
+            id = reflection.foreign_key.map { |col| owner.public_send(col) }
+          else
+            primary_key_column = reflection.active_record_primary_key
+            id = owner.public_send(reflection.foreign_key)
+          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)
+          )
+        else
+          target.public_send(options[:dependent])
+        end
+      end
+
+      def inversed_from(record)
+        replace_keys(record)
+        super
+      end
+
+      def default(&block)
+        writer(owner.instance_exec(&block)) if reader.nil?
+      end
+
+      def reset
+        super
+        @updated = false
+      end
+
+      def updated?
+        @updated
+      end
+
+      def decrement_counters
+        update_counters(-1)
+      end
+
+      def increment_counters
+        update_counters(1)
+      end
+
+      def decrement_counters_before_last_save
+        if reflection.polymorphic?
+          model_type_was = owner.attribute_before_last_save(reflection.foreign_type)
+          model_was = owner.class.polymorphic_class_for(model_type_was) if model_type_was
+        else
+          model_was = klass
+        end
+
+        foreign_key_was = owner.attribute_before_last_save(reflection.foreign_key)
+
+        if foreign_key_was && model_was < ActiveRecord::Base
+          update_counters_via_scope(model_was, foreign_key_was, -1)
+        end
+      end
+
+      def target_changed?
+        owner.attribute_changed?(reflection.foreign_key) || (!foreign_key_present? && target&.new_record?)
+      end
+
+      def target_previously_changed?
+        owner.attribute_previously_changed?(reflection.foreign_key)
+      end
+
+      def saved_change_to_target?
+        owner.saved_change_to_attribute?(reflection.foreign_key)
+      end
+
+      private
+        def replace(record)
+          if record
+            raise_on_type_mismatch!(record)
+            set_inverse_instance(record)
+            @updated = true
+          elsif target
+            remove_inverse_instance(target)
+          end
+
+          replace_keys(record, force: true)
+
+          self.target = record
+        end
+
+        def update_counters(by)
+          if require_counter_update? && foreign_key_present?
+            if target && !stale_target?
+              target.increment!(reflection.counter_cache_column, by, touch: reflection.options[:touch])
+            else
+              update_counters_via_scope(klass, owner._read_attribute(reflection.foreign_key), by)
+            end
+          end
+        end
+
+        def update_counters_via_scope(klass, foreign_key, by)
+          scope = klass.unscoped.where!(primary_key(klass) => foreign_key)
+          scope.update_counters(reflection.counter_cache_column => by, touch: reflection.options[:touch])
+        end
+
+        def find_target?
+          !loaded? && foreign_key_present? && klass
+        end
+
+        def require_counter_update?
+          reflection.counter_cache_column && owner.persisted?
+        end
+
+        def replace_keys(record, force: false)
+          reflection_fk = reflection.foreign_key
+          if reflection_fk.is_a?(Array)
+            target_key_values = record ? Array(primary_key(record.class)).map { |key| record._read_attribute(key) } : []
+
+            if force || reflection_fk.map { |fk| owner._read_attribute(fk) } != target_key_values
+              reflection_fk.each_with_index do |key, index|
+                owner[key] = target_key_values[index]
+              end
+            end
+          else
+            target_key_value = record ? record._read_attribute(primary_key(record.class)) : nil
+
+            if force || owner._read_attribute(reflection_fk) != target_key_value
+              owner[reflection_fk] = target_key_value
+            end
+          end
+        end
+
+        def primary_key(klass)
+          reflection.association_primary_key(klass)
+        end
+
+        def foreign_key_present?
+          Array(reflection.foreign_key).all? { |fk| owner._read_attribute(fk) }
+        end
+
+        def invertible_for?(record)
+          inverse = inverse_reflection_for(record)
+          inverse && (inverse.has_one? || inverse.klass.has_many_inversing)
+        end
+
+        def stale_state
+          owner._read_attribute(reflection.foreign_key) { |n| owner.send(:missing_attribute, n, caller) }
+        end
+    end
+  end
+end

data/lib/active_record/associations/belongs_to_polymorphic_association.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Associations
+    # = Active Record Belongs To Polymorphic Association
+    class BelongsToPolymorphicAssociation < BelongsToAssociation # :nodoc:
+      def klass
+        type = owner[reflection.foreign_type]
+        type.presence && owner.class.polymorphic_class_for(type)
+      end
+
+      def target_changed?
+        super || owner.attribute_changed?(reflection.foreign_type)
+      end
+
+      def target_previously_changed?
+        super || owner.attribute_previously_changed?(reflection.foreign_type)
+      end
+
+      def saved_change_to_target?
+        super || owner.saved_change_to_attribute?(reflection.foreign_type)
+      end
+
+      private
+        def replace_keys(record, force: false)
+          super
+
+          target_type = record ? record.class.polymorphic_name : nil
+
+          if force || owner._read_attribute(reflection.foreign_type) != target_type
+            owner[reflection.foreign_type] = target_type
+          end
+        end
+
+        def inverse_reflection_for(record)
+          reflection.polymorphic_inverse_of(record.class)
+        end
+
+        def raise_on_type_mismatch!(record)
+          # A polymorphic association cannot have a type mismatch, by definition
+        end
+
+        def stale_state
+          if foreign_key = super
+            [foreign_key, owner[reflection.foreign_type]]
+          end
+        end
+    end
+  end
+end

data/lib/active_record/associations/builder/association.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+# This is the parent Association class which defines the variables
+# used by all associations.
+#
+# The hierarchy is defined as follows:
+#  Association
+#    - SingularAssociation
+#      - BelongsToAssociation
+#      - HasOneAssociation
+#    - CollectionAssociation
+#      - HasManyAssociation
+
+module ActiveRecord::Associations::Builder # :nodoc:
+  class Association # :nodoc:
+    class << self
+      attr_accessor :extensions
+    end
+    self.extensions = []
+
+    VALID_OPTIONS = [
+      :class_name, :anonymous_class, :primary_key, :foreign_key, :dependent, :validate, :inverse_of, :strict_loading, :query_constraints
+    ].freeze # :nodoc:
+
+    def self.build(model, name, scope, options, &block)
+      if model.dangerous_attribute_method?(name)
+        raise ArgumentError, "You tried to define an association named #{name} on the model #{model.name}, but " \
+                             "this will conflict with a method #{name} already defined by Active Record. " \
+                             "Please choose a different association name."
+      end
+
+      reflection = create_reflection(model, name, scope, options, &block)
+      define_accessors(model, reflection)
+      define_callbacks(model, reflection)
+      define_validations(model, reflection)
+      define_change_tracking_methods(model, reflection)
+      reflection
+    end
+
+    def self.create_reflection(model, name, scope, options, &block)
+      raise ArgumentError, "association names must be a Symbol" unless name.kind_of?(Symbol)
+
+      validate_options(options)
+
+      extension = define_extensions(model, name, &block)
+      options[:extend] = [*options[:extend], extension] if extension
+
+      scope = build_scope(scope)
+
+      ActiveRecord::Reflection.create(macro, name, scope, options, model)
+    end
+
+    def self.build_scope(scope)
+      if scope && scope.arity == 0
+        proc { instance_exec(&scope) }
+      else
+        scope
+      end
+    end
+
+    def self.macro
+      raise NotImplementedError
+    end
+
+    def self.valid_options(options)
+      VALID_OPTIONS + Association.extensions.flat_map(&:valid_options)
+    end
+
+    def self.validate_options(options)
+      options.assert_valid_keys(valid_options(options))
+    end
+
+    def self.define_extensions(model, name)
+      # noop
+    end
+
+    def self.define_callbacks(model, reflection)
+      if dependent = reflection.options[:dependent]
+        check_dependent_options(dependent, model)
+        add_destroy_callbacks(model, reflection)
+        add_after_commit_jobs_callback(model, dependent)
+      end
+
+      Association.extensions.each do |extension|
+        extension.build(model, reflection)
+      end
+    end
+
+    # Defines the setter and getter methods for the association
+    # class Post < ActiveRecord::Base
+    #   has_many :comments
+    # end
+    #
+    # Post.first.comments and Post.first.comments= methods are defined by this method...
+    def self.define_accessors(model, reflection)
+      mixin = model.generated_association_methods
+      name = reflection.name
+      define_readers(mixin, name)
+      define_writers(mixin, name)
+    end
+
+    def self.define_readers(mixin, name)
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}
+          association(:#{name}).reader
+        end
+      CODE
+    end
+
+    def self.define_writers(mixin, name)
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}=(value)
+          association(:#{name}).writer(value)
+        end
+      CODE
+    end
+
+    def self.define_validations(model, reflection)
+      # noop
+    end
+
+    def self.define_change_tracking_methods(model, reflection)
+      # noop
+    end
+
+    def self.valid_dependent_options
+      raise NotImplementedError
+    end
+
+    def self.check_dependent_options(dependent, model)
+      if dependent == :destroy_async && !model.destroy_association_async_job
+        err_message = "A valid destroy_association_async_job is required to use `dependent: :destroy_async` on associations"
+        raise ActiveRecord::ConfigurationError, err_message
+      end
+      unless valid_dependent_options.include?(dependent)
+        raise ArgumentError, "The :dependent option must be one of #{valid_dependent_options}, but is :#{dependent}"
+      end
+    end
+
+    def self.add_destroy_callbacks(model, reflection)
+      name = reflection.name
+      model.before_destroy(->(o) { o.association(name).handle_dependency })
+    end
+
+    def self.add_after_commit_jobs_callback(model, dependent)
+      if dependent == :destroy_async
+        mixin = model.generated_association_methods
+
+        unless mixin.method_defined?(:_after_commit_jobs)
+          model.after_commit(-> do
+            _after_commit_jobs.each do |job_class, job_arguments|
+              job_class.perform_later(**job_arguments)
+            end
+          end)
+
+          mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+            def _after_commit_jobs
+              @_after_commit_jobs ||= []
+            end
+          CODE
+        end
+      end
+    end
+
+    private_class_method :build_scope, :macro, :valid_options, :validate_options, :define_extensions,
+      :define_callbacks, :define_accessors, :define_readers, :define_writers, :define_validations,
+      :define_change_tracking_methods, :valid_dependent_options, :check_dependent_options,
+      :add_destroy_callbacks, :add_after_commit_jobs_callback
+  end
+end

data/lib/active_record/associations/builder/belongs_to.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module ActiveRecord::Associations::Builder # :nodoc:
+  class BelongsTo < SingularAssociation # :nodoc:
+    def self.macro
+      :belongs_to
+    end
+
+    def self.valid_options(options)
+      valid = super + [:polymorphic, :counter_cache, :optional, :default]
+      valid += [:foreign_type] if options[:polymorphic]
+      valid += [:ensuring_owner_was] if options[:dependent] == :destroy_async
+      valid
+    end
+
+    def self.valid_dependent_options
+      [:destroy, :delete, :destroy_async]
+    end
+
+    def self.define_callbacks(model, reflection)
+      super
+      add_counter_cache_callbacks(model, reflection) if reflection.options[:counter_cache]
+      add_touch_callbacks(model, reflection)         if reflection.options[:touch]
+      add_default_callbacks(model, reflection)       if reflection.options[:default]
+    end
+
+    def self.add_counter_cache_callbacks(model, reflection)
+      cache_column = reflection.counter_cache_column
+
+      model.after_update lambda { |record|
+        association = association(reflection.name)
+
+        if association.saved_change_to_target?
+          association.increment_counters
+          association.decrement_counters_before_last_save
+        end
+      }
+
+      klass = reflection.class_name.safe_constantize
+      klass._counter_cache_columns |= [cache_column] if klass && klass.respond_to?(:_counter_cache_columns)
+      model.counter_cached_association_names |= [reflection.name]
+    end
+
+    def self.touch_record(o, changes, foreign_key, name, touch) # :nodoc:
+      old_foreign_id = changes[foreign_key] && changes[foreign_key].first
+
+      if old_foreign_id
+        association = o.association(name)
+        reflection = association.reflection
+        if reflection.polymorphic?
+          foreign_type = reflection.foreign_type
+          klass = changes[foreign_type] && changes[foreign_type].first || o.public_send(foreign_type)
+          klass = o.class.polymorphic_class_for(klass)
+        else
+          klass = association.klass
+        end
+        primary_key = reflection.association_primary_key(klass)
+        old_record = klass.find_by(primary_key => old_foreign_id)
+
+        if old_record
+          if touch != true
+            old_record.touch_later(touch)
+          else
+            old_record.touch_later
+          end
+        end
+      end
+
+      record = o.public_send name
+      if record && record.persisted?
+        if touch != true
+          record.touch_later(touch)
+        else
+          record.touch_later
+        end
+      end
+    end
+
+    def self.add_touch_callbacks(model, reflection)
+      foreign_key = reflection.foreign_key
+      name        = reflection.name
+      touch       = reflection.options[:touch]
+
+      callback = lambda { |changes_method| lambda { |record|
+        BelongsTo.touch_record(record, record.send(changes_method), foreign_key, name, touch)
+      }}
+
+      if reflection.counter_cache_column
+        touch_callback = callback.(:saved_changes)
+        update_callback = lambda { |record|
+          instance_exec(record, &touch_callback) unless association(reflection.name).saved_change_to_target?
+        }
+        model.after_update update_callback, if: :saved_changes?
+      else
+        model.after_create callback.(:saved_changes), if: :saved_changes?
+        model.after_update callback.(:saved_changes), if: :saved_changes?
+        model.after_destroy callback.(:changes_to_save)
+      end
+
+      model.after_touch callback.(:changes_to_save)
+    end
+
+    def self.add_default_callbacks(model, reflection)
+      model.before_validation lambda { |o|
+        o.association(reflection.name).default(&reflection.options[:default])
+      }
+    end
+
+    def self.add_destroy_callbacks(model, reflection)
+      model.after_destroy lambda { |o| o.association(reflection.name).handle_dependency }
+    end
+
+    def self.define_validations(model, reflection)
+      if reflection.options.key?(:required)
+        reflection.options[:optional] = !reflection.options.delete(:required)
+      end
+
+      if reflection.options[:optional].nil?
+        required = model.belongs_to_required_by_default
+      else
+        required = !reflection.options[:optional]
+      end
+
+      super
+
+      if required
+        if ActiveRecord.belongs_to_required_validates_foreign_key
+          model.validates_presence_of reflection.name, message: :required
+        else
+          condition = lambda { |record|
+            foreign_key = reflection.foreign_key
+            foreign_type = reflection.foreign_type
+
+            record.read_attribute(foreign_key).nil? ||
+              record.attribute_changed?(foreign_key) ||
+              (reflection.polymorphic? && (record.read_attribute(foreign_type).nil? || record.attribute_changed?(foreign_type)))
+          }
+
+          model.validates_presence_of reflection.name, message: :required, if: condition
+        end
+      end
+    end
+
+    def self.define_change_tracking_methods(model, reflection)
+      model.generated_association_methods.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{reflection.name}_changed?
+          association(:#{reflection.name}).target_changed?
+        end
+
+        def #{reflection.name}_previously_changed?
+          association(:#{reflection.name}).target_previously_changed?
+        end
+      CODE
+    end
+
+    private_class_method :macro, :valid_options, :valid_dependent_options, :define_callbacks,
+      :define_validations, :define_change_tracking_methods, :add_counter_cache_callbacks,
+      :add_touch_callbacks, :add_default_callbacks, :add_destroy_callbacks
+  end
+end

data/lib/active_record/associations/builder/collection_association.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "active_record/associations"
+
+module ActiveRecord::Associations::Builder # :nodoc:
+  class CollectionAssociation < Association # :nodoc:
+    CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]
+
+    def self.valid_options(options)
+      super + [:before_add, :after_add, :before_remove, :after_remove, :extend]
+    end
+
+    def self.define_callbacks(model, reflection)
+      super
+      name    = reflection.name
+      options = reflection.options
+      CALLBACKS.each { |callback_name|
+        define_callback(model, callback_name, name, options)
+      }
+    end
+
+    def self.define_extensions(model, name, &block)
+      if block_given?
+        extension_module_name = "#{name.to_s.camelize}AssociationExtension"
+        extension = Module.new(&block)
+        model.const_set(extension_module_name, extension)
+      end
+    end
+
+    def self.define_callback(model, callback_name, name, options)
+      full_callback_name = "#{callback_name}_for_#{name}"
+
+      callback_values = Array(options[callback_name.to_sym])
+      method_defined = model.respond_to?(full_callback_name)
+
+      # If there are no callbacks, we must also check if a superclass had
+      # previously defined this association
+      return if callback_values.empty? && !method_defined
+
+      unless method_defined
+        model.class_attribute(full_callback_name, instance_accessor: false, instance_predicate: false)
+      end
+
+      callbacks = callback_values.map do |callback|
+        case callback
+        when Symbol
+          ->(method, owner, record) { owner.send(callback, record) }
+        when Proc
+          ->(method, owner, record) { callback.call(owner, record) }
+        else
+          ->(method, owner, record) { callback.send(method, owner, record) }
+        end
+      end
+      model.send "#{full_callback_name}=", callbacks
+    end
+
+    # Defines the setter and getter methods for the collection_singular_ids.
+    def self.define_readers(mixin, name)
+      super
+
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name.to_s.singularize}_ids
+          association(:#{name}).ids_reader
+        end
+      CODE
+    end
+
+    def self.define_writers(mixin, name)
+      super
+
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name.to_s.singularize}_ids=(ids)
+          association(:#{name}).ids_writer(ids)
+        end
+      CODE
+    end
+
+    private_class_method :valid_options, :define_callback, :define_extensions, :define_readers, :define_writers
+  end
+end