jira-auto-tool 0.1.1

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool"
+require_relative "helpers/environment_based_value"
+
+module Jira
+  module Auto
+    class Tool
+      class Ticket
+        include Helpers::EnvironmentBasedValue
+
+        attr_reader :tool, :jira_ticket
+
+        def initialize(tool, jira_ticket, implementation_team = nil, expected_start_date = nil)
+          @tool = tool
+          @jira_ticket = jira_ticket
+          @implementation_team = implementation_team
+          @expected_start_date = expected_start_date
+        end
+
+        def key
+          jira_ticket.key
+        end
+
+        def sprint=(sprint)
+          @sprint = sprint
+
+          jira_ticket.save!({ "fields" => { tool.jira_sprint_field.id => sprint.id } })
+        rescue StandardError => e
+          message = "Failed to set sprint for ticket #{key} to #{sprint.id}! #{self}"
+
+          log.error { message }
+
+          raise e.class, message
+        end
+
+        def to_s
+          "Ticket(#{to_s_fields.collect { |field| "#{field}: #{send(field)}" }.join(", ")})"
+        end
+
+        def to_s_fields
+          %i[key summary sprint implementation_team expected_start_date]
+        end
+
+        def sprint
+          jira_ticket.fields.fetch(tool.jira_sprint_field.id)
+        end
+
+        def jira_client
+          tool.jira_client
+        end
+
+        def jira_sprint_field
+          tool.jira_sprint_field
+        end
+
+        def expected_start_date
+          @expected_start_date || jira_field_value(expected_start_date_field.id)
+        end
+
+        IMPLEMENTATION_TEAM_VALUE_ATTRIBUTES = %w[value name].freeze
+
+        def implementation_team
+          @implementation_team ||=
+            begin
+              attributes = implementation_team_attributes
+
+              if attributes.nil?
+                nil
+              else
+                IMPLEMENTATION_TEAM_VALUE_ATTRIBUTES.any? { |attr| attributes.key?(attr) } or
+                  raise "Implementation team #{IMPLEMENTATION_TEAM_VALUE_ATTRIBUTES.join(" and ")} " \
+                        "attributes not found in #{attributes}!"
+
+                attributes.values_at(*IMPLEMENTATION_TEAM_VALUE_ATTRIBUTES).compact.first
+              end
+            end
+        end
+
+        def implementation_team_attributes
+          jira_field_value(implementation_team_field.id)
+        end
+
+        def implementation_team_field
+          tool.implementation_team_field
+        end
+
+        def expected_start_date_field
+          tool.expected_start_date_field
+        end
+
+        def summary
+          jira_ticket.summary
+        end
+
+        def jira_field_value(field_id = caller_locations(1, 1).first.base_label)
+          log.debug { "jira_field_value(#{field_id})" }
+
+          field = jira_ticket.fields.fetch(field_id) do |id|
+            raise "#{id}: value not found in #{jira_ticket.fields}"
+          end
+
+          log.debug { "jira_field_value(#{field_id}), field: #{field}" }
+
+          field
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool/helpers/overridable_time"
+require_relative "request_builder/sprint_creator"
+require_relative "request_builder/sprint_state_updater"
+
+module Jira
+  module Auto
+    class Tool
+      class UntilDate
+        class FormatError < RuntimeError; end
+
+        attr_reader :time
+
+        NAMED_DATES = %i[
+          today
+          current_quarter
+          coming_quarter
+        ].freeze
+
+        NAMED_DATE_REGEX = /^(#{NAMED_DATES.join("|")})$/
+
+        INCLUDES_TIME_REGEX = /.+\s\d{2}:\d{2}.+/
+        STARTS_WITH_DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/ # TODO : use something more reliable like the Chronic gem
+        TIME_UNTIL_MIDNIGHT_UTC = " 23:59:59 UTC"
+
+        def initialize(date_string)
+          @time =
+            case date_string
+            when NAMED_DATE_REGEX
+              send(date_string.intern)
+            else
+              parse_date(date_string)
+            end
+        end
+
+        def current_date_time
+          Helpers::OverridableTime.now.utc
+        end
+
+        private
+
+        def parse_date(date_string)
+          case date_string
+          when INCLUDES_TIME_REGEX
+            Time.parse(date_string)
+          when STARTS_WITH_DATE_REGEX
+            Time.parse(date_string + TIME_UNTIL_MIDNIGHT_UTC).end_of_day
+          else
+            raise FormatError, "date string '#{date_string}' is not in a supported format"
+          end
+        end
+
+        def today
+          current_date_time.end_of_day
+        end
+
+        def current_quarter
+          today.end_of_quarter
+        end
+
+        def coming_quarter
+          (current_quarter + 1.day).end_of_quarter
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Jira
+  module Auto
+    class Tool
+      VERSION = "0.1.1"
+    end
+  end
+end

data/lib/jira/auto/tool.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/blank"
+require "date"
+require "active_support/core_ext/numeric/time"
+require "active_support/core_ext/date/calculations"
+require "jira-ruby"
+
+require_relative "tool/config"
+require_relative "tool/board_controller"
+require_relative "tool/helpers/environment_based_value"
+require_relative "tool/project"
+require_relative "tool/rate_limited_jira_client"
+require_relative "tool/request_builder"
+require_relative "tool/setup_logging"
+require_relative "tool/sprint_controller"
+require_relative "tool/sprint_state_controller"
+require_relative "tool/team"
+require_relative "tool/team_sprint_prefix_mapper"
+require_relative "tool/team_sprint_ticket_dispatcher"
+require_relative "tool/ticket"
+require_relative "tool/version"
+
+module Jira
+  module Auto
+    class Tool
+      extend Helpers::EnvironmentBasedValue
+
+      class Error < StandardError; end
+
+      def config
+        @config ||= Config.new(self)
+      end
+
+      def board_name
+        jira_board_name
+      end
+
+      def board
+        found_board = boards.find { |a_board| a_board.name == board_name } or
+          raise KeyError, "Board '#{board_name}' not found!"
+
+        log.debug { "Jira board '#{board_name}' found: #{found_board}!" }
+
+        found_board
+      end
+
+      def boards
+        board_controller.boards
+      end
+
+      def fetch_sprint(sprint_name)
+        sprint_controller.sprints.find { |sprint| sprint.name == sprint_name } or
+          raise KeyError, "Sprint '#{sprint_name}' not found for #{board.name}!" # TODO: - test this condition
+      end
+
+      ATTRIBUTES_TO_IGNORE_FOR_SPRINT_CREATION = %i[state].freeze
+
+      def create_sprint(attributes)
+        attributes_for_sprint_creation = attributes.except(*ATTRIBUTES_TO_IGNORE_FOR_SPRINT_CREATION)
+
+        created_sprint = create_future_sprint(attributes_for_sprint_creation)
+
+        log.debug { created_sprint.inspect }
+
+        transition_sprint_state(created_sprint, desired_state: attributes.fetch(:state))
+      end
+
+      def transition_sprint_state(created_sprint, desired_state:)
+        SprintStateController.new(jira_client, created_sprint).transition_to(desired_state)
+      end
+
+      def jira_client
+        RateLimitedJiraClient.new(jira_client_options,
+                                  rate_interval:
+                                    jat_rate_interval_in_seconds_when_defined_else(
+                                      RateLimitedJiraClient::NO_RATE_INTERVAL_IN_SECONDS
+                                    ).to_i,
+                                  rate_limit:
+                                    jat_rate_limit_in_seconds_when_defined_else(
+                                      RateLimitedJiraClient::NO_RATE_LIMIT_IN_SECONDS
+                                    ).to_i)
+      end
+
+      def jira_client_options
+        {
+          username: jira_username,
+          password: jira_api_token,
+          site: jira_site_url,
+          context_path: jira_context_path_when_defined_else(""),
+          auth_type: :basic,
+          http_debug: jira_http_debug?
+        }
+      end
+
+      def jira_http_debug?
+        value = if config.key?(:jira_http_debug)
+                  config[:jira_http_debug]
+                else
+                  jira_http_debug_defined? && jira_http_debug
+                end
+
+        result = case value
+                 when String
+                   value =~ /^(true|yes|1)$/i
+                 else
+                   value
+                 end
+
+        log.debug { "jira_http_debug? = #{result} (jira_http_debug = #{value}, config = #{config.inspect})" }
+
+        result
+      end
+
+      def jira_request_path(path)
+        jira_client.options[:context_path] + path
+      end
+
+      def jira_base_url
+        jira_client.options[:site] + jira_client.options[:context_path]
+      end
+
+      def jira_url(url)
+        jira_base_url + url
+      end
+
+      %i[
+        art_sprint_regex
+        expected_start_date_field_name
+        implementation_team_field_name
+        jat_rate_limit_in_seconds
+        jat_rate_interval_in_seconds
+        jat_tickets_for_team_sprint_ticket_dispatcher_jql
+        jira_api_token
+        jira_board_name
+        jira_board_name_regex
+        jira_context_path
+        jira_http_debug
+        jira_project_key
+        jira_site_url
+        jira_username
+        jira_sprint_field_name
+      ].each do |method_name|
+        define_overridable_environment_based_value(method_name)
+      end
+
+      def board_controller
+        @board_controller ||= BoardController.new(self)
+      end
+
+      def sprint_controller
+        @sprint_controller ||= SprintController.new(self, board)
+      end
+
+      def project_ticket_fields
+        project.ticket_fields
+      end
+
+      def project
+        @project ||= Project.find(self, jira_project_key)
+      end
+
+      def expected_start_date_field(field_name = expected_start_date_field_name)
+        field_controller.expected_start_date_field(field_name)
+      end
+
+      def implementation_team_field(field_name = implementation_team_field_name)
+        field_controller.implementation_team_field(field_name)
+      end
+
+      def jira_sprint_field(field_name = jira_sprint_field_name)
+        field_controller.sprint_field(field_name)
+      end
+
+      def field_controller
+        @field_controller ||= FieldController.new(jira_client)
+      end
+
+      def unclosed_sprints
+        sprint_controller.unclosed_sprints
+      end
+
+      def unclosed_sprint_prefixes
+        sprint_controller.unclosed_sprint_prefixes
+      end
+
+      def teams
+        implementation_team_field.values.collect { |value| Team.new(value) }.collect(&:name)
+      end
+
+      def tickets(jql = "project = #{project.key}")
+        jira_client.Issue.jql(jql).collect { |jira_ticket| Ticket.new(self, jira_ticket) }
+      rescue StandardError => e
+        raise <<~EOEM
+          Error fetching project tickets: Something went wrong:
+          __________ Please check your Jira configuration and your query ______
+          jql = #{jql}
+          #{e.class}: #{e.message}
+        EOEM
+      end
+
+      def team_sprint_ticket_dispatcher
+        TeamSprintTicketDispatcher.new(jira_client,
+                                       tickets(jat_tickets_for_team_sprint_ticket_dispatcher_jql),
+                                       unclosed_sprint_prefixes)
+      end
+
+      private
+
+      def create_future_sprint(attributes)
+        RequestBuilder::SprintCreator
+          .create_sprint(self, board.id, attributes)
+      end
+    end
+  end
+end

data/sig/jira/sprint/tool.rbs

@@ -0,0 +1,8 @@
+module Jira
+ module Auto
+    module Tool
+      VERSION: String
+      # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+    end
+  end
+end

data/spec/jira/auto/tool/board/cache_spec.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require "rspec"
+
+require "jira/auto/tool/board/cache"
+
+module Jira
+  module Auto
+    class Tool
+      class Board
+        class Cache
+          RSpec.describe Cache do
+            let(:cache) { described_class.new(tool) }
+            let(:tool) { instance_double(Tool, jira_client: jira_client) }
+            let(:jira_client) { jira_resource_double(JIRA::Client) }
+            let(:board_factory) { double("BoardFactory") } # rubocop:disable RSpec/VerifiedDoubles
+
+            describe "#boards" do
+              before { allow(cache).to receive_messages(valid?: valid?) }
+
+              context "when cache is valid" do
+                let(:valid?) { true }
+
+                let(:raw_content) do
+                  {
+                    "boards" => [
+                      { "id" => 16, "name" => "name for board #16" },
+                      { "id" => 32, "name" => "name for board #32" }
+                    ]
+                  }
+                end
+
+                before do
+                  allow(cache).to receive_messages(raw_content: raw_content)
+                  allow(jira_client).to receive_messages(Board: board_factory)
+
+                  allow(board_factory)
+                    .to receive(:build).with({ "id" => 16, "name" => "name for board #16" })
+                                       .and_return(:first_jira_board)
+
+                  allow(Board).to receive(:new).with(tool, :first_jira_board).and_return(:first_board)
+
+                  allow(board_factory)
+                    .to receive(:build).with({ "id" => 32, "name" => "name for board #32" })
+                                       .and_return(:second_jira_board)
+
+                  allow(Board).to receive(:new).with(tool, :second_jira_board).and_return(:second_board)
+                end
+
+                it "returns the boards" do
+                  expect(cache.boards).to eq(%i[first_board second_board])
+                end
+              end
+
+              context "when cache is invalid" do
+                let(:valid?) { false }
+
+                it do
+                  expect { cache.boards }
+                    .to raise_error(RuntimeError, "This method should not be used since the cache is invalid")
+                end
+              end
+            end
+
+            describe "#save" do
+              def build_board(id)
+                instance_double(
+                  Board,
+                  jira_board: jira_resource_double(attrs: { "id" => id, "name" => "name for board ##{id}" })
+                )
+              end
+
+              let(:boards) { [4, 8].collect { |id| build_board(id) } }
+              let(:expected_board_yaml) do
+                <<~EOBYAML
+                  ---
+                  boards:
+                  - id: 4
+                    name: 'name for board #4'
+                  - id: 8
+                    name: 'name for board #8'
+                EOBYAML
+              end
+
+              before do
+                allow(cache).to receive_messages(file_path: "path/to/cache.yml")
+              end
+
+              it "returns the boards" do
+                expect(File).to receive(:write).with("path/to/cache.yml", expected_board_yaml)
+
+                expect(cache.save(boards)).to eq(boards)
+              end
+            end
+
+            describe "#clear" do
+              before do
+                allow(cache).to receive_messages(file_path: "path/to/cache.yml")
+                allow(FileUtils).to receive(:rm_f).with("path/to/cache.yml")
+              end
+
+              it "deletes the cache file" do
+                cache.clear
+
+                expect(FileUtils).to have_received(:rm_f).with("path/to/cache.yml")
+              end
+            end
+
+            describe "#valid?" do
+              before do
+                allow(cache).to receive_messages(file_path: "path/to/cache.yml")
+
+                allow(File).to receive(:exist?).with("path/to/cache.yml").and_return(exist?)
+              end
+
+              context "when cache file exists" do
+                let(:exist?) { true }
+
+                before do
+                  allow(cache).to receive_messages(expired?: expired?)
+                end
+
+                context "when cache has not expired" do
+                  let(:expired?) { false }
+
+                  it { expect(cache).to be_valid }
+                end
+
+                context "when cache has expired" do
+                  let(:expired?) { true }
+
+                  it { expect(cache).not_to be_valid }
+                end
+              end
+            end
+
+            describe "#expired?" do
+              before do
+                allow(cache).to receive_messages(cached_at: cached_at)
+              end
+
+              context "when expired" do
+                let(:cached_at) { Time.now - 1.day }
+
+                it { expect(cache.send(:expired?)).to be_truthy }
+              end
+
+              context "when not expired" do
+                let(:cached_at) { Time.now }
+
+                it { expect(cache.send(:expired?)).to be_falsy }
+              end
+            end
+
+            describe "#one_hour_ago" do
+              let(:time_now) { Time.parse("2025-02-21 20:55:00 UTC") }
+
+              before { allow(Helpers::OverridableTime).to receive_messages(now: time_now) }
+
+              it { expect(cache.send(:one_day_ago)).to eq(Time.parse("2025-02-20 20:55:00 UTC")) }
+            end
+
+            describe "#file_path" do
+              let(:config) { instance_double(Config, dir: "path/to/config/dir") }
+
+              before do
+                allow(tool).to receive_messages(config: config)
+              end
+
+              it "is located in the config dir" do
+                expect(cache.send(:file_path)).to eq("path/to/config/dir/jira-auto-tool.cache.yml")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/jira/auto/tool/board/unavailable_board_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool/board/unavailable_board"
+
+module Jira
+  module Auto
+    class Tool
+      class Board
+        class UnavailableBoard < Board
+          RSpec.describe UnavailableBoard do
+            let(:tool) { instance_double(Tool) }
+            let(:board) { described_class.new(tool, 4) }
+
+            it { expect(board.id).to eq(4) }
+            it { expect(board.name).to eq("N/A") }
+            it { expect(board.url).to eq("N/A") }
+
+            describe "#<=>" do
+              def new_board(id)
+                described_class.new(tool, id)
+              end
+
+              let(:board_with_same_id) { new_board(4) }
+
+              it { expect(board <=> board_with_same_id).to eq(0) }
+              it { expect(new_board(1) <=> board).to eq(-1) }
+              it { expect(new_board(5) <=> board).to eq(1) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/jira/auto/tool/board_controller/options_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "rspec"
+
+require "jira/auto/tool/board_controller/options"
+
+module Jira
+  module Auto
+    class Tool
+      class BoardController
+        class Options
+          # TODO: clean this autogenerated code
+          # rubocop:disable  RSpec/MultipleExpectations
+          RSpec.describe Options do
+            let(:tool) { instance_double(Tool, board_controller: board_controller) }
+            let(:board_controller) { instance_double(BoardController) }
+            let(:parser) { instance_double(OptionParser) }
+
+            describe ".add" do
+              it "configures board cache clear option" do
+                expect(parser).to receive(:section_header).with("Board")
+                expect(parser).to receive(:on).with("--board-name=STRING", String)
+                expect(parser).to receive(:on).with("--board-cache-clear", any_args) do |&block|
+                  expect(board_controller).to receive(:clear_cache)
+                  block.call
+                end
+
+                expect(parser).to receive(:on).with("--board-list", any_args)
+
+                described_class.add(tool, parser)
+              end
+
+              it "configures board list option" do
+                expect(parser).to receive(:section_header).with("Board")
+                expect(parser).to receive(:on).with("--board-name=STRING", String)
+                expect(parser).to receive(:on).with("--board-cache-clear", any_args)
+
+                expect(parser).to receive(:on).with("--board-list", any_args) do |&block|
+                  expect(board_controller).to receive(:list_boards)
+                  block.call
+                end
+
+                described_class.add(tool, parser)
+              end
+            end
+            # rubocop:enable  RSpec/MultipleExpectations
+          end
+        end
+      end
+    end
+  end
+end