henitai 0.1.7 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0cdead9488bf4134ad58d6d920152df41ea0bd7de9a5073ed71975bba2da8d6
-  data.tar.gz: c57e3419807bdc599ddb741803895da2228a59df82bab8a03b15698de246d98f
+  metadata.gz: a993f2073367de6b25c8fe922a2089f57103d79790c1e9cd95d2ba6b573b3050
+  data.tar.gz: d6956c7b23f1ec7cd97773cdd249a2c12b17f75e080cb98092d34049a763c607
 SHA512:
-  metadata.gz: b8dac0f228eb54df57b00ff8a51e8147548fbd41bc0c2d09972868efef45ea30be5269f16fcc83f9616e71b8e011b676cc5914eb407f5ac3651455e481162c8e
-  data.tar.gz: 3bb1af3759153a8c9d806a3799180bfc69fffc80f555376f205d87a8c5073c0fd94dc12b40ceba0283f0ae227251b6ef11836e51259a372be8475bfcb95ba522
+  metadata.gz: e7a1925ad77b77ac4ed802b3419b15988a436098488a2dfb0ee11f8f930da024bc05a686606ae4e86ba6fd9f36ef4aed19ef8b1e46bef31e143d25ee4dc54ded
+  data.tar.gz: f095d945bd5f9313a202db7a6ce3936a69233b47d62b92ec353950857c27d58b75dc8084164383d66558ef2a076c62e2fd53e68621d8b9d95546c6b1114faa73

data/CHANGELOG.md

@@ -7,6 +7,36 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.10] - 2026-04-16
+
+### Fixed
+- RuboCop `RSpec/MultipleExpectations` offenses in `coverage_formatter_spec` and
+  `per_test_coverage_collector_spec` resolved by splitting each two-assertion
+  example into focused single-expectation examples
+
+## [0.1.9] - 2026-04-16
+
+### Fixed
+- SimpleCov is now suppressed during Minitest mutant child runs: `SimpleCov.start`
+  is turned into a no-op before test files are required, eliminating the
+  "Stopped processing SimpleCov as a previous error has been detected" warning
+  and avoiding unnecessary coverage instrumentation overhead in every mutant fork
+
+## [0.1.8] - 2026-04-16
+
+### Added
+- Minitest integration now supports per-test coverage: a `MinitestCoverageReporter`
+  snapshots `Coverage.peek_result` after each test and writes `henitai_per_test.json`,
+  enabling targeted mutation runs that only execute the tests covering the mutated lines —
+  the same efficiency that was previously available only to RSpec projects
+
+### Fixed
+- RSpec integration now respects `--exclude-pattern` entries in `.rspec` so excluded
+  spec files are not passed to the runner during mutation runs
+- Per-test source file filter corrected to check only the project-relative path prefix
+  rather than scanning the full absolute path, preventing false exclusions when the
+  project lives under a directory whose path contains `/spec/` or `/test/`
+
 ## [0.1.7] - 2026-04-14
 
 ### Added
@@ -181,7 +211,10 @@ 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.7...HEAD
+[Unreleased]: https://github.com/martinotten/henitai/compare/v0.1.10...HEAD
+[0.1.10]: https://github.com/martinotten/henitai/compare/v0.1.9...v0.1.10
+[0.1.9]: https://github.com/martinotten/henitai/compare/v0.1.8...v0.1.9
+[0.1.8]: https://github.com/martinotten/henitai/compare/v0.1.7...v0.1.8
 [0.1.7]: https://github.com/martinotten/henitai/compare/v0.1.6...v0.1.7
 [0.1.6]: https://github.com/martinotten/henitai/compare/v0.1.5...v0.1.6
 [0.1.5]: https://github.com/martinotten/henitai/compare/v0.1.4...v0.1.5

data/lib/henitai/coverage_formatter.rb

@@ -1,112 +1,23 @@
 # frozen_string_literal: true
 
-require "coverage"
-require "fileutils"
-require "json"
+require "henitai/per_test_coverage_collector"
 
 module Henitai
   # Collects per-test coverage data for static filtering heuristics.
   class CoverageFormatter
-    REPORT_DIR_ENV = "HENITAI_REPORTS_DIR"
-    REPORT_FILE_NAME = "henitai_per_test.json"
+    REPORT_DIR_ENV = PerTestCoverageCollector::REPORT_DIR_ENV
+    REPORT_FILE_NAME = PerTestCoverageCollector::REPORT_FILE_NAME
 
     def initialize(_output)
-      @coverage_by_test = Hash.new do |hash, test_file|
-        hash[test_file] = Hash.new { |nested, source_file| nested[source_file] = [] }
-      end
-      @previous_snapshot = {}
-      @warned_missing_coverage = false
+      @collector = PerTestCoverageCollector.new
     end
 
     def example_finished(notification)
-      snapshot = current_snapshot
-      return warn_missing_coverage unless snapshot
-
-      test_file = notification.example.metadata[:file_path]
-      new_lines(snapshot).each do |source_file, lines|
-        @coverage_by_test[test_file][source_file].concat(lines)
-        @coverage_by_test[test_file][source_file].uniq!
-        @coverage_by_test[test_file][source_file].sort!
-      end
-      @previous_snapshot = snapshot
+      @collector.record_test(notification.example.metadata[:file_path])
     end
 
     def dump_summary(_summary)
-      return if @coverage_by_test.empty?
-
-      FileUtils.mkdir_p(File.dirname(report_path))
-      File.write(report_path, JSON.pretty_generate(serializable_report))
-    end
-
-    private
-
-    def report_path
-      File.join(reports_dir, REPORT_FILE_NAME)
-    end
-
-    def reports_dir
-      ENV.fetch(REPORT_DIR_ENV, "coverage")
-    end
-
-    def current_snapshot
-      Coverage.peek_result
-    rescue StandardError
-      nil
-    end
-
-    def warn_missing_coverage
-      return if @warned_missing_coverage
-
-      warn "Per-test coverage unavailable; skipping coverage formatter output"
-      @warned_missing_coverage = true
-    end
-
-    def new_lines(snapshot)
-      snapshot.each_with_object({}) do |(source_file, file_coverage), result|
-        next unless source_file?(source_file)
-
-        lines = new_line_numbers(
-          file_coverage,
-          previous_line_counts(source_file)
-        )
-        result[source_file] = lines unless lines.empty?
-      end
-    end
-
-    def new_line_numbers(file_coverage, previous_counts)
-      line_counts_for(file_coverage).each_with_index.filter_map do |count, index|
-        next unless count.to_i.positive?
-        next if previous_counts.fetch(index, 0).to_i.positive?
-
-        index + 1
-      end
-    end
-
-    def previous_line_counts(source_file)
-      line_counts_for(@previous_snapshot.fetch(source_file, []))
-    end
-
-    def line_counts_for(file_coverage)
-      case file_coverage
-      when Hash
-        Array(file_coverage[:lines] || file_coverage["lines"])
-      else
-        Array(file_coverage)
-      end
-    end
-
-    def source_file?(path)
-      expanded = File.expand_path(path)
-      expanded.start_with?(Dir.pwd) &&
-        !expanded.include?("#{File::SEPARATOR}spec#{File::SEPARATOR}")
-    end
-
-    def serializable_report
-      @coverage_by_test.transform_values do |source_map|
-        source_map.to_h do |source_file, lines|
-          [File.expand_path(source_file), lines.uniq.sort]
-        end
-      end
+      @collector.write_report
     end
   end
 end

data/lib/henitai/eager_load.rb

@@ -4,7 +4,7 @@ require "henitai"
 
 # Force all autoloaded constants to load so mutation testing tools
 # (e.g. mutant) can discover subjects via ObjectSpace.
-SIDE_EFFECT_FILES = %w[minitest_simplecov.rb rspec_coverage_formatter.rb].freeze
+SIDE_EFFECT_FILES = %w[minitest_simplecov.rb minitest_coverage_hook.rb rspec_coverage_formatter.rb].freeze
 
 Dir[File.join(__dir__, "**/*.rb")].each do |f|
   require f unless SIDE_EFFECT_FILES.any? { |name| f.end_with?(name) }

data/lib/henitai/equivalence_detector.rb

@@ -21,7 +21,8 @@ module Henitai
     def equivalent_mutation?(mutant)
       equivalent_arithmetic_mutation?(mutant) ||
         equivalent_logical_mutation?(mutant) ||
-        equivalent_singleton_equality_mutation?(mutant)
+        equivalent_singleton_equality_mutation?(mutant) ||
+        equivalent_string_eql_mutation?(mutant)
     end
 
     def equivalent_arithmetic_mutation?(mutant)
@@ -162,6 +163,59 @@ module Henitai
         equality_operators?(original.children[1], mutated.children[1])
     end
 
+    # Detects `lhs == rhs` mutated to `lhs.eql?(rhs)` (or the reverse) when at
+    # least one operand is a string literal.
+    #
+    # String#eql? is documented to compare both type and value. Since String#==
+    # also compares type and value (it returns false for any non-String argument
+    # without invoking the other object's #==), the two methods are equivalent
+    # for all possible inputs whenever at least one operand is statically known
+    # to be a String — proven here by the presence of a :str literal on the
+    # receiver or the argument side.
+    #
+    # When no operand is a string literal we conservatively leave the mutant
+    # pending: the receiver could be any object whose custom #== diverges from
+    # its #eql?.
+    def equivalent_string_eql_mutation?(mutant)
+      original = mutant.original_node
+      mutated  = mutant.mutated_node
+
+      string_eql_send?(original) && string_eql_send?(mutated) &&
+        same_receiver?(original, mutated) &&
+        string_eql_operators?(original.children[1], mutated.children[1]) &&
+        same_rhs?(original, mutated) &&
+        string_operand?(original)
+    end
+
+    def string_eql_send?(node)
+      node.is_a?(Parser::AST::Node) &&
+        node.type == :send &&
+        node.children.size == 3 &&
+        string_eql_operator?(node.children[1])
+    end
+
+    def string_eql_operator?(operator)
+      %i[== eql?].include?(operator)
+    end
+
+    def string_eql_operators?(op_a, op_b)
+      string_eql_operator?(op_a) && string_eql_operator?(op_b) && op_a != op_b
+    end
+
+    def same_rhs?(original, mutated)
+      same_node?(original.children[2], mutated.children[2])
+    end
+
+    # Returns true when at least one operand is a string literal, giving static
+    # proof that the comparison is string-typed on at least one side.
+    def string_operand?(node)
+      string_literal?(node.children[0]) || string_literal?(node.children[2])
+    end
+
+    def string_literal?(node)
+      node.is_a?(Parser::AST::Node) && node.type == :str
+    end
+
     def singleton_rhs_match?(original, mutated)
       rhs = original.children[2]
       singleton_literal?(rhs) && same_node?(rhs, mutated.children[2])

data/lib/henitai/integration.rb

@@ -326,7 +326,8 @@ module Henitai
       end
 
       def spec_files
-        Dir.glob("spec/**/*_spec.rb")
+        paths = Dir.glob("spec/**/*_spec.rb")
+        paths - excluded_spec_files
       end
 
       def fallback_spec_files(subject)
@@ -341,6 +342,26 @@ module Henitai
         matches.empty? ? spec_files : matches
       end
 
