kimera 0.1.5 → 0.1.6

data/lib/kimera/cli/run/cycle.rb

@@ -4,6 +4,7 @@ require_relative "../../execution/suite_env"
 require_relative "../../incremental/selection"
 require_relative "../../incremental/session"
 require_relative "digest"
+require_relative "narrowing"
 require_relative "pass"
 require_relative "sources"
 
@@ -24,19 +25,21 @@ class Kimera::CLI::Run::Cycle
 
   def scope(selected)
     eligible = focus(selected || @registry.each.map { |mutant, _| mutant.id })
-    ignored = Kimera::IgnoreList.ids(@registry, @options[:ignore]) & eligible
-    notify(selected, ignored)
+    resolution = Kimera::IgnoreList.resolve(@registry, @options[:ignore])
+    ignored = resolution.ids & eligible
+    notify(selected, ignored, resolution)
     session(eligible - ignored, ignored)
   end
 
-  def notify(selected, ignored)
-    @digest.stale(@registry, @options[:ignore])
+  def notify(selected, ignored, resolution)
+    @digest.anchors(resolution)
     @digest.announce(selected, ignored, files: @registry.files.size, since: @options[:since])
+    @digest.evaluating(ignored) if @options[:evaluate_ignored]
   end
 
   def session(todo, ignored)
     loaded = Kimera::Incremental::Session.load(@options[:session], registry: @registry)
-    perform(todo, loaded)
+    perform(@options[:evaluate_ignored] ? todo + ignored : todo, loaded)
     conclude(todo, ignored, loaded)
   end
 
@@ -55,21 +58,23 @@ class Kimera::CLI::Run::Cycle
 
   def emission
     { path: @options[:report], format: @options.fetch(:format, "text"), metadata: provenance }
-      .merge(coverage: coverage, log: @options[:log])
+      .merge(coverage: coverage, log: @options[:log], scope: narrowing.note)
   end
 
+  def narrowing = @_narrowing ||= Kimera::CLI::Run::Narrowing.new(@options)
+
   def coverage = @options[:fail_on_no_coverage] ? :list : :hint
 
   def focus(eligible)
-    ids = Array(@options[:focus])
+    ids = Array(@options[:focus]).map { |token| @registry.keys.id(token) }
     return eligible if ids.empty?
     missing = ids - eligible
     missing.empty? ? ids : raise(Kimera::UsageError, "focused mutant(s) not in scope: #{missing.join(", ")}")
   end
 
   def provenance
-    @options.slice(:framework, :source_root, :tests, :exclude_tests, :operators, :coverage, :isolated, :jobs)
-      .transform_keys(&:to_s)
+    @options.slice(:framework, :source_root, :tests, :exclude_tests, :operators, :coverage, :isolated, :jobs, :since)
+      .transform_keys(&:to_s).merge(narrowing.provenance)
   end
 
   def harness(remaining, loaded, env: ENV)

data/lib/kimera/cli/run/digest.rb

@@ -21,8 +21,14 @@ class Kimera::CLI::Run::Digest
     @io.puts("Ignoring #{ignored.size} mutant(s) marked equivalent.") unless ignored.empty?
   end
 
-  def stale(registry, rules)
-    Kimera::IgnoreList.stale(registry, rules).each { |rule| @errors.puts(anchor(rule)) }
+  def evaluating(ignored)
+    return if ignored.empty?
+    @io.puts("Evaluating them anyway (--evaluate-ignored): each keeps status ignored and records its verdict.")
+  end
+
+  def anchors(resolution)
+    resolution.stale.each { |rule| @errors.puts(anchor(rule)) }
+    resolution.moved.each { |shift| @errors.puts(moved(shift)) }
   end
 
   def verbose(options)
@@ -43,6 +49,8 @@ class Kimera::CLI::Run::Digest
     "kimera: warning: ignore entry matches no mutant (stale anchor?): #{spot(rule)} #{rule[:label]}".rstrip
   end
 
+  def moved(shift) = "kimera: warning: ignore entry re-anchored: #{shift} (update the entry to silence this)"
+
   def spot(rule)
     [rule[:file], rule[:line]].compact.join(":")
   end

data/lib/kimera/cli/run/emission.rb

@@ -17,8 +17,8 @@ class Kimera::CLI::Run::Emission
     @quiet = quiet
   end
 
