jira-auto-tool 0.1.1

data/features/sprint_filtering.feature

@@ -0,0 +1,111 @@
+Feature: Sprint Filtering
+  In order to target specific sprints
+  As a user
+  I need the ability to filter sprints
+
+  Background:
+    Given a Jira Scrum board
+    And the board only has the following sprints:
+      | name                    | length | start_date              | state  |
+      | ART-16_CRM_24.4.1       | 2-week | 2024-12-01 11:00:00 UTC | closed |
+      | ART-16_E2E-Test_24.4.1  | 4-day  | 2024-12-01 11:00:00 UTC | future |
+      | ART-32_Sys-Team_24.4.12 | 1-week | 2024-12-24 11:00:00 UTC | future |
+      | ART-32_Sys-Team_25.1.1  | 1-week | 2025-01-07 11:00:00 UTC | future |
+      | ART-16_E2E-Test_24.4.2  | 4-day  | 2024-12-05 11:00:00 UTC | future |
+      | ART-32_Platform_24.4.7  | 3-week | 2024-10-07 11:00:00 UTC | future |
+
+
+  Scenario: No filter applied except ignoring closed sprints
+    When I successfully run `jira-auto-tool --sprint-list`
+    Then the output should match:
+      """
+      \+-------+--\+
+      \|                                                                         \s+   Matching Sprints                                                                     \s+                       \|
+      \+-------\+-------------------------\+----------------\+-------------------------\+-------------------------\+-----------------------\+---------------------------------+--\+-------------------\+
+      \| Id    \| Name                    \| Length In Days \| Start Date              \| End Date                \| Board Name            \| Board UI URL                  \s+  \| Board Project Key \|
+      \+-------\+-------------------------\+----------------\+-------------------------\+-------------------------\+-----------------------\+---------------------------------+--\+-------------------\+
+      """
+    And the output should match:
+      """
+      .+-------------------------.+
+      .+ Name                    .+
+      .+-------------------------.+
+      .+ ART-32_Platform_24.4.7  .+
+      .+ ART-16_E2E-Test_24.4.1  .+
+      .+ ART-16_E2E-Test_24.4.2  .+
+      .+ ART-32_Sys-Team_24.4.12 .+
+      .+ ART-32_Sys-Team_25.1.1  .+
+      .+-------------------------.+
+      """
+
+  Scenario: No filtering (except closed sprints) and excluding the corresponding board information
+    When I successfully run `jira-auto-tool --sprint-list-without-board-info`
+    Then the stdout should contain:
+      """
+      +------------------------------------------------------------------------------------------------------+
+      |                                           Matching Sprints                                           |
+      +-------+-------------------------+----------------+-------------------------+-------------------------+
+      | Id    | Name                    | Length In Days | Start Date              | End Date                |
+      +-------+-------------------------+----------------+-------------------------+-------------------------+
+      """
+    And the output should match:
+      """
+      .+-------------------------.+
+      .+ Name                    .+
+      .+-------------------------.+
+      .+ ART-32_Platform_24.4.7  .+
+      .+ ART-16_E2E-Test_24.4.1  .+
+      .+ ART-16_E2E-Test_24.4.2  .+
+      .+ ART-32_Sys-Team_24.4.12 .+
+      .+ ART-32_Sys-Team_25.1.1  .+
+      .+-------------------------.+
+      """
+
+  Scenario: Filter sprints with a string
+    Given the following environment variables are set:
+      | name             | value  |
+      | ART_SPRINT_REGEX | ART-16 |
+    When I successfully run `jira-auto-tool --sprint-list`
+    Then the output should match:
+      """
+      \+---------+------------\+
+      \|                                                                       \s+   Matching Sprints                                                                \s+                       \|
+      \+-------\+---------+--------\+----------------\+-------------------------\+-------------------------\+-----------------------\+---------------------------------+--\+-------------------\+
+      \| Id    \| Name  \s+        \| Length In Days \| Start Date              \| End Date                \| Board Name            \| Board UI URL                  \s+  \| Board Project Key \|
+      \+-------\+---------+--------\+----------------\+-------------------------\+-------------------------\+-----------------------\+---------------------------------+--\+-------------------\+
+      """
+    And the output should match:
+      """
+      .*------------------------.*
+      .*                        .*
+      .*------------------------.*
+      .* Name                   .*
+      .*------------------------.*
+      .* ART-16_E2E-Test_24.4.1 .*
+      .* ART-16_E2E-Test_24.4.2 .*
+      .*------------------------.*
+      """
+
+  Scenario: Filter sprints with a regular expression
+    Given the following environment variables are set:
+      | name             | value             |
+      | ART_SPRINT_REGEX | Platform\|(4\.1)$ |
+    When I successfully run `jira-auto-tool --sprint-list`
+    Then the output should match:
+      """
+      \+-----------+------\+
+      \|                                                                      \s+   Matching Sprints                                                                \s+                       \|
+      \+-------\+---------+-------\+----------------\+-------------------------\+-------------------------\+-----------------------\+---------------------------------+--\+-------------------\+
+      \| Id    \| Name  \s+       \| Length In Days \| Start Date              \| End Date                \| Board Name            \| Board UI URL                  \s+  \| Board Project Key \|
+      \+-------\+---------+-------\+----------------\+-------------------------\+-------------------------\+-----------------------\+---------------------------------+--\+-------------------\+
+      """
+    And the output should match:
+      """
+      .+------------------------.+
+      .+ Name                   .+
+      .+------------------------.+
+      .+ ART-32_Platform_24.4.7 .+
+      .+ ART-16_E2E-Test_24.4.1 .+
+      .+------------------------.+
+      """
+

