gitlab-dangerfiles 0.1.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6298bb4b8fed9c66cd1bc9b811e9ddb93d6e8474dd8797da837780ec5bcbe1a8
-  data.tar.gz: 2be36370906090104ebba958d4910d5f105cf3b8d0619849c78dbb5b625dcd9a
+  metadata.gz: a41237cf8c1b948162962ffd5712cac36034d6e3f6ddbd551f7b7f5c64315ac6
+  data.tar.gz: 9416beb3ed3688db58d83bfafb103a3f21b15c7a1e1dae83fe08dae33b13d329
 SHA512:
-  metadata.gz: 9c09bdec93ab9d0b1a73565e62a46e400204907f758cb924c0d27d27eda7aae0871e45a02d7ac1f6846d2aa0f6a8c41d341f57147d5e04d94ac4351a2b6b64d1
-  data.tar.gz: 67710acb881d9f5229944ccb3dc40bb7d9c4ae0d66743190cfb3fac7e560f22f3ca8a7ca7b7b60119e6f595b4a4e00d3235df0728a79370d60723985cb4d0b93
+  metadata.gz: 294c63c0dad1685a71e4110ab5248d96e7efa97ef448dc861c6a443a8123fd490b1fbdf303b87bf7c18802074b24b3b371a433b3ef06c831cc368559c4c832a0
+  data.tar.gz: aa3bc70fe5068018df9dd1eee9010732b4df231033434ba02c3872b0902e3850adde1b97b6228dbda9f58e10c032b7d4b6467c96f18392d3e74dfab497638835

data/lib/danger/helper.rb

@@ -2,93 +2,72 @@
 
 require "net/http"
 require "json"
+require "danger"
 require_relative "../gitlab/dangerfiles/teammate"
+require_relative "../gitlab/dangerfiles/title_linting"
 
 module Danger
   # Common helper functions for our danger scripts.
   class Helper < Danger::Plugin
     RELEASE_TOOLS_BOT = "gitlab-release-tools-bot"
