saboteur 0.12.0 → 0.12.2

data/lib/saboteur/cli/survivors_command.rb

@@ -2,8 +2,10 @@
 # frozen_string_literal: true
 
 require "json"
+require "stringio"
 
 require_relative "../survivor_guidance"
+require_relative "../reporter/palette"
 require_relative "../reporter/survivor_hints"
 
 module Saboteur
@@ -17,6 +19,11 @@ module Saboteur
       # Where `saboteur run` writes the JSON report unless configured otherwise.
       DEFAULT_REPORT = Config::DEFAULTS["json_report"]
 
+      # survivors owns its usage line (#1150): the report path is optional
+      # because the run always writes the same default.
+      SURVIVORS_USAGE = "Usage: saboteur survivors [options] [REPORT] - REPORT defaults to " \
+                        ".saboteur/report.json"
+
       private
 
       def survivors_command
@@ -27,28 +34,53 @@ module Saboteur
       end
 
       def survivors_command_inner
-        parser = OptionParser.new do |opts|
-          opts.on("--ranked", "Review-priority order: the report's ranked findings first")
-          opts.on("--file SUBSTR", "Only survivors whose path contains SUBSTR")
-          opts.on("--operator NAME", "Only survivors of operator NAME")
-          opts.on("--triage LABEL", "Only survivors classified LABEL (for example boundary)")
-          opts.on("--show DIGEST", "Diff, replay command and ignore template for one survivor")
-        end
         options = {}
-        args = parser.parse!(@argv, into: options)
+        parser = survivors_parser(options)
+        args = parse_survivors_args(parser, options)
+        if options[:help]
+          @out.puts(parser)
+          return EXIT_OK
+        end
         path = args.shift || DEFAULT_REPORT
-        raise UsageError, "unexpected arguments: #{args.join(' ')}" if args.any?
+        raise UsageError, "unexpected arguments: #{args.join(' ')}\n#{parser}" if args.any?
 
         report = load_survivor_report(path)
-        browser = SurvivorsBrowser.new(report)
+        browser = SurvivorsBrowser.new(report, palette: Reporter::Palette.for(@out, mode: options.fetch(:color, :auto)))
         if options[:show]
           @out.puts(browser.show(options[:show]))
         else
-          @out.puts(browser.list(**options.slice(:ranked, :file, :operator, :triage)))
+          # Explicit keywords, and list takes no catch-all (#1267): a new
+          # parser option that never reaches the browser raises here instead
+          # of being swallowed. --ranked is the documented compat no-op.
+          @out.puts(browser.list(file: options[:file], operator: options[:operator], triage: options[:triage]))
         end
         EXIT_OK
       end
 
+      # The same colour flags as run (#1150), plus the browser filters.
+      def survivors_parser(options)
+        OptionParser.new do |opts|
+          opts.banner = SURVIVORS_USAGE
+          opts.on("--ranked", "Review-priority order (the default): the terminal report's ordering")
+          opts.on("--file SUBSTR", "Only survivors whose path contains SUBSTR")
+          opts.on("--operator NAME", "Only survivors of operator NAME")
+          opts.on("--triage LABEL", "Only survivors classified LABEL (for example boundary)")
+          opts.on("--show DIGEST", "Diff, replay command and ignore template for one survivor")
+          opts.on("--color [MODE]", %w[always never auto],
+                  "Colour the output: always, never, or auto when MODE is omitted") do |mode|
+            options[:color] = (mode || :always).to_sym
+          end
+          opts.on("--no-color", "Alias for --color=never") { options[:color] = :never }
+          opts.on("--help", "Show this help") { options[:help] = true }
+        end
+      end
+
+      def parse_survivors_args(parser, options)
+        parser.parse!(@argv, into: options)
+      rescue OptionParser::ParseError => e
+        raise UsageError, "#{e.message}\n#{parser}"
+      end
+
       def load_survivor_report(path)
         unless File.file?(path)
           hint = path == DEFAULT_REPORT ? "; run saboteur first, or pass a report path" : ""
@@ -64,14 +96,21 @@ module Saboteur
     # Reads the report's files section (the complete mutant list), not the
     # capped findings, so survivors beyond the findings limit still list.
     class SurvivorsBrowser
