activerecord 2.0.5 → 2.1.0

data/lib/active_record/associations/association_collection.rb

@@ -3,6 +3,71 @@ require 'set'
 module ActiveRecord
   module Associations
     class AssociationCollection < AssociationProxy #:nodoc:
+      def initialize(owner, reflection)
+        super
+        construct_sql
+      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
+          
+          # Build options specific to association
+          construct_find_options!(options)
+          
+          merge_options_from_reflection!(options)
+          
+          # Pass through args exactly as we received them.
+          args << options
+          @reflection.klass.find(*args)
+        end
+      end
+      
+      # Fetches the first one using SQL if possible.
+      def first(*args)
+        if fetch_first_or_last_using_find? args
+          find(:first, *args)
+        else
+          load_target unless loaded?
+          @target.first(*args)
+        end
+      end
+
+      # Fetches the last one using SQL if possible.
+      def last(*args)
+        if fetch_first_or_last_using_find? args
+          find(:last, *args)
+        else
+          load_target unless loaded?
+          @target.last(*args)
+        end
+      end
+
       def to_ary
         load_target
         @target.to_ary
@@ -13,6 +78,14 @@ module ActiveRecord
         @loaded = false
       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
+
       # Add +records+ to this association.  Returns +self+ so method calls may be chained.  
       # Since << flattens its argument list and inserts each record, +push+ and +concat+ behave identically.
       def <<(*records)
@@ -22,10 +95,9 @@ module ActiveRecord
         @owner.transaction do
           flatten_deeper(records).each do |record|
             raise_on_type_mismatch(record)
-            callback(:before_add, record)
-            result &&= insert_record(record) unless @owner.new_record?
-            @target << record
-            callback(:after_add, record)
+            add_record_to_target_with_callbacks(record) do |r|
+              result &&= insert_record(record) unless @owner.new_record?
+            end
           end
         end
 
@@ -41,22 +113,27 @@ module ActiveRecord
         delete(@target)
         reset_target!
       end
-
+      
       # Calculate sum using SQL, not Enumerable
-      def sum(*args, &block)
-        calculate(:sum, *args, &block)
+      def sum(*args)
+        if block_given?
+          calculate(:sum, *args) { |*block_args| yield(*block_args) }
+        else
+          calculate(:sum, *args)
+        end
       end
 
       # Remove +records+ from this association.  Does not destroy +records+.
       def delete(*records)
         records = flatten_deeper(records)
         records.each { |record| raise_on_type_mismatch(record) }
-        records.reject! { |record| @target.delete(record) if record.new_record? }
-        return if records.empty?
         
         @owner.transaction do
           records.each { |record| callback(:before_remove, record) }
-          delete_records(records)
+          
+          old_records = records.reject {|r| r.new_record? }
+          delete_records(old_records) if old_records.any?
+          
           records.each do |record|
             @target.delete(record)
             callback(:after_remove, record)
@@ -89,12 +166,18 @@ module ActiveRecord
         if attrs.is_a?(Array)
           attrs.collect { |attr| create(attr) }
         else
-          create_record(attrs) { |record| record.save }
+          create_record(attrs) do |record|
+            yield(record) if block_given?
+            record.save
+          end
         end
       end
 
       def create!(attrs = {})
-        create_record(attrs) { |record| record.save! }
+        create_record(attrs) do |record|
+          yield(record) if block_given?
+          record.save!
+        end
       end
 
       # Returns the size of the collection by executing a SELECT COUNT(*) query if the collection hasn't been loaded and
@@ -121,9 +204,9 @@ module ActiveRecord
         size.zero?
       end
 
-      def any?(&block)
+      def any?
         if block_given?
-          method_missing(:any?, &block)
+          method_missing(:any?) { |*block_args| yield(*block_args) }
         else
           !empty?
         end
@@ -155,13 +238,53 @@ module ActiveRecord
         end
       end
 
+      def include?(record)
+        return false unless record.is_a?(@reflection.klass)
+        load_target if @reflection.options[:finder_sql] && !loaded?
+        return @target.include?(record) if loaded?
+        exists?(record)
+      end
 
       protected
-        def method_missing(method, *args, &block)
+        def construct_find_options!(options)
+        end
+        
+        def load_target
+          if !@owner.new_record? || foreign_key_present
+            begin
+              if !loaded?
+                if @target.is_a?(Array) && @target.any?
+                  @target = find_target + @target.find_all {|t| t.new_record? }
+                else
+                  @target = find_target
+                end
+              end
+            rescue ActiveRecord::RecordNotFound
+              reset
+            end
+          end
+
+          loaded if target
+          target
+        end
+        
+        def method_missing(method, *args)
           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) }
