gitlab_roulette 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5cc6e8fe267c4dc7c5e6609f0425c218c4eb3fee2e929483da159d0940015a73
+  data.tar.gz: df8c969d4d068993f2478b4913d4fb7e8762461fbc5fab4dd14f018d7d4d3c79
+SHA512:
+  metadata.gz: 4e8bf7d129da294a986eafd3bb59f8aa9b0edc6c23852feba0cc0346b494d9dc902113c85c860ddaeaeab504da19616e969c1403e1b744cf5a56502952ce8923
+  data.tar.gz: 68dbb71f8222cdcdae6e6afe9deec123794675681b9bf227fc73135205e1af1d45b0a3af36e60d301da771006125cd7fb651fb5721d5b06a5b30c52cbc4fdb88

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+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, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at andrei.merfu@sparktech.ro. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Dangerfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'lib/gitlab_roulette/gitlab_danger'
+require_relative 'lib/gitlab_roulette/danger/request_helper'
+
+danger.import_plugin('danger/plugins/helper.rb')
+danger.import_plugin('danger/plugins/roulette.rb')
+
+danger.import_dangerfile(path: 'danger/roulette')

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in gitlab_roulette.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,80 @@
+PATH
+  remote: .
+  specs:
+    gitlab_roulette (1.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.7.0)
+      public_suffix (>= 2.0.2, < 5.0)
+    claide (1.0.3)
+    claide-plugins (0.9.2)
+      cork
+      nap
+      open4 (~> 1.3)
+    colored2 (3.1.2)
+    cork (0.3.0)
+      colored2 (~> 3.1)
+    danger (6.1.0)
+      claide (~> 1.0)
+      claide-plugins (>= 0.9.2)
+      colored2 (~> 3.1)
+      cork (~> 0.1)
+      faraday (~> 0.9)
+      faraday-http-cache (~> 2.0)
+      git (~> 1.5)
+      kramdown (~> 2.0)
+      kramdown-parser-gfm (~> 1.0)
+      no_proxy_fix
+      octokit (~> 4.7)
+      terminal-table (~> 1)
+    danger-gitlab (7.0.0)
+      danger (~> 6.0)
+      gitlab (~> 4.2, >= 4.2.0)
+    faraday (0.17.1)
+      multipart-post (>= 1.2, < 3)
+    faraday-http-cache (2.0.0)
+      faraday (~> 0.8)
+    git (1.5.0)
+    gitlab (4.12.0)
+      httparty (~> 0.14, >= 0.14.0)
+      terminal-table (~> 1.5, >= 1.5.1)
+    httparty (0.17.1)
+      mime-types (~> 3.0)
+      multi_xml (>= 0.5.2)
+    kramdown (2.1.0)
+    kramdown-parser-gfm (1.1.0)
+      kramdown (~> 2.0)
+    mime-types (3.3)
+      mime-types-data (~> 3.2015)
+    mime-types-data (3.2019.1009)
+    multi_xml (0.6.0)
+    multipart-post (2.1.1)
+    nap (1.1.0)
+    no_proxy_fix (0.1.2)
+    octokit (4.14.0)
+      sawyer (~> 0.8.0, >= 0.5.3)
+    open4 (1.3.4)
+    public_suffix (4.0.1)
+    rake (10.5.0)
+    sawyer (0.8.2)
+      addressable (>= 2.3.5)
+      faraday (> 0.8, < 2.0)
+    terminal-table (1.8.0)
+      unicode-display_width (~> 1.1, >= 1.1.1)
+    unicode-display_width (1.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  danger (~> 6.1.0)
+  danger-gitlab (~> 7.0.0)
+  faraday (~> 0.17.1)
+  gitlab_roulette!
+  rake (~> 10.0)
+
+BUNDLED WITH
+   2.0.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Andrei Merfu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,64 @@
+# Gitlab Roulette
+
+Gitlab Roulette chooses automatically a random reviewer and maintainer for your merge request and prints a beautiful message using DangerBot.
+
+<a href="https://ibb.co/Sn9Dsyd"><img src="https://i.ibb.co/hWtx79Z/Screenshot-2019-12-15-at-16-10-36.png" alt="Screenshot-2019-12-15-at-16-10-36" border="0"></a>
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'gitlab_roulette'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install gitlab_roulette
+
+## Usage
+
+First of all, you must set some environment variables to your Gitlab CI pipeline:
+
+```yaml
+  CI_PROJECT_NAME: "your_project_name"
+  GITLAB_ROULETTE_URL: "url to json file"
+  GITLAB_HOST: "https://self_hosted_gitlab_url"
+```
+
+Then all you have to do is to create a Dangerfile in the root directory of the project with the following configuration:
+
+```ruby
+	# frozen_string_literal: true
+
+	danger.import_dangerfile(gem: "gitlab_roulette")
+```
+
+GITLAB_ROULETTE_URL contains a JSON file with all the users from your Gitlab and his rank
+
+```json
+[
+	{
+		"username":"andrei.merfu","name":"Andrei Merfu",
+		"role":"Backend Engineer",
+		"projects": {
+			"gitlab_roulette":"maintainer backend"
+		}
+	},
+	{
+		"username":"another.user","name":"X Y",
+		"role":"Backend Engineer",
+		"projects": {
+			"gitlab_roulette":"reviewer backend"
+		}
+	}
+]
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "gitlab_roulette"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/danger/plugins/helper.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/gitlab_roulette/danger/helper'
+
+module Danger
+  # Common helper functions for our danger scripts. See Gitlab::Danger::Helper
+  # for more details
+  class Helper < Plugin
+    # Put the helper code somewhere it can be tested
+    include GitlabRoulette::Danger::Helper
+  end
+end

data/danger/plugins/roulette.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/gitlab_roulette/danger/roulette'
+
+module Danger
+  class Roulette < Plugin
+    # Put the helper code somewhere it can be tested
+    include GitlabRoulette::Danger::Roulette
+  end
+end

data/danger/roulette/Dangerfile

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'digest/md5'
+
+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 (e.g.
+~frontend or ~backend), and by a maintainer in all other categories.
+MARKDOWN
+
+CATEGORY_TABLE_HEADER = <<MARKDOWN
+
+To spread load more evenly across eligible reviewers, Danger has randomly picked
+a candidate for each review slot. Feel free to override this selection if you
+think someone else would be better-suited, or the chosen person is unavailable.
+
+Once you've decided who will review this merge request, mention them as you
+normally would! Danger does not (yet?) automatically notify them for you.
+
+| Category | Reviewer | Maintainer |
+| -------- | -------- | ---------- |
+MARKDOWN
+
+UNKNOWN_FILES_MESSAGE = <<MARKDOWN
+
+These files couldn't be categorised, so Danger was unable to suggest a reviewer.
+Please consider creating a merge request to
+[add support](https://gitlab.com/gitlab-org/gitlab/blob/master/lib/gitlab/danger/helper.rb)
+for them.
+MARKDOWN
+
+NO_REVIEWER = 'No reviewer available'.freeze
+NO_MAINTAINER = 'No maintainer available'.freeze
+
+def spin_for_category(team, project, category, branch_name)
+  puts "team = #{team}\n project=#{project}\n category=#{category}\n branch_name=#{branch_name}\n"
+  random = roulette.new_random(branch_name)
+  labels = gitlab.mr_labels
+  puts "labels = #{labels}"
+
+  reviewers, traintainers, maintainers =
+    %i[reviewer? traintainer? maintainer?].map do |kind|
+      team.select do |member|
+        member.public_send(kind, project, category, labels) # rubocop:disable GitlabSecurity/PublicSend
+      end
+    end
+
+  # TODO: take CODEOWNERS into account?
+  # https://gitlab.com/gitlab-org/gitlab/issues/26723
+
+  puts "reviewers = #{reviewers}\n maintainers=#{maintainers}\n"
+  # Make traintainers have triple the chance to be picked as a reviewer
+  reviewer = roulette.spin_for_person(reviewers + traintainers + traintainers, random: random)
+  maintainer = roulette.spin_for_person(maintainers, random: random)
+
+  "| #{helper.label_for_category(category)} | #{reviewer&.markdown_name || NO_REVIEWER} | #{maintainer&.markdown_name || NO_MAINTAINER} |"
+end
+
+changes = helper.changes_by_category
+
+# Ignore any files that are known but uncategorized. Prompt for any unknown files
+changes.delete(:none)
+categories = changes.keys - [:unknown]
+
+# Ensure to spin for database reviewer/maintainer when ~database is applied (e.g. to review SQL queries)
+categories << :database if gitlab.mr_labels.include?('database') && !categories.include?(:database)
+
+# Single codebase MRs are reviewed using a slightly different process, so we
+# disable the review roulette for such MRs.
+# CSS Clean up MRs are reviewed using a slightly different process, so we
+# disable the review roulette for such MRs.
+if changes.any? && !gitlab.mr_labels.include?('single codebase') && !gitlab.mr_labels.include?('CSS cleanup')
+  # Strip leading and trailing CE/EE markers
+  canonical_branch_name =
+    roulette.canonical_branch_name(gitlab.mr_json['source_branch'])
+
+  team =
+    begin
+      roulette.project_team(helper.project_name)
+    rescue => err
+      warn("Reviewer roulette failed to load team data: #{err.message}")
+      []
+    end
+
+  project = helper.project_name
+  unknown = changes.fetch(:unknown, [])
+
+  rows = categories.map { |category| spin_for_category(team, project, category, canonical_branch_name) }
+
+  markdown(MESSAGE)
+  markdown(CATEGORY_TABLE_HEADER + rows.join("\n")) unless rows.empty?
+  markdown(UNKNOWN_FILES_MESSAGE + helper.markdown_list(unknown)) unless unknown.empty?
+end

data/gitlab_roulette.gemspec

@@ -0,0 +1,36 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "gitlab_roulette/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "gitlab_roulette"
+  spec.version       = GitlabRoulette::VERSION
+  spec.authors       = ["Andrei Merfu"]
+  spec.email         = ["andreimerfu@outlook.com"]
+
+  spec.summary       = %q{GitlabRoulette adds a reviewer roulette to your self hosted Gitlab repository}
+  spec.description   = %q{GitlabRoulette choose reviewer and a maintainer for your merge request automatically}
+  spec.homepage      = "https://github.com/andreimerfu/gitlab_roulette.git"
+  spec.license       = "MIT"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/andreimerfu/gitlab_roulette.git"
+  spec.metadata["changelog_uri"] = "https://github.com/andreimerfu/gitlab_roulette.git"
+
+  # 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.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "danger-gitlab", "~> 7.0.0"
+  spec.add_development_dependency "danger", "~> 6.1.0"
+  spec.add_development_dependency "faraday", "~> 0.17.1"
+end

data/lib/gitlab_roulette.rb

@@ -0,0 +1,15 @@
+require "gitlab_roulette/version"
+require "faraday"
+require "ostruct"
+require "json"
+
+require "danger"
+
+require "gitlab_roulette/danger/helper"
+require "gitlab_roulette/danger/request_helper"
+require "gitlab_roulette/danger/roulette"
+require "gitlab_roulette/danger/teammate"
+
+module GitlabRoulette
+  class Error < StandardError; end
+end

data/lib/gitlab_roulette/danger/helper.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require_relative 'teammate'
+
+module Gitlab
+  module Danger
+    module Helper
+      RELEASE_TOOLS_BOT = 'gitlab-release-tools-bot'
+
+      # Returns a list of all files that have been added, modified or renamed.
+      # `git.modified_files` might contain paths that already have been renamed,
+      # so we need to remove them from the list.
+      #
+      # 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
+      # ```
+      # [ 'new_file.rb', 'modified_file.rb', 'renamed_file_after.rb' ]
+      # ```
+      #
+      # @return [Array<String>]
+      def all_changed_files
+        Set.new
+          .merge(git.added_files.to_a)
+          .merge(git.modified_files.to_a)
+          .merge(git.renamed_files.map { |x| x[:after] })
+          .subtract(git.renamed_files.map { |x| x[:before] })
+          .to_a
+          .sort
+      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')
+      end
+
+      def gitlab_helper
+        # Unfortunately the following does not work:
+        # - respond_to?(:gitlab)
+        # - respond_to?(:gitlab, true)
+        gitlab
+      rescue NoMethodError
+        nil
+      end
+
+      def release_automation?
+        gitlab_helper&.mr_author == RELEASE_TOOLS_BOT
+      end
+
+      def project_name
+        ENV["CI_PROJECT_NAME"]
+      end
+
+      def markdown_list(items)
+        list = items.map { |item| "* `#{item}`" }.join("\n")
+
+        if items.size > 10
+          "\n<details>\n\n#{list}\n\n</details>\n"
+        else
+          list
+        end
+      end
+
+      # @return [Hash<String,Array<String>>]
+      def changes_by_category
+        all_changed_files.each_with_object(Hash.new { |h, k| h[k] = [] }) do |file, hash|
+          hash[category_for_file(file)] << file
+        end
+      end
+
+      # Determines the category a file is in, e.g., `:frontend` or `:backend`
+      # @return[Symbol]
+      def category_for_file(file)
+        _, category = CATEGORIES.find { |regexp, _| regexp.match?(file) }
+
+        category || :unknown
+      end
+
+      # Returns the GFM for a category label, making its best guess if it's not
+      # a category we know about.
+      #
+      # @return[String]
+      def label_for_category(category)
+        CATEGORY_LABELS.fetch(category, "~#{category}")
+      end
+
+      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
+      CATEGORIES = {
+        %r{\Adoc/} => :none, # To reinstate roulette for documentation, set to `:docs`.
+        %r{\A(CONTRIBUTING|LICENSE|MAINTENANCE|PHILOSOPHY|PROCESS|README)(\.md)?\z} => :none, # To reinstate roulette for documentation, set to `: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 |
+          karma\.config\.js |
+          webpack\.config\.js |
+          package\.json |
+          yarn\.lock |
+          \.gitlab/ci/frontend\.gitlab-ci\.yml
+        )\z}x => :frontend,
+
+        %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{\Arubocop/cop/migration(/|\.rb)} => :database,
+
+        %r{\A(\.gitlab-ci\.yml\z|\.gitlab\/ci)} => :engineering_productivity,
+        %r{Dangerfile\z} => :engineering_productivity,
+        %r{\A(ee/)?(danger/|lib/gitlab/danger/)} => :engineering_productivity,
+        %r{\A(ee/)?scripts/} => :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/(?!javascripts|frontend)[^/]+} => :backend,
+        %r{\A(ee/)?vendor/(?!assets)[^/]+} => :backend,
+        %r{\A(ee/)?vendor/(languages\.yml|licenses\.csv)\z} => :backend,
+        %r{\A(Gemfile|Gemfile.lock|Procfile|Rakefile)\z} => :backend,
+        %r{\A[A-Z_]+_VERSION\z} => :backend,
+        %r{\A\.rubocop(_todo)?\.yml\z} => :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
+      }.freeze
+
+      def new_teammates(usernames)
+        usernames.map { |u| Gitlab::Danger::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
+
+        labels - current_mr_labels
+      end
+
+      private
+
+      def has_database_scoped_labels?(current_mr_labels)
+        current_mr_labels.any? { |label| label.start_with?('database::') }
+      end
+    end
+  end
+end

data/lib/gitlab_roulette/danger/request_helper.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+
+module Gitlab
+  module Danger
+    module RequestHelper
+      HTTPError = Class.new(RuntimeError)
+
+      # @param [String] url
+      def self.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
+    end
+  end
+end

data/lib/gitlab_roulette/danger/roulette.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative 'teammate'
+
+module Gitlab
+  module Danger
+    module Roulette
+      ROULETTE_DATA_URL = ENV["GITLAB_ROULETTE_URL"]
+
+      # Looks up the current list of GitLab team members and parses it into a
+      # useful form
+      #
+      # @return [Array<Teammate>]
+      def team
+        @team ||=
+          begin
+            if ROULETTE_DATA_URL.include?("https") || ROULETTE_DATA_URL.include?("http")
+              data = Gitlab::Danger::RequestHelper.http_get_json(ROULETTE_DATA_URL)
+            else
+              file = File.read(ROULETTE_DATA_URL)
+
+              data = JSON.parse(file)
+            end
+            data.map { |hash| ::Gitlab::Danger::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) }
+      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))
+      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:)
+        people.shuffle(random: random)
+          .find(&method(:valid_person?))
+      end
+
+      private
+
+      # @param [Teammate] person
+      # @return [Boolean]
+      def valid_person?(person)
+        !mr_author?(person) && person.available?
+      end
+
+      # @param [Teammate] person
+      # @return [Boolean]
+      def mr_author?(person)
+        person.username == gitlab.mr_author
+      end
+    end
+  end
+end

