gitlab-dangerfiles 1.1.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5e1069be5416d6980879af3330451834b57881c46101119bfc5917e2057edd7
-  data.tar.gz: e911c514f8d32d65e4aecef6ad111c80c808dd273b12775d57438532ba8a05b3
+  metadata.gz: 0d3407bad03ff3220a55329e625c1fd5a962b4ffe29b4ab1da68a7e998761024
+  data.tar.gz: a9f31b18452500fa6e437a847b1d726cbbe2c47a1912c5e40fd18196ca3716fa
 SHA512:
-  metadata.gz: b3814724620240a6485ffce4191fb8a2461c267dda5dad2466b6dc5173fbe848b66cae92aaea69ef82a49dd4726db3a7e77c106fdbd73ea58738eaf4613c4cba
-  data.tar.gz: 0fcabbe03f856d29951ae2f35e9f6f9784fa22af8d8d6bfa13a41452b4a1c35a454135751443882e6a2762325ef05dd6b8bd1b3dde58c5c7661db65ffef4c5d7
+  metadata.gz: 3390ab204b7572654e748198fb1d03b70056ab26b32a8ea29cc2c624e307e59c5cfab5306afb8900c71df62671b984ccdbb21e7c1e9adb16b2ab43a9299774c0
+  data.tar.gz: '06879db4e54bff63e540793f8c94f3c9412d6481641144bfa80934bb36a82872c76e9693c86aa9b381d78528da06a27795f620ff9127829e4904938807958ede'

data/.yardopts

@@ -0,0 +1,5 @@
+--protected
+--no-private
+-
+CODE_OF_CONDUCT.md
+LICENSE.txt

data/Gemfile

@@ -5,3 +5,4 @@ gemspec
 
 gem "rake", "~> 12.0"
 gem "guard-rspec"