data/features/step_definitions/execution_context_steps.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+Given("the current date time is {string}") do |current_date_time|
+  set_environment_variable("JAT_CURRENT_DATE_TIME", current_date_time)
+end
+
+Given(/^the following environment variables are set:$/) do |table|
+  table.hashes.each do |env_var|
+    name = env_var.fetch("name")
+    value = env_var.fetch("value")
+    @jira_auto_tool.send("#{name.downcase}=", value)
+    set_environment_variable(name, value)
+  end
+end
+
+BUFFER_TIME_IN_SECONDS = 10
+Then(/^successfully running `(.*)` takes between (.*) and (.*) seconds$/) do |command_line, minimal_time, maximal_time|
+  start_time = Time.now
+
+  run_command_and_stop(command_line, fail_on_error: true, timeout: maximal_time.to_i + BUFFER_TIME_IN_SECONDS)
+
+  end_time = Time.now
+
+  expect(end_time - start_time).to be_between(minimal_time.to_i, maximal_time.to_i)
+end
+
+Given(/^I wait for over a day$/) do
+  in_over_a_day = (Time.now + 1.day + 2.minute).to_s
+
+  log.debug { "Waiting until #{in_over_a_day}" }
+
+  set_environment_variable("JAT_CURRENT_DATE_TIME", in_over_a_day)
+end

