mutineer 1.0.2 → 1.2.0

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/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
@@ -434,7 +454,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.2.0"
 end

data/lib/mutineer.rb

@@ -25,6 +25,12 @@ 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/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.0.2
+  version: 1.2.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,19 +65,26 @@ 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
 - 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
+- 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/operand_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