henitai 0.1.10 → 0.2.1

data/lib/henitai/survivor_rerun_strategy.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Survivor-rerun fast path for {Runner}.
+  #
+  # When +--survivors-from+ is given, this collaborator loads the prior report
+  # and either:
+  #
+  #   * builds stub Mutants directly from +activation-recipes.json+ (the recipe
+  #     fast path, bypassing source parsing and mutant generation), or
+  #   * filters a freshly generated mutant list down to the prior survivors.
+  #
+  # In both cases it records {#survivor_stats} (matched/unmatched counts and the
+  # drift warning) for the Runner to attach to its Result.
+  class SurvivorRerunStrategy
+    attr_reader :survivor_stats
+
+    def initialize(survivors_from:, config:, git_diff_analyzer:)
+      @survivors_from = survivors_from
+      @config = config
+      @git_diff_analyzer = git_diff_analyzer
+      @survivor_stats = nil
+    end
+
+    def active?
+      !@survivors_from.nil?
+    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 apply_selection(mutants)
+      dirty_worktree_files = dirty_worktree_changed_files
+      loaded   = load_survivor_report
+      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
+
+    private
+
+    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 normalize_path(path)
+      File.expand_path(path)
+    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
+end

data/lib/henitai/survivor_selector.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Filters a mutant list to those that match a set of prior survivor stable IDs.
+  #
+  # After calling #select, #unmatched_ids reports which survivor IDs had no
+  # corresponding mutant in the current generation. A high unmatched ratio
+  # indicates that the source has drifted and a full run is recommended.
+  class SurvivorSelector
+    DRIFT_THRESHOLD = 0.5
+    class SelectionError < StandardError; end
+
+    def initialize(survivor_ids:)
+      @survivor_ids  = survivor_ids.to_set
+      @unmatched_ids = nil
+    end
+
+    def select(mutants)
+      current_index = mutants.to_h { |m| [m.stable_id, m] }
+      matched_ids, @unmatched_ids = @survivor_ids.partition { |id| current_index.key?(id) }
+      matched_ids.filter_map { |id| current_index[id] }
+    end
+
+    def unmatched_ids
+      raise SelectionError, "Call #select before accessing #unmatched_ids" if @unmatched_ids.nil?
+
+      @unmatched_ids
+    end
+
+    def drift_warning?
+      return false if @survivor_ids.empty?
+
+      unmatched_ids.size.to_f / @survivor_ids.size > DRIFT_THRESHOLD
+    end
+  end
+end

data/lib/henitai/survivor_test_filter.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Splits a matched survivor set into stable and pending subsets by consulting
+  # a git diff against the covering tests from the prior report.
+  #
+  # A survivor is **stable** (can skip re-execution) when:
+  #   - it has covering test data in the prior report, AND
+  #   - none of those test files appear in the diff between the prior run's
+  #     git_sha and the current HEAD.
+  #
+  # A survivor is **pending** (must execute) when:
+  #   - git_sha is nil (no anchor → conservative), OR
+  #   - its coveredBy data is absent or empty, OR
+  #   - at least one covering test file changed.
+  #
+  # On any git error the filter conservatively treats all survivors as pending.
+  class SurvivorTestFilter
+    # @param coverage_map  [Hash<String, Array<String>>] stableId → [test_files]
+    # @param git_sha       [String, nil] git SHA from the prior report
+    # @param dirty_source_files [Boolean] true when the current worktree has
+    #   dirty source files and the survivor shortcut must be disabled
+    # @param worktree_changed_files [Array<String>] dirty tracked/untracked files
+    # @param diff_analyzer [GitDiffAnalyzer]
+    def initialize(
+      coverage_map:,
+      git_sha:,
+      dirty_source_files: false,
+      worktree_changed_files: [],
+      diff_analyzer: GitDiffAnalyzer.new
+    )
+      @coverage_map  = coverage_map
+      @git_sha       = git_sha
+      @dirty_source_files = dirty_source_files
+      @worktree_changed_files = Array(worktree_changed_files)
+      @diff_analyzer = diff_analyzer
+    end
+
+    # @param mutants [Array<Mutant>]
+    # @return [Hash<Symbol, Array<Mutant>>] { stable: [...], pending: [...] }
+    def apply(mutants)
+      return { stable: [], pending: mutants } if @dirty_source_files
+      return { stable: [], pending: mutants } if @git_sha.nil?
+
+      changed = changed_test_files
+      return { stable: [], pending: mutants } if changed.nil?
+
+      mutants.each_with_object({ stable: [], pending: [] }) do |mutant, result|
+        bucket = stable_survivor?(mutant, changed) ? :stable : :pending
+        result[bucket] << mutant
+      end
+    end
+
+    private
+
+    def stable_survivor?(mutant, changed)
+      covering = @coverage_map[mutant.stable_id]
+      return false if covering.nil? || covering.empty?
+
+      covering.none? { |test_file| changed.include?(test_file) }
+    end
+
+    # Returns a Set of changed test file paths, or nil on any git error
+    # (nil triggers conservative fallback in #apply — all survivors pending).
+    def changed_test_files
+      committed = @diff_analyzer.changed_files(from: @git_sha, to: "HEAD")
+      (committed + @worktree_changed_files).to_set
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/henitai/unparse_helper.rb

