henitai 0.1.0

data/lib/henitai/mutant/activator.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require_relative "../parser_current"
+require "unparser"
+
+module Henitai
+  class Mutant
+    # Activates a mutant inside the forked child process.
+    class Activator
+      SERIALIZER_METHODS = {
+        arg: :argument_parameter_fragment,
+        optarg: :optional_parameter_fragment,
+        restarg: :rest_parameter_fragment,
+        kwarg: :keyword_parameter_fragment,
+        kwoptarg: :optional_keyword_parameter_fragment,
+        kwrestarg: :keyword_rest_parameter_fragment,
+        blockarg: :block_parameter_fragment,
+        forward_arg: :forward_parameter_fragment
+      }.freeze
+
+      def self.activate!(mutant)
+        new.activate!(mutant)
+      end
+
+      def activate!(mutant)
+        subject = mutant.subject
+        raise ArgumentError, "Cannot activate wildcard subjects" if subject.method_name.nil?
+
+        Henitai::WarningSilencer.silence do
+          target_for(subject).class_eval(method_source(mutant), __FILE__, __LINE__ + 1)
+          nil
+        end
+      rescue Unparser::UnsupportedNodeError
+        :compile_error
+      end
+
+      private
+
+      def target_for(subject)
+        target = load_target(subject)
+        subject.method_type == :class ? target.singleton_class : target
+      end
+
+      def method_source(mutant)
+        method_name = mutant.subject.method_name
+        parameters = parameter_source(mutant)
+        replacement = body_source(mutant)
+
+        <<~RUBY
+          define_method(:#{method_name}) do |#{parameters}|
+            #{replacement}
+          end
+        RUBY
+      end
+
+      def body_source(mutant)
+        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)
+
+        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)
+      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
+
+        left_location == right_location
+      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) }
+        else
+          child
+        end
+      end
+
+      def method_body(subject_node)
+        case subject_node.type
+        when :def
+          subject_node.children[2]
+        when :defs
+          subject_node.children[3]
+        when :block
+          block_body(subject_node)
+        else
+          subject_node
+        end
+      end
+
+      def parameter_source(mutant)
+        args_node = method_arguments(mutant.subject.ast_node)
+        return "" unless args_node
+        return forward_parameter_fragment(nil) if args_node.type == :forward_args
+
+        args_node.children.filter_map do |argument|
+          parameter_fragment(argument)
+        end.join(", ")
+      end
+
+      def method_arguments(subject_node)
+        case subject_node&.type
+        when :def
+          subject_node.children[1]
+        when :defs
+          subject_node.children[2]
+        when :block
+          block_arguments(subject_node)
+        end
+      end
+
+      def parameter_fragment(argument)
+        method_name = SERIALIZER_METHODS[argument&.type]
+        return unless method_name
+
+        send(method_name, argument)
+      end
+
+      def argument_parameter_fragment(argument)
+        argument.children[0].to_s
+      end
+
+      def optional_parameter_fragment(argument)
+        "#{argument.children[0]} = #{compile_safe_unparse(argument.children[1])}"
+      end
+
+      def rest_parameter_fragment(argument)
+        prefixed_parameter(argument, "*")
+      end
+
+      def keyword_parameter_fragment(argument)
+        "#{argument.children[0]}:"
+      end
+
+      def optional_keyword_parameter_fragment(argument)
+        "#{argument.children[0]}: #{compile_safe_unparse(argument.children[1])}"
+      end
+
+      def keyword_rest_parameter_fragment(argument)
+        prefixed_parameter(argument, "**")
+      end
+
+      def block_parameter_fragment(argument)
+        "&#{argument.children[0]}"
+      end
+
+      def forward_parameter_fragment(_argument)
+        "*args, **kwargs, &block"
+      end
+
+      def prefixed_parameter(argument, prefix)
+        name = argument.children[0]
+        name ? "#{prefix}#{name}" : prefix
+      end
+
+      def block_body(subject_node)
+        subject_node.children[2]
+      end
+
+      def block_arguments(subject_node)
+        subject_node.children[1]
+      end
+
+      def load_target(subject)
+        Object.const_get(subject.namespace.delete_prefix("::"))
+      rescue NameError
+        load_source_file(subject)
+        Object.const_get(subject.namespace.delete_prefix("::"))
+      end
+
+      def load_source_file(subject)
+        source_file = subject.source_file || source_file_from_ast(subject)
+        return unless source_file && File.file?(source_file)
+
+        load(source_file)
+      end
+
+      def source_file_from_ast(subject)
+        ast_node = subject.ast_node
+        return unless ast_node
+
+        location = ast_node.location
+        return unless location
+
+        expression = location.expression
+        return unless expression
+
+        expression.source_buffer.name
+      end
+
+      def node_location_signature(node)
+        expression = node&.location&.expression
+        return unless expression
+
+        [
+          expression.source_buffer.name,
+          expression.line,
+          expression.column,
+          expression.last_line,
+          expression.last_column
+        ]
+      end
+
+      def compile_safe_unparse(node)
+        Unparser.unparse(node)
+      rescue StandardError => e
+        raise Unparser::UnsupportedNodeError, e.message
+      end
+    end
+  end
+end

