activerecord 1.14.4 → 1.15.0

data/lib/active_record/associations/association_collection.rb

@@ -9,7 +9,7 @@ module ActiveRecord
       end
   
       def reset
-        @target = []
+        reset_target!
         @loaded = false
       end
 
@@ -28,7 +28,7 @@ module ActiveRecord
             callback(:after_add, record)
           end
         end
-				
+
         result && self
       end
 
@@ -39,7 +39,12 @@ module ActiveRecord
       def delete_all
         load_target
         delete(@target)
-        @target = []
+        reset_target!
+      end
+
+      # Calculate sum using SQL, not Enumerable
+      def sum(*args, &block)
+        calculate(:sum, *args, &block)
       end
 
       # Remove +records+ from this association.  Does not destroy +records+.
@@ -77,9 +82,9 @@ module ActiveRecord
           each { |record| record.destroy }
         end
 
-        @target = []
+        reset_target!
       end
-      
+
       def create(attributes = {})
         # Can't use Base.create since the foreign key may be a protected attribute.
         if attributes.is_a?(Array)
@@ -95,21 +100,35 @@ module ActiveRecord
       # 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
-        if loaded? then @target.size else count_records end
+        if loaded? && !@reflection.options[:uniq]
+          @target.size
+        elsif !loaded? && !@reflection.options[:uniq] && @target.is_a?(Array)
+          unsaved_records = Array(@target.detect { |r| r.new_record? })
+          unsaved_records.size + count_records
+        else
+          count_records
+        end
       end
-      
+
       # 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
-      
+
       def empty?
         size.zero?
       end
-      
+
       def uniq(collection = self)
-        collection.inject([]) { |uniq_records, record| uniq_records << record unless uniq_records.include?(record); uniq_records }
+        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+
@@ -127,12 +146,23 @@ module ActiveRecord
         end
       end
 
-      private
-        # Array#flatten has problems with recursive arrays. Going one level deeper solves the majority of the problems.
-        def flatten_deeper(array)
-          array.collect { |element| element.respond_to?(:flatten) ? element.flatten : element }.flatten
+      protected
+        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
+
+          @reflection.options[:uniq] ? uniq(records) : records
+        end
+
+      private
         def callback(method, record)
           callbacks_for(method).each do |callback|
             case callback

data/lib/active_record/associations/association_proxy.rb

@@ -4,14 +4,27 @@ module ActiveRecord
       attr_reader :reflection
       alias_method :proxy_respond_to?, :respond_to?
       alias_method :proxy_extend, :extend
-      instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?|^proxy_respond_to\?|^proxy_extend|^send)/ }
+      delegate :to_param, :to => :proxy_target
+      instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_)/ }
 
       def initialize(owner, reflection)
         @owner, @reflection = owner, reflection
-        proxy_extend(reflection.options[:extend]) if reflection.options[:extend]
+        Array(reflection.options[:extend]).each { |ext| proxy_extend(ext) }
         reset
       end
       
+      def proxy_owner
+        @owner
+      end
+      
+      def proxy_reflection
+        @reflection
+      end
+      
+      def proxy_target
+        @target
+      end
+
       def respond_to?(symbol, include_priv = false)
         proxy_respond_to?(symbol, include_priv) || (load_target && @target.respond_to?(symbol, include_priv))
       end
@@ -28,7 +41,7 @@ module ActiveRecord
       end
       
       def conditions
-        @conditions ||= eval("%(#{@reflection.active_record.send :sanitize_sql, @reflection.options[:conditions]})") if @reflection.options[:conditions]
+        @conditions ||= interpolate_sql(sanitize_sql(@reflection.options[:conditions])) if @reflection.options[:conditions]
       end
       alias :sql_conditions :conditions
       
@@ -106,21 +119,22 @@ module ActiveRecord
         
       private
         def method_missing(method, *args, &block)
-          load_target
-          @target.send(method, *args, &block)
+          if load_target        
+            @target.send(method, *args, &block)
+          end
         end
 
         def load_target