+gem "yard"

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2020 Rémy Coutable
+Copyright (c) 2020-2021 GitLab
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,8 +1,6 @@
 # Gitlab::Dangerfiles
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/gitlab/dangerfiles`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+The goal of this gem is to centralize Danger plugins and rules that to be used by multiple GitLab projects.
 
 ## Installation
 
@@ -14,15 +12,57 @@ gem 'gitlab-dangerfiles'
 
 And then execute:
 
-    $ bundle install
+```sh
+$ bundle install
+```
 
 Or install it yourself as:
 
-    $ gem install gitlab-dangerfiles
+```sh
+$ gem install gitlab-dangerfiles
+```
 
 ## Usage
 
-TODO: Write usage instructions here
+### Importing plugins and rules
+
+In your project's `Dangerfile`, add the following two line to import the plugins and rules from this gem:
+
+```ruby
+# Get an instance of Gitlab::Dangerfiles
+gitlab_dangerfiles = Gitlab::Dangerfiles::Engine.new(self)
+
+# Import all plugins from the gem
+gitlab_dangerfiles.import_plugins
+
+# Import all rules from the gem
+gitlab_dangerfiles.import_dangerfiles
+
+# Or import a subset of rules from the gem
+gitlab_dangerfiles.import_dangerfiles(rules: [:changes_size])
+```
+
+### Plugins
+
+Danger plugins are located under `lib/danger/plugins`.
+
+- `Danger::Helper` available in `Dangerfile`s as `helper`
+- `Danger::Roulette` available in `Dangerfile`s as `roulette`
+
+For the full documentation about the plugins, please see https://www.rubydoc.info/gems/gitlab-dangerfiles.
+
+### Rules
+
+
+Danger rules are located under `lib/danger/rules`.
+
+#### `changes_size`
+
+##### Available configurations
+
+- `code_size_thresholds`: 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.
 
 ## Development
 

data/gitlab-dangerfiles.gemspec

@@ -3,8 +3,8 @@ require_relative "lib/gitlab/dangerfiles/version"
 Gem::Specification.new do |spec|
   spec.name = "gitlab-dangerfiles"
   spec.version = Gitlab::Dangerfiles::VERSION
-  spec.authors = ["Rémy Coutable"]
-  spec.email = ["remy@rymai.me"]
+  spec.authors = ["GitLab"]
+  spec.email = ["gitlab_rubygems@gitlab.com"]
 
   spec.summary = %q{This gem provides common Dangerfile and plugins for GitLab projects.}
   spec.description = %q{This gem provides common Dangerfile and plugins for GitLab projects.}
@@ -16,7 +16,7 @@ Gem::Specification.new do |spec|
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://gitlab.com/gitlab-org/gitlab-dangerfiles"
-  spec.metadata["changelog_uri"] = "https://gitlab.com/gitlab-org/gitlab-dangerfiles"
+  spec.metadata["changelog_uri"] = "https://gitlab.com/gitlab-org/gitlab-dangerfiles/-/releases"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.

data/lib/danger/plugins/helper.rb

@@ -4,6 +4,7 @@ require "net/http"
 require "json"
 
 require_relative "../../gitlab/dangerfiles/changes"
+require_relative "../../gitlab/dangerfiles/config"
 require_relative "../../gitlab/dangerfiles/teammate"
 require_relative "../../gitlab/dangerfiles/title_linting"
 
@@ -11,7 +12,6 @@ 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: "",
@@ -22,36 +22,47 @@ module Danger
       product_intelligence: '~"product intelligence"',
     }.freeze
 
-    HTTPError = Class.new(StandardError)
-
-    def gitlab_helper
-      # Unfortunately the following does not work:
-      # - respond_to?(:gitlab)
-      # - respond_to?(:gitlab, true)
-      gitlab
-    rescue NoMethodError
-      nil
+    # Allows to set specific rule's configuration by passing a block.
+    #
+    # @yield [c] Yield a Gitlab::Dangerfiles::Config object
+    #
+    # @yieldparam [Gitlab::Dangerfiles::Config] The Gitlab::Dangerfiles::Config object
+    # @yieldreturn [Gitlab::Dangerfiles::Config] The Gitlab::Dangerfiles::Config object
+    #
+    # @example
+    #   helper.config do |config|
+    #     config.code_size_thresholds = { high: 42, medium: 12 }
+    #   end
+    #
+    # @return [Gitlab::Dangerfiles::Config]
+    def config
+      (@config ||= Gitlab::Dangerfiles::Config.new).tap do |c|
+        yield c if block_given?
+      end
     end
 
-    def html_link(str)
-      ci? ? gitlab_helper.html_link(str) : str
+    # @example
+    #   <a href='https://gitlab.com/artsy/eigen/blob/561827e46167077b5e53515b4b7349b8ae04610b/file.txt'>file.txt</a>
+    #
+    # @param [String,  Array<String>] paths
+    #        A list of strings to convert to gitlab anchors
+    # @param [Boolean] full_path
+    #        Shows the full path as the link's text, defaults to +true+.
+    #
+    # @see https://danger.systems/reference.html Danger reference where #html_link is described
+    # @see https://github.com/danger/danger/blob/eca19719d3e585fe1cc46bc5377f9aa955ebf609/lib/danger/danger_core/plugins/dangerfile_gitlab_plugin.rb#L216 Danger reference where #html_link is implemented
+    #
+    # @return [String] a list of HTML anchors for a file, or multiple files
+    def html_link(paths, full_path: true)
+      ci? ? gitlab_helper.html_link(paths, full_path: full_path) : paths
     end
 
+    # @return [Boolean] whether we're in the CI context or not.
     def ci?
       !gitlab_helper.nil?
     end
 
-    # @param [String] url
-    def http_get_json(url)
-      rsp = Net::HTTP.get_response(URI.parse(url))
-
-      unless rsp.is_a?(Net::HTTPOK)
-        raise HTTPError, "Failed to read #{url}: #{rsp.code} #{rsp.message}"
-      end
-
-      JSON.parse(rsp.body)
-    end
-
+    # @return [Array<String>] a list of filenames added in this MR.
     def added_files
       @added_files ||= if changes_from_api
           changes_from_api.select { |file| file["new_file"] }.map { |file| file["new_path"] }
@@ -60,6 +71,7 @@ module Danger
         end
     end
 
+    # @return [Array<String>] a list of filenames modifier in this MR.
     def modified_files
       @modified_files ||= if changes_from_api
           changes_from_api.select { |file| !file["new_file"] && !file["deleted_file"] && !file["renamed_file"] }.map { |file| file["new_path"] }
@@ -68,6 +80,7 @@ module Danger
         end
     end
 
+    # @return [Array<String>] a list of filenames renamed in this MR.
     def renamed_files
       @renamed_files ||= if changes_from_api
           changes_from_api.select { |file| file["renamed_file"] }.each_with_object([]) do |file, memo|
@@ -78,6 +91,7 @@ module Danger
         end
     end
 
+    # @return [Array<String>] a list of filenames deleted in this MR.
     def deleted_files
       @deleted_files ||= if changes_from_api
           changes_from_api.select { |file| file["deleted_file"] }.map { |file| file["new_path"] }
@@ -86,43 +100,20 @@ module Danger
         end
     end
 
-    def diff_for_file(filename)
-      if changes_from_api
-        changes_hash = changes_from_api.find { |file| file["new_path"] == filename }
-        changes_hash["diff"] if changes_hash
-      else
-        git.diff_for_file(filename)&.patch
-      end
-    end
-
-    def changes_from_api
-      return nil unless ci?
-      return nil if defined?(@force_changes_from_git)
-
-      @changes_from_api ||= gitlab_helper.mr_changes.to_h["changes"]
-    rescue
-      # Fallback to the Git strategy in any case
-      @force_changes_from_git = true
-      nil
-    end
-
-    # Returns a list of all files that have been added, modified or renamed.
-    # `modified_files` might contain paths that already have been renamed,
-    # so we need to remove them from the list.
-    #
-    # Considering these changes:
+    # @example
+    #   # Considering these changes:
+    #   # - A new_file.rb
+    #   # - D deleted_file.rb
+    #   # - M modified_file.rb
+    #   # - R renamed_file_before.rb -> renamed_file_after.rb
+    #   # it will return:
     #
-    # - A new_file.rb
-    # - D deleted_file.rb
-    # - M modified_file.rb
-    # - R renamed_file_before.rb -> renamed_file_after.rb
+    #   #=> ['new_file.rb', 'modified_file.rb', 'renamed_file_after.rb']
     #
-    # it will return
-    # ```
-    # [ 'new_file.rb', 'modified_file.rb', 'renamed_file_after.rb' ]
-    # ```
     #
