mutineer-mongoid 2.0.0

data/lib/mutineer/minitest_integration.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require_relative "minitest_integration/stop_at_first_failure"
+require_relative "minitest_integration/kill_recorder"
+
+module Mutineer
+  # Child-process-only: loads a test file in the current process and runs it
+  # programmatically, returning an exit status integer (0 = all passed,
+  # 1 = any failure/error).
+  #
+  # Never call this in the parent — it manipulates global Minitest state
+  # (autorun, runnables) that only makes sense in a throwaway forked child.
+  #
+  # A missing minitest is rescued as FrameworkUnavailable (Isolation.run
+  # still turns that raise into exit 2). There is no rescue around the
+  # suite run itself: Isolation.run's fork block is the single exception
+  # 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 mutant run (one that stops at the first failure, or a
+    # `--matrix` run that records every test), 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. A matrix run uses the same
+    # order, so its first failure comes at the same point as the stop's.
+    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.
+    #
+    # `test_files` is one path or an Array of paths (coverage selection
+    # passes the covering subset); each is loaded before the single
+    # 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.
+    # @param record_to [IO, nil] a `--matrix` run: send each test's outcome to
+    #   this channel (see {KillRecorder}) and run every test.
+    # @return [Integer] 0 on success, 1 on failure.
+    # @raise [ArgumentError] when both options are given: a matrix run never stops.
+    def self.run(test_files, stop_at_first_failure: false, record_to: nil)
+      if stop_at_first_failure && record_to
+        raise ArgumentError, "stop_at_first_failure and record_to cannot be combined: a matrix run runs every test"
+      end
+
+      begin
+        require "minitest"
+      rescue LoadError
+        raise Mutineer::FrameworkUnavailable,
+              "minitest is not available — add minitest to the project under test, " \
+              "or use --framework rspec"
+      end
+
+      # minitest is required LAZILY (never at load time) so Mutineer keeps
+      # zero runtime gem deps and loads fine in an rspec-only project; a missing
+      # minitest raises a clear Mutineer error rather than a LoadError backtrace.
+
+      # Neutralise autorun so a test file's `require "minitest/autorun"`
+      # registers no at_exit hook.
+      def Minitest.autorun; end # rubocop:disable Lint/NestedMethodDefinition
+
+      # Drop runnables inherited from the parent suite (this is the child's
+      # private copy — the parent is unaffected) so only the target test runs.
+      Minitest::Runnable.reset
+      # Each test class's file position: the file that first defined it.
+      rank = {}
+      Array(test_files).each_with_index do |f, i|
+        load f
+        Minitest::Runnable.runnables.each { |klass| rank[klass] ||= i }
+      end
+
+      armed =
+        if record_to
+          KillRecorder.arm!(record_to, Minitest::Runnable.runnables)
+        elsif stop_at_first_failure
+          StopAtFirstFailure.arm!(Minitest::Runnable.runnables)
+        end
+      # Pin the seed only when a hook is armed; an unknown Minitest shape gets
+      # the normal full, randomly ordered run.
+      args = armed && !ENV["SEED"] ? ["--seed", STOP_AT_FIRST_FAILURE_SEED.to_s] : []
+      keep_file_order(rank) if armed
+      # No silencing here: the fork boundary that calls this method has already
+      # pointed stdout at File::NULL (see ChildStdout).
+      passed = Minitest.run(args)
+      # Reached only when the suite returned: a test that exits the process
+      # skips it, and the parent then keeps the row incomplete.
+      KillRecorder.finish! if record_to
+
+      # A plugin can replace the summary reporter, so a stop decides by itself.
+      passed && !StopAtFirstFailure.stopped_here? ? 0 : 1
+    ensure
+      StopAtFirstFailure.disarm!
+      KillRecorder.disarm!
+    end
+
+    # Runs the test classes in the order of their files (#203). Minitest
+    # shuffles the classes with the seed, then runs the serial classes before
+    # the parallel (`parallelize_me!`) ones. A stable sort by file position
+    # after that shuffle puts the files in the given order and keeps the
+    # seeded order within one file. The serial-then-parallel split is
+    # unchanged. Only the child's own class list gets {FileOrder}.
+    #
+    # @api private
+    # @param rank [Hash{Class => Integer}] each class's file position.
+    # @return [void]
+    def self.keep_file_order(rank)
+      FileOrder.rank = rank
+      ::Minitest::Runnable.runnables.extend(FileOrder)
+    end
+
+    # Extends the list of test classes: its `shuffle` keeps the file order.
+    module FileOrder
+      class << self
+        # Each test class's file position.
+        #
+        # @return [Hash{Class => Integer}, nil]
+        attr_accessor :rank
+      end
+
+      # The seeded shuffle, then a stable sort by file position.
+      #
+      # @return [Array<Class>]
+      def shuffle(...)
+        rank = FileOrder.rank || {}
+        super.sort_by.with_index { |klass, i| [rank.fetch(klass, rank.size), i] }
+      end
+
+      # Minitest 5.15 and older drop empty classes before the shuffle, so the
+      # filtered list keeps the file order too.
+      #
+      # @return [Array<Class>]
+      def reject(...)
+        super.extend(FileOrder)
+      end
+    end
+  end
+end

