payping-gitlab-triage 0.1.1

data/lib/gitlab/triage/entity_builders/summary_builder.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative '../command_builders/text_content_builder'
+
+module Gitlab
+  module Triage
+    module EntityBuilders
+      class SummaryBuilder
+        def initialize(
+          type:, action:, resources:, network:,
+          policy_spec: {}, separator: "\n")
+          @type = type
+          @policy_spec = policy_spec
+          @item_template = action[:item]
+          @title_template = action[:title]
+          @summary_template = action[:summary]
+          @summary_destination = action[:destination]
+          @redact_confidentials =
+            action[:redact_confidential_resources] != false
+          @resources = resources
+          @network = network
+          @separator = separator
+        end
+
+        def title
+          @title ||= build_text(title_resource, @title_template)
+        end
+
+        def description
+          @description ||= build_text(description_resource, @summary_template)
+        end
+
+        def destination
+          @summary_destination
+        end
+
+        def valid?
+          title =~ /\S+/ && any_resources?
+        end
+
+        def any_resources?
+          @resources.any?
+        end
+
+        private
+
+        def title_resource
+          { type: @type }
+        end
+
+        def description_resource
+          title_resource.merge(
+            title: title, items: items, resources: @resources)
+        end
+
+        def items
+          @items ||= @resources.map { |x| build_item(x) }.join(@separator)
+        end
+
+        def build_item(resource)
+          case resource
+          when SummaryBuilder
+            resource.description
+          else
+            build_text(resource, @item_template)
+          end
+        end
+
+        def build_text(resource, template)
+          return '' unless template
+
+          CommandBuilders::TextContentBuilder.new(
+            template,
+            resource: resource,
+            network: @network,
+            redact_confidentials: @redact_confidentials)
+            .build_command.chomp
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/errors/network.rb

@@ -0,0 +1,11 @@
+module Gitlab
+  module Triage
+    module Errors
+      module Network
+        InternalServerError = Class.new(StandardError)
+        TooManyRequests = Class.new(StandardError)
+        UnexpectedResponse = Class.new(StandardError)
+      end
+    end
+  end
+end

data/lib/gitlab/triage/errors.rb

@@ -0,0 +1 @@
+require_relative 'errors/network'

data/lib/gitlab/triage/expand_condition/expansion.rb

