fun_ci 1.2.1 → 2.0.1

data/lib/fun_ci/agent/digest.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Agent
+    # Why a needed stage failed, as the short text `status` and `wait` print
+    # (acceptance-tests.md, AT-9.6, AT-10.17), drawn from its evidence: for an
+    # overrun, what it was running; then the failures, or else the first
+    # excerpt, or else the output's last lines.
+    module Digest
+      HEADINGS = { "failed" => "failed", "over_budget" => "ran over budget" }.freeze
+      LINES = 20
+      FAILURES = 10
+      MESSAGE_LINES = 5
+
+      def self.lines(stages, needed)
+        stages.select { |stage| needed.include?(stage.name) && HEADINGS.key?(stage.state) }
+              .flat_map { |stage| of(stage) }
+      end
+
+      def self.of(stage)
+        evidence = stage.evidence
+        [heading(stage, evidence), *(evidence.failures.any? ? failure_lines(evidence.failures) : excerpt(evidence))]
+      end
+
+      def self.heading(stage, evidence)
+        running = evidence.facts.find { |fact| fact[:name] == "running" }
+        "#{stage.name} #{HEADINGS.fetch(stage.state)}:#{" running #{running[:value]}" if running}"
+      end
+
+      def self.failure_lines(failures)
+        failures.first(FAILURES).flat_map do |failure|
+          ["  #{place(failure)}", *failure[:message].to_s.lines.first(MESSAGE_LINES).map { |line| "    #{line.chomp}" }]
+        end
+      end
+
+      def self.place(failure)
+        failure[:file] ? "#{failure[:file]}:#{failure[:line]}  #{failure[:test]}" : failure[:test]
+      end
+
+      # The first excerpt's first lines, or the output's last lines.
+      def self.excerpt(evidence)
+        first = evidence.excerpts.find { |excerpt| excerpt[:extractor] != "output-tail" }
+        lines = first ? first[:lines].first(LINES) : evidence.excerpts.flat_map { |e| e[:lines] }.last(LINES)
+        lines.map { |line| "  #{line}" }
+      end
+      private_class_method :of, :heading, :failure_lines, :place, :excerpt
+    end
+  end
+end

data/lib/fun_ci/agent/events.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Agent
+    # What happened to a project's runs between two looks at them
+    # (acceptance-tests.md, AT-9.16), oldest run first: a run started, each
+    # stage that finished in the order it finished, a run that passed or
+    # failed, a run a newer commit superseded. The first look is at nothing.
+    module Events
+      # finished: [{ stage:, state:, seconds: }, ...] in the order they finished.
+      RunState = Data.define(:id, :sha, :branch, :status, :finished, :superseded_by)
+      OUTCOMES = { "completed" => "passed", "failed" => "failed" }.freeze
+      FAILED_STATES = %w[failed over_budget].freeze
+
+      # before, after: { run id => RunState }.
+      def self.between(before, after)
+        after.values.sort_by(&:id).flat_map { |run| of(run, before[run.id]) }
+      end
+
+      def self.failure?(event)
+        return true if event[:event] == "run_superseded"
+
+        event[:event] == "stage_finished" && FAILED_STATES.include?(event[:state])
+      end
+
+      def self.of(run, was)
+        about = { commit: run.sha, branch: run.branch }
+        [*(was ? [] : [{ event: "run_started", **about }]),
+         *newly_finished(run, was).map { |stage| { event: "stage_finished", **about, **stage } },
+         *ended(run, was, about)]
+      end
+
+      def self.newly_finished(run, was)
+        seen = (was&.finished || []).map { |stage| stage[:stage] }
+        run.finished.reject { |stage| seen.include?(stage[:stage]) }
+      end
+
+      def self.ended(run, was, about)
+        return [] if was&.status == run.status
+        return [{ event: "run_superseded", **about, by_commit: run.superseded_by }] if run.status == "cancelled"
+
+        OUTCOMES.key?(run.status) ? [{ event: "run_finished", **about, state: OUTCOMES.fetch(run.status) }] : []
+      end
+      private_class_method :of, :newly_finished, :ended
+    end
+  end
+end

