jirametrics 2.28 → 2.29

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d93d43ce61e0fcec89c5ee737044cff4007b1f0079be2c6be774c56cb15130e8
-  data.tar.gz: ffbe1b15fc8aa08f928e7c322cf53dc5a1646b9da01b7b9e81e8b5bd2c44650d
+  metadata.gz: 2cf59f19d1ee1de238db86ef01bd46d25c5741a6a85789d62f64c310d97055fd
+  data.tar.gz: 31a15ee2f64eef895dbfd95bd14004b70bec1be5810224f95fee39595022b84f
 SHA512:
-  metadata.gz: 66d0c9c0db9b11c4278935a8342cae5f9b6b4e34fffc46d1bad6b719b6ca779374191f05f4139caf28995e8014ab77cfea79945df9abe546405abf9e381e4311
-  data.tar.gz: 3f10707f9b44c14dd8dae67ce73cd208cb7554cee147d502f3b99315b49cb524aa6f12662c1624720f204e814a5686e37393f907da8ec43f1befc88398a79cc7
+  metadata.gz: 812c19230db1c44dc41e3b99f32d6d65235de7e620d4faedb4b51ac41c4da220795013b1b80c058f0f85ef6ab6fab6146ad5ed7cb2c48abe6ccddaed92002968
+  data.tar.gz: 1895fc706f93d0ad4cc60a83fb1bc82fa416f389b3b620ca01f9fefb774e11a5f9c1f96d8f9b00a0b2cdd82ca5443a7dd21c4f069fdb45988a5de4669cebf7ae

data/lib/jirametrics/aging_work_in_progress_chart.rb

@@ -6,6 +6,7 @@ require 'jirametrics/board_movement_calculator'
 
 class AgingWorkInProgressChart < ChartBase
   include GroupableIssueChart
+
   attr_accessor :possible_statuses, :board_id
   attr_reader :board_columns
 
@@ -55,7 +56,7 @@ class AgingWorkInProgressChart < ChartBase
   def run
     determine_board_columns
 
-    @header_text += " on board: #{@all_boards[@board_id].name}"
+    @header_text += " on board: #{current_board.name}"
     data_sets = make_data_sets
 
     adjust_visibility_of_unmapped_status_column data_sets: data_sets
@@ -76,7 +77,7 @@ class AgingWorkInProgressChart < ChartBase
 
     @fake_column = BoardColumn.new({
       'name' => '[Unmapped Statuses]',
-      'statuses' => unmapped_statuses.collect { |id| { 'id' => id.to_s } }.uniq # rubocop:disable Performance/ChainArrayAllocation
+      'statuses' => unmapped_statuses.collect { |id| { 'id' => id.to_s } }.uniq
     })
     @board_columns = columns + [@fake_column]
   end
@@ -114,14 +115,7 @@ class AgingWorkInProgressChart < ChartBase
 
     calculator = BoardMovementCalculator.new board: @all_boards[@board_id], issues: issues, today: date_range.end
 
-    column_indexes_to_remove = []
-    unless @show_all_columns
-      column_indexes_to_remove = indexes_of_leading_and_trailing_zeros(calculator.age_data_for(percentage: 100))
-
-      column_indexes_to_remove.reverse_each do |index|
-        @board_columns.delete_at index
-      end
-    end
+    column_indexes_to_remove = trim_board_columns data_sets: data_sets, calculator: calculator
 
     @row_index_offset = data_sets.size
 
@@ -177,6 +171,44 @@ class AgingWorkInProgressChart < ChartBase
     result
   end
 
