henitai 0.1.10 → 0.2.1

data/lib/henitai/configuration_validator/scalars.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Henitai
+  module ConfigurationValidator
+    # Leaf validators for individual configuration values.
+    #
+    # Each method returns silently for an acceptable value or raises
+    # +Henitai::ConfigurationError+ via {Rules.configuration_error}.
+    module Scalars
+      module_function
+
+      def validate_operator(value)
+        return if value.nil?
+
+        operator = value.respond_to?(:to_sym) ? value.to_sym : nil
+        return if VALID_OPERATORS.include?(operator)
+
+        Rules.configuration_error(
+          "Invalid configuration value for mutation.operators: expected one of " \
+          "#{VALID_OPERATORS.join(', ')}, got #{value.inspect}"
+        )
+      end
+
+      def validate_timeout(value)
+        return if value.nil?
+        return if value.is_a?(Numeric)
+
+        Rules.configuration_error(
+          "Invalid configuration value for mutation.timeout: expected Numeric, got #{value.class}"
+        )
+      end
+
+      def validate_threshold(value, path)
+        return if value.is_a?(Integer) && value.between?(0, 100)
+
+        Rules.configuration_error(
+          "Invalid configuration value for #{path}: expected Integer between 0 and 100, " \
+          "got #{value.inspect}"
+        )
+      end
+
+      def validate_boolean(value, path)
+        return if [true, false].include?(value)
+
+        Rules.configuration_error(
+          "Invalid configuration value for #{path}: expected true or false, got #{value.inspect}"
+        )
+      end
+
+      def validate_optional_string(value, path)
+        return if value.nil?
+        return if value.is_a?(String)
+
+        Rules.configuration_error("Invalid configuration value for #{path}: expected String, got #{value.class}")
+      end
+
+      def validate_string_array(value, path)
+        return if value.nil?
+        return if value.is_a?(Array) && value.all?(String)
+
+        Rules.configuration_error(
+          "Invalid configuration value for #{path}: expected Array<String>, got #{describe_array_type(value)}"
+        )
+      end
+
+      def validate_ignore_patterns(value)
+        Array(value).each do |pattern|
+          Regexp.new(pattern)
+        rescue RegexpError => e
+          Rules.configuration_error(
+            "Invalid configuration value for mutation.ignore_patterns: " \
+            "invalid regular expression #{pattern.inspect}: #{e.message}"
+          )
+        end
+      end
+
+      def validate_max_flaky_retries(value)
+        return if value.nil?
+        return if value.is_a?(Integer) && value >= 0
+
+        Rules.configuration_error(
+          "Invalid configuration value for mutation.max_flaky_retries: expected Integer >= 0, got #{value.inspect}"
+        )
+      end
+
+      def validate_sampling_ratio(value)
+        return if value.nil?
+        return if value.is_a?(Numeric) && value >= 0.0 && value <= 1.0
+
+        Rules.configuration_error(
+          "Invalid configuration value for mutation.sampling.ratio: " \
+          "expected Numeric between 0 and 1, got #{value.inspect}"
+        )
+      end
+
+      def validate_sampling_strategy(value)
+        return if value.nil?
+
+        strategy = value.respond_to?(:to_sym) ? value.to_sym : nil
+        return if strategy == :stratified
+
+        Rules.configuration_error(
+          "Invalid configuration value for mutation.sampling.strategy: expected stratified, got #{value.inspect}"
+        )
+      end
+
+      def validate_sampling_completeness(value)
+        return if value.key?(:ratio) && value.key?(:strategy)
+
+        Rules.configuration_error(
+          "Invalid configuration value for mutation.sampling: expected both ratio and strategy"
+        )
+      end
+
+      def describe_array_type(value)
+        return value.class.name unless value.is_a?(Array)
+
+        element_types = value.map { |item| item.class.name }.uniq.join(", ")
+        "Array<#{element_types}>"
+      end
+    end
+  end
+end

data/lib/henitai/configuration_validator.rb

@@ -1,12 +1,18 @@
 # frozen_string_literal: true
 
+require_relative "configuration_validator/rules"
+
 module Henitai
-  # rubocop:disable Metrics/ModuleLength
   # Internal validator for configuration data loaded from YAML and CLI overrides.
