Class: ActiveRecord::Reflection::AssociationReflection

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

Overview

Holds all the meta-data about an association as it was specified in the Active Record class.

Constant Summary collapse

VALID_AUTOMATIC_INVERSE_MACROS =
[:has_many, :has_one, :belongs_to]
INVALID_AUTOMATIC_INVERSE_OPTIONS =
[:conditions, :through, :polymorphic, :foreign_key]

Instance Attribute Summary collapse

Attributes inherited from MacroReflection

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

Instance Method Summary collapse

Methods inherited from MacroReflection

#==, #autosave=, #scope_for

Methods inherited from AbstractReflection

#alias_candidate, #build_association, #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_keys, #primary_key_type, #quoted_table_name, #table_name, #through_reflection?

Constructor Details

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

Returns a new instance of AssociationReflection.


360
361
362
363
364
365
366
367
368
# File 'activerecord/lib/active_record/reflection.rb', line 360

def initialize(name, scope, options, active_record)
  super
  @automatic_inverse_of = nil
  @type         = options[:as] && (options[:foreign_type] || "#{options[:as]}_type")
  @foreign_type = options[:foreign_type] || "#{name}_type"
  @constructable = calculate_constructable(macro, options)
  @association_scope_cache = {}
  @scope_lock = Mutex.new
end

Instance Attribute Details

#foreign_typeObject (readonly)

Returns the value of attribute foreign_type


357
358
359
# File 'activerecord/lib/active_record/reflection.rb', line 357

def foreign_type
  @foreign_type
end

#parent_reflectionObject

Reflection


358
359
360
# File 'activerecord/lib/active_record/reflection.rb', line 358

def parent_reflection
  @parent_reflection
end

#typeObject (readonly)

Returns the value of attribute type


357
358
359
# File 'activerecord/lib/active_record/reflection.rb', line 357

def type
  @type
end

Instance Method Details

#active_record_primary_keyObject


405
406
407
# File 'activerecord/lib/active_record/reflection.rb', line 405

def active_record_primary_key
  @active_record_primary_key ||= options[:primary_key] || primary_key(active_record)
end

#add_as_polymorphic_through(reflection, seed) ⇒ Object


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

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

#add_as_source(seed) ⇒ Object


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

def add_as_source(seed)
  seed
end

#add_as_through(seed) ⇒ Object


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

def add_as_through(seed)
  seed + [self]
end

#association_classObject

Raises:

  • (NotImplementedError)

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

def association_class; raise NotImplementedError; end

#association_foreign_keyObject


392
393
394
# File 'activerecord/lib/active_record/reflection.rb', line 392

def association_foreign_key
  @association_foreign_key ||= options[:association_foreign_key] || class_name.foreign_key
end

#association_primary_key(klass = nil) ⇒ Object

klass option is necessary to support loading polymorphic associations


397
398
399
# File 'activerecord/lib/active_record/reflection.rb', line 397

def association_primary_key(klass = nil)
  options[:primary_key] || primary_key(klass || self.klass)
end

#association_primary_key_typeObject


401
402
403
# File 'activerecord/lib/active_record/reflection.rb', line 401

def association_primary_key_type
  klass.type_for_attribute(association_primary_key)
end

#association_scope_cache(conn, owner) ⇒ Object


370
371
372
373
374
375
376
377
378
# File 'activerecord/lib/active_record/reflection.rb', line 370

def association_scope_cache(conn, owner)
  key = conn.prepared_statements
  if polymorphic?
    key = [key, owner._read_attribute(@foreign_type)]
  end
  @association_scope_cache[key] ||= @scope_lock.synchronize {
    @association_scope_cache[key] ||= yield
  }
end

#belongs_to?Boolean

Returns true if self is a belongs_to reflection.

Returns:

  • (Boolean)

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

def belongs_to?; false; end

#check_preloadable!Object Also known as: check_eager_loadable!


413
414
415
416
417
418
419
420
421
422
423
# File 'activerecord/lib/active_record/reflection.rb', line 413

