mutaruby 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fb14367f23f77c599ae74ba8f36f1d5e0e71c73ab8fa8267378569a3a359655
-  data.tar.gz: 036b55cb7754d44886e7056f0d63dda5725a0caf7037dc8eff50d49bf7df73fb
+  metadata.gz: 9b140915c577e60f56e81a1bec2d530a3791a82794bcb1e68de429f53fd5074d
+  data.tar.gz: 55cd843abdd670e427fc4a76b891cd75503623b160bc30dce514c90308966de4
 SHA512:
-  metadata.gz: 718044deb537125a73dfc0864aeea698594711196ecf12ba16655fac80e6fa23e6c5ef2ef478d360b270da7f3264e7fccc7d8f5bff2bf88e2863cbe61e937d8c
-  data.tar.gz: 7fb23d15489c6dae51343866c850e7e4a9ccf049f966e8521fa20fbe92a3eaca1f52bde4014a5387151d1aa36febbc44c92c20708e83fbf22e573dbddbd09f9e
+  metadata.gz: 1e6660338016f557eb61693a675c7fb672c8ed3f04bff6858412936ed470f4479278e9bc86da140bedfd7434141ba9699395d6bf9fa84831d18d14e4cd1c472f
+  data.tar.gz: 3b5aed66653a95656ef93303e76d981065cf68ed88116e3a4ffdedb097f706052189acb3b70457c1f06c617d49e135f3b3e530d9f7556e878b0dd5ea1a8c6e7f

data/CHANGELOG.md

@@ -3,6 +3,37 @@
 All notable changes to this project are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project uses [Semantic Versioning](https://semver.org/).
 
+## [0.3.0] - 2026-10-12
+
+### Added
+
+- `--coverage`: coverage-based test selection. The baseline run records, with Ruby's Coverage API and the test
+  framework's per-test hooks, which tests execute which lines; each mutant then runs only those tests (Minitest and
+  RSpec), and falls back to the whole command for load-time code, unreached lines and other test commands. The
+  summary and the JSON report show how many mutants ran a subset.
+- `--subject`: select methods by their place in the code (`Foo#bar`, `Foo.bar`, `Foo#*`, `Foo.*`, `Foo` with its
+  nested namespaces, `Foo*`).
+- Eight operators: `block-removal`, `method-swap`, `element-removal`, `regexp-never-match`, `yield-removal`,
+  `super-removal`, `when-removal`, `rescue-removal`.
+- `--unparser`: render rebuilt nodes (`element-removal`) with the MIT-licensed `unparser` gem, an optional extra.
+  Text splicing, with its self-check, stays the default.
+
+### Fixed
+
+- An interrupted run starts no new mutant and waits for its workers to finish before it removes their sandboxes.
+- A test run interrupted while mutaruby waits for it is stopped (with its process tree) before the interrupt goes
+  on, so its output file and sandbox are free to be removed.
+- On Windows, a forcibly stopped run is given time to exit for good before its sandbox is removed (the directory
+  stays locked until then). A sandbox that still cannot be removed no longer hides the real error (Ctrl-C, a
+  failing baseline); removal is also retried when the directory is not yet empty.
+- With `--coverage`, Ruby processes started by the tests themselves (a test that runs another suite) are neither
+  recorded nor filtered, and launcher processes (`bundle exec`, `rake`) do not overwrite the map.
+
+### Changed
+
+- The README's comparison credits mutant as the mature reference implementation and states that mutaruby is an
+  independent, clean-room implementation that shares no code with it.
+
 ## [0.2.0] - 2026-10-12
 
 ### Added
@@ -71,6 +102,7 @@ First release.
   reason, ambiguity and staleness checks, `--strict-ignore` and `--suggest-ignore`.
 - Human, JSON and JUnit XML reports, a mutation score and `--fail-under` for CI.
 
+[0.3.0]: https://github.com/Atlas-Authorization/mutaruby/releases/tag/v0.3.0
 [0.2.0]: https://github.com/Atlas-Authorization/mutaruby/releases/tag/v0.2.0
 [0.1.1]: https://github.com/Atlas-Authorization/mutaruby/releases/tag/v0.1.1
 [0.1.0]: https://github.com/Atlas-Authorization/mutaruby/releases/tag/v0.1.0

data/README.md

@@ -5,10 +5,10 @@
 
 Free, MIT-licensed mutation testing for Ruby.
 
-mutaruby is mutation-tested with itself. In version 0.2.0, all 3,812 mutants of its own code are accounted for:
-3,806 are killed by its tests (521 of them by timeout), and the other 6 are true equivalents, each listed in
-[`.mutaruby-ignore.yml`](.mutaruby-ignore.yml) with a reason you can check. `bundle exec rake mutate` reproduces the
-run; it fails on any surviving mutant or stale ignore entry.
+mutaruby is mutation-tested with itself. In version 0.3.0, all 4,968 mutants of its own code are accounted for:
+4,962 are killed by its tests (573 of them by timeout), and the other 6 are true equivalents, each listed in
+[`.mutaruby-ignore.yml`](.mutaruby-ignore.yml) with a reason you can check. `bundle exec rake mutate` (or the sharded
+`Self-mutation` workflow) reproduces the run; it fails on any surviving mutant or stale ignore entry.
 
 mutaruby makes small, deliberate changes to your code, one at a time, and runs your test command against each change.
 If your tests still pass, the change (the *mutant*) **survived**, and that points to code your tests do not really check.
