henitai 0.1.2 → 0.1.3

data/lib/henitai/execution_engine.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "etc"
+require_relative "parallel_execution_runner"
 
 module Henitai
   # Runs pending mutants through the selected integration.
@@ -12,7 +12,7 @@ module Henitai
           pending_mutants = Array(mutants).select(&:pending?)
           mutex = Mutex.new
           if parallel_execution?(config, pending_mutants)
-            run_parallel(pending_mutants, integration, config, progress_reporter, mutex)
+            run_parallel(pending_mutants, integration, config, progress_reporter)
           else
             run_linear(pending_mutants, integration, config, progress_reporter, mutex)
           end
@@ -31,7 +31,12 @@ module Henitai
 
     def worker_count(config)
       configured_jobs = config.respond_to?(:jobs) ? config.jobs : nil
-      configured_jobs || Etc.nprocessors
+      return configured_jobs if configured_jobs
+
+      # The fallback stays conservative for now; the execution policy still
+      # defaults to a single worker even though AvailableCpuCount exists as a
+      # future policy hook.
+      1
     end
 
     def run_linear(mutants, integration, config, progress_reporter, mutex)
@@ -40,24 +45,29 @@ module Henitai
       end
     end
 
-    def run_parallel(mutants, integration, config, progress_reporter, mutex)
-      queue = Queue.new
-      mutants.each { |mutant| queue << mutant }
+    def run_parallel(mutants, integration, config, progress_reporter)
+      ParallelExecutionRunner.new(
+        worker_count: worker_count(config)
+      ).run(
+        mutants,
+        integration,
+        config,
+        progress_reporter,
+        stdin_pipe: pipe_stdin?,
+        process_mutant: method(:process_mutant)
+      )
+    end
 
-      Array.new(worker_count(config)) do
-        Thread.new do
-          loop do
-            mutant = queue.pop(true)
-            process_mutant(mutant, integration, config, progress_reporter, mutex)
-          rescue ThreadError
-            break
-          end
-        end
-      end.each(&:join)
+    def pipe_stdin?
+      $stdin.stat.pipe?
+    rescue Errno::EBADF
+      false
     end
 
     def process_mutant(mutant, integration, config, progress_reporter, mutex)
       test_files = prioritized_tests_for(mutant, integration, config)
+      mutant.covered_by = test_files if mutant.respond_to?(:covered_by=)
+      mutant.tests_completed = test_files.size if mutant.respond_to?(:tests_completed=)
       scenario_result = run_with_flaky_retry(mutant, integration, config, test_files, mutex)
       mutant.status = scenario_status(scenario_result)
 
@@ -69,16 +79,18 @@ module Henitai
     end
 
     def prioritized_tests_for(mutant, integration, config)