@@ -0,0 +1,203 @@
+module Gitlab
+  module Triage
+    module ExpandCondition
+      class Expansion
+        # @pattern describes how we're looking for the pattern, and
+        # @compile is a block which should compile the scanned data
+        # into a list of results.
+        #
+        # Please see the comments for #perform to see actual example.
+        def initialize(pattern, &compile)
+          @pattern = pattern
+          @compile = compile
+        end
+
+        # This method will take a list of strings, which contains
+        # some kind of pattern, described by @pattern and expand them
+        # into each possible matches via @compile. For example,
+        # suppose @pattern is:
+        #
+        #     /\{(\d+)\.\.(\d+)\}/
+        #
+        # And @compile is:
+        #
+        #     do |(lower, upper)|
+        #       Integer(lower)..Integer(upper)
+        #     end
+        #
+        # And the input is:
+        #
+        # * a:{0..1}
+        # * b:{2..3}
+        # * c
+        #
+        # The result would be:
+        #
+        # * * a:0
+        #   * b:2
+        #   * c
+        # * * a:0
+        #   * b:3
+        #   * c
+        # * * a:1
+        #   * b:2
+        #   * c
+        # * * a:1
+        #   * b:3
+        #   * c
+        #
+        # We get this by picking the 1st number from the 1st string,
+        # which is 0 from "a:{0..1}", and the 1st number from the
+        # 2nd string, which is 2 from "b:{2..3}", and since the 3rd
+        # string is just a fixed string, we just pick it.
+        #
+        # This way we have the first possible match, that is:
+        #
+        # * a:0
+        # * b:2
+        # * c
+        #
+        # Then we repeat the process by picking the next number for the
+        # next possible match, starting from the least significant
+        # string, which is c, but there's nothing more to pick. Then we
+        # go to the next one, which will be the 2nd string: "b:{2..3}",
+        # and we pick the 2nd number for it: 3. Since we have a new pick,
+        # we have a new possible match:
+        #
+        # * a:0
+        # * b:3
+        # * c
+        #
+        # Again we repeat the process, and 2nd string doesn't have more
+        # choices therefore we need to go to the 1st string now. When
+        # this happens, we'll need to reset the picks from the previous
+        # string, thus 2nd string will go back to 2. The next number for
+        # the 1st string is 1, and then we form the new match:
+        #
+        # * a:1
+        # * b:2
+        # * c
+        #
+        # The next step will be the last match by picking the next number
+        # from the 2nd string again: 3, and we get:
+        #
+        # * a:1
+        # * b:3
+        # * c
+        #
+        # The method will stop here because it had walked through all the
+        # possible combinations. The total number of results is the product
+        # of numbers of sequences.
+        #
+        # Note that a string can contain multiple sequences, and it will
+        # also walk through them one by one. For example, given:
+        #
+        # * a:{0..1}:{2..3}
+        # * c
+        #
+        # We'll get:
+        #
+        # * * a:0:2
+        #   * c
+        # * * a:0:3
+        #   * c
+        # * * a:1:2
+        #   * c
+        # * * a:1:3
+        #   * c
+        def perform(strings)
+          expanded_strings =
+            strings.map(&:strip).map(&method(:expand_patterns))
+
+          product_of_all(expanded_strings)
+        end
+
+        # This method returns the product of list of lists. For example,
+        # giving it [%w[a:0 a:1], %w[b:2 b:3], %w[c]] will return:
+        #
+        # [%w[a:0 b:2 c], %w[a:0 b:3 c], %w[a:1 b:2 c], %w[a:1 b:3 c]]
+        def product_of_all(expanded_strings)
+          expanded_strings.first.product(*expanded_strings.drop(1))
+        end
+
+        # This method expands the string from the sequences. For example,
+        # giving it "a:{0..1}:{2..3}" will return:
+        #
+        # %w[
+        #   a:0:2
+        #   a:0:3
+        #   a:1:2
+        #   a:1:3
+        # ]
+        def expand_patterns(string)
+          expand(string, scan_patterns(string))
+        end
+
+        # This method extracts the sequences from the string. For example,
+        # giving it "a:{0..1}:{2..3}" will return:
+        #
+        # [0..1, 2..3]
+        def scan_patterns(string)
+          string.scan(@pattern).map(&@compile)
+        end
+
+        # This recursive method does the heavy lifting. It substitutes the
+        # sequence patterns in a string with a picked number from the
+        # sequence, and collect all the results. Here's an example:
+        #
+        # expand("a:{0..1}:{2..3}", [0..1, 2..3])
+        #
+        # This means that we want to pick the numbers from the sequences,
+        # and fill them back to the string containing the pattern in the
+        # respective order. We don't care which pattern it is because
+        # the order should have spoken for it. The result will be:
+        #
+        # %w[
+        #   a:0:2
+        #   a:0:3
+        #   a:1:2
+        #   a:1:3
+        # ]
+        #
+        # We start by picking the first sequence, which is 0..1 here. We
+        # want all the possible picks, thus we flat_map on it, substituting
+        # the first pattern with the picked number. This means we get:
+        #
+        # "a:0:{2..3}"
+        #
+        # For the first iteration. Before we jump to the next pick from the
+        # sequence, we recursively do this again on the current string,
+        # which only has one sequence pattern left. It will be called like:
+        #
+        # expand("a:0:{2..3}", [2..3])
+        #
+        # Because we also dropped the first sequence we have already used.
+        # On the next recursive call, we don't have any sequences left,
+        # therefore we just return the current string: "a:0:2".
+        #
+        # Flattening the recursion, it might look like this:
+        #
+        # (0..1).flat_map do |x|
+        #   (2..3).flat_map do |y|
+        #     "a:{0..1}:{2..3}".sub(PATTERN, x.to_s).sub(PATTERN, y.to_s)
+        #   end
+        # end
+        #
+        # So here we could clearly see that we go deep first, substituting
+        # the least significant pattern first, and then go back to the
+        # previous one, until there's nothing more to pick.
+        def expand(string, items)
+          if items.empty?
+            [string]
+          else
+            remainings = items.drop(1)
+
+            items.first.flat_map do |item|
+              expand(string.sub(@pattern, item.to_s), remainings)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/expand_condition/list.rb

@@ -0,0 +1,25 @@
+require_relative 'expansion'
+
+module Gitlab
+  module Triage
+    module ExpandCondition
+      module List
+        PATTERN = /\{.+?,.+?\}/m.freeze
+
+        def self.expand(conditions)
+          labels = conditions[:labels]
+
+          return conditions unless labels
+
+          expansion = Expansion.new(PATTERN) do |list|
+            list.gsub(/\{|\}/, '').split(',').map(&:strip)
+          end
+
+          expansion.perform(labels).map do |new_labels|
+            conditions.merge(labels: new_labels)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/expand_condition/sequence.rb

