henitai 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49d5bc19a4c6d8335797de16d71488d9ffdbb5b85c03b541da1f99a5ba39a009
-  data.tar.gz: bb6490909c3c87cbe815ed960b649e23d60850ee41bb019097f6a4772de777ab
+  metadata.gz: 458245aa72b025224bd6c95c2bcca98ea095dd86a41e93ab8f0671ba56644369
+  data.tar.gz: 94a822238b18f41803753a85adae77675f422d2a901cdd89723ea68b14a8842a
 SHA512:
-  metadata.gz: 10d2c66aa8f8ca9ecd64a482d4bc73880f1598e3174a9df220201874333eab2d846903560dec5270fed4291b401a58f7a41b0e28fcafd5918fbd631bfb77e70b
-  data.tar.gz: d2c3859f3c70d28032a7a18b859df7713d6e39ca265004c8be86fe0d15ec450aea2e0bf2a60b147e6d2098c6c1f436829bdef87e6ff68353782790c9419465d6
+  metadata.gz: ed70e5425023aa08cd3ecd4ff6cb20dbd6c78b14f1811caaf9b43034e7649cdfeed617398a4fbf200730c1f4e8a36ab1fdfbe727b27379f4ed3b4eeef53be781
+  data.tar.gz: 0f2b4a04643f9e1bcd3f188e06d851f34eafbbf65dcafd42b9698678cb0ee540fca70e31207003d81cb4713ee1ca2c78901780e5f474128e20331c150949052a

data/CHANGELOG.md

@@ -7,6 +7,48 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.0] - 2026-07-14
+
+### Added
+- `hard` operator set (`mutation.operators: hard` / `--operators hard`), a
+  strict superset of `full` for usually-unkillable mutations (ADR-12):
+  currently `EqualityIdentityOperator` and the new `HashKeyType`
+  (`{ a: 1 }` -> `{ "a" => 1 }`) — framework key normalization (e.g.
+  ActiveRecord `order`/`where`) makes key-type mutants frequently equivalent
+- `HashLiteral` gains per-pair removal (`{ a: 1, b: 2 }` -> `{ b: 2 }`);
+  single-pair hashes and double-splat entries are skipped
+
+### Changed
+- `full` now means "usually killable": the symbol-key -> string-key mutation
+  moved from `HashLiteral` into the new hard-set `HashKeyType`, and
+  `EqualityIdentityOperator` moved from `full` to `hard` — `full` runs emit
+  fewer, higher-signal mutants
+
+## [0.3.1] - 2026-07-13
+
+### Fixed
+- Per-mutant log capture no longer crashes with
+  `Encoding::UndefinedConversionError` when the host app sets
+  `Encoding.default_internal` (as Rails test environments do) and a child
+  process prints multibyte output: the capped log streams are opened in
+  binary mode, so pipe chunks are written byte-for-byte. Also keeps a
+  multibyte character split across drain chunks (or truncated at the cap)
+  from corrupting the file.
+
+### Changed
+- `--since REF` now includes the working tree: tracked files with
+  uncommitted changes and untracked files count as changed, matching what
+  actually gets tested. Previously only committed changes in `REF..HEAD`
+  were considered, so pre-commit runs silently selected nothing.
+- `--since REF` is test-aware: a changed test file selects the source files
+  it covers, using the per-test coverage map from the previous run
+  (`henitai_per_test.json`). Editing only a test now re-tests the subjects
+  that test can kill. First run without a map: no expansion.
+- An empty `--since` run now says why: the terminal summary appends
+  `No mutants: no configured source files changed since REF.` instead of
+  printing an unexplained all-zero table. `Result` gained a `since`
+  attribute to carry the scope.
+
 ## [0.3.0] - 2026-07-13
 
 ### Added
@@ -380,7 +422,9 @@ 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.3.0...HEAD
+[Unreleased]: https://github.com/martinotten/henitai/compare/v0.4.0...HEAD
+[0.4.0]: https://github.com/martinotten/henitai/compare/v0.3.1...v0.4.0
+[0.3.1]: https://github.com/martinotten/henitai/compare/v0.3.0...v0.3.1
 [0.3.0]: https://github.com/martinotten/henitai/compare/v0.2.1...v0.3.0
 [0.2.1]: https://github.com/martinotten/henitai/compare/v0.2.0...v0.2.1
 [0.2.0]: https://github.com/martinotten/henitai/compare/v0.1.10...v0.2.0

data/README.md

@@ -51,7 +51,8 @@ gem install henitai
 # Run mutation testing on the entire project
 bundle exec henitai run
 