-      test_prioritizer.sort(
-        integration.select_tests(mutant.subject),
+      tests = integration.select_tests(mutant.subject)
+      tests = per_test_coverage_selector.filter(
+        tests,
         mutant,
-        test_history(config)
+        reports_dir: config.reports_dir
       )
+      test_prioritizer.sort(tests, mutant, test_history(config))
     end
 
-    def test_prioritizer
-      @test_prioritizer ||= TestPrioritizer.new
-    end
+    def test_prioritizer = @test_prioritizer ||= TestPrioritizer.new
+
+    def per_test_coverage_selector = @per_test_coverage_selector ||= PerTestCoverageSelector.new
 
     def test_history(config)
       return {} unless config.respond_to?(:history)

data/lib/henitai/integration/rspec_process_runner.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Henitai
+  module Integration
+    # 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)
+      ensure
+        finalize_mutant_run(integration, pid, wait_result)
+      end
+
+      def run_suite(integration, test_files, timeout:)
+        log_paths = integration.scenario_log_paths("baseline")
+        wait_result = nil
+        FileUtils.mkdir_p(File.dirname(log_paths[:stdout_path]))
+        pid = integration.spawn_suite_process(test_files, log_paths)
+        wait_result = integration.wait_with_timeout(pid, timeout)
+        integration.build_result(wait_result, log_paths)
+      ensure
+        if pid
+          integration.cleanup_process_group(pid) unless wait_result == :timeout
+          integration.reap_child(pid) if wait_result.nil?
+        end
+      end
+
+      private
+
+      def fork_mutant_process(integration, mutant, test_files, log_paths)
+        Process.fork do
+          Process.setpgid(0, 0)
+          ENV["HENITAI_MUTANT_ID"] = mutant.id
+          Process.exit(
+            integration.run_in_child(
+              mutant: mutant,
+              test_files: test_files,
+              log_paths: log_paths
+            )
+          )
+        end
+      end
+
+      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.rb

@@ -2,6 +2,7 @@
 
 require "fileutils"
 require "minitest"
+require_relative "integration/rspec_process_runner"
 
 module Henitai
   # Namespace for test-framework integrations.
@@ -148,11 +149,99 @@ module Henitai
         raise NotImplementedError
       end
 
+      def per_test_coverage_supported?
+        false
+      end
+
+      def wait_with_timeout(pid, timeout)
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+
+        loop do
+          wait_result = Process.wait(pid, Process::WNOHANG)
+          return Process.last_status if wait_result
+
+          if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+            final_wait_result = Process.wait(pid, Process::WNOHANG)
+            return Process.last_status if final_wait_result
+
+            return handle_timeout(pid)
+          end
+
+          pause(0.01)
+        end
+      end
+
+      def reap_child(pid)
+        Process.wait(pid)
+      rescue Errno::ECHILD, Errno::ESRCH
+        nil
+      end
+
+      def cleanup_process_group(pid)
+        Process.kill(:SIGTERM, -pid)
+        pause(2.0)
+        Process.kill(:SIGKILL, -pid)
+      rescue Errno::EPERM
+        cleanup_child_process(pid)
+      rescue Errno::ESRCH
+        nil
+      end
+
       private
 
       def pause(seconds)
         sleep(seconds)
       end
+
+      def handle_timeout(pid)
+        begin
+          cleanup_process_group(pid)
+        ensure
+          reap_child(pid)
+        end
+        :timeout
+      end
+
+      def cleanup_child_process(pid)
+        Process.kill(:SIGTERM, pid)
+        pause(2.0)
+        Process.kill(:SIGKILL, pid)
+      rescue Errno::EPERM, Errno::ESRCH
+        nil
+      end
+
+      def rspec_options
+        []
+      end
+
+      def subprocess_env
+        { "PARALLEL_WORKERS" => "1" }
+      end
+
+      def scenario_log_support
+        @scenario_log_support ||= ScenarioLogSupport.new
+      end
+
+      def with_subprocess_env
+        original_env = {} # : Hash[String, String?]
+        subprocess_env.each do |key, value|
+          original_env[key] = ENV.fetch(key, nil)
+          ENV[key] = value
+        end
+        yield
+      ensure
+        restore_subprocess_env(original_env)
+      end
+
+      def restore_subprocess_env(original_env)
+        original_env.each do |key, value|
+          if value.nil?
+            ENV.delete(key)
+          else
+            ENV[key] = value
+          end
+        end
+      end
     end
 
     # RSpec integration adapter.
@@ -185,65 +274,25 @@ module Henitai
       end
 
       def run_mutant(mutant:, test_files:, timeout:)
-        log_paths = scenario_log_paths("mutant-#{mutant.id}")
-        pid = Process.fork do
-          ENV["HENITAI_MUTANT_ID"] = mutant.id
-          Process.exit(run_in_child(mutant:, test_files:, log_paths:))
-        end
-
-        build_result(wait_with_timeout(pid, timeout), log_paths)
+        RspecProcessRunner.new.run_mutant(self, mutant:, test_files:, timeout:)
       end
 
-      def run_suite(test_files, timeout: DEFAULT_SUITE_TIMEOUT)
-        log_paths = scenario_log_paths("baseline")
-        FileUtils.mkdir_p(File.dirname(log_paths[:stdout_path]))
-        pid = File.open(log_paths[:stdout_path], "w") do |stdout_file|
-          File.open(log_paths[:stderr_path], "w") do |stderr_file|
-            Process.spawn(*suite_command(test_files), out: stdout_file, err: stderr_file)
-          end
-        end
-        build_result(wait_with_timeout(pid, timeout), log_paths)
+      def per_test_coverage_supported?
+        true
       end
 
-      private
-
-      def run_in_child(mutant:, test_files:, log_paths:)
-        Thread.report_on_exception = false
-        scenario_log_support.with_coverage_dir(mutant.id) do
-          scenario_log_support.capture_child_output(log_paths) do
-            return 2 if Mutant::Activator.activate!(mutant) == :compile_error
-
-            run_tests(test_files)
-          end
-        end
+      def run_suite(test_files, timeout: DEFAULT_SUITE_TIMEOUT)
+        RspecProcessRunner.new.run_suite(self, test_files, timeout:)
       end
 
       def suite_command(test_files)
-        ["bundle", "exec", "rspec", *test_files]
-      end
-
-      def wait_with_timeout(pid, timeout)
-        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
-
-        loop do
-          return Process.last_status if Process.wait(pid, Process::WNOHANG)
-          return handle_timeout(pid) if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
-
-          pause(0.01)
-        end
-      end
-
-      def handle_timeout(pid)
-        begin
-          Process.kill(:SIGTERM, pid)
-          pause(2.0)
-          Process.kill(:SIGKILL, pid)
-        rescue Errno::ESRCH
-          # The child may exit after SIGTERM but before SIGKILL.
-        ensure
-          reap_child(pid)
-        end
-        :timeout
+        [
+          "bundle", "exec", "ruby",
+          "-r", "henitai/rspec_coverage_formatter",
+          "-S", "rspec", *test_files,
+          "--format", "progress",
+          "--format", "Henitai::CoverageFormatter"
+        ]
       end
 
       def run_tests(test_files)
@@ -254,32 +303,6 @@ module Henitai
         status == true ? 0 : 1
       end
 
-      def rspec_options
-        ["--require", "henitai/rspec_coverage_formatter"]
-      end
-
-      def scenario_log_support
-        @scenario_log_support ||= ScenarioLogSupport.new
-      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
-
       def scenario_log_paths(name)
         reports_dir = ENV.fetch("HENITAI_REPORTS_DIR", "reports")
         log_dir = File.join(reports_dir, "mutation-logs")
@@ -398,10 +421,70 @@ module Henitai
         ].uniq
       end
 
