activerecord 1.10.1 → 1.11.0

data/lib/active_record/acts/nested_set.rb

@@ -181,17 +181,17 @@ module ActiveRecord
                                                                
         # Returns a set of itself and all of it's nested children
         def full_set
-          self.class.find_all( "#{scope_condition} AND (#{left_col_name} BETWEEN #{self[left_col_name]} and #{self[right_col_name]})" )
+          self.class.find(:all, :conditions => "#{scope_condition} AND (#{left_col_name} BETWEEN #{self[left_col_name]} and #{self[right_col_name]})" )
         end
                   
         # Returns a set of all of it's children and nested children
         def all_children
-          self.class.find_all( "#{scope_condition} AND (#{left_col_name} > #{self[left_col_name]}) and (#{right_col_name} < #{self[right_col_name]})" )
+          self.class.find(:all, :conditions => "#{scope_condition} AND (#{left_col_name} > #{self[left_col_name]}) and (#{right_col_name} < #{self[right_col_name]})" )
         end
                                   
         # Returns a set of only this entries immediate children
         def direct_children
-          self.class.find_all( "#{scope_condition} and #{parent_column} = #{self.id}")
+          self.class.find(:all, :conditions => "#{scope_condition} and #{parent_column} = #{self.id}")
         end
                                       
         # Prunes a branch off of the tree, shifting all of the elements on the right
@@ -209,4 +209,4 @@ module ActiveRecord
       end
     end
   end
-end
+end

data/lib/active_record/acts/tree.rb

@@ -35,9 +35,26 @@ module ActiveRecord
         def acts_as_tree(options = {})
           configuration = { :foreign_key => "parent_id", :order => nil, :counter_cache => nil }
           configuration.update(options) if options.is_a?(Hash)
-          
+
           belongs_to :parent, :class_name => name, :foreign_key => configuration[:foreign_key], :counter_cache => configuration[:counter_cache]
           has_many :children, :class_name => name, :foreign_key => configuration[:foreign_key], :order => configuration[:order], :dependent => true
+
+          module_eval <<-END
+            def self.roots
+              self.find(:all, :conditions => "#{configuration[:foreign_key]} IS NULL", :order => "#{configuration[:order]}")
+            end
+            def self.root
+              self.find(:first, :conditions => "#{configuration[:foreign_key]} IS NULL", :order => "#{configuration[:order]}")
+            end
+          END
+
+          define_method(:siblings) do
+            if parent
+              self.class.find(:all, :conditions => [ "#{configuration[:foreign_key]} = ?", parent.id ], :order => configuration[:order])
+            else
+              self.class.roots
+            end
+          end
         end
       end
     end

data/lib/active_record/associations.rb

@@ -17,7 +17,7 @@ module ActiveRecord
     def clear_association_cache #:nodoc:
       self.class.reflect_on_all_associations.to_a.each do |assoc|
         instance_variable_set "@#{assoc.name}", nil
-      end
+      end unless self.new_record?
     end
     
     # Associations are a set of macro-like class methods for tying objects together through foreign keys. They express relationships like 
@@ -43,7 +43,7 @@ module ActiveRecord
     #
     # == Example
     #
-    # link:../../examples/associations.png
+    # link:files/examples/associations.png
     #
     # == Is it belongs_to or has_one?
     #
@@ -96,6 +96,30 @@ module ActiveRecord
     # * You can add an object to a collection without automatically saving it by using the #collection.build method (documented below).
     # * All unsaved (new_record? == true) members of the collection are automatically saved when the parent is saved.
     #
+    # === Association callbacks
+    #
+    # Similiar to the normal callbacks that hook into the lifecycle of an Active Record object, you can also define callbacks that get
+    # trigged when you add an object to or removing an object from a association collection. Example:
+    #
+    #   class Project
+    #     has_and_belongs_to_many :developers, :after_add => :evaluate_velocity
+    #
+    #     def evaluate_velocity(developer)
+    #       ...
+    #     end
+    #   end 
+    #
+    # It's possible to stack callbacks by passing them as an array. Example:
+    # 
+    #   class Project
+    #     has_and_belongs_to_many :developers, :after_add => [:evaluate_velocity, Proc.new { |p, d| p.shipping_date = Time.now}]
+    #   end
+    #
+    # Possible callbacks are: before_add, after_add, before_remove and after_remove.
+    #
+    # Should any of the before_add callbacks throw an exception, the object does not get added to the collection. Same with
+    # the before_remove callbacks, if an exception is thrown the object doesn't get removed.
+    #
     # == Caching
     #
     # All of the methods are built on a simple caching principle that will keep the result of the last query around unless specifically
