activerecord 1.15.6 → 2.0.0

data/lib/active_record/associations/association_collection.rb

@@ -7,7 +7,7 @@ module ActiveRecord
         load_target
         @target.to_ary
       end
-  
+
       def reset
         reset_target!
         @loaded = false
@@ -17,7 +17,7 @@ module ActiveRecord
       # Since << flattens its argument list and inserts each record, +push+ and +concat+ behave identically.
       def <<(*records)
         result = true
-        load_target
+        load_target if @owner.new_record?
 
         @owner.transaction do
           flatten_deeper(records).each do |record|
@@ -34,7 +34,7 @@ module ActiveRecord
 
       alias_method :push, :<<
       alias_method :concat, :<<
-                      
+
       # Remove all records from this association
       def delete_all
         load_target
@@ -66,9 +66,9 @@ 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
+        return self if length.zero? # forces load_target if it hasn't happened already
 
-        if @reflection.options[:dependent] && @reflection.options[:dependent] == :delete_all
+        if @reflection.options[:dependent] && @reflection.options[:dependent] == :destroy
           destroy_all
         else          
           delete_all
@@ -84,27 +84,24 @@ module ActiveRecord
 
         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)
-          attributes.collect { |attr| create(attr) }
+      
+      def create(attrs = {})
+        if attrs.is_a?(Array)
+          attrs.collect { |attr| create(attr) }
         else
-          record = build(attributes)
-          if @owner.new_record?
-            ActiveSupport::Deprecation.warn("Calling .create on a has_many association without saving its owner will not work in rails 2.0, you probably want .build instead")
-          else
-            record.save
-          end
-          record
+          create_record(attrs) { |record| record.save }
         end
       end
 
+      def create!(attrs = {})
+        create_record(attrs) { |record| record.save! }
+      end
+
       # Returns the size of the collection by executing a SELECT COUNT(*) query if the collection hasn't been loaded and
       # 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? && !@reflection.options[:uniq]
+        if @owner.new_record? || (loaded? && !@reflection.options[:uniq])
           @target.size
         elsif !loaded? && !@reflection.options[:uniq] && @target.is_a?(Array)
           unsaved_records = Array(@target.detect { |r| r.new_record? })
@@ -124,6 +121,14 @@ module ActiveRecord
         size.zero?
       end
 
+      def any?(&block)
+        if block_given?
+          method_missing(:any?, &block)
+        else
+          !empty?
+        end
+      end
+
       def uniq(collection = self)
         seen = Set.new
         collection.inject([]) do |kept, record|
@@ -150,7 +155,21 @@ module ActiveRecord
         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
+            @reflection.klass.send(:with_scope, construct_scope) { @reflection.klass.send(method, *args, &block) }
+          end
+        end
+
+        # overloaded in derived Association classes to provide useful scoping depending on association type.
+        def construct_scope
+          {}
+        end
+
         def reset_target!
           @target = Array.new
         end
@@ -167,6 +186,27 @@ module ActiveRecord
         end
 
       private
+
+        def create_record(attrs, &block)
+          ensure_owner_is_not_new
+          record = @reflection.klass.send(:with_scope, :create => construct_scope[:create]) { @reflection.klass.new(attrs) }
+          add_record_to_target_with_callbacks(record, &block)
+        end
+
+        def build_record(attrs, &block)
+          record = @reflection.klass.new(attrs)
+          add_record_to_target_with_callbacks(record, &block)
+        end
+
+        def add_record_to_target_with_callbacks(record)
+          callback(:before_add, record)
+          yield(record) if block_given?
+          @target ||= [] unless loaded?
+          @target << record
+          callback(:after_add, record)
+          record
+        end
+
         def callback(method, record)
           callbacks_for(method).each do |callback|
             case callback
@@ -187,8 +227,14 @@ module ActiveRecord
         def callbacks_for(callback_name)
           full_callback_name = "#{callback_name}_for_#{@reflection.name}"
           @owner.class.read_inheritable_attribute(full_callback_name.to_sym) || []
-        end
+        end   
         
