Merge pull request #27851 from tenderlove/scope-chain

Deprecate `scope_chain`

3 files changed, 32 insertions, 52 deletions

diff --git a/activerecord/lib/active_record/associations/join_dependency.rb b/activerecord/lib/active_record/associations/join_dependency.rb
index a79eb03acc..87e0847ec1 100644
--- a/activerecord/lib/active_record/associations/join_dependency.rb
+++ b/activerecord/lib/active_record/associations/join_dependency.rb
@@ -171,7 +171,7 @@ module ActiveRecord
           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)
+          child.join_constraints(foreign_table, foreign_klass, child, join_type, tables, chain)
         end
 
         def make_outer_joins(parent, child)
diff --git a/activerecord/lib/active_record/associations/join_dependency/join_association.rb b/activerecord/lib/active_record/associations/join_dependency/join_association.rb
index a5705951f3..f5fcba1236 100644
--- a/activerecord/lib/active_record/associations/join_dependency/join_association.rb
+++ b/activerecord/lib/active_record/associations/join_dependency/join_association.rb
@@ -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,7 +49,6 @@ module ActiveRecord
                   .instance_exec(node, &item)
               end
             end
-            scope_chain_index += 1
 
             klass_scope =
               if klass.current_scope
diff --git a/activerecord/lib/active_record/reflection.rb b/activerecord/lib/active_record/reflection.rb
index 2c8c4b6297..d923050822 100644
--- a/activerecord/lib/active_record/reflection.rb
+++ b/activerecord/lib/active_record/reflection.rb
@@ -1,5 +1,6 @@
 require "thread"
 require "active_support/core_ext/string/filters"
+require "active_support/deprecation"
 
 module ActiveRecord
   # = Active Record Reflection
@@ -175,8 +176,19 @@ module ActiveRecord
         JoinKeys.new(foreign_key, active_record_primary_key)
       end
 
+      # Returns a list of scopes that should be applied for this Reflection
+      # object when querying the database.
+      def scopes
+        scope ? [scope] : []
+      end
+
+      def scope_chain
+        chain.map(&:scopes)
+      end
+      deprecate :scope_chain
+
       def constraints
-        scope_chain.flatten
+        chain.map(&:scopes).flatten
       end
 
       def counter_cache_column
@@ -461,12 +473,6 @@ module ActiveRecord
         false
       end
 
-      # An array of arrays of scopes. Each item in the outside array corresponds to a reflection
-      # in the #chain.
-      def scope_chain
-        scope ? [[scope]] : [[]]
-      end
-
       def has_scope?
         scope
       end
@@ -796,45 +802,14 @@ module ActiveRecord
         through_reflection.clear_association_scope_cache
       end
 
-      # Consider the following example:
-      #
-      #   class Person
-      #     has_many :articles
-      #     has_many :comment_tags, through: :articles
-      #   end
-      #
-      #   class Article
-      #     has_many :comments
-      #     has_many :comment_tags, through: :comments, source: :tags
-      #   end
-      #
-      #   class Comment
-      #     has_many :tags
-      #   end
-      #
-      # There may be scopes on Person.comment_tags, Article.comment_tags and/or Comment.tags,
-      # but only Comment.tags will be represented in the #chain. So this method creates an array
-      # of scopes corresponding to the chain.
-      def scope_chain
-        @scope_chain ||= begin
-          scope_chain = source_reflection.scope_chain.map(&:dup)
-
-          # Add to it the scope from this reflection (if any)
-          scope_chain.first << scope if scope
-
-          through_scope_chain = through_reflection.scope_chain.map(&:dup)
-
-          if options[:source_type]
-            type = foreign_type
-            source_type = options[:source_type]
-            through_scope_chain.first << lambda { |object|
-              where(type => source_type)
-            }
-          end
+      def scopes
+        source_reflection.scopes + super
+      end
 
-          # Recursively fill out the rest of the array from the through reflection
-          scope_chain + through_scope_chain
-        end
+      def source_type_scope
+        type = foreign_type
+        source_type = options[:source_type]
+        lambda { |object| where(type => source_type) }
       end
 
       def has_scope?
@@ -1008,6 +983,15 @@ module ActiveRecord
         @previous_reflection = previous_reflection
       end
 
+      def scopes
+        scopes = @previous_reflection.scopes
+        if @previous_reflection.options[:source_type]
+          scopes + [@previous_reflection.source_type_scope]
+        else
+          scopes
+        end
+      end
+
       def klass
         @reflection.klass
       end