@@ -150,7 +174,8 @@ module ActiveRecord
     # in both conditions and orders. So :order => "posts.id DESC" will work while :order => "id DESC" will not. This may require that
     # you alter the :order and :conditions on the association definitions themselves.
     #
-    # It's currently not possible to use eager loading on multiple associations from the same table.
+    # It's currently not possible to use eager loading on multiple associations from the same table. Eager loading will also not pull
+    # additional attributes on join tables, so "rich associations" with has_and_belongs_to_many is not a good fit for eager loading.
     #
     # == Modules
     #
@@ -199,6 +224,8 @@ module ActiveRecord
       # * <tt>collection<<(object, ...)</tt> - adds one or more objects to the collection by setting their foreign keys to the collection's primary key.
       # * <tt>collection.delete(object, ...)</tt> - removes one or more objects from the collection by setting their foreign keys to NULL.  
       #   This will also destroy the objects if they're declared as belongs_to and dependent on this model.
+      # * <tt>collection=objects</tt> - replaces the collections content by deleting and adding objects as appropriate.
+      # * <tt>collection_singular_ids=ids</tt> - replace the collection by the objects identified by the primary keys in +ids+
       # * <tt>collection.clear</tt> - removes every object from the collection. This does not destroy the objects.
       # * <tt>collection.empty?</tt> - returns true if there are no associated objects.
       # * <tt>collection.size</tt> - returns the number of associated objects.
@@ -214,12 +241,14 @@ module ActiveRecord
       # * <tt>Firm#clients</tt> (similar to <tt>Clients.find :all, :conditions => "firm_id = #{id}"</tt>)
       # * <tt>Firm#clients<<</tt>
       # * <tt>Firm#clients.delete</tt>
+      # * <tt>Firm#clients=</tt>
+      # * <tt>Firm#client_ids=</tt>
       # * <tt>Firm#clients.clear</tt>
       # * <tt>Firm#clients.empty?</tt> (similar to <tt>firm.clients.size == 0</tt>)
       # * <tt>Firm#clients.size</tt> (similar to <tt>Client.count "firm_id = #{id}"</tt>)
       # * <tt>Firm#clients.find</tt> (similar to <tt>Client.find(id, :conditions => "firm_id = #{id}")</tt>)
       # * <tt>Firm#clients.build</tt> (similar to <tt>Client.new("firm_id" => id)</tt>)
-      # * <tt>Firm#clients.create</tt> (similar to <tt>c = Client.new("client_id" => id); c.save; c</tt>)
+      # * <tt>Firm#clients.create</tt> (similar to <tt>c = Client.new("firm_id" => id); c.save; c</tt>)
       # The declaration can also include an options hash to specialize the behavior of the association.
       # 
       # Options are:
@@ -254,7 +283,8 @@ module ActiveRecord
       #       'WHERE ps.post_id = #{id} AND ps.person_id = p.id ' +
       #       'ORDER BY p.first_name'
       def has_many(association_id, options = {})
-        validate_options([ :foreign_key, :class_name, :exclusively_dependent, :dependent, :conditions, :order, :finder_sql, :counter_sql ], options.keys)
+        validate_options([ :foreign_key, :class_name, :exclusively_dependent, :dependent, :conditions, :order, :finder_sql, :counter_sql, 
+													 :before_add, :after_add, :before_remove, :after_remove ], options.keys)
         association_name, association_class_name, association_class_primary_key_name =
               associate_identification(association_id, options[:class_name], options[:foreign_key])
  
@@ -271,7 +301,8 @@ module ActiveRecord
         end
 
         add_multiple_associated_save_callbacks(association_name)
-
+				add_association_callbacks(association_name, options)
+				
         collection_accessor_methods(association_name, association_class_name, association_class_primary_key_name, options, HasManyAssociation)
         
         # deprecated api
@@ -299,7 +330,7 @@ module ActiveRecord
       #   with +attributes+ and linked to this object through a foreign key and that has already been saved (if it passed the validation).
       #
       # Example: An Account class declares <tt>has_one :beneficiary</tt>, which will add:
-      # * <tt>Account#beneficiary</tt> (similar to <tt>Beneficiary.find_first "account_id = #{id}"</tt>)
+      # * <tt>Account#beneficiary</tt> (similar to <tt>Beneficiary.find(:first, :conditions => "account_id = #{id}")</tt>)
       # * <tt>Account#beneficiary=(beneficiary)</tt> (similar to <tt>beneficiary.account_id = account.id; beneficiary.save</tt>)
       # * <tt>Account#beneficiary.nil?</tt>
       # * <tt>Account#build_beneficiary</tt> (similar to <tt>Beneficiary.new("account_id" => id)</tt>)