def check_preloadable!
  return unless scope

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

#check_validity!Object


409
410
411
# File 'activerecord/lib/active_record/reflection.rb', line 409

def check_validity!
  check_validity_of_inverse!
end

#clear_association_scope_cacheObject

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


446
447
448
# File 'activerecord/lib/active_record/reflection.rb', line 446

def clear_association_scope_cache # :nodoc:
  @association_scope_cache.clear
end

#collect_join_chainObject

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


440
441
442
# File 'activerecord/lib/active_record/reflection.rb', line 440

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)

486
487
488
# File 'activerecord/lib/active_record/reflection.rb', line 486

def collection?
  false
end

#compute_class(name) ⇒ Object


353
354
355
# File 'activerecord/lib/active_record/reflection.rb', line 353

def compute_class(name)
  active_record.send(:compute_type, name)
end

#constructable?Boolean

:nodoc:

Returns:

  • (Boolean)

380
381
382
# File 'activerecord/lib/active_record/reflection.rb', line 380

def constructable? # :nodoc:
  @constructable
end

#foreign_keyObject


388
389
390
# File 'activerecord/lib/active_record/reflection.rb', line 388

def foreign_key
  @foreign_key ||= options[:foreign_key] || derive_foreign_key.freeze
end

#has_inverse?Boolean

Returns:

  • (Boolean)

464
465
466
# File 'activerecord/lib/active_record/reflection.rb', line 464

def has_inverse?
  inverse_name
end

#has_one?Boolean

Returns true if self is a has_one reflection.

Returns:

  • (Boolean)

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

def has_one?; false; end

#has_scope?Boolean

Returns:

  • (Boolean)

460
461
462
# File 'activerecord/lib/active_record/reflection.rb', line 460

def has_scope?
  scope
end

#join_id_for(owner) ⇒ Object

:nodoc:


426
427
428
# File 'activerecord/lib/active_record/reflection.rb', line 426

def join_id_for(owner) # :nodoc:
  owner[active_record_primary_key]
end

#join_tableObject


384
385
386
# File 'activerecord/lib/active_record/reflection.rb', line 384

def join_table
  @join_table ||= options[:join_table] || derive_join_table
end

#klassObject

Returns the target association's class.

class Author < ActiveRecord::Base
  has_many :books
end

Author.reflect_on_association(:books).klass# => Book

Note: Do not call klass.new or klass.create to instantiate a new association object. Use build_association or create_association instead. This allows plugins to hook into association object creation.


349
350
351
# File 'activerecord/lib/active_record/reflection.rb', line 349

def klass
  @klass ||= compute_class(class_name)
end

#macroObject

Returns the macro type.

has_many :clients returns :has_many

Raises:

  • (NotImplementedError)

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

def macro; raise NotImplementedError; end

#nested?Boolean

Returns:

  • (Boolean)

450
451
452
# File 'activerecord/lib/active_record/reflection.rb', line 450

def nested?
  false
end

#polymorphic?Boolean

Returns:

  • (Boolean)

511
512
513
# File 'activerecord/lib/active_record/reflection.rb', line 511

def polymorphic?
  options[:polymorphic]
end

#polymorphic_inverse_of(associated_class) ⇒ Object


468
469
470
471
472
473
474
475
476
# File 'activerecord/lib/active_record/reflection.rb', line 468

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

#scope_chainObject

An array of arrays of scopes. Each item in the outside array corresponds to a reflection in the #chain.


456
457
458
# File 'activerecord/lib/active_record/reflection.rb', line 456

def scope_chain
  scope ? [[scope]] : [[]]
end

#source_reflectionObject


434
435
436
# File 'activerecord/lib/active_record/reflection.rb', line 434

def source_reflection
  self
end

#through_reflectionObject


430
431
432
# File 'activerecord/lib/active_record/reflection.rb', line 430

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)

499
500
501
# File 'activerecord/lib/active_record/reflection.rb', line 499

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