Class: ActiveRecord::Reflection::AssociationReflection

# File 'activerecord/lib/active_record/reflection.rb', line 806

def collection?
  false
end

# File 'activerecord/lib/active_record/reflection.rb', line 851

def deprecated?
  @deprecated
end

# File 'activerecord/lib/active_record/reflection.rb', line 582

attr_reader :type, :foreign_type, :extensions

# File 'activerecord/lib/active_record/reflection.rb', line 582

attr_reader :type, :foreign_type, :extensions

# File 'activerecord/lib/active_record/reflection.rb', line 784

def has_inverse?
  inverse_name
end

# File 'activerecord/lib/active_record/reflection.rb', line 827

def has_one?; false; end

# File 'activerecord/lib/active_record/reflection.rb', line 780

def has_scope?
  scope
end

# File 'activerecord/lib/active_record/reflection.rb', line 776

def nested?
  false
end

# File 'activerecord/lib/active_record/reflection.rb', line 583

attr_accessor :parent_reflection # Reflection

# File 'activerecord/lib/active_record/reflection.rb', line 831

def polymorphic?
  options[:polymorphic]
end

# File 'activerecord/lib/active_record/reflection.rb', line 582

attr_reader :type, :foreign_type, :extensions

# File 'activerecord/lib/active_record/reflection.rb', line 819

def validate?
  !options[:validate].nil? ? options[:validate] : (options[:autosave] == true || collection?)
end

# File 'activerecord/lib/active_record/reflection.rb', line 716

def active_record_primary_key_definition # :nodoc:
  if options[:primary_key]
    @active_record_primary_key_definition ||= ActiveRecord::Key.for(options[:primary_key])
  elsif active_record.has_query_constraints? || options[:query_constraints]
    ActiveRecord::Key.for(active_record.query_constraints_list)
  else
    inferred_primary_key_definition(active_record)
  end
end

# File 'activerecord/lib/active_record/reflection.rb', line 843

def add_as_polymorphic_through(reflection, seed)
  seed + [PolymorphicReflection.new(self, reflection)]
end

# File 'activerecord/lib/active_record/reflection.rb', line 839

def add_as_source(seed)
  seed
end

# File 'activerecord/lib/active_record/reflection.rb', line 847

def add_as_through(seed)
  seed + [self]
end

# File 'activerecord/lib/active_record/reflection.rb', line 829

def association_class; raise NotImplementedError; end

# File 'activerecord/lib/active_record/reflection.rb', line 691

def association_foreign_key
  association_foreign_key_definition.name
end

# File 'activerecord/lib/active_record/reflection.rb', line 696

def association_foreign_key_definition # :nodoc:
  @association_foreign_key_definition ||= ActiveRecord::Key.for(options[:association_foreign_key] || class_name.foreign_key)
end

# File 'activerecord/lib/active_record/reflection.rb', line 700

def association_primary_key(klass = nil)
  association_primary_key_definition(klass).name
end

# File 'activerecord/lib/active_record/reflection.rb', line 705

def association_primary_key_definition(klass = nil) # :nodoc:
  primary_key_definition(klass || self.klass)
end

# File 'activerecord/lib/active_record/reflection.rb', line 650

def association_route(origin_class: active_record, destination_class: nil)
  if origin_class.equal?(active_record) && (slot = @default_association_route) &&
      (destination_class.nil? || destination_class.equal?(slot[1])) && current_default_association_route?(slot)
    return slot[3]
  end

  destination_class ||= klass unless polymorphic?

  if origin_class.equal?(active_record) && destination_class.equal?(default_destination_class)
    return default_association_route
  end

  # Schema contexts are replaced on reload, so key by both endpoints to
  # avoid reusing routes with outdated keys.
  by_destination = association_route_cache.fetch_or_store(origin_class.schema_context) { AssociationRoute::Cache.new }
  by_destination.fetch_or_store(destination_class&.schema_context) do
    resolve_association_route(origin_class, destination_class)
  end
end

# File 'activerecord/lib/active_record/reflection.rb', line 865

def association_route_cache
  AssociationRoute::Cache.for(self)
end

# File 'activerecord/lib/active_record/reflection.rb', line 642

def association_route_chain(origin_class: active_record, destination_class: nil)
  [association_route(origin_class: origin_class, destination_class: destination_class)]
end

# File 'activerecord/lib/active_record/reflection.rb', line 922

def association_route_class
  AssociationRoute::Reverse
end

# File 'activerecord/lib/active_record/reflection.rb', line 941

def association_route_constraints(_reference_class, _target_class)
  Key::Mapping.empty
end

# File 'activerecord/lib/active_record/reflection.rb', line 918

def association_route_target_key(_target_class)
  active_record_primary_key_definition
end

# File 'activerecord/lib/active_record/reflection.rb', line 957