-      def initialize(report)
+      # Sibling digests named on a collapse line; the rest are a count - the
+      # same shape the terminal report's collapse uses (#1150).
+      SIBLING_DIGEST_CAP = 3
+
+      def initialize(report, palette: Reporter::Palette.for(StringIO.new))
         @report = report
         @findings = report.dig("saboteur", "findings") || {}
+        @palette = palette
       end
 
-      def list(ranked: false, file: nil, operator: nil, triage: nil)
-        survivors = filtered(file, operator, triage)
-        survivors = ranked_order(survivors) if ranked
+      # One ordering everywhere (#1150): the terminal report's ranked order
+      # is the default, exactly as the findings carry it; --ranked stays
+      # accepted for compatibility.
+      def list(file: nil, operator: nil, triage: nil)
+        survivors = ranked_order(filtered(file, operator, triage))
         return "no survivors#{filters_note(file, operator, triage)}" if survivors.empty?
 
         [header(survivors.size, file, operator, triage), *rows(survivors)]
@@ -160,19 +199,32 @@ module Saboteur
       def header(size, file, operator, triage)
         text = "#{size} survivor#{'s' unless size == 1}#{filters_note(file, operator, triage)}"
         truncated = @findings["survivorsTruncated"].to_i
-        return text unless truncated.positive?
-
-        "#{text} (the report's ranked findings name only the first #{@findings['limit'] || 10})"
+        if truncated.positive?
+          text = "#{text} (the report's ranked findings name only the first #{@findings['limit'] || 10})"
+        end
+        @palette.paint(:head, text)
       end
 
+      # The terminal collapse: sibling mutants on one statement fold into the
+      # first row, which names up to SIBLING_DIGEST_CAP of their digests.
       def rows(survivors)
-        survivors.each_with_index.map do |s, i|
-          format("%3<i>d. %<path>s:%<line>d  %-28<operator>s %<digest>s  %<classification>s",
-                 i: i + 1, path: s[:path], line: s[:line], operator: s[:operator], digest: s[:digest],
-                 classification: s[:classification] || "-")
+        survivors.group_by { |s| [s[:path], s[:line]] }.values.each_with_index.map do |group, i|
+          first, *siblings = group
+          format("%3<i>d. %<path>s:%<line>d  %-28<operator>s %<digest>s  %<classification>s%<suffix>s",
+                 i: i + 1, path: first[:path], line: first[:line], operator: first[:operator],
+                 digest: first[:digest], classification: first[:classification] || "-",
+                 suffix: siblings_suffix(siblings))
         end
       end
 
+      def siblings_suffix(siblings)
+        return "" if siblings.empty?
+
+        named = siblings.first(SIBLING_DIGEST_CAP).map { |s| s[:digest] }.join(", ")
+        rest = siblings.size - SIBLING_DIGEST_CAP
+        "  (+#{siblings.size} here: #{named}#{", +#{rest} more" if rest.positive?})"
+      end
+
       def ignore_entry(survivor, subject)
         block = if subject
                   SurvivorGuidance.ignore_block(survivor[:digest], subject)
@@ -192,12 +244,17 @@ module Saboteur
                 subject: m["subject"], covered: m["coveredBy"] || [], source: entry["source"] }
             end
           end
-          survivors.sort_by { |s| [s[:path], s[:line], s[:digest]] }
+          survivors
         end
       end
 
+      # Ranked order straight from the report: the uncapped findings "order"
+      # list first, with the capped findings as the fallback for older
+      # reports; anything unknown trails in file order.
       def ranked_order(survivors)
-        rank = @findings.fetch("survivors", []).each_with_index.to_h { |f, i| [f["digest"], i] }
+        order = @findings["order"] ||
+                (@findings.fetch("survivors", []) + @findings.fetch("accepted", [])).map { |f| f["digest"] }
+        rank = order.each_with_index.to_h
         survivors.sort_by { |s| [rank[s[:digest]] || Float::INFINITY, -s[:covered].size, s[:path], s[:line], s[:digest]] }
       end
 

data/lib/saboteur/cli/whole_suite_map_lookup.rb

