gitlab-dangerfiles 4.6.0 → 4.8.0

data/lib/danger/plugins/roulette.rb

@@ -1,34 +1,16 @@
 # frozen_string_literal: true
 
+require_relative "../../gitlab/dangerfiles/approval"
+require_relative "../../gitlab/dangerfiles/spinner"
 require_relative "../../gitlab/dangerfiles/teammate"
-require_relative "../../gitlab/dangerfiles/weightage/maintainers"
-require_relative "../../gitlab/dangerfiles/weightage/reviewers"
 
 module Danger
   # Common helper functions for our danger scripts. See Danger::Helper
   # for more details
   class Roulette < Danger::Plugin
-    ROULETTE_DATA_URL = "https://gitlab-org.gitlab.io/gitlab-roulette/roulette.json"
     HOURS_WHEN_PERSON_CAN_BE_PICKED = (6..14).freeze
-
-    Spin = Struct.new(:category, :reviewer, :maintainer, :optional_role)
     HTTPError = Class.new(StandardError)
 
-    Approval = Struct.new(:category, :spin) do
-      def self.from_approval_rule(rule, maintainer)
-        category =
-          if rule["section"] == "codeowners"
-            "`#{rule["name"]}`"
-          else
-            rule["section"]
-          end.to_sym
-
-        spin = Spin.new(category, nil, maintainer, :reviewer)
-
-        new(category, spin)
-      end
-    end
-
     def prepare_categories(changes_keys)
       categories = Set.new(changes_keys)
 
@@ -53,7 +35,7 @@ module Danger
     #
     # @return [Gitlab::Dangerfiles::Teammate]
     def team_mr_author
-      @team_mr_author ||= find_member(helper.mr_author)
+      @team_mr_author ||= Gitlab::Dangerfiles::Teammate.find_member(helper.mr_author)
     end
 
     # Assigns GitLab team members to be reviewer and maintainer
@@ -63,70 +45,22 @@ module Danger
     # @param categories [Array<Symbol>] An array of categories symbols.
     #
     # @return [Array<Spin>]
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
     def spin(project = nil, categories = [:none], ux_fallback_wider_community_reviewer: teammate_pedroms)
+      # TODO: Deprecate the project argument. It prevents us from
+      # memorizing Spinner and can cause unexpected results if it's
+      # passing a different project than the merge request project.
       project = (project || config_project_name).downcase
       categories = categories.map { |category| category&.downcase || :none }
-      categories.reject! { |category| import_and_integrate_reject_category?(category, project) }
-
-      spins = categories.sort_by(&:to_s).map do |category|
-        spin_for_category(project, category)
-      end
-
-      backend_spin = spins.find { |spin| spin.category == :backend }
-      frontend_spin = spins.find { |spin| spin.category == :frontend }
-
-      spins.each do |spin|
-        case spin.category
-        when :qa
-          # MR includes QA changes, but also other changes, and author isn't an SET
-          if categories.size > 1 &&
-             !(team_mr_author && team_mr_author.capabilities(project).any? { |capability| capability.end_with?("qa") })
-            spin.optional_role = :maintainer
-          end
-        when :test
-          spin.optional_role = :maintainer
-
-          if spin.reviewer.nil?
-            # Fetch an already picked backend reviewer, or pick one otherwise
-            spin.reviewer = backend_spin&.reviewer || spin_for_category(project, :backend).reviewer
-          end
-        when :tooling
-          if spin.maintainer.nil?
-            # Fetch an already picked backend maintainer, or pick one otherwise
-            spin.maintainer = backend_spin&.maintainer || spin_for_category(project, :backend).maintainer
-          end
-        when :ci_template
-          if spin.maintainer.nil?
-            # Fetch an already picked backend maintainer, or pick one otherwise
-            spin.maintainer = backend_spin&.maintainer || spin_for_category(project, :backend).maintainer
-          end
-        when :analytics_instrumentation
-          spin.optional_role = :maintainer
-
-          if spin.maintainer.nil?
-            # Fetch an already picked maintainer, or pick one otherwise
-            spin.maintainer = backend_spin&.maintainer || frontend_spin&.maintainer || spin_for_category(project, :backend).maintainer
-          end
-        when :import_integrate_be, :import_integrate_fe
-          spin.optional_role = :maintainer
-        when :ux
-          spin.optional_role = :maintainer
 
