saboteur 0.4.0 → 0.5.0

data/lib/saboteur/cli.rb

@@ -6,9 +6,17 @@ require_relative "../saboteur"
 require_relative "doctor"
 require_relative "help"
 require_relative "reporter/replay"
+require_relative "baseline/command"
+require_relative "cli/exit_status"
+require_relative "preview"
+require_relative "cli/run_reporting"
 
 module Saboteur
   class CLI
+    include Baseline::Command
+    include ExitStatus
+    include RunReporting
+
     USAGE = "Usage: saboteur run [SOURCE...] [--test TEST...] [--threshold PERCENT] [--since REF] " \
             "[--subject 'Klass#meth'] [--timeout-factor N] [--jobs N] [--seed N] [--id DIGEST]
 " \
@@ -32,7 +40,8 @@ module Saboteur
 
     def call
       case @argv.shift
-      when "run" then help_requested? ? show_help("run") : run
+      when "run" then run_command
+      when "baseline" then baseline
       when "doctor" then help_requested? ? show_help("doctor") : doctor
       when "version", "--version" then @out.puts(VERSION) || EXIT_OK
       when "help" then show_help(@argv.shift)
@@ -54,25 +63,34 @@ module Saboteur
         define_selection_options(opts)
         define_explicit_file_options(opts)
         define_execution_options(opts)
+        define_matrix_option(opts)
         define_output_options(opts)
       end
     end
 
     # Each command's own option lines, as printed under OPTIONS in `saboteur help`.
     def option_lines
-      { "run" => parser.summarize, "doctor" => doctor_parser.summarize }
+      { "run" => parser.summarize, "doctor" => doctor_parser.summarize, "baseline" => baseline_parser.summarize }
     end
 
     def doctor_parser
       OptionParser.new do |opts|
-        opts.banner = "Usage: saboteur doctor [--config PATH] [--seed N]"
+        opts.banner = "Usage: saboteur doctor [--config PATH] [--seed N] [--suite] [--test PATH]"
         opts.on("--config PATH", "Config file (default config/saboteur.rb)") { |value| set(:config, value) }
         opts.on("--seed N", Integer, "Seed for the two baseline runs (default 1)") { |value| set(:seed, value) }
+        opts.on("--suite", "Also run the unchanged suite twice (slow on a large suite)") { set(:suite, true) }
+        opts.on("--test PATH", "Spec file or directory for the suite runs; repeatable. Implies --suite") do |value|
+          (options[:tests] ||= []) << value
+        end
       end
     end
 
     private
 
+    def run_command
+      help_requested? ? show_help("run") : run
+    end
+
     def help_requested?
       @argv.intersect?(%w[--help -h])
     end
@@ -112,11 +130,12 @@ module Saboteur
     def run
       parser.parse!(@argv)
       use_explicit_sources
-      reject_threshold_with_agent_format
+      validate_run_options
+      warn_dirty_tree
 
-      arguments = { err: @err }
-      arguments[:digest] = options[:id] if options[:id]
-      agent? ? agent_run(arguments) : text_run(Engine.new(config, **arguments).call)
+      return preview if options[:list_operators] || options[:dry_run]
+
+      execute_run
     rescue ConfigError => e
       @err.puts("saboteur: #{e.message}")
       agent_failure(e.message, EXIT_USAGE)
@@ -125,32 +144,45 @@ module Saboteur
       agent_failure(e.message, EXIT_TOOL)
     end
 
+    # Mutants run your code, and a mutant of code that writes or deletes files
+    # can change the tree. Say so up front when uncommitted work is at stake.
+    def warn_dirty_tree
+      WorkingTree.new(config.root, ignored: config.output_paths).state.warning&.then { |text| @err.puts(text) }
+    end
+
+    # Usage errors found before the target boots.
+    def validate_run_options
+      reject_threshold_with_agent_format
+      Selection::GitDiff.verify_ref!(config["since"], root: config.root) if config["since"]
+    end
+
     # Agent mode has one strict meaning for exit 0, so a score threshold cannot also decide it.
     def reject_threshold_with_agent_format
-      return unless agent? && config["threshold"]
+      return unless agent? && (config["threshold"] || gates.any?)
 
-      raise UsageError, "--threshold cannot be combined with --agent: agent mode exits 0 only for a complete, clean run"
+      raise UsageError, "#{config['threshold'] ? '--threshold' : '--max-* gates'} cannot be combined with --agent"
     end
 
