jirametrics 2.4 → 2.30

data/lib/jirametrics/status_collection.rb

@@ -4,68 +4,113 @@ class StatusNotFoundError < StandardError
 end
 
 class StatusCollection
+  attr_reader :historical_status_mappings
+
   def initialize
     @list = []
+    @historical_status_mappings = {} # 'name:id' => category
   end
 
-  def filter_status_names category_name:, including: nil, excluding: nil
-    including = expand_statuses including
-    excluding = expand_statuses excluding
+  # Return the status matching this id or nil if it can't be found.
+  def find_by_id id
+    @list.find { |status| status.id == id }
+  end
 
-    @list.filter_map do |status|
-      keep = status.category_name == category_name ||
-        including.any? { |s| s.name == status.name }
-      keep = false if excluding.any? { |s| s.name == status.name }
+  def find_by_id! id
+    status = @list.find { |status| status.id == id }
+    raise "Can't find any status for id #{id} in #{self}" unless status
 
-      status.name if keep
-    end
+    status
   end
 
-  def expand_statuses names_or_ids
-    result = []
-    return result if names_or_ids.nil?
-
-    names_or_ids = [names_or_ids] unless names_or_ids.is_a? Array
-
-    names_or_ids.each do |name_or_id|
-      status = @list.find { |s| s.name == name_or_id || s.id == name_or_id }
-      if status.nil?
-        if block_given?
-          yield name_or_id
-          next
-        else
-          all_status_names = @list.collect { |s| "#{s.name.inspect}:#{s.id.inspect}" }.uniq.sort.join(', ')
-          raise StatusNotFoundError, "Status not found: \"#{name_or_id}\". Possible statuses are: #{all_status_names}"
-        end
-      end
+  def find_all_by_name identifier
+    name, id = parse_name_id identifier
+
+    if id
+      status = find_by_id id
+      return [] if status.nil?
 
-      result << status
+      if name && status.name != name
+        raise "Specified status ID of #{id} does not match specified name #{name.inspect}. " \
+          "You might have meant one of these: #{self}."
+      end
+      [status]
+    else
+      @list.select { |status| status.name == name }
     end
-    result
   end
 
-  def todo including: nil, excluding: nil
-    filter_status_names category_name: 'To Do', including: including, excluding: excluding
+  def find_all_categories
+    @list
+      .collect(&:category)
+      .uniq
+      .sort_by(&:id)
   end
 
-  def in_progress including: nil, excluding: nil
-    filter_status_names category_name: 'In Progress', including: including, excluding: excluding
+  def parse_name_id name
+    # Names could arrive in one of the following formats: "Done:3", "3", "Done"
+    if name =~ /^(.*):(\d+)$/
+      [$1, $2.to_i]
+    elsif name.match?(/^\d+$/)
+      [nil, name.to_i]
+    else
+      [name, nil]
+    end
   end
 
-  def done including: nil, excluding: nil
-    filter_status_names category_name: 'Done', including: including, excluding: excluding
-  end
+  def find_all_categories_by_name identifier
+    key = nil
+    id = nil
 
-  def find_by_name name
-    find { |status| status.name == name }
+    if identifier.is_a? Symbol
+      key = identifier.to_s
+    else
+      name, id = parse_name_id identifier
+    end
+
+    find_all_categories.select { |c| c.id == id || c.name == name || c.key == key }
   end
 
-  def find(&block)= @list.find(&block)
   def collect(&block) = @list.collect(&block)
+  def find(&block) = @list.find(&block)
   def each(&block) = @list.each(&block)
   def select(&block) = @list.select(&block)
   def <<(arg) = @list << arg
   def empty? = @list.empty?
   def clear = @list.clear
   def delete(object) = @list.delete(object)
+
+  def to_s
+    "[#{@list.sort.join(', ')}]"
+  end
+
+  def inspect
+    "StatusCollection#{self}"
+  end
+
+  def fabricate_status_for id:, name:
+    category = @historical_status_mappings["#{name.inspect}:#{id.inspect}"]
+    category = in_progress_category if category.nil?
+
+    status = Status.new(
+      name: name,
+      id: id,
+      category_name: category.name,
+      category_id: category.id,
+      category_key: category.key,
+      artificial: true
+    )
+    @list << status
+    status
+  end
+
+  private
+
+  # Return the in-progress category or raise an error if we can't find one.
+  def in_progress_category
+    first_in_progress_status = find { |s| s.category.indeterminate? }
+    raise "Can't find even one in-progress status in #{self}" unless first_in_progress_status
+
+    first_in_progress_status.category
+  end
 end