@@ -371,8 +402,8 @@ module ActiveRecord
       # * <tt>Post#author=(author)</tt> (similar to <tt>post.author_id = author.id</tt>)
       # * <tt>Post#author?</tt> (similar to <tt>post.author == some_author</tt>)
       # * <tt>Post#author.nil?</tt>
-      # * <tt>Post#build_author</tt> (similar to <tt>Author.new("post_id" => id)</tt>)
-      # * <tt>Post#create_author</tt> (similar to <tt>b = Author.new("post_id" => id); b.save; b</tt>)
+      # * <tt>Post#build_author</tt> (similar to <tt>post.author = Author.new</tt>)
+      # * <tt>Post#create_author</tt> (similar to <tt>post.author = Author.new; post.author.save; post.author</tt>)
       # The declaration can also include an options hash to specialize the behavior of the association.
       # 
       # Options are:
@@ -447,7 +478,6 @@ module ActiveRecord
       # that you want available on retrieval. Note that any fields in the join table will override matching field names
       # in the two joined tables. As a consequence, having an "id" field in the join table usually has the undesirable
       # result of clobbering the "id" fields in either of the other two tables.
-      # 
       #
       # Adds the following methods for retrieval and query.
       # +collection+ is replaced with the symbol passed as the first argument, so 
@@ -462,6 +492,8 @@ module ActiveRecord
       #   (collection.concat_with_attributes is an alias to this method).
       # * <tt>collection.delete(object, ...)</tt> - removes one or more objects from the collection by removing their associations from the join table.  
       #   This does not destroy the objects.
+      # * <tt>collection=objects</tt> - replaces the collections content by deleting and adding objects as appropriate.
+      # * <tt>collection_singular_ids=ids</tt> - replace the collection by the objects identified by the primary keys in +ids+
       # * <tt>collection.clear</tt> - removes every object from the collection. This does not destroy the objects.
       # * <tt>collection.empty?</tt> - returns true if there are no associated objects.
       # * <tt>collection.size</tt> - returns the number of associated objects.
@@ -473,6 +505,8 @@ module ActiveRecord
       # * <tt>Developer#projects<<</tt>
       # * <tt>Developer#projects.push_with_attributes</tt>
       # * <tt>Developer#projects.delete</tt>
+      # * <tt>Developer#projects=</tt>
+      # * <tt>Developer#project_ids=</tt>
       # * <tt>Developer#projects.clear</tt>
       # * <tt>Developer#projects.empty?</tt>
       # * <tt>Developer#projects.size</tt>
@@ -506,9 +540,12 @@ module ActiveRecord
       #   has_and_belongs_to_many :projects
       #   has_and_belongs_to_many :nations, :class_name => "Country"
       #   has_and_belongs_to_many :categories, :join_table => "prods_cats"
+      #   has_and_belongs_to_many :active_projects, :join_table => 'developers_projects', :delete_sql => 
+      #   'DELETE FROM developers_projects WHERE active=1 AND developer_id = #{id} AND project_id = #{record.id}'
       def has_and_belongs_to_many(association_id, options = {})
         validate_options([ :class_name, :table_name, :foreign_key, :association_foreign_key, :conditions,
-                           :join_table, :finder_sql, :delete_sql, :insert_sql, :order, :uniq ], options.keys)
+                           :join_table, :finder_sql, :delete_sql, :insert_sql, :order, :uniq, :before_add, :after_add, 
+                           :before_remove, :after_remove ], options.keys)
         association_name, association_class_name, association_class_primary_key_name =
               associate_identification(association_id, options[:class_name], options[:foreign_key])
 
@@ -522,6 +559,7 @@ module ActiveRecord
 
         before_destroy_sql = "DELETE FROM #{options[:join_table]} WHERE #{association_class_primary_key_name} = \\\#{self.quoted_id}"
         module_eval(%{before_destroy "self.connection.delete(%{#{before_destroy_sql}})"}) # "
+        add_association_callbacks(association_name, options)
         
         # deprecated api
         deprecated_collection_count_method(association_name)
@@ -631,6 +669,10 @@ module ActiveRecord
             association.replace(new_value)
             association
           end
+
+          define_method("#{Inflector.singularize(association_name)}_ids=") do |new_value|
+            send("#{association_name}=", association_class_name.constantize.find(new_value))
+          end
         end
 
         def require_association_class(class_name)
@@ -656,7 +698,7 @@ module ActiveRecord
           end
 
           module_eval do
-            after_save <<-end_eval
+            after_callback = <<-end_eval
               association = instance_variable_get("@#{association_name}")
               if association.respond_to?(:loaded?)
                 if @new_record_before_save