data/lib/fun_ci/agent/events_command.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "command_support"
+require_relative "snapshots"
+require_relative "events"
+require_relative "waiting"
+
+module FunCi
+  module Agent
+    # `fun-ci events [--follow] [--only failures]` (acceptance-tests.md,
+    # AT-9.16): one JSON line per event of the project's recent runs, then,
+    # with --follow, each new one as it happens, until interrupted.
+    class EventsCommand
+      include CommandSupport
+
+      NAME = "events"
+      SCHEMA = 1
+      RECENT_RUNS = 10
+
+      def initialize(context)
+        @context = context
+      end
+
+      def run(args)
+        options = Options.parse(args, takes: %i[follow only json])
+        seen = emit({}, options.only)
+        follow(seen, options.only) if options.follow
+        0
+      rescue Options::Invalid => e
+        usage(e.message)
+      end
+
+      private
+
+      def follow(seen, only)
+        loop do
+          @context.clock.pause(Waiting::POLL_SECONDS)
+          @context.pipeline.watch(@context.db)
+          seen = emit(seen, only)
+        end
+      rescue Interrupt
+        # Following ends when whoever follows stops it.
+      end
+
+      # Prints what happened since `before`, and answers the look it took.
+      def emit(before, only)
+        after = snapshots.take(limit: RECENT_RUNS)
+        Events.between(before, after).select { |event| !only || Events.failure?(event) }.each { |event| print(event) }
+        after
+      end
+
+      def print(event)
+        @context.io.stdout.puts JSON.generate({ schema: SCHEMA, **event })
+        @context.io.stdout.flush
+      end
+
+      def snapshots = @snapshots ||= Snapshots.new(@context.db, @context.git)
+    end
+  end
+end

data/lib/fun_ci/agent/evidence_text.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Agent
+    # A stage's evidence as text: its facts, its failures, each with its whole
+    # message, each excerpt under its title, each naming the extractor that
+    # found it, then the problems extractors had.
+    module EvidenceText
+      def self.lines(document)
+        facts(document.facts) + failures(document.failures) +
+          document.excerpts.flat_map { |excerpt| excerpt(excerpt) } + problems(document.problems)
+      end
+
+      def self.facts(facts)
+        facts.empty? ? [] : ["", "Facts:", *facts.map { |fact| "  #{fact[:name]}: #{fact[:value]}" }]
+      end
+
+      def self.problems(problems)
+        return [] if problems.empty?
+
+        lines = problems.map { |problem| "  #{problem[:extractor]}: #{problem[:message]}" }
+        ["", "Problems collecting the evidence:", *lines]
+      end
+
+      def self.failures(failures)
+        failures.group_by { |failure| failure[:extractor] }.flat_map do |extractor, found|
+          ["", "Failures, from #{extractor}:", *found.flat_map { |failure| failure(failure) }]
+        end
+      end
+
+      def self.failure(failure)
+        place = failure[:file] ? "#{failure[:file]}:#{failure[:line]}  #{failure[:test]}" : failure[:test]
+        ["  #{place}", *indented(failure[:message], "    "), *own_output(failure[:output])]
+      end
+
+      def self.own_output(output) = output.to_s.empty? ? [] : ["    Output:", *indented(output, "      ")]
+      def self.indented(text, margin) = text.to_s.lines(chomp: true).map { |line| "#{margin}#{line}" }
+
+      def self.excerpt(excerpt)
+        place = excerpt[:location] == "output" ? "" : " (#{excerpt[:location]})"
+        ["", "#{excerpt[:title]}#{place}, from #{excerpt[:extractor]}:", *excerpt[:lines].map { |line| "  #{line}" }]
+      end
+      private_class_method :facts, :problems, :failures, :failure, :own_output, :indented, :excerpt
+    end
+  end
+end

data/lib/fun_ci/agent/exit_code.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Agent
+    # What `status` and `wait` exit with (acceptance-tests.md, §9).
+    module ExitCode
+      FOR = { passed: 0, failed: 1, over_budget: 2, undecided: 3, superseded: 4, unknown: 5 }.freeze
+      USAGE = 64
+    end
+  end
+end

