payping-gitlab-triage 0.1.1

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

@@ -0,0 +1,84 @@
+require_relative 'base_conditions_filter'
+require_relative '../url_builders/url_builder'
+
+module Gitlab
+  module Triage
+    module Filters
+      class MemberConditionsFilter < BaseConditionsFilter
+        SOURCES = %w[project group].freeze
+        CONDITIONS = %w[member_of not_member_of].freeze
+
+        def initialize(resource, condition, network = nil)
+          @network = network
+          super(resource, condition)
+        end
+
+        def self.filter_parameters
+          [
+            {
+              name: :source,
+              type: String,
+              values: SOURCES
+            },
+            {
+              name: :condition,
+              type: String,
+              values: CONDITIONS
+            },
+            {
+              name: :source_id,
+              type: [Numeric, String]
+            }
+          ]
+        end
+
+        def initialize_variables(condition)
+          @source = condition[:source].to_sym
+          @condition = condition[:condition].to_sym
+          @source_id = condition[:source_id]
+        end
+
+        def resource_value
+          @resource[member_field][:username] if @resource[member_field]
+        end
+
+        def condition_value
+          members.map do |member|
+            member[:username]
+          end
+        end
+
+        def calculate
+          return false unless resource_value
+
+          case @condition
+          when :member_of
+            condition_value.include?(resource_value)
+          when :not_member_of
+            !condition_value.include?(resource_value)
+          end
+        end
+
+        def members
+          @members ||= @network.query_api_cached(member_url)
+        end
+
+        def member_url
+          UrlBuilders::UrlBuilder.new(url_opts).build
+        end
+
+        private
+
+        def url_opts
+          {
+            network_options: @network.options,
+            resource_type: 'members',
+            source: @source == :group ? 'groups' : 'projects',
+            source_id: @source_id,
+            params: { per_page: 100 }
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require_relative 'base_conditions_filter'
+
+module Gitlab
+  module Triage
+    module Filters
+      class MergeRequestDateConditionsFilter < IssueDateConditionsFilter
+        def self.generate_allowed_attributes
+          super << 'merged_at'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require_relative 'base_conditions_filter'
+
+module Gitlab
+  module Triage
+    module Filters
+      class NameConditionsFilter < BaseConditionsFilter
+        def initialize_variables(matching_name)
+          @attribute = :name
+          @matching_name = matching_name
+        end
+
+        def resource_value
+          @resource[@attribute]
+        end
+
+        def condition_value
+          @matching_name
+        end
+
+        def calculate
+          resource_value == condition_value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require_relative 'base_conditions_filter'
+
+module Gitlab
+  module Triage
+    module Filters
+      class NoAdditionalLabelsConditionsFilter < BaseConditionsFilter
+        def self.filter_parameters
+          []
+        end
+
+        def validate_condition(condition)
+          raise ArgumentError, 'condition must be an array containing the only label values allowed' unless condition.is_a?(Array)
+        end
+
+        def initialize_variables(expected_labels)
+          @attribute = :labels
+          @expected_labels = expected_labels
+        end
+
+        def resource_value
+          @resource[@attribute]
+        end
+
+        def calculate
+          (resource_value - @expected_labels).empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require_relative 'base_conditions_filter'
+require_relative '../resource/context'
+require 'date'
+
+module Gitlab
+  module Triage
+    module Filters
+      class RubyConditionsFilter < BaseConditionsFilter
+        def self.limiter_parameters
+          [{ name: :ruby, type: String }]
+        end
+
+        def initialize(resource, condition, network = nil)
+          super(resource, condition)
+
+          @network = network
+        end
+
+        def calculate
+          context = Resource::Context.build(@resource, network: @network, redact_confidentials: false)
+
+          !!context.eval(@expression)
+        end
+
+        private
+
+        def initialize_variables(condition)
+          @expression = condition[:ruby]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require_relative 'base_conditions_filter'
+
+module Gitlab
+  module Triage
+    module Filters
+      class VotesConditionsFilter < BaseConditionsFilter
+        ATTRIBUTES = %w[upvotes downvotes].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
+          @resource[@attribute]
+        end
+
+        def condition_value
+          @threshold
+        end
+
+        def calculate
+          case @condition
+          when :greater_than
+            resource_value > condition_value
+          when :less_than
+            resource_value < condition_value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/graphql_network.rb

@@ -0,0 +1,81 @@
+require 'active_support/all'
+require 'net/protocol'
+require 'globalid'
+
+require_relative 'retryable'
+require_relative 'ui'
+require_relative 'errors'
+
+module Gitlab
+  module Triage
+    class GraphqlNetwork
+      attr_reader :options, :adapter
+
+      MINIMUM_RATE_LIMIT = 25
+
+      def initialize(adapter)
+        @adapter = adapter
+        @options = adapter.options
+      end
+
+      def query(graphql_query, variables = {})
+        return if graphql_query.blank?
+
+        response = {}
+        resources = []
+
+        parsed_graphql_query = adapter.parse(graphql_query.query)
+
+        begin
+          print '.'
+
+          response = adapter.query(
+            parsed_graphql_query,
+            resource_path: graphql_query.resource_path,
+            variables: variables.merge(after: response.delete(:end_cursor))
+          )
+
+          rate_limit_debug(response) if options.debug
+          rate_limit_wait(response)
+
+          resources.concat(Array.wrap(response.delete(:results)))
+        end while response.delete(:more_pages)
+
+        resources
+          .map { |resource| resource.deep_transform_keys(&:underscore) }
+          .map(&:with_indifferent_access)
+          .map { |resource| normalize(resource) }
+      end
+
+      private
+
+      def normalize(resource)
+        resource
+          .slice(:iid, :title, :state, :author, :merged_at, :user_notes_count, :user_discussions_count, :upvotes, :downvotes, :project_id, :web_url)
+          .merge(
+            id: extract_id_from_global_id(resource[:id]),
+            labels: [*resource.dig(:labels, :nodes)].pluck(:title),
+            assignees: [*resource.dig(:assignees, :nodes)]
+          )
+      end
+
+      def extract_id_from_global_id(global_id)
+        return if global_id.blank?
+
+        GlobalID.parse(global_id).model_id.to_i
+      end
+
+      def rate_limit_debug(response)
+        rate_limit_infos = "Rate limit remaining: #{response[:ratelimit_remaining]} (reset at #{response[:ratelimit_reset_at]})"
+        puts Gitlab::Triage::UI.debug "rate_limit_infos: #{rate_limit_infos}"
+      end
+
+      def rate_limit_wait(response)
+        return unless response.delete(:ratelimit_remaining) < MINIMUM_RATE_LIMIT
+
+        puts Gitlab::Triage::UI.debug "Rate limit almost exceeded, sleeping for #{response[:ratelimit_reset_at] - Time.now} seconds" if options.debug
+        sleep(1) until Time.now >= response[:ratelimit_reset_at]
+      end
+    end
+  end
+end

data/lib/gitlab/triage/graphql_queries/query_builder.rb

@@ -0,0 +1,158 @@
+require_relative 'query_param_builders/base_param_builder'
+require_relative 'query_param_builders/date_param_builder'
+require_relative 'query_param_builders/labels_param_builder'
+
+module Gitlab
+  module Triage
+    module GraphqlQueries
+      class QueryBuilder
+        def initialize(source_type, resource_type, conditions, graphql_only: false)
+          @source_type = source_type.to_s.singularize
+          @resource_type = resource_type
+          @conditions = conditions
+          @graphql_only = graphql_only
+          @resource_declarations = [
+            '$source: ID!',
+            '$after: String'
+          ]
+        end
+
+        def resource_path
+          [source_type, resource_type]
+        end
+
+        def query
+          return if resource_fields.empty?
+
+          format(
+            BASE_QUERY,
+            source_type: source_type,
+            resource_type: resource_type.to_s.camelize(:lower),
+            resource_fields: resource_fields.join(' '),
+            resource_query: resource_query,
+            resource_declarations: resource_declarations.join(', ')
+          )
+        end
+
+        delegate :any?, to: :resource_fields
+
+        private
+
+        attr_reader :source_type, :resource_type, :conditions, :graphql_only, :resource_declarations
+
+        BASE_QUERY = <<~GRAPHQL.freeze
+          query(%{resource_declarations}) {
+            %{source_type}(fullPath: $source) {
+              id
+              %{resource_type}(after: $after%{resource_query}) {
+                pageInfo {
+                  hasNextPage
+                  endCursor
+                }
+                nodes {
+                  id iid title updatedAt createdAt webUrl projectId %{resource_fields}
+                }
+              }
+            }
+          }
+        GRAPHQL
+
+        def vote_attribute
+          @vote_attribute ||= (conditions.dig(:votes, :attribute) || conditions.dig(:upvotes, :attribute)).to_s
+        end
+
+        def resource_fields
+          fields = []
+
+          fields << 'userNotesCount' if conditions.dig(:discussions, :attribute).to_s == 'notes'
+          fields << 'userDiscussionsCount' if conditions.dig(:discussions, :attribute).to_s == 'threads'
+
+          if graphql_only
+            fields << 'labels { nodes { title } }'
+            fields << 'author { id name username }'
+            fields << 'assignees { nodes { id name username } }' if conditions.key?(:assignee_member)
+            fields << 'upvotes' if vote_attribute == 'upvotes'
+            fields << 'downvotes' if vote_attribute == 'downvotes'
+            fields.push('draft', 'mergedAt') if resource_type == 'merge_requests'
+          end
+
+          fields
+        end
+
+        def resource_query
+          condition_queries = []
+
+          condition_queries << QueryParamBuilders::BaseParamBuilder.new('includeSubgroups', true, with_quotes: false) if source_type == 'group'
+
+          conditions.each do |condition, condition_params|
+            condition_queries << QueryParamBuilders::DateParamBuilder.new(condition_params) if condition.to_s == 'date'
+            condition_queries << QueryParamBuilders::BaseParamBuilder.new('milestoneTitle', condition_params) if condition.to_s == 'milestone'
+            condition_queries << QueryParamBuilders::BaseParamBuilder.new('state', condition_params, with_quotes: false) if condition.to_s == 'state'
+
+            if condition.to_s == 'iids'
+              @resource_declarations << '$iids: [String!]'
+              condition_queries << QueryParamBuilders::BaseParamBuilder.new('iids', '$iids', with_quotes: false)
+            end
+
+            case resource_type
+            when 'issues'
+              condition_queries << issues_label_query(condition, condition_params)
+            when 'merge_requests'
+              condition_queries << merge_requests_label_query(condition, condition_params)
+              condition_queries << merge_requests_resource_query(condition, condition_params)
+            end
+          end
+
+          condition_queries
+            .compact
+            .map(&:build_param)
+            .join
+        end
+
+        def issues_label_query(condition, condition_params)
+          args =
+            case condition.to_s
+            when 'forbidden_labels'
+              ['labelName', condition_params, { negated: true }]
+            when 'labels'
+              ['labelName', condition_params, {}]
+            else
+              return nil
+            end
+
+          QueryParamBuilders::LabelsParamBuilder.new(*args[0...-1], **args.last)
+        end
+
+        def merge_requests_resource_query(condition, condition_params)
+          args =
+            case condition.to_s
+            when 'source_branch'
+              ['sourceBranches', condition_params, {}]
+            when 'target_branch'
+              ['targetBranches', condition_params, {}]
+            when 'draft'
+              ['draft', condition_params, { with_quotes: false }]
+            else
+              return nil
+            end
+
+          QueryParamBuilders::BaseParamBuilder.new(*args[0...-1], **args.last)
+        end
+
+        def merge_requests_label_query(condition, condition_params)
+          args =
+            case condition.to_s
+            when 'forbidden_labels'
+              ['labels', condition_params, { negated: true }]
+            when 'labels'
+              ['labels', condition_params, {}]
+            else
+              return nil
+            end
+
+          QueryParamBuilders::LabelsParamBuilder.new(*args[0...-1], **args.last)
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/graphql_queries/query_param_builders/base_param_builder.rb

@@ -0,0 +1,30 @@
+require_relative '../../utils'
+
+module Gitlab
+  module Triage
+    module GraphqlQueries
+      module QueryParamBuilders
+        class BaseParamBuilder
+          attr_reader :param_name, :param_contents, :with_quotes, :negated
+
+          def initialize(param_name, param_contents, with_quotes: true, negated: false)
+            @param_name = param_name
+            @param_contents = param_contents.to_s.strip
+            @with_quotes = with_quotes
+            @negated = negated
+          end
+
+          def build_param
+            contents = with_quotes ? Utils.graphql_quote(param_contents) : param_contents
+
+            if negated
+              ", not: { #{param_name}: #{contents} }"
+            else
+              ", #{param_name}: #{contents}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/graphql_queries/query_param_builders/date_param_builder.rb

@@ -0,0 +1,35 @@
+require_relative '../../param_builders/date_param_builder'
+require_relative 'base_param_builder'
+
+module Gitlab
+  module Triage
+    module GraphqlQueries
+      module QueryParamBuilders
+        class DateParamBuilder < BaseParamBuilder
+          ATTRIBUTES = %w[updated_at created_at merged_at].freeze
+
+          def initialize(condition_hash)
+            date_param_builder = ParamBuilders::DateParamBuilder.new(ATTRIBUTES, condition_hash)
+
+            super(build_param_name(condition_hash), date_param_builder.param_content)
+          end
+
+          private
+
+          def build_param_name(condition_hash)
+            prefix = condition_hash[:attribute].to_s.sub(/_at\z/, '')
+            suffix =
+              case condition_hash[:condition].to_sym
+              when :older_than
+                'Before'
+              when :newer_than
+                'After'
+              end
+
+            "#{prefix}#{suffix}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/graphql_queries/query_param_builders/labels_param_builder.rb

@@ -0,0 +1,18 @@
+require_relative '../../utils'
+require_relative 'base_param_builder'
+
+module Gitlab
+  module Triage
+    module GraphqlQueries
+      module QueryParamBuilders
+        class LabelsParamBuilder < BaseParamBuilder
+          def initialize(param_name, labels, negated: false)
+            label_param_content = labels.map { |label| Utils.graphql_quote(label) }.join(', ').then { |content| "[#{content}]" }
+
+            super(param_name, label_param_content, with_quotes: false, negated: negated)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/limiters/base_limiter.rb

@@ -0,0 +1,35 @@
+require 'active_support/all'
+
+module Gitlab
+  module Triage
+    module Limiters
+      class BaseLimiter
+        def initialize(resources, limit)
+          @resources = initialize_resources(resources)
+          validate_limit(limit)
+          initialize_variables(limit)
+        end
+
+        def limit
+          raise NotImplementedError
+        end
+
+        def self.limiter_parameters
+          []
+        end
+
+        private
+
+        def initialize_variables(limit); end
+
+        def initialize_resources(resources)
+          resources
+        end
+
+        def validate_limit(limit)
+          LimiterValidator.new(self.class.limiter_parameters, limit).validate!
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/limiters/date_field_limiter.rb

@@ -0,0 +1,45 @@
+require_relative 'base_limiter'
+require_relative '../validators/limiter_validator'
+
+module Gitlab
+  module Triage
+    module Limiters
+      class DateFieldLimiter < BaseLimiter
+        LIMITS = %i[most_recent oldest].freeze
+
+        def self.limiter_parameters
+          [
+            {
+              name: :most_recent,
+              type: Integer
+            },
+            {
+              name: :oldest,
+              type: Integer
+            }
+          ]
+        end
+
+        def initialize_variables(limit)
+          @criterion = LIMITS.find(&limit.method(:[]))
+          @threshold = limit[@criterion]
+        end
+
+        def limit
+          case @criterion
+          when :oldest
+            @resources.first(@threshold)
+          when :most_recent
+            @resources.last(@threshold).reverse
+          end
+        end
+
+        private
+
+        def initialize_resources(resources)
+          resources.sort_by { |res| res[:created_at] }
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/network.rb

@@ -0,0 +1,39 @@
+require_relative 'graphql_network'
+require_relative 'rest_api_network'
+
+module Gitlab
+  module Triage
+    Network = Struct.new(:restapi, :graphql, keyword_init: true) do
+      def query_api(url)
+        restapi.query_api(url)
+      end
+
+      def query_graphql(...)
+        graphql.query(...)
+      end
+
+      def query_api_cached(url)
+        restapi.query_api_cached(url)
+      end
+
+      def restapi_options
+        restapi.options
+      end
+
+      # FIXME: Remove the alias method
+      alias_method :options, :restapi_options
+
+      def graphql_options
+        graphql.options
+      end
+
+      def post_api(...)
+        restapi.post_api(...)
+      end
+
+      def delete_api(...)
+        restapi.delete_api(...)
+      end
+    end
+  end
+end