-          # We want at least a UX reviewer who can review any wider community
-          # contribution even without a team designer. We assign this to Pedro.
-          spin.reviewer = ux_fallback_wider_community_reviewer if
-            labels.include?("Community contribution") &&
-            spin.reviewer.nil? &&
-            spin.maintainer.nil?
-        end
-      end
-
-      spins
+      Gitlab::Dangerfiles::Spinner.new(
+        project: project,
+        author: helper.mr_author, team_author: team_mr_author,
+        labels: labels, categories: categories, random: random,
+        ux_fallback_wider_community_reviewer:
+          ux_fallback_wider_community_reviewer)
+        .spin
     end
 
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-
     def codeowners_approvals
       approval_rules = helper.mr_approval_state["rules"]
 
@@ -134,23 +68,31 @@ module Danger
 
       required_approval_rules = unique_approval_rules(approval_rules)
       required_approval_rules.filter_map do |rule|
-        spin_for_approval_rule?(rule) &&
-          Approval.from_approval_rule(rule, spin_for_approver(rule))
+        if spin_for_approval_rule?(rule)
+          approver = Gitlab::Dangerfiles::Spinner.new(
+            project: config_project_name.downcase,
+            author: helper.mr_author, team_author: team_mr_author,
+            random: random
+          ).spin_for_approver(rule)
+
+          Gitlab::Dangerfiles::Approval.from_approval_rule(rule, approver)
+        end
       end
     end
 
+    alias_method :required_approvals, :codeowners_approvals
+
+    # For backward compatibility
     def warnings
-      @warnings ||= []
+      Gitlab::Dangerfiles::Teammate.warnings
     end
 
+    private
+
     def teammate_pedroms
-      @teammate_pedroms ||= find_member("pedroms")
+      @teammate_pedroms ||= Gitlab::Dangerfiles::Teammate.find_member("pedroms")
     end
 
-    alias_method :required_approvals, :codeowners_approvals
-
-    private
-
     def spin_for_approval_rule?(rule)
       rule["rule_type"] == "code_owner" &&
         should_include_codeowners_rule?(rule) &&
@@ -188,179 +130,17 @@ module Danger
       end
     end
 
-    # @param [Gitlab::Dangerfiles::Teammate] person
-    # @return [Boolean]
-    def valid_person?(person)
-      !mr_author?(person) && person.available
-    end
-
-    # @param [Gitlab::Dangerfiles::Teammate] person
-    # @return [Boolean]
-    def mr_author?(person)
-      person.username == helper.mr_author
-    end
-
-    # @param [String] category name
-    # @return [Boolean]
-    def import_and_integrate_reject_category?(category, project)
-      # Reject Import and Integrate categories if the MR author has reviewing abilities for the category.
-      team_mr_author&.import_integrate_be?(project, category, labels) ||
-        team_mr_author&.import_integrate_fe?(project, category, labels)
-    end
-
     def random
       @random ||= Random.new(Digest::MD5.hexdigest(helper.mr_source_branch).to_i(16))
     end
 
