mutineer 1.0.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77a6283314f6511b6ea8165477cda70f0e54bc5ba25d9e80b7afb95903d168b8
-  data.tar.gz: a7172bbd15af300e3064fa4df50a4845e4710d31c5458f6c535cb54472634a75
+  metadata.gz: 1ca70f2affdf60ddda53d3d38e23ddff4ba6cae27cd789501c7fe3060975f146
+  data.tar.gz: 94a9968fe182655e6d566e9edfc43f1f2e15b050c7690f8905e7be9f7d710b61
 SHA512:
-  metadata.gz: da4882d841268217538cd4e2f327efbc5630d0d198ff38636203cb304a4a5b219af9f317097c10cfa69fc85da4c8b55570add95ff5d36cfb7a23dcf4dc12b8d9
-  data.tar.gz: 7eee3c779742a39f0828027a96d1843e9dbd0843434eba9de07bdbf8528fbbf926828471253c38e05f4ef2af5a09bc3c966f11a0482685bfce560fdd3763f228
+  metadata.gz: 8da96d70db7af241cda4ca44ecbe84522b0c0b68427a46c05e3178723c2eada7d957677c8b2cc7d2853d9593cba546c194f342862058dffdba55d03e8ef27021
+  data.tar.gz: 50481e9ca34d07530878f6ff0f25f192ab63c3200376a1a1ea5665341955a00c6bf2f9e7a4429d6cd8fd8d2119c4316c4c993741f219897f57ab493ca6c428b1

data/CHANGELOG.md

@@ -6,6 +6,82 @@ All notable changes to this project are documented here. The format is based on
 
 ## [Unreleased]
 
