henitai 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 748dc8e07fefafa1e15d8f84b6e047896d20615362c1edc4d69e6321acd3db4d
-  data.tar.gz: d61c9559adc952e63417d3edffc9826093ea5e0e9b3298761badf85080e11a12
+  metadata.gz: 28b31872e8c6d86e806caa179862bb2af3eda92425e2c9f0690fd4b5d287d573
+  data.tar.gz: d7b0d36289b8fbbe11c0a690f1b501f857e738fb997790626282846df5450724
 SHA512:
-  metadata.gz: 3172df8aa6dac29dd8498e0c2b697e0a1698a049ce86db1b976a5d93163206e146b16b2a641dd77088e0cc58e17238ffa657f704732a0e574d93a331faa80be0
-  data.tar.gz: 6458897e5a6c53321362b5f65cfd9018c8ca415ccad74a0ba8303c56336e182407b50cd3ac02d976bb55d2eb284444676de137719194c7bbb04f20717903f082
+  metadata.gz: ed8eab942e02c4723a2a7b77f0d4b713698e61a914e1d9ab8bb3e4b1429514737dfef8160cc279a17d5d6428f6b02910f0d0258cd7e0a61342982d4a2f18e8cc
+  data.tar.gz: 4e4994d17183eecf751848d6877a300352f0e366fd715f557bc27fbdeede4e4f9164d51861bf3d1cca475fe2e789d2c80c9e2ff25331f8c34a2e957a59fbe5b9

data/CHANGELOG.md

@@ -7,6 +7,43 @@ 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
+- `StringLiteral` operator no longer generates no-op mutations where the
+  replacement equals the original value (e.g. the spurious `"" → ""` mutant
+  that was emitted for methods already returning an empty string literal)
+- Terminal diff output now uses `display_unparse` for string literal nodes,
+  making whitespace-only mutations unambiguous in the report
+  (e.g. `""`, `" "`, and `"\n"` are now visually distinct)
+- Targeted coverage bootstrap (`--since` / explicit subjects) now correctly
+  retriggers a full suite run when the scoped bootstrap does not produce
+  coverage for all configured source files; previously the run could raise
+  `CoverageError` even though a fallback was available
+- Coverage formatter specs now honor `HENITAI_REPORTS_DIR`, so the baseline
+  coverage bootstrap no longer fails when the suite runs under the mutation
+  runner's configured reports directory
+
+### Changed
+- `ScenarioExecutionResult.build` factory method consolidates status and
+  exit-status derivation that was previously spread across `Integration`,
+  reducing the mutation surface of the value object
+
 ## [0.1.3] - 2026-04-13
 
 ### Added
