jira-auto-tool 0.1.1

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool/helpers/option_parser"
+require "jira/auto/tool/board_controller"
+require "jira/auto/tool/board/cache"
+
+module Jira
+  module Auto
+    class Tool
+      class BoardController
+        class Options
+          def self.add(tool, parser)
+            parser.section_header "Board"
+
+            parser.on("--board-name=STRING", String) do |board_name|
+              tool.jira_board_name = board_name
+            end
+
+            parser.on("--board-cache-clear", "Clear the board cache so they are requested again.") do
+              tool.board_controller.clear_cache
+            end
+
+            parser.on("--board-list", "List boards. The output can be controlled via the " \
+                                      "#{Tool::Environment::JIRA_BOARD_NAME_REGEX} environment variable") do
+              tool.board_controller.list_boards
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool/board"
+require "jira/auto/tool/board/cache"
+
+module Jira
+  module Auto
+    class Tool
+      class BoardController
+        attr_reader :jira_client, :tool
+
+        def initialize(tool)
+          @tool = tool
+          @jira_client = tool.jira_client
+        end
+
+        def list_boards
+          table = Terminal::Table.new(
+            title: "Boards",
+            headings: ["Project Key", "Name", "Board UI URL"],
+            rows: boards.collect { |board| [board.project_key, board.name, board.ui_url] }
+          )
+
+          puts table
+        end
+
+        def boards
+          return cached_boards if valid_cache?
+
+          cache_boards(filtered_boards)
+        end
+
+        def clear_cache
+          cache.clear
+        end
+
+        private
+
+        def filtered_boards
+          named_filtered_boards = apply_board_name_filter(unfiltered_boards)
+
+          apply_project_key_filter(named_filtered_boards)
+        end
+
+        def unfiltered_boards
+          @unfiltered_boards ||= request_boards
+        end
+
+        def valid_cache?
+          cache.valid?
+        end
+
+        def cached_boards
+          cache.boards
+        end
+
+        def cache
+          @cache ||= Board::Cache.new(tool)
+        end
+
+        def request_boards
+          jira_client.Board.all.collect { |board| Board.new(tool, board) }
+        end
+
+        def cache_boards(boards)
+          cache.save(boards)
+        end
+
+        def apply_project_key_filter(boards_to_filter)
+          return boards_to_filter unless tool.jira_project_key_defined?
+
+          boards_to_filter.find_all do |board|
+            !board.with_project_information? ||
+              board.project_key == tool.jira_project_key
+          end
+        end
+
+        def apply_board_name_filter(boards_to_filter)
+          return boards_to_filter unless tool.jira_board_name_regex_defined?
+
+          board_name_regex = Regexp.new(tool.jira_board_name_regex)
+
+          boards_to_filter.find_all { |board| board.name =~ board_name_regex }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool/helpers/option_parser"
+
+module Jira
+  module Auto
+    class Tool
+      module CommonOptions
+        DISPLAY_HELP_OPTION = "--help"
+
+        def self.add(tool, parser)
+          ::ARGV << DISPLAY_HELP_OPTION if ARGV.empty?
+
+          add_help_banner_and_options(parser)
+
+          parser.on("-v", "--version", "Print the version") do
+            Kernel.puts tool.class::VERSION
+
+            Kernel.exit 1
+          end
+        end
+
+        def self.add_help_banner_and_options(parser)
+          parser.banner = <<~EOBANNER
+            Usage: #{File.basename($PROGRAM_NAME)} [options]*
+
+          EOBANNER
+
+          parser.on("-h", DISPLAY_HELP_OPTION, "Print this help") do
+            Kernel.puts parser
+            Kernel.exit 1
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Jira
+  module Auto
+    class Tool
+      class Config
+        class Options
+          def self.add(_tool, parser)
+            # parser.section_header "Config"
+            #
+            # parser.on("--config-list") do
+            #   # TODO: tool.config.list
+            # end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Jira
+  module Auto
+    class Tool
+      class Config
+        include Comparable
+
+        attr_reader :tool
+
+        def initialize(tool)
+          @tool = tool
+        end
+
+        def []=(key, value)
+          value_store[sanitize_key(key)] = value
+          save
+        end
+
+        def [](key)
+          value_store[sanitize_key(key)]
+        end
+
+        def key?(key)
+          value_store.key?(sanitize_key(key))
+        end
+
+        def <=>(other)
+          value_store <=> (other.is_a?(Config) ? other.value_store : other)
+        end
+
+        def path
+          File.join(dir, "jira-auto-tool.config.yml")
+        end
+
+        def dir
+          config_dir = File.join(Dir.home, ".config/jira-auto-tool")
+          FileUtils.makedirs(config_dir)
+          config_dir
+        end
+
+        private
+
+        def sanitize_key(key)
+          key.to_s
+        end
+
+        def save
+          File.write(path, value_store.to_yaml)
+        end
+
+        def value_store
+          @value_store ||= load
+        end
+
+        def load
+          File.exist?(path) ? YAML.safe_load_file(path) : {}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+#
+# require "jira-ruby"
+# require "json"
+#
+# # Jira client setup
+# options = {
+#   username: "your_username", # Replace with Jira username
+#   password: "your_api_token", # Replace with your API token for authentication
+#   site: "https://your-domain.atlassian.net", # Replace with your Jira instance URL
+#   context_path: "",
+#   auth_type: :basic
+# }
+#
+# client = JIRA::Client.new(options)
+#
+# # Get issue metadata for project and custom field
+# def fetch_custom_field_options(client, project_key, custom_field_id)
+#   # Fetch issue metadata for the project
+#   response = client.get("/rest/api/3/issue/createmeta?projectKeys=#{project_key}&expand=projects.issuetypes.fields")
+#   metadata = JSON.parse(response.body)
+#
+#   # Parse metadata for the specified custom field
+#   options = []
+#   metadata["projects"].each do |project|
+#     project["issuetypes"].each do |issuetype|
+#       fields = issuetype["fields"] || {}
+#       if fields[custom_field_id] && fields[custom_field_id]["allowedValues"]
+#         options = fields[custom_field_id]["allowedValues"].map { |option| option["value"] }
+#       end
+#     end
+#   end
+#
+#   # Return unique options
+#   options.uniq
+# rescue JIRA::HTTPError => e
+#   puts "Failed to fetch field metadata: #{e.response.body}"
+#   nil
+# end
+#
+# # Replace with your Jira project key and the custom field ID
+# project_key = "PROJ"
+# custom_field_id = "customfield_10021" # Replace with your custom field ID
+# options = fetch_custom_field_options(client, project_key, custom_field_id)
+#
+# puts "Possible values: #{options}"

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool/request_builder/field_context_fetcher"
+require "jira/auto/tool/request_builder/field_option_fetcher"
+
+module Jira
+  module Auto
+    class Tool
+      class Field
+        include Comparable
+
+        attr_reader :jira_client, :jira_field
+
+        def initialize(jira_client, jira_field)
+          @jira_client = jira_client
+          @jira_field = jira_field
+        end
+
+        def name
+          jira_field.name
+        end
+
+        def type
+          jira_field.schema.fetch("type")
+        end
+
+        def id
+          jira_field.id
+        end
+
+        def <=>(other)
+          comparison_values(self) <=> comparison_values(other)
+        end
+
+        def values
+          RequestBuilder::FieldOptionFetcher.fetch_field_options(self)
+        end
+
+        def field_context
+          contexts = field_contexts
+
+          log.warn { "field #{self} has several field contexts" } unless contexts.size == 1
+
+          field_contexts.first # TODO: - handle several field contexts
+        end
+
+        def field_contexts
+          RequestBuilder::FieldContextFetcher.fetch_field_contexts(self)
+        end
+
+        private
+
+        def comparison_values(object)
+          %i[name type id].collect { |field| object.send(field) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool"
+require_relative "field"
+
+module Jira
+  module Auto
+    class Tool
+      class FieldController
+        class FieldNotFoundError < StandardError; end
+        class ExpectedFieldTypeError < StandardError; end
+
+        def initialize(jira_client)
+          @jira_client = jira_client
+        end
+
+        def sprint_field(field_name)
+          field_fetcher(field_name, "array")
+        end
+
+        def expected_start_date_field(field_name)
+          field_fetcher(field_name, "date")
+        end
+
+        def implementation_team_field(field_name)
+          field_fetcher(field_name, "option|any")
+        end
+
+        def ticket_fields
+          @ticket_fields ||= @jira_client.Field.all.collect { |field| Field.new(@jira_client, field) }
+        rescue StandardError => e
+          raise "Error fetching project ticket fields: Something went wrong:\n#{e}"
+        end
+
+        private
+
+        def field_fetcher(field_name, expected_type)
+          field = ticket_fields.find { |f| f.name == field_name } or
+            raise FieldNotFoundError, "Field '#{field_name}' not found!"
+
+          field.type =~ Regexp.new(expected_type) or
+            raise ExpectedFieldTypeError,
+                  "Field '#{field_name}' expected to have type '#{expected_type}', but was '#{field.type}'."
+
+          field
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool"
+
+module Jira
+  module Auto
+    class Tool
+      class FieldOption
+        include Comparable
+
+        attr_reader :jira_client, :id, :value
+
+        def initialize(jira_client, id, value)
+          @jira_client = jira_client
+          @id = id
+          @value = value
+        end
+
+        def to_s
+          "FieldOption(id: #{id}, value: '#{value}')"
+        end
+
+        def <=>(other)
+          comparison_values(self) <=> comparison_values(other)
+        end
+
+        private
+
+        def comparison_values(object)
+          %i[id value].collect { |field| object.send(field) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+#
+# def get_createmeta_for_project(client, project_key)
+#   response = client.get("/rest/api/3/issue/createmeta?projectKeys=#{project_key}")
+#   metadata = JSON.parse(response.body)
+#
+#   # Parse issue types and fields for the project
+#   metadata["projects"].each do |project|
+#     project["issuetypes"].each do |issuetype|
+#       puts "Issue Type: #{issuetype["name"]}"
+#
+#       issuetype["fields"].each do |field_id, field_details|
+#         puts "Field: #{field_details["name"]}, ID: #{field_id}"
+#       end
+#     end
+#   end
+# rescue JIRA::HTTPError => e
+#   puts "Failed to retrieve create metadata: #{e.response.body}"
+# end
+#
+# # Replace with your project key
+# project_key = "PROJ"
+# get_createmeta_for_project(client, project_key)

data/lib/jira/auto/tool/helpers/environment_based_value.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Jira
+  module Auto
+    class Tool
+      module Helpers
+        module EnvironmentBasedValue
+          # TODO: overly complex - simplify by moving this to the Config and define a Configurable module
+          def define_overridable_environment_based_value(method_name)
+            define_reader(method_name)
+            define_predicate(method_name)
+            define_reader_accepting_default_value(method_name)
+            define_writer(method_name)
+            define_environment_variable_name_constant(method_name)
+          end
+
+          def define_reader(method_name)
+            define_method(method_name) do
+              self.class.instance_variable_name(method_name)
+
+              if config.key?(method_name)
+                config[method_name]
+              else
+                self.class.fetch_corresponding_environment_variable(method_name.to_s)
+              end
+            end
+          end
+
+          def define_predicate(method_name)
+            define_method(:"#{method_name}_defined?") do
+              self.class.corresponding_environment_variable_defined?(method_name.to_s)
+            end
+          end
+
+          def define_reader_accepting_default_value(method_name)
+            define_method(:"#{method_name}_when_defined_else") do |value|
+              if config.key?(method_name)
+                config[method_name]
+              elsif self.class.corresponding_environment_variable_defined?(method_name.to_s)
+                send(method_name)
+              else
+                value
+              end
+            end
+          end
+
+          def define_writer(method_name)
+            define_method(:"#{method_name}=") do |value|
+              log.debug { "#{method_name}= #{value.inspect}" }
+              config[method_name] = value
+            end
+          end
+
+          def define_environment_variable_name_constant(method_name)
+            constant_name = method_name.to_s.upcase
+            class_eval <<-EOCONSTANT, __FILE__, __LINE__ + 1
+              # This module and constant will be interpolated as follows:
+              # module Environment
+              #   CONSTANT_NAME = "CONSTANT_NAME"
+              # end
+              module Environment
+                 #{constant_name} = #{constant_name.inspect}
+              end
+            EOCONSTANT
+          end
+
+          def fetch_corresponding_environment_variable(
+            caller_method_name = caller_locations(1, 1).first.base_label
+          )
+            environment_variable_name = caller_method_name.upcase
+
+            value = ENV.fetch(environment_variable_name) do |name|
+              raise KeyError, "Missing #{name} environment variable!"
+            end
+
+            log.debug { "fetch_corresponding_environment_variable(#{environment_variable_name}) - #{value.inspect}" }
+
+            value
+          end
+
+          def corresponding_environment_variable_defined?(caller_method_name = caller_locations(1, 1).first.base_label)
+            environment_variable_name = caller_method_name.upcase
+
+            log.debug { "corresponding_environment_variable_defined?(#{environment_variable_name})" }
+
+            ENV.key?(environment_variable_name)
+          end
+
+          def instance_variable_name(method_name)
+            "@#{method_name}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jira/auto/tool/helpers/option_parser.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "jira/auto/tool"
+
+class OptionParser
+  def section_header(section_name)
+    header_name = "#{section_name}:"
+
+    on <<~EOSH
+
+      #{header_name}
+      #{header_name.gsub(/./, "-")}
+    EOSH
+  end
+end

data/lib/jira/auto/tool/helpers/overridable_time.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Jira
+  module Auto
+    class Tool
+      module Helpers
+        class OverridableTime
+          def self.now
+            overridden_date_time = ENV.fetch("JAT_CURRENT_DATE_TIME", nil)
+            log.debug { "JAT_CURRENT_DATE_TIME is set to #{overridden_date_time}" }
+
+            (overridden_date_time ? Time.parse(overridden_date_time) : Time.now)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jira/auto/tool/helpers/pagination.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Jira
+  module Auto
+    class Tool
+      module Helpers
+        module Pagination
+          PAGE_SIZE = 50
+
+          def self.fetch_all_object_pages(parameter_naming_convention = :camelCase)
+            all_objects = []
+            start_at = 0
+
+            loop do
+              pagination_options = build_pagination_options(parameter_naming_convention, PAGE_SIZE, start_at)
+
+              log.debug { "Fetching objects from Jira (#{pagination_options.inspect})..." }
+
+              fetched_objects = yield(pagination_options)
+
+              log.debug { "Fetched #{fetched_objects.size} object." }
+
+              all_objects.concat(fetched_objects)
+
+              start_at += PAGE_SIZE
+
+              break if fetched_objects.empty?
+            end
+
+            log.debug { all_objects.collect(&:name).join(", ") }
+
+            all_objects
+          end
+
+          def self.build_pagination_options(parameter_naming_convention, max_results, start_at)
+            PAGINATION_PARAMETER_STYLES
+              .fetch(parameter_naming_convention) { |k| "#{k.inspect}: not found in #{PAGINATION_PARAMETER_STYLES}" }
+              .zip([max_results, start_at])
+              .to_h
+          end
+
+          PAGINATION_PARAMETER_STYLES = {
+            camelCase: %i[maxResults startAt],
+            snake_case: %i[max_results start_at]
+          }.freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool"
+
+module Jira
+  module Auto
+    class Tool
+      module JiraHttpOptions
+        DISPLAY_HELP_OPTION = "--help"
+
+        def self.add(tool, parser)
+          parser.section_header "JIRA HTTP"
+          parser.on("--[no-]jira-http-debug", "Enable or disable HTTP debug mode") do |v|
+            tool.jira_http_debug = v
+          end
+        end
+      end
+    end
+  end
+end