+            if block_given?
+              super { |*block_args| yield(*block_args) }
+            else
+              super
+            end
+          elsif @reflection.klass.scopes.include?(method)
+            @reflection.klass.scopes[method].call(self, *args)
+          else          
+            with_scope(construct_scope) do
+              if block_given?
+                @reflection.klass.send(method, *args) { |*block_args| yield(*block_args) }
+              else
+                @reflection.klass.send(method, *args)
+              end
+            end
           end
         end
 
@@ -187,15 +310,25 @@ module ActiveRecord
 
       private
 
-        def create_record(attrs, &block)
+        def create_record(attrs)
+          attrs.update(@reflection.options[:conditions]) if @reflection.options[:conditions].is_a?(Hash)
           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)
+          if block_given?
+            add_record_to_target_with_callbacks(record) { |*block_args| yield(*block_args) }
+          else
+            add_record_to_target_with_callbacks(record)
+          end
         end
 
-        def build_record(attrs, &block)
+        def build_record(attrs)
+          attrs.update(@reflection.options[:conditions]) if @reflection.options[:conditions].is_a?(Hash)
           record = @reflection.klass.new(attrs)
-          add_record_to_target_with_callbacks(record, &block)
+          if block_given?
+            add_record_to_target_with_callbacks(record) { |*block_args| yield(*block_args) }
+          else
+            add_record_to_target_with_callbacks(record)
+          end
         end
 
         def add_record_to_target_with_callbacks(record)
@@ -209,21 +342,10 @@ module ActiveRecord
 
         def callback(method, record)
           callbacks_for(method).each do |callback|
-            case callback
-              when Symbol
-                @owner.send(callback, record)
-              when Proc, Method
-                callback.call(@owner, record)
-              else
-                if callback.respond_to?(method)
-                  callback.send(method, @owner, record)
-                else
-                  raise ActiveRecordError, "Callbacks must be a symbol denoting the method to call, a string to be evaluated, a block to be invoked, or an object responding to the callback method."
-                end
-            end
+            ActiveSupport::Callbacks::Callback.new(method, callback, record).call(@owner, record)
           end
         end
-        
+
         def callbacks_for(callback_name)
           full_callback_name = "#{callback_name}_for_#{@reflection.name}"
           @owner.class.read_inheritable_attribute(full_callback_name.to_sym) || []
@@ -234,7 +356,10 @@ module ActiveRecord
             raise ActiveRecord::RecordNotSaved, "You cannot call create unless the parent is saved"
           end
         end
-               
+
+        def fetch_first_or_last_using_find?(args)
+          args.first.kind_of?(Hash) || !(loaded? || @owner.new_record? || @reflection.options[:finder_sql] || !@target.blank? || args.first.kind_of?(Integer))
+        end
     end
   end
-end
+end

data/lib/active_record/associations/association_proxy.rb

@@ -1,11 +1,55 @@
 module ActiveRecord
   module Associations
+    # This is the root class of all association proxies:
+    #
+    #   AssociationProxy
+    #     BelongsToAssociation
+    #       HasOneAssociation
+    #     BelongsToPolymorphicAssociation
+    #     AssociationCollection
+    #       HasAndBelongsToManyAssociation
+    #       HasManyAssociation
+    #         HasManyThroughAssociation
+    #            HasOneThroughAssociation
+    #
+    # Association proxies in Active Record are middlemen between the object that
+    # holds the association, known as the <tt>@owner</tt>, and the actual associated
+    # object, known as the <tt>@target</tt>. The kind of association any proxy is
+    # about is available in <tt>@reflection</tt>. That's an instance of the class
+    # ActiveRecord::Reflection::AssociationReflection.
+    #
+    # For example, given
+    #
+    #   class Blog < ActiveRecord::Base
+    #     has_many :posts
+    #   end
+    #
+    #   blog = Blog.find(:first)
+    #
+    # the association proxy in <tt>blog.posts</tt> has the object in +blog+ as
+    # <tt>@owner</tt>, the collection of its posts as <tt>@target</tt>, and
+    # the <tt>@reflection</tt> object represents a <tt>:has_many</tt> macro.
+    #
+    # This class has most of the basic instance methods removed, and delegates
+    # unknown methods to <tt>@target</tt> via <tt>method_missing</tt>. As a
+    # corner case, it even removes the +class+ method and that's why you get
+    #
+    #   blog.posts.class # => Array
+    #
+    # though the object behind <tt>blog.posts</tt> is not an Array, but an
+    # ActiveRecord::Associations::HasManyAssociation.
+    #
+    # The <tt>@target</tt> object is not loaded until needed. For example,
+    #
+    #   blog.posts.count
+    #
+    # is computed directly through SQL and does not trigger by itself the
+    # instantiation of the actual post records.
     class AssociationProxy #:nodoc:
