2007-01-22 14:43:50 +01:00
|
|
|
require 'set'
|
|
|
|
|
|
|
|
module ActiveRecord
|
|
|
|
module Associations
|
|
|
|
class AssociationCollection < AssociationProxy #:nodoc:
|
2008-05-18 06:22:34 +02:00
|
|
|
def initialize(owner, reflection)
|
|
|
|
super
|
|
|
|
construct_sql
|
|
|
|
end
|
|
|
|
|
|
|
|
def find(*args)
|
|
|
|
options = args.extract_options!
|
|
|
|
|
|
|
|
# If using a custom finder_sql, scan the entire collection.
|
|
|
|
if @reflection.options[:finder_sql]
|
|
|
|
expects_array = args.first.kind_of?(Array)
|
|
|
|
ids = args.flatten.compact.uniq.map(&:to_i)
|
|
|
|
|
|
|
|
if ids.size == 1
|
|
|
|
id = ids.first
|
|
|
|
record = load_target.detect { |r| id == r.id }
|
|
|
|
expects_array ? [ record ] : record
|
|
|
|
else
|
|
|
|
load_target.select { |r| ids.include?(r.id) }
|
|
|
|
end
|
|
|
|
else
|
|
|
|
conditions = "#{@finder_sql}"
|
|
|
|
if sanitized_conditions = sanitize_sql(options[:conditions])
|
|
|
|
conditions << " AND (#{sanitized_conditions})"
|
|
|
|
end
|
|
|
|
|
|
|
|
options[:conditions] = conditions
|
|
|
|
|
|
|
|
if options[:order] && @reflection.options[:order]
|
|
|
|
options[:order] = "#{options[:order]}, #{@reflection.options[:order]}"
|
|
|
|
elsif @reflection.options[:order]
|
|
|
|
options[:order] = @reflection.options[:order]
|
|
|
|
end
|
|
|
|
|
|
|
|
# Build options specific to association
|
|
|
|
construct_find_options!(options)
|
|
|
|
|
|
|
|
merge_options_from_reflection!(options)
|
|
|
|
|
|
|
|
# Pass through args exactly as we received them.
|
|
|
|
args << options
|
|
|
|
@reflection.klass.find(*args)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2008-06-02 08:35:38 +02:00
|
|
|
# Fetches the first one using SQL if possible.
|
|
|
|
def first(*args)
|
|
|
|
if fetch_first_or_last_using_find? args
|
|
|
|
find(:first, *args)
|
|
|
|
else
|
|
|
|
load_target unless loaded?
|
|
|
|
@target.first(*args)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
# Fetches the last one using SQL if possible.
|
|
|
|
def last(*args)
|
|
|
|
if fetch_first_or_last_using_find? args
|
|
|
|
find(:last, *args)
|
|
|
|
else
|
|
|
|
load_target unless loaded?
|
|
|
|
@target.last(*args)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2007-01-22 14:43:50 +01:00
|
|
|
def to_ary
|
|
|
|
load_target
|
|
|
|
@target.to_ary
|
|
|
|
end
|
2007-12-21 08:48:59 +01:00
|
|
|
|
2007-01-22 14:43:50 +01:00
|
|
|
def reset
|
2007-02-09 09:04:31 +01:00
|
|
|
reset_target!
|
2007-01-22 14:43:50 +01:00
|
|
|
@loaded = false
|
|
|
|
end
|
|
|
|
|
2008-09-07 07:54:05 +02:00
|
|
|
def build(attributes = {}, &block)
|
2008-05-18 06:22:34 +02:00
|
|
|
if attributes.is_a?(Array)
|
2008-09-07 07:54:05 +02:00
|
|
|
attributes.collect { |attr| build(attr, &block) }
|
2008-05-18 06:22:34 +02:00
|
|
|
else
|
2008-09-07 07:54:05 +02:00
|
|
|
build_record(attributes) do |record|
|
|
|
|
block.call(record) if block_given?
|
|
|
|
set_belongs_to_association_for(record)
|
|
|
|
end
|
2008-05-18 06:22:34 +02:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2007-01-22 14:43:50 +01:00
|
|
|
# Add +records+ to this association. Returns +self+ so method calls may be chained.
|
|
|
|
# Since << flattens its argument list and inserts each record, +push+ and +concat+ behave identically.
|
|
|
|
def <<(*records)
|
|
|
|
result = true
|
2007-12-21 08:48:59 +01:00
|
|
|
load_target if @owner.new_record?
|
2007-01-22 14:43:50 +01:00
|
|
|
|
|
|
|
@owner.transaction do
|
|
|
|
flatten_deeper(records).each do |record|
|
|
|
|
raise_on_type_mismatch(record)
|
2008-05-18 06:22:34 +02:00
|
|
|
add_record_to_target_with_callbacks(record) do |r|
|
|
|
|
result &&= insert_record(record) unless @owner.new_record?
|
|
|
|
end
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
|
|
|
end
|
2007-02-09 09:04:31 +01:00
|
|
|
|
2007-01-22 14:43:50 +01:00
|
|
|
result && self
|
|
|
|
end
|
|
|
|
|
|
|
|
alias_method :push, :<<
|
|
|
|
alias_method :concat, :<<
|
2007-12-21 08:48:59 +01:00
|
|
|
|
2007-01-22 14:43:50 +01:00
|
|
|
# Remove all records from this association
|
|
|
|
def delete_all
|
|
|
|
load_target
|
|
|
|
delete(@target)
|
2007-02-09 09:04:31 +01:00
|
|
|
reset_target!
|
|
|
|
end
|
2008-05-18 06:22:34 +02:00
|
|
|
|
2007-02-09 09:04:31 +01:00
|
|
|
# Calculate sum using SQL, not Enumerable
|
2008-05-18 06:22:34 +02:00
|
|
|
def sum(*args)
|
|
|
|
if block_given?
|
|
|
|
calculate(:sum, *args) { |*block_args| yield(*block_args) }
|
|
|
|
else
|
|
|
|
calculate(:sum, *args)
|
|
|
|
end
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
|
|
|
|
|
|
|
# Remove +records+ from this association. Does not destroy +records+.
|
|
|
|
def delete(*records)
|
|
|
|
records = flatten_deeper(records)
|
|
|
|
records.each { |record| raise_on_type_mismatch(record) }
|
|
|
|
|
|
|
|
@owner.transaction do
|
|
|
|
records.each { |record| callback(:before_remove, record) }
|
2008-05-18 06:22:34 +02:00
|
|
|
|
|
|
|
old_records = records.reject {|r| r.new_record? }
|
|
|
|
delete_records(old_records) if old_records.any?
|
|
|
|
|
2007-01-22 14:43:50 +01:00
|
|
|
records.each do |record|
|
|
|
|
@target.delete(record)
|
|
|
|
callback(:after_remove, record)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
# Removes all records from this association. Returns +self+ so method calls may be chained.
|
|
|
|
def clear
|
2007-12-21 08:48:59 +01:00
|
|
|
return self if length.zero? # forces load_target if it hasn't happened already
|
2007-01-22 14:43:50 +01:00
|
|
|
|
2007-12-21 08:48:59 +01:00
|
|
|
if @reflection.options[:dependent] && @reflection.options[:dependent] == :destroy
|
2007-01-22 14:43:50 +01:00
|
|
|
destroy_all
|
|
|
|
else
|
|
|
|
delete_all
|
|
|
|
end
|
|
|
|
|
|
|
|
self
|
|
|
|
end
|
|
|
|
|
|
|
|
def destroy_all
|
|
|
|
@owner.transaction do
|
|
|
|
each { |record| record.destroy }
|
|
|
|
end
|
|
|
|
|
2007-02-09 09:04:31 +01:00
|
|
|
reset_target!
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
2007-12-21 08:48:59 +01:00
|
|
|
|
|
|
|
def create(attrs = {})
|
|
|
|
if attrs.is_a?(Array)
|
|
|
|
attrs.collect { |attr| create(attr) }
|
2007-01-22 14:43:50 +01:00
|
|
|
else
|
2008-06-02 08:35:38 +02:00
|
|
|
create_record(attrs) do |record|
|
|
|
|
yield(record) if block_given?
|
|
|
|
record.save
|
|
|
|
end
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2007-12-21 08:48:59 +01:00
|
|
|
def create!(attrs = {})
|
2008-06-02 08:35:38 +02:00
|
|
|
create_record(attrs) do |record|
|
|
|
|
yield(record) if block_given?
|
|
|
|
record.save!
|
|
|
|
end
|
2007-12-21 08:48:59 +01:00
|
|
|
end
|
|
|
|
|
2007-01-22 14:43:50 +01:00
|
|
|
# Returns the size of the collection by executing a SELECT COUNT(*) query if the collection hasn't been loaded and
|
|
|
|
# calling collection.size if it has. If it's more likely than not that the collection does have a size larger than zero
|
|
|
|
# and you need to fetch that collection afterwards, it'll take one less SELECT query if you use length.
|
|
|
|
def size
|
2007-12-21 08:48:59 +01:00
|
|
|
if @owner.new_record? || (loaded? && !@reflection.options[:uniq])
|
2007-02-09 09:04:31 +01:00
|
|
|
@target.size
|
|
|
|
elsif !loaded? && !@reflection.options[:uniq] && @target.is_a?(Array)
|
2008-09-07 07:54:05 +02:00
|
|
|
unsaved_records = @target.select { |r| r.new_record? }
|
2007-02-09 09:04:31 +01:00
|
|
|
unsaved_records.size + count_records
|
|
|
|
else
|
|
|
|
count_records
|
|
|
|
end
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
2007-02-09 09:04:31 +01:00
|
|
|
|
2007-01-22 14:43:50 +01:00
|
|
|
# Returns the size of the collection by loading it and calling size on the array. If you want to use this method to check
|
|
|
|
# whether the collection is empty, use collection.length.zero? instead of collection.empty?
|
|
|
|
def length
|
|
|
|
load_target.size
|
|
|
|
end
|
2007-02-09 09:04:31 +01:00
|
|
|
|
2007-01-22 14:43:50 +01:00
|
|
|
def empty?
|
|
|
|
size.zero?
|
|
|
|
end
|
2007-02-09 09:04:31 +01:00
|
|
|
|
2008-05-18 06:22:34 +02:00
|
|
|
def any?
|
2007-12-21 08:48:59 +01:00
|
|
|
if block_given?
|
2008-05-18 06:22:34 +02:00
|
|
|
method_missing(:any?) { |*block_args| yield(*block_args) }
|
2007-12-21 08:48:59 +01:00
|
|
|
else
|
|
|
|
!empty?
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2007-01-22 14:43:50 +01:00
|
|
|
def uniq(collection = self)
|
2007-02-09 09:04:31 +01:00
|
|
|
seen = Set.new
|
|
|
|
collection.inject([]) do |kept, record|
|
|
|
|
unless seen.include?(record.id)
|
|
|
|
kept << record
|
|
|
|
seen << record.id
|
|
|
|
end
|
|
|
|
kept
|
|
|
|
end
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
|
|
|
|
|
|
|
# Replace this collection with +other_array+
|
|
|
|
# This will perform a diff and delete/add only records that have changed.
|
|
|
|
def replace(other_array)
|
|
|
|
other_array.each { |val| raise_on_type_mismatch(val) }
|
|
|
|
|
|
|
|
load_target
|
|
|
|
other = other_array.size < 100 ? other_array : other_array.to_set
|
|
|
|
current = @target.size < 100 ? @target : @target.to_set
|
|
|
|
|
|
|
|
@owner.transaction do
|
|
|
|
delete(@target.select { |v| !other.include?(v) })
|
|
|
|
concat(other_array.select { |v| !current.include?(v) })
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2008-05-18 06:22:34 +02:00
|
|
|
def include?(record)
|
|
|
|
return false unless record.is_a?(@reflection.klass)
|
|
|
|
load_target if @reflection.options[:finder_sql] && !loaded?
|
|
|
|
return @target.include?(record) if loaded?
|
|
|
|
exists?(record)
|
|
|
|
end
|
2007-12-21 08:48:59 +01:00
|
|
|
|
2007-02-09 09:04:31 +01:00
|
|
|
protected
|
2008-05-18 06:22:34 +02:00
|
|
|
def construct_find_options!(options)
|
|
|
|
end
|
|
|
|
|
|
|
|
def load_target
|
|
|
|
if !@owner.new_record? || foreign_key_present
|
|
|
|
begin
|
|
|
|
if !loaded?
|
|
|
|
if @target.is_a?(Array) && @target.any?
|
|
|
|
@target = find_target + @target.find_all {|t| t.new_record? }
|
|
|
|
else
|
|
|
|
@target = find_target
|
|
|
|
end
|
|
|
|
end
|
|
|
|
rescue ActiveRecord::RecordNotFound
|
|
|
|
reset
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
loaded if target
|
|
|
|
target
|
|
|
|
end
|
|
|
|
|
|
|
|
def method_missing(method, *args)
|
2007-12-21 08:48:59 +01:00
|
|
|
if @target.respond_to?(method) || (!@reflection.klass.respond_to?(method) && Class.respond_to?(method))
|
2008-05-18 06:22:34 +02:00
|
|
|
if block_given?
|
|
|
|
super { |*block_args| yield(*block_args) }
|
|
|
|
else
|
|
|
|
super
|
|
|
|
end
|
|
|
|
elsif @reflection.klass.scopes.include?(method)
|
|
|
|
@reflection.klass.scopes[method].call(self, *args)
|
|
|
|
else
|
|
|
|
with_scope(construct_scope) do
|
|
|
|
if block_given?
|
|
|
|
@reflection.klass.send(method, *args) { |*block_args| yield(*block_args) }
|
|
|
|
else
|
|
|
|
@reflection.klass.send(method, *args)
|
|
|
|
end
|
|
|
|
end
|
2007-12-21 08:48:59 +01:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
# overloaded in derived Association classes to provide useful scoping depending on association type.
|
|
|
|
def construct_scope
|
|
|
|
{}
|
|
|
|
end
|
|
|
|
|
2007-02-09 09:04:31 +01:00
|
|
|
def reset_target!
|
|
|
|
@target = Array.new
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
2007-02-09 09:04:31 +01:00
|
|
|
|
|
|
|
def find_target
|
|
|
|
records =
|
|
|
|
if @reflection.options[:finder_sql]
|
|
|
|
@reflection.klass.find_by_sql(@finder_sql)
|
|
|
|
else
|
|
|
|
find(:all)
|
|
|
|
end
|
|
|
|
|
|
|
|
@reflection.options[:uniq] ? uniq(records) : records
|
|
|
|
end
|
|
|
|
|
|
|
|
private
|
2007-12-21 08:48:59 +01:00
|
|
|
|
2008-05-18 06:22:34 +02:00
|
|
|
def create_record(attrs)
|
|
|
|
attrs.update(@reflection.options[:conditions]) if @reflection.options[:conditions].is_a?(Hash)
|
2007-12-21 08:48:59 +01:00
|
|
|
ensure_owner_is_not_new
|
|
|
|
record = @reflection.klass.send(:with_scope, :create => construct_scope[:create]) { @reflection.klass.new(attrs) }
|
2008-05-18 06:22:34 +02:00
|
|
|
if block_given?
|
|
|
|
add_record_to_target_with_callbacks(record) { |*block_args| yield(*block_args) }
|
|
|
|
else
|
|
|
|
add_record_to_target_with_callbacks(record)
|
|
|
|
end
|
2007-12-21 08:48:59 +01:00
|
|
|
end
|
|
|
|
|
2008-05-18 06:22:34 +02:00
|
|
|
def build_record(attrs)
|
|
|
|
attrs.update(@reflection.options[:conditions]) if @reflection.options[:conditions].is_a?(Hash)
|
2007-12-21 08:48:59 +01:00
|
|
|
record = @reflection.klass.new(attrs)
|
2008-05-18 06:22:34 +02:00
|
|
|
if block_given?
|
|
|
|
add_record_to_target_with_callbacks(record) { |*block_args| yield(*block_args) }
|
|
|
|
else
|
|
|
|
add_record_to_target_with_callbacks(record)
|
|
|
|
end
|
2007-12-21 08:48:59 +01:00
|
|
|
end
|
|
|
|
|
|
|
|
def add_record_to_target_with_callbacks(record)
|
|
|
|
callback(:before_add, record)
|
|
|
|
yield(record) if block_given?
|
|
|
|
@target ||= [] unless loaded?
|
2008-09-07 07:54:05 +02:00
|
|
|
@target << record unless @reflection.options[:uniq] && @target.include?(record)
|
2007-12-21 08:48:59 +01:00
|
|
|
callback(:after_add, record)
|
|
|
|
record
|
|
|
|
end
|
|
|
|
|
2007-01-22 14:43:50 +01:00
|
|
|
def callback(method, record)
|
|
|
|
callbacks_for(method).each do |callback|
|
2008-05-18 06:22:34 +02:00
|
|
|
ActiveSupport::Callbacks::Callback.new(method, callback, record).call(@owner, record)
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
|
|
|
end
|
2008-05-18 06:22:34 +02:00
|
|
|
|
2007-01-22 14:43:50 +01:00
|
|
|
def callbacks_for(callback_name)
|
|
|
|
full_callback_name = "#{callback_name}_for_#{@reflection.name}"
|
|
|
|
@owner.class.read_inheritable_attribute(full_callback_name.to_sym) || []
|
2007-12-21 08:48:59 +01:00
|
|
|
end
|
2007-01-22 14:43:50 +01:00
|
|
|
|
2007-12-21 08:48:59 +01:00
|
|
|
def ensure_owner_is_not_new
|
|
|
|
if @owner.new_record?
|
|
|
|
raise ActiveRecord::RecordNotSaved, "You cannot call create unless the parent is saved"
|
|
|
|
end
|
|
|
|
end
|
2008-06-02 08:35:38 +02:00
|
|
|
|
|
|
|
def fetch_first_or_last_using_find?(args)
|
|
|
|
args.first.kind_of?(Hash) || !(loaded? || @owner.new_record? || @reflection.options[:finder_sql] || !@target.blank? || args.first.kind_of?(Integer))
|
|
|
|
end
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
|
|
|
end
|
2008-05-18 06:22:34 +02:00
|
|
|
end
|