henitai 0.1.1 → 0.1.3

data/lib/henitai/parallel_execution_runner.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Runs pending mutants across worker threads with signal and stdin handling.
+  class ParallelExecutionRunner
+    ParallelExecutionContext = Struct.new(
+      :queue, :integration, :config, :progress_reporter,
+      :mutex, :state, :old_handlers, :stdin_watcher
+    )
+
+    def initialize(worker_count:)
+      @worker_count = worker_count
+    end
+
+    def run(mutants, integration, config, progress_reporter, options = {})
+      context = build_parallel_context(
+        mutants,
+        integration,
+        config,
+        progress_reporter
+      )
+      execute_parallel_execution(
+        context,
+        stdin_pipe: options.fetch(:stdin_pipe, false),
+        process_mutant: options.fetch(:process_mutant)
+      )
+    end
+
+    def execute_parallel_execution(context, stdin_pipe:, process_mutant:)
+      install_parallel_signal_traps(context)
+      start_parallel_stdin_watcher(context, stdin_pipe)
+      parallel_workers(context, process_mutant).each(&:join)
+    ensure
+      stop_parallel_stdin_watcher(context)
+      restore_parallel_signal_traps(context)
+      raise context.state[:error] if context&.state&.fetch(:error, nil)
+      raise Interrupt if context&.state&.fetch(:stopping, false)
+    end
+
+    private
+
+    attr_reader :worker_count
+
+    def build_parallel_queue(mutants)
+      Queue.new.tap { |queue| mutants.each { |mutant| queue << mutant } }
+    end
+
+    def build_parallel_context(mutants, integration, config, progress_reporter)
+      ParallelExecutionContext.new(
+        build_parallel_queue(mutants),
+        integration,
+        config,
+        progress_reporter,
+        Mutex.new,
+        { stopping: false }
+      )
+    end
+
+    def install_parallel_signal_traps(context)
+      context.old_handlers = {
+        int: trap(:INT) { stop_parallel_execution(context) },
+        term: trap(:TERM) { stop_parallel_execution(context) },
+        hup: trap(:HUP) { stop_parallel_execution(context) }
+      }
+    end
+
+    def stop_parallel_execution(context)
+      context.state[:stopping] = true
+      context.queue.clear
+    end
+
+    def start_parallel_stdin_watcher(context, stdin_pipe)
+      return unless stdin_pipe
+      # CI runners expose stdin as a non-interactive pipe, so EOF there should
+      # not be treated as a user disconnect.
+      return if ci_environment?
+
+      context.stdin_watcher = Thread.new do
+        $stdin.read
+        stop_parallel_execution(context)
+      rescue IOError, Errno::EBADF
+        nil
+      end
+    end
+
+    def parallel_workers(context, process_mutant)
+      Array.new(worker_count) { Thread.new { process_parallel_worker(context, process_mutant) } }
+    end
+
+    def process_parallel_worker(context, process_mutant)
+      loop do
+        break if context.state[:stopping]
+
+        process_mutant.call(
+          context.queue.pop(true),
+          context.integration,
+          context.config,
+          context.progress_reporter,
+          context.mutex
+        )
+      rescue ThreadError
+        break
+      rescue StandardError => e
+        record_parallel_error(context, e)
+        break
+      end
+    end
+
+    def stop_parallel_stdin_watcher(context)
+      context&.stdin_watcher&.kill
+    end
+
+    def restore_parallel_signal_traps(context)
+      handlers = context&.old_handlers
+      return unless handlers
+
+      trap(:INT, handlers[:int] || "DEFAULT")
+      trap(:TERM, handlers[:term] || "DEFAULT")
+      trap(:HUP, handlers[:hup] || "DEFAULT")
+    end
+
+    def record_parallel_error(context, error)
+      context.mutex.synchronize do
+        context.state[:error] ||= error
+        context.state[:stopping] = true
+        context.queue.clear
+      end
+    end
+
+    def ci_environment?
+      value = ENV.fetch("CI", nil)
+      value && !%w[0 false].include?(value.downcase)
+    end
+  end
+end

