henitai 0.1.0

data/lib/henitai/operators/conditional_expression.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require_relative "../parser_current"
+
+module Henitai
+  module Operators
+    # Rewrites conditional expressions and loop guards.
+    class ConditionalExpression < Henitai::Operator
+      NODE_TYPES = %i[if case while until].freeze
+
+      def self.node_types
+        NODE_TYPES
+      end
+
+      def mutate(node, subject:)
+        case node.type
+        when :if
+          mutate_if(node, subject:)
+        when :case
+          mutate_case(node, subject:)
+        when :while, :until
+          mutate_loop(node, subject:)
+        else
+          []
+        end
+      end
+
+      private
+
+      def mutate_if(node, subject:)
+        condition, then_branch, else_branch = node.children
+        mutations = condition_variants(node, subject:, condition:)
+
+        has_else_branch = then_branch && else_branch
+        append_removed_else_branch(mutations, node, subject:, then_branch:) if has_else_branch
+        append_removed_then_branch(mutations, node, subject:, else_branch:) if then_branch
+
+        mutations
+      end
+
+      def mutate_case(node, subject:)
+        condition = node.children.first
+        when_nodes, else_branch = case_children(node.children.drop(1))
+        mutations = condition_variants(node, subject:, condition:)
+
+        mutations.concat(case_when_mutants(subject:, node:, when_nodes:))
+
+        if else_branch
+          mutations << branch_mutant(
+            subject:,
+            node:,
+            replacement: else_branch,
+            description: "kept else branch"
+          )
+        end
+
+        mutations
+      end
+
+      def mutate_loop(node, subject:)
+        condition = node.children.first
+        condition_variants(node, subject:, condition:)
+      end
+
+      def case_when_mutants(subject:, node:, when_nodes:)
+        when_nodes.each_with_index.map do |when_node, index|
+          branch_mutant(
+            subject:,
+            node:,
+            replacement: when_node.children.last || nil_node,
+            description: "kept when branch #{index + 1}"
+          )
+        end
+      end
+
+      def case_children(children)
+        return [[], nil] if children.empty?
+
+        if children.last&.type == :when
+          [children, nil]
+        else
+          [children[0...-1], children.last]
+        end
+      end
+
+      def condition_variants(node, subject:, condition:)
+        [
+          true_condition_mutant(node, subject:),
+          false_condition_mutant(node, subject:),
+          negated_condition_mutant(node, subject:, condition:)
+        ]
+      end
+
+      def true_condition_mutant(node, subject:)
+        condition_mutant(
+          node,
+          subject:,
+          replacement: true_node,
+          description: "replaced condition with true"
+        )
+      end
+
+      def false_condition_mutant(node, subject:)
+        condition_mutant(
+          node,
+          subject:,
+          replacement: false_node,
+          description: "replaced condition with false"
+        )
+      end
+
+      def negated_condition_mutant(node, subject:, condition:)
+        condition_mutant(
+          node,
+          subject:,
+          replacement: negate(condition),
+          description: "negated condition"
+        )
+      end
+
+      def condition_mutant(node, subject:, replacement:, description:)
+        branch_mutant(
+          subject:,
+          node:,
+          replacement: with_condition(node, replacement),
+          description:
+        )
+      end
+
+      def append_removed_else_branch(mutations, node, subject:, then_branch:)
+        mutations << branch_mutant(
+          subject:,
+          node:,
+          replacement: then_branch,
+          description: "removed else branch"
+        )
+      end
+
+      def append_removed_then_branch(mutations, node, subject:, else_branch:)
+        mutations << branch_mutant(
+          subject:,
+          node:,
+          replacement: else_branch || nil_node,
+          description: "removed then branch"
+        )
+      end
+
+      def branch_mutant(subject:, node:, replacement:, description:)
+        build_mutant(
+          subject:,
+          original_node: node,
+          mutated_node: replacement,
+          description:
+        )
+      end
+
+      def with_condition(node, replacement_condition)
+        children = node.children.dup
+        children[0] = replacement_condition
+        Parser::AST::Node.new(node.type, children)
+      end
+
+      def negate(node)
+        Parser::AST::Node.new(:send, [node, :!])
+      end
+
+      # rubocop:disable Lint/BooleanSymbol
+      def true_node
+        # Parser uses :true / :false node types, so the AST symbols are intentional.
+        Parser::AST::Node.new(:true, [])
+      end
+
+      def false_node
+        # Parser uses :true / :false node types, so the AST symbols are intentional.
+        Parser::AST::Node.new(:false, [])
+      end
+
+      def nil_node
+        Parser::AST::Node.new(:nil, [])
+      end
+      # rubocop:enable Lint/BooleanSymbol
+    end
+  end
+end