data/lib/henitai/mutant.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Henitai
+  # Represents a single syntactic mutation applied to a Subject.
+  #
+  # A Mutant holds:
+  #   - the original and mutated AST nodes
+  #   - the operator that generated it
+  #   - the source location of the mutation
+  #   - its current status in the pipeline
+  #
+  # Statuses follow the Stryker mutation-testing-report-schema vocabulary:
+  #   :pending, :killed, :survived, :timeout, :compile_error, :runtime_error,
+  #   :ignored, :no_coverage
+  class Mutant
+    autoload :Activator, "henitai/mutant/activator"
+
+    # Status-Vokabular folgt dem Stryker mutation-testing-report-schema.
+    # :equivalent ist ein Henitai-interner Status (wird im JSON als "Ignored" serialisiert,
+    # aber in der Scoring-Berechnung separat behandelt: confirmed equivalent mutants
+    # werden aus dem Nenner der MS-Berechnung herausgenommen).
+    STATUSES = %i[
+      pending
+      killed
+      survived
+      timeout
+      compile_error
+      runtime_error
+      ignored
+      no_coverage
+      equivalent
+    ].freeze
+
+    attr_reader :id, :subject, :operator, :original_node, :mutated_node,
+                :mutation_type, :description, :location
+    attr_accessor :status, :killing_test, :duration
+
+    # @param subject [Subject] the subject being mutated
+    # @param operator [Symbol] operator name, e.g. :ArithmeticOperator
+    # @param nodes [Hash] AST nodes with :original and :mutated entries
+    # @param description [String] human-readable description of the mutation
+    # @param location [Hash] { file:, start_line:, end_line:, start_col:, end_col: }
+    def initialize(subject:, operator:, nodes:, description:, location:)
+      @id            = SecureRandom.uuid
+      @subject       = subject
+      @operator      = operator
+      @original_node = nodes.fetch(:original)
+      @mutated_node  = nodes.fetch(:mutated)
+      @description   = description
+      @location      = location
+      @status        = :pending
+      @killing_test  = nil
+      @duration      = nil
+    end
+
+    def killed?      = @status == :killed
+    def survived?    = @status == :survived
+    def pending?     = @status == :pending
+    def ignored?     = @status == :ignored
+    def equivalent?  = @status == :equivalent
+
+    def to_s
+      "#{operator}@#{location[:file]}:#{location[:start_line]} — #{description}"
+    end
+  end
+end

data/lib/henitai/mutant_generator.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require_relative "parser_current"
+require_relative "source_parser"
+
+module Henitai
+  # Traverses a subject's AST and asks operators to build mutants.
+  class MutantGenerator
+    def generate(subjects, operators, config: nil)
+      normalized_operators = normalize_operators(operators)
+      arid_node_filter = AridNodeFilter.new
+      syntax_validator = SyntaxValidator.new
+      sampling_strategy = SamplingStrategy.new
+
+      mutants = Array(subjects).flat_map do |subject|
+        generate_for_subject(
+          subject,
+          normalized_operators,
+          config:,
+          arid_node_filter:,
+          syntax_validator:
+        )
+      end
+
+      sample_mutants(mutants, config:, sampling_strategy:)
+    end
+
+    private
+
+    def normalize_operators(operators)
+      Array(operators).map do |operator|
+        operator.is_a?(Class) ? operator.new : operator
+      end
+    end
+
+    def generate_for_subject(subject, operators, config:, arid_node_filter:, syntax_validator:)
+      return [] unless subject.source_file && subject.source_range
+
+      visitor = SubjectVisitor.new(
+        subject,
+        operators,
+        config:,
+        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
+      )
+    end
+
+    # Depth-first pre-order AST visitor for a single subject.
+    class SubjectVisitor
+      attr_reader :mutants
+
+      def initialize(subject, operators, config:, arid_node_filter:, syntax_validator:)
+        @subject = subject
+        @config = config
+        @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
+      end
+
+      def process(node)
+        walk(node)
+      end
+
+      private
+
+      def walk(node)
+        return unless node.is_a?(Parser::AST::Node)
+
+        apply_operators(node) if node_within_subject_range?(node)
+        node.children.each do |child|
+          walk(child)
+        end
+      end
+
+      def apply_operators(node)
+        return if @arid_node_filter.suppressed?(node, @config)
+
+        @operators_by_node_type[node.type].each do |operator|
+          operator.mutate(node, subject: @subject).each do |mutant|
+            @mutants << mutant if @syntax_validator.valid?(mutant)
+          end
+        end
+      end
+
+      def node_within_subject_range?(node)
+        location = node.location&.expression
+        return true unless location && @subject.source_range
+
+        node_range = location.line..location.last_line
+        ranges_overlap?(node_range, @subject.source_range)
+      end
+
+      def ranges_overlap?(left, right)
+        left.begin <= right.end && right.begin <= left.end
+      end
+    end
+
+    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
+      end
+
+      grouped.values.flat_map do |mutants_for_line|
+        mutants_for_line.sort_by { |mutant| mutant_priority_key(mutant) }.take(max_mutants_per_line)
+      end
+    end
+
+    def sample_mutants(mutants, config:, sampling_strategy:)
+      sampling = config&.sampling
+      return mutants unless sampling
+      return mutants if sampling[:ratio].nil?
+
+      sampling_strategy.sample(
+        mutants,
+        ratio: sampling[:ratio],
+        strategy: sampling[:strategy] || :stratified
+      )
+    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 operator_priority_map
+      # The constant order defines signal priority for per-line pruning.
+      @operator_priority_map ||= Operator::FULL_SET.each_with_index.to_h
+    end
+  end
+end