henitai 0.5.1 → 0.6.0

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
 

data/lib/henitai/result.rb

@@ -26,9 +26,8 @@ module Henitai
       process_abort: true
     }.freeze
 
-    # Maps each criterion to the mutant status it governs. process_abort has no
-    # producer in lib/ yet -- nothing classifies a mutant as :runtime_error --
-    # so that entry is forward-looking wiring rather than a live code path.
+    # Maps each criterion to the mutant status it governs. MutantVerdict emits
+    # :runtime_error for process aborts, signals, and unknown child outcomes.
     CRITERION_STATUSES = {
       test_result: :killed,
       timeout: :timeout,
@@ -36,7 +35,7 @@ module Henitai
     }.freeze
 
     attr_reader :mutants, :started_at, :finished_at, :thresholds, :survivor_stats,
-                :session_id, :git_sha, :since, :coverage_criteria
+                :session_id, :git_sha, :since, :coverage_criteria, :complete_files, :sampling
 
     # @param source_provider [#call] maps a file path to its source string.
     #   Injected so the domain object performs no disk IO; the caller (which
@@ -48,12 +47,16 @@ module Henitai
     #   canonical report; non-authoritative (subject-scoped, --since,
     #   --survivors-from) runs are merged into it instead — see
     #   CanonicalReportMerger.
+    # @param complete_files [Array<String>, nil] source files this run mutated
+    #   completely (every subject). The merger replaces a prior report's entry
+    #   for such a file wholesale instead of merging by stableId, so stale
+    #   mutants of changed or deleted code do not linger.
     # rubocop:disable Metrics/ParameterLists
     def initialize(mutants:, started_at:, finished_at:, thresholds: nil,
                    partial_rerun: false, survivor_stats: nil,
                    session_id: SecureRandom.uuid, git_sha: nil,
                    source_provider: ->(_file) { "" }, authoritative: true,
-                   since: nil, coverage_criteria: nil)
+                   since: nil, coverage_criteria: nil, complete_files: nil, sampling: nil)
       @mutants         = mutants
       @started_at      = started_at
       @finished_at     = finished_at
@@ -65,7 +68,9 @@ module Henitai
       @source_provider = source_provider
       @authoritative   = authoritative
       @since           = since
+      @complete_files = Array(complete_files)
       @coverage_criteria = DEFAULT_COVERAGE_CRITERIA.merge(coverage_criteria || {})
+      @sampling = sampling
     end
     # rubocop:enable Metrics/ParameterLists
 
@@ -89,11 +94,12 @@ module Henitai
 
     # Mutation Score (MS) — Architektur-Formel aus Abschnitt 6.1:
     #
-    #   MS = detected / (total − ignored − no_coverage − compile_error − equivalent)
+    #   MS = detected / (total − ignored − no_coverage − compile_error − equivalent − pending)
     #
     # Confirmed equivalent mutants werden aus BEIDEN Seiten der Gleichung entfernt:
     # Sie sind weder im Zähler (nicht detektierbar) noch im Nenner (nicht testbar).
-    # Das ist der entscheidende Unterschied zum MSI.
+    # Das ist der entscheidende Unterschied zum MSI. Pending mutants (left over from
+    # an interrupted run, without a verdict) are excluded from both sides as well.
     #
     # @return [Float, nil] 0.0–100.0, nil wenn kein valider Mutant vorhanden
     def mutation_score
@@ -102,8 +108,9 @@ module Henitai
 
     # Mutation Score Indicator (MSI) — naive Berechnung ohne Äquivalenz-Bereinigung:
     #
-    #   MSI = killed / all_mutants
+    #   MSI = killed / (total − pending)
     #
+    # Only mutants with a verdict count; pending mutants have none.
     # MSI ist immer ≤ MS. Der Unterschied kommuniziert die Äquivalenz-Unsicherheit.
     # Beide Werte MÜSSEN im Report zusammen ausgewiesen werden (Anti-Pattern: nur MS).
     #
@@ -151,6 +158,8 @@ module Henitai
       schema = base_schema
       sha = @git_sha
       schema[:gitSha] = sha if sha
+      schema[:completeFiles] = complete_files if complete_files.any? && !authoritative?
+      schema[:sampling] = @sampling if @sampling
       return schema unless partial_rerun?
 
       schema[:partialRerun] = true
@@ -171,7 +180,7 @@ module Henitai
     end
 
     def mutation_score_for(list)
-      excluded = %i[ignored no_coverage compile_error equivalent]
+      excluded = %i[ignored no_coverage compile_error equivalent pending]
       valid = list.reject { |m| excluded.include?(m.status) }
       return nil if valid.empty?
 
@@ -179,9 +188,10 @@ module Henitai
     end
 
     def mutation_score_indicator_for(list)
-      return nil if list.empty?
+      decided = list.reject { |m| m.status == :pending }
+      return nil if decided.empty?
 
-      ((list.count(&:killed?).to_f / list.count) * 100.0).round(2).to_f
+      ((decided.count(&:killed?).to_f / decided.count) * 100.0).round(2).to_f
     end
 
     def base_schema
@@ -205,10 +215,16 @@ module Henitai
           language: "ruby",
           source: @source_provider.call(file_mutants.first.location[:file]),
           mutants: file_mutants.map { |m| mutant_to_schema(m) }
-        }
+        }.merge(file_provenance)
       end
     end
 
+    # Vendor fields: which run produced this file entry. Kept per file so a
+    # merged report can tell which session snapshot holds its mutants.
+    def file_provenance
+      { sessionId: @session_id, gitSha: @git_sha }.compact
+    end
+
     def mutant_to_schema(mutant)
       {
         id: mutant.id,
@@ -261,11 +277,11 @@ module Henitai
     end
 
     # Serialized as the schema's statusReason so directive reasons show up
-    # next to the Ignored status in the HTML report.
+    # next to the Ignored status, and harness reasons (a failed fidelity
+    # check, for example) next to CompileError, in the HTML report.
     def status_reason_for(mutant)
-      return nil unless mutant.respond_to?(:ignore_reason)
-
-      mutant.ignore_reason
+      reason = mutant.status_reason if mutant.respond_to?(:status_reason)
+      reason || (mutant.ignore_reason if mutant.respond_to?(:ignore_reason))
     end
 
     # Vendored extension field (like stableId): marks verdicts reused from

data/lib/henitai/reuse_context.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+
+require_relative "verdict_fingerprint"
+
+module Henitai
+  # Run-level fingerprint of everything outside a mutant and its covering
+  # tests that can change a verdict: the test dependency files, the
+  # verdict-relevant configuration and the henitai version. Recorded with every
+  # cached Killed/Survived verdict and required to match for reuse.
+  #
+  # Computed once per instance, so the filter that reads verdicts and the
+  # history store that writes them always agree. nil when the dependency files
+  # cannot be read — nothing is then reusable.
+  class ReuseContext
+    def initialize(config:, version: Henitai::VERSION, root: Dir.pwd)
+      @config = config
+      @version = version
+      @root = root
+    end
+
+    def fingerprint
+      return @fingerprint if defined?(@fingerprint)
+
+      @fingerprint = compute
+    end
+
+    private
+
+    def compute
+      dependencies = VerdictFingerprint.dependency_fingerprint(@root)
+      return nil unless dependencies
+
+      Digest::SHA256.hexdigest(JSON.generate(components(dependencies)))
+    end
+
+    def components(dependencies)
+      {
+        "dependencies" => dependencies,
+        "version" => @version,
+        "integration" => @config.integration.to_s,
+        "operators" => @config.operators.to_s,
+        "test_excludes" => Array(@config.test_excludes).map(&:to_s).sort,
+        "coverage_criteria" => @config.coverage_criteria.to_h.sort_by { |key, _| key.to_s }
+      }
+    end
+  end
+end

data/lib/henitai/rspec_coverage_formatter.rb

@@ -5,6 +5,10 @@ require "henitai/coverage_formatter"
 
 RSpec::Core::Formatters.register(
   Henitai::CoverageFormatter,
+  :example_started,
   :example_finished,
+  :example_group_started,
+  :example_group_finished,
+  :message,
   :dump_summary
 )