@@ -43,6 +43,7 @@ The survivor above tells you that no test checks a total of exactly 100.
 - [Quickstart](#quickstart)
 - [CLI reference](#cli-reference)
 - [Mutation operators](#mutation-operators)
+- [Coverage-based test selection](#coverage-based-test-selection)
 - [Equivalent mutants: the ignore file](#equivalent-mutants-the-ignore-file)
 - [Using it in CI](#using-it-in-ci)
 - [Output formats](#output-formats)
@@ -138,6 +139,8 @@ Positional arguments are files or globs relative to the project root. The defaul
 | `-t`, `--test COMMAND` | **Required.** Shell command that runs your tests: run with `/bin/sh -c` on Linux and macOS, with `cmd.exe` on Windows. Exit 0 means the mutant survived, non-zero means killed. |
 | `-C`, `--root DIR` | Project root (default: the current directory). This is the directory copied into each sandbox, and the command runs there. |
 | `-j`, `--jobs N` | Parallel workers (default: the number of CPUs). Each worker has its own copy of the project. |
+| `--coverage` | Run, for each mutant, only the tests that execute its lines (Minitest and RSpec). See [Coverage-based test selection](#coverage-based-test-selection). |
+| `--unparser` | Render rebuilt nodes (the `element-removal` operator) with the [`unparser`](https://github.com/mbj/unparser) gem instead of from the source text. Needs `gem install unparser`. |
 | `--timeout SECONDS` | Per-mutant time limit. A mutant that exceeds it (an infinite loop, say) is killed together with every process it started and counted as **killed, by timeout**. The default is `baseline time x factor + 5` seconds. |
 | `--timeout-factor F` | The factor for the default timeout (default: 3). |
 | `--copy-exclude GLOB` | Do not copy matching paths into the sandboxes (repeatable). `.git` and `coverage` are never copied. Matches against the relative path and against the base name, e.g. `--copy-exclude node_modules --copy-exclude 'log/*'`. |
@@ -150,6 +153,7 @@ The command gets these environment variables: `MUTARUBY=1`, and while a mutant r
 | Option | Meaning |
 |---|---|
 | `--since REF` | Only mutate files changed since a git ref: committed, staged and unstaged changes plus new untracked files (`git diff --name-only REF` and `git ls-files --others --exclude-standard`), intersected with the file arguments. |
+| `--subject PATTERN` | Only mutants in these methods (repeatable): `Foo#bar` (instance method), `Foo.bar` (singleton method), `Foo#*` / `Foo.*` (all of one kind), `Foo` or `Foo::Bar` (every method of that namespace and of the namespaces nested in it), `Foo*` (a glob over namespaces). |
 | `--method PATTERN` | Only mutants inside matching methods (repeatable). The pattern is a glob matched against the qualified name (`Pricing#discount` for an instance method, `Pricing.build` for a singleton method) or the bare name (`discount`). `Pricing#*` selects every instance method of `Pricing`. |
 | `--exclude-method PATTERN` | Skip mutants inside matching methods (repeatable). |
 | `--line SPEC` | Only mutants starting on these lines (repeatable). `SPEC` is `[FILE:]LINE` or `[FILE:]FROM-TO`, e.g. `lib/a.rb:10-20` or `42`. |
@@ -237,10 +241,56 @@ mutant's, are dropped before anything runs. `--list-operators` prints this list.
 | `op-assign` | swaps compound assignments: `+=` and `-=`, `*=` and `/=`, `\|=` and `&=`, `<<=` and `>>=` | `i += 1` to `i -= 1` |
 | `or-assign` | `\|\|=` becomes `=` | `@x \|\|= load` to `@x = load` |
 | `and-assign` | `&&=` becomes `=` | `a &&= b` to `a = b` |
+| `block-removal` | a call loses its block | `list.map { \|x\| f(x) }` to `list.map` |
+| `method-swap` | a method becomes its counterpart: `first`/`last`, `min`/`max`, `min_by`/`max_by`, `any?`/`all?`, `select`/`reject` (and `filter`), `upcase`/`downcase`, `floor`/`ceil`, `succ`/`pred`, `keys`/`values`, `start_with?`/`end_with?`, `take`/`drop`, `take_while`/`drop_while`, `push`/`unshift`, `pop`/`shift` | `items.first` to `items.last` |
+| `element-removal` | one element of a bracketed array or braced hash removed (literals with 2 to 6 elements) | `[a, b]` to `[b]` and `[a]` |
+| `regexp-never-match` | a regexp literal becomes one that matches nothing | `/\A\d+\z/` to `/(?!)/` |
+| `yield-removal` | `yield` becomes `nil` | `yield(item)` to `nil` |
+| `super-removal` | `super` becomes `nil` | `super(name)` to `nil` |
+| `when-removal` | one `when` branch of a `case` removed | |
+| `rescue-removal` | one `rescue` clause removed | |
 
 Strings inside interpolations, heredocs, `%w[]` arrays and the arguments of `require`-style declarations are not
 mutated, and neither are symbols used as hash keys (`a: 1`).
 
+## Coverage-based test selection
+
+Most mutants are reached by only a few tests, yet by default every mutant runs the whole test command. With
+`--coverage`, mutaruby first finds out which tests execute which lines, then runs each mutant against just those
+tests:
+
+```sh
+mutaruby -t "bundle exec rspec" --coverage
+mutaruby -t "bundle exec rake test" --coverage
+```
+
+How it works:
+
+1. The baseline run (which has to pass anyway) is made with a small probe loaded into the test process
+   (`RUBYLIB` plus `RUBYOPT=-rmutaruby_probe`). The probe uses Ruby's `Coverage` API and the test framework's
+   per-test hooks to record, for every test, the lines of the project it executes. Tests are identified as
+   `Class#test_name` for Minitest and by the example id (`./spec/a_spec.rb[1:2]`) for RSpec.
+2. For each mutant, the tests that execute any of its lines are written to a file, and the run loads the probe in
+   selection mode, which tells Minitest or RSpec to run only those tests. The test command itself is unchanged.
+3. A mutant runs the **whole** command instead when one of its lines ran while the code was being loaded (a class
+   body, a constant, a method definition line), when no test reaches its lines, or when the baseline recorded no
+   Minitest or RSpec tests at all (mutaruby then prints a warning).
+
+What it saves depends on the suite. Measured on GitHub Actions (`script/benchmark-coverage.rb`, 4 workers), with the
+same verdicts both ways:
+
+| Project | Mutants | Whole test command | `--coverage` |
+|---|---|---|---|
+| mutaruby's own unit suite (a 1/25 sample of its mutants) | 199 | 3,788 s | 2,276 s (1.7x faster) |
+| `test/fixtures/calc` (5 tests, Minitest or RSpec) | 43 | 13 s | 13 s |
+
+A small suite gains nothing: starting Ruby costs more than its tests. The larger and slower the suite, and the fewer
+tests reach each line, the bigger the win.
+
+The summary shows how many mutants ran a subset, and the JSON report has, per mutant, the number of tests it ran
+(`tests`, or `null` for the whole command). Selection assumes that tests are independent of each other: a test that
+only passes after another one has run can make a mutant look killed.
+
 ## Equivalent mutants: the ignore file
 
 `.mutaruby-ignore.yml` (or the file given to `--ignore-file`) is a YAML list. Each entry names one **mutation site** and
@@ -342,17 +392,21 @@ survivors as failed tests.
 
 ## How it compares with mutant
 
-[mutant](https://github.com/mbj/mutant) is the established mutation tester for Ruby, and it is more mature and more
-capable than mutaruby: it has many more operators, semantic knowledge of Ruby's core library, selection of only the
-tests that cover each subject, and years of use on large code bases. It is commercially licensed (free for open
-source projects).
+[mutant](https://github.com/mbj/mutant) is the mature reference implementation of mutation testing for Ruby, and the
+tool mutaruby is most often compared with. It is more capable: many more operators, semantic knowledge of Ruby's core
+library, precise subject and test selection, and years of use on large code bases. It is distributed under its own
+commercial licence (free for open source projects).
+
+**mutaruby shares no code with mutant.** It is an independent, clean-room implementation, written from general,
+publicly known ideas about mutation testing (operators, coverage-based test selection, equivalent-mutant handling),
+and it is MIT-licensed. Its only runtime dependency is `parser`; `unparser`, an MIT-licensed gem, is an optional
+extra for `--unparser`.
 
 mutaruby aims to be **MIT-licensed and simple**:
 
 - It works with **any test command** (rspec, minitest, rake, a Makefile target), because the oracle is just an exit
-  status. There is no framework integration to configure, and no per-test selection either, so it is slower than
-  mutant on big suites unless you point the command at the relevant tests.
-- It is small enough to read in an afternoon, and it has no dependency besides `parser`.
+  status. With `--coverage` it also runs only the tests that reach each mutant, for Minitest and RSpec suites.
+- It is small enough to read in an afternoon.
 - It runs each mutant in a **separate process** in a **copy of the project**, so it cannot leave your working tree
   modified.
 
@@ -419,7 +473,8 @@ mutaruby works the same way on Windows, with these differences:
 
 - On Windows, processes that a test run leaves running after it exits normally are not stopped (see
   [Windows notes](#windows-notes)).
-- The test command is run as is for every mutant; mutaruby does not work out which tests cover which code.
+- Per-test selection (`--coverage`) understands Minitest and RSpec; any other command runs in full for every mutant.
+  Selection assumes the tests do not depend on each other's order or side effects.
 - The parser grammar is chosen to match the running Ruby, up to the newest grammar the installed `parser` gem knows.
   Files that `parser` cannot read (for example syntax newer than it supports) are skipped with a warning.
 - Mutants are syntactic. Some are equivalent by nature; that is what the ignore file is for.

data/lib/mutaruby/cli.rb

@@ -71,6 +71,8 @@ module Mutaruby
         op.on('-j', '--jobs N', Integer, "Parallel workers (default: #{Etc.nprocessors})") { |v| o.jobs = v }
         op.on('--timeout SECONDS', Float, 'Per-mutant timeout (default: baseline time x factor + 5s)') { |v| o.timeout = v }
         op.on('--timeout-factor F', Float, 'Multiplier on the baseline time for the default timeout (default: 3)') { |v| o.timeout_factor = v }
+        op.on('--coverage', 'Run only the tests that cover each mutant (Minitest and RSpec; mapped in the baseline run)') { o.coverage = true }
+        op.on('--unparser', 'Render rebuilt nodes with the unparser gem (element-removal; needs gem install unparser)') { o.renderer = :unparser }
         op.on('--copy-exclude GLOB', 'Do not copy matching paths into the sandboxes (repeatable; .git and coverage are always skipped)') { |v| o.copy_excludes += [v] }
         op.separator ''
         op.separator 'Selection:'
@@ -79,6 +81,7 @@ module Mutaruby
         op.on('--exclude-method PATTERN', 'Skip mutants inside matching methods (repeatable)') { |v| o.exclude_methods += [v] }
         op.on('--line SPEC', 'Only mutants on these lines: [FILE:]LINE or [FILE:]FROM-TO (repeatable)') { |v| o.lines += [Selection.parse_line_spec(v)] }
         op.on('--exclude-line SPEC', 'Skip mutants on these lines (repeatable)') { |v| o.exclude_lines += [Selection.parse_line_spec(v)] }
+        op.on('--subject PATTERN', 'Only mutants in these methods: "Foo#bar", "Foo.bar", "Foo#*", "Foo" (with nested namespaces), "Foo*" (repeatable)') { |v| o.subjects += [v] }
         op.on('--operators LIST', Array, 'Only these operators (comma-separated; globs allowed, e.g. condition-*)') { |v| @include_ops += v }
         op.on('--exclude-operators LIST', Array, 'Skip these operators (comma-separated; globs allowed)') { |v| @exclude_ops += v }
         op.on('--shard I/N', 'Run only shard I of N (1-based) of the selected mutants') { |v| o.shard = Selection.parse_shard(v) }

data/lib/mutaruby/command.rb

@@ -52,11 +52,14 @@ module Mutaruby
                           chdir: dir, in: File::NULL, out: out, err: out, **@platform.spawn_options)
       waiter = Process.detach(pid)
       @lock.synchronize { @live[pid] = waiter }
-      timed_out = waiter.join(timeout).nil?
-      # A timed-out run, and (where the platform allows) anything a finished run left behind, must not outlive it.
-      kill_group(pid, waiter) if timed_out || @platform.stop_leftovers?
-      st = waiter.value
-      @lock.synchronize { @live.delete(pid) }
+      begin
+        timed_out = wait(pid, waiter, timeout)
+        # A timed-out run, and (where the platform allows) anything a finished run left behind, must not outlive it.
+        kill_group(pid, waiter) if timed_out || @platform.stop_leftovers?
+        st = waiter.value
+      ensure
+        @lock.synchronize { @live.delete(pid) }
+      end
       status = if timed_out then :timeout
                elsif st.success? then :passed
                else :failed
@@ -64,6 +67,15 @@ module Mutaruby
       Result.new(status: status, exitstatus: st.exitstatus, seconds: monotonic - started)
     end
 
+    # True when the run timed out. Interrupted while waiting (Ctrl-C), the run is stopped before the interrupt goes on:
+    # its output file, its sandbox and its process group must not outlive it.
+    def wait(pid, waiter, timeout)
+      waiter.join(timeout).nil?
+    rescue Interrupt
+      kill_group(pid, waiter)
+      raise
+    end
+
     # Bundler exports the ORIGINAL Gemfile path to child processes. Left as is, `bundle exec` in the sandbox would
     # resolve the Gemfile (and a `gemspec` line's lib/ directory) from the user's checkout and test the unmutated code.
     # The per-mutant variables are always set or cleared explicitly, so a mutaruby run nested inside another one's
@@ -86,6 +98,7 @@ module Mutaruby
       deadline = monotonic + @kill_grace
       sleep POLL while monotonic < deadline && @platform.alive?(pid, waiter)
       @platform.stop_tree(pid, graceful: false)
+      @platform.settle(waiter, @kill_grace)
     end
 
     def tail(bytes)

data/lib/mutaruby/coverage_map.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Mutaruby
+  # Which tests execute which lines of the project, recorded in the baseline run by the probe
+  # (lib/mutaruby/probe/mutaruby_probe.rb) through Ruby's Coverage API. Used to run, for each mutant, only the tests
+  # that reach its lines.
+  class CoverageMap
+    PROBE_DIR = File.expand_path('probe', __dir__).freeze
+
+    # Environment that loads the probe into the test process, plus `extra` (the probe's own variables). RUBYLIB is a
+    # path list (spaces are fine there); RUBYOPT names only the feature, so no path has to survive its splitting.
+    def self.probe_env(extra)
+      lib = [PROBE_DIR, ENV.fetch('RUBYLIB', '')].reject(&:empty?).join(File::PATH_SEPARATOR)
+      opt = [ENV.fetch('RUBYOPT', ''), '-rmutaruby_probe'].reject(&:empty?).join(' ')
+      { 'RUBYLIB' => lib, 'RUBYOPT' => opt }.merge(extra)
+    end
+
+    def self.load(path)
+      new(JSON.parse(File.read(path, encoding: 'UTF-8')))
+    end
+
+    attr_reader :framework
+
+    # data: { "framework" => "minitest" | "rspec" | nil, "tests" => { id => { file => [line, ...] } },
+    #         "load" => { file => [line, ...] } }
+    def initialize(data)
+      @framework = data['framework']
+      @tests = Hash.new { |h, k| h[k] = [] }
+      data['tests'].each do |id, files|
+        files.each { |file, lines| lines.each { |l| @tests[[file, l]] << id } }
+      end
+      @load = data['load'].flat_map { |file, lines| lines.map { |l| [file, l] } }
+    end
+
+    # True when the run recorded tests of a supported framework.
+    def usable?
+      !@framework.nil? && @tests.any?
+    end
+
+    # The ids of the tests that execute any of `lines` of `file`, sorted; nil when the whole suite has to run: a line
+    # that ran while the code was loaded (a class body, a method definition), or a line no test reaches.
+    def tests_for(file, lines)
+      return nil if lines.any? { |l| @load.include?([file, l]) }
+
+      ids = lines.flat_map { |l| @tests.fetch([file, l], []) }.uniq.sort
+      ids.empty? ? nil : ids
+    end
+  end
+end

data/lib/mutaruby/generator.rb

@@ -3,6 +3,7 @@
 require_relative 'parsing'
 require_relative 'mutation'
 require_relative 'splicer'
+require_relative 'render'
 
 module Mutaruby
   # Walks a file's AST (the `parser` gem) and produces every mutant of it. Each mutant is ONE splice of the original
@@ -46,7 +47,24 @@ module Mutaruby
       'raise-removal' => 'raise X -> nil (also fail)',
       'op-assign' => 'swap compound assignment (+= <-> -=, *= <-> /=, |= <-> &=, <<= <-> >>=)',
       'or-assign' => 'a ||= b -> a = b',
-      'and-assign' => 'a &&= b -> a = b'
+      'and-assign' => 'a &&= b -> a = b',
+      'block-removal' => 'list.map { |x| f(x) } -> list.map (the call without its block)',
+      'method-swap' => 'swap a method for its counterpart (first <-> last, min <-> max, select <-> reject, ...)',
+      'element-removal' => '[a, b] -> [b], [a]; { k: 1, j: 2 } -> { j: 2 }, { k: 1 } (one element removed at a time)',
+      'regexp-never-match' => '/pattern/ -> /(?!)/ (a regexp that matches nothing)',
+      'yield-removal' => 'yield x -> nil',
+      'super-removal' => 'super / super(x) -> nil',
+      'when-removal' => 'one `when` branch of a case removed',
+      'rescue-removal' => 'one `rescue` clause removed'
+    }.freeze
+
+    # method-swap pairs: each method and the one it is replaced with.
+    METHOD_SWAPS = {
+      first: :last, last: :first, min: :max, max: :min, min_by: :max_by, max_by: :min_by, any?: :all?, all?: :any?,
+      select: :reject, reject: :select, filter: :reject, upcase: :downcase, downcase: :upcase, floor: :ceil,
+      ceil: :floor, succ: :pred, pred: :succ, keys: :values, values: :keys, start_with?: :end_with?,
+      end_with?: :start_with?, take: :drop, drop: :take, take_while: :drop_while, drop_while: :take_while,
+      push: :unshift, unshift: :push, pop: :shift, shift: :pop
     }.freeze
 
     SWAPS = {
@@ -75,8 +93,11 @@ module Mutaruby
 
     # path: file path for messages; rel: path relative to the project root (stored on the mutants).
     # operators: nil (all) or a list of operator ids.
-    def initialize(source, path:, rel: path, operators: nil)
+    # renderer: :text (default) builds replacements from the source text; any other value (:unparser) renders the
+    # operators that rebuild a node (element-removal) with the `unparser` gem instead, which must be installed.
+    def initialize(source, path:, rel: path, operators: nil, renderer: :text)
       @src = source
+      @renderer = renderer
       @path = path
       @rel = rel
       @operators = operators
@@ -226,10 +247,8 @@ module Mutaruby
       when :true then add(n.loc.expression, 'false', 'literal-boolean')
       when :false then add(n.loc.expression, 'true', 'literal-boolean')
       when :nil then add(n.loc.expression, 'true', 'literal-nil')
-      when :array
-        add(n.loc.expression, '[]', 'literal-array') if n.children.any? && n.loc.begin&.source == '['
-      when :hash
-        add(n.loc.expression, '{}', 'literal-hash') if n.children.any? && n.loc.begin&.source == '{'
+      when :array then visit_collection(n, '[', '[]', 'literal-array')
+      when :hash then visit_collection(n, '{', '{}', 'literal-hash')
       when :irange, :erange
         # an endless range (a..) means the same with either operator
         add(n.loc.operator, n.type == :irange ? '...' : '..', 'range-swap') unless n.children[1].nil?
@@ -242,6 +261,39 @@ module Mutaruby
       when :and_asgn then add(n.loc.operator, '=', 'and-assign')
       when :begin, :kwbegin then visit_body(n)
       when :def, :defs then visit_def(n)
+      when :block, :numblock then add(n.loc.expression, src_of(n.children.first), 'block-removal')
+      when :regexp then add(n.loc.expression, '/(?!)/', 'regexp-never-match')
+      when :yield then add(n.loc.expression, 'nil', 'yield-removal')
+      when :super, :zsuper then add(n.loc.expression, 'nil', 'super-removal')
+      when :case then remove_clauses(n.children[1...-1], 'when-removal')
+      when :rescue then remove_clauses(n.children[1...-1], 'rescue-removal')
+      end
+    end
+
+    # A bracketed array / braced hash: emptied, and each element removed in turn.
+    def visit_collection(n, open, empty, op)
+      return unless n.loc.begin&.source == open
+
+      add(n.loc.expression, empty, op) if n.children.any?
+      remove_elements(n) if n.children.size.between?(2, MAX_ARGS)
+    end
+
+    # Each clause (a `when`, a `rescue`) deleted in turn; the validity check drops what would not parse.
+    def remove_clauses(clauses, op)
+      clauses.each { |c| add(c.loc.expression, '', op) }
+    end
+
+    # [a, b, c] -> [b, c], [a, c], [a, b] (and the same for the pairs of a braced hash).
+    def remove_elements(n)
+      kids = n.children
+      kids.each_index do |i|
+        rest = kids.reject.with_index { |_, j| j == i }
+        if @renderer == :text
+          add(kids.first.loc.expression.join(kids.last.loc.expression), rest.map { |k| src_of(k) }.join(', '),
+              'element-removal')
+        else
+          add(n.loc.expression, Render.unparse(src_of(n), i), 'element-removal')
+        end
       end
     end
 
@@ -250,6 +302,7 @@ module Mutaruby
       SWAPS.each do |op, table|
         add(n.loc.selector, table[meth].to_s, op) if table.key?(meth) && args.size == 1
       end
+      add(n.loc.selector, METHOD_SWAPS[meth].to_s, 'method-swap') if recv && METHOD_SWAPS.key?(meth)
       add(n.loc.expression, src_of(recv), 'negation-removal') if meth == :!
       add(n.loc.expression, src_of(recv), 'unary-minus-removal') if meth == :-@
       add(n.loc.dot, '.', 'safe-navigation') if n.type == :csend
@@ -298,12 +351,12 @@ module Mutaruby
     end
 
     def visit_int(n)
-      v = n.children.first
+      v, = n.children
       [v + 1, v - 1, 0, 1].each { |x| add(n.loc.expression, x.to_s, 'literal-int') }
     end
 
     def visit_float(n)
-      v = n.children.first
+      v, = n.children
       add(n.loc.expression, '0.0', 'literal-float') unless v.zero?
       add(n.loc.expression, (v + 1.0).to_s, 'literal-float') if v.finite?
     end
@@ -317,7 +370,8 @@ module Mutaruby
       close = n.loc.end if open
       return unless close
 
-      fill = n.children.first.empty? ? 'mutaruby' : ''
+      text, = n.children
+      fill = text.empty? ? 'mutaruby' : ''
       add(n.loc.expression, "#{open.source}#{fill}#{close.source}", 'literal-string')
     end
 

data/lib/mutaruby/platform.rb

@@ -20,6 +20,9 @@ module Mutaruby
       # After a run ends, whatever is left of its process group is stopped too.
       def stop_leftovers? = true
 
+      # Nothing to wait for: the group is gone once signalled with SIGKILL.
+      def settle(_waiter, _seconds); end
+
       # graceful: SIGTERM, otherwise SIGKILL, to the process group led by pid.
       def stop_tree(pid, graceful:)
         Process.kill(graceful ? 'TERM' : 'KILL', -pid)
@@ -57,6 +60,12 @@ module Mutaruby
       # already have reused its id for an unrelated process.
       def stop_leftovers? = false
 
+      # After taskkill /F, give the process up to `seconds` to exit for good: until then Windows keeps its files and
+      # working directory (the sandbox) locked.
+      def settle(waiter, seconds)
+        waiter.join(seconds)
+      end
+
       def stop_tree(pid, graceful:)
         @system.call('taskkill', '/T', *(graceful ? [] : ['/F']), '/PID', pid.to_s)
       end

data/lib/mutaruby/probe/mutaruby_probe.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+# Loaded into the user's test process by mutaruby (RUBYLIB=<this directory>, RUBYOPT=-rmutaruby_probe) when
+# coverage-based test selection is on. It depends on nothing from mutaruby itself and does nothing unless one of its
+# environment variables is set:
+#
+#   MUTARUBY_COVERAGE_OUT=FILE   record, for every test, the lines of the project it executes (Ruby's Coverage API),
+#                                and write them to FILE as JSON when the process exits
+#   MUTARUBY_COVERAGE_ROOT=DIR   the project directory; only files below it are recorded
+#   MUTARUBY_SELECT=FILE         run only the tests whose ids FILE lists, one per line
+#
+# The test command may start several Ruby processes (bundle exec -> rake -> ruby running the tests). Each loads the
+# probe, but only the process that loads a test framework records or selects: launchers write nothing. That process
+# then removes the variables, so Ruby processes started by the tests themselves run normally.
+#
+# Test ids: "Class#test_method" for Minitest, the example id ("./spec/a_spec.rb[1:2]") for RSpec.
+module MutarubyProbe
+  class << self
+    def setup
+      @out = ENV.fetch('MUTARUBY_COVERAGE_OUT', '')
+      @select = ENV.fetch('MUTARUBY_SELECT', '')
+      @installed = []
+      return if @out.empty? && @select.empty?
+
+      @select.empty? ? start_recording : load_selection
+      Object.prepend(RequireHook)
+    end
+
+    def recording? = !@out.empty?
+
+    # --- recording -------------------------------------------------------------------------------------------------
+
+    def start_recording
+      require 'coverage'
+      require 'json'
+      root = ENV.fetch('MUTARUBY_COVERAGE_ROOT')
+      @root = "#{File.realpath(root)}/"
+      @tests = Hash.new { |h, id| h[id] = {} }
+      @load = {}
+      Coverage.start(lines: true)
+      at_exit { write if @installed.any? }
+    end
+
+    # Lines run before a test starts (loading code, defining methods) count as load-time lines.
+    def test_started(id)
+      collect(@load)
+      @current = id
+    end
+
+    def test_finished
+      collect(@tests[@current])
+    end
+
+    def collect(into)
+      Coverage.result(stop: false, clear: true).each do |path, data|
+        rel = relative(path)
+        next unless rel
+
+        lines = data[:lines]
+        hit = lines.each_index.select { |i| lines[i].to_i.positive? }.map { |i| i + 1 }
+        into[rel] = (into.fetch(rel, []) | hit).sort
+      end
+    end
+
+    # Path relative to the project, or nil for files outside it. Coverage reports the path a file was loaded from; it
+    # is compared by its real path.
+    def relative(path)
+      real = real_path(path)
+      real.delete_prefix(@root) if real.start_with?(@root)
+    end
+
+    # Ruby records required files by their real path already; a file deleted since it was loaded keeps that path.
+    def real_path(path)
+      File.realpath(path)
+    rescue SystemCallError
+      path
+    end
+
+    # Lines run after the last test (at_exit and after_run hooks) count as load-time lines too.
+    def write
+      collect(@load)
+      File.write(@out, JSON.generate(framework: @installed.first, tests: @tests, load: @load))
+    end
+
+    # --- selection -------------------------------------------------------------------------------------------------
+
+    def load_selection
+      @selected = File.readlines(@select, chomp: true)
+    end
+
+    def selected?(id) = @selected.include?(id)
+
+    # --- frameworks ------------------------------------------------------------------------------------------------
+
+    def install_hooks
+      install_minitest if !@installed.include?('minitest') && defined?(::Minitest::Test)
+      install_rspec if !@installed.include?('rspec') && defined?(::RSpec) && ::RSpec.respond_to?(:configure)
+    end
+
+    # The first framework found: this is the test process. Its children must not record or select.
+    def claim
+      %w[MUTARUBY_COVERAGE_OUT MUTARUBY_COVERAGE_ROOT MUTARUBY_SELECT].each { |k| ENV.delete(k) }
+    end
+
+    def install_minitest
+      claim
+      @installed << 'minitest'
+      if recording?
+        ::Minitest::Test.prepend(MinitestRecording)
+      else
+        ::Minitest::Test.singleton_class.prepend(MinitestSelection)
+      end
+    end
+
+    def install_rspec
+      claim
+      @installed << 'rspec'
+      if recording?
+        ::RSpec.configure do |c|
+          c.around do |ex| # (an example hook)
+            MutarubyProbe.test_started(ex.id)
+            ex.run
+          ensure
+            MutarubyProbe.test_finished
+          end
+        end
+      else
+        ::RSpec.configure do |c|
+          c.define_derived_metadata do |meta|
+            meta[:mutaruby_selected] = true if MutarubyProbe.selected?("#{meta[:rerun_file_path]}[#{meta[:scoped_id]}]")
+          end
+          c.filter_run_including(mutaruby_selected: true)
+        end
+      end
+    end
+  end
+
+  # Re-checks for test frameworks after every require: they are loaded after this file.
+  module RequireHook
+    private
+
+    def require(name)
+      super
+    ensure
+      MutarubyProbe.install_hooks
+    end
+  end
+
+  module MinitestRecording
+    def before_setup
+      MutarubyProbe.test_started("#{self.class}##{name}")
+      super
+    end
+
+    def after_teardown
+      super
+    ensure
+      MutarubyProbe.test_finished
+    end
+  end
+
+  module MinitestSelection
+    def runnable_methods
+      super.select { |m| MutarubyProbe.selected?("#{name}##{m}") }
+    end
+  end
+end
+
+MutarubyProbe.setup

data/lib/mutaruby/render.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'error'
+
+module Mutaruby
+  # Renders rebuilt nodes back to Ruby source with the MIT-licensed `unparser` gem (optional: `gem install unparser`).
+  # Text splicing stays the default; this path is used, with --unparser, for operators that rebuild a node. The
+  # rendered text is still spliced over the node's own range, so the splice self-check applies as usual.
+  module Render
+    class Unavailable < Error; end
+
+    module_function
+
+    def load!
+      require 'unparser'
+    rescue LoadError
+      raise Unavailable, '--unparser needs the unparser gem (gem install unparser)'
+    end
+
+    # `source` (an array or hash literal) without its element number `index`, rendered by unparser. The node is
+    # parsed again by unparser itself, so its AST is in the form unparser expects.
+    def unparse(source, index)
+      load!
+      node = Unparser.parse(source)
+      Unparser.unparse(node.updated(nil, node.children.reject.with_index { |_, j| j == index }))
+    end
+  end
+end

data/lib/mutaruby/reporters.rb

@@ -43,6 +43,10 @@ module Mutaruby
       io.puts "  survived:    #{report.count(:survived)}"
       io.puts "  equivalent:  #{report.count(:equivalent)} (ignore file)"
       io.puts "  score:       #{score_text(report)}  = killed / (mutants - equivalent)"
+      if report.coverage
+        subset = report.outcomes.count(&:tests)
+        io.puts "  coverage:    #{report.coverage}: #{subset} of #{report.outcomes.size} mutants ran only the tests covering them"
+      end
       io.puts format('  time:        %.1fs (baseline %.2fs, timeout %ss, jobs %d)', report.seconds,
                      report.baseline_seconds, report.timeout, report.jobs)
     end
@@ -50,12 +54,12 @@ module Mutaruby
     def json_data(report)
       {
         tool: 'mutaruby', version: VERSION, command: report.command,
-        score: report.score&.round(4), complete: report.complete,
+        score: report.score&.round(4), complete: report.complete, coverage: report.coverage,
         counts: { mutants: report.outcomes.size, killed: report.killed, timeout: report.count(:timeout),
                   survived: report.count(:survived), equivalent: report.count(:equivalent) },
         files: report.files, baseline_seconds: secs(report.baseline_seconds), timeout: report.timeout,
         mutants: report.outcomes.map do |o|
-          o.mutation.to_h.merge(status: o.status, seconds: secs(o.seconds), ignore_reason: o.ignore&.reason)
+          o.mutation.to_h.merge(status: o.status, seconds: secs(o.seconds), ignore_reason: o.ignore&.reason, tests: o.tests)
         end,
         stale_ignores: report.stale.map { |e| e.to_h.compact.except(:index) },
         warnings: report.warnings

data/lib/mutaruby/runner.rb

@@ -4,19 +4,21 @@ require_relative 'ignore_file'
 require_relative 'sandbox'
 require_relative 'command'
 require_relative 'selection'
+require_relative 'coverage_map'
 
 module Mutaruby
   class BaselineFailed < Error; end
 
   # Generates the mutants, checks the baseline, runs every mutant and collects the verdicts.
   class Runner
-    Outcome = Struct.new(:mutation, :status, :seconds, :ignore, keyword_init: true) do
+    # tests: how many tests the mutant ran with coverage-based selection; nil when it ran the whole command.
+    Outcome = Struct.new(:mutation, :status, :seconds, :ignore, :tests, keyword_init: true) do
       # :killed, :timeout (also a kill), :survived, :equivalent (survived, listed in the ignore file)
       def killed? = %i[killed timeout].include?(status)
     end
 
     Report = Struct.new(:root, :command, :files, :outcomes, :sources, :stale, :warnings, :baseline_seconds, :timeout,
-                        :jobs, :seconds, :complete, keyword_init: true) do
+                        :jobs, :seconds, :complete, :coverage, keyword_init: true) do
       def count(status) = outcomes.count { |o| o.status == status }
       def killed = count(:killed) + count(:timeout)
 
@@ -29,10 +31,11 @@ module Mutaruby
 
     Options = Struct.new(:root, :command, :patterns, :since, :jobs, :timeout, :timeout_factor, :methods,
                          :exclude_methods, :lines, :exclude_lines, :shard, :ignore_file, :operators, :copy_excludes,
-                         :progress, keyword_init: true) do
+                         :progress, :subjects, :coverage, :renderer, keyword_init: true) do
       def self.build(**kw)
         new(root: '.', patterns: [], jobs: 1, timeout_factor: 3.0, methods: [], exclude_methods: [], lines: [],
-            exclude_lines: [], copy_excludes: [], progress: false, **kw)
+            exclude_lines: [], copy_excludes: [], progress: false, subjects: [], coverage: false, renderer: :text,
+            **kw)
       end
     end
 
@@ -52,7 +55,7 @@ module Mutaruby
       sources = files.to_h { |f| [f, File.binread(File.join(@root, f)).force_encoding(Encoding::UTF_8)] }
       warnings = []
       all = files.flat_map do |f|
-        g = Generator.new(sources[f], path: File.join(@root, f), rel: f, operators: @o.operators)
+        g = Generator.new(sources[f], path: File.join(@root, f), rel: f, operators: @o.operators, renderer: @o.renderer)
         ms = g.mutations
         warnings.concat(g.errors)
         ms
@@ -73,28 +76,45 @@ module Mutaruby
       p = plan
       first = Sandbox.new(@root, excludes: @o.copy_excludes)
       sandboxes << first
-      base = cmd.run(first.dir, capture: true)
+      coverage_out = first.scratch('coverage.json')
+      base_env = @o.coverage ? CoverageMap.probe_env('MUTARUBY_COVERAGE_OUT' => coverage_out,
+                                                     'MUTARUBY_COVERAGE_ROOT' => first.dir) : {}
+      base = cmd.run(first.dir, capture: true, env: base_env)
       unless base.passed?
         raise BaselineFailed, "the test command fails on the UNMUTATED code (exit #{base.exitstatus}); every mutant " \
                               "would count as killed, so nothing would be measured.\ncommand: #{@o.command}\n" \
                               "--- output (tail) ---\n#{base.output}"
       end
       timeout = @o.timeout || ((base.seconds * @o.timeout_factor) + 5).ceil
+      p[:coverage] = coverage_map(coverage_out, p[:warnings]) if @o.coverage
       outcomes = execute(p, cmd, sandboxes, timeout)
       matched = outcomes.select { |o| o.status == :equivalent }.map(&:ignore)
       stale = p[:ignore] && p[:complete] ? p[:ignore].stale(matched, p[:files]) : []
       Report.new(root: @root, command: @o.command, files: p[:files], outcomes: outcomes, sources: p[:sources],
                  stale: stale, warnings: p[:warnings], baseline_seconds: base.seconds, timeout: timeout,
-                 jobs: jobs, seconds: monotonic - t0, complete: p[:complete])
+                 jobs: jobs, seconds: monotonic - t0, complete: p[:complete], coverage: p[:coverage]&.framework)
     rescue Interrupt
+      # Workers see @stop and start no new mutant; the runs in flight are killed; then the workers finish, before
+      # their sandboxes go.
+      @stop = true
       cmd.kill_all
+      @threads&.each(&:join)
       raise
     ensure
-      sandboxes.each(&:cleanup)
+      remove(sandboxes, $!)
     end
 
     private
 
+    # Removes the sandboxes. When the run is already failing (an interrupt, a failing baseline), a sandbox that cannot
+    # be removed is left behind rather than replacing that error: on Windows a process that is still exiting keeps its
+    # directory locked for a moment.
+    def remove(sandboxes, failing)
+      sandboxes.each(&:cleanup)
+    rescue SystemCallError
+      raise unless failing
+    end
+
     def jobs
       [@o.jobs, 1].max
     end
@@ -102,7 +122,17 @@ module Mutaruby
     def selection
       Selection.new(root: @root, patterns: @o.patterns, since: @o.since, methods: @o.methods,
                     exclude_methods: @o.exclude_methods, lines: @o.lines, exclude_lines: @o.exclude_lines,
-                    shard: @o.shard)
+                    shard: @o.shard, subjects: @o.subjects)
+    end
+
+    # The coverage map recorded by the baseline run, or nil (with a warning) when no supported test framework ran.
+    def coverage_map(path, warnings)
+      map = File.exist?(path) ? CoverageMap.load(path) : nil
+      return map if map&.usable?
+
+      warnings << 'coverage: no Minitest or RSpec tests were recorded in the baseline run; every mutant runs the ' \
+                  'whole test command'
+      nil
     end
 
     def load_ignore
@@ -123,9 +153,9 @@ module Mutaruby
       sandboxes << Sandbox.new(@root, excludes: @o.copy_excludes) while sandboxes.size < n
       results = []
       lock = Mutex.new
-      threads = sandboxes.map do |box|
+      @threads = sandboxes.map do |box|
         Thread.new do
-          while (m = next_mutation(queue))
+          while !@stop && (m = next_mutation(queue))
             o = evaluate(m, box, plan, cmd, timeout)
             lock.synchronize do
               results << o
@@ -134,33 +164,33 @@ module Mutaruby
           end
         end
       end
-      begin
-        threads.each(&:join)
-      rescue Interrupt
-        threads.each(&:kill)
-        raise
-      end
+      @threads.each(&:join)
       @out.puts if @o.progress && results.any?
       results.sort_by { |o| o.mutation.id }
     end
 
     def next_mutation(queue)
-      queue.pop(true)
+      queue.deq(true)
     rescue ThreadError
       nil
     end
 
     def evaluate(m, box, plan, cmd, timeout)
-      r = box.with_file(m.file, m.text, plan[:sources][m.file]) do
-        cmd.run(box.dir, timeout: timeout, env: { 'MUTARUBY_MUTANT_ID' => m.id.to_s, 'MUTARUBY_FILE' => m.file })
+      env = { 'MUTARUBY_MUTANT_ID' => m.id.to_s, 'MUTARUBY_FILE' => m.file }
+      tests = plan[:coverage]&.tests_for(m.file, m.lineno..(m.lineno + m.orig.count("\n")))
+      if tests
+        list = box.scratch('tests.txt')
+        File.write(list, tests.map { |t| "#{t}\n" }.join)
+        env.merge!(CoverageMap.probe_env('MUTARUBY_SELECT' => list))
       end
+      r = box.with_file(m.file, m.text, plan[:sources][m.file]) { cmd.run(box.dir, timeout: timeout, env: env) }
       entry = plan[:ignore]&.match(m)
       status = if r.timeout? then :timeout
                elsif !r.passed? then :killed
                elsif entry then :equivalent
                else :survived
                end
-      Outcome.new(mutation: m, status: status, seconds: r.seconds, ignore: entry)
+      Outcome.new(mutation: m, status: status, seconds: r.seconds, ignore: entry, tests: tests&.size)
     end
 
     def progress(outcome)

data/lib/mutaruby/sandbox.rb

@@ -17,7 +17,7 @@ module Mutaruby
     # process that is still exiting, or a virus scanner, can hold it for a moment).
     RETRIES = 10
     RETRY_DELAY = 0.1
-    LOCKED = [Errno::EACCES, Errno::EBUSY, Errno::EPERM].freeze
+    LOCKED = [Errno::EACCES, Errno::EBUSY, Errno::EPERM, Errno::ENOTEMPTY].freeze
 
     # Runs the block, retrying while it raises one of the LOCKED errors.
     def self.retrying(tries: RETRIES, delay: RETRY_DELAY)
@@ -51,6 +51,11 @@ module Mutaruby
       File.join(@dir, rel)
     end
 
+    # A path for mutaruby's own files: next to the project copy, not inside it.
+    def scratch(name)
+      File.join(@base, name)
+    end
+
     # Writes `text` to `rel` inside the sandbox, yields, and restores the original bytes afterwards (also on error).
     def with_file(rel, text, original)
       target = path(rel)

data/lib/mutaruby/selection.rb

@@ -34,7 +34,7 @@ module Mutaruby
 
     # lines / exclude_lines: LineSpec objects (see parse_line_spec). shard: [i, n] or nil.
     def initialize(root:, patterns: [], since: nil, methods: [], exclude_methods: [], lines: [], exclude_lines: [],
-                   shard: nil)
+                   shard: nil, subjects: [])
       @root = File.expand_path(root)
       @patterns = patterns.empty? ? DEFAULT_PATTERNS : patterns
       @since = since
@@ -43,11 +43,13 @@ module Mutaruby
       @lines = lines
       @exclude_lines = exclude_lines
       @shard = shard
+      @subjects = subjects
     end
 
     # True when every mutant of each selected file is run (so stale ignore entries can be detected).
     def complete?
-      @methods.empty? && @exclude_methods.empty? && @lines.empty? && @exclude_lines.empty? && @shard.nil?
+      @methods.empty? && @exclude_methods.empty? && @lines.empty? && @exclude_lines.empty? && @shard.nil? &&
+        @subjects.empty?
     end
 
     # Sorted paths of the matching files, relative to the root.
@@ -64,7 +66,8 @@ module Mutaruby
 
     def filter(mutations)
       kept = mutations.select do |m|
-        (@methods.empty? || @methods.any? { |p| method_match?(p, m.method) }) &&
+        (@subjects.empty? || @subjects.any? { |s| subject_match?(s, m.method) }) &&
+          (@methods.empty? || @methods.any? { |p| method_match?(p, m.method) }) &&
           @exclude_methods.none? { |p| method_match?(p, m.method) } &&
           (@lines.empty? || @lines.any? { |s| s.cover?(m) }) &&
           @exclude_lines.none? { |s| s.cover?(m) }
@@ -83,6 +86,21 @@ module Mutaruby
       name ? File.fnmatch?(pattern, name) || File.fnmatch?(pattern, name.split(/[#.]/).last) : false
     end
 
+    # A subject names methods by their place in the code:
+    #   "Foo#bar", "Foo.bar"      one method (instance, singleton); globs allowed: "Foo#*", "Foo.*", "Foo#to_*"
+    #   "Foo", "Foo::Bar"         every method of that namespace and of the namespaces nested in it
+    #   "Foo*"                    a glob over namespaces ("Foo*" matches Foo, FooBar and Foo::Baz)
+    def subject_match?(subject, name)
+      name ? subject_name_match?(subject, name) : false
+    end
+
+    def subject_name_match?(subject, name)
+      return File.fnmatch?(subject, name) if subject.match?(/[#.]/)
+
+      namespace = name.split(/[#.]/).first
+      namespace.start_with?("#{subject}::") || File.fnmatch?(subject, namespace)
+    end
+
     # Files changed relative to a git ref: committed, staged and unstaged edits, plus new untracked files.
     def changed_files
       git('diff', '--name-only', '--relative', @since, '--') + git('ls-files', '--others', '--exclude-standard')

data/lib/mutaruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mutaruby
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mutaruby
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Atlas Authorization
@@ -46,12 +46,15 @@ files:
 - lib/mutaruby.rb
 - lib/mutaruby/cli.rb
 - lib/mutaruby/command.rb
+- lib/mutaruby/coverage_map.rb
 - lib/mutaruby/error.rb
 - lib/mutaruby/generator.rb
 - lib/mutaruby/ignore_file.rb
 - lib/mutaruby/mutation.rb
 - lib/mutaruby/parsing.rb
 - lib/mutaruby/platform.rb
+- lib/mutaruby/probe/mutaruby_probe.rb
+- lib/mutaruby/render.rb
 - lib/mutaruby/reporters.rb
 - lib/mutaruby/runner.rb
 - lib/mutaruby/sandbox.rb