-    # @return [Array<String>]
+    # @return [Array<String>] a list of all files that have been added, modified or renamed.
+    #   +modified_files+ might contain paths that already have been renamed,
+    #   so we need to remove them from the list.
     def all_changed_files
       Set.new
         .merge(added_files)
@@ -133,16 +124,19 @@ module Danger
         .sort
     end
 
-    # Returns a string containing changed lines as git diff
+    # @param filename [String] A file name for which we want the diff.
     #
-    # Considering changing a line in lib/gitlab/usage_data.rb it will return:
+    # @example
+    #   # 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 = diff_for_file(changed_file)
+    #   ["--- a/lib/gitlab/usage_data.rb",
+    #    "+++ b/lib/gitlab/usage_data.rb",
+    #    "+      # Test change",
+    #    "-      # Old change"]
+    #
+    # @return [Array<String>] an array of changed lines in Git diff format.
+    def changed_lines(filename)
+      diff = diff_for_file(filename)
       return [] unless diff
 
       diff.split("\n").select { |line| %r{^[+-]}.match?(line) }
@@ -152,6 +146,14 @@ module Danger
       gitlab_helper&.mr_author == RELEASE_TOOLS_BOT
     end
 
+    # @param items [Array<String>] An array of items to transform into a bullet list.
+    #
+    # @example
+    #   markdown_list(%w[foo bar])
+    #   # => * foo
+    #        * bar
+    #
+    # @return [String] a bullet list for the given +items+. If there are more than 10 items, wrap the list in a +<details></details>+ block.
     def markdown_list(items)
       list = items.map { |item| "* `#{item}`" }.join("\n")
 
@@ -162,14 +164,24 @@ module Danger
       end
     end
 
-    # @return [Hash<Symbol,Array<String>>]
+    # @param categories [{Regexp => Array<Symbol>}, {Array<Regexp> => Array<Symbol>}] A hash of the form +{ filename_regex => categories, [filename_regex, changes_regex] => categories }+.
+    #                   +filename_regex+ is the regex pattern to match file names. +changes_regex+ is the regex pattern to
+    #                   match changed lines in files that match +filename_regex+
+    #
+    # @return [{Symbol => Array<String>}] a hash of the type +{ category1: ["file1", "file2"], category2: ["file3", "file4"] }+
+    #   using filename regex (+filename_regex+) and specific change regex (+changes_regex+) from the given +categories+ hash.
     def changes_by_category(categories)
       all_changed_files.each_with_object(Hash.new { |h, k| h[k] = [] }) do |file, hash|
         categories_for_file(file, categories).each { |category| hash[category] << file }
       end
     end
 
-    # @return [Gitlab::Dangerfiles::Changes]
+    # @param categories [{Regexp => Array<Symbol>}, {Array<Regexp> => Array<Symbol>}] A hash of the form +{ filename_regex => categories, [filename_regex, changes_regex] => categories }+.
+    #                   +filename_regex+ is the regex pattern to match file names. +changes_regex+ is the regex pattern to
+    #                   match changed lines in files that match +filename_regex+
+    #
+    # @return [Gitlab::Dangerfiles::Changes] a +Gitlab::Dangerfiles::Changes+ object that represents the changes of an MR
+    #   using filename regex (+filename_regex+) and specific change regex (+changes_regex+) from the given +categories+ hash.
     def changes(categories)
       Gitlab::Dangerfiles::Changes.new([]).tap do |changes|
         added_files.each do |file|
@@ -194,16 +206,19 @@ module Danger
       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.