-      def reap_child(pid)
-        Process.wait(pid)
-      rescue Errno::ECHILD, Errno::ESRCH
-        nil
+      def spawn_suite_process(test_files, log_paths)
+        File.open(log_paths[:stdout_path], "w") do |stdout_file|
+          File.open(log_paths[:stderr_path], "w") do |stderr_file|
+            Process.spawn(
+              subprocess_env,
+              *suite_command(test_files),
+              out: stdout_file,
+              err: stderr_file,
+              pgroup: true
+            )
+          end
+        end
+      end
+
+      def run_in_child(mutant:, test_files:, log_paths:)
+        Thread.report_on_exception = false
+        with_subprocess_env do
+          scenario_log_support.with_coverage_dir(mutant.id) do
+            scenario_log_support.capture_child_output(log_paths) do
+              return 2 if Mutant::Activator.activate!(mutant) == :compile_error
+
+              run_tests(test_files)
+            end
+          end
+        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
+    end
+
+    # Stores the child-process log helpers shared by the integration specs.
+    class ScenarioLogSupport
+      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
     end
 
@@ -424,13 +507,11 @@ module Henitai
 
       def run_suite(test_files, timeout: DEFAULT_SUITE_TIMEOUT)
         log_paths = scenario_log_paths("baseline")
-        FileUtils.mkdir_p(File.dirname(log_paths[:stdout_path]))
-        pid = File.open(log_paths[:stdout_path], "w") do |stdout_file|
-          File.open(log_paths[:stderr_path], "w") do |stderr_file|
-            Process.spawn(subprocess_env, *suite_command(test_files), out: stdout_file, err: stderr_file)
-          end
-        end
-        build_result(wait_with_timeout(pid, timeout), log_paths)
+        pid = spawn_suite_process(test_files, log_paths)
+        wait_result = wait_with_timeout(pid, timeout)
+        build_result(wait_result, log_paths)
+      ensure
+        cleanup_suite_process(pid, wait_result)
       end
 
       private
@@ -463,12 +544,33 @@ module Henitai
       end
 
       def subprocess_env
-        env = {} # : Hash[String, String]
+        env = super
         env["RAILS_ENV"] = "test" unless ENV["RAILS_ENV"] == "test"
         env["PARALLEL_WORKERS"] = "1"
         env
       end
 
+      def spawn_suite_process(test_files, log_paths)
+        FileUtils.mkdir_p(File.dirname(log_paths[:stdout_path]))
+        File.open(log_paths[:stdout_path], "w") do |stdout_file|
+          File.open(log_paths[:stderr_path], "w") do |stderr_file|
+            Process.spawn(
+              subprocess_env,
+              *suite_command(test_files),
+              out: stdout_file,
+              err: stderr_file
+            )
+          end
+        end
+      end
+
+      def cleanup_suite_process(pid, wait_result)
+        return unless pid
+
+        cleanup_child_process(pid)
+        reap_child(pid) if wait_result.nil?
+      end
+
       def spec_files
         (Dir.glob("test/**/*_test.rb") + Dir.glob("test/**/*_spec.rb"))
           .reject { |f| f.start_with?("test/system/") }

data/lib/henitai/mutant.rb

@@ -35,7 +35,7 @@ module Henitai
 
     attr_reader :id, :subject, :operator, :original_node, :mutated_node,
                 :mutation_type, :description, :location
-    attr_accessor :status, :killing_test, :duration
+    attr_accessor :status, :killing_test, :duration, :covered_by, :tests_completed
 
     # @param subject [Subject] the subject being mutated
     # @param operator [Symbol] operator name, e.g. :ArithmeticOperator
@@ -53,6 +53,8 @@ module Henitai
       @status        = :pending
       @killing_test  = nil
       @duration      = nil
+      @covered_by    = nil
+      @tests_completed = nil
     end
 
     def killed?      = @status == :killed

