jira-auto-tool 0.1.1

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

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require "delegate"
+require "jira-ruby"
+
+require_relative "sprint_state_controller"
+
+module Jira
+  module Auto
+    class Tool
+      class Sprint < SimpleDelegator
+        include Comparable
+
+        def self.date_for_save(date)
+          case date
+          when Time, Date, DateTime
+            date
+          when String
+            Time.parse(date)
+          else
+            raise ArgumentError, "#{date.inspect} (#{date.class}), date must be a Time, Date, DateTime or a String"
+          end
+            .utc.iso8601
+        end
+
+        attr_reader :jira_sprint, :tool
+
+        def initialize(tool, jira_sprint)
+          super(jira_sprint)
+          @tool = tool
+          @jira_sprint = jira_sprint
+        end
+
+        def id
+          @jira_sprint.id
+        end
+
+        def name
+          @jira_sprint.name
+        end
+
+        def length_in_days
+          (end_date - start_date) / 1.day
+        end
+
+        def start_date
+          get_optional_date :startDate
+        end
+
+        def start_date=(date)
+          jira_sprint.attrs["startDate"] = self.class.date_for_save(date)
+        end
+
+        def start_date?
+          start_date != UNDEFINED_DATE
+        end
+
+        def end_date
+          get_optional_date :endDate
+        end
+
+        def end_date=(date)
+          jira_sprint.attrs["endDate"] = self.class.date_for_save(date)
+        end
+
+        def end_date?
+          end_date != UNDEFINED_DATE
+        end
+
+        UNDEFINED_DATE = Time.new(1970, 1, 1, 0, 0, 0, "UTC")
+
+        def get_optional_date(jira_field_id)
+          return UNDEFINED_DATE unless jira_sprint.respond_to?(jira_field_id)
+
+          parse_date(jira_sprint.send(jira_field_id))
+        end
+
+        def missing_dates?
+          start_date == UNDEFINED_DATE || end_date == UNDEFINED_DATE
+        end
+
+        def rename_to(new_name)
+          return if new_name == name || closed?
+
+          jira_sprint.attrs["name"] = new_name
+
+          save
+        end
+
+        def save
+          remove_attributes_that_causes_errors_on_save
+
+          jira_sprint.save!
+        end
+
+        def remove_attributes_that_causes_errors_on_save
+          jira_sprint.attrs.delete("rapidview_id")
+        end
+
+        def state
+          @jira_sprint.state
+        end
+
+        def closed?
+          state == SprintStateController::SprintState::CLOSED
+        end
+
+        def origin_board_id
+          @jira_sprint.originBoardId
+        end
+
+        def index_in_quarter
+          parsed_name.index_in_quarter
+        end
+
+        def board
+          @board ||= Board.find_by_id(tool, origin_board_id)
+        end
+
+        def jira_client
+          @jira_sprint.client
+        end
+
+        def name_prefix
+          parsed_name.prefix
+        end
+
+        def parsed_name
+          Name.parse(name)
+        end
+
+        def <=>(other)
+          comparison_values(self) <=> comparison_values(other)
+        end
+
+        def to_s
+          "name = #{name}, start_date = #{start_date}, end_date = #{end_date}, length_in_days = #{length_in_days}"
+        end
+
+        def self.to_table_row_field_names
+          %i[id name length_in_days start_date end_date]
+        end
+
+        def self.to_table_row_header(without_board_information: false)
+          header = to_table_row_field_names.collect { |field| field.to_s.titleize }
+
+          header.concat(Board.to_table_row_header.collect { |field| "Board #{field}" }) unless without_board_information
+
+          header
+        end
+
+        def to_table_row(without_board_information: false)
+          row = self.class.to_table_row_field_names.collect { |field| send(field) }
+
+          row.concat(board.to_table_row) unless without_board_information
+
+          row
+        rescue StandardError => e
+          raise e.class, "#{e.class}: sprint #{name.inspect}: #{e.message}:\n#{inspect}"
+        end
+
+        private
+
+        def comparison_values(object)
+          comparison_fields(object).collect { |field| object.send(field) }
+        end
+
+        def comparison_fields(object)
+          %i[start_date end_date] +
+            if Name.respects_naming_convention?(object.name)
+              [:parsed_name]
+            else
+              [:name]
+            end
+        end
+
+        def parse_date(date)
+          Time.parse(date).utc
+        end
+      end
+    end
+  end
+end