+    DRAFT_REGEX = /\A*#{Regexp.union(/(?i)(\[WIP\]\s*|WIP:\s*|WIP$)/, /(?i)(\[draft\]|\(draft\)|draft:|draft\s\-\s|draft$)/)}+\s*/i.freeze
     CATEGORY_LABELS = {
       docs: "~documentation", # Docs are reviewed along DevOps stages, so don't need roulette for now.
       none: "",
       qa: "~QA",
       test: "~test ~Quality for `spec/features/*`",
       engineering_productivity: '~"Engineering Productivity" for CI, Danger',
-    }.freeze
-    # First-match win, so be sure to put more specific regex at the top...
-    CATEGORIES = {
-      %r{\Adoc/} => :docs,
-      %r{\A(CONTRIBUTING|LICENSE|MAINTENANCE|PHILOSOPHY|PROCESS|README)(\.md)?\z} => :docs,
-
-      %r{\A(ee/)?app/(assets|views)/} => :frontend,
-      %r{\A(ee/)?public/} => :frontend,
-      %r{\A(ee/)?spec/(javascripts|frontend)/} => :frontend,
-      %r{\A(ee/)?vendor/assets/} => :frontend,
-      %r{\A(ee/)?scripts/frontend/} => :frontend,
-      %r{(\A|/)(
-        \.babelrc |
-        \.eslintignore |
-        \.eslintrc(\.yml)? |
-        \.nvmrc |
-        \.prettierignore |
-        \.prettierrc |
-        \.scss-lint.yml |
-        \.stylelintrc |
-        \.haml-lint.yml |
-        \.haml-lint_todo.yml |
-        babel\.config\.js |
-        jest\.config\.js |
-        package\.json |
-        yarn\.lock |
-        config/.+\.js
-      )\z}x => :frontend,
-
-      %r{(\A|/)(
-        \.gitlab/ci/frontend\.gitlab-ci\.yml
-      )\z}x => %i[frontend engineering_productivity],
-
-      %r{\A(ee/)?db/(?!fixtures)[^/]+} => :database,
-      %r{\A(ee/)?lib/gitlab/(database|background_migration|sql|github_import)(/|\.rb)} => :database,
-      %r{\A(app/models/project_authorization|app/services/users/refresh_authorized_projects_service)(/|\.rb)} => :database,
-      %r{\A(ee/)?app/finders/} => :database,
-      %r{\Arubocop/cop/migration(/|\.rb)} => :database,
-
-      %r{\A(\.gitlab-ci\.yml\z|\.gitlab\/ci)} => :engineering_productivity,
-      %r{\A\.codeclimate\.yml\z} => :engineering_productivity,
-      %r{\A\.overcommit\.yml\.example\z} => :engineering_productivity,
-      %r{\A\.editorconfig\z} => :engineering_productivity,
-      %r{Dangerfile\z} => :engineering_productivity,
-      %r{\A(ee/)?(danger/|lib/gitlab/danger/)} => :engineering_productivity,
-      %r{\A(ee/)?scripts/} => :engineering_productivity,
-      %r{\Atooling/} => :engineering_productivity,
-
-      %r{\A(ee/)?app/(?!assets|views)[^/]+} => :backend,
-      %r{\A(ee/)?(bin|config|generator_templates|lib|rubocop)/} => :backend,
-      %r{\A(ee/)?spec/features/} => :test,
-      %r{\A(ee/)?spec/} => :backend,
-      %r{\A(ee/)?vendor/} => :backend,
-      %r{\A(Gemfile|Gemfile.lock|Rakefile)\z} => :backend,
-      %r{\A[A-Z_]+_VERSION\z} => :backend,
-      %r{\A\.rubocop(_todo)?\.yml\z} => :backend,
-      %r{\Afile_hooks/} => :backend,
-
-      %r{\A(ee/)?qa/} => :qa,
-
-      # Files that don't fit into any category are marked with :none
-      %r{\A(ee/)?changelogs/} => :none,
-      %r{\Alocale/gitlab\.pot\z} => :none,
-
-      # Fallbacks in case the above patterns miss anything
-      %r{\.rb\z} => :backend,
-      %r{(
-        \.(md|txt)\z |
-        \.markdownlint\.json
-      )}x => :none, # To reinstate roulette for documentation, set to `:docs`.
-      %r{\.js\z} => :frontend,
+      ci_template: '~"ci::templates"',
     }.freeze
 
     HTTPError = Class.new(StandardError)
 
+    Change = Struct.new(:file, :change_type, :category)
+
+    class Changes < ::SimpleDelegator
+      def added
+        select_by_change_type(:added)
+      end
+
+      def modified
+        select_by_change_type(:modified)
+      end
+
+      def deleted
+        select_by_change_type(:deleted)
+      end
+
+      def renamed_before
+        select_by_change_type(:renamed_before)
+      end
+
+      def renamed_after
+        select_by_change_type(:renamed_after)
+      end
+
+      def has_category?(category)
+        any? { |change| change.category == category }
+      end
+
+      def by_category(category)
+        Changes.new(select { |change| change.category == category })
+      end
+
+      def categories
+        map(&:category).uniq
+      end
+
+      def files
+        map(&:file)
+      end
+
+      private
+
+      def select_by_change_type(change_type)
+        Changes.new(select { |change| change.change_type == change_type })
+      end
+    end
+
     def gitlab_helper
       # Unfortunately the following does not work:
       # - respond_to?(:gitlab)
@@ -98,10 +77,6 @@ module Danger
       nil
     end
 
-    def rule_names
-      ci? ? Gitlab::Dangerfiles::LOCAL_RULES | Gitlab::Dangerfiles::CI_ONLY_RULES : Gitlab::Dangerfiles::LOCAL_RULES
-    end
-
     def html_link(str)
       ci? ? gitlab_helper.html_link(str) : str
     end
@@ -148,23 +123,25 @@ module Danger
         .sort
     end
 
