jirametrics 2.31 → 3.0

data/lib/jirametrics/sprint_burndown.rb

@@ -1,20 +1,7 @@
 # frozen_string_literal: true
 
-class SprintSummaryStats
-  attr_accessor :started, :added, :changed, :removed, :completed, :remaining, :points_values_changed
-
-  def initialize
-    @added = 0
-    @completed = 0
-    @removed = 0
-    @started = 0
-    @remaining = 0
-    @points_values_changed = false
-  end
-end
-
 class SprintBurndown < ChartBase
-  attr_reader :use_story_points, :use_story_counts
+  attr_reader :use_story_points, :use_story_counts, :summary_stats
   attr_accessor :board_id
 
   def initialize
@@ -53,112 +40,118 @@ class SprintBurndown < ChartBase
     return nil unless current_board.scrum?
 
     sprints = sprints_in_time_range current_board
-
-    change_data_by_sprint = {}
-    sprints.each do |sprint|
-      change_data = []
-      issues.each do |issue|
-        change_data += changes_for_one_issue(issue: issue, sprint: sprint)
-      end
-      change_data_by_sprint[sprint] = change_data.sort_by(&:time)
-    end
+    change_data_by_sprint = gather_change_data_by_sprint sprints
 
     result = +''
     result << render_top_text(binding)
 
-    possible_colours = (1..ChartBase::OKABE_ITO_PALETTE.size).collect { |i| CssVariable["--sprint-burndown-sprint-color-#{i}"] }
-    charts_to_generate = []
-    charts_to_generate << [:data_set_by_story_points, 'Story Points'] if @use_story_points
-    charts_to_generate << [:data_set_by_story_counts, 'Story Count'] if @use_story_counts
+    # HashEachMethods misreads this array of [method, title] pairs as a hash and thinks y_axis_title
+    # is unused; in fact the ERB template reads it (and data_method) from the binding we pass to render.
     charts_to_generate.each do |data_method, y_axis_title| # rubocop:disable Style/HashEachMethods
       @summary_stats.clear
-      data_sets = []
-      sprints.each_with_index do |sprint, index|
-        color = possible_colours[index % possible_colours.size]
-        label = sprint.name
-        data = send(data_method, sprint: sprint, change_data_for_sprint: change_data_by_sprint[sprint])
-        data_sets << {
-          label: label,
-          data: data,
-          fill: false,
-          showLine: true,
-          borderColor: color,
-          backgroundColor: color,
-          stepped: true,
-          pointStyle: %w[rect circle] # First dot is visually different from the rest
-        }
-      end
-
-      legend = []
-      case data_method
-      when :data_set_by_story_counts
-        legend << '<b>Started</b>: Number of issues already in the sprint, when the sprint was started.'
-        legend << '<b>Completed</b>: Number of issues, completed during the sprint'
-        legend << '<b>Added</b>: Number of issues added in the middle of the sprint'
-        legend << '<b>Removed</b>: Number of issues removed while the sprint was in progress'
-      when :data_set_by_story_points
-        legend << '<b>Started</b>: Total count of story points when the sprint was started'
-        legend << '<b>Completed</b>: Count of story points completed during the sprint'
-        legend << '<b>Added</b>: Count of story points added in the middle of the sprint'
-        legend << '<b>Removed</b>: Count of story points removed while the sprint was in progress'
-      else
-        raise "Unexpected method #{data_method}"
-      end
-
+      data_sets = sprint_data_sets(
+        data_method: data_method, sprints: sprints, change_data_by_sprint: change_data_by_sprint
+      )
+      legend = legend_for data_method
       result << render(binding, __FILE__)
     end
 
     result
   end
 