+## [1.1.0] - 2026-09-28
+
+### Added
+- **Safe-navigation operator** (Tier-2, opt-in via `--operators`):
+  `safe_navigation` replaces `&.` with `.`. The mutant survives when no test
+  passes `nil` to the call.
+- **Range operator** (Tier-2, opt-in via `--operators`): `range` replaces
+  `..` with `...` and `...` with `..`. The `..` -> `...` mutant survives when
+  no test checks the last element of the range. Endless ranges (`1..`) are
+  skipped, because `(1..)` and `(1...)` give the same result for slicing,
+  `include?`, `===` and pattern matching.
+- **Negation-removal operator** (Tier-2, opt-in via `--operators`):
+  `negation_removal` removes the `!` from `!x` and the `not` from `not x`.
+  The mutant survives when no test depends on the negated value. The
+  explicit form `x.!` is skipped, because `x.` does not parse.
+
+### Changed
+- **Stderr of tests and specs is visible** in the in-process and `--daemon`
+  runs. Mutineer silences stdout once per child process and no longer hides
+  stderr, so its own child diagnostics always reach you. `--test-command`
+  runs still capture stderr with stdout and show it under `--verbose`.
+- **A mutant's test run stops at the first failing test** — one failure
+  already kills the mutant, so the forked child does not run the tests that
+  remain. Killed mutants cost less time, and survived mutants cost the same.
+  Under Minitest, when the outer reporter of the run records a failure or an
+  error (a skip does not count), each remaining test and each remaining test
+  class returns before it starts. A skipped class does not start its
+  class-level hooks. The run does not unwind: a class that is running
+  finishes normally, so its `after_all` hooks and a class-level
+  `transaction { super; raise ActiveRecord::Rollback }` still run. RSpec runs
+  with `--fail-fast`. This applies to the in-process backend only: coverage
+  capture and the clean checks still run every test, and the `--daemon` and
+  `--test-command` backends do not change. The CLI `--fail-fast` flag keeps
+  its meaning. On rack's `lib/rack/utils.rb` (`--jobs 1`), a full run takes
+  about 35–41 s instead of about 86–89 s. With the same coverage map, the
+  verdicts are the same.
+- **The mutant run uses a fixed Minitest seed** — with the stop, the test
+  order can decide the verdict, so the child runs Minitest with seed `1`
+  unless the environment sets `SEED`. The same code then gives the same
+  verdict on each run. Coverage capture and the clean checks keep the random
+  seed, so the clean check runs the tests in a random order while each mutant
+  run uses the fixed order. RSpec keeps its configured order: a suite configured with
+  `config.order = :random` can still get a different verdict on each run for
+  the case below. In an order-dependent Minitest suite, the fixed seed makes
+  a false `killed` happen on every run or on no run, not on some runs.
+- **A mutant whose failing test runs before a hanging test is now `killed`,
+  not `timeout`** — the run stops at the failure, before the hang. The tests
+  did detect the mutation, so `killed` is the correct verdict. If the hanging
+  test runs first in the fixed order, the verdict stays `timeout`. Compared
+  with a baseline from an earlier version, the score usually goes up. In an
+  order-dependent suite it can also go down: a mutant that a random order
+  killed on some runs can survive on every run in the fixed order. A change
+  to the tests can change the fixed order, so a later run can move such a
+  mutant from `killed` to `timeout`, and a `--baseline` gate then reports a
+  score drop.
+- **Some runs still run most tests** — Minitest `parallelize_me!`, and Rails
+  `parallelize` above its threshold (by default more than 50 tests in the
+  child, or at any test count when `PARALLEL_WORKERS` is 2 or more in the
+  environment), queue their tests before the first result comes back, so the
+  queued tests still run. The verdict is the same as before. Below the
+  Rails threshold, the tests run one after the other in the child, and the
+  stop works.
+
+### Fixed
+- **Tests that reopen `$stdout`** (Minitest's `capture_subprocess_io`,
+  RSpec's `to_stdout_from_any_process`) no longer make a green suite
+  "not green" or count as false kills.
+- **Test or source files that print while they load** no longer make coverage
+  capture fail with `invalid coverage output`. The capture subprocess now
+  sends its result over a separate pipe, not over stdout.
+- **Chain-link operator** (Tier-2, opt-in via `--operators`):
+  `chain_link` drops one call from a chain, with its arguments and block
+  (`user.account.name` -> `user.name`). The mutant survives when no test tells
+  the chain apart from the same chain without that step. Conversions and copies
+  (`to_s`, `to_a`, `dup`, `freeze`, ...) and `new` are never dropped.
+
 ## [1.0.2] - 2026-09-21
 
 ### Added
@@ -422,6 +498,7 @@ 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.
 
+[1.1.0]: https://github.com/davidteren/mutineer/releases/tag/v1.1.0
 [1.0.2]: https://github.com/davidteren/mutineer/releases/tag/v1.0.2
 [1.0.1]: https://github.com/davidteren/mutineer/releases/tag/v1.0.1
 [1.0.0]: https://github.com/davidteren/mutineer/releases/tag/v1.0.0

data/README.md

@@ -13,6 +13,8 @@ testing anything.
 - **One mutation per mutant**, validity-checked by re-parsing.
 - **Fork-isolated**, parallel execution (Linux + macOS).
 - **Coverage-guided** — each mutant runs only the test files that cover its line.
+- **Stops at the first failing test** — in-process runs (not `--daemon` or
+  `--test-command`) stop a mutant's test run at the first failure.
 
 📖 **[mutineer.github.io →](https://davidteren.github.io/mutineer/)** — overview, operators, and usage.
 
@@ -82,7 +84,7 @@ 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`, `string_literal`, `regex`,
-`collection_method`.
+`collection_method`, `safe_navigation`, `range`, `negation_removal`, `chain_link`.
 
 ## Rails apps
 

data/lib/mutineer/child_stdout.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Mutineer
+  # Silences stdout in a forked child that runs tests. Every fork boundary
+  # calls {.silence} once, right after `fork`, so the test runners themselves
+  # do not touch stdout. The parent reads each child's result from a separate
+  # pipe or from the exit status, never from stdout.
+  #
+  # Stderr stays open: it carries mutineer's own diagnostics from the child.
+  #
+  # Stdlib-only, so the app-side daemon can load it.
+  module ChildStdout
+    # Points fd 1 at File::NULL and makes `$stdout` the real STDOUT again.
+    #
+    # The reopen goes through STDOUT, not `$stdout`: the parent may have left
+    # `$stdout` as a StringIO, which cannot reopen. A test that calls
+    # `$stdout.reopen` (Minitest's `capture_subprocess_io`, RSpec's
+    # `to_stdout_from_any_process`) then gets a real IO. Child processes of the
+    # test inherit the silenced fd 1 too.
+    #
+    # The reopen takes an open IO, not a path. A path reopen checks the access
+    # mode of STDOUT and raises ArgumentError when a parent left STDOUT on a
+    # file in another mode (for example the "w+x" Tempfile of Minitest's
+    # `capture_subprocess_io`).
+    #
+    # Call it only in a child that exits after the tests run. Nothing restores
+    # the previous stdout.
+    #
+    # @return [void]
+    def self.silence
+      File.open(File::NULL, "w") { |null| STDOUT.reopen(null) }
+      $stdout = STDOUT
+    end
+  end
+end

data/lib/mutineer/coverage_map.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "open3"
 require "json"
 require "digest"
 require "fileutils"
@@ -9,6 +8,7 @@ require "coverage"
 require "set"
 require_relative "minitest_integration"
 require_relative "test_runners"
+require_relative "child_stdout"
 
 module Mutineer
   # Maps `(source_file, line) -> [test_files]` so each mutant runs only against
@@ -22,6 +22,10 @@ module Mutineer
     # Seconds per coverage subprocess before the parent kills it.
     DEFAULT_CAPTURE_TIMEOUT = 120
 
+    # File descriptor in a capture subprocess that carries the JSON result to
+    # the parent. Stdout stays free for test output, which goes to File::NULL.
+    RESULT_FD = 3
+
     attr_reader :project_root, :failed_test_files, :failed_clean_tests, :phase_a_ran, :map
 
     # Build a QUERY-ONLY map from data captured elsewhere (the daemon builds the
@@ -232,6 +236,7 @@ module Mutineer
         rd.close
         payload =
           begin
+            ChildStdout.silence
             # Fork-safety hook: the in-process path reconnects AR; the daemon
             # routes to its worker DB. Nil (non-Rails) = no-op. Injected so this
             # file needs neither Runner (Prism) nor Rails.
@@ -293,22 +298,8 @@ module Mutineer
     # before any source is loaded. Returns the wrapped capture payload
     # (`passed` + `coverage`), or nil when the subprocess failed (logged + skipped).
     def capture(test_path)
-      out = +""
-      status = nil
-      Open3.popen2(RbConfig.ruby, "-") do |stdin, stdout, wait_thr|
-        stdin.write(subprocess_script(test_path))
-        stdin.close
-        reader = Thread.new { out << stdout.read }
-        # Bound the subprocess with a wall clock: a hanging test file must not
-        # wedge the whole run before any per-mutant timeout.
-        unless wait_thr.join(@capture_timeout)
-          Process.kill(:KILL, wait_thr.pid) rescue nil # rubocop:disable Style/RescueModifier
-          reader.kill
-          return fail_test(test_path, "timed out after #{@capture_timeout}s")
-        end
-        reader.join
-        status = wait_thr.value
-      end
+      status, out = spawn_script(subprocess_script(test_path))
+      return fail_test(test_path, "timed out after #{@capture_timeout}s") unless status
       return fail_test(test_path, "subprocess exited #{status.exitstatus}") unless status.success?
 
       parsed = JSON.parse(out)
@@ -442,20 +433,72 @@ module Mutineer
     # @param test_paths [Array<String>] test file paths.
     # @return [Boolean]
     def subprocess_clean_pass?(test_paths)
-      status = nil
-      Open3.popen2(RbConfig.ruby, "-") do |stdin, stdout, wait_thr|
-        stdin.write(clean_check_script(test_paths))
-        stdin.close
-        reader = Thread.new { stdout.read }
-        unless wait_thr.join(@capture_timeout)
-          Process.kill(:KILL, wait_thr.pid) rescue nil # rubocop:disable Style/RescueModifier
-          reader.kill
-          return false
-        end
-        reader.join
-        status = wait_thr.value
+      status, = spawn_script(clean_check_script(test_paths), result: false)
+      status&.success? || false
+    end
+
+    # Runs `script` in a fresh `ruby -` that reads the script from stdin. The
+    # child's stdout goes to File::NULL, so test output never reaches the user
+    # or the result. With `result: true`, the child writes its result as one
+    # line to fd {RESULT_FD}, a pipe that only the script uses. The child's
+    # stderr is the parent's stderr, so warnings from the script reach the
+    # user. A wall clock of `@capture_timeout` bounds the whole call, so a hung
+    # test cannot wedge the run.
+    #
+    # The parent reads one line, not until EOF: a process that a test leaves
+    # running can inherit fd {RESULT_FD} (a `fork` without `exec` keeps it
+    # despite close-on-exec) and hold the pipe open long after the child exits.
+    # A clean check reports only through its exit status, so it gets no pipe.
+    #
+    # @api private
+    # @param script [String] Ruby script text.
+    # @param result [Boolean] whether to open the result pipe on fd {RESULT_FD}.
+    # @return [Array(Process::Status, String)] the exit status and the line the
+    #   child wrote to fd {RESULT_FD} (`""` without one); `[nil, ""]` after a
+    #   timeout.
+    def spawn_script(script, result: true)
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + @capture_timeout
+      script_rd, script_wr = IO.pipe
+      result_rd, result_wr = IO.pipe if result
+      options = { in: script_rd, out: File::NULL }
+      options[RESULT_FD] = result_wr if result
+      pid = Process.spawn(RbConfig.ruby, "-", **options)
+      waiter = Process.detach(pid)
+      script_rd.close
+      result_wr&.close
+      reader = Thread.new { result_rd.gets.to_s } if result
+      script_wr.write(script)
+      script_wr.close
+      unless waiter.join(remaining(deadline))
+        Process.kill(:KILL, pid) rescue nil # rubocop:disable Style/RescueModifier
+        waiter.join
+        reader&.kill
+        return [nil, ""]
       end
-      status&.success?
+      [waiter.value, reader&.join(remaining(deadline))&.value.to_s]
+    ensure
+      reader&.kill
+      [script_rd, script_wr, result_rd, result_wr].compact.each { |io| io.close unless io.closed? }
+    end
+
+    # Seconds left before `deadline`, never negative.
+    #
+    # @api private
+    # @param deadline [Float] a CLOCK_MONOTONIC time.
+    # @return [Float]
+    def remaining(deadline)
+      [deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC), 0].max
+    end
+
+    # Ruby source that opens the result channel in a {#spawn_script} child. The
+    # script runs it first, so no file that a test opens can take fd
+    # {RESULT_FD}. Close-on-exec keeps the fd out of the test's own
+    # subprocesses.
+    #
+    # @api private
+    # @return [String] Ruby script text.
+    def result_channel_expression
+      "_result = IO.new(#{RESULT_FD}, \"w\"); _result.close_on_exec = true"
     end
 
     # Runs test files in a fork of the booted parent and returns whether they passed.
@@ -473,6 +516,7 @@ module Mutineer
         rd.close
         Process.setpgid(0, 0) rescue nil # rubocop:disable Style/RescueModifier
         begin
+          ChildStdout.silence
           after_fork&.call
           Coverage.result(clear: true, stop: false) if Coverage.running?
           wr.write(Marshal.dump(TestRunners.for(@framework).run(abs_tests).zero?))
@@ -533,12 +577,10 @@ module Mutineer
       loads = Array(test_paths).map { |t| "load #{absolute(t).inspect}" }.join("\n")
       <<~RUBY
         require "minitest"
-        require "stringio"
         def Minitest.autorun; end
         $LOAD_PATH.unshift(*#{abs_load_paths.inspect})
         #{abs_source_paths.inspect}.each { |f| load f }
         #{loads}
-        $stdout = StringIO.new
         exit(Minitest.run([]) ? 0 : 1)
       RUBY
     end
@@ -561,7 +603,6 @@ module Mutineer
         $LOAD_PATH.unshift(*#{abs_load_paths.inspect})
         #{abs_source_paths.inspect}.each { |f| load f }
         _sink = StringIO.new
-        $stdout = _sink
         status = RSpec::Core::Runner.run(["--no-color", #{specs}], _sink, _sink)
         exit(status.zero? ? 0 : 1)
       RUBY
@@ -583,31 +624,31 @@ module Mutineer
     # @return [String] Ruby script text.
     def minitest_subprocess_script(test_path)
       <<~RUBY
+        #{result_channel_expression}
         require "coverage"
         require "json"
-        require "stringio"
         require "minitest"
         def Minitest.autorun; end
         Coverage.start(lines: true)
         $LOAD_PATH.unshift(*#{abs_load_paths.inspect})
         #{abs_source_paths.inspect}.each { |f| load f }
         load #{absolute(test_path).inspect}
-        _orig = $stdout
-        $stdout = StringIO.new
         _passed = Minitest.run([])
-        $stdout = _orig
-        puts JSON.generate("passed" => _passed == true, "coverage" => Coverage.result,
-                           "loaded_files" => #{loaded_files_expression})
+        _result.puts JSON.generate("passed" => _passed == true, "coverage" => Coverage.result,
+                                    "loaded_files" => #{loaded_files_expression})
+        _result.close
       RUBY
     end
 
     # Same coverage-JSON contract as the minitest path, but driven by RSpec:
     # require rspec/core lazily, load the sources under Coverage, then run the
-    # one spec via RSpec::Core::Runner with output silenced so only the JSON
-    # reaches stdout. A missing rspec makes `require` raise -> subprocess exits
-    # non-zero -> capture() records a skipped (incomplete-map) test, with a hint.
+    # one spec via RSpec::Core::Runner. The JSON goes to the result channel (see
+    # {#spawn_script}), so spec output cannot corrupt it. A missing rspec makes
+    # the script exit non-zero -> capture() records a skipped (incomplete-map)
+    # test, with a hint.
     def rspec_subprocess_script(test_path)
       <<~RUBY
+        #{result_channel_expression}
         require "coverage"
         require "json"
         require "stringio"
@@ -621,13 +662,11 @@ module Mutineer
         Coverage.start(lines: true)
         $LOAD_PATH.unshift(*#{abs_load_paths.inspect})
         #{abs_source_paths.inspect}.each { |f| load f }
-        _orig = $stdout
         _sink = StringIO.new
-        $stdout = _sink
         _status = RSpec::Core::Runner.run(["--no-color", #{absolute(test_path).inspect}], _sink, _sink)
-        $stdout = _orig
-        puts JSON.generate("passed" => _status.zero?, "coverage" => Coverage.result,
-                           "loaded_files" => #{loaded_files_expression})
+        _result.puts JSON.generate("passed" => _status.zero?, "coverage" => Coverage.result,
+                                    "loaded_files" => #{loaded_files_expression})
+        _result.close
       RUBY
     end
 

data/lib/mutineer/daemon_server.rb

@@ -2,6 +2,7 @@
 
 require "json"
 require "tempfile"
+require_relative "child_stdout"
 
 module Mutineer
   # App-side daemon (persistent worker).
@@ -177,9 +178,9 @@ module Mutineer
           # New process group so a per-fork timeout can SIGKILL the whole subtree,
           # and silence the child's stdout so test output never corrupts the IPC pipe.
           Process.setpgid(0, 0) rescue nil # rubocop:disable Style/RescueModifier
-          $stdout.reopen(File::NULL, "w")
           code =
             begin
+              ChildStdout.silence
               # Route THIS fork at its own worker database before any test loads.
               # A routing failure raises here and is scored `error`, never a false verdict.
               @worker_db&.after_fork(worker, schema_for_fork)

data/lib/mutineer/isolation.rb

@@ -3,6 +3,7 @@
 require "tempfile"
 require_relative "result"
 require_relative "parser"
+require_relative "child_stdout"
 
 module Mutineer
   # Fork-based isolation for running one mutant. The block runs in a child
@@ -26,6 +27,9 @@ module Mutineer
     # exit code) or any explicit `exit` is honoured; an unhandled exception
     # becomes exit 2 with the cause written to STDERR.
     #
+    # The child silences its stdout (see {ChildStdout.silence}) before the
+    # block runs, so test output never reaches the user. Stderr stays open.
+    #
     # @param timeout [Integer] timeout in seconds.
     # @yieldreturn [Integer] child exit status.
     # @return [Mutineer::Result] result from the child process.
@@ -36,15 +40,17 @@ module Mutineer
         Process.setpgid(0, 0) rescue nil # rubocop:disable Style/RescueModifier
         code = 0
         begin
+          ChildStdout.silence
           result = yield
           code = result.is_a?(Integer) ? result : 0
         rescue SystemExit => e
           code = e.status
         rescue Exception => e # rubocop:disable Lint/RescueException
-          warn "[mutineer-child] #{e.class}: #{e.message}"
+          # STDERR, not `warn`: a test may have left `$stderr` as a StringIO.
+          STDERR.puts "[mutineer-child] #{e.class}: #{e.message}"
           code = 2
         end
-        $stderr.flush
+        STDERR.flush
         # exit! skips at_exit handlers — critical, since a child forked from
         # inside our own Minitest suite would otherwise re-run the parent's
         # at_exit autorun hook on the way out.

data/lib/mutineer/minitest_integration/stop_at_first_failure.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module Mutineer
+  class MinitestIntegration
+    # Stops a Minitest run at the first failing test: one failure already
+    # kills the mutant. Child-process only, like MinitestIntegration.
+    #
+    # It sets a flag instead of unwinding the stack, so that class-level
+    # wrappers (`after_all`, a block-form transaction) still finish. The
+    # remaining tests and classes then return before they start.
+    #
+    # Minitest 5 and 6 need different hook points. An unknown shape installs
+    # no hook, and the run is a full run.
+    module StopAtFirstFailure
+      # Prepended on `Minitest::CompositeReporter`.
+      module RecordFailure
+        # Records the result, then sets the stop flag on a failure or an
+        # error. Only the outer reporter counts: a test can build and record
+        # on its own reporter.
+        #
+        # @param result [Minitest::Result] the result of one test.
+        # @return [void]
+        def record(result)
+          super
+          return if result.passed? || result.skipped?
+          return unless equal?(StopAtFirstFailure.armed_reporter)
+          return unless StopAtFirstFailure.armed_here?
+
+          StopAtFirstFailure.stopped = true
+        end
+      end
+
+      # Prepended on the `Minitest` singleton class for Minitest 6.
+      module OuterReporter6
+        # Keeps the outer reporter. Only the first call counts, because a test
+        # can call this method with its own reporter.
+        #
+        # @param reporter [Minitest::CompositeReporter] the outer reporter.
+        # @param options [Hash] the Minitest options.
+        # @return [Object] whatever Minitest returns.
+        def run_all_suites(reporter, options)
+          StopAtFirstFailure.armed_reporter ||= reporter if StopAtFirstFailure.armed_here?
+          super
+        end
+      end
+
+      # Prepended on the `Minitest` singleton class for Minitest 5.
+      module OuterReporter5
+        # The Minitest 5 form of OuterReporter6#run_all_suites.
+        #
+        # @param reporter [Minitest::CompositeReporter] the outer reporter.
+        # @param options [Hash] the Minitest options.
+        # @return [Object] whatever Minitest returns.
+        def __run(reporter, options)
+          StopAtFirstFailure.armed_reporter ||= reporter if StopAtFirstFailure.armed_here?
+          super
+        end
+      end
+
+      # Prepended on the singleton class of each test class for Minitest 6.
+      module SkipAfterStop6
+        # Skips the test class after a stop.
+        #
+        # @param reporter [Minitest::CompositeReporter] the reporter.
+        # @param options [Hash] the Minitest options.
+        # @return [Object, nil] whatever Minitest returns, or nil when skipped.
+        def run_suite(reporter, options = {})
+          return if StopAtFirstFailure.stopped_here?
+
+          super
+        end
+
+        # Skips one test after a stop, without a record.
+        #
+        # @param klass [Class] the test class.
+        # @param method_name [String] the test method.
+        # @param reporter [Minitest::CompositeReporter] the reporter.
+        # @return [Object, nil] whatever Minitest returns, or nil when skipped.
+        def run(klass, method_name, reporter)
+          return if StopAtFirstFailure.stopped_here?
+
+          super
+        end
+      end
+
+      # Prepended on the singleton class of each test class for Minitest 5.
+      module SkipAfterStop5
+        # Skips the test class after a stop.
+        #
+        # @param reporter [Minitest::CompositeReporter] the reporter.
+        # @param options [Hash] the Minitest options.
+        # @return [Object, nil] whatever Minitest returns, or nil when skipped.
+        def run(reporter, options = {})
+          return if StopAtFirstFailure.stopped_here?
+
+          super
+        end
+
+        # Skips one test after a stop, without a record.
+        #
+        # @param klass [Class] the test class.
+        # @param method_name [String] the test method.
+        # @param reporter [Minitest::CompositeReporter] the reporter.
+        # @return [Object, nil] whatever Minitest returns, or nil when skipped.
+        def run_one_method(klass, method_name, reporter)
+          return if StopAtFirstFailure.stopped_here?
+
+          super
+        end
+      end
+
+      class << self
+        # The pid of the armed process. Forked workers inherit the other
+        # state, and the pid keeps them from acting on it.
+        #
+        # @return [Integer, nil]
+        attr_accessor :armed_pid
+
+        # The outer reporter of the armed run.
+        #
+        # @return [Minitest::CompositeReporter, nil]
+        attr_accessor :armed_reporter
+
+        # True after the outer reporter records a failure or an error.
+        #
+        # @return [Boolean, nil]
+        attr_accessor :stopped
+
+        # Installs the hooks and arms the stop for this process. Call it after
+        # the test files load, so that every test class gets its prepend.
+        #
+        # @param runnables [Array<Class>] the loaded test classes.
+        # @return [Boolean] false when the Minitest shape is unknown.
+        def arm!(runnables)
+          outer, skip = hooks_for_loaded_minitest
+          return false unless outer
+
+          prepend_once(::Minitest::CompositeReporter, RecordFailure)
+          prepend_once(::Minitest.singleton_class, outer)
+          runnables.each { |klass| prepend_once(klass.singleton_class, skip) }
+          self.armed_pid = Process.pid
+          self.armed_reporter = nil
+          self.stopped = false
+          true
+        end
+
+        # Clears the armed state.
+        #
+        # @return [void]
+        def disarm!
+          self.armed_pid = nil
+          self.armed_reporter = nil
+          self.stopped = false
+        end
+
+        # True when the run is armed in this process.
+        #
+        # @return [Boolean]
+        def armed_here?
+          armed_pid == Process.pid
+        end
+
+        # True when the armed run in this process has stopped.
+        #
+        # @return [Boolean]
+        def stopped_here?
+          stopped == true && armed_here?
+        end
+
+        private
+
+        # Picks the hook modules for the loaded Minitest.
+        #
+        # @return [Array(Module, Module), nil] the outer reporter hook and the
+        #   skip hook, or nil for an unknown shape.
+        def hooks_for_loaded_minitest
+          runnable = ::Minitest::Runnable
+          if ::Minitest.respond_to?(:run_all_suites) && runnable.respond_to?(:run_suite)
+            [OuterReporter6, SkipAfterStop6]
+          elsif ::Minitest.respond_to?(:__run) && runnable.respond_to?(:run_one_method)
+            [OuterReporter5, SkipAfterStop5]
+          end
+        end
+
+        # Prepends `mod` on `target` once. A copy on a superclass does not
+        # count, because it comes after the own methods of `target`.
+        #
+        # @param target [Module] the class or singleton class.
+        # @param mod [Module] the module to prepend.
+        # @return [void]
+        def prepend_once(target, mod)
+          return if target.ancestors.take_while { |a| !a.equal?(target) }.include?(mod)
+
+          target.prepend(mod)
+        end
+      end
+    end
+  end
+end

data/lib/mutineer/minitest_integration.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "stringio"
+require_relative "minitest_integration/stop_at_first_failure"
 
 module Mutineer
   # Child-process-only: loads a test file in the current process and runs it
@@ -16,6 +16,11 @@ module Mutineer
   # boundary for unexpected errors. Swallowing those here would create a
   # second exit-2 path and break this method's 0/1 return contract.
   class MinitestIntegration
+    # The seed of a run that stops at the first failure, unless `SEED` is set.
+    # With the stop, the test order can decide `killed` vs `timeout`; a fixed
+    # order keeps the verdict stable for a `--baseline` gate.
+    STOP_AT_FIRST_FAILURE_SEED = 1
+
     # Tested via runner_test.rb, not in isolation — a direct unit test
     # would require forking and duplicate isolation_test's coverage.
     #
@@ -24,8 +29,10 @@ module Mutineer
     # Minitest.run.
     #
     # @param test_files [String, Array<String>] one file or many files.
+    # @param stop_at_first_failure [Boolean] end the run at the first failing
+    #   test. Only the mutant path passes true.
     # @return [Integer] 0 on success, 1 on failure.
-    def self.run(test_files)
+    def self.run(test_files, stop_at_first_failure: false)
       begin
         require "minitest"
       rescue LoadError
@@ -47,13 +54,20 @@ module Mutineer
       Minitest::Runnable.reset
       Array(test_files).each { |f| load f }
 
-      orig = $stdout
-      # Silence the child's test output; the parent only cares about pass/fail.
-      $stdout = StringIO.new
-      passed = Minitest.run([])
-      $stdout = orig
+      args = []
+      if stop_at_first_failure && StopAtFirstFailure.arm!(Minitest::Runnable.runnables)
+        # Pin the seed only when the stop is armed; an unknown Minitest shape
+        # gets the normal full, randomly ordered run.
+        args = ["--seed", STOP_AT_FIRST_FAILURE_SEED.to_s] unless ENV["SEED"]
+      end
+      # No silencing here: the fork boundary that calls this method has already
+      # pointed stdout at File::NULL (see ChildStdout).
+      passed = Minitest.run(args)
 
-      passed ? 0 : 1
+      # A plugin can replace the summary reporter, so a stop decides by itself.
+      passed && !StopAtFirstFailure.stopped_here? ? 0 : 1
+    ensure
+      StopAtFirstFailure.disarm!
     end
   end
 end

data/lib/mutineer/mutator_registry.rb

@@ -11,12 +11,16 @@ require_relative "mutators/condition_negation"
 require_relative "mutators/string_literal"
 require_relative "mutators/regex_literal"
 require_relative "mutators/collection_method"
+require_relative "mutators/safe_navigation"
+require_relative "mutators/range_literal"
+require_relative "mutators/negation_removal"
+require_relative "mutators/chain_link"
 
 module Mutineer
   # Maps operator names to operator classes.
   #
   # DEFAULT_NAMES is the v1 default set (Tier-1 plus statement-removal).
-  # The six Tier-2 operators live in ALL but are OFF by default — they only
+  # The Tier-2 operators live in ALL but are OFF by default — they only
   # run when named via `--operators` or `operators:` in `.mutineer.yml`.
   # Keeping DEFAULT_NAMES an explicit subset (not ALL.keys) is what keeps
   # the default survivor set unchanged.
@@ -33,13 +37,19 @@ module Mutineer
       "condition_negation" => Mutators::ConditionNegation,
       "string_literal"     => Mutators::StringLiteral,
       "regex"              => Mutators::RegexLiteral,
-      "collection_method"  => Mutators::CollectionMethod
+      "collection_method"  => Mutators::CollectionMethod,
+      "safe_navigation"    => Mutators::SafeNavigation,
+      "range"              => Mutators::RangeLiteral,
+      "negation_removal"   => Mutators::NegationRemoval,
+      "chain_link"         => Mutators::ChainLink
     }.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 string_literal regex collection_method].freeze
+    TIER2_NAMES   = %w[return_nil literal_mutation condition_negation string_literal regex collection_method
+                       safe_navigation range negation_removal
+                       chain_link].freeze
 
     # Short human-readable descriptions for each operator.
     DESCRIPTIONS = {
@@ -53,7 +63,11 @@ module Mutineer
       "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"
+      "collection_method"  => "map<->each, all?<->any?, first<->last, min<->max, select<->reject",
+      "safe_navigation"    => "&. -> .",
+      "range"              => ".. <-> ...",
+      "negation_removal"   => "!x, not x -> x",
+      "chain_link"         => "drop one call from a chain: a.b.c -> a.c"
     }.freeze
 
     # Resolves operator names to classes.

data/lib/mutineer/mutators/chain_link.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Chain-link mutator (Tier-2).
+    #
+    # Drops one dotted call from a chain of calls, with its arguments and block:
+    # `user.account.owner.name` becomes `user.owner.name` and `user.account.name`.
+    # The chain's receiver and its final call stay, so a chain of n dotted calls
+    # gives at most n - 1 mutations. A chain begins at a receiver that is not a
+    # dotted call: a local, a constant, `self`, `list[i]`, `(a + b)`. A call in
+    # an argument or a block starts a chain of its own.
+    #
+    # The mutant survives when no test tells the chain apart from the same chain
+    # without that step: a scope, a filter or a lookup the tests never see.
+    #
+    # Links in {SKIPPED} are never dropped. On a value that already has the
+    # target type or needs no copy, a conversion (`name.to_s.strip`) or a copy
+    # (`list.dup.sort`) is a no-op, so dropping it most often makes an
+    # equivalent mutant. Dropping `new` sends the next call to the class, which
+    # raises (killed by any test that runs the line) or reaches a class method
+    # that builds the instance itself (equivalent); neither says anything about
+    # the tests.
+    class ChainLink < Base
+      # Method names whose link is never dropped: core conversions and copies,
+      # plus `new`.
+      SKIPPED = %i[
+        to_s to_str to_sym to_i to_int to_f to_r to_c to_a to_ary to_h to_hash to_proc to_set
+        dup clone freeze itself
+        new
+      ].freeze
+
+      # Resets the per-subject record of calls already placed in a chain.
+      #
+      # @param subject [Mutineer::Subject] subject whose body is visited.
+      # @param source [String] full source text for byte-based slicing.
+      # @return [Array<Mutineer::Mutation>] collected mutations.
+      def mutations_for(subject, source)
+        @links = {}.compare_by_identity
+        super
+      end
+
+      # Visits a call. The outermost dotted call of a chain is its final call;
+      # the dotted calls below it in the receiver are its links.
+      #
+      # @param node [Prism::CallNode] call node to inspect.
+      # @return [void]
+      def visit_call_node(node)
+        chain(node) if dotted?(node) && !@links.key?(node)
+        super
+      end
+
+      # Visits `a.b.c += 1`, whose final call Prism parses as its own node.
+      #
+      # @param node [Prism::CallOperatorWriteNode] node to inspect.
+      # @return [void]
+      def visit_call_operator_write_node(node)
+        chain(node)
+        super
+      end
+
+      # Visits `a.b.c ||= 1`.
+      #
+      # @param node [Prism::CallOrWriteNode] node to inspect.
+      # @return [void]
+      def visit_call_or_write_node(node)
+        chain(node)
+        super
+      end
+
+      # Visits `a.b.c &&= 1`.
+      #
+      # @param node [Prism::CallAndWriteNode] node to inspect.
+      # @return [void]
+      def visit_call_and_write_node(node)
+        chain(node)
+        super
+      end
+
+      # Visits a call used as an assignment target, as in `a.b.c, d = 1, 2`.
+      #
+      # @param node [Prism::CallTargetNode] node to inspect.
+      # @return [void]
+      def visit_call_target_node(node)
+        chain(node)
+        super
+      end
+
+      # Nested method definitions are discovered as their own subjects; do not
+      # recurse into them (prevents double-counting their chains).
+      #
+      # @param node [Prism::DefNode] nested definition node.
+      # @return [void]
+      def visit_def_node(node); end
+
+      private
+
+      # Walks a final call's receiver chain, recording each link so it is not
+      # taken for the final call of a chain of its own, and dropping each link
+      # not in {SKIPPED}.
+      #
+      # @param top [Prism::Node] the chain's final call; responds to `receiver`.
+      # @return [void]
+      def chain(top)
+        link = top.receiver
+        while dotted?(link)
+          @links[link] = true
+          drop(link) unless SKIPPED.include?(link.name)
+          link = link.receiver
+        end
+      end
+
+      # Emits the removal of one link: from the end of its receiver to the end
+      # of its arguments and block, so a chain split across lines keeps the
+      # layout of the lines that remain.
+      #
+      # @param link [Prism::CallNode] the dotted call to drop.
+      # @return [void]
+      def drop(link)
+        @mutations << Mutation.new(
+          start_offset: link.receiver.location.end_offset,
+          end_offset: link.location.end_offset,
+          replacement: "",
+          operator: :chain_link
+        )
+      end
+
+      # Returns whether a node is a call through `.`, `&.` or `::`.
+      #
+      # @param node [Prism::Node, nil] node to inspect.
+      # @return [Boolean] true for a call node with a call operator.
+      def dotted?(node)
+        node.is_a?(Prism::CallNode) && !node.call_operator_loc.nil?
+      end
+    end
+  end
+end

data/lib/mutineer/mutators/negation_removal.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Negation-removal mutator (Tier-2).
+    #
+    # Removes the `!` or `not` of a negation, one mutation per occurrence:
+    # `!x` becomes `x` and `not x` becomes ` x`. The mutant survives when no
+    # test depends on the negated value.
+    class NegationRemoval < Base
+      # Visits call nodes and emits negation-removal mutations.
+      #
+      # @param node [Prism::CallNode] call node to inspect.
+      # @return [void]
+      def visit_call_node(node)
+        emit(node)
+        super # nested negations (!!x) each get their own mutation
+      end
+
+      private
+
+      # Emits a mutation when the node is a prefix `!` or `not`.
+      #
+      # The explicit form `x.!` is skipped: without its message, `x.` does
+      # not parse.
+      #
+      # @param node [Prism::CallNode] call node to inspect.
+      # @return [void]
+      def emit(node)
+        return unless node.name == :! && node.call_operator_loc.nil?
+
+        loc = node.message_loc
+        @mutations << Mutation.new(
+          start_offset: loc.start_offset,
+          end_offset: loc.end_offset,
+          replacement: "",
+          operator: :negation_removal
+        )
+      end
+    end
+  end
+end

data/lib/mutineer/mutators/range_literal.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Range mutator (Tier-2).
+    #
+    # Swaps `..` with `...` and `...` with `..`, one mutation per range. The
+    # `..` -> `...` mutant survives when no test checks the last element.
+    # Flip-flops are FlipFlopNode, not RangeNode, so this mutator skips them.
+    #
+    # Endless ranges (`1..`, `1..nil`) are skipped. `(1..)` and `(1...)` give
+    # the same result for slicing, `include?`, `===`, `size` and patterns, so
+    # the mutant is equivalent and no normal test can kill it.
+    class RangeLiteral < Base
+      # Maps each range operator to its opposite.
+      SWAPS = { ".." => "...", "..." => ".." }.freeze
+
+      # Visits range nodes and emits range mutations.
+      #
+      # @param node [Prism::RangeNode] range node to inspect.
+      # @return [void]
+      def visit_range_node(node)
+        emit(node) unless endless?(node)
+        super # nested ranges ((1..2)...(3..4)) each get their own mutation
+      end
+
+      private
+
+      # Whether the range has no end: `1..` or `1..nil`.
+      #
+      # @param node [Prism::RangeNode] range node to inspect.
+      # @return [Boolean]
+      def endless?(node)
+        node.right.nil? || node.right.is_a?(Prism::NilNode)
+      end
+
+      # Emits the mutation that swaps the range operator.
+      #
+      # @param node [Prism::RangeNode] range node to mutate.
+      # @return [void]
+      def emit(node)
+        loc = node.operator_loc
+        @mutations << Mutation.new(
+          start_offset: loc.start_offset,
+          end_offset: loc.end_offset,
+          replacement: SWAPS.fetch(loc.slice),
+          operator: :range
+        )
+      end
+    end
+  end
+end

data/lib/mutineer/mutators/safe_navigation.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Safe-navigation mutator (Tier-2).
+    #
+    # Replaces `&.` with `.`, one mutation per occurrence. The mutant raises
+    # NoMethodError on a nil receiver, so it survives when no test passes nil.
+    class SafeNavigation < Base
+      # Visits call nodes and emits safe-navigation mutations.
+      #
+      # @param node [Prism::CallNode] call node to inspect.
+      # @return [void]
+      def visit_call_node(node)
+        emit(node)
+        super # chained calls (a&.b&.c) each get their own mutation
+      end
+
+      # Visits `a&.b += 1`, which Prism parses as its own node, not a CallNode.
+      #
+      # @param node [Prism::CallOperatorWriteNode] node to inspect.
+      # @return [void]
+      def visit_call_operator_write_node(node)
+        emit(node)
+        super
+      end
+
+      # Visits `a&.b ||= 1`.
+      #
+      # @param node [Prism::CallOrWriteNode] node to inspect.
+      # @return [void]
+      def visit_call_or_write_node(node)
+        emit(node)
+        super
+      end
+
+      # Visits `a&.b &&= 1`.
+      #
+      # @param node [Prism::CallAndWriteNode] node to inspect.
+      # @return [void]
+      def visit_call_and_write_node(node)
+        emit(node)
+        super
+      end
+
+      # Visits a call used as an assignment target, as in `for a&.b in list`.
+      #
+      # @param node [Prism::CallTargetNode] node to inspect.
+      # @return [void]
+      def visit_call_target_node(node)
+        emit(node)
+        super
+      end
+
+      private
+
+      # Emits a mutation when the node's call operator is `&.`.
+      #
+      # @param node [Prism::Node] a node with `safe_navigation?` and `call_operator_loc`.
+      # @return [void]
+      def emit(node)
+        return unless node.safe_navigation?
+
+        loc = node.call_operator_loc
+        @mutations << Mutation.new(
+          start_offset: loc.start_offset,
+          end_offset: loc.end_offset,
+          replacement: ".",
+          operator: :safe_navigation
+        )
+      end
+    end
+  end
+end

data/lib/mutineer/runner.rb

@@ -434,7 +434,8 @@ module Mutineer
         else
           Isolation.apply_whole_file(mutated, source_file)
         end
-        TestRunners.for(framework).run(abs_tests)
+        # One failing test already kills the mutant, so the child stops there.
+        TestRunners.for(framework).run(abs_tests, stop_at_first_failure: true)
       end
     end
 

data/lib/mutineer/test_runners/minitest.rb

@@ -9,8 +9,12 @@ module Mutineer
       # Runs the given Minitest files.
       #
       # @param test_files [String, Array<String>] one file or many files.
+      # @param stop_at_first_failure [Boolean] when true, the run ends at the
+      #   first failing test.
       # @return [Integer] 0 on success, 1 on failure.
-      def self.run(test_files) = MinitestIntegration.run(test_files)
+      def self.run(test_files, stop_at_first_failure: false)
+        MinitestIntegration.run(test_files, stop_at_first_failure: stop_at_first_failure)
+      end
     end
   end
 end

data/lib/mutineer/test_runners/rspec.rb

@@ -16,24 +16,22 @@ module Mutineer
       # Runs the given RSpec files.
       #
       # @param spec_files [String, Array<String>] one file or many files.
+      # @param stop_at_first_failure [Boolean] when true, the run ends at the
+      #   first failing example (RSpec `--fail-fast`).
       # @return [Integer] 0 on success, 1 on failure.
-      def self.run(spec_files)
+      def self.run(spec_files, stop_at_first_failure: false)
         require_rspec!
 
         ::RSpec::Core::Runner.disable_autorun!
         ::RSpec.reset
 
+        # The sink takes RSpec's own formatter output. Spec output is not
+        # silenced here: the fork boundary that calls this method has already
+        # pointed stdout at File::NULL (see ChildStdout).
         sink = StringIO.new
-        orig_out = $stdout
-        orig_err = $stderr
-        $stdout = sink
-        $stderr = sink
-        begin
-          status = ::RSpec::Core::Runner.run(["--no-color", *Array(spec_files)], sink, sink)
-        ensure
-          $stdout = orig_out
-          $stderr = orig_err
-        end
+        args = ["--no-color"]
+        args << "--fail-fast" if stop_at_first_failure
+        status = ::RSpec::Core::Runner.run([*args, *Array(spec_files)], sink, sink)
 
         status.zero? ? 0 : 1
       end

data/lib/mutineer/test_runners.rb

@@ -6,8 +6,10 @@ require_relative "test_runners/rspec"
 module Mutineer
   # Picks the test-framework runner.
   #
-  # Each runner responds to `.run(files) -> 0/1` (0 = all passed, 1 = any
-  # failure) and is called only inside a forked child.
+  # Each runner responds to `.run(files, stop_at_first_failure: false) -> 0/1`
+  # (0 = all passed, 1 = any failure) and is called only inside a forked child.
+  # Only the mutant path passes `stop_at_first_failure: true`. The fork boundary
+  # silences stdout (see ChildStdout); the runners do not.
   module TestRunners
     # Returns the runner module for a framework name.
     #

data/lib/mutineer/version.rb

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

data/lib/mutineer.rb

@@ -25,6 +25,10 @@ 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/mutators/safe_navigation"
+require_relative "mutineer/mutators/range_literal"
+require_relative "mutineer/mutators/negation_removal"
+require_relative "mutineer/mutators/chain_link"
 require_relative "mutineer/mutator_registry"
 require_relative "mutineer/worker_pool"
 require_relative "mutineer/progress"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mutineer
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.0
 platform: ruby
 authors:
 - David Teren
@@ -9,20 +9,6 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -68,6 +54,7 @@ files:
 - lib/mutineer.rb
 - lib/mutineer/baseline.rb
 - lib/mutineer/changed_lines.rb
+- lib/mutineer/child_stdout.rb
 - lib/mutineer/cli.rb
 - lib/mutineer/config.rb
 - lib/mutineer/coverage_map.rb
@@ -78,6 +65,7 @@ files:
 - lib/mutineer/file_swap.rb
 - lib/mutineer/isolation.rb
 - lib/mutineer/minitest_integration.rb
+- lib/mutineer/minitest_integration/stop_at_first_failure.rb
 - lib/mutineer/mutant_id.rb
 - lib/mutineer/mutation.rb
 - lib/mutineer/mutator_registry.rb
@@ -85,12 +73,16 @@ files:
 - lib/mutineer/mutators/base.rb
 - lib/mutineer/mutators/boolean_connector.rb
 - lib/mutineer/mutators/boolean_literal.rb
+- lib/mutineer/mutators/chain_link.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/negation_removal.rb
+- lib/mutineer/mutators/range_literal.rb
 - lib/mutineer/mutators/regex_literal.rb
 - lib/mutineer/mutators/return_nil.rb
+- lib/mutineer/mutators/safe_navigation.rb
 - lib/mutineer/mutators/statement_removal.rb
 - lib/mutineer/mutators/string_literal.rb
 - lib/mutineer/pairing.rb