henitai 0.5.3 → 0.6.0

data/lib/henitai/operators/method_expression.rb

@@ -5,8 +5,11 @@ require_relative "../parser_current"
 module Henitai
   module Operators
     # Replaces generic method call results with nil.
+    #
+    # A call with a block is replaced together with its block: replacing only
+    # the call would leave +nil { ... }+ behind, which does not parse.
     class MethodExpression < Henitai::Operator
-      NODE_TYPES = [:send].freeze
+      NODE_TYPES = %i[send block numblock].freeze
       EXCLUDED_METHODS = %i[
         +
         -
@@ -31,9 +34,10 @@ module Henitai
       end
 
       def mutate(node, subject:)
-        return [] unless node.type == :send
+        call = called_method(node)
+        return [] unless call&.type == :send
 
-        _receiver, method_name, *_arguments = node.children
+        _receiver, method_name, *_arguments = call.children
         return [] if excluded_method?(method_name)
 
         [
@@ -48,6 +52,13 @@ module Henitai
 
       private
 
+      def called_method(node)
+        case node.type
+        when :send then node
+        when :block, :numblock then node.children.first
+        end
+      end
+
       def excluded_method?(method_name)
         method_name.to_s.end_with?("=") || EXCLUDED_METHODS.include?(method_name)
       end

data/lib/henitai/operators/regex_metacharacters.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Henitai
+  module Operators
+    # Locates the regexp metacharacters that RegexMutator edits.
+    #
+    # An escaped character and the contents of a character class are literal
+    # text: the +^+ in +[^0-9]+ negates the class and is no anchor, and the
+    # +++ in +[+-]+ or +\++ is no quantifier. The scan therefore skips
+    # escapes and tracks character-class nesting, including POSIX brackets
+    # such as +[[:alpha:]]+.
+    class RegexMetacharacters
+      ANCHORS = %w[^ $].freeze
+      QUANTIFIERS = %w[+ * ?].freeze
+      GROUPING = %w[( |].freeze
+
+      def initialize(source)
+        @source = source
+        @found = Hash.new { |hash, key| hash[key] = [] }
+        scan
+      end
+
+      # Indices of the +char+ quantifier ("+" or "*") applied to an atom.
+      def quantifiers(char)
+        @found[[:quantifier, char]].dup
+      end
+
+      # Indices of the +char+ anchor ("^" or "$").
+      def anchors(char)
+        @found[[:anchor, char]].dup
+      end
+
+      # Indices of the opening brackets of top-level, non-negated classes.
+      def class_openers
+        @found[:class_opener].dup
+      end
+
+      private
+
+      def scan
+        @index = 0
+        @depth = 0
+        @previous = nil
+        step while @index < @source.length
+      end
+
+      def step
+        char = @source[@index]
+        if char == "\\"
+          @previous = :atom
+          @index += 2
+        else
+          @depth.positive? ? within_class(char) : top_level(char)
+          @index += 1
+        end
+      end
+
+      def within_class(char)
+        @depth += 1 if char == "["
+        @depth -= 1 if char == "]"
+        @previous = :atom if @depth.zero?
+      end
+
+      def top_level(char)
+        record(char)
+        @previous = kind_of_token(char)
+        @depth = 1 if char == "["
+      end
+
+      def record(char)
+        if ANCHORS.include?(char)
+          @found[[:anchor, char]] << @index
+        elsif char == "["
+          @found[:class_opener] << @index unless @source[@index + 1] == "^"
+        elsif QUANTIFIERS.include?(char) && @previous == :atom
+          @found[[:quantifier, char]] << @index
+        end
+      end
+
+      def kind_of_token(char)
+        return :anchor if ANCHORS.include?(char)
+        return :quantifier if QUANTIFIERS.include?(char) || char == "}"
+        return :group if GROUPING.include?(char)
+
+        :atom
+      end
+    end
+  end
+end

data/lib/henitai/operators/regex_mutator.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../parser_current"
+require_relative "regex_metacharacters"
 
 module Henitai
   module Operators
@@ -8,7 +9,10 @@ module Henitai
     # and character-class negation.
     #
     # Each applicable transformation yields a separate mutant. Invalid
-    # results (unparseable regex) are discarded before emission.
+    # results (unparseable regex) are discarded before emission. Only static,
+    # single-segment literals are mutated: an interpolated or multi-line
+    # regexp is split into several parts, and rewriting one part alone would
+    # drop or misread the others.
     # Anchor removal and character-class negation are intentionally one-way:
     # they reduce noisy patterns rather than mirroring a full edit matrix.
     class RegexMutator < Henitai::Operator
@@ -30,11 +34,11 @@ module Henitai
       private
 
       def extract_parts(node)
-        str_child  = node.children.find { |c| c.is_a?(Parser::AST::Node) && c.type == :str }
-        opts_node  = node.children.find { |c| c.is_a?(Parser::AST::Node) && c.type == :regopt }
-        return nil unless str_child
+        *parts, opts_node = node.children
+        return unless opts_node.is_a?(Parser::AST::Node) && opts_node.type == :regopt
+        return unless parts.size == 1 && parts.first.is_a?(Parser::AST::Node) && parts.first.type == :str
 
-        [str_child.children[0], opts_node]
+        [parts.first.children[0], opts_node]
       end
 
       def build_regex_mutant(node, opts_node, new_source, original, description, subject:) # rubocop:disable Metrics/ParameterLists
@@ -47,35 +51,26 @@ module Henitai
       end
 
       def transformations(source)
+        found = RegexMetacharacters.new(source)
         [
-          *quantifier_swaps(source),
-          *anchor_removals(source),
-          *char_class_negations(source)
+          [edit(source, found.quantifiers("+"), "*"), "replaced + quantifier with *"],
+          [edit(source, found.quantifiers("*"), "+"), "replaced * quantifier with +"],
+          # Anchors are removed, never added, and character classes are only
+          # negated: the reverse edits would just recreate an input.
+          [edit(source, found.anchors("^").first(1), ""), "removed ^ anchor"],
+          [edit(source, found.anchors("$").last(1), ""), "removed $ anchor"],
+          [insert_after(source, found.class_openers, "^"), "negated character class"]
         ]
       end
 
-      def quantifier_swaps(source)
-        # Quantifier swaps are symmetric. The other transforms are intentionally
-        # one-way because they model reductions instead of reversible edits.
-        [
-          [source.gsub(/(?<=[^*+?\\])\+/, "*"), "replaced + quantifier with *"],
-          [source.gsub(/(?<=[^*+?\\])\*/, "+"), "replaced * quantifier with +"]
-        ]
-      end
-
-      def anchor_removals(source)
-        # Anchors are removed, not added back. The mutation is deliberately
-        # asymmetric because "restoring" anchors would just recreate the input.
-        [
-          [source.sub("^", ""), "removed ^ anchor"],
-          [source.sub(/\$$/, ""), "removed $ anchor"]
-        ]
+      # Replaces the single characters at +indices+, from the last to the
+      # first so earlier indices stay valid.
+      def edit(source, indices, text)
+        indices.sort.reverse.each_with_object(source.dup) { |index, result| result[index] = text }
       end
 
-      def char_class_negations(source)
-        # Negation only flips a positive class into a negated one. We do not
-        # emit the reverse mutation because that would mirror the same edit.
-        [[source.gsub(/\[(?!\^)/, "[^"), "negated character class"]]
+      def insert_after(source, indices, text)
+        indices.sort.reverse.each_with_object(source.dup) { |index, result| result.insert(index + 1, text) }
       end
 
       def valid_regex?(source)

data/lib/henitai/operators/return_value.rb

@@ -47,7 +47,7 @@ module Henitai
       end
 
       def mutate_implicit_return(node, subject:)
-        return [] unless node == final_expression_node(subject&.ast_node)
+        return [] unless node.equal?(final_expression_node(subject&.ast_node))
 
         replacement_nodes(node).map do |replacement|
           build_mutant(

data/lib/henitai/operators.rb

@@ -24,6 +24,7 @@ module Henitai
     autoload :MethodExpression, "henitai/operators/method_expression"
     autoload :AssignmentExpression, "henitai/operators/assignment_expression"
     autoload :MethodChainUnwrap,    "henitai/operators/method_chain_unwrap"
+    autoload :RegexMetacharacters,  "henitai/operators/regex_metacharacters"
     autoload :RegexMutator,         "henitai/operators/regex_mutator"
     autoload :UnaryOperator,        "henitai/operators/unary_operator"
     autoload :UpdateOperator,       "henitai/operators/update_operator"

data/lib/henitai/per_test_coverage.rb

@@ -35,12 +35,7 @@ module Henitai
     # @return [Array<String>] sorted; empty when the test is unknown or the
     #   map is unavailable.
     def source_files_covered_by(test_file)
-      wanted = File.expand_path(test_file.to_s)
-      map.select { |test, _| File.expand_path(test) == wanted }
-         .values
-         .flat_map(&:keys)
-         .uniq
-         .sort
+      Array(map_by_absolute_test_path[File.expand_path(test_file.to_s)]&.keys).sort
     end
 
     # True when the given test file's recorded coverage intersects the
@@ -63,11 +58,20 @@ module Henitai
         mutant.location[:end_line]
     end
 
+    # RSpec records test files as "./spec/x_spec.rb" while candidates arrive
+    # as "spec/x_spec.rb"; both resolve to the same absolute key.
     def coverage_lines_for(test, mutant)
-      source_map = map[test.to_s] || {}
+      source_map = map_by_absolute_test_path[File.expand_path(test.to_s)] || {}
       Array(source_map[File.expand_path(mutant.location[:file])]).uniq
     end
 
+    def map_by_absolute_test_path
+      @map_by_absolute_test_path ||= map.each_with_object({}) do |(test, source_map), index|
+        merged = index[File.expand_path(test)] ||= {}
+        source_map.each { |file, lines| merged[file] = Array(merged[file]) + Array(lines) }
+      end
+    end
+
     def mutant_lines(mutant)
       (mutant.location[:start_line]..mutant.location[:end_line]).to_a
     end

data/lib/henitai/per_test_coverage_collector.rb

@@ -3,9 +3,12 @@
 require "coverage"
 require "fileutils"
 require "json"
+require_relative "per_test_coverage_delta"
+require_relative "suite_boot_clock"
 
 module Henitai
   # Accumulates per-test line coverage deltas across test examples.
+  # {PerTestCoverageDelta} decides which lines a single test executed.
   #
   # Framework-agnostic core used by both the RSpec and Minitest adapters.
   # Callers invoke record_test after each test completes and write_report
@@ -13,16 +16,25 @@ module Henitai
   class PerTestCoverageCollector
     REPORT_DIR_ENV = "HENITAI_REPORTS_DIR"
     REPORT_FILE_NAME = "henitai_per_test.json"
+    BOOT_FILE_NAME = "henitai_suite_boot.json"
 
-    def initialize
+    # @param boot_clock [SuiteBootClock] measures suite boot time
+    def initialize(boot_clock: SuiteBootClock.from_env(ENV))
+      @boot_clock = boot_clock
       @coverage_by_test = Hash.new do |hash, test_file|
         hash[test_file] = Hash.new { |nested, source_file| nested[source_file] = [] }
       end
       @duration_by_test = Hash.new(0.0)
       @previous_snapshot = {}
+      @delta = PerTestCoverageDelta.new
       @warned_missing_coverage = false
     end
 
+    # Called when the first test of the suite starts; ends the boot phase.
+    def test_started
+      @boot_clock.mark_first_test_started
+    end
+
     def record_test(test_file, duration: nil)
       snapshot = current_snapshot
       return warn_missing_coverage unless snapshot
@@ -36,19 +48,34 @@ module Henitai
       @previous_snapshot = snapshot
     end
 
+    # Advances past a test whose result cannot be attributed to a file, so its
+    # coverage is not credited to the next test.
+    def skip_test
+      @previous_snapshot = current_snapshot || @previous_snapshot
+    end
+
     def write_report
       return if @coverage_by_test.empty?
 
-      FileUtils.mkdir_p(File.dirname(report_path))
+      FileUtils.mkdir_p(reports_dir)
       File.write(report_path, JSON.pretty_generate(serializable_report))
+      write_boot_report if @boot_clock.measured?
     end
 
     private
 
+    def write_boot_report
+      File.write(boot_path, JSON.pretty_generate("boot_seconds" => @boot_clock.boot_seconds))
+    end
+
     def report_path
       File.join(reports_dir, REPORT_FILE_NAME)
     end
 
+    def boot_path
+      File.join(reports_dir, BOOT_FILE_NAME)
+    end
+
     def reports_dir
       ENV.fetch(REPORT_DIR_ENV, "coverage")
     end
@@ -81,39 +108,11 @@ module Henitai
       snapshot.each_with_object({}) do |(source_file, file_coverage), result|
         next unless source_file?(source_file)
 
-        lines = new_line_numbers(
-          file_coverage,
-          previous_line_counts(source_file)
-        )
+        lines = @delta.executed_lines(file_coverage, @previous_snapshot.fetch(source_file, []))
         result[source_file] = lines unless lines.empty?
       end
     end
 
-    # Count-delta attribution: a line belongs to every test whose run
-    # incremented its cumulative count, not just the first toucher. This keeps
-    # the per-test map a complete over-approximation of reachability — the
-    # soundness precondition for survivor verdict reuse (ADR-11).
-    def new_line_numbers(file_coverage, previous_counts)
-      line_counts_for(file_coverage).each_with_index.filter_map do |count, index|
-        next unless count.to_i > previous_counts.fetch(index, 0).to_i
-
-        index + 1
-      end
-    end
-
-    def previous_line_counts(source_file)
-      line_counts_for(@previous_snapshot.fetch(source_file, []))
-    end
-
-    def line_counts_for(file_coverage)
-      case file_coverage
-      when Hash
-        Array(file_coverage[:lines] || file_coverage["lines"])
-      else
-        Array(file_coverage)
-      end
-    end
-
     def source_file?(path)
       expanded = File.expand_path(path)
       prefix = "#{Dir.pwd}#{File::SEPARATOR}"

data/lib/henitai/per_test_coverage_delta.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Computes which source lines a test executed in one file, from two
+  # cumulative +Coverage.peek_result+ entries (before and after the test).
+  #
+  # Line coverage alone misses endless methods (+def x = expr+): calling
+  # one never increments any line count, so their body lines would only be
+  # attributed to the test that loaded the file. When method coverage is
+  # available, every called method also contributes its +def+ line and the
+  # lines inside its range that line coverage does not track.
+  class PerTestCoverageDelta
+    def executed_lines(current, previous)
+      (counted_lines(current, previous) | called_method_lines(current, previous)).sort
+    end
+
+    private
+
+    # Count-delta attribution: a line belongs to every test whose run
+    # incremented its cumulative count, not just the first toucher. This keeps
+    # the per-test map a complete over-approximation of reachability — the
+    # soundness precondition for survivor verdict reuse (ADR-11).
+    def counted_lines(current, previous)
+      previous_counts = line_counts(previous)
+      line_counts(current).each_with_index.filter_map do |count, index|
+        index + 1 if count.to_i > previous_counts.fetch(index, 0).to_i
+      end
+    end
+
+    def called_method_lines(current, previous)
+      counts = line_counts(current)
+      previous_calls = method_counts(previous)
+      method_counts(current).flat_map do |key, calls|
+        next [] unless calls.to_i > previous_calls.fetch(key, 0).to_i
+
+        untracked_method_lines(key, counts)
+      end
+    end
+
+    def untracked_method_lines(key, counts)
+      first_line = key[2]
+      last_line = key[4]
+      (first_line..last_line).select do |line|
+        line == first_line || counts[line - 1].nil?
+      end
+    end
+
+    def line_counts(file_coverage)
+      return Array(file_coverage) unless file_coverage.is_a?(Hash)
+
+      Array(file_coverage[:lines] || file_coverage["lines"])
+    end
+
+    def method_counts(file_coverage)
+      return {} unless file_coverage.is_a?(Hash)
+
+      file_coverage[:methods] || file_coverage["methods"] || {}
+    end
+  end
+end

data/lib/henitai/per_test_coverage_selector.rb

@@ -1,30 +1,43 @@
 # frozen_string_literal: true
 
 module Henitai
-  # Narrows candidate test files using the per-test coverage report.
+  # Selects the test files to run for a mutant, coverage first.
   #
-  # The intersection check itself lives in {PerTestCoverage}; this class only
-  # adds the selection policy: when no candidate provably covers the mutant
-  # (or the map / location is unavailable), it falls back to all candidates —
-  # over-selection costs time, never correctness.
+  # The per-test coverage map is the primary source: every integration test
+  # file that provably reaches the mutant's lines is selected, whether or not
+  # its name matches the subject. Name matching ({fallback}) is only consulted
+  # when the map cannot decide — no map, no location, no covering test in the
+  # map, or no covering test left in the integration. Over-selection costs
+  # time; a missed covering test would produce a false survivor. Mutants on a
+  # method's def line additionally take the name-matched tests, because that
+  # line's coverage is only a load-time record.
+  #
+  # `test_files` and `fallback` are lambdas so that expensive name matching
+  # and file discovery run only when they are needed.
   class PerTestCoverageSelector
     def initialize(coverage_report_reader: CoverageReportReader.new)
       @coverage_report_reader = coverage_report_reader
     end
 
-    def filter(tests, mutant, reports_dir:)
-      candidates = Array(tests)
-      return candidates if candidates.empty?
+    def select(mutant, reports_dir:, test_files:, fallback:)
+      covering = per_test_coverage(reports_dir).tests_covering(mutant)
+      return fallback.call if covering.empty?
 
-      coverage = per_test_coverage(reports_dir)
-      covered_tests = candidates.select do |test|
-        coverage.covers?(test, mutant)
-      end
-      covered_tests.empty? ? candidates : covered_tests
+      covered = covered_integration_tests(test_files.call, covering)
+      return fallback.call if covered.empty?
+
+      SignatureLine.on?(mutant) ? covered | fallback.call : covered
     end
 
     private
 
+    def covered_integration_tests(integration_tests, covering)
+      covering_paths = covering.map { |test| File.expand_path(test) }
+      Array(integration_tests).select do |test|
+        covering_paths.include?(File.expand_path(test))
+      end
+    end
+
     def per_test_coverage(reports_dir)
       @per_test_coverage ||= {}
       @per_test_coverage[reports_dir] ||= PerTestCoverage.new(

data/lib/henitai/process_wakeup.rb

@@ -13,10 +13,15 @@ module Henitai
       self
     end
 
+    # Also wake on these sockets; +provider+ is asked for them on every wait,
+    # so a connection that was lost can drop out of the set.
+    def watch(&provider)
+      @watched = provider
+      self
+    end
+
     def wait(timeout)
-      # rubocop:disable Lint/IncompatibleIoSelectWithFiberScheduler
-      IO.select([reader], nil, nil, timeout)
-      # rubocop:enable Lint/IncompatibleIoSelectWithFiberScheduler
+      IO.select([reader, *@watched&.call], nil, nil, timeout)
     rescue Errno::EINTR
       nil
     end

data/lib/henitai/process_worker_runner.rb

@@ -27,6 +27,10 @@ module Henitai
         Process.wait(pid)
       end
 
+      def pause(seconds)
+        Kernel.sleep(seconds)
+      end
+
       def trap(signal, handler = nil, &block)
         Kernel.trap(signal, handler || block)
       end
@@ -35,10 +39,11 @@ module Henitai
     # Loop primitives the {SlotScheduler} reads back from its host.
     attr_reader :worker_count, :runtime, :wakeup
 
-    def initialize(worker_count:, runtime: Runtime.new, wakeup: nil)
+    def initialize(worker_count:, runtime: Runtime.new, wakeup: nil, flaky_tests: nil)
       @worker_count = worker_count
       @runtime = runtime
       @wakeup = wakeup
+      @flaky_tests = flaky_tests
       @shutdown_requested = false
     end
 
@@ -85,18 +90,21 @@ module Henitai
     def prepare_run(mutants, integration, config, progress_reporter, options)
       @shutdown_requested = false
       @wakeup = Henitai::ProcessWakeup.new.install if @wakeup.nil?
+      @wakeup.watch { @runtime.wakeup_ios } if @runtime.respond_to?(:wakeup_ios)
       @scheduler = SlotScheduler.new(
         integration: integration,
         config: config,
         progress_reporter: progress_reporter,
         options: options,
-        host: self
+        host: self,
+        flaky_tests: @flaky_tests
       )
       @scheduler.enqueue(mutants)
     end
 
     def event_loop
       saved_traps = install_signal_traps
+      @scheduler.fill_idle_slots
       loop do
         break if @scheduler.done?
 
@@ -108,7 +116,6 @@ module Henitai
     end
 
     def process_cycle
-      @scheduler.fill_idle_slots unless @shutdown_requested
       @scheduler.reap_all_completed_children
       @scheduler.check_timeouts
       @scheduler.fill_idle_slots unless @shutdown_requested
@@ -129,14 +136,21 @@ module Henitai
     end
 
     def wait_for_next_event
-      @wakeup&.wait(@scheduler.next_event_timeout)
+      @wakeup&.wait(next_wait_timeout)
       @wakeup&.drain
     end
 
+    # An event the runtime already read off its socket cannot wake the select.
+    def next_wait_timeout
+      return 0 if @runtime.respond_to?(:pending_events?) && @runtime.pending_events?
+
+      @scheduler.next_event_timeout
+    end
+
     def install_signal_traps
       saved = {}
       %w[INT TERM HUP].each do |sig|
-        saved[sig] = @runtime.trap(sig) { @shutdown_requested = true }
+        saved[sig] = @runtime.trap(sig) { request_shutdown }
       end
       saved
     end

data/lib/henitai/reporter.rb

@@ -71,6 +71,15 @@ module Henitai
       def canonical_path
         File.join(config.reports_dir, "mutation-report.json")
       end
+
+      # Scoped runs upload the merged canonical report so that they do not
+      # replace the full report with a partial one.
+      def merged_schema_for(result)
+        schema = result.to_stryker_schema
+        return schema if authoritative?(result)
+
+        CanonicalReportMerger.merge(schema, canonical_path, prune_missing: true)
+      end
     end
 
     # Terminal reporter.
@@ -395,6 +404,8 @@ module Henitai
 
         FileUtils.mkdir_p(File.dirname(history_report_path))
         File.write(history_report_path, JSON.pretty_generate(store.trend_report))
+      rescue StandardError => e
+        warn "henitai: could not export mutation history (#{e.class}: #{e.message})"
       end
 
       def default_history_store
@@ -450,10 +461,7 @@ module Henitai
       end
 
       def schema_for(result)
-        schema = result.to_stryker_schema
-        return schema if authoritative?(result)
-
-        CanonicalReportMerger.merge(schema, canonical_path, prune_missing: true)
+        merged_schema_for(result)
       end
 
       def escaped_report_json(schema)
@@ -515,9 +523,8 @@ module Henitai
       end
 
       def ignore_reason_for(mutant)
-        return nil unless mutant.respond_to?(:ignore_reason)
-
-        reason = mutant.ignore_reason
+        reason = mutant.status_reason if mutant.respond_to?(:status_reason)
+        reason ||= mutant.ignore_reason if mutant.respond_to?(:ignore_reason)
         reason ? "(#{reason})" : nil
       end
 
@@ -609,7 +616,7 @@ module Henitai
 
       def build_request(result, uri)
         request = Net::HTTP::Put.new(uri.request_uri, request_headers)
-        request.body = JSON.generate(result.to_stryker_schema)
+        request.body = JSON.generate(merged_schema_for(result))
         request
       end