data/features/step_definitions/jira_board_steps.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "time"
+
+Given(/^a Jira Scrum board$/) do
+  expect(@board).not_to be_nil
+end
+
+Given(/^the board has no sprint$/) do
+  expect(@board.jira_board.sprints).to be_empty
+end
+
+Given(/^the board has only closed sprints$/) do
+  4.times do |sprint_index|
+    @jira_auto_tool.create_sprint(name: "sprint_24.1.#{sprint_index}", state: "closed",
+                                  start_date: Time.now + sprint_index.days, length_in_days: 14)
+  end
+end
+
+DAYS_IN_A_WEEK = 7
+
+def parse_length_in_days(length_string)
+  case length_string
+  when /(\d+)-week/
+    Regexp.last_match(1).to_i * DAYS_IN_A_WEEK
+  when /(\d+)-day/
+    Regexp.last_match(1).to_i
+  else
+    raise "#{length_string} is not an expected sprint length"
+  end
+end
+
+Given(/^an unclosed (.+) sprint named (.+) starting on (.+)$/) do |sprint_length, sprint_name, start_date_time|
+  @jira_auto_tool.create_sprint({ name: sprint_name, start_date: start_date_time,
+                                  length_in_days: parse_length_in_days(sprint_length), state: "future" })
+end
+
+Then(/^a sprint named (.*) should exist$/) do |expected_name|
+  unclosed_sprints = @jira_auto_tool.sprint_controller.unclosed_sprints
+  expect(unclosed_sprints.collect(&:name)).to include(expected_name)
+  @actual_sprint = unclosed_sprints.find { |sprint| sprint.name == expected_name }
+end
+
+And(/^it starts on (.*)$/) do |expected_start|
+  expect(@actual_sprint.start_date).to eq(Time.parse(expected_start).utc)
+end
+
+And(/^it ends on (.*)$/) do |expected_end|
+  expect(@actual_sprint.end_date).to eq(Time.parse(expected_end).utc)
+end
+
+And(/^its state is (.*)$/) do |expected_state|
+  expect(@actual_sprint.state).to eq(expected_state)
+end
+
+Given(/^the board only has the following sprints:$/) do |table|
+  table_value_keys = table.raw.first
+
+  table.hashes.each do |sprint_hash|
+    attributes = {}
+
+    table_value_keys.each do |key|
+      value = sprint_hash[key]
+
+      case key.intern
+      when :length
+        attributes[:length_in_days] = parse_length_in_days(value)
+      when :expecting_added_sprint, :comment
+        next
+      else
+        attributes[key.intern] = value
+      end
+    end
+
+    @jira_auto_tool.create_sprint(attributes)
+  end
+end
+
+Then(/^afterwards the board only has the following sprints:$/) do |table|
+  expected_value_keys = table.raw.first
+
+  expected_sprints = table.hashes.collect(&:values).collect(&:flatten)
+
+  actual_sprints = @jira_auto_tool.sprint_controller.sprints.collect do |sprint|
+    expected_value_keys.collect do |key|
+      unavailable_date = key =~ /date/ && !sprint.send("#{key}?")
+
+      value = unavailable_date ? "" : sprint.send(key)
+
+      value.is_a?(Time) ? value.utc.to_s : value
+    end
+  end
+
+  expect(actual_sprints).to contain_exactly(*expected_sprints)
+end
+
+Then(/^the output contains (no )?requests that enumerate the list of boards$/) do |contains_or_not|
+  contains_predicate = contains_or_not.nil? || contains_or_not.empty? ? :to : :not_to
+
+  board_enumeration_pattern = /#{Regexp.escape("get: /rest/agile/1.0/board - []")}/
+  expect(last_command_started.output).send(contains_predicate, match(board_enumeration_pattern))
+end

data/features/step_definitions/jira_ticket_steps.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+And(/^tickets on the board have an expected date field named "([^"]*)"$/) do |date_field_name|
+  @date_field = @jira_auto_tool.expected_start_date_field(date_field_name)
+
+  expect(@date_field).not_to be_nil
+end
+
+And(/^tickets on the board have a team field named "([^"]*)" with exactly those values:$/) do
+|team_field_name, field_values|
+
+  expected_field_values = field_values.hashes.collect { |hashes| hashes["values"] }
+
+  @team_field = @jira_auto_tool.implementation_team_field(team_field_name)
+
+  expect(@team_field.values.collect(&:value)).to eq(expected_field_values)
+end
+
+Given(/^the following tickets exist:$/) do |ticket_table|
+  # Summary | Description | Implementation Team | Expected Start |
+  # table is a table.hashes.keys # => [:summary, :team, :expected_start]
+  ticket_table.hashes.each do |ticket_info|
+    log.debug { ticket_info.inspect }
+
+    jira_ticket = @jira_auto_tool.jira_client.Issue.build
+
+    jira_ticket.save!({ fields: {
+                        project: { key: @jira_auto_tool.board.project_key },
+                        summary: ticket_info[:summary],
+                        description: ticket_info[:description],
+                        issuetype: { name: "Task" },
+                        @jira_auto_tool.implementation_team_field.id.intern =>
+                     { "value" => ticket_info[:implementation_team] },
+                        @jira_auto_tool.expected_start_date_field.id.intern => ticket_info[:expected_start_date]
+                      } })
+
+    log.debug { "created jira ticket: #{jira_ticket.key}" }
+  end
+end
+
+Then(/^the tickets should have been assigned to sprints as follows:$/) do |ticket_expectation_table|
+  # table is a table.hashes.keys # => [:summary, :sprint]
+  ticket_expectations =
+    ticket_expectation_table.hashes.collect { |expectation| [expectation[:summary], expectation[:sprint]] }
+
+  actual_ticket_values = @jira_auto_tool.tickets.collect do |ticket|
+    sprint = ticket.sprint
+
+    log.debug { "ticket: #{ticket.summary} sprint: #{sprint.inspect}" }
+
+    [ticket.summary, sprint&.first&.fetch("name") || ""]
+  end
+
+  expect(actual_ticket_values.sort).to eq(ticket_expectations.sort)
+end
+
+Given(/^a Jira project$/) do
+  @project = @jira_auto_tool.project
+end
+
+And(/^JAT_TICKETS_FOR_TEAM_SPRINT_TICKET_DISPATCHER_JQL has been defined as an environment variable$/) do
+  expect(ENV).to have_key("JAT_TICKETS_FOR_TEAM_SPRINT_TICKET_DISPATCHER_JQL")
+end