-    def all_ee_changes
-      all_changed_files.grep(%r{\Aee/})
-    end
-
-    def ee?
-      # Support former project name for `dev` and support local Danger run
-      %w[gitlab gitlab-ee].include?(ENV["CI_PROJECT_NAME"]) || Dir.exist?("../../ee")
+    # Returns a string containing changed lines as git diff
+    #
+    # Considering changing a line in lib/gitlab/usage_data.rb it will return:
+    #
+    # [ "--- a/lib/gitlab/usage_data.rb",
+    #   "+++ b/lib/gitlab/usage_data.rb",
+    #   "+      # Test change",
+    #   "-      # Old change" ]
+    def changed_lines(changed_file)
+      diff = git.diff_for_file(changed_file)
+      return [] unless diff
+
+      diff.patch.split("\n").select { |line| %r{^[+-]}.match?(line) }
     end
 
     def release_automation?
       gitlab_helper&.mr_author == RELEASE_TOOLS_BOT
     end
 
-    def project_name
-      ee? ? "gitlab" : "gitlab-foss"
-    end
-
     def markdown_list(items)
       list = items.map { |item| "* `#{item}`" }.join("\n")
 
@@ -175,17 +152,51 @@ module Danger
       end
     end
 
-    # @return [Hash<String,Array<String>>]
-    def changes_by_category
+    # @return [Hash<Symbol,Array<String>>]
+    def changes_by_category(categories)
       all_changed_files.each_with_object(Hash.new { |h, k| h[k] = [] }) do |file, hash|
-        categories_for_file(file).each { |category| hash[category] << file }
+        categories_for_file(file, categories).each { |category| hash[category] << file }
       end
     end
 
-    # Determines the categories a file is in, e.g., `[:frontend]`, `[:backend]`, or  `%i[frontend engineering_productivity]`.
+    # @return [Changes]
+    def changes(categories)
+      Changes.new([]).tap do |changes|
+        git.added_files.each do |file|
+          categories_for_file(file, categories).each { |category| changes << Change.new(file, :added, category) }
+        end
+
+        git.modified_files.each do |file|
+          categories_for_file(file, categories).each { |category| changes << Change.new(file, :modified, category) }
+        end
+
+        git.deleted_files.each do |file|
+          categories_for_file(file, categories).each { |category| changes << Change.new(file, :deleted, category) }
+        end
+
+        git.renamed_files.map { |x| x[:before] }.each do |file|
+          categories_for_file(file, categories).each { |category| changes << Change.new(file, :renamed_before, category) }
+        end
+
+        git.renamed_files.map { |x| x[:after] }.each do |file|
+          categories_for_file(file, categories).each { |category| changes << Change.new(file, :renamed_after, category) }
+        end
+      end
+    end
+
+    # Determines the categories a file is in, e.g., `[:frontend]`, `[:backend]`, or  `%i[frontend engineering_productivity]`
+    # using filename regex and specific change regex if given.
+    #
     # @return Array<Symbol>
-    def categories_for_file(file)
-      _, categories = CATEGORIES.find { |regexp, _| regexp.match?(file) }
+    def categories_for_file(file, categories)
+      _, categories = categories.find do |key, _|
+        filename_regex, changes_regex = Array(key)
+
+        found = filename_regex.match?(file)
+        found &&= changed_lines(file).any? { |changed_line| changes_regex.match?(changed_line) } if changes_regex
+
+        found
+      end
 
       Array(categories || :unknown)
     end
@@ -202,43 +213,64 @@ module Danger
       usernames.map { |u| Gitlab::Dangerfiles::Teammate.new("username" => u) }
     end
 
-    def missing_database_labels(current_mr_labels)
-      labels = if has_database_scoped_labels?(current_mr_labels)
-          ["database"]
-        else
-          ["database", "database::review pending"]
-        end
+    def mr_iid
+      return "" unless gitlab_helper
 
-      labels - current_mr_labels
+      gitlab_helper.mr_json["iid"]
     end
 