+  def trim_board_columns data_sets:, calculator:
+    return [] if @show_all_columns
+
+    columns_with_aging_items = data_sets.flat_map do |set|
+      set['data'].filter_map { |d| d['x'] if d.is_a? Hash }
+    end.uniq
+
+    # @fake_column is always the last element and is handled separately.
+    real_column_count = @board_columns.size - 1
+
+    # The last visible column always has artificially inflated age_data because
+    # ages_of_issues_when_leaving_column uses `today` as end_date when there is no
+    # next column. Exclude it from the right-boundary search so it is only kept when
+    # it has current aging items (handled by the last_aging fallback below).
+    age_data = calculator.age_data_for(percentage: 100)
+    last_data = (0...(real_column_count - 1)).to_a.reverse.find { |i| !age_data[i].zero? }
+
+    in_current = ->(i) { columns_with_aging_items.include?(@board_columns[i].name) }
+    first_aging = (0...real_column_count).find(&in_current)
+    last_aging  = (0...real_column_count).to_a.reverse.find(&in_current)
+
+    # Combine: include any column with age_data (up to but not including the last visible
+    # column) and any column with current aging items.
+    first_data = (0...real_column_count).find { |i| !age_data[i].zero? }
+    left_bound  = [first_data, first_aging].compact.min
+    right_bound = [last_data, last_aging].compact.max
+
+    indexes_to_remove =
+      if left_bound && right_bound
+        (0...left_bound).to_a + ((right_bound + 1)...real_column_count).to_a
+      else
+        (0...real_column_count).to_a
+      end
+
+    indexes_to_remove.reverse_each { |index| @board_columns.delete_at index }
+    indexes_to_remove
+  end
+
   def column_for issue:
     @board_columns.find do |board_column|
       board_column.status_ids.include? issue.status.id
@@ -192,7 +224,7 @@ class AgingWorkInProgressChart < ChartBase
       end
     end
 
-    if has_unmapped
+    if has_unmapped && @description_text
       @description_text += "<p>The items shown in #{column_name.inspect} are not visible on the " \
         'board but are still active. Most likely everyone has forgotten about them.</p>'
     else

data/lib/jirametrics/aging_work_table.rb

@@ -45,7 +45,9 @@ class AgingWorkTable < ChartBase
   # This is its own method simply so the tests can initialize the calculator without doing a full run.
   def initialize_calculator
     @today = date_range.end
-    @calculator = BoardMovementCalculator.new board: current_board, issues: issues, today: @today
+    @calculators = @all_boards.transform_values do |board|
+      BoardMovementCalculator.new board: board, issues: issues, today: @today
+    end
   end
 
   def expedited_but_not_started
@@ -123,7 +125,8 @@ class AgingWorkTable < ChartBase
     due = issue.due_date
     message = nil
 
-    days_remaining, error = @calculator.forecasted_days_remaining_and_message issue: issue, today: @today
+    calculator = @calculators[issue.board.id]
+    days_remaining, error = calculator.forecasted_days_remaining_and_message issue: issue, today: @today
 
     unless error
       if due

data/lib/jirametrics/board.rb

@@ -72,7 +72,7 @@ class Board
     return true if board_type == 'scrum'
     return false unless board_type == 'simple'
 
-    @features.any? { |f| f.name == 'jsw.agility.sprints' && f.enabled? }
+    has_sprints_feature?
   end
 
   def kanban?
@@ -82,6 +82,14 @@ class Board
     !scrum?
   end
 
+  def team_managed_kanban?
+    board_type == 'simple' && !has_sprints_feature?
+  end
+
+  def has_sprints_feature?
+    @features.any? { |f| f.name == 'jsw.agility.sprints' && f.enabled? }
+  end
+
   def id
     @raw['id'].to_i
   end

data/lib/jirametrics/examples/standard_project.rb

@@ -9,7 +9,7 @@ class Exporter
       show_experimental_charts: false, github_repos: nil
     exporter = self
     project name: name do
-      file_system.log name
+      file_system.log name, also_write_to_stderr: true
       file_prefix file_prefix
 
       self.anonymize if anonymize
@@ -82,6 +82,9 @@ class Exporter
           end
 
           aging_work_in_progress_chart
+          wip_by_column_chart do
+            show_recommendations
+          end
           aging_work_bar_chart
           aging_work_table
           daily_wip_by_age_chart

data/lib/jirametrics/html/index.css

@@ -50,6 +50,11 @@
   --wip-chart-active-color: #326cff;
   --wip-chart-border-color: gray;
 
