Class: ActiveRecord::Associations::Association

Inherits:
Object
  • Object
show all
Defined in:
activerecord/lib/active_record/associations/association.rb

Overview

Direct Known Subclasses

CollectionAssociation, SingularAssociation

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(owner, reflection) ⇒ Association

Returns a new instance of Association


24
25
26
27
28
29
30
31
# File 'activerecord/lib/active_record/associations/association.rb', line 24

def initialize(owner, reflection)
  reflection.check_validity!

  @owner, @reflection = owner, reflection

  reset
  reset_scope
end

Instance Attribute Details

#ownerObject (readonly)

Returns the value of attribute owner


20
21
22
# File 'activerecord/lib/active_record/associations/association.rb', line 20

def owner
  @owner
end

#reflectionObject (readonly)

Returns the value of attribute reflection


20
21
22
# File 'activerecord/lib/active_record/associations/association.rb', line 20

def reflection
  @reflection
end

#targetObject

Returns the value of attribute target


20
21
22
# File 'activerecord/lib/active_record/associations/association.rb', line 20

def target
  @target
end

Instance Method Details

#aliased_table_nameObject

Returns the name of the table of the associated class:

post.comments.aliased_table_name # => "comments"

37
38
39
# File 'activerecord/lib/active_record/associations/association.rb', line 37

def aliased_table_name
  klass.table_name
end

#association_scopeObject

The scope for this association.

Note that the association_scope is merged into the target_scope only when the scope method is called. This is because at that point the call may be surrounded by scope.scoping { … } or with_scope { … } etc, which affects the scope which actually gets built.


93
94
95
96
97
# File 'activerecord/lib/active_record/associations/association.rb', line 93

def association_scope
  if klass
    @association_scope ||= AssociationScope.new(self).scope
  end
end

#initialize_attributes(record) ⇒ Object

:nodoc:


162
163
164
165
166
167
# File 'activerecord/lib/active_record/associations/association.rb', line 162

def initialize_attributes(record) #:nodoc:
  skip_assign = [reflection.foreign_key, reflection.type].compact
  attributes = create_scope.except(*(record.changed - skip_assign))
  record.assign_attributes(attributes)
  set_inverse_instance(record)
end

#interpolate(sql, record = nil) ⇒ Object


142
143
144
145
146
147
148
# File 'activerecord/lib/active_record/associations/association.rb', line 142

def interpolate(sql, record = nil)
  if sql.respond_to?(:to_proc)
    owner.instance_exec(record, &sql)
  else
    sql
  end
end

#klassObject

Returns the class of the target. belongs_to polymorphic overrides this to look at the polymorphic_type field on the owner.


113
114
115
# File 'activerecord/lib/active_record/associations/association.rb', line 113

def klass
  reflection.klass
end

#load_targetObject

Loads the target if needed and returns it.

This method is abstract in the sense that it relies on find_target, which is expected to be provided by descendants.

If the target is already loaded it is just returned. Thus, you can call load_target unconditionally to get the target.

ActiveRecord::RecordNotFound is rescued within the method, and it is not reraised. The proxy is reset and nil is the return value.


133
134
135
136
137
138
139
140
# File 'activerecord/lib/active_record/associations/association.rb', line 133

def load_target
  @target = find_target if (@stale_state && stale_target?) || find_target?

  loaded! unless loaded?
  target
rescue ActiveRecord::RecordNotFound
  reset
end

#loaded!Object

Asserts the target has been loaded setting the loaded flag to true.


62
63
64
65
# File 'activerecord/lib/active_record/associations/association.rb', line 62

def loaded!
  @loaded      = true
  @stale_state = stale_state
end

#loaded?Boolean

Has the target been already loaded?

Returns:

  • (Boolean)

57
58
59
# File 'activerecord/lib/active_record/associations/association.rb', line 57

def loaded?
  @loaded
end

#marshal_dumpObject

We can't dump @reflection since it contains the scope proc


151
152
153
154
# File 'activerecord/lib/active_record/associations/association.rb', line 151

def marshal_dump
  ivars = (instance_variables - [:@reflection]).map { |name| [name, instance_variable_get(name)] }
  [@reflection.name, ivars]
end

#marshal_load(data) ⇒ Object


156
157
158
159
160
# File 'activerecord/lib/active_record/associations/association.rb', line 156

def marshal_load(data)
  reflection_name, ivars = data
  ivars.each { |name, val| instance_variable_set(name, val) }
  @reflection = @owner.class.reflect_on_association(reflection_name)
end

#reloadObject

Reloads the target and returns self on success.


49
50
51
52
53
54
# File 'activerecord/lib/active_record/associations/association.rb', line 49

def reload
  reset
  reset_scope
  load_target
  self unless target.nil?
end

#resetObject

Resets the loaded flag to false and sets the target to nil.


42
43
44
45
46
# File 'activerecord/lib/active_record/associations/association.rb', line 42

def reset
  @loaded = false
  @target = nil
  @stale_state = nil
end

#reset_scopeObject


99
100
101
# File 'activerecord/lib/active_record/associations/association.rb', line 99

def reset_scope
  @association_scope = nil
end

#scopeObject


83
84
85
# File 'activerecord/lib/active_record/associations/association.rb', line 83

def scope
  target_scope.merge(association_scope)
end

#set_inverse_instance(record) ⇒ Object

Set the inverse association, if possible


104
105
106
107
108
109
# File 'activerecord/lib/active_record/associations/association.rb', line 104

def set_inverse_instance(record)
  if record && invertible_for?(record)
    inverse = record.association(inverse_reflection_for(record).name)
    inverse.target = owner
  end
end

#stale_target?Boolean

The target is stale if the target no longer points to the record(s) that the relevant foreign_key(s) refers to. If stale, the association accessor method on the owner will reload the target. It's up to subclasses to implement the state_state method if relevant.

Note that if the target has not been loaded, it is not considered stale.

Returns:

  • (Boolean)

73
74
75
# File 'activerecord/lib/active_record/associations/association.rb', line 73

def stale_target?
  loaded? && @stale_state != stale_state
end

#target_scopeObject

Can be overridden (i.e. in ThroughAssociation) to merge in other scopes (i.e. the through association's scope)


119
120
121
# File 'activerecord/lib/active_record/associations/association.rb', line 119

def target_scope
  AssociationRelation.create(klass, klass.arel_table, self).merge!(klass.all)
end