-    def text_run(report)
-      @err.puts
-      Reporter::Terminal.new(@out).call(report)
-      Reporter::Replay.new(@out).call(report) if options[:id]
-      code = exit_code(report)
-      # The JSON carries the exit cause an outer harness trusts, so it is
-      # the completion evidence for the whole run: write it only after
-      # every other fallible reporting stage, or a late failure would
-      # leave a fresh, misleading report behind.
-      write_html(report)
-      write_json(report, exit_cause(report, code))
-      code
+    # One line naming the reports written, paths relative to the root when
+    # they sit under it (a blank line before it, as the old JSON line had).
+    def announce_reports(reports)
+      written = reports.select { |path, _label| path }
+      return if written.empty?
+
+      root = File.join(File.realpath(config.root), "")
+      names = written.map do |path, label|
+        shown = File.expand_path(path).delete_prefix(root)
+        "#{shown} (#{label})"
+      end
+      @out.puts "\nReports: #{names.join(', ')}"
     end
 
     def doctor
       doctor_parser.parse!(@argv)
       raise UsageError, "unexpected arguments: #{@argv.join(' ')}" if @argv.any?
 
-      Doctor.new(config, out: @out).call
+      options[:tests]&.each { |test| require_existing_test(test) }
+      Doctor.new(config, out: @out, suite: options[:suite] || options.key?(:tests)).call
       EXIT_OK
     rescue ConfigError => e
       @err.puts("saboteur: #{e.message}")
@@ -162,29 +194,6 @@ module Saboteur
 
     # Agent mode: stdout carries exactly one JSON payload. The target's own output (boot
     # files, hooks, spec loading, child processes) goes to stderr while the engine runs.
-    def agent_run(arguments)
-      tree = WorkingTree.new(config.root, ignored: output_paths).state
-      report = stdout_on_stderr { Engine.new(config, **arguments).call }
-      payload = Reporter::Agent.call(report, agent_provenance(report, tree))
-      rendered = Reporter::Agent.render(payload)
-      # Same publish order as text_run: the JSON is the completion
-      # evidence, so it is written only after every other fallible stage,
-      # including the agent payload itself.
-      write_html(report, announce: false)
-      write_json(report, agent_exit_cause(report, payload), announce: false)
-      @out.print(rendered)
-      Reporter::Agent.exit_code(payload)
-    end
-
-    # Paths of saboteur's own output, relative to the root, that do not count as source changes.
-    def output_paths
-      root = File.join(File.realpath(config.root), "")
-      %w[cache_dir json_report html_report].filter_map { |key| config.path(key) }
-                                           .map { |path| File.expand_path(path) }
-                                           .select { |path| path.start_with?(root) }
-                                           .map { |path| path.delete_prefix(root) }
-    end
-
     # Descriptor 1 points at stderr for the block, so Kernel#puts, system and forked
     # children cannot write into the JSON on stdout.
     def stdout_on_stderr
@@ -196,11 +205,12 @@ module Saboteur
       saved&.close
     end
 
-    def agent_provenance(report, tree)
+    def agent_provenance(report, tree, engine)
       Reporter::Agent::Provenance.new(
         ref: config["since"], seed: report.seed, head: tree.head, working_tree: tree.label,
         changed_files: tree.changed_files, mode: agent_mode, json_report: config.path("json_report"),
-        subjects: Array(config["subjects"]), tests: Array(options[:tests]), sources: @sources || [],
+        subjects: Array(config["subjects"]), tests: Array(engine.guessed_tests || options[:tests]),
+        sources: @sources || [],
         config_path: options[:config], digest: options[:id], cache: config["cache"],
         incremental: config["incremental"], settings: options.slice(*Reporter::Agent::Commands::SETTING_FLAGS.keys)
       )
@@ -213,89 +223,21 @@ module Saboteur
       @sources&.any? ? "files" : "full"
     end
 
-    def write_json(report, cause, announce: true)
+    # Writes the JSON report and returns its path, or nil when none is configured.
+    def write_json(report, cause)
       path = config.path("json_report")
       return unless path
 
       Reporter::Stryker.new(path).call(report, exit_cause: cause)
-      @out.puts "\nJSON report: #{path}" if announce
+      path
     end
 
