2007-01-22 14:43:50 +01:00
|
|
|
module ActiveRecord
|
|
|
|
module Associations
|
2008-05-18 06:22:34 +02:00
|
|
|
# This is the root class of all association proxies:
|
|
|
|
#
|
|
|
|
# AssociationProxy
|
|
|
|
# BelongsToAssociation
|
|
|
|
# HasOneAssociation
|
|
|
|
# BelongsToPolymorphicAssociation
|
|
|
|
# AssociationCollection
|
|
|
|
# HasAndBelongsToManyAssociation
|
|
|
|
# HasManyAssociation
|
|
|
|
# HasManyThroughAssociation
|
|
|
|
# HasOneThroughAssociation
|
|
|
|
#
|
|
|
|
# Association proxies in Active Record are middlemen between the object that
|
|
|
|
# holds the association, known as the <tt>@owner</tt>, and the actual associated
|
|
|
|
# object, known as the <tt>@target</tt>. The kind of association any proxy is
|
|
|
|
# about is available in <tt>@reflection</tt>. That's an instance of the class
|
|
|
|
# ActiveRecord::Reflection::AssociationReflection.
|
|
|
|
#
|
|
|
|
# For example, given
|
|
|
|
#
|
|
|
|
# class Blog < ActiveRecord::Base
|
|
|
|
# has_many :posts
|
|
|
|
# end
|
|
|
|
#
|
|
|
|
# blog = Blog.find(:first)
|
|
|
|
#
|
|
|
|
# the association proxy in <tt>blog.posts</tt> has the object in +blog+ as
|
|
|
|
# <tt>@owner</tt>, the collection of its posts as <tt>@target</tt>, and
|
|
|
|
# the <tt>@reflection</tt> object represents a <tt>:has_many</tt> macro.
|
|
|
|
#
|
|
|
|
# This class has most of the basic instance methods removed, and delegates
|
|
|
|
# unknown methods to <tt>@target</tt> via <tt>method_missing</tt>. As a
|
|
|
|
# corner case, it even removes the +class+ method and that's why you get
|
|
|
|
#
|
|
|
|
# blog.posts.class # => Array
|
|
|
|
#
|
|
|
|
# though the object behind <tt>blog.posts</tt> is not an Array, but an
|
|
|
|
# ActiveRecord::Associations::HasManyAssociation.
|
|
|
|
#
|
2008-10-27 07:47:01 +01:00
|
|
|
# The <tt>@target</tt> object is not \loaded until needed. For example,
|
2008-05-18 06:22:34 +02:00
|
|
|
#
|
|
|
|
# blog.posts.count
|
|
|
|
#
|
|
|
|
# is computed directly through SQL and does not trigger by itself the
|
|
|
|
# instantiation of the actual post records.
|
2007-01-22 14:43:50 +01:00
|
|
|
class AssociationProxy #:nodoc:
|
|
|
|
alias_method :proxy_respond_to?, :respond_to?
|
|
|
|
alias_method :proxy_extend, :extend
|
2007-02-09 09:04:31 +01:00
|
|
|
delegate :to_param, :to => :proxy_target
|
2008-06-02 08:35:38 +02:00
|
|
|
instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^object_id$)/ }
|
2007-01-22 14:43:50 +01:00
|
|
|
|
|
|
|
def initialize(owner, reflection)
|
|
|
|
@owner, @reflection = owner, reflection
|
2007-02-09 09:04:31 +01:00
|
|
|
Array(reflection.options[:extend]).each { |ext| proxy_extend(ext) }
|
2007-01-22 14:43:50 +01:00
|
|
|
reset
|
|
|
|
end
|
2007-12-21 08:48:59 +01:00
|
|
|
|
2008-10-27 07:47:01 +01:00
|
|
|
# Returns the owner of the proxy.
|
2007-02-09 09:04:31 +01:00
|
|
|
def proxy_owner
|
|
|
|
@owner
|
|
|
|
end
|
2007-12-21 08:48:59 +01:00
|
|
|
|
2008-10-27 07:47:01 +01:00
|
|
|
# Returns the reflection object that represents the association handled
|
|
|
|
# by the proxy.
|
2007-02-09 09:04:31 +01:00
|
|
|
def proxy_reflection
|
|
|
|
@reflection
|
|
|
|
end
|
2007-12-21 08:48:59 +01:00
|
|
|
|
2008-10-27 07:47:01 +01:00
|
|
|
# Returns the \target of the proxy, same as +target+.
|
2007-02-09 09:04:31 +01:00
|
|
|
def proxy_target
|
|
|
|
@target
|
|
|
|
end
|
|
|
|
|
2008-10-27 07:47:01 +01:00
|
|
|
# Does the proxy or its \target respond to +symbol+?
|
2008-09-07 07:54:05 +02:00
|
|
|
def respond_to?(*args)
|
|
|
|
proxy_respond_to?(*args) || (load_target && @target.respond_to?(*args))
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
2007-12-21 08:48:59 +01:00
|
|
|
|
2008-10-27 07:47:01 +01:00
|
|
|
# Forwards <tt>===</tt> explicitly to the \target because the instance method
|
|
|
|
# removal above doesn't catch it. Loads the \target if needed.
|
2007-01-22 14:43:50 +01:00
|
|
|
def ===(other)
|
|
|
|
load_target
|
|
|
|
other === @target
|
|
|
|
end
|
2007-12-21 08:48:59 +01:00
|
|
|
|
2008-10-27 07:47:01 +01:00
|
|
|
# Returns the name of the table of the related class:
|
|
|
|
#
|
|
|
|
# post.comments.aliased_table_name # => "comments"
|
|
|
|
#
|
2007-01-22 14:43:50 +01:00
|
|
|
def aliased_table_name
|
|
|
|
@reflection.klass.table_name
|
|
|
|
end
|
2007-12-21 08:48:59 +01:00
|
|
|
|
2008-10-27 07:47:01 +01:00
|
|
|
# Returns the SQL string that corresponds to the <tt>:conditions</tt>
|
|
|
|
# option of the macro, if given, or +nil+ otherwise.
|
2007-01-22 14:43:50 +01:00
|
|
|
def conditions
|
2008-10-27 07:47:01 +01:00
|
|
|
@conditions ||= interpolate_sql(@reflection.sanitized_conditions) if @reflection.sanitized_conditions
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
|
|
|
alias :sql_conditions :conditions
|
2007-12-21 08:48:59 +01:00
|
|
|
|
2008-10-27 07:47:01 +01:00
|
|
|
# Resets the \loaded flag to +false+ and sets the \target to +nil+.
|
2007-01-22 14:43:50 +01:00
|
|
|
def reset
|
|
|
|
@loaded = false
|
2007-12-21 08:48:59 +01:00
|
|
|
@target = nil
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
|
|
|
|
2008-10-27 07:47:01 +01:00
|
|
|
# Reloads the \target and returns +self+ on success.
|
2007-01-22 14:43:50 +01:00
|
|
|
def reload
|
|
|
|
reset
|
|
|
|
load_target
|
2007-12-21 08:48:59 +01:00
|
|
|
self unless @target.nil?
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
|
|
|
|
2008-10-27 07:47:01 +01:00
|
|
|
# Has the \target been already \loaded?
|
2007-01-22 14:43:50 +01:00
|
|
|
def loaded?
|
|
|
|
@loaded
|
|
|
|
end
|
2007-12-21 08:48:59 +01:00
|
|
|
|
2008-10-27 07:47:01 +01:00
|
|
|
# Asserts the \target has been loaded setting the \loaded flag to +true+.
|
2007-01-22 14:43:50 +01:00
|
|
|
def loaded
|
|
|
|
@loaded = true
|
|
|
|
end
|
2007-12-21 08:48:59 +01:00
|
|
|
|
2008-10-27 07:47:01 +01:00
|
|
|
# Returns the target of this proxy, same as +proxy_target+.
|
2007-01-22 14:43:50 +01:00
|
|
|
def target
|
|
|
|
@target
|
|
|
|
end
|
2007-12-21 08:48:59 +01:00
|
|
|
|
2008-10-27 07:47:01 +01:00
|
|
|
# Sets the target of this proxy to <tt>\target</tt>, and the \loaded flag to +true+.
|
2007-01-22 14:43:50 +01:00
|
|
|
def target=(target)
|
|
|
|
@target = target
|
|
|
|
loaded
|
|
|
|
end
|
2007-12-21 08:48:59 +01:00
|
|
|
|
2008-10-27 07:47:01 +01:00
|
|
|
# Forwards the call to the target. Loads the \target if needed.
|
2007-12-21 08:48:59 +01:00
|
|
|
def inspect
|
2008-05-18 06:22:34 +02:00
|
|
|
load_target
|
2007-12-21 08:48:59 +01:00
|
|
|
@target.inspect
|
|
|
|
end
|
|
|
|
|
2008-10-27 07:47:01 +01:00
|
|
|
def send(method, *args)
|
|
|
|
if proxy_respond_to?(method)
|
|
|
|
super
|
|
|
|
else
|
|
|
|
load_target
|
|
|
|
@target.send(method, *args)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2007-01-22 14:43:50 +01:00
|
|
|
protected
|
2008-10-27 07:47:01 +01:00
|
|
|
# Does the association have a <tt>:dependent</tt> option?
|
2007-01-22 14:43:50 +01:00
|
|
|
def dependent?
|
2007-12-21 08:48:59 +01:00
|
|
|
@reflection.options[:dependent]
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
2007-12-21 08:48:59 +01:00
|
|
|
|
2008-10-27 07:47:01 +01:00
|
|
|
# Returns a string with the IDs of +records+ joined with a comma, quoted
|
|
|
|
# if needed. The result is ready to be inserted into a SQL IN clause.
|
|
|
|
#
|
|
|
|
# quoted_record_ids(records) # => "23,56,58,67"
|
|
|
|
#
|
2007-01-22 14:43:50 +01:00
|
|
|
def quoted_record_ids(records)
|
|
|
|
records.map { |record| record.quoted_id }.join(',')
|
|
|
|
end
|
|
|
|
|
|
|
|
def interpolate_sql(sql, record = nil)
|
|
|
|
@owner.send(:interpolate_sql, sql, record)
|
|
|
|
end
|
|
|
|
|
2008-10-27 07:47:01 +01:00
|
|
|
# Forwards the call to the reflection class.
|
2009-08-04 17:16:03 +02:00
|
|
|
def sanitize_sql(sql, table_name = @reflection.klass.quoted_table_name)
|
|
|
|
@reflection.klass.send(:sanitize_sql, sql, table_name)
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
|
|
|
|
2008-10-27 07:47:01 +01:00
|
|
|
# Assigns the ID of the owner to the corresponding foreign key in +record+.
|
|
|
|
# If the association is polymorphic the type of the owner is also set.
|
2007-01-22 14:43:50 +01:00
|
|
|
def set_belongs_to_association_for(record)
|
|
|
|
if @reflection.options[:as]
|
|
|
|
record["#{@reflection.options[:as]}_id"] = @owner.id unless @owner.new_record?
|
|
|
|
record["#{@reflection.options[:as]}_type"] = @owner.class.base_class.name.to_s
|
|
|
|
else
|
2009-02-04 21:26:08 +01:00
|
|
|
unless @owner.new_record?
|
|
|
|
primary_key = @reflection.options[:primary_key] || :id
|
|
|
|
record[@reflection.primary_key_name] = @owner.send(primary_key)
|
|
|
|
end
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2008-10-27 07:47:01 +01:00
|
|
|
# Merges into +options+ the ones coming from the reflection.
|
2007-01-22 14:43:50 +01:00
|
|
|
def merge_options_from_reflection!(options)
|
|
|
|
options.reverse_merge!(
|
|
|
|
:group => @reflection.options[:group],
|
2009-02-04 21:26:08 +01:00
|
|
|
:having => @reflection.options[:having],
|
2007-01-22 14:43:50 +01:00
|
|
|
:limit => @reflection.options[:limit],
|
|
|
|
:offset => @reflection.options[:offset],
|
|
|
|
:joins => @reflection.options[:joins],
|
|
|
|
:include => @reflection.options[:include],
|
2008-05-18 06:22:34 +02:00
|
|
|
:select => @reflection.options[:select],
|
|
|
|
:readonly => @reflection.options[:readonly]
|
2007-01-22 14:43:50 +01:00
|
|
|
)
|
|
|
|
end
|
2007-12-21 08:48:59 +01:00
|
|
|
|
2008-10-27 07:47:01 +01:00
|
|
|
# Forwards +with_scope+ to the reflection.
|
2008-05-18 06:22:34 +02:00
|
|
|
def with_scope(*args, &block)
|
|
|
|
@reflection.klass.send :with_scope, *args, &block
|
|
|
|
end
|
|
|
|
|
2007-01-22 14:43:50 +01:00
|
|
|
private
|
2008-10-27 07:47:01 +01:00
|
|
|
# Forwards any missing method call to the \target.
|
2008-05-18 06:22:34 +02:00
|
|
|
def method_missing(method, *args)
|
2007-12-21 08:48:59 +01:00
|
|
|
if load_target
|
2009-02-04 21:26:08 +01:00
|
|
|
unless @target.respond_to?(method)
|
|
|
|
message = "undefined method `#{method.to_s}' for \"#{@target}\":#{@target.class.to_s}"
|
|
|
|
raise NoMethodError, message
|
|
|
|
end
|
2008-10-27 07:47:01 +01:00
|
|
|
|
2008-05-18 06:22:34 +02:00
|
|
|
if block_given?
|
|
|
|
@target.send(method, *args) { |*block_args| yield(*block_args) }
|
|
|
|
else
|
|
|
|
@target.send(method, *args)
|
|
|
|
end
|
2007-02-09 09:04:31 +01:00
|
|
|
end
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
|
|
|
|
2008-10-27 07:47:01 +01:00
|
|
|
# Loads the \target if needed and returns it.
|
2008-05-18 06:22:34 +02:00
|
|
|
#
|
|
|
|
# This method is abstract in the sense that it relies on +find_target+,
|
|
|
|
# which is expected to be provided by descendants.
|
|
|
|
#
|
2008-10-27 07:47:01 +01:00
|
|
|
# If the \target is already \loaded it is just returned. Thus, you can call
|
|
|
|
# +load_target+ unconditionally to get the \target.
|
2008-05-18 06:22:34 +02:00
|
|
|
#
|
|
|
|
# ActiveRecord::RecordNotFound is rescued within the method, and it is
|
2008-10-27 07:47:01 +01:00
|
|
|
# not reraised. The proxy is \reset and +nil+ is the return value.
|
2007-01-22 14:43:50 +01:00
|
|
|
def load_target
|
2007-02-09 09:04:31 +01:00
|
|
|
return nil unless defined?(@loaded)
|
|
|
|
|
|
|
|
if !loaded? and (!@owner.new_record? || foreign_key_present)
|
|
|
|
@target = find_target
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
|
|
|
|
2007-02-09 09:04:31 +01:00
|
|
|
@loaded = true
|
|
|
|
@target
|
|
|
|
rescue ActiveRecord::RecordNotFound
|
|
|
|
reset
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
|
|
|
|
2008-10-27 07:47:01 +01:00
|
|
|
# Can be overwritten by associations that might have the foreign key
|
|
|
|
# available for an association without having the object itself (and
|
|
|
|
# still being a new record). Currently, only +belongs_to+ presents
|
|
|
|
# this scenario (both vanilla and polymorphic).
|
2007-01-22 14:43:50 +01:00
|
|
|
def foreign_key_present
|
|
|
|
false
|
|
|
|
end
|
|
|
|
|
2008-10-27 07:47:01 +01:00
|
|
|
# Raises ActiveRecord::AssociationTypeMismatch unless +record+ is of
|
|
|
|
# the kind of the class of the associated objects. Meant to be used as
|
|
|
|
# a sanity check when you are about to assign an associated record.
|
2007-01-22 14:43:50 +01:00
|
|
|
def raise_on_type_mismatch(record)
|
2008-10-27 07:47:01 +01:00
|
|
|
unless record.is_a?(@reflection.klass) || record.is_a?(@reflection.class_name.constantize)
|
2008-06-02 08:35:38 +02:00
|
|
|
message = "#{@reflection.class_name}(##{@reflection.klass.object_id}) expected, got #{record.class}(##{record.class.object_id})"
|
|
|
|
raise ActiveRecord::AssociationTypeMismatch, message
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
|
|
|
end
|
2007-02-09 09:04:31 +01:00
|
|
|
|
2008-10-27 07:47:01 +01:00
|
|
|
# Array#flatten has problems with recursive arrays. Going one level
|
|
|
|
# deeper solves the majority of the problems.
|
2007-02-09 09:04:31 +01:00
|
|
|
def flatten_deeper(array)
|
2008-10-27 07:47:01 +01:00
|
|
|
array.collect { |element| (element.respond_to?(:flatten) && !element.is_a?(Hash)) ? element.flatten : element }.flatten
|
|
|
|
end
|
|
|
|
|
|
|
|
# Returns the ID of the owner, quoted if needed.
|
|
|
|
def owner_quoted_id
|
|
|
|
@owner.quoted_id
|
2007-02-09 09:04:31 +01:00
|
|
|
end
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|