henitai 0.1.10 → 0.2.1

data/lib/henitai/mutant/activator.rb

@@ -23,31 +23,30 @@ module Henitai
       end
       Warning.singleton_class.prepend(ConstantRedefinitionFilter)
 
-      SERIALIZER_METHODS = {
-        arg: :argument_parameter_fragment,
-        optarg: :optional_parameter_fragment,
-        restarg: :rest_parameter_fragment,
-        kwarg: :keyword_parameter_fragment,
-        kwoptarg: :optional_keyword_parameter_fragment,
-        kwrestarg: :keyword_rest_parameter_fragment,
-        blockarg: :block_parameter_fragment,
-        forward_arg: :forward_parameter_fragment
-      }.freeze
-
       def self.activate!(mutant)
         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
 
@@ -113,78 +112,13 @@ module Henitai
       end
 
       def parameter_source(mutant)
-        args_node = method_arguments(mutant.subject.ast_node)
-        return "" unless args_node
-        return forward_parameter_fragment(nil) if args_node.type == :forward_args
-
-        args_node.children.filter_map do |argument|
-          parameter_fragment(argument)
-        end.join(", ")
-      end
-
-      def method_arguments(subject_node)
-        case subject_node&.type
-        when :def
-          subject_node.children[1]
-        when :defs
-          subject_node.children[2]
-        when :block
-          block_arguments(subject_node)
-        end
-      end
-
-      def parameter_fragment(argument)
-        method_name = SERIALIZER_METHODS[argument&.type]
-        return unless method_name
-
-        send(method_name, argument)
-      end
-
-      def argument_parameter_fragment(argument)
-        argument.children[0].to_s
-      end
-
-      def optional_parameter_fragment(argument)
-        "#{argument.children[0]} = #{compile_safe_unparse(argument.children[1])}"
-      end
-
-      def rest_parameter_fragment(argument)
-        prefixed_parameter(argument, "*")
-      end
-
-      def keyword_parameter_fragment(argument)
-        "#{argument.children[0]}:"
-      end
-
-      def optional_keyword_parameter_fragment(argument)
-        "#{argument.children[0]}: #{compile_safe_unparse(argument.children[1])}"
-      end
-
-      def keyword_rest_parameter_fragment(argument)
-        prefixed_parameter(argument, "**")
-      end
-
-      def block_parameter_fragment(argument)
-        "&#{argument.children[0]}"
-      end
-
-      def forward_parameter_fragment(_argument)
-        "*args, **kwargs, &block"
-      end
-
-      def prefixed_parameter(argument, prefix)
-        name = argument.children[0]
-        name ? "#{prefix}#{name}" : prefix
+        ParameterSource.new.build(mutant.subject.ast_node)
       end
 
       def block_body(subject_node)
         subject_node.children[2]
       end
 
-      def block_arguments(subject_node)
-        subject_node.children[1]
-      end
-
       def heredoc_location?(location)
         location.respond_to?(:heredoc_body) && location.heredoc_body
       end