data/lib/jirametrics/stitcher.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+class Stitcher < HtmlGenerator
+  class StitchContent
+    include ValueEquality
+
+    attr_reader :file, :title, :content, :type
+
+    def initialize file:, title:, type:, content:
+      @file = file
+      @title = title
+      @content = content
+      @type = type
+    end
+  end
+
+  attr_reader :loaded_files, :all_stitches
+
+  def initialize file_system:
+    super()
+    self.file_system = file_system
+    @all_stitches = []
+    @loaded_files = []
+  end
+
+  def run stitch_file:
+    output_filename = make_output_filename stitch_file
+    file_system.log "Creating file #{output_filename.inspect}", also_write_to_stderr: true
+    erb = ERB.new file_system.load(stitch_file)
+    @sections = [[erb.result(binding), :body]]
+    create_html output_filename: output_filename, settings: {}
+  end
+
+  def make_output_filename input_filename
+    if /^(.+)\.erb$/ =~ input_filename
+      "#{$1}.html"
+    else
+      "#{input_filename}.html"
+    end
+  end
+
+  def grab_by_title title, from_file:, type: 'chart'
+    parse_file from_file
+    stitch_content = @all_stitches.find { |s| s.file == from_file && s.title == title && s.type == type }
+    return stitch_content.content if stitch_content
+
+    file_system.error "Unable to find content in file #{from_file.inspect} matching title: #{title.inspect}"
+    ''
+  end
+
+  def parse_file filename
+    return false if @loaded_files.include? filename
+
+    # To match: <!-- seam-start | chart78 | GithubPrScatterplot | PR Scatterplot | chart -->
+    regex = /^<!-- seam-(?<seam>start|end) \| (?<id>[^|]+) \| (?<clazz>[^|]+) \| (?<title>[^|]+) \| (?<type>[^|]+) -->$/
+    content = nil
+    file_system.load(filename).lines do |line|
+      matches = line.match(regex)
+      if matches
+        if matches[:seam] == 'start'
+          content = +''
+        else
+          if content.nil? || content.strip.empty?
+            file_system.warning "Seam found with no content in #{filename.inspect}: " \
+              "id=#{matches[:id].strip.inspect}, class=#{matches[:clazz].strip.inspect}, " \
+              "title=#{matches[:title].strip.inspect}"
+          end
+          @all_stitches << Stitcher::StitchContent.new(
+            file: filename, title: matches[:title], type: matches[:type], content: content
+          )
+          content = nil
+        end
+      elsif content
+        content << line
+      end
+    end
+
+    @loaded_files << filename
+    true
+  end
+end

data/lib/jirametrics/throughput_by_completed_resolution_chart.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'jirametrics/throughput_chart'
+
+class ThroughputByCompletedResolutionChart < ThroughputChart
+  def initialize block
+    super
+    header_text 'Throughput, grouped by completion status and resolution'
+    description_text nil
+  end
+
+  def default_grouping_rules issue, rules
+    status, resolution = issue.status_resolution_at_done
+    if resolution
+      rules.label = "#{status.name}:#{resolution}"
+      rules.label_hint = "Status: #{status.name.inspect}:#{status.id}, resolution: #{resolution.inspect}"
+    else
+      rules.label = status.name
+      rules.label_hint = "Status: #{status.name.inspect}:#{status.id}"
+    end
+  end
+end

data/lib/jirametrics/throughput_chart.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'cgi'
+
 class ThroughputChart < ChartBase
   include GroupableIssueChart
 
@@ -10,42 +12,54 @@ class ThroughputChart < ChartBase
 
     header_text 'Throughput Chart'
     description_text <<-TEXT
-      <div class="p">
-        This chart shows how many items we completed per week
+      <div>Throughput data is very useful for#{' '}
+        <a href="https://blog.mikebowler.ca/2024/06/02/probabilistic-forecasting/">probabilistic forecasting</a>,
+        to determine when we'll be done. Try it now with the
+        <a href="<%= throughput_forecaster_url %>" target="_blank" rel="noopener noreferrer">
+        Focused Objective throughput forecaster,</a> to see how long it would take to complete all of the
+        <%= @not_started_count %> items you currently have in your backlog.
       </div>
       #{describe_non_working_days}
     TEXT
