gitlab-dangerfiles 2.5.0 → 2.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 93e497ecb88959ef6d916e995491d4a17644b2875b765a87d1b8dbf2a2e245cd
-  data.tar.gz: 2060f3bb306e1abf440eb4d2eead9f4a97dd5999d28a691fe119260fcf338b45
+  metadata.gz: '083c7ae273083c8b4a4e62ae6b6ef18a86f541770681aec50e01e70f15e62953'
+  data.tar.gz: 0ec743dea037dbc84a59adc29acf405d834e1110aaf9e86320f935868dce3e34
 SHA512:
-  metadata.gz: 01a447e73d6550265ddf775674190816341bd07f484be816b7583fc3b70427bcfb2b1a0c9aa86b651486bed62953a8e97838c58527eee11af4c169f2633d7d2f
-  data.tar.gz: f85733f1b015c3170cafc990b0cf84c773ed8532f11e3978b59d21477ad592d8095ff6b46b4a673da98f956c1368ed4a6501e3ae26b62c1d1c534022bbc4b88b
+  metadata.gz: ecc770656df082b0cec24b6293ec92f118cd04ed7d654c65f3791fad283dbfa53583c14c33a93b29f0dc79e921ee8cdddc9d2c062ba1cc9e8e97f44e05244121
+  data.tar.gz: b92837330d8edef3136ff37751589592a7a4b2cb6c1f4204e982a1b2bcce236f7cd09e8501b1190c79ff4c4590cbe63ed5b02567d3b377435cc3c7db3c83a747

data/.gitlab/changelog_config.yml

@@ -0,0 +1,13 @@
+---
+# Settings for generating changelogs using the GitLab API. See
+# https://docs.gitlab.com/ee/api/repositories.html#generate-changelog-data for
+# more information.
+categories:
+  added: Added
+  fixed: Fixed
+  changed: Changed
+  deprecated: Deprecated
+  removed: Removed
+  security: Security
+  performance: Performance
+  other: Other

data/.gitlab/merge_request_templates/Release.md

@@ -1,35 +1,12 @@
-<!-- Replace `v4.5.0` with the previous release here, and `e18d76b309e42888759c1effe96767f13e34ae55`
-with the latest commit from https://gitlab.com/gitlab-org/gitlab-dangerfiles/commits/master that will be included in the release. -->
-- Diff: https://gitlab.com/gitlab-org/gitlab-dangerfiles/compare/v4.5.0...e18d76b309e42888759c1effe96767f13e34ae55
-
-- Release notes:
-
-<!-- Keep the sections order but remove the empty sections -->
-
-```markdown
-### New features and features updates
-
-- !aaa <Title of the aaa MR>.
-
-### Fixes
-
-- !bbb <Title of the bbb MR>.
-
-### Doc changes
-
-- !ccc <Title of the ccc MR>.
-
-### Other changes (tooling, technical debt)
-
-- !ddd <Title of the ddd MR>.
-```
+<!-- Replace `<NEW_VERSION>` with the previous release here, and `<COMMIT_UPDATING_VERSION>`
+with the latest commit from this merge request. -->
+- Diff: https://gitlab.com/gitlab-org/ruby/gems/gitlab-dangerfiles/compare/v<NEW_VERSION>...<COMMIT_UPDATING_VERSION>
 
 - Checklist before merging:
   - [ ] Diff link is up-to-date.
