saboteur 0.5.0 → 0.7.0

data/lib/saboteur/help.rb

@@ -25,7 +25,10 @@ module Saboteur
       2 => "Usage or configuration error: fix the command or config/saboteur.rb. A replay --id that matches no " \
            "mutant is only found after the target has booted. A named source or test file that does not exist.",
       3 => "Tool error: saboteur could not finish, or more than half of the executed mutants errored (such " \
-           "a run tested almost nothing). With --threshold, also any errored or resource-limited mutant."
+           "a run tested almost nothing). With --threshold, also any errored or resource-limited mutant.",
+      4 => "Time budget spent: --max-duration stopped the run before the next subject, so the score is " \
+           "partial. --max-duration-ok leaves the exit to the plain verdict: 0, 1, or 3 when the budget " \
+           "stopped the run before any mutant was tested."
     }.freeze
 
     DOCTOR_EXIT_CODE_MEANINGS = {
@@ -40,15 +43,20 @@ module Saboteur
         summary: "Mutate your code and report the mutants your tests do not catch",
         description: "Builds a per-test coverage map, makes small changes to your methods, runs only the " \
                      "tests that cover each change, and reports survivors (changes no test noticed). Source files or " \
-                     "directories after run replace include and exclude; --test limits the specs that run; " \
-                     "--threshold PERCENT replaces the survivor check: exit 0 when the score is at or above " \
-                     "PERCENT, exit 1 when it is below. Inline comment syntax: " \
+                     "directories after run replace include and exclude. Without --test, the run infers the " \
+                     "specs named after the mutated files and runs only those; a mutated file with no " \
+                     "conventional spec stops the run with exit 2 before anything boots, and --all keeps " \
+                     "the whole configured suite. --threshold PERCENT replaces the survivor check: exit 0 " \
+                     "when the score is at or above PERCENT, exit 1 when it is below. All operators run " \
+                     "unless you select a smaller set; exclusions always remove operators from that set. " \
+                     "Inline comment syntax: " \
                      '# saboteur:disable-line [operator ...] reason="...". A reason is required.',
         takes_options: true,
         exit_codes: EXIT_CODE_MEANINGS,
         examples: [
-          ["Pull request: only methods changed since the target branch", "saboteur run --since origin/main"],
-          ["Whole project, four workers, repeatable seed", "saboteur run --jobs 4 --seed 42"],
+          ["Pull request: only methods changed since the target branch, with the inferred specs",
+           "saboteur run --since origin/main"],
+          ["Whole project and whole suite, four workers, repeatable seed", "saboteur run --all --jobs 4 --seed 42"],
           ["One class or method", "saboteur run --subject 'Person#adult?'"],
           ["Replay one mutant by the digest printed next to a survivor", "saboteur run --id 1a2b3c4d5e6f7a8b"],
           ["Mutate named files against named specs, skipping the whole-suite coverage run",
@@ -57,6 +65,35 @@ module Saboteur
           ["AI agent: bounded JSON summary and strict exit codes", "saboteur run --agent --since origin/main"]
         ]
       ),
+      Command.new(
+        name: "pr",
+        summary: "Preset: the fast pull-request loop over the lines changed since a ref",
+        description: "Expands to saboteur run --baseline-passes 1 --max-duration 10m --max-duration-ok " \
+                     "--since REF, with REF the first operand (default main): one baseline check, a " \
+                     "ten-minute wall-clock budget, and mutants limited to the changed methods. The " \
+                     "preset opts out of the budget-specific exit 4; the normal and incomplete " \
+                     "verdicts still fail the run (survivors exit 1, a budget stop before any mutant " \
+                     "ran exits 3). Every run option still works; an explicit flag after the preset " \
+                     "wins (#244).",
+        takes_options: true,
+        exit_codes: EXIT_CODE_MEANINGS,
+        examples: [["Changed lines since main", "saboteur pr"],
+                   ["Changed lines since another target", "saboteur pr origin/develop"],
+                   ["The same loop with two baseline checks", "saboteur pr --baseline-passes 2"]]
+      ),
+      Command.new(
+        name: "audit",
+        summary: "Preset: the whole project, all operators, both reports",
+        description: "Expands to saboteur run --all --operators all --baseline-passes 2 " \
+                     "--json .saboteur/audit-report.json --html .saboteur/audit-report.html: every " \
+                     "subject against the whole suite, all operators, both baseline checks, writing " \
+                     "the Stryker JSON and HTML reports. Configured selection limits (since, " \
+                     "subjects, exclude_operators, max_duration) still apply; an explicit flag after " \
+                     "the preset wins (#244), and an explicit --test replaces the injected --all.",
+        takes_options: true,
+        exit_codes: EXIT_CODE_MEANINGS,
+        examples: [["Full project audit with JSON and HTML reports", "saboteur audit"]]
+      ),
       Command.new(
         name: "doctor",
         summary: "Check the environment, and with --suite run the baseline twice, without mutating anything",
@@ -121,7 +158,7 @@ module Saboteur
 
     AGENT_EXIT_CODES = "  With --agent the codes are stricter: 0 only when the run was complete and clean; " \
                        "1 survivors to review;\n  2 usage or config error; 3 incomplete (no coverage, caps, errors, " \
-                       "nothing selected) or tool failure."
+                       "a budget stop before any mutant ran, nothing selected) or tool failure."
 
     FILES = [
       ["config/saboteur.rb", "Settings as Ruby (Saboteur.configure). Command line options override it."],
@@ -165,8 +202,16 @@ module Saboteur
       @commands.select(&:takes_options).map { |command| options_section(command) }
     end
 
+    # run, audit and pr share one exit-code table; the overview keeps every
+    # command's section but carries the agent note only on the first table
+    # that shares it, so the phrase appears exactly once.
     def exit_code_sections
-      @commands.select(&:exit_codes).map { |command| exit_codes_section(command.exit_codes, command.name) }
+      noted = []
+      @commands.select(&:exit_codes).map do |command|
+        first = noted.none? { |codes| codes.equal?(command.exit_codes) }
+        noted << command.exit_codes
+        exit_codes_section(command.exit_codes, command.name, agent_note: first)
+      end
     end
 
     def title
@@ -203,10 +248,10 @@ module Saboteur
       "EXAMPLES\n#{examples.map { |note, line| "  # #{note}\n  #{line}" }.join("\n")}\n"
     end
 
-    def exit_codes_section(codes, command_name = nil)
+    def exit_codes_section(codes, command_name = nil, agent_note: true)
       rows = codes.map { |code, meaning| "  #{code}  #{meaning}" }
       title = command_name ? "EXIT CODES (saboteur #{command_name})" : "EXIT CODES"
-      note = codes.equal?(EXIT_CODE_MEANINGS) ? "#{AGENT_EXIT_CODES}\n" : ""
+      note = agent_note && codes.equal?(EXIT_CODE_MEANINGS) ? "#{AGENT_EXIT_CODES}\n" : ""
       "#{title}\n#{rows.join("\n")}\n#{note}"
     end
 

data/lib/saboteur/ignore_list.rb

@@ -103,7 +103,10 @@ module Saboteur
 
     # Marks matching survivors as ignored. Returns warnings for stale entries:
     # entries whose subject was examined but whose mutation no longer exists.
-    def apply(results)
+    # unscoped_digests (subject id => every digest generated before a diff
+    # scope cut) keeps a scoped run from calling a scoped-out entry stale
+    # (#284).
+    def apply(results, unscoped_digests: nil)
       seen = {}
       results.each do |result|
         key = [result.subject.id, result.digest]
@@ -113,8 +116,15 @@ module Saboteur
         seen[key] = true
         result.ignored = entry.reason if result.survived?
       end
+      stale_warnings(results, seen, unscoped_digests)
+    end
+
+    private
+
+    def stale_warnings(results, seen, unscoped_digests)
       examined = results.to_set { |result| result.subject.id }
       entries.select { |entry| examined.include?(entry.subject) && !seen[[entry.subject, entry.mutation]] }
+             .reject { |entry| unscoped_digests&.fetch(entry.subject, nil)&.include?(entry.mutation) }
              .map { |entry| "stale ignore entry #{entry.subject} #{entry.mutation}: no such mutation" }
     end
   end

data/lib/saboteur/install.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require_relative "text"
 
 module Saboteur
   # Writes the Rails starter files: config/saboteur.rb, bin/saboteur and a
@@ -64,7 +65,7 @@ module Saboteur
     # Printed after install; the Gemfile is never edited.
     def gemfile_hint
       gemfile = File.join(@root, "Gemfile")
-      return nil if File.file?(gemfile) && File.read(gemfile).match?(/^\s*gem\s+["']saboteur["']/)
+      return nil if File.file?(gemfile) && Text.utf8(File.read(gemfile)).match?(/^\s*gem\s+["']saboteur["']/)
 
       GEMFILE_HINT
     end
@@ -108,8 +109,8 @@ module Saboteur
       link = symlink_component(".gitignore")
       return Result.new(:skipped, ".gitignore") if link && !@force
 
-      current = File.file?(path) ? File.read(path) : ""
-      listed = listed?(current)
+      current = File.file?(path) ? Text.utf8_identity(File.read(path)) : ""
+      listed = listed?(Text.utf8(current))
       return Result.new(:unchanged, ".gitignore") if listed && !link
 
       File.delete(link) if link

data/lib/saboteur/integration/base.rb

@@ -10,8 +10,13 @@ module Saboteur
     # so a kill by a failed assertion can be told from a kill by a crash.
     # failure_messages: the first line of each failure, so a verdict that
     # does not hold up can say why the test failed.
-    RunResult = Data.define(:passed, :failed_ids, :executed_ids, :runtime, :failure_classes, :failure_messages) do
-      def initialize(passed:, failed_ids:, executed_ids:, runtime:, failure_classes: {}, failure_messages: {})
+    # failure_details: the full message and first backtrace frames of each
+    # failure, so a neutral re-run (the verdict check) can say exactly why
+    # the killer failed with the method unchanged (#296).
+    RunResult = Data.define(:passed, :failed_ids, :executed_ids, :runtime, :failure_classes, :failure_messages,
+                            :failure_details) do
+      def initialize(passed:, failed_ids:, executed_ids:, runtime:, failure_classes: {}, failure_messages: {},
+                     failure_details: {})
         super
       end
     end

data/lib/saboteur/integration/rspec.rb

@@ -55,7 +55,8 @@ module Saboteur
         passed = execute(listener)
         RunResult.new(passed: passed && listener.failed.empty?, failed_ids: listener.failed,
                       executed_ids: listener.executed, runtime: listener.runtime,
-                      failure_classes: listener.failure_classes, failure_messages: listener.failure_messages)
+                      failure_classes: listener.failure_classes, failure_messages: listener.failure_messages,
+                      failure_details: listener.failure_details)
       end
 
       def run_all(recorder)
@@ -71,7 +72,8 @@ module Saboteur
         passed = execute(listener, log_phase: true)
         RunResult.new(passed: passed && listener.failed.empty?, failed_ids: listener.failed,
                       executed_ids: listener.executed, runtime: listener.runtime,
-                      failure_classes: listener.failure_classes, failure_messages: listener.failure_messages)
+                      failure_classes: listener.failure_classes, failure_messages: listener.failure_messages,
+                      failure_details: listener.failure_details)
       end
 
       private
@@ -185,8 +187,10 @@ module Saboteur
         EVENTS = %i[example_started example_finished example_failed].freeze
 
         MESSAGE_LIMIT = 200
+        DETAIL_LIMIT = 2_000
+        BACKTRACE_LIMIT = 5
 
-        attr_reader :executed, :failed, :failure_classes, :failure_messages
+        attr_reader :executed, :failed, :failure_classes, :failure_messages, :failure_details
         attr_accessor :runtime
 
         def initialize(recorder = nil)
@@ -195,6 +199,7 @@ module Saboteur
           @failed = []
           @failure_classes = {}
           @failure_messages = {}
+          @failure_details = {}
           @runtime = 0.0
         end
 
@@ -213,12 +218,43 @@ module Saboteur
           exception = notification.example.execution_result.exception
           @failure_classes[notification.example.id] = exception&.class&.name
           @failure_messages[notification.example.id] = first_line(exception&.message)
+          @failure_details[notification.example.id] = detail_for(exception)
         end
 
         private
 
+        # The full failure, class and first frames: a neutral re-run that
+        # fails needs enough context to explain why (the compact first line
+        # alone reads as just "expected: 0").
+        def detail_for(exception)
+          return nil unless exception
+
+          message = Text.utf8("#{exception.class.name}: #{exception.message}")
+          ([message] + relevant_frames(exception)).join("\n")[0, DETAIL_LIMIT]
+        rescue StandardError
+          exception.message.to_s.dump[0, DETAIL_LIMIT]
+        end
+
+        # An expectation failure leads with rspec's own frames (notify_failure,
+        # handle_failure); under the cap they would crowd out the spec line.
+        # Keep the project frames; fall back to the raw ones when rspec itself
+        # raised, so the detail never comes back empty.
+        def relevant_frames(exception)
+          frames = Array(exception.backtrace).map { |frame| Text.utf8(frame.to_s) }
+          project = frames.reject { |frame| frame.include?("/gems/rspec") }
+          (project.empty? ? frames : project).first(BACKTRACE_LIMIT)
+        end
+
         def first_line(message)
-          message.to_s.lines.map(&:strip).find { |line| !line.empty? }.to_s[0, MESSAGE_LIMIT]
+          # Exception messages can carry bytes invalid under the locale encoding
+          # (e.g. a path with raw bytes); scrub before splitting, or .lines/.strip
+          # raises Encoding::CompatibilityError and the run reports error (CI #272).
+          Text.utf8(message.to_s).lines.map(&:strip).find { |line| !line.empty? }.to_s[0, MESSAGE_LIMIT]
+        rescue StandardError
+          # Text.utf8 is mutable code: when the mutant under test breaks it,
+          # the raise must not flip the run to error - the recorded failure
+          # is what classifies the kill. dump is ASCII-safe for any bytes.
+          message.to_s.dump[0, MESSAGE_LIMIT]
         end
       end
     end

data/lib/saboteur/mutation_source/builtin.rb

@@ -13,6 +13,9 @@ require_relative "operator_registry"
 require_relative "range_replacement"
 require_relative "operator_assignment"
 require_relative "condition_negation"
+require_relative "method_swap"
+require_relative "operand_replacement"
+require_relative "interpolation_removal"
 
 module Saboteur
   module MutationSource
@@ -53,9 +56,9 @@ module Saboteur
       CATCH_ALL = %w[StandardError ::StandardError Exception ::Exception].freeze
       SCOPE_NODES = [Prism::DefNode, Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode].freeze
 
-      def initialize(arid: DEFAULT_ARID, operators: [])
+      def initialize(arid: DEFAULT_ARID, operators: [], exclude_operators: [])
         super()
-        @operators = OperatorRegistry.resolve(operators)
+        @operators = OperatorRegistry.select(operators, exclude_operators)
         @arid = arid.map { |pattern| pattern.is_a?(Regexp) ? pattern : Regexp.new(pattern) }
         @filter_replacement = FilterReplacement.new(arid: arid)
         @literal_replacement = LiteralReplacement.new(arid: arid)
@@ -66,6 +69,9 @@ module Saboteur
         @range_replacement = RangeReplacement.new(arid: arid)
         @operator_assignment = OperatorAssignment.new(arid: arid)
         @condition_negation = ConditionNegation.new(arid: arid)
+        @method_swap = MethodSwap.new(arid: arid)
+        @operand_replacement = OperandReplacement.new(arid: arid)
+        @interpolation_removal = InterpolationRemoval.new(arid: arid)
       end
 
       def name
@@ -78,20 +84,20 @@ module Saboteur
         @found = []
         coarse(body)
         visit(body)
-        @found.concat(@filter_replacement.mutations_for(subject))
-        @found.concat(@literal_replacement.mutations_for(subject))
-        @found.concat(@argument_removal.mutations_for(subject))
-        @found.concat(@pair_removal.mutations_for(subject))
-        @found.concat(@chain_removal.mutations_for(subject))
-        @found.concat(@endpoint_replacement.mutations_for(subject))
-        @found.concat(@range_replacement.mutations_for(subject))
-        @found.concat(@operator_assignment.mutations_for(subject))
-        @found.concat(@condition_negation.mutations_for(subject))
+        @found.concat(delegated.flat_map { |source| source.mutations_for(subject) })
         @found.select { |mutation| @operators.include?(mutation.operator) }
       ensure
         @subject = nil
       end
 
+      # The single-purpose sources run after the shared walk, in registration
+      # order; each filters its own operator through the same policy below.
+      def delegated
+        [@filter_replacement, @literal_replacement, @argument_removal, @pair_removal, @chain_removal,
+         @endpoint_replacement, @range_replacement, @operator_assignment, @condition_negation,
+         @method_swap, @operand_replacement, @interpolation_removal]
+      end
+
       private
 
       # --- coarse ---------------------------------------------------------
@@ -185,9 +191,12 @@ module Saboteur
         add("safe_navigation", node.call_operator_loc, ".") if node.safe_navigation?
       end
 
+      # Only the infix spelling is binary: an operator call has no call
+      # operator, and its receiver, message, single argument and lack of a
+      # block all follow from that (a block binds to the last operand's own
+      # call, never to the operator).
       def binary?(node)
-        node.receiver && node.message_loc && node.call_operator_loc.nil? &&
-          node.arguments&.arguments&.size == 1 && node.block.nil?
+        node.call_operator_loc.nil?
       end
 
       def numeric_operands?(node)

data/lib/saboteur/mutation_source/hazard_guard.rb

@@ -31,6 +31,7 @@ module Saboteur
       ].freeze
 
       OPEN3 = /\A(::)?Open3\z/
+      SEND_NAMES = %w[send public_send __send__].freeze
       ALWAYS_NAMES = %w[rmtree].freeze
       KERNEL_RECEIVERS = %w[Kernel Process].freeze
 
@@ -81,6 +82,19 @@ module Saboteur
         name = node.name.to_s
         receiver = node.receiver&.slice&.sub(/\A::/, "")
         return true if OPEN3.match?(receiver.to_s)
+
+        args = node.arguments&.arguments || []
+        # obj.send(:rmtree, x) is obj.rmtree(x) with indirection (#240): the
+        # resolved selector faces the same direct-call semantics, with the
+        # arguments shifted past it (#294 review). A dynamic selector stays
+        # out of scope, as documented.
+        return true if SEND_NAMES.include?(name) && (selector = literal_selector(args.first)) &&
+                       direct_hazard?(selector, receiver, args[1])
+
+        direct_hazard?(name, receiver, args.first)
+      end
+
+      def direct_hazard?(name, receiver, first_arg)
         return true if ALWAYS_NAMES.include?(name)
 
         tag = receiver ? "#{receiver}.#{name}" : name
@@ -89,14 +103,18 @@ module Saboteur
         # spelling of a bare process spawn is the same hazard.
         return true if KERNEL_RECEIVERS.include?(receiver) && @tags.include?(name)
 
-        piped_open?(node, name, receiver)
+        piped_open?(first_arg, name, receiver)
+      end
+
+      # A literal symbol or string selector names the real call.
+      def literal_selector(first)
+        first.unescaped if first.is_a?(Prism::SymbolNode) || first.is_a?(Prism::StringNode)
       end
 
       # Kernel#open with a "| command" argument spawns a process.
-      def piped_open?(node, name, receiver)
+      def piped_open?(first, name, receiver)
         return false unless name == "open" && (receiver.nil? || receiver == "Kernel")
 
-        first = node.arguments&.arguments&.first
         case first
         when Prism::StringNode then first.unescaped.start_with?("|")
         when Prism::InterpolatedStringNode

data/lib/saboteur/mutation_source/interpolation_removal.rb

@@ -0,0 +1,41 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require "prism"
+require_relative "base"
+require_relative "operator_visit"
+
+module Saboteur
+  module MutationSource
+    # Removes one piece of an interpolated string at a time: each #{expr}
+    # and each literal segment. Plain strings stay with literal_replacement
+    # and backticks stay untouched (the hazard guard owns those).
+    class InterpolationRemoval < Base
+      include OperatorVisit
+
+      # Base inherits Object's empty initializer; there is no parent state to set.
+      def initialize(arid: []) # rubocop:disable Lint/MissingSuper
+        @arid = arid.map { |pattern| Regexp.new(pattern) }
+      end
+
+      def name
+        "interpolation_removal"
+      end
+
+      private
+
+      def mutate_node(node, subject, found)
+        remove_parts(node, subject, found) if node.is_a?(Prism::InterpolatedStringNode)
+      end
+
+      def remove_parts(node, subject, found)
+        node.parts.each do |part|
+          location = part.location
+          edit = Edit.new(file: subject.file, start_byte: location.start_offset,
+                          end_byte: location.end_offset, replacement: "")
+          found << Mutation.new(subject_id: subject.id, operator: name, edits: [edit], source: name)
+        end
+      end
+    end
+  end
+end

data/lib/saboteur/mutation_source/method_swap.rb

@@ -0,0 +1,45 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require "prism"
+require_relative "base"
+require_relative "operator_visit"
+
+module Saboteur
+  module MutationSource
+    # Swaps a method whose name has a semantic opposite: min with max,
+    # any? with all?, map with each. Only message bytes change; receiver,
+    # arguments and block stay intact. A receiver is required, so a bare
+    # max(a, b) Kernel call is left alone.
+    class MethodSwap < Base
+      include OperatorVisit
+
+      SWAPS = { min: "max", max: "min", any?: "all?", all?: "any?", map: "each", each: "map" }.freeze
+
+      # Base inherits Object's empty initializer; there is no parent state to set.
+      def initialize(arid: []) # rubocop:disable Lint/MissingSuper
+        @arid = arid.map { |pattern| Regexp.new(pattern) }
+      end
+
+      def name
+        "method_swap"
+      end
+
+      private
+
+      def mutate_node(node, subject, found)
+        swap(node, subject, found) if node.is_a?(Prism::CallNode)
+      end
+
+      def swap(node, subject, found)
+        replacement = SWAPS[node.name]
+        return unless replacement && node.receiver
+
+        location = node.message_loc
+        edit = Edit.new(file: subject.file, start_byte: location.start_offset,
+                        end_byte: location.end_offset, replacement: replacement)
+        found << Mutation.new(subject_id: subject.id, operator: name, edits: [edit], source: name)
+      end
+    end
+  end
+end

data/lib/saboteur/mutation_source/mutation.rb

@@ -15,13 +15,15 @@ module Saboteur
       end
 
       # Stable id for the ignore list. Offsets are made relative to subject_start
-      # so edits elsewhere in the file do not change the id.
+      # so edits elsewhere in the file do not change the id. The digest hashes
+      # bytes, not encodings: a binary-read source and a UTF-8 replacement hold
+      # the same identity, and joining them without .b raises under LANG=C.
       def digest(subject_start:, original_source:)
         parts = edits.map do |edit|
           original = original_source.byteslice(edit.start_byte, edit.end_byte - edit.start_byte)
-          [edit.start_byte - subject_start, original, edit.replacement].join("\0")
+          [edit.start_byte - subject_start, original.to_s.b, edit.replacement.b].join("\0".b)
         end
-        Digest::SHA256.hexdigest([subject_id, operator, *parts].join("\x1F"))[0, 16]
+        Digest::SHA256.hexdigest([subject_id.to_s.b, operator.to_s.b, *parts].join("\x1F".b))[0, 16]
       end
     end
   end

data/lib/saboteur/mutation_source/operand_replacement.rb

@@ -0,0 +1,54 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require "prism"
+require_relative "base"
+require_relative "operator_visit"
+
+module Saboteur
+  module MutationSource
+    # Replaces a binary operation with each of its operands: a + b yields a
+    # and b. Arithmetic and comparison calls only; boolean connectors stay
+    # with boolean_logic, which already replaces a connector with each side.
+    # An operand binds at least as tightly as the operation it replaces, so
+    # it needs no parentheses (the re-parse check backs this).
+    class OperandReplacement < Base
+      include OperatorVisit
+
+      FAMILIES = %i[+ - * / % ** < <= > >= == !=].freeze
+
+      # Base inherits Object's empty initializer; there is no parent state to set.
+      def initialize(arid: []) # rubocop:disable Lint/MissingSuper
+        @arid = arid.map { |pattern| Regexp.new(pattern) }
+      end
+
+      def name
+        "operand_replacement"
+      end
+
+      private
+
+      def mutate_node(node, subject, found)
+        replace_operands(node, subject, found) if node.is_a?(Prism::CallNode)
+      end
+
+      def replace_operands(node, subject, found)
+        return unless FAMILIES.include?(node.name) && binary?(node)
+
+        [node.receiver, *node.arguments.arguments].each do |operand|
+          edit = Edit.new(file: subject.file, start_byte: node.start_offset,
+                          end_byte: node.end_offset, replacement: operand.slice)
+          found << Mutation.new(subject_id: subject.id, operator: name, edits: [edit], source: name)
+        end
+      end
+
+      # Only the infix spelling is binary: an operator call has no call
+      # operator, and its receiver, message, single argument and lack of a
+      # block all follow from that (a block binds to the last operand's own
+      # call, never to the operator).
+      def binary?(node)
+        node.call_operator_loc.nil?
+      end
+    end
+  end
+end

data/lib/saboteur/mutation_source/operator_examples.rb

@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+module Saboteur
+  module MutationSource
+    module OperatorExamples
+      EXAMPLES = {
+        "body_nil" => "def value = 1 -> def value = nil",
+        "body_true" => "def ok? = false -> def ok? = true",
+        "body_false" => "def ok? = true -> def ok? = false",
+        "body_raise" => "def value = 1 -> def value; raise; end",
+        "comparison" => "a < b -> a <= b",
+        "arithmetic" => "a + b -> a - b",
+        "boolean_logic" => "a && b -> a",
+        "condition_true" => "if x -> if true",
+        "condition_false" => "if x -> if false",
+        "negation_removal" => "!x -> x",
+        "literal_number" => "1 -> 0",
+        "or_assign" => "x ||= 1 -> x = 1",
+        "safe_navigation" => "x&.name -> x.name",
+        "statement_removal" => "check; value -> nil; value",
+        "filter_replacement" => "xs.select { |x| x } -> xs.reject { |x| x }",
+        "literal_string" => "\"hello\" -> \"\"",
+        "literal_boolean" => "true -> false",
+        "argument_removal" => "send(a, b) -> send(a)",
+        "pair_removal" => "{a: 1, b: 2} -> {b: 2}",
+        "endpoint_replacement" => "xs.first -> xs.last",
+        "chain_removal" => "x.first.to_s -> x.to_s",
+        "range" => "1..3 -> 1...3",
+        "operator_assignment" => "x += 1 -> x -= 1",
+        "condition_negation" => "x ? a : b -> !(x) ? a : b",
+        "method_swap" => "xs.min -> xs.max",
+        "operand_replacement" => "a + b -> a",
+        "interpolation_removal" => "\"hi \#{name}\" -> \"hi \""
+      }.freeze
+    end
+  end
+end