activerecord 1.13.2 → 1.14.0

data/lib/active_record/associations/association_collection.rb

@@ -18,6 +18,7 @@ module ActiveRecord
       def <<(*records)
         result = true
         load_target
+
         @owner.transaction do
           flatten_deeper(records).each do |record|
             raise_on_type_mismatch(record)
@@ -28,7 +29,7 @@ module ActiveRecord
           end
         end
 				
-        result and self
+        result && self
       end
 
       alias_method :push, :<<
@@ -60,11 +61,13 @@ module ActiveRecord
       # 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 hasn't happened already
-        if @options[:exclusively_dependent]
+
+        if @reflection.options[:dependent] && @reflection.options[:dependent] == :delete_all
           destroy_all
         else          
           delete_all
         end
+
         self
       end
       
@@ -124,14 +127,6 @@ module ActiveRecord
       end
 
       private
-        def raise_on_type_mismatch(record)
-          raise ActiveRecord::AssociationTypeMismatch, "#{@association_class} expected, got #{record.class}" unless record.is_a?(@association_class)
-        end
-
-        def target_obsolete?
-          false
-        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
@@ -155,8 +150,8 @@ module ActiveRecord
         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 []
+          full_callback_name = "#{callback_name}_for_#{@reflection.name}"
+          @owner.class.read_inheritable_attribute(full_callback_name.to_sym) || []
         end
         
     end

data/lib/active_record/associations/association_proxy.rb

@@ -1,29 +1,45 @@
 module ActiveRecord
   module Associations
     class AssociationProxy #:nodoc:
+      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)/ }
 
-      def initialize(owner, association_name, association_class_name, association_class_primary_key_name, options)
-        @owner = owner
-        @options = options
-        @association_name = association_name
-        @association_class = eval(association_class_name, nil, __FILE__, __LINE__)
-        @association_class_primary_key_name = association_class_primary_key_name
-
-        proxy_extend(options[:extend]) if options[:extend]
-
+      def initialize(owner, reflection)
+        @owner, @reflection = owner, reflection
+        proxy_extend(reflection.options[:extend]) if reflection.options[:extend]
         reset
       end
       
-      def reload
-        reset
+      def respond_to?(symbol, include_priv = false)
+        proxy_respond_to?(symbol, include_priv) || (load_target && @target.respond_to?(symbol, include_priv))
+      end
+      
+      # Explicitly proxy === because the instance method removal above
+      # doesn't catch it.
+      def ===(other)
         load_target
+        other === @target
+      end
+      
+      def aliased_table_name
+        @reflection.klass.table_name
+      end
+      
+      def conditions
+        @conditions ||= eval("%(#{@reflection.active_record.send :sanitize_sql, @reflection.options[:conditions]})") if @reflection.options[:conditions]
+      end
+      alias :sql_conditions :conditions
+      
+      def reset
+        @target = nil
+        @loaded = false
       end
 
-      def respond_to?(symbol, include_priv = false)
-        proxy_respond_to?(symbol, include_priv) || (load_target && @target.respond_to?(symbol, include_priv))
+      def reload
+        reset
+        load_target
       end
 
       def loaded?
@@ -38,14 +54,14 @@ module ActiveRecord
         @target
       end
       
-      def target=(t)
-        @target = t
-        @loaded = true
+      def target=(target)
+        @target = target
+        loaded
       end
       
       protected
         def dependent?
-          @options[:dependent] || false
+          @reflection.options[:dependent] || false
         end
         
         def quoted_record_ids(records)
@@ -61,15 +77,34 @@ module ActiveRecord
         end
 
         def sanitize_sql(sql)
-          @association_class.send(:sanitize_sql, sql)
+          @reflection.klass.send(:sanitize_sql, sql)
         end
 
         def extract_options_from_args!(args)
           @owner.send(:extract_options_from_args!, args)
         end