@@ -0,0 +1,33 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+module Saboteur
+  class CLI
+    # The whole-suite coverage map a finished run hands to survivor
+    # presentation, and the notice for a scoped run that has none.
+    module WholeSuiteMapLookup
+      private
+
+      # No engine or no cache: no whole-suite map can exist, so the survivor
+      # block keeps its legacy covered-by line over an impossible build (review C1).
+      def whole_suite_map_for(engine, report)
+        warn_survivors_unconfirmed(report, engine)
+        return engine.whole_suite_coverage_map if engine&.whole_suite_map_lookup?
+
+        Reporter::SurvivorList::NO_WHOLE_SUITE_LOOKUP
+      end
+
+      # A scoped run's survivors may be pinned by a spec it never loaded.
+      # With no whole-suite map to check, say so once, even under --quiet
+      # (#1286). Verdicts, score and exit code are unchanged.
+      def warn_survivors_unconfirmed(report, engine)
+        return if report.unignored_survivors.empty?
+        return unless engine&.whole_suite_map_lookup? && engine.scoped_selection?
+        return if engine.whole_suite_coverage_map
+
+        @err.puts "saboteur: survivors unconfirmed: no whole-suite coverage map; " \
+                  "run `saboteur run --all` to build one"
+      end
+    end
+  end
+end

data/lib/saboteur/cli.rb

@@ -13,7 +13,9 @@ require_relative "cli/error_cause"
 require_relative "cli/exit_status"
 require_relative "cli/baseline_gate"
 require_relative "preview"
+require_relative "cli/color_option"
 require_relative "cli/run_reporting"
+require_relative "cli/whole_suite_map_lookup"
 require_relative "cli/survivors_command"
 require_relative "cli/explain_command"
 require_relative "cli/source_set"
@@ -43,7 +45,9 @@ module Saboteur
     include Baseline::Command
     include ExitStatus
     include BaselineGate
+    include ColorOption
     include RunReporting
+    include WholeSuiteMapLookup
     include SurvivorsCommand
     include ExplainCommand
     include SourceSet
@@ -100,7 +104,7 @@ module Saboteur
     end
 
     def call
-      command = @argv.shift
+      command = @command = @argv.shift
       case command
       when "run" then run_command
       when "baseline" then baseline
@@ -109,7 +113,7 @@ module Saboteur
       when "doctor" then doctor_command
       when "badge", "trend" then history_entry(command)
       when "version", "--version" then @out.puts(VERSION) || EXIT_OK
-      when "help", "--help", "-h" then show_help(@argv.shift)
+      when "help", "--help", "-h" then help_command
       when "agent-skill" then @out.print(AgentSkill::TEXT) || EXIT_OK
       else preset_or_usage_error(command)
       end

data/lib/saboteur/engine/coverage_store.rb

@@ -18,7 +18,10 @@ module Saboteur
       CACHE_INPUTS = %w[integration require rspec_args rails tests coverage_recorder].freeze
       # Names the freshest whole-suite map build; read as an untrusted hint:
       # only a bare 64-hex key joins the cache dir (#427).
-      WHOLE_SUITE_POINTER = "whole-suite-map"
+      # Renamed from "whole-suite-map" in 0.12.2: older versions also wrote
+      # the pointer for maps built from inferred specs, which are not whole
+      # suites, so their pointers are never read (#1286).
+      WHOLE_SUITE_POINTER = "whole-suite-map-v2"
       LOCKFILES = %w[Gemfile.lock gems.locked].freeze
       LOG = "coverage-build.log"
       # RSpec rewrites this on every run (example_status_persistence_file_path),
@@ -65,7 +68,7 @@ module Saboteur
         return serve_cached(path, cached, files, preloaded) if cached
 
         note = miss_note(files)
-        @diagnostics.inform(note.message(scoped: !@config["tests"].empty?)) if @config["cache"]
+        @diagnostics.notice(note.message(scoped: !@config["tests"].empty?)) if @config["cache"]
         started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         map = fresh_map(files, note, preloaded)
         build_seconds = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
@@ -237,7 +240,7 @@ module Saboteur
         return build_parts(files, parts) if parts.size > 1
 
         scope = @config["tests"].empty? ? "the whole suite" : "the selected specs"
-        @diagnostics.inform("building coverage map (runs #{scope} once)")
+        @diagnostics.notice("building coverage map (runs #{scope} once)")
         # The suite child forked next inherits this heap; pack it first, to
         # reduce later copying of shared pages.
         Execution::ForkReadiness.prepare_heap
@@ -267,7 +270,7 @@ module Saboteur
         total, counts = usage_checked { check_parts_cover_suite(parts) }
         saved = saved_parts(files, parts.size, counts)
         todo = saved.each_index.select { |index| saved[index].nil? }
