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

app/controllers/application_controller.rb

@@ -403,7 +403,7 @@ class ApplicationController < ActionController::Base
   end
   def manifest_import_enabled?
-    Group.supports_nested_groups? && Gitlab::CurrentSettings.import_sources.include?('manifest')
+    Group.supports_nested_objects? && Gitlab::CurrentSettings.import_sources.include?('manifest')
   end
   # U2F (universal 2nd factor) devices need a unique identifier for the application

app/controllers/concerns/group_tree.rb

@@ -32,14 +32,14 @@ module GroupTree
   def filtered_groups_with_ancestors(groups)
     filtered_groups = groups.search(params[:filter]).page(params[:page])
-    if Group.supports_nested_groups?
+    if Group.supports_nested_objects?
       # We find the ancestors by ID of the search results here.
       # Otherwise the ancestors would also have filters applied,
       # which would cause them not to be preloaded.
       #
       # Pagination needs to be applied before loading the ancestors to
       # make sure ancestors are not cut off by pagination.
-      Gitlab::GroupHierarchy.new(Group.where(id: filtered_groups.select(:id)))
+      Gitlab::ObjectHierarchy.new(Group.where(id: filtered_groups.select(:id)))
         .base_and_ancestors
     else
       filtered_groups

app/finders/group_descendants_finder.rb

@@ -112,7 +112,7 @@ class GroupDescendantsFinder
   # rubocop: disable CodeReuse/ActiveRecord
   def ancestors_of_groups(base_for_ancestors)
     group_ids = base_for_ancestors.except(:select, :sort).select(:id)
-    Gitlab::GroupHierarchy.new(Group.where(id: group_ids))
+    Gitlab::ObjectHierarchy.new(Group.where(id: group_ids))
       .base_and_ancestors(upto: parent_group.id)
   end
   # rubocop: enable CodeReuse/ActiveRecord
@@ -132,7 +132,7 @@ class GroupDescendantsFinder
   end
   def subgroups
-    return Group.none unless Group.supports_nested_groups?
+    return Group.none unless Group.supports_nested_objects?
     # When filtering subgroups, we want to find all matches withing the tree of
     # descendants to show to the user
@@ -183,7 +183,7 @@ class GroupDescendantsFinder
   # rubocop: disable CodeReuse/ActiveRecord
   def hierarchy_for_parent
-    @hierarchy ||= Gitlab::GroupHierarchy.new(Group.where(id: parent_group.id))
+    @hierarchy ||= Gitlab::ObjectHierarchy.new(Group.where(id: parent_group.id))
   end
   # rubocop: enable CodeReuse/ActiveRecord
 end

app/finders/groups_finder.rb

@@ -46,7 +46,7 @@ class GroupsFinder < UnionFinder
     return [Group.all] if current_user&.full_private_access? && all_available?
     groups = []
-    groups << Gitlab::GroupHierarchy.new(groups_for_ancestors, groups_for_descendants).all_groups if current_user
+    groups << Gitlab::ObjectHierarchy.new(groups_for_ancestors, groups_for_descendants).all_objects if current_user
     groups << Group.unscoped.public_to_user(current_user) if include_public_groups?
     groups << Group.none if groups.empty?
     groups
@@ -66,7 +66,7 @@ class GroupsFinder < UnionFinder
       .groups
       .where('members.access_level >= ?', params[:min_access_level])
-    Gitlab::GroupHierarchy
+    Gitlab::ObjectHierarchy
       .new(groups)
       .base_and_descendants
   end

app/helpers/groups_helper.rb

@@ -126,7 +126,7 @@ module GroupsHelper
   end
   def supports_nested_groups?
-    Group.supports_nested_groups?
+    Group.supports_nested_objects?
   end
   private

app/models/ci/runner.rb

@@ -66,7 +66,7 @@ module Ci
     scope :belonging_to_parent_group_of_project, -> (project_id) {
       project_groups = ::Group.joins(:projects).where(projects: { id: project_id })
-      hierarchy_groups = Gitlab::GroupHierarchy.new(project_groups).base_and_ancestors
+      hierarchy_groups = Gitlab::ObjectHierarchy.new(project_groups).base_and_ancestors
       joins(:groups).where(namespaces: { id: hierarchy_groups })
     }

app/models/concerns/descendant.rb

+# frozen_string_literal: true
+
+module Descendant
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def supports_nested_objects?
+      Gitlab::Database.postgresql?
+    end
+  end
+end

app/models/group.rb

@@ -10,6 +10,7 @@ class Group < Namespace
   include Referable
   include SelectForProjectAuthorization
   include LoadedInGroupList
+  include Descendant
   include GroupDescendant
   include TokenAuthenticatable
   include WithUploads
@@ -63,10 +64,6 @@ class Group < Namespace
   after_update :path_changed_hook, if: :path_changed?
   class << self
-    def supports_nested_groups?
-      Gitlab::Database.postgresql?
-    end
-
     def sort_by_attribute(method)
       if method == 'storage_size_desc'
         # storage_size is a virtual column so we need to

app/models/namespace.rb

@@ -175,16 +175,16 @@ class Namespace < ActiveRecord::Base
   # Returns all ancestors, self, and descendants of the current namespace.
   def self_and_hierarchy
-    Gitlab::GroupHierarchy
+    Gitlab::ObjectHierarchy
       .new(self.class.where(id: id))
-      .all_groups
+      .all_objects
   end
   # Returns all the ancestors of the current namespaces.
   def ancestors
     return self.class.none unless parent_id
-    Gitlab::GroupHierarchy
+    Gitlab::ObjectHierarchy
       .new(self.class.where(id: parent_id))
       .base_and_ancestors
   end
@@ -192,27 +192,27 @@ class Namespace < ActiveRecord::Base
   # returns all ancestors upto but excluding the given namespace
   # when no namespace is given, all ancestors upto the top are returned
   def ancestors_upto(top = nil, hierarchy_order: nil)
-    Gitlab::GroupHierarchy.new(self.class.where(id: id))
+    Gitlab::ObjectHierarchy.new(self.class.where(id: id))
       .ancestors(upto: top, hierarchy_order: hierarchy_order)
   end
   def self_and_ancestors
     return self.class.where(id: id) unless parent_id
-    Gitlab::GroupHierarchy
+    Gitlab::ObjectHierarchy
       .new(self.class.where(id: id))
       .base_and_ancestors
   end
   # Returns all the descendants of the current namespace.
   def descendants
-    Gitlab::GroupHierarchy
+    Gitlab::ObjectHierarchy
       .new(self.class.where(parent_id: id))
       .base_and_descendants
   end
   def self_and_descendants
-    Gitlab::GroupHierarchy
+    Gitlab::ObjectHierarchy
       .new(self.class.where(id: id))
       .base_and_descendants
   end
@@ -293,7 +293,7 @@ class Namespace < ActiveRecord::Base
   end
   def force_share_with_group_lock_on_descendants
-    return unless Group.supports_nested_groups?
+    return unless Group.supports_nested_objects?
     # We can't use `descendants.update_all` since Rails will throw away the WITH
     # RECURSIVE statement. We also can't use WHERE EXISTS since we can't use

app/models/project.rb

@@ -570,7 +570,7 @@ class Project < ActiveRecord::Base
   # returns all ancestor-groups upto but excluding the given namespace
   # when no namespace is given, all ancestors upto the top are returned
   def ancestors_upto(top = nil, hierarchy_order: nil)
-    Gitlab::GroupHierarchy.new(Group.where(id: namespace_id))
+    Gitlab::ObjectHierarchy.new(Group.where(id: namespace_id))
       .base_and_ancestors(upto: top, hierarchy_order: hierarchy_order)
   end

app/models/user.rb

@@ -709,13 +709,13 @@ class User < ActiveRecord::Base
   # Returns the groups a user is a member of, either directly or through a parent group
   def membership_groups
-    Gitlab::GroupHierarchy.new(groups).base_and_descendants
+    Gitlab::ObjectHierarchy.new(groups).base_and_descendants
   end
   # Returns a relation of groups the user has access to, including their parent
   # and child groups (recursively).
   def all_expanded_groups
-    Gitlab::GroupHierarchy.new(groups).all_groups
+    Gitlab::ObjectHierarchy.new(groups).all_objects
   end
   def expanded_groups_requiring_two_factor_authentication
@@ -1153,7 +1153,7 @@ class User < ActiveRecord::Base
   end
   def manageable_groups
-    Gitlab::GroupHierarchy.new(owned_or_maintainers_groups).base_and_descendants
+    Gitlab::ObjectHierarchy.new(owned_or_maintainers_groups).base_and_descendants
   end
   def namespaces

app/policies/group_policy.rb

@@ -16,7 +16,7 @@ class GroupPolicy < BasePolicy
   condition(:maintainer) { access_level >= GroupMember::MAINTAINER }
   condition(:reporter) { access_level >= GroupMember::REPORTER }
-  condition(:nested_groups_supported, scope: :global) { Group.supports_nested_groups? }
+  condition(:nested_groups_supported, scope: :global) { Group.supports_nested_objects? }
   condition(:has_parent, scope: :subject) { @subject.has_parent? }
   condition(:share_with_group_locked, scope: :subject) { @subject.share_with_group_lock? }

app/services/ci/register_job_service.rb

@@ -118,7 +118,7 @@ module Ci
       # Workaround for weird Rails bug, that makes `runner.groups.to_sql` to return `runner_id = NULL`
       groups = ::Group.joins(:runner_namespaces).merge(runner.runner_namespaces)
-      hierarchy_groups = Gitlab::GroupHierarchy.new(groups).base_and_descendants
+      hierarchy_groups = Gitlab::ObjectHierarchy.new(groups).base_and_descendants
       projects = Project.where(namespace_id: hierarchy_groups)
         .with_group_runners_enabled
         .with_builds_enabled

app/services/groups/nested_create_service.rb

@@ -18,7 +18,7 @@ module Groups
         return namespace
       end
-      if group_path.include?('/') && !Group.supports_nested_groups?
+      if group_path.include?('/') && !Group.supports_nested_objects?
         raise 'Nested groups are not supported on MySQL'
       end

app/services/groups/transfer_service.rb

@@ -40,7 +40,7 @@ module Groups
     def ensure_allowed_transfer
       raise_transfer_error(:group_is_already_root) if group_is_already_root?
-      raise_transfer_error(:database_not_supported) unless Group.supports_nested_groups?
+      raise_transfer_error(:database_not_supported) unless Group.supports_nested_objects?
       raise_transfer_error(:same_parent_as_current) if same_parent?
       raise_transfer_error(:invalid_policies) unless valid_policies?
       raise_transfer_error(:namespace_with_same_path) if namespace_with_same_path?

app/services/users/refresh_authorized_projects_service.rb

@@ -102,7 +102,7 @@ module Users
     end
     def fresh_authorizations
-      klass = if Group.supports_nested_groups?
+      klass = if Group.supports_nested_objects?
                 Gitlab::ProjectAuthorizations::WithNestedGroups
               else
                 Gitlab::ProjectAuthorizations::WithoutNestedGroups

lib/api/entities.rb

@@ -323,7 +323,7 @@ module API
       expose :request_access_enabled
       expose :full_name, :full_path
-      if ::Group.supports_nested_groups?
+      if ::Group.supports_nested_objects?
         expose :parent_id
       end

lib/api/groups.rb

@@ -113,7 +113,7 @@ module API
         requires :name, type: String, desc: 'The name of the group'
         requires :path, type: String, desc: 'The path of the group'
-        if ::Group.supports_nested_groups?
+        if ::Group.supports_nested_objects?
           optional :parent_id, type: Integer, desc: 'The parent group id for creating nested group'
         end

lib/gitlab/group_hierarchy.rb → lib/gitlab/object_hierarchy.rb

 # 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

spec/features/groups/show_spec.rb

@@ -65,7 +65,7 @@ describe 'Group show page' do
     context 'when subgroups are supported', :js, :nested_groups do
       before do
-        allow(Group).to receive(:supports_nested_groups?) { true }
+        allow(Group).to receive(:supports_nested_objects?) { true }
         visit path
       end
@@ -76,7 +76,7 @@ describe 'Group show page' do
     context 'when subgroups are not supported' do
       before do
-        allow(Group).to receive(:supports_nested_groups?) { false }
+        allow(Group).to receive(:supports_nested_objects?) { false }
         visit path
       end