+
+        def set_belongs_to_association_for(record)
+          if @reflection.options[:as]
+            record["#{@reflection.options[:as]}_id"]   = @owner.id unless @owner.new_record?
+            record["#{@reflection.options[:as]}_type"] = @owner.class.base_class.name.to_s
+          else
+            record[@reflection.primary_key_name] = @owner.id unless @owner.new_record?
+          end
+        end
+
+        def merge_options_from_reflection!(options)
+          options.reverse_merge!(
+            :group   => @reflection.options[:group],
+            :limit   => @reflection.options[:limit],
+            :offset  => @reflection.options[:offset],
+            :joins   => @reflection.options[:joins],
+            :include => @reflection.options[:include],
+            :select  => @reflection.options[:select]
+          )
+        end
         
       private
-        
         def method_missing(method, *args, &block)
           load_target
           @target.send(method, *args, &block)
@@ -78,13 +113,14 @@ module ActiveRecord
         def load_target
           if !@owner.new_record? || foreign_key_present
             begin
-              @target = find_target if not loaded?
+              @target = find_target if !loaded?
             rescue ActiveRecord::RecordNotFound
               reset
             end
           end
-          @loaded = true if @target
-          @target
+
+          loaded if target
+          target
         end
 
         # Can be overwritten by associations that might have the foreign key available for an association without
@@ -94,8 +130,10 @@ module ActiveRecord
         end
 
         def raise_on_type_mismatch(record)
-          raise ActiveRecord::AssociationTypeMismatch, "#{@association_class} expected, got #{record.class}" unless record.is_a?(@association_class)
+          unless record.is_a?(@reflection.klass)
+            raise ActiveRecord::AssociationTypeMismatch, "#{@reflection.class_name} expected, got #{record.class}"
+          end
         end
     end
   end
-end
+end

data/lib/active_record/associations/belongs_to_association.rb

@@ -1,74 +1,55 @@
 module ActiveRecord
   module Associations
     class BelongsToAssociation < AssociationProxy #:nodoc:
-      
-      def initialize(owner, association_name, association_class_name, association_class_primary_key_name, options)
-        super        
-        construct_sql        
-      end
-      
-      def reset
-        @target = nil
-        @loaded = false
-      end
-
       def create(attributes = {})
-        record = @association_class.create(attributes)
-        replace(record, true)
-        record
+        replace(@reflection.klass.create(attributes))
       end
 
       def build(attributes = {})
-        record = @association_class.new(attributes)
-        replace(record, true)
-        record
+        replace(@reflection.klass.new(attributes))
       end
 
-      def replace(obj, dont_save = false)
-        if obj.nil?
-          @target = @owner[@association_class_primary_key_name] = nil
+      def replace(record)
+        counter_cache_name = @reflection.counter_cache_column
+
+        if record.nil?
+          if counter_cache_name && @owner[counter_cache_name] && !@owner.new_record?
+            @reflection.klass.decrement_counter(counter_cache_name, @owner[@reflection.primary_key_name]) if @owner[@reflection.primary_key_name]
+          end
+
+          @target = @owner[@reflection.primary_key_name] = nil
         else
-          raise_on_type_mismatch(obj) unless obj.nil?
+          raise_on_type_mismatch(record)
 
-          @target = (AssociationProxy === obj ? obj.target : obj)
-          @owner[@association_class_primary_key_name] = obj.id unless obj.new_record?
+          if counter_cache_name && !@owner.new_record?
+            @reflection.klass.increment_counter(counter_cache_name, record.id)
+            @reflection.klass.decrement_counter(counter_cache_name, @owner[@reflection.primary_key_name]) if @owner[@reflection.primary_key_name]
+          end
+
+          @target = (AssociationProxy === record ? record.target : record)
+          @owner[@reflection.primary_key_name] = record.id unless record.new_record?
           @updated = true
         end
-        @loaded = true
 
