activerecord 5.0.7 → 5.1.7

data/lib/active_record/associations/has_many_association.rb

@@ -16,25 +16,16 @@ module ActiveRecord
         when :restrict_with_error
           unless empty?
             record = owner.class.human_attribute_name(reflection.name).downcase
-            message = owner.errors.generate_message(:base, :'restrict_dependent_destroy.many', record: record, raise: true) rescue nil
-            if message
-              ActiveSupport::Deprecation.warn(<<-MESSAGE.squish)
-                The error key `:'restrict_dependent_destroy.many'` has been deprecated and will be removed in Rails 5.1.
-                Please use `:'restrict_dependent_destroy.has_many'` instead.
-              MESSAGE
-            end
-            owner.errors.add(:base, message || :'restrict_dependent_destroy.has_many', record: record)
+            owner.errors.add(:base, :'restrict_dependent_destroy.has_many', record: record)
             throw(:abort)
           end
 
+        when :destroy
+          # No point in executing the counter update since we're going to destroy the parent anyway
+          load_target.each { |t| t.destroyed_by_association = reflection }
+          destroy_all
         else
-          if options[:dependent] == :destroy
-            # No point in executing the counter update since we're going to destroy the parent anyway
-            load_target.each { |t| t.destroyed_by_association = reflection }
-            destroy_all
-          else
-            delete_all
-          end
+          delete_all
         end
       end
 
@@ -68,15 +59,15 @@ module ActiveRecord
         # the loaded flag is set to true as well.
         def count_records
           count = if reflection.has_cached_counter?
-            owner._read_attribute reflection.counter_cache_column
+            owner._read_attribute(reflection.counter_cache_column).to_i
           else
-            scope.count
+            scope.count(:all)
           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
+          (@target ||= []) && loaded! if count == 0
 
           [association_scope.limit_value, count].compact.min
         end
@@ -104,7 +95,7 @@ module ActiveRecord
         end
 
         def delete_or_nullify_all_records(method)
-          count = delete_count(method, self.scope)
+          count = delete_count(method, scope)
           update_counter(-count)
         end
 

data/lib/active_record/associations/has_many_through_association.rb

@@ -38,7 +38,7 @@ module ActiveRecord
       def insert_record(record, validate = true, raise = false)
         ensure_not_nested
 
-        if record.new_record? || record.changed?
+        if record.new_record? || record.has_changes_to_save?
           return unless super
         end
 
@@ -84,7 +84,10 @@ module ActiveRecord
         end
 
         def save_through_record(record)
-          build_through_record(record).save!
+          association = build_through_record(record)
+          if association.changed?
+            association.save!
+          end
         ensure
           @through_records.delete(record.object_id)
         end
@@ -106,6 +109,11 @@ module ActiveRecord
           record
         end
 
+        def remove_records(existing_records, records, method)
+          super
+          delete_through_records(records)
+        end
+
         def target_reflection_has_associated_record?
           !(through_reflection.belongs_to? && owner[through_reflection.foreign_key].blank?)
         end
@@ -144,7 +152,7 @@ module ActiveRecord
               stmt.from scope.klass.arel_table
               stmt.wheres = arel.constraints
 
-              count = scope.klass.connection.delete(stmt, 'SQL', scope.bound_attributes)
+              count = scope.klass.connection.delete(stmt, "SQL", scope.bound_attributes)
             end
           when :nullify
             count = scope.update_all(source_reflection.foreign_key => nil)
@@ -194,7 +202,7 @@ module ActiveRecord
 
         def find_target
           return [] unless target_reflection_has_associated_record?
-          get_records
+          super
         end
 
         # NOTE - not sure that we can actually cope with inverses here

data/lib/active_record/associations/has_one_association.rb

@@ -12,14 +12,7 @@ module ActiveRecord
         when :restrict_with_error
           if load_target
             record = owner.class.human_attribute_name(reflection.name).downcase