data/features/support/10.setup_cucumber.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "aruba/cucumber"
+
+Aruba.configure do |config|
+  config.exit_timeout = 300 # seconds
+
+  config.activate_announcer_on_command_failure = %i[command stdout stderr]
+  config.log_level = :debug
+end

data/features/support/env.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module JiraSprintToolWorld
+  def log
+    @log ||= Logging.logger[self]
+  end
+
+  def remove_existing_sprints(jira_auto_tool)
+    sprints = jira_auto_tool.sprint_controller.sprints
+
+    log.debug { "Removing sprints #sprints = #{sprints.size}: #{sprints.map(&:name).join(", ")}" }
+
+    sprints.each(&:delete)
+  end
+
+  def remove_existing_board_tickets(jira_auto_tool)
+    tickets = jira_auto_tool.jira_client.Issue.jql("project = #{jira_auto_tool.board.project_key}")
+
+    log.debug { "Removing tickets from board #{jira_auto_tool.board.name}:  #tickets = #{tickets.size}" }
+
+    tickets.each(&:delete)
+  end
+end
+
+World(JiraSprintToolWorld)

data/features/support/hooks.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "jira-ruby"
+
+require "jira/auto/tool"
+
+def ensure_the_aruba_sandbox_is_active
+  setup_aruba
+  ENV["HOME"] = expand_path(".")
+  cd(".")
+
+  expect(Dir.home).to eq(expand_path("."))
+end
+
+Before do
+  ensure_the_aruba_sandbox_is_active
+
+  @jira_auto_tool = Jira::Auto::Tool.new
+  @jira_client = @jira_auto_tool.jira_client
+  @board = @jira_auto_tool.board
+
+  remove_existing_sprints(@jira_auto_tool)
+  remove_existing_board_tickets(@jira_auto_tool)
+  Jira::Auto::Tool::Board::Cache.new(@jira_auto_tool).clear
+end

data/features/support/setup_rspec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "rspec"
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+    expectations.max_formatted_output_length = nil
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+end

data/features/support/setup_simplecov.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "simplecov"
+
+SimpleCov.start

data/features/update_sprint_end_date_and_shift_following_ones.feature