@@ -122,7 +159,8 @@ 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.3...HEAD
+[Unreleased]: https://github.com/martinotten/henitai/compare/v0.1.4...HEAD
+[0.1.4]: https://github.com/martinotten/henitai/compare/v0.1.3...v0.1.4
 [0.1.3]: https://github.com/martinotten/henitai/compare/v0.1.2...v0.1.3
 [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

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

@@ -27,7 +27,7 @@ module Henitai
         bootstrap_coverage(integration, config, test_files)
       end
 
-      return if coverage_available?(source_files, config)
+      return if coverage_available?(source_files, config, test_files)
 
       raise CoverageError,
             "Coverage data is unavailable for the configured source files"
@@ -37,24 +37,37 @@ module Henitai
 
     attr_reader :static_filter
 
-    def coverage_available?(source_files, config)
+    def coverage_available?(source_files, config, test_files)
       coverage_lines = static_filter.coverage_lines_for(config)
+      covered_sources = covered_source_files(source_files, coverage_lines)
+      existing_sources = existing_source_file_paths(source_files)
 
-      source_file_paths(source_files).any? do |path|
-        Array(coverage_lines[path]).any?
-      end
+      return covered_sources.any? if existing_sources.empty?
+      return covered_sources.any? if test_files
+
+      covered_sources.any?
     end
 
     def coverage_ready?(source_files, config, integration, test_files)
       coverage_fresh?(source_files, config, integration, test_files) &&
-        coverage_available?(source_files, config) &&
+        coverage_available?(source_files, config, test_files) &&
         per_test_coverage_ready?(source_files, config, integration, test_files)
     end
 
+    def covered_source_files(source_files, coverage_lines)
+      source_file_paths(source_files).select do |path|
+        Array(coverage_lines[path]).any?
+      end
+    end
+
     def source_file_paths(source_files)
       Array(source_files).map { |path| File.expand_path(path) }
     end
 
+    def existing_source_file_paths(source_files)
+      source_file_paths(source_files).select { |path| File.exist?(path) }
+    end
+
     # Returns true when a coverage report already exists and is newer than
     # every watched source and test file. Stale or absent reports return false.
     def coverage_fresh?(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

@@ -314,35 +314,18 @@ module Henitai
       end
 
       def build_result(wait_result, log_paths)
-        status = scenario_status(wait_result)
         stdout = read_log_file(log_paths[:stdout_path])
         stderr = read_log_file(log_paths[:stderr_path])
         write_combined_log(log_paths[:log_path], stdout, stderr)
 
-        ScenarioExecutionResult.new(
-          status:,
+        ScenarioExecutionResult.build(
+          wait_result:,
           stdout:,
           stderr:,
-          log_path: log_paths[:log_path],
-          exit_status: exit_status_for(wait_result)
+          log_path: log_paths[:log_path]
         )
       end
 
-      def scenario_status(wait_result)
-        return :timeout if wait_result == :timeout
-        return :compile_error if exit_status_for(wait_result) == 2
-        return :survived if wait_result.respond_to?(:success?) && wait_result.success?
-
-        :killed
-      end
-
-      def exit_status_for(wait_result)
-        return nil if wait_result == :timeout
-        return nil unless wait_result.respond_to?(:exitstatus)
-
-        wait_result.exitstatus
-      end
-
       def spec_files
         Dir.glob("spec/**/*_spec.rb")
       end
@@ -494,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/operators/string_literal.rb

@@ -27,7 +27,8 @@ module Henitai
       private
 
       def mutate_plain_string(node, subject:)
-        REPLACEMENTS.map do |replacement|
+        original_value = node.children.first
+        REPLACEMENTS.reject { |r| r == original_value }.map do |replacement|
           build_mutant(
             subject:,
             original_node: node,

data/lib/henitai/reporter.rb

@@ -126,11 +126,23 @@ module Henitai
       end
 
       def original_line(mutant)
-        format("- %s", safe_unparse(mutant.original_node))
+        format("- %s", display_unparse(mutant.original_node))
       end
 
       def mutated_line(mutant)
-        format("+ %s", safe_unparse(mutant.mutated_node))
+        format("+ %s", display_unparse(mutant.mutated_node))
+      end
+
+      # Like safe_unparse but makes invisible characters visible in terminal
+      # output. For string literal nodes the inner value is shown via #inspect
+      # so that e.g. "" vs " " vs "\n" are unambiguous. Other nodes unparse
+      # normally.
+      def display_unparse(node)
+        if node.respond_to?(:type) && node.respond_to?(:children) && node.type == :str
+          node.children.first.inspect
+        else
+          safe_unparse(node)
+        end
       end
 
       def score_line(result)

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/scenario_execution_result.rb

@@ -5,6 +5,16 @@ module Henitai
   class ScenarioExecutionResult
     attr_reader :status, :stdout, :stderr, :exit_status, :log_path
 
+    def self.build(wait_result:, stdout:, stderr:, log_path:)
+      new(
+        status: status_for(wait_result),
+        stdout: stdout,
+        stderr: stderr,
+        log_path: log_path,
+        exit_status: exit_status_for(wait_result)
+      )
+    end
+
     def initialize(status:, stdout:, stderr:, log_path:, exit_status: nil)
       @status = status
       @stdout = stdout.to_s
@@ -51,11 +61,11 @@ module Henitai
       log_text.lines.last(lines).join
     end
 
-    def should_show_logs?(all_logs: false)
+    def should_show_logs?(all_logs: nil)
       all_logs || timeout?
     end
 
-    def failure_tail(all_logs: false, lines: 12)
+    def failure_tail(all_logs: nil, lines: 12)
       return combined_output if all_logs
       return "" unless should_show_logs?(all_logs:)
 
@@ -64,6 +74,25 @@ module Henitai
 
     private
 
+    class << self
+      private
+
+      def status_for(wait_result)
+        return :timeout if wait_result == :timeout
+        return :compile_error if exit_status_for(wait_result) == 2
+        return :survived if wait_result.respond_to?(:success?) && wait_result.success?
+
+        :killed
+      end
+
+      def exit_status_for(wait_result)
+        return nil if wait_result == :timeout
+        return nil unless wait_result.respond_to?(:exitstatus)
+
+        wait_result.exitstatus
+      end
+    end
+
     def stream_section(name, content)
       "#{name}:\n#{content}"
     end

data/lib/henitai/version.rb

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

data/sig/henitai.rbs

@@ -112,6 +112,7 @@ module Henitai
     attr_reader exit_status: Integer?
     attr_reader log_path: String
 
+    def self.build: (wait_result: untyped, stdout: String?, stderr: String?, log_path: String) -> ScenarioExecutionResult
     def initialize: (status: Symbol, stdout: String?, stderr: String?, log_path: String, ?exit_status: Integer?) -> void
     def survived?: () -> bool
     def killed?: () -> bool
@@ -121,6 +122,11 @@ module Henitai
     def tail: (?Integer) -> String
     def should_show_logs?: (?all_logs: bool) -> bool
     def failure_tail: (?all_logs: bool, ?lines: Integer) -> String
+
+    private
+
+    def self.status_for: (untyped) -> Symbol
+    def self.exit_status_for: (untyped) -> Integer?
   end
 
   class Subject
@@ -474,6 +480,7 @@ module Henitai
       def survived_mutant_header: (Mutant) -> String
       def original_line: (Mutant) -> String
       def mutated_line: (Mutant) -> String
+      def display_unparse: (untyped) -> String
       def score_line: (Result) -> String
       def format_row: (String, untyped) -> String
       def count_status: (Result, Symbol) -> Integer
@@ -606,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.3
+  version: 0.1.5
 platform: ruby
 authors:
 - Martin Otten
-autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-04-13 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
@@ -158,9 +157,8 @@ 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.2
+  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: []