-            message = owner.errors.generate_message(:base, :'restrict_dependent_destroy.one', record: record, raise: true) rescue nil
-            if message
-              ActiveSupport::Deprecation.warn(<<-MESSAGE.squish)
-                The error key `:'restrict_dependent_destroy.one'` has been deprecated and will be removed in Rails 5.1.
-                Please use `:'restrict_dependent_destroy.has_one'` instead.
-              MESSAGE
-            end
-            owner.errors.add(:base, message || :'restrict_dependent_destroy.has_one', record: record)
+            owner.errors.add(:base, :'restrict_dependent_destroy.has_one', record: record)
             throw(:abort)
           end
 
@@ -32,10 +25,10 @@ module ActiveRecord
         raise_on_type_mismatch!(record) if record
         load_target
 
-        return self.target if !(target || record)
+        return target unless target || record
 
         assigning_another_record = target != record
-        if assigning_another_record || record.changed?
+        if assigning_another_record || record.has_changes_to_save?
           save &&= owner.persisted?
 
           transaction_if(save) do
@@ -60,12 +53,13 @@ module ActiveRecord
       def delete(method = options[:dependent])
         if load_target
           case method
-            when :delete
-              target.delete
-            when :destroy
-              target.destroy
-            when :nullify
-              target.update_columns(reflection.foreign_key => nil) if target.persisted?
+          when :delete
+            target.delete
+          when :destroy
+            target.destroyed_by_association = reflection
+            target.destroy
+          when :nullify
+            target.update_columns(reflection.foreign_key => nil) if target.persisted?
           end
         end
       end
@@ -82,18 +76,20 @@ module ActiveRecord
 
         def remove_target!(method)
           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 after its foreign key was set to nil."
-              end
+          when :delete
+            target.delete
+          when :destroy
+            target.destroyed_by_association = reflection
+            target.destroy
+          else
+            nullify_owner_attributes(target)
+            remove_inverse_instance(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 after its foreign key was set to nil."
+            end
           end
         end
 

data/lib/active_record/associations/has_one_through_association.rb

@@ -15,13 +15,17 @@ module ActiveRecord
           ensure_not_nested
 
           through_proxy  = owner.association(through_reflection.name)
-          through_record = through_proxy.send(:load_target)
+          through_record = through_proxy.load_target
 
           if through_record && !record
             through_record.destroy
           elsif record
             attributes = construct_join_attributes(record)
 
+            if through_record && through_record.destroyed?
+              through_record = through_proxy.tap(&:reload).target
+            end
+
             if through_record
               through_record.update(attributes)
             elsif owner.new_record?

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

@@ -1,4 +1,4 @@
-require 'active_record/associations/join_dependency/join_part'
+require "active_record/associations/join_dependency/join_part"
 
 module ActiveRecord
   module Associations
@@ -23,48 +23,24 @@ module ActiveRecord
 
         JoinInformation = Struct.new :joins, :binds
 
-        def join_constraints(foreign_table, foreign_klass, node, join_type, tables, scope_chain, chain)
+        def join_constraints(foreign_table, foreign_klass, join_type, tables, chain)
           joins         = []
           binds         = []
           tables        = tables.reverse
 
-          scope_chain_index = 0
-          scope_chain = scope_chain.reverse
-
           # The chain starts with the target table, but we want to end with it here (makes
           # more sense in this context), so we reverse
           chain.reverse_each do |reflection|
             table = tables.shift
             klass = reflection.klass
 
-            join_keys   = reflection.join_keys(klass)
+            join_keys   = reflection.join_keys
             key         = join_keys.key
             foreign_key = join_keys.foreign_key
 
             constraint = build_constraint(klass, table, key, foreign_table, foreign_key)
 
-            predicate_builder = PredicateBuilder.new(TableMetadata.new(klass, table))
-            scope_chain_items = scope_chain[scope_chain_index].map do |item|
-              if item.is_a?(Relation)
-                item
-              else
-                ActiveRecord::Relation.create(klass, table, predicate_builder)
-                  .instance_exec(node, &item)
-              end
-            end
-            scope_chain_index += 1
-
-            relation = ActiveRecord::Relation.create(klass, table, predicate_builder)
-            current_scope = klass.current_scope
-
-            klass_scope =
-              if current_scope && current_scope.empty_scope?
-                relation
-              else
-                klass.send(:build_default_scope, relation)
-              end
-
-            rel = scope_chain_items.inject(klass_scope || scope_chain_items.shift, &:merge!)
+            rel = reflection.join_scope(table)
 
             if rel && !rel.arel.constraints.empty?
               binds += rel.bound_attributes

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

@@ -1,4 +1,4 @@
-require 'active_record/associations/join_dependency/join_part'
+require "active_record/associations/join_dependency/join_part"
 
 module ActiveRecord
   module Associations

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

@@ -15,7 +15,7 @@ module ActiveRecord
         # association.
         attr_reader :base_klass, :children
 
-        delegate :table_name, :column_names, :primary_key, :to => :base_klass
+        delegate :table_name, :column_names, :primary_key, to: :base_klass
 
         def initialize(base_klass, children)
           @base_klass = base_klass

data/lib/active_record/associations/join_dependency.rb

@@ -1,18 +1,18 @@
 module ActiveRecord
   module Associations
     class JoinDependency # :nodoc:
-      autoload :JoinBase,        'active_record/associations/join_dependency/join_base'
-      autoload :JoinAssociation, 'active_record/associations/join_dependency/join_association'
+      autoload :JoinBase,        "active_record/associations/join_dependency/join_base"
+      autoload :JoinAssociation, "active_record/associations/join_dependency/join_association"
 
       class Aliases # :nodoc:
         def initialize(tables)
           @tables = tables
-          @alias_cache = tables.each_with_object({}) { |table,h|
-            h[table.node] = table.columns.each_with_object({}) { |column,i|
+          @alias_cache = tables.each_with_object({}) { |table, h|
+            h[table.node] = table.columns.each_with_object({}) { |column, i|
               i[column.name] = column.alias
             }
           }
-          @name_and_alias_cache = tables.each_with_object({}) { |table,h|
+          @name_and_alias_cache = tables.each_with_object({}) { |table, h|
             h[table.node] = table.columns.map { |column|
               [column.name, column.alias]
             }
@@ -32,7 +32,7 @@ module ActiveRecord
           @alias_cache[node][column]
         end
 
-        class Table < Struct.new(:node, :columns) # :nodoc:
+        Table = Struct.new(:node, :columns) do # :nodoc:
           def table
             Arel::Nodes::TableAlias.new node.table, node.aliased_table_name
           end
@@ -62,7 +62,7 @@ module ActiveRecord
             walk_tree assoc, hash
           end
         when Hash
-          associations.each do |k,v|
+          associations.each do |k, v|
             cache = hash[k] ||= {}
             walk_tree v, cache
           end
@@ -92,8 +92,9 @@ module ActiveRecord
       #    associations # => [:appointments]
       #    joins # =>  []
       #
-      def initialize(base, associations, joins)
-        @alias_tracker = AliasTracker.create_with_joins(base.connection, base.table_name, joins, base.type_caster)
+      def initialize(base, associations, joins, eager_loading: true)
+        @alias_tracker = AliasTracker.create_with_joins(base.connection, base.table_name, joins)
+        @eager_loading = eager_loading
         tree = self.class.make_tree associations
         @join_root = JoinBase.new base, build(tree, base)
         @join_root.children.each { |child| construct_tables! @join_root, child }
@@ -125,15 +126,15 @@ module ActiveRecord
       end
 
       def 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 ||= 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, aliases)
+      def instantiate(result_set, &block)
         primary_key = aliases.column_alias(join_root, join_root.primary_key)
 
         seen = Hash.new { |i, object_id|
@@ -142,7 +143,7 @@ module ActiveRecord
           }
         }
 
-        model_cache = Hash.new { |h,klass| h[klass] = {} }
+        model_cache = Hash.new { |h, klass| h[klass] = {} }
         parents = model_cache[join_root]
         column_aliases = aliases.column_aliases join_root
 
@@ -153,10 +154,10 @@ module ActiveRecord
           class_name: join_root.base_klass.name
         }
 
-        message_bus.instrument('instantiation.active_record', payload) do
+        message_bus.instrument("instantiation.active_record", payload) do
           result_set.each { |row_hash|
             parent_key = primary_key ? row_hash[primary_key] : row_hash
-            parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases)
+            parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases, &block)
             construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
           }
         end
@@ -166,139 +167,141 @@ module ActiveRecord
 
       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, child, join_type, tables, child.reflection.scope_chain, chain)
-      end
+        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)
+        end
 
-      def make_outer_joins(parent, child)
-        tables    = table_aliases_for(parent, child)
-        join_type = Arel::Nodes::OuterJoin
-        info      = make_constraints parent, child, tables, join_type
+        def make_outer_joins(parent, child)
+          tables    = table_aliases_for(parent, child)
+          join_type = Arel::Nodes::OuterJoin
+          info      = make_constraints parent, child, tables, join_type
 
-        [info] + child.children.flat_map { |c| make_outer_joins(child, c) }
-      end
+          [info] + child.children.flat_map { |c| make_outer_joins(child, c) }
+        end
 
-      def make_left_outer_joins(parent, child)
-        tables    = child.tables
-        join_type = Arel::Nodes::OuterJoin
-        info      = make_constraints parent, child, tables, join_type
+        def make_left_outer_joins(parent, child)
+          tables    = child.tables
+          join_type = Arel::Nodes::OuterJoin
+          info      = make_constraints parent, child, tables, join_type
 
-        [info] + child.children.flat_map { |c| make_left_outer_joins(child, c) }
-      end
+          [info] + child.children.flat_map { |c| make_left_outer_joins(child, c) }
+        end
 
-      def make_inner_joins(parent, child)
-        tables    = child.tables
-        join_type = Arel::Nodes::InnerJoin
-        info      = make_constraints parent, child, tables, join_type
+        def make_inner_joins(parent, child)
+          tables    = child.tables
+          join_type = Arel::Nodes::InnerJoin
+          info      = make_constraints parent, child, tables, join_type
 
-        [info] + child.children.flat_map { |c| make_inner_joins(child, c) }
-      end
+          [info] + child.children.flat_map { |c| make_inner_joins(child, c) }
+        end
 
-      def table_aliases_for(parent, node)
-        node.reflection.chain.map { |reflection|
-          alias_tracker.aliased_table_for(
-            reflection.table_name,
-            table_alias_for(reflection, parent, reflection != node.reflection)
-          )
-        }
-      end
+        def table_aliases_for(parent, node)
+          node.reflection.chain.map { |reflection|
+            alias_tracker.aliased_table_for(
+              reflection.table_name,
+              table_alias_for(reflection, parent, reflection != node.reflection),
+              reflection.klass.type_caster
+            )
+          }
+        end
 
-      def construct_tables!(parent, node)
-        node.tables = table_aliases_for(parent, node)
-        node.children.each { |child| construct_tables! node, child }
-      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}"
-        name << "_join" if join
-        name
-      end
+        def table_alias_for(reflection, parent, join)
+          name = "#{reflection.plural_name}_#{parent.table_name}"
+          name << "_join" if join
+          name
+        end
 
-      def walk(left, right)
-        intersection, missing = right.children.map { |node1|
-          [left.children.find { |node2| node1.match? node2 }, node1]
-        }.partition(&:first)
+        def walk(left, right)
+          intersection, missing = right.children.map { |node1|
+            [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
-      end
+          ojs = missing.flat_map { |_, n| make_outer_joins left, n }
+          intersection.flat_map { |l, r| walk l, r }.concat ojs
+        end
 
-      def find_reflection(klass, name)
-        klass._reflect_on_association(name) or
-          raise ConfigurationError, "Can't join '#{ klass.name }' to association named '#{ name }'; perhaps you misspelled it?"
-      end
+        def find_reflection(klass, name)
+          klass._reflect_on_association(name) ||
+            raise(ConfigurationError, "Can't join '#{klass.name}' to association named '#{name}'; perhaps you misspelled it?")
+        end
 
-      def build(associations, base_klass)
-        associations.map do |name, right|
-          reflection = find_reflection base_klass, name
-          reflection.check_validity!
-          reflection.check_eager_loadable!
+        def build(associations, base_klass)
+          associations.map do |name, right|
+            reflection = find_reflection base_klass, name
+            reflection.check_validity!
+            reflection.check_eager_loadable!
 
-          if reflection.polymorphic?
-            raise EagerLoadPolymorphicError.new(reflection)
-          end
+            if reflection.polymorphic?
+              next unless @eager_loading
+              raise EagerLoadPolymorphicError.new(reflection)
+            end
 
-          JoinAssociation.new reflection, build(right, reflection.klass)
+            JoinAssociation.new reflection, build(right, reflection.klass)
+          end.compact
         end
-      end
 
-      def construct(ar_parent, parent, row, rs, seen, model_cache, aliases)
-        return if ar_parent.nil?
+        def construct(ar_parent, parent, row, rs, seen, model_cache, aliases)
+          return if ar_parent.nil?
+
+          parent.children.each do |node|
+            if node.reflection.collection?
+              other = ar_parent.association(node.reflection.name)
+              other.loaded!
+            elsif ar_parent.association_cached?(node.reflection.name)
+              model = ar_parent.association(node.reflection.name).target
+              construct(model, node, row, rs, seen, model_cache, aliases)
+              next
+            end
 
-        parent.children.each do |node|
-          if node.reflection.collection?
-            other = ar_parent.association(node.reflection.name)
-            other.loaded!
-          elsif ar_parent.association_cached?(node.reflection.name)
-            model = ar_parent.association(node.reflection.name).target
-            construct(model, node, row, rs, seen, model_cache, aliases)
-            next
-          end
+            key = aliases.column_alias(node, node.primary_key)
+            id = row[key]
+            if id.nil?
+              nil_association = ar_parent.association(node.reflection.name)
+              nil_association.loaded!
+              next
+            end
 
-          key = aliases.column_alias(node, node.primary_key)
-          id = row[key]
-          if id.nil?
-            nil_association = ar_parent.association(node.reflection.name)
-            nil_association.loaded!
-            next
-          end
+            model = seen[ar_parent.object_id][node.base_klass][id]
 
-          model = seen[ar_parent.object_id][node.base_klass][id]
+            if model
+              construct(model, node, row, rs, seen, model_cache, aliases)
+            else
+              model = construct_model(ar_parent, node, row, model_cache, id, aliases)
 
-          if model
-            construct(model, node, row, rs, seen, model_cache, aliases)
-          else
-            model = construct_model(ar_parent, node, row, model_cache, id, aliases)
+              if node.reflection.scope_for(node.base_klass).readonly_value
+                model.readonly!
+              end
 
-            if node.reflection.scope_for(node.base_klass).readonly_value
-              model.readonly!
+              seen[ar_parent.object_id][node.base_klass][id] = model
+              construct(model, node, row, rs, seen, model_cache, aliases)
             end
-
-            seen[ar_parent.object_id][node.base_klass][id] = model
-            construct(model, node, row, rs, seen, model_cache, aliases)
           end
         end
-      end
 
-      def construct_model(record, node, row, model_cache, id, aliases)
-        other = record.association(node.reflection.name)
+        def construct_model(record, node, row, model_cache, id, aliases)
+          other = record.association(node.reflection.name)
 
-        model = model_cache[node][id] ||=
-          node.instantiate(row, aliases.column_aliases(node)) do |m|
-            other.set_inverse_instance(m)
+          model = model_cache[node][id] ||=
+            node.instantiate(row, aliases.column_aliases(node)) do |m|
+              other.set_inverse_instance(m)
+            end
+
+          if node.reflection.collection?
+            other.target.push(model)
+          else
+            other.target = model
           end
 
-        if node.reflection.collection?
-          other.target.push(model)
-        else
-          other.target = model
+          model
         end
-
-        model
-      end
     end
   end
 end