-    def write_html(report, announce: true)
+    def write_html(report)
       path = config.path("html_report")
       return unless path
 
       Reporter::Html.new(path).call(report)
-      @out.puts "HTML report: #{path}" if announce
-    end
-
-    def exit_code(report)
-      return EXIT_TOOL if mostly_errored?(report)
-
-      return EXIT_TOOL if incomplete_under_threshold?(report)
-
-      failed_quality_gate?(report) ? EXIT_SURVIVORS : EXIT_OK
-    end
-
-    def mostly_errored?(report)
-      return false unless report.majority_errored?
-
-      executed = report.executed
-      errors = executed.count { |result| result.status == :error }
-      @err.puts("saboteur: #{errors} of #{executed.size} mutants errored, so the run tested almost nothing; " \
-                "fix the errors and run again")
-      true
-    end
-
-    # Agent mode: the recorded cause is the payload's own verdict, so the
-    # JSON and the process exit classify the run the same way. An
-    # incomplete run that mostly errored keeps its distinct cause, so the
-    # harness rule means the same thing in both modes.
-    def agent_exit_cause(report, payload)
-      case payload[:verdict]
-      when "clean" then "ok"
-      when "survivors" then "survivors"
-      else report.majority_errored? ? "errorMajority" : "incomplete"
-      end
-    end
-
-    # Why the run exits the way it does, recorded in the JSON report so an
-    # outer harness can tell "most mutants errored" from the other exit 3s.
-    def exit_cause(report, code)
-      case code
-      when EXIT_OK then "ok"
-      when EXIT_SURVIVORS then config["threshold"].nil? ? "survivors" : "belowThreshold"
-      else report.majority_errored? ? "errorMajority" : "incompleteUnderThreshold"
-      end
-    end
-
-    # With --threshold the score decides; without it any unignored survivor does.
-    def failed_quality_gate?(report)
-      threshold = config["threshold"]
-      return report.unignored_survivors.any? if threshold.nil?
-
-      score = report.score
-      return missing_score_reported? if score.nil?
-
-      score * 100 < threshold
-    end
-
-    # A gate that cannot measure a score must not pass: CI would go green
-    # on a run that tested nothing.
-    def missing_score_reported?
-      @err.puts("saboteur: no mutant was tested, so there is no score to compare with --threshold")
-      true
-    end
-
-    # Errors and resource limits are outside the score. With a threshold they
-    # make the run incomplete, so the score alone cannot pass it.
-    def incomplete_under_threshold?(report)
-      return false if config["threshold"].nil?
-
-      count = report.counts.values_at(:error, :resource_limit).sum
-      @err.puts("saboteur: #{count} mutant(s) errored or hit a resource limit, so the score is incomplete") if
-        count.positive?
-      count.positive?
+      path
     end
 
     # Positional arguments name the files (or directories) to mutate. They
@@ -337,10 +279,25 @@ module Saboteur
     end
 
     def overrides
-      options.except(:config, :id)
+      options.except(:config, :id, :suite, :list_operators, :dry_run)
+    end
+
+    def preview
+      raise UsageError, "--dry-run and --list-operators print text, not --agent JSON" if agent?
+      raise UsageError, "--id replays one mutant: not with --dry-run or --list-operators" if options[:id]
+
+      return MutationSource::OperatorRegistry.list(@out) || EXIT_OK if options[:list_operators]
+
+      Preview.new(config, out: @out, err: @err).call
+      EXIT_OK
     end
 
     def define_selection_options(opts)
+      opts.on("--operators NAMES", Array, "Choose operator names or tiers (core, extended, all)") do |v|
+        set(:operators, v)
+      end
+      opts.on("--list-operators", "List operator names, descriptions and tiers") { set(:list_operators, true) }
+      opts.on("--dry-run", "Preview mutants without boot, tests, forks or report writes") { set(:dry_run, true) }
       opts.on("--id DIGEST", "Replay exactly one current mutant by its full digest") { |v| set(:id, v) }
       opts.on("--since REF", "Only mutate subjects changed since git REF") { |v| options[:since] = v }
       opts.on("--subject EXPR", "Klass#meth, Klass.meth or a namespace; repeatable") { |v| add_subject(v) }