+  #
+  # The public entry point is {.validate!}; the individual rules live in
+  # {Rules}. Unknown-key warnings are emitted via {.warn} so that callers (and
+  # specs) can observe them on this module.
   module ConfigurationValidator
     VALID_TOP_LEVEL_KEYS = %i[
       integration
       includes
+      excludes
       mutation
       coverage_criteria
       thresholds
@@ -27,6 +33,7 @@ module Henitai
       validate_top_level_keys
       validate_integration
       validate_includes
+      validate_excludes
       validate_jobs
       validate_reporters
       validate_reports_dir
@@ -38,246 +45,12 @@ module Henitai
     ].freeze
 
     def self.validate!(raw)
-      ensure_hash!(raw, "configuration")
-      VALIDATION_STEPS.each { |step| send(step, raw) }
+      Rules.ensure_hash!(raw, "configuration")
+      VALIDATION_STEPS.each { |step| Rules.public_send(step, raw) }
     end
 
-    class << self
-      private
-
-      def validate_top_level_keys(raw)
-        warn_unknown_keys(raw, VALID_TOP_LEVEL_KEYS)
-      end
-
-      def validate_integration(raw)
-        value = raw[:integration]
-        return if value.nil?
-        return if value.is_a?(String)
-
-        ensure_hash!(value, "integration")
-        warn_unknown_keys(value, VALID_INTEGRATION_KEYS, "integration")
-        validate_optional_string(value[:name], "integration.name")
-      end
-
-      def validate_includes(raw)
-        validate_string_array(raw[:includes], "includes")
-      end
-
-      def validate_jobs(raw)
-        value = raw[:jobs]
-        return if value.nil?
-        return if value.is_a?(Integer)
-
-        configuration_error("Invalid configuration value for jobs: expected Integer, got #{value.class}")
-      end
-
-      def validate_reporters(raw)
-        validate_string_array(raw[:reporters], "reporters")
-      end
-
-      def validate_reports_dir(raw)
-        validate_optional_string(raw[:reports_dir], "reports_dir")
-      end
-
-      def validate_all_logs(raw)
-        value = raw[:all_logs]
-        return if value.nil?
-
-        validate_boolean(value, "all_logs")
-      end
-
-      def validate_dashboard(raw)
-        value = raw[:dashboard]
-        return if value.nil?
-
-        ensure_hash!(value, "dashboard")
-        warn_unknown_keys(value, VALID_DASHBOARD_KEYS, "dashboard")
-        validate_optional_string(value[:project], "dashboard.project")
-        validate_optional_string(value[:base_url], "dashboard.base_url")
-      end
-
-      def validate_mutation(raw)
-        value = raw[:mutation]
-        return if value.nil?
-
-        ensure_hash!(value, "mutation")
-        warn_unknown_keys(value, VALID_MUTATION_KEYS, "mutation")
-        validate_operator(value[:operators])
-        validate_mutation_limits(value)
-        validate_mutation_filters(value)
-        validate_sampling(value[:sampling])
-      end
-
-      def validate_mutation_limits(value)
-        validate_timeout(value[:timeout])
-        validate_max_flaky_retries(value[:max_flaky_retries])
-      end
-
-      def validate_mutation_filters(value)
-        validate_string_array(value[:ignore_patterns], "mutation.ignore_patterns")
-        validate_ignore_patterns(value[:ignore_patterns])
-      end
-
-      def validate_coverage_criteria(raw)
-        value = raw[:coverage_criteria]
-        return if value.nil?
-
-        ensure_hash!(value, "coverage_criteria")
-        warn_unknown_keys(value, VALID_COVERAGE_CRITERIA_KEYS, "coverage_criteria")
-        value.each do |key, flag|
-          validate_boolean(flag, "coverage_criteria.#{key}")
-        end
-      end
-
-      def validate_thresholds(raw)
-        value = raw[:thresholds]
-        return if value.nil?
-
-        ensure_hash!(value, "thresholds")
-        warn_unknown_keys(value, VALID_THRESHOLDS_KEYS, "thresholds")
-        value.each do |key, threshold|
-          validate_threshold(threshold, "thresholds.#{key}")
-        end
-      end
-
-      def validate_operator(value)
-        return if value.nil?
-
-        operator = value.respond_to?(:to_sym) ? value.to_sym : nil
-        return if VALID_OPERATORS.include?(operator)
-
-        configuration_error(
-          "Invalid configuration value for mutation.operators: expected one of " \
-          "#{VALID_OPERATORS.join(', ')}, got #{value.inspect}"
-        )
-      end
-
-      def validate_timeout(value)
-        return if value.nil?
-        return if value.is_a?(Numeric)
-
-        configuration_error("Invalid configuration value for mutation.timeout: expected Numeric, got #{value.class}")
-      end
-
-      def validate_threshold(value, path)
-        return if value.is_a?(Integer) && value.between?(0, 100)
-
-        configuration_error(
-          "Invalid configuration value for #{path}: expected Integer between 0 and 100, " \
-          "got #{value.inspect}"
-        )
-      end
-
-      def validate_boolean(value, path)
-        return if [true, false].include?(value)
-
-        configuration_error("Invalid configuration value for #{path}: expected true or false, got #{value.inspect}")
-      end
-
-      def validate_optional_string(value, path)
-        return if value.nil?
-        return if value.is_a?(String)
-
-        configuration_error("Invalid configuration value for #{path}: expected String, got #{value.class}")
-      end
-
-      def validate_string_array(value, path)
-        return if value.nil?
-        return if value.is_a?(Array) && value.all?(String)
-
-        configuration_error(
-          "Invalid configuration value for #{path}: expected Array<String>, got #{describe_array_type(value)}"
-        )
-      end
-
-      def validate_ignore_patterns(value)
-        Array(value).each do |pattern|
-          Regexp.new(pattern)
-        rescue RegexpError => e
-          configuration_error(
-            "Invalid configuration value for mutation.ignore_patterns: " \
-            "invalid regular expression #{pattern.inspect}: #{e.message}"
-          )
-        end
-      end
-
-      def validate_max_flaky_retries(value)
-        return if value.nil?
-        return if value.is_a?(Integer) && value >= 0
-
-        configuration_error(
-          "Invalid configuration value for mutation.max_flaky_retries: expected Integer >= 0, got #{value.inspect}"
-        )
-      end
-
-      def validate_sampling(value)
-        return if value.nil?
-
-        ensure_hash!(value, "mutation.sampling")
-        warn_unknown_keys(value, VALID_SAMPLING_KEYS, "mutation.sampling")
-        validate_sampling_completeness(value)
-        validate_sampling_ratio(value[:ratio])
-        validate_sampling_strategy(value[:strategy])
-      end
-
-      def validate_sampling_ratio(value)
-        return if value.nil?
-        return if value.is_a?(Numeric) && value >= 0.0 && value <= 1.0
-
-        configuration_error(
-          "Invalid configuration value for mutation.sampling.ratio: " \
-          "expected Numeric between 0 and 1, got #{value.inspect}"
-        )
-      end
-
-      def validate_sampling_strategy(value)
-        return if value.nil?
-
-        strategy = value.respond_to?(:to_sym) ? value.to_sym : nil
-        return if strategy == :stratified
-
-        configuration_error(
-          "Invalid configuration value for mutation.sampling.strategy: expected stratified, got #{value.inspect}"
-        )
-      end
-
-      def validate_sampling_completeness(value)
-        return if value.key?(:ratio) && value.key?(:strategy)
-
-        configuration_error(
-          "Invalid configuration value for mutation.sampling: expected both ratio and strategy"
-        )
-      end
-
-      def warn_unknown_keys(raw, allowed_keys, path = nil)
-        raw.each_key do |key|
-          next if allowed_keys.include?(key)
-
-          warn "Unknown configuration key: #{key_path(path, key)}"
-        end
-      end
-
-      def key_path(path, key)
-        path ? "#{path}.#{key}" : key.to_s
-      end
-
-      def ensure_hash!(value, path)
-        return if value.is_a?(Hash)
-
-        configuration_error("Invalid configuration value for #{path}: expected Hash, got #{value.class}")
-      end
-
-      def describe_array_type(value)
-        return value.class.name unless value.is_a?(Array)
-
-        element_types = value.map { |item| item.class.name }.uniq.join(", ")
-        "Array<#{element_types}>"
-      end
-
-      def configuration_error(message)
-        raise Henitai::ConfigurationError, message
-      end
+    def self.warn(message)
+      Kernel.warn(message)
     end
   end