@@ -0,0 +1,52 @@
+Feature: Rename sprints
+  In order to adjust the end date of a sprint to cope with specific periods like year end
+  As a team member
+  I need the ability to update the end date of a sprint and shift the following sprints
+
+  Background:
+    Given a Jira Scrum board
+
+  Scenario: Adjust the end of a sprint and shift the following ones so there are no gaps
+    Given the board only has the following sprints:
+      | comment       | name                   | length | start_date              | state  |
+      | "no           | Food_Supply_25.1.2     | 2-week | 2025-01-07 11:00:00 UTC | closed |
+      | change        | Food_Supply_25.1.3     | 2-week | 2025-01-21 11:00:00 UTC | closed |
+      | since         | Food_Supply_25.1.4     | 2-week | 2025-02-04 11:00:00 UTC | closed |
+      | closed"       | Food_Supply_25.1.5     | 2-week | 2025-02-18 11:00:00 UTC | closed |
+      |               | Food_Delivery_25.1.2   | 2-week | 2025-01-07 11:00:00 UTC | future |
+      |               | Food_Delivery_25.1.3   | 2-week | 2025-01-21 11:00:00 UTC | future |
+      |               | Food_Delivery_25.1.4   | 2-week | 2025-02-04 11:00:00 UTC | future |
+      | new end date  | Food_Delivery_25.1.5   | 2-week | 2025-02-18 11:00:00 UTC | future |
+      | shifted       | Food_Delivery_25.2.1   | 2-week | 2025-03-04 11:00:00 UTC | future |
+      | idem          | Food_Delivery_25.2.2   | 2-week | 2025-03-18 11:00:00 UTC | future |
+      | idem          | Food_Delivery_25.2.3   | 2-week | 2025-04-01 11:00:00 UTC | future |
+      | idem          | Food_Delivery_25.2.4   | 2-week | 2025-04-15 11:00:00 UTC | future |
+      | idem          | Food_Delivery_25.2.5   | 2-week | 2025-04-29 11:00:00 UTC | future |
+      |               | Food_Restaurant_24.4.1 | 4-day  | 2025-01-07 11:00:00 UTC | future |
+      | "last two     | Food_Restaurant_25.1.5 | 4-day  | 2025-01-18 11:00:00 UTC | future |
+      | updated"      | Food_Restaurant_25.2.1 | 4-day  | 2025-04-01 11:00:00 UTC | future |
+      | "no update    | Food_Market_25.2.5     | 4-day  | 2025-06-14 11:00:00 UTC | future |
+      | since         | Food_Market_25.3.1     | 4-day  | 2025-07-07 11:00:00 UTC | future |
+      | not matching" | Food_Market_25.3.2     | 4-day  | 2025-07-21 11:00:00 UTC | future |
+    When I successfully run `jira-auto-tool --sprint-update-end-date=25.1.5,"2025-02-25 16:00:00 UTC"`
+    Then afterwards the board only has the following sprints:
+      | name                   | start_date              | end_date                | state  |
+      | Food_Supply_25.1.2     | 2025-01-07 11:00:00 UTC | 2025-01-21 11:00:00 UTC | closed |
+      | Food_Supply_25.1.3     | 2025-01-21 11:00:00 UTC | 2025-02-04 11:00:00 UTC | closed |
+      | Food_Supply_25.1.4     | 2025-02-04 11:00:00 UTC | 2025-02-18 11:00:00 UTC | closed |
+      | Food_Supply_25.1.5     | 2025-02-18 11:00:00 UTC | 2025-03-04 11:00:00 UTC | closed |
+      | Food_Delivery_25.1.2   | 2025-01-07 11:00:00 UTC | 2025-01-21 11:00:00 UTC | future |
+      | Food_Delivery_25.1.3   | 2025-01-21 11:00:00 UTC | 2025-02-04 11:00:00 UTC | future |
+      | Food_Delivery_25.1.4   | 2025-02-04 11:00:00 UTC | 2025-02-18 11:00:00 UTC | future |
+      | Food_Delivery_25.1.5   | 2025-02-18 11:00:00 UTC | 2025-02-25 16:00:00 UTC | future |
+      | Food_Delivery_25.2.1   | 2025-02-25 16:00:00 UTC | 2025-03-11 16:00:00 UTC | future |
+      | Food_Delivery_25.2.2   | 2025-03-11 16:00:00 UTC | 2025-03-25 16:00:00 UTC | future |
+      | Food_Delivery_25.2.3   | 2025-03-25 16:00:00 UTC | 2025-04-08 16:00:00 UTC | future |
+      | Food_Delivery_25.2.4   | 2025-04-08 16:00:00 UTC | 2025-04-22 16:00:00 UTC | future |
+      | Food_Delivery_25.2.5   | 2025-04-22 16:00:00 UTC | 2025-05-06 16:00:00 UTC | future |
+      | Food_Restaurant_24.4.1 | 2025-01-07 11:00:00 UTC | 2025-01-11 11:00:00 UTC | future |
+      | Food_Restaurant_25.1.5 | 2025-01-18 11:00:00 UTC | 2025-02-25 16:00:00 UTC | future |
+      | Food_Restaurant_25.2.1 | 2025-02-25 16:00:00 UTC | 2025-03-01 16:00:00 UTC | future |
+      | Food_Market_25.2.5     | 2025-06-14 11:00:00 UTC | 2025-06-18 11:00:00 UTC | future |
+      | Food_Market_25.3.1     | 2025-07-07 11:00:00 UTC | 2025-07-11 11:00:00 UTC | future |
+      | Food_Market_25.3.2     | 2025-07-21 11:00:00 UTC | 2025-07-25 11:00:00 UTC | future |

