Rename GroupHierarchy into ObjectHierarchy

- we now use the hierarchy class also for epics
- also rename supports_nested_groups? into supports_nested_objects?
  - move it to a concern

1 files changed, 28 insertions, 24 deletions

diff --git a/lib/gitlab/group_hierarchy.rb b/lib/gitlab/object_hierarchy.rb
index 97cbdc6cb39..f2772c733c7 100644
--- a/lib/gitlab/group_hierarchy.rb
+++ b/lib/gitlab/object_hierarchy.rb
@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
 module Gitlab
-  # Retrieving of parent or child groups based on a base ActiveRecord relation.
+  # Retrieving of parent or child objects based on a base ActiveRecord relation.
   #
   # This class uses recursive CTEs and as a result will only work on PostgreSQL.
-  class GroupHierarchy
+  class ObjectHierarchy
     attr_reader :ancestors_base, :descendants_base, :model
 
     # ancestors_base - An instance of ActiveRecord::Relation for which to
-    #                  get parent groups.
+    #                  get parent objects.
     # descendants_base - An instance of ActiveRecord::Relation for which to
-    #                    get child groups. If omitted, ancestors_base is used.
+    #                    get child objects. If omitted, ancestors_base is used.
     def initialize(ancestors_base, descendants_base = ancestors_base)
       raise ArgumentError.new("Model of ancestors_base does not match model of descendants_base") if ancestors_base.model != descendants_base.model
 
@@ -39,7 +39,7 @@ module Gitlab
     end
     # rubocop: enable CodeReuse/ActiveRecord
 
-    # Returns a relation that includes the ancestors_base set of groups
+    # Returns a relation that includes the ancestors_base set of objects
     # and all their ancestors (recursively).
     #
     # Passing an `upto` will stop the recursion once the specified parent_id is
@@ -47,13 +47,13 @@ module Gitlab
     # included.
     #
     # Passing a `hierarchy_order` with either `:asc` or `:desc` will cause the
-    # recursive query order from most nested group to root or from the root
-    # ancestor to most nested group respectively. This uses a `depth` column
+    # recursive query order from most nested object to root or from the root
+    # ancestor to most nested object respectively. This uses a `depth` column
     # where `1` is defined as the depth for the base and increment as we go up
     # each parent.
     # rubocop: disable CodeReuse/ActiveRecord
     def base_and_ancestors(upto: nil, hierarchy_order: nil)
-      return ancestors_base unless Group.supports_nested_groups?
+      return ancestors_base unless hierarchy_supported?
 
       recursive_query = base_and_ancestors_cte(upto, hierarchy_order).apply_to(model.all)
       recursive_query = recursive_query.order(depth: hierarchy_order) if hierarchy_order
@@ -62,16 +62,16 @@ module Gitlab
     end
     # rubocop: enable CodeReuse/ActiveRecord
 
-    # Returns a relation that includes the descendants_base set of groups
+    # Returns a relation that includes the descendants_base set of objects
     # and all their descendants (recursively).
     def base_and_descendants
-      return descendants_base unless Group.supports_nested_groups?
+      return descendants_base unless hierarchy_supported?
 
       read_only(base_and_descendants_cte.apply_to(model.all))
     end
 
-    # Returns a relation that includes the base groups, their ancestors,
-    # and the descendants of the base groups.
+    # Returns a relation that includes the base objects, their ancestors,
+    # and the descendants of the base objects.
     #
     # The resulting query will roughly look like the following:
     #
@@ -91,16 +91,16 @@ module Gitlab
     # Using this approach allows us to further add criteria to the relation with
     # Rails thinking it's selecting data the usual way.
     #
-    # If nested groups are not supported, ancestors_base is returned.
+    # If nested objects are not supported, ancestors_base is returned.
     # rubocop: disable CodeReuse/ActiveRecord
-    def all_groups
-      return ancestors_base unless Group.supports_nested_groups?
+    def all_objects
+      return ancestors_base unless hierarchy_supported?
 
       ancestors = base_and_ancestors_cte
       descendants = base_and_descendants_cte
 
-      ancestors_table = ancestors.alias_to(groups_table)
-      descendants_table = descendants.alias_to(groups_table)
+      ancestors_table = ancestors.alias_to(objects_table)
+      descendants_table = descendants.alias_to(objects_table)
 
       relation = model
         .unscoped
@@ -117,23 +117,27 @@ module Gitlab
 
     private
 
+    def hierarchy_supported?
+      Gitlab::Database.postgresql?
+    end
+
     # rubocop: disable CodeReuse/ActiveRecord
     def base_and_ancestors_cte(stop_id = nil, hierarchy_order = nil)
       cte = SQL::RecursiveCTE.new(:base_and_ancestors)
       depth_column = :depth
 
       base_query = ancestors_base.except(:order)
-      base_query = base_query.select("1 as #{depth_column}", groups_table[Arel.star]) if hierarchy_order
+      base_query = base_query.select("1 as #{depth_column}", objects_table[Arel.star]) if hierarchy_order
 
       cte << base_query
 
       # Recursively get all the ancestors of the base set.
       parent_query = model
-        .from([groups_table, cte.table])
-        .where(groups_table[:id].eq(cte.table[:parent_id]))
+        .from([objects_table, cte.table])
+        .where(objects_table[:id].eq(cte.table[:parent_id]))
         .except(:order)
 
-      parent_query = parent_query.select(cte.table[depth_column] + 1, groups_table[Arel.star]) if hierarchy_order
+      parent_query = parent_query.select(cte.table[depth_column] + 1, objects_table[Arel.star]) if hierarchy_order
       parent_query = parent_query.where(cte.table[:parent_id].not_eq(stop_id)) if stop_id
 
       cte << parent_query
@@ -149,15 +153,15 @@ module Gitlab
 
       # Recursively get all the descendants of the base set.
       cte << model
-        .from([groups_table, cte.table])
-        .where(groups_table[:parent_id].eq(cte.table[:id]))
+        .from([objects_table, cte.table])
+        .where(objects_table[:parent_id].eq(cte.table[:id]))
         .except(:order)
 
       cte
     end
     # rubocop: enable CodeReuse/ActiveRecord
 
-    def groups_table
+    def objects_table
       model.arel_table
     end