jirametrics 2.5 → 2.30

data/lib/jirametrics/issue.rb

@@ -3,19 +3,27 @@
 require 'time'
 
 class Issue
-  attr_reader :changes, :raw, :subtasks, :board
-  attr_accessor :parent
+  attr_reader :changes, :raw, :subtasks, :board, :discarded_changes, :discarded_change_times
+  attr_accessor :parent, :github_prs
 
   def initialize raw:, board:, timezone_offset: '+00:00'
     @raw = raw
     @timezone_offset = timezone_offset
     @subtasks = []
     @changes = []
+    @github_prs = []
     @board = board
 
-    return unless @raw['changelog']
+    # We only check for this here because if a board isn't passed in then things will fail much
+    # later and be hard to find. Let's find out early.
+    raise "No board for issue #{key}" if board.nil?
 
-    load_history_into_changes
+    # There are cases where we create an Issue of fragments like linked issues and those won't have
+    # changelogs.
+    load_history_into_changes if @raw['changelog']
+
+    # As above with fragments, there may not be a fields section
+    return unless @raw['fields']
 
     # If this is an older pull of data then comments may not be there.
     load_comments_into_changes if @raw['fields']['comment']
@@ -38,12 +46,12 @@ class Issue
   def key = @raw['key']
 
   def type = @raw['fields']['issuetype']['name']
-
   def type_icon_url = @raw['fields']['issuetype']['iconUrl']
 
-  def summary = @raw['fields']['summary']
+  def priority_name = @raw.dig('fields', 'priority', 'name')
+  def priority_url = @raw.dig('fields', 'priority', 'iconUrl')
 
-  def status = Status.new(raw: @raw['fields']['status'])
+  def summary = @raw['fields']['summary']
 
   def labels = @raw['fields']['labels'] || []
 
@@ -51,6 +59,20 @@ class Issue
 
   def resolution = @raw['fields']['resolution']&.[]('name')
 
+  def status
+    @status = Status.from_raw(@raw['fields']['status']) unless @status
+    @status
+  end
+
+  def status= status
+    @status = status
+  end
+
+  def due_date
+    text = @raw['fields']['duedate']
+    text.nil? ? nil : Date.parse(text)
+  end
+
   def url
     # Strangely, the URL isn't anywhere in the returned data so we have to fabricate it.
     "#{@board.server_url_prefix}/browse/#{key}"
@@ -65,35 +87,43 @@ class Issue
   end
 
   def first_time_in_status *status_names
-    @changes.find { |change| change.current_status_matches(*status_names) }&.time
+    @changes.find { |change| change.current_status_matches(*status_names) }
   end
 
   def first_time_not_in_status *status_names
-    @changes.find { |change| change.status? && status_names.include?(change.value) == false }&.time
+    @changes.find { |change| change.status? && status_names.include?(change.value) == false }
   end
 
   def first_time_in_or_right_of_column column_name
     first_time_in_status(*board.status_ids_in_or_right_of_column(column_name))
   end
 
+  def first_time_label_added *labels
+    @changes.each do |change|
+      next unless change.labels?
+
+      change_labels = change.value.split
+      return change if change_labels.any? { |l| labels.include?(l) }
+    end
+    nil
+  end
+
   def still_in_or_right_of_column column_name
     still_in_status(*board.status_ids_in_or_right_of_column(column_name))
   end
 
   def still_in
-    time = nil
-    @changes.each do |change|
-      next unless change.status?
-
+    result = nil
+    status_changes.each do |change|
       current_status_matched = yield change
 
-      if current_status_matched && time.nil?
-        time = change.time
-      elsif !current_status_matched && time
-        time = nil
+      if current_status_matched && result.nil?
+        result = change
+      elsif !current_status_matched && result
+        result = nil
       end
     end
-    time
+    result
   end
   private :still_in
 
@@ -106,56 +136,205 @@ class Issue
 
   # If it ever entered one of these categories and it's still there then what was the last time it entered
   def still_in_status_category *category_names
+    category_ids = find_status_category_ids_by_names category_names
+
     still_in do |change|
