henitai 0.2.0 → 0.2.1

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
@@ -124,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
@@ -277,6 +200,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

@@ -17,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,

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

@@ -6,74 +6,11 @@ require "json"
 require "sqlite3"
 require "time"
 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
@@ -120,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
@@ -261,4 +198,3 @@ module Henitai
     end
   end
 end
-# rubocop:enable Metrics/ClassLength

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