-# Run only on subjects changed since main (CI-friendly)
+# Run only on subjects changed since main (CI-friendly). Includes uncommitted
+# working-tree changes; changed test files select the sources they cover.
 bundle exec henitai run --since origin/main
 
 # Run on a specific subject pattern
@@ -270,7 +271,17 @@ The repository ships a JSON Schema at [`assets/schema/henitai.schema.json`](/wor
 - `AssignmentExpression` — mutate compound assignment
 - `UnaryOperator` — remove unary `-` and `~`
 - `UpdateOperator` — swap compound assignments (`+=`↔`-=`, `*=`↔`/=`, `||=`↔`&&=`)
+
+**Hard** — adds usually-unkillable mutations on top of full, for hunting the
+last survivors (see [ADR-12](docs/architecture/adr/ADR-12-hard-operator-set.md)):
+
 - `EqualityIdentityOperator` — `==` ↔ `eql?`/`equal?` (hardest equality pairing to kill; see [ADR-10](docs/architecture/adr/ADR-10-split-equality-identity-mutations.md))
+- `HashKeyType` — `{ a: 1 }` → `{ "a" => 1 }` (frameworks that normalize key
+  types, e.g. ActiveRecord `order`/`where`, make these mutants equivalent at
+  many call sites; disable per site with `# henitai:disable HashKeyType`)
+
+`HashLiteral` (full set) empties the hash and removes one pair at a time
+(`{ a: 1, b: 2 }` → `{}` / `{ b: 2 }`).
 
 ## Stryker Dashboard integration
 

data/assets/schema/henitai.schema.json

@@ -44,7 +44,7 @@
       "additionalProperties": false,
       "properties": {
         "operators": {
-          "enum": ["light", "full"]
+          "enum": ["light", "full", "hard"]
         },
         "timeout": {
           "type": "number"

data/lib/henitai/cli/operator_command.rb

@@ -14,7 +14,8 @@ module Henitai
         "StringLiteral" => ["String literals", '"foo" -> ""'],
         "ReturnValue" => ["Return expressions", "return x -> return nil"],
         "ArrayDeclaration" => ["Array literals", "[1, 2] -> []"],
-        "HashLiteral" => ["Hash literals", "{ a: 1 } -> {}"],
+        "HashLiteral" => ["Hash literals", "{ a: 1, b: 2 } -> {} / { b: 2 }"],
+        "HashKeyType" => ["Hash key types", '{ a: 1 } -> { "a" => 1 }'],
         "RangeLiteral" => ["Range literals", "1..5 -> 1...5"],
         "SafeNavigation" => ["Safe navigation", "user&.name -> user.name"],
         "PatternMatch" => ["Pattern matching", "in { x: Integer } -> in { x: String }"],

data/lib/henitai/cli/run_options.rb

@@ -21,7 +21,7 @@ module Henitai
       end
 
       def add_operator_option(opts, options)
-        opts.on("--operators SET", "Operator set: light | full") do |set|
+        opts.on("--operators SET", "Operator set: light | full | hard") do |set|
           options[:operators] = set
         end
       end

data/lib/henitai/configuration_validator.rb

@@ -33,7 +33,7 @@ module Henitai
     VALID_THRESHOLDS_KEYS = %i[high low].freeze
     VALID_DASHBOARD_KEYS = %i[project base_url].freeze
     VALID_INTEGRATION_KEYS = %i[name].freeze
-    VALID_OPERATORS = %i[light full].freeze
+    VALID_OPERATORS = %i[light full hard].freeze
     VALIDATION_STEPS = %i[
       validate_top_level_keys
       validate_integration

data/lib/henitai/integration/scenario_log_support.rb

@@ -62,8 +62,11 @@ module Henitai
 
       # One capture channel: a pipe whose read end is drained (capped) into the
       # log file by a dedicated thread. Returns the pieces close needs.
+      # Binary mode: readpartial yields ASCII-8BIT chunks, and a text-mode file
+      # would transcode them (raising Encoding::UndefinedConversionError on
+      # multibyte output when Encoding.default_internal is set, as Rails does).
       def open_capped_stream(path, cap)
-        file = File.new(path, "w")
+        file = File.new(path, "wb")
         file.sync = true
         reader, writer = IO.pipe
         thread = Thread.new { drain_capped(reader, file, cap) }

data/lib/henitai/operator.rb

@@ -44,13 +44,23 @@ module Henitai
       AssignmentExpression
       UnaryOperator
       UpdateOperator
+    ]).freeze
+
+    # Usually-unkillable operators on top of full: mutations whose survival
+    # rarely indicates a test gap (framework key normalization, the
+    # ==/eql?/equal? pairing). Opt in when hunting the last survivors
+    # (ADR-12).
+    HARD_SET = (FULL_SET + %w[
       EqualityIdentityOperator
+      HashKeyType
     ]).freeze
 
-    # @param set [Symbol] :light or :full
+    SETS = { light: LIGHT_SET, full: FULL_SET, hard: HARD_SET }.freeze
+
+    # @param set [Symbol] :light, :full or :hard
     # @return [Array<Operator>] operator instances for the given set
     def self.for_set(set)
-      names = set.to_sym == :full ? FULL_SET : LIGHT_SET
+      names = SETS.fetch(set.to_sym, LIGHT_SET)
       names.map { |name| Henitai::Operators.const_get(name).new }
     end
 

data/lib/henitai/operators/hash_key_type.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Henitai
+  module Operators
+    # Mutates symbol hash keys into string keys, one pair at a time
+    # (`{ a: 1 }` -> `{ "a" => 1 }`). Symbol/string key confusion is a real
+    # defect class, but frameworks that normalize keys (e.g. ActiveRecord's
+    # `order`/`where`) make these mutants frequently unkillable — hence the
+    # hard set, not full (ADR-12).
+    class HashKeyType < Henitai::Operator
+      NODE_TYPES = [:hash].freeze
+
+      def self.node_types
+        NODE_TYPES
+      end
+
+      def mutate(node, subject:)
+        node.children.each_with_index.filter_map do |pair, index|
+          next unless symbol_key_pair?(pair)
+
+          build_mutant(
+            subject:,
+            original_node: node,
+            mutated_node: mutated_hash(node, index),
+            description: "replaced symbol key with string key"
+          )
+        end
+      end
+
+      private
+
+      def symbol_key_pair?(node)
+        node.type == :pair && node.children.first&.type == :sym
+      end
+
+      def mutated_hash(node, index)
+        pairs = node.children.each_with_index.map do |pair, pair_index|
+          pair_index == index ? stringified_pair(pair) : pair
+        end
+        Parser::AST::Node.new(:hash, pairs)
+      end
+
+      def stringified_pair(pair)
+        key, value = pair.children
+        string_key = Parser::AST::Node.new(:str, [key.children.first.to_s])
+        Parser::AST::Node.new(:pair, [string_key, value])
+      end
+    end
+  end
+end

data/lib/henitai/operators/hash_literal.rb

@@ -4,7 +4,10 @@ require_relative "../parser_current"
 
 module Henitai
   module Operators
-    # Reduces hash literals by emptying them or mutating symbol keys.
+    # Reduces hash literals: empties the whole hash and removes one pair at a
+    # time. Symbol-key -> string-key mutation lives in {HashKeyType} (hard
+    # set) because framework key normalization makes it frequently unkillable
+    # (ADR-12).
     class HashLiteral < Henitai::Operator
       NODE_TYPES = [:hash].freeze
 
@@ -16,7 +19,7 @@ module Henitai
         return [] if node.children.empty?
 
         mutants = [empty_hash_mutant(node, subject:)]
-        mutants.concat(symbol_key_mutants(node, subject:))
+        mutants.concat(pair_removal_mutants(node, subject:))
         mutants
       end
 
@@ -31,35 +34,31 @@ module Henitai
         )
       end
 
-      def symbol_key_mutants(node, subject:)
+      # Removing the only entry would duplicate the empty-hash mutant.
+      def pair_removal_mutants(node, subject:)
+        return [] if node.children.size < 2
+
         node.children.each_with_index.filter_map do |pair, index|
-          next unless symbol_key_pair?(pair)
+          next unless pair.type == :pair
 
           build_mutant(
             subject:,
             original_node: node,
-            mutated_node: mutated_hash(node, index),
-            description: "replaced symbol key with string key"
+            mutated_node: hash_without_pair(node, index),
+            description: "removed hash pair #{pair_key_label(pair)}"
           )
         end
       end
 
-      def symbol_key_pair?(node)
-        node.type == :pair && node.children.first&.type == :sym
-      end
-
-      def mutated_hash(node, pair_index)
-        mutated_pairs = node.children.each_with_index.map do |pair, index|
-          index == pair_index ? mutated_pair(pair) : pair
-        end
-
-        Parser::AST::Node.new(:hash, mutated_pairs)
+      def hash_without_pair(node, pair_index)
+        remaining = node.children.reject.with_index { |_pair, index| index == pair_index }
+        Parser::AST::Node.new(:hash, remaining)
       end
 
-      def mutated_pair(pair)
-        key, value = pair.children
-        mutated_key = Parser::AST::Node.new(:str, [key.children.first.to_s])
-        Parser::AST::Node.new(:pair, [mutated_key, value])
+      # Pair keys are always AST nodes (sym/str/…); their first child is the
+      # literal value used purely as a human-readable label.
+      def pair_key_label(pair)
+        pair.children.first.children.first
       end
     end
   end

data/lib/henitai/operators.rb

@@ -16,6 +16,7 @@ module Henitai
     autoload :ReturnValue, "henitai/operators/return_value"
     autoload :ArrayDeclaration, "henitai/operators/array_declaration"
     autoload :HashLiteral, "henitai/operators/hash_literal"
+    autoload :HashKeyType, "henitai/operators/hash_key_type"
     autoload :RangeLiteral, "henitai/operators/range_literal"
     autoload :SafeNavigation, "henitai/operators/safe_navigation"
     autoload :PatternMatch, "henitai/operators/pattern_match"

data/lib/henitai/per_test_coverage.rb

@@ -28,6 +28,21 @@ module Henitai
       map.keys.select { |test| covers?(test, mutant) }.sort
     end
 
+    # The source files the given test file's recorded coverage reaches.
+    # Test keys are matched path-insensitively (relative or absolute form);
+    # returned source paths are absolute, as recorded.
+    #
+    # @return [Array<String>] sorted; empty when the test is unknown or the
+    #   map is unavailable.
+    def source_files_covered_by(test_file)
+      wanted = File.expand_path(test_file.to_s)
+      map.select { |test, _| File.expand_path(test) == wanted }
+         .values
+         .flat_map(&:keys)
+         .uniq
+         .sort
+    end
+
     # True when the given test file's recorded coverage intersects the
     # mutant's current line range.
     def covers?(test, mutant)

data/lib/henitai/reporter.rb

@@ -137,10 +137,20 @@ module Henitai
           format_row("No coverage", count_status(result, :no_coverage)),
           format_row("Duration", format_duration(result.duration)),
           reused_verdicts_line(result),
-          executed_only_score_line(result)
+          executed_only_score_line(result),
+          empty_since_scope_line(result)
         ].compact
       end
 
