henitai 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 586e777c1eb78b5345eedde4f010ab262fe1ced6e0ac3714e21dbd9aa7cc63d3
-  data.tar.gz: 7d6d5d3939777b28ab127133dc4f2d9663c29c812f6f4a77af4705a3f36ef973
+  metadata.gz: d11d8d5361258fac7bddc006b8fd8485d1d085c3eaf294afc5dc97c6eed9ee7c
+  data.tar.gz: c3620c79cd2b1e59ec43abb143775e0b5edcbc2ed89b3384caa39703e7b9759a
 SHA512:
-  metadata.gz: 0fd445f2506b0dec762413e3e992af6b93797728c4253a86de2e1ce0f60fcd189ac2d2f342033ac8d16653064ce3fc3cd885c69ad34026e9781c60ca88d85de4
-  data.tar.gz: 9d00b7d9f3237b70460306aae62729d38e0142fbf7b954c2b4528feda3a4e596f08bd373c9ed448fd0ff12de7c5c1fb867c3ea9f8cf8582792a9c3a454d2bfd5
+  metadata.gz: eed2ea62f262d95b79bae130a0d19437749c07b8873d532bd029755a72d9600335131167da004fe01dcb9d83427fb6155de1d841df4ea8dac0e2b4651de33d26
+  data.tar.gz: a4709f5c4804af79ea9599a62dfce714487c6d947bc8f85459cebebe206c4f0f7df965bff8c0aedacca227dceb67b32876733e9bfb450dc96357e2ef879f07c4

data/CHANGELOG.md

@@ -7,6 +7,32 @@ 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
+- Minitest integration for Rails projects: injects SimpleCov for coverage
+  collection, sets `RAILS_ENV=test` and `PARALLEL_WORKERS=1` in the baseline
+  subprocess, preloads `config/environment.rb` before mutant activation, adds
+  `test/` to `$LOAD_PATH` before forking, and excludes `test/system/` by default
+- `simplecov` runtime dependency (required by the Minitest integration)
+
+### Fixed
+- `rspec/core` was unconditionally required at load time, causing a `LoadError`
+  in projects that do not have RSpec installed — now loaded lazily only when the
+  RSpec integration is used
+- Coverage path normalisation now uses `File.realpath` so symlinked temp
+  directories on macOS no longer cause false no-coverage results
+
+## [0.1.0] - 2026-03-01
+
 ### Added
 - Initial gem scaffold with Ruby 4.0.2 support
 - Dev Container configuration (official `ruby:4.0.2-alpine` base image, Codex CLI preinstalled)
@@ -16,4 +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/commits/main
+[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

@@ -2,7 +2,6 @@
 
 require "fileutils"
 require "minitest"
-require "rspec/core"
 
 module Henitai
   # Namespace for test-framework integrations.
@@ -57,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")
         }
@@ -70,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)
@@ -95,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.
@@ -106,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.
@@ -131,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.
@@ -186,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
@@ -224,6 +247,7 @@ module Henitai
       end
 
       def run_tests(test_files)
+        require "rspec/core"
         status = RSpec::Core::Runner.run(test_files + rspec_options)
         return status if status.is_a?(Integer)
 
@@ -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
@@ -391,10 +411,33 @@ module Henitai
     # runner. Minitest shares selection and execution semantics, but per-test
     # coverage collection is not yet wired into this path.
     class Minitest < Rspec
+      def run_mutant(mutant:, test_files:, timeout:)
+        setup_load_path
+        super
+      end
+
+      def run_in_child(mutant:, test_files:, log_paths:)
+        ENV["RAILS_ENV"] = "test" unless ENV["RAILS_ENV"] == "test"
+        preload_environment
+        super
+      end
+
+      def run_suite(test_files, timeout: DEFAULT_SUITE_TIMEOUT)
+        log_paths = scenario_log_paths("baseline")
+        FileUtils.mkdir_p(File.dirname(log_paths[:stdout_path]))
+        pid = File.open(log_paths[:stdout_path], "w") do |stdout_file|
+          File.open(log_paths[:stderr_path], "w") do |stderr_file|
+            Process.spawn(subprocess_env, *suite_command(test_files), out: stdout_file, err: stderr_file)
+          end
+        end
+        build_result(wait_with_timeout(pid, timeout), log_paths)
+      end
+
       private
 
       def suite_command(test_files)
         ["bundle", "exec", "ruby", "-I", "test",
+         "-r", "henitai/minitest_simplecov",
          "-e", "ARGV.each { |f| require File.expand_path(f) }",
          *test_files]
       end
@@ -409,8 +452,26 @@ module Henitai
         status == true ? 0 : 1
       end
 
+      def preload_environment
+        env_file = File.expand_path("config/environment.rb")
+        require env_file if File.exist?(env_file)
+      end
+
+      def setup_load_path
+        test_dir = File.expand_path("test")
+        $LOAD_PATH.unshift(test_dir) unless $LOAD_PATH.include?(test_dir)
+      end
+
+      def subprocess_env
+        env = {} # : Hash[String, String]
+        env["RAILS_ENV"] = "test" unless ENV["RAILS_ENV"] == "test"
+        env["PARALLEL_WORKERS"] = "1"
+        env
+      end
+
       def spec_files
-        Dir.glob("test/**/*_test.rb") + Dir.glob("test/**/*_spec.rb")
+        (Dir.glob("test/**/*_test.rb") + Dir.glob("test/**/*_spec.rb"))
+          .reject { |f| f.start_with?("test/system/") }
       end
     end
   end

data/lib/henitai/minitest_simplecov.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Injected by henitai into the Minitest baseline subprocess to collect
+# line coverage and write it as a SimpleCov-compatible .resultset.json.
+#
+# 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"))
+SimpleCov.start

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?
@@ -147,7 +183,10 @@ module Henitai
     end
 
     def normalize_path(path)
-      File.expand_path(path)
+      expanded = File.expand_path(path)
+      File.realpath(expanded)
+    rescue Errno::ENOENT, Errno::ENOTDIR
+      expanded
     end
 
     def equivalence_detector

data/lib/henitai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Henitai
-  VERSION = "0.1.0"
+  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]
@@ -282,9 +287,17 @@ module Henitai
     end
 
     class Minitest < Rspec
+      def run_mutant: (mutant: Mutant, test_files: Array[String], timeout: Float) -> ScenarioExecutionResult
+      def run_suite: (Array[String], ?timeout: Float) -> ScenarioExecutionResult
+
       private
 
+      def run_in_child: (mutant: Mutant, test_files: Array[String], log_paths: Hash[Symbol, String]) -> Integer
+      def suite_command: (Array[String]) -> Array[String]
       def run_tests: (Array[String]) -> Integer
+      def preload_environment: () -> void
+      def setup_load_path: () -> void
+      def subprocess_env: () -> Hash[String, String]
       def spec_files: () -> Array[String]
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: henitai
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Martin Otten
@@ -23,6 +23,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -83,6 +97,7 @@ files:
 - lib/henitai/execution_engine.rb
 - lib/henitai/git_diff_analyzer.rb
 - lib/henitai/integration.rb
+- lib/henitai/minitest_simplecov.rb
 - lib/henitai/mutant.rb
 - lib/henitai/mutant/activator.rb
 - lib/henitai/mutant_generator.rb
@@ -107,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
@@ -131,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.0
+  source_code_uri: https://github.com/martinotten/henitai/tree/v0.1.2
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: