activerecord 1.13.2 → 1.14.0

data/lib/active_record/associations/has_many_association.rb

@@ -1,20 +1,18 @@
 module ActiveRecord
   module Associations
     class HasManyAssociation < AssociationCollection #:nodoc:
-      def initialize(owner, association_name, association_class_name, association_class_primary_key_name, options)
+      def initialize(owner, reflection)
         super
-        @conditions = sanitize_sql(options[:conditions])
-
         construct_sql
       end
 
       def build(attributes = {})
         if attributes.is_a?(Array)
-          attributes.collect { |attr| create(attr) }
+          attributes.collect { |attr| build(attr) }
         else
           load_target
-          record = @association_class.new(attributes)
-          record[@association_class_primary_key_name] = @owner.id unless @owner.new_record?
+          record = @reflection.klass.new(attributes)
+          set_belongs_to_association_for(record)
           @target << record
           record
         end
@@ -22,13 +20,13 @@ module ActiveRecord
 
       # DEPRECATED.
       def find_all(runtime_conditions = nil, orderings = nil, limit = nil, joins = nil)
-        if @options[:finder_sql]
-          @association_class.find_by_sql(@finder_sql)
+        if @reflection.options[:finder_sql]
+          @reflection.klass.find_by_sql(@finder_sql)
         else
           conditions = @finder_sql
           conditions += " AND (#{sanitize_sql(runtime_conditions)})" if runtime_conditions
-          orderings ||= @options[:order]
-          @association_class.find_all(conditions, orderings, limit, joins)
+          orderings ||= @reflection.options[:order]
+          @reflection.klass.find_all(conditions, orderings, limit, joins)
         end
       end
 
@@ -39,14 +37,14 @@ module ActiveRecord
 
       # Count the number of associated records. All arguments are optional.
       def count(runtime_conditions = nil)
-        if @options[:counter_sql]
-          @association_class.count_by_sql(@counter_sql)
-        elsif @options[:finder_sql]
-          @association_class.count_by_sql(@finder_sql)
+        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
-          @association_class.count(sql)
+          @reflection.klass.count(sql)
         end
       end
 
@@ -54,7 +52,7 @@ module ActiveRecord
         options = Base.send(:extract_options_from_args!, args)
 
         # If using a custom finder_sql, scan the entire collection.
-        if @options[:finder_sql]
+        if @reflection.options[:finder_sql]
           expects_array = args.first.kind_of?(Array)
           ids = args.flatten.compact.uniq
 
@@ -72,64 +70,63 @@ module ActiveRecord
           end
           options[:conditions] = conditions
 
-          if options[:order] && @options[:order]
-            options[:order] = "#{options[:order]}, #{@options[:order]}"
-          elsif @options[:order]
-            options[:order] = @options[:order]
+          if options[:order] && @reflection.options[:order]
+            options[:order] = "#{options[:order]}, #{@reflection.options[:order]}"
+          elsif @reflection.options[:order]
+            options[:order] = @reflection.options[:order]
           end
 
+          merge_options_from_reflection!(options)
+
           # Pass through args exactly as we received them.
           args << options
-          @association_class.find(*args)
+          @reflection.klass.find(*args)
         end
       end
       
       protected
         def method_missing(method, *args, &block)
-          if @target.respond_to?(method) || (!@association_class.respond_to?(method) && Class.respond_to?(method))
+          if @target.respond_to?(method) || (!@reflection.klass.respond_to?(method) && Class.respond_to?(method))
             super
           else
-            @association_class.with_scope(
+            @reflection.klass.with_scope(
               :find => {
                 :conditions => @finder_sql, 
                 :joins      => @join_sql, 
                 :readonly   => false
               },
               :create => {
-                @association_class_primary_key_name => @owner.id
+                @reflection.primary_key_name => @owner.id
               }
             ) do
-              @association_class.send(method, *args, &block)
+              @reflection.klass.send(method, *args, &block)
             end
           end
         end
             
         def find_target
-          if @options[:finder_sql]
-            @association_class.find_by_sql(@finder_sql)
+          if @reflection.options[:finder_sql]
+            @reflection.klass.find_by_sql(@finder_sql)
           else
-            @association_class.find(:all, 
-              :conditions => @finder_sql,
-              :order      => @options[:order], 
-              :limit      => @options[:limit],
-              :joins      => @options[:joins],
-              :include    => @options[:include],
-              :group      => @options[:group]
-            )
+            find(:all)
           end
         end
 
         def count_records
           count = if has_cached_counter?
             @owner.send(:read_attribute, cached_counter_attribute_name)
-          elsif @options[:counter_sql]
-            @association_class.count_by_sql(@counter_sql)
+          elsif @reflection.options[:counter_sql]
+            @reflection.klass.count_by_sql(@counter_sql)
           else
-            @association_class.count(@counter_sql)
+            @reflection.klass.count(@counter_sql)
           end
           
           @target = [] and loaded if count == 0
           
+          if @reflection.options[:limit]
+            count = [ @reflection.options[:limit], count ].min
+          end
+          
           return count
         end
 
@@ -138,22 +135,22 @@ module ActiveRecord
         end
 
         def cached_counter_attribute_name
-          "#{@association_name}_count"
+          "#{@reflection.name}_count"
         end
 
         def insert_record(record)
-          record[@association_class_primary_key_name] = @owner.id
+          set_belongs_to_association_for(record)
           record.save
         end
 
         def delete_records(records)
-          if @options[:dependent]
+          if @reflection.options[:dependent]
             records.each { |r| r.destroy }
           else
             ids = quoted_record_ids(records)
-            @association_class.update_all(
-              "#{@association_class_primary_key_name} = NULL", 
-              "#{@association_class_primary_key_name} = #{@owner.quoted_id} AND #{@association_class.primary_key} IN (#{ids})"
+            @reflection.klass.update_all(
+              "#{@reflection.primary_key_name} = NULL", 
+              "#{@reflection.primary_key_name} = #{@owner.quoted_id} AND #{@reflection.klass.primary_key} IN (#{ids})"
             )
           end
         end
@@ -163,21 +160,29 @@ module ActiveRecord
         end
 
         def construct_sql
-          if @options[:finder_sql]
-            @finder_sql = interpolate_sql(@options[:finder_sql])
-          else
-            @finder_sql = "#{@association_class.table_name}.#{@association_class_primary_key_name} = #{@owner.quoted_id}"
-            @finder_sql << " AND (#{interpolate_sql(@conditions)})" if @conditions
+          case
+            when @reflection.options[:finder_sql]
+              @finder_sql = interpolate_sql(@reflection.options[:finder_sql])
+
+            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}"
+              @finder_sql << " AND (#{conditions})" if conditions
+            
+            else
+              @finder_sql = "#{@reflection.klass.table_name}.#{@reflection.primary_key_name} = #{@owner.quoted_id}"
+              @finder_sql << " AND (#{conditions})" if conditions
           end
 
-          if @options[:counter_sql]
-            @counter_sql = interpolate_sql(@options[:counter_sql])
-          elsif @options[:finder_sql]
-            @options[:counter_sql] = @options[:finder_sql].gsub(/SELECT (.*) FROM/i, "SELECT COUNT(*) FROM")
-            @counter_sql = interpolate_sql(@options[:counter_sql])
+          if @reflection.options[:counter_sql]
+            @counter_sql = interpolate_sql(@reflection.options[:counter_sql])
+          elsif @reflection.options[:finder_sql]
+            # replace the SELECT clause with COUNT(*), preserving any hints within /* ... */
+            @reflection.options[:counter_sql] = @reflection.options[:finder_sql].sub(/SELECT (\/\*.*?\*\/ )?(.*)\bFROM\b/im) { "SELECT #{$1}COUNT(*) FROM" }
+            @counter_sql = interpolate_sql(@reflection.options[:counter_sql])
           else
-            @counter_sql = "#{@association_class.table_name}.#{@association_class_primary_key_name} = #{@owner.quoted_id}"
-            @counter_sql << " AND (#{interpolate_sql(@conditions)})" if @conditions
+            @counter_sql = @finder_sql
           end
         end
     end

data/lib/active_record/associations/has_many_through_association.rb

@@ -0,0 +1,144 @@
+module ActiveRecord
+  module Associations
+    class HasManyThroughAssociation < AssociationProxy #:nodoc:
+      def initialize(owner, reflection)
+        super
+        reflection.check_validity!
+        @finder_sql = construct_conditions
+        construct_sql
+      end
+
+
+      def find(*args)
+        options = Base.send(:extract_options_from_args!, args)
+
+        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
+        
+        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.
+        args << options
+        @reflection.klass.find(*args)
+      end
+
+      def reset
+        @target = []
+        @loaded = false
+      end
+
+      protected
+        def method_missing(method, *args, &block)
+          if @target.respond_to?(method) || (!@reflection.klass.respond_to?(method) && Class.respond_to?(method))
+            super
+          else
+            @reflection.klass.with_scope(construct_scope) { @reflection.klass.send(method, *args, &block) }
+          end
+        end
+            
+        def find_target
+          @reflection.klass.find(:all, 
+            :select     => construct_select,
+            :conditions => construct_conditions,
+            :from       => construct_from,
+            :joins      => construct_joins,
+            :order      => @reflection.options[:order], 
+            :limit      => @reflection.options[:limit],
+            :group      => @reflection.options[:group],
+            :include    => @reflection.options[:include] || @reflection.source_reflection.options[:include]
+          )
+        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}"
+          else
+            case @reflection.source_reflection.macro
+              when :belongs_to, :has_many
+                "#{@reflection.through_reflection.table_name}.#{@reflection.through_reflection.primary_key_name} = #{@owner.quoted_id}"
+              else
+                raise ActiveRecordError, "Invalid source reflection macro :#{@reflection.source_reflection.macro} for has_many #{@reflection.name}, :through => #{@reflection.through_reflection.name}.  Use :source to specify the source reflection."
+            end
+          end
+          conditions << " AND (#{sql_conditions})" if sql_conditions
+          
+          return conditions
+        end
+
+        def construct_from
+          @reflection.table_name
+        end
+        
+        def construct_select(custom_select = nil)
+          selected = custom_select || @reflection.options[:select] || "#{@reflection.table_name}.*"          
+        end
+        
+        def construct_joins(custom_joins = nil)
+          if @reflection.through_reflection.options[:as] || @reflection.source_reflection.macro == :belongs_to
+            reflection_primary_key = @reflection.klass.primary_key
+            source_primary_key     = @reflection.source_reflection.primary_key_name
+          else
+            reflection_primary_key = @reflection.source_reflection.primary_key_name
+            source_primary_key     = @reflection.klass.primary_key
+          end
+
+          "INNER JOIN %s ON %s.%s = %s.%s #{@reflection.options[:joins]} #{custom_joins}" % [
+            @reflection.through_reflection.table_name,
+            @reflection.table_name, reflection_primary_key,
+            @reflection.through_reflection.table_name, source_primary_key
+          ]
+        end
+        
+        def construct_scope
+          {
+            :find   => { :from => construct_from, :conditions => construct_conditions, :joins => construct_joins, :select => construct_select },
+            :create => { @reflection.primary_key_name => @owner.id }
+          }
+        end
+        
+        def construct_sql
+          case
+            when @reflection.options[:finder_sql]
+              @finder_sql = interpolate_sql(@reflection.options[:finder_sql])
+
+              @finder_sql = "#{@reflection.klass.table_name}.#{@reflection.primary_key_name} = #{@owner.quoted_id}"
+              @finder_sql << " AND (#{conditions})" if conditions
+          end
+
+          if @reflection.options[:counter_sql]
+            @counter_sql = interpolate_sql(@reflection.options[:counter_sql])
+          elsif @reflection.options[:finder_sql]
+            # replace the SELECT clause with COUNT(*), preserving any hints within /* ... */
+            @reflection.options[:counter_sql] = @reflection.options[:finder_sql].sub(/SELECT (\/\*.*?\*\/ )?(.*)\bFROM\b/im) { "SELECT #{$1}COUNT(*) FROM" }
+            @counter_sql = interpolate_sql(@reflection.options[:counter_sql])
+          else
+            @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])
+        end
+        
+        alias_method :sql_conditions, :conditions
+    end
+  end
+end

