首先，我们理解下Reflection的概念：
反射：在计算机科学里，是指程序在运行时，可以访问、检测和修改它本身状态或行为的一种能力。
内省：内省（或称“自省”）机制仅指程序在运行时对自身信息（称为元数据）的检测。
和内省相比反射不仅仅能检测自身的信息，还能做出修改。
而ActiveRecord::Reflection里主要保存了某个Model的associations和aggregations的配置信息,在设置完associations或aggregations之后会保存相应的配置信息到Reflection。
# frozen_string_literal: true
require "active_support/core_ext/string/filters"
require "concurrent/map"
module ActiveRecord
# = Active Record Reflection
module Reflection # :nodoc:
extend ActiveSupport::Concern
included do
class_attribute :_reflections, instance_writer: false, default: {}
class_attribute :aggregate_reflections, instance_writer: false, default: {}
end
class << self
def create(macro, name, scope, options, ar)
reflection = reflection_class_for(macro).new(name, scope, options, ar)
options[:through] ? ThroughReflection.new(reflection) : reflection
end
def add_reflection(ar, name, reflection)
ar.clear_reflections_cache
name = -name.to_s
ar._reflections = ar._reflections.except(name).merge!(name => reflection)
end
def add_aggregate_reflection(ar, name, reflection)
ar.aggregate_reflections = ar.aggregate_reflections.merge(-name.to_s => reflection)
end
private
def reflection_class_for(macro)
case macro
when :composed_of
AggregateReflection
when :has_many
HasManyReflection
when :has_one
HasOneReflection
when :belongs_to
BelongsToReflection
else
raise "Unsupported Macro: #{macro}"
end
end
end
# \Reflection enables the ability to examine the associations and aggregations of
# Active Record classes and objects. This information, for example,
# can be used in a form builder that takes an Active Record object
# and creates input fields for all of the attributes depending on their type
# and displays the associations to other objects.
#
# MacroReflection class has info for AggregateReflection and AssociationReflection
# classes.
module ClassMethods
# Returns an array of AggregateReflection objects for all the aggregations in the class.
def reflect_on_all_aggregations
aggregate_reflections.values
end
# Returns the AggregateReflection object for the named +aggregation+ (use the symbol).
#
# Account.reflect_on_aggregation(:balance) # => the balance AggregateReflection
#
def reflect_on_aggregation(aggregation)
aggregate_reflections[aggregation.to_s]
end
# Returns a Hash of name of the reflection as the key and an AssociationReflection as the value.
#
# Account.reflections # => {"balance" => AggregateReflection}
#
def reflections
@__reflections ||= begin
ref = {}
_reflections.each do |name, reflection|
parent_reflection = reflection.parent_reflection
if parent_reflection
parent_name = parent_reflection.name
ref[parent_name.to_s] = parent_reflection
else
ref[name] = reflection
end
end
ref
end
end
# Returns an array of AssociationReflection objects for all the
# associations in the class. If you only want to reflect on a certain
# association type, pass in the symbol (:has_many, :has_one,
# :belongs_to) as the first parameter.
#
# Example:
#
# Account.reflect_on_all_associations # returns an array of all associations
# Account.reflect_on_all_associations(:has_many) # returns an array of all has_many associations
#
def reflect_on_all_associations(macro = nil)
association_reflections = reflections.values
association_reflections.select! { |reflection| reflection.macro == macro } if macro
association_reflections
end
# Returns the AssociationReflection object for the +association+ (use the symbol).
#
# Account.reflect_on_association(:owner) # returns the owner AssociationReflection
# Invoice.reflect_on_association(:line_items).macro # returns :has_many
#
def reflect_on_association(association)
reflections[association.to_s]
end
def _reflect_on_association(association) #:nodoc:
_reflections[association.to_s]
end
# Returns an array of AssociationReflection objects for all associations which have :autosave enabled.
def reflect_on_all_autosave_associations
reflections.values.select { |reflection| reflection.options[:autosave] }
end
def clear_reflections_cache # :nodoc:
@__reflections = nil
end
end
# Holds all the methods that are shared between MacroReflection and ThroughReflection.
#
# AbstractReflection
# MacroReflection
# AggregateReflection
# AssociationReflection
# HasManyReflection
# HasOneReflection
# BelongsToReflection
# HasAndBelongsToManyReflection
# ThroughReflection
# PolymorphicReflection
# RuntimeReflection
class AbstractReflection # :nodoc:
def through_reflection?
false
end
def table_name
klass.table_name
end
# Returns a new, unsaved instance of the associated class. +attributes+ will
# be passed to the class's constructor.
def build_association(attributes, &block)
klass.new(attributes, &block)
end
# Returns the class name for the macro.
#
# composed_of :balance, class_name: 'Money' returns 'Money'
# has_many :clients returns 'Client'
def class_name
@class_name ||= (options[:class_name] || derive_class_name).to_s
end
JoinKeys = Struct.new(:key, :foreign_key) # :nodoc:
def join_keys
@join_keys ||= get_join_keys(klass)
end
# Returns a list of scopes that should be applied for this Reflection
# object when querying the database.
def scopes
scope ? [scope] : []
end
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)
key = join_keys.key
foreign_key = join_keys.foreign_key
klass_scope.where!(table[key].eq(foreign_table[foreign_key]))
if type
klass_scope.where!(type => foreign_klass.polymorphic_name)
end
if klass.finder_needs_type_condition?
klass_scope.where!(klass.send(:type_condition, table))
end
scope_chain_items.inject(klass_scope, &:merge!)
end
def join_scopes(table, predicate_builder) # :nodoc:
if scope
[scope_for(build_scope(table, predicate_builder))]
else
[]
end
end
def klass_join_scope(table, predicate_builder) # :nodoc:
relation = build_scope(table, predicate_builder)
klass.scope_for_association(relation)
end
def constraints
chain.flat_map(&:scopes)
end
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
def inverse_of
return unless inverse_name
@inverse_of ||= klass._reflect_on_association inverse_name
end
def check_validity_of_inverse!
unless polymorphic?
if has_inverse? && inverse_of.nil?
raise InverseOfAssociationNotFoundError.new(self)
end
end
end
# 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.
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
alias inverse_updates_counter_cache? inverse_which_updates_counter_cache
def inverse_updates_counter_in_memory?
inverse_of && inverse_which_updates_counter_cache == inverse_of
end
# 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.
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
def counter_must_be_updated_by_has_many?
!inverse_updates_counter_in_memory? && has_cached_counter?
end
def alias_candidate(name)
"#{plural_name}_#{name}"
end
def chain
collect_join_chain
end
def get_join_keys(association_klass)
JoinKeys.new(join_primary_key(association_klass), join_foreign_key)
end
def build_scope(table, predicate_builder = predicate_builder(table))
Relation.create(
klass,
table: table,
predicate_builder: predicate_builder
)
end
def join_primary_key(*)
foreign_key
end
def join_foreign_key
active_record_primary_key
end
protected
def actual_source_reflection # FIXME: this is a horrible name
self
end
private
def predicate_builder(table)
PredicateBuilder.new(TableMetadata.new(klass, table))
end
def primary_key(klass)
klass.primary_key || raise(UnknownPrimaryKey.new(klass))
end
end
# Base class for AggregateReflection and AssociationReflection. Objects of
# AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
class MacroReflection < AbstractReflection
# Returns the name of the macro.
#
# composed_of :balance, class_name: 'Money' returns :balance
# has_many :clients returns :clients
attr_reader :name
attr_reader :scope
# Returns the hash of options used for the macro.
#
# composed_of :balance, class_name: 'Money' returns { class_name: "Money" }
# has_many :clients returns {}
attr_reader :options
attr_reader :active_record
attr_reader :plural_name # :nodoc:
def initialize(name, scope, options, active_record)
@name = name
@scope = scope
@options = options
@active_record = active_record
@klass = options[:anonymous_class]
@plural_name = active_record.pluralize_table_names ?
name.to_s.pluralize : name.to_s
end
def autosave=(autosave)
@options[:autosave] = autosave
parent_reflection = self.parent_reflection
if parent_reflection
parent_reflection.autosave = autosave
end
end
# Returns the class for the macro.
#
# composed_of :balance, class_name: 'Money' returns the Money class
# has_many :clients returns the Client class
#
# class Company < ActiveRecord::Base
# has_many :clients
# end
#
# Company.reflect_on_association(:clients).klass
# # => Client
#
# 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.
def klass
@klass ||= compute_class(class_name)
end
def compute_class(name)
name.constantize
end
# Returns +true+ if +self+ and +other_aggregation+ have the same +name+ attribute, +active_record+ attribute,
# and +other_aggregation+ has an options hash assigned to it.
def ==(other_aggregation)
super ||
other_aggregation.kind_of?(self.class) &&
name == other_aggregation.name &&
!other_aggregation.options.nil? &&
active_record == other_aggregation.active_record
end
def scope_for(relation, owner = nil)
relation.instance_exec(owner, &scope) || relation
end
private
def derive_class_name
name.to_s.camelize
end
end
# Holds all the metadata about an aggregation as it was specified in the
# Active Record class.
class AggregateReflection < MacroReflection #:nodoc:
def mapping
mapping = options[:mapping] || [name, name]
mapping.first.is_a?(Array) ? mapping : [mapping]
end
end
# Holds all the metadata about an association as it was specified in the
# Active Record class.
class AssociationReflection < MacroReflection #:nodoc:
def compute_class(name)
if polymorphic?
raise ArgumentError, "Polymorphic associations do not support computing the class."
end
active_record.send(:compute_type, name)
end
attr_reader :type, :foreign_type
attr_accessor :parent_reflection # Reflection
def initialize(name, scope, options, active_record)
super
@type = options[:as] && (options[:foreign_type] || "#{options[:as]}_type")
@foreign_type = options[:polymorphic] && (options[:foreign_type] || "#{name}_type")
@constructable = calculate_constructable(macro, options)
@association_scope_cache = Concurrent::Map.new
if options[:class_name] && options[:class_name].class == Class
raise ArgumentError, "A class was passed to `:class_name` but we are expecting a string."
end
end
def association_scope_cache(conn, owner, &block)
key = conn.prepared_statements
if polymorphic?
key = [key, owner._read_attribute(@foreign_type)]
end
@association_scope_cache.compute_if_absent(key) { StatementCache.create(conn, &block) }
end
def constructable? # :nodoc:
@constructable
end
def join_table
@join_table ||= options[:join_table] || derive_join_table
end
def foreign_key
@foreign_key ||= options[:foreign_key] || derive_foreign_key.freeze
end
def association_foreign_key
@association_foreign_key ||= options[:association_foreign_key] || class_name.foreign_key
end
# klass option is necessary to support loading polymorphic associations
def association_primary_key(klass = nil)
options[:primary_key] || primary_key(klass || self.klass)
end
def active_record_primary_key
@active_record_primary_key ||= options[:primary_key] || primary_key(active_record)
end
def check_validity!
check_validity_of_inverse!
end
def check_preloadable!
return unless scope
unless 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
alias :check_eager_loadable! :check_preloadable!
def join_id_for(owner) # :nodoc:
owner[join_foreign_key]
end
def through_reflection
nil
end
def source_reflection
self
end
# A chain of reflections from this one back to the owner. For more see the explanation in
# ThroughReflection.
def collect_join_chain
[self]
end
# This is for clearing cache on the reflection. Useful for tests that need to compare
# SQL queries on associations.
def clear_association_scope_cache # :nodoc:
@association_scope_cache.clear
end
def nested?
false
end
def has_scope?
scope
end
def has_inverse?
inverse_name
end
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
# Returns the macro type.
#
# has_many :clients returns :has_many
def macro; raise NotImplementedError; end
# 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.
def collection?
false
end
# 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
def validate?
!options[:validate].nil? ? options[:validate] : (options[:autosave] == true || collection?)
end
# Returns +true+ if +self+ is a +belongs_to+ reflection.
def belongs_to?; false; end
# Returns +true+ if +self+ is a +has_one+ reflection.
def has_one?; false; end
def association_class; raise NotImplementedError; end
def polymorphic?
options[:polymorphic]
end
VALID_AUTOMATIC_INVERSE_MACROS = [:has_many, :has_one, :belongs_to]
INVALID_AUTOMATIC_INVERSE_OPTIONS = [:through, :foreign_key]
def add_as_source(seed)
seed
end
def add_as_polymorphic_through(reflection, seed)
seed + [PolymorphicReflection.new(self, reflection)]
end
def add_as_through(seed)
seed + [self]
end
def extensions
Array(options[:extend])
end
private
def calculate_constructable(macro, options)
true
end
# Attempts to find the inverse association name automatically.
# If it cannot find a suitable inverse association name, it returns
# +nil+.
def inverse_name
unless defined?(@inverse_name)
@inverse_name = options.fetch(:inverse_of) { automatic_inverse_of }
end
@inverse_name
end
# returns either +nil+ or the inverse association name that it finds.
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)
rescue NameError
# 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)
return inverse_name
end
end
end
# Checks if the inverse reflection that is returned from the
# +automatic_inverse_of+ method is a valid reflection. We must
# make sure that the reflection's active_record name matches up
# with the current reflection's klass name.
def valid_inverse_reflection?(reflection)
reflection &&
klass <= reflection.active_record &&
can_find_inverse_of_automatically?(reflection)
end
# Checks to see if the reflection doesn't have any options that prevent
# us from being able to guess the inverse automatically. First, the
# inverse_of option cannot be set to false. Second, we must
# have has_many, has_one, belongs_to associations.
# Third, we must not have options such as :foreign_key
# which prevent us from correctly guessing the inverse association.
#
# Anything with a scope can additionally ruin our attempt at finding an
# inverse, so we exclude reflections with scopes.
def can_find_inverse_of_automatically?(reflection)
reflection.options[:inverse_of] != false &&
VALID_AUTOMATIC_INVERSE_MACROS.include?(reflection.macro) &&
!INVALID_AUTOMATIC_INVERSE_OPTIONS.any? { |opt| reflection.options[opt] } &&
!reflection.scope
end
def derive_class_name
class_name = name.to_s
class_name = class_name.singularize if collection?
class_name.camelize
end
def derive_foreign_key
if belongs_to?
"#{name}_id"
elsif options[:as]
"#{options[:as]}_id"
else
active_record.name.foreign_key
end
end
def derive_join_table
ModelSchema.derive_join_table_name active_record.table_name, klass.table_name
end
end
class HasManyReflection < AssociationReflection # :nodoc:
def macro; :has_many; end
def collection?; true; end
def association_class
if options[:through]
Associations::HasManyThroughAssociation
else
Associations::HasManyAssociation
end
end
def association_primary_key(klass = nil)
primary_key(klass || self.klass)
end
end
class HasOneReflection < AssociationReflection # :nodoc:
def macro; :has_one; end
def has_one?; true; end
def association_class
if options[:through]
Associations::HasOneThroughAssociation
else
Associations::HasOneAssociation
end
end
private
def calculate_constructable(macro, options)
!options[:through]
end
end
class BelongsToReflection < AssociationReflection # :nodoc:
def macro; :belongs_to; end
def belongs_to?; true; end
def association_class
if polymorphic?
Associations::BelongsToPolymorphicAssociation
else
Associations::BelongsToAssociation
end
end
def join_primary_key(klass = nil)
polymorphic? ? association_primary_key(klass) : association_primary_key
end
def join_foreign_key
foreign_key
end
private
def can_find_inverse_of_automatically?(_)
!polymorphic? && super
end
def calculate_constructable(macro, options)
!polymorphic?
end
end
class HasAndBelongsToManyReflection < AssociationReflection # :nodoc:
def macro; :has_and_belongs_to_many; end
def collection?
true
end
end
# Holds all the metadata about a :through association as it was specified
# in the Active Record class.
class ThroughReflection < AbstractReflection #:nodoc:
delegate :foreign_key, :foreign_type, :association_foreign_key, :join_id_for,
:active_record_primary_key, :type, :get_join_keys, to: :source_reflection
def initialize(delegate_reflection)
@delegate_reflection = delegate_reflection
@klass = delegate_reflection.options[:anonymous_class]
@source_reflection_name = delegate_reflection.options[:source]
end
def through_reflection?
true
end
def klass
@klass ||= delegate_reflection.compute_class(class_name)
end
# Returns the source of the through reflection. It checks both a singularized
# and pluralized form for :belongs_to or :has_many.
#
# class Post < ActiveRecord::Base
# has_many :taggings
# has_many :tags, through: :taggings
# end
#
# class Tagging < ActiveRecord::Base
# belongs_to :post
# belongs_to :tag
# end
#
# tags_reflection = Post.reflect_on_association(:tags)
# tags_reflection.source_reflection
# # =>
#
def source_reflection
through_reflection.klass._reflect_on_association(source_reflection_name)
end
# Returns the AssociationReflection object specified in the :through option
# of a HasManyThrough or HasOneThrough association.
#
# class Post < ActiveRecord::Base
# has_many :taggings
# has_many :tags, through: :taggings
# end
#
# tags_reflection = Post.reflect_on_association(:tags)
# tags_reflection.through_reflection
# # =>
#
def through_reflection
active_record._reflect_on_association(options[:through])
end
# Returns an array of reflections which are involved in this association. Each item in the
# array corresponds to a table which will be part of the query for this association.
#
# The chain is built by recursively calling #chain on the source reflection and the through
# reflection. The base case for the recursion is a normal association, which just returns
# [self] as its #chain.
#
# class Post < ActiveRecord::Base
# has_many :taggings
# has_many :tags, through: :taggings
# end
#
# tags_reflection = Post.reflect_on_association(:tags)
# tags_reflection.chain
# # => [,
# ]
#
def collect_join_chain
collect_join_reflections [self]
end
# This is for clearing cache on the reflection. Useful for tests that need to compare
# SQL queries on associations.
def clear_association_scope_cache # :nodoc:
delegate_reflection.clear_association_scope_cache
source_reflection.clear_association_scope_cache
through_reflection.clear_association_scope_cache
end
def scopes
source_reflection.scopes + super
end
def join_scopes(table, predicate_builder) # :nodoc:
source_reflection.join_scopes(table, predicate_builder) + super
end
def has_scope?
scope || options[:source_type] ||
source_reflection.has_scope? ||
through_reflection.has_scope?
end
# A through association is nested if there would be more than one join table
def nested?
source_reflection.through_reflection? || through_reflection.through_reflection?
end
# We want to use the klass from this reflection, rather than just delegate straight to
# the source_reflection, because the source_reflection may be polymorphic. We still
# need to respect the source_reflection's :primary_key option, though.
def association_primary_key(klass = nil)
# Get the "actual" source reflection if the immediate source reflection has a
# source reflection itself
actual_source_reflection.options[:primary_key] || primary_key(klass || self.klass)
end
# Gets an array of possible :through source reflection names in both singular and plural form.
#
# class Post < ActiveRecord::Base
# has_many :taggings
# has_many :tags, through: :taggings
# end
#
# tags_reflection = Post.reflect_on_association(:tags)
# tags_reflection.source_reflection_names
# # => [:tag, :tags]
#
def source_reflection_names
options[:source] ? [options[:source]] : [name.to_s.singularize, name].uniq
end
def source_reflection_name # :nodoc:
return @source_reflection_name if @source_reflection_name
names = [name.to_s.singularize, name].collect(&:to_sym).uniq
names = names.find_all { |n|
through_reflection.klass._reflect_on_association(n)
}
if names.length > 1
raise AmbiguousSourceReflectionForThroughAssociation.new(
active_record.name,
macro,
name,
options,
source_reflection_names
)
end
@source_reflection_name = names.first
end
def source_options
source_reflection.options
end
def through_options
through_reflection.options
end
def check_validity!
if through_reflection.nil?
raise HasManyThroughAssociationNotFoundError.new(active_record.name, self)
end
if through_reflection.polymorphic?
if has_one?
raise HasOneAssociationPolymorphicThroughError.new(active_record.name, self)
else
raise HasManyThroughAssociationPolymorphicThroughError.new(active_record.name, self)
end
end
if source_reflection.nil?
raise HasManyThroughSourceAssociationNotFoundError.new(self)
end
if options[:source_type] && !source_reflection.polymorphic?
raise HasManyThroughAssociationPointlessSourceTypeError.new(active_record.name, self, source_reflection)
end
if source_reflection.polymorphic? && options[:source_type].nil?
raise HasManyThroughAssociationPolymorphicSourceError.new(active_record.name, self, source_reflection)
end
if has_one? && through_reflection.collection?
raise HasOneThroughCantAssociateThroughCollection.new(active_record.name, self, through_reflection)
end
if parent_reflection.nil?
reflections = active_record.reflections.keys.map(&:to_sym)
if reflections.index(through_reflection.name) > reflections.index(name)
raise HasManyThroughOrderError.new(active_record.name, self, through_reflection)
end
end
check_validity_of_inverse!
end
def constraints
scope_chain = source_reflection.constraints
scope_chain << scope if scope
scope_chain
end
def add_as_source(seed)
collect_join_reflections seed
end
def add_as_polymorphic_through(reflection, seed)
collect_join_reflections(seed + [PolymorphicReflection.new(self, reflection)])
end
def add_as_through(seed)
collect_join_reflections(seed + [self])
end
protected
def actual_source_reflection # FIXME: this is a horrible name
source_reflection.actual_source_reflection
end
private
attr_reader :delegate_reflection
def collect_join_reflections(seed)
a = source_reflection.add_as_source seed
if options[:source_type]
through_reflection.add_as_polymorphic_through self, a
else
through_reflection.add_as_through a
end
end
def inverse_name; delegate_reflection.send(:inverse_name); end
def derive_class_name
# get the class_name of the belongs_to association of the through reflection
options[:source_type] || source_reflection.class_name
end
delegate_methods = AssociationReflection.public_instance_methods -
public_instance_methods
delegate(*delegate_methods, to: :delegate_reflection)
end
class PolymorphicReflection < AbstractReflection # :nodoc:
delegate :klass, :scope, :plural_name, :type, :get_join_keys, :scope_for, to: :@reflection
def initialize(reflection, previous_reflection)
@reflection = reflection
@previous_reflection = previous_reflection
end
def join_scopes(table, predicate_builder) # :nodoc:
scopes = @previous_reflection.join_scopes(table, predicate_builder) + super
scopes << build_scope(table, predicate_builder).instance_exec(nil, &source_type_scope)
end
def constraints
@reflection.constraints + [source_type_scope]
end
private
def source_type_scope
type = @previous_reflection.foreign_type
source_type = @previous_reflection.options[:source_type]
lambda { |object| where(type => source_type) }
end
end
class RuntimeReflection < AbstractReflection # :nodoc:
delegate :scope, :type, :constraints, :get_join_keys, to: :@reflection
def initialize(reflection, association)
@reflection = reflection
@association = association
end
def klass
@association.klass
end
def aliased_table
@aliased_table ||= Arel::Table.new(table_name, type_caster: klass.type_caster)
end
def all_includes; yield; end
end
end
end
_reflections和aggregate_reflections类变量保存了相应的reflection配置自信息。
而暴露给我们的api，也就是module ClassMethods里的方法查询配置信息的。
AbstractReflection
抽象的Reflection类，主要实现了所有Reflection需要的基础方法：
- through_reflection? 是否是through reflection
- table_name 返回表名
- build_association 返回一个新的，未保存的association实例。
- class_name 返回类名
等等 TODO，很多方法需要再阅读玩其他代码之后才能理解作用。
MacroReflection
AggregateReflection和AssociationReflection的父类，
定义了一些基础的attr_reader,包括,name scope options active_record和plural_name。
以及定义了initialize方法.
AggregateReflection
ActiveRecord::Base composed_of 方法对应的Reflection配置信息。只定义了mapping方法返回mapping信息。
AssociationReflection
所有association对象的父类，实现了association的公用部分。
HasManyReflection、HasOneReflection、BelongsToReflection
基本上每个Reflection对应的association_class功能
ThroughReflection
带有through的Association对应这个类。
PolymorphicReflection
多态的Relection。
RuntimeReflection
还不知道哪里有用到，之后补上。