data/lib/gitlab_roulette/danger/teammate.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'cgi'
+
+module Gitlab
+  module Danger
+    class Teammate
+      attr_reader :name, :username, :role, :projects
+
+      def initialize(options = {})
+        @username = options['username']
+        @name = options['name'] || @username
+        @role = options['role']
+        @projects = options['projects']
+      end
+
+      def markdown_name
+        "[#{name}](#{gitlab_host}/#{username}) (`@#{username}`)"
+      end
+
+      def in_project?(name)
+        projects&.has_key?(name)
+      end
+
+      # Traintainers also count as reviewers
+      def reviewer?(project, category, labels)
+        has_capability?(project, category, :reviewer, labels) ||
+          traintainer?(project, category, labels)
+      end
+
+      def traintainer?(project, category, labels)
+        has_capability?(project, category, :trainee_maintainer, labels)
+      end
+
+      def maintainer?(project, category, labels)
+        has_capability?(project, category, :maintainer, labels)
+      end
+
+      def status
+        api_endpoint = "#{gitlab_host}/api/v4/users/#{CGI.escape(username)}/status"
+        @status ||= Gitlab::Danger::RequestHelper.http_get_json(api_endpoint)
+      rescue Gitlab::Danger::RequestHelper::HTTPError, JSON::ParserError
+        nil # better no status than a crashing Danger
+      end
+
+      # @return [Boolean]
+      def available?
+        !out_of_office? && has_capacity?
+      end
+
+      private
+
+      def gitlab_host
+        @gitlab_host ||= ENV["GITLAB_HOST"]
+      end
+
+      # @return [Boolean]
+      def out_of_office?
+        status&.dig("message")&.match?(/OOO/i) || false
+      end
+
+      # @return [Boolean]
+      def has_capacity?
+        status&.dig("emoji") != 'red_circle'
+      end
+
+      def has_capability?(project, category, kind, labels)
+        case category
+        when :test
+          area = role[/Software Engineer in Test(?:.*?, (\w+))/, 1]
+
+          area && labels.any?("devops::#{area.downcase}") if kind == :reviewer
+        when :engineering_productivity
+          return false unless role[/Engineering Productivity/]
+          return true if kind == :reviewer
+
+          capabilities(project).include?("#{kind} backend")
+        else
+          capabilities(project).include?("#{kind} #{category}")
+        end
+      end
+
+      def capabilities(project)
+        Array(projects.fetch(project, []))
+      end
+    end
+  end
+end

