gitlab-dangerfiles 4.6.0 → 4.7.0

data/lib/danger/rules/commit_messages/Dangerfile

@@ -121,7 +121,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/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/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/spec_helper.rb

@@ -45,6 +45,19 @@ module DangerSpecHelper
   end
 end
 
+RSpec::Matchers.define :match_teammates do |expected|
+  match do |actual|
+    expected.each do |expected_person|
+      matched_person = actual.find { |actual_person| actual_person.name == expected_person.username }
+
+      matched_person &&
+        matched_person.name == expected_person.name &&
+        matched_person.role == expected_person.role &&
+        matched_person.projects == expected_person.projects
+    end
+  end
+end
+
 RSpec.shared_context "with dangerfile" do
   let(:dangerfile) { DangerSpecHelper.testing_dangerfile }
   let(:added_files) { %w[added-from-git] }
@@ -68,3 +81,220 @@ RSpec.shared_context "with dangerfile" do
     allow(dangerfile.helper).to receive(:changes).and_return(changes) if dangerfile.respond_to?(:helper)
   end
 end
+
+RSpec.shared_context "with teammates" do
+  let(:backend_available) { true }
+  let(:backend_tz_offset_hours) { 2.0 }
+  let(:backend_maintainer_project) { { "gitlab" => "maintainer backend" } }
+  let(:backend_maintainer) do
+    Gitlab::Dangerfiles::Teammate.new(
+      "username" => "backend-maintainer",
+      "name" => "Backend maintainer",
+      "role" => "Backend engineer",
+      "projects" => backend_maintainer_project,
+      "available" => backend_available,
+      "tz_offset_hours" => backend_tz_offset_hours,
+    )
+  end
+
+  let(:another_backend_maintainer) do
+    Gitlab::Dangerfiles::Teammate.new(
+      "username" => "another-backend-maintainer",
+      "name" => "Another Backend Maintainer",
+      "role" => "Backend engineer",
+      "projects" => backend_maintainer_project,
+      "available" => backend_available,
+      "tz_offset_hours" => backend_tz_offset_hours,
+    )
+  end
+
+  let(:backend_reviewer_available) { true }
+  let(:backend_reviewer) do
+    Gitlab::Dangerfiles::Teammate.new(
+      "username" => "backend-reviewer",
+      "name" => "Backend reviewer",
+      "role" => "Backend engineer",
+      "projects" => { "gitlab" => "reviewer backend" },
+      "available" => backend_reviewer_available,
+      "tz_offset_hours" => 1.0,
+    )
+  end
+
+  let(:frontend_reviewer) do
+    Gitlab::Dangerfiles::Teammate.new(
+      "username" => "frontend-reviewer",
+      "name" => "Frontend reviewer",
+      "role" => "Frontend engineer",
+      "projects" => { "gitlab" => "reviewer frontend" },
+      "available" => true,
+      "tz_offset_hours" => 2.0,
+    )
+  end
+
+  let(:frontend_maintainer) do
+    Gitlab::Dangerfiles::Teammate.new(
+      "username" => "frontend-maintainer",
+      "name" => "Frontend maintainer",
+      "role" => "Frontend engineer",
+      "projects" => { "gitlab" => "maintainer frontend" },
+      "available" => true,
+      "tz_offset_hours" => 2.0,
+    )
+  end
+
+  let(:ux_reviewer) do
+    Gitlab::Dangerfiles::Teammate.new(
+      "username" => "ux-reviewer",
+      "name" => "UX reviewer",
+      "role" => "Product Designer",
+      "projects" => { "gitlab" => "reviewer ux" },
+      "specialty" => "Create: Source Code",
+      "available" => true,
+      "tz_offset_hours" => 2.0,
+    )
+  end
+
+  let(:software_engineer_in_test) do
+    Gitlab::Dangerfiles::Teammate.new(
+      "username" => "software-engineer-in-test",
+      "name" => "Software Engineer in Test",
+      "role" => "Software Engineer in Test, Create:Source Code",
+      "projects" => { "gitlab" => "maintainer qa", "gitlab-qa" => "maintainer" },
+      "available" => true,
+      "tz_offset_hours" => 2.0,
+    )
+  end
+
+  let(:software_engineer_in_import_integrate_fe) do
+    Gitlab::Dangerfiles::Teammate.new(
+      "username" => "software-engineer-in-import-and-integrate-fe",
+      "name" => "Software Engineer in Import and Integrate FE",
+      "role" => "Frontend Engineer, Manage:Import and Integrate",
+      "projects" => { "gitlab" => "reviewer frontend" },
+      "available" => true,
+      "tz_offset_hours" => 2.0,
+    )
+  end
+
+  let(:software_engineer_in_import_integrate_be) do
+    Gitlab::Dangerfiles::Teammate.new(
+      "username" => "software-engineer-in-import-and-integrate-be",
+      "name" => "Software Engineer in Import and Integrate BE",
+      "role" => "Backend Engineer, Manage:Import and Integrate",
+      "projects" => { "gitlab" => "reviewer backend" },
+      "available" => true,
+      "tz_offset_hours" => 2.0,
+    )
+  end
+
+  let(:tooling_reviewer) do
+    Gitlab::Dangerfiles::Teammate.new(
+      "username" => "eng-prod-reviewer",
+      "name" => "EP engineer",
+      "role" => "Engineering Productivity",
+      "projects" => { "gitlab" => "reviewer tooling" },
+      "available" => true,
+      "tz_offset_hours" => 2.0,
+    )
+  end
+
+  let(:ci_template_reviewer) do
+    Gitlab::Dangerfiles::Teammate.new(
+      "username" => "ci-template-maintainer",
+      "name" => "CI Template engineer",
+      "role" => '~"ci::templates"',
+      "projects" => { "gitlab" => "reviewer ci_template" },
+      "available" => true,
+      "tz_offset_hours" => 2.0,
+    )
+  end
+
+  let(:analytics_instrumentation_reviewer) do
+    Gitlab::Dangerfiles::Teammate.new(
+      "username" => "analytics-instrumentation-reviewer",
+      "name" => "PI engineer",
+      "role" => "Backend Engineer, Analytics: Analytics Instrumentation",
+      "projects" => { "gitlab" => "reviewer analytics_instrumentation" },
+      "available" => true,
+      "tz_offset_hours" => 2.0,
+    )
+  end
+
+  let(:import_and_integrate_backend_reviewer) do
+    Gitlab::Dangerfiles::Teammate.new(
+      "username" => "import-and-integrate-backend-reviewer",
+      "name" => "Import and Integrate BE engineer",
+      "role" => "Backend Engineer, Manage:Import and Integrate",
+      "projects" => { "gitlab" => "reviewer backend" },
+      "available" => backend_reviewer_available,
+      "tz_offset_hours" => 2.0,
+    )
+  end
+
+  let(:import_and_integrate_frontend_reviewer) do
+    Gitlab::Dangerfiles::Teammate.new(
+      "username" => "import-and-integrate-frontend-reviewer",
+      "name" => "Import and Integrate FE engineer",
+      "role" => "Frontend Engineer, Manage:Import and Integrate",
+      "projects" => { "gitlab" => "reviewer frontend" },
+      "available" => true,
+      "tz_offset_hours" => 2.0,
+    )
+  end
+
+  let(:workhorse_reviewer) do
+    Gitlab::Dangerfiles::Teammate.new(
+      "username" => "workhorse-reviewer",
+      "name" => "Workhorse reviewer",
+      "role" => "Backend engineer",
+      "projects" => { "gitlab-workhorse" => "reviewer" },
+      "available" => true,
+      "tz_offset_hours" => 2.0,
+    )
+  end
+
+  let(:workhorse_maintainer) do
+    Gitlab::Dangerfiles::Teammate.new(
+      "username" => "workhorse-maintainer",
+      "name" => "Workhorse maintainer",
+      "role" => "Backend engineer",
+      "projects" => { "gitlab-workhorse" => "maintainer" },
+      "available" => true,
+      "tz_offset_hours" => 2.0,
+    )
+  end
+
+  let(:teammates) do
+    [
+      backend_maintainer.to_h,
+      backend_reviewer.to_h,
+      frontend_maintainer.to_h,
+      frontend_reviewer.to_h,
+      ux_reviewer.to_h,
+      software_engineer_in_test.to_h,
+      tooling_reviewer.to_h,
+      ci_template_reviewer.to_h,
+      workhorse_reviewer.to_h,
+      workhorse_maintainer.to_h,
+      analytics_instrumentation_reviewer.to_h,
+      import_and_integrate_backend_reviewer.to_h,
+      import_and_integrate_frontend_reviewer.to_h,
+      software_engineer_in_import_integrate_fe.to_h,
+      software_engineer_in_import_integrate_be.to_h
+    ]
+  end
+
+  let(:teammate_json) { teammates.to_json }
+  let(:teammate_pedroms) { instance_double(Gitlab::Dangerfiles::Teammate, name: "Pedro") }
+  let(:company_members) { Gitlab::Dangerfiles::Teammate.fetch_company_members }
+
+  before do
+    WebMock
+      .stub_request(:get, Gitlab::Dangerfiles::Teammate::ROULETTE_DATA_URL)
+      .to_return(body: teammate_json)
+
+    # This avoid changing the internal state of the class
+    allow(Gitlab::Dangerfiles::Teammate).to receive(:warnings).and_return([])
+    allow(Gitlab::Dangerfiles::Teammate).to receive(:company_members).and_return(company_members)
+  end
+end