-          if !@owner.new_record? || foreign_key_present
-            begin
-              @target = find_target if !loaded?
-            rescue ActiveRecord::RecordNotFound
-              reset
-            end
+          return nil unless defined?(@loaded)
+
+          if !loaded? and (!@owner.new_record? || foreign_key_present)
+            @target = find_target
           end
 
-          loaded if target
-          target
+          @loaded = true
+          @target
+        rescue ActiveRecord::RecordNotFound
+          reset
         end
 
         # Can be overwritten by associations that might have the foreign key available for an association without
@@ -134,6 +148,11 @@ module ActiveRecord
             raise ActiveRecord::AssociationTypeMismatch, "#{@reflection.class_name} expected, got #{record.class}"
           end
         end
+
+        # Array#flatten has problems with recursive arrays. Going one level deeper solves the majority of the problems.
+        def flatten_deeper(array)
+          array.collect { |element| element.respond_to?(:flatten) ? element.flatten : element }.flatten
+        end
     end
   end
 end

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -13,6 +13,17 @@ module ActiveRecord
         record
       end
 
+      def create(attributes = {})
+        # Can't use Base.create since the foreign key may be a protected attribute.
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create(attr) }
+        else
+          record = build(attributes)
+          insert_record(record) unless @owner.new_record?
+          record
+        end
+      end
+
       def find_first
         load_target.first
       end
@@ -56,7 +67,9 @@ module ActiveRecord
           @reflection.klass.find(*args)
         end
       end      
-
+      
+      # Deprecated as of Rails 1.2.   If your associations require attributes
+      # you should be using has_many :through
       def push_with_attributes(record, join_attributes = {})
         raise_on_type_mismatch(record)
         join_attributes.each { |key, value| record[key.to_s] = value }
@@ -68,13 +81,10 @@ module ActiveRecord
 
         self
       end
-      
+      deprecate :push_with_attributes => "consider using has_many :through instead"
+
       alias :concat_with_attributes :push_with_attributes
 
-      def size
-        @reflection.options[:uniq] ? count_records : super
-      end
-      
       protected
         def method_missing(method, *args, &block)
           if @target.respond_to?(method) || (!@reflection.klass.respond_to?(method) && Class.respond_to?(method))
@@ -85,17 +95,7 @@ module ActiveRecord
             end
           end
         end
-            
-        def find_target
-          if @reflection.options[:finder_sql]
-            records = @reflection.klass.find_by_sql(@finder_sql)
-          else
-            records = find(:all)
-          end
-          
-          @reflection.options[:uniq] ? uniq(records) : records
-        end
-        
+
         def count_records
           load_target.size
         end
@@ -118,7 +118,7 @@ module ActiveRecord
                   attributes[column.name] = record.quoted_id
                 else
                   if record.attributes.has_key?(column.name)
-                    value = @owner.send(:quote, record[column.name], column)
+                    value = @owner.send(:quote_value, record[column.name], column)
                     attributes[column.name] = value unless value.nil?
                   end
               end

data/lib/active_record/associations/has_many_association.rb

@@ -10,10 +10,12 @@ module ActiveRecord
         if attributes.is_a?(Array)
           attributes.collect { |attr| build(attr) }
         else
-          load_target
           record = @reflection.klass.new(attributes)
           set_belongs_to_association_for(record)
+          
+          @target ||= [] unless loaded?
           @target << record
+          
           record
         end
       end
@@ -29,22 +31,28 @@ module ActiveRecord
           @reflection.klass.find_all(conditions, orderings, limit, joins)
         end
       end
+      deprecate :find_all => "use find(:all, ...) instead"
 
       # DEPRECATED. Find the first associated record.  All arguments are optional.
       def find_first(conditions = nil, orderings = nil)
         find_all(conditions, orderings, 1).first
       end
+      deprecate :find_first => "use find(:first, ...) instead"
 
       # Count the number of associated records. All arguments are optional.
-      def count(runtime_conditions = nil)
+      def count(*args)
         if @reflection.options[:counter_sql]
           @reflection.klass.count_by_sql(@counter_sql)
         elsif @reflection.options[:finder_sql]
           @reflection.klass.count_by_sql(@finder_sql)
         else
