gitlab-triage 0.14.1 → 0.15.0

data/lib/gitlab/triage/engine.rb

@@ -22,18 +22,18 @@ require_relative 'ui'
 module Gitlab
   module Triage
     class Engine
-      attr_reader :host_url, :api_version, :per_page, :policies, :options
+      attr_reader :per_page, :policies, :options
 
       def initialize(policies:, options:, network_adapter_class: Gitlab::Triage::NetworkAdapters::HttpartyAdapter)
-        @host_url = policies.delete(:host_url) { options.host_url }
-        @api_version = policies.delete(:api_version) { 'v4' }
+        options.host_url = policies.delete(:host_url) { options.host_url }
+        options.api_version = policies.delete(:api_version) { 'v4' }
+        options.dry_run = ENV['TEST'] == 'true' if options.dry_run.nil?
+
         @per_page = policies.delete(:per_page) { 100 }
         @policies = policies
         @options = options
         @network_adapter_class = network_adapter_class
 
-        options.dry_run = true if ENV['TEST'] == 'true'
-
         assert_project_id!
         assert_token!
       end
@@ -53,6 +53,10 @@ module Gitlab
         end
       end
 
+      def network
+        @network ||= Network.new(network_adapter)
+      end
+
       private
 
       def assert_project_id!
@@ -71,21 +75,6 @@ module Gitlab
         @resource_rules ||= policies.delete(:resource_rules) { {} }
       end
 
-      def network
-        @network ||= Network.new(network_adapter, options)
-      end
-
-      def net
-        @net ||= {
-          host_url: host_url,
-          api_version: api_version,
-          token: options.token,
-          source_id: options.project_id,
-          debug: options.debug,
-          network: network
-        }
-      end
-
       def network_adapter
         @network_adapter ||= @network_adapter_class.new(options)
       end
@@ -110,7 +99,7 @@ module Gitlab
         return if rules.blank?
 
         rules.each do |rule|
-          process_action(Policies::RulePolicy.new(resource_type, rule, resources_for_rule(resource_type, rule), net))
+          process_action(Policies::RulePolicy.new(resource_type, rule, resources_for_rule(resource_type, rule), network))
         end
       end
 
@@ -122,7 +111,7 @@ module Gitlab
         # { summary_rule => resources }
         summary_parts = Hash[summary[:rules].zip(resources)]
 
-        process_action(Policies::SummaryPolicy.new(resource_type, summary, summary_parts, net))
+        process_action(Policies::SummaryPolicy.new(resource_type, summary, summary_parts, network))
       end
 
       def resources_for_rules(resource_type, rules)
@@ -136,7 +125,10 @@ module Gitlab
         ExpandCondition.perform(rule_conditions(rule)) do |conditions|
           # 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, conditions))
+          resources = network.query_api(build_get_url(resource_type, conditions))
+          # In some filters/actions we want to know which resource type it is
+          attach_resource_type(resources, resource_type)
+
           puts "\n\n* Found #{resources.count} resources..."
           print "* Filtering resources..."
           resources = filter_resources(resources, conditions)
@@ -150,10 +142,16 @@ module Gitlab
         resources
       end
 
+      # We don't have to do this once the response will contain the type
+      # of the resource. For now let's just attach it.
+      def attach_resource_type(resources, resource_type)
+        resources.each { |resource| resource[:type] ||= resource_type }
+      end
+
       def process_action(policy)
         Action.process(
           policy: policy,
-          net: net,
+          network: network,
           dry: options.dry_run)
         puts
       end
@@ -166,9 +164,9 @@ module Gitlab
           results << Filters::VotesConditionsFilter.new(resource, conditions[:upvotes]).calculate if conditions[:upvotes]
           results << Filters::ForbiddenLabelsConditionsFilter.new(resource, conditions[:forbidden_labels]).calculate if conditions[:forbidden_labels]
           results << Filters::NoAdditionalLabelsConditionsFilter.new(resource, conditions.fetch(:labels) { [] }).calculate if conditions[:no_additional_labels]
-          results << Filters::AuthorMemberConditionsFilter.new(resource, conditions[:author_member], net).calculate if conditions[:author_member]
-          results << Filters::AssigneeMemberConditionsFilter.new(resource, conditions[:assignee_member], net).calculate if conditions[:assignee_member]
-          results << Filters::RubyConditionsFilter.new(resource, conditions, net).calculate if conditions[:ruby]
+          results << Filters::AuthorMemberConditionsFilter.new(resource, conditions[:author_member], network).calculate if conditions[:author_member]
+          results << Filters::AssigneeMemberConditionsFilter.new(resource, conditions[:assignee_member], network).calculate if conditions[:assignee_member]
+          results << Filters::RubyConditionsFilter.new(resource, conditions, network).calculate if conditions[:ruby]
 
           results.all?
         end