+    # @param filename [String] A file name.
+    # @param categories [{Regexp => Array<Symbol>}, {Array<Regexp> => Array<Symbol>}] A hash of the form +{ filename_regex => categories, [filename_regex, changes_regex] => categories }+.
+    #                   +filename_regex+ is the regex pattern to match file names. +changes_regex+ is the regex pattern to
+    #                   match changed lines in files that match +filename_regex+
     #
-    # @return Array<Symbol>
-    def categories_for_file(file, categories)
+    # @return [Array<Symbol>] the categories a file is in, e.g., +[:frontend]+, +[:backend]+, or +%i[frontend engineering_productivity]+
+    #   using filename regex (+filename_regex+) and specific change regex (+changes_regex+) from the given +categories+ hash.
+    def categories_for_file(filename, 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 = filename_regex.match?(filename)
+        found &&= changed_lines(filename).any? { |changed_line| changes_regex.match?(changed_line) } if changes_regex
 
         found
       end
@@ -211,114 +226,192 @@ module Danger
       Array(categories || :unknown)
     end
 
-    # Returns the GFM for a category label, making its best guess if it's not
-    # a category we know about.
+    # @param category [Symbol] A category.
     #
-    # @return[String]
+    # @return [String] the GFM for a category label, making its best guess if it's not
+    #   a category we know about.
     def label_for_category(category)
       CATEGORY_LABELS.fetch(category, "~#{category}")
     end
 
-    def new_teammates(usernames)
-      usernames.map { |u| Gitlab::Dangerfiles::Teammate.new("username" => u) }
-    end
-
+    # @return [String] +""+ when not in the CI context, and the MR IID as a string otherwise.
     def mr_iid
       return "" unless ci?
 
-      gitlab_helper.mr_json["iid"]
+      gitlab_helper.mr_json["iid"].to_s
     end
 
+    # @return [String] +`whoami`+ when not in the CI context, and the MR author username otherwise.
     def mr_author
       return `whoami`.strip unless ci?
 
       gitlab_helper.mr_author
     end
 
+    # @return [String] +""+ when not in the CI context, and the MR title otherwise.
     def mr_title
       return "" unless ci?
 
       gitlab_helper.mr_json["title"]
     end
 
+    # @return [String] +""+ when not in the CI context, and the MR URL otherwise.
     def mr_web_url
       return "" unless ci?
 
       gitlab_helper.mr_json["web_url"]
     end
 
+    # @return [Array<String>] +[]+ when not in the CI context, and the MR labels otherwise.
     def mr_labels
       return [] unless ci?
 
       gitlab_helper.mr_labels
     end
 
+    # @return [String] +`git rev-parse --abbrev-ref HEAD`+ when not in the CI context, and the MR source branch otherwise.
     def mr_source_branch
       return `git rev-parse --abbrev-ref HEAD`.strip unless ci?
 
       gitlab_helper.mr_json["source_branch"]
     end
 
+    # @return [String] +""+ when not in the CI context, and the MR target branch otherwise.
     def mr_target_branch
       return "" unless ci?
 
       gitlab_helper.mr_json["target_branch"]
     end
 
+    # @return [Boolean] whether a MR is a Draft or not.
     def draft_mr?
       Gitlab::Dangerfiles::TitleLinting.has_draft_flag?(mr_title)
     end
 
+    # @return [Boolean] whether a MR is opened in the security mirror or not.
     def security_mr?
       mr_web_url.include?("/gitlab-org/security/")
     end
 
+    # @return [Boolean] whether a MR title includes "cherry-pick" or not.
     def cherry_pick_mr?
       Gitlab::Dangerfiles::TitleLinting.has_cherry_pick_flag?(mr_title)
     end
 
+    # @return [Boolean] whether a MR title includes "RUN ALL RSPEC" or not.
     def run_all_rspec_mr?
       Gitlab::Dangerfiles::TitleLinting.has_run_all_rspec_flag?(mr_title)
     end
 
+    # @return [Boolean] whether a MR title includes "RUN AS-IF-FOSS" or not.
     def run_as_if_foss_mr?
       Gitlab::Dangerfiles::TitleLinting.has_run_as_if_foss_flag?(mr_title)
     end
 
+    # @return [Boolean] whether a MR targets a stable branch or not.
     def stable_branch?
       /\A\d+-\d+-stable-ee/i.match?(mr_target_branch)
     end
 
+    # Whether a MR has any database-scoped labels (i.e. +"database::*"+) set or not.
+    #
+    # @return [Boolean]
+    def has_database_scoped_labels?
+      mr_labels.any? { |label| label.start_with?("database::") }
+    end
+
+    # @return [Boolean] whether a MR has any CI-related changes (i.e. +".gitlab-ci.yml"+ or +".gitlab/ci/*"+) or not.
+    def has_ci_changes?
+      changed_files(%r{\A(\.gitlab-ci\.yml|\.gitlab/ci/)}).any?
+    end
+
+    # @param labels [Array<String>] An array of labels.
+    #
+    # @return [Boolean] whether a MR has the given +labels+ set or not.
     def mr_has_labels?(*labels)
       labels = labels.flatten.uniq
 
       (labels & mr_labels) == labels
     end
 
+    # @param labels [Array<String>] An array of labels.
+    # @param sep [String] A separator.
+    #
+    # @example
+    #   labels_list(["foo", "bar baz"], sep: "; ")
+    #    # => '~"foo"; ~"bar baz"'
+    #
+    # @return [String] the list of +labels+ ready for being used in a Markdown comment, separated by +sep+.
     def labels_list(labels, sep: ", ")
       labels.map { |label| %Q{~"#{label}"} }.join(sep)
     end
 
+    # @deprecated Use {#quick_action_label} instead.
     def prepare_labels_for_mr(labels)
+      quick_action_label(labels)
+    end
+
+    # @param labels [Array<String>] An array of labels.
+    #
+    # @example
+    #   quick_action_label(["foo", "bar baz"])
+    #    # => '/label ~"foo" ~"bar baz"'
+    #
+    # @return [String] a quick action to set the +given+ labels. Returns +""+ if +labels+ is empty.
+    def quick_action_label(labels)
       return "" unless labels.any?
 
       "/label #{labels_list(labels, sep: " ")}"
     end
 
+    # @param regex [Regexp] A Regexp to match against.
+    #
+    # @return [Array<String>] changed files matching the given +regex+.
     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::") }
+    # @return [Array<String>] the group labels (i.e. +"group::*"+) set on the MR.
+    def group_label
+      mr_labels.find { |label| label.start_with?("group::") }
     end
 
-    def has_ci_changes?
-      changed_files(%r{\A(\.gitlab-ci\.yml|\.gitlab/ci/)}).any?
+    private
+
+    # @return [Danger::RequestSources::GitLab, nil] the +gitlab+ helper, or +nil+ when it's not available.
+    def gitlab_helper
+      # Unfortunately the following does not work:
+      # - respond_to?(:gitlab)
+      # - respond_to?(:gitlab, true)
+      gitlab
+    rescue NoMethodError
+      nil
     end
 
-    def group_label(labels)
-      labels.find { |label| label.start_with?("group::") }
+    # @param filename [String] A filename for which we want the diff.
+    #
+    # @return [String] the raw diff as a string for the given +filename+.
+    def diff_for_file(filename)
+      if changes_from_api
+        changes_hash = changes_from_api.find { |file| file["new_path"] == filename }
+        changes_hash["diff"] if changes_hash
+      else
+        git.diff_for_file(filename)&.patch
+      end
+    end
+
+    # Fetches MR changes from the API instead of Git (default).
+    #
+    # @return [Array<Hash>, nil]
+    def changes_from_api
+      return nil unless ci?
+      return nil if defined?(@force_changes_from_git)
+
+      @changes_from_api ||= gitlab_helper.mr_changes.to_h["changes"]
+    rescue
+      # Fallback to the Git strategy in any case
+      @force_changes_from_git = true
+      nil
     end
   end
 end

data/lib/danger/plugins/roulette.rb

@@ -16,13 +16,21 @@ module Danger
     }.freeze
 
     Spin = Struct.new(:category, :reviewer, :maintainer, :optional_role, :timezone_experiment)