-        @diagnostics.inform(parts_note(parts.size, todo.size))
+        @diagnostics.notice(parts_note(parts.size, todo.size))
         built = todo.empty? ? [] : run_parts(files, parts, todo)
         todo.zip(built) { |index, map| saved[index] = map }
         map = combine_saved(saved, total, files, parts.size)

data/lib/saboteur/engine/diagnostics.rb

@@ -17,6 +17,12 @@ module Saboteur
       # be watched: the heartbeat then adds the count, the percentage and an
       # estimate of the time left to its elapsed-time line.
       class ProgressHeartbeat
+        # --quiet substitute: responds to the supervisor's calls, prints nothing.
+        NULL = Object.new.tap do |noop|
+          def noop.watch(*) = self
+          def noop.tick = nil
+        end
+
         COUNT = %r{(\d+)/([1-9]\d*) examples finished}
         TAIL_BYTES = 4096
 
@@ -91,9 +97,10 @@ module Saboteur
       attr_reader :warnings, :live_announced, :invalid_mutations, :generation_events, :omissions, :discovery_failures,
                   :hazard_suppressions, :inline_suppressions, :verbose, :quiet_start
 
-      def initialize(err, verbose: false, palette: nil, quiet_start: true)
+      def initialize(err, verbose: false, palette: nil, quiet_start: true, quiet: false)
         @err = err
         @verbose = verbose
+        @quiet = quiet
         @quiet_start = quiet_start
         @palette = palette || Reporter::Palette.for(err)
         @warnings = []
@@ -180,10 +187,17 @@ module Saboteur
         @err.puts("saboteur: #{Text.display_safe_lines(message)}")
       end
 
+      # First-run explanations (#1264): the --quiet contract is findings,
+      # score and verdict, so these stay off stderr under it and print
+      # exactly as before otherwise.
+      def notice(message)
+        inform(message) unless @quiet
+      end
+
       # Chatter the default view folds into the quiet-start lines;
       # --verbose prints it byte-for-byte as before.
       def detail(message)
-        inform(message) if @verbose || !@quiet_start
+        inform(message) if !@quiet && (@verbose || !@quiet_start)
       end
 
       # A selection explanation the default view carries as one dim
@@ -199,7 +213,7 @@ module Saboteur
       # The quiet start: three lines, then progress. --verbose keeps
       # today's chatter instead and never prints these.
       def quiet_start_header(scope:, seed:, operators:)
-        return if @verbose || !@quiet_start
+        return if @quiet || @verbose || !@quiet_start
 
         dot = @palette.glyph(:middot)
         line = "saboteur #{Saboteur::VERSION} #{dot} #{scope} #{dot} seed #{seed} #{dot} " \
@@ -208,7 +222,7 @@ module Saboteur
       end
 
       def quiet_baseline(passes:, elapsed:, tests:, cached:)
-        return if @verbose || !@quiet_start
+        return if @quiet || @verbose || !@quiet_start
 
         check = @palette.paint(:pass, @palette.glyph(:check))
         suffix = cached ? " (cached)" : ""
@@ -219,7 +233,7 @@ module Saboteur
       end
 
       def quiet_inference(spec_count)
-        return if spec_count.nil? || @verbose || !@quiet_start
+        return if spec_count.nil? || @quiet || @verbose || !@quiet_start
 
         files = spec_count == 1 ? "spec file" : "spec files"
         @err.puts(@palette.paint(:dim, "spec inference: #{spec_count} #{files} (details: --verbose)"))
@@ -252,6 +266,10 @@ module Saboteur
       # fork time. Prints "<label>: N s elapsed" about every interval
       # seconds, so a long phase does not look stuck.
       def progress_heartbeat(label, interval: 30)
+        # --quiet: the contract is findings, score and verdict - no elapsed
+        # chatter; the heartbeat's ticks become no-ops.
+        return ProgressHeartbeat::NULL if @quiet
+
         ProgressHeartbeat.new(self, label, interval: interval)
       end
 
@@ -261,6 +279,8 @@ module Saboteur
       # The count lives in one file the workers inherit, so every worker adds
       # to the same number.
       def start_progress(total)
+        return if @quiet
+
         @progress_total = total
         @progress_started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         @progress_file = Tempfile.new("saboteur-progress")