@@ -198,17 +196,12 @@ module Gitlab
           params[condition_builder.param_name] = condition_builder.param_content
         end
 
-        get_url = UrlBuilders::UrlBuilder.new(
-          host_url: host_url,
-          api_version: api_version,
+        UrlBuilders::UrlBuilder.new(
+          network_options: options,
           source_id: options.project_id,
           resource_type: resource_type,
           params: params
         ).build
-
-        puts Gitlab::Triage::UI.debug "get_url: #{get_url}" if options.debug
-
-        get_url
       end
     end
   end

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

@@ -6,23 +6,25 @@ module Gitlab
   module Triage
     module EntityBuilders
       class IssueBuilder
-        attr_reader :title
         attr_writer :description, :items
 
-        def initialize(action, resources, net)
-          @title = action[:title]
+        def initialize(type:, action:, resources:, network:)
+          @type = type
           @item_template = action[:item]
+          @title_template = action[:title]
           @summary_template = action[:summary]
+          @redact_confidentials =
+            action[:redact_confidential_resources] != false
           @resources = resources
-          @net = net
+          @network = network
         end
 
-        def description
-          return '' unless @summary_template
+        def title
+          @title ||= build_text(title_resource, @title_template)
+        end
 
-          @description ||= CommandBuilders::TextContentBuilder.new(
-            @summary_template, resource: summary_resource, net: @net)
-            .build_command
+        def description
+          @description ||= build_text(description_resource, @summary_template)
         end
 
         def valid?
@@ -31,22 +33,30 @@ module Gitlab
 
         private
 
-        def summary_resource
-          @summary_resource ||= {
-            'items' => items,
-            'title' => title
-          }
+        def title_resource
+          { type: @type }
         end
 
-        def items
-          return '' unless @item_template
+        def description_resource
+          title_resource.merge(title: title, items: items)
+        end
 
+        def items
           @items ||= @resources.map(&method(:build_item)).join("\n")
         end
 
         def build_item(resource)
+          build_text(resource, @item_template)
+        end
+
+        def build_text(resource, template)
+          return '' unless template
+
           CommandBuilders::TextContentBuilder.new(
-            @item_template, resource: resource, net: @net)
+            template,
+            resource: resource,
+            network: @network,
+            redact_confidentials: @redact_confidentials)
             .build_command.chomp
         end
       end

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

@@ -8,9 +8,8 @@ module Gitlab
         SOURCES = %w[project group].freeze
         CONDITIONS = %w[member_of not_member_of].freeze
 
-        def initialize(resource, condition, net = {})
-          @net = net
-          @network = net[:network]
+        def initialize(resource, condition, network = nil)
+          @network = network
           super(resource, condition)
         end
 
@@ -61,19 +60,18 @@ module Gitlab
         end
 
         def members
-          @members ||= @network.query_api_cached(@net[:token], member_url)
+          @members ||= @network.query_api_cached(member_url)
         end
 
         def member_url
-          UrlBuilders::UrlBuilder.new(net_opts).build
+          UrlBuilders::UrlBuilder.new(url_opts).build
         end
 
         private
 
