gitlab-dangerfiles 3.13.0 → 4.10.0

data/lib/danger/rules/type_label/Dangerfile

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-TYPE_LABEL_MISSING_MESSAGE = "Please add a [merge request type](https://about.gitlab.com/handbook/engineering/metrics/#work-type-classification) to this merge request."
-
 require_relative "../../../gitlab/dangerfiles/type_label_guesser"
 
 return if helper.has_scoped_label_with_scope?("type")
@@ -10,9 +8,3 @@ if respond_to?(:changelog)
   type_label_guesser = Gitlab::Dangerfiles::TypeLabelGuesser.new
   helper.labels_to_add.concat(type_label_guesser.labels_from_changelog_categories(changelog.categories))
 end
-
-if ENV['DANGER_ERROR_WHEN_TYPE_LABEL_IS_MISSING'] == 'true'
-  fail TYPE_LABEL_MISSING_MESSAGE
-else
-  warn TYPE_LABEL_MISSING_MESSAGE
-end

data/lib/danger/rules/z_add_labels/Dangerfile

@@ -6,10 +6,10 @@ return unless helper.ci?
 
 def post_labels(labels)
   gitlab.api.update_merge_request(helper.mr_target_project_id,
-                                  helper.mr_iid,
-                                  add_labels: labels.join(","))
+    helper.mr_iid,
+    add_labels: labels.join(","))
 rescue Gitlab::Error::Forbidden
-  warn("This Merge Request needs to be labelled with #{helper.labels_list(labels)}. Please request a reviewer or maintainer to add them.")
+  warn("Labels missing: please ask a reviewer or maintainer to add #{helper.labels_list(labels)} to this merge request.")
 end
 
 post_labels(helper.labels_to_add) if helper.labels_to_add.any?

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,82 @@
+# 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.+:Import and Integrate/)
+        end
+      end
+
+      class ImportIntegrateFE < Capability
+        def has_capability?(teammate)
+          kind == :reviewer && teammate.role.match?(/Frontend Engineer.+: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/config.rb

@@ -21,31 +21,54 @@ module Gitlab
       #           match changed lines in files that match +filename_regex+. Used in `helper.changes_by_category`, `helper.changes`, and `helper.categories_for_file`.
       attr_accessor :files_to_category
 
+      # @!attribute custom_labels_for_categories
+      #   @return [{String => String}] A hash of the form +{ category_name => label }+.
+      #           Used in `helper.custom_labels_for_categories`.
+      attr_accessor :custom_labels_for_categories
+
+      # @!attribute disabled_roulette_categories
+      #   @return [Array] indicating which categories would be disabled for the simple roulette. Default to `[]` (all categories are enabled)
+      attr_accessor :disabled_roulette_categories
+
+      # Rule: changes_size
       # @!attribute code_size_thresholds
       #   @return [{ high: Integer, medium: Integer }] a hash of the form +{ high: 42, medium: 12 }+ where +:high+ is the lines changed threshold which triggers an error, and +:medium+ is the lines changed threshold which triggers a warning. Also, see +DEFAULT_CHANGES_SIZE_THRESHOLDS+ for the format of the hash.
       attr_accessor :code_size_thresholds
 
+      # Rule: commit_messages
       # @!attribute max_commits_count
       #   @return [Integer] the maximum number of allowed non-squashed/non-fixup commits for a given MR. A warning is triggered if the MR has more commits.
       attr_accessor :max_commits_count
 
-      # @!attribute disabled_roulette_categories
-      #   @return [Array] indicating which categories would be disabled for the simple roulette. Default to `[]` (all categories are enabled)
-      attr_accessor :disabled_roulette_categories
+      # Rule: duo_code_review
+      # @!attribute duo_code_review
+      #   @return [Symbol] whether a review from GitLab Duo Code is `:mandatory` or `:optional`. Default to `:optional`.
+      attr_accessor :duo_code_review
 
+      # Rule: simple_roulette
       # @!attribute included_optional_codeowners_sections_for_roulette
       #   @return [Array] indicating which optional codeowners sections should be included in roulette. Default to `[]`.
       attr_accessor :included_optional_codeowners_sections_for_roulette
 
+      # Rule: simple_roulette
       # @!attribute excluded_required_codeowners_sections_for_roulette
       #   @return [Array] indicating which required codeowners sections should be excluded from roulette. Default to `[]`.
       attr_accessor :excluded_required_codeowners_sections_for_roulette
 
+      # @!attribute auto_assign_for_roulette_roles
+      #   @return [Array<Symbol>] which roles to auto assign as reviewers, given roulette recommendations (:reviewer, :maintainer, or both). If empty, auto-assignment is disabled. Default to `[]`.
+      attr_accessor :auto_assign_for_roulette_roles
+
+      # @!attribute auto_assign_for_roulette_labels
+      #   @return [Array<String>] MR labels that allow auto reviewer assignment. If empty, applies to all MRs, provided :auto_assign_for_roulette_roles is not empty. Default to `[]`.
+      attr_accessor :auto_assign_for_roulette_labels
+
       DEFAULT_CHANGES_SIZE_THRESHOLDS = { high: 2_000, medium: 500 }.freeze
       DEFAULT_COMMIT_MESSAGES_MAX_COMMITS_COUNT = 10
 
       def initialize
         @files_to_category = {}
+        @custom_labels_for_categories = {}
         @project_root = nil
         @project_name = ENV["CI_PROJECT_NAME"]
         @ci_only_rules = []
@@ -54,6 +77,9 @@ module Gitlab
         @disabled_roulette_categories = []
         @included_optional_codeowners_sections_for_roulette = []
         @excluded_required_codeowners_sections_for_roulette = []
+        @auto_assign_for_roulette_roles = []
+        @auto_assign_for_roulette_labels = []
+        @duo_code_review = :optional
       end
     end
   end

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

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" => "Frontend Engineer in Import and Integrate",
+      "role" => "AnyRole Frontend Engineer, AnyStage: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" => "Backend Engineer in Import and Integrate",
+      "role" => "AnyRole Backend Engineer, AnyStage: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" => "AnyRole Backend Engineer, AnyStage: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" => "AnyRole Frontend Engineer, AnyStage: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(:ux_fallback_reviewer) { instance_double(Gitlab::Dangerfiles::Teammate) }
+  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