+    @x_axis_title = nil
+    @y_axis_title = 'Count of items'
 
     init_configuration_block(block) do
-      grouping_rules do |issue, rule|
-        rule.label = issue.type
-        rule.color = color_for type: issue.type
-      end
+      grouping_rules { |issue, rule| default_grouping_rules(issue, rule) }
     end
   end
 
   def run
+    # This is saved as an instance variable so that it's accessible later when rendering the description text
+    @not_started_count = issues.count { |issue| issue.started_stopped_times.first.nil? }
+
     completed_issues = completed_issues_in_range include_unstarted: true
     rules_to_issues = group_issues completed_issues
     data_sets = []
-    if rules_to_issues.size > 1
-      data_sets << weekly_throughput_dataset(
-        completed_issues: completed_issues,
-        label: 'Totals',
-        color: CssVariable['--throughput_chart_total_line_color'],
-        dashed: true
-      )
-    end
+    total_data_set = weekly_throughput_dataset(
+      completed_issues: completed_issues,
+      label: 'Totals',
+      color: CssVariable['--throughput_chart_total_line_color'],
+      dashed: true
+    )
+    @throughput_samples = total_data_set[:data].collect { |d| d[:y] }
+    data_sets << total_data_set if rules_to_issues.size > 1
 
     rules_to_issues.each_key do |rules|
       data_sets << weekly_throughput_dataset(
-        completed_issues: rules_to_issues[rules], label: rules.label, color: rules.color
+        completed_issues: rules_to_issues[rules], label: rules.label, color: rules.color,
+        label_hint: rules.label_hint
       )
     end
 
     wrap_and_render(binding, __FILE__)
   end
 
+  def default_grouping_rules issue, rule
+    rule.label = issue.type
+    rule.color = color_for type: issue.type
+  end
+
   def calculate_time_periods
     first_day = @date_range.begin
     first_day = case first_day.wday
@@ -65,10 +79,22 @@ class ThroughputChart < ChartBase
     end
   end
 