data/lib/henitai/per_test_coverage_selector.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Narrows candidate test files using the per-test coverage report.
+  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?
+      return candidates unless location_available?(mutant)
+      return candidates unless per_test_coverage_available?(reports_dir)
+
+      covered_tests = candidates.select do |test|
+        covers_mutant?(test, mutant, reports_dir)
+      end
+      covered_tests.empty? ? candidates : covered_tests
+    end
+
+    private
+
+    def location_available?(mutant)
+      mutant.respond_to?(:location) &&
+        mutant.location.is_a?(Hash) &&
+        mutant.location[:file] &&
+        mutant.location[:start_line] &&
+        mutant.location[:end_line]
+    end
+
+    def covers_mutant?(test, mutant, reports_dir)
+      covered_lines = coverage_lines_for(test, mutant, reports_dir)
+      mutant_lines(mutant).any? { |line| covered_lines.include?(line) }
+    end
+
+    def coverage_lines_for(test, mutant, reports_dir)
+      source_map = per_test_coverage(reports_dir)[test.to_s] || {}
+      Array(source_map[File.expand_path(mutant.location[:file])]).uniq
+    end
+
+    def mutant_lines(mutant)
+      (mutant.location[:start_line]..mutant.location[:end_line]).to_a
+    end
+
+    def per_test_coverage(reports_dir)
+      @per_test_coverage ||= {}
+      @per_test_coverage[reports_dir] ||= begin
+        path = File.join(reports_dir, "henitai_per_test.json")
+        coverage_report_reader.test_lines_by_file(path)
+      end
+    end
+
+    def per_test_coverage_available?(reports_dir)
+      !per_test_coverage(reports_dir).empty?
+    end
+
+    attr_reader :coverage_report_reader
+  end
+end

data/lib/henitai/result.rb

@@ -11,13 +11,15 @@ module Henitai
     include UnparseHelper
 
     SCHEMA_VERSION = "1.0"
+    DEFAULT_THRESHOLDS = { high: 80, low: 60 }.freeze
 
-    attr_reader :mutants, :started_at, :finished_at
+    attr_reader :mutants, :started_at, :finished_at, :thresholds
 
-    def initialize(mutants:, started_at:, finished_at:)
+    def initialize(mutants:, started_at:, finished_at:, thresholds: nil)
       @mutants     = mutants
       @started_at  = started_at
       @finished_at = finished_at
+      @thresholds  = DEFAULT_THRESHOLDS.merge(thresholds || {})
     end
 
     # @return [Integer] number of killed mutants
@@ -88,7 +90,7 @@ module Henitai
     def to_stryker_schema
       {
         schemaVersion: SCHEMA_VERSION,
-        thresholds: { high: 80, low: 60 },
+        thresholds: thresholds,
         files: build_files_section
       }
     end
@@ -119,7 +121,17 @@ module Henitai
         status: stryker_status(mutant.status),
         description: mutant.description,
         duration: duration_for(mutant)
-      }.compact
+      }.compact.merge(coverage_schema(mutant))
+    end
+
+    def coverage_schema(mutant)
+      covered_by = Array(mutant.covered_by).compact
+      return {} if covered_by.empty?
+
+      {
+        coveredBy: covered_by,
+        testsCompleted: mutant.tests_completed || covered_by.size
+      }
     end
 
     def replacement_for(mutant)

data/lib/henitai/rspec_coverage_formatter.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "rspec/core"
+require "henitai/coverage_formatter"
+
+RSpec::Core::Formatters.register(
+  Henitai::CoverageFormatter,
+  :example_finished,
+  :dump_summary
+)

data/lib/henitai/runner.rb

@@ -35,18 +35,24 @@ module Henitai
     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.
+    #
+    # For targeted runs (`subjects:` provided), the bootstrap is further scoped
+    # to the spec files that cover the requested subjects rather than the full
+    # suite, reducing the baseline run time proportionally.
+    #
     # @return [Result]
     def run
       started_at = Time.now
       source_files = self.source_files
-      bootstrap_coverage(source_files)
       subjects = resolve_subjects(source_files)
-      mutants = generate_mutants(subjects)
-      mutants = filter_mutants(mutants)
-      mutants = execute_mutants(mutants)
-      finished_at = Time.now
+      mutants = execute_mutants(mutants_for(subjects, source_files))
 
-      build_result(mutants, started_at, finished_at)
+      build_result(mutants, started_at, Time.now)
     end
 
     private
@@ -69,6 +75,29 @@ module Henitai
       static_filter.apply(mutants, config)
     end
 