data/lib/gitlab_roulette/gitlab_danger.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+class GitlabDanger
+  LOCAL_RULES ||= %w[
+    changes_size
+    gemfile
+    documentation
+    frozen_string
+    duplicate_yarn_dependencies
+    prettier
+    eslint
+    database
+    commit_messages
+  ].freeze
+
+  CI_ONLY_RULES ||= %w[
+    metadata
+    changelog
+    specs
+    roulette
+    single_codebase
+    gitlab_ui_wg
+    ce_ee_vue_templates
+  ].freeze
+
+  MESSAGE_PREFIX = '==>'.freeze
+
+  attr_reader :gitlab_danger_helper
+
+  def initialize(gitlab_danger_helper)
+    @gitlab_danger_helper = gitlab_danger_helper
+  end
+
+  def self.local_warning_message
+    "#{MESSAGE_PREFIX} Only the following Danger rules can be run locally: #{LOCAL_RULES.join(', ')}"
+  end
+
+  def self.success_message
+    "#{MESSAGE_PREFIX} No Danger rule violations!"
+  end
+
+  def rule_names
+    ci? ? LOCAL_RULES | CI_ONLY_RULES : LOCAL_RULES
+  end
+
+  def html_link(str)
+    self.ci? ? gitlab_danger_helper.html_link(str) : str
+  end
+
+  def ci?
+    !gitlab_danger_helper.nil?
+  end
+end