@@ -668,13 +710,18 @@ module ActiveRecord
                 association.send(:construct_sql)   # reconstruct the SQL queries now that we know the owner's id
               end
             end_eval
+
+            # Doesn't use after_save as that would save associations added in after_create/after_update twice
+            after_create(after_callback)
+            after_update(after_callback)
           end
         end
 
         def association_constructor_method(constructor, association_name, association_class_name, association_class_primary_key_name, options, association_proxy_class)
           define_method("#{constructor}_#{association_name}") do |*params|
-            attributees = params.first unless params.empty?
-            association = instance_variable_get("@#{association_name}")
+            attributees      = params.first unless params.empty?
+            replace_existing = params[1].nil? ? true : params[1]
+            association      = instance_variable_get("@#{association_name}")
 
             if association.nil?
               association = association_proxy_class.new(self,
@@ -683,7 +730,11 @@ module ActiveRecord
               instance_variable_set("@#{association_name}", association)
             end
 
-            association.send(constructor, attributees)
+            if association_proxy_class == HasOneAssociation
+              association.send(constructor, attributees, replace_existing)
+            else
+              association.send(constructor, attributees)
+            end
           end
         end
 
@@ -715,7 +766,7 @@ module ActiveRecord
                   next unless row[primary_key_table[reflection.table_name]]
 
                   record.send(
-                    "#{reflection.name}=", 
+                    "set_#{reflection.name}_target", 
                     reflection.klass.send(:instantiate, extract_record(schema_abbreviations, reflection.table_name, row))
                   )
               end
@@ -770,11 +821,21 @@ module ActiveRecord
           sql << reflections.collect { |reflection| association_join(reflection) }.to_s
           sql << "#{options[:joins]} " if options[:joins]
           add_conditions!(sql, options[:conditions])
+          add_sti_conditions!(sql, reflections)
           sql << "ORDER BY #{options[:order]} " if options[:order]
           
           return sanitize_sql(sql)
         end
 
+        def add_sti_conditions!(sql, reflections)
+          sti_sql = ""
+          reflections.each do |reflection|
+            sti_sql << " AND #{reflection.klass.send(:type_condition)}" unless reflection.klass.descends_from_active_record?
+          end
+          sti_sql.sub!(/AND/, "WHERE") unless sql =~ /where/i
+          sql << sti_sql
+        end
+
         def column_aliases(schema_abbreviations)
           schema_abbreviations.collect { |cn, tc| "#{tc.join(".")} AS #{cn}" }.join(", ")
         end
@@ -786,7 +847,7 @@ module ActiveRecord
               "#{reflection.options[:join_table]}.#{reflection.options[:foreign_key] || table_name.classify.foreign_key} = " +
               "#{table_name}.#{primary_key} " +
               " LEFT OUTER JOIN #{reflection.klass.table_name} ON " +
-              "#{reflection.options[:join_table]}.#{reflection.options[:associated_foreign_key] || reflection.klass.table_name.classify.foreign_key} = " +
+              "#{reflection.options[:join_table]}.#{reflection.options[:association_foreign_key] || reflection.klass.table_name.classify.foreign_key} = " +
               "#{reflection.klass.table_name}.#{reflection.klass.primary_key} "
             when :has_many, :has_one
               " LEFT OUTER JOIN #{reflection.klass.table_name} ON " +
@@ -801,6 +862,18 @@ module ActiveRecord
           end          
         end
 
+        def add_association_callbacks(association_name, options)
+        	callbacks = %w(before_add after_add before_remove after_remove)
+        	callbacks.each do |callback_name|
+        	  full_callback_name = "#{callback_name.to_s}_for_#{association_name.to_s}"
+        	  defined_callbacks = options[callback_name.to_sym]
+        	  if options.has_key?(callback_name.to_sym)
+        	    callback_array = defined_callbacks.kind_of?(Array) ? defined_callbacks : [defined_callbacks]
+        	    class_inheritable_reader full_callback_name.to_sym
+              write_inheritable_array(full_callback_name.to_sym, callback_array)
+        	  end
+        	end
+        end
 
         def extract_record(schema_abbreviations, table_name, row)
           record = {}

data/lib/active_record/associations/association_collection.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 module ActiveRecord
   module Associations
     class AssociationCollection < AssociationProxy #:nodoc:
@@ -19,11 +21,13 @@ module ActiveRecord
         @owner.transaction do
           flatten_deeper(records).each do |record|
             raise_on_type_mismatch(record)
+            callback(:before_add, record)
             result &&= insert_record(record) unless @owner.new_record?
             @target << record
+            callback(:after_add, record)
           end
         end
-
+				
         result and self
       end
 
@@ -38,8 +42,12 @@ module ActiveRecord
         return if records.empty?
         
         @owner.transaction do
+          records.each { |record| callback(:before_remove, record) }
           delete_records(records)
-          records.each { |record| @target.delete(record) }
+          records.each do |record|
+            @target.delete(record)
+            callback(:after_remove, record)
+          end
         end
       end
       
@@ -83,11 +91,19 @@ module ActiveRecord
         collection.inject([]) { |uniq_records, record| uniq_records << record unless uniq_records.include?(record); uniq_records }
       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) }