data/lib/jira/auto/tool/board/cache.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+require "jira/auto/tool/helpers/overridable_time"
+
+module Jira
+  module Auto
+    class Tool
+      class Board
+        class Cache
+          attr_reader :tool
+
+          def initialize(tool)
+            @tool = tool
+          end
+
+          def boards
+            raise "This method should not be used since the cache is invalid" unless valid?
+
+            @boards ||= raw_content.fetch("boards").collect do |board_info|
+              Board.new(tool, tool.jira_client.Board.build(board_info))
+            end
+          end
+
+          def save(boards)
+            File.write(file_path, { "boards" => boards.collect { |board| board.jira_board.attrs } }.to_yaml)
+
+            boards
+          end
+
+          def clear
+            FileUtils.rm_f(file_path)
+          end
+
+          def valid?
+            File.exist?(file_path) && !expired?
+          end
+
+          private
+
+          def expired?
+            log.debug { "expired? #{cached_at} < #{one_day_ago}" }
+
+            cached_at < one_day_ago
+          end
+
+          def one_day_ago
+            Helpers::OverridableTime.now - 1.day
+          end
+
+          def cached_at
+            File.mtime(file_path)
+          end
+
+          def raw_content
+            YAML.safe_load_file(file_path) || {}
+          end
+
+          def file_path
+            File.join(tool.config.dir, "jira-auto-tool.cache.yml")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jira/auto/tool/board/unavailable_board.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Jira
+  module Auto
+    class Tool
+      class Board
+        class UnavailableBoard < Board
+          include Comparable
+
+          attr_reader :id
+
+          def initialize(tool, id)
+            super(tool, JIRA::Resource::Board.new(id: id))
+            @id = id
+          end
+
+          def name
+            "N/A"
+          end
+
+          def url
+            "N/A"
+          end
+
+          def ui_url
+            "N/A"
+          end
+
+          def <=>(other)
+            id <=> other.id
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool/board/unavailable_board"
+
+module Jira
+  module Auto
+    class Tool
+      class Board
+        include Comparable
+
+        attr_reader :tool, :jira_board
+
+        def self.find_by_id(tool, id)
+          cached_boards[id] ||=
+            begin
+              new(tool, JIRA::Resource::Board.find(tool.jira_client, id))
+            rescue JIRA::HTTPError => e
+              if e.code.to_i == 404
+                UnavailableBoard.new(tool, id)
+              else
+                raise e.class,
+                      "#{e.class}: code = #{e.code.inspect}: #{self.class}.find_by_id(tool, #{id.inspect}): " \
+                      "#{e.message}"
+              end
+            end
+        end
+
+        def self.cached_boards
+          @cached_boards ||= {}
+        end
+
+        def initialize(tool, jira_board)
+          @tool = tool
+          @jira_board = jira_board
+        end
+
+        def id
+          jira_board.id
+        end
+
+        def unavailable?
+          instance_of?(UnavailableBoard)
+        end
+
+        def <=>(other)
+          id <=> other.id
+        end
+
+        def name
+          jira_board.name
+        end
+
+        def self.to_table_row_field_names
+          %i[name ui_url project_key]
+        end
+
+        ActiveSupport::Inflector.inflections(:en) do |inflect|
+          inflect.acronym "UI"
+          inflect.acronym "URL"
+        end
+
+        def self.to_table_row_header
+          to_table_row_field_names.collect { |field| field.to_s.titleize }
+        end
+
+        def to_table_row
+          self.class.to_table_row_field_names.collect { |field| send(field) }
+        end
+
+        PROJECT_INFORMATION_NOT_AVAILABLE = "N/A"
+
+        def project_key
+          if with_project_information?
+            jira_board.location.fetch("projectKey")
+          else
+            PROJECT_INFORMATION_NOT_AVAILABLE
+          end
+        end
+
+        def with_project_information?
+          jira_board.respond_to?(:location)
+        end
+
+        def sprint_compatible?
+          jira_board.type =~ /^(scrum)$/
+        end
+
+        def url
+          jira_board.url
+        end
+
+        def ui_url
+          request_path =
+            if with_project_information?
+              "/jira/software/c/projects/#{project_key}/boards/#{id}"
+            else
+              "/secure/RapidBoard.jspa?rapidView=#{id}"
+            end
+
+          tool.jira_url(request_path)
+        end
+      end
+    end
+  end
+end