henitai 0.1.2 → 0.1.4

data/lib/henitai/mutant_generator.rb

@@ -34,7 +34,8 @@ module Henitai
     end
 
     def generate_for_subject(subject, operators, config:, arid_node_filter:, syntax_validator:)
-      return [] unless subject.source_file && subject.source_range
+      source_node = source_node_for(subject)
+      return [] unless source_node
 
       visitor = SubjectVisitor.new(
         subject,
@@ -43,11 +44,8 @@ module Henitai
         arid_node_filter:,
         syntax_validator:
       )
-      visitor.process(SourceParser.parse_file(subject.source_file))
-      prune_mutants_per_line(
-        visitor.mutants,
-        max_mutants_per_line: config&.max_mutants_per_line || 1
-      )
+      visitor.process(source_node)
+      visitor.mutants
     end
 
     # Depth-first pre-order AST visitor for a single subject.
@@ -60,13 +58,8 @@ module Henitai
         @mutants = []
         @arid_node_filter = arid_node_filter
         @syntax_validator = syntax_validator
-        @operators_by_node_type = operators.each_with_object(
-          Hash.new { |hash, key| hash[key] = [] }
-        ) do |operator, map|
-          operator.class.node_types.each do |node_type|
-            map[node_type] << operator
-          end
-        end
+        initialize_subject_range(subject)
+        @operators_by_node_type = index_operators(operators)
       end
 
       def process(node)
@@ -95,27 +88,28 @@ module Henitai
       end
 
       def node_within_subject_range?(node)
+        return true unless @subject_range_begin
+
         location = node.location&.expression
-        return true unless location && @subject.source_range
+        return true unless location
 
-        node_range = location.line..location.last_line
-        ranges_overlap?(node_range, @subject.source_range)
+        location.line <= @subject_range_end && @subject_range_begin <= location.last_line
       end
 
-      def ranges_overlap?(left, right)
-        left.begin <= right.end && right.begin <= left.end
-      end
-    end
+      def initialize_subject_range(subject)
+        subject_range = subject.source_range
+        return unless subject_range
 
-    def prune_mutants_per_line(mutants, max_mutants_per_line:)
-      grouped = mutants.each_with_object({}) do |mutant, selected|
-        key = line_key(mutant)
-        selected[key] ||= []
-        selected[key] << mutant
+        @subject_range_begin = subject_range.begin
+        @subject_range_end = subject_range.end
       end
 
-      grouped.values.flat_map do |mutants_for_line|
-        mutants_for_line.sort_by { |mutant| mutant_priority_key(mutant) }.take(max_mutants_per_line)
+      def index_operators(operators)
+        operators.each_with_object(Hash.new { |hash, key| hash[key] = [] }) do |operator, map|
+          operator.class.node_types.each do |node_type|
+            map[node_type] << operator
+          end
+        end
       end
     end
 
@@ -131,28 +125,11 @@ module Henitai
       )
     end
 
-    def line_key(mutant)
-      [
-        mutant.location[:file],
-        mutant.location[:start_line]
-      ]
-    end
-
-    def mutant_priority_key(mutant)
-      [
-        operator_priority(mutant.operator),
-        mutant.location[:start_col] || 0,
-        mutant.description
-      ]
-    end
-
-    def operator_priority(operator_name)
-      operator_priority_map.fetch(operator_name, operator_priority_map.length)
-    end
+    def source_node_for(subject)
+      return subject.ast_node if subject.ast_node
+      return nil unless subject.source_file && subject.source_range
 
-    def operator_priority_map
-      # The constant order defines signal priority for per-line pruning.
-      @operator_priority_map ||= Operator::FULL_SET.each_with_index.to_h
+      SourceParser.new.parse_file(subject.source_file)
     end
   end
 end

data/lib/henitai/operator.rb

@@ -13,7 +13,8 @@ module Henitai
   #
   # Additional operators (full set):
   #   ArrayDeclaration, HashLiteral, RangeLiteral, SafeNavigation,
-  #   PatternMatch, BlockStatement, MethodExpression, AssignmentExpression
+  #   PatternMatch, BlockStatement, MethodExpression, AssignmentExpression,
+  #   UnaryOperator, UpdateOperator, RegexMutator, MethodChainUnwrap
   #
   # Each operator subclass must implement:
   #   - .node_types  → Array<Symbol>  AST node types this operator handles
@@ -32,12 +33,16 @@ module Henitai
     FULL_SET = (LIGHT_SET + %w[
       ArrayDeclaration
       HashLiteral
+      MethodChainUnwrap
       RangeLiteral
+      RegexMutator
       SafeNavigation
       PatternMatch
       BlockStatement
       MethodExpression
       AssignmentExpression
+      UnaryOperator
+      UpdateOperator
     ]).freeze
 
     # @param set [Symbol] :light or :full

data/lib/henitai/operators/assignment_expression.rb

@@ -4,13 +4,14 @@ require_relative "../parser_current"
 
 module Henitai
   module Operators
-    # Mutates compound assignments and reduces ||= to a plain assignment.
+    # Reduces ||= to a plain assignment, removing the memoization guard.
+    #
+    # Arithmetic compound assignments (+=, -=, *=, /=) are covered by
+    # UpdateOperator, which also handles the logical pair swap (||= ↔ &&=).
+    # AssignmentExpression is intentionally scoped to or_asgn reduction only
+    # to avoid emitting duplicate mutants in the full operator set.
     class AssignmentExpression < Henitai::Operator
-      NODE_TYPES = %i[op_asgn or_asgn].freeze
-      OPERATOR_MAP = {
-        :+ => :-,
-        :- => :+
-      }.freeze
+      NODE_TYPES = %i[or_asgn].freeze
 
       def self.node_types
         NODE_TYPES
@@ -18,8 +19,6 @@ module Henitai
 
       def mutate(node, subject:)
         case node.type
-        when :op_asgn
-          mutate_compound_assignment(node, subject:)
         when :or_asgn
           # Memoization-style ||= is usually filtered earlier by AridNodeFilter.
           mutate_coalesce_assignment(node, subject:)
@@ -30,21 +29,6 @@ module Henitai
 
       private
 
-      def mutate_compound_assignment(node, subject:)
-        left, operator, right = node.children
-        replacement = OPERATOR_MAP[operator]
-        return [] unless replacement
-
-        [
-          build_mutant(
-            subject:,
-            original_node: node,
-            mutated_node: Parser::AST::Node.new(:op_asgn, [left, replacement, right]),
-            description: "replaced #{operator} with #{replacement}"
-          )
-        ]
-      end
-
       def mutate_coalesce_assignment(node, subject:)
         left, right = node.children
         mutated_node = assignment_node(left, right)

data/lib/henitai/operators/conditional_expression.rb

@@ -74,13 +74,7 @@ module Henitai
       end
 
       def case_children(children)
-        return [[], nil] if children.empty?
-
-        if children.last&.type == :when
-          [children, nil]
-        else
-          [children[0...-1], children.last]
-        end
+        [children[0...-1], children.last]
       end
 
       def condition_variants(node, subject:, condition:)

data/lib/henitai/operators/method_chain_unwrap.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../parser_current"
+
+module Henitai
+  module Operators
+    # Removes individual links from a method chain by replacing the outer
+    # send node with its receiver.
+    #
+    # Only fires when the immediate receiver is itself a :send node, which
+    # naturally excludes block-receiver chains (list.select { }.count) and
+    # standalone calls.
+    #
+    # Example: array.uniq.sort.first
+    #   → array.uniq.sort  (removed .first)
+    #   → array.uniq       (removed .sort)
+    #   → array            (removed .uniq) — via the :uniq node
+    class MethodChainUnwrap < Henitai::Operator
+      NODE_TYPES = %i[send].freeze
+
+      def self.node_types
+        NODE_TYPES
+      end
+
+      def mutate(node, subject:)
+        receiver = node.children[0]
+        return [] unless receiver.is_a?(Parser::AST::Node) && receiver.type == :send
+
+        method_name = node.children[1]
+        [
+          build_mutant(
+            subject:,
+            original_node: node,
+            mutated_node: receiver,
+            description: "removed .#{method_name} from chain"
+          )
+        ]
+      end
+    end
+  end
+end

data/lib/henitai/operators/regex_mutator.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative "../parser_current"
+
+module Henitai
+  module Operators
+    # Mutates regular expression literals by altering quantifiers, anchors,
+    # and character-class negation.
+    #
+    # Each applicable transformation yields a separate mutant. Invalid
+    # results (unparseable regex) are discarded before emission.
+    # Anchor removal and character-class negation are intentionally one-way:
+    # they reduce noisy patterns rather than mirroring a full edit matrix.
+    class RegexMutator < Henitai::Operator
+      NODE_TYPES = %i[regexp].freeze
+
+      def self.node_types
+        NODE_TYPES
+      end
+
+      def mutate(node, subject:)
+        source, opts_node = extract_parts(node)
+        return [] unless source
+
+        transformations(source).filter_map do |new_source, description|
+          build_regex_mutant(node, opts_node, new_source, source, description, subject:)
+        end
+      end
+
+      private
+
+      def extract_parts(node)
+        str_child  = node.children.find { |c| c.is_a?(Parser::AST::Node) && c.type == :str }
+        opts_node  = node.children.find { |c| c.is_a?(Parser::AST::Node) && c.type == :regopt }
+        return nil unless str_child
+
+        [str_child.children[0], opts_node]
+      end
+
+      def build_regex_mutant(node, opts_node, new_source, original, description, subject:) # rubocop:disable Metrics/ParameterLists
+        return if new_source == original
+        return unless valid_regex?(new_source)
+
+        children = [Parser::AST::Node.new(:str, [new_source]), opts_node]
+        mutated = Parser::AST::Node.new(:regexp, children)
+        build_mutant(subject:, original_node: node, mutated_node: mutated, description:)
+      end
+
+      def transformations(source)
+        [
+          *quantifier_swaps(source),
+          *anchor_removals(source),
+          *char_class_negations(source)
+        ]
+      end
+
+      def quantifier_swaps(source)
+        # Quantifier swaps are symmetric. The other transforms are intentionally
+        # one-way because they model reductions instead of reversible edits.
+        [
+          [source.gsub(/(?<=[^*+?\\])\+/, "*"), "replaced + quantifier with *"],
+          [source.gsub(/(?<=[^*+?\\])\*/, "+"), "replaced * quantifier with +"]
+        ]
+      end
+
+      def anchor_removals(source)
+        # Anchors are removed, not added back. The mutation is deliberately
+        # asymmetric because "restoring" anchors would just recreate the input.
+        [
+          [source.sub("^", ""), "removed ^ anchor"],
+          [source.sub(/\$$/, ""), "removed $ anchor"]
+        ]
+      end
+
+      def char_class_negations(source)
+        # Negation only flips a positive class into a negated one. We do not
+        # emit the reverse mutation because that would mirror the same edit.
+        [[source.gsub(/\[(?!\^)/, "[^"), "negated character class"]]
+      end
+
+      def valid_regex?(source)
+        Regexp.new(source)
+        true
+      rescue RegexpError
+        false
+      end
+    end
+  end
+end

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/operators/unary_operator.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "../parser_current"
+
+module Henitai
+  module Operators
+    # Removes unary prefix operators by replacing the send node with its receiver.
+    #
+    # Covers :-@ (unary minus) and :~ (bitwise NOT).
+    # Unary negation (!) is intentionally excluded — BooleanLiteral owns that.
+    class UnaryOperator < Henitai::Operator
+      NODE_TYPES = %i[send].freeze
+      UNARY_METHODS = %i[-@ ~].freeze
+
+      def self.node_types
+        NODE_TYPES
+      end
+
+      def mutate(node, subject:)
+        receiver, method_name, *arguments = node.children
+        return [] unless UNARY_METHODS.include?(method_name)
+        return [] unless arguments.empty?
+        return [] unless receiver
+
+        [
+          build_mutant(
+            subject:,
+            original_node: node,
+            mutated_node: receiver,
+            description: "removed unary #{method_name.to_s.delete('@')}"
+          )
+        ]
+      end
+    end
+  end
+end

data/lib/henitai/operators/update_operator.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "../parser_current"
+
+module Henitai
+  module Operators
+    # Swaps compound assignment operators with their inverses.
+    #
+    # Covers arithmetic pairs (+=/-=, *=/=) via :op_asgn and
+    # logical pairs (||=/&&=) via :or_asgn/:and_asgn. Exponent and modulo
+    # compound assignments are intentionally excluded: they are not part of the
+    # supported swap matrix and are already covered by other operator families
+    # when appropriate.
+    class UpdateOperator < Henitai::Operator
+      NODE_TYPES = %i[op_asgn or_asgn and_asgn].freeze
+      ARITHMETIC_SWAPS = {
+        :+ => :-,
+        :- => :+,
+        :* => :/,
+        :/ => :*
+      }.freeze
+
+      def self.node_types
+        NODE_TYPES
+      end
+
+      def mutate(node, subject:)
+        case node.type
+        when :op_asgn
+          mutate_arithmetic(node, subject:)
+        when :or_asgn
+          mutate_logical(node, subject:, from: "||=", to: :and_asgn, to_op: "&&=")
+        when :and_asgn
+          mutate_logical(node, subject:, from: "&&=", to: :or_asgn, to_op: "||=")
+        else
+          []
+        end
+      end
+
+      private
+
+      def mutate_arithmetic(node, subject:)
+        target, operator, value = node.children
+        replacement = ARITHMETIC_SWAPS[operator]
+        return [] unless replacement
+
+        [
+          build_mutant(
+            subject:,
+            original_node: node,
+            mutated_node: Parser::AST::Node.new(:op_asgn, [target, replacement, value]),
+            description: "replaced #{operator}= with #{replacement}="
+          )
+        ]
+      end
+
+      def mutate_logical(node, subject:, from:, to:, to_op:)
+        target, value = node.children
+        [
+          build_mutant(
+            subject:,
+            original_node: node,
+            mutated_node: Parser::AST::Node.new(to, [target, value]),
+            description: "replaced #{from} with #{to_op}"
+          )
+        ]
+      end
+    end
+  end
+end

data/lib/henitai/operators.rb

@@ -21,5 +21,9 @@ module Henitai
     autoload :BlockStatement, "henitai/operators/block_statement"
     autoload :MethodExpression, "henitai/operators/method_expression"
     autoload :AssignmentExpression, "henitai/operators/assignment_expression"
+    autoload :MethodChainUnwrap,    "henitai/operators/method_chain_unwrap"
+    autoload :RegexMutator,         "henitai/operators/regex_mutator"
+    autoload :UnaryOperator,        "henitai/operators/unary_operator"
+    autoload :UpdateOperator,       "henitai/operators/update_operator"
   end
 end

data/lib/henitai/parallel_execution_runner.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Runs pending mutants across worker threads with signal and stdin handling.
+  class ParallelExecutionRunner
+    ParallelExecutionContext = Struct.new(
+      :queue, :integration, :config, :progress_reporter,
+      :mutex, :state, :old_handlers, :stdin_watcher
+    )
+
+    def initialize(worker_count:)
+      @worker_count = worker_count
+    end
+
+    def run(mutants, integration, config, progress_reporter, options = {})
+      context = build_parallel_context(
+        mutants,
+        integration,
+        config,
+        progress_reporter
+      )
+      execute_parallel_execution(
+        context,
+        stdin_pipe: options.fetch(:stdin_pipe, false),
+        process_mutant: options.fetch(:process_mutant)
+      )
+    end
+
+    def execute_parallel_execution(context, stdin_pipe:, process_mutant:)
+      install_parallel_signal_traps(context)
+      start_parallel_stdin_watcher(context, stdin_pipe)
+      parallel_workers(context, process_mutant).each(&:join)
+    ensure
+      stop_parallel_stdin_watcher(context)
+      restore_parallel_signal_traps(context)
+      raise context.state[:error] if context&.state&.fetch(:error, nil)
+      raise Interrupt if context&.state&.fetch(:stopping, false)
+    end
+
+    private
+
+    attr_reader :worker_count
+
+    def build_parallel_queue(mutants)
+      Queue.new.tap { |queue| mutants.each { |mutant| queue << mutant } }
+    end
+
+    def build_parallel_context(mutants, integration, config, progress_reporter)
+      ParallelExecutionContext.new(
+        build_parallel_queue(mutants),
+        integration,
+        config,
+        progress_reporter,
+        Mutex.new,
+        { stopping: false }
+      )
+    end
+
+    def install_parallel_signal_traps(context)
+      context.old_handlers = {
+        int: trap(:INT) { stop_parallel_execution(context) },
+        term: trap(:TERM) { stop_parallel_execution(context) },
+        hup: trap(:HUP) { stop_parallel_execution(context) }
+      }
+    end
+
+    def stop_parallel_execution(context)
+      context.state[:stopping] = true
+      context.queue.clear
+    end
+
+    def start_parallel_stdin_watcher(context, stdin_pipe)
+      return unless stdin_pipe
+      # CI runners expose stdin as a non-interactive pipe, so EOF there should
+      # not be treated as a user disconnect.
+      return if ci_environment?
+
+      context.stdin_watcher = Thread.new do
+        $stdin.read
+        stop_parallel_execution(context)
+      rescue IOError, Errno::EBADF
+        nil
+      end
+    end
+
+    def parallel_workers(context, process_mutant)
+      Array.new(worker_count) { Thread.new { process_parallel_worker(context, process_mutant) } }
+    end
+
+    def process_parallel_worker(context, process_mutant)
+      loop do
+        break if context.state[:stopping]
+
+        process_mutant.call(
+          context.queue.pop(true),
+          context.integration,
+          context.config,
+          context.progress_reporter,
+          context.mutex
+        )
+      rescue ThreadError
+        break
+      rescue StandardError => e
+        record_parallel_error(context, e)
+        break
+      end
+    end
+
+    def stop_parallel_stdin_watcher(context)
+      context&.stdin_watcher&.kill
+    end
+
+    def restore_parallel_signal_traps(context)
+      handlers = context&.old_handlers
+      return unless handlers
+
+      trap(:INT, handlers[:int] || "DEFAULT")
+      trap(:TERM, handlers[:term] || "DEFAULT")
+      trap(:HUP, handlers[:hup] || "DEFAULT")
+    end
+
+    def record_parallel_error(context, error)
+      context.mutex.synchronize do
+        context.state[:error] ||= error
+        context.state[:stopping] = true
+        context.queue.clear
+      end
+    end
+
+    def ci_environment?
+      value = ENV.fetch("CI", nil)
+      value && !%w[0 false].include?(value.downcase)
+    end
+  end
+end

data/lib/henitai/per_test_coverage_selector.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Narrows candidate test files using the per-test coverage report.
+  class PerTestCoverageSelector
+    def initialize(coverage_report_reader: CoverageReportReader.new)
+      @coverage_report_reader = coverage_report_reader
+    end
+
+    def filter(tests, mutant, reports_dir:)
+      candidates = Array(tests)
+      return candidates if candidates.empty?
+      return candidates unless location_available?(mutant)
+      return candidates unless per_test_coverage_available?(reports_dir)
+
+      covered_tests = candidates.select do |test|
+        covers_mutant?(test, mutant, reports_dir)
+      end
+      covered_tests.empty? ? candidates : covered_tests
+    end
+
+    private
+
+    def location_available?(mutant)
+      mutant.respond_to?(:location) &&
+        mutant.location.is_a?(Hash) &&
+        mutant.location[:file] &&
+        mutant.location[:start_line] &&
+        mutant.location[:end_line]
+    end
+
+    def covers_mutant?(test, mutant, reports_dir)
+      covered_lines = coverage_lines_for(test, mutant, reports_dir)
+      mutant_lines(mutant).any? { |line| covered_lines.include?(line) }
+    end
+
+    def coverage_lines_for(test, mutant, reports_dir)
+      source_map = per_test_coverage(reports_dir)[test.to_s] || {}
+      Array(source_map[File.expand_path(mutant.location[:file])]).uniq
+    end
+
+    def mutant_lines(mutant)
+      (mutant.location[:start_line]..mutant.location[:end_line]).to_a
+    end
+
+    def per_test_coverage(reports_dir)
+      @per_test_coverage ||= {}
+      @per_test_coverage[reports_dir] ||= begin
+        path = File.join(reports_dir, "henitai_per_test.json")
+        coverage_report_reader.test_lines_by_file(path)
+      end
+    end
+
+    def per_test_coverage_available?(reports_dir)
+      !per_test_coverage(reports_dir).empty?
+    end
+
+    attr_reader :coverage_report_reader
+  end
+end

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)