data/lib/henitai/mutant_generator.rb

@@ -34,7 +34,8 @@ module Henitai
     end
 
     def generate_for_subject(subject, operators, config:, arid_node_filter:, syntax_validator:)
-      return [] unless subject.source_file && subject.source_range
+      source_node = source_node_for(subject)
+      return [] unless source_node
 
       visitor = SubjectVisitor.new(
         subject,
@@ -43,11 +44,8 @@ module Henitai
         arid_node_filter:,
         syntax_validator:
       )
-      visitor.process(SourceParser.parse_file(subject.source_file))
-      prune_mutants_per_line(
-        visitor.mutants,
-        max_mutants_per_line: config&.max_mutants_per_line || 1
-      )
+      visitor.process(source_node)
+      visitor.mutants
     end
 
     # Depth-first pre-order AST visitor for a single subject.
@@ -60,13 +58,8 @@ module Henitai
         @mutants = []
         @arid_node_filter = arid_node_filter
         @syntax_validator = syntax_validator
-        @operators_by_node_type = operators.each_with_object(
-          Hash.new { |hash, key| hash[key] = [] }
-        ) do |operator, map|
-          operator.class.node_types.each do |node_type|
-            map[node_type] << operator
-          end
-        end
+        initialize_subject_range(subject)
+        @operators_by_node_type = index_operators(operators)
       end
 
       def process(node)
@@ -95,27 +88,28 @@ module Henitai
       end
 
       def node_within_subject_range?(node)
+        return true unless @subject_range_begin
+
         location = node.location&.expression
-        return true unless location && @subject.source_range
+        return true unless location
 
-        node_range = location.line..location.last_line
-        ranges_overlap?(node_range, @subject.source_range)
+        location.line <= @subject_range_end && @subject_range_begin <= location.last_line
       end
 
-      def ranges_overlap?(left, right)
-        left.begin <= right.end && right.begin <= left.end
-      end
-    end
+      def initialize_subject_range(subject)
+        subject_range = subject.source_range
+        return unless subject_range
 
-    def prune_mutants_per_line(mutants, max_mutants_per_line:)
-      grouped = mutants.each_with_object({}) do |mutant, selected|
-        key = line_key(mutant)
-        selected[key] ||= []
-        selected[key] << mutant
+        @subject_range_begin = subject_range.begin
+        @subject_range_end = subject_range.end
       end
 
-      grouped.values.flat_map do |mutants_for_line|
-        mutants_for_line.sort_by { |mutant| mutant_priority_key(mutant) }.take(max_mutants_per_line)
+      def index_operators(operators)
+        operators.each_with_object(Hash.new { |hash, key| hash[key] = [] }) do |operator, map|
+          operator.class.node_types.each do |node_type|
+            map[node_type] << operator
+          end
+        end
       end
     end
 
@@ -131,28 +125,11 @@ module Henitai
       )
     end
 
-    def line_key(mutant)
-      [
-        mutant.location[:file],
-        mutant.location[:start_line]
-      ]
-    end
-
-    def mutant_priority_key(mutant)
-      [
-        operator_priority(mutant.operator),
-        mutant.location[:start_col] || 0,
-        mutant.description
-      ]
-    end
-
-    def operator_priority(operator_name)
-      operator_priority_map.fetch(operator_name, operator_priority_map.length)
-    end
+    def source_node_for(subject)
+      return subject.ast_node if subject.ast_node
+      return nil unless subject.source_file && subject.source_range
 
-    def operator_priority_map
-      # The constant order defines signal priority for per-line pruning.
-      @operator_priority_map ||= Operator::FULL_SET.each_with_index.to_h
+      SourceParser.new.parse_file(subject.source_file)
     end
   end
 end

data/lib/henitai/operator.rb

@@ -13,7 +13,8 @@ module Henitai
   #
   # Additional operators (full set):
   #   ArrayDeclaration, HashLiteral, RangeLiteral, SafeNavigation,
-  #   PatternMatch, BlockStatement, MethodExpression, AssignmentExpression
+  #   PatternMatch, BlockStatement, MethodExpression, AssignmentExpression,
+  #   UnaryOperator, UpdateOperator, RegexMutator, MethodChainUnwrap
   #
   # Each operator subclass must implement:
   #   - .node_types  → Array<Symbol>  AST node types this operator handles
@@ -32,12 +33,16 @@ module Henitai
     FULL_SET = (LIGHT_SET + %w[
       ArrayDeclaration
       HashLiteral
+      MethodChainUnwrap
       RangeLiteral
+      RegexMutator
       SafeNavigation
       PatternMatch
       BlockStatement
       MethodExpression
       AssignmentExpression
+      UnaryOperator
+      UpdateOperator
     ]).freeze
 
     # @param set [Symbol] :light or :full