gitlab-triage 0.0.1

data/lib/gitlab/triage/command_builders/label_command_builder.rb

@@ -0,0 +1,19 @@
+require_relative 'base_command_builder'
+
+module Gitlab
+  module Triage
+    module CommandBuilders
+      class LabelCommandBuilder < BaseCommandBuilder
+        private
+
+        def slash_command_string
+          "/label"
+        end
+
+        def format_item(item)
+          "~\"#{item}\""
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/command_builders/status_command_builder.rb

@@ -0,0 +1,23 @@
+require_relative 'base_command_builder'
+
+module Gitlab
+  module Triage
+    module CommandBuilders
+      class StatusCommandBuilder < BaseCommandBuilder
+        private
+
+        def separator
+          ''
+        end
+
+        def slash_command_string
+          "/"
+        end
+
+        def format_item(item)
+          item
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/engine.rb

@@ -0,0 +1,146 @@
+require 'active_support/all'
+
+require_relative 'limiters/date_conditions_limiter'
+require_relative 'limiters/votes_conditions_limiter'
+require_relative 'command_builders/comment_command_builder'
+require_relative 'command_builders/label_command_builder'
+require_relative 'command_builders/cc_command_builder'
+require_relative 'command_builders/status_command_builder'
+require_relative 'filter_builders/single_filter_builder'
+require_relative 'filter_builders/multi_filter_builder'
+require_relative 'network'
+require_relative 'network_adapters/httparty_adapter'
+require_relative 'ui'
+
+module Gitlab
+  module Triage
+    class Engine
+      attr_reader :host_url, :api_version, :per_page, :policies, :options
+
+      def initialize(policies:, options:, network_adapter: Gitlab::Triage::NetworkAdapters::HttpartyAdapter.new)
+        @host_url = policies.delete(:host_url) { 'https://gitlab.com' }
+        @api_version = policies.delete(:api_version) { 'v4' }
+        @per_page = policies.delete(:per_page) { 100 }
+        @policies = policies
+        @options = options
+        @network_adapter = network_adapter
+
+        options.dry_run = true if ENV['TEST'] == 'true'
+
+        assert_project_id!
+        assert_token!
+      end
+
+      def perform
+        puts "Performing a dry run.\n\n" if options.dry_run
+
+        resource_rules.each do |type, resource|
+          puts Gitlab::Triage::UI.header("Processing rules for #{type}")
+          puts
+          resource[:rules].each do |rule|
+            puts Gitlab::Triage::UI.header("Processing rule: #{rule[:name]}", char: '~')
+            puts
+            process_rule(type, rule)
+          end
+        end
+      end
+
+      private
+
+      def assert_project_id!
+        return if options.project_id
+
+        raise ArgumentError, 'A project_id is needed (pass it with the `--project-id` option)!'
+      end
+
+      def assert_token!
+        return if options.token
+
+        raise ArgumentError, 'A token is needed (pass it with the `--token` option)!'
+      end
+
+      def resource_rules
+        @resource_rules ||= policies.delete(:resource_rules) { {} }
+      end
+
+      def network
+        @network ||= Network.new(@network_adapter)
+      end
+
+      def rule_conditions(rule)
+        rule.fetch(:conditions) { {} }
+      end
+
+      def rule_actions(rule)
+        rule.fetch(:actions) { {} }
+      end
+
+      def process_rule(resource_type, rule)
+        # retrieving the resources for every rule is inefficient
+        # however, previous rules may affect those upcoming
+        resources = network.query_api(options.token, build_get_url(resource_type, rule_conditions(rule)))
+        puts "\n\nFound #{resources.count} resources..."
+        puts "Limiting resources..."
+        resources = limit_resources(resources, rule_conditions(rule))
+        puts "Total resource after limiting: #{resources.count} resources"
+        process_resources(resource_type, resources, rule)
+      end
+
+      def limit_resources(resources, conditions)
+        resources.select do |resource|
+          results = []
+          results << Limiters::DateConditionsLimiter.new(resource, conditions[:date]).calculate if conditions[:date]
+          results << Limiters::VotesConditionsLimiter.new(resource, conditions[:upvotes]).calculate if conditions[:upvotes]
+          !results.uniq.include?(false)
+        end
+      end
+
+      def process_resources(resource_type, resources, rule)
+        comment = build_comment(rule_actions(rule))
+
+        if options.dry_run && resources.any?
+          puts "\nThe following comment would be posted for the rule '#{rule[:name]}':\n\n"
+          puts ">>>\n#{comment}\n>>>"
+          return
+        end
+
+        resources.each do |resource|
+          network.post_api(options.token, build_post_url(resource_type, resource), comment)
+        end
+      end
+
+      def build_comment(actions)
+        CommandBuilders::CommentCommandBuilder.new(
+          [
+            actions[:comment],
+            CommandBuilders::LabelCommandBuilder.new(actions[:labels]).build_command,
+            CommandBuilders::CcCommandBuilder.new(actions[:mention]).build_command,
+            CommandBuilders::StatusCommandBuilder.new(actions[:status]).build_command
+          ]
+        ).build_command
+      end
+
+      def build_get_url(resource_type, conditions)
+        # Example issues query with state and labels
+        # https://gitlab.com/api/v4/projects/test-triage%2Fissue-project/issues?state=open&labels=project%20label%20with%20spaces,group_label_no_spaces
+        query_base = ["#{host_url}/api/#{api_version}/projects/#{CGI.escape(options.project_id.to_s)}/#{resource_type}/?per_page=#{per_page}"]
+        query_base << FilterBuilders::MultiFilterBuilder.new('labels', conditions[:labels], ',').build_filter if conditions[:labels]
+        query_base << FilterBuilders::SingleFilterBuilder.new('state', conditions[:state]).build_filter if conditions[:state]
+        query_base << FilterBuilders::MultiFilterBuilder.new('milestone', conditions[:milestone], ',').build_filter if conditions[:milestone]
+
+        get_url = query_base.join
+        puts Gitlab::Triage::UI.debug "get_url: #{get_url}" if options.debug
+
+        get_url
+      end
+
+      def build_post_url(resource_type, resource)
+        # POST /projects/:id/issues/:issue_iid/notes
+        post_url = "#{host_url}/api/#{api_version}/projects/#{options.project_id}/#{resource_type}/#{resource['iid']}/notes/"
+        puts Gitlab::Triage::UI.debug "post_url: #{post_url}" if options.debug
+
+        post_url
+      end
+    end
+  end
+end

