henitai 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb30ced7751d8a102dbfe3a5eebdb33235997723d6b2f9c7f6e5c43a02eb09b6
-  data.tar.gz: 6386ce164d48f3527f5fa042595c4218e8b508b5d7a64a255a37e74b4696b867
+  metadata.gz: d11d8d5361258fac7bddc006b8fd8485d1d085c3eaf294afc5dc97c6eed9ee7c
+  data.tar.gz: c3620c79cd2b1e59ec43abb143775e0b5edcbc2ed89b3384caa39703e7b9759a
 SHA512:
-  metadata.gz: 5c6463df3bd0184d655aedf48110635fa7706e161ef41c2a1305a738d2499713a4fd522e7a540f87900fac181cc10526fef4eadb541951d079a877c70762f4de
-  data.tar.gz: 16e16613e3c3055105685f73a0832f9aa4ce401f254710af391ef6d5c1983d3a7ecaec44ae7b5c1976bfa8a8714a7a8e1951050aa49c034d1afb817e9812817d
+  metadata.gz: eed2ea62f262d95b79bae130a0d19437749c07b8873d532bd029755a72d9600335131167da004fe01dcb9d83427fb6155de1d841df4ea8dac0e2b4651de33d26
+  data.tar.gz: a4709f5c4804af79ea9599a62dfce714487c6d947bc8f85459cebebe206c4f0f7df965bff8c0aedacca227dceb67b32876733e9bfb450dc96357e2ef879f07c4

data/CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.2] - 2026-04-07
+
+### Fixed
+- `Henitai::Mutant::Activator` now rewrites heredoc-backed method bodies from
+  source slices instead of unparsing the whole body, eliminating timeouts on
+  HTML reporter mutants
+- `henitai run -v` now stops before the run pipeline starts
+
 ## [0.1.1] - 2026-04-03
 
 ### Added
@@ -34,6 +42,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - CLI critical path: `henitai run` now executes the full pipeline, supports `--since`, returns CI-friendly exit codes, and `henitai version` prints `Henitai::VERSION`
 - RSpec per-test coverage output: `henitai/coverage_formatter` now writes `coverage/henitai_per_test.json`
 
-[Unreleased]: https://github.com/martinotten/henitai/compare/v0.1.1...HEAD
+[Unreleased]: https://github.com/martinotten/henitai/compare/v0.1.2...HEAD
+[0.1.2]: https://github.com/martinotten/henitai/compare/v0.1.1...v0.1.2
 [0.1.1]: https://github.com/martinotten/henitai/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/martinotten/henitai/releases/tag/v0.1.0

data/lib/henitai/coverage_bootstrapper.rb

@@ -9,7 +9,6 @@ module Henitai
 
     def ensure!(source_files:, config:, integration:)
       return if source_files.empty?
-      return if coverage_available?(source_files, config)
 
       bootstrap_coverage(integration, config)
       return if coverage_available?(source_files, config)

data/lib/henitai/coverage_formatter.rb

@@ -10,8 +10,6 @@ module Henitai
     REPORT_DIR_ENV = "HENITAI_REPORTS_DIR"
     REPORT_FILE_NAME = "henitai_per_test.json"
 
-    RSpec::Core::Formatters.register self, :example_finished, :dump_summary
-
     def initialize(_output)
       @coverage_by_test = Hash.new do |hash, test_file|
         hash[test_file] = Hash.new { |nested, source_file| nested[source_file] = [] }
@@ -91,7 +89,7 @@ module Henitai
     def line_counts_for(file_coverage)
       case file_coverage
       when Hash
-        Array(file_coverage["lines"])
+        Array(file_coverage[:lines] || file_coverage["lines"])
       else
         Array(file_coverage)
       end
@@ -105,7 +103,9 @@ module Henitai
 
     def serializable_report
       @coverage_by_test.transform_values do |source_map|
-        source_map.transform_values { |lines| lines.uniq.sort }
+        source_map.to_h do |source_file, lines|
+          [File.expand_path(source_file), lines.uniq.sort]
+        end
       end
     end
   end

data/lib/henitai/integration.rb

@@ -56,8 +56,8 @@ module Henitai
 
       def build_child_output_files(log_paths)
         {
-          original_stdout: $stdout.dup,
-          original_stderr: $stderr.dup,
+          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")
         }
@@ -69,13 +69,17 @@ module Henitai
       end
 
       def redirect_child_output(output_files)