data/lib/active_record/associations/has_one_association.rb

@@ -1,9 +1,8 @@
 module ActiveRecord
   module Associations
     class HasOneAssociation < BelongsToAssociation #:nodoc:
-      def initialize(owner, association_name, association_class_name, association_class_primary_key_name, options)
+      def initialize(owner, reflection)
         super
-
         construct_sql
       end
 
@@ -14,12 +13,12 @@ module ActiveRecord
       end
 
       def build(attributes = {}, replace_existing = true)
-        record = @association_class.new(attributes)
+        record = @reflection.klass.new(attributes)
 
         if replace_existing
           replace(record, true) 
         else
-          record[@association_class_primary_key_name] = @owner.id unless @owner.new_record?
+          record[@reflection.primary_key_name] = @owner.id unless @owner.new_record?
           self.target = record
         end
 
@@ -28,13 +27,14 @@ module ActiveRecord
 
       def replace(obj, dont_save = false)
         load_target
+
         unless @target.nil?
           if dependent? && !dont_save && @target != obj
             @target.destroy unless @target.new_record?
             @owner.clear_association_cache
           else
-            @target[@association_class_primary_key_name] = nil
-            @target.save unless @owner.new_record?
+            @target[@reflection.primary_key_name] = nil
+            @target.save unless @owner.new_record? || @target.new_record?
           end
         end
 
@@ -42,12 +42,12 @@ module ActiveRecord
           @target = nil
         else
           raise_on_type_mismatch(obj)
-          
-          obj[@association_class_primary_key_name] = @owner.id unless @owner.new_record?
+          set_belongs_to_association_for(obj)
           @target = (AssociationProxy === obj ? obj.target : obj)
         end
 
         @loaded = true
+
         unless @owner.new_record? or obj.nil? or dont_save
           return (obj.save ? self : false)
         else
@@ -57,17 +57,23 @@ module ActiveRecord
             
       private
         def find_target
-          @association_class.find(:first, :conditions => @finder_sql, :order => @options[:order], :include => @options[:include])
-        end
-
-        def target_obsolete?
-          false
+          @reflection.klass.find(:first, 
+            :conditions => @finder_sql, 
+            :order      => @reflection.options[:order], 
+            :include    => @reflection.options[:include]
+          )
         end
 
         def construct_sql
-          @finder_sql = "#{@association_class.table_name}.#{@association_class_primary_key_name} = #{@owner.quoted_id}"
-          @finder_sql << " AND (#{sanitize_sql(@options[:conditions])})" if @options[:conditions]
-          @finder_sql
+          case
+            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}"          
+            else
+              @finder_sql = "#{@reflection.table_name}.#{@reflection.primary_key_name} = #{@owner.quoted_id}"
+          end
+          @finder_sql << " AND (#{conditions})" if conditions
         end
     end
   end