+    HTTPError = Class.new(StandardError)
 
+    # Finds the +Gitlab::Dangerfiles::Teammate+ object whose username matches the MR author username.
+    #
+    # @return [Gitlab::Dangerfiles::Teammate]
     def team_mr_author
-      team.find { |person| person.username == helper.mr_author }
+      company_members.find { |person| person.username == helper.mr_author }
     end
 
     # Assigns GitLab team members to be reviewer and maintainer
-    # for each change category that a Merge Request contains.
+    # for the given +categories+.
+    #
+    # @param project [String] A project path.
+    # @param categories [Array<Symbol>] An array of categories symbols.
+    # @param timezone_experiment [Boolean] Whether to select reviewers based in timezone or not.
     #
     # @return [Array<Spin>]
     def spin(project, categories = [nil], timezone_experiment: false)
@@ -33,6 +41,7 @@ module Danger
       end
 
       backend_spin = spins.find { |spin| spin.category == :backend }
+      frontend_spin = spins.find { |spin| spin.category == :frontend }
 
       spins.each do |spin|
         including_timezone = INCLUDE_TIMEZONE_FOR_CATEGORY.fetch(spin.category, timezone_experiment)
@@ -61,64 +70,32 @@ module Danger
           end
         when :product_intelligence
           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, timezone_experiment: including_timezone).maintainer