-          sql = @finder_sql
-          sql += " AND (#{sanitize_sql(runtime_conditions)})" if runtime_conditions
-          @reflection.klass.count(sql)
+          column_name, options = @reflection.klass.send(:construct_count_options_from_legacy_args, *args)          
+          options[:conditions] = options[:conditions].nil? ?
+            @finder_sql :
+            @finder_sql + " AND (#{sanitize_sql(options[:conditions])})"
+          options[:include] = @reflection.options[:include]
+
+          @reflection.klass.count(column_name, options)
         end
       end
 
@@ -83,33 +91,45 @@ module ActiveRecord
           @reflection.klass.find(*args)
         end
       end
-      
+
       protected
         def method_missing(method, *args, &block)
           if @target.respond_to?(method) || (!@reflection.klass.respond_to?(method) && Class.respond_to?(method))
             super
           else
+            create_scoping = {}
+            set_belongs_to_association_for(create_scoping)
+
             @reflection.klass.with_scope(
+              :create => create_scoping,
               :find => {
                 :conditions => @finder_sql, 
                 :joins      => @join_sql, 
                 :readonly   => false
-              },
-              :create => {
-                @reflection.primary_key_name => @owner.id
               }
             ) do
               @reflection.klass.send(method, *args, &block)
             end
           end
         end
-            
-        def find_target
-          if @reflection.options[:finder_sql]
-            @reflection.klass.find_by_sql(@finder_sql)
-          else
-            find(:all)
+
+        def load_target
+          if !@owner.new_record? || foreign_key_present
+            begin
+              if !loaded?
+                if @target.is_a?(Array) && @target.any?
+                  @target = (find_target + @target).uniq
+                else
+                  @target = find_target
+                end
+              end
+            rescue ActiveRecord::RecordNotFound
+              reset
+            end
           end
+
+          loaded if target
+          target
         end
 
         def count_records
@@ -118,7 +138,7 @@ module ActiveRecord
           elsif @reflection.options[:counter_sql]
             @reflection.klass.count_by_sql(@counter_sql)
           else
-            @reflection.klass.count(@counter_sql)
+            @reflection.klass.count(:conditions => @counter_sql)
           end
           
           @target = [] and loaded if count == 0
@@ -167,7 +187,7 @@ module ActiveRecord
             when @reflection.options[:as]
               @finder_sql = 
                 "#{@reflection.klass.table_name}.#{@reflection.options[:as]}_id = #{@owner.quoted_id} AND " + 
-                "#{@reflection.klass.table_name}.#{@reflection.options[:as]}_type = #{@owner.class.quote @owner.class.base_class.name.to_s}"
+                "#{@reflection.klass.table_name}.#{@reflection.options[:as]}_type = #{@owner.class.quote_value(@owner.class.base_class.name.to_s)}"
               @finder_sql << " AND (#{conditions})" if conditions
             
             else

data/lib/active_record/associations/has_many_through_association.rb

@@ -8,7 +8,6 @@ module ActiveRecord
         construct_sql
       end
 
-
       def find(*args)
         options = Base.send(:extract_options_from_args!, args)
 
@@ -23,12 +22,12 @@ module ActiveRecord
         elsif @reflection.options[:order]
           options[:order] = @reflection.options[:order]
         end
-        
+
         options[:select]  = construct_select(options[:select])
         options[:from]  ||= construct_from
         options[:joins]   = construct_joins(options[:joins])
         options[:include] = @reflection.source_reflection.options[:include] if options[:include].nil?
-        
+
         merge_options_from_reflection!(options)
 
         # Pass through args exactly as we received them.
@@ -41,6 +40,68 @@ module ActiveRecord
         @loaded = false
       end
 
+      # Adds records to the association. The source record and its associates
+      # must have ids in order to create records associating them, so this
+      # will raise ActiveRecord::HasManyThroughCantAssociateNewRecords if
+      # either is a new record.  Calls create! so you can rescue errors.
+      #
+      # The :before_add and :after_add callbacks are not yet supported.
+      def <<(*records)
+        return if records.empty?
+        through = @reflection.through_reflection
+        raise ActiveRecord::HasManyThroughCantAssociateNewRecords.new(@owner, through) if @owner.new_record?
+
+        load_target
+
+        klass = through.klass
+        klass.transaction do
+          flatten_deeper(records).each do |associate|
+            raise_on_type_mismatch(associate)
+            raise ActiveRecord::HasManyThroughCantAssociateNewRecords.new(@owner, through) unless associate.respond_to?(:new_record?) && !associate.new_record?
+
+            @owner.send(@reflection.through_reflection.name).proxy_target << klass.with_scope(:create => construct_join_attributes(associate)) { klass.create! }
+            @target << associate
+          end
+        end
+
+        self
+      end
+
+      [:push, :concat].each { |method| alias_method method, :<< }
+
+      # Remove +records+ from this association.  Does not destroy +records+.
+      def delete(*records)
+        records = flatten_deeper(records)
+        records.each { |associate| raise_on_type_mismatch(associate) }
+        records.reject! { |associate| @target.delete(associate) if associate.new_record? }
+        return if records.empty?
+        
+        @delete_join_finder ||= "find_all_by_#{@reflection.source_reflection.association_foreign_key}"
+        through = @reflection.through_reflection
+        through.klass.transaction do
+          records.each do |associate|
+            joins = @owner.send(through.name).send(@delete_join_finder, associate.id)
+            @owner.send(through.name).delete(joins)
+            @target.delete(associate)
+          end
+        end
+      end
+
+      def build(attrs = nil)
+        raise ActiveRecord::HasManyThroughCantAssociateNewRecords.new(@owner, @reflection.through_reflection)
+      end
+
+      def create!(attrs = nil)
+        @reflection.klass.transaction do
+          self << @reflection.klass.with_scope(:create => attrs) { @reflection.klass.create! }
+        end
+      end
+
+      # Calculate sum using SQL, not Enumerable
+      def sum(*args, &block)
+        calculate(:sum, *args, &block)
+      end
+
       protected
         def method_missing(method, *args, &block)
           if @target.respond_to?(method) || (!@reflection.klass.respond_to?(method) && Class.respond_to?(method))
@@ -49,41 +110,68 @@ module ActiveRecord
             @reflection.klass.with_scope(construct_scope) { @reflection.klass.send(method, *args, &block) }
           end
         end
-            
+
         def find_target
