henitai 0.1.1 → 0.1.3

data/lib/henitai/mutant/activator.rb

@@ -7,6 +7,22 @@ module Henitai
   class Mutant
     # Activates a mutant inside the forked child process.
     class Activator
+      # Filters "already initialized constant" C-level warnings that fire when
+      # a source file is loaded into a process that already has the constant
+      # defined via require. Uses a thread-local flag so the filter is active
+      # only during load_source_file, leaving all other warnings untouched.
+      module ConstantRedefinitionFilter
+        PATTERN = /already initialized constant|previous definition of/
+        private_constant :PATTERN
+
+        def warn(msg, **kwargs)
+          return if Thread.current[:henitai_filter_const_warnings] && PATTERN.match?(msg.to_s)
+
+          super
+        end
+      end
+      Warning.singleton_class.prepend(ConstantRedefinitionFilter)
+
       SERIALIZER_METHODS = {
         arg: :argument_parameter_fragment,
         optarg: :optional_parameter_fragment,
@@ -26,8 +42,9 @@ module Henitai
         subject = mutant.subject
         raise ArgumentError, "Cannot activate wildcard subjects" if subject.method_name.nil?
 
+        target = target_for(subject)
         Henitai::WarningSilencer.silence do
-          target_for(subject).class_eval(method_source(mutant), __FILE__, __LINE__ + 1)
+          target.class_eval(method_source(mutant), __FILE__, __LINE__ + 1)
           nil
         end
       rescue Unparser::UnsupportedNodeError
@@ -57,44 +74,28 @@ module Henitai
         subject_node = mutant.subject.ast_node
         return compile_safe_unparse(mutant.mutated_node) unless subject_node
 
-        mutated_subject = replace_node(
-          subject_node,
-          mutant.original_node,
-          mutant.mutated_node
-        )
-        body = method_body(mutated_subject) || Parser::AST::Node.new(:nil, [])
-        compile_safe_unparse(body)
-      end
-
-      def replace_node(node, original_node, mutated_node)
-        return mutated_node if same_node?(node, original_node)
-        return node unless node.is_a?(Parser::AST::Node)
+        body = method_body(subject_node)
+        return compile_safe_unparse(Parser::AST::Node.new(:nil, [])) unless body
 
-        updated_children = node.children.map do |child|
-          replace_child(child, original_node, mutated_node)
-        end
-
-        return node if updated_children == node.children
-
-        Parser::AST::Node.new(node.type, updated_children)
+        body_source_for_mutant(body, mutant)
       end
 
-      def same_node?(left, right)
-        left_location = node_location_signature(left)
-        right_location = node_location_signature(right)
-        return left.equal?(right) unless left_location && right_location
+      def body_source_for_mutant(body, mutant)
+        original_range = mutant.original_node.location&.expression
+        location = body.location
+        return source_body(location, body) unless original_range && location
 
-        left_location == right_location
+        replacement = compile_safe_unparse(mutant.mutated_node)
+        body_source_for_location(location, original_range, replacement, body)
       end
 
-      def replace_child(child, original_node, mutated_node)
-        case child
-        when Parser::AST::Node
-          replace_node(child, original_node, mutated_node)
-        when Array
-          child.map { |item| replace_child(item, original_node, mutated_node) }
+      def body_source_for_location(location, original_range, replacement, body)
+        if heredoc_location?(location)
+          heredoc_body_source(location, original_range, replacement) ||
+            source_body(location, body)
         else
-          child
+          expression_source(location, original_range, replacement) ||
+            source_body(location, body)
         end
       end
 
@@ -184,6 +185,38 @@ module Henitai
         subject_node.children[1]
       end
 
+      def heredoc_location?(location)
+        location.respond_to?(:heredoc_body) && location.heredoc_body
+      end
+
+      def heredoc_body_source(location, original_range, replacement)
+        body_source = replace_source_fragment(
+          location.heredoc_body,
+          original_range,
+          replacement
+        )
+        return unless body_source
+
+        "#{location.expression.source}\n#{body_source}#{location.heredoc_end.source}"
+      end
+
+      def source_body(location, body)
+        return compile_safe_unparse(body) unless location
+
+        if heredoc_location?(location)
+          "#{location.expression.source}\n#{location.heredoc_body.source}#{location.heredoc_end.source}"
+        else
+          location.expression.source
+        end
+      end
+
+      def expression_source(location, original_range, replacement)
+        source_range = location.expression
+        return unless source_range
+
+        replace_source_fragment(source_range, original_range, replacement)
+      end
+
       def load_target(subject)
         Object.const_get(subject.namespace.delete_prefix("::"))
       rescue NameError
@@ -195,7 +228,10 @@ module Henitai
         source_file = subject.source_file || source_file_from_ast(subject)
         return unless source_file && File.file?(source_file)
 
+        Thread.current[:henitai_filter_const_warnings] = true
         load(source_file)
+      ensure
+        Thread.current[:henitai_filter_const_warnings] = false
       end
 
       def source_file_from_ast(subject)
@@ -211,17 +247,17 @@ module Henitai
         expression.source_buffer.name
       end
 
-      def node_location_signature(node)
-        expression = node&.location&.expression
-        return unless expression
+      def replace_source_fragment(source_range, original_range, replacement)
+        source = source_range.source
+        start = original_range.begin_pos - source_range.begin_pos
+        stop = original_range.end_pos - source_range.begin_pos
+        return unless start >= 0 && stop <= source.bytesize && start <= stop
+
+        prefix = source.byteslice(0, start)
+        suffix = source.byteslice(stop, source.bytesize - stop)
+        return unless prefix && suffix
 
-        [
-          expression.source_buffer.name,
-          expression.line,
-          expression.column,
-          expression.last_line,
-          expression.last_column
-        ]
+        prefix + replacement + suffix
       end
 
       def compile_safe_unparse(node)

data/lib/henitai/mutant.rb

@@ -35,7 +35,7 @@ module Henitai
 
     attr_reader :id, :subject, :operator, :original_node, :mutated_node,
                 :mutation_type, :description, :location
-    attr_accessor :status, :killing_test, :duration
+    attr_accessor :status, :killing_test, :duration, :covered_by, :tests_completed
 
     # @param subject [Subject] the subject being mutated
     # @param operator [Symbol] operator name, e.g. :ArithmeticOperator
@@ -53,6 +53,8 @@ module Henitai
       @status        = :pending
       @killing_test  = nil
       @duration      = nil
+      @covered_by    = nil
+      @tests_completed = nil
     end
 
     def killed?      = @status == :killed

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/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