data/lib/fun_ci/agent/git.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "open3"
+require_relative "../pipeline/git_environment"
+
+module FunCi
+  module Agent
+    # The project's git, as agent commands ask it: which commit a revision
+    # names, that commit's subject, and the directory the project is in.
+    class Git
+      def initialize(dir)
+        @dir = dir
+      end
+
+      def resolve(rev) = git("rev-parse", "--verify", "--quiet", "#{rev}^{commit}")
+      def subject(sha) = git("log", "-1", "--format=%s", sha).to_s
+      def toplevel = File.realpath(git("rev-parse", "--show-toplevel"))
+
+      # The branch checked out, as the git hooks name it: "" when HEAD is
+      # detached, which trigger names (Pipeline::Commit).
+      def branch = git("branch", "--show-current").to_s
+
+      private
+
+      # Its first line of output, or nil when git fails.
+      def git(*)
+        output, status = Open3.capture2(Pipeline::GitEnvironment::CLEAN, "git", *, chdir: @dir, err: File::NULL)
+        status.success? ? output.lines.first&.chomp : nil
+      end
+    end
+  end
+end

data/lib/fun_ci/agent/live_pipeline.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+require_relative "../pipeline/run_canceller"
+require_relative "../setup/project_config"
+
+module FunCi
+  module Agent
+    # The project's pipeline, as `wait` starts and watches it: a run starts
+    # the way the post-commit hook starts one, with `fun-ci trigger
+    # --background` in a process of its own, rather than as a fork of the
+    # waiting process and its open database connection.
+    class LivePipeline
+      FUN_CI = File.expand_path("../../../exe/fun-ci", __dir__)
+
+      # command: what runs fun-ci, the gem's own executable by default.
+      def initialize(project_dir, command: [RbConfig.ruby, FUN_CI])
+        @project_dir = project_dir
+        @command = command
+      end
+
+      # Answers the finished starter, or nil in a project not set up for fun-ci.
+      def start(sha, branch)
+        return unless Setup::ProjectConfig.new(@project_dir).validate.empty?
+
+        pid = Process.spawn(*@command, "trigger", "--background", sha, branch,
+                            chdir: @project_dir, %i[out err] => File::NULL)
+        Process.detach(pid).join
+      end
+
+      # Records failed each slow suite whose process died (acceptance-tests.md, AT-8.3).
+      def watch(db) = Pipeline::RunCanceller.new.record_dead(db)
+    end
+  end
+end

data/lib/fun_ci/agent/options.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "optparse"
+require_relative "verdict"
+
+module FunCi
+  module Agent
+    # The arguments of an agent command: at most one revision, then, for a
+    # command that takes :stage, a stage's name, and whichever of the switches
+    # below the command takes.
+    module Options
+      class Invalid < StandardError; end
+
+      Parsed = Data.define(:rev, :stage, :need, :json, :within, :follow_branch, :limit, :branch, :follow, :only, :raw)
+      DEFAULTS = { need: "fast", json: false, within: nil, follow_branch: false, limit: 10, branch: nil,
+                   follow: false, only: nil, raw: false }.freeze
+      SWITCHES = { need: ["--need LEVEL"], json: ["--json"], within: ["--within DURATION"], raw: ["--raw"],
+                   follow_branch: ["--follow-branch"], limit: ["-n N", Integer], branch: ["--branch NAME"],
+                   follow: ["--follow"], only: ["--only KIND"] }.freeze
+      FILTERS = %w[failures].freeze
+      MULTIPLIERS = { "" => 1, "s" => 1, "m" => 60 }.freeze
+
+      STAGES = %w[lint build fast slow].freeze
+
+      def self.parse(args, takes:)
+        values = DEFAULTS.dup
+        revs = parser(values, takes).parse(args)
+        stage = takes.include?(:stage) && STAGES.include?(revs.last) ? revs.pop : nil
+        raise Invalid, "one revision at a time, not #{revs.join(" ")}" if revs.size > 1
+
+        Parsed.new(rev: revs.first || "HEAD", stage: stage, **values)
+      rescue OptionParser::ParseError => e
+        raise Invalid, e.message
+      end
+
+      # Without OptionParser's own --help and --version (long options only), which print and exit.
+      def self.parser(values, takes)
+        parser = OptionParser.new
+        parser.base.long.clear
+        (takes & SWITCHES.keys).each do |key|
+          parser.on(*SWITCHES.fetch(key)) { |value| values[key] = convert(key, value) }
+        end
+        parser
+      end
+
+      def self.convert(key, value)
+        return level(value) if key == :need
+        return seconds(value) if key == :within
+        return filter(value) if key == :only
+
+        value
+      end
+
+      def self.level(value)
+        return value if Verdict::LEVELS.key?(value)
+
+        raise Invalid, "unknown level '#{value}': use build, fast or all"
+      end
+
+      def self.filter(value)
+        return value if FILTERS.include?(value)
+
+        raise Invalid, "unknown filter '#{value}': use #{FILTERS.join(", ")}"
+      end
+
+      def self.seconds(value)
+        match = /\A(\d+)([sm]?)\z/.match(value)
+        raise Invalid, "can't read the deadline '#{value}': use 30, 30s or 5m" unless match
+
+        match[1].to_i * MULTIPLIERS.fetch(match[2])
+      end
+      private_class_method :parser, :convert, :level, :filter, :seconds
+    end
+  end
+end