def automatic_inverse_of
  if can_find_inverse_of_automatically?(self)
    inverse_name = ActiveSupport::Inflector.underscore(options[:as] || active_record.name.demodulize).to_sym

    begin
      reflection = klass._reflect_on_association(inverse_name)
      if !reflection && active_record.automatically_invert_plural_associations
        plural_inverse_name = ActiveSupport::Inflector.pluralize(inverse_name)
        reflection = klass._reflect_on_association(plural_inverse_name)
      end
    rescue NameError => error
      raise unless error.name.to_s == class_name

      # Give up: we couldn't compute the klass type so we won't be able
      # to find any associations either.
      reflection = false
    end

    if valid_inverse_reflection?(reflection)
      reflection.name
    end
  end
end

# File 'activerecord/lib/active_record/reflection.rb', line 926

def build_association_route(reference_class:, target_class:, fixed_values: {})
  reference = Key::Mapping.new(
    reference_key: foreign_key_definition,
    target_key: association_route_target_key(target_class)
  )
  constraints = association_route_constraints(reference_class, target_class)

  association_route_class.new(
    link: AssociationLink.for(
      reference: reference, constraints: constraints, fixed_values: fixed_values,
      reference_class: reference_class, target_class: target_class
    )
  )
end

# File 'activerecord/lib/active_record/reflection.rb', line 999

def can_find_inverse_of_automatically?(reflection, inverse_reflection = false)
  reflection.options[:inverse_of] != false &&
    !reflection.options[:through] &&
    !reflection.options[:foreign_key] &&
    scope_allows_automatic_inverse_of?(reflection, inverse_reflection)
end

# File 'activerecord/lib/active_record/reflection.rb', line 742

def check_eager_loadable!
  return unless scope

  unless scope.arity == 0
    raise ArgumentError, <<-MSG.squish
      The association scope '#{name}' is instance dependent (the scope
      block takes an argument). Eager loading instance dependent scopes
      is not supported.
    MSG
  end
end

# File 'activerecord/lib/active_record/reflection.rb', line 726

def check_validity!
  return if @validated

  check_validity_of_inverse!

  if !polymorphic? && (klass.composite_primary_key? || active_record.composite_primary_key?)
    if (has_one? || collection?) && active_record_primary_key_definition.length != foreign_key_definition.length
      raise CompositePrimaryKeyMismatchError.new(self)
    elsif belongs_to? && association_primary_key_definition.length != foreign_key_definition.length
      raise CompositePrimaryKeyMismatchError.new(self)
    end
  end

  @validated = true
end

# File 'activerecord/lib/active_record/reflection.rb', line 769

def clear_association_scope_cache(klass = self.klass) # :nodoc:
  AssociationRoute::Cache.clear(self)
  @default_association_route = nil unless frozen?
  ActiveSupport::Ractors[@default_association_route_key] = nil
  klass.initialize_find_by_cache
end

# File 'activerecord/lib/active_record/reflection.rb', line 764

def collect_join_chain
  [self]
end

# File 'activerecord/lib/active_record/reflection.rb', line 558