@@ -9,8 +9,11 @@ module Henitai
 
     def safe_unparse(node)
       Unparser.unparse(node)
-    rescue StandardError
-      # Unparser does not support all AST node types, so fall back gracefully.
+    rescue Unparser::UnknownNodeError, Unparser::InvalidNodeError,
+           Unparser::UnsupportedNodeError, EncodingError
+      # Unparser does not support all AST node types, and some mutated string
+      # segments carry incompatible encodings; fall back gracefully for those.
+      # Other failures (e.g. NoMethodError) are bugs and must surface.
       fallback_source(node)
     end
 

data/lib/henitai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Henitai
-  VERSION = "0.1.10"
+  VERSION = "0.2.1"
 end

data/lib/henitai.rb

@@ -26,6 +26,7 @@ module Henitai
   autoload :PerTestCoverageSelector, "henitai/per_test_coverage_selector"
   autoload :Subject, "henitai/subject"
   autoload :Mutant, "henitai/mutant"
+  autoload :MutantIdentity, "henitai/mutant_identity"
   autoload :Operator, "henitai/operator"
   autoload :Operators, "henitai/operators"
   autoload :SourceParser, "henitai/source_parser"
@@ -39,6 +40,11 @@ module Henitai
   autoload :EquivalenceDetector, "henitai/equivalence_detector"
   autoload :StaticFilter, "henitai/static_filter"
   autoload :StillbornFilter, "henitai/stillborn_filter"
+  autoload :SurvivorLoader,          "henitai/survivor_loader"
+  autoload :SurvivorSelector,        "henitai/survivor_selector"
+  autoload :SurvivorTestFilter,      "henitai/survivor_test_filter"
+  autoload :SurvivorActivationCache, "henitai/survivor_activation_cache"
+  autoload :SurvivorRerunStrategy, "henitai/survivor_rerun_strategy"
   autoload :ScenarioExecutionResult, "henitai/scenario_execution_result"
   autoload :CoverageFormatter, "henitai/coverage_formatter"
   autoload :MinitestCoverageReporter, "henitai/minitest_coverage_reporter"
@@ -47,6 +53,10 @@ module Henitai
   autoload :SamplingStrategy, "henitai/sampling_strategy"
   autoload :TestPrioritizer, "henitai/test_prioritizer"
   autoload :ExecutionEngine, "henitai/execution_engine"
+  autoload :ParallelExecutionRunner, "henitai/parallel_execution_runner"
+  autoload :ProcessWorkerRunner, "henitai/process_worker_runner"
+  autoload :SlotScheduler, "henitai/slot_scheduler"
+  autoload :ProcessWakeup, "henitai/process_wakeup"
   autoload :Runner, "henitai/runner"
   autoload :Reporter, "henitai/reporter"
   autoload :Integration, "henitai/integration"

data/sig/configuration_validator.rbs

@@ -1,29 +1,53 @@
 module Henitai
   module ConfigurationValidator
