mutineer 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ca70f2affdf60ddda53d3d38e23ddff4ba6cae27cd789501c7fe3060975f146
-  data.tar.gz: 94a9968fe182655e6d566e9edfc43f1f2e15b050c7690f8905e7be9f7d710b61
+  metadata.gz: 2b48ca68bd77d82bd83917312fe4bc2377954403e0a63c99702c9059b9dde07b
+  data.tar.gz: 0c11eaa74d07db731902b2fe70313f71b17eded8a59f10e5652b86985c11641c
 SHA512:
-  metadata.gz: 8da96d70db7af241cda4ca44ecbe84522b0c0b68427a46c05e3178723c2eada7d957677c8b2cc7d2853d9593cba546c194f342862058dffdba55d03e8ef27021
-  data.tar.gz: 50481e9ca34d07530878f6ff0f25f192ab63c3200376a1a1ea5665341955a00c6bf2f9e7a4429d6cd8fd8d2119c4316c4c993741f219897f57ab493ca6c428b1
+  metadata.gz: 23505720f25f34b80bde51fb0a900c16a40295966ec8bd14713d22eca03ea0058a69d83b3f701672adee6a20b10f342f09d8b561d974f2a8f23d12a82ba22e46
+  data.tar.gz: cb2b659574bf1454ef265e3723b2c906485589696316cb63d9fb81d7696e04867e9fec73ee36b8d67063c7d941f4165fd35c922cc47cbc19466ec839ff8cbc2c

data/CHANGELOG.md

@@ -6,6 +6,54 @@ All notable changes to this project are documented here. The format is based on
 
 ## [Unreleased]
 
+## [1.2.0] - 2026-09-28
+
+### Added
+- **Operand-removal operator** (Tier-2, opt-in via `--operators`):
+  `operand_removal` replaces `a && b` with `(a)` and with `(b)`, and does the
+  same for `||`, `and` and `or`. The mutant survives when no test needs the
+  operand that the mutant removes. The operator never keeps a jump operand
+  (`return`, `break`, `next`, `redo`, `retry`) alone, because a jump does not
+  parse in a value context. It never removes an operand that holds a heredoc,
+  because the heredoc body stays behind as code. It skips nested method
+  definitions, because mutineer mutates each one as its own method.
+- **Array-literal operator** (Tier-2, opt-in via `--operators`):
+  `array_literal` replaces a non-empty array literal, such as `[a, b]` or
+  `%i[a b]`, with `[]`. The mutant survives when no test checks the contents
+  of the array. The operator skips an implicit array (`x = 1, 2`), an array
+  that holds a heredoc, and nested method definitions.
+- **Sources also pair with Minitest's `test/**/test_*.rb` files** — after the
+  `_test.rb` forms, so existing projects pair as before. `lib/helper.rb` does
+  not pair with the `test/test_helper.rb` support file. A failed capture of a
+  `test_<name>.rb` file now marks `<name>.rb` uncapturable, as `<name>_test.rb`
+  does (#120). Without `framework:` set, a source with `spec/<name>_spec.rb`
+  and `test/test_<name>.rb` but no `<name>_test.rb` now pairs with the
+  Minitest file, as the "Minitest first" order says.
+
+### Fixed
+- **`reload` loads the mutant by an absolute path** — a relative source path
+  gave the mutant relative backtrace paths, so code that checks its own frames
+  by absolute path failed for every mutant, a false kill (#123).
+- **`require "test_helper"` works without `RUBYOPT`** — a standalone run puts
+  `lib`, then each test file's `test_helper.rb` directory, on the load path,
+  as boot mode and `rake test` do. A run where no test records coverage because
+  captures failed now exits 1 instead of reporting N/A (#119).
+- **A disable-line marker warns about an operator it does not know** — a
+  reason written without `--` became part of the operator name, so the marker
+  suppressed nothing and said nothing (#124). A marker followed only by spaces
+  or commas, such as `disable-line  -- why`, now disables the whole line.
+- **Coverage capture and the clean check run each source once** — they read
+  sources with `load`, so a test's own `require` ran them again: a `Struct`
+  superclass raised `superclass mismatch`, and load-time code ran twice (#122).
+  A mutant of such a class still errors under `--strategy reload`, which loads
+  the mutated file again; `--strategy redefine` runs it.
+  Code that guards itself to run once (`unless defined?(X)`) can now show as
+  covered, so its mutants run where they were `no_coverage` before.
+- **A red unmutated suite now shows why it failed** — in a standalone run, the
+  Minitest summary or RSpec output of the failing test, with its failure
+  message, goes to stderr before the "not green" error. A passing run prints
+  nothing extra. Boot mode (`--rails`, `--boot`) is unchanged (#121).
+
 ## [1.1.0] - 2026-09-28
 
 ### Added
@@ -498,6 +546,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.2.0]: https://github.com/davidteren/mutineer/releases/tag/v1.2.0
 [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

data/README.md

@@ -84,7 +84,8 @@ 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`, `safe_navigation`, `range`, `negation_removal`, `chain_link`.
+`collection_method`, `safe_navigation`, `range`, `negation_removal`, `chain_link`,
+`operand_removal`, `array_literal`.
 
 ## Rails apps
 
@@ -212,7 +213,7 @@ Tradeoffs — this path is correct but not free:
 Some mutants are equivalent (behaviour-identical) and survive forever — keeping a
 file off 100%. Suppress them so the score and `--threshold` gate stay meaningful:
 
-- **Inline:** `some_line # mutineer:disable-line` (or scope it: `# mutineer:disable-line comparison`).
+- **Inline:** `some_line # mutineer:disable-line` (or scope it: `# mutineer:disable-line comparison`). Put a reason after `--`: `# mutineer:disable-line comparison -- the test checks only 20`.
 - **Config:** a `.mutineer.yml` `ignore:` list of stable mutant ids. Each survivor's
   `id` is printed in the JSON report, so copy it straight into `ignore:`.
 

data/lib/mutineer/coverage_map.rb

@@ -96,7 +96,7 @@ module Mutineer
     # Is this source file's empty coverage the result of an *errored* capture
     # rather than a genuine coverage gap? True iff some capture failed this run
     # AND this file got zero coverage from any successful capture AND a failed
-    # test file maps to it by the standard _test/_spec naming convention. Derived
+    # test file maps to it by the _test/_spec/test_ naming convention. Derived
     # purely from already-persisted state (@map keys + @failed_test_files); no
     # rerun, no new cached field, no digest change.
     #
@@ -142,10 +142,17 @@ module Mutineer
       @map.keys.map { |k| k.rpartition(":").first }.to_set
     end
 
-    # Basenames of failed test files with a trailing _test/_spec (and .rb) stripped,
-    # i.e. the source basenames they would have covered by convention.
+    # Basenames of the sources that failed test files pair with by convention:
+    # a trailing _test/_spec is stripped first, as pairing tries that form first.
     def failed_test_targets
-      @failed_test_files.map { |t| File.basename(t, ".rb").sub(/_(test|spec)\z/, "") }.to_set
+      @failed_test_files.map do |t|
+        name = File.basename(t, ".rb")
+        case name
+        when /_(test|spec)\z/ then name.sub(/_(test|spec)\z/, "")
+        when "test_helper" then name # Minitest's support file pairs with no source
+        else name.delete_prefix("test_")
+        end
+      end.to_set
     end
 
     # Shared cache dance for both build paths: hit the digest-keyed cache, else
@@ -577,11 +584,17 @@ module Mutineer
       loads = Array(test_paths).map { |t| "load #{absolute(t).inspect}" }.join("\n")
       <<~RUBY
         require "minitest"
+        require "stringio"
         def Minitest.autorun; end
+        _report = StringIO.new
+        Minitest.define_singleton_method(:plugin_mutineer_report_init) { |options| reporter << Minitest::SummaryReporter.new(_report, options) }
+        Minitest.extensions << "mutineer_report"
         $LOAD_PATH.unshift(*#{abs_load_paths.inspect})
-        #{abs_source_paths.inspect}.each { |f| load f }
+        #{abs_source_paths.inspect}.each { |f| require f }
         #{loads}
-        exit(Minitest.run([]) ? 0 : 1)
+        _passed = Minitest.run([])
+        $stderr.write(_report.string) unless _passed
+        exit(_passed ? 0 : 1)
       RUBY
     end
 
@@ -601,9 +614,10 @@ module Mutineer
         end
         RSpec::Core::Runner.disable_autorun!
         $LOAD_PATH.unshift(*#{abs_load_paths.inspect})
-        #{abs_source_paths.inspect}.each { |f| load f }
+        #{abs_source_paths.inspect}.each { |f| require f }
         _sink = StringIO.new
         status = RSpec::Core::Runner.run(["--no-color", #{specs}], _sink, _sink)
+        $stderr.write(_sink.string) unless status.zero?
         exit(status.zero? ? 0 : 1)
       RUBY
     end
@@ -628,12 +642,17 @@ module Mutineer
         require "coverage"
         require "json"
         require "minitest"
+        require "stringio"
         def Minitest.autorun; end
+        _report = StringIO.new
+        Minitest.define_singleton_method(:plugin_mutineer_report_init) { |options| reporter << Minitest::SummaryReporter.new(_report, options) }
+        Minitest.extensions << "mutineer_report"
         Coverage.start(lines: true)
         $LOAD_PATH.unshift(*#{abs_load_paths.inspect})
-        #{abs_source_paths.inspect}.each { |f| load f }
+        #{abs_source_paths.inspect}.each { |f| require f }
         load #{absolute(test_path).inspect}
         _passed = Minitest.run([])
+        $stderr.write(_report.string) unless _passed
         _result.puts JSON.generate("passed" => _passed == true, "coverage" => Coverage.result,
                                     "loaded_files" => #{loaded_files_expression})
         _result.close
@@ -641,7 +660,7 @@ module Mutineer
     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
+    # require rspec/core lazily, require the sources under Coverage, then run the
     # 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)
@@ -661,9 +680,10 @@ module Mutineer
         RSpec::Core::Runner.disable_autorun!
         Coverage.start(lines: true)
         $LOAD_PATH.unshift(*#{abs_load_paths.inspect})
-        #{abs_source_paths.inspect}.each { |f| load f }
+        #{abs_source_paths.inspect}.each { |f| require f }
         _sink = StringIO.new
         _status = RSpec::Core::Runner.run(["--no-color", #{absolute(test_path).inspect}], _sink, _sink)
+        $stderr.write(_sink.string) unless _status.zero?
         _result.puts JSON.generate("passed" => _status.zero?, "coverage" => Coverage.result,
                                     "loaded_files" => #{loaded_files_expression})
         _result.close

data/lib/mutineer/isolation.rb

@@ -99,7 +99,7 @@ module Mutineer
     # @param source_file [String] original source file path.
     # @return [Object] whatever `load` returns.
     def self.apply_whole_file(mutated, source_file)
-      Tempfile.create(["mutineer_mutant", ".rb"], File.dirname(source_file)) do |f|
+      Tempfile.create(["mutineer_mutant", ".rb"], File.dirname(File.expand_path(source_file))) do |f|
         f.write(mutated)
         f.flush
         load f.path

data/lib/mutineer/mutator_registry.rb

@@ -15,6 +15,8 @@ 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"
 
 module Mutineer
   # Maps operator names to operator classes.
@@ -41,7 +43,9 @@ module Mutineer
       "safe_navigation"    => Mutators::SafeNavigation,
       "range"              => Mutators::RangeLiteral,
       "negation_removal"   => Mutators::NegationRemoval,
-      "chain_link"         => Mutators::ChainLink
+      "chain_link"         => Mutators::ChainLink,
+      "operand_removal"    => Mutators::OperandRemoval,
+      "array_literal"      => Mutators::ArrayLiteral
     }.freeze
 
     # The default Tier-1 operator set.
@@ -49,7 +53,7 @@ module Mutineer
     # 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].freeze
+                       chain_link operand_removal array_literal].freeze
 
     # Short human-readable descriptions for each operator.
     DESCRIPTIONS = {
@@ -67,7 +71,9 @@ module Mutineer
       "safe_navigation"    => "&. -> .",
       "range"              => ".. <-> ...",
       "negation_removal"   => "!x, not x -> x",
-      "chain_link"         => "drop one call from a chain: a.b.c -> a.c"
+      "chain_link"         => "drop one call from a chain: a.b.c -> a.c",
+      "operand_removal"    => "a && b -> a, b",
+      "array_literal"      => "[a, b] -> []"
     }.freeze
 
     # Resolves operator names to classes.

data/lib/mutineer/mutators/array_literal.rb

@@ -0,0 +1,51 @@
+# 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
+
+      # Skips a nested method definition. The project finds it as a subject of
+      # its own, so a visit here counts its arrays twice.
+      #
+      # @param node [Prism::DefNode] nested definition node.
+      # @return [void]
+      def visit_def_node(node); 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

data/lib/mutineer/mutators/base.rb

@@ -26,6 +26,21 @@ module Mutineer
         subject.def_node.body&.accept(self)
         @mutations
       end
+
+      private
+
+      # Returns whether a node is, or contains, a heredoc.
+      #
+      # A heredoc's body lies outside its node's byte range. A mutation that
+      # deletes the node leaves the body behind as code, so the mutant
+      # always raises.
+      #
+      # @param node [Prism::Node] node to inspect.
+      # @return [Boolean] true when a heredoc is inside the node.
+      def heredoc?(node)
+        (node.respond_to?(:heredoc?) && node.heredoc?) ||
+          node.compact_child_nodes.any? { |child| heredoc?(child) }
+      end
     end
   end
 end

data/lib/mutineer/mutators/operand_removal.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Operand-removal mutator (Tier-2).
+    #
+    # Replaces a boolean expression with one of its operands, two mutations
+    # per `&&`, `||`, `and` or `or`: `a && b` becomes `(a)` and `(b)`. The
+    # parentheses keep the precedence of `and` and `or`. A surviving mutant
+    # shows that no test needs the operand that was removed.
+    class OperandRemoval < Base
+      # Node types for jumps. A jump in a value context does not parse, so
+      # the operator never keeps a jump alone.
+      JUMPS = [Prism::ReturnNode, Prism::BreakNode, Prism::NextNode, Prism::RedoNode, Prism::RetryNode].freeze
+
+      # Visits `and` nodes.
+      #
+      # @param node [Prism::AndNode] node to inspect.
+      # @return [void]
+      def visit_and_node(node)
+        emit(node)
+        super # nested connectors (a && b && c) each get their own mutations
+      end
+
+      # Visits `or` nodes.
+      #
+      # @param node [Prism::OrNode] node to inspect.
+      # @return [void]
+      def visit_or_node(node)
+        emit(node)
+        super
+      end
+
+      # Skips a nested method definition. The project finds it as a subject of
+      # its own, so a visit here counts its connectors twice.
+      #
+      # @param node [Prism::DefNode] nested definition node.
+      # @return [void]
+      def visit_def_node(node); end
+
+      private
+
+      # Emits one mutation that keeps the left operand, then one that keeps
+      # the right operand. The order is fixed, because the two mutants share
+      # a token and their occurrence ordinals tell them apart.
+      #
+      # @param node [Prism::AndNode, Prism::OrNode] connector node.
+      # @return [void]
+      def emit(node)
+        [[node.left, node.right], [node.right, node.left]].each do |kept, removed|
+          next if JUMPS.any? { |type| kept.is_a?(type) } || heredoc?(removed)
+
+          @mutations << Mutation.new(
+            start_offset: node.location.start_offset,
+            end_offset: node.location.end_offset,
+            replacement: "(#{kept.slice})",
+            operator: :operand_removal
+          )
+        end
+      end
+    end
+  end
+end

data/lib/mutineer/pairing.rb

@@ -5,9 +5,9 @@ module Mutineer
   # no Rails, no class loading, no process. Two jobs:
   #   * expand_sources — a directory argument becomes its sorted **/*.rb files.
   #   * infer_test     — a source's test file by convention (app/ and lib/
-  #                     sources map to test/.../_test.rb or spec/.../_spec.rb),
-  #                     preserving namespaced subdirectories. First EXISTING
-  #                     candidate wins.
+  #                     sources map to test/.../_test.rb, test/.../test_*.rb
+  #                     or spec/.../_spec.rb), preserving namespaced
+  #                     subdirectories. First EXISTING candidate wins.
   #
   # Independently unit-testable: every method is pure in/out over the
   # filesystem, so the pairing contract is exercised with plain fixtures, no
@@ -68,8 +68,8 @@ module Mutineer
       end
     end
 
-    # Ordered candidate test paths. lib/ sources also get test/lib/... and
-    # spec/lib/... (Rails apps put lib tests under either layout).
+    # Ordered candidate test paths: _test.rb, then Minitest's test_*.rb, then
+    # _spec.rb. lib/ sources also get the test/lib/... and spec/lib/... layouts.
     #
     # @param base [String] logical source path without extension.
     # @param lib [Boolean] whether the source originated from lib/.
@@ -78,6 +78,11 @@ module Mutineer
     def candidates(base, lib, prefer)
       minitest = ["test/#{base}_test.rb"]
       minitest << "test/lib/#{base}_test.rb" if lib
+      unless File.basename(base) == "helper" # test/test_helper.rb is Minitest's support file, not a test
+        prefixed = base.sub(%r{[^/]+\z}) { |name| "test_#{name}" }
+        minitest << "test/#{prefixed}.rb"
+        minitest << "test/lib/#{prefixed}.rb" if lib
+      end
       rspec = ["spec/#{base}_spec.rb"]
       rspec << "spec/lib/#{base}_spec.rb" if lib
       prefer == "rspec" ? rspec + minitest : minitest + rspec

data/lib/mutineer/runner.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pathname"
 require_relative "parser"
 require_relative "project"
 require_relative "result"
@@ -93,10 +94,16 @@ module Mutineer
           verbose: config.verbose
         ).build_via_fork(after_fork: (config.rails ? -> { reconnect_active_record } : nil))
       else
+        # As in boot mode, and with lib first as `rake test` does.
+        test_roots = test_load_roots(config.tests.map { |t| File.expand_path(t, config.project_root) })
+        libs = config.load_paths.map { |p| File.expand_path(p, config.project_root) }
+        $LOAD_PATH.unshift(*(libs + test_roots).uniq.reject { |d| $LOAD_PATH.include?(d) })
+        # Relative, so the cache digest does not depend on the checkout path.
+        rel_roots = test_roots.map { |d| Pathname(d).relative_path_from(File.expand_path(config.project_root)).to_s }
         coverage_map = CoverageMap.new(
           source_paths: config.sources, test_paths: config.tests,
           cache_dir: config.cache_dir, project_root: config.project_root,
-          load_paths: config.load_paths, framework: config.framework
+          load_paths: config.load_paths + rel_roots, framework: config.framework
         ).build_or_load
       end
       abort_if_unclean!(coverage_map)
@@ -157,7 +164,7 @@ module Mutineer
       ignored_results = []
       Project.discover(config.sources, only: config.only).each do |subject|
         source = (source_map[subject.file] ||= File.read(subject.file))
-        disabled = (disabled_map[subject.file] ||= suppress_map(source))
+        disabled = (disabled_map[subject.file] ||= suppress_map(source, subject.file))
         mutations = operator_classes.flat_map { |klass| klass.new.mutations_for(subject, source) }
         ids = MutantId.for_subject(subject, source, mutations)
         mutations.each_with_index do |mutation, i|
@@ -253,8 +260,13 @@ module Mutineer
     #
     # @param coverage_map [Mutineer::CoverageMap] the built or loaded map.
     # @return [void]
-    # @raise [Mutineer::SmokeCheckError] when any captured test failed clean.
+    # @raise [Mutineer::SmokeCheckError] when any captured test failed clean,
+    #   or when no test recorded coverage and a capture failed.
     def self.abort_if_unclean!(coverage_map)
+      if coverage_map.map.empty? && coverage_map.failed_test_files.any?
+        raise SmokeCheckError, "no test recorded coverage, and capture failed for #{coverage_map.failed_test_files.join(', ')}"
+      end
+
       files = coverage_map.failed_clean_tests
       return if files.empty?
 
@@ -299,13 +311,21 @@ module Mutineer
     # sits on the same physical line as the code it silences). A bare marker
     # disables every operator on that line; `disable-line a, b` only the listed
     # operators. Block-form disable/enable ranges are intentionally not supported.
-    def self.suppress_map(source)
+    def self.suppress_map(source, file)
       map = {}
       source.each_line.with_index(1) do |text, line|
         next unless (m = text.match(/#\s*mutineer:disable-line(?:\s+([\w,\s]+))?/))
 
-        ops = m[1]
-        map[line] = ops ? ops.split(",").map { |o| o.strip.to_sym }.reject(&:empty?).to_set : :all
+        ops = m[1]&.split(",")&.map(&:strip)&.reject(&:empty?)
+        # Only spaces or commas after the marker (e.g. `disable-line  -- why`)
+        # is a bare marker, not an empty list that silences nothing.
+        ops = nil if ops&.empty?
+        unknown = ops.to_a.reject { |o| MutatorRegistry::ALL.key?(o) }
+        unknown.each do |o|
+          warn "mutineer: unknown operator #{o.inspect} in #{file}:#{line} " \
+               "(known: #{MutatorRegistry::ALL.keys.join(', ')}); write a reason after --"
+        end
+        map[line] = ops ? ops.map(&:to_sym).to_set : :all
       end
       map
     end

data/lib/mutineer/version.rb

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

data/lib/mutineer.rb

@@ -29,6 +29,8 @@ 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/mutators/operand_removal"
+require_relative "mutineer/mutators/array_literal"
 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.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - David Teren
@@ -70,6 +70,7 @@ files:
 - lib/mutineer/mutation.rb
 - lib/mutineer/mutator_registry.rb
 - lib/mutineer/mutators/arithmetic.rb
+- lib/mutineer/mutators/array_literal.rb
 - lib/mutineer/mutators/base.rb
 - lib/mutineer/mutators/boolean_connector.rb
 - lib/mutineer/mutators/boolean_literal.rb
@@ -79,6 +80,7 @@ files:
 - lib/mutineer/mutators/condition_negation.rb
 - lib/mutineer/mutators/literal_mutation.rb
 - lib/mutineer/mutators/negation_removal.rb
+- lib/mutineer/mutators/operand_removal.rb
 - lib/mutineer/mutators/range_literal.rb
 - lib/mutineer/mutators/regex_literal.rb
 - lib/mutineer/mutators/return_nil.rb