+  # Every sprint's changes, flattened across all issues and sorted into time order.
+  def gather_change_data_by_sprint sprints
+    sprints.to_h do |sprint|
+      change_data = issues.flat_map { |issue| changes_for_one_issue(issue: issue, sprint: sprint) }
+      [sprint, change_data.sort_by(&:time)]
+    end
+  end
+
+  # The [data-builder method, y-axis label] pairs for whichever burndown measures are turned on.
+  def charts_to_generate
+    charts = []
+    charts << [:data_set_by_story_points, 'Story Points'] if @use_story_points
+    charts << [:data_set_by_story_counts, 'Story Count'] if @use_story_counts
+    charts
+  end
+
+  # One Chart.js data set per sprint, each in its own colour from the palette.
+  def sprint_data_sets data_method:, sprints:, change_data_by_sprint:
+    possible_colours = (1..ChartBase::OKABE_ITO_PALETTE.size).collect do |i|
+      CssVariable["--sprint-burndown-sprint-color-#{i}"]
+    end
+    sprints.each_with_index.collect do |sprint, index|
+      color = possible_colours[index % possible_colours.size]
+      {
+        label: sprint.name,
+        data: send(data_method, sprint: sprint, change_data_for_sprint: change_data_by_sprint[sprint]),
+        fill: false,
+        showLine: true,
+        borderColor: color,
+        backgroundColor: color,
+        stepped: true,
+        pointStyle: %w[rect circle] # First dot is visually different from the rest
+      }
+    end
+  end
+
+  def legend_for data_method
+    case data_method
+    when :data_set_by_story_counts
+      ['<b>Started</b>: Number of issues already in the sprint, when the sprint was started.',
+       '<b>Completed</b>: Number of issues, completed during the sprint',
+       '<b>Added</b>: Number of issues added in the middle of the sprint',
+       '<b>Removed</b>: Number of issues removed while the sprint was in progress']
+    when :data_set_by_story_points
+      ['<b>Started</b>: Total count of story points when the sprint was started',
+       '<b>Completed</b>: Count of story points completed during the sprint',
+       '<b>Added</b>: Count of story points added in the middle of the sprint',
+       '<b>Removed</b>: Count of story points removed while the sprint was in progress']
+    else
+      raise "Unexpected method #{data_method}"
+    end
+  end
+
   def sprints_in_time_range board
-    board.sprints.select do |sprint|
-      # If it's never been started then it's just a holding area. Ignore it.
-      next if sprint.future?
+    board.sprints.select { |sprint| sprint_in_time_range? sprint }
+  end
 
-      sprint_end_time = sprint.completed_time || sprint.end_time
-      sprint_start_time = sprint.start_time
-      next false if sprint_start_time.nil?
+  # A sprint counts when it has actually started (future and never-started sprints are just holding
+  # areas, so we ignore them) and its active span overlaps the chart's time range.
+  def sprint_in_time_range? sprint
+    return false if sprint.future?
 
-      time_range.include?(sprint_start_time) || time_range.include?(sprint_end_time) ||
-        (sprint_start_time < time_range.begin && sprint_end_time > time_range.end)
-    end || []
+    sprint_start_time = sprint.start_time
+    return false if sprint_start_time.nil?
+
+    sprint_end_time = sprint.completed_time || sprint.end_time
+    time_range.include?(sprint_start_time) || time_range.include?(sprint_end_time) ||
+      (sprint_start_time < time_range.begin && sprint_end_time > time_range.end)
   end
 
   # select all the changes that are relevant for the sprint. If this issue never appears in this sprint then return [].
   def changes_for_one_issue issue:, sprint:
     estimate = 0.0
-    ever_in_sprint = false
     currently_in_sprint = false
+    completed_has_been_tracked = false
     change_data = []
 
     estimate_display_name = current_board.estimation_configuration.display_name
-
     issue_completed_time = issue.started_stopped_times.last
-    completed_has_been_tracked = false
 
     issue.changes.each do |change|
       action = nil
       value = nil
 
       if change.sprint?
-        # We can get two sprint changes in a row that tell us the same thing so we have to verify
-        # that something actually changed.
         in_change_item = sprint_in_change_item(sprint, change)
-        if currently_in_sprint == false && in_change_item
-          action = :enter_sprint
-          ever_in_sprint = true
-          value = estimate
-        elsif currently_in_sprint && in_change_item == false
-          action = :leave_sprint
-          value = -estimate
-        end
+        action, value = sprint_change_action(in_change_item, currently_in_sprint, estimate)
         currently_in_sprint = in_change_item
