henitai 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 425e1946a343ce94a9172939a8ad5c5d49e01fe86fbf2b01326b2f0be068df85
-  data.tar.gz: 85867b98b26cb3710d0c1e56bd4b37b5ba78f08f47ad8378dc76ae07ce1dfc9a
+  metadata.gz: 458245aa72b025224bd6c95c2bcca98ea095dd86a41e93ab8f0671ba56644369
+  data.tar.gz: 94a822238b18f41803753a85adae77675f422d2a901cdd89723ea68b14a8842a
 SHA512:
-  metadata.gz: f0de6ea6a0a5a830a917f1097ac243ce43c6b8bf3bcc44ac1967133288770746d9c4df8fdee6609081613bfa174be5169e13143a22f1d3d22e8f74fd0cc008d7
-  data.tar.gz: 37eedd8f351dbd8a9094c668ce7c56560186936f0953b098f740b6cee1654971d1b5402efe2fd0d5650442b701af7fedaea257ec9f7827575f3f04c052c2593a
+  metadata.gz: ed70e5425023aa08cd3ecd4ff6cb20dbd6c78b14f1811caaf9b43034e7649cdfeed617398a4fbf200730c1f4e8a36ab1fdfbe727b27379f4ed3b4eeef53be781
+  data.tar.gz: 0f2b4a04643f9e1bcd3f188e06d851f34eafbbf65dcafd42b9698678cb0ee540fca70e31207003d81cb4713ee1ca2c78901780e5f474128e20331c150949052a

data/CHANGELOG.md

@@ -7,6 +7,23 @@ 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
@@ -405,7 +422,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.3.1...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

data/README.md

@@ -271,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/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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Henitai
-  VERSION = "0.3.1"
+  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]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: henitai
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  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.1
+  source_code_uri: https://github.com/martinotten/henitai/tree/v0.4.0
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: