require 'set' module ActiveRecord module Associations # AssociationCollection is an abstract class that provides common stuff to # ease the implementation of association proxies that represent # collections. See the class hierarchy in AssociationProxy. # # You need to be careful with assumptions regarding the target: The proxy # does not fetch records from the database until it needs them, but new # ones created with +build+ are added to the target. So, the target may be # non-empty and still lack children waiting to be read from the database. # If you look directly to the database you cannot assume that's the entire # collection because new records may have beed added to the target, etc. # # If you need to work on all current children, new and existing records, # +load_target+ and the +loaded+ flag are your friends. class AssociationCollection < AssociationProxy #:nodoc: 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 { |arg| arg.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 # 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 def to_ary load_target if @target.is_a?(Array) @target.to_ary else Array(@target) end end def reset reset_target! @loaded = false end def build(attributes = {}, &block) if attributes.is_a?(Array) attributes.collect { |attr| build(attr, &block) } else build_record(attributes) do |record| block.call(record) if block_given? set_belongs_to_association_for(record) end end end # 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 load_target if @owner.new_record? transaction do flatten_deeper(records).each do |record| raise_on_type_mismatch(record) add_record_to_target_with_callbacks(record) do |r| result &&= insert_record(record) unless @owner.new_record? end end end result && self end alias_method :push, :<< alias_method :concat, :<< # Starts a transaction in the association class's database connection. # # class Author < ActiveRecord::Base # has_many :books # end # # Author.find(:first).books.transaction do # # same effect as calling Book.transaction # end def transaction(*args) @reflection.klass.transaction(*args) do yield end end # Remove all records from this association # # See delete for more info. def delete_all load_target delete(@target) reset_target! end # Calculate sum using SQL, not Enumerable def sum(*args) if block_given? calculate(:sum, *args) { |*block_args| yield(*block_args) } else calculate(:sum, *args) end end # Count all records using SQL. If the +:counter_sql+ option is set for the association, it will # be used for the query. If no +:counter_sql+ was supplied, but +:finder_sql+ was set, the # descendant's +construct_sql+ method will have set :counter_sql automatically. # Otherwise, construct options and pass them with scope to the target class's +count+. def count(*args) if @reflection.options[:counter_sql] @reflection.klass.count_by_sql(@counter_sql) else column_name, options = @reflection.klass.send(:construct_count_options_from_args, *args) if @reflection.options[:uniq] # This is needed because 'SELECT count(DISTINCT *)..' is not valid SQL. column_name = "#{@reflection.quoted_table_name}.#{@reflection.klass.primary_key}" if column_name == :all options.merge!(:distinct => true) end value = @reflection.klass.send(:with_scope, construct_scope) { @reflection.klass.count(column_name, options) } limit = @reflection.options[:limit] offset = @reflection.options[:offset] if limit || offset [ [value - offset.to_i, 0].max, limit.to_i ].min else value end end end # Removes +records+ from this association calling +before_remove+ and # +after_remove+ callbacks. # # This method is abstract in the sense that +delete_records+ has to be # provided by descendants. Note this method does not imply the records # are actually removed from the database, that depends precisely on # +delete_records+. They are in any case removed from the collection. def delete(*records) remove_records(records) do |records, old_records| delete_records(old_records) if old_records.any? records.each { |record| @target.delete(record) } end end # Destroy +records+ and remove them from this association calling # +before_remove+ and +after_remove+ callbacks. # # Note that this method will _always_ remove records from the database # ignoring the +:dependent+ option. def destroy(*records) records = find(records) if records.any? {|record| record.kind_of?(Fixnum) || record.kind_of?(String)} remove_records(records) do |records, old_records| old_records.each { |record| record.destroy } end load_target end # Removes all records from this association. Returns +self+ so method calls may be chained. def clear return self if length.zero? # forces load_target if it hasn't happened already if @reflection.options[:dependent] && @reflection.options[:dependent] == :destroy destroy_all else delete_all end self end # Destory all the records from this association. # # See destroy for more info. def destroy_all load_target destroy(@target).tap do reset_target! end end def create(attrs = {}) if attrs.is_a?(Array) attrs.collect { |attr| create(attr) } else create_record(attrs) do |record| yield(record) if block_given? record.save end end end def create!(attrs = {}) create_record(attrs) do |record| yield(record) if block_given? record.save! end end # 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 the collection has been already loaded +size+ and +length+ are # equivalent. If not and you are going to need the records anyway # +length+ will take one less query. Otherwise +size+ is more efficient. # # This method is abstract in the sense that it relies on # +count_records+, which is a method descendants have to provide. def size if @owner.new_record? || (loaded? && !@reflection.options[:uniq]) @target.size elsif !loaded? && @reflection.options[:group] load_target.size elsif !loaded? && !@reflection.options[:uniq] && @target.is_a?(Array) unsaved_records = @target.select { |r| r.new_record? } unsaved_records.size + count_records else count_records end end # Returns the size of the collection calling +size+ on the target. # # If the collection has been already loaded +length+ and +size+ are # equivalent. If not and you are going to need the records anyway this # method will take one less query. Otherwise +size+ is more efficient. def length load_target.size end # Equivalent to collection.size.zero?. If the collection has # not been already loaded and you are going to fetch the records anyway # it is better to check collection.length.zero?. def empty? size.zero? end def any? if block_given? method_missing(:any?) { |*block_args| yield(*block_args) } else !empty? end end def uniq(collection = self) seen = Set.new collection.inject([]) do |kept, record| unless seen.include?(record.id) kept << record seen << record.id end kept end 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 transaction do delete(@target.select { |v| !other.include?(v) }) concat(other_array.select { |v| !current.include?(v) }) end end def include?(record) return false unless record.is_a?(@reflection.klass) return include_in_memory?(record) if record.new_record? load_target if @reflection.options[:finder_sql] && !loaded? return @target.include?(record) if loaded? exists?(record) end def proxy_respond_to?(method, include_private = false) super || @reflection.klass.respond_to?(method, include_private) end protected 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.map do |f| i = @target.index(f) t = @target.delete_at(i) if i if t && t.changed? t else f.mark_for_destruction if t && t.marked_for_destruction? f end end + @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, &block) case method.to_s when 'find_or_create' return find(:first, :conditions => args.first) || create(args.first) when /^find_or_create_by_(.*)$/ rest = $1 find_args = pull_finder_args_from(DynamicFinderMatch.match(method).attribute_names, *args) return send("find_by_#{rest}", *find_args) || method_missing("create_by_#{rest}", *args, &block) when /^create_by_(.*)$/ return create($1.split('_and_').zip(args).inject({}) { |h,kv| k,v=kv ; h[k] = v ; h }, &block) end if @target.respond_to?(method) || (!@reflection.klass.respond_to?(method) && Class.respond_to?(method)) 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 end end # overloaded in derived Association classes to provide useful scoping depending on association type. def construct_scope {} end def reset_target! @target = Array.new end def find_target records = if @reflection.options[:finder_sql] @reflection.klass.find_by_sql(@finder_sql) else find(:all) end records = @reflection.options[:uniq] ? uniq(records) : records records.each do |record| set_inverse_instance(record, @owner) end records end def add_record_to_target_with_callbacks(record) callback(:before_add, record) yield(record) if block_given? @target ||= [] unless loaded? @target << record unless @reflection.options[:uniq] && @target.include?(record) callback(:after_add, record) set_inverse_instance(record, @owner) record end private # Separate the "finder" args from the "create" args given to a # find_or_create_by_ call. Returns an array with the # parameter values in the same order as the keys in the # "names" array. This code was based on code in base.rb's # method_missing method. def pull_finder_args_from(names, *args) attributes = names.collect { |name| name.intern } attribute_hash = {} args.each_with_index do |arg, i| if arg.is_a?(Hash) attribute_hash.merge! arg else attribute_hash[attributes[i]] = arg end end attribute_hash = attribute_hash.with_indifferent_access attributes.collect { |attr| attribute_hash[attr] } end def create_record(attrs) attrs.update(@reflection.options[:conditions]) if @reflection.options[:conditions].is_a?(Hash) ensure_owner_is_not_new record = @reflection.klass.send(:with_scope, :create => construct_scope[:create]) do @reflection.build_association(attrs) end if block_given? add_record_to_target_with_callbacks(record) { |*block_args| yield(*block_args) } else add_record_to_target_with_callbacks(record) end end def build_record(attrs) attrs.update(@reflection.options[:conditions]) if @reflection.options[:conditions].is_a?(Hash) record = @reflection.build_association(attrs) if block_given? add_record_to_target_with_callbacks(record) { |*block_args| yield(*block_args) } else add_record_to_target_with_callbacks(record) end end def remove_records(*records) records = flatten_deeper(records) records.each { |record| raise_on_type_mismatch(record) } transaction do records.each { |record| callback(:before_remove, record) } old_records = records.reject { |r| r.new_record? } yield(records, old_records) records.each { |record| callback(:after_remove, record) } end end def callback(method, record) callbacks_for(method).each do |callback| ActiveSupport::Callbacks::Callback.new(method, callback, record).call(@owner, record) end end def callbacks_for(callback_name) full_callback_name = "#{callback_name}_for_#{@reflection.name}" @owner.class.read_inheritable_attribute(full_callback_name.to_sym) || [] end def ensure_owner_is_not_new if @owner.new_record? raise ActiveRecord::RecordNotSaved, "You cannot call create unless the parent is saved" end end def fetch_first_or_last_using_find?(args) args.first.kind_of?(Hash) || !(loaded? || @owner.new_record? || @reflection.options[:finder_sql] || @target.any? { |record| record.new_record? } || args.first.kind_of?(Integer)) end def include_in_memory?(record) if @reflection.is_a?(ActiveRecord::Reflection::ThroughReflection) @owner.send(proxy_reflection.through_reflection.name.to_sym).each do |source| source_reflection_target = source.send(proxy_reflection.source_reflection.name) return true if source_reflection_target.respond_to?(:include?) ? source_reflection_target.include?(record) : source_reflection_target == record end false else @target.include?(record) end end end end end