activerecord 3.2.22.5 → 4.0.0.beta1

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -5,7 +5,7 @@ module ActiveRecord
       attr_reader :join_table
 
       def initialize(owner, reflection)
-        @join_table = Arel::Table.new(reflection.options[:join_table])
+        @join_table = Arel::Table.new(reflection.join_table)
         super
       end
 
@@ -32,10 +32,6 @@ module ActiveRecord
         record
       end
 
-      # ActiveRecord::Relation#delete_all needs to support joins before we can use a
-      # SQL-only implementation.
-      alias delete_all_on_destroy delete_all
-
       private
 
         def count_records
@@ -47,11 +43,17 @@ module ActiveRecord
             records = load_target if records == :all
             records.each { |record| owner.connection.delete(interpolate(sql, record)) }
           else
-            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
+            relation  = join_table
+            condition = relation[reflection.foreign_key].eq(owner.id)
+
+            unless records == :all
+              condition = condition.and(
+                relation[reflection.association_foreign_key]
+                  .in(records.map { |x| x.id }.compact)
+              )
+            end
+
+            owner.connection.delete(relation.where(condition).compile_delete)
           end
         end
 

data/lib/active_record/associations/has_many_association.rb

@@ -7,9 +7,30 @@ module ActiveRecord
     # is provided by its child HasManyThroughAssociation.
     class HasManyAssociation < CollectionAssociation #:nodoc:
 
+      def handle_dependency
+        case options[:dependent]
+        when :restrict, :restrict_with_exception
+          raise ActiveRecord::DeleteRestrictionError.new(reflection.name) unless empty?
+
+        when :restrict_with_error
+          unless empty?
+            record = klass.human_attribute_name(reflection.name).downcase
+            owner.errors.add(:base, :"restrict_dependent_destroy.many", record: record)
+            false
+          end
+
+        else
+          if options[:dependent] == :destroy
+            # No point in executing the counter update since we're going to destroy the parent anyway
+            load_target.each(&:mark_for_destruction)
+          end
+
+          delete_all
+        end
+      end
+
       def insert_record(record, validate = true, raise = false)
         set_owner_attributes(record)
-        set_inverse_instance(record)
 
         if raise
           record.save!(:validate => validate)
@@ -39,7 +60,7 @@ module ActiveRecord
           elsif options[:counter_sql] || options[:finder_sql]
             reflection.klass.count_by_sql(custom_counter_sql)
           else
-            scoped.count
+            scope.count
           end
 
           # If there's nothing in the database and @target has no new records
@@ -47,18 +68,18 @@ module ActiveRecord
           # documented side-effect of the method that may avoid an extra SELECT.
           @target ||= [] and loaded! if count == 0
 
-          [options[:limit], count].compact.min
+          [association_scope.limit_value, count].compact.min
         end
 
-        def has_cached_counter?(reflection = self.reflection)
+        def has_cached_counter?(reflection = reflection)
           owner.attribute_present?(cached_counter_attribute_name(reflection))
         end
 
-        def cached_counter_attribute_name(reflection = self.reflection)
-          "#{reflection.name}_count"
+        def cached_counter_attribute_name(reflection = reflection)
+          options[:counter_cache] || "#{reflection.name}_count"
         end
 
-        def update_counter(difference, reflection = self.reflection)
+        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)
@@ -77,7 +98,7 @@ module ActiveRecord
         #     it will be decremented twice.
         #
         # Hence this method.
-        def inverse_updates_counter_cache?(reflection = self.reflection)
+        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
@@ -90,7 +111,12 @@ module ActiveRecord
             records.each { |r| r.destroy }
             update_counter(-records.length) unless inverse_updates_counter_cache?
           else
-            scope = self.scoped.where(reflection.klass.primary_key => records)
+            if records == :all
+              scope = self.scope
+            else
+              keys  = records.map { |r| r[reflection.association_primary_key] }
+              scope = self.scope.where(reflection.association_primary_key => keys)
+            end
 
             if method == :delete_all
               update_counter(-scope.delete_all)

data/lib/active_record/associations/has_many_through_association.rb

@@ -1,4 +1,3 @@
-require 'active_support/core_ext/object/blank'
 
 module ActiveRecord
   # = Active Record Has Many Through Association
@@ -38,6 +37,20 @@ module ActiveRecord
         super
       end
 
+      def concat_records(records)
+        ensure_not_nested
+
+        records = super
+
+        if owner.new_record? && records
+          records.flatten.each do |record|
+            build_through_record(record)
+          end
+        end
+
+        records
+      end
+
       def insert_record(record, validate = true, raise = false)
         ensure_not_nested
 
@@ -54,10 +67,6 @@ module ActiveRecord
         record
       end
 
-      # ActiveRecord::Relation#delete_all needs to support joins before we can use a
-      # SQL-only implementation.
-      alias delete_all_on_destroy delete_all
-
       private
 
         def through_association
@@ -87,10 +96,10 @@ module ActiveRecord
           @through_records.delete(record.object_id)
         end
 
-        def build_record(attributes, options = {})
+        def build_record(attributes)
           ensure_not_nested
 
-          record = super(attributes, options)
+          record = super(attributes)
 
           inverse = source_reflection.inverse_of
           if inverse
@@ -105,11 +114,7 @@ module ActiveRecord
         end
 
         def target_reflection_has_associated_record?
-          if through_reflection.macro == :belongs_to && owner[through_reflection.foreign_key].blank?
-            false
-          else
-            true
-          end
+          !(through_reflection.macro == :belongs_to && owner[through_reflection.foreign_key].blank?)
         end
 
         def update_through_counter?(method)
@@ -126,7 +131,12 @@ module ActiveRecord
         def delete_records(records, method)
           ensure_not_nested
 
-          scope = through_association.scoped.where(construct_join_attributes(*records))
+          # This is unoptimised; it will load all the target records
+          # even when we just want to delete everything.
+          records = load_target if records == :all
+
+          scope = through_association.scope
+          scope.where! construct_join_attributes(*records)
 
           case method
           when :destroy
@@ -175,7 +185,7 @@ module ActiveRecord
 
         def find_target
           return [] unless target_reflection_has_associated_record?
-          scoped.all
+          scope.to_a
         end
 
         # NOTE - not sure that we can actually cope with inverses here

data/lib/active_record/associations/has_one_association.rb

@@ -1,9 +1,26 @@
-require 'active_support/core_ext/object/inclusion'
 
 module ActiveRecord
   # = Active Record Belongs To Has One Association
   module Associations
     class HasOneAssociation < SingularAssociation #:nodoc:
+
+      def handle_dependency
+        case options[:dependent]
+        when :restrict, :restrict_with_exception
+          raise ActiveRecord::DeleteRestrictionError.new(reflection.name) if load_target
+
+        when :restrict_with_error
+          if load_target
+            record = klass.human_attribute_name(reflection.name).downcase
+            owner.errors.add(:base, :"restrict_dependent_destroy.one", record: record)
+            false
+          end
+
+        else
+          delete
+        end
+      end
+
       def replace(record, save = true)
         raise_on_type_mismatch(record) if record
         load_target
@@ -13,11 +30,11 @@ module ActiveRecord
         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
@@ -38,7 +55,7 @@ module ActiveRecord
             when :destroy
               target.destroy
             when :nullify
-              target.update_attribute(reflection.foreign_key, nil)
+              target.update_columns(reflection.foreign_key => nil)
           end
         end
       end
@@ -54,16 +71,19 @@ module ActiveRecord
         end
 
         def remove_target!(method)
-          if method.in?([:delete, :destroy])
-            target.send(method)
-          else
-            nullify_owner_attributes(target)
+          case method
+            when :delete
+              target.delete
+            when :destroy
+              target.destroy
+            else
+              nullify_owner_attributes(target)
 
-            if target.persisted? && owner.persisted? && !target.save
-              set_owner_attributes(target)
-              raise RecordNotSaved, "Failed to remove the existing associated #{reflection.name}. " +
-                                    "The record failed to save when after its foreign key was set to nil."
-            end
+              if target.persisted? && owner.persisted? && !target.save
+                set_owner_attributes(target)
+                raise RecordNotSaved, "Failed to remove the existing associated #{reflection.name}. " +
+                                      "The record failed to save after its foreign key was set to nil."
+              end
           end
         end
 

data/lib/active_record/associations/has_one_through_association.rb

@@ -23,7 +23,7 @@ module ActiveRecord
             attributes = construct_join_attributes(record)
 
             if through_record
-              through_record.update_attributes(attributes)
+              through_record.update(attributes)
             elsif owner.new_record?
               through_proxy.build(attributes)
             else

data/lib/active_record/associations/join_dependency.rb

@@ -68,7 +68,7 @@ module ActiveRecord
             remove_duplicate_results!(base, records, association)
           end
         when Hash
-          associations.keys.each do |name|
+          associations.each_key do |name|
             reflection = base.reflections[name]
             remove_uniq_by_reflection(reflection, records)
 
@@ -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 on #{parent.active_record.name}; perhaps you misspelled it?"
+          raise ConfigurationError, "Association named '#{ associations }' was not found; perhaps you misspelled it?"
           unless join_association = find_join_association(reflection, parent)
             @reflections << reflection
             join_association = build_join_association(reflection, parent)

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

@@ -55,12 +55,7 @@ module ActiveRecord
 
         def find_parent_in(other_join_dependency)
           other_join_dependency.join_parts.detect do |join_part|
-            case parent
-            when JoinBase
-              parent.active_record == join_part.active_record
-            else
-              parent == join_part
-            end
+            parent == join_part
           end
         end
 
@@ -97,11 +92,21 @@ module ActiveRecord
 
             constraint = build_constraint(reflection, table, key, foreign_table, foreign_key)
 
-            conditions = self.conditions[i].dup
-            conditions << { reflection.type => foreign_klass.base_class.name } if reflection.type
+            scope_chain_items = scope_chain[i]
+
+            if reflection.type
+              scope_chain_items += [
+                ActiveRecord::Relation.new(reflection.klass, table)
+                  .where(reflection.type => foreign_klass.base_class.name)
+              ]
+            end
+
+            scope_chain_items.each do |item|
+              unless item.is_a?(Relation)
+                item = ActiveRecord::Relation.new(reflection.klass, table).instance_exec(self, &item)
+              end
 
-            unless conditions.empty?
-              constraint = constraint.and(sanitize(conditions, table))
+              constraint = constraint.and(item.arel.constraints) unless item.arel.constraints.empty?
             end
 
             relation.from(join(table, constraint))
@@ -139,18 +144,8 @@ module ActiveRecord
           table.table_alias || table.name
         end
 
-        def conditions
-          @conditions ||= reflection.conditions.reverse
-        end
-
-        private
-
-        def interpolate(conditions)
-          if conditions.respond_to?(:to_proc) && !conditions.is_a?(Hash)
-            instance_eval(&conditions)
-          else
-            conditions
-          end
+        def scope_chain
+          @scope_chain ||= reflection.scope_chain.reverse
         end
 
       end

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

@@ -54,7 +54,7 @@ module ActiveRecord
           unless @column_names_with_alias
             @column_names_with_alias = []
 
-            ([primary_key] + (column_names - [primary_key])).each_with_index do |column_name, i|
+            ([primary_key] + (column_names - [primary_key])).compact.each_with_index do |column_name, i|
               @column_names_with_alias << [column_name, "#{aliased_prefix}_r#{i}"]
             end
           end

data/lib/active_record/associations/join_helper.rb

@@ -19,7 +19,7 @@ module ActiveRecord
 
           if reflection.source_macro == :has_and_belongs_to_many
             tables << alias_tracker.aliased_table_for(
-              (reflection.source_reflection || reflection).options[:join_table],
+              (reflection.source_reflection || reflection).join_table,
               table_alias_for(reflection, true)
             )
           end
@@ -40,16 +40,6 @@ module ActiveRecord
       def join(table, constraint)
         table.create_join(table, table.create_on(constraint), join_type)
       end
-
-      def sanitize(conditions, table)
-        conditions = conditions.map do |condition|
-          condition = active_record.send(:sanitize_sql, interpolate(condition), table.table_alias || table.name)
-          condition = Arel.sql(condition) unless condition.is_a?(Arel::Node)
-          condition
-        end
-
-        conditions.length == 1 ? conditions.first : Arel::Nodes::And.new(conditions)
-      end
     end
   end
 end

data/lib/active_record/associations/preloader.rb

@@ -12,7 +12,7 @@ module ActiveRecord
     # and all of its books via a single query:
     #
     #   SELECT * FROM authors
-    #   LEFT OUTER JOIN books ON authors.id = books.id
+    #   LEFT OUTER JOIN books ON authors.id = books.author_id
     #   WHERE authors.name = 'Ken Akamatsu'
     #
     # However, this could result in many rows that contain redundant data. After
@@ -46,7 +46,7 @@ module ActiveRecord
         autoload :BelongsTo,           'active_record/associations/preloader/belongs_to'
       end
 
-      attr_reader :records, :associations, :options, :model
+      attr_reader :records, :associations, :preload_scope, :model
 
       # Eager loads the named associations for the given Active Record record(s).
       #
@@ -72,7 +72,7 @@ module ActiveRecord
       #   books.
       # - a Hash which specifies multiple association names, as well as
       #   association names for the to-be-preloaded association objects. For
-      #   example, specifying <tt>{ :author => :avatar }</tt> will preload a
+      #   example, specifying <tt>{ author: :avatar }</tt> will preload a
       #   book's author, as well as that author's avatar.
       #
       # +:associations+ has the same format as the +:include+ option for
@@ -80,17 +80,12 @@ module ActiveRecord
       #
       #   :books
       #   [ :books, :author ]
-      #   { :author => :avatar }
-      #   [ :books, { :author => :avatar } ]
-      #
-      # +options+ contains options that will be passed to ActiveRecord::Base#find
-      # (which is called under the hood for preloading records). But it is passed
-      # only one level deep in the +associations+ argument, i.e. it's not passed
-      # to the child associations when +associations+ is a Hash.
-      def initialize(records, associations, options = {})
-        @records      = Array.wrap(records).compact.uniq
-        @associations = Array.wrap(associations)
-        @options      = options
+      #   { author: :avatar }
+      #   [ :books, { author: :avatar } ]
+      def initialize(records, associations, preload_scope = nil)
+        @records       = Array.wrap(records).compact.uniq
+        @associations  = Array.wrap(associations)
+        @preload_scope = preload_scope || Relation.new(nil, nil)
       end
 
       def run
@@ -105,7 +100,9 @@ module ActiveRecord
         case association
         when Hash
           preload_hash(association)
-        when String, Symbol
+        when Symbol
+          preload_one(association)
+        when String
           preload_one(association.to_sym)
         else
           raise ArgumentError, "#{association.inspect} was not recognised for preload"
@@ -114,7 +111,7 @@ module ActiveRecord
 
       def preload_hash(association)
         association.each do |parent, child|
-          Preloader.new(records, parent, options).run
+          Preloader.new(records, parent, preload_scope).run
           Preloader.new(records.map { |record| record.send(parent) }.flatten, child).run
         end
       end
@@ -129,7 +126,7 @@ module ActiveRecord
       def preload_one(association)
         grouped_records(association).each do |reflection, klasses|
           klasses.each do |klass, records|
-            preloader_for(reflection).new(klass, records, reflection, options).run
+            preloader_for(reflection).new(klass, records, reflection, preload_scope).run
           end
         end
       end