+    VALID_TOP_LEVEL_KEYS: Array[Symbol]
+    VALID_MUTATION_KEYS: Array[Symbol]
+    VALID_SAMPLING_KEYS: Array[Symbol]
+    VALID_COVERAGE_CRITERIA_KEYS: Array[Symbol]
+    VALID_THRESHOLDS_KEYS: Array[Symbol]
+    VALID_DASHBOARD_KEYS: Array[Symbol]
+    VALID_INTEGRATION_KEYS: Array[Symbol]
+    VALID_OPERATORS: Array[Symbol]
+    VALIDATION_STEPS: Array[Symbol]
+
     def self.validate!: (Hash[Symbol, untyped]) -> void
+    def self.warn: (String) -> void
 
-    private
+    module Rules
+      def self?.validate_top_level_keys: (Hash[Symbol, untyped]) -> void
+      def self?.validate_integration: (Hash[Symbol, untyped]) -> void
+      def self?.validate_includes: (Hash[Symbol, untyped]) -> void
+      def self?.validate_excludes: (Hash[Symbol, untyped]) -> void
+      def self?.validate_jobs: (Hash[Symbol, untyped]) -> void
+      def self?.validate_reporters: (Hash[Symbol, untyped]) -> void
+      def self?.validate_reports_dir: (Hash[Symbol, untyped]) -> void
+      def self?.validate_all_logs: (Hash[Symbol, untyped]) -> void
+      def self?.validate_dashboard: (Hash[Symbol, untyped]) -> void
+      def self?.validate_mutation: (Hash[Symbol, untyped]) -> void
+      def self?.validate_mutation_limits: (Hash[Symbol, untyped]) -> void
+      def self?.validate_mutation_filters: (Hash[Symbol, untyped]) -> void
+      def self?.validate_coverage_criteria: (Hash[Symbol, untyped]) -> void
+      def self?.validate_thresholds: (Hash[Symbol, untyped]) -> void
+      def self?.validate_sampling: (untyped) -> void
+      def self?.warn_unknown_keys: (Hash[Symbol, untyped], Array[Symbol], ?String?) -> void
+      def self?.key_path: (String?, Symbol) -> String
+      def self?.ensure_hash!: (untyped, String) -> void
+      def self?.configuration_error: (String) -> void
+    end
 
-    def self.validate_top_level_keys: (Hash[Symbol, untyped]) -> void
-    def self.validate_integration: (Hash[Symbol, untyped]) -> void
-    def self.validate_includes: (Hash[Symbol, untyped]) -> void
-    def self.validate_jobs: (Hash[Symbol, untyped]) -> void
-    def self.validate_reporters: (Hash[Symbol, untyped]) -> void
-    def self.validate_all_logs: (Hash[Symbol, untyped]) -> void
-    def self.validate_dashboard: (Hash[Symbol, untyped]) -> void
-    def self.validate_mutation: (Hash[Symbol, untyped]) -> void
-    def self.validate_coverage_criteria: (Hash[Symbol, untyped]) -> void
-    def self.validate_thresholds: (Hash[Symbol, untyped]) -> void
-    def self.validate_operator: (untyped) -> void
-    def self.validate_timeout: (untyped) -> void
-    def self.validate_threshold: (untyped, String) -> void
-    def self.validate_boolean: (untyped, String) -> void
-    def self.validate_optional_string: (untyped, String) -> void
-    def self.validate_string_array: (untyped, String) -> void
-    def self.warn_unknown_keys: (Hash[Symbol, untyped], Array[Symbol], ?String) -> void
-    def self.key_path: (?String, Symbol) -> String
-    def self.ensure_hash!: (untyped, String) -> void
-    def self.describe_array_type: (untyped) -> String
-    def self.configuration_error: (String) -> void
+    module Scalars
+      def self?.validate_operator: (untyped) -> void
+      def self?.validate_timeout: (untyped) -> void
+      def self?.validate_threshold: (untyped, String) -> void
+      def self?.validate_boolean: (untyped, String) -> void
+      def self?.validate_optional_string: (untyped, String) -> void
+      def self?.validate_string_array: (untyped, String) -> void
+      def self?.validate_ignore_patterns: (untyped) -> void
+      def self?.validate_max_flaky_retries: (untyped) -> void
+      def self?.validate_sampling_ratio: (untyped) -> void
+      def self?.validate_sampling_strategy: (untyped) -> void
+      def self?.validate_sampling_completeness: (Hash[Symbol, untyped]) -> void
+      def self?.describe_array_type: (untyped) -> String
+    end
   end
 end