@@ -0,0 +1,25 @@
+require_relative 'expansion'
+
+module Gitlab
+  module Triage
+    module ExpandCondition
+      module Sequence
+        PATTERN = /\{\s*(\d+)\s*\.\.\s*(\d+)\s*\}/.freeze
+
+        def self.expand(conditions)
+          labels = conditions[:labels]
+
+          return conditions unless labels
+
+          expansion = Expansion.new(PATTERN) do |(lower, upper)|
+            Integer(lower)..Integer(upper)
+          end
+
+          expansion.perform(labels).map do |new_labels|
+            conditions.merge(labels: new_labels)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/expand_condition.rb

@@ -0,0 +1,23 @@
+require_relative 'expand_condition/list'
+require_relative 'expand_condition/sequence'
+
+module Gitlab
+  module Triage
+    module ExpandCondition
+      PIPELINE = [
+        List,
+        Sequence
+      ].freeze
+
+      def self.perform(conditions, pipeline = PIPELINE, &block)
+        expand([conditions], pipeline).each(&block)
+      end
+
+      def self.expand(conditions, pipeline = PIPELINE)
+        pipeline.inject(conditions) do |result, job|
+          result.flat_map(&job.method(:expand))
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/filters/assignee_member_conditions_filter.rb

@@ -0,0 +1,13 @@
+require_relative 'member_conditions_filter'
+
+module Gitlab
+  module Triage
+    module Filters
+      class AssigneeMemberConditionsFilter < MemberConditionsFilter
+        def member_field
+          :assignee
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/filters/author_member_conditions_filter.rb

@@ -0,0 +1,13 @@
+require_relative 'member_conditions_filter'
+
+module Gitlab
+  module Triage
+    module Filters
+      class AuthorMemberConditionsFilter < MemberConditionsFilter
+        def member_field
+          :author
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/filters/base_conditions_filter.rb

@@ -0,0 +1,58 @@
+require 'active_support/all'
+require_relative '../validators/params_validator'
+
+module Gitlab
+  module Triage
+    module Filters
+      class BaseConditionsFilter
+        def initialize(resource, condition)
+          @resource = resource
+          validate_condition(condition)
+          initialize_variables(condition)
+        end
+
+        def calculate
+          raise NotImplementedError
+        end
+
+        def self.filter_parameters
+          []
+        end
+
+        def self.params_filter_names(params = nil)
+          params ||= filter_parameters
+
+          params.map do |param|
+            param[:name]
+          end
+        end
+
+        def self.all_params_filter_names
+          params_filter_names
+        end
+
+        def self.params_checking_condition_value
+          params_filter_names params_check_for_field(:values)
+        end
+
+        def self.params_checking_condition_type
+          params_filter_names params_check_for_field(:type)
+        end
+
+        def self.params_check_for_field(field)
+          filter_parameters.select do |param|
+            param[field].present?
+          end
+        end
+
+        private
+
+        def validate_condition(condition)
+          ParamsValidator.new(self.class.filter_parameters, condition).validate!
+        end
+
+        def initialize_variables(condition); end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/filters/branch_date_filter.rb

@@ -0,0 +1,73 @@
+require_relative 'base_conditions_filter'
+
+module Gitlab
+  module Triage
+    module Filters
+      class BranchDateFilter < BaseConditionsFilter
+        ATTRIBUTES = %w[committed_date authored_date].freeze
+        CONDITIONS = %w[older_than newer_than].freeze
+        TIME_BASED_INTERVALS = %w[minutes hours].freeze
+        DATE_BASED_INTERVALS = %w[days weeks months years].freeze
+        INTERVAL_TYPES = TIME_BASED_INTERVALS + DATE_BASED_INTERVALS
+
+        def self.allowed_attributes
+          self::ATTRIBUTES
+        end
+
+        def self.filter_parameters
+          [
+            {
+              name: :attribute,
+              type: String,
+              values: allowed_attributes
+            },
+            {
+              name: :condition,
+              type: String,
+              values: CONDITIONS
+            },
+            {
+              name: :interval_type,
+              type: String,
+              values: INTERVAL_TYPES
+            },
+            {
+              name: :interval,
+              type: Numeric
+            }
+          ]
+        end
+
+        def initialize_variables(condition)
+          @attribute = condition[:attribute].to_sym
+          @condition = condition[:condition].to_sym
+          @interval_type = condition[:interval_type].to_sym
+          @interval = condition[:interval]
+        end
+
+        def resource_value
+          @resource[:commit][@attribute]&.to_date
+        end
+
+        def condition_value
+          if TIME_BASED_INTERVALS.include?(@interval_type.to_s)
+            @interval.public_send(@interval_type).ago.to_datetime # rubocop:disable GitlabSecurity/PublicSend
+          else
+            @interval.public_send(@interval_type).ago.to_date # rubocop:disable GitlabSecurity/PublicSend
+          end
+        end
+
+        def calculate
+          return false unless resource_value
+
+          case @condition
+          when :older_than
+            resource_value < condition_value
+          when :newer_than
+            resource_value > condition_value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/filters/branch_protected_filter.rb

