gitlab-dangerfiles 4.6.0 → 4.8.0

data/lib/gitlab/dangerfiles/spec_helper.rb

@@ -17,7 +17,7 @@ module DangerSpecHelper
       "GITLAB_CI" => "true",
       "DANGER_GITLAB_HOST" => "gitlab.example.com",
       "CI_MERGE_REQUEST_IID" => 28_493,
-      "DANGER_GITLAB_API_TOKEN" => "123sbdq54erfsd3422gdfio",
+      "DANGER_GITLAB_API_TOKEN" => "123sbdq54erfsd3422gdfio"
     }
   end
 
@@ -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
 
@@ -14,7 +86,7 @@ module Gitlab
         @username = options["username"]
         @name = options["name"]
         @markdown_name = options["markdown_name"] ||
-                         default_markdown_name(options["username"])
+          default_markdown_name(options["username"])
         @role = options["role"]
         @specialty = options["specialty"]
         @projects = process_projects(options["projects"])
@@ -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/type_label_guesser.rb

@@ -9,7 +9,7 @@ module Gitlab
         performance: %w[type::bug bug::performance],
         added: %w[type::feature feature::addition],
         deprecated: %w[type::maintenance maintenance::removal],
-        removed: %w[type::maintenance maintenance::removal],
+        removed: %w[type::maintenance maintenance::removal]
       }.freeze
 
       def labels_from_changelog_categories(categories)

data/lib/gitlab/dangerfiles/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gitlab-dangerfiles
 version: !ruby/object:Gem::Version
-  version: 4.6.0
+  version: 4.8.0
 platform: ruby
 authors:
 - GitLab
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-11-06 00:00:00.000000000 Z
+date: 2024-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -213,6 +213,7 @@ files:
 - CONTRIBUTING.md
 - Dangerfile
 - Gemfile
+- Gemfile.lock
 - Guardfile
 - LICENSE.txt
 - README.md
@@ -238,14 +239,17 @@ files:
 - lib/gitlab-dangerfiles.rb
 - lib/gitlab/Dangerfile
 - lib/gitlab/dangerfiles.rb
+- lib/gitlab/dangerfiles/approval.rb
 - lib/gitlab/dangerfiles/base_linter.rb
-- lib/gitlab/dangerfiles/category.rb
+- lib/gitlab/dangerfiles/capability.rb
 - lib/gitlab/dangerfiles/changes.rb
 - lib/gitlab/dangerfiles/commit_linter.rb
 - lib/gitlab/dangerfiles/config.rb
 - lib/gitlab/dangerfiles/emoji_checker.rb
 - lib/gitlab/dangerfiles/merge_request_linter.rb
 - lib/gitlab/dangerfiles/spec_helper.rb
+- lib/gitlab/dangerfiles/spin.rb
+- lib/gitlab/dangerfiles/spinner.rb
 - lib/gitlab/dangerfiles/task_loader.rb
 - lib/gitlab/dangerfiles/tasks/main.rake
 - lib/gitlab/dangerfiles/teammate.rb
@@ -278,7 +282,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.3.27
 signing_key:
 specification_version: 4
 summary: This gem provides common Dangerfile and plugins for GitLab projects.