Class: ActiveRecord::Reflection::AbstractReflection
- Inherits:
-
Object
- Object
- ActiveRecord::Reflection::AbstractReflection
show all
- Defined in:
- lib/active_record/reflection.rb
Overview
Defined Under Namespace
Classes: JoinKeys
Instance Method Summary
collapse
Instance Method Details
#alias_candidate(name) ⇒ Object
283
284
285
|
# File 'lib/active_record/reflection.rb', line 283
def alias_candidate(name)
"#{plural_name}_#{name}"
end
|
#build_association(attributes, &block) ⇒ Object
Returns a new, unsaved instance of the associated class. attributes
will be passed to the class’s constructor.
157
158
159
|
# File 'lib/active_record/reflection.rb', line 157
def build_association(attributes, &block)
klass.new(attributes, &block)
end
|
#build_scope(table, predicate_builder = predicate_builder(table)) ⇒ Object
295
296
297
298
299
300
301
|
# File 'lib/active_record/reflection.rb', line 295
def build_scope(table, predicate_builder = predicate_builder(table))
Relation.create(
klass,
table: table,
predicate_builder: predicate_builder
)
end
|
#chain ⇒ Object
287
288
289
|
# File 'lib/active_record/reflection.rb', line 287
def chain
collect_join_chain
end
|
#check_validity_of_inverse! ⇒ Object
239
240
241
242
243
244
245
|
# File 'lib/active_record/reflection.rb', line 239
def check_validity_of_inverse!
unless polymorphic?
if has_inverse? && inverse_of.nil?
raise InverseOfAssociationNotFoundError.new(self)
end
end
end
|
#class_name ⇒ Object
Returns the class name for the macro.
composed_of :balance, class_name: 'Money'
returns 'Money'
has_many :clients
returns 'Client'
165
166
167
|
# File 'lib/active_record/reflection.rb', line 165
def class_name
@class_name ||= (options[:class_name] || derive_class_name).to_s
end
|
#constraints ⇒ Object
217
218
219
|
# File 'lib/active_record/reflection.rb', line 217
def constraints
chain.flat_map(&:scopes)
end
|
#counter_cache_column ⇒ Object
221
222
223
224
225
226
227
228
229
230
231
|
# File 'lib/active_record/reflection.rb', line 221
def counter_cache_column
if belongs_to?
if options[:counter_cache] == true
"#{active_record.name.demodulize.underscore.pluralize}_count"
elsif options[:counter_cache]
options[:counter_cache].to_s
end
else
options[:counter_cache] ? options[:counter_cache].to_s : "#{name}_count"
end
end
|
#counter_must_be_updated_by_has_many? ⇒ Boolean
279
280
281
|
# File 'lib/active_record/reflection.rb', line 279
def counter_must_be_updated_by_has_many?
!inverse_updates_counter_in_memory? && has_cached_counter?
end
|
#get_join_keys(association_klass) ⇒ Object
291
292
293
|
# File 'lib/active_record/reflection.rb', line 291
def get_join_keys(association_klass)
JoinKeys.new(join_primary_key(association_klass), join_foreign_key)
end
|
#has_cached_counter? ⇒ Boolean
Returns whether a counter cache should be used for this association.
The counter_cache option must be given on either the owner or inverse association, and the column must be present on the owner.
273
274
275
276
277
|
# File 'lib/active_record/reflection.rb', line 273
def has_cached_counter?
options[:counter_cache] ||
inverse_which_updates_counter_cache && inverse_which_updates_counter_cache.options[:counter_cache] &&
!!active_record.columns_hash[counter_cache_column]
end
|
#inverse_of ⇒ Object
233
234
235
236
237
|
# File 'lib/active_record/reflection.rb', line 233
def inverse_of
return unless inverse_name
@inverse_of ||= klass._reflect_on_association inverse_name
end
|
#inverse_updates_counter_in_memory? ⇒ Boolean
265
266
267
|
# File 'lib/active_record/reflection.rb', line 265
def inverse_updates_counter_in_memory?
inverse_of && inverse_which_updates_counter_cache == inverse_of
end
|
#inverse_which_updates_counter_cache ⇒ Object
Also known as:
inverse_updates_counter_cache?
This shit is nasty. We need to avoid the following situation:
* An associated record is deleted via record.destroy
* Hence the callbacks run, and they find a belongs_to on the record with a
:counter_cache options which points back at our owner. So they update the
counter cache.
* In which case, we must make sure to *not* update the counter cache, or else
it will be decremented twice.
Hence this method.
257
258
259
260
261
262
|
# File 'lib/active_record/reflection.rb', line 257
def inverse_which_updates_counter_cache
return @inverse_which_updates_counter_cache if defined?(@inverse_which_updates_counter_cache)
@inverse_which_updates_counter_cache = klass.reflect_on_all_associations(:belongs_to).find do |inverse|
inverse.counter_cache_column == counter_cache_column
end
end
|
#join_foreign_key ⇒ Object
307
308
309
|
# File 'lib/active_record/reflection.rb', line 307
def join_foreign_key
active_record_primary_key
end
|
#join_keys ⇒ Object
171
172
173
|
# File 'lib/active_record/reflection.rb', line 171
def join_keys
@join_keys ||= get_join_keys(klass)
end
|
#join_primary_key ⇒ Object
303
304
305
|
# File 'lib/active_record/reflection.rb', line 303
def join_primary_key(*)
foreign_key
end
|
#join_scope(table, foreign_table, foreign_klass) ⇒ Object
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
# File 'lib/active_record/reflection.rb', line 181
def join_scope(table, foreign_table, foreign_klass)
predicate_builder = predicate_builder(table)
scope_chain_items = join_scopes(table, predicate_builder)
klass_scope = klass_join_scope(table, predicate_builder)
if type
klass_scope.where!(type => foreign_klass.polymorphic_name)
end
scope_chain_items.inject(klass_scope, &:merge!)
key = join_keys.key
foreign_key = join_keys.foreign_key
klass_scope.where!(table[key].eq(foreign_table[foreign_key]))
if klass.finder_needs_type_condition?
klass_scope.where!(klass.send(:type_condition, table))
end
klass_scope
end
|
#join_scopes(table, predicate_builder) ⇒ Object
204
205
206
207
208
209
210
|
# File 'lib/active_record/reflection.rb', line 204
def join_scopes(table, predicate_builder) if scope
[scope_for(build_scope(table, predicate_builder))]
else
[]
end
end
|
#klass_join_scope(table, predicate_builder) ⇒ Object
212
213
214
215
|
# File 'lib/active_record/reflection.rb', line 212
def klass_join_scope(table, predicate_builder) relation = build_scope(table, predicate_builder)
klass.scope_for_association(relation)
end
|
#scopes ⇒ Object
Returns a list of scopes that should be applied for this Reflection object when querying the database.
177
178
179
|
# File 'lib/active_record/reflection.rb', line 177
def scopes
scope ? [scope] : []
end
|
#table_name ⇒ Object
151
152
153
|
# File 'lib/active_record/reflection.rb', line 151
def table_name
klass.table_name
end
|
#through_reflection? ⇒ Boolean
147
148
149
|
# File 'lib/active_record/reflection.rb', line 147
def through_reflection?
false
end
|