henitai 0.1.10 → 0.2.1

data/lib/henitai/integration/rspec_process_runner.rb

@@ -2,15 +2,68 @@
 
 module Henitai
   module Integration
+    # Tracks real OS child pids for scheduler observability.
+    # Gated on HENITAI_DEBUG_SCHEDULER=1. Thread-safe.
+    module SchedulerDiagnostics
+      @mutex = Mutex.new
+      @intervals = []
+      @live_count = 0
+      @max_concurrent = 0
+
+      class << self
+        def enabled?
+          ENV["HENITAI_DEBUG_SCHEDULER"] == "1"
+        end
+
+        def child_started(pid)
+          return unless enabled?
+
+          started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          @mutex.synchronize do
+            @live_count += 1
+            @max_concurrent = [@max_concurrent, @live_count].max
+            @intervals << { pid: pid, started_at: started_at, ended_at: nil }
+          end
+        end
+
+        def child_ended(pid)
+          return if pid.nil? || !enabled?
+
+          ended_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          @mutex.synchronize do
+            @live_count -= 1
+            entry = @intervals.rfind { |i| i[:pid] == pid && i[:ended_at].nil? }
+            entry[:ended_at] = ended_at if entry
+          end
+        end
+
+        def summary
+          @mutex.synchronize { { max_concurrent: @max_concurrent, intervals: @intervals.dup } }
+        end
+
+        def reset!
+          @mutex.synchronize do
+            @intervals = []
+            @live_count = 0
+            @max_concurrent = 0
+          end
+        end
+      end
+    end
+
+    # Captures the PID and log paths for a spawned mutant child process.
+    ChildHandle = Struct.new(:pid, :log_paths)
+
     # Runs RSpec child and suite processes on behalf of the integration.
     class RspecProcessRunner
       def run_mutant(integration, mutant:, test_files:, timeout:)
-        log_paths = integration.scenario_log_paths(mutant_log_name(mutant))
-        pid = fork_mutant_process(integration, mutant, test_files, log_paths)
-        wait_result = integration.wait_with_timeout(pid, timeout)
-        integration.build_result(wait_result, log_paths)
+        handle = integration.spawn_mutant(mutant:, test_files:)
+        SchedulerDiagnostics.child_started(handle.pid)
+        wait_result = integration.wait_with_timeout(handle.pid, timeout)
+        integration.build_result(wait_result, handle.log_paths)
       ensure
-        finalize_mutant_run(integration, pid, wait_result)
+        SchedulerDiagnostics.child_ended(handle&.pid)
+        finalize_mutant_run(integration, handle&.pid, wait_result)
       end
 
       def run_suite(integration, test_files, timeout:)
@@ -27,10 +80,11 @@ module Henitai
         end
       end
 
-      private
-
-      def fork_mutant_process(integration, mutant, test_files, log_paths)
-        Process.fork do
+      # Called from Integration::Rspec#spawn_mutant (and Minitest#spawn_mutant).
+      # Forks a child, sets process group, activates the mutant, runs tests.
+      # Returns a ChildHandle with the forked pid and log_paths.
+      def spawn_mutant(integration, mutant:, test_files:, log_paths:)
+        pid = Process.fork do
           Process.setpgid(0, 0)
           ENV["HENITAI_MUTANT_ID"] = mutant.id
           Process.exit(
@@ -41,18 +95,17 @@ module Henitai
             )
           )
         end
+        ChildHandle.new(pid:, log_paths:)
       end
 
+      private
+
       def finalize_mutant_run(integration, pid, wait_result)
         return unless pid
 
         integration.cleanup_process_group(pid) unless wait_result == :timeout
         integration.reap_child(pid) if wait_result.nil?
       end
-
-      def mutant_log_name(mutant)
-        "mutant-#{mutant.id}"
-      end
     end
   end
 end