data/lib/gitlab_roulette/version.rb

@@ -0,0 +1,3 @@
+module GitlabRoulette
+  VERSION = "1.0.0"
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: gitlab_roulette
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Andrei Merfu
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-12-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: danger-gitlab
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+- !ruby/object:Gem::Dependency
+  name: danger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.1.0
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.1
+description: GitlabRoulette choose reviewer and a maintainer for your merge request
+  automatically
+email:
+- andreimerfu@outlook.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CODE_OF_CONDUCT.md
+- Dangerfile
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- danger/plugins/helper.rb
+- danger/plugins/roulette.rb
+- danger/roulette/Dangerfile
+- gitlab_roulette.gemspec
+- lib/gitlab_roulette.rb
+- lib/gitlab_roulette/danger/helper.rb
+- lib/gitlab_roulette/danger/request_helper.rb
+- lib/gitlab_roulette/danger/roulette.rb
+- lib/gitlab_roulette/danger/teammate.rb
+- lib/gitlab_roulette/gitlab_danger.rb
+- lib/gitlab_roulette/version.rb
+homepage: https://github.com/andreimerfu/gitlab_roulette.git
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/andreimerfu/gitlab_roulette.git
+  source_code_uri: https://github.com/andreimerfu/gitlab_roulette.git
+  changelog_uri: https://github.com/andreimerfu/gitlab_roulette.git
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: GitlabRoulette adds a reviewer roulette to your self hosted Gitlab repository
+test_files: []