-        def net_opts
+        def url_opts
           {
-            host_url: @net[:host_url],
-            api_version: @net[:api_version],
+            network_options: @network.options,
             resource_type: 'members',
             source: @source == :group ? 'groups' : 'projects',
             source_id: @source_id,

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

@@ -10,14 +10,16 @@ module Gitlab
           [{ name: :ruby, type: String }]
         end
 
-        def initialize(resource, condition, net = {})
+        def initialize(resource, condition, network = nil)
           super(resource, condition)
 
-          @net = net
+          @network = network
         end
 
         def calculate
-          !!Resource::Context.new(@resource, @net).eval(@expression)
+          context = Resource::Context.build(@resource, network: @network)
+
+          !!context.eval(@expression)
         end
 
         private

data/lib/gitlab/triage/network.rb

@@ -9,19 +9,21 @@ module Gitlab
     class Network
       include Retryable
 
-      attr_reader :options
+      TokenNotFound = Class.new(StandardError)
 
-      def initialize(adapter, options = {})
+      attr_reader :options, :adapter
+
+      def initialize(adapter)
         @adapter = adapter
-        @options = options
-        @cache = Hash.new { |hash, key| hash[key] = {} }
+        @options = adapter.options
+        @cache = {}
       end
 
-      def query_api_cached(token, url)
-        @cache.dig(token, url) || @cache[token][url] = query_api(token, url)
+      def query_api_cached(url)
+        @cache[url] || @cache[url] = query_api(url)
       end
 
-      def query_api(token, url)
+      def query_api(url)
         response = {}
         resources = []
 
@@ -29,6 +31,8 @@ module Gitlab
           print '.'
 
           response = execute_with_retry(Net::ReadTimeout) do
+            puts Gitlab::Triage::UI.debug "query_api: #{url}" if options.debug
+
             @adapter.get(token, response.fetch(:next_page_url) { url })
           end
 
@@ -47,14 +51,22 @@ module Gitlab
         []
       end
 
-      def post_api(token, url, body)
+      def post_api(url, body)
         execute_with_retry(Net::ReadTimeout) do
+          puts Gitlab::Triage::UI.debug "post_api: #{url}" if options.debug
+
           @adapter.post(token, url, body)
         end
 
       rescue Net::ReadTimeout
         false
       end
+
+      private
+
+      def token
+        options.token || raise(TokenNotFound)
+      end
     end
   end
 end

data/lib/gitlab/triage/network_adapters/base_adapter.rb

@@ -6,7 +6,7 @@ module Gitlab
       class BaseAdapter
         attr_reader :options
 
-        def initialize(options = {})
+        def initialize(options)
           @options = options
         end
       end

data/lib/gitlab/triage/option_parser.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal
+# rubocop:disable Rails/Exit
+
+require 'optparse'
+require 'fileutils'
+require_relative 'options'
+
+module Gitlab
+  module Triage
+    class OptionParser
+      class << self
+        def parse(argv)
+          options = Options.new
+          options.host_url = 'https://gitlab.com'
+
+          parser = ::OptionParser.new do |opts|
+            opts.banner = "Usage: gitlab-triage [options]\n\n"
+
+            opts.on('-n', '--dry-run', "Don't actually update anything, just print") do |value|
+              options.dry_run = value
+            end
+
+            opts.on('-f', '--policies-file [string]', String, 'A valid policies YML file') do |value|
+              options.policies_file = value
+            end
+
+            opts.on('-p', '--project-id [string]', String, 'A project ID or path') do |value|
+              options.project_id = value
+            end
+
+            opts.on('-t', '--token [string]', String, 'A valid API token') do |value|
+              options.token = value
+            end
+
+            opts.on('-H', '--host-url [string]', String, 'A valid host url') do |value|
+              options.host_url = value
+            end
+
+            opts.on('-d', '--debug', 'Print debug information') do |value|
+              options.debug = value
+            end
+
+            opts.on('-h', '--help', 'Print help message') do
+              $stdout.puts opts
+              exit
+            end
+
+            opts.on('--init', 'Initialize the project with a policy file') do
+              example_path =
+                File.expand_path('../../../support/.triage-policies.example.yml', __dir__)
+
+              FileUtils.cp(example_path, '.triage-policies.yml')
+              exit
+            end
+
+            opts.on('--init-ci', 'Initialize the project with a .gitlab-ci.yml file') do
+              example_path =
+                File.expand_path('../../../support/.gitlab-ci.example.yml', __dir__)
+
+              FileUtils.cp(example_path, '.gitlab-ci.yml')
+              exit
+            end
+          end
+
+          parser.parse!(argv)
+
+          options
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/options.rb

@@ -0,0 +1,21 @@
+module Gitlab
+  module Triage
+    Options = Struct.new(
+      :dry_run,
+      :policies_file,
+      :project_id,
+      :token,
+      :debug,
+      :host_url,
+      :api_version
+    ) do
+      def initialize(*args)
+        super
+
+        # Defaults
+        self.host_url ||= 'https://gitlab.com'
+        self.api_version ||= 'v4'
+      end
+    end
+  end
+end

data/lib/gitlab/triage/policies/base_policy.rb

@@ -3,7 +3,17 @@
 module Gitlab
   module Triage
     module Policies
-      BasePolicy = Struct.new(:type, :policy_spec, :resources, :net) do
+      class BasePolicy
+        attr_reader :type, :policy_spec, :resources, :network
+
+        def initialize(type, policy_spec, resources, network)
+          @type = type
+          @policy_spec = policy_spec
+          # In some filters/actions we want to know which resource type it is
+          @resources = attach_resource_type(resources, type)
+          @network = network
+        end
+
         def name
           @name ||= (policy_spec[:name] || "#{type}-#{object_id}")
         end
@@ -17,12 +27,21 @@ module Gitlab
         end
 
         def comment?
-          (actions.keys - [:summarize]).any?
+          # The actual keys are strings
+          (actions.keys.map(&:to_sym) - [:summarize]).any?
         end
 
         def build_issue
           raise NotImplementedError
         end
+
+        private
+
+        # We don't have to do this once the response will contain the type
+        # of the resource. For now let's just attach it.
+        def attach_resource_type(resources, type)
+          resources.map { |resource| resource.reverse_merge(type: type) }
+        end
       end
     end
   end