-        return (@target.nil? ? nil : self)
+        loaded
+        record
       end
       
       def updated?
         @updated
       end
       
-      protected
-
-
       private
         def find_target
-          if @options[:conditions]
-            @association_class.find(
-              @owner[@association_class_primary_key_name], 
-              :conditions => interpolate_sql(@options[:conditions]),
-              :include    => @options[:include]
-            )
-          else
-            @association_class.find(@owner[@association_class_primary_key_name], :include => @options[:include])
-          end
+          @reflection.klass.find(
+            @owner[@reflection.primary_key_name], 
+            :conditions => conditions,
+            :include    => @reflection.options[:include]
+          )
         end
 
         def foreign_key_present
-          !@owner[@association_class_primary_key_name].nil?
-        end
-
-        def target_obsolete?
-          @owner[@association_class_primary_key_name] != @target.id
-        end
-        
-        def construct_sql
-          @finder_sql = "#{@association_class.table_name}.#{@association_class.primary_key} = #{@owner.id}"
+          !@owner[@reflection.primary_key_name].nil?
         end
     end
   end

data/lib/active_record/associations/belongs_to_polymorphic_association.rb

@@ -0,0 +1,50 @@
+module ActiveRecord
+  module Associations
+    class BelongsToPolymorphicAssociation < AssociationProxy #:nodoc:
+      def replace(record)
+        if record.nil?
+          @target = @owner[@reflection.primary_key_name] = @owner[@reflection.options[:foreign_type]] = nil
+        else
+          @target = (AssociationProxy === record ? record.target : record)
+
+          unless record.new_record?
+            @owner[@reflection.primary_key_name] = record.id
+            @owner[@reflection.options[:foreign_type]] = record.class.base_class.name.to_s
+          end
+
+          @updated = true
+        end
+
+        loaded
+        record
+      end
+
+      def updated?
+        @updated
+      end
+
+      private
+        def find_target
+          return nil if association_class.nil?
+
+          if @reflection.options[:conditions]
+            association_class.find(
+              @owner[@reflection.primary_key_name], 
+              :conditions => conditions,
+              :include    => @reflection.options[:include]
+            )
+          else
+            association_class.find(@owner[@reflection.primary_key_name], :include => @reflection.options[:include])
+          end
+        end
+
+        def foreign_key_present
+          !@owner[@reflection.primary_key_name].nil?
+        end
+
+        def association_class
+          @owner[@reflection.options[:foreign_type]] ? @owner[@reflection.options[:foreign_type]].constantize : nil
+        end
+    end
+  end
+end

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -1,20 +1,14 @@
 module ActiveRecord
   module Associations
     class HasAndBelongsToManyAssociation < AssociationCollection #:nodoc:
-      def initialize(owner, association_name, association_class_name, association_class_primary_key_name, options)
+      def initialize(owner, reflection)
         super
-
-        @association_foreign_key = options[:association_foreign_key] || association_class_name.foreign_key
-        @association_table_name = options[:table_name] || @association_class.table_name
-        @join_table = options[:join_table]
-        @order = options[:order]
-
         construct_sql
       end
  
       def build(attributes = {})
         load_target
-        record = @association_class.new(attributes)
+        record = @reflection.klass.new(attributes)
         @target << record
         record
       end
@@ -27,7 +21,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
 
@@ -40,60 +34,66 @@ module ActiveRecord
           end
         else
           conditions = "#{@finder_sql}"
+
           if sanitized_conditions = sanitize_sql(options[:conditions])
             conditions << " AND (#{sanitized_conditions})"
           end
+
           options[:conditions] = conditions
           options[:joins] = @join_sql
           options[:readonly] ||= false
 
-          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      
 
       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
       
       alias :concat_with_attributes :push_with_attributes
 
       def size
-        @options[:uniq] ? count_records : super
+        @reflection.options[:uniq] ? count_records : super
       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(:find => { :conditions => @finder_sql, :joins => @join_sql, :readonly => false }) do