-    def sanitize_mr_title(title)
-      title.gsub(/^WIP: */, "").gsub(/`/, '\\\`')
+    def mr_title
+      return "" unless gitlab_helper
+
+      gitlab_helper.mr_json["title"]
     end
 
-    def security_mr?
-      return false unless gitlab_helper
+    def mr_web_url
+      return "" unless gitlab_helper
+
+      gitlab_helper.mr_json["web_url"]
+    end
+
+    def mr_labels
+      return [] unless gitlab_helper
+
+      gitlab_helper.mr_labels
+    end
+
+    def mr_target_branch
+      return "" unless gitlab_helper
 
-      gitlab_helper.mr_json["web_url"].include?("/gitlab-org/security/")
+      gitlab_helper.mr_json["target_branch"]
+    end
+
+    def draft_mr?
+      Gitlab::Dangerfiles::TitleLinting.has_draft_flag?(mr_title)
+    end
+
+    def security_mr?
+      mr_web_url.include?("/gitlab-org/security/")
     end
 
     def cherry_pick_mr?
-      return false unless gitlab_helper
+      Gitlab::Dangerfiles::TitleLinting.has_cherry_pick_flag?(mr_title)
+    end
 
-      /cherry[\s-]*pick/i.match?(gitlab_helper.mr_json["title"])
+    def run_all_rspec_mr?
+      Gitlab::Dangerfiles::TitleLinting.has_run_all_rspec_flag?(mr_title)
     end
 
-    def stable_branch?
-      return false unless gitlab_helper
+    def run_as_if_foss_mr?
+      Gitlab::Dangerfiles::TitleLinting.has_run_as_if_foss_flag?(mr_title)
+    end
 
-      /\A\d+-\d+-stable-ee/i.match?(gitlab_helper.mr_json["target_branch"])
+    def stable_branch?
+      /\A\d+-\d+-stable-ee/i.match?(mr_target_branch)
     end
 
     def mr_has_labels?(*labels)
-      return false unless gitlab_helper
-
       labels = labels.flatten.uniq
-      (labels & gitlab_helper.mr_labels) == labels
+
+      (labels & mr_labels) == labels
     end
 
     def labels_list(labels, sep: ", ")
@@ -251,10 +283,20 @@ module Danger
       "/label #{labels_list(labels, sep: " ")}"
     end
 
-    private
+    def changed_files(regex)
+      all_changed_files.grep(regex)
+    end
 
     def has_database_scoped_labels?(current_mr_labels)
       current_mr_labels.any? { |label| label.start_with?("database::") }
     end
+
+    def has_ci_changes?
+      changed_files(%r{\A(\.gitlab-ci\.yml|\.gitlab/ci/)}).any?
+    end
+
+    def group_label(labels)
+      labels.find { |label| label.start_with?("group::") }
+    end
   end
 end

data/lib/danger/roulette.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 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
@@ -9,42 +11,58 @@ module Danger
     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)
+    INCLUDE_TIMEZONE_FOR_CATEGORY = {
+      database: false,
+    }.freeze
+
+    Spin = Struct.new(:category, :reviewer, :maintainer, :optional_role, :timezone_experiment)
+
+    def team_mr_author
+      team.find { |person| person.username == mr_author_username }
+    end
 
     # Assigns GitLab team members to be reviewer and maintainer
     # for each change category that a Merge Request contains.
     #
     # @return [Array<Spin>]
-    def spin(project, categories, branch_name, timezone_experiment: false)
-      team = begin
-          project_team(project)
-        rescue => err
-          warn("Reviewer roulette failed to load team data: #{err.message}")
-          []
-        end
+    def spin(project, categories, timezone_experiment: false)
+      spins = categories.sort.map do |category|
+        including_timezone = INCLUDE_TIMEZONE_FOR_CATEGORY.fetch(category, timezone_experiment)
 
-      canonical_branch_name = canonical_branch_name(branch_name)
-
-      spin_per_category = categories.each_with_object({}) do |category, memo|
-        memo[category] = spin_for_category(team, project, category, canonical_branch_name, timezone_experiment: timezone_experiment)
+        spin_for_category(project, category, timezone_experiment: including_timezone)
       end
 
-      spin_per_category.map do |category, spin|
-        case category
+      backend_spin = spins.find { |spin| spin.category == :backend }
+
+      spins.each do |spin|
+        including_timezone = INCLUDE_TIMEZONE_FOR_CATEGORY.fetch(spin.category, timezone_experiment)
+        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&.any_capability?(project, spin.category)
+            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 = spin_per_category[:backend]&.reviewer || spin_for_category(team, project, :backend, canonical_branch_name).reviewer
+            spin.reviewer = backend_spin&.reviewer || spin_for_category(project, :backend, timezone_experiment: including_timezone).reviewer
           end
         when :engineering_productivity
           if spin.maintainer.nil?
             # Fetch an already picked backend maintainer, or pick one otherwise
-            spin.maintainer = spin_per_category[:backend]&.maintainer || spin_for_category(team, project, :backend, canonical_branch_name).maintainer
+            spin.maintainer = backend_spin&.maintainer || spin_for_category(project, :backend, timezone_experiment: including_timezone).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, timezone_experiment: including_timezone).maintainer
           end
         end
-
-        spin
       end
+
+      spins
     end
 
     # Looks up the current list of GitLab team members and parses it into a
@@ -66,14 +84,9 @@ module Danger
     # @return [Array<Teammate>]
     def project_team(project_name)
       team.select { |member| member.in_project?(project_name) }
-    end
-
-    def canonical_branch_name(branch_name)
-      branch_name.gsub(/^[ce]e-|-[ce]e$/, "")
-    end
-
-    def new_random(seed)
-      Random.new(Digest::MD5.hexdigest(seed).to_i(16))
+    rescue => err
+      warn("Reviewer roulette failed to load team data: #{err.message}")
+      []
     end
 
     # Known issue: If someone is rejected due to OOO, and then becomes not OOO, the
@@ -106,30 +119,49 @@ module Danger
     # @param [Teammate] person
     # @return [Boolean]
     def mr_author?(person)
-      person.username == gitlab.mr_author
+      person.username == mr_author_username
+    end
+
+    def mr_author_username
+      helper.gitlab_helper&.mr_author || `whoami`
+    end
+
+    def mr_source_branch
+      return `git rev-parse --abbrev-ref HEAD` unless helper.gitlab_helper&.mr_json
+
+      helper.gitlab_helper.mr_json["source_branch"]
+    end
+
+    def mr_labels
+      helper.gitlab_helper&.mr_labels || []
+    end
+
+    def new_random(seed)
+      Random.new(Digest::MD5.hexdigest(seed).to_i(16))
     end
 
     def spin_role_for_category(team, role, project, category)
       team.select do |member|
-        member.public_send("#{role}?", project, category, gitlab.mr_labels) # rubocop:disable GitlabSecurity/PublicSend
+        member.public_send("#{role}?", project, category, mr_labels) # rubocop:disable GitlabSecurity/PublicSend
       end
     end
 
-    def spin_for_category(team, project, category, branch_name, timezone_experiment: false)
+    def spin_for_category(project, category, timezone_experiment: false)
+      team = project_team(project)
       reviewers, traintainers, maintainers =
         %i[reviewer traintainer maintainer].map do |role|
           spin_role_for_category(team, role, project, category)
         end
 
-      # TODO: take CODEOWNERS into account?
-      # https://gitlab.com/gitlab-org/gitlab/issues/26723
+      random = new_random(mr_source_branch)
+
+      weighted_reviewers = Gitlab::Dangerfiles::Weightage::Reviewers.new(reviewers, traintainers).execute
+      weighted_maintainers = Gitlab::Dangerfiles::Weightage::Maintainers.new(maintainers).execute
 
-      # Make traintainers have triple the chance to be picked as a reviewer
-      random = new_random(branch_name)
-      reviewer = spin_for_person(reviewers + traintainers + traintainers, random: random, timezone_experiment: timezone_experiment)
-      maintainer = spin_for_person(maintainers, random: random, timezone_experiment: timezone_experiment)
+      reviewer = spin_for_person(weighted_reviewers, random: random, timezone_experiment: timezone_experiment)
+      maintainer = spin_for_person(weighted_maintainers, random: random, timezone_experiment: timezone_experiment)
 
-      Spin.new(category, reviewer, maintainer)
+      Spin.new(category, reviewer, maintainer, false, timezone_experiment)
     end
   end
 end