data/lib/henitai/operators/equality_operator.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../parser_current"
+
+module Henitai
+  module Operators
+    # Replaces comparison operators with the other comparison operators.
+    class EqualityOperator < Henitai::Operator
+      NODE_TYPES = [:send].freeze
+      OPERATORS = %i[== != < > <= >= <=> eql? equal?].freeze
+
+      def self.node_types
+        NODE_TYPES
+      end
+
+      def mutate(node, subject:)
+        method_name = node.children[1]
+        return [] unless OPERATORS.include?(method_name)
+
+        OPERATORS.each_with_object([]) do |replacement, mutants|
+          next if replacement == method_name
+
+          mutants << build_mutant(
+            subject:,
+            original_node: node,
+            mutated_node: mutated_node(node, replacement),
+            description: "replaced #{method_name} with #{replacement}"
+          )
+        end
+      end
+
+      private
+
+      def mutated_node(node, replacement)
+        receiver = node.children[0]
+        arguments = node.children[2..] || []
+        Parser::AST::Node.new(:send, [receiver, replacement, *arguments])
+      end
+    end
+  end
+end

data/lib/henitai/operators/hash_literal.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "../parser_current"
+
+module Henitai
+  module Operators
+    # Reduces hash literals by emptying them or mutating symbol keys.
+    class HashLiteral < Henitai::Operator
+      NODE_TYPES = [:hash].freeze
+
+      def self.node_types
+        NODE_TYPES
+      end
+
+      def mutate(node, subject:)
+        return [] if node.children.empty?
+
+        mutants = [empty_hash_mutant(node, subject:)]
+        mutants.concat(symbol_key_mutants(node, subject:))
+        mutants
+      end
+
+      private
+
+      def empty_hash_mutant(node, subject:)
+        build_mutant(
+          subject:,
+          original_node: node,
+          mutated_node: Parser::AST::Node.new(:hash, []),
+          description: "replaced hash with empty hash"
+        )
+      end
+
+      def symbol_key_mutants(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
+
+      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)
+      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])
+      end
+    end
+  end
+end

data/lib/henitai/operators/logical_operator.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative "../parser_current"
+
+module Henitai
+  module Operators
+    # Replaces short-circuit logical operators and collapses them to operands.
+    class LogicalOperator < Henitai::Operator
+      NODE_TYPES = %i[and or].freeze
+
+      def self.node_types
+        NODE_TYPES
+      end
+
+      def mutate(node, subject:)
+        case node.type
+        when :and
+          mutate_and(node, subject:)
+        when :or
+          mutate_or(node, subject:)
+        else
+          []
+        end
+      end
+
+      private
+
+      def mutate_and(node, subject:)
+        mutate_binary(node, subject:, replacement_type: :or, from: "&&", to: "||")
+      end
+
+      def mutate_or(node, subject:)
+        mutate_binary(node, subject:, replacement_type: :and, from: "||", to: "&&")
+      end
+
+      def mutate_binary(node, subject:, replacement_type:, from:, to:)
+        [
+          build_replaced_operator_mutant(
+            node,
+            subject:,
+            replacement_type:,
+            from:,
+            to:
+          ),
+          build_replaced_lhs_mutant(node, subject:, from:),
+          build_replaced_rhs_mutant(node, subject:, from:)
+        ]
+      end
+
+      def build_replaced_operator_mutant(node, subject:, replacement_type:, from:, to:)
+        lhs, rhs = node.children
+
+        build_mutant(
+          subject:,
+          original_node: node,
+          mutated_node: Parser::AST::Node.new(replacement_type, [lhs, rhs]),
+          description: "replaced #{from} with #{to}"
+        )
+      end
+
+      def build_replaced_lhs_mutant(node, subject:, from:)
+        lhs, = node.children
+
+        build_mutant(
+          subject:,
+          original_node: node,
+          mutated_node: lhs,
+          description: "replaced #{from} with lhs"
+        )
+      end
+
+      def build_replaced_rhs_mutant(node, subject:, from:)
+        _, rhs = node.children
+
+        build_mutant(
+          subject:,
+          original_node: node,
+          mutated_node: rhs,
+          description: "replaced #{from} with rhs"
+        )
+      end
+    end
+  end
+end

data/lib/henitai/operators/method_expression.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "../parser_current"
+
+module Henitai
+  module Operators
+    # Replaces generic method call results with nil.
+    class MethodExpression < Henitai::Operator
+      NODE_TYPES = [:send].freeze
+      EXCLUDED_METHODS = %i[
+        +
+        -
+        *
+        /
+        **
+        %
+        ==
+        !=
+        <
+        >
+        <=
+        >=
+        <=>
+        eql?
+        equal?
+        !
+      ].freeze
+
+      def self.node_types
+        NODE_TYPES
+      end
+
+      def mutate(node, subject:)
+        return [] unless node.type == :send
+
+        _receiver, method_name, *_arguments = node.children
+        return [] if excluded_method?(method_name)
+
+        [
+          build_mutant(
+            subject:,
+            original_node: node,
+            mutated_node: Parser::AST::Node.new(:nil, []),
+            description: "replaced method call with nil"
+          )
+        ]
+      end
+
+      private
+
+      def excluded_method?(method_name)
+        method_name.to_s.end_with?("=") || EXCLUDED_METHODS.include?(method_name)
+      end
+    end
+  end
+end

data/lib/henitai/operators/pattern_match.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "../parser_current"
+
+module Henitai
+  module Operators
+    # Mutates case-match arms and removes pattern guards.
+    class PatternMatch < Henitai::Operator
+      NODE_TYPES = [:case_match].freeze
+
+      def self.node_types
+        NODE_TYPES
+      end
+
+      def mutate(node, subject:)
+        mutants = []
+        arm_number = 0
+
+        node.children.each_with_index do |child, index|
+          next unless child&.type == :in_pattern
+
+          arm_number += 1
+          mutants << remove_in_arm(node, subject:, index:, arm_number:)
+
+          guard = child.children[1]
+          next unless guard
+
+          mutants << remove_guard(node, subject:, index:, arm_number:, child:)
+        end
+
+        mutants
+      end
+
+      private
+
+      def remove_in_arm(node, subject:, index:, arm_number:)
+        children = node.children.dup
+        children.delete_at(index)
+
+        build_mutant(
+          subject:,
+          original_node: node,
+          mutated_node: Parser::AST::Node.new(:case_match, children),
+          description: "removed in arm #{arm_number}"
+        )
+      end
+
+      def remove_guard(node, subject:, index:, arm_number:, child:)
+        children = node.children.dup
+        children[index] = mutated_arm(child)
+
+        build_mutant(
+          subject:,
+          original_node: node,
+          mutated_node: Parser::AST::Node.new(:case_match, children),
+          description: "removed pattern guard #{arm_number}"
+        )
+      end
+
+      def mutated_arm(node)
+        pattern, _guard, body = node.children
+        Parser::AST::Node.new(:in_pattern, [pattern, nil, body])
+      end
+    end
+  end
+end

data/lib/henitai/operators/range_literal.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../parser_current"
+
+module Henitai
+  module Operators
+    # Flips inclusive and exclusive range operators.
+    class RangeLiteral < Henitai::Operator
+      NODE_TYPES = %i[irange erange].freeze
+
+      def self.node_types
+        NODE_TYPES
+      end
+
+      def mutate(node, subject:)
+        case node.type
+        when :irange
+          mutate_range(node, subject:, replacement_type: :erange, from: "..", to: "...")
+        when :erange
+          mutate_range(node, subject:, replacement_type: :irange, from: "...", to: "..")
+        else
+          []
+        end
+      end
+
+      private
+
+      def mutate_range(node, subject:, replacement_type:, from:, to:)
+        [
+          build_mutant(
+            subject:,
+            original_node: node,
+            mutated_node: Parser::AST::Node.new(replacement_type, node.children),
+            description: "replaced #{from} with #{to}"
+          )
+        ]
+      end
+    end
+  end
+end