data/lib/jira/auto/tool/sprint_controller/options.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool/until_date"
+
+module Jira
+  module Auto
+    class Tool
+      class SprintController
+        class Options
+          def self.add(tool, parser)
+            add_quarterly_sprint_adding_options(parser, tool)
+            add_sprint_listing_options(parser, tool)
+            add_sprint_prefix_listing_options(parser, tool)
+          end
+
+          def self.add_quarterly_sprint_adding_options(parser, tool)
+            parser.on("--quarterly-sprint-add-one", "--qsao",
+                      "Create a follow up sprint for each of the existing unclosed sprint prefixes") do
+              tool.sprint_controller.quarterly_add_one_sprint_for_each_unclosed_sprint_prefix
+            end
+
+            parser.accept(UntilDate) { |until_date_string| UntilDate.new(until_date_string) }
+
+            parser.on("--quarterly-sprint-add-until=DATE", "--qsau", UntilDate,
+                      "Create sprints until date is included for each of the unclosed sprint prefixes") do |until_date|
+              tool.sprint_controller.quarterly_add_sprints_until(until_date)
+            end
+          end
+
+          def self.add_sprint_listing_options(parser, tool)
+            parser.on("--sprint-list",
+                      "List sprints. The output may be controlled via the ART_PREFIX_REGEX environment variable") do
+              tool.sprint_controller.list_sprints
+            end
+
+            parser.on("--sprint-list-without-board-info",
+                      "List sprints without the board information. " \
+                      "The output may be controlled via the ART_PREFIX_REGEX environment variable") do
+              tool.sprint_controller.list_sprints(without_board_information: true)
+            end
+          end
+
+          def self.add_sprint_prefix_listing_options(parser, tool)
+            parser.section_header "Sprint Prefix"
+
+            parser.on("--sprint-prefix-list",
+                      "List sprints. The output may be controlled via the ART_PREFIX_REGEX environment variable") do
+              tool.sprint_controller.list_sprint_prefixes
+            end
+
+            parser.on("--sprint-prefix-list-without-board-info",
+                      "List sprints without the board information. " \
+                      "The output may be controlled via the ART_PREFIX_REGEX environment variable") do
+              tool.sprint_controller.list_sprint_prefixes(without_board_information: true)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require_relative "next_sprint_creator"
+require_relative "sprint"
+require_relative "sprint/prefix"
+require_relative "sprint_state_controller"
+require_relative "helpers/pagination"
+
+module Jira
+  module Auto
+    class Tool
+      class SprintController
+        attr_accessor :tool, :board
+
+        def initialize(tool, board)
+          @tool = tool
+          @board = board
+        end
+
+        def quarterly_add_sprints_until(until_date)
+          unclosed_sprint_prefixes.each { |prefix| prefix.quarterly_add_sprints_until(until_date) }
+        end
+
+        def quarterly_add_one_sprint_for_each_unclosed_sprint_prefix
+          exit_with_board_warning "No sprint added since no reference sprint was found!" unless sprint_exist?
+          unless unclosed_sprint_exist?
+            exit_with_board_warning "No sprint added since no unclosed reference sprint was found!"
+          end
+
+          unclosed_sprint_prefixes.each(&:add_sprint_following_last_one)
+        end
+
+        SUCCESSFUL_EXECUTION_EXIT_CODE = 0
+        UNSUCCESSFUL_EXECUTION_EXIT_CODE = 1
+
+        def exit_with_board_warning(message, exit_code = SUCCESSFUL_EXECUTION_EXIT_CODE)
+          log.warn { "Jira board '#{board.name}': #{message}" }
+          exit(exit_code)
+        end
+
+        def unclosed_sprint_prefixes
+          @unclosed_sprint_prefixes ||= calculate_unclosed_sprint_prefixes.sort_by(&:name)
+        end
+
+        def unclosed_sprint_exist?
+          !unclosed_sprints.empty?
+        end
+
+        def sprint_exist?
+          !sprints.empty?
+        end
+
+        def list_sprint_prefixes(without_board_information: false)
+          list_object(Sprint::Prefix, :unclosed_sprint_prefixes,
+                      "Sprint Prefixes With Corresponding Last Sprints",
+                      without_board_information: without_board_information)
+        end
+
+        def list_sprints(without_board_information: false)
+          list_object(Sprint, :unclosed_sprints, "Matching Sprints",
+                      without_board_information: without_board_information)
+        end
+
+        def list_object(object_class, object_method, title, without_board_information: false)
+          table_row_header = object_class.to_table_row_header(without_board_information: without_board_information)
+
+          rows = send(object_method).collect do |sprint|
+            sprint.to_table_row(without_board_information: without_board_information)
+          end
+
+          table = Terminal::Table.new(
+            title: title,
+            headings: table_row_header,
+            rows: rows
+          )
+
+          puts table
+        end
+
+        def sprints
+          jira_sprints.collect { |jira_sprint| Sprint.new(tool, jira_sprint) }
+                      .uniq(&:id)
+                      .sort
+        end
+
+        def jira_sprints
+          sprint_filter_string = tool.art_sprint_regex_defined? ? tool.art_sprint_regex : ""
+          sprint_filter_regex = Regexp.new(sprint_filter_string)
+
+          unfiltered_board_sprints.find_all { |sprint| sprint.name =~ sprint_filter_regex }
+        end
+
+        def unfiltered_board_sprints
+          all_board_sprints = []
+
+          sprint_compatible_boards.each do |board|
+            all_board_sprints.concat(unfiltered_jira_sprints(board))
+          end
+
+          all_board_sprints
+        end
+
+        def sprint_compatible_boards
+          boards.find_all(&:sprint_compatible?)
+        end
+
+        def boards
+          tool.board_controller.boards
+        end
+
+        def unfiltered_jira_sprints(board)
+          Helpers::Pagination.fetch_all_object_pages do |pagination_options|
+            fetch_jira_sprints(board, pagination_options)
+          end
+        end
+
+        def fetch_jira_sprints(board, options)
+          log.debug { "Fetching sprints from Jira (#{options.inspect})" }
+
+          fetched_sprints = board.jira_board.sprints(options)
+
+          log.debug do
+            "Board: #{board.name}: Fetched #sprints #{fetched_sprints.size} sprints from Jira: " \
+              "#{fetched_sprints.map(&:name).join(", ")}"
+          end
+
+          fetched_sprints
+        end
+
+        def unclosed_sprints
+          sprints.find_all { |sprint| sprint.state != SprintStateController::SprintState::CLOSED }
+        end
+
+        private
+
+        def calculate_unclosed_sprint_prefixes
+          unclosed_sprints.each_with_object({}) do |sprint, prefixes|
+            if Sprint::Name.respects_naming_convention?(sprint.name)
+              prefix = prefixes[sprint.name_prefix] ||= Sprint::Prefix.new(sprint.name_prefix)
+              prefix << sprint
+            else
+              log.warn do
+                "IGNORING sprint '#{sprint.name}' (board '#{board.name}'): " \
+                  "it does not respect the naming conventions #{Sprint::Name::SPRINT_NAME_REGEX}."
+              end
+            end
+          end.values
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Jira
+  module Auto
+    class Tool
+      class SprintStateController
+        attr_reader :jira_client, :sprint
+
+        def initialize(jira_client, sprint)
+          @jira_client = jira_client
+          @sprint = sprint
+        end
+
+        def transition_to(desired_state)
+          transition_state(desired_state)
+        end
+
+        module SprintState
+          ACTIVE = "active"
+          FUTURE = "future"
+          CLOSED = "closed"
+        end
+
+        STATE_TRANSITIONS =
+          {
+            SprintState::FUTURE => SprintState::ACTIVE,
+            SprintState::ACTIVE => SprintState::CLOSED
+          }.freeze
+
+        # TODO: - write unit tests
+        # TODO - fix infinite loop in case of invalid/in-existing state
+        def transition_state(desired_state)
+          current_state = sprint.state
+
+          loop do
+            log.debug do
+              "sprint_to_update = #{sprint.name}, current_state = #{current_state} desired_state = #{desired_state}"
+            end
+
+            break if current_state == desired_state
+
+            new_state = STATE_TRANSITIONS[current_state]
+
+            update_sprint_state(new_state)
+
+            current_state = new_state
+          end
+        end
+
+        def update_sprint_state(new_state)
+          RequestBuilder::SprintStateUpdater
+            .new(jira_client, sprint: sprint, new_state: new_state)
+            .run
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool"
+
+module Jira
+  module Auto
+    class Tool
+      class Team
+        def initialize(field_option)
+          @field_option = field_option
+        end
+
+        def name
+          @field_option.value
+        end
+
+        def id
+          @field_option.id
+        end
+      end
+    end
+  end
+end