data/lib/fun_ci/agent/output.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "status_text"
+require_relative "why_text"
+require_relative "why_json"
+require_relative "status_json"
+require_relative "runs_text"
+require_relative "exit_code"
+
+module FunCi
+  module Agent
+    # Prints what an agent command found, as text or, with --json, as JSON.
+    class Output
+      NO_STAGE = "No stage it needs failed or ran over budget; name one to see it: fun-ci why REV STAGE"
+
+      def initialize(stdout, json:)
+        @stdout = stdout
+        @json = json
+      end
+
+      def report(report)
+        @json ? print_json(StatusJson.document(report)) : print_lines(StatusText.lines(report))
+      end
+
+      # Everything kept about the stage named, or says no stage decided the verdict.
+      def why(report, stage_name)
+        stage = report.stages.find { |candidate| candidate.name == stage_name }
+        return print_json(WhyJson.document(report, stage)) if @json
+        return print_lines([StatusText.header(report), NO_STAGE]) unless stage
+
+        print_lines(WhyText.lines(report, stage))
+      end
+
+      # Says the commit has no run, and answers the exit code for that.
+      def unknown(sha)
+        @json ? print_json(StatusJson.unknown(sha)) : print_lines(["fun-ci: no run for #{sha[0, 7]} in this project."])
+        ExitCode::FOR.fetch(:unknown)
+      end
+
+      # Says the commit has no run and none can start, which leaves it unknown.
+      def not_set_up(sha)
+        if @json
+          print_json(StatusJson.unknown(sha))
+        else
+          print_lines(["fun-ci: no run for #{sha[0, 7]}, and this project isn't set up to start one."])
+        end
+        ExitCode::FOR.fetch(:unknown)
+      end
+
+      # Says the commit has no run yet, which leaves it undecided.
+      def no_run_yet(sha)
+        if @json
+          print_json(StatusJson.unknown(sha).merge(verdict: "undecided"))
+        else
+          print_lines(["fun-ci: no run for #{sha[0, 7]} yet."])
+        end
+        ExitCode::FOR.fetch(:undecided)
+      end
+
+      # Says the wait moves on to the commit that superseded `sha`; JSON has only the answer.
+      def following(sha, report)
+        return if @json
+
+        @stdout.puts "fun-ci: #{sha[0, 7]} was superseded; following #{report.branch} to #{report.superseded_by[0, 7]}."
+      end
+
+      # entries: [[report, age in words], ...], newest first.
+      def runs(entries)
+        return print_json(entries.map { |report, _| StatusJson.document(report) }) if @json
+
+        print_lines(RunsText.lines(entries))
+      end
+
+      private
+
+      def print_json(document) = @stdout.puts(JSON.generate(document))
+      def print_lines(lines) = lines.each { |line| @stdout.puts line }
+    end
+  end
+end

