activerecord 3.0.20 → 3.1.0.beta1

data/lib/active_record/associations/collection_proxy.rb

@@ -0,0 +1,125 @@
+module ActiveRecord
+  module Associations
+    # 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 CollectionProxy # :nodoc:
+      alias :proxy_extend :extend
+
+      instance_methods.each { |m| undef_method m unless m.to_s =~ /^(?:nil\?|send|object_id|to_a)$|^__|^respond_to|proxy_/ }
+
+      delegate :group, :order, :limit, :joins, :where, :preload, :eager_load, :includes, :from,
+               :lock, :readonly, :having, :to => :scoped
+
+      delegate :target, :load_target, :loaded?, :scoped,
+               :to => :@association
+
+      delegate :select, :find, :first, :last,
+               :build, :create, :create!,
+               :concat, :delete_all, :destroy_all, :delete, :destroy, :uniq,
+               :sum, :count, :size, :length, :empty?,
+               :any?, :many?, :include?,
+               :to => :@association
+
+      def initialize(association)
+        @association = association
+        Array.wrap(association.options[:extend]).each { |ext| proxy_extend(ext) }
+      end
+
+      def respond_to?(*args)
+        super ||
+        (load_target && target.respond_to?(*args)) ||
+        @association.klass.respond_to?(*args)
+      end
+
+      def method_missing(method, *args, &block)
+        match = DynamicFinderMatch.match(method)
+        if match && match.creator?
+          attributes = match.attribute_names
+          return send(:"find_by_#{attributes.join('_and_')}", *args) || create(Hash[attributes.zip(args)])
+        end
+
+        if target.respond_to?(method) || (!@association.klass.respond_to?(method) && Class.respond_to?(method))
+          if load_target
+            if target.respond_to?(method)
+              target.send(method, *args, &block)
+            else
+              begin
+                super
+              rescue NoMethodError => e
+                raise e, e.message.sub(/ for #<.*$/, " via proxy for #{target}")
+              end
+            end
+          end
+
+        else
+          scoped.readonly(nil).send(method, *args, &block)
+        end
+      end
+
+      # Forwards <tt>===</tt> explicitly to the \target because the instance method
+      # removal above doesn't catch it. Loads the \target if needed.
+      def ===(other)
+        other === load_target
+      end
+
+      def to_ary
+        load_target.dup
+      end
+      alias_method :to_a, :to_ary
+
+      def <<(*records)
+        @association.concat(records) && self
+      end
+      alias_method :push, :<<
+
+      def clear
+        delete_all
+        self
+      end
+
+      def reload
+        @association.reload
+        self
+      end
+
+      def new(*args, &block)
+        if @association.is_a?(HasManyThroughAssociation)
+          @association.build(*args, &block)
+        else
+          method_missing(:new, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -1,142 +1,51 @@
-require 'active_support/deprecation'
-
 module ActiveRecord
   # = Active Record Has And Belongs To Many Association
   module Associations
-    class HasAndBelongsToManyAssociation < AssociationCollection #:nodoc:
+    class HasAndBelongsToManyAssociation < CollectionAssociation #:nodoc:
+      attr_reader :join_table
+
       def initialize(owner, reflection)
+        @join_table = Arel::Table.new(reflection.options[:join_table])
         super
-        if columns.size > 2
-          ActiveSupport::Deprecation.warn "Having additional attributes on the join table of a has_and_belongs_to_many association is deprecated and will be removed in Rails 3.1. Please use a has_many :through association instead."
-        end
-      end
-
-      def create(attributes = {})
-        create_record(attributes) { |record| insert_record(record) }
       end
 
-      def create!(attributes = {})
-        create_record(attributes) { |record| insert_record(record, true) }
-      end
+      def insert_record(record, validate = true)
+        return if record.new_record? && !record.save(:validate => validate)
 
-      def columns
-        @reflection.columns(@reflection.options[:join_table], "#{@reflection.options[:join_table]} Columns")
-      end
+        if options[:insert_sql]
+          owner.connection.insert(interpolate(options[:insert_sql], record))
+        else
+          stmt = join_table.compile_insert(
+            join_table[reflection.foreign_key]             => owner.id,
+            join_table[reflection.association_foreign_key] => record.id
+          )
 
-      def reset_column_information
-        @reflection.reset_column_information
-      end
+          owner.connection.insert stmt.to_sql
+        end
 
-      def has_primary_key?
-        @has_primary_key ||= @owner.connection.supports_primary_key? && @owner.connection.primary_key(@reflection.options[:join_table])
+        record
       end
 
-      protected
-        def construct_find_options!(options)
-          options[:joins]      = Arel::SqlLiteral.new @join_sql
-          options[:readonly]   = finding_with_ambiguous_select?(options[:select] || @reflection.options[:select])
-          options[:select]   ||= (@reflection.options[:select] || Arel::SqlLiteral.new('*'))
-        end
+      private
 
         def count_records
           load_target.size
         end
 
-        def insert_record(record, force = true, validate = true)
-          if record.new_record?
-            if force
-              record.save!
-            else
-              return false unless record.save(:validate => validate)
-            end
-          end
-
-          if @reflection.options[:insert_sql]
-            @owner.connection.insert(interpolate_and_sanitize_sql(@reflection.options[:insert_sql], record))
+        def delete_records(records, method)
+          if sql = options[:delete_sql]
+            records.each { |record| owner.connection.delete(interpolate(sql, record)) }
           else
-            relation   = Arel::Table.new(@reflection.options[:join_table])
-            timestamps = record_timestamp_columns(record)
-            timezone   = record.send(:current_time_from_proper_timezone) if timestamps.any?
-
-            attributes = Hash[columns.map do |column|
-              name = column.name
-              value = case name.to_s
-                when @reflection.primary_key_name.to_s
-                  @owner.id
-                when @reflection.association_foreign_key.to_s
-                  record.id
-                when *timestamps
-                  timezone
-                else
-                  @owner.send(:quote_value, record[name], column) if record.has_attribute?(name)
-              end
-              [relation[name], value] unless value.nil?
-            end]
-
-            relation.insert(attributes)
+            relation = join_table
+            stmt = relation.where(relation[reflection.foreign_key].eq(owner.id).
+              and(relation[reflection.association_foreign_key].in(records.map { |x| x.id }.compact))
+            ).compile_delete
+            owner.connection.delete stmt.to_sql
           end
-
-          return true
         end
 
-        def delete_records(records)
-          if sql = @reflection.options[:delete_sql]
-            records.each { |record| @owner.connection.delete(interpolate_and_sanitize_sql(sql, record)) }
-          else
-            relation = Arel::Table.new(@reflection.options[:join_table])
-            relation.where(relation[@reflection.primary_key_name].eq(@owner.id).
-              and(relation[@reflection.association_foreign_key].in(records.map { |x| x.id }.compact))
-            ).delete
-          end
-        end
-
-        def construct_sql
-          if @reflection.options[:finder_sql]
-            @finder_sql = interpolate_and_sanitize_sql(@reflection.options[:finder_sql])
-          else
-            @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 #{@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}"
-
-          construct_counter_sql
-        end
-
-        def construct_scope
-          { :find => {  :conditions => @finder_sql,
-                        :joins => @join_sql,
-                        :readonly => false,
-                        :order => @reflection.options[:order],
-                        :include => @reflection.options[:include],
-                        :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 && columns.size != 2
-        end
-
-      private
-        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
-            build_record(attributes, &block)
-          end
-        end
-
-        def record_timestamp_columns(record)
-          if record.record_timestamps
-            record.send(:all_timestamp_attributes).map { |x| x.to_s }
-          else
-            []
-          end
+        def invertible_for?(record)
+          false
         end
     end
   end

data/lib/active_record/associations/has_many_association.rb

@@ -5,19 +5,14 @@ module ActiveRecord
     #
     # If the association has a <tt>:through</tt> option further specialization
     # is provided by its child HasManyThroughAssociation.
-    class HasManyAssociation < AssociationCollection #:nodoc:
-      def initialize(owner, reflection)
-        @finder_sql = nil
-        super
+    class HasManyAssociation < CollectionAssociation #:nodoc:
+
+      def insert_record(record, validate = true)
+        set_owner_attributes(record)
+        record.save(:validate => validate)
       end
-      protected
-        def owner_quoted_id
-          if @reflection.options[:primary_key]
-            quote_value(@owner.send(@reflection.options[:primary_key]))
-          else
-            @owner.quoted_id
-          end
-        end
+
+      private
 
         # Returns the number of records in this collection.
         #
@@ -34,94 +29,70 @@ module ActiveRecord
         # the loaded flag is set to true as well.
         def count_records
           count = if has_cached_counter?
-            @owner.send(:read_attribute, cached_counter_attribute_name)
-          elsif @reflection.options[:finder_sql] || @reflection.options[:counter_sql]
-            @reflection.klass.count_by_sql(@counter_sql)
+            owner.send(:read_attribute, cached_counter_attribute_name)
+          elsif options[:counter_sql] || options[:finder_sql]
+            reflection.klass.count_by_sql(custom_counter_sql)
           else
-            @reflection.klass.count(:conditions => @counter_sql, :include => @reflection.options[:include])
+            scoped.count
           end
 
           # If there's nothing in the database and @target has no new records
           # we are certain the current target is an empty array. This is a
           # documented side-effect of the method that may avoid an extra SELECT.
-          @target ||= [] and loaded if count == 0
-
-          if @reflection.options[:limit]
-            count = [ @reflection.options[:limit], count ].min
-          end
-
-          return count
-        end
+          @target ||= [] and loaded! if count == 0
 
-        def has_cached_counter?
-          @owner.attribute_present?(cached_counter_attribute_name)
+          [options[:limit], count].compact.min
         end
 
-        def cached_counter_attribute_name
-          "#{@reflection.name}_count"
+        def has_cached_counter?(reflection = reflection)
+          owner.attribute_present?(cached_counter_attribute_name(reflection))
         end
 
-        def insert_record(record, force = false, validate = true)
-          set_belongs_to_association_for(record)
-          force ? record.save! : record.save(:validate => validate)
+        def cached_counter_attribute_name(reflection = reflection)
+          "#{reflection.name}_count"
         end
 
-        # Deletes the records according to the <tt>:dependent</tt> option.
-        def delete_records(records)
-          case @reflection.options[:dependent]
-            when :destroy
-              records.each { |r| r.destroy }
-            when :delete_all
-              @reflection.klass.delete(records.map { |record| record.id })
-            else
-              relation = Arel::Table.new(@reflection.table_name)
-              relation.where(relation[@reflection.primary_key_name].eq(@owner.id).
-                  and(relation[@reflection.klass.primary_key].in(records.map { |r| r.id }))
-              ).update(relation[@reflection.primary_key_name] => nil)
-
-              @owner.class.update_counters(@owner.id, cached_counter_attribute_name => -records.size) if has_cached_counter?
+        def update_counter(difference, reflection = reflection)
+          if has_cached_counter?(reflection)
+            counter = cached_counter_attribute_name(reflection)
+            owner.class.update_counters(owner.id, counter => difference)
+            owner[counter] += difference
+            owner.changed_attributes.delete(counter) # eww
           end
         end
 
-        def target_obsolete?
-          false
+        # This shit is nasty. We need to avoid the following situation:
+        #
+        #   * An associated record is deleted via record.destroy
+        #   * Hence the callbacks run, and they find a belongs_to on the record with a
+        #     :counter_cache options which points back at our owner. So they update the
+        #     counter cache.
+        #   * In which case, we must make sure to *not* update the counter cache, or else
+        #     it will be decremented twice.
+        #
+        # Hence this method.
+        def inverse_updates_counter_cache?(reflection = reflection)
+          counter_name = cached_counter_attribute_name(reflection)
+          reflection.klass.reflect_on_all_associations(:belongs_to).any? { |inverse_reflection|
+            inverse_reflection.counter_cache_column == counter_name
+          }
         end
 
-        def construct_sql
-          case
-            when @reflection.options[:finder_sql]
-              @finder_sql = interpolate_and_sanitize_sql(@reflection.options[:finder_sql])
-
-            when @reflection.options[:as]
-              @finder_sql =
-                "#{@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
+        # Deletes the records according to the <tt>:dependent</tt> option.
+        def delete_records(records, method)
+          if method == :destroy
+            records.each { |r| r.destroy }
+            update_counter(-records.length) unless inverse_updates_counter_cache?
+          else
+            keys  = records.map { |r| r[reflection.association_primary_key] }
+            scope = scoped.where(reflection.association_primary_key => keys)
 
+            if method == :delete_all
+              update_counter(-scope.delete_all)
             else
-              @finder_sql = "#{@reflection.quoted_table_name}.#{@reflection.primary_key_name} = #{owner_quoted_id}"
-              @finder_sql << " AND (#{conditions})" if conditions
+              update_counter(-scope.update_all(reflection.foreign_key => nil))
+            end
           end
-
-          construct_counter_sql
-        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],
-                       :include => @reflection.options[:include]},
-            :create => create_scoping
-          }
-        end
-
-        def we_can_set_the_inverse_on_this?(record)
-          inverse = @reflection.inverse_of
-          return !inverse.nil?
         end
     end
   end