-  def weekly_throughput_dataset completed_issues:, label:, color:, dashed: false
+  def calculate_custom_periods
+    last_days = @issue_periods.values.compact.uniq.sort
+    last_days.each_with_index.map do |last_day, i|
+      first_day = i.zero? ? @date_range.begin : last_days[i - 1] + 1
+      first_day..last_day
+    end
+  end
+
+  def weekly_throughput_dataset completed_issues:, label:, color:, dashed: false, label_hint: nil
+    periods = @issue_periods&.values&.any? ? calculate_custom_periods : calculate_time_periods
     result = {
       label: label,
-      data: throughput_dataset(periods: calculate_time_periods, completed_issues: completed_issues),
+      label_hint: label_hint,
+      data: throughput_dataset(
+        periods: periods, completed_issues: completed_issues, label_hint: label_hint
+      ),
       fill: false,
       showLine: true,
       borderColor: color,
@@ -79,20 +105,44 @@ class ThroughputChart < ChartBase
     result
   end
 
-  def throughput_dataset periods:, completed_issues:
+  def throughput_forecaster_url
+    params = {
+      throughputMode: 'data',
+      samplesText: @throughput_samples.join(','),
+      storyLow: @not_started_count,
+      storyHigh: @not_started_count
+    }
+
+    query = params.map { |k, v| "#{k}=#{CGI.escape(v.to_s)}" }.join('&')
+    "https://focusedobjective.com/throughput?#{query}"
+  end
+
+  def throughput_dataset periods:, completed_issues:, label_hint: nil
+    custom_mode = @issue_periods&.values&.any?
     periods.collect do |period|
       closed_issues = completed_issues.filter_map do |issue|
-        stop_date = issue.board.cycletime.stopped_time(issue)&.to_date
-        [stop_date, issue] if stop_date && period.include?(stop_date)
+        stop_date = issue.started_stopped_dates.last
+        next unless stop_date
+
+        if custom_mode
+          [stop_date, issue] if @issue_periods[issue] == period.end
+        elsif period.include?(stop_date)
+          [stop_date, issue]
+        end
       end
 
       date_label = "on #{period.end}"
       date_label = "between #{period.begin} and #{period.end}" unless period.begin == period.end
 
-      { y: closed_issues.size,
+      with_label_hint = label_hint ? " with #{label_hint}" : ''
+      {
+        y: closed_issues.size,
         x: "#{period.end}T23:59:59",
-        title: ["#{closed_issues.size} items completed #{date_label}"] +
-          closed_issues.collect { |_stop_date, issue| "#{issue.key} : #{issue.summary}" }
+        title: ["#{closed_issues.size} items closed#{with_label_hint} #{date_label}"] +
+          closed_issues.collect do |_stop_date, issue|
+            hint = @issue_hints&.fetch(issue, nil)
+            "#{issue.key} : #{issue.summary}#{" #{hint}" if hint}"
+          end
       }
     end
   end

data/lib/jirametrics/time_based_histogram.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'jirametrics/groupable_issue_chart'
+
+class TimeBasedHistogram < ChartBase
+  include GroupableIssueChart
+
+  attr_reader :show_stats
+
+  def initialize
+    super
+
+    percentiles [50, 85, 98]
+    @show_stats = true
+  end
+
+  def percentiles percs = nil
+    @percentiles = percs unless percs.nil?
+    @percentiles
+  end
+
+  def disable_stats
+    @show_stats = false
+  end
+
+  def run
+    histogram_items = all_items
+    rules_to_items = group_issues histogram_items
+
+    the_stats = {}
+
+    overall_histogram = histogram_data_for(items: histogram_items).transform_values(&:size)
+    the_stats[:all] = stats_for histogram_data: overall_histogram, percentiles: @percentiles
+    data_sets = rules_to_items.keys.collect do |rules|
+      the_label = rules.label
+      the_histogram = histogram_data_for(items: rules_to_items[rules])
+      if @show_stats
+        the_stats[the_label] = stats_for(
+          histogram_data: the_histogram.transform_values(&:size), percentiles: @percentiles
+        )
+      end
+
+      data_set_for(
+        histogram_data: the_histogram,
+        label: the_label,
+        color: rules.color
+      )
+    end
+
+    if data_sets.empty?
+      return "<h1 class='foldable'>#{@header_text}</h1>" \
+             '<div>No data matched the selected criteria. Nothing to show.</div>'
+    end
+
+    wrap_and_render(binding, __FILE__)
+  end
+
+  def histogram_data_for items:
+    items_hash = {}
+    items.each do |item|
+      days = value_for_item item
+      (items_hash[days] ||= []) << item if days.positive?
+    end
+    items_hash
+  end
+
+  def stats_for histogram_data:, percentiles:
+    return {} if histogram_data.empty?
+
+    total_values = histogram_data.values.sum
+
+    # Calculate the average
+    weighted_sum = histogram_data.reduce(0) { |sum, (value, frequency)| sum + (value * frequency) }
+    average = total_values.zero? ? 0 : weighted_sum.to_f / total_values
+
+    # Find the mode (or modes!) and the spread of the distribution
+    sorted_histogram = histogram_data.sort_by { |_value, frequency| frequency }
+    max_freq = sorted_histogram[-1][1]
+    mode = sorted_histogram.select { |_v, f| f == max_freq }
+
+    minmax = histogram_data.keys.minmax
+
+    # Calculate percentiles
+    sorted_values = histogram_data.keys.sort
+    cumulative_counts = {}
+    cumulative_sum = 0
+
+    sorted_values.each do |value|
+      cumulative_sum += histogram_data[value]
+      cumulative_counts[value] = cumulative_sum
+    end
+
+    percentile_results = {}
+    percentiles.each do |percentile|
+      rank = (percentile / 100.0) * total_values
+      percentile_value = sorted_values.find { |value| cumulative_counts[value] >= rank }
+      percentile_results[percentile] = percentile_value
+    end
+
+    {
+      average: average,
+      mode: mode.collect(&:first).sort,
+      min: minmax[0],
+      max: minmax[1],
+      percentiles: percentile_results
+    }
+  end
+
+  def sort_items items
+    items
+  end
+
+  def label_for_item item, hint:
+    raise NotImplementedError, "#{self.class} must implement label_for_item"
+  end
+
+  def data_set_for histogram_data:, label:, color:
+    {
+      type: 'bar',
+      label: label,
+      data: histogram_data.keys.sort.filter_map do |days|
+        items = histogram_data[days]
+        next if items.empty?
+
+        {
+          x: days,
+          y: items.size,
+          title: [title_for_item(count: items.size, value: days)] +
+            sort_items(items).collect do |item|
+              hint = @issue_hints&.fetch(item, nil)
+              label_for_item(item, hint: hint)
+            end
+        }
+      end,
+      backgroundColor: color,
+      borderRadius: 0
+    }
+  end
+end

data/lib/jirametrics/time_based_scatterplot.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'jirametrics/groupable_issue_chart'
+
+class TimeBasedScatterplot < ChartBase
+  include GroupableIssueChart
+
+  def initialize
+    super
+
+    @percentage_lines = []
+    @highest_y_value = 0
+  end
+
+  def run
+    items = all_items
+    data_sets = create_datasets items
+    overall_percent_line = calculate_percent_line(items)
+    @percentage_lines << [overall_percent_line, CssVariable['--cycletime-scatterplot-overall-trendline-color']]
+
+    return "<h1 class='foldable'>#{@header_text}</h1><div>No data matched the selected criteria. Nothing to show.</div>" if data_sets.empty?
+
+    wrap_and_render(binding, __FILE__)
+  end
+
+  def create_datasets items
+    data_sets = []
+
+    group_issues(items).each do |rules, items_by_type|
+      label = rules.label
+      color = rules.color
+      percent_line = calculate_percent_line items_by_type
+      data = items_by_type.filter_map { |item| data_for_item(item, rules: rules) }
+      data_sets << {
+        label: "#{label} (85% at #{label_days(percent_line)})",
+        data: data,
+        fill: false,
+        showLine: false,
+        backgroundColor: color
+      }
+
+      data_sets << trend_line_data_set(label: label, data: data, color: color)
+
+      @percentage_lines << [percent_line, color]
+    end
+    data_sets
+  end
+
+  def show_trend_lines
+    @show_trend_lines = true
+  end
+
+  def trend_line_data_set label:, data:, color:
+    points = data.collect do |hash|
+      [Time.parse(hash[:x]).to_i, hash[:y]]
+    end
+
+    # The trend calculation works with numbers only so convert Time to an int and back
+    calculator = TrendLineCalculator.new(points)
+    data_points = calculator.chart_datapoints(
+      range: time_range.begin.to_i..time_range.end.to_i,
+      max_y: @highest_y_value
+    )
+    data_points.each do |point_hash|
+      point_hash[:x] = chart_format Time.at(point_hash[:x])
+    end
+
+    {
+      type: 'line',
+      label: "#{label} Trendline",
+      data: data_points,
+      fill: false,
+      borderWidth: 1,
+      markerType: 'none',
+      borderColor: color,
+      borderDash: [6, 3],
+      pointStyle: 'dash',
+      hidden: !@show_trend_lines
+    }
+  end
+
+  def minimum_y_value
+    nil
+  end
+
+  def data_for_item item, rules: nil
+    y = y_value(item)
+    min = minimum_y_value
+    return nil if min && y < min
+
+    @highest_y_value = y if @highest_y_value < y
+
+    {
+      y: y,
+      x: chart_format(x_value(item)),
+      title: [title_value(item, rules: rules)]
+    }
+  end
+
+  def calculate_percent_line items
+    min = minimum_y_value
+    times = items.collect { |item| y_value(item) }
+    times.reject! { |y| min && y < min }
+    index = times.size * 85 / 100
+    times.sort[index]
+  end
+end

data/lib/jirametrics/user.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class User
+  def initialize raw:
+    @raw = raw
+  end
+
+  def account_id = @raw['accountId']
+  def avatar_url = @raw['avatarUrls']['16x16']
+  def active? = @raw['active']
+  def display_name = @raw['displayName']
+end

data/lib/jirametrics/value_equality.rb

@@ -9,9 +9,9 @@ module ValueEquality
       names = object.instance_variables
       if object.respond_to? :value_equality_ignored_variables
         ignored_variables = object.value_equality_ignored_variables
-        names.reject! { |n| ignored_variables.include? n }
+        names.reject! { |n| ignored_variables.include? n.to_sym }
       end
-      names.map { |variable| instance_variable_get variable }
+      names.map { |variable| object.instance_variable_get variable }
     end
 
     code.call(self) == code.call(other)