-      elsif change.field == estimate_display_name && (issue_completed_time.nil? || change.time < issue_completed_time)
+      elsif estimate_change_before_completion?(change, estimate_display_name, issue_completed_time)
         action = :story_points
         estimate = change.value.to_f
         value = estimate - change.old_value.to_f
-      elsif completed_has_been_tracked == false && change.time == issue_completed_time
+      elsif reached_completion?(completed_has_been_tracked, change, issue_completed_time)
         completed_has_been_tracked = true
         action = :issue_stopped
         value = -estimate
@@ -171,191 +164,98 @@ class SprintBurndown < ChartBase
       )
     end
 
-    return [] unless ever_in_sprint
+    ever_entered_sprint?(change_data) ? change_data : []
+  end
 
-    change_data
+  # Two sprint changes in a row can say the same thing, so an event only fires when the membership
+  # actually flips: entering (was out, now in) or leaving (was in, now out).
+  def sprint_change_action in_change_item, currently_in_sprint, estimate
+    return [:enter_sprint, estimate] if currently_in_sprint == false && in_change_item
+    return [:leave_sprint, -estimate] if currently_in_sprint && in_change_item == false
+
+    [nil, nil]
+  end
+
+  def estimate_change_before_completion? change, estimate_display_name, issue_completed_time
+    change.field == estimate_display_name && (issue_completed_time.nil? || change.time < issue_completed_time)
+  end
+
+  def reached_completion? completed_has_been_tracked, change, issue_completed_time
+    completed_has_been_tracked == false && change.time == issue_completed_time
+  end
+
+  def ever_entered_sprint? change_data
+    change_data.any? { |data| data.action == :enter_sprint }
   end
 
   def sprint_in_change_item sprint, change_item
     change_item.raw['to'].split(/\s*,\s*/).any? { |id| id.to_i == sprint.id }
   end
 
-  def data_set_by_story_points sprint:, change_data_for_sprint: # rubocop:disable Metrics/CyclomaticComplexity
-    summary_stats = SprintSummaryStats.new
-    summary_stats.completed = 0.0
+  def data_set_by_story_points sprint:, change_data_for_sprint:
+    build_sprint_data_set(
+      sprint: sprint, change_data_for_sprint: change_data_for_sprint, measure: SprintPointsMeasure.new
+    )
+  end
 
-    estimate = 0.0
-    start_data_written = false
-    data_set = []
+  def data_set_by_story_counts sprint:, change_data_for_sprint:
+    build_sprint_data_set(
+      sprint: sprint, change_data_for_sprint: change_data_for_sprint, measure: SprintCountMeasure.new
+    )
+  end
 
-    issues_currently_in_sprint = []
+  # Walks the sprint's change stream once. The measure decides how each change accumulates and reads
+  # out; the loop structure is shared by both the story-points and story-counts views.
+  def build_sprint_data_set sprint:, change_data_for_sprint:, measure:
+    data_set = []
+    start_written = false
 
     change_data_for_sprint.each do |change_data|
-      if start_data_written == false && change_data.time >= sprint.start_time
-        data_set << {
-          y: estimate,
-          x: chart_format(sprint.start_time),
-          title: "Sprint started with #{estimate} points"
-        }
-        summary_stats.started = estimate
-        start_data_written = true
-      end
-
-      break if sprint.completed_time && change_data.time > sprint.completed_time
-
-      case change_data.action
-      when :enter_sprint
-        issues_currently_in_sprint << change_data.issue.key
-        estimate += change_data.estimate
-      when :leave_sprint
-        issues_currently_in_sprint.delete change_data.issue.key
-        estimate -= change_data.estimate
-      when :story_points
-        estimate += change_data.value if issues_currently_in_sprint.include? change_data.issue.key
+      if start_pending?(start_written, change_data, sprint)
+        data_set << sprint_start_point(measure, sprint)
+        start_written = true
       end
+      break if past_sprint_end?(change_data, sprint)
 