data/lib/henitai/mutant/parameter_source.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative "../parser_current"
+require "unparser"
+
+module Henitai
+  class Mutant
+    # Builds the parameter-list fragment of a +define_method+ block from a
+    # subject's method-definition AST node.
+    #
+    # Given the +def+/+defs+/+block+ node for a method, {#build} returns the
+    # comma-separated parameter source (e.g. "a, b = 1, *rest, key:, &blk")
+    # suitable for splicing into a +define_method(:name) do |...| ...+ template.
+    class ParameterSource
+      SERIALIZER_METHODS = {
+        arg: :argument_parameter_fragment,
+        optarg: :optional_parameter_fragment,
+        restarg: :rest_parameter_fragment,
+        kwarg: :keyword_parameter_fragment,
+        kwoptarg: :optional_keyword_parameter_fragment,
+        kwrestarg: :keyword_rest_parameter_fragment,
+        blockarg: :block_parameter_fragment,
+        forward_arg: :forward_parameter_fragment
+      }.freeze
+
+      def build(subject_node)
+        args_node = method_arguments(subject_node)
+        return "" unless args_node
+        return forward_parameter_fragment(nil) if args_node.type == :forward_args
+
+        args_node.children.filter_map do |argument|
+          parameter_fragment(argument)
+        end.join(", ")
+      end
+
+      private
+
+      def method_arguments(subject_node)
+        case subject_node&.type
+        when :def, :block
+          subject_node.children[1]
+        when :defs
+          subject_node.children[2]
+        end
+      end
+
+      def parameter_fragment(argument)
+        method_name = SERIALIZER_METHODS[argument&.type]
+        return unless method_name
+
+        send(method_name, argument)
+      end
+
+      def argument_parameter_fragment(argument)
+        argument.children[0].to_s
+      end
+
+      def optional_parameter_fragment(argument)
+        "#{argument.children[0]} = #{compile_safe_unparse(argument.children[1])}"
+      end
+
+      def rest_parameter_fragment(argument)
+        prefixed_parameter(argument, "*")
+      end
+
+      def keyword_parameter_fragment(argument)
+        "#{argument.children[0]}:"
+      end
+
+      def optional_keyword_parameter_fragment(argument)
+        "#{argument.children[0]}: #{compile_safe_unparse(argument.children[1])}"
+      end
+
+      def keyword_rest_parameter_fragment(argument)
+        prefixed_parameter(argument, "**")
+      end
+
+      def block_parameter_fragment(argument)
+        "&#{argument.children[0]}"
+      end
+
+      def forward_parameter_fragment(_argument)
+        "*args, **kwargs, &block"
+      end
+
+      def prefixed_parameter(argument, prefix)
+        name = argument.children[0]
+        name ? "#{prefix}#{name}" : prefix
+      end
+
+      def compile_safe_unparse(node)
+        Unparser.unparse(node)
+      rescue StandardError => e
+        raise Unparser::UnsupportedNodeError, e.message
+      end
+    end
+  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.
@@ -16,6 +17,7 @@ module Henitai
   #   :ignored, :no_coverage
   class Mutant
     autoload :Activator, "henitai/mutant/activator"
+    autoload :ParameterSource, "henitai/mutant/parameter_source"
 
     # Status-Vokabular folgt dem Stryker mutation-testing-report-schema.
     # :equivalent ist ein Henitai-interner Status (wird im JSON als "Ignored" serialisiert,
