henitai 0.1.10 → 0.2.0

data/lib/henitai/reporter.rb

@@ -90,6 +90,14 @@ module Henitai
       end
 
       def summary_lines(result)
+        if result.respond_to?(:partial_rerun?) && result.partial_rerun?
+          partial_summary_lines(result)
+        else
+          full_summary_lines(result)
+        end
+      end
+
+      def full_summary_lines(result)
         [
           "Mutation testing summary",
           score_line(result),
@@ -101,6 +109,28 @@ module Henitai
         ]
       end
 
+      def partial_summary_lines(result)
+        lines = [
+          "Partial survivor rerun",
+          format_row("Survived", count_status(result, :survived)),
+          format_row("Duration", format_duration(result.duration))
+        ]
+        append_survivor_stats(lines, result)
+        lines
+      end
+
+      def append_survivor_stats(lines, result)
+        return unless result.respond_to?(:survivor_stats)
+
+        stats = result.survivor_stats # : Hash[Symbol, untyped]?
+        return unless stats
+
+        lines << format_row("Matched", stats.fetch(:matched))
+        lines << format_row("Skipped", stats.fetch(:skipped_count, 0))
+        lines << format_row("Unmatched", stats.fetch(:unmatched_count))
+        lines << format_row("Drift warning", stats.fetch(:drift_warning) ? "yes" : "no")
+      end
+
       def survived_detail_lines(result)
         survivors = result.mutants.select(&:survived?)
         return [] if survivors.empty?
@@ -212,14 +242,57 @@ module Henitai
     # JSON reporter.
     class Json < Base
       def report(result)
-        FileUtils.mkdir_p(File.dirname(report_path))
-        File.write(report_path, JSON.pretty_generate(result.to_stryker_schema))
+        schema = result.to_stryker_schema
+        write_canonical(schema)
+        write_session_snapshot(schema)
+        write_activation_recipes(result)
         write_history_report
       end
 
       private
 
-      def report_path
+      def write_canonical(schema)
+        FileUtils.mkdir_p(File.dirname(canonical_path))
+        File.write(canonical_path, JSON.pretty_generate(schema))
+      end
+
+      def write_session_snapshot(schema)
+        session_id = schema[:sessionId]
+        return unless session_id
+
+        path = session_snapshot_path(session_id)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, JSON.pretty_generate(schema))
+      end
+
+      def write_activation_recipes(result)
+        session_id = result.session_id if result.respond_to?(:session_id)
+        return unless session_id
+
+        survived = survived_mutants_for(result)
+        return if survived.empty?
+
+        recipes = SurvivorActivationCache.compute(survived)
+        return if recipes.empty?
+
+        SurvivorActivationCache.write(session_recipe_path(session_id), recipes)
+      end
+
+      def survived_mutants_for(result)
+        return [] unless result.respond_to?(:mutants)
+
+        result.mutants.select(&:survived?)
+      end
+
+      def session_snapshot_path(session_id)
+        File.join(config.reports_dir, "sessions", session_id, "mutation-report.json")
+      end
+
+      def session_recipe_path(session_id)
+        File.join(config.reports_dir, "sessions", session_id, SurvivorActivationCache::FILENAME)
+      end
+
+      def canonical_path
         File.join(config.reports_dir, "mutation-report.json")
       end
 

data/lib/henitai/result.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "securerandom"
 require_relative "unparse_helper"
 
 module Henitai
@@ -13,14 +14,25 @@ module Henitai
     SCHEMA_VERSION = "1.0"
     DEFAULT_THRESHOLDS = { high: 80, low: 60 }.freeze
 
-    attr_reader :mutants, :started_at, :finished_at, :thresholds
+    attr_reader :mutants, :started_at, :finished_at, :thresholds, :survivor_stats,
+                :session_id, :git_sha
 
-    def initialize(mutants:, started_at:, finished_at:, thresholds: nil)
-      @mutants     = mutants
-      @started_at  = started_at
-      @finished_at = finished_at
-      @thresholds  = DEFAULT_THRESHOLDS.merge(thresholds || {})
+    # 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)
+      @mutants        = mutants
+      @started_at     = started_at
+      @finished_at    = finished_at
+      @thresholds     = DEFAULT_THRESHOLDS.merge(thresholds || {})
+      @partial_rerun  = partial_rerun
+      @survivor_stats = survivor_stats
+      @session_id     = session_id
+      @git_sha        = git_sha
     end