-      attr_reader :reflection
       alias_method :proxy_respond_to?, :respond_to?
       alias_method :proxy_extend, :extend
       delegate :to_param, :to => :proxy_target
-      instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_)/ }
+      instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^object_id$)/ }
 
       def initialize(owner, reflection)
         @owner, @reflection = owner, reflection
@@ -74,7 +118,7 @@ module ActiveRecord
       end
 
       def inspect
-        reload unless loaded?
+        load_target
         @target.inspect
       end
 
@@ -115,17 +159,36 @@ module ActiveRecord
             :offset  => @reflection.options[:offset],
             :joins   => @reflection.options[:joins],
             :include => @reflection.options[:include],
-            :select  => @reflection.options[:select]
+            :select  => @reflection.options[:select],
+            :readonly  => @reflection.options[:readonly]
           )
         end
 
+        def with_scope(*args, &block)
+          @reflection.klass.send :with_scope, *args, &block
+        end
+
       private
-        def method_missing(method, *args, &block)
+        def method_missing(method, *args)
           if load_target
-            @target.send(method, *args, &block)
+            if block_given?
+              @target.send(method, *args)  { |*block_args| yield(*block_args) }
+            else
+              @target.send(method, *args)
+            end
           end
         end
 
+        # Loads the target if needed and returns it.
+        #
+        # This method is abstract in the sense that it relies on +find_target+,
+        # which is expected to be provided by descendants.
+        #
+        # If the target is already loaded it is just returned. Thus, you can call
+        # +load_target+ unconditionally to get the target.
+        #
+        # ActiveRecord::RecordNotFound is rescued within the method, and it is
+        # not reraised. The proxy is reset and +nil+ is the return value.
         def load_target
           return nil unless defined?(@loaded)
 
@@ -147,7 +210,8 @@ module ActiveRecord
 
         def raise_on_type_mismatch(record)
           unless record.is_a?(@reflection.klass)
-            raise ActiveRecord::AssociationTypeMismatch, "#{@reflection.klass} expected, got #{record.class}"
+            message = "#{@reflection.class_name}(##{@reflection.klass.object_id}) expected, got #{record.class}(##{record.class.object_id})"
+            raise ActiveRecord::AssociationTypeMismatch, message
           end
         end
 

data/lib/active_record/associations/belongs_to_association.rb

@@ -13,7 +13,7 @@ module ActiveRecord
         counter_cache_name = @reflection.counter_cache_column
 
         if record.nil?
-          if counter_cache_name && @owner[counter_cache_name] && !@owner.new_record?
+          if 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
 
@@ -42,9 +42,11 @@ module ActiveRecord
       private
         def find_target
           @reflection.klass.find(
-            @owner[@reflection.primary_key_name], 
+            @owner[@reflection.primary_key_name],
+            :select     => @reflection.options[:select],
             :conditions => conditions,
-            :include    => @reflection.options[:include]
+            :include    => @reflection.options[:include],
+            :readonly   => @reflection.options[:readonly]
           )
         end
 

data/lib/active_record/associations/belongs_to_polymorphic_association.rb

@@ -7,10 +7,8 @@ module ActiveRecord
         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
+          @owner[@reflection.primary_key_name] = record.id
+          @owner[@reflection.options[:foreign_type]] = record.class.base_class.name.to_s
 
           @updated = true
         end
@@ -29,12 +27,13 @@ module ActiveRecord
 
           if @reflection.options[:conditions]
             association_class.find(
-              @owner[@reflection.primary_key_name], 
+              @owner[@reflection.primary_key_name],
+              :select     => @reflection.options[:select],
               :conditions => conditions,
               :include    => @reflection.options[:include]
             )
           else
-            association_class.find(@owner[@reflection.primary_key_name], :include => @reflection.options[:include])
+            association_class.find(@owner[@reflection.primary_key_name], :select => @reflection.options[:select], :include => @reflection.options[:include])
           end
         end