+  --wip-by-column-chart-bar-fill-color: #0072B2;          /* Okabe-Ito blue */
+  --wip-by-column-chart-bar-text-color: #ffffff;
+  --wip-by-column-chart-limit-line-color: #D55E00;        /* Okabe-Ito vermilion */
+  --wip-by-column-chart-recommendation-color: #009E73;    /* Okabe-Ito bluish green */
+
   --estimate-accuracy-chart-completed-fill-color: #00ff00;
   --estimate-accuracy-chart-completed-border-color: green;
   --estimate-accuracy-chart-active-fill-color: #FFCCCB;
@@ -233,6 +238,10 @@ html[data-theme="dark"] {
   --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;          /* Okabe-Ito sky blue */
+  --wip-by-column-chart-bar-text-color: #000000;
+  --wip-by-column-chart-limit-line-color: #E69F00;        /* Okabe-Ito orange */
+  --wip-by-column-chart-recommendation-color: #2DCB9A;    /* lighter bluish green for dark bg */
   --wip-chart-completed-color: #03cb03;
   --wip-chart-duration-less-than-day-color: #d2d988;
   --wip-chart-duration-week-or-less-color: #dfcd00;
@@ -274,6 +283,10 @@ html[data-theme="light"] {
   --wip-chart-active-color: #326cff;
   --status-category-inprogress-color: #2663ff;
   --hierarchy-table-inactive-item-text-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;
   --wip-chart-completed-color: #00ff00;
   --wip-chart-duration-less-than-day-color: #ffef41;
   --wip-chart-duration-week-or-less-color: #dcc900;
@@ -352,6 +365,11 @@ html[data-theme="light"] {
 
     --status-category-inprogress-color: #1c49bb;
 
+    --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;
+
     --cycletime-scatterplot-overall-trendline-color: gray;
 
     --hierarchy-table-inactive-item-text-color: #939393;

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_report_config.rb

@@ -33,17 +33,35 @@ 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
 
     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
   rescue NameError
     super
   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)
@@ -98,22 +116,6 @@ 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*')}"
   end

data/lib/jirametrics/project_config.rb

@@ -453,7 +453,7 @@ class ProjectConfig
   # To be used by the aggregate_config only. Not intended to be part of the public API
   def add_issues issues_list
     @issues = IssueCollection.new if @issues.nil?
-    @all_boards = {}
+    @all_boards ||= {}
 
     issues_list.each do |issue|
       @issues << issue

data/lib/jirametrics/wip_by_column_chart.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require 'jirametrics/chart_base'
+
+class WipByColumnChart < ChartBase
+  attr_accessor :possible_statuses, :board_id
+
+  ColumnStats = Struct.new(:name, :min_wip_limit, :max_wip_limit, :wip_history, keyword_init: true)
+
+  def initialize block
+    super()
+    header_text 'WIP by column'
+    description_text <<-HTML
+      <p>
+        This chart shows how much time each board column has spent at different WIP (Work in Progress) levels.
+      </p>
+      <p>
+        Each row on the Y axis is a WIP level (the number of items in that column at the same time).
+        Each column on the X axis is a board column.
+        The horizontal bars show what percentage of the total time that column spent at that WIP level —
+        a wider bar means more time was spent there.
+      </p>
+      <p>
+        A column whose widest bar is at WIP&nbsp;1 was almost always working on one item at a time, often called
+        single-piece-flow. This team is likely collaborating very well and might have been
+        <a href="https://blog.mikebowler.ca/2021/06/19/pair-programming/">pairing</a> or
+        <a href="https://blog.mikebowler.ca/2023/04/22/ensemble-programming/">mobbing/ensembling</a>
+        and these teams tend to be very effective.
+      </p>
+      <p>
+        A column with wide bars at high WIP levels usually indicates a team that is highly siloed. Where each person
+        is working by themselves.
+      </p>
+      <p>
+        The dashed lines show the minimum and maximum WIP limits configured on the board.
+        If the widest bar sits well above the maximum limit, the limit may be set too low or not being respected.
+        If the widest bar sits below the minimum limit, consider whether that limit is still meaningful.
+      </p>
+      <p>
+        Hover over any bar to see the exact percentage.
+      </p>
+      <% if @all_boards[@board_id].team_managed_kanban? %>
+        <p>
+          If the data looks a bit off then that's probably because you're using a Team Managed project in "kanban mode".
+          For this specific case, we are unable to tell if an item is actually visible on the board and so we may
+          be reporting more items started than you actually see on the board. See
+          <a href="https://jirametrics.org/faq/#team-managed-kanban-backlog">the FAQ</a>.
+        </p>
+      <% end %>
+    HTML
+
+    instance_eval(&block)
+  end
+
+  def show_recommendations
+    @show_recommendations = true
+  end
+
+  def run
+    @header_text += " on board: #{current_board.name}"
+    stats = column_stats
+    @column_names = stats.collect(&:name)
+    @wip_data = stats.collect do |stat|
+      total = stat.wip_history.sum { |_wip, seconds| seconds }.to_f
+      next [] if total.zero?
+
+      stat.wip_history.collect { |wip, seconds| { 'wip' => wip, 'pct' => format_pct(seconds, total) } }
+    end
+    @max_wip = stats.flat_map { |s| s.wip_history.collect { |wip, _| wip } }.max || 0
+    @wip_limits = stats.collect { |s| { 'min' => s.min_wip_limit, 'max' => s.max_wip_limit } }
+    @recommendations = @show_recommendations ? compute_recommendations(stats) : Array.new(stats.size)
+
+    trim_zero_end_columns
+    @recommendation_texts = @show_recommendations ? build_recommendation_texts : []
+
+    wrap_and_render(binding, __FILE__)
+  end
+
+  def column_stats
+    board = current_board
+    columns = board.visible_columns
+    status_to_column = build_status_to_column_map(columns)
+    relevant_issues = @issues.select { |issue| issue.board.id == @board_id }
+
+    current_column = initial_column_state(relevant_issues, status_to_column)
+    events = events_within_range(relevant_issues, status_to_column)
+    column_wip_seconds = compute_wip_seconds(columns, current_column, events)
+
+    columns.collect.with_index do |column, index|
+      ColumnStats.new(
+        name: column.name,
+        min_wip_limit: column.min,
+        max_wip_limit: column.max,
+        wip_history: column_wip_seconds[index].sort.to_a
+      )
+    end
+  end
+
+  private
+
+  def trim_zero_end_columns
+    all_zero = @wip_data.map { |col| col.none? { |e| e['wip'].positive? } }
+    first = all_zero.index(false)
+    return unless first
+
+    last = all_zero.rindex(false)
+    @column_names    = @column_names[first..last]
+    @wip_data        = @wip_data[first..last]
+    @wip_limits      = @wip_limits[first..last]
+    @recommendations = @recommendations[first..last]
+    @max_wip         = @wip_data.flat_map { |col| col.map { |e| e['wip'] } }.max || 0
+  end
+
+  def compute_recommendations stats
+    stats.collect do |stat|
+      next nil if stat.wip_history.empty?
+
+      total = stat.wip_history.sum { |_wip, seconds| seconds }.to_f
+      next nil if total.zero?
+
+      cumulative = 0
+      stat.wip_history.sort.find do |_wip, seconds|
+        cumulative += seconds
+        cumulative / total >= 0.85
+      end&.first
+    end
+  end
+
+  def build_recommendation_texts
+    @column_names.each_with_index.filter_map do |name, i|
+      rec = @recommendations[i]
+      next if rec.nil?
+
+      next "Almost nothing passes through column '#{name}'. Do we still need it?" if rec.zero?
+
+      max = @wip_limits[i]['max']
+      if max.nil?
+        "Add a WIP limit to column '#{name}' — suggested maximum: #{rec}"
+      elsif rec < max
+        "Lower the WIP limit for '#{name}' from #{max} to #{rec}"
+      elsif rec > max
+        "Raise the WIP limit for '#{name}' from #{max} to #{rec}"
+      end
+    end
+  end
+
+  def format_pct seconds, total
+    raw = seconds / total * 100.0
+    (1..10).each do |decimals|
+      rounded = raw.round(decimals)
+      next if rounded.zero? && raw.positive?
+      next if rounded >= 100.0 && raw < 100.0
+
+      return rounded
+    end
+    raw
+  end
+
+  def build_status_to_column_map columns
+    columns.each_with_object({}).with_index do |(column, map), index|
+      column.status_ids.each { |id| map[id] = index }
+    end
+  end
+
+  def initial_column_state relevant_issues, status_to_column
+    relevant_issues.each_with_object({}) do |issue, hash|
+      started_time, stopped_time = issue.board.cycletime.started_stopped_times(issue)
+      in_wip = started_time &&
+               started_time <= time_range.begin &&
+               (stopped_time.nil? || stopped_time > time_range.begin)
+      unless in_wip
+        hash[issue] = nil
+        next
+      end
+
+      last_change = issue.status_changes.reverse.find { |c| c.time <= time_range.begin }
+      hash[issue] = last_change ? status_to_column[last_change.value_id] : nil
+    end
+  end
+
+  def events_within_range relevant_issues, status_to_column
+    events = []
+    relevant_issues.each do |issue|
+      started_time, stopped_time = issue.board.cycletime.started_stopped_times(issue)
+      next unless started_time
+
+      # Issue starts within the window: add an explicit event to enter WIP in its current column
+      if started_time > time_range.begin && started_time <= time_range.end
+        last_change = issue.status_changes.reverse.find { |c| c.time <= started_time }
+        events << [started_time, issue, last_change ? status_to_column[last_change.value_id] : nil]
+      end
+
+      # Status changes while the issue is actively in WIP and within the window
+      issue.status_changes.each do |change|
+        next unless change.time > time_range.begin
+        next if change.time > time_range.end
+        next unless change.time >= started_time
+        next if stopped_time && change.time >= stopped_time
+
+        events << [change.time, issue, status_to_column[change.value_id]]
+      end
+
+      # Issue stops within the window: add an explicit event to exit WIP
+      if stopped_time && stopped_time > time_range.begin && stopped_time <= time_range.end
+        events << [stopped_time, issue, nil]
+      end
+    end
+    events.sort_by!(&:first)
+  end
+
+  def compute_wip_seconds columns, current_column, events
+    wip_counts = Array.new(columns.size, 0)
+    current_column.each_value { |col| wip_counts[col] += 1 unless col.nil? }
+
+    column_wip_seconds = Array.new(columns.size) { Hash.new(0) }
+    prev_time = time_range.begin
+
+    events.each do |time, issue, new_col|
+      elapsed = (time - prev_time).to_i
+      if elapsed.positive?
+        wip_counts.each_with_index { |wip, idx| column_wip_seconds[idx][wip] += elapsed }
+        prev_time = time
+      end
+
+      old_col = current_column[issue]
+      wip_counts[old_col] -= 1 unless old_col.nil?
+      wip_counts[new_col] += 1 unless new_col.nil?
+      current_column[issue] = new_col
+    end
+
+    elapsed = (time_range.end - prev_time).to_i
+    wip_counts.each_with_index { |wip, idx| column_wip_seconds[idx][wip] += elapsed } if elapsed.positive?
+
+    column_wip_seconds
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jirametrics
 version: !ruby/object:Gem::Version
-  version: '2.28'
+  version: '2.29'
 platform: ruby
 authors:
 - Mike Bowler
@@ -154,6 +154,7 @@ files:
 - lib/jirametrics/html/throughput_chart.erb
 - lib/jirametrics/html/time_based_histogram.erb
 - lib/jirametrics/html/time_based_scatterplot.erb
+- lib/jirametrics/html/wip_by_column_chart.erb
 - lib/jirametrics/html_generator.rb
 - lib/jirametrics/html_report_config.rb
 - lib/jirametrics/issue.rb
@@ -185,6 +186,7 @@ files:
 - lib/jirametrics/trend_line_calculator.rb
 - lib/jirametrics/user.rb
 - lib/jirametrics/value_equality.rb
+- lib/jirametrics/wip_by_column_chart.rb
 homepage: https://jirametrics.org
 licenses:
 - Apache-2.0
@@ -207,7 +209,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.8
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Extract Jira metrics
 test_files: []