-  - [ ] Based on the diff, `lib/gitlab/dangerfiles/version.rb` is updated, according to [SemVer](https://semver.org).
-  - [ ] Release notes are accurate.
+  - [ ] Based on the diff, `version.rb` is updated, according to [SemVer](https://semver.org).
 
 - Checklist after merging:
-  - [ ] [Update the release notes for the newly created tag](docs/release_process.md#how-to).
+  - [ ] Check that automatic release notes (generated following the same process as https://docs.gitlab.com/ee/development/changelog.html) are correct.
 
-/label ~"Engineering Productivity" ~"ep::workflow" ~"tooling::workflow" ~tooling ~"Danger bot"
+/label ~"type::maintenance" ~"static code analysis"

data/CONTRIBUTING.md

@@ -0,0 +1,40 @@
+## Developer Certificate of Origin and License
+
+By contributing to GitLab B.V., you accept and agree to the following terms and
+conditions for your present and future contributions submitted to GitLab B.V.
+Except for the license granted herein to GitLab B.V. and recipients of software
+distributed by GitLab B.V., you reserve all right, title, and interest in and to
+your Contributions.
+
+All contributions are subject to the Developer Certificate of Origin and license set out at [docs.gitlab.com/ce/legal/developer_certificate_of_origin](https://docs.gitlab.com/ce/legal/developer_certificate_of_origin).
+
+_This notice should stay as the first item in the CONTRIBUTING.md file._
+
+## Code of conduct
+
+As contributors and maintainers of this project, we pledge to respect all people
+who contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual
+language or imagery, derogatory comments or personal attacks, trolling, public
+or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct. Project maintainers who do not follow the
+Code of Conduct may be removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior can be
+reported by emailing contact@gitlab.com.
+
+This Code of Conduct is adapted from the [Contributor Covenant](https://contributor-covenant.org), version 1.1.0,
+available at [https://contributor-covenant.org/version/1/1/0/](https://contributor-covenant.org/version/1/1/0/).

data/Dangerfile

@@ -1,10 +1,5 @@
 require_relative "lib/gitlab-dangerfiles"
 
-# 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
+Gitlab::Dangerfiles.for_project(self) do |dangerfiles|
+  dangerfiles.import_defaults
+end

data/README.md

@@ -26,22 +26,45 @@ $ gem install gitlab-dangerfiles
 
 ### Importing plugins and rules
 
-In your project's `Dangerfile`, add the following two line to import the plugins and rules from this gem:
+In your project's `Dangerfile`, add the following to import the plugins and rules from this gem:
 
 ```ruby
 require 'gitlab-dangerfiles'
 
-# Get an instance of Gitlab::Dangerfiles
-gitlab_dangerfiles = Gitlab::Dangerfiles::Engine.new(self)
+Gitlab::Dangerfiles.for_project(self) do |dangerfiles|
+  # Import all plugins from the gem
+  dangerfiles.import_plugins
 
-# Import all plugins from the gem
-gitlab_dangerfiles.import_plugins
+  # Import all rules from the gem
+  dangerfiles.import_dangerfiles
 
-# Import all rules from the gem
-gitlab_dangerfiles.import_dangerfiles
+  # Or import only a subset of rules
+  dangerfiles.import_dangerfiles(only: %w[changes_size])
 
-# Or import a subset of rules from the gem
-gitlab_dangerfiles.import_dangerfiles(rules: [:changes_size])
+  # Or import all rules except a subset of rules
+  dangerfiles.import_dangerfiles(except: %w[commit_messages])
+
+  # Or import only a subset of rules, except a subset of rules
+  dangerfiles.import_dangerfiles(only: %w[changes_size], except: %w[commit_messages])
+end
+```
+
+For simple projects such as libraries, you can use the convenience method `import_defaults`:
+
+```ruby
+Gitlab::Dangerfiles.for_project(self) do |dangerfiles|
+  # Imports all plugins, rules and the default reviewer roulette
+  dangerfiles.import_defaults
+end
+```
+
+You may optionally pass a project name; by default, `ENV['CI_PROJECT_NAME']` will be used:
+
+```ruby
+Gitlab::Dangerfiles.for_project(self, 'my-project') do |dangerfiles|
+  # Imports all plugins, rules and the default reviewer roulette
+  dangerfiles.import_defaults
+end
 ```
 
 ### Plugins
@@ -53,6 +76,20 @@ Danger plugins are located under `lib/danger/plugins`.
 
 For the full documentation about the plugins, please see https://www.rubydoc.info/gems/gitlab-dangerfiles.
 
+### Configuration
+
+Default configuration can be overriden in the form `helper.config.CONFIG_NAME = NEW_VALUE` (`CONFIG_NAME` being a value configuration key).
+
+Alternatively, you can also get/set configuration on the engine directly via `Gitlab::Dangerfiles::Engine#config`.
+
+#### Available general configurations
+
+- `project_name`: The project name. Currently used by the Roulette plugin to fetch relevant
+  reviewers/maintainers based on the project name. Default to `ENV["CI_PROJECT_NAME"]`.
+- `files_to_category`: 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`. Used in `helper.changes_by_category`, `helper.changes`, and `helper.categories_for_file`.
+
 ### Rules
 
 Danger rules are located under `lib/danger/rules`.
@@ -72,6 +109,44 @@ Danger rules are located under `lib/danger/rules`.
 - `max_commits_count`: The maximum number of allowed non-squashed/non-fixup commits for a given MR.
    A warning is triggered if the MR has more commits.
 
+### Reviewer Roulette
+
+The library includes a simplified default reviewer roulette that you can use in your
+project. To use it in your project, perform the following steps:
+
+1. If not yet done, create a `Dangerfile` at the top-level of your project. Refer to [Usage](#usage) to
+   see how to set it up.
+1. When using the default roulette, use `import_defaults` or import it manually when setting
+   up the gitlab-dangerfiles instance:
+   ```ruby
+   Gitlab::Dangerfiles.for_project(self) do |dangerfiles|
+     dangerfiles.import_dangerfiles(only: %w[simple_roulette])
+   end
+   ```
+
+### CI configuration
+
+In order to run `danger` on GitLab CI, perform the following steps:
+
+1. If not yet done, create a `Dangerfile` at the top-level of your project. Refer to [Usage](#usage) to
+   see how to set it up.
+2. In `.gitlab-ci.yml`, include [CI configuration](https://gitlab.com/gitlab-org/quality/pipeline-common/-/blob/master/ci/danger-review.yml)
+   which defines `danger-review` [CI job](https://docs.gitlab.com/ee/ci/jobs/):
+
+```yaml
+include:
+  - project: 'gitlab-org/quality/pipeline-common'
+    file:
+      - '/ci/danger-review.yml'
+```
+
+3. Create a [Project access token](https://docs.gitlab.com/ee/user/project/settings/project_access_tokens.html)
+   with scope `api` and role `Maintainer`.
+4. Add a [CI/CD variable](https://docs.gitlab.com/ee/ci/variables/#add-a-cicd-variable-to-a-project)
+   `DANGER_GITLAB_API_TOKEN` (`Masked` but not `Protected`) and use Project access token as value.
+
+See a [real world example](https://gitlab.com/gitlab-org/ruby/gems/gitlab-styles/-/merge_requests/105).
+
 ## Documentation
 
 Latest documentation can be found at <https://www.rubydoc.info/gems/gitlab-dangerfiles>.

data/lib/danger/plugins/{helper.rb → internal/helper.rb}

@@ -3,10 +3,10 @@
 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"
+require_relative "../../../gitlab/dangerfiles/changes"
+require_relative "../../../gitlab/dangerfiles/config"
+require_relative "../../../gitlab/dangerfiles/teammate"
+require_relative "../../../gitlab/dangerfiles/title_linting"
 
 module Danger
   # Common helper functions for our danger scripts.
@@ -175,7 +175,7 @@ module Danger
     #
     # @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)
+    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
@@ -187,7 +187,7 @@ module Danger
     #
     # @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)
+    def changes(categories = [])
       Gitlab::Dangerfiles::Changes.new([]).tap do |changes|
         added_files.each do |file|
           categories_for_file(file, categories).each { |category| changes << Gitlab::Dangerfiles::Change.new(file, :added, category) }
@@ -212,14 +212,17 @@ module Danger
     end
 
     # @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+
+    # @param files_to_category [{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>] the categories a file is in, e.g., +[:frontend]+, +[:backend]+, or +%i[frontend tooling]+
     #   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, _|
+    def categories_for_file(filename, files_to_category = {})
+      files_to_category = Array(files_to_category).compact
+      files_to_category = helper.config.files_to_category if files_to_category.empty?
+
+      _, categories = files_to_category.find do |key, _|
         filename_regex, changes_regex = Array(key)
 
         found = filename_regex.match?(filename)

data/lib/danger/plugins/roulette.rb

@@ -33,8 +33,8 @@ module Danger
     # @param timezone_experiment [Boolean] Whether to select reviewers based in timezone or not.
     #
     # @return [Array<Spin>]
-    def spin(project, categories = [nil], timezone_experiment: false)
-      project = project.downcase
+    def spin(project = nil, categories = [nil], timezone_experiment: false)
+      project = (project || helper.config.project_name).downcase
       categories = categories.map { |category| category&.downcase }
 
       spins = categories.sort_by(&:to_s).map do |category|

data/lib/danger/rules/simple_roulette/Dangerfile

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+PROJECT_NAME = helper.config.project_name
+
+MESSAGE = <<MARKDOWN
+## Reviewer roulette
+
+Changes that require review have been detected! A merge request is normally
+reviewed by both a reviewer and a maintainer in its primary category and by a
+maintainer in all other categories.
+MARKDOWN
+
+TABLE_MARKDOWN = <<MARKDOWN
+
+To spread load more evenly across eligible reviewers, Danger has picked a candidate for each
+review slot. Feel free to
+[override these selections](https://about.gitlab.com/handbook/engineering/projects/##{PROJECT_NAME})
+if you think someone else would be better-suited
+or use the [GitLab Review Workload Dashboard](https://gitlab-org.gitlab.io/gitlab-roulette/) to find other available reviewers.
+
+To read more on how to use the reviewer roulette, please take a look at the
+[Engineering workflow](https://about.gitlab.com/handbook/engineering/workflow/#basics)
+and [code review guidelines](https://docs.gitlab.com/ee/development/code_review.html).
+Please consider assigning a reviewer or maintainer who is a
+[domain expert](https://about.gitlab.com/handbook/engineering/projects/#gitlab-development-kit) in the area of the merge request.
+
+Once you've decided who will review this merge request, mention them as you
+normally would! Danger does not automatically notify them for you.
+
+MARKDOWN
+
+TABLE_HEADER_WITH_CATEGORIES = <<MARKDOWN
+| Category | Reviewer | Maintainer |
+| -------- | -------- | ---------- |
+MARKDOWN
+
+TABLE_HEADER_WITHOUT_CATEGORIES = <<MARKDOWN
+| Reviewer | Maintainer |
+| -------- | ---------- |
+MARKDOWN
+
+OPTIONAL_REVIEW_TEMPLATE = '%{role} review is optional'
+NOT_AVAILABLE_TEMPLATE = 'No %{role} available'
+
+def note_for_spins_role(spins, role)
+  spins.each do |spin|
+    note = note_for_spin_role(spin, role)
+
+    return note if note
+  end
+
+  NOT_AVAILABLE_TEMPLATE % { role: role }
+end
+
+def note_for_spin_role(spin, role)
+  if spin.optional_role == role
+    return OPTIONAL_REVIEW_TEMPLATE % { role: role.capitalize }
+  end
+
+  spin.public_send(role)&.markdown_name(author: roulette.team_mr_author)
+end
+
+def markdown_row_for_spins(category = nil, spins_array)
+  reviewer_note = note_for_spins_role(spins_array, :reviewer)
+  maintainer_note = note_for_spins_role(spins_array, :maintainer)
+
+  row = +"| #{reviewer_note} | #{maintainer_note} |"
+  row.prepend("| #{helper.label_for_category(category)} ") if categories_defined?
+
+  row
+end
+
+def categories_defined?
+  helper.config.files_to_category.any?
+end
+
+def categories(changes)
+  categories_defined? ? changes.keys : [nil]
+end
+
+def table_header
+  categories_defined? ? TABLE_HEADER_WITH_CATEGORIES : TABLE_HEADER_WITHOUT_CATEGORIES
+end
+
+changes = helper.changes_by_category
+
+if changes.any?
+  random_roulette_spins = roulette.spin(nil, categories(changes))
+
+  rows = random_roulette_spins.map do |spin|
+    markdown_row_for_spins(spin.category, [spin])
+  end
+
+  markdown(MESSAGE)
+  markdown(TABLE_MARKDOWN + table_header + rows.join("\n")) unless rows.empty?
+end

data/lib/gitlab/dangerfiles/config.rb

@@ -3,6 +3,16 @@
 module Gitlab
   module Dangerfiles
     class Config
+      # @!attribute project_name
+      #   @return [String] the project name. Currently used by the Roulette plugin to fetch relevant reviewers/maintainers based on the project name. Default to +ENV["CI_PROJECT_NAME"]+.
+      attr_accessor :project_name
+
+      # @!attribute files_to_category
+      #   @return [{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+. Used in `helper.changes_by_category`, `helper.changes`, and `helper.categories_for_file`.
+      attr_accessor :files_to_category
+
       # @!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
@@ -15,6 +25,8 @@ module Gitlab
       DEFAULT_COMMIT_MESSAGES_MAX_COMMITS_COUNT = 10
 
       def initialize
+        @files_to_category = {}
+        @project_name = ENV["CI_PROJECT_NAME"]
         @code_size_thresholds = DEFAULT_CHANGES_SIZE_THRESHOLDS
         @max_commits_count = DEFAULT_COMMIT_MESSAGES_MAX_COMMITS_COUNT
       end

data/lib/gitlab/dangerfiles/teammate.rb

@@ -116,11 +116,10 @@ module Gitlab
 
           area && labels.any?("devops::#{area.downcase}") if kind == :reviewer
         when :tooling, :engineering_productivity # Deprecated as of 2.3.0 in favor of tooling
-          return false unless role[/Engineering Productivity/]
-          return true if kind == :reviewer
-          return true if capabilities(project).include?("#{kind} engineering_productivity")
+          return true if capabilities(project).include?("#{kind} #{category}")
+          return false if kind == :maintainer
 
-          capabilities(project).include?("#{kind} backend")
+          capabilities(project).include?("#{kind} backend") # fallback to backend reviewer
         when :integrations_be
           kind == :reviewer &&
             role.match?(/Backend Engineer.+Ecosystem:Integrations/)

data/lib/gitlab/dangerfiles/version.rb

@@ -1,5 +1,5 @@
 module Gitlab
   module Dangerfiles
-    VERSION = "2.5.0"
+    VERSION = "2.7.1"
   end
 end

data/lib/gitlab/dangerfiles.rb

@@ -13,8 +13,24 @@ module Gitlab
       commit_messages
     ].freeze
     CI_ONLY_RULES = %w[
+      simple_roulette
     ].freeze
 
+    # Utility method to construct a [Gitlab::Dangerfiles::Engine] instance,
+    # which is yielded to the given block.
+    #
+    # @param dangerfile [Danger::Dangerfile] A +Danger::Dangerfile+ object.
+    # @param project_name An option string to set the project name. Defaults to +ENV['CI_PROJECT_NAME']+.
+    #
+    # @return [Gitlab::Dangerfiles::Engine]
+    def self.for_project(dangerfile, project_name = nil)
+      Engine.new(dangerfile).tap do |engine|
+        engine.config.project_name = project_name if project_name
+
+        yield engine
+      end
+    end
+
     # This class provides utility methods to import plugins and dangerfiles easily.
     class Engine
       # @param dangerfile [Danger::Dangerfile] A +Danger::Dangerfile+ object.
@@ -26,41 +42,75 @@ module Gitlab
       # @return [Gitlab::Dangerfiles::Engine]
       def initialize(dangerfile)
         @dangerfile = dangerfile
+
+        # Import internal plugins eagerly, since other functionality in this class may depend on them.
+        danger_plugin.import_plugin(File.expand_path("../danger/plugins/internal/*.rb", __dir__))
       end
 
       # Import all available plugins.
       #
       # @example
       #   # In your main Dangerfile:
-      #   dangerfiles = Gitlab::Dangerfiles::Engine.new(self)
-      #
-      #   # Import all plugins
-      #   dangerfiles.import_plugins
+      #   Gitlab::Dangerfiles.for_project(self) do |dangerfiles|
+      #     dangerfiles.import_plugins
+      #   end
       def import_plugins
         danger_plugin.import_plugin(File.expand_path("../danger/plugins/*.rb", __dir__))
       end
 
       # Import available Dangerfiles.
       #
+      # @deprecated
       # @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)
+      # @param only [Symbol, Array<String>] An array of rules to import (defaults to all rules).
+      #   Available rules are: +changes_size+.
       #
-      #   # Import all rules
-      #   dangerfiles.import_dangerfiles
+      # @param except [Symbol, Array<String>] An array of rules to not import (defaults to []).
+      #   Available rules are: +changes_size+.
       #
-      #   # 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|
+      # @example
+      #   # In your main Dangerfile:
+      #   Gitlab::Dangerfiles.for_project(self) do |dangerfiles|
+      #     # Import all rules
+      #     dangerfiles.import_dangerfiles
+      #     # Or import only a subset of rules
+      #     dangerfiles.import_dangerfiles(only: %w[changes_size])
+      #     # Or import all rules except a subset of rules
+      #     dangerfiles.import_dangerfiles(except: %w[commit_messages])
+      #     # Or import only a subset of rules, except a subset of rules
+      #     dangerfiles.import_dangerfiles(only: %w[changes_size], except: %w[commit_messages])
+      #   end
+      def import_dangerfiles(rules: nil, only: nil, except: [])
+        puts "The `:rules` parameter is deprecated in favor of `:only`." unless rules.nil?
+
+        only ||= EXISTING_RULES if rules == :all
+        only ||= rules || EXISTING_RULES
+
+        filtered_rules(only, except).each do |rule|
           danger_plugin.import_dangerfile(path: File.join(RULES_DIR, rule))
         end
       end
 
+      # Proxy method to +helper_plugin.config+.
+      def config
+        helper_plugin.config
+      end
+
+      # Imports all default plugins and rules.
+      #
+      # @example
+      #   # In your main Dangerfile:
+      #   Gitlab::Dangerfiles.for_project(self) do |dangerfiles|
+      #     dangerfiles.import_defaults
+      #   end
+      def import_defaults
+        import_plugins
+        import_dangerfiles
+      end
+
       private
 
       attr_reader :dangerfile
@@ -71,10 +121,8 @@ module Gitlab
         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
+      def filtered_rules(only, except)
+        (Array(only).map(&:to_s) & EXISTING_RULES & allowed_rules) - except
       end
 
       def danger_plugin

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gitlab-dangerfiles
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 2.7.1
 platform: ruby
 authors:
 - GitLab
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-11-08 00:00:00.000000000 Z
+date: 2021-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: danger-gitlab
@@ -132,10 +132,12 @@ files:
 - ".gitignore"
 - ".gitlab-ci.yml"
 - ".gitlab/CODEOWNERS"
+- ".gitlab/changelog_config.yml"
 - ".gitlab/merge_request_templates/Release.md"
 - ".rspec"
 - ".yardopts"
 - CODE_OF_CONDUCT.md
+- CONTRIBUTING.md
 - Dangerfile
 - Gemfile
 - Guardfile
@@ -147,10 +149,11 @@ files:
 - fixtures/emojis/aliases.json
 - fixtures/emojis/digests.json
 - gitlab-dangerfiles.gemspec
-- lib/danger/plugins/helper.rb
+- lib/danger/plugins/internal/helper.rb
 - lib/danger/plugins/roulette.rb
 - lib/danger/rules/changes_size/Dangerfile
 - lib/danger/rules/commit_messages/Dangerfile
+- lib/danger/rules/simple_roulette/Dangerfile
 - lib/gitlab-dangerfiles.rb
 - lib/gitlab/Dangerfile
 - lib/gitlab/dangerfiles.rb