henitai 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2380a5f3e3144cd94e68967bbf73ff7a078608e3004df80222d22646170b28b6
-  data.tar.gz: 06ee93b8a55d6dd72b12007e66929b2de22e8da984db3f033472868fa6380d92
+  metadata.gz: 28b31872e8c6d86e806caa179862bb2af3eda92425e2c9f0690fd4b5d287d573
+  data.tar.gz: d7b0d36289b8fbbe11c0a690f1b501f857e738fb997790626282846df5450724
 SHA512:
-  metadata.gz: dc9efdf5285729c07f0ebaa6d487a1fc764589522172584468d4fb200ab2a35df706085f933f40a588447c9c599b6939db999ef2bceec42a014a2fe84d336b13
-  data.tar.gz: 83bc413591f334c60143ee7e8936d5fb0fc42b3e9865f470e20d9b9e85e26c18a9a03e8b3bbac2707fc385e3dd6b2e17dcc4d0599cbce2b5dd11a94704935f54
+  metadata.gz: ed8eab942e02c4723a2a7b77f0d4b713698e61a914e1d9ab8bb3e4b1429514737dfef8160cc279a17d5d6428f6b02910f0d0258cd7e0a61342982d4a2f18e8cc
+  data.tar.gz: 4e4994d17183eecf751848d6877a300352f0e366fd715f557bc27fbdeede4e4f9164d51861bf3d1cca475fe2e789d2c80c9e2ff25331f8c34a2e957a59fbe5b9

data/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.5] - 2026-04-14
+
+### Fixed
+- Steep type errors in `Runner` after removing targeted-run bootstrap scoping:
+  updated `bootstrap_mutants` RBS signature to match the new single-argument
+  form and removed stale signatures for `refresh_coverage_for_targeted_run`,
+  `scoped_bootstrap_test_files`, `targeted_run?`, and `retry_full_bootstrap?`
+- `RSpec/ExampleLength` offense in `coverage_bootstrapper_spec.rb` — extracted
+  workspace setup and report writing into helper methods
+
+### Changed
+- Targeted-run coverage bootstrap no longer scopes the initial run to the
+  subject's test files; the full suite is always used for the baseline,
+  trading a minor performance optimisation for reliability
+
 ## [0.1.4] - 2026-04-14
 
 ### Fixed

data/README.md

@@ -163,10 +163,13 @@ cd henitai
 bundle install
 bundle exec rspec        # run tests
 bundle exec rubocop      # lint