+    # rubocop:enable Metrics/ParameterLists
+
+    def partial_rerun? = @partial_rerun
 
     # @return [Integer] number of killed mutants
     def killed   = mutants.count(&:killed?)
@@ -88,14 +100,32 @@ module Henitai
     # Serialise to Stryker mutation-testing-report-schema JSON (schema 1.0).
     # @return [Hash]
     def to_stryker_schema
-      {
+      schema = base_schema
+      sha = @git_sha
+      schema[:gitSha] = sha if sha
+      return schema unless partial_rerun?
+
+      schema[:partialRerun] = true
+      schema[:unmatchedSurvivorIds] = unmatched_survivor_ids
+      schema
+    end
+
+    private
+
+    def base_schema
+      { # : Hash[Symbol, untyped]
         schemaVersion: SCHEMA_VERSION,
+        sessionId: @session_id,
         thresholds: thresholds,
         files: build_files_section
       }
     end
 
-    private
+    def unmatched_survivor_ids
+      return survivor_stats.fetch(:unmatched_ids) if survivor_stats
+
+      [] # : Array[String]
+    end
 
     def build_files_section
       mutants.group_by { |m| m.location[:file] }.transform_values do |file_mutants|
@@ -115,6 +145,7 @@ module Henitai
     def mutant_to_schema(mutant)
       {
         id: mutant.id,
+        stableId: mutant.stable_id,
         mutatorName: mutant.operator,
         replacement: replacement_for(mutant),
         location: location_for(mutant),

data/lib/henitai/runner.rb

@@ -25,28 +25,39 @@ module Henitai
   #   Gate 5 — Reporting
   #     Write results to configured reporters (terminal, html, json, dashboard).
   #
+  # rubocop:disable Metrics/ClassLength
   class Runner
     attr_reader :config, :result
 
-    def initialize(config: Configuration.load, subjects: nil, since: nil)
-      @config   = config
-      @subjects = subjects
-      @since    = since
+    def initialize(config: Configuration.load, subjects: nil, since: nil, survivors_from: nil)
+      @config         = config
+      @subjects       = subjects
+      @since          = since
+      @survivors_from = survivors_from
     end
 
     # Entry point — runs the full pipeline and returns a Result.
     #
-    # Coverage bootstrap (Gate 0) runs in a background thread so that Gate 1
-    # (subject resolution) and Gate 2 (mutant generation) proceed concurrently.
-    # The thread is joined before Gate 3 (static filtering), which is the first
-    # phase that requires coverage data.
+    # Fast path (recipe rerun): when +--survivors-from+ is given and an
+    # +activation-recipes.json+ file exists beside the report with entries for
+    # all survivor IDs, stub Mutants are built from the recipes and the full
+    # source-parse / mutant-generation pipeline is skipped entirely.
+    #
+    # Normal path: Coverage bootstrap (Gate 0) runs in a background thread so
+    # that Gate 1 (subject resolution) and Gate 2 (mutant generation) proceed
+    # concurrently. The thread is joined before Gate 3 (static filtering).
     #
     # @return [Result]
     def run
       started_at = Time.now
-      source_files = self.source_files
-      subjects = resolve_subjects(source_files)
-      mutants = execute_mutants(mutants_for(subjects, source_files))
+
+      mutants = if survivor_rerun? && (fast_mutants = try_recipe_run)
+                  execute_mutants(fast_mutants)
+                else
+                  source_files = self.source_files
+                  subjects = resolve_subjects(source_files)
+                  execute_mutants(mutants_for(subjects, source_files))
+                end
 
       build_result(mutants, started_at, Time.now)
     end
@@ -75,8 +86,8 @@ module Henitai
       bootstrap_thread = bootstrap_mutants(source_files)
       mutants = generate_mutants(subjects)
       bootstrap_thread.value
-
-      filter_mutants(mutants)
+      filtered = filter_mutants(mutants)
+      apply_survivor_selection(filtered)
     end
 
     def bootstrap_mutants(source_files)
@@ -109,13 +120,24 @@ module Henitai
         mutants:,
         started_at:,
         finished_at:,
-        thresholds: result_thresholds
+        thresholds: result_thresholds,
+        partial_rerun: survivor_rerun?,
+        survivor_stats: @survivor_stats,
+        git_sha: safe_head_sha
       )
       persist_history(@result, finished_at)
       report(@result)
       @result
     end
 
+    def safe_head_sha
+      git_diff_analyzer.head_sha
+    rescue StandardError
+      # `head_sha` rescues Errno::ENOENT. This extra rescue is defensive for
+      # unexpected Open3/git runtime errors; conservative fallback is `nil`.
+      nil
+    end
+
     def bootstrap_coverage(source_files, test_files = nil)
       coverage_bootstrapper.ensure!(source_files:, config:, integration:, test_files:)
     end
@@ -200,5 +222,172 @@ module Henitai
 
       config.thresholds
     end
+
+    def survivor_rerun?
+      !@survivors_from.nil?
+    end
+
+    def apply_survivor_selection(mutants)
+      return mutants unless survivor_rerun?
+
+      dirty_worktree_files = dirty_worktree_changed_files
+      loaded   = SurvivorLoader.new(@survivors_from, include_paths: Array(config.includes)).load
+      selector = SurvivorSelector.new(survivor_ids: loaded.survivor_ids)
+      selected = selector.select(mutants)
+      finalize_survivor_split(
+        selector,
+        selected,
+        test_filter(
+          loaded,
+          dirty_source_files: dirty_source_files?(dirty_worktree_files, git_sha: loaded.git_sha)
+        ).apply(selected)
+      )
+    end
+
+    # Attempts to run survivors directly from pre-computed activation recipes,
+    # bypassing source parsing and mutant generation entirely.
+    # Returns the mutant array on success, or nil if recipes are unavailable.
+    def try_recipe_run
+      dirty_worktree_files = dirty_worktree_changed_files
+      loaded = load_survivor_report
+      return nil unless recipe_fast_path_safe?(loaded, dirty_worktree_files)
+
+      run_from_recipes(loaded, dirty_worktree_files)
+    end
+
+    def load_survivor_report
+      SurvivorLoader.new(@survivors_from, include_paths: Array(config.includes)).load
+    end
+
+    def run_from_recipes(loaded, dirty_worktree_files)
+      recipes = load_activation_recipes(loaded.survivor_ids)
+      return nil if recipes.nil?
+
+      selector, stubs = recipe_selector_and_stubs(loaded.survivor_ids, recipes)
+      split = test_filter(
+        loaded,
+        dirty_source_files: dirty_source_files?(dirty_worktree_files, git_sha: loaded.git_sha)
+      ).apply(stubs)
+      finalize_survivor_split(selector, stubs, split)
+    end
+
+    def recipe_fast_path_safe?(loaded, dirty_worktree_files)
+      !dirty_source_files?(dirty_worktree_files, git_sha: loaded.git_sha)
+    end
+
+    # Builds stub Mutants from recipes and a SurvivorSelector primed with the
+    # survivor ID set. The selector is given a synthetic #select call so that
+    # #drift_warning? / #unmatched_ids are available (all IDs will be matched).
+    def recipe_selector_and_stubs(survivor_ids, recipes)
+      stubs    = survivor_ids.map { |id| build_stub_mutant(id, recipes[id]) }
+      selector = SurvivorSelector.new(survivor_ids:)
+      selector.select(stubs)
+      [selector, stubs]
+    end
+
+    # Returns the recipe hash if the file exists and covers every survivor ID;
+    # otherwise returns nil to trigger the normal generation path.
+    def load_activation_recipes(survivor_ids)
+      path    = File.join(File.dirname(@survivors_from), SurvivorActivationCache::FILENAME)
+      recipes = SurvivorActivationCache.load(path)
+      return nil if recipes.nil?
+      return nil unless survivor_ids.all? { |id| recipes.key?(id) }
+
+      recipes
+    end
+
+    def build_stub_mutant(stable_id, recipe)
+      mutant = Mutant.new(
+        subject: stub_subject_from_recipe(recipe),
+        operator: recipe.fetch("operator"),
+        nodes: { original: nil, mutated: nil },
+        description: recipe.fetch("description"),
+        location: recipe_location(recipe["location"]),
+        precomputed_stable_id: stable_id,
+        precomputed_activation_source: recipe.fetch("activationSource")
+      )
+      mutant.covered_by = recipe["coveredBy"]
+      mutant
+    end
+
+    def stub_subject_from_recipe(recipe)
+      Subject.new(
+        namespace: recipe["namespace"],
+        method_name: recipe["methodName"],
+        method_type: (recipe["methodType"] || "instance").to_sym,
+        source_location: { file: recipe["sourceFile"], range: nil }
+      )
+    end
+
+    def recipe_location(loc)
+      return {} unless loc.is_a?(Hash)
+
+      {
+        file: loc["file"],
+        start_line: loc["startLine"],
+        end_line: loc["endLine"],
+        start_col: loc["startCol"],
+        end_col: loc["endCol"]
+      }.compact
+    end
+
+    def finalize_survivor_split(selector, selected, split)
+      split[:stable].each { |m| m.status = :survived }
+      warn_survivor_drift(selector) if selector.drift_warning?
+      @survivor_stats = build_survivor_stats(selector, selected, split)
+      split[:stable] + split[:pending]
+    end
+
+    def test_filter(loaded, dirty_source_files: false)
+      SurvivorTestFilter.new(
+        coverage_map: loaded.coverage_map,
+        git_sha: loaded.git_sha,
+        dirty_source_files:,
+        worktree_changed_files: Array(dirty_worktree_changed_files),
+        diff_analyzer: git_diff_analyzer
+      )
+    end
+
+    def dirty_worktree_changed_files
+      @dirty_worktree_changed_files ||= git_diff_analyzer.working_tree_changed_files
+    rescue StandardError
+      nil
+    end
+
+    def dirty_source_files?(dirty_worktree_files, git_sha: nil)
+      return true if dirty_worktree_files.nil?
+
+      all_changed = dirty_worktree_files + committed_changed_files(git_sha)
+      include_roots = Array(config.includes).map { |path| normalize_path(path) }
+      all_changed.any? { |path| in_include_root?(normalize_path(path), include_roots) }
+    rescue StandardError
+      true
+    end
+
+    def committed_changed_files(git_sha)
+      return [] unless git_sha
+
+      git_diff_analyzer.changed_files(from: git_sha, to: "HEAD")
+    end
+
+    def in_include_root?(path, include_roots)
+      include_roots.any? { |root| path == root || path.start_with?("#{root}/") }
+    end
+
+    def warn_survivor_drift(selector)
+      warn "henitai: WARNING: #{selector.unmatched_ids.size} prior survivors " \
+           "could not be matched; the source may have drifted - consider a full run"
+    end
+
+    def build_survivor_stats(selector, selected, split)
+      {
+        matched: selected.size,
+        unmatched_count: selector.unmatched_ids.size,
+        unmatched_ids: selector.unmatched_ids,
+        skipped_count: split[:stable].size,
+        drift_warning: selector.drift_warning?
+      }
+    end
   end
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/henitai/scenario_execution_result.rb

@@ -7,7 +7,7 @@ module Henitai
 
     def self.build(wait_result:, stdout:, stderr:, log_path:)
       new(
-        status: status_for(wait_result),
+        status: status_for(wait_result, stdout:, stderr:),
         stdout: stdout,
         stderr: stderr,
         log_path: log_path,
@@ -62,7 +62,7 @@ module Henitai
     end
 
     def should_show_logs?(all_logs: nil)
-      all_logs || timeout?
+      all_logs || timeout? || status == :compile_error
     end
 
     def failure_tail(all_logs: nil, lines: 12)
@@ -77,8 +77,10 @@ module Henitai
     class << self
       private
 
-      def status_for(wait_result)
+      def status_for(wait_result, stdout:, stderr:)
         return :timeout if wait_result == :timeout
+        return :compile_error if no_examples_found?(stdout, stderr)
+        return :compile_error if zero_examples_failure?(wait_result, stdout, stderr)
         return :compile_error if exit_status_for(wait_result) == 2
         return :survived if wait_result.respond_to?(:success?) && wait_result.success?
 
@@ -91,6 +93,17 @@ module Henitai
 
         wait_result.exitstatus
       end
+
+      def no_examples_found?(stdout, stderr)
+        stdout.to_s.include?("No examples found.") || stderr.to_s.include?("No examples found.")
+      end
+
+      def zero_examples_failure?(wait_result, stdout, stderr)
+        return false unless exit_status_for(wait_result) == 1
+
+        output = [stdout.to_s, stderr.to_s].join("\n")
+        output.include?("0 examples, 0 failures")
+      end
     end
 
     def stream_section(name, content)

data/lib/henitai/static_filter.rb

@@ -37,11 +37,18 @@ module Henitai
 
       coverage_lines = coverage_lines_by_file(coverage_report_path)
       coverage_lines = merge_method_coverage(coverage_lines, coverage_report_path)
-      return coverage_lines unless coverage_lines.empty?
-
-      coverage_lines_from_test_lines(
+      per_test_lines = coverage_lines_from_test_lines(
         test_lines_by_file(per_test_coverage_report_path)
       )
+
+      return per_test_lines if coverage_lines.empty?
+
+      # Merge per-test coverage into the standard coverage map.
+      # Standard coverage may be incomplete when child processes fork before
+      # all files are loaded; per-test coverage widens the result set.
+      per_test_lines.each_with_object(coverage_lines) do |(file, lines), merged|
+        merged[file] = ((merged[file] || []) + lines).uniq.sort
+      end
     end
 
     def coverage_lines_by_file(path = DEFAULT_COVERAGE_REPORT_PATH)

data/lib/henitai/survivor_activation_cache.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Henitai
+  # Stores and retrieves pre-computed +define_method+ activation sources for
+  # survived mutants, enabling survivor reruns to skip the full mutant-generation
+  # pipeline.
+  #
+  # The cache artifact (+activation-recipes.json+) is written alongside the
+  # session snapshot in +reports/sessions/<session_id>/+. When a survivor rerun
+  # finds this file next to the report it was given, it can build stub Mutant
+  # objects directly and execute them without re-parsing source files.
+  #
+  # A recipe entry encodes everything needed to activate and re-report a mutant:
+  # the +define_method+ source, subject coordinates, operator, description,
+  # location, and the coveredBy test list.
+  class SurvivorActivationCache
+    FILENAME = "activation-recipes.json"
+
+    # Build a recipe hash for each survived mutant that has a computable
+    # activation source.
+    #
+    # @param survived_mutants [Array<Mutant>]
+    # @return [Hash<String, Hash>] stableId → recipe
+    def self.compute(survived_mutants)
+      survived_mutants.each_with_object({}) do |mutant, cache|
+        source = Mutant::Activator.activation_source_for(mutant)
+        next unless source
+
+        cache[mutant.stable_id] = build_recipe(mutant, source)
+      end
+    end
+
+    # @param path [String] path to +activation-recipes.json+
+    # @return [Hash, nil] nil when the file is absent or unparseable
+    def self.load(path)
+      return nil unless File.exist?(path)
+
+      JSON.parse(File.read(path))
+    rescue JSON::ParserError
+      nil
+    end
+
+    # @param path    [String]
+    # @param recipes [Hash<String, Hash>]
+    def self.write(path, recipes)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, JSON.pretty_generate(recipes))
+    end
+
+    class << self
+      private
+
+      def build_recipe(mutant, activation_source)
+        {
+          "activationSource" => activation_source,
+          "namespace" => mutant.subject.namespace,
+          "methodName" => mutant.subject.method_name,
+          "methodType" => mutant.subject.method_type.to_s,
+          "sourceFile" => mutant.subject.source_file,
+          "operator" => mutant.operator,
+          "description" => mutant.description,
+          "location" => serialize_location(mutant.location),
+          "coveredBy" => Array(mutant.covered_by).compact
+        }
+      end
+
+      def serialize_location(location)
+        {
+          "file" => location[:file],
+          "startLine" => location[:start_line],
+          "endLine" => location[:end_line],
+          "startCol" => location[:start_col],
+          "endCol" => location[:end_col]
+        }.compact
+      end
+    end
+  end
+end