@@ -271,6 +291,8 @@ module Saboteur
       end
 
       def progress(result)
+        return if @quiet
+
         mark = MARKS.fetch(result.status, "?")
         return plain_progress(painted_mark(mark)) unless @progress_file
 

data/lib/saboteur/engine/pipelines.rb

@@ -104,9 +104,16 @@ module Saboteur
       # "Full run" for ignore staleness (#1206): no --since diff, no --subject
       # filter, and no narrowed include (explicit file arguments replace the
       # configured include) - only then was every in-scope subject examined, so
-      # an entry whose subject never appears really points at gone code.
+      # an entry whose subject never appears really points at gone code. The
+      # include nobody set counts as unscoped whether it is the generic
+      # default or the Rails one a config-less app gets (#1255).
       def unscoped_full_run?
-        !config["since"] && config["subjects"].empty? && config["include"] == Config::DEFAULTS["include"]
+        !config["since"] && config["subjects"].empty? && default_include?
+      end
+
+      def default_include?
+        config["include"] == Config::DEFAULTS["include"] ||
+          (config["include"] == Config::RAILS_INCLUDE && !config.explicit?("include"))
       end
 
       def external_command? = !config["test_command"].to_s.empty?

data/lib/saboteur/engine/survivor_confirmation.rb

@@ -15,13 +15,14 @@ module Saboteur
       # confirmation_budget caps the whole pass.
       MAX_SPECS_PER_SURVIVOR = 8
 
-      def initialize(config:, map:, scheduler:, diagnostics:, budget_exceeded:, cache: nil)
+      def initialize(config:, map:, scheduler:, diagnostics:, budget_exceeded:, cache: nil, load_specs: ->(_files) {})
         @config = config
         @map = map
         @scheduler = scheduler
         @diagnostics = diagnostics
         @budget_exceeded = budget_exceeded
         @cache = cache
+        @load_specs = load_specs
       end
 
       def call(results, ignore_list:, early_stop: nil)
@@ -33,19 +34,60 @@ module Saboteur
                             "stopped early (#{early_stop.reason})")
         end
         @remaining = @config["confirmation_budget"]
+        @map_silent = 0
         results.map { |result| survivors.include?(result) ? confirm(result) : result }
                .tap { |confirmed| summarize(confirmed) }
+               .tap { warn_map_silent }
       end
 
       private
 
+      # A crash while confirming one survivor downgrades it to unconfirmed
+      # with one warning; it never ends the run (#1140).
       def confirm(result)
+        confirm_checked(result)
+      rescue RefusedSpecPath => e
+        warn_refused(e)
+        result.with_confirmation("unconfirmed_map(a covering spec from the whole-suite map was refused)")
+      rescue StandardError => e
+        warn_failed(result, e)
+        unconfirmed(result, "confirmation failed: #{e.class}")
+      end
+
+      # The map named a spec that is not a spec file inside the project: the
+      # map cannot be trusted, so its survivors stay counted (#1286).
+      def warn_refused(error)
+        return if @warned_refused
+
+        @warned_refused = true
+        @diagnostics.warn("survivor confirmation refused the whole-suite coverage map: " \
+                          "#{error.message.lines.first.strip}; its survivors stay counted; " \
+                          "run `saboteur run --all` to rebuild it")
+      end
+
+      # One line per run, however many survivors hit the same failure.
+      def warn_failed(result, error)
+        return if @warned_failure
+
+        @warned_failure = true
+        @diagnostics.warn("survivor confirmation failed for #{result.subject.id} #{result.digest} " \
+                          "(#{error.class}: #{error.message.lines.map(&:strip).reject(&:empty?).first}); " \
+                          "its survivors stay unconfirmed, outside the score")
+      end
+
+      def confirm_checked(result)
         return unconfirmed(result, "the confirmation budget is spent") if @remaining <= 0
         return unconfirmed(result, "the --max-duration budget is spent") if @budget_exceeded.call
 
-        tests = unrun_covering_tests(result)
-        return unconfirmed(result, "no covering tests") if tests.empty?
+        # Nothing in the whole-suite map covers the edited lines (the tree
+        # drifted since the map was built): the map cannot confirm anything.
+        covering = covering_tests(result)
+        return map_silent(result) if covering.empty?
 