+      # A zero-mutant summary with every counter at 0 and n/a scores is
+      # baffling without its cause; name it when the run was scoped by --since.
+      def empty_since_scope_line(result)
+        return nil unless result.mutants.empty?
+        return nil unless result.respond_to?(:since) && result.since
+
+        "No mutants: no configured source files changed since #{result.since}."
+      end
+
       def reused_verdicts_line(result)
         reused = reused_mutants(result)
         return nil if reused.empty?

data/lib/henitai/result.rb

@@ -16,7 +16,7 @@ module Henitai
     DEFAULT_THRESHOLDS = { high: 80, low: 60 }.freeze
 
     attr_reader :mutants, :started_at, :finished_at, :thresholds, :survivor_stats,
-                :session_id, :git_sha
+                :session_id, :git_sha, :since
 
     # @param source_provider [#call] maps a file path to its source string.
     #   Injected so the domain object performs no disk IO; the caller (which
@@ -32,7 +32,8 @@ module Henitai
     def initialize(mutants:, started_at:, finished_at:, thresholds: nil,
                    partial_rerun: false, survivor_stats: nil,
                    session_id: SecureRandom.uuid, git_sha: nil,
-                   source_provider: ->(_file) { "" }, authoritative: true)
+                   source_provider: ->(_file) { "" }, authoritative: true,
+                   since: nil)
       @mutants         = mutants
       @started_at      = started_at
       @finished_at     = finished_at