+      def excluded_spec_files
+        rspec_exclude_patterns.flat_map { |pattern| Dir.glob(pattern) }.uniq
+      end
+
+      def rspec_exclude_patterns
+        rspec_config_lines.filter_map do |line|
+          line[/\A--exclude-pattern\s+(.+)\z/, 1]
+        end
+      end
+
+      def rspec_config_lines
+        return [] unless File.exist?(rspec_config_path)
+
+        File.readlines(rspec_config_path, chomp: true).map(&:strip)
+      end
+
+      def rspec_config_path
+        ".rspec"
+      end
+
       def selection_patterns(subject)
         [
           subject.expression,
@@ -470,6 +491,12 @@ module Henitai
       end
     end
 
+    # Prepended onto SimpleCov's singleton class to turn start into a no-op
+    # during mutant child runs. Using prepend avoids "method redefined" warnings.
+    module SimpleCovStartSuppressor
+      def start(*_args) = nil
+    end
+
     # Minitest integration adapter.
     #
     # Coverage formatter injection remains implemented in the RSpec child
@@ -477,7 +504,7 @@ module Henitai
     # coverage collection is not yet wired into this path.
     class Minitest < Rspec
       def per_test_coverage_supported?
-        false
+        true
       end
 
       def run_mutant(mutant:, test_files:, timeout:)
@@ -505,11 +532,13 @@ module Henitai
       def suite_command(test_files)
         ["bundle", "exec", "ruby", "-I", "test",
          "-r", "henitai/minitest_simplecov",
+         "-r", "henitai/minitest_coverage_hook",
          "-e", "ARGV.each { |f| require File.expand_path(f) }",
          *test_files]
       end
 
       def run_tests(test_files)
+        suppress_simplecov!
         test_files.each { |file| require File.expand_path(file) }
         # @type var empty_args: Array[String]
         empty_args = []
@@ -529,6 +558,16 @@ module Henitai
         $LOAD_PATH.unshift(test_dir) unless $LOAD_PATH.include?(test_dir)
       end
 
+      def suppress_simplecov!
+        require "simplecov"
+        sc = Object.const_get(:SimpleCov) # steep:ignore Ruby::UnknownConstant
+        return if sc.singleton_class.ancestors.include?(SimpleCovStartSuppressor)
+
+        sc.singleton_class.prepend(SimpleCovStartSuppressor)
+      rescue LoadError, NameError
+        nil
+      end
+
       def subprocess_env
         env = super
         env["RAILS_ENV"] = "test" unless ENV["RAILS_ENV"] == "test"

data/lib/henitai/minitest_coverage_hook.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# Injected by henitai into the Minitest baseline subprocess to collect
+# per-test line coverage. Must be required after henitai/minitest_simplecov
+# so that Coverage is already running when the reporter takes snapshots.
+
+require "minitest"
+require "henitai/minitest_coverage_reporter"
+
+Minitest.extensions << "henitai_coverage"
+
+# Henitai per-test coverage plugin for Minitest.
+module Minitest
+  def self.plugin_henitai_coverage_init(_options)
+    reporter.reporters << Henitai::MinitestCoverageReporter.new
+  end
+end

data/lib/henitai/minitest_coverage_reporter.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "minitest"
+require "henitai/per_test_coverage_collector"
+
+module Henitai
+  # Minitest reporter that collects per-test line coverage deltas.
+  #
+  # Added to Minitest's reporter chain by the henitai_coverage plugin
+  # (see minitest_coverage_hook.rb). Delegates accumulation and serialisation
+  # to PerTestCoverageCollector so the JSON output format is identical to the
+  # RSpec integration.
+  class MinitestCoverageReporter < Minitest::Reporter
+    def initialize(io = $stdout, options = {})
+      super
+      @collector = PerTestCoverageCollector.new
+    end
+
+    def record(result)
+      super
+      @collector.record_test(relative_to_pwd(result.source_location.first))
+    end
+
+    def report
+      super
+      @collector.write_report
+    end
+
+    private
+
+    def relative_to_pwd(path)
+      prefix = "#{Dir.pwd}#{File::SEPARATOR}"
+      path.start_with?(prefix) ? path.sub(prefix, "") : path
+    end
+  end
+end

data/lib/henitai/per_test_coverage_collector.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "coverage"
+require "fileutils"
+require "json"
+
+module Henitai
+  # Accumulates per-test line coverage deltas across test examples.
+  #
+  # Framework-agnostic core used by both the RSpec and Minitest adapters.
+  # Callers invoke record_test after each test completes and write_report
+  # once the full suite has finished.
+  class PerTestCoverageCollector
+    REPORT_DIR_ENV = "HENITAI_REPORTS_DIR"
+    REPORT_FILE_NAME = "henitai_per_test.json"
+
+    def initialize
+      @coverage_by_test = Hash.new do |hash, test_file|
+        hash[test_file] = Hash.new { |nested, source_file| nested[source_file] = [] }
+      end
+      @previous_snapshot = {}
+      @warned_missing_coverage = false
+    end
+
+    def record_test(test_file)
+      snapshot = current_snapshot
+      return warn_missing_coverage unless snapshot
+
+      new_lines(snapshot).each do |source_file, lines|
+        @coverage_by_test[test_file][source_file].concat(lines)
+        @coverage_by_test[test_file][source_file].uniq!
+        @coverage_by_test[test_file][source_file].sort!
+      end
+      @previous_snapshot = snapshot
+    end
+
+    def write_report
+      return if @coverage_by_test.empty?
+
+      FileUtils.mkdir_p(File.dirname(report_path))
+      File.write(report_path, JSON.pretty_generate(serializable_report))
+    end
+
+    private
+
+    def report_path
+      File.join(reports_dir, REPORT_FILE_NAME)
+    end
+
+    def reports_dir
+      ENV.fetch(REPORT_DIR_ENV, "coverage")
+    end
+
+    def current_snapshot
+      Coverage.peek_result
+    rescue StandardError
+      nil
+    end
+
+    def warn_missing_coverage
+      return if @warned_missing_coverage
+
+      warn "Per-test coverage unavailable; skipping coverage formatter output"
+      @warned_missing_coverage = true
+    end
+
+    def new_lines(snapshot)
+      snapshot.each_with_object({}) do |(source_file, file_coverage), result|
+        next unless source_file?(source_file)
+
+        lines = new_line_numbers(
+          file_coverage,
+          previous_line_counts(source_file)
+        )
+        result[source_file] = lines unless lines.empty?
+      end
+    end
+
+    def new_line_numbers(file_coverage, previous_counts)
+      line_counts_for(file_coverage).each_with_index.filter_map do |count, index|
+        next unless count.to_i.positive?
+        next if previous_counts.fetch(index, 0).to_i.positive?
+
+        index + 1
+      end
+    end
+
+    def previous_line_counts(source_file)
+      line_counts_for(@previous_snapshot.fetch(source_file, []))
+    end
+
+    def line_counts_for(file_coverage)
+      case file_coverage
+      when Hash
+        Array(file_coverage[:lines] || file_coverage["lines"])
+      else
+        Array(file_coverage)
+      end
+    end
+
+    def source_file?(path)
+      expanded = File.expand_path(path)
+      prefix = "#{Dir.pwd}#{File::SEPARATOR}"
+      return false unless expanded.start_with?(prefix)
+
+      relative = expanded.sub(prefix, "")
+      !relative.start_with?("spec#{File::SEPARATOR}") &&
+        !relative.start_with?("test#{File::SEPARATOR}")
+    end
+
+    def serializable_report
+      @coverage_by_test.transform_values do |source_map|
+        source_map.to_h do |source_file, lines|
+          [File.expand_path(source_file), lines.uniq.sort]
+        end
+      end
+    end
+  end
+end

data/lib/henitai/version.rb

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

data/lib/henitai.rb

@@ -41,6 +41,8 @@ module Henitai
   autoload :StillbornFilter, "henitai/stillborn_filter"
   autoload :ScenarioExecutionResult, "henitai/scenario_execution_result"
   autoload :CoverageFormatter, "henitai/coverage_formatter"
+  autoload :MinitestCoverageReporter, "henitai/minitest_coverage_reporter"
+  autoload :PerTestCoverageCollector, "henitai/per_test_coverage_collector"
   autoload :SyntaxValidator, "henitai/syntax_validator"
   autoload :SamplingStrategy, "henitai/sampling_strategy"
   autoload :TestPrioritizer, "henitai/test_prioritizer"

data/sig/henitai.rbs

@@ -39,6 +39,15 @@ end
 
 module ::Minitest
   def self.run: (Array[String]) -> bool
+  def self.extensions: () -> Array[String]
+  def self.reporter: () -> untyped
+  def self.plugin_henitai_coverage_init: (untyped) -> void
+
+  class Reporter
+    def initialize: (?IO, ?Hash[untyped, untyped]) -> void
+    def record: (untyped) -> void
+    def report: () -> void
+  end
 end
 
 module ::RSpec::Core::Formatters
@@ -177,25 +186,45 @@ module Henitai
     def valid?: (Mutant) -> bool
   end
 
-  class CoverageFormatter
+  class PerTestCoverageCollector
     REPORT_DIR_ENV: String
     REPORT_FILE_NAME: String
 
-    def initialize: (untyped) -> void
-    def example_finished: (untyped) -> void
-    def dump_summary: (untyped) -> void
+    def initialize: () -> void
+    def record_test: (String) -> void
+    def write_report: () -> void
 
     private
 
     def report_path: () -> String
     def reports_dir: () -> String
     def current_snapshot: () -> untyped
-    def new_lines: (untyped) -> untyped
-    def new_line_numbers: (untyped, untyped) -> untyped
-    def previous_line_counts: (String) -> untyped
+    def warn_missing_coverage: () -> void
+    def new_lines: (untyped) -> Hash[String, Array[Integer]]
+    def new_line_numbers: (untyped, untyped) -> Array[Integer]
+    def previous_line_counts: (String) -> Array[untyped]
     def line_counts_for: (untyped) -> Array[untyped]
     def source_file?: (String) -> bool
-    def serializable_report: () -> untyped
+    def serializable_report: () -> Hash[String, Hash[String, Array[Integer]]]
+  end
+
+  class CoverageFormatter
+    REPORT_DIR_ENV: String
+    REPORT_FILE_NAME: String
+
+    def initialize: (untyped) -> void
+    def example_finished: (untyped) -> void
+    def dump_summary: (untyped) -> void
+  end
+
+  class MinitestCoverageReporter < ::Minitest::Reporter
+    def initialize: (?IO, ?Hash[untyped, untyped]) -> void
+    def record: (untyped) -> void
+    def report: () -> void
+
+    private
+
+    def relative_to_pwd: (String) -> String
   end
 
   class SamplingStrategy
@@ -301,6 +330,10 @@ module Henitai
       def with_subprocess_env: () { () -> untyped } -> untyped
       def spec_files: () -> Array[String]
       def fallback_spec_files: (Subject) -> Array[String]
+      def excluded_spec_files: () -> Array[String]
+      def rspec_exclude_patterns: () -> Array[String]
+      def rspec_config_lines: () -> Array[String]
+      def rspec_config_path: () -> String
       def selection_patterns: (Subject) -> Array[String]
       def requires_source_file?: (String, String) -> bool
       def requires_source_file_transitively?: (String, String, ?Array[String]) -> bool
@@ -311,6 +344,10 @@ module Henitai
       def expand_candidates: (String, String) -> Array[String]
     end
 
+    module SimpleCovStartSuppressor
+      def start: (*untyped) -> nil
+    end
+
     class Minitest < Rspec
       def run_mutant: (mutant: Mutant, test_files: Array[String], timeout: Float) -> ScenarioExecutionResult
       def run_suite: (Array[String], ?timeout: Float) -> ScenarioExecutionResult
@@ -321,6 +358,7 @@ module Henitai
       def run_tests: (Array[String]) -> Integer
       def preload_environment: () -> void
       def setup_load_path: () -> void
+      def suppress_simplecov!: () -> void
       def subprocess_env: () -> Hash[String, String]
       def cleanup_suite_process: (Integer?, untyped) -> void
       def spec_files: () -> Array[String]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: henitai
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.10
 platform: ruby
 authors:
 - Martin Otten
@@ -101,6 +101,8 @@ files:
 - lib/henitai/git_diff_analyzer.rb
 - lib/henitai/integration.rb
 - lib/henitai/integration/rspec_process_runner.rb
+- lib/henitai/minitest_coverage_hook.rb
+- lib/henitai/minitest_coverage_reporter.rb
 - lib/henitai/minitest_simplecov.rb
 - lib/henitai/mutant.rb
 - lib/henitai/mutant/activator.rb
@@ -129,6 +131,7 @@ files:
 - lib/henitai/operators/update_operator.rb
 - lib/henitai/parallel_execution_runner.rb
 - lib/henitai/parser_current.rb
+- lib/henitai/per_test_coverage_collector.rb
 - lib/henitai/per_test_coverage_selector.rb
 - lib/henitai/reporter.rb
 - lib/henitai/result.rb
@@ -157,7 +160,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.7
+  source_code_uri: https://github.com/martinotten/henitai/tree/v0.1.10
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: