activerecord 5.2.0 → 5.2.3

data/lib/active_record/associations/collection_association.rb

@@ -45,6 +45,8 @@ module ActiveRecord
       def ids_reader
         if loaded?
           target.pluck(reflection.association_primary_key)
+        elsif !target.empty?
+          load_target.pluck(reflection.association_primary_key)
         else
           @association_ids ||= scope.pluck(reflection.association_primary_key)
         end
@@ -103,15 +105,12 @@ module ActiveRecord
         if attributes.is_a?(Array)
           attributes.collect { |attr| build(attr, &block) }
         else
-          add_to_target(build_record(attributes)) do |record|
-            yield(record) if block_given?
-          end
+          add_to_target(build_record(attributes, &block))
         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.
+      # Add +records+ to this association. Since +<<+ flattens its argument list
+      # and inserts each record, +push+ and +concat+ behave identically.
       def concat(*records)
         records = records.flatten
         if owner.new_record?
@@ -356,15 +355,17 @@ module ActiveRecord
           if attributes.is_a?(Array)
             attributes.collect { |attr| _create_record(attr, raise, &block) }
           else
+            record = build_record(attributes, &block)
             transaction do
-              add_to_target(build_record(attributes)) do |record|
-                yield(record) if block_given?
-                insert_record(record, true, raise) {
+              result = nil
+              add_to_target(record) do
+                result = insert_record(record, true, raise) {
                   @_was_loaded = loaded?
-                  @association_ids = nil
                 }
               end
+              raise ActiveRecord::Rollback unless result
             end
+            record
           end
         end
 
@@ -396,6 +397,7 @@ module ActiveRecord
 
           delete_records(existing_records, method) if existing_records.any?
           records.each { |record| target.delete(record) }
+          @association_ids = nil
 
           records.each { |record| callback(:after_remove, record) }
         end
@@ -408,9 +410,9 @@ module ActiveRecord
         end
 
         def replace_records(new_target, original_target)
-          delete(target - new_target)
+          delete(difference(target, new_target))
 
-          unless concat(new_target - target)
+          unless concat(difference(new_target, target))
             @target = original_target
             raise RecordNotSaved, "Failed to replace #{reflection.name} because one or more of the " \
                                   "new records could not be saved."
@@ -420,7 +422,7 @@ module ActiveRecord
         end
 
         def replace_common_records_in_memory(new_target, original_target)
-          common_records = new_target & original_target
+          common_records = intersection(new_target, original_target)
           common_records.each do |record|
             skip_callbacks = true
             replace_on_target(record, @target.index(record), skip_callbacks)
@@ -436,13 +438,14 @@ module ActiveRecord
               unless owner.new_record?
                 result &&= insert_record(record, true, raise) {
                   @_was_loaded = loaded?
-                  @association_ids = nil
                 }
               end
             end
           end
 
-          result && records
+          raise ActiveRecord::Rollback unless result
+
+          records
         end
 
         def replace_on_target(record, index, skip_callbacks)
@@ -457,6 +460,7 @@ module ActiveRecord
           if index
             target[index] = record
           elsif @_was_loaded || !loaded?
+            @association_ids = nil
             target << record
           end
 

data/lib/active_record/associations/collection_proxy.rb

@@ -366,34 +366,6 @@ module ActiveRecord
         @association.create!(attributes, &block)
       end
 
-      # Add one or more records to the collection by setting their foreign keys
-      # to the association's primary key. Since #<< flattens its argument list and
-      # inserts each record, +push+ and #concat behave identically. Returns +self+
-      # so method calls may be chained.
-      #
-      #   class Person < ActiveRecord::Base
-      #     has_many :pets
-      #   end
-      #
-      #   person.pets.size # => 0
-      #   person.pets.concat(Pet.new(name: 'Fancy-Fancy'))
-      #   person.pets.concat(Pet.new(name: 'Spook'), Pet.new(name: 'Choo-Choo'))
-      #   person.pets.size # => 3
-      #
-      #   person.id # => 1
-      #   person.pets
-      #   # => [
-      #   #       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
-      #   #       #<Pet id: 2, name: "Spook", person_id: 1>,
-      #   #       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
-      #   #    ]
-      #
-      #   person.pets.concat([Pet.new(name: 'Brain'), Pet.new(name: 'Benny')])
-      #   person.pets.size # => 5
-      def concat(*records)
-        @association.concat(*records)
-      end
-
       # Replaces this collection with +other_array+. This will perform a diff
       # and delete/add only records that have changed.
       #
@@ -500,7 +472,7 @@ module ActiveRecord
       #   Pet.find(1, 2, 3)
       #   # => ActiveRecord::RecordNotFound: Couldn't find all Pets with 'id': (1, 2, 3)
       def delete_all(dependent = nil)
-        @association.delete_all(dependent)
+        @association.delete_all(dependent).tap { reset_scope }
       end
 
       # Deletes the records of the collection directly from the database
@@ -527,7 +499,7 @@ module ActiveRecord
       #
       #   Pet.find(1) # => Couldn't find Pet with id=1
       def destroy_all
-        @association.destroy_all
+        @association.destroy_all.tap { reset_scope }
       end
 
       # Deletes the +records+ supplied from the collection according to the strategy
@@ -646,7 +618,7 @@ module ActiveRecord
       #   #       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
       #   #    ]
       def delete(*records)
-        @association.delete(*records)
+        @association.delete(*records).tap { reset_scope }
       end
 
       # Destroys the +records+ supplied and removes them from the collection.
@@ -718,7 +690,7 @@ module ActiveRecord
       #
       #   Pet.find(4, 5, 6) # => ActiveRecord::RecordNotFound: Couldn't find all Pets with 'id': (4, 5, 6)
       def destroy(*records)
-        @association.destroy(*records)
+        @association.destroy(*records).tap { reset_scope }
       end
 
       ##
@@ -1033,8 +1005,9 @@ module ActiveRecord
       end
 
       # Adds one or more +records+ to the collection by setting their foreign keys
-      # to the association's primary key. Returns +self+, so several appends may be
-      # chained together.
+      # to the association's primary key. Since +<<+ flattens its argument list and
+      # inserts each record, +push+ and +concat+ behave identically. Returns +self+
+      # so several appends may be chained together.
       #
       #   class Person < ActiveRecord::Base
       #     has_many :pets
@@ -1057,6 +1030,7 @@ module ActiveRecord
       end
       alias_method :push, :<<
       alias_method :append, :<<
+      alias_method :concat, :<<
 
       def prepend(*args)
         raise NoMethodError, "prepend on association is not defined. Please use <<, push or append"

data/lib/active_record/associations/has_many_association.rb

@@ -99,6 +99,7 @@ module ActiveRecord
         def delete_or_nullify_all_records(method)
           count = delete_count(method, scope)
           update_counter(-count)
+          count
         end
 
         # Deletes the records according to the <tt>:dependent</tt> option.
@@ -130,6 +131,14 @@ module ActiveRecord
           end
           saved_successfully
         end
+
+        def difference(a, b)
+          a - b
+        end
+
+        def intersection(a, b)
+          a & b
+        end
     end
   end
 end

data/lib/active_record/associations/has_many_through_association.rb

@@ -90,7 +90,7 @@ module ActiveRecord
         def build_record(attributes)
           ensure_not_nested
 
-          record = super(attributes)
+          record = super
 
           inverse = source_reflection.inverse_of
           if inverse
@@ -161,6 +161,30 @@ module ActiveRecord
           else
             update_counter(-count)
           end
+
+          count
+        end
+
+        def difference(a, b)
+          distribution = distribution(b)
+
+          a.reject { |record| mark_occurrence(distribution, record) }
+        end
+
+        def intersection(a, b)
+          distribution = distribution(b)
+
+          a.select { |record| mark_occurrence(distribution, record) }
+        end
+
+        def mark_occurrence(distribution, record)
+          distribution[record] > 0 && distribution[record] -= 1
+        end
+
+        def distribution(array)
+          array.each_with_object(Hash.new(0)) do |record, distribution|
+            distribution[record] += 1
+          end
         end
 
         def through_records_for(record)

data/lib/active_record/associations/has_one_association.rb

@@ -107,6 +107,14 @@ module ActiveRecord
             yield
           end
         end
+
+        def _create_record(attributes, raise_error = false, &block)
+          unless owner.persisted?
+            raise ActiveRecord::RecordNotSaved, "You cannot call create unless the parent is saved"
+          end
+
+          super
+        end
     end
   end
 end

data/lib/active_record/associations/has_one_through_association.rb

@@ -28,7 +28,11 @@ module ActiveRecord
             end
 
             if through_record
-              through_record.update(attributes)
+              if through_record.new_record?
+                through_record.assign_attributes(attributes)
+              else
+                through_record.update(attributes)
+              end
             elsif owner.new_record? || !save
               through_proxy.build(attributes)
             else

data/lib/active_record/associations/join_dependency.rb

@@ -67,63 +67,31 @@ module ActiveRecord
         end
       end
 
-      # base is the base class on which operation is taking place.
-      # associations is the list of associations which are joined using hash, symbol or array.
-      # joins is the list of all string join commands and arel nodes.
-      #
-      #  Example :
-      #
-      #  class Physician < ActiveRecord::Base
-      #    has_many :appointments
-      #    has_many :patients, through: :appointments
-      #  end
-      #
-      #  If I execute `@physician.patients.to_a` then
-      #    base # => Physician
-      #    associations # => []
-      #    joins # =>  [#<Arel::Nodes::InnerJoin: ...]
-      #
-      #  However if I execute `Physician.joins(:appointments).to_a` then
-      #    base # => Physician
-      #    associations # => [:appointments]
-      #    joins # =>  []
-      #
-      def initialize(base, table, associations, alias_tracker)
-        @alias_tracker = alias_tracker
+      def initialize(base, table, associations)
         tree = self.class.make_tree associations
         @join_root = JoinBase.new(base, table, build(tree, base))
-        @join_root.children.each { |child| construct_tables! @join_root, child }
       end
 
       def reflections
         join_root.drop(1).map!(&:reflection)
       end
 
-      def join_constraints(joins_to_add, join_type)
-        joins = join_root.children.flat_map { |child|
-          make_join_constraints(join_root, child, join_type)
-        }
+      def join_constraints(joins_to_add, join_type, alias_tracker)
+        @alias_tracker = alias_tracker
+
+        construct_tables!(join_root)
+        joins = make_join_constraints(join_root, join_type)
 
         joins.concat joins_to_add.flat_map { |oj|
+          construct_tables!(oj.join_root)
           if join_root.match? oj.join_root
             walk join_root, oj.join_root
           else
-            oj.join_root.children.flat_map { |child|
-              make_join_constraints(oj.join_root, child, join_type)
-            }
+            make_join_constraints(oj.join_root, join_type)
           end
         }
       end
 
-      def aliases
-        @aliases ||= Aliases.new join_root.each_with_index.map { |join_part, i|
-          columns = join_part.column_names.each_with_index.map { |column_name, j|
-            Aliases::Column.new column_name, "t#{i}_r#{j}"
-          }
-          Aliases::Table.new(join_part, columns)
-        }
-      end
-
       def instantiate(result_set, &block)
         primary_key = aliases.column_alias(join_root, join_root.primary_key)
 
@@ -155,28 +123,40 @@ module ActiveRecord
         parents.values
       end
 
+      def apply_column_aliases(relation)
+        relation._select!(-> { aliases.columns })
+      end
+
       protected
-        attr_reader :alias_tracker, :base_klass, :join_root
+        attr_reader :alias_tracker, :join_root
 
       private
-
-        def make_constraints(parent, child, tables, join_type)
-          chain         = child.reflection.chain
-          foreign_table = parent.table
-          foreign_klass = parent.base_klass
-          child.join_constraints(foreign_table, foreign_klass, join_type, tables, chain)
+        def aliases
+          @aliases ||= Aliases.new join_root.each_with_index.map { |join_part, i|
+            columns = join_part.column_names.each_with_index.map { |column_name, j|
+              Aliases::Column.new column_name, "t#{i}_r#{j}"
+            }
+            Aliases::Table.new(join_part, columns)
+          }
         end
 
-        def make_outer_joins(parent, child)
-          join_type = Arel::Nodes::OuterJoin
-          make_join_constraints(parent, child, join_type, true)
+        def construct_tables!(join_root)
+          join_root.each_children do |parent, child|
+            child.tables = table_aliases_for(parent, child)
+          end
         end
 
-        def make_join_constraints(parent, child, join_type, aliasing = false)
-          tables = aliasing ? table_aliases_for(parent, child) : child.tables
-          joins  = make_constraints(parent, child, tables, join_type)
+        def make_join_constraints(join_root, join_type)
+          join_root.children.flat_map do |child|
+            make_constraints(join_root, child, join_type)
+          end
+        end
 
-          joins.concat child.children.flat_map { |c| make_join_constraints(child, c, join_type, aliasing) }
+        def make_constraints(parent, child, join_type = Arel::Nodes::OuterJoin)
+          foreign_table = parent.table
+          foreign_klass = parent.base_klass
+          joins = child.join_constraints(foreign_table, foreign_klass, join_type, alias_tracker)
+          joins.concat child.children.flat_map { |c| make_constraints(child, c, join_type) }
         end
 
         def table_aliases_for(parent, node)
@@ -189,11 +169,6 @@ module ActiveRecord
           }
         end
 
-        def construct_tables!(parent, node)
-          node.tables = table_aliases_for(parent, node)
-          node.children.each { |child| construct_tables! node, child }
-        end
-
         def table_alias_for(reflection, parent, join)
           name = "#{reflection.plural_name}_#{parent.table_name}"
           join ? "#{name}_join" : name
@@ -204,8 +179,8 @@ module ActiveRecord
             [left.children.find { |node2| node1.match? node2 }, node1]
           }.partition(&:first)
 
-          ojs = missing.flat_map { |_, n| make_outer_joins left, n }
-          intersection.flat_map { |l, r| walk l, r }.concat ojs
+          joins = intersection.flat_map { |l, r| r.table = l.table; walk(l, r) }
+          joins.concat missing.flat_map { |_, n| make_constraints(left, n) }
         end
 
         def find_reflection(klass, name)
@@ -223,7 +198,7 @@ module ActiveRecord
               raise EagerLoadPolymorphicError.new(reflection)
             end
 
-            JoinAssociation.new(reflection, build(right, reflection.klass), alias_tracker)
+            JoinAssociation.new(reflection, build(right, reflection.klass))
           end
         end
 
@@ -248,7 +223,7 @@ module ActiveRecord
               next
             end
 
-            model = seen[ar_parent.object_id][node.base_klass][id]
+            model = seen[ar_parent.object_id][node][id]
 
             if model
               construct(model, node, row, rs, seen, model_cache, aliases)
@@ -260,7 +235,7 @@ module ActiveRecord
                 model.readonly!
               end
 
-              seen[ar_parent.object_id][node.base_klass][id] = model
+              seen[ar_parent.object_id][node][id] = model
               construct(model, node, row, rs, seen, model_cache, aliases)
             end
           end