data/lib/gitlab/dangerfiles/spin.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module Dangerfiles
+    Spin = Struct.new(:category, :reviewer, :maintainer, :optional_role) do
+      def no_reviewer?
+        reviewer.nil?
+      end
+
+      def no_maintainer?
+        maintainer.nil?
+      end
+    end
+  end
+end

data/lib/gitlab/dangerfiles/spinner.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require_relative "spin"
+require_relative "teammate"
+require_relative "weightage/maintainers"
+require_relative "weightage/reviewers"
+
+module Gitlab
+  module Dangerfiles
+    class Spinner
+      attr_reader :project, :author, :team_author, :labels, :categories
+
+      def initialize(
+        project:, author:, team_author: nil, labels: [], categories: [],
+        random: Random.new, ux_fallback_wider_community_reviewer: nil)
+        @project = project
+        @author = author
+        @team_author = team_author
+        @labels = labels
+        @categories = categories.reject do |category|
+          import_and_integrate_reject_category?(category)
+        end
+        @random = random
+        @ux_fallback_wider_community_reviewer = ux_fallback_wider_community_reviewer
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def spin
+        spins = categories.sort_by(&:to_s).map do |category|
+          spin_for_category(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
+            spin.optional_role = :maintainer if
+              categories.size > 1 && author_no_qa_capability?
+          when :test
+            spin.optional_role = :maintainer
+
+            if spin.no_reviewer?
+              # Fetch an already picked backend reviewer, or pick one otherwise
+              spin.reviewer = backend_spin&.reviewer || spin_for_category(:backend).reviewer
+            end
+          when :tooling
+            if spin.no_maintainer?
+              # Fetch an already picked backend maintainer, or pick one otherwise
+              spin.maintainer = backend_spin&.maintainer || spin_for_category(:backend).maintainer
+            end
+          when :ci_template # rubocop:disable Lint/DuplicateBranch -- bug?
+            if spin.no_maintainer?
+              # Fetch an already picked backend maintainer, or pick one otherwise
+              spin.maintainer = backend_spin&.maintainer || spin_for_category(:backend).maintainer
+            end
+          when :analytics_instrumentation
+            spin.optional_role = :maintainer
+
+            if spin.no_maintainer?
+              # Fetch an already picked maintainer, or pick one otherwise
+              spin.maintainer = backend_spin&.maintainer || frontend_spin&.maintainer || spin_for_category(: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.no_reviewer? &&
+              spin.no_maintainer?
+          end
+        end
+
+        spins
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      # 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|
+          Gitlab::Dangerfiles::Teammate.find_member(
+            approver["username"], project: project)
+        end
+
+        spin_for_person(approvers) || spin_for_approver_fallback(rule)
+      end
+
+      private
+
+      attr_reader :random, :ux_fallback_wider_community_reviewer
+
+      # @param [String] category name
+      # @return [Boolean]
+      def import_and_integrate_reject_category?(category)
+        # Reject Import and Integrate categories if the MR author has reviewing abilities for the category.
+        team_author&.import_integrate_be?(project, category, labels) ||
+          team_author&.import_integrate_fe?(project, category, labels)
+      end
+
+      # MR includes QA changes, but also other changes, and author isn't an SET
+      def author_no_qa_capability?
+        !(team_author && team_author.capabilities(project).any? { |capability| capability.end_with?("qa") })
+      end
+
+      def spin_for_category(category)
+        reviewers, traintainers, maintainers =
+          %i[reviewer traintainer maintainer].map do |role|
+            spin_role_for_category(role, category)
+          end
+
+        weighted_reviewers = Weightage::Reviewers.new(reviewers, traintainers).execute
+        weighted_maintainers = 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 spin_role_for_category(role, 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 { |person| valid_person?(person) }
+      end
+
+      # @param [Gitlab::Dangerfiles::Teammate] person
+      # @return [Boolean]
+      def valid_person?(person)
+        person.username != author && person.available
+      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|
+          Teammate.find_member(approver["username"]) || 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
+
+      # @return [Array<Gitlab::Dangerfiles::Teammate>]
+      def team
+        @team ||= Teammate.company_members.select do |member|
+          member.in_project?(project)
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/dangerfiles/teammate.rb

@@ -1,10 +1,82 @@
 # frozen_string_literal: true
 
-require_relative "category"
+require "net/http"
+require "json"
+
+require_relative "capability"
 
 module Gitlab
   module Dangerfiles
     class Teammate
+      ROULETTE_DATA_URL = "https://gitlab-org.gitlab.io/gitlab-roulette/roulette.json"
+
+      def self.find_member(username, project: nil)
+        company_members.find do |member|
+          member.username == username &&
+            (project.nil? || member.in_project?(project))
+        end
+      end
+
+      def self.has_member_for_the_group?(category, labels:, **arguments)
+        capabilities = %i[reviewer maintainer].map do |kind|
+          # Use new to use the base class for original has_capability? method
+          Capability.new(category: category, kind: kind, labels: labels, **arguments)
+        end
+
+        company_members.any? do |teammate|
+          capabilities.any? do |capability|
+            capability.has_capability?(teammate) &&
+              teammate.member_of_the_group?(labels)
+          end
+        end
+      end
+
+      # Looks up the current list of GitLab team members and parses it into a
+      # useful form.
+      #
+      # @return [Array<Gitlab::Dangerfiles::Teammate>]
+      def self.company_members
+        @company_members ||= fetch_company_members
+      end
+
+      def self.fetch_company_members
+        data = http_get_json(ROULETTE_DATA_URL) || []
+        data.map { |hash| Teammate.new(hash) }
+      rescue JSON::ParserError
+        warnings << "Failed to parse JSON response from #{ROULETTE_DATA_URL}"
+        []
+      end
+
+      # Fetches the given +url+ and parse its response as JSON.
+      #
+      # @param [String] url
+      #
+      # @return [Hash, Array, NilClass]
+      def self.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
+
+      def self.warnings
+        @warnings ||= []
+      end
+
       attr_reader :options, :username, :name, :role, :specialty, :projects, :available, :hungry, :reduced_capacity, :tz_offset_hours,
         :only_maintainer_reviews
 
@@ -25,6 +97,20 @@ module Gitlab
         @only_maintainer_reviews = options["only_maintainer_reviews"]
       end
 
+      def member_of_the_group?(labels)
+        # Specialty can be:
+        # Source Code
+        # [Growth: Activation, Growth: Expansion]
+        # Runner
+        group_labels = Array(specialty).map do |field|
+          group = field.strip.sub(/^.+: ?/, "").downcase
+
+          "group::#{group}"
+        end
+
+        (group_labels & labels).any?
+      end
+
       def to_h
         options
       end
@@ -128,7 +214,7 @@ module Gitlab
       end
 
       def has_capability?(project, category, kind, labels)
-        Category.for(category, project: project, kind: kind, labels: labels).has_capability?(self)
+        Capability.for(category, project: project, kind: kind, labels: labels).has_capability?(self)
       end
 
       def pluralize(count, singular, plural)

data/lib/gitlab/dangerfiles/version.rb

@@ -1,5 +1,5 @@
 module Gitlab
   module Dangerfiles
-    VERSION = "4.6.0"
+    VERSION = "4.7.0"
   end
 end