mutineer 0.8.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfadc70b171d8778c8afa95021c2989ad33ab2880200a22886fec274e358efcc
-  data.tar.gz: f6f6c91f6e5fffc0a2d05d93b0981df165d6d5b2df1e1434949c7dea1c0f70a6
+  metadata.gz: 0d61c927b33961995a0d38b691cdf0b34a6e9041213980c0cd7a3a01f457f875
+  data.tar.gz: 8e4f32e923344837ab664805a3099a9e67d405bbe7b63d83986d1af0b488ead5
 SHA512:
-  metadata.gz: 01de0a56c54a7b85fd98d92831681a258a4420b3e5b3d34ce932811259a776764c888aae13a8975632c66851798f9b4a53f343864518fd8fe608e7dddff20e07
-  data.tar.gz: 63c802e363a3f87a8ecd43a5bf726d2ce23af2aadf890b87b7ad6616076e9f2461876c0af5faa70c83caf93027fd9e8754bf6866c5ab25e7d2a51bd51f9f3d4c
+  metadata.gz: 5ea750d511b52ef0f9d320c39ef0b4a3b51189116c09811b3bf4f2d5752b026d1ddc62411387a261f6f60ba73e23e2b76af1e553a745bd63f9a3d56a0cd068cb
+  data.tar.gz: 6dc10950ea34998e459e5007095bd43df87a633a4ca18e19afee1812a8fed154e086f3ae3a7b808bd84ba93336bb61208195d001efd846fea367502a23167ef2

data/CHANGELOG.md