+bundle exec henitai clean # remove stale generated report artifacts
 bundle exec henitai run  # dogfood
 ```
 
-A Dev Container configuration is included (`.devcontainer/`) for VS Code with the official `ruby:4.0.2-alpine` image and the Codex CLI preinstalled.
+A Dev Container configuration is included (`.devcontainer/`) for VS Code with the official `ruby:4`
+image, the Codex CLI, and RTK preinstalled. Codex support is bootstrapped with
+`rtk init -g --codex --auto-patch` during container creation.
 
 ## Architecture
 

data/lib/henitai/cli.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "fileutils"
 require "optparse"
 module Henitai
   # Command-line interface entry point.
@@ -35,6 +36,15 @@ module Henitai
       "  low: 60"
     ].freeze
 
+    REPORT_CLEANUP_PATHS = [
+      %w[mutation-logs baseline.log],
+      %w[mutation-logs baseline.stdout.log],
+      %w[mutation-logs baseline.stderr.log],
+      %w[coverage .resultset.json],
+      %w[coverage .last_run.json],
+      ["henitai_per_test.json"]
+    ].freeze
+
     OPERATOR_METADATA = {
       "ArithmeticOperator" => ["Arithmetic operators", "a + b -> a - b"],
       "EqualityOperator" => ["Comparison operators", "a == b -> a != b"],
@@ -69,6 +79,7 @@ module Henitai
       command = @argv.shift
       case command
       when "run"     then run_command
+      when "clean"   then clean_command
       when "version" then puts Henitai::VERSION
       when "init"    then init_command
       when "operator" then operator_command
@@ -94,6 +105,18 @@ module Henitai
       handle_run_error(e)
     end
 
+    def clean_command
+      @command_halted = false
+      options = parse_clean_options
+      return if @command_halted
+
+      config = load_config(options)
+      removed_paths = cleanup_report_artifacts(config)
+      puts clean_summary(removed_paths)
+    rescue StandardError => e
+      handle_run_error(e)
+    end
+
     def parse_run_options
       options = {}
       build_run_option_parser(options).parse!(@argv)
@@ -142,6 +165,21 @@ module Henitai
       end
     end
 
+    def parse_clean_options
+      options = {}
+      build_clean_option_parser(options).parse!(@argv)
+      options
+    end
+
+    def build_clean_option_parser(options)
+      OptionParser.new do |opts|
+        opts.banner = "Usage: henitai clean [options]"
+        add_config_option(opts, options)
+        add_help_option(opts)
+        add_version_option(opts)
+      end
+    end
+
     def add_since_option(opts, options)
       opts.on("--since GIT_REF", "Only mutate subjects changed since GIT_REF") do |ref|
         options[:since] = ref
@@ -198,6 +236,7 @@ module Henitai
 
         Usage:
           henitai run [options] [SUBJECT_PATTERN...]
+          henitai clean [options]
           henitai version
           henitai init [PATH]
           henitai operator list
@@ -207,6 +246,7 @@ module Henitai
           bundle exec henitai run --since origin/main
           bundle exec henitai run 'Foo::Bar#my_method'
           bundle exec henitai run 'MyNamespace*' --operators full
+          bundle exec henitai clean
           bundle exec henitai init
           bundle exec henitai operator list
 
@@ -239,6 +279,28 @@ module Henitai
       exit 2
     end
 
+    def clean_summary(removed_paths)
+      return "No generated report artifacts to clean" if removed_paths.empty?
+
+      format(
+        "Removed %<count>s generated report artifact%<plural>s",
+        count: removed_paths.length,
+        plural: removed_paths.length == 1 ? "" : "s"
+      )
+    end
+
+    def cleanup_report_artifacts(config)
+      removed_paths = report_cleanup_paths(config).select { |path| File.exist?(path) }
+      removed_paths.each { |path| FileUtils.rm_f(path) }
+      removed_paths
+    end
+
+    def report_cleanup_paths(config)
+      REPORT_CLEANUP_PATHS.map do |relative_path|
+        File.join(config.reports_dir, *relative_path)
+      end
+    end
+
     def exit_status_for(result, config)
       result.mutation_score.to_i >= config.thresholds.fetch(:low, 60) ? 0 : 1
     end

data/lib/henitai/coverage_bootstrapper.rb

@@ -45,7 +45,7 @@ module Henitai
       return covered_sources.any? if existing_sources.empty?
       return covered_sources.any? if test_files
 
-      covered_sources == existing_sources
+      covered_sources.any?
     end
 
     def coverage_ready?(source_files, config, integration, test_files)

data/lib/henitai/equivalence_detector.rb

@@ -19,7 +19,9 @@ module Henitai
     private
 
     def equivalent_mutation?(mutant)
-      equivalent_arithmetic_mutation?(mutant) || equivalent_logical_mutation?(mutant)
+      equivalent_arithmetic_mutation?(mutant) ||
+        equivalent_logical_mutation?(mutant) ||
+        equivalent_singleton_equality_mutation?(mutant)
     end
 
     def equivalent_arithmetic_mutation?(mutant)
@@ -137,6 +139,62 @@ module Henitai
       end
     end
 
+    # Detects `lhs == <singleton>` mutated to `lhs.equal?(<singleton>)` (or the
+    # reverse), but only when the receiver is itself a singleton literal.
+    #
+    # Both sides must be singleton literals so that we can prove, without
+    # runtime type information, that `==` reduces to identity comparison.
+    # A variable or arbitrary expression as the receiver is unsafe: for example
+    # `1.0 == 1` is true while `1.0.equal?(1)` is false, and any object with a
+    # custom `#==` can exhibit the same divergence.
+    #
+    # Singleton types accepted on both receiver and RHS:
+    #   Symbol  – interned; only one instance of :foo ever exists in a process.
+    #   nil/true/false – singletons by language specification.
+    def equivalent_singleton_equality_mutation?(mutant)
+      original = mutant.original_node
+      mutated  = mutant.mutated_node
+
+      equality_send?(original) && equality_send?(mutated) &&
+        same_receiver?(original, mutated) &&
+        singleton_literal?(original.children[0]) &&
+        singleton_rhs_match?(original, mutated) &&
+        equality_operators?(original.children[1], mutated.children[1])
+    end
+
+    def singleton_rhs_match?(original, mutated)
+      rhs = original.children[2]
+      singleton_literal?(rhs) && same_node?(rhs, mutated.children[2])
+    end
+
+    def equality_send?(node)
+      node.is_a?(Parser::AST::Node) &&
+        node.type == :send &&
+        node.children.size == 3 &&
+        equality_operator?(node.children[1])
+    end
+
+    def equality_operator?(operator)
+      %i[== equal?].include?(operator)
+    end
+
+    def equality_operators?(op_a, op_b)
+      equality_operator?(op_a) && equality_operator?(op_b) && op_a != op_b
+    end
+
+    # Returns true for AST nodes that represent Ruby singleton values:
+    # symbols, nil, true, and false.
+    def singleton_literal?(node)
+      return false unless node.is_a?(Parser::AST::Node)
+
+      # rubocop:disable Lint/BooleanSymbol
+      case node.type
+      when :sym, :nil, :true, :false then true
+      else false
+      end
+      # rubocop:enable Lint/BooleanSymbol
+    end
+
     def same_node?(left, right)
       left == right
     end