+        def ensure_owner_is_not_new
+          if @owner.new_record?
+            raise ActiveRecord::RecordNotSaved, "You cannot call create unless the parent is saved"
+          end
+        end
+               
     end
   end
-end
+end

data/lib/active_record/associations/association_proxy.rb

@@ -46,8 +46,8 @@ module ActiveRecord
       alias :sql_conditions :conditions
       
       def reset
-        @target = nil
         @loaded = false
+        @target = nil
       end
 
       def reload
@@ -72,9 +72,14 @@ module ActiveRecord
         loaded
       end
       
+      def inspect
+        reload unless loaded?
+        @target.inspect
+      end
+
       protected
         def dependent?
-          @reflection.options[:dependent] || false
+          @reflection.options[:dependent]
         end
         
         def quoted_record_ids(records)
@@ -93,10 +98,6 @@ module ActiveRecord
           @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?
@@ -138,14 +139,14 @@ module ActiveRecord
         end
 
         # Can be overwritten by associations that might have the foreign key available for an association without
-        # having the object itself (and still being a new record). Currently, only belongs_to present this scenario.
+        # having the object itself (and still being a new record). Currently, only belongs_to presents this scenario.
         def foreign_key_present
           false
         end
 
         def raise_on_type_mismatch(record)
           unless record.is_a?(@reflection.klass)
-            raise ActiveRecord::AssociationTypeMismatch, "#{@reflection.class_name} expected, got #{record.class}"
+            raise ActiveRecord::AssociationTypeMismatch, "#{@reflection.klass} expected, got #{record.class}"
           end
         end
 

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -5,31 +5,26 @@ module ActiveRecord
         super
         construct_sql
       end
- 
+
       def build(attributes = {})
         load_target
-        record = @reflection.klass.new(attributes)
-        @target << record
-        record
+        build_record(attributes)
       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
+        create_record(attributes) { |record| insert_record(record) }
+      end
+      
+      def create!(attributes = {})
+        create_record(attributes) { |record| insert_record(record, true) }
       end
 
       def find_first
         load_target.first
       end
-      
+
       def find(*args)
-        options = Base.send(:extract_options_from_args!, args)
+        options = args.extract_options!
 
         # If using a custom finder_sql, scan the entire collection.
         if @reflection.options[:finder_sql]
@@ -52,7 +47,7 @@ module ActiveRecord
 
           options[:conditions] = conditions
           options[:joins]      = @join_sql
-          options[:readonly]   = finding_with_ambigious_select?(options[:select])
+          options[:readonly]   = finding_with_ambiguous_select?(options[:select] || @reflection.options[:select])
 
           if options[:order] && @reflection.options[:order]
             options[:order] = "#{options[:order]}, #{@reflection.options[:order]}"
@@ -62,47 +57,26 @@ module ActiveRecord
 
           merge_options_from_reflection!(options)
 
+          options[:select] ||= (@reflection.options[:select] || '*')
+
           # Pass through args exactly as we received them.
           args << options
           @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 }
-
-        callback(:before_add, record)
-        insert_record(record) unless @owner.new_record?
-        @target << record
-        callback(:after_add, record)
-
-        self
       end
-      deprecate :push_with_attributes => "consider using has_many :through instead"
-
-      alias :concat_with_attributes :push_with_attributes
 
       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(:find => { :conditions => @finder_sql, :joins => @join_sql, :readonly => false }) do
-              @reflection.klass.send(method, *args, &block)
-            end
-          end
-        end
-
         def count_records
           load_target.size
         end
 
-        def insert_record(record)
+        def insert_record(record, force=true)
           if record.new_record?
-            return false unless record.save
+            if force
+              record.save!
+            else
+              return false unless record.save
+            end
           end
 
           if @reflection.options[:insert_sql]
@@ -131,10 +105,10 @@ module ActiveRecord
 
             @owner.connection.execute(sql)
           end
-          
+
           return true
         end
-        
+
         def delete_records(records)
           if sql = @reflection.options[:delete_sql]
             records.each { |record| @owner.connection.execute(interpolate_sql(sql, record)) }