data/lib/fun_ci/agent/report_stage.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../evidence/document"
+require_relative "../persistence/stage_job"
+
+module FunCi
+  module Agent
+    RunReport = Data.define(:sha, :subject, :branch, :need, :stages, :verdict, :deciding, :superseded_by)
+
+    # One stage of a run, as an agent is told it.
+    class RunReport
+      STATES = { "completed" => "passed", "timed_out" => "over_budget", "scheduled" => "waiting" }.freeze
+
+      # What a failed stage left to explain itself: the end of its output,
+      # and the failures it reported, each { file:, line:, test:, message: },
+      # unless they were pruned; the evidence document, if it kept one; and
+      # how many bytes of raw output are kept, if any.
+      Kept = Data.define(:tail, :failures, :pruned, :evidence, :raw_bytes)
+
+      class Kept
+        def initialize(pruned: false, evidence: nil, raw_bytes: nil, **) = super
+
+        def document
+          evidence ? Evidence::Document.from_json(evidence) : Evidence::Document.legacy(tail: tail, failures: failures)
+        end
+      end
+
+      NOTHING_KEPT = Kept.new(tail: nil, failures: [])
+
+      # How a finished stage's process ended, and the budget it had.
+      Exit = Data.define(:exit_status, :signal, :budget)
+      NO_EXIT = Exit.new(exit_status: nil, signal: nil, budget: nil)
+
+      # id: the stage's row, nil for a stage that hasn't started.
+      Stage = Data.define(:name, :state, :seconds, :kept, :exit, :id)
+
+      class Stage
+        def initialize(kept: NOTHING_KEPT, exit: NO_EXIT, id: nil, **) = super
+        def exit_status = exit.exit_status
+        def signal = exit.signal
+        def budget = exit.budget
+        def evidence = kept.document
+        def pruned? = kept.pruned
+        def raw_bytes = kept.raw_bytes
+        def tail = kept.tail
+        # The failures its evidence names, from whichever extractor found them.
+        def failures = evidence.failures.map { |failure| failure.except(:extractor) }
+
+        def self.from_row(name, job)
+          return new(name: name, state: "waiting", seconds: nil) unless job
+
+          ended = Exit.new(exit_status: job[:exit_status], signal: job[:signal], budget: job[:budget])
+          new(name: name, state: STATES.fetch(job[:status], job[:status]), seconds: seconds(job), id: job[:id],
+              kept: kept(job), exit: ended)
+        end
+
+        def self.kept(job)
+          failures = job[:failures] ? JSON.parse(job[:failures], symbolize_names: true) : []
+          Kept.new(tail: job[:output_tail], failures: failures, pruned: job[:pruned] == 1, evidence: job[:evidence],
+                   raw_bytes: job[:raw_bytes])
+        end
+
+        def self.seconds(job)
+          Persistence::StageJob.elapsed_duration(job)&.round(1)
+        end
+        private_class_method :kept, :seconds
+      end
+    end
+  end
+end

data/lib/fun_ci/agent/reports.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../persistence/project_runs"
+require_relative "../persistence/stage_job"
+require_relative "../persistence/raw_outputs"
+require_relative "run_report"
+
+module FunCi
+  module Agent
+    # The runs of the project git names, as an agent is told them.
+    class Reports
+      def initialize(db, git)
+        @db = db
+        @git = git
+        @runs = Persistence::ProjectRuns.new(db, git.toplevel)
+        @raw = Persistence::RawOutputs.beside(db.filename("main"))
+      end
+
+      # What the stage kept of its raw output, or nil.
+      def raw_output(stage) = stage.id && @raw.read(stage.id)
+
+      # The commit's newest run, or nil.
+      def for(sha, need)
+        run = @runs.latest_of_commit(sha)
+        run && of(run, need)
+      end
+
+      # Notes that an agent is waiting on the commit's newest run, as of `at`.
+      def mark_waited(sha, at)
+        run = @runs.latest_of_commit(sha)
+        Persistence::PipelineRun.mark_waited(@db, run[:id], at.utc.iso8601) if run
+      end
+
+      # [[run, its report for the whole pipeline], ...], newest first.
+      def recent(limit:, branch:)
+        @runs.recent(limit: limit, branch: branch).map { |run| [run, of(run, "all")] }
+      end
+
+      def of(run, need)
+        superseded_by = run[:status] == "cancelled" ? @runs.superseded_by(run) : nil
+        jobs = Persistence::StageJob.for_run(@db, run[:id]).map { |job| job.merge(raw_bytes: @raw.bytes(job[:id])) }
+        RunReport.build(run: run, jobs: jobs, need: need,
+                        commit: { subject: @git.subject(run[:commit_hash]), superseded_by: superseded_by })
+      end
+    end
+  end
+end