+    def mutants_for(subjects, source_files)
+      bootstrap_thread = bootstrap_mutants(source_files, subjects)
+      mutants = generate_mutants(subjects)
+      bootstrap_thread.value
+
+      filtered_mutants = filter_mutants(mutants)
+      return filtered_mutants unless targeted_run?
+
+      refresh_coverage_for_targeted_run(filtered_mutants, source_files)
+    end
+
+    def refresh_coverage_for_targeted_run(mutants, source_files)
+      return mutants unless retry_full_bootstrap?(mutants)
+
+      bootstrap_coverage(source_files)
+      filter_mutants(mutants)
+    end
+
+    def bootstrap_mutants(source_files, subjects)
+      scoped_tests = scoped_bootstrap_test_files(subjects)
+      Thread.new { bootstrap_coverage(source_files, scoped_tests) }
+    end
+
     def execute_mutants(mutants)
       execution_engine.run(
         mutants,
@@ -94,13 +123,33 @@ module Henitai
       @result = Result.new(
         mutants:,
         started_at:,
-        finished_at:
+        finished_at:,
+        thresholds: result_thresholds
       )
       persist_history(@result, finished_at)
       report(@result)
       @result
     end
 
+    # Returns the spec files to use for the coverage bootstrap.
+    #
+    # For full runs (no subject pattern given), returns nil so the bootstrapper
+    # falls back to the integration's full test-file list.
+    #
+    # For targeted runs, returns the union of test files selected for each
+    # resolved subject. Falls back to nil (all tests) if the selection is empty,
+    # so the bootstrapper always has a non-empty file list.
+    def scoped_bootstrap_test_files(subjects)
+      return nil if pattern_subjects.empty?
+
+      files = subjects.flat_map { |subject| integration.select_tests(subject) }.uniq
+      files.empty? ? nil : files
+    end
+
+    def bootstrap_coverage(source_files, test_files = nil)
+      coverage_bootstrapper.ensure!(source_files:, config:, integration:, test_files:)
+    end
+
     def subject_resolver
       @subject_resolver ||= SubjectResolver.new
     end
@@ -125,10 +174,6 @@ module Henitai
       @coverage_bootstrapper ||= CoverageBootstrapper.new
     end
 
-    def bootstrap_coverage(source_files)
-      coverage_bootstrapper.ensure!(source_files:, config:, integration:)
-    end
-
     def integration
       @integration ||= Integration.for(config.integration).new
     end
@@ -172,6 +217,19 @@ module Henitai
       Array(@subjects)
     end
 
+    def targeted_run?
+      !pattern_subjects.empty?
+    end
+
+    def retry_full_bootstrap?(mutants)
+      executable_mutants = Array(mutants).reject do |mutant|
+        %i[ignored compile_error equivalent].include?(mutant.status)
+      end
+      return false if executable_mutants.empty?
+
+      executable_mutants.all? { |mutant| mutant.status == :no_coverage }
+    end
+
     def unique_subjects(subjects)
       subjects.uniq { |subject| [subject.expression, subject.source_file] }
     end
@@ -179,5 +237,11 @@ module Henitai
     def normalize_path(path)
       File.expand_path(path)
     end
+
+    def result_thresholds
+      return nil unless config.respond_to?(:thresholds)
+
+      config.thresholds
+    end
   end
 end

data/lib/henitai/source_parser.rb

@@ -12,12 +12,23 @@ module Henitai
   class SourceParser
     DEFAULT_PATH = "(string)"
 
+    @cache = {}
+
     def self.parse(source, path: DEFAULT_PATH)
       new.parse(source, path:)
     end
 
+    # Returns the parsed AST for +path+, re-using a cached result when the
+    # file's mtime has not changed. This avoids parsing the same file twice
+    # across pipeline phases (e.g. SubjectResolver then MutantGenerator).
     def self.parse_file(path)
-      new.parse_file(path)
+      key = [path, File.mtime(path)]
+      @cache[key] ||= new.parse_file(path)
+    end
+
+    # Clears the parse cache. Intended for test isolation.
+    def self.clear_cache!
+      @cache.clear
     end
 
     def parse(source, path: DEFAULT_PATH)

data/lib/henitai/static_filter.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
-require "json"
+require_relative "coverage_report_reader"
 
 module Henitai
   # Applies static, pre-execution filtering to generated mutants.
   class StaticFilter
-    DEFAULT_COVERAGE_REPORT_PATH = "coverage/.resultset.json"
-    DEFAULT_PER_TEST_COVERAGE_REPORT_PATH = "coverage/henitai_per_test.json"
+    DEFAULT_COVERAGE_REPORT_PATH = CoverageReportReader::DEFAULT_COVERAGE_REPORT_PATH
+    DEFAULT_PER_TEST_COVERAGE_REPORT_PATH = CoverageReportReader::DEFAULT_PER_TEST_COVERAGE_REPORT_PATH
+
+    def initialize(coverage_report_reader: CoverageReportReader.new)
+      @coverage_report_reader = coverage_report_reader
+    end
 
     # This method is the gate-level filter orchestrator.
     def apply(mutants, config)
@@ -32,6 +36,7 @@ module Henitai
       per_test_coverage_report_path = per_test_coverage_report_path(config)
 
       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(
@@ -40,31 +45,17 @@ module Henitai
     end
 
     def coverage_lines_by_file(path = DEFAULT_COVERAGE_REPORT_PATH)
-      return {} unless File.exist?(path)
-
-      coverage = Hash.new { |hash, key| hash[key] = [] }
-      JSON.parse(File.read(path)).each_value do |result|
-        result.fetch("coverage", {}).each do |file, file_coverage|
-          coverage[normalize_path(file)].concat(covered_lines(file_coverage))
-        end
-      end
-
-      coverage.transform_values(&:uniq).transform_values(&:sort)
+      coverage_report_reader.coverage_lines_by_file(path)
     end
 
     def test_lines_by_file(path = DEFAULT_PER_TEST_COVERAGE_REPORT_PATH)
-      return {} unless File.exist?(path)
-
-      parsed = JSON.parse(File.read(path))
-      return {} unless parsed.is_a?(Hash)
-
-      parsed.transform_values do |coverage|
-        normalize_test_coverage(coverage)
-      end
+      coverage_report_reader.test_lines_by_file(path)
     end
 
     private
 
+    attr_reader :coverage_report_reader
+
     def ignored?(mutant, config)
       source = source_for(mutant)
       return false unless source
@@ -97,9 +88,10 @@ module Henitai
 
     def covered?(mutant, coverage_lines)
       file = normalize_path(mutant.location[:file])
-      start_line = mutant.location[:start_line]
-
-      Array(coverage_lines[file]).include?(start_line)
+      covered = Array(coverage_lines[file])
+      (mutant.location[:start_line]..mutant.location[:end_line]).any? do |line|
+        covered.include?(line)
+      end
     end
 
     def source_for(mutant)
@@ -115,23 +107,40 @@ module Henitai
       @compiled_ignore_patterns[patterns] ||= patterns.map { |pattern| Regexp.new(pattern) }
     end
 
-    def covered_lines(file_coverage)
-      Array(file_coverage["lines"]).each_with_index.filter_map do |count, index|
-        index + 1 if count.to_i.positive?
+    def merge_method_coverage(coverage_lines, path)
+      return coverage_lines unless File.exist?(path)
+
+      JSON.parse(File.read(path)).each_value do |suite|
+        suite.fetch("coverage", {}).each do |file, file_coverage|
+          merge_file_method_coverage(coverage_lines, file, file_coverage)
+        end
       end
+
+      coverage_lines.transform_values(&:sort)
     end
 
-    def normalize_test_coverage(coverage)
-      case coverage
-      when Hash
-        coverage.transform_values do |lines|
-          Array(lines).grep(Integer).uniq.sort
-        end
-      else
-        Array(coverage).grep(Integer).uniq.sort
+    def merge_file_method_coverage(coverage_lines, file, file_coverage)
+      methods = file_coverage["methods"]
+      return unless methods.is_a?(Hash)
+
+      normalized = normalize_path(file)
+      methods.each do |key, count|
+        next unless count.to_i.positive?
+
+        range = method_line_range(key)
+        next unless range
+
+        coverage_lines[normalized] = Array(coverage_lines[normalized]) | range.to_a
       end
     end
 
+    def method_line_range(key)
+      m = key.match(/(\d+), \d+, (\d+), \d+\]\z/)
+      return unless m
+
+      (m.captures.first.to_i..m.captures.last.to_i)
+    end
+
     def coverage_lines_from_test_lines(test_lines)
       coverage = Hash.new { |hash, key| hash[key] = [] }
 
@@ -147,10 +156,16 @@ module Henitai
     end
 
     def normalize_path(path)
+      @normalize_path_cache ||= {}
+      return @normalize_path_cache[path] if @normalize_path_cache.key?(path)
+
       expanded = File.expand_path(path)
-      File.realpath(expanded)
-    rescue Errno::ENOENT, Errno::ENOTDIR
-      expanded
+      resolved = begin
+        File.realpath(expanded)
+      rescue Errno::ENOENT, Errno::ENOTDIR
+        expanded
+      end
+      @normalize_path_cache[path] = resolved
     end
 
     def equivalence_detector

data/lib/henitai/version.rb

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

data/lib/henitai.rb

@@ -22,6 +22,8 @@ module Henitai
 
   autoload :Configuration, "henitai/configuration"
   autoload :CoverageBootstrapper, "henitai/coverage_bootstrapper"
+  autoload :CoverageReportReader, "henitai/coverage_report_reader"
+  autoload :PerTestCoverageSelector, "henitai/per_test_coverage_selector"
   autoload :Subject, "henitai/subject"
   autoload :Mutant, "henitai/mutant"
   autoload :Operator, "henitai/operator"
@@ -33,6 +35,7 @@ module Henitai
   autoload :MutantGenerator, "henitai/mutant_generator"
   autoload :MutantHistoryStore, "henitai/mutant_history_store"
   autoload :AridNodeFilter, "henitai/arid_node_filter"
+  autoload :AvailableCpuCount, "henitai/available_cpu_count"
   autoload :EquivalenceDetector, "henitai/equivalence_detector"
   autoload :StaticFilter, "henitai/static_filter"
   autoload :StillbornFilter, "henitai/stillborn_filter"