data/lib/henitai/operators/return_value.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "../parser_current"
+
+module Henitai
+  module Operators
+    # Replaces return values and implicit final expressions with neutral values.
+    class ReturnValue < Henitai::Operator
+      # Parser uses :true / :false node types, so the AST symbols are intentional.
+      # rubocop:disable Lint/BooleanSymbol
+      NODE_TYPES = %i[return send int float str dstr true false if case while until array hash].freeze
+      REPLACEMENT_FACTORIES = [
+        -> { Parser::AST::Node.new(:nil, []) },
+        -> { Parser::AST::Node.new(:int, [0]) },
+        -> { Parser::AST::Node.new(:false, []) }
+      ].freeze
+      # rubocop:enable Lint/BooleanSymbol
+
+      def self.node_types
+        NODE_TYPES
+      end
+
+      def mutate(node, subject:)
+        case node.type
+        when :return
+          mutate_explicit_return(node, subject:)
+        else
+          mutate_implicit_return(node, subject:)
+        end
+      end
+
+      private
+
+      def mutate_explicit_return(node, subject:)
+        expression = node.children.first
+        return [] unless expression
+        return [] if expression.type == :nil
+
+        replacement_nodes(expression).map do |replacement|
+          build_mutant(
+            subject:,
+            original_node: node,
+            mutated_node: Parser::AST::Node.new(:return, [replacement]),
+            description: "replaced return value with #{replacement_label(replacement)}"
+          )
+        end
+      end
+
+      def mutate_implicit_return(node, subject:)
+        return [] unless node == final_expression_node(subject&.ast_node)
+
+        replacement_nodes(node).map do |replacement|
+          build_mutant(
+            subject:,
+            original_node: node,
+            mutated_node: replacement,
+            description: "replaced final expression with #{replacement_label(replacement)}"
+          )
+        end
+      end
+
+      def final_expression_node(method_node)
+        return unless method_node
+
+        body = method_node.children.last
+        return body unless body&.type == :begin
+
+        body.children.rfind { |child| child.is_a?(Parser::AST::Node) }
+      end
+
+      # rubocop:disable Lint/BooleanSymbol
+      def replacement_nodes(node)
+        nodes = REPLACEMENT_FACTORIES.map(&:call)
+
+        case node.type
+        when :true
+          nodes << Parser::AST::Node.new(:false, [])
+        when :false
+          nodes.delete_if { |replacement| replacement.type == :false }
+          nodes << Parser::AST::Node.new(:true, [])
+        end
+
+        nodes
+          .uniq { |replacement| [replacement.type, replacement.children] }
+          .reject { |replacement| replacement == node }
+      end
+
+      def replacement_label(node)
+        case node.type
+        when :nil
+          "nil"
+        when :false
+          "false"
+        when :true
+          "true"
+        when :int
+          node.children.first.to_s
+        else
+          node.type.to_s
+        end
+      end
+      # rubocop:enable Lint/BooleanSymbol
+    end
+  end
+end

data/lib/henitai/operators/safe_navigation.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../parser_current"
+
+module Henitai
+  module Operators
+    # Removes the nil guard from safe navigation calls.
+    class SafeNavigation < Henitai::Operator
+      NODE_TYPES = [:csend].freeze
+
+      def self.node_types
+        NODE_TYPES
+      end
+
+      def mutate(node, subject:)
+        [
+          build_mutant(
+            subject:,
+            original_node: node,
+            mutated_node: mutated_node(node),
+            description: "removed nil guard"
+          )
+        ]
+      end
+
+      private
+
+      def mutated_node(node)
+        receiver, method_name, *arguments = node.children
+        Parser::AST::Node.new(:send, [receiver, method_name, *arguments])
+      end
+    end
+  end
+end