henitai 0.1.8 → 0.2.0

data/lib/henitai/mutant/activator.rb

@@ -6,6 +6,7 @@ require "unparser"
 module Henitai
   class Mutant
     # Activates a mutant inside the forked child process.
+    # rubocop:disable Metrics/ClassLength
     class Activator
       # Filters "already initialized constant" C-level warnings that fire when
       # a source file is loaded into a process that already has the constant
@@ -38,16 +39,26 @@ module Henitai
         new.activate!(mutant)
       end
 
+      # Returns the +define_method+ source string for +mutant+ without
+      # actually evaluating it. Used to pre-compute activation recipes.
+      # Returns nil if the source cannot be computed (e.g. unsupported AST node).
+      def self.activation_source_for(mutant)
+        new.send(:method_source, mutant)
+      rescue StandardError
+        nil
+      end
+
       def activate!(mutant)
         subject = mutant.subject
         raise ArgumentError, "Cannot activate wildcard subjects" if subject.method_name.nil?
 
+        source = mutant.precomputed_activation_source || method_source(mutant)
         target = target_for(subject)
         Henitai::WarningSilencer.silence do
-          target.class_eval(method_source(mutant), __FILE__, __LINE__ + 1)
+          target.class_eval(source, __FILE__, __LINE__ + 1)
           nil
         end
-      rescue Unparser::UnsupportedNodeError
+      rescue Unparser::UnsupportedNodeError, SyntaxError
         :compile_error
       end
 
@@ -266,5 +277,6 @@ module Henitai
         raise Unparser::UnsupportedNodeError, e.message
       end
     end
+    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/henitai/mutant.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "securerandom"
+require_relative "mutant_identity"
 
 module Henitai
   # Represents a single syntactic mutation applied to a Subject.
@@ -34,7 +35,8 @@ module Henitai
     ].freeze
 
     attr_reader :id, :subject, :operator, :original_node, :mutated_node,
-                :mutation_type, :description, :location
+                :mutation_type, :description, :location,
+                :precomputed_stable_id, :precomputed_activation_source
     attr_accessor :status, :killing_test, :duration, :covered_by, :tests_completed
 
     # @param subject [Subject] the subject being mutated
@@ -42,7 +44,9 @@ module Henitai
     # @param nodes [Hash] AST nodes with :original and :mutated entries
     # @param description [String] human-readable description of the mutation
     # @param location [Hash] { file:, start_line:, end_line:, start_col:, end_col: }
-    def initialize(subject:, operator:, nodes:, description:, location:)
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(subject:, operator:, nodes:, description:, location:,
+                   precomputed_stable_id: nil, precomputed_activation_source: nil)
       @id            = SecureRandom.uuid
       @subject       = subject
       @operator      = operator
@@ -50,12 +54,19 @@ module Henitai
       @mutated_node  = nodes.fetch(:mutated)
       @description   = description
       @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
     end
+    # rubocop:enable Metrics/ParameterLists
+
+    def stable_id
+      @stable_id ||= @precomputed_stable_id || MutantIdentity.stable_id(self)
+    end
 
     def killed?      = @status == :killed
     def survived?    = @status == :survived

data/lib/henitai/mutant_generator.rb

@@ -68,15 +68,34 @@ module Henitai
 
       private
 
-      def walk(node)
+      def walk(node, parent: nil)
         return unless node.is_a?(Parser::AST::Node)
 
+        # Str children of a non-heredoc dstr are raw text segments embedded
+        # inside a quoted interpolated string. They have no surrounding quotes
+        # in the source, so replacing them via source-fragment substitution
+        # would insert a quoted literal into the raw-text position and produce
+        # a SyntaxError when the mutant is activated.
+        # Heredoc dstr children are exempt: the heredoc body is plain text, so
+        # inserting "" there stays valid Ruby.
+        return if embedded_non_heredoc_dstr_str?(node, parent)
+
         apply_operators(node) if node_within_subject_range?(node)
         node.children.each do |child|
-          walk(child)
+          walk(child, parent: node)
         end
       end
 
+      def embedded_non_heredoc_dstr_str?(node, parent)
+        node.type == :str &&
+          parent&.type == :dstr &&
+          !heredoc_node?(parent)
+      end
+
+      def heredoc_node?(node)
+        node.location.respond_to?(:heredoc_body) && node.location.heredoc_body
+      end
+
       def apply_operators(node)
         return if @arid_node_filter.suppressed?(node, @config)
 

data/lib/henitai/mutant_history_store.rb

@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 
 require "date"
-require "digest"
 require "fileutils"
 require "json"
 require "sqlite3"
 require "time"
-require "unparser"
+require_relative "mutant_identity"
 
 module Henitai
   # Persists mutant outcomes across runs in a lightweight SQLite database.
@@ -87,7 +86,7 @@ module Henitai
       with_database do |db|
         ensure_schema(db)
         db.transaction do
-          insert_run(db, result, version, recorded_at)
+          insert_run(db, result, version, recorded_at) unless partial_rerun?(result)
           Array(result.mutants).each do |mutant|
             upsert_mutant(db, mutant, version, recorded_at)
           end
@@ -108,6 +107,10 @@ module Henitai
 
     private
 
+    def partial_rerun?(result)
+      result.respond_to?(:partial_rerun?) && result.partial_rerun?
+    end
+
     def with_database
       db = SQLite3::Database.new(path)
       db.results_as_hash = true
@@ -140,25 +143,7 @@ module Henitai
     end
 
     def stable_mutant_id(mutant)
-      Digest::SHA256.hexdigest(
-        [
-          mutant.subject.expression,
-          mutant.operator,
-          mutant.description,
-          mutant.location[:file],
-          mutant.location[:start_line],
-          mutant.location[:end_line],
-          mutant.location[:start_col],
-          mutant.location[:end_col],
-          mutation_signature(mutant)
-        ].join("\0")
-      )
-    end
-
-    def mutation_signature(mutant)
-      Unparser.unparse(mutant.mutated_node)
-    rescue StandardError
-      mutant.mutated_node.class.name
+      MutantIdentity.stable_id(mutant)
     end
 
     def mutation_history_entry(mutant, version, recorded_at)

data/lib/henitai/mutant_identity.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "digest"
+require "unparser"
+
+module Henitai
+  # Computes a stable, run-independent SHA256 identity for a mutant.
+  #
+  # The identity is derived from the mutant's semantic content, not the
+  # session UUID or source coordinates, so it survives ordinary line shifts.
+  module MutantIdentity
+    def self.stable_id(mutant)
+      Digest::SHA256.hexdigest(identity_components(mutant).join("\0"))
+    end
+
+    def self.identity_components(mutant)
+      [
+        mutant.subject.expression,
+        mutant.operator,
+        mutant.description,
+        mutant.location[:file],
+        mutation_signature(mutant)
+      ]
+    end
+    private_class_method :identity_components
+
+    def self.mutation_signature(mutant)
+      Unparser.unparse(mutant.mutated_node)
+    rescue StandardError
+      mutant.mutated_node.class.name
+    end
+    private_class_method :mutation_signature
+  end
+end

data/lib/henitai/parallel_execution_runner.rb

@@ -31,15 +31,26 @@ module Henitai
       start_parallel_stdin_watcher(context, stdin_pipe)
       parallel_workers(context, process_mutant).each(&:join)
     ensure
+      teardown_parallel_execution(context)
+    end
+
+    private
+
+    attr_reader :worker_count
+
+    def teardown_parallel_execution(context)
       stop_parallel_stdin_watcher(context)
       restore_parallel_signal_traps(context)
+      emit_scheduler_diagnostics if Integration::SchedulerDiagnostics.enabled?
       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 emit_scheduler_diagnostics
+      summary = Integration::SchedulerDiagnostics.summary
+      warn "[henitai-scheduler] max_concurrent_children=#{summary[:max_concurrent]}"
+      warn "[henitai-scheduler] child_intervals=#{summary[:intervals].inspect}"
+    end
 
     def build_parallel_queue(mutants)
       Queue.new.tap { |queue| mutants.each { |mutant| queue << mutant } }
@@ -84,20 +95,16 @@ module Henitai
     end
 
     def parallel_workers(context, process_mutant)
-      Array.new(worker_count) { Thread.new { process_parallel_worker(context, process_mutant) } }
+      Array.new(worker_count) do
+        Thread.new { process_parallel_worker(context, process_mutant) }
+      end
     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
-        )
+        run_one_mutant(context, process_mutant)
       rescue ThreadError
         break
       rescue StandardError => e
@@ -106,6 +113,17 @@ module Henitai
       end
     end
 
+    def run_one_mutant(context, process_mutant)
+      mutant = context.queue.pop(true)
+      process_mutant.call(
+        mutant,
+        context.integration,
+        context.config,
+        context.progress_reporter,
+        context.mutex
+      )
+    end
+
     def stop_parallel_stdin_watcher(context)
       context&.stdin_watcher&.kill
     end

data/lib/henitai/process_wakeup.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Wakeup pipe used to interrupt child-process wait loops when CHLD arrives.
+  class ProcessWakeup
+    def initialize(signal_name: "CHLD")
+      @signal_name = signal_name
+      @reader, @writer = IO.pipe
+    end
+
+    def install
+      @previous_handler = Signal.trap(signal_name) { signal }
+      self
+    end
+
+    def wait(timeout)
+      # rubocop:disable Lint/IncompatibleIoSelectWithFiberScheduler
+      IO.select([reader], nil, nil, timeout)
+      # rubocop:enable Lint/IncompatibleIoSelectWithFiberScheduler
+    rescue Errno::EINTR
+      nil
+    end
+
+    def drain
+      loop do
+        reader.read_nonblock(4096)
+      end
+    rescue IO::WaitReadable, EOFError
+      nil
+    end
+
+    def signal
+      writer.write_nonblock(".")
+    rescue IO::WaitWritable, IOError, Errno::EPIPE
+      nil
+    end
+
+    def close
+      Signal.trap(signal_name, previous_handler) if previous_handler
+    ensure
+      reader.close unless reader.closed?
+      writer.close unless writer.closed?
+    end
+
+    private
+
+    attr_reader :previous_handler, :reader, :signal_name, :writer
+  end
+end