-      status = find_status_by_name change.value
-      category_names.include?(status.category_name) || category_names.include?(status.category_id)
+      status = find_or_create_status id: change.value_id, name: change.value
+      category_ids.include? status.category.id
     end
   end
 
   def most_recent_status_change
-    changes.reverse.find { |change| change.status? }
+    # Any issue that we loaded from its own file will always have a status as we artificially insert a status
+    # change to represent creation. Issues that were just fragments referenced from a main issue (ie a linked issue)
+    # may not have any status changes as we have no idea when it was created. This will be nil in that case
+    status_changes.last
   end
 
-  # Are we currently in this status? If yes, then return the time of the most recent status change.
+  # Are we currently in this status? If yes, then return the most recent status change.
   def currently_in_status *status_names
     change = most_recent_status_change
-    return false if change.nil?
+    return nil if change.nil?
 
-    change.time if change.current_status_matches(*status_names)
+    change if change.current_status_matches(*status_names)
   end
 
-  # Are we currently in this status category? If yes, then return the time of the most recent status change.
+  # Are we currently in this status category? If yes, then return the most recent status change.
   def currently_in_status_category *category_names
+    category_ids = find_status_category_ids_by_names category_names
+
     change = most_recent_status_change
-    return false if change.nil?
+    return nil if change.nil?
 
-    status = find_status_by_name change.value
-    change.time if status && category_names.include?(status.category_name)
+    status = find_or_create_status id: change.value_id, name: change.value
+    change if status && category_ids.include?(status.category.id)
   end
 
-  def find_status_by_name name
-    status = board.possible_statuses.find_by_name(name)
-    return status if status
+  def find_or_create_status id:, name:
+    status = board.possible_statuses.find_by_id(id)
 
-    raise "Status name #{name.inspect} for issue #{key} not found in #{board.possible_statuses.collect(&:name).inspect}"
+    unless status
+      # Have to pull this list before the call to fabricate or else the warning will incorrectly
+      # list this status as one it actually found
+      found_statuses = board.possible_statuses.to_s
+
+      status = board.possible_statuses.fabricate_status_for id: id, name: name
+
+      message = +'The history for issue '
+      message << key
+      message << ' references the status ('
+      message << "#{name.inspect}:#{id.inspect}"
+      message << ') that can\'t be found. We are guessing that this belongs to the '
+      message << status.category.to_s
+      message << ' status category but that may be wrong. See https://jirametrics.org/faq/#q1 for more '
+      message << 'details on defining statuses.'
+      board.project_config.file_system.warning message, more: "The statuses we did find are: #{found_statuses}"
+    end
+
+    status
   end
 
   def first_status_change_after_created
-    @changes.find { |change| change.status? && change.artificial? == false }&.time
+    status_changes.find { |change| change.artificial? == false }
   end
 
   def first_time_in_status_category *category_names
-    @changes.each do |change|
-      next unless change.status?
+    category_ids = find_status_category_ids_by_names category_names
 
-      category = find_status_by_name(change.value).category_name
-      return change.time if category_names.include? category
+    status_changes.each do |change|
+      to_status = find_or_create_status(id: change.value_id, name: change.value)
+      id = to_status.category.id
+      return change if category_ids.include? id
     end
     nil
   end
 
+  def first_time_visible_on_board
+    visible_status_ids = board.visible_columns.collect(&:status_ids).flatten
+    return first_time_in_status(*visible_status_ids) unless board.scrum?
+
+    # For scrum boards, an issue is only visible when BOTH conditions are true simultaneously:
+    # 1. Its status is in a visible column
+    # 2. It is in an active sprint
+    # At each moment one condition becomes true, check if the other is already true.
+    candidates = []
+
+    status_changes.each do |change|
+      next unless visible_status_ids.include?(change.value_id)
+      candidates << change if in_active_sprint_at?(change.time)
+    end
+
+    sprint_entry_events.each do |effective_time, representative_change|
+      candidates << representative_change if in_visible_status_at?(effective_time, visible_status_ids)
+    end
+
+    candidates.min_by(&:time)
+  end
+
+  def reasons_not_visible_on_board
+    reasons = []
+    reasons << 'Not in an active sprint' if board.scrum? && sprints.none?(&:active?)
+    unless board.visible_columns.any? { |c| c.status_ids.include?(status.id) }
+      reasons << 'Status is not configured for any visible column on the board'
+    end
+    reasons
+  end
+
+  def visible_on_board?
+    reasons_not_visible_on_board.empty?
+  end
+
+  # If this issue will ever be in an active sprint then return the time that it
+  # was first added to that sprint, whether or not the sprint was active at that
+  # time. Although it seems like an odd thing to calculate, it's a reasonable proxy
+  # for 'ready' in cases where the team doesn't have an explicit 'ready' status.
+  # You'd be better off with an explicit 'ready' but sometimes that's not an option.
+  def first_time_added_to_active_sprint
+    unless board.scrum?
+      raise 'first_time_added_to_active_sprint() can only be used with Scrum boards: ' \
+          "issue=#{key}, board=#{board.inspect}"
+    end
+    data_clazz = Struct.new(:sprint_id, :sprint_start, :sprint_stop, :change)
+
+    matching_changes = []
+    all_datas = []
+
+    @changes.each do |change|
+      next unless change.sprint?
+
+      added_sprint_ids = change.value_id - change.old_value_id
+      added_sprint_ids.each do |id|
+        data = data_clazz.new
+        data.sprint_id = id
+        data.change = change
+        data.sprint_start, data.sprint_stop = find_sprint_start_end(sprint_id: id, change: change)
+        all_datas << data
+      end
+
+      removed_sprint_ids = change.old_value_id - change.value_id
+      removed_sprint_ids.each do |id|
+        data = all_datas.find { |d| d.sprint_id == id }
+        # It's possible for an issue to be created inside a sprint and therefore for
+        # that add-to-sprint not show in the history.
+        next unless data
+
+        all_datas.delete(data)
+        next if data.sprint_start.nil? || data.sprint_start >= change.time
+
+        matching_changes << data.change
+      end
+    end
+
+    # There can't be any more removes so whatever is left is a valid option
+    # Now all we care about is if the sprint has started.
+    all_datas.each do |data|
+      matching_changes << data.change if data.sprint_start
+    end
+
+    matching_changes.min_by(&:time)
+  end
+
+  def find_sprint_start_end sprint_id:, change:
+    # There are two different places that sprint data could be found. In theory all
+    # sprints would be found in both places. In practice, sometimes what we need is
+    # in one or the other but not both.
+
+    # First look in the actual sprints json. If any issues are in this sprint then it should
+    # be here.
+    sprint = board.sprints.find { |s| s.id == sprint_id }
+    if sprint
+      return [nil, nil] if sprint.future?
+
+      return [sprint.start_time, sprint.completed_time]
+    end
+
+    # Then look at the sprints inside the issue. Even though the field id may be specified,
+    # that custom field may not be present. This happens if it was in that sprint but was
+    # then removed, whether or not that sprint had ever started.
+    sprint_data = raw['fields'][change.field_id]&.find { |sd| sd['id'].to_i == sprint_id }
+    if sprint_data
+      return [nil, nil] if sprint_data['state'] == 'future'
+
+      start = parse_time(sprint_data['startDate'])
+      stop = parse_time(sprint_data['completeDate'])
+      return [start, stop]
+    end
+
+    # If we got this far then the sprint can't be found anywhere, so we pretend that it never
+    # started. Is this guaranteed to be true? No. In theory if all issues were removed from
+    # an active sprint then it would also disappear, even though it had started. Nothing we
+    # can do to detect that edge-case though.
+    [nil, nil]
+  end
+
   def parse_time text
-    Time.parse(text).getlocal(@timezone_offset)
+    if text.nil?
+      nil
+    elsif text.is_a? String
+      Time.parse(text).getlocal(@timezone_offset)
+    else
+      Time.at(text / 1000).getlocal(@timezone_offset)
+    end
   end
 
   def created
@@ -163,20 +342,28 @@ class Issue
     parse_time @raw['fields']['created'] if @raw['fields']['created']
   end
 
+  def time_created
+    @changes.first
+  end
+
   def updated
     parse_time @raw['fields']['updated']
   end
 
   def first_resolution