-  # rubocop:enable Metrics/ModuleLength
 end

data/lib/henitai/coverage_bootstrapper.rb

@@ -18,16 +18,18 @@ module Henitai
     def ensure!(source_files:, config:, integration:, test_files: nil)
       return if source_files.empty?
 
+      resolved_test_files = resolve_test_files(integration, test_files)
+
       # Skip the bootstrap only when the coverage artifacts are both newer than
       # all watched files and actually cover the configured sources. A fresh
       # but irrelevant report (e.g. from a different working directory) must
       # still trigger a re-bootstrap rather than silently proceeding with no
       # usable coverage.
-      unless coverage_ready?(source_files, config, integration, test_files)
-        bootstrap_coverage(integration, config, test_files)
+      unless coverage_ready?(source_files, config, integration, resolved_test_files)
+        bootstrap_coverage(integration, config, resolved_test_files)
       end
 
-      return if coverage_available?(source_files, config, test_files)
+      return if coverage_available?(source_files, config)
 
       raise CoverageError,
             "Coverage data is unavailable for the configured source files"
@@ -37,20 +39,16 @@ module Henitai
 
     attr_reader :static_filter
 
-    def coverage_available?(source_files, config, test_files)
+    def coverage_available?(source_files, config)
       coverage_lines = static_filter.coverage_lines_for(config)
       covered_sources = covered_source_files(source_files, coverage_lines)