data/lib/fun_ci/agent/run_report.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "verdict"
+require_relative "report_stage"
+
+module FunCi
+  module Agent
+    # What an agent is told about one run: its commit, each of the four stages
+    # in pipeline order, and the verdict for the level it needs.
+    class RunReport
+      STAGES = %w[lint build fast slow].freeze
+
+      # deciding: the stage whose failure or overrun decided the verdict, if one did.
+      def initialize(deciding: nil, **) = super
+
+      # commit: the run's subject and the commit that superseded it, if any.
+      def self.build(run:, jobs:, need:, commit:)
+        verdict = Verdict.decide(run_status: run[:status], stages: jobs, need: need)
+        new(sha: run[:commit_hash], branch: run[:branch], need: need, stages: stages(jobs), verdict: verdict,
+            deciding: Verdict.deciding_stage(stages: jobs, need: need), **commit)
+      end
+
+      # The four stages in pipeline order, from the run's stage rows.
+      def self.stages(jobs)
+        by_name = jobs.to_h { |job| [job[:stage], job] }
+        STAGES.map { |name| Stage.from_row(name, by_name[name]) }
+      end
+    end
+  end
+end

data/lib/fun_ci/agent/runs_command.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "command_support"
+require_relative "output"
+require_relative "age"
+
+module FunCi
+  module Agent
+    # `fun-ci runs [-n N] [--branch NAME] [--json]` (acceptance-tests.md, AT-9.4).
+    class RunsCommand
+      include CommandSupport
+
+      NAME = "runs"
+
+      def initialize(context)
+        @context = context
+      end
+
+      def run(args)
+        options = Options.parse(args, takes: %i[limit branch json])
+        entries = reports.recent(limit: options.limit, branch: options.branch).map { |run, report| [report, age(run)] }
+        Output.new(@context.io.stdout, json: options.json).runs(entries)
+        0
+      rescue Options::Invalid => e
+        usage(e.message)
+      end
+
+      private
+
+      def age(run) = Age.words(@context.clock.now - Time.parse(run[:created_at]))
+    end
+  end
+end

data/lib/fun_ci/agent/runs_text.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "run_report"
+
+module FunCi
+  module Agent
+    # One line per run, the columns lined up: short SHA, branch, age, each
+    # stage's outcome in a word of four letters at most, and the subject.
+    module RunsText
+      WORDS = { "passed" => "ok", "failed" => "FAIL", "over_budget" => "OVER", "running" => "...", "waiting" => "-",
+                "cancelled" => "x" }.freeze
+
+      # entries: [[report, age in words], ...], newest first.
+      def self.lines(entries)
+        widths = [entries.map { |report, _| report.branch.size }.max, entries.map { |_, age| age.size }.max]
+        entries.map { |report, age| line(report, age, widths) }
+      end
+
+      def self.line(report, age, (branch_width, age_width))
+        stages = report.stages.map { |stage| "#{stage.name} #{WORDS.fetch(stage.state).ljust(4)}" }.join("  ")
+        "#{report.sha[0,
+                      7]}  #{report.branch.ljust(branch_width)}  #{age.ljust(age_width)}  #{stages}  #{report.subject}"
+      end
+      private_class_method :line
+    end
+  end
+end