-        $stdout.reopen(output_files[:stdout_file])
-        $stderr.reopen(output_files[:stderr_file])
+        reopen_child_output_stream(stdout_stream, output_files[:stdout_file])
+        reopen_child_output_stream(stderr_stream, output_files[:stderr_file])
+        $stdout = stdout_stream
+        $stderr = stderr_stream
       end
 
       def restore_child_output(output_files)
-        reopen_child_output_stream($stdout, output_files[:original_stdout])
-        reopen_child_output_stream($stderr, output_files[:original_stderr])
+        reopen_child_output_stream(stdout_stream, output_files[:original_stdout])
+        reopen_child_output_stream(stderr_stream, output_files[:original_stderr])
+        $stdout = output_files[:original_stdout]
+        $stderr = output_files[:original_stderr]
       end
 
       def reopen_child_output_stream(stream, original_stream)
@@ -94,6 +98,14 @@ module Henitai
         reports_dir = ENV.fetch("HENITAI_REPORTS_DIR", "reports")
         File.join(reports_dir, "mutation-coverage", mutant_id.to_s)
       end
+
+      def stdout_stream
+        @stdout_stream ||= IO.for_fd(1)
+      end
+
+      def stderr_stream
+        @stderr_stream ||= IO.for_fd(2)
+      end
     end
 
     # Integration adapter for RSpec.
@@ -105,7 +117,12 @@ module Henitai
     def self.for(name)
       const_get(name.capitalize)
     rescue NameError
-      raise ArgumentError, "Unknown integration: #{name}. Available: rspec"
+      available = constants.filter_map do |constant_name|
+        integration = const_get(constant_name)
+        constant_name.to_s.downcase if integration.is_a?(Class) && integration < Base
+      end.sort.join(", ")
+
+      raise ArgumentError, "Unknown integration: #{name}. Available: #{available}"
     end
 
     # Base class for all integrations.
@@ -130,6 +147,12 @@ module Henitai
       def run_mutant(mutant:, test_files:, timeout:)
         raise NotImplementedError
       end
+
+      private
+
+      def pause(seconds)
+        sleep(seconds)
+      end
     end
 
     # RSpec integration adapter.
@@ -185,6 +208,7 @@ module Henitai
       private
 
       def run_in_child(mutant:, test_files:, log_paths:)
+        Thread.report_on_exception = false
         scenario_log_support.with_coverage_dir(mutant.id) do
           scenario_log_support.capture_child_output(log_paths) do
             return 2 if Mutant::Activator.activate!(mutant) == :compile_error
@@ -231,11 +255,7 @@ module Henitai
       end
 
       def rspec_options
-        ["--require", "henitai/coverage_formatter"]
-      end
-
-      def pause(seconds)
-        sleep(seconds)
+        ["--require", "henitai/rspec_coverage_formatter"]
       end
 
       def scenario_log_support

data/lib/henitai/minitest_simplecov.rb

@@ -6,6 +6,9 @@
 # Must be required before any application code is loaded so that Coverage
 # tracking is active from the first line.
 
+require "coverage"
+Coverage.start(lines: true, branches: true, methods: true)
+
 require "simplecov"
 
 SimpleCov.coverage_dir(ENV.fetch("HENITAI_COVERAGE_DIR", "coverage"))

data/lib/henitai/mutant/activator.rb

@@ -7,6 +7,22 @@ module Henitai
   class Mutant
     # Activates a mutant inside the forked child process.
     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
