Class: ActiveRecord::Reflection::AssociationReflection

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

def collection?
  false
end

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

attr_reader :type, :foreign_type

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

def has_inverse?
  inverse_name
end

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

def has_one?; false; end

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

def has_scope?
  scope
end

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

def nested?
  false
end

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

attr_accessor :parent_reflection # Reflection

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

def polymorphic?
  options[:polymorphic]
end

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

attr_reader :type, :foreign_type

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

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

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

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

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

def add_as_source(seed)
  seed
end

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

def add_as_through(seed)
  seed + [self]
end

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

def association_class; raise NotImplementedError; end

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

def association_foreign_key
  @association_foreign_key ||= -(options[:association_foreign_key]&.to_s || class_name.foreign_key)
end

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

def association_primary_key(klass = nil)
  primary_key(klass || self.klass)
end

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

def association_scope_cache(klass, owner, &block)
  key = self
  if polymorphic?
    key = [key, owner._read_attribute(@foreign_type)]
  end
  klass.cached_find_by_statement(key, &block)
end

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

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
        plural_inverse_name = ActiveSupport::Inflector.pluralize(inverse_name)
        reflection = klass._reflect_on_association(plural_inverse_name)

        if reflection && !active_record.automatically_invert_plural_associations
          ActiveRecord.deprecator.warn(
            "The `#{active_record.name}##{name}` inverse association could have been automatically" \
            " inferred as `#{klass.name}##{plural_inverse_name}` but wasn't because `automatically_invert_plural_associations`" \
            " is disabled.\n\n" \
            "If automatic inference is intended, you can consider enabling" \
            " `config.active_record.automatically_invert_plural_associations`.\n\n" \
            "If automatic inference is not intended, you can silence this warning by defining the association with `inverse_of: nil`."
          )
          reflection = nil
        end
      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 792

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 610

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 598

def check_validity!
  check_validity_of_inverse!

  if !polymorphic? && (klass.composite_primary_key? || active_record.composite_primary_key?)
    if (has_one? || collection?) && Array(active_record_primary_key).length != Array(foreign_key).length
      raise CompositePrimaryKeyMismatchError.new(self)
    elsif belongs_to? && Array(association_primary_key).length != Array(foreign_key).length
      raise CompositePrimaryKeyMismatchError.new(self)
    end
  end
end

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

def clear_association_scope_cache # :nodoc:
  klass.initialize_find_by_cache
end

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

def collect_join_chain
  [self]
end

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

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 813

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 831

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 819

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 871

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 721

def extensions
  Array(options[:extend])
end

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

def foreign_key(infer_from_inverse_of: true)
  @foreign_key ||= if options[:foreign_key]
    if options[:foreign_key].is_a?(Array)
      options[:foreign_key].map { |fk| fk.to_s.freeze }.freeze
    else
      options[:foreign_key].to_s.freeze
    end
  elsif options[:query_constraints]
    options[:query_constraints].map { |fk| fk.to_s.freeze }.freeze
  else
    derived_fk = derive_foreign_key(infer_from_inverse_of: infer_from_inverse_of)

    if active_record.has_query_constraints?
      derived_fk = derive_fk_query_constraints(derived_fk)
    end

    derived_fk
  end
end

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

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 594

def join_foreign_key
  active_record_primary_key
end

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

def join_id_for(owner) # :nodoc:
  Array(join_foreign_key).map { |key| owner._read_attribute(key) }
end

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

def join_primary_key(klass = nil)
  foreign_key
end

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

def join_primary_type
  type
end

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

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

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

def macro; raise NotImplementedError; end

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

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 705

def polymorphic_name
  active_record.polymorphic_name
end

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

def scope_allows_automatic_inverse_of?(reflection, inverse_reflection)
  if inverse_reflection
    !reflection.scope
  else
    !reflection.scope || reflection.klass.automatic_scope_inversing
  end
end

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

def source_reflection
  self
end

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

def through_reflection
  nil
end

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

def valid_inverse_reflection?(reflection)
  reflection &&
    reflection != self &&
    foreign_key == reflection.foreign_key &&
    klass <= reflection.active_record &&
    can_find_inverse_of_automatically?(reflection, true)
end