@@ -144,7 +118,7 @@ module ActiveRecord
             @owner.connection.execute(sql)
           end
         end
-        
+
         def construct_sql
           interpolate_sql_options!(@reflection.options, :finder_sql)
 
@@ -158,12 +132,33 @@ module ActiveRecord
           @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
 
-        # Join tables with additional columns on top of the two foreign keys must be considered ambigious unless a select
-        # clause has been explicitly defined. Otherwise you can get broken records back, if, say, the join column also has
-        # and id column, which will then overwrite the id column of the records coming back.
-        def finding_with_ambigious_select?(select_clause)
+        def construct_scope
+          { :find => {  :conditions => @finder_sql,
+                        :joins => @join_sql,
+                        :readonly => false,
+                        :order => @reflection.options[:order],
+                        :limit => @reflection.options[:limit] } }
+        end
+
+        # Join tables with additional columns on top of the two foreign keys must be considered ambiguous unless a select
+        # clause has been explicitly defined. Otherwise you can get broken records back, if, for example, the join column also has
+        # an id column. This will then overwrite the id column of the records coming back.
+        def finding_with_ambiguous_select?(select_clause)
           !select_clause && @owner.connection.columns(@reflection.options[:join_table], "Join Table Columns").size != 2
         end
+
+      private
+        def create_record(attributes)
+          # 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
+          end
+        end
     end
   end
 end

data/lib/active_record/associations/has_many_association.rb

@@ -10,34 +10,9 @@ module ActiveRecord
         if attributes.is_a?(Array)
           attributes.collect { |attr| build(attr) }
         else
-          record = @reflection.klass.new(attributes)
-          set_belongs_to_association_for(record)
-          
-          @target ||= [] unless loaded?
-          @target << record
-          
-          record
-        end
-      end
-
-      # DEPRECATED.
-      def find_all(runtime_conditions = nil, orderings = nil, limit = nil, joins = nil)
-        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 ||= @reflection.options[:order]
-          @reflection.klass.find_all(conditions, orderings, limit, joins)
+          build_record(attributes) { |record| set_belongs_to_association_for(record) }
         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(*args)
@@ -46,7 +21,7 @@ module ActiveRecord
         elsif @reflection.options[:finder_sql]
           @reflection.klass.count_by_sql(@finder_sql)
         else
-          column_name, options = @reflection.klass.send(:construct_count_options_from_legacy_args, *args)          
+          column_name, options = @reflection.klass.send(:construct_count_options_from_args, *args)          
           options[:conditions] = options[:conditions].nil? ?
             @finder_sql :
             @finder_sql + " AND (#{sanitize_sql(options[:conditions])})"
@@ -57,12 +32,12 @@ module ActiveRecord
       end
 
       def find(*args)
-        options = Base.send(:extract_options_from_args!, 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
+          ids           = args.flatten.compact.uniq.map(&:to_i)
 
           if ids.size == 1
             id = ids.first
@@ -93,26 +68,6 @@ module ActiveRecord
       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
-              }
-            ) do
-              @reflection.klass.send(method, *args, &block)
-            end
-          end
-        end
-
         def load_target
           if !@owner.new_record? || foreign_key_present
             begin
@@ -164,14 +119,17 @@ module ActiveRecord
         end
 
         def delete_records(records)
-          if @reflection.options[:dependent]
-            records.each { |r| r.destroy }
-          else
-            ids = quoted_record_ids(records)
-            @reflection.klass.update_all(
-              "#{@reflection.primary_key_name} = NULL", 
-              "#{@reflection.primary_key_name} = #{@owner.quoted_id} AND #{@reflection.klass.primary_key} IN (#{ids})"
-            )
+          case @reflection.options[:dependent]
+            when :destroy
+              records.each(&:destroy)
+            when :delete_all
+              @reflection.klass.delete(records.map(&:id))
+            else
+              ids = quoted_record_ids(records)
+              @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
 
@@ -205,6 +163,12 @@ module ActiveRecord
             @counter_sql = @finder_sql
           end
         end
+
+        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 }
+        end
     end
   end
 end