-    @changes.find { |change| change.resolution? }&.time
+    @changes.find { |change| change.resolution? }
   end
 
   def last_resolution
-    @changes.reverse.find { |change| change.resolution? }&.time
+    @changes.reverse.find { |change| change.resolution? }
   end
 
   def assigned_to
-    @raw['fields']&.[]('assignee')&.[]('displayName')
+    @raw['fields']['assignee']&.[]('displayName')
+  end
+
+  def assigned_to_icon_url
+    @raw['fields']['assignee']&.[]('avatarUrls')&.[]('16x16')
   end
 
   # Many test failures are simply unreadable because the default inspect on this class goes
@@ -244,13 +431,10 @@ class Issue
 
     blocked_statuses = settings['blocked_statuses']
     stalled_statuses = settings['stalled_statuses']
-    unless blocked_statuses.is_a?(Array) && stalled_statuses.is_a?(Array)
-      raise "blocked_statuses(#{blocked_statuses.inspect}) and " \
-        "stalled_statuses(#{stalled_statuses.inspect}) must both be arrays"
-    end
 
     blocked_link_texts = settings['blocked_link_text']
     stalled_threshold = settings['stalled_threshold_days']
+    flagged_means_blocked = !!settings['flagged_means_blocked'] # rubocop:disable Style/DoubleNegation
 
     blocking_issue_keys = []
 
@@ -259,11 +443,13 @@ class Issue
     previous_change_time = created
 
     blocking_status = nil
+    blocking_is_blocked = false
     flag = nil
+    flag_reason = nil
 
     # This mock change is to force the writing of one last entry at the end of the time range.
     # By doing this, we're able to eliminate a lot of duplicated code in charts.
-    mock_change = ChangeItem.new time: end_time, author: '', artificial: true, raw: { 'field' => '' }
+    mock_change = ChangeItem.new time: end_time, artificial: true, raw: { 'field' => '' }, author_raw: nil
 
     (changes + [mock_change]).each do |change|
       previous_was_active = false if check_for_stalled(
@@ -273,17 +459,20 @@ class Issue
         blocking_stalled_changes: result
       )
 
-      if change.flagged?
-        flag = change.value
-        flag = nil if change.value == ''
+      if change.flagged? && flagged_means_blocked
+        flag, flag_reason = blocked_stalled_changes_flag_logic change
       elsif change.status?
         blocking_status = nil
-        if blocked_statuses.include?(change.value) || stalled_statuses.include?(change.value)
+        blocking_is_blocked = false
+        if blocked_statuses.find_by_id(change.value_id)
+          blocking_status = change.value
+          blocking_is_blocked = true
+        elsif stalled_statuses.find_by_id(change.value_id)
           blocking_status = change.value
         end
       elsif change.link?
         # Example: "This issue is satisfied by ANON-30465"
-        unless /^This issue (?<link_text>.+) (?<issue_key>.+)$/ =~ (change.value || change.old_value)
+        unless /^This (?<_>issue|work item) (?<link_text>.+) (?<issue_key>.+)$/ =~ (change.value || change.old_value)
           puts "Issue(#{key}) Can't parse link text: #{change.value || change.old_value}"
           next
         end
@@ -299,8 +488,9 @@ class Issue
 
       new_change = BlockedStalledChange.new(
         flagged: flag,
+        flag_reason: flag_reason,
         status: blocking_status,
-        status_is_blocking: blocking_status.nil? || blocked_statuses.include?(blocking_status),
+        status_is_blocking: blocking_status.nil? || blocking_is_blocked,
         blocking_issue_keys: (blocking_issue_keys.empty? ? nil : blocking_issue_keys.dup),
         time: change.time
       )