+        other_array.each { |val| raise_on_type_mismatch(val) }
 
-        @target = other_array
-        @loaded = true
+        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
 
       private
@@ -103,6 +119,29 @@ module ActiveRecord
         def flatten_deeper(array)
           array.collect { |element| element.respond_to?(:flatten) ? element.flatten : element }.flatten
         end
+        
+        def callback(method, record)
+          callbacks_for(method).each do |callback|
+            case callback
+              when Symbol
+                @owner.send(callback, record)
+              when Proc, Method
+                callback.call(@owner, record)
+              else
+                if callback.respond_to?(method)
+                  callback.send(method, @owner, record)
+                else
+                  raise ActiveRecordError, "Callbacks must be a symbol denoting the method to call, a string to be evaluated, a block to be invoked, or an object responding to the callback method."
+                end
+            end
+          end
+        end
+        
+        def callbacks_for(callback_name)
+          full_callback_name = "#{callback_name.to_s}_for_#{@association_name.to_s}"
+          @owner.class.read_inheritable_attribute(full_callback_name.to_sym) or []
+        end
+        
     end
   end
 end

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -66,7 +66,7 @@ module ActiveRecord
         # Otherwise, construct a query.
         else
           ids_list = ids.map { |id| @owner.send(:quote, id) }.join(',')
-          records = find_target(@finder_sql.sub(/(ORDER BY|$)/, "AND j.#{@association_foreign_key} IN (#{ids_list}) \\1"))
+          records = find_target(@finder_sql.sub(/(ORDER BY|$)/, " AND j.#{@association_foreign_key} IN (#{ids_list}) \\1"))
           if records.size == ids.size
             if ids.size == 1 and !expects_array
               records.first
@@ -82,8 +82,10 @@ module ActiveRecord
       def push_with_attributes(record, join_attributes = {})
         raise_on_type_mismatch(record)
         join_attributes.each { |key, value| record[key.to_s] = value }
+        callback(:before_add, record)
         insert_record(record) unless @owner.new_record?
         @target << record
+        callback(:after_add, record)
         self
       end
       
@@ -104,7 +106,9 @@ module ActiveRecord
         end
 
         def insert_record(record)
-          return false unless record.save
+          if record.new_record?
+            return false unless record.save
+          end
 
           if @options[:insert_sql]
             @owner.connection.execute(interpolate_sql(@options[:insert_sql], record))
@@ -136,7 +140,7 @@ module ActiveRecord
         
         def delete_records(records)
           if sql = @options[:delete_sql]
-            records.each { |record| @owner.connection.execute(sql) }
+            records.each { |record| @owner.connection.execute(interpolate_sql(sql, record)) }
           else
             ids = quoted_record_ids(records)
             sql = "DELETE FROM #{@join_table} WHERE #{@association_class_primary_key_name} = #{@owner.quoted_id} AND #{@association_foreign_key} IN (#{ids})"
@@ -145,7 +149,7 @@ module ActiveRecord
         end
 
         def construct_sql
-          interpolate_sql_options!(@options, :finder_sql, :delete_sql)
+          interpolate_sql_options!(@options, :finder_sql)
           
           if @options[:finder_sql]
             @finder_sql = @options[:finder_sql]
@@ -156,6 +160,15 @@ module ActiveRecord
               "j.#{@association_class_primary_key_name} = #{@owner.quoted_id} "
             
             @finder_sql << " AND #{interpolate_sql(@options[:conditions])}" if @options[:conditions]
+
+            unless @association_class.descends_from_active_record?
+              type_condition = @association_class.send(:subclasses).inject("t.#{@association_class.inheritance_column} = '#{@association_class.name.demodulize}' ") do |condition, subclass| 
+                condition << "OR t.#{@association_class.inheritance_column} = '#{subclass.name.demodulize}' "
+              end
+
+              @finder_sql << " AND (#{type_condition})"
+            end
+	
             @finder_sql << " ORDER BY #{@order}" if @order
           end
         end