@@ -34,7 +36,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 +45,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 +55,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/sql.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Henitai
+  class MutantHistoryStore
+    # SQL statements used by {MutantHistoryStore} to create the schema and
+    # persist run/mutant rows in the SQLite history database.
+    module Sql
+      RUNS_TABLE = <<~SQL
+        CREATE TABLE IF NOT EXISTS runs (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          version TEXT NOT NULL,
+          recorded_at TEXT NOT NULL,
+          mutation_score REAL,
+          mutation_score_indicator REAL,
+          equivalence_uncertainty TEXT,
+          total_mutants INTEGER NOT NULL,
+          killed_mutants INTEGER NOT NULL,
+          survived_mutants INTEGER NOT NULL,
+          timeout_mutants INTEGER NOT NULL,
+          equivalent_mutants INTEGER NOT NULL
+        );
+      SQL
+
+      MUTANTS_TABLE = <<~SQL
+        CREATE TABLE IF NOT EXISTS mutants (
+          mutant_id TEXT PRIMARY KEY,
+          first_seen_version TEXT NOT NULL,
+          first_seen_at TEXT NOT NULL,
+          last_seen_version TEXT NOT NULL,
+          last_seen_at TEXT NOT NULL,
+          current_status TEXT NOT NULL,
+          status_history TEXT NOT NULL,
+          days_alive INTEGER NOT NULL
+        );
+      SQL
+
+      INSERT_RUN = <<~SQL
+        INSERT INTO runs (
+          version,
+          recorded_at,
+          mutation_score,
+          mutation_score_indicator,
+          equivalence_uncertainty,
+          total_mutants,
+          killed_mutants,
+          survived_mutants,
+          timeout_mutants,
+          equivalent_mutants
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      SQL
+
+      UPSERT_MUTANT = <<~SQL
+        INSERT INTO mutants (
+          mutant_id,
+          first_seen_version,
+          first_seen_at,
+          last_seen_version,
+          last_seen_at,
+          current_status,
+          status_history,
+          days_alive
+        ) 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
+      SQL
+    end
+  end
+end

data/lib/henitai/mutant_history_store.rb

@@ -1,80 +1,16 @@
 # frozen_string_literal: true
 
 require "date"
-require "digest"
 require "fileutils"
 require "json"
 require "sqlite3"
 require "time"
-require "unparser"
+require_relative "mutant_identity"
+require_relative "mutant_history_store/sql"
 
 module Henitai
   # Persists mutant outcomes across runs in a lightweight SQLite database.
-  # rubocop:disable Metrics/ClassLength
   class MutantHistoryStore
-    RUNS_TABLE_SQL = <<~SQL
-      CREATE TABLE IF NOT EXISTS runs (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        version TEXT NOT NULL,
-        recorded_at TEXT NOT NULL,
-        mutation_score REAL,
-        mutation_score_indicator REAL,
-        equivalence_uncertainty TEXT,
-        total_mutants INTEGER NOT NULL,
-        killed_mutants INTEGER NOT NULL,
-        survived_mutants INTEGER NOT NULL,
-        timeout_mutants INTEGER NOT NULL,
-        equivalent_mutants INTEGER NOT NULL
-      );
-    SQL
-
-    MUTANTS_TABLE_SQL = <<~SQL
-      CREATE TABLE IF NOT EXISTS mutants (
-        mutant_id TEXT PRIMARY KEY,
-        first_seen_version TEXT NOT NULL,
-        first_seen_at TEXT NOT NULL,
-        last_seen_version TEXT NOT NULL,
-        last_seen_at TEXT NOT NULL,
-        current_status TEXT NOT NULL,
-        status_history TEXT NOT NULL,
-        days_alive INTEGER NOT NULL
-      );
-    SQL
-
-    INSERT_RUN_SQL = <<~SQL
-      INSERT INTO runs (
-        version,
-        recorded_at,
-        mutation_score,
-        mutation_score_indicator,
-        equivalence_uncertainty,
-        total_mutants,
-        killed_mutants,
-        survived_mutants,
-        timeout_mutants,
-        equivalent_mutants
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    SQL
-
-    UPSERT_MUTANT_SQL = <<~SQL
-      INSERT INTO mutants (
-        mutant_id,
-        first_seen_version,
-        first_seen_at,
-        last_seen_version,
-        last_seen_at,
-        current_status,
-        status_history,
-        days_alive
-      ) 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
-    SQL
-
     def initialize(path:)
       @path = path
     end
@@ -87,7 +23,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 +44,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
@@ -117,17 +57,17 @@ module Henitai
     end
 
     def ensure_schema(db)
-      db.execute_batch(RUNS_TABLE_SQL)
-      db.execute_batch(MUTANTS_TABLE_SQL)
+      db.execute_batch(Sql::RUNS_TABLE)
+      db.execute_batch(Sql::MUTANTS_TABLE)
     end
 
     def insert_run(db, result, version, recorded_at)
-      db.execute(INSERT_RUN_SQL, insert_run_bindings(result, version, recorded_at))
+      db.execute(Sql::INSERT_RUN, insert_run_bindings(result, version, recorded_at))
     end
 
     def upsert_mutant(db, mutant, version, recorded_at)
       db.execute(
-        UPSERT_MUTANT_SQL,
+        Sql::UPSERT_MUTANT,
         upsert_mutant_bindings(mutant_history_data(db, mutant, version, recorded_at))
       )
     end
@@ -140,25 +80,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)
@@ -276,4 +198,3 @@ module Henitai
     end
   end
 end
-# rubocop:enable Metrics/ClassLength

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/per_test_coverage_collector.rb

@@ -53,7 +53,9 @@ module Henitai
 
     def current_snapshot
       Coverage.peek_result
-    rescue StandardError
+    rescue RuntimeError
+      # Raised when coverage measurement is not running; caller warns and skips.
+      # Other errors are genuine bugs and must surface.
       nil
     end