+      # defined via require. Uses a thread-local flag so the filter is active
+      # only during load_source_file, leaving all other warnings untouched.
+      module ConstantRedefinitionFilter
+        PATTERN = /already initialized constant|previous definition of/
+        private_constant :PATTERN
+
+        def warn(msg, **kwargs)
+          return if Thread.current[:henitai_filter_const_warnings] && PATTERN.match?(msg.to_s)
+
+          super
+        end
+      end
+      Warning.singleton_class.prepend(ConstantRedefinitionFilter)
+
       SERIALIZER_METHODS = {
         arg: :argument_parameter_fragment,
         optarg: :optional_parameter_fragment,
@@ -26,8 +42,9 @@ module Henitai
         subject = mutant.subject
         raise ArgumentError, "Cannot activate wildcard subjects" if subject.method_name.nil?
 
+        target = target_for(subject)
         Henitai::WarningSilencer.silence do
-          target_for(subject).class_eval(method_source(mutant), __FILE__, __LINE__ + 1)
+          target.class_eval(method_source(mutant), __FILE__, __LINE__ + 1)
           nil
         end
       rescue Unparser::UnsupportedNodeError
@@ -57,44 +74,28 @@ module Henitai
         subject_node = mutant.subject.ast_node
         return compile_safe_unparse(mutant.mutated_node) unless subject_node
 
-        mutated_subject = replace_node(
-          subject_node,
-          mutant.original_node,
-          mutant.mutated_node
-        )
-        body = method_body(mutated_subject) || Parser::AST::Node.new(:nil, [])
-        compile_safe_unparse(body)
-      end
-
-      def replace_node(node, original_node, mutated_node)
-        return mutated_node if same_node?(node, original_node)
-        return node unless node.is_a?(Parser::AST::Node)
+        body = method_body(subject_node)
+        return compile_safe_unparse(Parser::AST::Node.new(:nil, [])) unless body
 
-        updated_children = node.children.map do |child|
-          replace_child(child, original_node, mutated_node)
-        end
-
-        return node if updated_children == node.children
-
-        Parser::AST::Node.new(node.type, updated_children)
+        body_source_for_mutant(body, mutant)
       end
 
-      def same_node?(left, right)
-        left_location = node_location_signature(left)
-        right_location = node_location_signature(right)
-        return left.equal?(right) unless left_location && right_location
+      def body_source_for_mutant(body, mutant)
+        original_range = mutant.original_node.location&.expression
+        location = body.location
+        return source_body(location, body) unless original_range && location
 
-        left_location == right_location
+        replacement = compile_safe_unparse(mutant.mutated_node)
+        body_source_for_location(location, original_range, replacement, body)
       end
 
-      def replace_child(child, original_node, mutated_node)
-        case child
-        when Parser::AST::Node
-          replace_node(child, original_node, mutated_node)
-        when Array
-          child.map { |item| replace_child(item, original_node, mutated_node) }
+      def body_source_for_location(location, original_range, replacement, body)
+        if heredoc_location?(location)
+          heredoc_body_source(location, original_range, replacement) ||
+            source_body(location, body)
         else
-          child
+          expression_source(location, original_range, replacement) ||
+            source_body(location, body)
         end
       end
 
@@ -184,6 +185,38 @@ module Henitai
         subject_node.children[1]
       end
 
+      def heredoc_location?(location)
+        location.respond_to?(:heredoc_body) && location.heredoc_body
+      end
+
+      def heredoc_body_source(location, original_range, replacement)
+        body_source = replace_source_fragment(
+          location.heredoc_body,
+          original_range,
+          replacement
+        )
+        return unless body_source
+
+        "#{location.expression.source}\n#{body_source}#{location.heredoc_end.source}"
+      end
+
+      def source_body(location, body)
+        return compile_safe_unparse(body) unless location
+
+        if heredoc_location?(location)
+          "#{location.expression.source}\n#{location.heredoc_body.source}#{location.heredoc_end.source}"
+        else
+          location.expression.source
+        end
+      end
+
+      def expression_source(location, original_range, replacement)
+        source_range = location.expression
+        return unless source_range
+
+        replace_source_fragment(source_range, original_range, replacement)
+      end
+
       def load_target(subject)
         Object.const_get(subject.namespace.delete_prefix("::"))
       rescue NameError
@@ -195,7 +228,10 @@ module Henitai
         source_file = subject.source_file || source_file_from_ast(subject)
         return unless source_file && File.file?(source_file)
 
+        Thread.current[:henitai_filter_const_warnings] = true
         load(source_file)
+      ensure
+        Thread.current[:henitai_filter_const_warnings] = false
       end
 
       def source_file_from_ast(subject)
@@ -211,17 +247,17 @@ module Henitai
         expression.source_buffer.name
       end
 
-      def node_location_signature(node)
-        expression = node&.location&.expression
-        return unless expression
+      def replace_source_fragment(source_range, original_range, replacement)
+        source = source_range.source
+        start = original_range.begin_pos - source_range.begin_pos
+        stop = original_range.end_pos - source_range.begin_pos
+        return unless start >= 0 && stop <= source.bytesize && start <= stop
+
+        prefix = source.byteslice(0, start)
+        suffix = source.byteslice(stop, source.bytesize - stop)
+        return unless prefix && suffix
 
-        [
-          expression.source_buffer.name,
-          expression.line,
-          expression.column,
-          expression.last_line,
-          expression.last_column
-        ]
+        prefix + replacement + suffix
       end
 
       def compile_safe_unparse(node)

data/lib/henitai/rspec_coverage_formatter.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "rspec/core"
+require "henitai/coverage_formatter"
+
+RSpec::Core::Formatters.register(
+  Henitai::CoverageFormatter,
+  :example_finished,
+  :dump_summary
+)

data/lib/henitai/static_filter.rb

@@ -32,6 +32,7 @@ module Henitai
       per_test_coverage_report_path = per_test_coverage_report_path(config)
 
       coverage_lines = coverage_lines_by_file(coverage_report_path)
+      coverage_lines = merge_method_coverage(coverage_lines, coverage_report_path)
       return coverage_lines unless coverage_lines.empty?
 
       coverage_lines_from_test_lines(
@@ -97,9 +98,10 @@ module Henitai
 
     def covered?(mutant, coverage_lines)
       file = normalize_path(mutant.location[:file])
-      start_line = mutant.location[:start_line]
-
-      Array(coverage_lines[file]).include?(start_line)
+      covered = Array(coverage_lines[file])
+      (mutant.location[:start_line]..mutant.location[:end_line]).any? do |line|
+        covered.include?(line)
+      end
     end
 
     def source_for(mutant)
@@ -115,6 +117,40 @@ module Henitai
       @compiled_ignore_patterns[patterns] ||= patterns.map { |pattern| Regexp.new(pattern) }
     end
 
+    def merge_method_coverage(coverage_lines, path)
+      return coverage_lines unless File.exist?(path)
+
+      JSON.parse(File.read(path)).each_value do |suite|
+        suite.fetch("coverage", {}).each do |file, file_coverage|
+          merge_file_method_coverage(coverage_lines, file, file_coverage)
+        end
+      end
+
+      coverage_lines.transform_values(&:sort)
+    end
+
+    def merge_file_method_coverage(coverage_lines, file, file_coverage)
+      methods = file_coverage["methods"]
+      return unless methods.is_a?(Hash)
+
+      normalized = normalize_path(file)
+      methods.each do |key, count|
+        next unless count.to_i.positive?
+
+        range = method_line_range(key)
+        next unless range
+
+        coverage_lines[normalized] = Array(coverage_lines[normalized]) | range.to_a
+      end
+    end
+
+    def method_line_range(key)
+      m = key.match(/(\d+), \d+, (\d+), \d+\]\z/)
+      return unless m
+
+      (m.captures.first.to_i..m.captures.last.to_i)
+    end
+
     def covered_lines(file_coverage)
       Array(file_coverage["lines"]).each_with_index.filter_map do |count, index|
         index + 1 if count.to_i.positive?

data/lib/henitai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Henitai
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/sig/henitai.rbs

@@ -223,6 +223,10 @@ module Henitai
       def test_files: () -> Array[String]
       def run_mutant: (mutant: Mutant, test_files: Array[String], timeout: Float) -> ScenarioExecutionResult
       def run_suite: (Array[String], ?timeout: Float) -> ScenarioExecutionResult
+
+      private
+
+      def pause: (Float) -> void
     end
 
     class ScenarioLogSupport
@@ -240,6 +244,8 @@ module Henitai
       def reopen_child_output_stream: (untyped, untyped) -> void
       def close_child_output_files: (Hash[Symbol, untyped]) -> void
       def mutation_coverage_dir: (String) -> String
+      def stdout_stream: () -> IO
+      def stderr_stream: () -> IO
     end
 
     class Rspec < Base
@@ -265,7 +271,6 @@ module Henitai
       def combined_log: (String, String) -> String
       def scenario_log_paths: (String) -> Hash[Symbol, String]
       def run_tests: (Array[String]) -> Integer
-      def pause: (Float) -> void
       def scenario_log_support: () -> ScenarioLogSupport
       def rspec_options: () -> Array[String]
       def spec_files: () -> Array[String]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: henitai
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Martin Otten
@@ -122,6 +122,7 @@ files:
 - lib/henitai/parser_current.rb
 - lib/henitai/reporter.rb
 - lib/henitai/result.rb
+- lib/henitai/rspec_coverage_formatter.rb
 - lib/henitai/runner.rb
 - lib/henitai/sampling_strategy.rb
 - lib/henitai/scenario_execution_result.rb
@@ -146,7 +147,7 @@ metadata:
   changelog_uri: https://github.com/martinotten/henitai/blob/main/CHANGELOG.md
   documentation_uri: https://github.com/martinotten/henitai/blob/main/README.md
   homepage_uri: https://github.com/martinotten/henitai
-  source_code_uri: https://github.com/martinotten/henitai/tree/v0.1.1
+  source_code_uri: https://github.com/martinotten/henitai/tree/v0.1.2
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: