henitai 0.2.1 → 0.3.0

data/lib/henitai/integration/minitest.rb

@@ -4,6 +4,10 @@ require "fileutils"
 # Guarded to avoid a circular require: integration.rb requires this file at its
 # tail, by which point Base is already defined, so the require is skipped.
 require_relative "../integration" unless defined?(Henitai::Integration::Base)
+require_relative "minitest_load_path"
+require_relative "minitest_suite_command"
+require_relative "minitest_test_runner"
+require_relative "rails_environment_preloader"
 
 module Henitai
   module Integration
@@ -26,18 +30,18 @@ module Henitai
       end
 
       def run_mutant(mutant:, test_files:, timeout:)
-        setup_load_path
+        MinitestLoadPath.ensure!
         super
       end
 
       def spawn_mutant(mutant:, test_files:)
-        setup_load_path
+        MinitestLoadPath.ensure!
         super
       end
 
       def run_in_child(mutant:, test_files:, log_paths:)
         ENV["RAILS_ENV"] = "test" unless ENV["RAILS_ENV"] == "test"
-        preload_environment
+        RailsEnvironmentPreloader.new.call
         super
       end
 
@@ -50,50 +54,14 @@ module Henitai
         cleanup_suite_process(pid, wait_result)
       end
 
-      private
-
       def suite_command(test_files)
-        ["bundle", "exec", "ruby", "-I", "test",
-         "-r", "henitai/minitest_simplecov",
-         "-r", "henitai/minitest_coverage_hook",
-         "-e", "ARGV.each { |f| require File.expand_path(f) }",
-         *test_files]
-      end
-
-      def run_tests(test_files)
-        suppress_simplecov!
-        suppress_minitest_autorun!
-        test_files.each { |file| require File.expand_path(file) }
-        # @type var empty_args: Array[String]
-        empty_args = []
-        status = ::Minitest.run(empty_args)
-        return status if status.is_a?(Integer)
-
-        status == true ? 0 : 1
-      end
-
-      def preload_environment
-        env_file = File.expand_path("config/environment.rb")
-        require env_file if File.exist?(env_file)
-      end
-
-      def setup_load_path
-        test_dir = File.expand_path("test")
-        $LOAD_PATH.unshift(test_dir) unless $LOAD_PATH.include?(test_dir)
+        MinitestSuiteCommand.new.build(test_files)
       end
 
-      def suppress_minitest_autorun!
-        require "minitest"
-        singleton_class = ::Minitest.singleton_class
-        suppressor = @minitest_autorun_suppressor ||= Module.new.tap do |mod|
-          mod.define_method(:autorun) { nil }
-        end
-        return if singleton_class.ancestors.include?(suppressor)
+      private
 
-        singleton_class.prepend(suppressor)
-        nil
-      rescue LoadError, NameError
-        nil
+      def run_tests(test_files)
+        MinitestTestRunner.new.call(test_files)
       end
 
       def subprocess_env

data/lib/henitai/integration/minitest_load_path.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Henitai
+  module Integration
+    # Ensures the current project's test/ directory is on $LOAD_PATH, for
+    # Minitest#run_mutant/#spawn_mutant. Idempotent: safe to call repeatedly.
+    module MinitestLoadPath
+      def self.ensure!
+        test_dir = File.expand_path("test")
+        $LOAD_PATH.unshift(test_dir) unless $LOAD_PATH.include?(test_dir)
+      end
+    end
+  end
+end

data/lib/henitai/integration/minitest_suite_command.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Henitai
+  module Integration
+    # Builds the argv used to run Minitest test files in an external Ruby
+    # process, for Minitest#spawn_suite_process's baseline coverage bootstrap.
+    class MinitestSuiteCommand
+      def build(test_files)
+        ["bundle", "exec", "ruby", "-I", "test",
+         "-r", "henitai/minitest_simplecov",
+         "-r", "henitai/minitest_coverage_hook",
+         "-e", "ARGV.each { |f| require File.expand_path(f) }",
+         *test_files]
+      end
+    end
+  end
+end

data/lib/henitai/integration/minitest_test_runner.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "coverage_suppression"
+
+module Henitai
+  module Integration
+    # Runs Minitest test files in-process and normalizes the result to an
+    # exit code, for Minitest#run_tests during a single mutant activation.
+    class MinitestTestRunner
+      def call(test_files)
+        CoverageRuntimeSuppressors.suppress_simplecov!
+        suppress_autorun!
+        test_files.each { |file| require File.expand_path(file) }
+        # @type var empty_args: Array[String]
+        empty_args = []
+        status = ::Minitest.run(empty_args)
+        return status if status.is_a?(Integer)
+
+        status == true ? 0 : 1
+      end
+
+      private
+
+      def suppress_autorun!
+        require "minitest"
+        singleton_class = ::Minitest.singleton_class
+        suppressor = @autorun_suppressor ||= Module.new.tap do |mod|
+          mod.define_method(:autorun) { nil }
+        end
+        return if singleton_class.ancestors.include?(suppressor)
+
+        singleton_class.prepend(suppressor)
+        nil
+      rescue LoadError, NameError
+        nil
+      end
+    end
+  end
+end

data/lib/henitai/integration/rails_environment_preloader.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Henitai
+  module Integration
+    # Loads a Rails app's config/environment.rb if present, for
+    # Minitest#run_in_child. A no-op outside a Rails project.
+    class RailsEnvironmentPreloader
+      def call
+        env_file = File.expand_path("config/environment.rb")
+        require env_file if File.exist?(env_file)
+      end
+    end
+  end
+end

data/lib/henitai/integration/rspec_child_runner.rb

@@ -42,17 +42,17 @@ module Henitai
 
       def load_rspec_spec_files(test_files)
         debug_child_puts("[henitai-debug-child] load_spec_files_start")
-        ::RSpec.__send__(:configuration).files_to_run = test_files.map do |file|
+        ::RSpec.configuration.files_to_run = test_files.map do |file|
           File.expand_path(file)
         end
-        ::RSpec.__send__(:configuration).load_spec_files
+        ::RSpec.configuration.load_spec_files
         debug_child_example_count("after_load")
         debug_child_puts("[henitai-debug-child] load_spec_files_return")
       end
 
       def run_rspec_specs(runner)
         debug_child_puts("[henitai-debug-child] run_specs_start")
-        result = runner.send(:run_specs, ::RSpec.__send__(:world).ordered_example_groups)
+        result = runner.send(:run_specs, ::RSpec.world.ordered_example_groups)
         debug_child_puts("[henitai-debug-child] run_specs_return result=#{result.inspect}")
         result
       end

data/lib/henitai/integration/rspec_test_selection.rb

@@ -18,7 +18,10 @@ module Henitai
       def select_tests(subject)
         matches = spec_files.select do |path|
           content = File.read(path)
+          # rubocop:disable Style/ArrayIntersect -- content is a String (substring
+          # search), not a collection; `intersect?` would raise a TypeError.
           selection_patterns(subject).any? { |pattern| content.include?(pattern) }
+          # rubocop:enable Style/ArrayIntersect
         rescue StandardError
           false
         end

data/lib/henitai/integration/scenario_log_support.rb

@@ -7,6 +7,12 @@ module Henitai
     # Shared helpers for capturing stdout/stderr from child test processes and
     # for reading and combining the captured log files afterwards.
     class ScenarioLogSupport
+      # Env var carrying the per-stream capture cap (bytes) into forked
+      # children. Set by the execution engine from Configuration#max_log_bytes.
+      MAX_LOG_BYTES_ENV = "HENITAI_MAX_LOG_BYTES"
+      DEFAULT_MAX_LOG_BYTES = 5_000_000
+      DRAIN_CHUNK_BYTES = 65_536
+
       def capture_child_output(log_paths)
         output_files = open_child_output(log_paths)
         yield
@@ -26,10 +32,20 @@ module Henitai
         end
       end
 
+      # Captures via a pipe drained by a background thread that writes to the
+      # log file only up to +max_log_bytes+ and then discards the overflow.
+      # A runaway mutant (e.g. one that recurses henitai into itself and spews
+      # backtraces) can otherwise fill hundreds of MB per child; draining past
+      # the cap keeps the writer from blocking on a full pipe.
       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)
+        cap = max_log_bytes
+        output_files = {
+          original_stdout: stdout_stream.dup,
+          original_stderr: stderr_stream.dup,
+          stdout: open_capped_stream(log_paths[:stdout_path], cap),
+          stderr: open_capped_stream(log_paths[:stderr_path], cap)
+        }
         redirect_child_output(output_files)
         output_files
       end
@@ -38,26 +54,54 @@ module Henitai
         return unless output_files
 
         restore_child_output(output_files)
-        close_child_output_files(output_files)
+        finish_capped_stream(output_files[:stdout])
+        finish_capped_stream(output_files[:stderr])
+        output_files[:original_stdout]&.close
+        output_files[:original_stderr]&.close
+      end
+
+      # One capture channel: a pipe whose read end is drained (capped) into the
+      # log file by a dedicated thread. Returns the pieces close needs.
+      def open_capped_stream(path, cap)
+        file = File.new(path, "w")
+        file.sync = true
+        reader, writer = IO.pipe
+        thread = Thread.new { drain_capped(reader, file, cap) }
+        { file:, reader:, writer:, thread: }
+      end
+
+      def drain_capped(reader, file, cap)
+        written = 0
+        truncated = false
+        loop do
+          chunk = reader.readpartial(DRAIN_CHUNK_BYTES)
+          next unless written < cap
+
+          slice = chunk.byteslice(0, cap - written)
+          file.write(slice)
+          written += slice.bytesize
+          next unless written >= cap && !truncated
+
+          file.write("\n[henitai] output truncated at #{cap} bytes\n")
+          truncated = true
+        end
+      rescue IOError
+        # EOFError (a subclass) on writer close, or a closed pipe: draining done.
+        nil
       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 finish_capped_stream(stream)
+        return unless stream
 
-      def sync_child_output_files(output_files)
-        output_files[:stdout_file].sync = true
-        output_files[:stderr_file].sync = true
+        stream[:writer].close
+        stream[:thread].join
+        stream[:reader].close
+        stream[:file].close
       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])
+        reopen_child_output_stream(stdout_stream, output_files[:stdout][:writer])
+        reopen_child_output_stream(stderr_stream, output_files[:stderr][:writer])
         $stdout = stdout_stream
         $stderr = stderr_stream
       end
@@ -73,10 +117,10 @@ module Henitai
         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
+      def max_log_bytes
+        raw = ENV.fetch(MAX_LOG_BYTES_ENV, nil)
+        value = raw.to_i
+        value.positive? ? value : DEFAULT_MAX_LOG_BYTES
       end
 
       def read_log_file(path)

data/lib/henitai/minitest_coverage_reporter.rb

@@ -18,7 +18,10 @@ module Henitai
 
     def record(result)
       super
-      @collector.record_test(relative_to_pwd(result.source_location.first))
+      @collector.record_test(
+        relative_to_pwd(result.source_location.first),
+        duration: result.time
+      )
     end
 
     def report

data/lib/henitai/mutant/activator.rb

@@ -57,15 +57,27 @@ module Henitai
         subject.method_type == :class ? target.singleton_class : target
       end
 
+      # The trailing module_function re-copy handles module_function subjects:
+      # module_function copies the (private) instance method onto the module's
+      # singleton, and define_method only replaces the instance side — without
+      # the re-copy, callers of Module.method keep running the original code
+      # and every mutant in such modules falsely survives. The guard checks
+      # the pre-injection shape (private instance + singleton method on a
+      # non-Class module) so a class-level method that merely shares an
+      # instance method's name is never clobbered.
       def method_source(mutant)
         method_name = mutant.subject.method_name
         parameters = parameter_source(mutant)
         replacement = body_source(mutant)
 
         <<~RUBY
+          __henitai_module_function__ = !is_a?(Class) &&
+            private_method_defined?(:#{method_name}) &&
+            singleton_class.method_defined?(:#{method_name})
           define_method(:#{method_name}) do |#{parameters}|
             #{replacement}
           end
+          module_function :#{method_name} if __henitai_module_function__
         RUBY
       end
 
@@ -164,6 +176,8 @@ module Henitai
 
         Thread.current[:henitai_filter_const_warnings] = true
         load(source_file)
+        loaded_feature = File.expand_path(source_file)
+        $LOADED_FEATURES << loaded_feature unless $LOADED_FEATURES.include?(loaded_feature)
       ensure
         Thread.current[:henitai_filter_const_warnings] = false
       end

data/lib/henitai/mutant.rb

@@ -2,6 +2,7 @@
 
 require "securerandom"
 require_relative "mutant_identity"
+require_relative "unparse_helper"
 
 module Henitai
   # Represents a single syntactic mutation applied to a Subject.
@@ -16,6 +17,8 @@ module Henitai
   #   :pending, :killed, :survived, :timeout, :compile_error, :runtime_error,
   #   :ignored, :no_coverage
   class Mutant
+    include UnparseHelper
+
     autoload :Activator, "henitai/mutant/activator"
     autoload :ParameterSource, "henitai/mutant/parameter_source"
 
@@ -38,7 +41,8 @@ module Henitai
     attr_reader :id, :subject, :operator, :original_node, :mutated_node,
                 :mutation_type, :description, :location,
                 :precomputed_stable_id, :precomputed_activation_source
-    attr_accessor :status, :killing_test, :duration, :covered_by, :tests_completed
+    attr_accessor :status, :killing_test, :duration, :covered_by, :tests_completed,
+                  :ignore_reason, :from_cache
 
     # @param subject [Subject] the subject being mutated
     # @param operator [Symbol] operator name, e.g. :ArithmeticOperator
@@ -57,11 +61,9 @@ module Henitai
       @location      = location
       @precomputed_stable_id = precomputed_stable_id
       @precomputed_activation_source = precomputed_activation_source
-      @status        = :pending
-      @killing_test  = nil
-      @duration      = nil
-      @covered_by    = nil
-      @tests_completed = nil
+      @status = :pending
+      @killing_test = @duration = @covered_by = @tests_completed = @ignore_reason = nil
+      @from_cache = false
     end
     # rubocop:enable Metrics/ParameterLists
 
@@ -69,7 +71,12 @@ module Henitai
       @stable_id ||= @precomputed_stable_id || MutantIdentity.stable_id(self)
     end
 
+    # Unparsing is expensive and the value is needed by both the JSON and
+    # the terminal reporter — compute once per mutant.
+    def mutated_source = @mutated_source ||= safe_unparse(mutated_node)
+
     def killed?      = @status == :killed
+    def from_cache?  = @from_cache == true
     def survived?    = @status == :survived
     def pending?     = @status == :pending
     def ignored?     = @status == :ignored

data/lib/henitai/mutant_history_store/sql.rb

@@ -49,6 +49,14 @@ module Henitai
         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       SQL
 
+      # Nullable verdict-cache columns added after the initial release; see
+      # MIGRATION_COLUMNS. Old rows keep NULL there, which the incremental
+      # filter treats as never-reusable — the correct conservative behavior.
+      MIGRATION_COLUMNS = {
+        "subject_source_hash" => "TEXT",
+        "covered_tests_fingerprint" => "TEXT"
+      }.freeze
+
       UPSERT_MUTANT = <<~SQL
         INSERT INTO mutants (
           mutant_id,
@@ -58,14 +66,24 @@ module Henitai
           last_seen_at,
           current_status,
           status_history,
-          days_alive
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+          days_alive,
+          subject_source_hash,
+          covered_tests_fingerprint
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         ON CONFLICT(mutant_id) DO UPDATE SET
           last_seen_version = excluded.last_seen_version,
           last_seen_at = excluded.last_seen_at,
           current_status = excluded.current_status,
           status_history = excluded.status_history,
-          days_alive = excluded.days_alive
+          days_alive = excluded.days_alive,
+          subject_source_hash = excluded.subject_source_hash,
+          covered_tests_fingerprint = excluded.covered_tests_fingerprint
+      SQL
+
+      VERDICT_LOOKUP = <<~SQL
+        SELECT current_status, subject_source_hash, covered_tests_fingerprint
+        FROM mutants
+        WHERE mutant_id = ?
       SQL
     end
   end

data/lib/henitai/mutant_history_store/verdict_cache.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative "../verdict_fingerprint"
+
+module Henitai
+  class MutantHistoryStore
+    # Verdict-cache column handling for the incremental (`--incremental`)
+    # reuse feature. Mixed into {MutantHistoryStore}.
+    module VerdictCache
+      # The reusable verdicts: hashes are persisted for killed and survived
+      # mutants only; every other status stays NULL and always re-executes.
+      CACHEABLE_STATUSES = %w[killed survived].freeze
+
+      private
+
+      # Cache-hit mutants (from_cache) were never executed this run, so their
+      # covered tests are unknown — carry the stored fingerprints forward
+      # instead of recomputing them from empty data (which would wipe them
+      # and silently disable reuse after one cached run).
+      def verdict_cache_bindings(mutant, existing_row)
+        status = mutant.status.to_s
+        return [nil, nil] unless CACHEABLE_STATUSES.include?(status)
+        return existing_cache_bindings(existing_row) if from_cache?(mutant)
+        return killed_cache_bindings(mutant) if status == "killed"
+
+        survived_cache_bindings(mutant, existing_row)
+      end
+
+      def killed_cache_bindings(mutant)
+        [
+          VerdictFingerprint.subject_source_hash(mutant),
+          VerdictFingerprint.tests_fingerprint(covered_tests_for(mutant))
+        ]
+      end
+
+      # Survived rows fingerprint the full-map intersection set — the same
+      # set the incremental filter recomputes live — never Mutant#covered_by,
+      # which reflects selector fallback and test_excludes and would
+      # permanently mismatch the live set. When the fingerprint cannot be
+      # recomputed (no per-test map, recipe stubs without a source range),
+      # the previously stored bindings are kept: the filter re-validates
+      # everything live before reuse, so a carried-forward fingerprint can
+      # never validate a changed state.
+      def survived_cache_bindings(mutant, existing_row)
+        bindings = [
+          VerdictFingerprint.subject_source_hash(mutant),
+          survived_tests_fingerprint(mutant)
+        ]
+        return bindings unless bindings.any?(&:nil?)
+
+        existing_cache_bindings(existing_row)
+      end
+
+      def survived_tests_fingerprint(mutant)
+        return nil unless per_test_coverage
+
+        VerdictFingerprint.survivor_tests_fingerprint(
+          per_test_coverage.tests_covering(mutant),
+          dependency_sha: recording_dependency_sha
+        )
+      end
+
+      # One dependency sha per record call set, computed lazily so runs
+      # without survivors never touch the dependency files.
+      def recording_dependency_sha
+        @recording_dependency_sha ||= VerdictFingerprint.dependency_fingerprint
+      end
+
+      def existing_cache_bindings(existing_row)
+        return [nil, nil] unless existing_row
+
+        [existing_row["subject_source_hash"], existing_row["covered_tests_fingerprint"]]
+      end
+
+      def from_cache?(mutant)
+        mutant.respond_to?(:from_cache?) && mutant.from_cache?
+      end
+
+      def covered_tests_for(mutant)
+        mutant.respond_to?(:covered_by) ? mutant.covered_by : nil
+      end
+    end
+  end
+end