+      measure.update_state change_data
       next unless change_data.time >= sprint.start_time
 
-      message = nil
-      case change_data.action
-      when :story_points
-        next unless issues_currently_in_sprint.include? change_data.issue.key
-
-        old_estimate = change_data.estimate - change_data.value
-        message = "Story points changed from #{old_estimate} points to #{change_data.estimate} points"
-        summary_stats.points_values_changed = true
-      when :enter_sprint
-        message = "Added to sprint with #{change_data.estimate || 'no'} points"
-        summary_stats.added += change_data.estimate
-      when :issue_stopped
-        estimate -= change_data.estimate
-        message = "Completed with #{change_data.estimate || 'no'} points"
-        issues_currently_in_sprint.delete change_data.issue.key
-        summary_stats.completed += change_data.estimate
-      when :leave_sprint
-        message = "Removed from sprint with #{change_data.estimate || 'no'} points"
-        summary_stats.removed += change_data.estimate
-      else
-        raise "Unexpected action: #{change_data.action}"
-      end
-
-      data_set << {
-        y: estimate,
-        x: chart_format(change_data.time),
-        title: "#{change_data.issue.key} #{message}"
-      }
-    end
-
-    unless start_data_written
-      # There was nothing that triggered us to write the sprint started block so do it now.
-      data_set << {
-        y: estimate,
-        x: chart_format(sprint.start_time),
-        title: "Sprint started with #{estimate} points"
-      }
-      summary_stats.started = estimate
-    end
-
-    if sprint.completed_time
-      data_set << {
-        y: estimate,
-        x: chart_format(sprint.completed_time),
-        title: "Sprint ended with #{estimate} points unfinished"
-      }
-      summary_stats.remaining = estimate
+      message = measure.record change_data
+      data_set << change_point(measure, change_data, message) if message
     end
 
-    unless sprint.completed_at?(time_range.end)
-      data_set << {
-        y: estimate,
-        x: chart_format(time_range.end),
-        title: "Sprint still active. #{estimate} points still in progress."
-      }
-    end
-
-    @summary_stats[sprint] = summary_stats
+    append_closing_points data_set, measure, sprint, start_written
+    @summary_stats[sprint] = measure.summary_stats
     data_set
   end
 
-  def data_set_by_story_counts sprint:, change_data_for_sprint:
-    summary_stats = SprintSummaryStats.new
-
-    data_set = []
-    issues_currently_in_sprint = []
-    start_data_written = false
-
-    change_data_for_sprint.each do |change_data|
-      if start_data_written == false && change_data.time >= sprint.start_time
-        data_set << {
-          y: issues_currently_in_sprint.size,
-          x: chart_format(sprint.start_time),
-          title: "Sprint started with #{issues_currently_in_sprint.size} stories"
-        }
-        summary_stats.started = issues_currently_in_sprint.size
-        start_data_written = true
-      end
-
-      break if sprint.completed_time && change_data.time > sprint.completed_time
-
-      case change_data.action
-      when :enter_sprint
-        issues_currently_in_sprint << change_data.issue.key
-      when :leave_sprint, :issue_stopped
-        issues_currently_in_sprint.delete change_data.issue.key
-      end
-
-      next unless change_data.time >= sprint.start_time
+  def start_pending? start_written, change_data, sprint
+    !start_written && change_data.time >= sprint.start_time
+  end
 
-      message = nil
-      case change_data.action
-      when :enter_sprint
-        message = 'Added to sprint'
-        summary_stats.added += 1
-      when :issue_stopped
-        message = 'Completed'
-        summary_stats.completed += 1
-      when :leave_sprint
-        message = 'Removed from sprint'
-        summary_stats.removed += 1
-      end
+  def past_sprint_end? change_data, sprint
+    sprint.completed_time && change_data.time > sprint.completed_time
+  end
 
-      next unless message
+  def sprint_start_point measure, sprint
+    measure.summary_stats.started = measure.value
+    { y: measure.value, x: chart_format(sprint.start_time), title: measure.started_title }
+  end
 