+          end
         end
       end
 
       spins
     end
 
-    # Looks up the current list of GitLab team members and parses it into a
-    # useful form
-    #
-    # @return [Array<Teammate>]
-    def team
-      @team ||= begin
-          data = helper.http_get_json(ROULETTE_DATA_URL)
-          data.map { |hash| Gitlab::Dangerfiles::Teammate.new(hash) }
-        rescue JSON::ParserError
-          raise "Failed to parse JSON response from #{ROULETTE_DATA_URL}"
-        end
-    end
-
-    # Like +team+, but only returns teammates in the current project, based on
-    # project_name.
-    #
-    # @return [Array<Teammate>]
-    def project_team(project_name)
-      team.select { |member| member.in_project?(project_name) }
-    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
-    # selection will change on next spin
-    # @param [Array<Teammate>] people
-    def spin_for_person(people, random:, timezone_experiment: false)
-      shuffled_people = people.shuffle(random: random)
-
-      if timezone_experiment
-        shuffled_people.find(&method(:valid_person_with_timezone?))
-      else
-        shuffled_people.find(&method(:valid_person?))
-      end
-    end
-
     private
 
-    # @param [Teammate] person
+    # @param [Gitlab::Dangerfiles::Teammate] person
     # @return [Boolean]
     def valid_person?(person)
       !mr_author?(person) && person.available
     end
 
-    # @param [Teammate] person
+    # @param [Gitlab::Dangerfiles::Teammate] person
     # @return [Boolean]
     def valid_person_with_timezone?(person)
       valid_person?(person) && HOURS_WHEN_PERSON_CAN_BE_PICKED.cover?(person.local_hour)
     end
 
-    # @param [Teammate] person
+    # @param [Gitlab::Dangerfiles::Teammate] person
     # @return [Boolean]
     def mr_author?(person)
       person.username == helper.mr_author
@@ -134,6 +111,22 @@ module Danger
       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, random:, timezone_experiment: false)
+      shuffled_people = people.shuffle(random: random)
+
+      if timezone_experiment
+        shuffled_people.find(&method(:valid_person_with_timezone?))
+      else
+        shuffled_people.find(&method(:valid_person?))
+      end
+    end
+
     def spin_for_category(project, category, timezone_experiment: false)
       team = project_team(project)
       reviewers, traintainers, maintainers =
@@ -151,5 +144,44 @@ module Danger
 
       Spin.new(category, reviewer, maintainer, false, timezone_experiment)
     end
+
+    # Fetches the given +url+ and parse its response as JSON.
+    #
+    # @param [String] url
+    #
+    # @return [Hash, Array]
+    def http_get_json(url)
+      rsp = Net::HTTP.get_response(URI.parse(url))
+
+      unless rsp.is_a?(Net::HTTPOK)
+        raise HTTPError, "Failed to read #{url}: #{rsp.code} #{rsp.message}"
+      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
+          raise "Failed to parse JSON response from #{ROULETTE_DATA_URL}"
+        end
+    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 { |member| member.in_project?(project_name) }
+    rescue => err
+      warn("Reviewer roulette failed to load team data: #{err.message}")
+      []
+    end
   end
 end

data/lib/danger/rules/changes_size/Dangerfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+thresholds = helper.config.code_size_thresholds
+lines_changed = git.lines_of_code
+
+if lines_changed > thresholds[:high]
+  warn "This merge request is definitely too big (#{lines_changed} lines changed), please split it into multiple merge requests."
+elsif lines_changed > thresholds[:medium]
+  warn "This merge request is quite big (#{lines_changed} lines changed), please consider splitting it into multiple merge requests."
+end

data/lib/gitlab/dangerfiles.rb

@@ -2,8 +2,87 @@ require "gitlab/dangerfiles/version"
 
 module Gitlab
   module Dangerfiles