@@ -356,15 +313,37 @@ module Saboteur
       opts.on("--integration NAME", "Test adapter (rspec)") { |v| set(:integration, v) }
       opts.on("--reeval STRATEGY", Execution::Reevaluator::STRATEGIES, "class_eval or nesting") { |v| set(:reeval, v) }
       opts.on("--no-cache", "Rebuild the coverage map") { set(:cache, false) }
+      opts.on("--allow-hazardous", "Also run mutants inside destructive calls (rm_rf, system, ...)") do
+        set(:allow_hazardous, true)
+      end
+      opts.on("--fail-fast", "Stop after the first subject with a survivor (needs --jobs 1)") { set(:fail_fast, true) }
       opts.on("--incremental", "Reuse earlier verdicts whose inputs did not change") { set(:incremental, true) }
+      opts.on("--allow-focus", "Run even when a focus filter (fit, fdescribe, :focus) narrows the suite") do
+        set(:allow_focus, true)
+      end
+      opts.on("--[no-]guess-tests", "With --since: run only the specs named after the changed files " \
+                                    "(lib/a.rb -> spec/a_spec.rb); the whole suite if any has none") do |v|
+        set(:guess_tests, v)
+      end
+    end
+
+    def define_matrix_option(opts)
+      opts.on("--matrix", "Run every covering test per mutant and list blind and redundant tests") do
+        set(:matrix, true)
+      end
     end
 
     def define_output_options(opts)
+      opts.on("--score-history PATH", "Append score history JSONL (opt-in)") { |v| set(:score_history, v) }
       opts.on("--json PATH", "Stryker JSON report path") { |v| set(:json_report, v) }
       opts.on("--html PATH", "Self-contained HTML report path") { |v| set(:html_report, v) }
       opts.on("--format FORMAT", %w[text agent], "text (default) or agent: one bounded JSON summary on stdout, " \
                                                  "strict exit codes") { |v| @format = v }
       opts.on("--agent", "Same as --format agent") { @format = "agent" }
+      opts.on("--verbose", "Text report: also print score split, timings and kill causes") { @verbose = true }
+      opts.on("--[no-]color", "Colour the text report (default: on for a terminal unless NO_COLOR is set)") do |v|
+        @color = v ? :always : :never
+      end
     end
 
     def define_explicit_file_options(opts)
@@ -374,6 +353,7 @@ module Saboteur
       opts.on("--threshold PERCENT", Float, "Exit 1 when the score is below PERCENT (0-100)") do |v|
         set(:threshold, v)
       end
+      Gates.define_options(opts) { |key, value| set(key, value) }
     end
 
     def add_subject(expr)

data/lib/saboteur/config.rb

@@ -2,6 +2,8 @@
 # frozen_string_literal: true
 
 require_relative "mutation_source/builtin"
+require_relative "mutation_source/operator_registry"
+require_relative "mutation_source/hazard_guard"
 
 module Saboteur
   # Settings from config/saboteur.rb, overridden by CLI flags.
@@ -20,6 +22,11 @@ module Saboteur
       "include" => ["lib/**/*.rb"],
       "exclude" => [],
       "arid" => MutationSource::Builtin::DEFAULT_ARID,
+      "whole_file" => [],
+      "hazard" => MutationSource::HazardGuard::DEFAULT_HAZARD,
+      "allow_hazardous" => false,
+      "sandbox" => true, # true, false, or "strict": strict refuses to run without full Landlock
+      "sandbox_writable" => [],
       "timeout_factor" => 3.0,
       "timeout_min" => 5.0,
       "baseline_timeout" => 300.0,
@@ -31,29 +38,37 @@ module Saboteur
       "ignore_file" => "config/saboteur_ignore.rb",
       "custom_map" => "config/saboteur_custom_map.rb",
       "sources" => ["builtin"],
+      "operators" => [],
       "hooks" => [],
       "rails" => false,
       "reeval" => "nesting",
       "cache_dir" => ".saboteur",
       "json_report" => ".saboteur/report.json",
       "html_report" => ".saboteur/report.html",
+      "score_history" => nil,
       "rspec_args" => [],
       "subjects" => [],
       "since" => nil,
       "cache" => true,
       "incremental" => false,
+      "allow_focus" => false,
+      "fail_fast" => false,
+      "guess_tests" => false,
+      "matrix" => false,
       "seed" => 1,
       "tests" => [],
       "fingerprint_extra" => [],