@@ -43,6 +44,7 @@ module Henitai
       @git_sha         = git_sha
       @source_provider = source_provider
       @authoritative   = authoritative
+      @since           = since
     end
     # rubocop:enable Metrics/ParameterLists
 

data/lib/henitai/runner.rb

@@ -168,7 +168,8 @@ module Henitai
         survivor_stats: survivor_strategy.survivor_stats,
         git_sha: safe_head_sha,
         source_provider: source_provider,
-        authoritative: full_run?
+        authoritative: full_run?,
+        since: @since
       )
     end
 
@@ -267,12 +268,28 @@ module Henitai
     def filter_changed(files)
       return files unless @since
 
-      changed_file_set = git_diff_analyzer
-                         .changed_files(from: @since, to: "HEAD")
-                         .map { |path| normalize_path(path) }
+      changed_file_set = changed_paths_since.map { |path| normalize_path(path) }
+      changed_file_set += covered_sources_for_changed_tests(changed_file_set)
       files.select { |path| changed_file_set.include?(normalize_path(path)) }
     end
 
+    # Committed changes since the ref plus the current working tree (tracked
+    # dirty and untracked files): the working tree is what gets tested, so it
+    # is always part of "changed since REF".
+    def changed_paths_since
+      git_diff_analyzer.changed_files(from: @since, to: "HEAD") +
+        git_diff_analyzer.working_tree_changed_files
+    end
+
+    # Changed test files select the source files they cover, so an edited
+    # test re-tests the subjects it can kill. Uses the per-test map from the
+    # previous run — Gate 1 runs before this run's bootstrap finishes.
+    def covered_sources_for_changed_tests(changed_paths)
+      changed_paths
+        .flat_map { |path| per_test_coverage.source_files_covered_by(path) }
+        .map { |path| normalize_path(path) }
+    end
+
     def pattern_subjects
       Array(@subjects)
     end