data/lib/mutineer/mongoid_failures.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "test_runners/rspec"
+
+module Mutineer
+  # Separates MongoDB infrastructure failures from assertions that kill mutants.
+  # Loaded only in daemon children. Duplicate-key and other application errors
+  # still kill mutants; connection failures and server failovers do not.
+  module MongoidFailures
+    # Driver errors describing unavailable connections or authentication.
+    CONNECTION_ERRORS = %w[
+      Mongo::Error::SocketError Mongo::Error::SocketTimeoutError
+      Mongo::Error::NoServerAvailable Mongo::Error::ConnectionCheckOutTimeout
+      Mongo::Error::ConnectionUnavailable Mongo::Error::ConnectionPerished
+      Mongo::Error::PoolError Mongo::Error::TimeoutError
+      Mongo::Error::NoServiceConnectionAvailable Mongo::Error::MissingConnection
+      Mongo::Error::ClientClosed Mongo::Error::AuthError
+    ].freeze
+    # Retryable server/network failures; excludes duplicate-key and validation codes.
+    SERVER_CODES = [6, 7, 89, 91, 189, 10107, 11600, 11602, 13435, 13436].freeze
+
+    # Observe both examples and suite hooks before RSpec flattens their failures.
+    # @param tests [Array<String>] covering spec files.
+    # @return [Integer] 0 survived, 1 assertion/application failure, 2 infrastructure.
+    def self.run(tests)
+      require "rspec/core"
+      ::RSpec::Core::Reporter.prepend(Reporter) unless ::RSpec::Core::Reporter < Reporter
+      @failure = nil
+      status = TestRunners::RSpec.run(tests)
+      if @failure
+        warn "[mutineer] MongoDB infrastructure failure: #{@failure.class}"
+        2
+      else
+        status
+      end
+    end
+
+    # Inspect aggregate failures and exception causes without looping on a cycle.
+    # @param exception [Exception, nil] failure reported by RSpec.
+    # @return [void]
+    def self.record(exception)
+      pending = [exception].compact
+      seen = {}
+      until pending.empty?
+        error = pending.pop
+        next if seen[error.object_id]
+
+        seen[error.object_id] = true
+        @failure = error if infrastructure_error?(error)
+        pending << error.cause if error.cause
+        pending.concat(error.all_exceptions) if error.respond_to?(:all_exceptions)
+      end
+    end
+
+    # Match actual driver classes, including subclasses, without requiring Mongo.
+    # @param error [Exception] reported exception.
+    # @return [Boolean]
+    def self.infrastructure_error?(error)
+      names = error.class.ancestors.map(&:name)
+      CONNECTION_ERRORS.any? { |name| names.include?(name) } ||
+        (names.include?("Mongo::Error::OperationFailure") && SERVER_CODES.include?(error.code))
+    end
+
+    # RSpec reports suite-hook exceptions separately from failed examples.
+    module Reporter
+      # @param example [RSpec::Core::Example] failed example.
+      # @return [Object] RSpec's notification result.
+      def example_failed(example)
+        MongoidFailures.record(example.exception)
+        super
+      end
+
+      # @param exception [Exception] exception raised outside an example.
+      # @param context_description [String] RSpec's hook description.
+      # @return [Object] RSpec's notification result.
+      def notify_non_example_exception(exception, context_description)
+        MongoidFailures.record(exception)
+        super
+      end
+    end
+  end
+end