-      data_set << {
-        y: issues_currently_in_sprint.size,
-        x: chart_format(change_data.time),
-        title: "#{change_data.issue.key} #{message}"
-      }
-    end
+  def change_point measure, change_data, message
+    { y: measure.value, x: chart_format(change_data.time), title: "#{change_data.issue.key} #{message}" }
+  end
 
-    unless start_data_written
-      # There was nothing that triggered us to write the sprint started block so do it now.
-      data_set << {
-        y: issues_currently_in_sprint.size,
-        x: chart_format(sprint.start_time),
-        title: "Sprint started with #{issues_currently_in_sprint.size || 'no'} stories"
-      }
-    end
+  def append_closing_points data_set, measure, sprint, start_written
+    # Nothing in the change stream triggered the sprint-start marker, so write it now.
+    data_set << sprint_start_point(measure, sprint) unless start_written
 
     if sprint.completed_time
-      data_set << {
-        y: issues_currently_in_sprint.size,
-        x: chart_format(sprint.completed_time),
-        title: "Sprint ended with #{issues_currently_in_sprint.size} stories unfinished"
-      }
-      summary_stats.remaining = issues_currently_in_sprint.size
+      data_set << { y: measure.value, x: chart_format(sprint.completed_time), title: measure.ended_title }
+      measure.summary_stats.remaining = measure.value
     end
+    return if sprint.completed_at?(time_range.end)
 
-    unless sprint.completed_at?(time_range.end)
-      # If the sprint is still active then we draw one final line to the end of the time range
-      data_set << {
-        y: issues_currently_in_sprint.size,
-        x: chart_format(time_range.end),
-        title: "Sprint still active. #{issues_currently_in_sprint.size} issues in progress."
-      }
-    end
-
-    @summary_stats[sprint] = summary_stats
-    data_set
+    data_set << { y: measure.value, x: chart_format(time_range.end), title: measure.active_title }
   end
 end

data/lib/jirametrics/sprint_count_measure.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# The story-count view of a sprint burndown: simply how many issues are in the sprint at any point.
+# It plugs into SprintBurndown#build_sprint_data_set, which shares its loop with the story-points
+# view (SprintPointsMeasure).
+class SprintCountMeasure
+  attr_reader :summary_stats
+
+  def initialize
+    @summary_stats = SprintSummaryStats.new
+    @issues_currently_in_sprint = []
+  end
+
+  def value = @issues_currently_in_sprint.size
+
+  def update_state change_data
+    case change_data.action
+    when :enter_sprint
+      @issues_currently_in_sprint << change_data.issue.key
+    when :leave_sprint, :issue_stopped
+      @issues_currently_in_sprint.delete change_data.issue.key
+    end
+  end
+
+  def record change_data
+    case change_data.action
+    when :enter_sprint
+      @summary_stats.added += 1
+      'Added to sprint'
+    when :issue_stopped
+      @summary_stats.completed += 1
+      'Completed'
+    when :leave_sprint
+      @summary_stats.removed += 1
+      'Removed from sprint'
+    end
+  end
+
+  def started_title = "Sprint started with #{value} stories"
+  def ended_title = "Sprint ended with #{value} stories unfinished"
+  def active_title = "Sprint still active. #{value} issues in progress."
+end

data/lib/jirametrics/sprint_issue_change_data.rb

@@ -4,6 +4,7 @@ require 'jirametrics/value_equality'
 
 class SprintIssueChangeData
   include ValueEquality
+
   attr_reader :time, :action, :value, :issue, :estimate
 
   def initialize time:, action:, value:, issue:, estimate:

