activerecord 2.0.5 → 2.1.0

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -1,16 +1,6 @@
 module ActiveRecord
   module Associations
     class HasAndBelongsToManyAssociation < AssociationCollection #:nodoc:
-      def initialize(owner, reflection)
-        super
-        construct_sql
-      end
-
-      def build(attributes = {})
-        load_target
-        build_record(attributes)
-      end
-
       def create(attributes = {})
         create_record(attributes) { |record| insert_record(record) }
       end
@@ -19,53 +9,13 @@ module ActiveRecord
         create_record(attributes) { |record| insert_record(record, true) }
       end
 
-      def find_first
-        load_target.first
-      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
-
-          if ids.size == 1
-            id = ids.first.to_i
-            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
+      protected
+        def construct_find_options!(options)
           options[:joins]      = @join_sql
           options[:readonly]   = finding_with_ambiguous_select?(options[:select] || @reflection.options[:select])
-
-          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)
-
-          options[:select] ||= (@reflection.options[:select] || '*')
-
-          # Pass through args exactly as we received them.
-          args << options
-          @reflection.klass.find(*args)
+          options[:select]   ||= (@reflection.options[:select] || '*')
         end
-      end
-
-      protected
+        
         def count_records
           load_target.size
         end
@@ -85,10 +35,10 @@ module ActiveRecord
             columns = @owner.connection.columns(@reflection.options[:join_table], "#{@reflection.options[:join_table]} Columns")
 
             attributes = columns.inject({}) do |attrs, column|
-              case column.name
-                when @reflection.primary_key_name
+              case column.name.to_s
+                when @reflection.primary_key_name.to_s
                   attrs[column.name] = @owner.quoted_id
-                when @reflection.association_foreign_key
+                when @reflection.association_foreign_key.to_s
                   attrs[column.name] = record.quoted_id
                 else
                   if record.has_attribute?(column.name)
@@ -100,7 +50,7 @@ module ActiveRecord
             end
 
             sql =
-              "INSERT INTO #{@reflection.options[:join_table]} (#{@owner.send(:quoted_column_names, attributes).join(', ')}) " +
+              "INSERT INTO #{@owner.connection.quote_table_name @reflection.options[:join_table]} (#{@owner.send(:quoted_column_names, attributes).join(', ')}) " +
               "VALUES (#{attributes.values.join(', ')})"
 
             @owner.connection.insert(sql)
@@ -125,11 +75,11 @@ module ActiveRecord
           if @reflection.options[:finder_sql]
             @finder_sql = @reflection.options[:finder_sql]
           else
-            @finder_sql = "#{@reflection.options[:join_table]}.#{@reflection.primary_key_name} = #{@owner.quoted_id} "
+            @finder_sql = "#{@owner.connection.quote_table_name @reflection.options[:join_table]}.#{@reflection.primary_key_name} = #{@owner.quoted_id} "
             @finder_sql << " AND (#{conditions})" if conditions
           end
 
-          @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}"
+          @join_sql = "INNER JOIN #{@owner.connection.quote_table_name @reflection.options[:join_table]} ON #{@reflection.quoted_table_name}.#{@reflection.klass.primary_key} = #{@owner.connection.quote_table_name @reflection.options[:join_table]}.#{@reflection.association_foreign_key}"
         end
 
         def construct_scope
@@ -148,15 +98,13 @@ module ActiveRecord
         end
 
       private
-        def create_record(attributes)
+        def create_record(attributes, &block)
           # Can't use Base.create because the foreign key may be a protected attribute.
           ensure_owner_is_not_new
           if attributes.is_a?(Array)
             attributes.collect { |attr| create(attr) }
           else
-            record = build(attributes)
-            yield(record)
-            record
+            build_record(attributes, &block)
           end
         end
     end

data/lib/active_record/associations/has_many_association.rb

@@ -1,19 +1,6 @@
 module ActiveRecord
   module Associations
     class HasManyAssociation < AssociationCollection #:nodoc:
-      def initialize(owner, reflection)
-        super
-        construct_sql
-      end
-
-      def build(attributes = {})
-        if attributes.is_a?(Array)
-          attributes.collect { |attr| build(attr) }
-        else
-          build_record(attributes) { |record| set_belongs_to_association_for(record) }
-        end
-      end
-
       # Count the number of associated records. All arguments are optional.
       def count(*args)
         if @reflection.options[:counter_sql]
@@ -22,7 +9,7 @@ module ActiveRecord
           @reflection.klass.count_by_sql(@finder_sql)
         else
           column_name, options = @reflection.klass.send(:construct_count_options_from_args, *args)          
-          options[:conditions] = options[:conditions].nil? ?
+          options[:conditions] = options[:conditions].blank? ?
             @finder_sql :
             @finder_sql + " AND (#{sanitize_sql(options[:conditions])})"
           options[:include] ||= @reflection.options[:include]
@@ -31,62 +18,7 @@ module ActiveRecord
         end
       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(&: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
-
-          merge_options_from_reflection!(options)
-
-          # Pass through args exactly as we received them.
-          args << options
-          @reflection.klass.find(*args)
-        end
-      end
-
       protected
-        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
           count = if has_cached_counter?
             @owner.send(:read_attribute, cached_counter_attribute_name)
@@ -144,12 +76,12 @@ 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_value(@owner.class.base_class.name.to_s)}"
+                "#{@reflection.quoted_table_name}.#{@reflection.options[:as]}_id = #{@owner.quoted_id} AND " +
+                "#{@reflection.quoted_table_name}.#{@reflection.options[:as]}_type = #{@owner.class.quote_value(@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 = "#{@reflection.quoted_table_name}.#{@reflection.primary_key_name} = #{@owner.quoted_id}"
               @finder_sql << " AND (#{conditions})" if conditions
           end
 
@@ -167,7 +99,10 @@ module ActiveRecord
         def construct_scope
           create_scoping = {}
           set_belongs_to_association_for(create_scoping)
-          { :find => { :conditions => @finder_sql, :readonly => false, :order => @reflection.options[:order], :limit => @reflection.options[:limit] }, :create => create_scoping }
+          {
+            :find => { :conditions => @finder_sql, :readonly => false, :order => @reflection.options[:order], :limit => @reflection.options[:limit] },
+            :create => create_scoping
+          }
         end
     end
   end

data/lib/active_record/associations/has_many_through_association.rb

@@ -1,104 +1,23 @@
 module ActiveRecord
   module Associations
-    class HasManyThroughAssociation < AssociationProxy #:nodoc:
+    class HasManyThroughAssociation < HasManyAssociation #:nodoc:
       def initialize(owner, reflection)
-        super
         reflection.check_validity!
-        @finder_sql = construct_conditions
-        construct_sql
-      end
-
-      def find(*args)
-        options = args.extract_options!
-
-        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
-
-      # 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?
-
-        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.send(:with_scope, :create => construct_join_attributes(associate)) { klass.create! }
-            @target << associate if loaded?
-          end
-        end
-
-        self
+        super
       end
 
-      [:push, :concat].each { |method| alias_method method, :<< }
-
-      # Removes +records+ from this association.  Does not destroy +records+.
-      def delete(*records)
-        records = flatten_deeper(records)
-        records.each { |associate| raise_on_type_mismatch(associate) }
-
-        through = @reflection.through_reflection
-        raise ActiveRecord::HasManyThroughCantDissociateNewRecords.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::HasManyThroughCantDissociateNewRecords.new(@owner, through) unless associate.respond_to?(:new_record?) && !associate.new_record?
+      alias_method :new, :build
 
-            @owner.send(through.name).proxy_target.delete(klass.delete_all(construct_join_attributes(associate)))
-            @target.delete(associate)
-          end
+      def create!(attrs = nil)
+        @reflection.klass.transaction do
+          self << (object = attrs ? @reflection.klass.send(:with_scope, :create => attrs) { @reflection.klass.create! } : @reflection.klass.create!)
+          object
         end
-
-        self
       end
 