-    def self.import_plugins(danger)
-      danger.import_plugin(File.expand_path("../danger/plugins/*.rb", __dir__))
+    RULES_DIR = File.expand_path("../danger/rules", __dir__)
+    EXISTING_RULES = Dir.glob(File.join(RULES_DIR, "*")).each_with_object([]) do |path, memo|
+      if File.directory?(path)
+        memo << File.basename(path)
+      end
+    end
+    LOCAL_RULES = %w[
+      changes_size
+    ].freeze
+    CI_ONLY_RULES = %w[
+    ].freeze
+
+    # This class provides utility methods to import plugins and dangerfiles easily.
+    class Engine
+      # @param dangerfile [Danger::Dangerfile] A +Danger::Dangerfile+ object.
+      #
+      # @example
+      #   # In your main Dangerfile:
+      #   dangerfiles = Gitlab::Dangerfiles::Engine.new(self)
+      #
+      # @return [Gitlab::Dangerfiles::Engine]
+      def initialize(dangerfile)
+        @dangerfile = dangerfile
+      end
+
+      # Import all available plugins.
+      #
+      # @example
+      #   # In your main Dangerfile:
+      #   dangerfiles = Gitlab::Dangerfiles::Engine.new(self)
+      #
+      #   # Import all plugins
+      #   dangerfiles.import_plugins
+      def import_plugins
+        danger_plugin.import_plugin(File.expand_path("../danger/plugins/*.rb", __dir__))
+      end
+
+      # Import available Dangerfiles.
+      #
+      # @param rules [Symbol, Array<String>] Can be either +:all+ (default) to import all rules,
+      #   or an array of rules.
+      #   Available rules are: +changes_size+.
+      #
+      # @example
+      #   # In your main Dangerfile:
+      #   dangerfiles = Gitlab::Dangerfiles::Engine.new(self)
+      #
+      #   # Import all rules
+      #   dangerfiles.import_dangerfiles
+      #
+      #   # Or import only a subset of rules
+      #   dangerfiles.import_dangerfiles(rules: %w[changes_size])
+      def import_dangerfiles(rules: :all)
+        filtered_rules(rules).each do |rule|
+          danger_plugin.import_dangerfile(path: File.join(RULES_DIR, rule))
+        end
+      end
+
+      private
+
+      attr_reader :dangerfile
+
+      def allowed_rules
+        return LOCAL_RULES unless helper_plugin.respond_to?(:ci?)
+
+        helper_plugin.ci? ? LOCAL_RULES | CI_ONLY_RULES : LOCAL_RULES
+      end
+
+      def filtered_rules(rules)
+        rules = EXISTING_RULES if rules == :all
+
+        Array(rules).map(&:to_s) & EXISTING_RULES & allowed_rules
+      end
+
+      def danger_plugin
+        @danger_plugin ||= dangerfile.plugins[Danger::DangerfileDangerPlugin]
+      end
+
+      def helper_plugin
+        @helper_plugin ||= dangerfile.plugins[Danger::Helper]
+      end
     end
   end
 end

data/lib/gitlab/dangerfiles/changes.rb

@@ -4,41 +4,63 @@ require_relative "title_linting"
 
 module Gitlab
   module Dangerfiles
+    # @!attribute file
+    #   @return [String] the file name that's changed.
+    # @!attribute change_type
+    #   @return [Symbol] the type of change (+:added+, +:modified+, +:deleted+, +:renamed_before+, +:renamed_after+).
+    # @!attribute category
+    #   @return [Symbol] the category of the change.
+    #     This is defined by consumers of the gem through +helper.changes_by_category+ or +helper.changes+.
     Change = Struct.new(:file, :change_type, :category)
 
     class Changes < ::SimpleDelegator
+      # Return an +Gitlab::Dangerfiles::Changes+ object with only the changes for the added files.
+      #
+      # @return [Gitlab::Dangerfiles::Changes]
       def added
         select_by_change_type(:added)
       end
 
+      # @return [Gitlab::Dangerfiles::Changes] the changes for the modified files.
       def modified
         select_by_change_type(:modified)
       end
 
+      # @return [Gitlab::Dangerfiles::Changes] the changes for the deleted files.
       def deleted
         select_by_change_type(:deleted)
       end
 
+      # @return [Gitlab::Dangerfiles::Changes] the changes for the renamed files (before the rename).
       def renamed_before
         select_by_change_type(:renamed_before)
       end
 
+      # @return [Gitlab::Dangerfiles::Changes] the changes for the renamed files (after the rename).
       def renamed_after
         select_by_change_type(:renamed_after)
       end
 
+      # @param category [Symbol] A category of change.
+      #
+      # @return [Boolean] whether there are any change for the given +category+.
       def has_category?(category)
         any? { |change| change.category == category }
       end
 
+      # @param category [Symbol] a category of change.
+      #
+      # @return [Gitlab::Dangerfiles::Changes] changes for the given +category+.
       def by_category(category)
         Changes.new(select { |change| change.category == category })
       end
 
+      # @return [Array<Symbol>] an array of the unique categories of changes.
       def categories
         map(&:category).uniq
       end
 
+      # @return [Array<String>] an array of the changed files.
       def files
         map(&:file)
       end

data/lib/gitlab/dangerfiles/commit_linter.rb

