henitai 0.2.0 → 0.3.0

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

@@ -6,7 +6,6 @@ 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
@@ -24,17 +23,6 @@ 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
@@ -69,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
 
@@ -124,78 +124,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
@@ -241,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
@@ -277,6 +214,5 @@ module Henitai
         raise Unparser::UnsupportedNodeError, e.message
       end
     end
-    # rubocop:enable Metrics/ClassLength
   end
 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

@@ -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,7 +17,10 @@ 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"
 
     # Status-Vokabular folgt dem Stryker mutation-testing-report-schema.
     # :equivalent ist ein Henitai-interner Status (wird im JSON als "Ignored" serialisiert,
@@ -37,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
@@ -56,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
 
@@ -68,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

@@ -0,0 +1,90 @@
+# 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
+
+      # 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,
+          first_seen_version,
+          first_seen_at,
+          last_seen_version,
+          last_seen_at,
+          current_status,
+          status_history,
+          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,
+          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
+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

data/lib/henitai/mutant_history_store.rb

@@ -6,76 +6,20 @@ require "json"
 require "sqlite3"
 require "time"
 require_relative "mutant_identity"
+require_relative "mutant_history_store/sql"
+require_relative "mutant_history_store/verdict_cache"
 
 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:)
+    include VerdictCache
+
+    # @param per_test_coverage [PerTestCoverage, nil] live per-test coverage
+    #   view used to record the full-map intersection set for survived
+    #   verdicts; without it survived rows stay NULL (never reusable).
+    def initialize(path:, per_test_coverage: nil)
       @path = path
+      @per_test_coverage = per_test_coverage
     end
 
     attr_reader :path
@@ -94,6 +38,27 @@ module Henitai
       end
     end
 
+    # Verdict-cache lookup for `--incremental`: returns the stored hashes for
+    # the mutant's LATEST verdict when it is Killed or Survived — the upsert
+    # keeps exactly one row per stable id, so current_status is always the
+    # most recent outcome. nil for every other status, unknown ids and legacy
+    # rows without hashes (recorded before the cache columns existed).
+    def verdict_for(stable_id)
+      return nil unless File.exist?(path)
+
+      with_database do |db|
+        ensure_schema(db)
+        verdict_from_row(db.get_first_row(Sql::VERDICT_LOOKUP, stable_id))
+      end
+    end
+
+    # Killed-only view of {#verdict_for}, kept for the original killed reuse
+    # path.
+    def killed_verdict_for(stable_id)
+      verdict = verdict_for(stable_id)
+      verdict if verdict && verdict[:status] == :killed
+    end
+
     def trend_report
       with_database do |db|
         ensure_schema(db)
@@ -107,6 +72,19 @@ module Henitai
 
     private
 
+    attr_reader :per_test_coverage
+
+    def verdict_from_row(row)
+      return nil unless row && VerdictCache::CACHEABLE_STATUSES.include?(row["current_status"])
+      return nil if row["subject_source_hash"].nil? || row["covered_tests_fingerprint"].nil?
+
+      {
+        status: row["current_status"].to_sym,
+        subject_source_hash: row["subject_source_hash"],
+        covered_tests_fingerprint: row["covered_tests_fingerprint"]
+      }
+    end
+
     def partial_rerun?(result)
       result.respond_to?(:partial_rerun?) && result.partial_rerun?
     end
@@ -120,17 +98,30 @@ 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)
+      migrate_mutants_table(db)
+    end
+
+    # Additive, idempotent in-place migration: databases created before the
+    # verdict-cache columns existed gain them on first contact, with existing
+    # rows left intact (NULL hashes — valid but never reusable).
+    def migrate_mutants_table(db)
+      existing = db.execute("PRAGMA table_info(mutants)").map { |row| row["name"] }
+      Sql::MIGRATION_COLUMNS.each do |column, type|
+        next if existing.include?(column)
+
+        db.execute("ALTER TABLE mutants ADD COLUMN #{column} #{type}")
+      end
     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
@@ -157,18 +148,12 @@ module Henitai
     def mutant_history_data(db, mutant, version, recorded_at)
       mutant_id = stable_mutant_id(mutant)
       existing = existing_mutant_row(db, mutant_id)
-      history = existing_status_history(existing)
-      history << mutation_history_entry(mutant, version, recorded_at)
+      history = existing_status_history(existing) << mutation_history_entry(mutant, version, recorded_at)
       first_seen = first_seen_metadata(existing, version, recorded_at)
 
       {
-        mutant_id: mutant_id,
-        first_seen_version: first_seen[:version],
-        first_seen_at: first_seen[:at],
-        version: version,
-        recorded_at: recorded_at,
-        mutant: mutant,
-        history: history,
+        mutant_id:, version:, recorded_at:, mutant:, history:, existing_row: existing,
+        first_seen_version: first_seen[:version], first_seen_at: first_seen[:at],
         days_alive: days_alive_since(first_seen[:at], recorded_at)
       }
     end
@@ -248,17 +233,18 @@ module Henitai
     end
 
     def upsert_mutant_bindings(data)
+      mutant = data.fetch(:mutant)
       [
         data.fetch(:mutant_id),
         data.fetch(:first_seen_version),
         data.fetch(:first_seen_at),
         data.fetch(:version),
         data.fetch(:recorded_at).iso8601,
-        data.fetch(:mutant).status.to_s,
+        mutant.status.to_s,
         JSON.generate(data.fetch(:history)),
-        data.fetch(:days_alive)
+        data.fetch(:days_alive),
+        *verdict_cache_bindings(mutant, data[:existing_row])
       ]
     end
   end
 end
-# rubocop:enable Metrics/ClassLength