-      "threshold" => nil
+      "threshold" => nil,
+      "max_timeouts" => nil,
+      "max_errors" => nil
     }.freeze
 
     INTEGER_KEYS = %w[jobs max_memory_mb max_processes max_mutants_per_method seed].freeze
     FLOAT_KEYS = %w[timeout_factor timeout_min baseline_timeout coverage_timeout].freeze
     THRESHOLD_RANGE = (0.0..100.0)
 
-    LIST_KEYS = %w[require include exclude arid sources hooks rspec_args subjects tests
-                   fingerprint_extra].freeze
+    LIST_KEYS = %w[require include exclude arid hazard sources hooks rspec_args subjects tests
+                   fingerprint_extra sandbox_writable operators whole_file].freeze
 
     attr_reader :root
 
@@ -106,7 +121,7 @@ module Saboteur
       matched = self["include"].flat_map { |pattern| Dir.glob(pattern, base: root) }
       excluded = self["exclude"].flat_map { |pattern| Dir.glob(pattern, base: root) }
       (matched - excluded).select { |file| file.end_with?(".rb") }
-                          .map { |file| File.realpath(File.join(root, file)) }.uniq.sort
+                          .map { |file| File.realpath(File.expand_path(file, root)) }.uniq.sort
     end
 
     # Patterns that match no file. A pattern goes stale when files move;
@@ -122,6 +137,15 @@ module Saboteur
       value && File.expand_path(value, root)
     end
 
+    # Paths of saboteur's own output, relative to the root, that do not count as source changes.
+    def output_paths
+      prefix = File.join(File.realpath(root), "")
+      %w[cache_dir json_report html_report score_history].filter_map { |key| path(key) }
+                                                         .map { |file| File.expand_path(file) }
+                                                         .select { |file| file.start_with?(prefix) }
+                                                         .map { |file| file.delete_prefix(prefix) }
+    end
+
     private
 
     def coerce!
@@ -139,9 +163,39 @@ module Saboteur
 
     def validate_report_paths!
       json = path("json_report")
-      return unless json && json == path("html_report")
+      if json && json == path("html_report")
+        raise ConfigError, "json_report and html_report both point to #{json}; give each report its own path"
+      end
+
+      paths = %w[json_report html_report score_history].filter_map { |key| path(key) }
+      return if paths.uniq.size == paths.size
+
+      raise ConfigError, "json_report, html_report and score_history must have distinct paths"
+    end
+
+    def validate_modes!
+      validate_fail_fast!
+      validate_matrix!
+      validate_guess_tests!
+      validate_gates!
+    end
+
+    def validate_gates!
+      Gates::SETTINGS.each_key { |key| Gates.limit(self[key], key) }
+    end
 
-      raise ConfigError, "json_report and html_report both point to #{json}; give each report its own path"
+    def validate_fail_fast!
+      return unless self["fail_fast"] && self["jobs"] > 1
+
+      raise ConfigError, "fail_fast needs jobs 1: parallel workers have already started the other subjects"
+    end
+
+    # A reused verdict was computed by a run that stopped at the first
+    # failing test, so it lists too few killers for a matrix.
+    def validate_matrix!
+      return unless self["matrix"] && self["incremental"]
+
+      raise ConfigError, "matrix cannot be combined with incremental: reused verdicts list only the first killer"
     end
 
     def validate_threshold!
@@ -151,6 +205,13 @@ module Saboteur
       raise ConfigError, "threshold must be between 0 and 100"
     end
 
+    def validate_guess_tests!
+      return unless self["guess_tests"]
+
+      raise ConfigError, "guess_tests needs since" unless self["since"]
+      raise ConfigError, "guess_tests cannot be combined with tests" if self["tests"].any?
+    end
+
     def validate_reeval!
       raise ConfigError, "reeval must be one of: #{Execution::Reevaluator::STRATEGIES.join(', ')}" unless
         Execution::Reevaluator::STRATEGIES.include?(self["reeval"].to_s)
@@ -158,9 +219,13 @@ module Saboteur
 
     def validate!
       raise ConfigError, "jobs must be >= 1" if self["jobs"] < 1
+      unless [true, false, "strict"].include?(self["sandbox"])
+        raise ConfigError, 'sandbox must be true, false, or "strict"'
+      end
 
       validate_mutant_limit!
       validate_threshold!