@@ -4,6 +4,32 @@ All notable changes to this project are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/), and this project adheres to
 [Semantic Versioning](https://semver.org/).
 
+## [0.9.1] - 2026-07-01
+
+### Fixed
+- **Per-method uncapturable granularity** (#25) — the `:uncapturable` taint was
+  whole-file, so a method reachable only by a *failed* capture in an otherwise-
+  covered file was mislabeled `no_coverage`. It's now attributed per method (by
+  the method's body coverage), so only the affected method is tainted. Fully-
+  failed files are unchanged.
+
+## [0.9.0] - 2026-06-30
+
+### Added
+- **`--fail-fast`** (#21) — stop at the first surviving mutant; in-flight workers
+  drain, the rest are skipped. Fast red signal for PR gates.
+- **`--format html`** (#23) — a single self-contained HTML report (inline CSS, no
+  external assets) with the score, per-source table, and a card per survivor
+  (subject, file:line, operator, stable id, diff).
+- **String, regex, and collection-method operators** (#24, Tier-2, opt-in via
+  `--operators`): `string_literal`, `regex`, `collection_method`
+  (`map`↔`each`, `all?`↔`any?`, `first`↔`last`, `min`↔`max`, `select`↔`reject`).
+
+### Changed
+- **`--dry-run` now honors suppression** (#22) — inline `# mutineer:disable-line`
+  and `.mutineer.yml` `ignore:` entries are omitted from the preview and counted
+  as "ignored (suppressed)", matching a real run.
+
 ## [0.8.0] - 2026-06-30
 
 ### Fixed
@@ -14,12 +40,14 @@ All notable changes to this project are documented here. The format is based on
   are now discovered as singletons, and the redefine strategy re-opens
   `class << self` so the mutation lands on the called method. (Scores for
   singleton-heavy files will rise to their true values.)
-- **Fork-capture failures are diagnosable** (#19, part 1) — capture/worker pipes
-  are `binmode` (a binary Marshal payload could otherwise be lost to an encoding
-  error and swallowed), and a child that dies without writing now reports how it
-  died (exit status / signal) instead of a silent "produced no result". `--verbose`
-  always surfaces a real reason now. (The residual write-heavy capture failure
-  on some real Rails suites remains under investigation — now diagnosable.)
+- **Write-heavy Rails tests are capturable again** (#19) — capture/worker pipes
+  are `binmode`: a binary Marshal payload over a text-mode pipe could raise an
+  encoding error the child then swallowed → empty pipe → false `:uncapturable`.
+  That was the root cause of the residual write-heavy failures too. A child that
+  dies without writing now also reports how it died (exit status / signal), and
+  `--verbose` always surfaces a real reason. Verified on a real Rails app: all 6
+  previously-uncapturable interactors (incl. caxlsx + Google-client) now capture
+  with real scores, 0 uncapturable.
 
 ## [0.7.1] - 2026-06-30
 
@@ -156,6 +184,8 @@ Rails hardening + CI batch (issues #8–#13), all verified Rails-free.
 - `.mutineer.yml` configuration (CLI > config > default precedence).
 - Byte-correct source handling for multibyte (UTF-8) sources.
 
+[0.9.1]: https://github.com/davidteren/mutineer/releases/tag/v0.9.1
+[0.9.0]: https://github.com/davidteren/mutineer/releases/tag/v0.9.0
 [0.8.0]: https://github.com/davidteren/mutineer/releases/tag/v0.8.0
 [0.7.1]: https://github.com/davidteren/mutineer/releases/tag/v0.7.1
 [0.7.0]: https://github.com/davidteren/mutineer/releases/tag/v0.7.0

data/README.md

@@ -2,7 +2,7 @@
 
 [![Gem Version](https://img.shields.io/gem/v/mutineer?logo=rubygems&color=e23b3b)](https://rubygems.org/gems/mutineer)
 [![GitHub Marketplace](https://img.shields.io/badge/Marketplace-Mutineer%20Ruby-2da44e?logo=githubactions&logoColor=white)](https://github.com/marketplace/actions/mutineer-ruby)
-[![Socket Badge](https://badge.socket.dev/rubygems/package/mutineer/0.7.1?platform=ruby)](https://socket.dev/rubygems/package/mutineer/overview/0.7.1?platform=ruby)
+[![Socket](https://img.shields.io/badge/Socket-security%20report-0a66c2?logo=socket&logoColor=white)](https://socket.dev/rubygems/package/mutineer)
 
 A clean-room mutation-testing tool for Ruby. Mutineer mutates your source one
 change at a time, runs your test suite (Minitest or RSpec) against each mutant, and reports the
@@ -56,9 +56,10 @@ mutineer run lib/calculator.rb --test test/calculator_test.rb --threshold 90
 | `--jobs N` | Parallel worker count (default: processor count; `1` under `--rails`) |
 | `--verbose` | Surface the real error when a fork capture fails (alias `--debug`) |
 | `--strategy NAME` | Mutation application: `reload` whole-file (default) or `redefine` surgical (`7a`/`7b` accepted as deprecated aliases) |
-| `--format human\|json` | Report format (default: human) |
+| `--format human\|json\|html` | Report format (default: human; `html` is a self-contained file) |
 | `--output FILE` | Write the report to FILE instead of stdout |
-| `--dry-run` | List candidate mutations without executing |
+| `--dry-run` | List candidate mutations without executing (honors suppression) |
+| `--fail-fast` | Stop at the first surviving mutant |
 | `--list-operators` | List available operators (default vs optional) and exit |
 | `--version`, `--help` | Print version / usage and exit |
 
@@ -75,7 +76,8 @@ mutineer run lib/calculator.rb --test test/calculator_test.rb --threshold 90
 Run `mutineer --list-operators` to see them. Default (Tier 1): `arithmetic`,
 `comparison`, `boolean_connector`, `boolean_literal`, `statement_removal`.
 Available but off by default (Tier 2, enable via `--operators`): `return_nil`,
-`literal_mutation`, `condition_negation`.
+`literal_mutation`, `condition_negation`, `string_literal`, `regex`,
+`collection_method`.
 
 ## Rails apps
 

data/lib/mutineer/cli.rb

@@ -47,9 +47,10 @@ module Mutineer
         --boot FILE          Require FILE once in the parent to boot the app env, then
                              fork per mutant (Rails apps; requires --test)
         --rails              Sugar for --boot config/environment --strategy redefine
-        --format human|json  Report format (default: human)
+        --format human|json|html  Report format (default: human)
         --output FILE        Write the report to FILE instead of stdout
         --dry-run            List mutations without executing
+        --fail-fast          Stop at the first surviving mutant
         --verbose            Surface the real error when a fork capture fails (alias: --debug)
 
       Options:
@@ -85,6 +86,7 @@ module Mutineer
         end
         o.on("--list-operators") { show_operators = true }
         o.on("--dry-run") { opts[:dry_run] = true }
+        o.on("--fail-fast") { opts[:fail_fast] = true }
         o.on("--only NAME") { |v| opts[:only] = v; explicit << :only }
         o.on("--since REF") { |v| opts[:since] = v; explicit << :since }
         o.on("--test FILE") { |v| (opts[:tests] ||= []) << v }
@@ -209,8 +211,8 @@ module Mutineer
       end
       config.jobs = jobs
 
-      unless %w[human json].include?(config.format)
-        warn %(mutineer: unknown format "#{config.format}". Expected: human, json)
+      unless %w[human json html].include?(config.format)
+        warn %(mutineer: unknown format "#{config.format}". Expected: human, json, html)
         exit 2
       end
 
@@ -377,7 +379,7 @@ module Mutineer
 
       # #14: nudge toward the opt-in tier-2 operators (human report only — never
       # pollute JSON output).
-      if config.format != "json" && (hint = tier2_hint(config.operators))
+      if !%w[json html].include?(config.format) && (hint = tier2_hint(config.operators))
         puts hint
       end
 
@@ -411,6 +413,8 @@ module Mutineer
       sources = {}
       per_operator = Hash.new(0)
       skipped = 0
+      ignored = 0
+      ignore_set = config.ignore.to_set
 
       # --since narrows the preview to changed lines too, so `--dry-run --since`
       # shows exactly what a real `--since` run would mutate.
@@ -421,29 +425,36 @@ module Mutineer
 
       Project.discover(config.sources, only: config.only).each do |subject|
         source = (sources[subject.file] ||= Parser.parse_file(subject.file).source.source)
-        operator_classes.each do |klass|
-          klass.new.mutations_for(subject, source).each do |mutation|
-            unless mutation.valid?(source)
-              skipped += 1
-              next
-            end
-            if changed
-              line = source.byteslice(0, mutation.start_offset).count("\n") + 1
-              next unless changed[File.expand_path(subject.file, config.project_root)]&.include?(line)
-            end
-            per_operator[mutation.operator] += 1
-            original = source.byteslice(mutation.start_offset...mutation.end_offset)
-            line = source.byteslice(0, mutation.start_offset).count("\n") + 1
-            puts "[#{mutation.operator}] #{subject.qualified_name}  " \
-                 "#{subject.file}:#{line}  `#{original}` -> `#{mutation.replacement}`"
+        # #22: honor suppression so the preview matches what a real run mutates.
+        # Mirror execute's per-subject shape (ids need the full mutation list).
+        disabled = Runner.suppress_map(source)
+        mutations = operator_classes.flat_map { |klass| klass.new.mutations_for(subject, source) }
+        ids = MutantId.for_subject(subject, source, mutations)
+        mutations.each_with_index do |mutation, i|
+          unless mutation.valid?(source)
+            skipped += 1
+            next
           end
+          line = source.byteslice(0, mutation.start_offset).count("\n") + 1
+          next if changed && !changed[File.expand_path(subject.file, config.project_root)]&.include?(line)
+
+          if Runner.suppressed?(mutation.operator, line, ids[i], disabled, ignore_set)
+            ignored += 1
+            next
+          end
+
+          per_operator[mutation.operator] += 1
+          original = source.byteslice(mutation.start_offset...mutation.end_offset)
+          puts "[#{mutation.operator}] #{subject.qualified_name}  " \
+               "#{subject.file}:#{line}  `#{original}` -> `#{mutation.replacement}`"
         end
       end
 
       total = per_operator.values.sum
       breakdown = per_operator.map { |op, n| "#{op}: #{n}" }.join(", ")
       summary = breakdown.empty? ? "" : "#{breakdown} — "
-      puts "#{summary}#{total} mutations (dry run, not executed); #{skipped} skipped (invalid)"
+      puts "#{summary}#{total} mutations (dry run, not executed); " \
+           "#{skipped} skipped (invalid); #{ignored} ignored (suppressed)"
       exit 0
     end
   end

data/lib/mutineer/config.rb

@@ -25,13 +25,13 @@ module Mutineer
     :cache_dir, :project_root, :load_paths,
     :jobs, :format, :output, :strategy, :require_paths,
     :boot, :rails, :since, :framework, :verbose, :ignore,
-    :baseline, :baseline_epsilon,
+    :baseline, :baseline_epsilon, :fail_fast,
     keyword_init: true
   ) do
     # Config file name.
     CONFIG_FILE = ".mutineer.yml"
     # Keys accepted in .mutineer.yml (R7). `require` maps to the :require_paths field.
-    KNOWN_KEYS = %w[operators jobs threshold only require boot rails since framework verbose ignore baseline].freeze
+    KNOWN_KEYS = %w[operators jobs threshold only require boot rails since framework verbose ignore baseline fail_fast].freeze
 
     def initialize(**kwargs)
       super
@@ -50,6 +50,7 @@ module Mutineer
       self.verbose       = false if verbose.nil?
       self.ignore        ||= []
       self.baseline_epsilon ||= 0.0
+      self.fail_fast     = false if fail_fast.nil?
     end
 
     # Walk from `start` toward `home`, returning the first .mutineer.yml path found

data/lib/mutineer/coverage_map.rb

@@ -87,6 +87,27 @@ module Mutineer
       failed_test_targets.include?(File.basename(rel, ".rb"))
     end
 
+    # #25: per-METHOD taint. A mutant on a line whose enclosing method got zero
+    # successful coverage, in a file a failed sibling test targets, is
+    # :uncapturable (the capture that would have covered it errored) — NOT a
+    # genuine gap. A method with any covered line means its uncovered lines are a
+    # real :no_coverage. A failed capture emits no coverage, so per-line intent is
+    # unknowable; method-range + successful coverage is the finest derivable signal.
+    # Fully-failed files behave exactly as uncapturable_source? did (every method
+    # range has zero coverage), so #8/#9/#19 behavior is unchanged.
+    #
+    # @param file [String] source file path.
+    # @param line_range [Range] 1-based enclosing-method line range.
+    # @return [Boolean]
+    def method_uncapturable?(file, line_range)
+      return false if @failed_test_files.empty?
+
+      rel = relativize(absolute(file))
+      return false unless failed_test_targets.include?(File.basename(rel, ".rb"))
+
+      line_range.none? { |ln| @map.key?("#{rel}:#{ln}") }
+    end
+
     private
 
     # Source rel-paths that received coverage from any successful capture.

data/lib/mutineer/mutator_registry.rb

@@ -8,6 +8,9 @@ require_relative "mutators/statement_removal"
 require_relative "mutators/return_nil"
 require_relative "mutators/literal_mutation"
 require_relative "mutators/condition_negation"
+require_relative "mutators/string_literal"
+require_relative "mutators/regex_literal"
+require_relative "mutators/collection_method"
 
 module Mutineer
   # Maps operator names to operator classes.
@@ -28,13 +31,16 @@ module Mutineer
       "statement_removal"  => Mutators::StatementRemoval,
       "return_nil"         => Mutators::ReturnNil,
       "literal_mutation"   => Mutators::LiteralMutation,
-      "condition_negation" => Mutators::ConditionNegation
+      "condition_negation" => Mutators::ConditionNegation,
+      "string_literal"     => Mutators::StringLiteral,
+      "regex"              => Mutators::RegexLiteral,
+      "collection_method"  => Mutators::CollectionMethod
     }.freeze
 
     # The default Tier-1 operator set.
     DEFAULT_NAMES = %w[arithmetic comparison boolean_connector boolean_literal statement_removal].freeze
     # Tier-2 operators that remain opt-in.
-    TIER2_NAMES   = %w[return_nil literal_mutation condition_negation].freeze
+    TIER2_NAMES   = %w[return_nil literal_mutation condition_negation string_literal regex collection_method].freeze
 
     # Short human-readable descriptions for each operator.
     DESCRIPTIONS = {
@@ -45,7 +51,10 @@ module Mutineer
       "statement_removal"  => "replace a non-final statement with nil",
       "return_nil"         => "replace a return / final expression with nil",
       "literal_mutation"   => "integer -> 0, 1, n+1; string -> empty",
-      "condition_negation" => "wrap if/unless/ternary condition in !( ... )"
+      "condition_negation" => "wrap if/unless/ternary condition in !( ... )",
+      "string_literal"     => "non-empty string -> \"\", empty string -> \"mutineer\"",
+      "regex"              => "drop leading ^ / trailing $, swap + <-> *",
+      "collection_method"  => "map<->each, all?<->any?, first<->last, min<->max, select<->reject"
     }.freeze
 
     # Resolves operator names to classes.

data/lib/mutineer/mutators/collection_method.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Collection / enumerable method-name mutator (Tier-2).
+    #
+    # Swaps the method-name token of a call to its semantic opposite, one
+    # mutation per occurrence, exactly like the arithmetic/comparison operators.
+    class CollectionMethod < Base
+      # Method-name swaps. All targets are core-Ruby Enumerable/Array methods so
+      # the mutant exercises real behaviour rather than always raising.
+      #
+      # ponytail: include? -> exclude? was specced but skipped — exclude? is not
+      # core Ruby, so that mutant would always NoMethodError (a weak mutant).
+      REPLACEMENTS = {
+        map: "each", each: "map",
+        all?: "any?", any?: "all?",
+        first: "last", last: "first",
+        min: "max", max: "min",
+        select: "reject", reject: "select"
+      }.freeze
+
+      # Visits call nodes and emits collection-method mutations.
+      #
+      # @param node [Prism::CallNode] call node to inspect.
+      # @return [void]
+      def visit_call_node(node)
+        replacement = REPLACEMENTS[node.name]
+        loc = node.message_loc
+        if replacement && loc
+          @mutations << Mutation.new(
+            start_offset: loc.start_offset,
+            end_offset: loc.end_offset,
+            replacement: replacement,
+            operator: :collection_method
+          )
+        end
+        super
+      end
+    end
+  end
+end

data/lib/mutineer/mutators/regex_literal.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Regular-expression literal mutator (Tier-2).
+    #
+    # Conservative, clearly-safe textual swaps inside a plain regex literal:
+    # drop a leading +^+ anchor, drop a trailing +$+ anchor, and swap the +
+    # and * quantifiers. Interpolated regexes use a different node type and are
+    # never visited. Escaped tokens (preceded by a backslash) are left alone.
+    class RegexLiteral < Base
+      # Visits regular-expression literals.
+      #
+      # @param node [Prism::RegularExpressionNode] node to inspect.
+      # @return [void]
+      def visit_regular_expression_node(node)
+        loc = node.content_loc
+        content = @source.byteslice(loc.start_offset...loc.end_offset)
+        scan(content, loc.start_offset)
+        super
+      end
+
+      private
+
+      # Scans the pattern bytes and emits anchor/quantifier mutations.
+      #
+      # @param content [String] regex pattern between the slashes.
+      # @param base [Integer] byte offset of the pattern start in source.
+      # @return [void]
+      def scan(content, base)
+        emit(base, base + 1, "") if content.start_with?("^")
+        emit(base + content.bytesize - 1, base + content.bytesize, "") if trailing_anchor?(content)
+
+        escaped = false
+        offset = base
+        content.each_char do |ch|
+          unless escaped
+            emit(offset, offset + 1, "*") if ch == "+"
+            emit(offset, offset + 1, "+") if ch == "*"
+          end
+          escaped = ch == "\\" && !escaped
+          offset += ch.bytesize
+        end
+      end
+
+      # Whether the pattern ends with an unescaped +$+ anchor.
+      #
+      # @param content [String] regex pattern.
+      # @return [Boolean] true when a trailing anchor is droppable.
+      def trailing_anchor?(content)
+        content.end_with?("$") && !content.end_with?("\\$")
+      end
+
+      # Emits a regex mutation.
+      #
+      # @param start_offset [Integer] byte start.
+      # @param end_offset [Integer] byte end.
+      # @param replacement [String] replacement text.
+      # @return [void]
+      def emit(start_offset, end_offset, replacement)
+        @mutations << Mutation.new(
+          start_offset: start_offset,
+          end_offset: end_offset,
+          replacement: replacement,
+          operator: :regex
+        )
+      end
+    end
+  end
+end

data/lib/mutineer/mutators/string_literal.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # String literal mutator (Tier-2).
+    #
+    # Empties a non-empty string literal and fills an empty one. Only plain
+    # quoted strings are touched; interpolated strings, heredocs and %-literals
+    # are skipped for safety (they re-parse unpredictably).
+    class StringLiteral < Base
+      # Visits string literals.
+      #
+      # @param node [Prism::StringNode] node to inspect.
+      # @return [void]
+      def visit_string_node(node)
+        # ponytail: only plain "..." / '...' quotes. opening is nil for
+        # interpolation parts and %w[] elements; heredocs/%-literals use a
+        # different opening token. Skipping them keeps mutants re-parseable.
+        if %w[" '].include?(node.opening)
+          loc = node.content_loc
+          @mutations << Mutation.new(
+            start_offset: loc.start_offset,
+            end_offset: loc.end_offset,
+            replacement: node.unescaped.empty? ? "mutineer" : "",
+            operator: :string_literal
+          )
+        end
+        super
+      end
+    end
+  end
+end

data/lib/mutineer/reporter.rb

@@ -2,6 +2,7 @@
 
 require "json"
 require "stringio"
+require "cgi"
 require_relative "mutation"
 
 module Mutineer
@@ -25,6 +26,8 @@ module Mutineer
       rendered =
         if format == "json"
           json_report(baseline)
+        elsif format == "html"
+          html_report
         else
           sio = StringIO.new
           human_report(sio, err, threshold)
@@ -128,6 +131,117 @@ module Mutineer
       "#{JSON.generate(doc)}\n"
     end
 
+    # #23: one self-contained HTML file (inline CSS, no external assets) — the
+    # overall score + summary counts, a per-source table, and every surviving
+    # mutant with its stable id and diff. All source/diff/identifier text is
+    # HTML-escaped (CGI.escapeHTML) so a `<`/`>` in source can never break the
+    # markup. Reuses survivor_json/per_source_json so one run yields one set of
+    # facts regardless of --format.
+    def html_report
+      score = @agg.mutation_score
+      survivors = @agg.surviving_mutants.map { |r| survivor_json(r) }
+                      .sort_by { |h| [h[:file], h[:line], h[:operator]] }
+      per_source = @agg.by_source.map { |file, agg| per_source_json(file, agg) }
+                       .sort_by { |h| h[:file] }
+
+      <<~HTML
+        <!DOCTYPE html>
+        <html lang="en">
+        <head>
+        <meta charset="utf-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1">
+        <title>Mutineer Mutation Report</title>
+        <style>
+          body { font-family: -apple-system, Segoe UI, Roboto, Helvetica, Arial, sans-serif;
+                 margin: 2rem; color: #1b1b1b; background: #fafafa; }
+          h1 { margin: 0 0 .25rem; }
+          .score { font-size: 2.5rem; font-weight: 700; }
+          .counts { color: #444; margin: .5rem 0 1.5rem; }
+          .counts span { display: inline-block; margin-right: 1rem; white-space: nowrap; }
+          table { border-collapse: collapse; width: 100%; margin-bottom: 2rem; background: #fff; }
+          th, td { border: 1px solid #ddd; padding: .4rem .6rem; text-align: left; }
+          th { background: #f0f0f0; }
+          td.num { text-align: right; font-variant-numeric: tabular-nums; }
+          .survivor { background: #fff; border: 1px solid #ddd; border-radius: 4px;
+                      padding: .75rem 1rem; margin-bottom: 1rem; }
+          .survivor h3 { margin: 0 0 .25rem; font-size: 1rem; }
+          .meta { color: #555; font-size: .85rem; margin-bottom: .5rem; }
+          .id { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; }
+          pre.diff { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+                     background: #f6f8fa; padding: .5rem .75rem; overflow-x: auto;
+                     margin: 0; border-radius: 4px; }
+          .diff .add { color: #116329; }
+          .diff .del { color: #82071e; }
+        </style>
+        </head>
+        <body>
+        <h1>Mutineer — Mutation Report</h1>
+        <div class="score">Score: #{score.nil? ? 'N/A' : "#{score}%"}</div>
+        #{summary_html}
+        #{per_source_html(per_source)}
+        #{survivors_html(survivors)}
+        </body>
+        </html>
+      HTML
+    end
+
+    # The summary counts block for the HTML header.
+    def summary_html
+      counts = {
+        "total" => @agg.total, "killed" => @agg.killed_count,
+        "survived" => @agg.survived_count, "no_coverage" => @agg.no_coverage_count,
+        "uncapturable" => @agg.uncapturable_count, "ignored" => @agg.ignored_count,
+        "skipped" => @agg.skipped_invalid_count,
+        "errored" => @agg.errored_count + @agg.timeout_count
+      }
+      spans = counts.map { |k, v| "<span><strong>#{v}</strong> #{esc(k)}</span>" }.join("\n  ")
+      "<div class=\"counts\">\n  #{spans}\n</div>"
+    end
+
+    # The per-source breakdown table.
+    def per_source_html(per_source)
+      return "" if per_source.empty?
+
+      rows = per_source.map do |h|
+        score = h[:score].nil? ? "N/A" : "#{h[:score]}%"
+        "<tr><td>#{esc(h[:file])}</td><td class=\"num\">#{score}</td>" \
+          "<td class=\"num\">#{h[:killed]}</td><td class=\"num\">#{h[:survived]}</td>" \
+          "<td class=\"num\">#{h[:no_coverage]}</td></tr>"
+      end.join("\n  ")
+      <<~HTML.chomp
+        <h2>Per-source</h2>
+        <table>
+        <tr><th>File</th><th>Score</th><th>Killed</th><th>Survived</th><th>No coverage</th></tr>
+          #{rows}
+        </table>
+      HTML
+    end
+
+    # The surviving-mutants list, each with subject, location, operator, stable
+    # id, and a colorized diff. All text is HTML-escaped.
+    def survivors_html(survivors)
+      return "<h2>Surviving Mutants</h2>\n<p>None — every covered mutant was killed.</p>" if survivors.empty?
+
+      cards = survivors.map do |s|
+        diff_lines = s[:diff].each_line.map do |line|
+          cls = line.start_with?("+") ? "add" : (line.start_with?("-") ? "del" : nil)
+          text = esc(line.chomp)
+          cls ? "<span class=\"#{cls}\">#{text}</span>" : text
+        end.join("\n")
+        <<~CARD.chomp
+          <div class="survivor">
+          <h3>#{esc(s[:subject])}</h3>
+          <div class="meta">#{esc(s[:file])}:#{s[:line]} &middot; #{esc(s[:operator])} &middot; <span class="id">#{esc(s[:id])}</span></div>
+          <pre class="diff">#{diff_lines}</pre>
+          </div>
+        CARD
+      end.join("\n")
+      "<h2>Surviving Mutants</h2>\n#{cards}"
+    end
+
+    # HTML-escapes any text destined for the document (stdlib CGI).
+    def esc(text) = CGI.escapeHTML(text.to_s)
+
     # #13: the same delta facts the human report prints, for dashboards. new_survivors
     # reuse the ignored_json shape (subject/file/line/operator/token/id) and sort
     # byte-stably so output doesn't depend on --jobs finish order.

data/lib/mutineer/runner.rb

@@ -127,13 +127,17 @@ module Mutineer
       results =
         begin
           framework = config.framework
-          bare = WorkerPool.new(config.jobs).run(jobs) do |subject, mutation|
+          # #21: --fail-fast stops scheduling new mutants after the first survivor;
+          # in-flight workers drain, unscheduled jobs stay nil (dropped below).
+          stop_when = config.fail_fast ? ->(r) { r.survived? } : nil
+          bare = WorkerPool.new(config.jobs).run(jobs, stop_when: stop_when) do |subject, mutation|
             run(mutation, source_file: subject.file, coverage_map: coverage_map,
                 subject: subject, strategy: strategy, rails: config.rails, framework: framework)
           end
           # The bare Results carry only status (Subjects hold live AST nodes that
           # do not marshal); reattach subject+mutation+id in the parent, in order.
-          bare.each_with_index.map { |r, i| r.with(subject: jobs[i][0], mutation: jobs[i][1], id: jobs[i][2]) }
+          # filter_map drops nils for jobs --fail-fast left unscheduled.
+          bare.each_with_index.filter_map { |r, i| r&.with(subject: jobs[i][0], mutation: jobs[i][1], id: jobs[i][2]) }
         ensure
           sweep_orphans(source_dirs)
         end
@@ -255,10 +259,18 @@ module Mutineer
       # covering test files run in the child.
       line   = source.byteslice(0, mutation.start_offset).count("\n") + 1
       chosen = coverage_map.tests_for(source_file, line)
-      # #9: distinguish a genuine coverage gap from a line whose would-be test
+      # #9/#25: distinguish a genuine coverage gap from a line whose would-be test
       # errored during capture (coverage lost) — the latter is :uncapturable.
+      # #25: taint per-METHOD (the mutant's enclosing def range), not whole-file,
+      # so a covered method's uncovered line stays :no_coverage while a method
+      # reachable only by a failed capture is :uncapturable.
       if chosen.empty?
-        return coverage_map.uncapturable_source?(source_file) ? Result.uncapturable : Result.no_coverage
+        # Use the method BODY range, not the whole def: the `def`/`end` lines are
+        # "covered" at class-load even when the body never runs, which would mask
+        # an uncovered method. body_loc is the body statements' span.
+        loc = subject&.body_loc
+        range = loc ? (loc.start_line..loc.end_line) : (line..line)
+        return coverage_map.method_uncapturable?(source_file, range) ? Result.uncapturable : Result.no_coverage
       end
 
       abs_tests = chosen.map { |t| File.expand_path(t, coverage_map.project_root) }

data/lib/mutineer/version.rb

@@ -2,5 +2,5 @@
 
 module Mutineer
   # Current Mutineer release version.
-  VERSION = "0.8.0"
+  VERSION = "0.9.1"
 end

data/lib/mutineer/worker_pool.rb

@@ -25,16 +25,25 @@ module Mutineer
     # Runs the work items through the pool.
     #
     # @param items [Array<Array>] work items.
+    # @param stop_when [Proc, nil] called with each collected Result; when it
+    #   returns truthy, no further items are scheduled and the run drains and
+    #   returns early (#21 --fail-fast). Unscheduled slots stay nil.
     # @yieldparam item [Array] one work item.
-    # @return [Array<Mutineer::Result>] results in input order.
-    def run(items)
-      results = Array.new(items.size)
-      queue   = (0...items.size).to_a
-      running = {} # pid => [index, read_io]
+    # @return [Array<Mutineer::Result>] results in input order (nil for any item
+    #   left unscheduled by an early stop).
+    def run(items, stop_when: nil)
+      results  = Array.new(items.size)
+      queue    = (0...items.size).to_a
+      running  = {} # pid => [index, read_io, buffer]
+      stopping = false
 
       until queue.empty? && running.empty?
-        fill(items, queue, running) { |*args| yield(*args) }
-        reap(results, running)
+        fill(items, queue, running) { |*args| yield(*args) } unless stopping
+        result = reap(results, running)
+        if !stopping && stop_when && result && stop_when.call(result)
+          stopping = true
+          queue.clear # schedule no more; let in-flight workers drain
+        end
       end
 
       results
@@ -107,8 +116,8 @@ module Mutineer
             rd.close
             Process.waitpid(pid) # reap the now-finished child (no zombie)
             running.delete(pid)
-            results[idx] = decode(buf)
-            return
+            # Return the collected Result so the caller's stop_when (#21) can see it.
+            return results[idx] = decode(buf)
           end
           buf << chunk
         end

data/lib/mutineer.rb

@@ -22,6 +22,9 @@ require_relative "mutineer/mutators/statement_removal"
 require_relative "mutineer/mutators/return_nil"
 require_relative "mutineer/mutators/literal_mutation"
 require_relative "mutineer/mutators/condition_negation"
+require_relative "mutineer/mutators/string_literal"
+require_relative "mutineer/mutators/regex_literal"
+require_relative "mutineer/mutators/collection_method"
 require_relative "mutineer/mutator_registry"
 require_relative "mutineer/worker_pool"
 require_relative "mutineer/runner"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mutineer
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.1
 platform: ruby
 authors:
 - David Teren
@@ -80,11 +80,14 @@ files:
 - lib/mutineer/mutators/base.rb
 - lib/mutineer/mutators/boolean_connector.rb
 - lib/mutineer/mutators/boolean_literal.rb
+- lib/mutineer/mutators/collection_method.rb
 - lib/mutineer/mutators/comparison.rb
 - lib/mutineer/mutators/condition_negation.rb
 - lib/mutineer/mutators/literal_mutation.rb
+- lib/mutineer/mutators/regex_literal.rb
 - lib/mutineer/mutators/return_nil.rb
 - lib/mutineer/mutators/statement_removal.rb
+- lib/mutineer/mutators/string_literal.rb
 - lib/mutineer/pairing.rb
 - lib/mutineer/parser.rb
 - lib/mutineer/project.rb