data/lib/jira/auto/tool/team_sprint_prefix_mapper/options.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool/until_date"
+
+module Jira
+  module Auto
+    class Tool
+      class TeamSprintPrefixMapper
+        class Options
+          def self.add(tool, parser)
+            parser.section_header "Team Sprint Prefix Mapping"
+
+            parser.on("--team-sprint-mapping-list", "--tsm-list",
+                      "List the sprint and team owning their content") do
+              tool.team_sprint_ticket_dispatcher.team_sprint_prefix_mapper.list_mappings
+            end
+
+            parser.on("--team-sprint-mapping-dispatch-tickets", "--tsm-dispatch",
+                      "Dispatch tickets to sprint so the teams start timely working on them") do
+              tool.team_sprint_ticket_dispatcher.dispatch_tickets
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "terminal-table"
+
+module Jira
+  module Auto
+    class Tool
+      class TeamSprintPrefixMapper
+        class NoMatchingTeamError < StandardError; end
+
+        class NoMatchingSprintPrefixError < StandardError; end
+
+        attr_reader :teams, :sprint_prefixes
+
+        def initialize(teams, sprint_prefixes)
+          @sprint_prefixes = sprint_prefixes
+          @teams = teams
+        end
+
+        def list_mappings
+          table = Terminal::Table.new(
+            title: "Team Sprint Mappings",
+            headings: ["Team", "Sprint Prefix"],
+            rows: teams.collect do |team|
+              [team, team_sprint_prefix_mappings.fetch(team, "!!__no matching sprint prefix__!!")]
+            end
+          )
+
+          puts table
+        end
+
+        def fetch_for(team_name)
+          team_sprint_prefix_mappings[team_name]
+        end
+
+        def fetch_for!(team_name)
+          fetch_for(team_name) or
+            raise NoMatchingSprintPrefixError,
+                  no_matching_sprint_prefix_for_team_message(team_name)
+        end
+
+        def team_sprint_prefix_mappings
+          @team_sprint_prefix_mappings ||=
+            sprint_prefixes.collect(&:name).each_with_object({}) do |prefix_name, mappings|
+              found_team = map_prefix_name_to_team_name(prefix_name)
+              mappings[prefix_name] = found_team if found_team
+            end.invert
+        end
+
+        def map_prefix_name_to_team_name(prefix_name)
+          sub_team_in_prefix = prefix_name.split(Sprint::Name::SPRINT_PREFIX_SEPARATOR).last
+
+          teams.find { |team| team.end_with?(sub_team_in_prefix) }
+        end
+
+        def no_matching_sprint_prefix_for_team_message(team_name)
+          "No matching sprint prefix for team '#{team_name}' in #{team_sprint_prefix_mappings.inspect}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Jira
+  module Auto
+    class Tool
+      class TeamSprintTicketDispatcher
+        attr_reader :jira_client, :tickets, :sprint_prefixes
+
+        def initialize(jira_client, tickets, sprint_prefixes)
+          @jira_client = jira_client
+          @tickets = tickets
+          @sprint_prefixes = sprint_prefixes
+        end
+
+        def dispatch_tickets
+          per_team_tickets do |team, tickets|
+            log.debug { "#{team}: dispatching tickets #{tickets.collect(&:key).join(", ")}" }
+
+            sprint_prefix_matching_team = sprint_prefix_for(team)
+
+            if sprint_prefix_matching_team.nil?
+              log.warn { team_sprint_prefix_mapper.no_matching_sprint_prefix_for_team_message(team) }
+            else
+              dispatch_tickets_to_prefix_sprints(sprint_prefix_matching_team, tickets)
+            end
+          end
+        end
+
+        def sprint_prefix_for(team)
+          team_sprint_prefix_mapper.fetch_for(team)
+        end
+
+        def dispatch_tickets_to_prefix_sprints(prefix_name, tickets)
+          prefix = sprint_prefixes.find { |sprint_prefix| sprint_prefix.name == prefix_name }
+
+          tickets.each do |ticket|
+            matched_sprint = match_ticket_to_prefix_sprint(prefix, ticket)
+
+            ticket.sprint = matched_sprint if matched_sprint
+          end
+        end
+
+        def match_ticket_to_prefix_sprint(prefix, ticket)
+          ticket_start_time = Time.parse(ticket.expected_start_date).end_of_day
+
+          first_sprint_when_overdue_ticket(ticket_start_time, prefix) ||
+            prefix.sprints.find do |sprint|
+              ticket_start_time.between?(sprint.start_date, sprint.end_date)
+            end
+        end
+
+        def first_sprint_when_overdue_ticket(ticket_start_time, prefix)
+          first_sprint = prefix.sprints.first
+
+          ticket_start_time < first_sprint.start_date ? first_sprint : nil
+        end
+
+        def per_team_tickets(&)
+          return enum_for(:per_team_tickets) unless block_given?
+
+          team_ticket_map = tickets.group_by(&:implementation_team)
+
+          team_ticket_map.each(&)
+        end
+
+        def team_sprint_prefix_mapper
+          TeamSprintPrefixMapper.new(teams, sprint_prefixes)
+        end
+
+        def teams
+          tickets.collect(&:implementation_team).uniq.sort
+        end
+      end
+    end
+  end
+end