@@ -15,7 +15,7 @@ module Gitlab
           {
             separator_missing: "The commit subject and body must be separated by a blank line",
             details_too_many_changes: "Commits that change #{MAX_CHANGED_LINES_IN_COMMIT} or more lines across " \
-            "at least #{MAX_CHANGED_FILES_IN_COMMIT} files must describe these changes in the commit body",
+            "at least #{MAX_CHANGED_FILES_IN_COMMIT} files should describe these changes in the commit body",
             details_line_too_long: "The commit body should not contain more than #{MAX_LINE_LENGTH} characters per line",
             message_contains_text_emoji: "Avoid the use of Markdown Emoji such as `:+1:`. These add limited value " \
             "to the commit message, and are displayed as plain text outside of GitLab",

data/lib/gitlab/dangerfiles/config.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module Dangerfiles
+    class Config
+      # @!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
+
+      DEFAULT_CHANGES_SIZE_THRESHOLDS = { high: 2_000, medium: 500 }.freeze
+
+      def initialize
+        @code_size_thresholds = DEFAULT_CHANGES_SIZE_THRESHOLDS
+      end
+    end
+  end
+end

data/lib/gitlab/dangerfiles/emoji_checker.rb

@@ -4,6 +4,7 @@ require "json"
 
 module Gitlab
   module Dangerfiles
+    # @api private
     class EmojiChecker
       DIGESTS = File.expand_path("../../../fixtures/emojis/digests.json", __dir__)
       ALIASES = File.expand_path("../../../fixtures/emojis/aliases.json", __dir__)

data/lib/gitlab/dangerfiles/teammate.rb

@@ -101,11 +101,6 @@ module Gitlab
           return true if capabilities(project).include?("#{kind} engineering_productivity")
 
           capabilities(project).include?("#{kind} backend")
-        when :product_intelligence
-          return false unless role[/Engineer, Product Intelligence/]
-
-          # any reviewer of project from Product Intelligence team can review MR
-          kind == :reviewer && capabilities(project).any?
         when nil
           capabilities(project).include?("#{kind}")
         else

data/lib/gitlab/dangerfiles/version.rb

@@ -1,5 +1,5 @@
 module Gitlab
   module Dangerfiles
-    VERSION = "1.1.1"
+    VERSION = "2.0.0"
   end
 end

data/lib/gitlab/dangerfiles/weightage.rb

@@ -2,6 +2,7 @@
 
 module Gitlab
   module Dangerfiles
+    # @api private
     module Weightage
       CAPACITY_MULTIPLIER = 2 # change this number to change what it means to be a reduced capacity reviewer 1/this number
       BASE_REVIEWER_WEIGHT = 1

data/lib/gitlab/dangerfiles/weightage/maintainers.rb

@@ -5,6 +5,7 @@ require_relative "../weightage"
 module Gitlab
   module Dangerfiles
     module Weightage
+      # @api private
       class Maintainers
         def initialize(maintainers)
           @maintainers = maintainers

data/lib/gitlab/dangerfiles/weightage/reviewers.rb

@@ -18,6 +18,7 @@ module Gitlab
       # | hungry traintainer           |                              8 |
       # +------------------------------+--------------------------------+
       #
+      # @api private
       class Reviewers
         DEFAULT_REVIEWER_WEIGHT = Gitlab::Dangerfiles::Weightage::CAPACITY_MULTIPLIER * Gitlab::Dangerfiles::Weightage::BASE_REVIEWER_WEIGHT
         TRAINTAINER_WEIGHT = 3

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gitlab-dangerfiles
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 2.0.0
 platform: ruby
 authors:
-- Rémy Coutable
+- GitLab
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-04-01 00:00:00.000000000 Z
+date: 2021-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: danger-gitlab
@@ -110,7 +110,7 @@ dependencies:
         version: '0'
 description: This gem provides common Dangerfile and plugins for GitLab projects.
 email:
-- remy@rymai.me
+- gitlab_rubygems@gitlab.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -119,6 +119,7 @@ files:
 - ".gitlab-ci.yml"
 - ".gitlab/merge_request_templates/Release.md"
 - ".rspec"
+- ".yardopts"
 - CODE_OF_CONDUCT.md
 - Gemfile
 - Guardfile
@@ -132,12 +133,14 @@ files:
 - gitlab-dangerfiles.gemspec
 - lib/danger/plugins/helper.rb
 - lib/danger/plugins/roulette.rb
+- lib/danger/rules/changes_size/Dangerfile
 - lib/gitlab-dangerfiles.rb
 - lib/gitlab/Dangerfile
 - lib/gitlab/dangerfiles.rb
 - lib/gitlab/dangerfiles/base_linter.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
@@ -154,7 +157,7 @@ metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://gitlab.com/gitlab-org/gitlab-dangerfiles
   source_code_uri: https://gitlab.com/gitlab-org/gitlab-dangerfiles
-  changelog_uri: https://gitlab.com/gitlab-org/gitlab-dangerfiles
+  changelog_uri: https://gitlab.com/gitlab-org/gitlab-dangerfiles/-/releases
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -170,7 +173,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: This gem provides common Dangerfile and plugins for GitLab projects.