jira-auto-tool 0.1.1

data/lib/jira/auto/tool/rate_limited_jira_client.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "ratelimit"
+require "redis"
+
+require "jira/auto/tool"
+
+module Jira
+  module Auto
+    class Tool
+      class RateLimitedJiraClient < JIRA::Client
+        NO_RATE_LIMIT_IN_SECONDS = 0
+        NO_RATE_INTERVAL_IN_SECONDS = 0
+
+        attr_reader :rate_interval, :rate_limit
+
+        def initialize(options, rate_interval: 1, rate_limit: 1)
+          super(options)
+          @rate_interval = rate_interval
+          @rate_limit = rate_limit
+        end
+
+        alias original_request request
+        def request(*args)
+          return original_request(*args) if rate_limit == NO_RATE_LIMIT_IN_SECONDS
+
+          rate_limiter.exec_within_threshold(rate_limiter_key, interval: rate_interval, threshold: rate_limit) do
+            response = original_request(*args)
+
+            rate_limiter.add(rate_limiter_key)
+
+            response
+          end
+        end
+
+        def rate_limiter_key
+          "jira_auto_tool_api_requests"
+        end
+
+        def rate_limiter
+          self.class.rate_limiter(rate_limiter_key, rate_interval)
+        end
+
+        def self.rate_limiter(rate_limiter_key, rate_interval)
+          @rate_limiter ||= Ratelimit.new(rate_limiter_key, bucket_interval: rate_interval)
+        end
+      end
+    end
+  end
+end

