henitai 0.2.0 → 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/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.2.0"
+  VERSION = "0.2.1"
 end

data/lib/henitai.rb

@@ -44,6 +44,7 @@ module Henitai
   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"
@@ -54,6 +55,7 @@ module Henitai
   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"

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