activerecord 5.0.7.2 → 5.1.0.beta1

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,12 @@ 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.destroy
+          when :nullify
+            target.update_columns(reflection.foreign_key => nil) if target.persisted?
           end
         end
       end
@@ -82,18 +75,19 @@ 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.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.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)
+      def initialize(base, associations, joins, eager_loading: true)
         @alias_tracker = AliasTracker.create_with_joins(base.connection, base.table_name, joins, base.type_caster)
+        @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,8 +126,8 @@ 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.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)
@@ -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,7 +154,7 @@ 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)
@@ -166,139 +167,140 @@ 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, child, 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)
+            )
+          }
+        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

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,14 +23,11 @@ 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, node, 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|
@@ -44,7 +41,7 @@ module ActiveRecord
             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|
+            scope_chain_items = reflection.scopes.map do |item|
               if item.is_a?(Relation)
                 item
               else
@@ -52,19 +49,25 @@ module ActiveRecord
                   .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
+              if klass.current_scope
+                klass.current_scope.clone.tap { |scope|
+                  scope.joins_values = []
+                }
               else
+                relation = ActiveRecord::Relation.create(
+                  klass,
+                  table,
+                  predicate_builder,
+                )
                 klass.send(:build_default_scope, relation)
               end
+            scope_chain_items.concat [klass_scope].compact
 
-            rel = scope_chain_items.inject(klass_scope || scope_chain_items.shift, &:merge!)
+            rel = scope_chain_items.inject(scope_chain_items.shift) do |left, right|
+              left.merge right
+            end
 
             if rel && !rel.arel.constraints.empty?
               binds += rel.bound_attributes