@@ -0,0 +1,26 @@
+require_relative 'base_conditions_filter'
+
+module Gitlab
+  module Triage
+    module Filters
+      class BranchProtectedFilter < BaseConditionsFilter
+        def initialize_variables(config_value)
+          @attribute = :protected
+          @condition = config_value.nil? ? true : config_value
+        end
+
+        def resource_value
+          @resource[:protected]
+        end
+
+        def condition_value
+          @condition
+        end
+
+        def calculate
+          resource_value == condition_value
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/filters/discussions_conditions_filter.rb

@@ -0,0 +1,58 @@
+require_relative 'base_conditions_filter'
+
+module Gitlab
+  module Triage
+    module Filters
+      class DiscussionsConditionsFilter < BaseConditionsFilter
+        ATTRIBUTES = %w[notes threads].freeze
+        CONDITIONS = %w[greater_than less_than].freeze
+
+        def self.filter_parameters
+          [
+            {
+              name: :attribute,
+              type: String,
+              values: ATTRIBUTES
+            },
+            {
+              name: :condition,
+              type: String,
+              values: CONDITIONS
+            },
+            {
+              name: :threshold,
+              type: Numeric
+            }
+          ]
+        end
+
+        def initialize_variables(condition)
+          @attribute = condition[:attribute].to_sym
+          @condition = condition[:condition].to_sym
+          @threshold = condition[:threshold]
+        end
+
+        def resource_value
+          if @attribute == :notes
+            @resource[:user_notes_count]
+          else
+            @resource[:user_discussions_count]
+          end
+        end
+
+        def condition_value
+          @threshold
+        end
+
+        def calculate
+          case @condition
+          when :greater_than
+            resource_value.to_i > condition_value
+          when :less_than
+            resource_value.to_i < condition_value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/filters/issue_date_conditions_filter.rb

@@ -0,0 +1,78 @@
+require_relative 'base_conditions_filter'
+
+module Gitlab
+  module Triage
+    module Filters
+      class IssueDateConditionsFilter < BaseConditionsFilter
+        CONDITIONS = %w[older_than newer_than].freeze
+        TIME_BASED_INTERVALS = %w[minutes hours].freeze
+        DATE_BASED_INTERVALS = %w[days weeks months years].freeze
+        INTERVAL_TYPES = TIME_BASED_INTERVALS + DATE_BASED_INTERVALS
+
+        def self.generate_allowed_attributes
+          %w[updated_at created_at]
+        end
+
+        def self.allowed_attributes
+          @allowed_attributes ||= generate_allowed_attributes.freeze
+        end
+
+        def self.filter_parameters
+          [
+            {
+              name: :attribute,
+              type: String,
+              values: allowed_attributes
+            },
+            {
+              name: :condition,
+              type: String,
+              values: CONDITIONS
+            },
+            {
+              name: :interval_type,
+              type: String,
+              values: INTERVAL_TYPES
+            },
+            {
+              name: :interval,
+              type: Numeric
+            }
+          ]
+        end
+
+        def initialize_variables(condition)
+          @attribute = condition[:attribute].to_sym
+          @condition = condition[:condition].to_sym
+          @interval_type = condition[:interval_type].to_sym
+          @interval = condition[:interval]
+        end
+
+        # Guard against merge requests with no merged_at values
+        def resource_value
+          @resource[@attribute]&.to_date
+        end
+
+        def condition_value
+          if TIME_BASED_INTERVALS.include?(@interval_type.to_s)
+            @interval.public_send(@interval_type).ago.to_datetime # rubocop:disable GitlabSecurity/PublicSend
+          else
+            @interval.public_send(@interval_type).ago.to_date # rubocop:disable GitlabSecurity/PublicSend
+          end
+        end
+
+        # Guard against merge requests with no merged_at values
+        def calculate
+          return false unless resource_value
+
+          case @condition
+          when :older_than
+            resource_value < condition_value
+          when :newer_than
+            resource_value > condition_value
+          end
+        end
+      end
+    end
+  end
+end