-          @reflection.klass.find(:all, 
+          records = @reflection.klass.find(:all,
             :select     => construct_select,
             :conditions => construct_conditions,
             :from       => construct_from,
             :joins      => construct_joins,
-            :order      => @reflection.options[:order], 
+            :order      => @reflection.options[:order],
             :limit      => @reflection.options[:limit],
             :group      => @reflection.options[:group],
             :include    => @reflection.options[:include] || @reflection.source_reflection.options[:include]
           )
+
+          @reflection.options[:uniq] ? records.to_set.to_a : records
         end
 
-        def construct_conditions
-          conditions = if @reflection.through_reflection.options[:as]
-              "#{@reflection.through_reflection.table_name}.#{@reflection.through_reflection.options[:as]}_id = #{@owner.quoted_id} " + 
-              "AND #{@reflection.through_reflection.table_name}.#{@reflection.through_reflection.options[:as]}_type = #{@owner.class.quote @owner.class.base_class.name.to_s}"
+        # Construct attributes for associate pointing to owner.
+        def construct_owner_attributes(reflection)
+          if as = reflection.options[:as]
+            { "#{as}_id" => @owner.id,
+              "#{as}_type" => @owner.class.base_class.name.to_s }
           else
-            "#{@reflection.through_reflection.table_name}.#{@reflection.through_reflection.primary_key_name} = #{@owner.quoted_id}"
+            { reflection.primary_key_name => @owner.id }
+          end
+        end
+
+        # Construct attributes for :through pointing to owner and associate.
+        def construct_join_attributes(associate)
+          construct_owner_attributes(@reflection.through_reflection).merge(@reflection.source_reflection.association_foreign_key => associate.id)
+        end
+
+        # Associate attributes pointing to owner, quoted.
+        def construct_quoted_owner_attributes(reflection)
+          if as = reflection.options[:as]
+            { "#{as}_id" => @owner.quoted_id,
+              "#{as}_type" => reflection.klass.quote_value(
+                @owner.class.base_class.name.to_s,
+                reflection.klass.columns_hash["#{as}_type"]) }
+          else
+            { reflection.primary_key_name => @owner.quoted_id }
+          end
+        end
+
+        # Build SQL conditions from attributes, qualified by table name.
+        def construct_conditions
+          table_name = @reflection.through_reflection.table_name
+          conditions = construct_quoted_owner_attributes(@reflection.through_reflection).map do |attr, value|
+            "#{table_name}.#{attr} = #{value}"
           end
-          conditions << " AND (#{sql_conditions})" if sql_conditions
-          
-          return conditions
+          conditions << sql_conditions if sql_conditions
+          "(" + conditions.join(') AND (') + ")"
         end
 
         def construct_from
           @reflection.table_name
         end
-        
+
         def construct_select(custom_select = nil)
-          selected = custom_select || @reflection.options[:select] || "#{@reflection.table_name}.*"          
+          selected = custom_select || @reflection.options[:select] || "#{@reflection.table_name}.*"
         end
-        
-        def construct_joins(custom_joins = nil)          
+
+        def construct_joins(custom_joins = nil)
           polymorphic_join = nil
           if @reflection.through_reflection.options[:as] || @reflection.source_reflection.macro == :belongs_to
             reflection_primary_key = @reflection.klass.primary_key
@@ -94,7 +182,7 @@ module ActiveRecord
             if @reflection.source_reflection.options[:as]
               polymorphic_join = "AND %s.%s = %s" % [
                 @reflection.table_name, "#{@reflection.source_reflection.options[:as]}_type",
-                @owner.class.quote(@reflection.through_reflection.klass.name)
+                @owner.class.quote_value(@reflection.through_reflection.klass.name)
               ]
             end
           end
@@ -106,14 +194,15 @@ module ActiveRecord
             polymorphic_join
           ]
         end
-        
+
         def construct_scope
-          {
-            :find   => { :from => construct_from, :conditions => construct_conditions, :joins => construct_joins, :select => construct_select },
-            :create => { @reflection.primary_key_name => @owner.id }
-          }
+          { :create => construct_owner_attributes(@reflection),
+            :find   => { :from        => construct_from,
+                         :conditions  => construct_conditions,
+                         :joins       => construct_joins,
+                         :select      => construct_select } }
         end
-        
+
         def construct_sql
           case
             when @reflection.options[:finder_sql]
@@ -133,14 +222,15 @@ module ActiveRecord
             @counter_sql = @finder_sql
           end
         end
-        
+
         def conditions
           @conditions ||= [
-            (interpolate_sql(@reflection.active_record.send(:sanitize_sql, @reflection.options[:conditions])) if @reflection.options[:conditions]),
-            (interpolate_sql(@reflection.active_record.send(:sanitize_sql, @reflection.through_reflection.options[:conditions])) if @reflection.through_reflection.options[:conditions])
-          ].compact.collect { |condition| "(#{condition})" }.join(' AND ') unless (!@reflection.options[:conditions] && !@reflection.through_reflection.options[:conditions])
+            (interpolate_sql(@reflection.klass.send(:sanitize_sql, @reflection.options[:conditions])) if @reflection.options[:conditions]),
+            (interpolate_sql(@reflection.active_record.send(:sanitize_sql, @reflection.through_reflection.options[:conditions])) if @reflection.through_reflection.options[:conditions]),
+            ("#{@reflection.through_reflection.table_name}.#{@reflection.through_reflection.klass.inheritance_column} = #{@reflection.klass.quote_value(@reflection.through_reflection.klass.name.demodulize)}" unless @reflection.through_reflection.klass.descends_from_active_record?)
+          ].compact.collect { |condition| "(#{condition})" }.join(' AND ') unless (!@reflection.options[:conditions] && !@reflection.through_reflection.options[:conditions] && @reflection.through_reflection.klass.descends_from_active_record?)
         end
-        
+
         alias_method :sql_conditions, :conditions
     end
   end