data/lib/mutineer/mongoid_worker_db.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "digest"
+
+module Mutineer
+  # Isolates Mongoid test runs in disposable databases, one per fork. Uses only
+  # the application's Mongoid and driver; neither is a runtime gem dependency.
+  # The boot-time snapshot includes documents and indexes. Every child starts
+  # from that snapshot, including after a killed or timed-out mutant.
+  class MongoidWorkerDb
+    # True only when the application has already loaded Mongoid.
+    # @return [Boolean]
+    def self.available?
+      defined?(Mongoid::Clients) ? true : false
+    end
+
+    # Capture the test database without writing to it. Multiple clients and
+    # mixed ActiveRecord/Mongoid applications fail before any suite can run.
+    # @raise [RuntimeError] for an unsupported or non-test configuration.
+    def initialize
+      raise "Mongoid worker databases require RAILS_ENV=test" unless ENV["RAILS_ENV"] == "test"
+      unless Mongoid.clients.keys.map(&:to_s) == ["default"]
+        raise "Mongoid worker databases support one default client only"
+      end
+      if defined?(ActiveRecord::Base)
+        raise "Mongoid worker databases do not support mixed ActiveRecord/Mongoid applications"
+      end
+
+      @client = Mongoid.default_client
+      source = Digest::SHA256.hexdigest(@client.database.name)[0, 8]
+      @prefix = "mutineer_#{source}_#{SecureRandom.hex(8)}_"
+      @snapshot = @client.database.list_collections.map do |info|
+        options = info.fetch("options", {})
+        if info["type"] != "collection" || options.key?("timeseries")
+          raise "Mongoid worker databases support ordinary collections only (#{info['name']})"
+        end
+
+        collection = @client[info.fetch("name")]
+        indexes = collection.indexes.to_a.reject { |index| index["name"] == "_id_" }
+        [collection.name, options, collection.find.to_a, indexes]
+      end
+      before_fork
+    end
+
+    # Seed documents, indexes and collection options all affect coverage.
+    # @return [String] opaque digest; no database contents are persisted in the cache.
+    def coverage_cache_key
+      Digest::SHA256.hexdigest(Marshal.dump(@snapshot))
+    end
+
+    # Close parent sockets before a fork, as required by the Mongoid driver.
+    # @return [void]
+    def before_fork
+      Mongoid.disconnect_clients
+    end
+
+    # Route the child before any specs load; failures become infrastructure
+    # errors rather than mutation kills. A fresh database needs no schema.rb.
+    # @param worker [Integer] worker slot (unused: process ids isolate children).
+    # @param schema_path [String, nil] ActiveRecord compatibility argument.
+    # @param seed [Boolean] ActiveRecord compatibility argument; always seeds.
+    # @return [void]
+    def after_fork(worker = 0, schema_path = nil, seed: true)
+      Mongoid.reconnect_clients
+      client = @client.use(database_name(Process.pid))
+      client.database.command(ping: 1)
+      Mongoid::Clients.set(:default, client)
+      Mongoid.override_database(client.database.name)
+      @snapshot.each do |name, options, documents, indexes|
+        client[name].create(**options.transform_keys(&:to_sym))
+        client[name].insert_many(documents) unless documents.empty?
+        indexes.each do |index|
+          attributes = index.reject { |key, _| %w[key v ns].include?(key) }.transform_keys(&:to_sym)
+          client[name].indexes.create_one(index.fetch("key"), **attributes)
+        end
+      end
+    end
+
+    # Parent-side cleanup runs after the child is reaped, even on timeout.
+    # Only this instance's random database prefix can be targeted.
+    # @param pid [Integer] the reaped child's process id.
+    # @return [void]
+    def cleanup(pid)
+      @client.use(database_name(pid)).database.drop
+    ensure
+      before_fork
+    end
+
+    # Exact disposable name for one child. Never accepts a database name.
+    # @param pid [Integer] child process id.
+    # @return [String]
+    def database_name(pid)
+      "#{@prefix}#{Integer(pid)}"
+    end
+  end
+end

data/lib/mutineer/mutant_id.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Mutineer
+  # Content-based id for a mutant — NOT byte offsets. Pure function, reused
+  # by the Runner (matching the ignore list), the Reporter (emitting a copy-
+  # pasteable id per survivor), and #13 baseline gating (diffing id-sets run to
+  # run). `digest` is stdlib, so zero new deps.
+  #
+  # Offset-free by design: keyed on the subject's project-relative file path +
+  # qualified_name (a method, not a byte position) + operator + the normalized
+  # mutated token + an occurrence ordinal among same-(operator, token) twins
+  # WITHIN the subject + (only when positive) the subject's ordinal among
+  # same-named subjects in its file. Unrelated edits that only shift byte offsets
+  # can preserve the id. File moves, renames, project-root changes, and changes to
+  # repeated-name or repeated-mutation order can change it.
+  module MutantId
+    module_function
+
+    # Computes the stable id for a single mutant.
+    #
+    # NUL-joined so token delimiters (`||=`, spaces, `::`, `#`) can never collide
+    # with the separator; `SHA256[0,12]` gives a fixed-length, copy-pasteable key.
+    # The file path is part of the key, so the same qualified name in two files
+    # (an owner-less `def`, or a class reopened elsewhere) cannot collide. `path`
+    # is required so no caller can get the colliding legacy id by accident.
+    #
+    # @param subject [Mutineer::Subject] the subject (method) the mutant lives in;
+    #   its `qualified_name` anchors the id to a method rather than a byte position.
+    # @param mutation [Mutineer::Mutation] the atomic edit whose operator is hashed.
+    # @param source [String] the full, unmutated source the mutation indexes into.
+    # @param occurrence [Integer] 0-based ordinal among twins sharing the same
+    #   (operator, token) within the subject, disambiguating otherwise-identical mutants.
+    # @param path [String] the subject's file, normalized with {ProjectPath.relative}
+    #   against the project root (an absolute real path when outside the root).
+    # @param subject_ordinal [Integer] 0-based ordinal among subjects in the same
+    #   file sharing this qualified name (two owner-less `def index` in two DSL
+    #   blocks). Hashed only when positive, so a subject whose name is unique in
+    #   its file keeps the id it had without it.
+    # @return [String] a 12-character hex id, stable while its keyed identity and
+    #   occurrence order stay unchanged.
+    def for(subject, mutation, source, occurrence = 0, path:, subject_ordinal: 0)
+      parts = [path, subject.qualified_name, mutation.operator, normalized_token(mutation, source), occurrence]
+      parts << subject_ordinal if subject_ordinal.positive?
+      digest(parts)
+    end
+
+    # Computes ids for a subject's full mutation list, in input order, assigning
+    # each its 0-based occurrence among twins sharing the same (operator, token).
+    # This is what disambiguates `a + b + c`'s two `+` mutants without an offset.
+    #
+    # @param subject [Mutineer::Subject] the subject the mutations belong to.
+    # @param source [String] the full, unmutated source for token normalization.
+    # @param mutations [Array<Mutineer::Mutation>] the subject's mutations, in order.
+    # @param path [String] the subject's normalized file path (see {.for}).
+    # @param subject_ordinal [Integer] the subject's ordinal among same-named
+    #   subjects in its file (see {.for}).
+    # @return [Array<String>] one 12-character id per mutation, positionally aligned.
+    def for_subject(subject, source, mutations, path:, subject_ordinal: 0)
+      with_occurrences(mutations, source) do |m, occ|
+        self.for(subject, m, source, occ, path: path, subject_ordinal: subject_ordinal)
+      end
+    end
+
+    # The pre-1.3 id: the {.for} formula without the path, so it collides across
+    # files. Kept only to match ignore entries and baselines stored in the old
+    # format; retained for migration compatibility.
+    #
+    # @param subject [Mutineer::Subject] the subject (method) the mutant lives in.
+    # @param mutation [Mutineer::Mutation] the atomic edit whose operator is hashed.
+    # @param source [String] the full, unmutated source the mutation indexes into.
+    # @param occurrence [Integer] 0-based ordinal among same-(operator, token) twins.
+    # @return [String] a 12-character hex id in the old format.
+    def legacy_for(subject, mutation, source, occurrence = 0)
+      digest([subject.qualified_name, mutation.operator,
+              normalized_token(mutation, source), occurrence])
+    end
+
+    # {.for_subject} for the pre-1.3 id format (see {.legacy_for}).
+    #
+    # @param subject [Mutineer::Subject] the subject the mutations belong to.
+    # @param source [String] the full, unmutated source for token normalization.
+    # @param mutations [Array<Mutineer::Mutation>] the subject's mutations, in order.
+    # @return [Array<String>] one old-format id per mutation, positionally aligned.
+    def legacy_for_subject(subject, source, mutations)
+      with_occurrences(mutations, source) { |m, occ| legacy_for(subject, m, source, occ) }
+    end
+
+    # Maps each mutation to the block's result, passing its 0-based occurrence
+    # among earlier mutations with the same (operator, token).
+    #
+    # @param mutations [Array<Mutineer::Mutation>] the subject's mutations, in order.
+    # @param source [String] the full, unmutated source for token normalization.
+    # @yieldparam mutation [Mutineer::Mutation] the current mutation.
+    # @yieldparam occurrence [Integer] its ordinal among same-(operator, token) twins.
+    # @return [Array] the block's results, positionally aligned.
+    def with_occurrences(mutations, source)
+      seen = Hash.new(0)
+      mutations.map do |m|
+        key = [m.operator, normalized_token(m, source)]
+        occ = seen[key]
+        seen[key] += 1
+        yield m, occ
+      end
+    end
+
+    # NUL-joins the id parts and returns the first 12 hex chars of their SHA256.
+    #
+    # @param parts [Array] the values that make up the id.
+    # @return [String] a 12-character hex id.
+    def digest(parts)
+      Digest::SHA256.hexdigest(parts.join("\x00"))[0, 12]
+    end
+
+    # Extracts the exact code being mutated, whitespace-collapsed — the same
+    # normalization the Reporter's `diff_for` uses for its token label.
+    #
+    # @param mutation [Mutineer::Mutation] supplies the byte range to slice.
+    # @param source [String] the source to byteslice (byte offsets, never char).
+    # @return [String] the mutated token with runs of whitespace collapsed to one space.
+    def normalized_token(mutation, source)
+      source.byteslice(mutation.start_offset...mutation.end_offset).gsub(/\s+/, " ").strip
+    end
+  end
+end

data/lib/mutineer/mutation.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "parser"
+
+module Mutineer
+  # One atomic byte-range edit.
+  #
+  # Immutable. One mutation per mutant — never combine. Source is mutated
+  # textually, never regenerated from the AST.
+  Mutation = Data.define(:start_offset, :end_offset, :replacement, :operator) do
+    # Applies the mutation to source text.
+    #
+    # @param source [String] original source text.
+    # @return [String] mutated source text.
+    def apply(source)
+      source.byteslice(0, start_offset) + replacement + source.byteslice(end_offset..)
+    end
+
+    # Checks whether the mutated source still parses cleanly.
+    #
+    # @param source [String] original source text.
+    # @return [Boolean] true when the mutated source re-parses without errors.
+    def valid?(source)
+      Parser.parse_string(apply(source)).errors.empty?
+    end
+  end
+end

data/lib/mutineer/mutator_registry.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative "mutators/arithmetic"
+require_relative "mutators/comparison"
+require_relative "mutators/boolean_connector"
+require_relative "mutators/boolean_literal"
+require_relative "mutators/statement_removal"
+require_relative "mutators/return_nil"
+require_relative "mutators/literal_mutation"
+require_relative "mutators/condition_negation"
+require_relative "mutators/string_literal"
+require_relative "mutators/regex_literal"
+require_relative "mutators/collection_method"
+require_relative "mutators/safe_navigation"
+require_relative "mutators/range_literal"
+require_relative "mutators/negation_removal"
+require_relative "mutators/chain_link"
+require_relative "mutators/operand_removal"
+require_relative "mutators/array_literal"
+require_relative "mutators/condition_forcing"
+require_relative "mutators/operator_assignment"
+
+module Mutineer
+  # Maps operator names to operator classes.
+  #
+  # DEFAULT_NAMES is the v1 default set (Tier-1 plus statement-removal).
+  # 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.
+  class MutatorRegistry
+    # All available mutator classes keyed by operator name.
+    ALL = {
+      "arithmetic"         => Mutators::Arithmetic,
+      "comparison"         => Mutators::Comparison,
+      "boolean_connector"  => Mutators::BooleanConnector,
+      "boolean_literal"    => Mutators::BooleanLiteral,
+      "statement_removal"  => Mutators::StatementRemoval,
+      "return_nil"         => Mutators::ReturnNil,
+      "literal_mutation"   => Mutators::LiteralMutation,
+      "condition_negation" => Mutators::ConditionNegation,
+      "string_literal"     => Mutators::StringLiteral,
+      "regex"              => Mutators::RegexLiteral,
+      "collection_method"  => Mutators::CollectionMethod,
+      "safe_navigation"    => Mutators::SafeNavigation,
+      "range"              => Mutators::RangeLiteral,
+      "negation_removal"   => Mutators::NegationRemoval,
+      "chain_link"         => Mutators::ChainLink,
+      "operand_removal"    => Mutators::OperandRemoval,
+      "array_literal"      => Mutators::ArrayLiteral,
+      "condition_true"     => Mutators::ConditionTrue,
+      "condition_false"    => Mutators::ConditionFalse,
+      "operator_assignment" => Mutators::OperatorAssignment
+    }.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
+                       safe_navigation range negation_removal
+                       chain_link operand_removal array_literal
+                       condition_true condition_false operator_assignment].freeze
+
+    # Short human-readable descriptions for each operator.
+    DESCRIPTIONS = {
+      "arithmetic"         => "+ <-> -, * <-> /, % -> *, ** -> *",
+      "comparison"         => "< <-> <=, > <-> >=, == <-> !=",
+      "boolean_connector"  => "&& <-> ||",
+      "boolean_literal"    => "true <-> false, nil -> true",
+      "statement_removal"  => "replace a non-final statement with nil",
+      "return_nil"         => "replace a return / final expression with nil",
+      "literal_mutation"   => "integer -> 0, 1, n+1; string -> empty",
+      "condition_negation" => "wrap if/unless/ternary condition in !( ... )",
+      "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",
+      "safe_navigation"    => "&. -> .",
+      "range"              => ".. <-> ...",
+      "negation_removal"   => "!x, not x -> x",
+      "chain_link"         => "drop one call from a chain: a.b.c -> a.c",
+      "operand_removal"    => "a && b -> a, b",
+      "array_literal"      => "[a, b] -> []",
+      "condition_true"     => "if/elsif/unless/ternary/modifier/case-in guard condition -> true",
+      "condition_false"    => "if/elsif/unless/ternary/modifier/case-in guard condition -> false",
+      "operator_assignment" => "+= <-> -=, *= <-> /=, %= -> *=, **= -> *= (not ||=, &&=)"
+    }.freeze
+
+    # Resolves operator names to classes.
+    #
+    # @param names [Array<String>] operator names to resolve.
+    # @return [Array<Class>] mutator classes in the requested order.
+    # @raise [ArgumentError] when a name is unknown.
+    def self.resolve(names = DEFAULT_NAMES)
+      names.map { |n| ALL.fetch(n) { raise ArgumentError, "Unknown operator: #{n.inspect}" } }
+    end
+
+    # Returns whether the operator is part of the default Tier-1 set.
+    #
+    # @param name [String] operator name.
+    # @return [Boolean] true when the operator is default.
+    def self.default?(name) = DEFAULT_NAMES.include?(name)
+
+    # Returns the tier number for an operator name.
+    #
+    # @param name [String] operator name.
+    # @return [Integer] 2 for Tier-2 operators, otherwise 1.
+    def self.tier(name)     = TIER2_NAMES.include?(name) ? 2 : 1
+  end
+end

data/lib/mutineer/mutators/arithmetic.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Arithmetic operator mutator.
+    #
+    # One mutation per occurrence, rewriting the operator token.
+    class Arithmetic < Base
+      # Token replacements for arithmetic operators.
+      REPLACEMENTS = {
+        :+ => "-", :- => "+", :* => "/", :/ => "*", :% => "*", :** => "*"
+      }.freeze
+
+      # Visits call nodes and emits arithmetic mutations.
+      #
+      # @param node [Prism::CallNode] call node to inspect.
+      # @return [void]
+      def visit_call_node(node)
+        replacement = REPLACEMENTS[node.name]
+        loc = node.message_loc
+        if replacement && loc
+          @mutations << Mutation.new(
+            start_offset: loc.start_offset,
+            end_offset: loc.end_offset,
+            replacement: replacement,
+            operator: :arithmetic
+          )
+        end
+        super # nested calls (e.g. a + (b * c)) each get their own mutation
+      end
+    end
+  end
+end

data/lib/mutineer/mutators/array_literal.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Array-literal mutator (Tier-2).
+    #
+    # Replaces a non-empty array literal with an empty one, one mutation per
+    # literal: `[a, b]` and `%i[a b]` become `[]`. The mutant survives when no
+    # test checks the contents of the array.
+    class ArrayLiteral < Base
+      # Visits array nodes and emits array-literal mutations.
+      #
+      # @param node [Prism::ArrayNode] array node to inspect.
+      # @return [void]
+      def visit_array_node(node)
+        emit(node)
+        super # nested arrays each get their own mutation
+      end
+
+      private
+
+      # Emits a mutation for a non-empty array with brackets.
+      #
+      # The operator skips an implicit array (`x = 1, 2`), because it has no
+      # brackets. It also skips an array that holds a heredoc, because the
+      # heredoc body stays behind as code.
+      #
+      # @param node [Prism::ArrayNode] array node to inspect.
+      # @return [void]
+      def emit(node)
+        return if node.opening_loc.nil? || node.elements.empty? || heredoc?(node)
+
+        @mutations << Mutation.new(
+          start_offset: node.location.start_offset,
+          end_offset: node.location.end_offset,
+          replacement: "[]",
+          operator: :array_literal
+        )
+      end
+    end
+  end
+end