-              @association_class.send(method, *args, &block)
+            @reflection.klass.with_scope(:find => { :conditions => @finder_sql, :joins => @join_sql, :readonly => false }) do
+              @reflection.klass.send(method, *args, &block)
             end
           end
         end
             
         def find_target
-          if @options[:finder_sql]
-            records = @association_class.find_by_sql(@finder_sql)
+          if @reflection.options[:finder_sql]
+            records = @reflection.klass.find_by_sql(@finder_sql)
           else
-            records = find(:all, :include => @options[:include])
+            records = find(:all)
           end
           
-          @options[:uniq] ? uniq(records) : records
+          @reflection.options[:uniq] ? uniq(records) : records
         end
         
         def count_records
@@ -105,16 +105,16 @@ module ActiveRecord
             return false unless record.save
           end
 
-          if @options[:insert_sql]
-            @owner.connection.execute(interpolate_sql(@options[:insert_sql], record))
+          if @reflection.options[:insert_sql]
+            @owner.connection.execute(interpolate_sql(@reflection.options[:insert_sql], record))
           else
-            columns = @owner.connection.columns(@join_table, "#{@join_table} Columns")
+            columns = @owner.connection.columns(@reflection.options[:join_table], "#{@reflection.options[:join_table]} Columns")
 
             attributes = columns.inject({}) do |attributes, column|
               case column.name
-                when @association_class_primary_key_name
+                when @reflection.primary_key_name
                   attributes[column.name] = @owner.quoted_id
-                when @association_foreign_key
+                when @reflection.association_foreign_key
                   attributes[column.name] = record.quoted_id
                 else
                   if record.attributes.has_key?(column.name)
@@ -126,7 +126,7 @@ module ActiveRecord
             end
 
             sql =
-              "INSERT INTO #{@join_table} (#{@owner.send(:quoted_column_names, attributes).join(', ')}) " +
+              "INSERT INTO #{@reflection.options[:join_table]} (#{@owner.send(:quoted_column_names, attributes).join(', ')}) " +
               "VALUES (#{attributes.values.join(', ')})"
 
             @owner.connection.execute(sql)
@@ -136,26 +136,26 @@ module ActiveRecord
         end
         
         def delete_records(records)
-          if sql = @options[:delete_sql]
+          if sql = @reflection.options[:delete_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})"
+            sql = "DELETE FROM #{@reflection.options[:join_table]} WHERE #{@reflection.primary_key_name} = #{@owner.quoted_id} AND #{@reflection.association_foreign_key} IN (#{ids})"
             @owner.connection.execute(sql)
           end
         end
-
+        
         def construct_sql
-          interpolate_sql_options!(@options, :finder_sql)
+          interpolate_sql_options!(@reflection.options, :finder_sql)
 
-          if @options[:finder_sql]
-            @finder_sql = @options[:finder_sql]
+          if @reflection.options[:finder_sql]
+            @finder_sql = @reflection.options[:finder_sql]
           else
-            @finder_sql = "#{@join_table}.#{@association_class_primary_key_name} = #{@owner.quoted_id} "
-            @finder_sql << " AND (#{interpolate_sql(@options[:conditions])})" if @options[:conditions]
+            @finder_sql = "#{@reflection.options[:join_table]}.#{@reflection.primary_key_name} = #{@owner.quoted_id} "
+            @finder_sql << " AND (#{conditions})" if conditions
           end
-          
-          @join_sql = "LEFT JOIN #{@join_table} ON #{@association_class.table_name}.#{@association_class.primary_key} = #{@join_table}.#{@association_foreign_key}"
+
+          @join_sql = "INNER JOIN #{@reflection.options[:join_table]} ON #{@reflection.klass.table_name}.#{@reflection.klass.primary_key} = #{@reflection.options[:join_table]}.#{@reflection.association_foreign_key}"
         end
         
     end