-      existing_sources = existing_source_file_paths(source_files)
-
-      return covered_sources.any? if existing_sources.empty?
-      return covered_sources.any? if test_files
 
       covered_sources.any?
     end
 
     def coverage_ready?(source_files, config, integration, test_files)
-      coverage_fresh?(source_files, config, integration, test_files) &&
-        coverage_available?(source_files, config, test_files) &&
+      coverage_fresh?(source_files, config, test_files) &&
+        coverage_available?(source_files, config) &&
         per_test_coverage_ready?(source_files, config, integration, test_files)
     end
 
@@ -64,17 +62,12 @@ module Henitai
       Array(source_files).map { |path| File.expand_path(path) }
     end
 
-    def existing_source_file_paths(source_files)
-      source_file_paths(source_files).select { |path| File.exist?(path) }
-    end
-
     # Returns true when a coverage report already exists and is newer than
     # every watched source and test file. Stale or absent reports return false.
-    def coverage_fresh?(source_files, config, integration, test_files)
+    def coverage_fresh?(source_files, config, test_files)
       watched_files_fresh?(
         coverage_report_path(config),
         source_files,
-        integration,
         test_files
       )
     end
@@ -88,9 +81,11 @@ module Henitai
     end
 
     def bootstrap_coverage(integration, config, test_files = nil)
+      test_files ||= integration.test_files
+
       with_reports_dir(config) do
         with_coverage_dir(config) do
-          result = integration.run_suite(test_files || integration.test_files)
+          result = integration.run_suite(test_files)
           return if result == :survived
 
           raise CoverageError, build_bootstrap_error(result)
@@ -139,11 +134,10 @@ module Henitai
       File.join(reports_dir, "coverage")
     end
 
-    def per_test_coverage_fresh?(source_files, config, integration, test_files)
+    def per_test_coverage_fresh?(source_files, config, test_files)
       watched_files_fresh?(
         per_test_coverage_report_path(config),
         source_files,
-        integration,
         test_files
       )
     end
@@ -155,7 +149,7 @@ module Henitai
     def per_test_coverage_ready?(source_files, config, integration, test_files)
       return true unless per_test_coverage_supported?(integration)
 
-      per_test_coverage_fresh?(source_files, config, integration, test_files) &&
+      per_test_coverage_fresh?(source_files, config, test_files) &&
         per_test_coverage_available?(config)
     end
 
@@ -165,21 +159,27 @@ module Henitai
       integration.per_test_coverage_supported?
     end
 
-    def watched_files_fresh?(report_path, source_files, integration, test_files)
+    def watched_files_fresh?(report_path, source_files, test_files)
       # This check assumes a single writer owns the coverage artifacts for the
       # workspace. It is intentionally not an atomic snapshot-and-validate step.
       return false unless File.exist?(report_path)
 
       report_mtime = File.mtime(report_path)
-      watched_files(source_files, integration, test_files).all? do |path|
+      watched_files(source_files, test_files).all? do |path|
         File.mtime(path) <= report_mtime
       rescue Errno::ENOENT
         false
       end
     end
 
-    def watched_files(source_files, integration, test_files)
-      Array(source_files) + Array(test_files || integration.test_files)
+    def watched_files(source_files, test_files)
+      Array(source_files) + Array(test_files)
+    end
+
+    def resolve_test_files(integration, test_files)
+      return test_files unless test_files.nil?
+
+      integration.test_files
     end
 
     def reports_dir(config)

data/lib/henitai/eager_load.rb

@@ -2,10 +2,41 @@
 
 require "henitai"
 