+      validate_modes!
       raise ConfigError, "seed must be >= 0" if self["seed"].negative?
       raise ConfigError, "max_memory_mb must be > 0" unless self["max_memory_mb"].positive?
       raise ConfigError, "max_processes must be > 0" unless self["max_processes"].positive?
@@ -168,6 +233,11 @@ module Saboteur
       raise ConfigError, "timeout_min must be > 0" unless self["timeout_min"].positive?
 
       validate_reeval!
+      validate_operator_config!
+    end
+
+    def validate_operator_config!
+      MutationSource::OperatorRegistry.resolve(self["operators"])
 
       self["arid"].each { |pattern| Regexp.new(pattern) }
     rescue RegexpError => e

data/lib/saboteur/doctor.rb

@@ -5,11 +5,13 @@ require "coverage"
 require_relative "baseline_health"
 
 module Saboteur
-  # Reports the current environment and runs baseline checks, never mutations.
+  # Reports the current environment, never mutations. The two unchanged suite
+  # passes are slow on a large suite, so they run only when asked for.
   class Doctor
-    def initialize(config, out: $stdout)
+    def initialize(config, out: $stdout, suite: false)
       @config = config
       @out = out
+      @suite = suite
     end
 
     def call
@@ -18,20 +20,31 @@ module Saboteur
       check_coverage
       check_boot_files
       check_custom_map
+      check_ignore_subjects
       hooks = Hooks.new
       integration = boot_target(hooks)
       @out.puts "Integration: #{@config['integration']} (loaded)"
       @out.puts "Rails: #{@config['rails'] ? 'enabled' : 'disabled'}"
       @out.puts "SimpleCov: #{defined?(::SimpleCov) ? 'present; start suppressed for this process' : 'not loaded'}"
       check_coverage
-      tests = BaselineHealth.new(@config, integration: integration, hooks: hooks).call
-      @out.puts "Baseline: #{tests.size} tests passed twice in the same order with seed #{@config['seed']}"
-      @out.puts "Healthy in these two runs. This does not prove the suite is free of flaky tests."
+      check_suite(integration, hooks)
       true
     end
 
     private
 
+    def check_suite(integration, hooks)
+      unless @suite
+        @out.puts "Baseline: not run. Pass --suite to run the unchanged suite twice " \
+                  "(add --test PATH to limit it to some specs)."
+        return
+      end
+
+      tests = BaselineHealth.new(@config, integration: integration, hooks: hooks).call
+      @out.puts "Baseline: #{tests.size} tests passed twice in the same order with seed #{@config['seed']}"
+      @out.puts "Healthy in these two runs. This does not prove the suite is free of flaky tests."
+    end
+
     def boot_target(hooks)
       Engine::Boot.new(@config, hooks).load_target
     rescue LoadError, SyntaxError, SystemExit, StandardError => e
@@ -52,10 +65,29 @@ module Saboteur
     def check_coverage
       state = Coverage.state
       @out.puts "Coverage: #{state}"
-      return if Coverage.supported?(:lines) && state == :suspended
+      return if Coverage.supported?(:lines) && Coverage.supported?(:methods) && state == :suspended
+
+      raise Error, "Coverage must be suspended with line and method support before boot; use the saboteur " \
+                   "executable, disable SimpleCov and remove other Coverage.start calls"
+    end
 
-      raise Error, "Coverage must be suspended with line support before boot; use the saboteur executable, " \
-                   "disable SimpleCov and remove other Coverage.start calls"
+    # Match against all included source definitions, not the current diff or
+    # selected tests. A limited run must not make a valid ignore look stale.
+    def check_ignore_subjects
+      ignores = IgnoreList.load(@config.path("ignore_file"))
+      return if ignores.entries.empty?
+
+      finder = SubjectFinder.new
+      parsed = @config.included_files.map { |file| finder.call(file) }
+      if parsed.any? { |result| result.errors.any? }
+        @out.puts "Warning: ignore subject check incomplete: an included file does not parse"
+        return
+      end
+      subjects = parsed.flat_map(&:subjects).to_set(&:id)
+      ignores.entries.map(&:subject).uniq.reject { |subject| subjects.include?(subject) }.each do |subject|
+        @out.puts "Warning: ignore subject #{subject} matches no discovered subject in included files; " \
+                  "check include/exclude settings and the exact Class#method or Class.method form"
+      end
     end
 
     def check_custom_map