@@ -319,6 +509,7 @@ class Issue
       hack = result.pop
       result << BlockedStalledChange.new(
         flagged: hack.flag,
+        flag_reason: hack.flag_reason,
         status: hack.status,
         status_is_blocking: hack.status_is_blocking,
         blocking_issue_keys: hack.blocking_issue_keys,
@@ -330,6 +521,28 @@ class Issue
     result
   end
 
+  def blocked_stalled_changes_flag_logic change
+    flag = change.value
+    flag = nil if change.value == ''
+    if flag
+      # When the user is adding a comment to explain why a flag was set, the flag is set immediately
+      # and the comment is inserted after the user hits enter, which means that there is some time
+      # gap. If a comment happened shortly after the flag was set, we assume they're linked. This
+      # won't always be true and so there will be false positives, but it's a reasonable assumption.
+      max_seconds_between_flag_and_comment = 30
+      comment_change = changes.find do |c|
+        c.comment? && c.time >= change.time && (c.time - change.time) <= max_seconds_between_flag_and_comment
+      end
+      flag_reason = comment_change && @board.project_config.atlassian_document_format.to_text(comment_change.value)
+      # Newer Jira instances may add this extra text but older instances did not. Strip it out if found.
+      flag_reason = flag_reason&.sub(/\A:flag_on: Flag added\s*/m, '')&.strip
+      flag_reason = nil if flag_reason&.empty?
+    else
+      flag_reason = nil
+    end
+    [flag, flag_reason]
+  end
+
   def check_for_stalled change_time:, previous_change_time:, stalled_threshold:, blocking_stalled_changes:
     stalled_threshold_seconds = stalled_threshold * 60 * 60 * 24
 
@@ -362,6 +575,45 @@ class Issue
     inserted_stalled
   end
 
+  # return [number of active seconds, total seconds] that this issue had up to the end_time.
+  # It does not include data before issue start or after issue end
+  def flow_efficiency_numbers end_time:, settings: @board.project_config.settings
+    issue_start, issue_stop = started_stopped_times
+    return [0.0, 0.0] if !issue_start || issue_start > end_time
+
+    value_add_time = 0.0
+    end_time = issue_stop if issue_stop && issue_stop < end_time
+
+    active_start = nil
+    blocked_stalled_changes(end_time: end_time, settings: settings).each_with_index do |change, index|
+      break if change.time > end_time
+
+      if index.zero?
+        active_start = change.time if change.active?
+        next
+      end
+
+      # Already active and we just got another active.
+      next if active_start && change.active?
+
+      if change.active?
+        active_start = change.time
+      elsif active_start && change.time >= issue_start
+        # Not active now but we have been. Record the active time.
+        change_delta = change.time - [issue_start, active_start].max
+        value_add_time += change_delta
+        active_start = nil
+      end
+    end
+
+    if active_start
+      change_delta = end_time - [issue_start, active_start].max
+      value_add_time += change_delta if change_delta.positive?
+    end
+
+    [value_add_time, end_time - issue_start]
+  end
+
   def all_subtask_activity_times
     subtask_activity_times = []
     @subtasks.each do |subtask|
@@ -371,8 +623,6 @@ class Issue
   end
 
   def expedited?
-    return false unless @board&.project_config
-
     names = @board.project_config.settings['expedited_priority_names']
     return false unless names
 
@@ -489,85 +739,205 @@ class Issue
     /(?<project_code1>[^-]+)-(?<id1>.+)/ =~ key
     /(?<project_code2>[^-]+)-(?<id2>.+)/ =~ other.key
     comparison = project_code1 <=> project_code2
-    comparison = id1 <=> id2 if comparison.zero?
+    comparison = id1.to_i <=> id2.to_i if comparison.zero?
     comparison
   end
 
-  def dump
-    result = +''
-    result << "#{key} (#{type}): #{compact_text summary, 200}\n"
-
-    assignee = raw['fields']['assignee']
-    result << "  [assignee] #{assignee['name'].inspect} <#{assignee['emailAddress']}>\n" unless assignee.nil?
-
-    raw['fields']['issuelinks'].each do |link|
-      result << "  [link] #{link['type']['outward']} #{link['outwardIssue']['key']}\n" if link['outwardIssue']
-      result << "  [link] #{link['type']['inward']} #{link['inwardIssue']['key']}\n" if link['inwardIssue']
+  def discard_changes_before cutoff_time
+    rejected_any = false
+    @changes.reject! do |change|
+      reject = change.status? && change.time <= cutoff_time && change.artificial? == false
+      if reject
+        (@discarded_changes ||= []) << change
+        rejected_any = true
+      end
+      reject
     end
-    changes.each do |change|
-      value = change.value
-      old_value = change.old_value
 
-      message = "  [change] #{change.time.strftime '%Y-%m-%d %H:%M:%S %z'} [#{change.field}] "
-      message << "#{compact_text(old_value).inspect} -> " unless old_value.nil? || old_value.empty?
-      message << compact_text(value).inspect
-      message << " (#{change.author})"
-      message << ' <<artificial entry>>' if change.artificial?
-      result << message << "\n"
-    end
-    result
+    (@discarded_change_times ||= []) << cutoff_time if rejected_any
+  end
+
+  def dump
+    IssuePrinter.new(self).to_s
   end
 
   def done?
     if artificial? || board.cycletime.nil?
       # This was probably loaded as a linked issue, which means we don't know what board it really
-      # belonged to. The best we can do is look at the status category. This case should be rare but
-      # it can happen.
-      status.category_name == 'Done'
+      # belonged to. The best we can do is look at the status key
+      status.category.done?
     else
       board.cycletime.done? self
     end
   end
 
+  def started_stopped_times
+    board.cycletime.started_stopped_times(self)
+  end
+
+  def started_stopped_dates
+    board.cycletime.started_stopped_dates(self)
+  end
+
+  def status_changes
+    @changes.select { |change| change.status? }
+  end
+
+  def status_resolution_at_done
+    done_time = started_stopped_times.last
+    return [nil, nil] if done_time.nil?
+
+    status_change = nil
+    resolution = nil
+
+    @changes.each do |change|
+      break if change.time > done_time
+
+      status_change = change if change.status?
+      resolution = change.value if change.resolution?
+    end
+
+    status = status_change ? find_or_create_status(id: status_change.value_id, name: status_change.value) : nil
+    [status, resolution]
+  end
+
+  def sprints
+    sprint_ids = []
+
+    changes.each do |change|
+      next unless change.sprint?
+
+      sprint_ids << change.raw['to'].split(/\s*,\s*/).collect { |id| id.to_i }
+    end
+    sprint_ids.flatten!
+
+    board.sprints.select { |s| sprint_ids.include? s.id }
+  end
+
+  def started_sprints
+    sprints.reject { |sprint| sprint.future? }
+  end
+
+  def compact_text text, max: 60
+    return '' if text.nil?
+
+    text = if text.is_a? Hash
+             @board.project_config.atlassian_document_format.to_text(text)
+           else
+             text
+           end
+    text = text.gsub(/\s+/, ' ').strip
+    text = "#{text[0...max]}..." if text.length > max
+    text
+  end
+
   private
 
-  def assemble_author raw
-    raw['author']&.[]('displayName') || raw['author']&.[]('name') || 'Unknown author'
+  # Returns [[effective_time, change_item]] for each moment the issue entered an active sprint.
+  # Skips sprints that were removed before they activated.
+  def sprint_entry_events
+    data_clazz = Struct.new(:sprint_id, :sprint_start, :add_time, :change)
+    events = []
+    in_sprint = []
+
+    @changes.each do |change|
+      next unless change.sprint?
+
+      (change.value_id - change.old_value_id).each do |sprint_id|
+        sprint_start, = find_sprint_start_end(sprint_id: sprint_id, change: change)
+        in_sprint << data_clazz.new(sprint_id, sprint_start, change.time, change) if sprint_start
+      end
+
+      (change.old_value_id - change.value_id).each do |sprint_id|
+        data = in_sprint.find { |d| d.sprint_id == sprint_id }
+        next unless data
+
+        in_sprint.delete(data)
+        next if data.sprint_start >= change.time # sprint hadn't activated before removal
+
+        effective_time = [data.add_time, data.sprint_start].max
+        events << [effective_time, sprint_change_at(effective_time, data.change)]
+      end
+    end
+
+    in_sprint.each do |data|
+      effective_time = [data.add_time, data.sprint_start].max
+      events << [effective_time, sprint_change_at(effective_time, data.change)]
+    end
+
+    events
+  end
+
+  def sprint_change_at effective_time, change
+    return change if effective_time == change.time
+
+    ChangeItem.new(
+      raw: { 'field' => 'Sprint', 'toString' => 'Sprint activated', 'to' => '0', 'from' => nil, 'fromString' => nil },
+      author_raw: nil,
+      time: effective_time,
+      artificial: true
+    )
+  end
+
+  def in_active_sprint_at? time
+    active_ids = []
+    @changes.each do |change|
+      break if change.time > time
+      next unless change.sprint?
+
+      (change.value_id - change.old_value_id).each do |sprint_id|
+        sprint_start, = find_sprint_start_end(sprint_id: sprint_id, change: change)
+        active_ids << sprint_id if sprint_start && sprint_start <= time
+      end
+      (change.old_value_id - change.value_id).each { |id| active_ids.delete(id) }
+    end
+    active_ids.any?
+  end
+
+  def in_visible_status_at? time, visible_status_ids
+    last = status_changes.reverse.find { |c| c.time <= time }
+    last && visible_status_ids.include?(last.value_id)
   end
 
   def load_history_into_changes
     @raw['changelog']['histories']&.each do |history|
       created = parse_time(history['created'])
 
-      # It should be impossible to not have an author but we've seen it in production
-      author = assemble_author history
       history['items']&.each do |item|
-        @changes << ChangeItem.new(raw: item, time: created, author: author)
+        if item['field'] == 'status' && item['to'].nil?
+          to_name = item['toString']
+          matches = board.possible_statuses.find_all_by_name(to_name)
+          guessed_id, id_note = if matches.length == 1
+            [matches.first.id.to_s, "Guessed id #{matches.first.id} from status name."]
+          elsif matches.length > 1
+            ['0', "Multiple statuses named #{to_name.inspect} exist (ids: #{matches.map(&:id).join(', ')}); cannot disambiguate. Using id 0."]
+          else
+            ['0', "No known status named #{to_name.inspect}. Using id 0."]
+          end
+          board.project_config.file_system.warning(
+            "Issue #{key} has a status change without a 'to' id " \
+            "(from #{item['fromString'].inspect} to #{to_name.inspect}). #{id_note}"
+          )
+          item = item.merge('to' => guessed_id)
+        end
+
+        @changes << ChangeItem.new(raw: item, time: created, author_raw: history['author'])
       end
     end
   end
 
   def load_comments_into_changes
     @raw['fields']['comment']['comments']&.each do |comment|
-      raw = {
+      raw = comment.merge({
         'field' => 'comment',
         'to' => comment['id'],
         'toString' =>  comment['body']
-      }
-      author = assemble_author comment
+      })
       created = parse_time(comment['created'])
-      @changes << ChangeItem.new(raw: raw, time: created, author: author, artificial: true)
+      @changes << ChangeItem.new(raw: raw, time: created, artificial: true, author_raw: comment['author'])
     end
   end
 
-  def compact_text text, max = 60
-    return nil if text.nil?
-
-    text = text.gsub(/\s+/, ' ').strip
-    text = "#{text[0..max]}..." if text.length > max
-    text
-  end
-
   def sort_changes!
     @changes.sort! do |a, b|
       # It's common that a resolved will happen at the same time as a status change.
@@ -585,6 +955,9 @@ class Issue
     first_status = nil
     first_status_id = nil
 
+    # There won't be a created timestamp in cases where this was a linked issue
+    return unless @raw['fields']['created']
+
     created_time = parse_time @raw['fields']['created']
     first_change = @changes.find { |change| change.field == field_name }
     if first_change.nil?
@@ -598,10 +971,21 @@ class Issue
       first_status = first_change.old_value
       first_status_id = first_change.old_value_id
     end
-    ChangeItem.new time: created_time, artificial: true, author: author, raw: {
+
+    creator = raw['fields']['creator']
+    ChangeItem.new time: created_time, artificial: true, author_raw: creator, raw: {
       'field' => field_name,
       'to' => first_status_id,
       'toString' => first_status
     }
   end
+
+  def find_status_category_ids_by_names category_names
+    category_names.filter_map do |name|
+      list = board.possible_statuses.find_all_categories_by_name name
+      raise "No status categories found for name: #{name}" if list.empty?
+
+      list
+    end.flatten.collect(&:id)
+  end
 end