data/lib/henitai/version.rb

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

data/sig/henitai.rbs

@@ -353,6 +353,8 @@ module Henitai
   class Operator
     LIGHT_SET: Array[String]
     FULL_SET: Array[String]
+    HARD_SET: Array[String]
+    SETS: Hash[Symbol, Array[String]]
 
     def self.for_set: (Symbol) -> Array[untyped]
     def self.node_types: () -> Array[Symbol]
@@ -718,6 +720,7 @@ module Henitai
     def initialize: (reports_dir: String, ?coverage_report_reader: CoverageReportReader) -> void
     def available?: () -> bool
     def tests_covering: (untyped) -> Array[String]
+    def source_files_covered_by: (untyped) -> Array[String]
     def covers?: (String, untyped) -> bool
 
     private
@@ -852,6 +855,7 @@ module Henitai
       def reused_verdicts_line: (Result) -> String?
       def reused_mutants: (Result) -> Array[Mutant]
       def executed_only_score_line: (Result) -> String?
+      def empty_since_scope_line: (Result) -> String?
       def count_status: (Result, Symbol) -> Integer
       def format_duration: (Float) -> String
       def format_percent: (Float?) -> String
@@ -977,8 +981,9 @@ module Henitai
     attr_reader survivor_stats: Hash[Symbol, untyped]?
     attr_reader session_id: String
     attr_reader git_sha: String?
+    attr_reader since: String?
 
-    def initialize: (mutants: Array[Mutant], started_at: Time, finished_at: Time, ?thresholds: Hash[Symbol, Integer]?, ?partial_rerun: bool, ?survivor_stats: Hash[Symbol, untyped]?, ?session_id: String, ?git_sha: String?, ?source_provider: ^(String) -> String, ?authoritative: bool) -> void
+    def initialize: (mutants: Array[Mutant], started_at: Time, finished_at: Time, ?thresholds: Hash[Symbol, Integer]?, ?partial_rerun: bool, ?survivor_stats: Hash[Symbol, untyped]?, ?session_id: String, ?git_sha: String?, ?source_provider: ^(String) -> String, ?authoritative: bool, ?since: String?) -> void
     def partial_rerun?: () -> bool
     def authoritative?: () -> bool
     def killed: () -> Integer
@@ -1086,6 +1091,8 @@ module Henitai
     def reject_excluded: (Array[String]) -> Array[String]
     def excluded_source_files: () -> Array[String]
     def filter_changed: (Array[String]) -> Array[String]
+    def changed_paths_since: () -> Array[String]
+    def covered_sources_for_changed_tests: (Array[String]) -> Array[String]
     def pattern_subjects: () -> Array[Subject]
     def unique_subjects: (Array[Subject]) -> Array[Subject]
     def normalize_path: (String) -> String

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: henitai
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Martin Otten
@@ -166,6 +166,7 @@ files:
 - lib/henitai/operators/conditional_expression.rb
 - lib/henitai/operators/equality_identity_operator.rb
 - lib/henitai/operators/equality_operator.rb
+- lib/henitai/operators/hash_key_type.rb
 - lib/henitai/operators/hash_literal.rb
 - lib/henitai/operators/logical_operator.rb
 - lib/henitai/operators/method_chain_unwrap.rb
@@ -223,7 +224,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.3.0
+  source_code_uri: https://github.com/martinotten/henitai/tree/v0.4.0
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: