Class: ActiveRecord::Reflection::AssociationReflection

Inherits:
MacroReflection show all
Defined in:
lib/active_record/reflection.rb

Overview

Holds all the metadata about an association as it was specified in the Active Record class.

Instance Attribute Summary collapse

Attributes inherited from MacroReflection

#active_record, #name, #options, #plural_name, #scope

Instance Method Summary collapse

Methods inherited from MacroReflection

#==, #autosave=, #klass, #scope_for

Methods inherited from AbstractReflection

#alias_candidate, #build_association, #build_scope, #chain, #check_validity_of_inverse!, #class_name, #constraints, #counter_cache_column, #counter_must_be_updated_by_has_many?, #has_cached_counter?, #inverse_of, #inverse_updates_counter_in_memory?, #inverse_which_updates_counter_cache, #join_scope, #join_scopes, #klass_join_scope, #scopes, #strict_loading?, #strict_loading_violation_message, #table_name, #through_reflection?

Constructor Details

#initialize(name, scope, options, active_record) ⇒ AssociationReflection

Returns a new instance of AssociationReflection.



477
478
479
480
481
482
483
484
485
486
487
# File 'lib/active_record/reflection.rb', line 477

def initialize(name, scope, options, active_record)
  super
  @type = -(options[:foreign_type]&.to_s || "#{options[:as]}_type") if options[:as]
  @foreign_type = -(options[:foreign_type]&.to_s || "#{name}_type") if options[:polymorphic]
  @join_table = nil
  @foreign_key = nil
  @association_foreign_key = nil
  @association_primary_key = nil

  ensure_option_not_given_as_class!(:class_name)
end

Instance Attribute Details

#foreign_typeObject (readonly)

Returns the value of attribute foreign_type.



474
475
476
# File 'lib/active_record/reflection.rb', line 474

def foreign_type
  @foreign_type
end

#parent_reflectionObject

Reflection



475
476
477
# File 'lib/active_record/reflection.rb', line 475

def parent_reflection
  @parent_reflection
end

#typeObject (readonly)

Returns the value of attribute type.



474
475
476
# File 'lib/active_record/reflection.rb', line 474

def type
  @type
end

Instance Method Details

#active_record_primary_keyObject



525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
# File 'lib/active_record/reflection.rb', line 525

def active_record_primary_key
  custom_primary_key = options[:primary_key]
  @active_record_primary_key ||= if custom_primary_key
    if custom_primary_key.is_a?(Array)
      custom_primary_key.map { |pk| pk.to_s.freeze }.freeze
    else
      custom_primary_key.to_s.freeze
    end
  elsif active_record.has_query_constraints? || options[:query_constraints]
    active_record.query_constraints_list
  elsif active_record.composite_primary_key?
    # If active_record has composite primary key of shape [:<tenant_key>, :id], infer primary_key as :id
    primary_key = primary_key(active_record)
    primary_key.include?("id") ? "id" : primary_key.freeze
  else
    primary_key(active_record).freeze
  end
end

#add_as_polymorphic_through(reflection, seed) ⇒ Object



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

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

#add_as_source(seed) ⇒ Object



667
668
669
# File 'lib/active_record/reflection.rb', line 667

def add_as_source(seed)
  seed
end

#add_as_through(seed) ⇒ Object



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

def add_as_through(seed)
  seed + [self]
end

#association_classObject

Raises:

  • (NotImplementedError)


657
# File 'lib/active_record/reflection.rb', line 657

def association_class; raise NotImplementedError; end

#association_foreign_keyObject



517
518
519
# File 'lib/active_record/reflection.rb', line 517

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

#association_primary_key(klass = nil) ⇒ Object



521
522
523
# File 'lib/active_record/reflection.rb', line 521

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

#association_scope_cache(klass, owner, &block) ⇒ Object



489
490
491
492
493
494
495
# File 'lib/active_record/reflection.rb', line 489

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

#belongs_to?Boolean

Returns true if self is a belongs_to reflection.

Returns:

  • (Boolean)


652
# File 'lib/active_record/reflection.rb', line 652

def belongs_to?; false; end

#check_eager_loadable!Object



568
569
570
571
572
573
574
575
576
577
578
# File 'lib/active_record/reflection.rb', line 568

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

#check_validity!Object



556
557
558
559
560
561
562
563
564
565
566
# File 'lib/active_record/reflection.rb', line 556

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

#clear_association_scope_cacheObject

This is for clearing cache on the reflection. Useful for tests that need to compare SQL queries on associations.



600
601
602
# File 'lib/active_record/reflection.rb', line 600

def clear_association_scope_cache # :nodoc:
  klass.initialize_find_by_cache
end

#collect_join_chainObject

A chain of reflections from this one back to the owner. For more see the explanation in ThroughReflection.



594
595
596
# File 'lib/active_record/reflection.rb', line 594

def collect_join_chain
  [self]
end

#collection?Boolean

Returns whether or not this association reflection is for a collection association. Returns true if the macro is either has_many or has_and_belongs_to_many, false otherwise.

Returns:

  • (Boolean)


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

def collection?
  false
end

#compute_class(name) ⇒ Object

:nodoc:



450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
# File 'lib/active_record/reflection.rb', line 450

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

#extensionsObject



679
680
681
# File 'lib/active_record/reflection.rb', line 679

def extensions
  Array(options[:extend])
end

#foreign_key(infer_from_inverse_of: true) ⇒ Object



501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
# File 'lib/active_record/reflection.rb', line 501

def foreign_key(infer_from_inverse_of: true)
  @foreign_key ||= if options[:query_constraints]
    options[:query_constraints].map { |fk| fk.to_s.freeze }.freeze
  elsif options[:foreign_key]
    options[:foreign_key].to_s
  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(active_record, derived_fk)
    end

    derived_fk
  end
end

#has_inverse?Boolean

Returns:

  • (Boolean)


612
613
614
# File 'lib/active_record/reflection.rb', line 612

def has_inverse?
  inverse_name
end

#has_one?Boolean

Returns true if self is a has_one reflection.

Returns:

  • (Boolean)


655
# File 'lib/active_record/reflection.rb', line 655

def has_one?; false; end

#has_scope?Boolean

Returns:

  • (Boolean)


608
609
610
# File 'lib/active_record/reflection.rb', line 608

def has_scope?
  scope
end

#join_foreign_keyObject



552
553
554
# File 'lib/active_record/reflection.rb', line 552

def join_foreign_key
  active_record_primary_key
end

#join_id_for(owner) ⇒ Object

:nodoc:



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

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

#join_primary_key(klass = nil) ⇒ Object



544
545
546
# File 'lib/active_record/reflection.rb', line 544

def join_primary_key(klass = nil)
  foreign_key
end

#join_primary_typeObject



548
549
550
# File 'lib/active_record/reflection.rb', line 548

def join_primary_type
  type
end

#join_tableObject



497
498
499
# File 'lib/active_record/reflection.rb', line 497

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

#macroObject

Returns the macro type.

has_many :clients returns :has_many

Raises:

  • (NotImplementedError)


629
# File 'lib/active_record/reflection.rb', line 629

def macro; raise NotImplementedError; end

#nested?Boolean

Returns:

  • (Boolean)


604
605
606
# File 'lib/active_record/reflection.rb', line 604

def nested?
  false
end

#polymorphic?Boolean

Returns:

  • (Boolean)


659
660
661
# File 'lib/active_record/reflection.rb', line 659

def polymorphic?
  options[:polymorphic]
end

#polymorphic_inverse_of(associated_class) ⇒ Object



616
617
618
619
620
621
622
623
624
# File 'lib/active_record/reflection.rb', line 616

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

#polymorphic_nameObject



663
664
665
# File 'lib/active_record/reflection.rb', line 663

def polymorphic_name
  active_record.polymorphic_name
end

#source_reflectionObject



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

def source_reflection
  self
end

#through_reflectionObject



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

def through_reflection
  nil
end

#validate?Boolean

Returns whether or not the association should be validated as part of the parent’s validation.

Unless you explicitly disable validation with validate: false, validation will take place when:

  • you explicitly enable validation; validate: true

  • you use autosave; autosave: true

  • the association is a has_many association

Returns:

  • (Boolean)


647
648
649
# File 'lib/active_record/reflection.rb', line 647

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