-    def spin_role_for_category(team, role, project, category)
-      team.select do |member|
-        member.public_send("#{role}?", project, category, labels)
-      end
-    end
-
-    # Known issue: If someone is rejected due to OOO, and then becomes not OOO, the
-    # selection will change on next spin.
-    #
-    # @param [Array<Gitlab::Dangerfiles::Teammate>] people
-    #
-    # @return [Gitlab::Dangerfiles::Teammate]
-    def spin_for_person(people)
-      shuffled_people = people.shuffle(random: random)
-
-      shuffled_people.find(&method(:valid_person?))
-    end
-
-    # Spin a reviewer for a particular approval rule
-    #
-    # @param [Hash] rule of approval
-    #
-    # @return [Gitlab::Dangerfiles::Teammate]
-    def spin_for_approver(rule)
-      approvers = rule["eligible_approvers"].filter_map do |approver|
-        find_member(approver["username"], project: config_project_name.downcase)
-      end
-
-      spin_for_person(approvers) || spin_for_approver_fallback(rule)
-    end
-
-    # It can be possible that we don't have a valid reviewer for approval.
-    # In this case, we sample again without considering:
-    #
-    # * If they're available
-    # * If they're an actual reviewer from roulette data
-    #
-    # We do this because we strictly require an approval from the approvers.
-    #
-    # @param [Hash] rule of approval
-    #
-    # @return [Gitlab::Dangerfiles::Teammate]
-    def spin_for_approver_fallback(rule)
-      fallback_approvers = rule["eligible_approvers"].map do |approver|
-        find_member(approver["username"]) ||
-          Gitlab::Dangerfiles::Teammate.new(approver)
-      end
-
-      # Intentionally not using `spin_for_person` to skip `valid_person?`.
-      # This should strictly return someone so we don't filter anything,
-      # and it's a fallback mechanism which should not happen often that
-      # deserves a complex algorithm.
-      fallback_approvers.sample(random: random)
-    end
-
-    def spin_for_category(project, category)
-      team = project_team(project)
-      reviewers, traintainers, maintainers =
-        %i[reviewer traintainer maintainer].map do |role|
-          spin_role_for_category(team, role, project, category)
-        end
-
-      weighted_reviewers = Gitlab::Dangerfiles::Weightage::Reviewers.new(reviewers, traintainers).execute
-      weighted_maintainers = Gitlab::Dangerfiles::Weightage::Maintainers.new(maintainers).execute
-
-      reviewer = spin_for_person(weighted_reviewers)
-      maintainer = spin_for_person(weighted_maintainers)
-
-      # allow projects with small number of reviewers to take from maintainers if possible
-      if reviewer.nil? && weighted_maintainers.uniq.size > 1
-        weighted_maintainers.delete(maintainer)
-        reviewer = spin_for_person(weighted_maintainers)
-      end
-
-      Spin.new(category, reviewer, maintainer, false)
-    end
-
     def prepare_ux_category!(categories)
-      if labels.include?("Community contribution")
-        categories << :ux
-      else
-        begin
+      if labels.include?("Community contribution") ||
           # We only want to spin a reviewer for merge requests which has a
-          # designer for the team. There's no easy way to tell this, so we
-          # pretend this is a community contribution, in which case we only
-          # pick the team designer. If there's no one got picked, it means
-          # there's no designer for this team.
-          labels << "Community contribution"
-
-          # Don't use a fallback reviewer so when a group doesn't have
-          # available reviewers, it'll not give us any reviewers.
-          ux_spin = spin(nil, [:ux], ux_fallback_wider_community_reviewer: nil).first
-
-          categories << :ux if ux_spin.reviewer || ux_spin.maintainer
-        ensure
-          # Make sure we delete the label afterward
-          labels.delete("Community contribution")
-        end
-      end
-    end
-
-    # Fetches the given +url+ and parse its response as JSON.
-    #
-    # @param [String] url
-    #
-    # @return [Hash, Array, NilClass]
-    def http_get_json(url)
-      rsp = Net::HTTP.get_response(URI.parse(url))
-
-      if rsp.is_a?(Net::HTTPRedirection)
-        uri = URI.parse(rsp.header["location"])
-
-        uri.query = nil if uri
-
-        warnings << "Redirection detected: #{uri}."
-        return nil
-      end
-
-      unless rsp.is_a?(Net::HTTPOK)
-        message = rsp.message[0, 30]
-        warnings << "HTTPError: Failed to read #{url}: #{rsp.code} #{message}."
-        return nil
-      end
-
-      JSON.parse(rsp.body)
-    end
-
-    # Looks up the current list of GitLab team members and parses it into a
-    # useful form.
-    #
-    # @return [Array<Gitlab::Dangerfiles::Teammate>]
-    def company_members
-      @company_members ||= begin
-          data = http_get_json(ROULETTE_DATA_URL) || []
-          data.map { |hash| Gitlab::Dangerfiles::Teammate.new(hash) }
-        rescue JSON::ParserError
-          warnings << "Failed to parse JSON response from #{ROULETTE_DATA_URL}"
-          []
-        end
-    end
-
-    def find_member(username, project: nil)
-      company_members.find do |member|
-        member.username == username &&
-          if project
-            member.in_project?(project)
-          else
-            true
-          end
+          # designer for the team.
+          Gitlab::Dangerfiles::Teammate.has_member_for_the_group?(
+            :ux, project: config_project_name.downcase, labels: labels)
+        categories << :ux
       end
     end
 
