jirametrics 2.25 → 2.30

data/lib/jirametrics/html/legacy_colors.css

@@ -0,0 +1,174 @@
+/* Legacy color scheme for jirametrics
+ *
+ * The default colors were updated to improve accessibility for people with
+ * color vision deficiencies. If you prefer the original colors, add this to
+ * your project config:
+ *
+ *   setting['include_css'] = './legacy_colors.css'
+ *
+ * and copy this file to the same directory as your config file.
+ */
+
+/* Light mode */
+:root,
+html[data-theme="light"] {
+  --body-background: white;
+  --default-text-color: black;
+  --grid-line-color: lightgray;
+  --warning-banner: yellow;
+
+  --cycletime-scatterplot-overall-trendline-color: gray;
+
+  --non-working-days-color: #F0F0F0;
+  --expedited-color: red;
+  --blocked-color: #FF7400;
+  --stalled-color: orange;
+  --dead-color: black;
+
+  --type-story-color: #4bc14b;
+  --type-task-color: blue;
+  --type-bug-color: orange;
+  --type-spike-color: #9400D3;
+
+  --status-category-todo-color: gray;
+  --status-category-inprogress-color: #2663ff;
+  --status-category-done-color: #00ff00;
+  --status-category-unknown-color: black;
+
+  --aging-work-bar-chart-percentage-line-color: red;
+  --aging-work-bar-chart-separator-color: white;
+
+  --throughput_chart_total_line_color: gray;
+
+  --aging-work-in-progress-chart-shading-color: lightgray;
+  --aging-work-in-progress-chart-shading-50-color: #2E8BC0;
+  --aging-work-in-progress-chart-shading-85-color: #ADD8E6;
+  --aging-work-in-progress-chart-shading-98-color: #FF8A8A;
+  --aging-work-in-progress-chart-shading-100-color: #FF2E2E;
+
+  --aging-work-in-progress-by-age-trend-line-color: gray;
+
+  --aging-work-table-date-in-jeopardy: yellow;
+  --aging-work-table-date-overdue: red;
+
+  --hierarchy-table-inactive-item-text-color: gray;
+
+  --wip-chart-completed-color: #00ff00;
+  --wip-chart-completed-but-not-started-color: #99FF99;
+  --wip-chart-duration-less-than-day-color: #ffef41;
+  --wip-chart-duration-week-or-less-color: #dcc900;
+  --wip-chart-duration-two-weeks-or-less-color: #dfa000;
+  --wip-chart-duration-four-weeks-or-less-color: #eb7200;
+  --wip-chart-duration-more-than-four-weeks-color: #e70000;
+  --wip-chart-active-color: #326cff;
+  --wip-chart-border-color: gray;
+
+  --wip-by-column-chart-bar-fill-color: #0072B2;
+  --wip-by-column-chart-bar-text-color: #ffffff;
+  --wip-by-column-chart-limit-line-color: #D55E00;
+  --wip-by-column-chart-recommendation-color: #009E73;
+
+  --estimate-accuracy-chart-completed-fill-color: #00ff00;
+  --estimate-accuracy-chart-completed-border-color: green;
+  --estimate-accuracy-chart-active-fill-color: #FFCCCB;
+  --estimate-accuracy-chart-active-border-color: red;
+
+  --expedited-chart-no-longer-expedited: gray;
+  --expedited-chart-dot-issue-started-color: orange;
+  --expedited-chart-dot-issue-stopped-color: green;
+  --expedited-chart-dot-expedite-started-color: red;
+  --expedited-chart-dot-expedite-stopped-color: green;
+
+  --sprint-burndown-sprint-color-1: blue;
+  --sprint-burndown-sprint-color-2: orange;
+  --sprint-burndown-sprint-color-3: green;
+  --sprint-burndown-sprint-color-4: red;
+  --sprint-burndown-sprint-color-5: brown;
+  --sprint-burndown-sprint-color-6: blue;    /* wraps back to color-1 (legacy had only 5) */
+  --sprint-burndown-sprint-color-7: orange;  /* wraps back to color-2 (legacy had only 5) */
+
+  --sprint-color: lightblue;
+
+  --daily-view-selected-issue-background: lightgray;
+  --daily-view-issue-border: green;
+  --daily-view-selected-issue-border: red;
+
+  --priority-color-highest: #dc2626;
+  --priority-color-high: #ea580c;
+  --priority-color-medium: #9ca3af;
+  --priority-color-low: #0891b2;
+  --priority-color-lowest: #64748b;
+  --priority-color-notset: gray;
+  --priority-color-critical: red;
+}
+
+/* Dark mode */
+html[data-theme="dark"] {
+  --warning-banner: #9F2B00;
+  --non-working-days-color: #2f2f2f;
+  --type-story-color: #6fb86f;
+  --type-task-color: #0021b3;
+  --type-bug-color: #bb5603;
+  --body-background: #343434;
+  --default-text-color: #aaa;
+  --grid-line-color: #424242;
+  --expedited-color: #b90000;
+  --blocked-color: #c75b02;
+  --stalled-color: #ae7202;
+  --wip-chart-active-color: #2551c1;
+  --status-category-inprogress-color: #1c49bb;
+  --hierarchy-table-inactive-item-text-color: #939393;
+  --wip-by-column-chart-bar-fill-color: #56B4E9;
+  --wip-by-column-chart-bar-text-color: #000000;
+  --wip-by-column-chart-limit-line-color: #E69F00;
+  --wip-by-column-chart-recommendation-color: #2DCB9A;
+  --wip-chart-completed-color: #03cb03;
+  --wip-chart-duration-less-than-day-color: #d2d988;
+  --wip-chart-duration-week-or-less-color: #dfcd00;
+  --wip-chart-duration-two-weeks-or-less-color: #cf9400;
+  --wip-chart-duration-four-weeks-or-less-color: #c25e00;
+  --wip-chart-duration-more-than-four-weeks-color: #8e0000;
+  --daily-view-selected-issue-background: #474747;
+  --priority-color-highest: #ef4444;
+  --priority-color-high: #f97316;
+  --priority-color-low: #06b6d4;
+  --priority-color-lowest: #94a3b8;
+}
+
+@media screen and (prefers-color-scheme: dark) {
+  :root {
+    --warning-banner: #9F2B00;
+    --non-working-days-color: #2f2f2f;
+    --type-story-color: #6fb86f;
+    --type-task-color: #0021b3;
+    --type-bug-color: #bb5603;
+    --body-background: #343434;
+    --default-text-color: #aaa;
+    --grid-line-color: #424242;
+    --expedited-color: #b90000;
+    --blocked-color: #c75b02;
+    --stalled-color: #ae7202;
+    --dead-color: black;
+    --wip-chart-active-color: #2551c1;
+    --status-category-inprogress-color: #1c49bb;
+    --cycletime-scatterplot-overall-trendline-color: gray;
+    --hierarchy-table-inactive-item-text-color: #939393;
+    --wip-by-column-chart-bar-fill-color: #56B4E9;
+    --wip-by-column-chart-bar-text-color: #000000;
+    --wip-by-column-chart-limit-line-color: #E69F00;
+    --wip-by-column-chart-recommendation-color: #2DCB9A;
+    --wip-chart-completed-color: #03cb03;
+    --wip-chart-completed-but-not-started-color: #99FF99;
+    --wip-chart-duration-less-than-day-color: #d2d988;
+    --wip-chart-duration-week-or-less-color: #dfcd00;
+    --wip-chart-duration-two-weeks-or-less-color: #cf9400;
+    --wip-chart-duration-four-weeks-or-less-color: #c25e00;
+    --wip-chart-duration-more-than-four-weeks-color: #8e0000;
+    --daily-view-selected-issue-background: #474747;
+    --priority-color-highest: #ef4444;
+    --priority-color-high: #f97316;
+    --priority-color-medium: #9ca3af;
+    --priority-color-low: #06b6d4;
+    --priority-color-lowest: #94a3b8;
+  }
+}

data/lib/jirametrics/html/time_based_scatterplot.erb

@@ -28,15 +28,20 @@ new Chart(document.getElementById('<%= chart_id %>').getContext('2d'), {
         max: "<%= (date_range.end + 1).to_s %>"
       },
       y: {
+        min: 0,
+        max: <%= (@highest_y_value * 1.1).ceil %>,
         scaleLabel: {
-          display: true,
-          min: 0,
-          max: <%= @highest_y_value %>
+          display: true
         },
         <%= render_axis_title :y %>
         grid: {
           color: <%= CssVariable['--grid-line-color'].to_json %>
         },
+        ticks: {
+          callback: function(value, index, ticks) {
+            return index === ticks.length - 1 ? null : value;
+          }
+        }
       }
     },
     plugins: {

data/lib/jirametrics/html/wip_by_column_chart.erb

@@ -0,0 +1,250 @@
+<%= seam_start %>
+<div class="chart" style="position:relative;">
+  <canvas id="<%= chart_id %>" width="<%= canvas_width %>" height="<%= canvas_height %>"></canvas>
+  <div id="<%= chart_id %>-tooltip" style="
+    display:none; position:absolute; pointer-events:none;
+    background:rgba(0,0,0,0.75); color:#fff; border-radius:4px;
+    padding:4px 8px; font:12px sans-serif; white-space:nowrap;
+  "></div>
+</div>
+<script>
+(function() {
+  var wipData         = <%= @wip_data.to_json %>;
+  var wipLimits       = <%= @wip_limits.to_json %>;
+  var recommendations = <%= @recommendations.to_json %>;
+  var maxWip          = <%= @max_wip %>;
+  var gridColor       = <%= CssVariable['--grid-line-color'].to_json %>;
+  var barFillColor    = <%= CssVariable['--wip-by-column-chart-bar-fill-color'].to_json %>;
+  var barTextColor    = <%= CssVariable['--wip-by-column-chart-bar-text-color'].to_json %>;
+  var limitColor      = <%= CssVariable['--wip-by-column-chart-limit-line-color'].to_json %>;
+  var recColor        = <%= CssVariable['--wip-by-column-chart-recommendation-color'].to_json %>;
+  var tooltipEl       = document.getElementById(<%= "#{chart_id}-tooltip".inspect %>);
+
+  var hitAreas = [];
+
+  var rectPlugin = {
+    id: 'wipRects',
+    afterDraw: function(chart) {
+      var ctx    = chart.ctx;
+      var xScale = chart.scales['x'];
+      var yScale = chart.scales['y'];
+      var slotWidth = xScale.width / Math.max(xScale.ticks.length, 1);
+
+      hitAreas = [];
+
+      // 1. Draw y-axis gridlines at integer band boundaries
+      ctx.save();
+      ctx.beginPath();
+      ctx.rect(xScale.left, yScale.top, xScale.right - xScale.left, yScale.bottom - yScale.top);
+      ctx.clip();
+      ctx.strokeStyle = gridColor;
+      ctx.lineWidth   = 1;
+      ctx.setLineDash([]);
+      for (var gi = 0; gi <= maxWip + 1; gi++) {
+        var gy = yScale.getPixelForValue(gi);
+        ctx.beginPath();
+        ctx.moveTo(xScale.left, gy);
+        ctx.lineTo(xScale.right, gy);
+        ctx.stroke();
+      }
+      ctx.restore();
+
+      // 2. Draw WIP limit lines (behind rectangles)
+      wipLimits.forEach(function(limits, colIndex) {
+        var xCenter  = xScale.getPixelForValue(colIndex);
+        var halfSlot = slotWidth * 0.45;
+
+        [['min', 'bottom'], ['max', 'top']].forEach(function(pair) {
+          var type     = pair[0];
+          var baseline = pair[1];
+          var val      = limits[type];
+          if (val === null || val === undefined) return;
+
+          var y = yScale.getPixelForValue(val + 0.5);
+
+          ctx.save();
+          ctx.strokeStyle = limitColor;
+          ctx.lineWidth   = 2;
+          ctx.setLineDash([5, 3]);
+          ctx.beginPath();
+          ctx.moveTo(xCenter - halfSlot, y);
+          ctx.lineTo(xCenter + halfSlot, y);
+          ctx.stroke();
+          ctx.restore();
+
+          ctx.save();
+          ctx.fillStyle    = limitColor;
+          ctx.font         = 'bold 10px sans-serif';
+          ctx.textAlign    = 'right';
+          ctx.textBaseline = baseline;
+          ctx.fillText(type + ': ' + val, xCenter + halfSlot, baseline === 'bottom' ? y - 2 : y + 2);
+          ctx.restore();
+        });
+      });
+
+      <% if @show_recommendations %>
+      // 3. Draw recommendation lines (behind rectangles, label on left)
+      recommendations.forEach(function(rec, colIndex) {
+        if (rec === null || rec === undefined || rec === 0) return;
+        var xCenter  = xScale.getPixelForValue(colIndex);
+        var halfSlot = slotWidth * 0.45;
+        var y = yScale.getPixelForValue(rec + 0.5);
+
+        ctx.save();
+        ctx.strokeStyle = recColor;
+        ctx.lineWidth   = 2;
+        ctx.setLineDash([5, 3]);
+        ctx.beginPath();
+        ctx.moveTo(xCenter - halfSlot, y);
+        ctx.lineTo(xCenter + halfSlot, y);
+        ctx.stroke();
+        ctx.restore();
+
+        ctx.save();
+        ctx.fillStyle    = recColor;
+        ctx.font         = 'bold 10px sans-serif';
+        ctx.textAlign    = 'left';
+        ctx.textBaseline = 'top';
+        ctx.fillText('rec: ' + rec, xCenter - halfSlot, y + 2);
+        ctx.restore();
+      });
+      <% end %>
+
+      // 4. Draw WIP rectangles centered in their bands (wip + 0.5)
+      var yStep = Math.abs(yScale.getPixelForValue(0.5) - yScale.getPixelForValue(1.5));
+
+      wipData.forEach(function(colData, colIndex) {
+        var xCenter = xScale.getPixelForValue(colIndex);
+
+        colData.forEach(function(entry) {
+          var wip       = entry['wip'];
+          var pct       = entry['pct'];
+          var rectWidth  = slotWidth * pct / 100;
+          var rectHeight = yStep * 0.8;
+          var yCenter   = yScale.getPixelForValue(wip + 0.5);
+          var x1 = xCenter - rectWidth / 2;
+          var y1 = yCenter - rectHeight / 2;
+
+          ctx.save();
+          ctx.fillStyle   = barFillColor;
+          ctx.strokeStyle = barFillColor;
+          ctx.lineWidth   = 1;
+          ctx.fillRect(x1, y1, rectWidth, rectHeight);
+          ctx.strokeRect(x1, y1, rectWidth, rectHeight);
+
+          ctx.fillStyle    = barTextColor;
+          ctx.font         = '11px sans-serif';
+          ctx.textAlign    = 'center';
+          ctx.textBaseline = 'middle';
+          if (rectWidth > 25) {
+            ctx.fillText(pct + '%', xCenter, yCenter);
+          }
+          ctx.restore();
+
+          var hitWidth = Math.max(rectWidth, slotWidth);
+          hitAreas.push({
+            x1: xCenter - hitWidth / 2, y1: y1,
+            x2: xCenter + hitWidth / 2, y2: y1 + rectHeight,
+            label: 'WIP ' + wip + ': ' + pct + '%'
+          });
+        });
+      });
+    }
+  };
+
+  var canvas = document.getElementById(<%= chart_id.inspect %>);
+
+  canvas.addEventListener('mousemove', function(e) {
+    var rect = canvas.getBoundingClientRect();
+    var mx = e.clientX - rect.left;
+    var my = e.clientY - rect.top;
+
+    var hit = null;
+    for (var i = 0; i < hitAreas.length; i++) {
+      var a = hitAreas[i];
+      if (mx >= a.x1 && mx <= a.x2 && my >= a.y1 && my <= a.y2) {
+        hit = a;
+        break;
+      }
+    }
+
+    if (hit) {
+      tooltipEl.textContent = hit.label;
+      tooltipEl.style.display = 'block';
+      tooltipEl.style.left = (mx + 10) + 'px';
+      tooltipEl.style.top  = (my - 20) + 'px';
+    } else {
+      tooltipEl.style.display = 'none';
+    }
+  });
+
+  canvas.addEventListener('mouseleave', function() {
+    tooltipEl.style.display = 'none';
+  });
+
+  new Chart(canvas.getContext('2d'),
+  {
+    type: 'bar',
+    plugins: [rectPlugin],
+    data: {
+      labels: <%= @column_names.to_json %>,
+      datasets: [{
+        data: [],
+        backgroundColor: 'transparent'
+      }]
+    },
+    options: {
+      responsive: <%= canvas_responsive? %>,
+      scales: {
+        x: {
+          grid: {
+            color: gridColor,
+            z: 1
+          }
+        },
+        y: {
+          title: {
+            display: true,
+            text: 'WIP'
+          },
+          grid: {
+            display: false
+          },
+          min: 0,
+          max: <%= @max_wip + 1 %>,
+          afterBuildTicks: function(scale) {
+            scale.ticks = [];
+            for (var i = 0; i <= maxWip; i++) {
+              scale.ticks.push({ value: i + 0.5 });
+            }
+          },
+          ticks: {
+            callback: function(value) {
+              return Math.round(value - 0.5);
+            }
+          }
+        }
+      },
+      plugins: {
+        legend: {
+          display: false
+        },
+        tooltip: {
+          enabled: false
+        }
+      }
+    }
+  });
+})();
+</script>
+<%= seam_end %>
+<% unless @recommendation_texts.empty? %>
+<div style="margin-top: 0.5em;">
+  <strong>WIP limit recommendations</strong>
+  <ul style="margin: 0.3em 0 0 0; padding-left: 1.5em;">
+    <% @recommendation_texts.each do |text| %>
+      <li><%= text %></li>
+    <% end %>
+  </ul>
+</div>
+<% end %>

data/lib/jirametrics/html_generator.rb

@@ -3,8 +3,9 @@
 class HtmlGenerator
   attr_accessor :file_system, :settings
 
-  def create_html output_filename:, settings:
+  def create_html output_filename:, settings:, project_name: ''
     @settings = settings
+    project_name = project_name.to_s
     html_directory = "#{Pathname.new(File.realpath(__FILE__)).dirname}/html"
     css = load_css html_directory: html_directory
     javascript = file_system.load(File.join(html_directory, 'index.js'))

data/lib/jirametrics/html_report_config.rb

@@ -33,23 +33,43 @@ class HtmlReportConfig < HtmlGenerator
     @charts = [] # Where we store all the charts we executed so we can assert against them.
   end
 
-  def method_missing name, &block
+  def method_missing name, *_args, board_id: nil, **_kwargs, &block
     class_name = name.to_s.split('_').map(&:capitalize).join
-    klass = Object.const_get(class_name)
-    raise NameError unless klass < ChartBase
+    klass = resolve_chart_class(class_name)
+    return super if klass.nil?
 
     block ||= ->(_) {}
-    execute_chart klass.new(block)
+
+    if klass.instance_method(:board_id=).owner == klass
+      execute_chart_per_board klass: klass, block: block, board_id: board_id
+    else
+      execute_chart klass.new(block)
+    end
+  end
+
+  def resolve_chart_class class_name
+    klass = Object.const_get(class_name)
+    klass < ChartBase ? klass : nil
   rescue NameError
-    super
+    nil
+  end
+
+  def execute_chart_per_board klass:, block:, board_id:
+    all_boards = @file_config.project_config.all_boards
+    ids = board_id ? [board_id] : issues.collect { |i| i.board.id }.uniq
+    ids = ids.sort_by { |id| all_boards[id]&.name || '' }
+    ids.each_with_index do |id, index|
+      execute_chart(klass.new(block)) do |chart|
+        chart.board_id = id
+        # We're showing the description only on the first one in order to reduce noise on the report
+        chart.description_text nil unless index.zero?
+      end
+    end
   end
 
   def respond_to_missing? name, include_private = false
     class_name = name.to_s.split('_').map(&:capitalize).join
-    klass = Object.const_get(class_name)
-    klass < ChartBase
-  rescue NameError
-    super
+    !resolve_chart_class(class_name).nil? || super
   end
 
   def cycletime label = nil, &block
@@ -78,7 +98,8 @@ class HtmlReportConfig < HtmlGenerator
 
     html create_footer
 
-    create_html output_filename: @file_config.output_filename, settings: settings
+    create_html output_filename: @file_config.output_filename, settings: settings,
+                project_name: @file_config.project_config.name
   end
 
   def file_system
@@ -97,24 +118,9 @@ class HtmlReportConfig < HtmlGenerator
     @file_config.project_config.exporter.timezone_offset
   end
 
-  def aging_work_in_progress_chart board_id: nil, &block
-    block ||= ->(_) {}
-
-    if board_id.nil?
-      ids = issues.collect { |i| i.board.id }.uniq.sort
-    else
-      ids = [board_id]
-    end
-
-    ids.each do |id|
-      execute_chart(AgingWorkInProgressChart.new(block)) do |chart|
-        chart.board_id = id
-      end
-    end
-  end
-
   def random_color
-    "##{Random.bytes(3).unpack1('H*')}"
+    @palette_index = (@palette_index || -1) + 1
+    ChartBase::OKABE_ITO_PALETTE[@palette_index % ChartBase::OKABE_ITO_PALETTE.size]
   end
 
   def html string, type: :body

data/lib/jirametrics/issue.rb

@@ -48,8 +48,8 @@ class Issue
   def type = @raw['fields']['issuetype']['name']
   def type_icon_url = @raw['fields']['issuetype']['iconUrl']
 
-  def priority_name = @raw['fields']['priority']['name']
-  def priority_url = @raw['fields']['priority']['iconUrl']
+  def priority_name = @raw.dig('fields', 'priority', 'name')
+  def priority_url = @raw.dig('fields', 'priority', 'iconUrl')
 
   def summary = @raw['fields']['summary']
 
@@ -210,7 +210,25 @@ class Issue
   end
 
   def first_time_visible_on_board
-    first_time_in_status(*board.visible_columns.collect(&:status_ids).flatten)
+    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
@@ -815,17 +833,92 @@ class Issue
 
   private
 
+  # 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'])
 
       history['items']&.each do |item|
         if item['field'] == 'status' && item['to'].nil?
-          board.project_config.file_system.log(
+          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 #{item['toString'].inspect}). Using id 0."
+            "(from #{item['fromString'].inspect} to #{to_name.inspect}). #{id_note}"
           )
-          item = item.merge('to' => '0')
+          item = item.merge('to' => guessed_id)
         end
 
         @changes << ChangeItem.new(raw: item, time: created, author_raw: history['author'])