data/lib/gitlab/triage/filter_builders/base_filter_builder.rb

@@ -0,0 +1,18 @@
+module Gitlab
+  module Triage
+    module FilterBuilders
+      class BaseFilterBuilder
+        attr_reader :filter_name, :filter_contents
+
+        def initialize(filter_name, filter_contents)
+          @filter_name = filter_name
+          @filter_contents = filter_contents
+        end
+
+        def build_filter
+          "&#{filter_name}=#{filter_content}"
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/filter_builders/multi_filter_builder.rb

@@ -0,0 +1,20 @@
+require_relative 'base_filter_builder'
+
+module Gitlab
+  module Triage
+    module FilterBuilders
+      class MultiFilterBuilder < BaseFilterBuilder
+        attr_reader :separator
+
+        def initialize(filter_name, filter_contents, separator)
+          @separator = separator
+          super(filter_name, filter_contents)
+        end
+
+        def filter_content
+          filter_contents.join(separator)
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/filter_builders/single_filter_builder.rb

@@ -0,0 +1,13 @@
+require_relative 'base_filter_builder'
+
+module Gitlab
+  module Triage
+    module FilterBuilders
+      class SingleFilterBuilder < BaseFilterBuilder
+        def filter_content
+          filter_contents
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module Gitlab
+  module Triage
+    module Limiters
+      class BaseConditionsLimiter
+        def initialize(resource, condition)
+          @resource = resource
+          validate_condition(condition)
+          initialize_variables(condition)
+        end
+
+        def self.params_limiter_names(params = nil)
+          params ||= limiter_parameters
+
+          params.map do |param|
+            param[:name]
+          end
+        end
+
+        def self.all_params_limiter_names
+          params_limiter_names
+        end
+
+        def self.params_checking_condition_value
+          params_limiter_names params_check_for_field(:values)
+        end
+
+        def self.params_checking_condition_type
+          params_limiter_names params_check_for_field(:type)
+        end
+
+        def self.params_check_for_field(field)
+          limiter_parameters.select do |param|
+            param[field].present?
+          end
+        end
+
+        def validate_condition(condition)
+          validate_required_parameters(condition)
+          validate_parameter_types(condition)
+          validate_parameter_content(condition)
+        end
+
+        def validate_required_parameters(condition)
+          self.class.limiter_parameters.each do |param|
+            raise ArgumentError, "#{param[:name]} is a required parameter" unless condition[param[:name]]
+          end
+        end
+
+        def validate_parameter_types(condition)
+          self.class.limiter_parameters.each do |param|
+            raise ArgumentError, "#{param[:name]} must be of type #{param[:type]}" unless condition[param[:name]].is_a?(param[:type])
+          end
+        end
+
+        def validate_parameter_content(condition)
+          self.class.limiter_parameters.each do |param|
+            if param[:values]
+              raise ArgumentError, "#{param[:name]} must be of one of #{param[:values].join(',')}" unless param[:values].include?(condition[param[:name]])
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require 'active_support/all'
+
+require_relative 'base_conditions_limiter'
+
+module Gitlab
+  module Triage
+    module Limiters
+      class DateConditionsLimiter < BaseConditionsLimiter
+        ATTRIBUTES = %w[updated_at created_at].freeze
+        CONDITIONS = %w[older_than newer_than].freeze
+        INTERVAL_TYPES = %w[days weeks months years].freeze
+
+        def self.limiter_parameters
+          [
+            {
+              name: :attribute,
+              type: String,
+              values: 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[@attribute].to_date
+        end
+
+        def condition_value
+          @interval.public_send(@interval_type).ago.to_date # rubocop:disable GitlabSecurity/PublicSend
+        end
+
+        def calculate
+          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/limiters/name_conditions_limiter.rb

@@ -0,0 +1,30 @@
+require_relative 'base_conditions_limiter'
+
+module Gitlab
+  module Triage
+    module Limiters
+      class NameConditionsLimiter < BaseConditionsLimiter
+        def self.limiter_parameters
+          []
+        end
+
+        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/limiters/votes_conditions_limiter.rb

@@ -0,0 +1,54 @@
+require_relative 'base_conditions_limiter'
+
+module Gitlab
+  module Triage
+    module Limiters
+      class VotesConditionsLimiter < BaseConditionsLimiter
+        ATTRIBUTES = %w[upvotes downvotes].freeze
+        CONDITIONS = %w[greater_than less_than].freeze
+
+        def self.limiter_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