+        tests = unrun_covering_tests(result, covering)
+        return result.with_confirmation("confirmed") if tests.empty?
+
+        load_unselected_specs(tests)
         outcome = run_confirmation(result, tests)
         @remaining -= outcome.runtime || 0
         case outcome.status
@@ -58,8 +100,14 @@ module Saboteur
       # The whole-suite map's covering tests for the mutant's edited lines
       # (branch evidence intersected, mirroring the scheduler), minus the
       # tests the mutant already ran, fastest first, capped.
-      def unrun_covering_tests(result)
-        fastest_first(covering_tests(result) - (result.executed || result.covered_by)).first(MAX_SPECS_PER_SURVIVOR)
+      def unrun_covering_tests(result, covering)
+        fastest_first(covering - (result.executed || result.covered_by)).first(MAX_SPECS_PER_SURVIVOR)
+      end
+
+      # The covering specs may live in files this run never loaded; the
+      # forked confirmation child can only run examples already in its world.
+      def load_unselected_specs(tests)
+        @load_specs.call(tests.map { |id| id.sub(/\[[\d:]+\]\z/, "") })
       end
 
       def covering_tests(result)
@@ -86,11 +134,12 @@ module Saboteur
       # becomes an error; a check the budgets never let run comes back
       # unverified - outside the score and never cached.
       def checked_kill(result, tests, outcome)
-        kill = result.with_confirmation("confirmed", status: :killed, reason: outcome.message,
-                                                     killed_by: outcome.failed_ids, covered_by: tests,
-                                                     kill_cause: outcome.kill_cause,
-                                                     runtime: (result.runtime || 0) + (outcome.runtime || 0),
-                                                     executed: (result.executed || []) + outcome.executed_ids)
+        kill = result.with_confirmation(
+          "killed_by_confirmation", status: :killed, reason: outcome.message, killed_by: outcome.failed_ids,
+                                    covered_by: tests, kill_cause: outcome.kill_cause,
+                                    runtime: (result.runtime || 0) + (outcome.runtime || 0),
+                                    executed: (result.executed || []) + outcome.executed_ids
+        )
         checked = VerdictCheck.new(run_unchanged: unchanged_runner(result.subject),
                                    baseline_timeout: @config["baseline_timeout"]).call([kill]).first
         return checked unless checked.status == :killed
@@ -108,7 +157,7 @@ module Saboteur
       # (#1079). ResultCache#record replaces the subject+mutation entry, so
       # the stale survivor verdict cannot win a later lookup.
       def record_kill(result, kill)
-        @cache&.record(kill.with_confirmation("confirmed", covered_by: covering_tests(result)))
+        @cache&.record(kill.with_confirmation("killed_by_confirmation", covered_by: covering_tests(result)))
       end
 
       # The unchanged-method re-run VerdictCheck checks a kill against, in
@@ -129,6 +178,13 @@ module Saboteur
         end
       end
 
+      # The map says nothing about the edited lines (the tree drifted since it
+      # was built): the survivor stays counted and the pass says so once.
+      def map_silent(result)
+        @map_silent += 1
+        result.with_confirmation("unconfirmed_map(no covering tests in the whole-suite map)")
+      end
+
       def unconfirmed(result, reason)
         result.with_confirmation("unconfirmed(#{reason})")
       end
@@ -148,6 +204,14 @@ module Saboteur
         durations.empty? ? nil : durations.sum / durations.size
       end
 
+      def warn_map_silent
+        return if @map_silent.zero?
+
+        @diagnostics.warn("survivor confirmation: the whole-suite coverage map covers none of the edited lines of " \
+                          "#{@map_silent} survivor#{'s' unless @map_silent == 1}, so they stay counted; " \
+                          "run `saboteur run --all` to rebuild it")
+      end
+
       def summarize(results)
         counts = results.filter_map(&:confirmation).tally
         return if counts.empty?

data/lib/saboteur/engine/test_guess.rb

@@ -116,7 +116,8 @@ module Saboteur
         # Why the subjectless files needed no spec.
         def subjectless_message(since:)
           detail = since ? "no changed mutation subjects" : "no mutation subjects"
-          "inferred specs: no spec is required for #{names(subjectless)}: they have #{detail}"
+          who = subjectless.size == 1 ? "it has" : "they have"
+          "inferred specs: no spec is required for #{names(subjectless)}: #{who} #{detail}"
         end
 
         # The per-file warning when the run proceeds with the mapped