data/lib/jira/auto/tool/request_builder/field_context_fetcher.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool/request_builder/get"
+require "jira/auto/tool/field_option"
+
+module Jira
+  module Auto
+    class Tool
+      class RequestBuilder
+        class FieldContextFetcher < Get
+          def self.fetch_field_contexts(field)
+            log.debug { "fetching field contexts for #{field}" }
+
+            response = new(field.jira_client, field).run
+
+            field_contexts =
+              JSON
+              .parse(response.body)
+              .symbolize_keys
+              .fetch(:values)
+              .collect(&:symbolize_keys)
+
+            log.debug { "field #{field} contexts fetched: #{field_contexts}" }
+
+            field_contexts
+          end
+
+          protected
+
+          attr_reader :field
+
+          def initialize(jira_client, field)
+            super(jira_client)
+            @field = field
+          end
+
+          def request_payload
+            nil
+          end
+
+          def http_verb
+            :get
+          end
+
+          def expected_response
+            200
+          end
+
+          def request_headers
+            nil
+          end
+
+          private
+
+          def end_date
+            start_date + length_in_days.days
+          end
+
+          def start_date
+            start.is_a?(Time) ? start : Time.parse(start)
+          end
+
+          def request_path
+            "/rest/api/3/field/#{field.id}/context"
+          end
+
+          def success_message_prefix
+            "Sprint created successfully"
+          end
+
+          def error_message_prefix
+            "Error creating sprint"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jira/auto/tool/request_builder/field_option_fetcher.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool/request_builder/get"
+require "jira/auto/tool/field_option"
+
+module Jira
+  module Auto
+    class Tool
+      class RequestBuilder
+        class FieldOptionFetcher < Get
+          def self.fetch_field_options(field)
+            log.debug { "fetching field options for #{field}" }
+
+            response = new(field.jira_client, field, field.field_context).run
+
+            options = JSON.parse(response.body)
+
+            field_options = options.fetch("values", []).collect do |option|
+              FieldOption.new(field.jira_client, option["id"], option["value"])
+            end
+
+            log.debug { "field #{field} options fetched: #{field_options}" }
+
+            field_options
+          end
+
+          protected
+
+          attr_reader :field
+
+          def initialize(jira_client, field, field_context)
+            super(jira_client)
+            @field = field
+            @field_context = field_context
+          end
+
+          private
+
+          def request_path
+            "/rest/api/3/field/#{field.id}/context/#{@field_context.fetch(:id)}/option"
+          end
+
+          def success_message_prefix
+            "Field options fetched successfully"
+          end
+
+          def error_message_prefix
+            "Error fetching field options"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jira/auto/tool/request_builder/get.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool/request_builder"
+
+module Jira
+  module Auto
+    class Tool
+      class RequestBuilder
+        class Get < RequestBuilder
+          def request_payload
+            nil
+          end
+
+          def http_verb
+            :get
+          end
+
+          def expected_response
+            200
+          end
+
+          def request_headers
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jira/auto/tool/request_builder/sprint_creator.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/blank"
+
+module Jira
+  module Auto
+    class Tool
+      class RequestBuilder
+        class SprintCreator < RequestBuilder
+          def self.create_sprint(tool, original_board_id, attributes)
+            log.debug { "create_sprint(#{attributes.inspect})" }
+
+            creation_response = new(tool.jira_client, original_board_id, attributes).run
+
+            created_sprint = Sprint.new(tool,
+                                        tool.jira_client.Sprint.find(JSON.parse(creation_response.body).fetch("id")))
+
+            log.debug { "created_sprint: #{created_sprint.id}" }
+
+            created_sprint
+          end
+
+          protected
+
+          attr_reader :origin_board_id, :attributes
+
+          def initialize(jira_client, origin_board_id, attributes)
+            super(jira_client)
+
+            @origin_board_id = origin_board_id
+            @attributes = attributes
+          end
+
+          def request_payload
+            payload = { originBoardId: origin_board_id, name: attributes.fetch(:name) }
+
+            payload[:startDate] = Sprint.date_for_save(start_date) if start_date
+            payload[:endDate] = Sprint.date_for_save(end_date) if end_date
+
+            payload
+          end
+
+          def start_date
+            @start_date ||= extract_date(attributes[:start_date])
+          end
+
+          def end_date
+            @end_date ||=
+              begin
+                date = extract_date(attributes[:end_date])
+
+                if date
+                  length = attributes[:length_in_days]
+
+                  unless length.blank?
+                    raise ArgumentError,
+                          "Should not provide both :end_date (#{date.inspect}) and :length_in_days (#{length})!"
+                  end
+
+                  date
+                elsif start_date && length_in_days
+                  start_date + length_in_days.days
+                end
+              end
+          end
+
+          def length_in_days
+            @length_in_days ||=
+              begin
+                raise ArgumentError, "Should provide :start_date in order to use :length_in_days!" unless start_date
+
+                length = attributes[:length_in_days]
+
+                length.blank? ? nil : Integer(length)
+              end
+          end
+
+          def http_verb
+            :post
+          end
+
+          def expected_response
+            201
+          end
+
+          private
+
+          def extract_date(date)
+            case date
+            when Time
+              date
+            else
+              date.blank? ? nil : Time.parse(date)
+            end
+          end
+
+          def request_path
+            "/rest/agile/1.0/sprint"
+          end
+
+          def success_message_prefix
+            "Sprint created successfully"
+          end
+
+          def error_message_prefix
+            "Error creating sprint"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jira/auto/tool/request_builder/sprint_state_updater.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Jira
+  module Auto
+    class Tool
+      class RequestBuilder
+        class SprintStateUpdater < RequestBuilder
+          attr_reader :sprint, :new_state
+
+          def initialize(jira_client, sprint:, new_state:)
+            super(jira_client)
+
+            @sprint = sprint
+            @new_state = new_state
+          end
+
+          ATTRIBUTES_TO_INCLUDE_FOR_STATE_UPDATE = %i[
+            id
+            self
+            name
+            startDate
+            endDate
+            originBoardId
+          ].freeze
+
+          private
+
+          def request_path
+            "/rest/agile/1.0/sprint/#{sprint.id}"
+          end
+
+          def request_payload
+            attributes = sprint.attrs.symbolize_keys
+
+            ATTRIBUTES_TO_INCLUDE_FOR_STATE_UPDATE.each_with_object({}) do |key, result|
+              result[key] = attributes[key]
+            end
+              .merge({ state: new_state })
+          end
+
+          def http_verb
+            :put
+          end
+
+          def expected_response
+            200
+          end
+
+          def error_message_prefix
+            "Error updating auto state"
+          end
+
+          def success_message_prefix
+            "Sprint state updated successfully"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jira/auto/tool/request_builder.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative "request_builder/sprint_creator"
+require_relative "request_builder/sprint_state_updater"
+
+module Jira
+  module Auto
+    class Tool
+      class RequestBuilder
+        attr_reader :jira_client
+
+        def initialize(jira_client)
+          @jira_client = jira_client
+        end
+
+        def run
+          response = send_request
+
+          if response.code.to_i == expected_response
+            log.debug { "#{success_message_prefix}: #{response.body}" }
+          else
+            error_message = "#{error_message_prefix}: #{response.code} - #{response.body}"
+            log.error { error_message }
+            raise error_message
+          end
+
+          response
+        end
+
+        protected
+
+        def error_message_prefix
+          raise NotImplementedError, "Subclasses must implement this method"
+        end
+
+        def expected_response
+          raise NotImplementedError, "Subclasses must implement this method"
+        end
+
+        def http_verb
+          raise NotImplementedError, "Subclasses must implement this method"
+        end
+
+        def request_payload
+          raise NotImplementedError, "Subclasses must implement this method"
+        end
+
+        def request_path
+          raise NotImplementedError, "Subclasses must implement this method"
+        end
+
+        def success_message_prefix
+          raise NotImplementedError, "Subclasses must implement this method"
+        end
+
+        def request_headers
+          { "Content-Type" => "application/json" }
+        end
+
+        def context_path
+          jira_client.options[:context_path]
+        end
+
+        def request_path_with_context
+          "#{context_path}#{request_path}"
+        end
+
+        private
+
+        def send_request
+          send_args = [http_verb, *build_request_args(request_path_with_context, request_payload)]
+
+          log.debug { "Sending #{send_args.collect { |arg| %("#{arg}") }.join(" ")}" }
+
+          jira_client.send(*send_args)
+        end
+
+        def build_request_args(request_url, payload)
+          [
+            request_url,
+            payload&.to_json,
+            request_headers
+          ]
+            .compact
+        end
+      end
+    end
+  end
+end

data/lib/jira/auto/tool/setup_logging.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "http_logger"
+require "logging"
+
+class Object
+  def log
+    @log ||= Logging.logger[self]
+  end
+end
+
+log_dir = File.join("log")
+FileUtils.makedirs(log_dir)
+
+Logging.logger.root.add_appenders(
+  Logging.appenders.stdout(level: :info),
+  Logging.appenders.file(File.join(log_dir, "#{File.basename($PROGRAM_NAME)}.log"), level: :info)
+)
+
+Logging.logger.root.level = :info
+
+logging_logger = Logging.logger["HTTPLogger"]
+logging_logger.level = :debug # info
+logging_logger.add_appenders(
+  Logging.appenders.stdout(level: :warn),
+  Logging.appenders.file(File.join(log_dir, "http_requests.log"), level: :debug)
+)
+
+HttpLogger.configure do |config|
+  config.logger = logging_logger
+  config.colorize = false
+  config.log_headers = true
+  config.log_request_body = true
+  config.log_response_body = true
+end

data/lib/jira/auto/tool/sprint/name.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "../sprint"
+
+module Jira
+  module Auto
+    class Tool
+      class Sprint
+        class Name
+          include Comparable
+
+          class NameConventionError < StandardError; end
+
+          SPRINT_PREFIX_SEPARATOR = "_"
+          NUMBERING_SEPARATOR = "."
+          SPRINT_NAME_REGEX = /
+            (.+)                                         # prefix
+            #{Regexp.escape(SPRINT_PREFIX_SEPARATOR)}
+            (\d\d)                                       # year
+            #{Regexp.escape(NUMBERING_SEPARATOR)}
+            (\d)                                         # quarter
+            #{Regexp.escape(NUMBERING_SEPARATOR)}
+            (\d+)                                        # index in quarter
+            $/x
+
+          def self.respects_naming_convention?(name_string)
+            SPRINT_NAME_REGEX.match? name_string
+          end
+
+          def self.parse(name_string)
+            name_string =~ SPRINT_NAME_REGEX ||
+              raise(NameConventionError,
+                    "'#{name_string}': " \
+                    "sprint name not matching #{SPRINT_NAME_REGEX}!")
+
+            new(::Regexp.last_match(1), ::Regexp.last_match(2).to_i, ::Regexp.last_match(3).to_i,
+                ::Regexp.last_match(4).to_i)
+          end
+
+          def self.build(prefix, year, quarter, index)
+            new(prefix, year, quarter, index)
+              .to_s
+          end
+
+          def self.new_with(prefix, suffix)
+            name = [prefix, suffix].join(SPRINT_PREFIX_SEPARATOR)
+
+            respects_naming_convention?(name) ||
+              raise(NameConventionError,
+                    "suffix not following convention '#{suffix}': " \
+                    "resulting sprint name '#{name}' " \
+                    "not matching #{SPRINT_NAME_REGEX}!")
+
+            parse(name)
+          end
+
+          FIELDS = %i[prefix year quarter index_in_quarter].freeze
+
+          FIELDS.each { |field| attr_accessor field }
+
+          def initialize(prefix, year, quarter, index_in_quarter)
+            @prefix = prefix
+            @year = year
+            @quarter = quarter
+            @index_in_quarter = index_in_quarter
+          end
+
+          YEAR_AS_TWO_DIGIT_RANGE = -2..-1
+
+          def to_s
+            [
+              prefix,
+              SPRINT_PREFIX_SEPARATOR,
+              year.to_s[YEAR_AS_TWO_DIGIT_RANGE],
+              NUMBERING_SEPARATOR,
+              quarter,
+              NUMBERING_SEPARATOR,
+              index_in_quarter
+            ].join
+          end
+
+          def planning_interval
+            [year, quarter]
+          end
+
+          def next_in_planning_interval
+            self.class.new(prefix, year, quarter, index_in_quarter + 1)
+          end
+
+          def <=>(other)
+            comparison_values(self) <=> comparison_values(other)
+          end
+
+          private
+
+          def comparison_values(object)
+            return [object] if object.is_a?(String)
+
+            FIELDS.collect { |field| object.send(field) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jira/auto/tool/sprint/prefix.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "../sprint"
+
+module Jira
+  module Auto
+    class Tool
+      class Sprint
+        class Prefix
+          include Comparable
+
+          attr_reader :name
+
+          def initialize(name, sprints = [])
+            @name = name
+            @sprints = sprints
+          end
+
+          def sprints
+            @sprints.sort
+          end
+
+          def <<(sprint)
+            @sprints << sprint
+          end
+
+          def quarterly_add_sprints_until(until_date)
+            add_sprint_following_last_one until covered?(until_date)
+          end
+
+          def covered?(until_date)
+            last_sprint.end_date > until_date.time
+          end
+
+          def add_sprint_following_last_one
+            self << NextSprintCreator.create_sprint_following(last_sprint)
+          end
+
+          def to_s
+            "name: #{name}, sprints: #{sprints}"
+          end
+
+          def to_table_row(without_board_information: false)
+            [name].concat(last_sprint.to_table_row(without_board_information:))
+          end
+
+          def self.to_table_row_header(without_board_information: false)
+            sprint_header = Sprint.to_table_row_header(without_board_information: without_board_information)
+            0.upto(1) { |i| sprint_header[i] = "Last Sprint #{sprint_header[i]}" }
+
+            ["Sprint Prefix"].concat(sprint_header)
+          end
+
+          def last_sprint
+            log.debug { "name = #{name}, #sprints = #{sprints.size}" }
+            sprints.max
+          end
+
+          def <=>(other)
+            [name, sprints] <=> [other.name, other.sprints]
+          end
+        end
+      end
+    end
+  end
+end