@@ -377,18 +157,5 @@ module Danger
     def labels
       @labels ||= helper.mr_labels
     end
-
-    # Like +team+, but only returns teammates in the current project, based on
-    # project_name.
-    #
-    # @return [Array<Gitlab::Dangerfiles::Teammate>]
-    def project_team(project_name)
-      company_members.select do |member|
-        member.in_project?(project_name)
-      end
-    rescue => err
-      warn("Reviewer roulette failed to load team data: #{err.message}")
-      []
-    end
   end
 end

data/lib/danger/rules/commit_messages/Dangerfile

@@ -96,11 +96,6 @@ def lint_commits(commits)
     if multi_line_commit_linter && multi_line_commit_linter.failed?
       warn_or_fail_commits(multi_line_commit_linter)
       commit_linters.delete(multi_line_commit_linter) # Don't show an error (here) and a warning (below)
-    elsif helper.ci? # We don't have access to the MR title locally
-      title_linter = lint_mr_title(helper.mr_title)
-      if title_linter.failed?
-        warn_or_fail_commits(title_linter)
-      end
     end
   else
     if count_non_fixup_commits(commit_linters) > MAX_COMMITS_COUNT
@@ -121,7 +116,7 @@ def warn_or_fail_commits(failed_linters, default_to_fail: true)
       when :subject_too_short, :subject_above_warning, :details_too_many_changes, :details_line_too_long
         warn_commit(linter.commit, problem_desc)
       else
-        self.__send__("#{level}_commit", linter.commit, problem_desc)
+        self.__send__(:"#{level}_commit", linter.commit, problem_desc)
       end
     end
   end

data/lib/danger/rules/simple_roulette/Dangerfile