data/lib/jirametrics/sprint_points_measure.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# The story-points view of a sprint burndown: a running total of estimate as issues enter, leave,
+# complete, or have their points changed. It plugs into SprintBurndown#build_sprint_data_set, which
+# shares its loop with the story-count view (SprintCountMeasure).
+class SprintPointsMeasure
+  attr_reader :summary_stats
+
+  def initialize
+    @summary_stats = SprintSummaryStats.new
+    @summary_stats.completed = 0.0
+    @estimate = 0.0
+    @issues_currently_in_sprint = []
+  end
+
+  def value = @estimate
+
+  def update_state change_data
+    case change_data.action
+    when :enter_sprint
+      @issues_currently_in_sprint << change_data.issue.key
+      @estimate += change_data.estimate
+    when :leave_sprint
+      @issues_currently_in_sprint.delete change_data.issue.key
+      @estimate -= change_data.estimate
+    when :story_points
+      @estimate += change_data.value if @issues_currently_in_sprint.include? change_data.issue.key
+    end
+  end
+
+  def record change_data
+    case change_data.action
+    when :story_points
+      return nil unless @issues_currently_in_sprint.include? change_data.issue.key
+
+      @summary_stats.points_values_changed = true
+      old_estimate = change_data.estimate - change_data.value
+      "Story points changed from #{old_estimate} points to #{change_data.estimate} points"
+    when :enter_sprint
+      @summary_stats.added += change_data.estimate
+      "Added to sprint with #{points_label change_data.estimate}"
+    when :issue_stopped
+      @estimate -= change_data.estimate
+      @issues_currently_in_sprint.delete change_data.issue.key
+      @summary_stats.completed += change_data.estimate
+      "Completed with #{points_label change_data.estimate}"
+    when :leave_sprint
+      @summary_stats.removed += change_data.estimate
+      "Removed from sprint with #{points_label change_data.estimate}"
+    else
+      raise "Unexpected action: #{change_data.action}"
+    end
+  end
+
+  def points_label estimate
+    "#{estimate || 'no'} points"
+  end
+
+  def started_title = "Sprint started with #{@estimate} points"
+  def ended_title = "Sprint ended with #{@estimate} points unfinished"
+  def active_title = "Sprint still active. #{@estimate} points still in progress."
+end

data/lib/jirametrics/sprint_summary_stats.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# The roll-up numbers for a single sprint's burndown: how many points/issues the sprint started
+# with, how many were added/removed/completed while it ran, and how many remained at the end.
+class SprintSummaryStats
+  attr_accessor :started, :added, :changed, :removed, :completed, :remaining, :points_values_changed
+
+  def initialize
+    @added = 0
+    @completed = 0
+    @removed = 0
+    @started = 0
+    @remaining = 0
+    @points_values_changed = false
+  end
+end

data/lib/jirametrics/status_collection.rb

@@ -49,8 +49,8 @@ class StatusCollection
 
   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]
+    if /^(?<status_name>.*):(?<status_id>\d+)$/ =~ name
+      [status_name, status_id.to_i]
     elsif name.match?(/^\d+$/)
       [nil, name.to_i]
     else

data/lib/jirametrics/stitcher.rb

@@ -32,8 +32,8 @@ class Stitcher < HtmlGenerator
   end
 
   def make_output_filename input_filename
-    if /^(.+)\.erb$/ =~ input_filename
-      "#{$1}.html"
+    if /^(?<base_name>.+)\.erb$/ =~ input_filename
+      "#{base_name}.html"
     else
       "#{input_filename}.html"
     end
@@ -48,7 +48,8 @@ class Stitcher < HtmlGenerator
     ''
   end
 
-  def parse_file filename
+  # Imperative: it parses the file. The boolean is a "was it newly parsed" status, not a question.
+  def parse_file filename # rubocop:disable Naming/PredicateMethod
     return false if @loaded_files.include? filename
 
     # To match: <!-- seam-start | chart78 | GithubPrScatterplot | PR Scatterplot | chart -->
@@ -57,19 +58,7 @@ class Stitcher < HtmlGenerator
     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
+        content = handle_seam matches, filename: filename, content: content
       elsif content
         content << line
       end
@@ -78,4 +67,20 @@ class Stitcher < HtmlGenerator
     @loaded_files << filename
     true
   end
+
+  # Handle one seam marker line, returning the new accumulator state: a fresh buffer for a start
+  # seam, or nil for an end seam (after recording the content collected since the start).
+  def handle_seam matches, filename:, content:
+    return +'' if matches[:seam] == 'start'
+
+    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
+    )
+    nil
+  end
 end