-      def build(attrs = nil)
-        raise ActiveRecord::HasManyThroughCantAssociateNewRecords.new(@owner, @reflection.through_reflection)
-      end
-      alias_method :new, :build
-
-      def create!(attrs = nil)
+      def create(attrs = nil)
         @reflection.klass.transaction do
-          self << (object = @reflection.klass.send(:with_scope, :create => attrs) { @reflection.klass.create! })
+          self << (object = attrs ? @reflection.klass.send(:with_scope, :create => attrs) { @reflection.klass.create } : @reflection.klass.create)
           object
         end
       end
@@ -111,33 +30,47 @@ module ActiveRecord
         return @target.size if loaded?
         return count
       end
-
-      # Calculate sum using SQL, not Enumerable
-      def sum(*args, &block)
-        calculate(:sum, *args, &block)
-      end
       
       def count(*args)
         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 statement.
-          column_name = "#{@reflection.klass.table_name}.#{@reflection.klass.primary_key}" if column_name == :all
+          # This is needed because 'SELECT count(DISTINCT *)..' is not valid SQL statement.
+          column_name = "#{@reflection.quoted_table_name}.#{@reflection.klass.primary_key}" if column_name == :all
           options.merge!(:distinct => true) 
         end
         @reflection.klass.send(:with_scope, construct_scope) { @reflection.klass.count(column_name, options) } 
       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.send(:with_scope, construct_scope) { @reflection.klass.send(method, *args, &block) }
+        def construct_find_options!(options)
+          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?
+        end
+        
+        def insert_record(record, force=true)
+          if record.new_record?
+            if force
+              record.save!
+            else
+              return false unless record.save
+            end
+          end
+          klass = @reflection.through_reflection.klass
+          @owner.send(@reflection.through_reflection.name).proxy_target << klass.send(:with_scope, :create => construct_join_attributes(record)) { klass.create! }
+        end
+
+        # TODO - add dependent option support
+        def delete_records(records)
+          klass = @reflection.through_reflection.klass
+          records.each do |associate|
+            klass.delete_all(construct_join_attributes(associate))
           end
         end
 
         def find_target
-          records = @reflection.klass.find(:all,
+          @reflection.klass.find(:all,
             :select     => construct_select,
             :conditions => construct_conditions,
             :from       => construct_from,
@@ -145,11 +78,9 @@ module ActiveRecord
             :order      => @reflection.options[:order],
             :limit      => @reflection.options[:limit],
             :group      => @reflection.options[:group],
+            :readonly   => @reflection.options[:readonly],
             :include    => @reflection.options[:include] || @reflection.source_reflection.options[:include]
           )
-
-          records.uniq! if @reflection.options[:uniq]
-          records
         end
 
         # Construct attributes for associate pointing to owner.
@@ -164,6 +95,8 @@ module ActiveRecord
 
         # Construct attributes for :through pointing to owner and associate.
         def construct_join_attributes(associate)
+          # TODO: revist this to allow it for deletion, supposing dependent option is supported
+          raise ActiveRecord::HasManyThroughCantAssociateThroughHasManyReflection.new(@owner, @reflection) if @reflection.source_reflection.macro == :has_many
           join_attributes = construct_owner_attributes(@reflection.through_reflection).merge(@reflection.source_reflection.primary_key_name => associate.id)
           if @reflection.options[:source_type]
             join_attributes.merge!(@reflection.source_reflection.options[:foreign_type] => associate.class.base_class.name.to_s)
@@ -185,7 +118,7 @@ module ActiveRecord
 
         # Build SQL conditions from attributes, qualified by table name.
         def construct_conditions
-          table_name = @reflection.through_reflection.table_name
+          table_name = @reflection.through_reflection.quoted_table_name
           conditions = construct_quoted_owner_attributes(@reflection.through_reflection).map do |attr, value|
             "#{table_name}.#{attr} = #{value}"
           end
@@ -194,21 +127,22 @@ module ActiveRecord
         end
 
         def construct_from
-          @reflection.table_name
+          @reflection.quoted_table_name
         end
 
         def construct_select(custom_select = nil)
-          selected = custom_select || @reflection.options[:select] || "#{@reflection.table_name}.*"
+          distinct = "DISTINCT " if @reflection.options[:uniq]
+          selected = custom_select || @reflection.options[:select] || "#{distinct}#{@reflection.quoted_table_name}.*"
         end
 
         def construct_joins(custom_joins = nil)
           polymorphic_join = nil
-          if @reflection.through_reflection.options[:as] || @reflection.source_reflection.macro == :belongs_to
+          if @reflection.source_reflection.macro == :belongs_to
             reflection_primary_key = @reflection.klass.primary_key
             source_primary_key     = @reflection.source_reflection.primary_key_name
             if @reflection.options[:source_type]
               polymorphic_join = "AND %s.%s = %s" % [
-                @reflection.through_reflection.table_name, "#{@reflection.source_reflection.options[:foreign_type]}",
+                @reflection.through_reflection.quoted_table_name, "#{@reflection.source_reflection.options[:foreign_type]}",
                 @owner.class.quote_value(@reflection.options[:source_type])
               ]
             end
@@ -217,7 +151,7 @@ module ActiveRecord
             source_primary_key     = @reflection.klass.primary_key
             if @reflection.source_reflection.options[:as]
               polymorphic_join = "AND %s.%s = %s" % [
-                @reflection.table_name, "#{@reflection.source_reflection.options[:as]}_type",
+                @reflection.quoted_table_name, "#{@reflection.source_reflection.options[:as]}_type",
                 @owner.class.quote_value(@reflection.through_reflection.klass.name)
               ]
             end
@@ -236,9 +170,12 @@ module ActiveRecord
             :find   => { :from        => construct_from,
                          :conditions  => construct_conditions,
                          :joins       => construct_joins,
+                         :include     => @reflection.options[:include],
                          :select      => construct_select,
                          :order       => @reflection.options[:order],
-                         :limit       => @reflection.options[:limit] } }
+                         :limit       => @reflection.options[:limit],
+                         :readonly    => @reflection.options[:readonly],
+             } }
         end
 
         def construct_sql