-  def emit(report, registry, path: nil, format: "text", metadata: nil, coverage: :hint, log: nil)
-    text = rendered(report, registry, coverage, path)
+  def emit(report, registry, path: nil, format: "text", metadata: nil, coverage: :hint, log: nil, scope: nil)
+    text = rendered(report, registry, coverage, path, scope)
     document = report.document(metadata)
     present(text, format, document)
     save(log, text) if log
@@ -27,9 +27,10 @@ class Kimera::CLI::Run::Emission
 
   private
 
-  def rendered(report, registry, coverage, path)
+  def rendered(report, registry, coverage, path, scope)
     io = StringIO.new
-    Kimera::Report::Text.new(registry, io: io, color: color?).report(report, coverage: coverage, path: path)
+    Kimera::Report::Text.new(registry, io: io, color: color?)
+      .report(report, scope: scope, coverage: coverage, path: path)
     io.string
   end
 

data/lib/kimera/cli/run/narrowing.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "../../scope/file_set"
+
+class Kimera::CLI
+end
+
+class Kimera::CLI::Run
+end
+
+class Kimera::CLI::Run::Narrowing
+  def initialize(options)
+    @options = options
+  end
+
+  def narrowed?
+    kept, total = counts
+    kept < total
+  end
+
+  def provenance
+    narrowed? ? { "narrowed" => true, "configured_tests" => @options[:configured_tests] } : { "narrowed" => false }
+  end
+
+  def note
+    return unless narrowed?
+    kept, total = counts
+    "narrowed run: --tests matched #{count(kept)} of #{count(total)} test files from the configured tests: " \
+      "glob; survivors may be killed by tests outside it"
+  end
+
+  private
+
+  def counts = @_counts ||= measure
+
+  def measure
+    tests, configured = @options.values_at(:tests, :configured_tests)
+    return [0, 0] if tests == configured
+    all = files(configured)
+    [(all & files(tests)).size, all.size]
+  end
+
+  def files(globs)
+    Kimera::FileSet.expand(globs, exclude: @options[:exclude_tests]).map { |file| File.expand_path(file) }
+  end
+
+  def count(number) = number.to_s.reverse.scan(/\d{1,3}/).join(",").reverse
+end

data/lib/kimera/cli/run/options.rb

@@ -35,8 +35,8 @@ module Kimera::CLI::RunOptions
       Kimera::Flag.build("--since REF", :since, "Incremental: only mutate lines changed vs REF (git diff)"),
       Kimera::Flag.build("--session FILE", :session, "Persist/resume per-mutant results in FILE"),
       Kimera::Flag.build(
-        "--focus ID", :focus, "Evaluate only one or more mutant IDs (repeatable)",
-        type: Integer, collect: true
+        "--focus ID|KEY", :focus, "Evaluate only these mutants, by ID or report key (repeatable)",
+        collect: true
       ),
       Kimera::Flag.build("--[no-]gate", :gate, "Return gate status (default: on; use --no-gate for exploration)"),
       Kimera::Flag.build("--max-survivors N", :max_survivors, "Gate: fail only if survivors exceed N", type: Integer),
@@ -44,6 +44,11 @@ module Kimera::CLI::RunOptions
         "--max-ignored N", :max_ignored,
         "Gate: fail if more than N mutants are ignore-listed", type: Integer
       ),