def compute_class(name)
  if polymorphic?
    raise ArgumentError, "Polymorphic associations do not support computing the class."
  end

  begin
    klass = active_record.send(:compute_type, name)
  rescue NameError => error
    if error.name.match?(/(?:\A|::)#{name}\z/)
      message = "Missing model class #{name} for the #{active_record}##{self.name} association."
      message += " You can specify a different model class with the :class_name option." unless options[:class_name]
      raise NameError.new(message, name)
    else
      raise
    end
  end

  unless klass < ActiveRecord::Base
    raise ArgumentError, "The #{name} model class for the #{active_record}##{self.name} association is not an ActiveRecord::Base subclass."
  end

  klass
end

# File 'activerecord/lib/active_record/reflection.rb', line 901

def current_default_association_route?(slot)
  slot &&
    slot[0].equal?(active_record.current_schema_context) &&
    slot[2].equal?(slot[1]&.current_schema_context)
end

# File 'activerecord/lib/active_record/reflection.rb', line 876

def default_association_route
  slot = @default_association_route
  return slot[3] if current_default_association_route?(slot)

  if frozen?
    slot = ActiveSupport::Ractors[@default_association_route_key]
    return slot[3] if current_default_association_route?(slot)
  end

  destination_class = default_destination_class
  origin_context = active_record.schema_context
  destination_context = destination_class&.schema_context
  route = resolve_association_route(active_record, destination_class)
  slot = [origin_context, destination_class, destination_context, route].freeze

  if frozen?
    ActiveSupport::Ractors[@default_association_route_key] = slot
  else
    @default_association_route = slot
  end
  route
end

# File 'activerecord/lib/active_record/reflection.rb', line 869

def default_destination_class
  polymorphic? ? nil : klass
end

# File 'activerecord/lib/active_record/reflection.rb', line 1020

def derive_class_name
  class_name = name.to_s
  class_name = class_name.singularize if collection?
  class_name.camelize
end

# File 'activerecord/lib/active_record/reflection.rb', line 1038

def derive_fk_query_constraints(foreign_key)
  primary_query_constraints = active_record.query_constraints_list
  owner_pk = active_record.primary_key

  if primary_query_constraints.size > 2
    raise ArgumentError, <<~MSG.squish
      The query constraints list on the `#{active_record}` model has more than 2
      attributes. Active Record is unable to derive the query constraints
      for the association. You need to explicitly define the query constraints
      for this association.
    MSG
  end

  if !primary_query_constraints.include?(owner_pk)
    raise ArgumentError, <<~MSG.squish
      The query constraints on the `#{active_record}` model does not include the primary
      key so Active Record is unable to derive the foreign key constraints for
      the association. You need to explicitly define the query constraints for this
      association.
    MSG
  end

  return foreign_key if primary_query_constraints.include?(foreign_key)

  first_key, last_key = primary_query_constraints

  if first_key == owner_pk
    [foreign_key, last_key.to_s]
  elsif last_key == owner_pk
    [first_key.to_s, foreign_key]
  else
    raise ArgumentError, <<~MSG.squish
      Active Record couldn't correctly interpret the query constraints
      for the `#{active_record}` model. The query constraints on `#{active_record}` are
      `#{primary_query_constraints}` and the foreign key is `#{foreign_key}`.
      You need to explicitly set the query constraints for this association.
    MSG
  end
end

# File 'activerecord/lib/active_record/reflection.rb', line 1026

def derive_foreign_key(infer_from_inverse_of: true)
  if belongs_to?
    "#{name}_id"
  elsif options[:as]
    "#{options[:as]}_id"
  elsif options[:inverse_of] && infer_from_inverse_of
    inverse_of.foreign_key(infer_from_inverse_of: false)
  else
    active_record.model_name.to_s.foreign_key
  end
end

# File 'activerecord/lib/active_record/reflection.rb', line 1078

def derive_join_table
  ModelSchema.derive_join_table_name active_record.table_name, klass.table_name
end

# File 'activerecord/lib/active_record/reflection.rb', line 670

def foreign_key(infer_from_inverse_of: true)
  foreign_key_definition(infer_from_inverse_of: infer_from_inverse_of).name
end

# File 'activerecord/lib/active_record/reflection.rb', line 675

def foreign_key_definition(infer_from_inverse_of: true) # :nodoc:
  @foreign_key_definition ||= if options[:foreign_key]
    ActiveRecord::Key.for(options[:foreign_key])
  elsif options[:query_constraints]
    ActiveRecord::Key.for(options[:query_constraints])
  else
    derived_fk = derive_foreign_key(infer_from_inverse_of: infer_from_inverse_of)

    if !derived_fk.is_a?(Array) && active_record.has_query_constraints?
      derived_fk = derive_fk_query_constraints(derived_fk)
    end

    ActiveRecord::Key.for(derived_fk)
  end
end

# File 'activerecord/lib/active_record/reflection.rb', line 621

def freeze
  return self if frozen?

  check_validity!

  unless polymorphic?
    klass
    association_primary_key_definition if belongs_to?
    inverse_of
    inverse_which_updates_counter_cache
  end

  active_record_primary_key_definition
  association_foreign_key_definition
  counter_cache_column
  foreign_key_definition
  @scope = ActiveSupport::Ractors.try_shareable_proc(@scope) if @scope

  super
end

# File 'activerecord/lib/active_record/reflection.rb', line 907

def initialize_copy(other)
  super
  @default_association_route = nil
  @default_association_route_key = :"active_record_default_association_route_#{object_id}"
end

# File 'activerecord/lib/active_record/reflection.rb', line 948

def inverse_name
  unless defined?(@inverse_name)
    @inverse_name = options.fetch(:inverse_of) { automatic_inverse_of }
  end

  @inverse_name
end

# File 'activerecord/lib/active_record/reflection.rb', line 646

def join_table
  @join_table ||= -(options[:join_table]&.to_s || derive_join_table)
end

# File 'activerecord/lib/active_record/reflection.rb', line 801

def macro; raise NotImplementedError; end

# File 'activerecord/lib/active_record/reflection.rb', line 788

def polymorphic_inverse_of(associated_class)
  if has_inverse?
    if inverse_relationship = associated_class._reflect_on_association(options[:inverse_of])
      inverse_relationship
    else
      raise InverseOfAssociationNotFoundError.new(self, associated_class)
    end
  end
end

# File 'activerecord/lib/active_record/reflection.rb', line 835

def polymorphic_name
  active_record.polymorphic_name
end

# File 'activerecord/lib/active_record/reflection.rb', line 857

def prepare_default_association_route # :nodoc:
  return unless @klass || polymorphic?
  return unless active_record.send(:schema_loaded?) && (polymorphic? || klass.send(:schema_loaded?))

  default_association_route
end

# File 'activerecord/lib/active_record/reflection.rb', line 913

def resolve_association_route(origin_class, destination_class)
  fixed_values = type ? { type => -origin_class.polymorphic_name } : {}
  build_association_route(reference_class: destination_class, target_class: origin_class, fixed_values: fixed_values)
end