activerecord 3.1.12 → 3.2.22.1

data/lib/active_record/associations/collection_proxy.rb

@@ -1,12 +1,5 @@
-require 'active_support/deprecation'
-
 module ActiveRecord
   module Associations
-    AssociationCollection = ActiveSupport::Deprecation::DeprecatedConstantProxy.new(
-      'ActiveRecord::Associations::AssociationCollection',
-      'ActiveRecord::Associations::CollectionProxy'
-    )
-
     # 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
@@ -46,7 +39,7 @@ module ActiveRecord
       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
+               :lock, :readonly, :having, :pluck, :to => :scoped
 
       delegate :target, :load_target, :loaded?, :to => :@association
 
@@ -84,14 +77,15 @@ module ActiveRecord
       def method_missing(method, *args, &block)
         match = DynamicFinderMatch.match(method)
         if match && match.instantiator?
-          send(:find_or_instantiator_by_attributes, match, match.attribute_names, *args) do |r|
-            proxy_association.send :set_owner_attributes, r
-            proxy_association.send :add_to_target, r
-            yield(r) if block_given?
+          send(:find_or_instantiator_by_attributes, match, match.attribute_names, *args) do |record|
+            proxy_association.send :set_owner_attributes, record
+            proxy_association.send :add_to_target, record
+            yield(record) if block_given?
+          end.tap do |record|
+            proxy_association.send :set_inverse_instance, record
           end
-        end
 
-        if target.respond_to?(method) || (!proxy_association.klass.respond_to?(method) && Class.respond_to?(method))
+        elsif target.respond_to?(method) || (!proxy_association.klass.respond_to?(method) && Class.respond_to?(method))
           if load_target
             if target.respond_to?(method)
               target.send(method, *args, &block)
@@ -134,33 +128,6 @@ module ActiveRecord
         proxy_association.reload
         self
       end
-
-      def proxy_owner
-        ActiveSupport::Deprecation.warn(
-          "Calling record.#{@association.reflection.name}.proxy_owner is deprecated. Please use " \
-          "record.association(:#{@association.reflection.name}).owner instead. Or, from an " \
-          "association extension you can access proxy_association.owner."
-        )
-        proxy_association.owner
-      end
-
-      def proxy_target
-        ActiveSupport::Deprecation.warn(
-          "Calling record.#{@association.reflection.name}.proxy_target is deprecated. Please use " \
-          "record.association(:#{@association.reflection.name}).target instead. Or, from an " \
-          "association extension you can access proxy_association.target."
-        )
-        proxy_association.target
-      end
-
-      def proxy_reflection
-        ActiveSupport::Deprecation.warn(
-          "Calling record.#{@association.reflection.name}.proxy_reflection is deprecated. Please use " \
-          "record.association(:#{@association.reflection.name}).reflection instead. Or, from an " \
-          "association extension you can access proxy_association.reflection."
-        )
-        proxy_association.reflection
-      end
     end
   end
 end

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -44,6 +44,7 @@ module ActiveRecord
 
         def delete_records(records, method)
           if sql = options[:delete_sql]
+            records = load_target if records == :all
             records.each { |record| owner.connection.delete(interpolate(sql, record)) }
           else
             relation = join_table

data/lib/active_record/associations/has_many_association.rb

@@ -9,6 +9,7 @@ module ActiveRecord
 
       def insert_record(record, validate = true, raise = false)
         set_owner_attributes(record)
+        set_inverse_instance(record)
 
         if raise
           record.save!(:validate => validate)
@@ -23,7 +24,7 @@ module ActiveRecord
         #
         # If the association has a counter cache it gets that value. Otherwise
         # it will attempt to do a count via SQL, bounded to <tt>:limit</tt> if
-        # there's one.  Some configuration options like :group make it impossible
+        # there's one. Some configuration options like :group make it impossible
         # to do an SQL count, in those cases the array count will be used.
         #
         # That does not depend on whether the collection has already been loaded
@@ -49,15 +50,15 @@ module ActiveRecord
           [options[:limit], count].compact.min
         end
 
-        def has_cached_counter?(reflection = reflection)
+        def has_cached_counter?(reflection = self.reflection)
           owner.attribute_present?(cached_counter_attribute_name(reflection))
         end
 
-        def cached_counter_attribute_name(reflection = reflection)
+        def cached_counter_attribute_name(reflection = self.reflection)
           "#{reflection.name}_count"
         end
 
-        def update_counter(difference, reflection = reflection)
+        def update_counter(difference, reflection = self.reflection)
           if has_cached_counter?(reflection)
             counter = cached_counter_attribute_name(reflection)
             owner.class.update_counters(owner.id, counter => difference)
@@ -76,7 +77,7 @@ module ActiveRecord
         #     it will be decremented twice.
         #
         # Hence this method.
-        def inverse_updates_counter_cache?(reflection = reflection)
+        def inverse_updates_counter_cache?(reflection = self.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
@@ -89,8 +90,7 @@ module ActiveRecord
             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)
+            scope = self.scoped.where(reflection.klass.primary_key => records)
 
             if method == :delete_all
               update_counter(-scope.delete_all)
@@ -99,6 +99,10 @@ module ActiveRecord
             end
           end
         end
+
+        def foreign_key_present?
+          owner.attribute_present?(reflection.association_primary_key)
+        end
     end
   end
 end

data/lib/active_record/associations/has_many_through_association.rb

@@ -8,7 +8,9 @@ module ActiveRecord
 
       def initialize(owner, reflection)
         super
-        @through_records = {}
+
+        @through_records     = {}
+        @through_association = nil
       end
 
       # Returns the size of the collection by executing a SELECT COUNT(*) query if the collection hasn't been
@@ -59,7 +61,7 @@ module ActiveRecord
       private
 
         def through_association
-          owner.association(through_reflection.name)
+          @through_association ||= owner.association(through_reflection.name)
         end
 
         # We temporarily cache through record that has been build, because if we build a
@@ -71,7 +73,9 @@ module ActiveRecord
         # association
         def build_through_record(record)
           @through_records[record.object_id] ||= begin
-            through_record = through_association.build(construct_join_attributes(record))
+            ensure_mutable
+
+            through_record = through_association.build
             through_record.send("#{source_reflection.name}=", record)
             through_record
           end
@@ -122,8 +126,7 @@ module ActiveRecord
         def delete_records(records, method)
           ensure_not_nested
 
-          through = through_association
-          scope   = through.scoped.where(construct_join_attributes(*records))
+          scope = through_association.scoped.where(construct_join_attributes(*records))
 
           case method
           when :destroy
@@ -134,7 +137,12 @@ module ActiveRecord
             count = scope.delete_all
           end
 
-          delete_through_records(through, records)
+          delete_through_records(records)
+
+          if source_reflection.options[:counter_cache]
+            counter = source_reflection.counter_cache_column
+            klass.decrement_counter counter, records.map(&:id)
+          end
 
           if through_reflection.macro == :has_many && update_through_counter?(method)
             update_counter(-count, through_reflection)
@@ -149,14 +157,16 @@ module ActiveRecord
           candidates.find_all { |c| c.attributes.slice(*attributes.keys) == attributes }
         end
 
-        def delete_through_records(through, records)
+        def delete_through_records(records)
           records.each do |record|
             through_records = through_records_for(record)
 
             if through_reflection.macro == :has_many
-              through_records.each { |r| through.target.delete(r) }
+              through_records.each { |r| through_association.target.delete(r) }
             else
-              through.target = nil if through_records.include?(through.target)
+              if through_records.include?(through_association.target)
+                through_association.target = nil
+              end
             end
 
             @through_records.delete(record.object_id)

data/lib/active_record/associations/has_one_association.rb

@@ -8,19 +8,21 @@ module ActiveRecord
         raise_on_type_mismatch(record) if record
         load_target
 
-        reflection.klass.transaction do
-          if target && target != record
-            remove_target!(options[:dependent]) unless target.destroyed?
-          end
-
-          if record
-            set_owner_attributes(record)
-            set_inverse_instance(record)
-
-            if owner.persisted? && save && !record.save
-              nullify_owner_attributes(record)
-              set_owner_attributes(target) if target
-              raise RecordNotSaved, "Failed to save the new associated #{reflection.name}."
+        # If target and record are nil, or target is equal to record,
+        # we don't need to have transaction.
+        if (target || record) && target != record
+          transaction_if(save) do
+            remove_target!(options[:dependent]) if target && !target.destroyed?
+  
+            if record
+              set_owner_attributes(record)
+              set_inverse_instance(record)
+  
+              if owner.persisted? && save && !record.save
+                nullify_owner_attributes(record)
+                set_owner_attributes(target) if target
+                raise RecordNotSaved, "Failed to save the new associated #{reflection.name}."
+              end
             end
           end
         end
@@ -68,6 +70,14 @@ module ActiveRecord
         def nullify_owner_attributes(record)
           record[reflection.foreign_key] = nil
         end
+
+        def transaction_if(value)
+          if value
+            reflection.klass.transaction { yield }
+          else
+            yield
+          end
+        end
     end
   end
 end

data/lib/active_record/associations/join_dependency/join_association.rb

@@ -55,7 +55,12 @@ module ActiveRecord
 
         def find_parent_in(other_join_dependency)
           other_join_dependency.join_parts.detect do |join_part|
-            parent == join_part
+            case parent
+            when JoinBase
+              parent.active_record == join_part.active_record
+            else
+              parent == join_part
+            end
           end
         end
 

data/lib/active_record/associations/join_dependency.rb

@@ -13,7 +13,7 @@ module ActiveRecord
         @join_parts    = [JoinBase.new(base)]
         @associations  = {}
         @reflections   = []
-        @alias_tracker = AliasTracker.new(joins)
+        @alias_tracker = AliasTracker.new(base.connection, joins)
         @alias_tracker.aliased_name_for(base.table_name) # Updates the count for base.table_name to 1
         build(associations)
       end