@@ -16,13 +16,15 @@ To spread load more evenly across eligible reviewers, Danger has picked a candid
 review slot. Feel free to
 [override these selections](https://about.gitlab.com/handbook/engineering/projects/##{PROJECT_NAME})
 if you think someone else would be better-suited
-or use the [GitLab Review Workload Dashboard](https://gitlab-org.gitlab.io/gitlab-roulette/) to find other available reviewers.
+or use the [GitLab Review Workload Dashboard](https://gitlab-org.gitlab.io/gitlab-roulette/?currentProject=#{PROJECT_NAME})
+to find other available reviewers.
 
 To read more on how to use the reviewer roulette, please take a look at the
 [Engineering workflow](https://about.gitlab.com/handbook/engineering/workflow/#basics)
 and [code review guidelines](https://docs.gitlab.com/ee/development/code_review.html).
 Please consider assigning a reviewer or maintainer who is a
-[domain expert](https://about.gitlab.com/handbook/engineering/projects/#gitlab-development-kit) in the area of the merge request.
+[domain expert](https://about.gitlab.com/handbook/engineering/projects/##{PROJECT_NAME})
+in the area of the merge request.
 
 Once you've decided who will review this merge request, mention them as you
 normally would! Danger does not automatically notify them for you.

data/lib/gitlab/dangerfiles/approval.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "spin"
+
+module Gitlab
+  module Dangerfiles
+    Approval = Struct.new(:category, :spin) do
+      def self.from_approval_rule(rule, maintainer)
+        category =
+          if rule["section"] == "codeowners"
+            "`#{rule['name']}`"
+          else
+            rule["section"]
+          end.to_sym
+
+        spin = Spin.new(category, nil, maintainer, :reviewer)
+
+        new(category, spin)
+      end
+    end
+  end
+end

data/lib/gitlab/dangerfiles/base_linter.rb

@@ -16,7 +16,7 @@ module Gitlab
           subject_too_long: "The %s may not be longer than #{MAX_LINE_LENGTH} characters",
           subject_starts_with_a_space: "The %s must not start with a space",
           subject_starts_with_lowercase: "The %s must start with a capital letter",
-          subject_ends_with_a_period: "The %s must not end with a period",
+          subject_ends_with_a_period: "The %s must not end with a period"
         }
       end
 

data/lib/gitlab/dangerfiles/capability.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module Dangerfiles
+    CapabilityStruct = Struct.new(:category, :project, :kind, :labels, keyword_init: true)
+
+    class Capability < CapabilityStruct
+      def self.for(category, **arguments)
+        (category_to_class[category] || self)
+          .new(category: category, **arguments)
+      end
+
+      def self.category_to_class
+        @category_to_class ||= {
+          none: None,
+          test: Test,
+          tooling: Tooling,
+          import_integrate_be: ImportIntegrateBE,
+          import_integrate_fe: ImportIntegrateFE,
+          ux: UX
+        }.freeze
+      end
+      private_class_method :category_to_class
+
+      def has_capability?(teammate)
+        teammate.capabilities(project).include?(capability)
+      end
+
+      private
+
+      def capability
+        @capability ||= "#{kind} #{category}"
+      end
+
+      class None < Capability
+        def capability
+          @capability ||= kind.to_s
+        end
+      end
+
+      class Test < Capability
+        def has_capability?(teammate)
+          return false if kind != :reviewer
+
+          area = teammate.role[/Software Engineer in Test(?:.*?, (\w+))/, 1]
+
+          !!area && labels.any?("devops::#{area.downcase}")
+        end
+      end
+
+      class Tooling < Capability
+        def has_capability?(teammate)
+          if super
+            true
+          elsif %i[trainee_maintainer maintainer].include?(kind)
+            false
+          else # fallback to backend reviewer
+            teammate.capabilities(project).include?("#{kind} backend")
+          end
+        end
+      end
+
+      class ImportIntegrateBE < Capability
+        def has_capability?(teammate)
+          kind == :reviewer &&
+            teammate.role.match?(/Backend Engineer.+Manage:Import and Integrate/)
+        end
+      end
+
+      class ImportIntegrateFE < Capability
+        def has_capability?(teammate)
+          kind == :reviewer &&
+            teammate.role.match?(/Frontend Engineer.+Manage:Import and Integrate/)
+        end
+      end
+
+      class UX < Capability
+        def has_capability?(teammate)
+          super && teammate.member_of_the_group?(labels)
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/dangerfiles/commit_linter.rb

@@ -26,7 +26,7 @@ module Gitlab
             message_contains_unicode_emoji: "Avoid the use of Unicode Emoji. These add no value to the commit " \
             "message, and may not be displayed properly everywhere",
             message_contains_short_reference: "Use full URLs instead of short references (`gitlab-org/gitlab#123` or " \
-            "`!123`), as short references are displayed as plain text outside of GitLab",
+            "`!123`), as short references are displayed as plain text outside of GitLab"
           }
         )
       end
@@ -148,7 +148,7 @@ module Gitlab
 
       def message_contains_short_reference?
         match_data = commit.message.match(SHORT_REFERENCE_REGEX) ||
-                     commit.message.match(MS_SHORT_REFERENCE_REGEX)
+          commit.message.match(MS_SHORT_REFERENCE_REGEX)
 
         return false unless match_data
 

data/lib/gitlab/dangerfiles/emoji_checker.rb

@@ -27,7 +27,7 @@ module Gitlab
 
       def initialize
         names = JSON.parse(File.read(DIGESTS)).keys +
-                JSON.parse(File.read(ALIASES)).keys
+          JSON.parse(File.read(ALIASES)).keys
 
         @emoji = names.map { |name| ":#{name}:" }
       end