data/lib/henitai/integration.rb

@@ -477,6 +477,10 @@ 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 per_test_coverage_supported?
+        false
+      end
+
       def run_mutant(mutant:, test_files:, timeout:)
         setup_load_path
         super

data/lib/henitai/runner.rb

@@ -41,10 +41,6 @@ module Henitai
     # The thread is joined before Gate 3 (static filtering), which is the first
     # phase that requires coverage data.
     #
-    # For targeted runs (`subjects:` provided), the bootstrap is further scoped
-    # to the spec files that cover the requested subjects rather than the full
-    # suite, reducing the baseline run time proportionally.
-    #
     # @return [Result]
     def run
       started_at = Time.now
@@ -76,26 +72,15 @@ module Henitai
     end
 
     def mutants_for(subjects, source_files)
-      bootstrap_thread = bootstrap_mutants(source_files, subjects)
+      bootstrap_thread = bootstrap_mutants(source_files)
       mutants = generate_mutants(subjects)
       bootstrap_thread.value
 
-      filtered_mutants = filter_mutants(mutants)
-      return filtered_mutants unless targeted_run?
-
-      refresh_coverage_for_targeted_run(filtered_mutants, source_files)
-    end
-
-    def refresh_coverage_for_targeted_run(mutants, source_files)
-      return mutants unless retry_full_bootstrap?(mutants)
-
-      bootstrap_coverage(source_files)
       filter_mutants(mutants)
     end
 
-    def bootstrap_mutants(source_files, subjects)
-      scoped_tests = scoped_bootstrap_test_files(subjects)
-      Thread.new { bootstrap_coverage(source_files, scoped_tests) }
+    def bootstrap_mutants(source_files)
+      Thread.new { bootstrap_coverage(source_files) }
     end
 
     def execute_mutants(mutants)
@@ -131,21 +116,6 @@ module Henitai
       @result
     end
 
-    # Returns the spec files to use for the coverage bootstrap.
-    #
-    # For full runs (no subject pattern given), returns nil so the bootstrapper
-    # falls back to the integration's full test-file list.
-    #
-    # For targeted runs, returns the union of test files selected for each
-    # resolved subject. Falls back to nil (all tests) if the selection is empty,
-    # so the bootstrapper always has a non-empty file list.
-    def scoped_bootstrap_test_files(subjects)
-      return nil if pattern_subjects.empty?
-
-      files = subjects.flat_map { |subject| integration.select_tests(subject) }.uniq
-      files.empty? ? nil : files
-    end
-
     def bootstrap_coverage(source_files, test_files = nil)
       coverage_bootstrapper.ensure!(source_files:, config:, integration:, test_files:)
     end
@@ -217,19 +187,6 @@ module Henitai
       Array(@subjects)
     end
 
-    def targeted_run?
-      !pattern_subjects.empty?
-    end
-
-    def retry_full_bootstrap?(mutants)
-      executable_mutants = Array(mutants).reject do |mutant|
-        %i[ignored compile_error equivalent].include?(mutant.status)
-      end
-      return false if executable_mutants.empty?
-
-      executable_mutants.all? { |mutant| mutant.status == :no_coverage }
-    end
-
     def unique_subjects(subjects)
       subjects.uniq { |subject| [subject.expression, subject.source_file] }
     end

data/lib/henitai/version.rb

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

data/sig/henitai.rbs

@@ -613,13 +613,9 @@ module Henitai
 
     def build_result: (Array[Mutant], Time, Time) -> Result
     def persist_history: (Result, Time) -> void
-    def refresh_coverage_for_targeted_run: (Array[Mutant], Array[String]) -> Array[Mutant]
     def bootstrap_coverage: (Array[String], ?Array[String]?) -> void
-    def bootstrap_mutants: (Array[String], Array[Subject]) -> Thread
+    def bootstrap_mutants: (Array[String]) -> Thread
     def mutants_for: (Array[Subject], Array[String]) -> Array[Mutant]
-    def scoped_bootstrap_test_files: (Array[Subject]) -> Array[String]?
-    def targeted_run?: () -> bool
-    def retry_full_bootstrap?: (Array[Mutant]) -> bool
     def with_reports_dir: () { () -> untyped } -> untyped
     def result_thresholds: () -> Hash[Symbol, Integer]?
   end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: henitai
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Martin Otten
-autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-04-14 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
@@ -160,7 +159,6 @@ metadata:
   homepage_uri: https://github.com/martinotten/henitai
   source_code_uri: https://github.com/martinotten/henitai/tree/v0.1.4
   rubygems_mfa_required: 'true'
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -175,8 +173,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.5
-signing_key: 
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Mutation testing for Ruby
 test_files: []