mutineer 1.4.0 → 1.5.0

data/lib/mutineer/runner.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
+require "digest"
 require "pathname"
 require_relative "parser"
 require_relative "project"
 require_relative "result"
+require_relative "statement_lines"
 require_relative "isolation"
 require_relative "minitest_integration"
 require_relative "test_runners"
@@ -92,10 +94,11 @@ module Mutineer
         # by forking the booted parent, then select covering tests per mutant.
         coverage_map = CoverageMap.new(
           source_paths: config.sources, test_paths: config.tests,
-          cache_dir: config.cache_dir, project_root: config.project_root,
+          cache_dir: File.expand_path(config.cache_dir, config.project_root), project_root: config.project_root,
           load_paths: config.load_paths, framework: config.framework,
           boot_path: File.expand_path(config.boot, config.project_root),
-          verbose: config.verbose
+          verbose: config.verbose,
+          capture_timeout: config.capture_timeout || CoverageMap::DEFAULT_CAPTURE_TIMEOUT
         ).build_via_fork(after_fork: (config.rails ? -> { reconnect_active_record } : nil))
       else
         # As in boot mode, and with lib first as `rake test` does.
@@ -106,8 +109,9 @@ module Mutineer
         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 + rel_roots, framework: config.framework
+          cache_dir: File.expand_path(config.cache_dir, config.project_root), project_root: config.project_root,
+          load_paths: config.load_paths + rel_roots, framework: config.framework,
+          capture_timeout: config.capture_timeout || CoverageMap::DEFAULT_CAPTURE_TIMEOUT
         ).build_or_load
       end
       abort_if_unclean!(coverage_map)
@@ -138,12 +142,16 @@ module Mutineer
           bare = WorkerPool.new(jobs_n).run(jobs, stop_when: stop_when,
                                                   on_result: ->(_r) { progress.tick }) do |subject, mutation|
             run(mutation, source_file: subject.file, coverage_map: coverage_map,
-                subject: subject, strategy: strategy, rails: config.rails, framework: framework)
+                subject: subject, strategy: strategy, rails: config.rails, framework: framework,
+                timeout: config.timeout || Isolation::DEFAULT_TIMEOUT, matrix: config.matrix)
           end
           # The bare Results carry only status (Subjects hold live AST nodes that
           # do not marshal); reattach subject+mutation+id in the parent, in order.
           # filter_map drops nils for jobs --fail-fast left unscheduled.
-          bare.each_with_index.filter_map { |r, i| r&.with(subject: jobs[i][0], mutation: jobs[i][1], id: jobs[i][2]) }
+          share_tests(bare.each_with_index.filter_map do |r, i|
+            r = unreported_row(r) if r && config.matrix
+            r&.with(subject: jobs[i][0], mutation: jobs[i][1], id: jobs[i][2])
+          end)
         ensure
           sweep_orphans(dirs)
         end
@@ -151,6 +159,18 @@ module Mutineer
       [AggregateResult.new(results + ignored_results), source_map, extras]
     end
 
+    # A `--matrix` error that carries no {Kills} row (the worker crashed, or its
+    # result was lost) gets an empty, incomplete row: its tests never reported,
+    # so a blind test may have killed it, and the report must say so.
+    #
+    # @param result [Mutineer::Result] a worker's result.
+    # @return [Mutineer::Result]
+    def self.unreported_row(result)
+      return result unless result.error? && result.kills.nil?
+
+      result.with(kills: Kills.new(killed_by: [], ran: [], complete: false))
+    end
+
     # Collect every (subject, mutation, id) up front so a backend can run them.
     # A mutant the user marked known-equivalent (inline disable-line comment or
     # .mutineer.yml ignore id) is classified :ignored here and NEVER run. It is
@@ -199,17 +219,25 @@ module Mutineer
         ordinal = (decls[subject.def_node.location.start_offset] ||= decls.size)
         ids = MutantId.for_subject(subject, source, mutations, path: id_path, subject_ordinal: ordinal)
         legacy_ids = MutantId.legacy_for_subject(subject, source, mutations)
+        lines = mutations.map { |m| source.byteslice(0, m.start_offset).count("\n") + 1 }
+        keys = result_keys(mutations, source, lines)
+        # A repeat of an earlier edit on the same line is dropped (#159),
+        # separately among the run and the ignored mutants, so an ignored copy
+        # never hides a copy that should run. A dropped copy records nothing.
+        seen = { run: Set.new, ignored: Set.new }
         mutations.each_with_index do |mutation, i|
           id = ids[i]
           legacy = legacy_ids[i]
+          ignored = suppressed?(mutation.operator, lines[i], [id, legacy], disabled, ignore_set)
+          next unless seen[ignored ? :ignored : :run].add?(keys[i])
+
           id_map[id] = legacy
           # An old entry still over-matches other files even when the new id is
           # listed too, so every old-entry match is reported for migration.
           if ignore_set.include?(legacy)
             (legacy_ignore_matches[legacy] ||= []) << { id: id, file: id_path, subject: subject.qualified_name }
           end
-          line = source.byteslice(0, mutation.start_offset).count("\n") + 1
-          if suppressed?(mutation.operator, line, [id, legacy], disabled, ignore_set)
+          if ignored
             ignored_results << Result.ignored.with(subject: subject, mutation: mutation, id: id)
           else
             jobs << [subject, mutation, id]
@@ -219,6 +247,33 @@ module Mutineer
       [jobs, ignored_results, source_map, { legacy_ignore_matches: legacy_ignore_matches, id_map: id_map }]
     end
 
+    # One key per mutation; two mutations share a key exactly when they are
+    # the same operator on the same line and give the same mutated source (one
+    # edit, #159). The caller drops a repeat after ids are assigned. Only a
+    # group of same-operator, same-line mutations can repeat, so only those
+    # build a key from their text: the span from the group's earliest start to
+    # its latest end, digested. Every other mutation gets a key of its own.
+    #
+    # @param mutations [Array<Mutineer::Mutation>] one subject's mutations.
+    # @param source [String] the full, unmutated source.
+    # @param lines [Array<Integer>] each mutation's line.
+    # @return [Array<Object>] one key per mutation, in order.
+    def self.result_keys(mutations, source, lines)
+      keys = Array.new(mutations.size) { |i| i }
+      mutations.each_index.group_by { |i| [mutations[i].operator, lines[i]] }.each_value do |group|
+        next if group.size < 2
+
+        from = group.map { |i| mutations[i].start_offset }.min
+        to = group.map { |i| mutations[i].end_offset }.max
+        group.each do |i|
+          m = mutations[i]
+          span = "#{source.byteslice(from...m.start_offset)}#{m.replacement}#{source.byteslice(m.end_offset...to)}"
+          keys[i] = [m.operator, lines[i], Digest::SHA256.digest(span)]
+        end
+      end
+      keys
+    end
+
     # External backend orchestration. Runs each mutant's whole-file mutation on
     # disk (crash-safe swap) and executes the user's --test-command as a subprocess
     # in the app's own runtime. Serial by construction (one shared DB, no
@@ -318,7 +373,10 @@ module Mutineer
     # Coverage-based test selection, shared by the in-process ({run}) and daemon
     # paths so both narrow identically (score parity). Returns
     # `[:run, abs_test_paths]` when some test covers the mutant's line, or
-    # `[:verdict, Result]` (no_coverage / uncapturable) when none do.
+    # `[:verdict, Result]` (no_coverage / uncapturable) when none do. A line
+    # Ruby does not count (a later line of a multi-line statement) uses the
+    # tests that ran the statement that holds it ({StatementLines}), unless the
+    # mutant sits in code of that statement that runs only sometimes.
     #
     # An empty selection is `:uncapturable` (not `:no_coverage`) when the
     # mutant's enclosing method body got coverage from no *successful* capture but
@@ -335,6 +393,11 @@ module Mutineer
     def self.coverage_selection(source_file, mutation, subject, source, coverage_map)
       line   = source.byteslice(0, mutation.start_offset).count("\n") + 1
       chosen = coverage_map.tests_for(source_file, line)
+      if chosen.empty? && subject
+        # A multi-line statement has a count on one of its lines only.
+        lines = StatementLines.for(subject.def_node, source, mutation.start_offset)
+        chosen = lines.flat_map { |l| coverage_map.tests_for(source_file, l) }.uniq
+      end
       if chosen.empty?
         # Method BODY range, not the whole def: the def/end lines are "covered" at
         # class-load even when the body never runs (body_loc is the statements' span).
@@ -346,15 +409,18 @@ module Mutineer
       [:run, chosen.map { |t| File.expand_path(t, coverage_map.project_root) }]
     end
 
-    # Scan a source once into { line_number => :all | Set[operator_syms] } from
+    # Map each line number to :all or a set of operator symbols, using
     # inline `# mutineer:disable-line [ops]` markers (RuboCop semantics: the marker
     # 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.
+    # Only a real `#` comment counts: Prism lists the comments, so the marker
+    # text inside a string, heredoc or regex silences nothing (#158).
     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]+))?/))
+      Parser.comments(source).grep(Prism::InlineComment).each do |comment|
+        line = comment.location.start_line
+        next unless (m = comment.slice.match(/#\s*mutineer:disable-line(?:\s+([\w,\s]+))?/))
 
         ops = m[1]&.split(",")&.map(&:strip)&.reject(&:empty?)
         # Only spaces or commas after the marker (e.g. `disable-line  -- why`)
@@ -471,9 +537,11 @@ module Mutineer
     # @param timeout [Integer] child timeout in seconds.
     # @param rails [Boolean] whether Rails reconnect handling is enabled.
     # @param framework [String] test framework name.
+    # @param matrix [Boolean] a `--matrix` run: run every covering test and
+    #   attach the {Kills} row, with project-relative test files.
     # @return [Mutineer::Result] mutant result.
     def self.run(mutation, source_file:, coverage_map: nil, subject: nil, strategy: "reload",
-                 timeout: Isolation::DEFAULT_TIMEOUT, rails: false, framework: "minitest")
+                 timeout: Isolation::DEFAULT_TIMEOUT, rails: false, framework: "minitest", matrix: false)
       source  = File.read(source_file)
       mutated = mutation.apply(source)
 
@@ -489,7 +557,7 @@ module Mutineer
 
       abs_tests = payload
 
-      Isolation.run(timeout: timeout) do
+      result = Isolation.run(timeout: timeout, channel: matrix) do |channel|
         # Forking inherits the parent's live DB connection; sharing one socket
         # across processes corrupts it. Drop it so AR reconnects per child.
         reconnect_active_record if rails
@@ -498,8 +566,57 @@ module Mutineer
         else
           Isolation.apply_whole_file(mutated, source_file)
         end
-        # One failing test already kills the mutant, so the child stops there.
-        TestRunners.for(framework).run(abs_tests, stop_at_first_failure: true)
+        if channel
+          # --matrix: every covering test runs, and each outcome goes to the parent.
+          TestRunners.for(framework).run(abs_tests, record_to: channel)
+        else
+          # 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
+      relative_kills(result, coverage_map.project_root)
+    end
+
+    # Rewrites the test files of a result's {Kills} row relative to the project
+    # root, the form the coverage map and the report use. A result without a
+    # row comes back unchanged.
+    #
+    # @api private
+    # @param result [Mutineer::Result] a mutant result.
+    # @param root [String] project root.
+    # @return [Mutineer::Result]
+    def self.relative_kills(result, root)
+      return result unless (kills = result.kills)
+
+      paths = {}
+      rel = lambda do |tests|
+        tests.map { |file, name, id| [(paths[file] ||= ProjectPath.relative(file, root)), name, id] }.uniq.sort
+      end
+      result.with(kills: kills.with(killed_by: rel.call(kills.killed_by), ran: rel.call(kills.ran)))
+    end
+
+    # Makes every {Kills} row refer to one shared, frozen array per test. Each
+    # row arrives with its own copy of every test it ran, and a large matrix
+    # (thousands of mutants times hundreds of tests) would otherwise hold that
+    # many copies. Results without a row come back unchanged.
+    #
+    # A test is its file and its id. The name is display data and can differ
+    # between mutants (an RSpec example worded from its matcher reads
+    # differently under each mutant), so every row gets the name the first
+    # mutant reported, and one example stays one test.
+    #
+    # @api private
+    # @param results [Array<Mutineer::Result>] mutant results.
+    # @return [Array<Mutineer::Result>]
+    def self.share_tests(results)
+      shared = {}
+      share = lambda do |tests|
+        tests.map { |file, name, id| shared[[file, id]] ||= [file, name, id].map { |s| -s }.freeze }.uniq.sort.freeze
+      end
+      results.map do |r|
+        next r unless (kills = r.kills)
+
+        r.with(kills: kills.with(killed_by: share.call(kills.killed_by), ran: share.call(kills.ran)))
       end
     end
 

data/lib/mutineer/statement_lines.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Mutineer
+  # The lines of the statement that holds a position in a method body.
+  #
+  # Ruby counts one line of a statement only. A position on another line of a
+  # multi-line statement has no count of its own, but the tests that ran the
+  # statement ran it. Prism marks the statements (`Node#newline?`), so the
+  # nearest marked ancestor of the position is the statement. The caller reads
+  # the counts on the lines of the statement; a line Ruby does not count has none.
+  module StatementLines
+    # @param def_node [Prism::DefNode] the method that holds the position.
+    # @param source [String] the source text of the file.
+    # @param offset [Integer] byte offset of the position.
+    # @return [Array<Integer>] the lines of the statement, with the body of each
+    #   heredoc in it. Empty when no statement in the body holds the position.
+    #   A first or last line that holds other code is left out, because Ruby
+    #   can count that line without the statement: the `def` line counts when
+    #   the file loads, and `x if done; y(` counts when `y` does not run.
+    def self.for(def_node, source, offset)
+      return [] unless def_node.body
+
+      path = path_to(def_node.body, offset) || []
+      index = path.rindex(&:newline?)
+      return [] unless index
+
+      statement = path[index]
+      # Code that runs only sometimes inside the statement: the tests that ran
+      # the statement need not have run it.
+      return [] if path[index..].each_cons(2).any? { |parent, child| sometimes?(parent, child) }
+
+      # Ruby counts the line of `x while c` or `x if c` when it checks `c`,
+      # also when `x` never runs. The path is the modifier, its body, statement.
+      return [] if index >= 2 && modifier?(path[index - 2])
+
+      location = statement.location
+      lines = (location.start_line..last_line(statement)).to_a
+      lines.delete(location.start_line) unless before(source, location).strip.empty?
+      after = after(source, location).strip
+      lines.delete(location.end_line) unless after.empty? || after.start_with?("#")
+      lines
+    end
+
+    # Nodes whose code runs only when a branch, a match or an exception picks
+    # it: a `when` or `in` clause (its condition or pattern), a `rescue` clause
+    # (its class list), an `else` branch, parameters (their defaults) and
+    # `defined?` (its operand never runs). A statement in their bodies is a statement of its own, found
+    # deeper on the path.
+    SOMETIMES = [Prism::WhenNode, Prism::InNode, Prism::RescueNode, Prism::ElseNode, Prism::ParametersNode,
+                 Prism::BlockParametersNode, Prism::DefinedNode].freeze
+
+    # Whether `child` runs only sometimes when `parent` runs. Besides the
+    # {SOMETIMES} nodes: a branch of an `if`/`unless` inside the statement (a
+    # ternary, or `if c then a else b end` on the statement's lines), the
+    # rescue side of `x rescue y`, the pattern of `v in p` or `v => p`, the value of
+    # `a ||= v` or `a &&= v`, the right side of `a || b` or `a && b`, and the
+    # arguments and block of `x&.m(...)` and the value of `x&.m += v`, which do
+    # not run when `x` is nil.
+    #
+    # @param parent [Prism::Node]
+    # @param child [Prism::Node]
+    # @return [Boolean]
+    def self.sometimes?(parent, child)
+      return true if SOMETIMES.any? { |klass| child.is_a?(klass) }
+      return !child.equal?(parent.predicate) if parent.is_a?(Prism::IfNode) || parent.is_a?(Prism::UnlessNode)
+      # A pattern stops at its first part that does not match (`v in 1 | 2`).
+      if parent.is_a?(Prism::MatchPredicateNode) || parent.is_a?(Prism::MatchRequiredNode)
+        return child.equal?(parent.pattern)
+      end
+      return child.equal?(parent.rescue_expression) if parent.is_a?(Prism::RescueModifierNode)
+      return child.equal?(parent.right) if parent.is_a?(Prism::OrNode) || parent.is_a?(Prism::AndNode)
+      if parent.is_a?(Prism::CallNode) && parent.safe_navigation?
+        return child.equal?(parent.arguments) || child.equal?(parent.block)
+      end
+      # `a&.b += v` skips `v` when `a` is nil, like `a&.b ||= v`.
+      return true if parent.respond_to?(:safe_navigation?) && parent.safe_navigation? &&
+                     parent.respond_to?(:value) && child.equal?(parent.value)
+
+      parent.class.name.end_with?("OrWriteNode", "AndWriteNode") && child.equal?(parent.value)
+    end
+
+    # The nodes from `node` down to the deepest one that holds the offset. A
+    # heredoc body lies outside the node of its opener, so a child is searched
+    # even when its parent does not hold the offset.
+    #
+    # @param node [Prism::Node]
+    # @param offset [Integer] byte offset.
+    # @return [Array<Prism::Node>, nil] nil when no node in the subtree holds it.
+    def self.path_to(node, offset)
+      node.compact_child_nodes.each do |child|
+        path = path_to(child, offset)
+        return [node, *path] if path
+      end
+      location = node.location
+      [node] if location.start_offset <= offset && offset < location.end_offset
+    end
+
+    # The last line of `node` and its children. A heredoc body ends below the
+    # node of its opener.
+    #
+    # @param node [Prism::Node]
+    # @return [Integer]
+    def self.last_line(node)
+      [node.location.end_line, *node.compact_child_nodes.map { |child| last_line(child) }].max
+    end
+
+    # Whether `node` is a modifier whose body comes before its keyword, such
+    # as `x while c` or `x if c`. The body of `begin ... end while c` runs once
+    # before the check, so it is not.
+    #
+    # @param node [Prism::Node, nil] the parent of the body that holds the statement.
+    # @return [Boolean]
+    def self.modifier?(node)
+      keyword =
+        case node
+        when Prism::WhileNode, Prism::UntilNode then node.keyword_loc unless node.begin_modifier?
+        when Prism::IfNode then node.if_keyword_loc
+        when Prism::UnlessNode then node.keyword_loc
+        end
+      return false if keyword.nil? || node.statements.nil?
+
+      node.statements.location.start_offset < keyword.start_offset
+    end
+
+    # The text before `location` on its first line.
+    #
+    # @param source [String]
+    # @param location [Prism::Location]
+    # @return [String]
+    def self.before(source, location)
+      source.byteslice(location.start_offset - location.start_column, location.start_column)
+    end
+
+    # The text after `location` on its last line.
+    #
+    # @param source [String]
+    # @param location [Prism::Location]
+    # @return [String]
+    def self.after(source, location)
+      source.byteslice(location.end_offset, source.bytesize).each_line.first.to_s
+    end
+  end
+end

data/lib/mutineer/test_runners/minitest.rb

@@ -11,9 +11,11 @@ module Mutineer
       # @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.
+      # @param record_to [IO, nil] a `--matrix` run: send each test's outcome to
+      #   this channel and run every test.
       # @return [Integer] 0 on success, 1 on failure.
-      def self.run(test_files, stop_at_first_failure: false)
-        MinitestIntegration.run(test_files, stop_at_first_failure: stop_at_first_failure)
+      def self.run(test_files, stop_at_first_failure: false, record_to: nil)
+        MinitestIntegration.run(test_files, stop_at_first_failure: stop_at_first_failure, record_to: record_to)
       end
     end
   end