@@ -109,7 +109,7 @@ module ActiveRecord
         case associations
         when Symbol, String
           reflection = parent.reflections[associations.to_s.intern] or
-          raise ConfigurationError, "Association named '#{ associations }' was not found; perhaps you misspelled it?"
+          raise ConfigurationError, "Association named '#{ associations }' was not found on #{parent.active_record.name}; perhaps you misspelled it?"
           unless join_association = find_join_association(reflection, parent)
             @reflections << reflection
             join_association = build_join_association(reflection, parent)
@@ -184,7 +184,7 @@ module ActiveRecord
 
         macro = join_part.reflection.macro
         if macro == :has_one
-          return if record.association_cache.key?(join_part.reflection.name)
+          return record.association(join_part.reflection.name).target if record.association_cache.key?(join_part.reflection.name)
           association = join_part.instantiate(row) unless row[join_part.aliased_primary_key].nil?
           set_target_and_inverse(join_part, association, record)
         else

data/lib/active_record/associations/preloader/through_association.rb

@@ -37,7 +37,8 @@ module ActiveRecord
             through_records = Array.wrap(owner.send(through_reflection.name))
 
             # Dont cache the association - we would only be caching a subset
-            if reflection.options[:source_type] && through_reflection.collection?
+            if (preload_options != through_options) ||
+               (reflection.options[:source_type] && through_reflection.collection?)
               owner.association(through_reflection.name).reset
             end
 
@@ -55,8 +56,7 @@ module ActiveRecord
               through_options[:include]    = options[:include] || options[:source]
               through_options[:conditions] = options[:conditions]
             end
-
-            through_options[:order] = options[:order]
+            through_options[:order] = options[:order] if options.has_key?(:order)
           end
 
           through_options

data/lib/active_record/associations/preloader.rb

@@ -30,17 +30,21 @@ module ActiveRecord
     # option references an association's column), it will fallback to the table
     # join strategy.
     class Preloader #:nodoc:
-      autoload :Association,           'active_record/associations/preloader/association'
-      autoload :SingularAssociation,   'active_record/associations/preloader/singular_association'
-      autoload :CollectionAssociation, 'active_record/associations/preloader/collection_association'
-      autoload :ThroughAssociation,    'active_record/associations/preloader/through_association'
+      extend ActiveSupport::Autoload
 
-      autoload :HasMany,             'active_record/associations/preloader/has_many'
-      autoload :HasManyThrough,      'active_record/associations/preloader/has_many_through'
-      autoload :HasOne,              'active_record/associations/preloader/has_one'
-      autoload :HasOneThrough,       'active_record/associations/preloader/has_one_through'
-      autoload :HasAndBelongsToMany, 'active_record/associations/preloader/has_and_belongs_to_many'
-      autoload :BelongsTo,           'active_record/associations/preloader/belongs_to'
+      eager_autoload do
+        autoload :Association,           'active_record/associations/preloader/association'
+        autoload :SingularAssociation,   'active_record/associations/preloader/singular_association'
+        autoload :CollectionAssociation, 'active_record/associations/preloader/collection_association'
+        autoload :ThroughAssociation,    'active_record/associations/preloader/through_association'
+
+        autoload :HasMany,             'active_record/associations/preloader/has_many'
+        autoload :HasManyThrough,      'active_record/associations/preloader/has_many_through'
+        autoload :HasOne,              'active_record/associations/preloader/has_one'
+        autoload :HasOneThrough,       'active_record/associations/preloader/has_one_through'
+        autoload :HasAndBelongsToMany, 'active_record/associations/preloader/has_and_belongs_to_many'
+        autoload :BelongsTo,           'active_record/associations/preloader/belongs_to'
+      end
 
       attr_reader :records, :associations, :options, :model
 

data/lib/active_record/associations/through_association.rb

@@ -37,9 +37,7 @@ module ActiveRecord
         # situation it is more natural for the user to just create or modify their join records
         # directly as required.
         def construct_join_attributes(*records)
-          if source_reflection.macro != :belongs_to
-            raise HasManyThroughCantAssociateThroughHasOneOrManyReflection.new(owner, reflection)
-          end
+          ensure_mutable
 
           join_attributes = {
             source_reflection.foreign_key =>
@@ -64,7 +62,7 @@ module ActiveRecord
         # properly support stale-checking for nested associations.
         def stale_state
           if through_reflection.macro == :belongs_to
-            owner[through_reflection.foreign_key].to_s
+            owner[through_reflection.foreign_key] && owner[through_reflection.foreign_key].to_s
           end
         end
 
@@ -73,6 +71,12 @@ module ActiveRecord
           !owner[through_reflection.foreign_key].nil?
         end
 
+        def ensure_mutable
+          if source_reflection.macro != :belongs_to
+            raise HasManyThroughCantAssociateThroughHasOneOrManyReflection.new(owner, reflection)
+          end
+        end
+
         def ensure_not_nested
           if reflection.nested?
             raise HasManyThroughNestedAssociationsAreReadonly.new(owner, reflection)