-# Force all autoloaded constants to load so mutation testing tools
-# (e.g. mutant) can discover subjects via ObjectSpace.
-SIDE_EFFECT_FILES = %w[minitest_simplecov.rb minitest_coverage_hook.rb rspec_coverage_formatter.rb].freeze
+# Standalone entry point that forces every Henitai constant to load so external
+# mutation tooling (e.g. mutant) can discover subjects via ObjectSpace.
+#
+# Usage:
+#   ruby -r henitai/eager_load -e ""
+#
+# A bare `Dir[].each { require }` glob loads files in filesystem order, which
+# does not respect dependency order: a child file that reopens an autoloaded
+# constant (e.g. `class CLI` or `class Rspec < Base`) triggers the parent
+# autoload before the child's own constants exist, raising NameError. To avoid
+# that, first touch every constant in the autoload table so each entry-point
+# file loads with its `require_relative` children in the correct order; only
+# then glob the remaining files, by which point every base class and namespace
+# is already defined and load order no longer matters.
 
-Dir[File.join(__dir__, "**/*.rb")].each do |f|
-  require f unless SIDE_EFFECT_FILES.any? { |name| f.end_with?(name) }
+# Files that run as side effects on load (test hooks and coverage formatters)
+# and must therefore be skipped by the eager loader.
+SIDE_EFFECT_FILES = %w[
+  minitest_simplecov.rb
+  minitest_coverage_hook.rb
+  rspec_coverage_formatter.rb
+].freeze
+
+# Recursively force every autoloaded constant under a module to load, so nested
+# namespaces (Operators::*, Mutant::*, CLI::*, Integration::*) load their bases
+# before the glob below touches their files.
+force_autoloads = lambda do |mod|
+  mod.constants(false).each do |constant|
+    value = mod.const_get(constant)
+    force_autoloads.call(value) if value.is_a?(Module) && value.name&.start_with?("Henitai")
+  end
+end
+
+force_autoloads.call(Henitai)
+
+Dir[File.join(__dir__, "**/*.rb")].each do |file|
+  require file unless SIDE_EFFECT_FILES.any? { |name| file.end_with?(name) }
 end

data/lib/henitai/execution_engine.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "parallel_execution_runner"
+require_relative "process_worker_runner"
 
 module Henitai
   # Runs pending mutants through the selected integration.
@@ -46,22 +47,16 @@ module Henitai
     end
 
     def run_parallel(mutants, integration, config, progress_reporter)
-      ParallelExecutionRunner.new(
-        worker_count: worker_count(config)
-      ).run(
+      runner = ProcessWorkerRunner.new(worker_count: worker_count(config))
+      results = runner.run(
         mutants,
         integration,
         config,
         progress_reporter,
-        stdin_pipe: pipe_stdin?,
-        process_mutant: method(:process_mutant)
+        test_file_resolver: ->(mutant) { prioritized_tests_for(mutant, integration, config) }
       )
-    end
-
-    def pipe_stdin?
-      $stdin.stat.pipe?
-    rescue Errno::EBADF
-      false
+      @flaky_retry_count = runner.flaky_retry_count
+      results
     end
 
     def process_mutant(mutant, integration, config, progress_reporter, mutex)

data/lib/henitai/git_diff_analyzer.rb

@@ -19,6 +19,21 @@ module Henitai
       stdout.split("\n").reject(&:empty?)
     end
 
+    def working_tree_changed_files(dir: Dir.pwd)
+      tracked = working_tree_tracked_files(dir)
+      untracked = untracked_files(dir)
+
+      (tracked + untracked).uniq
+    end
+
+    def head_sha(dir: Dir.pwd)
+      command = ["git", "-C", dir, "rev-parse", "HEAD"]
+      stdout, _, status = Open3.capture3(*command)
+      stdout.strip if status.success? && !stdout.strip.empty?
+    rescue Errno::ENOENT
+      nil
+    end
+
     def changed_methods(from:, to:, dir: Dir.pwd)
       changed_files(from:, to:, dir:).flat_map do |path|
         changed_methods_in_file(path, from:, to:, dir:)
@@ -78,5 +93,24 @@ module Henitai
 
       Open3.capture3(*command)
     end
+
+    def working_tree_tracked_files(dir)
+      stdout, stderr, status = git_diff(dir, "--name-only", "HEAD")
+
+      raise GitDiffError, stderr.strip unless status.success?
+
+      stdout.split("\n").reject(&:empty?)
+    end
+
+    def untracked_files(dir)
+      command = ["git"]
+      command += ["-C", dir] if dir
+      command += ["ls-files", "--others", "--exclude-standard"]
+      stdout, stderr, status = Open3.capture3(*command)
+
+      raise GitDiffError, stderr.strip unless status.success?
+
+      stdout.split("\n").reject(&:empty?)
+    end
   end
 end