jirametrics 2.31 → 3.0

data/lib/jirametrics/downloader_for_cloud.rb

@@ -130,7 +130,7 @@ class DownloaderForCloud < Downloader
     issue_datas
   end
 
-  def attach_worklogs_to_issues issue_datas:, issue_jsons:, max_results: 100 # rubocop:disable Lint/UnusedMethodArgument
+  def attach_worklogs_to_issues issue_datas:, issue_jsons:, max_results: 100
     issue_jsons.each do |issue_json|
       worklog = issue_json['fields']['worklog']
       next unless worklog
@@ -140,27 +140,7 @@ class DownloaderForCloud < Downloader
       next if all_worklogs.size >= total
 
       key = issue_json['key']
-      start_at = all_worklogs.size
-
-      loop do
-        response = @jira_gateway.call_url(
-          relative_url: "/rest/api/3/issue/#{CGI.escape(key)}/worklog?startAt=#{start_at}&maxResults=#{max_results}"
-        )
-
-        worklogs = response['worklogs'] || []
-        all_worklogs.concat(worklogs)
-
-        total = response['total'].to_i
-        log "        #{key} worklogs: page startAt=#{start_at}, " \
-            "received=#{worklogs.size}, fetched=#{all_worklogs.size}/#{total}"
-        break if all_worklogs.size >= total
-        # Guard against Jira reporting a higher total than it will actually return — seen when
-        # worklogs are deleted or access-restricted after the initial fetch. Without this,
-        # start_at never advances and we loop forever requesting the same empty page.
-        break if worklogs.empty?
-
-        start_at += worklogs.size
-      end
+      fetch_remaining_worklogs key: key, all_worklogs: all_worklogs, max_results: max_results
 
       issue_json['fields']['worklog'] = {
         'startAt' => 0,
@@ -173,6 +153,30 @@ class DownloaderForCloud < Downloader
     end
   end
 
+  # Page through the worklogs Jira didn't include inline, appending each page to all_worklogs.
+  def fetch_remaining_worklogs key:, all_worklogs:, max_results:
+    start_at = all_worklogs.size
+    loop do
+      response = @jira_gateway.call_url(
+        relative_url: "/rest/api/3/issue/#{CGI.escape(key)}/worklog?startAt=#{start_at}&maxResults=#{max_results}"
+      )
+
+      worklogs = response['worklogs'] || []
+      all_worklogs.concat(worklogs)
+
+      total = response['total'].to_i
+      log "        #{key} worklogs: page startAt=#{start_at}, " \
+          "received=#{worklogs.size}, fetched=#{all_worklogs.size}/#{total}"
+      break if all_worklogs.size >= total
+      # Guard against Jira reporting a higher total than it will actually return — seen when
+      # worklogs are deleted or access-restricted after the initial fetch. Without this,
+      # start_at never advances and we loop forever requesting the same empty page.
+      break if worklogs.empty?
+
+      start_at += worklogs.size
+    end
+  end
+
   def attach_changelog_to_issues issue_datas:, issue_jsons:
     max_results = 10_000 # The max jira accepts is 10K
     payload = {
@@ -212,71 +216,59 @@ class DownloaderForCloud < Downloader
 
   def download_issues board:
     log "  Downloading primary issues for board #{board.id} from #{jira_instance_type}", both: true
+    path = ensure_issues_directory
+    issue_data_hash = search_for_issues jql: build_jql(board), board_id: board.id, path: path
+
+    download_all_issues board: board, path: path, issue_data_hash: issue_data_hash
+
+    delete_issues_from_cache_that_are_not_in_server(
+      issue_data_hash: issue_data_hash, path: path
+    )
+  end
+
+  def ensure_issues_directory
     path = File.join(@target_path, "#{file_prefix}_issues/")
     unless @file_system.dir_exist?(path)
       log "  Creating path #{path}"
       @file_system.mkdir(path)
     end
+    path
+  end
 
-    filter_id = @board_id_to_filter_id[board.id]
-    jql = make_jql(filter_id: filter_id)
+  def build_jql board
+    jql = make_jql(filter_id: @board_id_to_filter_id[board.id])
     intercept_jql = @download_config.project_config.settings['intercept_jql']
-    jql = intercept_jql.call jql if intercept_jql
-
-    issue_data_hash = search_for_issues jql: jql, board_id: board.id, path: path
+    intercept_jql ? intercept_jql.call(jql) : jql
+  end
 
+  # Downloads the primary issues, then repeatedly follows related issues (parents, subtasks, links)
+  # until no new ones turn up. `in_related_phase` is false for the first pass and true thereafter,
+  # which controls the once-only "Identifying related issues" announcement and the loop diagnostics.
+  def download_all_issues board:, path:, issue_data_hash:
     checked_for_related = Set.new
     in_related_phase = false
 
     loop do
       related_issue_keys = Set.new
-      stale = issue_data_hash.values.reject { |data| data.up_to_date }
+      stale = issue_data_hash.values.reject(&:up_to_date)
       if in_related_phase
         @file_system.diagnostic "Download loop: #{issue_data_hash.size} total known, " \
                                 "#{stale.size} stale, #{checked_for_related.size} link-scanned"
       end
-      unless stale.empty?
-        log_start '  Downloading more issues ' unless in_related_phase
-        stale.each_slice(100) do |slice|
-          slice = bulk_fetch_issues(issue_datas: slice, board: board, in_initial_query: !in_related_phase)
-          progress_dot
-          slice.each do |data|
-            next unless data.issue
-
-            @file_system.save_json(
-              json: data.issue.raw, filename: data.cache_path
-            )
-            # Set the timestamp on the file to match the updated one so that we don't have
-            # to parse the file just to find the timestamp
-            @file_system.utime time: data.issue.updated, file: data.cache_path
-
-            collect_or_log_related(
-              issue: data.issue, found_in_primary_query: data.found_in_primary_query,
-              related_issue_keys: related_issue_keys, issue_data_hash: issue_data_hash
-            )
-            checked_for_related << data.key
-          end
-        end
-        end_progress unless in_related_phase
-      end
+      download_stale_issues(
+        stale: stale, board: board, in_related_phase: in_related_phase,
+        checked_for_related: checked_for_related, related_issue_keys: related_issue_keys,
+        issue_data_hash: issue_data_hash
+      )
 
       scan_cached_issues_for_related(
         issue_data_hash: issue_data_hash, board: board,
         checked_for_related: checked_for_related, related_issue_keys: related_issue_keys
       )
-
-      # Remove all the ones we already have
-      related_issue_keys.reject! { |key| issue_data_hash[key] }
-
-      related_issue_keys.each do |key|
-        data = DownloadIssueData.new key: key
-        data.found_in_primary_query = false
-        data.up_to_date = false
-        data.cache_path = File.join(path, "#{key}-#{board.id}.json")
-        issue_data_hash[key] = data
-      end
+      register_related_issues(
+        related_issue_keys: related_issue_keys, issue_data_hash: issue_data_hash, path: path, board: board
+      )
       break if related_issue_keys.empty?
-
       next if in_related_phase
 
       in_related_phase = true
@@ -285,10 +277,52 @@ class DownloaderForCloud < Downloader
     end
 
     end_progress if in_related_phase
+  end
 
-    delete_issues_from_cache_that_are_not_in_server(
-      issue_data_hash: issue_data_hash, path: path
-    )
+  def download_stale_issues stale:, board:, in_related_phase:, checked_for_related:, related_issue_keys:,
+                            issue_data_hash:
+    return if stale.empty?
+
+    log_start '  Downloading more issues ' unless in_related_phase
+    stale.each_slice(100) do |slice|
+      slice = bulk_fetch_issues(issue_datas: slice, board: board, in_initial_query: !in_related_phase)
+      progress_dot
+      save_fetched_issues(
+        slice: slice, checked_for_related: checked_for_related,
+        related_issue_keys: related_issue_keys, issue_data_hash: issue_data_hash
+      )
+    end
+    end_progress unless in_related_phase
+  end
+
+  def save_fetched_issues slice:, checked_for_related:, related_issue_keys:, issue_data_hash:
+    slice.each do |data|
+      next unless data.issue
+
+      @file_system.save_json(json: data.issue.raw, filename: data.cache_path)
+      # Set the timestamp on the file to match the updated one so that we don't have
+      # to parse the file just to find the timestamp
+      @file_system.utime time: data.issue.updated, file: data.cache_path
+
+      collect_or_log_related(
+        issue: data.issue, found_in_primary_query: data.found_in_primary_query,
+        related_issue_keys: related_issue_keys, issue_data_hash: issue_data_hash
+      )
+      checked_for_related << data.key
+    end
+  end
+
+  def register_related_issues related_issue_keys:, issue_data_hash:, path:, board:
+    # Remove all the ones we already have
+    related_issue_keys.reject! { |key| issue_data_hash[key] }
+
+    related_issue_keys.each do |key|
+      data = DownloadIssueData.new key: key
+      data.found_in_primary_query = false
+      data.up_to_date = false
+      data.cache_path = File.join(path, "#{key}-#{board.id}.json")
+      issue_data_hash[key] = data
+    end
   end
 
   def delete_issues_from_cache_that_are_not_in_server issue_data_hash:, path:
@@ -348,18 +382,20 @@ class DownloaderForCloud < Downloader
     parent_key = issue.parent_key(project_config: @download_config.project_config)
     keys << parent_key if parent_key
 
-    issue.raw['fields']['subtasks']&.each do |raw_subtask|
-      keys << raw_subtask['key']
-    end
+    issue.raw['fields']['subtasks']&.each { |raw_subtask| keys << raw_subtask['key'] }
+    add_linked_issue_keys issue, keys
+
+    keys
+  end
 
+  # Add the keys of issues linked to this one, skipping clone links (a clone isn't a dependency).
+  def add_linked_issue_keys issue, keys
     issue.raw['fields']['issuelinks']&.each do |link|
       next if link['type']['name'] == 'Cloners'
 
       linked = link['inwardIssue'] || link['outwardIssue']
       keys << linked['key'] if linked
     end
-
-    keys
   end
 
   # We only follow links one hop out from the primary (board) issues. If a related issue

data/lib/jirametrics/estimate_accuracy_chart.rb

@@ -110,25 +110,25 @@ class EstimateAccuracyChart < ChartBase
   def split_into_completed_and_aging issues:
     aging_hash = {}
     completed_hash = {}
+    issues.each { |issue| bucket_issue_by_estimate issue, completed_hash: completed_hash, aging_hash: aging_hash }
+    [completed_hash, aging_hash]
+  end
 
-    issues.each do |issue|
-      cycletime = issue.board.cycletime
-      start_time, stop_time = cycletime.started_stopped_times(issue)
+  def bucket_issue_by_estimate issue, completed_hash:, aging_hash:
+    cycletime = issue.board.cycletime
+    start_time, stop_time = cycletime.started_stopped_times(issue)
 
-      next unless start_time
+    return unless start_time
 
-      hash = stop_time ? completed_hash : aging_hash
+    hash = stop_time ? completed_hash : aging_hash
 
-      estimate = @y_axis_block.call issue, start_time
-      cycle_time = ((stop_time&.to_date || date_range.end) - start_time.to_date).to_i + 1
+    estimate = @y_axis_block.call issue, start_time
+    cycle_time = ((stop_time&.to_date || date_range.end) - start_time.to_date).to_i + 1
 
-      next if estimate.nil?
+    return if estimate.nil?
 
-      key = [estimate, cycle_time]
-      (hash[key] ||= []) << issue
-    end
-
-    [completed_hash, aging_hash]
+    key = [estimate, cycle_time]
+    (hash[key] ||= []) << issue
   end
 
   def hash_sorter

data/lib/jirametrics/examples/standard_project.rb

@@ -35,7 +35,7 @@ class Exporter
       download do
         self.rolling_date_count(rolling_date_count) if rolling_date_count
         self.no_earlier_than(no_earlier_than) if no_earlier_than
-        github_repo *github_repos if github_repos
+        github_repo(*github_repos) if github_repos
       end
 
       issues.reject! do |issue|
@@ -44,7 +44,7 @@ class Exporter
 
       exporter.filter_issues issues, ignore_issues
 
-      discard_changes_before status_becomes: (starting_status || :backlog) # rubocop:disable Style/RedundantParentheses
+      discard_changes_before status_becomes: (starting_status || :backlog)
 
       file do
         file_suffix '.html'

data/lib/jirametrics/expedited_chart.rb

@@ -67,12 +67,7 @@ class ExpeditedChart < ChartBase
       if expedited_priority_names.include? change.value
         expedite_start = change.time.to_date
       elsif expedite_start
-        start_date = expedite_start.to_date
-        stop_date = change.time.to_date
-
-        if date_range.include?(start_date) || date_range.include?(stop_date) ||
-           (start_date < date_range.begin && stop_date > date_range.end)
-
+        if expedite_visible?(expedite_start, change.time.to_date)
           result << [expedite_start, :expedite_start]
           result << [change.time.to_date, :expedite_stop]
         end
@@ -85,6 +80,13 @@ class ExpeditedChart < ChartBase
     result
   end
 
+  # True when an expedite span overlaps the chart's date range: either endpoint falls inside it, or it
+  # starts before and ends after (spanning the whole range).
+  def expedite_visible? start_date, stop_date
+    date_range.include?(start_date) || date_range.include?(stop_date) ||
+      (start_date < date_range.begin && stop_date > date_range.end)
+  end
+
   def find_expedited_issues
     expedited_issues = @issues.reject do |issue|
       prepare_expedite_data(issue).empty?
@@ -110,8 +112,7 @@ class ExpeditedChart < ChartBase
   end
 
   def make_expedite_lines_data_set issue:, expedite_data:
-    cycletime = issue.board.cycletime
-    started_date, stopped_date = cycletime.started_stopped_dates(issue)
+    started_date, stopped_date = issue.board.cycletime.started_stopped_dates(issue)
 
     expedite_data << [started_date, :issue_started] if started_date
     expedite_data << [stopped_date, :issue_stopped] if stopped_date
@@ -126,37 +127,16 @@ class ExpeditedChart < ChartBase
     expedited = false
 
     expedite_data.each do |time, action|
-      case action
-      when :issue_started
-        data << make_point(issue: issue, time: time, label: 'Started', expedited: expedited)
-        dot_colors << CssVariable['--expedited-chart-dot-issue-started-color']
-        point_styles << 'rect'
-      when :issue_stopped
-        data << make_point(issue: issue, time: time, label: 'Completed', expedited: expedited)
-        dot_colors << CssVariable['--expedited-chart-dot-issue-stopped-color']
-        point_styles << 'rect'
-      when :expedite_start
-        data << make_point(issue: issue, time: time, label: 'Expedited', expedited: true)
-        dot_colors << CssVariable['--expedited-chart-dot-expedite-started-color']
-        point_styles << 'circle'
-        expedited = true
-      when :expedite_stop
-        data << make_point(issue: issue, time: time, label: 'Not expedited', expedited: false)
-        dot_colors << CssVariable['--expedited-chart-dot-expedite-stopped-color']
-        point_styles << 'circle'
-        expedited = false
-      else
-        raise "Unexpected action: #{action}"
-      end
+      point, color, style, expedited = expedite_point(issue, time, action, expedited)
+      data << point
+      dot_colors << color
+      point_styles << style
     end
 
-    unless expedite_data.empty?
-      last_change_time = expedite_data[-1][0].to_date
-      if last_change_time && last_change_time <= date_range.end && stopped_date.nil?
-        data << make_point(issue: issue, time: date_range.end, label: 'Still ongoing', expedited: expedited)
-        dot_colors << '' # It won't be visible so it doesn't matter
-        point_styles << 'dash'
-      end
+    if still_ongoing?(expedite_data, stopped_date)
+      data << make_point(issue: issue, time: date_range.end, label: 'Still ongoing', expedited: expedited)
+      dot_colors << '' # It won't be visible so it doesn't matter
+      point_styles << 'dash'
     end
 
     {
@@ -171,4 +151,34 @@ class ExpeditedChart < ChartBase
       segment: EXPEDITED_SEGMENT
     }
   end
+
+  # Returns [point, dot_color, point_style, expedited] for one timeline event. The returned expedited
+  # flag carries the (possibly changed) state forward to the next event.
+  def expedite_point issue, time, action, expedited
+    case action
+    when :issue_started
+      [make_point(issue: issue, time: time, label: 'Started', expedited: expedited),
+       CssVariable['--expedited-chart-dot-issue-started-color'], 'rect', expedited]
+    when :issue_stopped
+      [make_point(issue: issue, time: time, label: 'Completed', expedited: expedited),
+       CssVariable['--expedited-chart-dot-issue-stopped-color'], 'rect', expedited]
+    when :expedite_start
+      [make_point(issue: issue, time: time, label: 'Expedited', expedited: true),
+       CssVariable['--expedited-chart-dot-expedite-started-color'], 'circle', true]
+    when :expedite_stop
+      [make_point(issue: issue, time: time, label: 'Not expedited', expedited: false),
+       CssVariable['--expedited-chart-dot-expedite-stopped-color'], 'circle', false]
+    else
+      raise "Unexpected action: #{action}"
+    end
+  end
+
+  # The issue is still expedited/open at the end of the chart: it hasn't stopped and its last recorded
+  # change is on or before the end of the range.
+  def still_ongoing? expedite_data, stopped_date
+    return false if expedite_data.empty?
+
+    last_change_time = expedite_data[-1][0].to_date
+    last_change_time && last_change_time <= date_range.end && stopped_date.nil?
+  end
 end

data/lib/jirametrics/exporter.rb

@@ -8,7 +8,9 @@ class Exporter
 
   def self.configure &block
     logfile_name = 'jirametrics.log'
-    logfile = File.open(logfile_name, 'w')
+    # No block form: FileSystem holds this descriptor open for the whole run and writes to it as we
+    # go, so it must outlive this method.
+    logfile = File.open(logfile_name, 'w') # rubocop:disable Style/FileOpen
   rescue Errno::EACCES
     # FileSystem can't be used here — it hasn't been created yet (it depends on this logfile).
     warn "Error: Cannot write to #{File.expand_path(logfile_name)}. " \
@@ -78,12 +80,7 @@ class Exporter
       project.evaluate_next_level
 
       project.run load_only: true
-      project.issues.each do |issue|
-        selected << [project, issue] if key == issue.key
-        issue.subtasks.each do |subtask|
-          selected << [project, subtask] if key == subtask.key
-        end
-      end
+      selected.concat matching_issues_in(project, key)
     rescue => e # rubocop:disable Style/RescueStandardError
       # This happens when we're attempting to load an aggregated project because it hasn't been
       # properly initialized. Since we don't care about aggregated projects, we just ignore it.
@@ -101,6 +98,17 @@ class Exporter
     end
   end
 
+  def matching_issues_in project, key
+    matches = []
+    project.issues.each do |issue|
+      matches << [project, issue] if key == issue.key
+      issue.subtasks.each do |subtask|
+        matches << [project, subtask] if key == subtask.key
+      end
+    end
+    matches
+  end
+
   def stitch stitch_file
     Stitcher.new(file_system: file_system).run(stitch_file: stitch_file)
   end
@@ -139,7 +147,8 @@ class Exporter
       @jira_config = file_system.load_json(filename, fail_on_error: false)
       raise "Unable to load Jira configuration file and cannot continue: #{filename.inspect}" if @jira_config.nil?
 
-      @jira_config['url'] = $1 if @jira_config['url'] =~ /^(.+)\/+$/
+      match = %r{^(?<base_url>.+)/+$}.match(@jira_config['url'])
+      @jira_config['url'] = match[:base_url] if match
     end
     @jira_config
   end
@@ -153,8 +162,8 @@ class Exporter
     unless args.empty?
       dates = []
       args.each do |arg|
-        if arg =~ /^(\d{4}-\d{2}-\d{2})\.\.(\d{4}-\d{2}-\d{2})$/
-          Date.parse($1).upto(Date.parse($2)).each { |date| dates << date }
+        if /^(?<from>\d{4}-\d{2}-\d{2})\.\.(?<to>\d{4}-\d{2}-\d{2})$/ =~ arg
+          Date.parse(from).upto(Date.parse(to)).each { |date| dates << date }
         else
           dates << Date.parse(arg)
         end

data/lib/jirametrics/file_config.rb

@@ -5,11 +5,12 @@ require 'csv'
 class FileConfig
   attr_reader :project_config, :issues
 
-  def initialize project_config:, block:, today: Date.today
+  def initialize project_config:, block:, today: Date.today, issues: nil
     @project_config = project_config
     @block = block
     @columns = nil
     @today = today
+    @issues = issues
   end
 
   def run
@@ -65,22 +66,28 @@ class FileConfig
   # most common usecase - the Team Dashboard from FocusedObjective.com. The rule for that one
   # is that all empty values in the first column should be at the bottom.
   def sort_output all_lines
-    all_lines.each_with_index.sort do |(a, a_idx), (b, b_idx)|
-      result = if a[0] == b[0]
-        a[1..] <=> b[1..]
-      elsif a[0].nil?
-        1
-      elsif b[0].nil?
-        -1
-      else
-        a[0] <=> b[0]
-      end
+    all_lines.each_with_index.sort do |(left, left_idx), (right, right_idx)|
+      result = compare_rows left, right
 
       # When objects aren't comparable, preserve original order for a stable sort.
-      result.nil? || result.zero? ? a_idx <=> b_idx : result
+      result.nil? || result.zero? ? left_idx <=> right_idx : result
     end.map(&:first)
   end
 
+  # Compare two rows by their first column, falling back to the remaining columns on a tie, and
+  # sorting nil first columns to the bottom.
+  def compare_rows left, right
+    if left[0] == right[0]
+      left[1..] <=> right[1..]
+    elsif left[0].nil?
+      1
+    elsif right[0].nil?
+      -1
+    else
+      left[0] <=> right[0]
+    end
+  end
+
   def columns &block
     assert_only_one_filetype_config_set
     @columns = ColumnsConfig.new file_config: self, block: block

data/lib/jirametrics/file_system.rb

@@ -2,6 +2,10 @@
 
 require 'json'
 
+# This is the stderr display/logging layer: it writes progress and log output straight to $stderr
+# (see the $stderr.print/.flush calls). That output isn't warnings, so $stderr.puts is intentional
+# throughout rather than warn.
+# rubocop:disable Style/StderrPuts
 class FileSystem
   attr_accessor :logfile, :logfile_name, :log_only
 
@@ -14,18 +18,14 @@ class FileSystem
   end
 
   # Effectively the same as File.read except it forces the encoding to UTF-8
-  def load filename, supress_deprecation: false
-    if filename.end_with?('.json') && !supress_deprecation
-      deprecated(message: 'call load_json instead', date: '2024-11-13')
-    end
-
+  def load filename
     File.read filename, encoding: 'UTF-8'
   end
 
   def load_json filename, fail_on_error: true
     return nil if fail_on_error == false && File.exist?(filename) == false
 
-    JSON.parse load(filename, supress_deprecation: true)
+    JSON.parse load(filename)
   end
 
   def save_json json:, filename:
@@ -70,7 +70,7 @@ class FileSystem
     # set up. Quick escape here so that we don't dump the error twice.
     return if logfile == $stdout
 
-    $stderr.puts message # rubocop:disable Style/StderrPuts
+    $stderr.puts message
   end
 
   def log_start message
@@ -98,21 +98,26 @@ class FileSystem
   def end_progress
     return if log_only
 
-    $stderr.puts '' # rubocop:disable Style/StderrPuts
+    $stderr.puts ''
   end
 
   # In some Jira instances, a sizeable portion of the JSON is made up of empty fields. I've seen
   # cases where this simple compression will drop the filesize by half.
   def compress node
     if node.is_a? Hash
-      node.reject! { |_key, value| value.nil? || (value.is_a?(Array) && value.empty?) }
+      node.reject! { |_key, value| prunable? value }
       node.each_value { |value| compress value }
     elsif node.is_a? Array
-      node.each { |a| compress a }
+      node.each { |element| compress element }
     end
     node
   end
 
+  # A value worth dropping from the compressed output: nothing there, or an empty array.
+  def prunable? value
+    value.nil? || (value.is_a?(Array) && value.empty?)
+  end
+
   def foreach root, &block
     Dir.foreach root, &block
   end
@@ -139,3 +144,4 @@ class FileSystem
     log text, also_write_to_stderr: true
   end
 end
+# rubocop:enable Style/StderrPuts

data/lib/jirametrics/flow_efficiency_calculator.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# Walks a stream of BlockedStalledChange entries and totals up the value-add (active) time between
+# issue_start and end_time. It's handed the already-computed stream and the resolved start/end so it
+# never reaches back through the issue's collaborators.
+#
+# Returns [value_add_seconds, total_seconds].
+class FlowEfficiencyCalculator
+  def initialize blocked_stalled_changes:, issue_start:, end_time:
+    @blocked_stalled_changes = blocked_stalled_changes
+    @issue_start = issue_start
+    @end_time = end_time
+  end
+
+  def calculate
+    @active_start = nil
+    @value_add_time = 0.0
+
+    @blocked_stalled_changes.each_with_index do |change, index|
+      break if change.time > @end_time
+
+      process change, index
+    end
+
+    close_final_active_period
+
+    [@value_add_time, @end_time - @issue_start]
+  end
+
+  def process change, index
+    if index.zero?
+      @active_start = change.time if change.active?
+      return
+    end
+
+    process_transition change
+  end
+
+  def process_transition change
+    # Already active and we just got another active.
+    return 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.
+      record_active_period ending_at: change.time
+      @active_start = nil
+    end
+  end
+
+  def record_active_period ending_at:
+    @value_add_time += ending_at - [@issue_start, @active_start].max
+  end
+
+  def close_final_active_period
+    return unless @active_start
+
+    change_delta = @end_time - [@issue_start, @active_start].max
+    @value_add_time += change_delta if change_delta.positive?
+  end
+end