data/lib/henitai/integration/rspec_test_selection.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Henitai
+  module Integration
+    # Spec-file discovery and subject-to-spec matching for the RSpec
+    # integration. Selection uses longest-prefix matching against the subject
+    # expression and namespace, with a transitive require-based fallback.
+    module RspecTestSelection
+      REQUIRE_DIRECTIVE_PATTERN = /
+        \A\s*
+        (require|require_relative)
+        \s*
+        (?:\(\s*)?
+        ["']([^"']+)["']
+        \s*\)?
+      /x
+
+      def select_tests(subject)
+        matches = spec_files.select do |path|
+          content = File.read(path)
+          selection_patterns(subject).any? { |pattern| content.include?(pattern) }
+        rescue StandardError
+          false
+        end
+
+        return matches unless matches.empty?
+
+        fallback_spec_files(subject)
+      end
+
+      private
+
+      def spec_files
+        @spec_files ||= begin
+          paths = Dir.glob("spec/**/*_spec.rb")
+          paths - excluded_spec_files
+        end
+      end
+
+      def fallback_spec_files(subject)
+        return [] unless subject.source_file
+
+        matches = spec_files.select do |path|
+          requires_source_file_transitively?(path, subject.source_file)
+        rescue StandardError
+          false
+        end
+
+        matches.empty? ? spec_files : matches
+      end
+
+      def excluded_spec_files
+        @excluded_spec_files ||= rspec_exclude_patterns.flat_map { |pattern| Dir.glob(pattern) }.uniq
+      end
+
+      def rspec_exclude_patterns
+        rspec_config_lines.filter_map do |line|
+          line[/\A--exclude-pattern\s+(.+)\z/, 1]
+        end
+      end
+
+      def rspec_config_lines
+        return [] unless File.exist?(rspec_config_path)
+
+        File.readlines(rspec_config_path, chomp: true).map(&:strip)
+      end
+
+      def rspec_config_path
+        ".rspec"
+      end
+
+      def selection_patterns(subject)
+        [
+          subject.expression,
+          subject.namespace
+        ].compact.uniq.sort_by(&:length).reverse
+      end
+
+      def requires_source_file?(spec_file, source_file)
+        content = File.read(spec_file)
+        basename = File.basename(source_file, ".rb")
+        content.include?(basename) || content.include?(source_file)
+      end
+
+      def requires_source_file_transitively?(spec_file, source_file, visited = [])
+        normalized_spec_file = File.expand_path(spec_file)
+        return false if visited.include?(normalized_spec_file)
+
+        visited << normalized_spec_file
+        return true if requires_source_file?(spec_file, source_file)
+
+        required_files(spec_file).any? do |required_file|
+          requires_source_file_transitively?(required_file, source_file, visited)
+        end
+      end
+
+      def required_files(spec_file)
+        File.read(spec_file).lines.filter_map do |line|
+          match = line.match(REQUIRE_DIRECTIVE_PATTERN)
+          next unless match
+
+          resolve_required_file(spec_file, match[1].to_s, match[2].to_s)
+        end
+      end
+
+      def resolve_required_file(spec_file, method_name, required_path)
+        candidates =
+          if method_name == "require_relative"
+            relative_candidates(spec_file, required_path)
+          else
+            require_candidates(spec_file, required_path)
+          end
+
+        candidates.find { |candidate| File.file?(candidate) }
+      end
+
+      def relative_candidates(spec_file, required_path)
+        expand_candidates(File.dirname(spec_file), required_path)
+      end
+
+      def require_candidates(spec_file, required_path)
+        ([File.dirname(spec_file), Dir.pwd] + $LOAD_PATH).flat_map do |base_path|
+          expand_candidates(base_path, required_path)
+        end
+      end
+
+      def expand_candidates(base_path, required_path)
+        [
+          File.expand_path(required_path, base_path),
+          File.expand_path("#{required_path}.rb", base_path)
+        ].uniq
+      end
+    end
+  end
+end

data/lib/henitai/integration/scenario_log_support.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Henitai
+  module Integration
+    # Shared helpers for capturing stdout/stderr from child test processes and
+    # for reading and combining the captured log files afterwards.
+    class ScenarioLogSupport
+      def capture_child_output(log_paths)
+        output_files = open_child_output(log_paths)
+        yield
+      ensure
+        close_child_output(output_files)
+      end
+
+      def with_coverage_dir(mutant_id)
+        original_coverage_dir = ENV.fetch("HENITAI_COVERAGE_DIR", nil)
+        ENV["HENITAI_COVERAGE_DIR"] = mutation_coverage_dir(mutant_id)
+        yield
+      ensure
+        if original_coverage_dir.nil?
+          ENV.delete("HENITAI_COVERAGE_DIR")
+        else
+          ENV["HENITAI_COVERAGE_DIR"] = original_coverage_dir
+        end
+      end
+
+      def open_child_output(log_paths)
+        FileUtils.mkdir_p(File.dirname(log_paths[:log_path]))
+        output_files = build_child_output_files(log_paths)
+        sync_child_output_files(output_files)
+        redirect_child_output(output_files)
+        output_files
+      end
+
+      def close_child_output(output_files)
+        return unless output_files
+
+        restore_child_output(output_files)
+        close_child_output_files(output_files)
+      end
+
+      def build_child_output_files(log_paths)
+        {
+          original_stdout: stdout_stream.dup,
+          original_stderr: stderr_stream.dup,
+          stdout_file: File.new(log_paths[:stdout_path], "w"),
+          stderr_file: File.new(log_paths[:stderr_path], "w")
+        }
+      end
+
+      def sync_child_output_files(output_files)
+        output_files[:stdout_file].sync = true
+        output_files[:stderr_file].sync = true
+      end
+
+      def redirect_child_output(output_files)
+        reopen_child_output_stream(stdout_stream, output_files[:stdout_file])
+        reopen_child_output_stream(stderr_stream, output_files[:stderr_file])
+        $stdout = stdout_stream
+        $stderr = stderr_stream
+      end
+
+      def restore_child_output(output_files)
+        reopen_child_output_stream(stdout_stream, output_files[:original_stdout])
+        reopen_child_output_stream(stderr_stream, output_files[:original_stderr])
+        $stdout = stdout_stream
+        $stderr = stderr_stream
+      end
+
+      def reopen_child_output_stream(stream, original_stream)
+        stream.reopen(original_stream) if original_stream
+      end
+
+      def close_child_output_files(output_files)
+        %i[stdout_file stderr_file original_stdout original_stderr].each do |key|
+          output_files[key]&.close
+        end
+      end
+
+      def read_log_file(path)
+        return "" unless File.exist?(path)
+
+        File.read(path)
+      end
+
+      def write_combined_log(path, stdout, stderr)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, combined_log(stdout, stderr))
+      end
+
+      def combined_log(stdout, stderr)
+        [
+          (stdout.empty? ? nil : "stdout:\n#{stdout}"),
+          (stderr.empty? ? nil : "stderr:\n#{stderr}")
+        ].compact.join("\n")
+      end
+
+      private
+
+      def mutation_coverage_dir(mutant_id)
+        reports_dir = ENV.fetch("HENITAI_REPORTS_DIR", "reports")
+        File.join(reports_dir, "mutation-coverage", mutant_id.to_s)
+      end
+
+      def stdout_stream
+        @stdout_stream ||= IO.for_fd(1)
+      end
+
+      def stderr_stream
+        @stderr_stream ||= IO.for_fd(2)
+      end
+    end
+  end
+end