@@ -246,8 +183,10 @@ module ActiveRecord
             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 = "#{@reflection.quoted_table_name}.#{@reflection.primary_key_name} = #{@owner.quoted_id}"
               @finder_sql << " AND (#{conditions})" if conditions
+            else
+              @finder_sql = construct_conditions
           end
 
           if @reflection.options[:counter_sql]
@@ -268,25 +207,37 @@ module ActiveRecord
 
         def build_conditions
           association_conditions = @reflection.options[:conditions]
-          through_conditions = @reflection.through_reflection.options[:conditions]
+          through_conditions = build_through_conditions
           source_conditions = @reflection.source_reflection.options[:conditions]
           uses_sti = !@reflection.through_reflection.klass.descends_from_active_record?
 
           if association_conditions || through_conditions || source_conditions || uses_sti
             all = []
 
-            [association_conditions, through_conditions, source_conditions].each do |conditions|
+            [association_conditions, source_conditions].each do |conditions|
               all << interpolate_sql(sanitize_sql(conditions)) if conditions
             end
 
+            all << through_conditions  if through_conditions
             all << build_sti_condition if uses_sti
 
             all.map { |sql| "(#{sql})" } * ' AND '
           end
         end
 
+        def build_through_conditions
+          conditions = @reflection.through_reflection.options[:conditions]
+          if conditions.is_a?(Hash)
+            interpolate_sql(sanitize_sql(conditions)).gsub(
+              @reflection.quoted_table_name,
+              @reflection.through_reflection.quoted_table_name)
+          elsif conditions
+            interpolate_sql(sanitize_sql(conditions))
+          end
+        end
+        
         def build_sti_condition
-          "#{@reflection.through_reflection.table_name}.#{@reflection.through_reflection.klass.inheritance_column} = #{@reflection.klass.quote_value(@reflection.through_reflection.klass.name.demodulize)}"
+          "#{@reflection.through_reflection.quoted_table_name}.#{@reflection.through_reflection.klass.inheritance_column} = #{@reflection.klass.quote_value(@reflection.through_reflection.klass.sti_name)}"
         end
 
         alias_method :sql_conditions, :conditions