+      Kimera::Flag.build(
+        "--evaluate-ignored", :evaluate_ignored,
+        "Also run ignored mutants; they stay ignored but record their verdict (killed, survived, ...)"
+      ),
+      Kimera::Flag.build("--no-baseline", :baseline, "Skip the config's baseline: file (its mutants are judged)"),
       Kimera::Flag.build(
         "--max-errors N", :max_errors,
         "Gate: fail if more than N mutants could not be judged (default 0)", type: Integer
@@ -63,6 +68,7 @@ module Kimera::CLI::RunOptions
       Kimera::Flag.build(["-q", "--quiet"], :quiet, "Suppress the final human-readable report"),
       Kimera::Flag.build(["-v", "--verbose"], :verbose, "Print resolved scope and execution settings"),
       Kimera::Flag.build("--log FILE", :log, "Write the final human-readable report to FILE"),
+      Kimera::Flag.build("--pidfile FILE", :pidfile, "Write kimera's process id to FILE, removed when the run ends"),
       Kimera::Flag.build(
         "--[no-]isolate-db", :isolate_db, "Wrap each mutant in a rolled-back ActiveRecord transaction"
       ),

data/lib/kimera/cli/run.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "fileutils"
 require_relative "../error"
 require_relative "../plugins"
 
@@ -27,7 +28,8 @@ class Kimera::CLI::Run
   end
 
   def run(argv)
-    cycle(parse(argv)).call
+    options = parse(argv)
+    pid_file(options[:pidfile]) { cycle(options).call }
   rescue Kimera::Error => error
     @errors.puts("kimera: #{error.message}")
     1
@@ -35,6 +37,18 @@ class Kimera::CLI::Run
 
   private
 
+  def pid_file(path, &)
+    return yield unless path
+    File.write(path, "#{Process.pid}\n")
+    held(path, &)
+  end
+
+  def held(path)
+    yield
+  ensure
+    FileUtils.rm_f(path)
+  end
+
   def parse(argv) = Kimera::CLI::Run::Arguments.new.parse(argv)
 
   def cycle(options)

data/lib/kimera/cli/survivors/panel.rb

@@ -11,7 +11,7 @@ class Kimera::CLI::Survivors::Panel
     @io.puts("#{matching.size} #{options[:status]} mutant(s):")
     sorted(matching).each { |row| entry(row) }
     @io.puts
-    @io.puts("detail: kimera mutant <N> --report #{options[:report]}")
+    @io.puts("detail: kimera mutant <ID|KEY> --report #{options[:report]}")
   end
 
   def describe(row)
@@ -76,6 +76,6 @@ class Kimera::CLI::Survivors::Panel
   end
 
   def location(row)
-    [row["file"], row["line"]].compact.join(":")
+    row["key"] || [row["file"], row["line"]].compact.join(":")
   end
 end

data/lib/kimera/cli/survivors.rb

@@ -11,7 +11,7 @@ class Kimera::CLI::Survivors
       "Lists a report's surviving mutants; FILE_SUBSTRING keeps only " \
       "mutants whose file path contains it (e.g. models/discount).",
     flags: [
-      Kimera::Flag.build("--id N", :id, "Show one mutant in full detail", type: Integer),
+      Kimera::Flag.build("--id ID|KEY", :id, "Show one mutant, by ID or key, in full detail"),
       Kimera::Flag.build(
         "--status NAME", :status,
         "List a different status (survived, no_coverage, " \
@@ -74,7 +74,7 @@ class Kimera::CLI::Survivors
   end
 
   def show(results, id)
-    row = results.find { |candidate| candidate["mutant_id"] == id }
+    row = Kimera::CLI::ReportFile.row(results, id)
     return missing(id) unless row
     Panel.new(io: @io).describe(row)
     0

data/lib/kimera/cli/test_command.rb

@@ -5,6 +5,12 @@ require_relative "../execution/suite_env"
 
 class Kimera::CLI::TestCommand
   LOADER = "ARGV.map { |f| File.expand_path(f) }.tap { ARGV.clear }.each { |f| require(f) }"
+  MAX_LISTED = 10
+  COUNT_LINE = /\d+ (?:failures?|examples?)\b/i
+  SUMMARIES = [COUNT_LINE, /failed|Error\b/i].freeze
+  RSPEC_RERUN = /^rspec (\S+) #/
+  MINITEST_HEADER = /^\s*\d+\) (?:Failure|Error):\n(.+?)(?: \[[^\]]*\])?:$/
+  CULPRITS = [RSPEC_RERUN, MINITEST_HEADER].freeze
   DRY_RUN = "require 'minitest'; Minitest.class_variable_set(:@@installed_at_exit, true); #{LOADER}; exit!(0)".freeze
 
   def initialize(framework, files, root:)
@@ -14,7 +20,9 @@ class Kimera::CLI::TestCommand
   end
 
   def baseline
-    check(run, "Baseline: configured test suite is green") { |failure| ["✗", "Baseline: #{advice(failure)}"] }
+    check(run, "Baseline: configured test suite is green") do |failure, output|
+      ["✗", "Baseline: #{advice(failure)}#{failing(output)}"]
+    end
   end
 
   def loading
@@ -32,7 +40,7 @@ class Kimera::CLI::TestCommand
 
   def check(command, passed)
     output, status = Open3.capture2e(Kimera::Execution::SUITE_ENV, *command, chdir: @root)
-    status.success? ? ["✓", passed] : yield(summary(output))
+    status.success? ? ["✓", passed] : yield(summary(output), output)
   rescue Errno::ENOENT
     yield(nil)
   end
@@ -41,8 +49,19 @@ class Kimera::CLI::TestCommand
 
   def dry_run = minitest? ? ruby(DRY_RUN) : rspec("--dry-run")
 
+  def failing(output)
+    ids = culprits(output.to_s)
+    return "" if ids.empty?
+    "\n  failing tests:#{ids.first(MAX_LISTED).map { |id| "\n    #{id}" }.join}#{overflow(ids)}"
+  end
+
+  def overflow(ids) = (ids.size - MAX_LISTED).then { |more| more.positive? ? "\n    … and #{more} more" : "" }
+
+  def culprits(output) = CULPRITS.flat_map { |pattern| output.scan(pattern).flatten }.uniq
+
   def summary(output)
-    output.lines.reverse.find { |line| line.match?(/\d+ failures?|\d+ examples?|failed|Error\b/i) }&.strip ||
+    lines = output.lines.reverse
+    SUMMARIES.lazy.filter_map { |pattern| lines.find { |line| line.match?(pattern) } }.first&.strip ||
       "test command failed"
   end
 

data/lib/kimera/execution/isolated_child.rb

@@ -3,6 +3,7 @@
 require "json"
 require "rspec/core"
 require "stringio"
+require_relative "../support/test_exit"
 
 begin
   RSpec::Core::ConfigurationOptions.new([]).configure(RSpec.configuration)
@@ -14,6 +15,10 @@ RSpec.configuration.output_stream = output
 RSpec.configuration.error_stream = StringIO.new
 RSpec.configuration.deprecation_stream = StringIO.new
 
+RSpec.configuration.before(:suite) do
+  RSpec.world.all_examples.each { |example| example.extend(Kimera::TestExit::Example) }
+end
+
 ledger, request = ARGV
 locations = JSON.parse(File.read(request, encoding: Encoding::UTF_8)).fetch("tests")
 code = RSpec::Core::Runner.run(locations)

data/lib/kimera/execution/isolated_child_minitest.rb

@@ -2,6 +2,7 @@
 
 require "json"
 require "minitest"
+require_relative "../support/test_exit"
 
 Minitest.seed ||= 1
 begin
@@ -36,7 +37,7 @@ killer =
   ids.find do |id|
     klass, name = methods[id]
     next false unless klass
-    result = klass.new(name).run
+    result = klass.new(name).extend(Kimera::TestExit::Test).run
     !result.passed? && !result.skipped?
   end
 

data/lib/kimera/execution/parallel_test_databases.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 class Kimera::Execution::ParallelTestDatabases
+  LOCK_WAITS = { /postg/i => "SET lock_timeout = '5s'", /mysql|trilogy/i => "SET SESSION lock_wait_timeout = 5" }.freeze
+
   def initialize(adapter:, jobs:, errors: nil)
     @adapter = adapter
     @jobs = jobs
@@ -26,16 +28,14 @@ class Kimera::Execution::ParallelTestDatabases
   end
 
   def before_exit(index)
-    Array(index).each { |worker| cleanup(worker) }
-  rescue StandardError => error
-    errors.puts("kimera: parallelize_teardown failed (#{error.class}: #{error.message})")
+    attempt("parallelize_teardown failed") { Array(index).each { |worker| cleanup(worker) } }
   end
 
   private
 
   def cleanup(index)
     return unless active?
-    scrub
+    attempt("could not empty the worker's test database") { scrub }
     ActiveSupport::Testing::Parallelization.run_cleanup_hooks.each { |hook| hook.call(index) }
   end
 
@@ -46,12 +46,24 @@ class Kimera::Execution::ParallelTestDatabases
     nil
   end
 
+  def attempt(failure)
+    yield
+  rescue StandardError => error
+    errors.puts("kimera: #{failure} (#{error.class}: #{error.message})")
+  end
+
   def scrub
     return unless defined?(ActiveRecord::Base)
     connection = ActiveRecord::Base.connection
+    bound(connection)
     connection.truncate_tables(*connection.tables)
   end
 
+  def bound(connection)
+    statement = LOCK_WAITS.find { |pattern, _| connection.adapter_name.match?(pattern) }&.last
+    connection.execute(statement) if statement
+  end
+
   def errors = @errors || $stderr
 
   def eligible?

data/lib/kimera/execution/shift.rb

@@ -73,11 +73,13 @@ class Kimera::Execution::Shift
 
   def step(line, responses, history, index)
     request = JSON.parse(line)
-    return if process(request["id"], responses, history, index, MODES.fetch(request["recheck"], :warm)).is_a?(Suspect)
+    return if tainted?(process(request["id"], responses, history, index, MODES.fetch(request["recheck"], :warm)))
     emit(responses, t: "ready")
     index + 1
   end
 
+  def tainted?(result) = result.is_a?(Suspect) || result.status == :timeout
+
   def safely(subject, mode)
     tests = available(subject.id)
     return subject.verdict(:no_coverage) if tests.empty?
@@ -103,7 +105,7 @@ class Kimera::Execution::Shift
     result = evaluate(id, mode)
     emit(io, **result.message)
     history << id if result.killed?
-    leaks.check(io, history, index) unless result.is_a?(Suspect)
+    leaks.check(io, history, index) unless tainted?(result)
     result
   end
 

data/lib/kimera/execution/worker_pool/worker.rb

@@ -38,9 +38,9 @@ Kimera::Execution::WorkerPool::Worker =
       deadline && !(deadline - now).positive?
     end
 
-    def retire
+    def retire(limit)
       self.inflight = nil
-      self.deadline = nil
+      renew(limit)
       request
     end
 

data/lib/kimera/execution/worker_pool.rb

@@ -92,7 +92,7 @@ class Kimera::Execution::WorkerPool
 
   def trace(slot, id) = context.options[:trace]&.call(slot, id)
 
-  def close(worker) = shut(worker.retire)
+  def close(worker) = shut(worker.retire(limit))
 
   def watch
     current = now

data/lib/kimera/frameworks/minitest_adapter.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "adapter"
+require_relative "../support/test_exit"
 
 module Kimera
   module Frameworks
@@ -75,7 +76,7 @@ class Kimera::Frameworks::MinitestAdapter < Kimera::Frameworks::Adapter
   def record(id, failed, failures)
     klass, name = @methods[id]
     return unless klass
-    result = klass.new(name).run
+    result = klass.new(name).extend(Kimera::TestExit::Test).run
     return unless killing?(result)
     failure(id, result, failed, failures)
   end

data/lib/kimera/frameworks/rspec_adapter.rb

@@ -3,6 +3,7 @@
 require "rspec/core"
 require_relative "adapter"
 require_relative "rspec_group_index"
+require_relative "../support/test_exit"
 
 module Kimera
   module Frameworks
@@ -105,7 +106,9 @@ class Kimera::Frameworks::RSpecAdapter < Kimera::Frameworks::Adapter
   end
 
   def index(top)
-    Kimera::Frameworks::RSpecGroupIndex.examples(top).each { |example| @examples[example.id] = example }
+    Kimera::Frameworks::RSpecGroupIndex.examples(top).each do |example|
+      @examples[example.id] = example.extend(Kimera::TestExit::Example)
+    end
   end
 
   def clear(examples)

data/lib/kimera/incremental/session.rb

@@ -68,10 +68,14 @@ class Kimera::Incremental::Session
 
   def report(evaluated, waived, registry)
     results = evaluated.filter_map { |id| @results[id] }
-    results += waived.map { |id| Kimera::MutantResult.waived(id, registry.index[id]&.file) }
+    results += waived.map { |id| waiver(id, registry) }
     Kimera::RunReport.new(results: results, leaks: @leaks, registry: registry)
   end
 
+  def waiver(id, registry)
+    @results[id]&.waive || Kimera::MutantResult.waived(id, registry.index[id]&.file)
+  end
+
   def merge!(report)
     report.results.each { |r| @results[r.mutant_id] = r }
     @leaks.concat(report.leaks)

data/lib/kimera/registry/mutant_keys.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "digest"
+require_relative "mutation_point"
+
+class Kimera::MutantKeys
+  ORDINAL = /\A\d+\z/
+  LINE = /:\d+:(?=\h{8}\z)/
+
+  Fingerprint =
+    Data.define(:point, :mutant) do
+      def key(repeats)
+        repeats[facts] += 1
+        "#{point.file}:#{point.location.start_line}:#{digest(repeats[facts])}"
+      end
+      private
+      def facts = [point.file, point.method_name, point.operator, point.original_source.split.join(" "), mutant.label]
+      def digest(repeat) = Digest::SHA256.hexdigest([*facts, repeat].join("\n"))[0, 8]
+    end
+
+  def self.of(registry)
+    repeats = Hash.new(0)
+    new(registry.each.to_h { |mutant, point| [mutant.id, Fingerprint.new(point, mutant).key(repeats)] })
+  end
+
+  def initialize(keys)
+    @keys = keys
+  end
+
+  def [](id) = @keys[id]
+
+  def id(token)
+    text = token.to_s
+    text.match?(ORDINAL) ? text.to_i : @keys.key(text) || moved(text) || text
+  end
+
+  private
+
+  def moved(text)
+    found = @keys.select { |_id, key| unlined(key) == unlined(text) }.keys
+    found.first if found.one?
+  end
+
+  def unlined(key) = key.sub(LINE, ":")
+end

data/lib/kimera/registry/registry.rb

@@ -2,6 +2,7 @@
 
 require "json"
 require_relative "mutation_point"
+require_relative "mutant_keys"
 
 class Kimera::Registry
   FORMAT_VERSION = 1
@@ -53,6 +54,10 @@ class Kimera::Registry
     paired[id]
   end
 
+  def keys
+    @_keys ||= Kimera::MutantKeys.of(self)
+  end
+
   def each
     return enum_for(:each) unless block_given?
     @points.each do |point|

data/lib/kimera/report/actions.rb

@@ -14,7 +14,7 @@ class Kimera::Report::Actions
     hints = path ? SavedHints.new(path) : UnsavedHints.new
     lines = [
       advice(report.survived, hints, :survivors), advice(report.uncovered, hints, :uncovered),
-      advice(report.errors, hints, :unjudged)
+      advice(report.errors, hints, :unjudged), advice(report.statuses(:ignored).select(&:lapsed?), hints, :lapsed)
     ].compact
     @io.puts("", "Next actions:", *lines) unless lines.empty?
   end
@@ -37,6 +37,8 @@ class Kimera::Report::Actions
 
     def unjudged(id) = "unjudged mutant(s): see why with `#{mutant(id)}`"
 
+    def lapsed(_id) = "ignored mutant(s) now killed: `kimera baseline prune BASELINE.yml --report #{@path}`"
+
     private
 
     def mutant(id) = "kimera mutant #{id} --report #{@path}"
@@ -48,5 +50,7 @@ class Kimera::Report::Actions
     def uncovered(_id) = "uncovered mutant(s): rerun with --report tmp/kimera.json"
 
     def unjudged(_id) = "unjudged mutant(s): retry with `kimera run --isolated`"
+
+    def lapsed(_id) = "ignored mutant(s) now killed: rerun with --report FILE, then `kimera baseline prune`"
   end
 end

data/lib/kimera/report/sections.rb

@@ -10,6 +10,21 @@ module Kimera::Report::Sections
 
   def unjudged(report) = section("Mutants Kimera could not judge", report.errors) { |r| unjudge(r) }
 
+  def waivers(report)
+    judged = report.statuses(:ignored).select(&:verdict)
+    return if judged.empty?
+    @io.puts
+    @io.puts(verdicts(judged))
+  end
+
+  def verdicts(judged)
+    lapsed = judged.count(&:lapsed?)
+    surviving = judged.count { |result| result.verdict == :survived }
+    other = judged.size - lapsed - surviving
+    line = "#{lapsed} ignored mutant(s) are now killed (their entries can be pruned); #{surviving} still survive"
+    other.zero? ? "#{line}." : "#{line}; #{other} could not be judged."
+  end
+
   def unjudge(result)
     id = result.mutant_id
     @io.puts("  #{red("unjudged")} ##{id}  #{where(@registry.index[id], result)}  #{result.detail}")

data/lib/kimera/report/text.rb

@@ -43,6 +43,7 @@ class Kimera::Report::Text
   def survivors(report)
     section("Surviving mutants", report.survived) { |result| survivor(result) }
     unjudged(report)
+    waivers(report)
   end
 
   def summary(report)