sixth_sense 0.1.0

data/lib/sixth_sense/mutation_matrix_mutant_generator.rb

@@ -0,0 +1,462 @@
+# frozen_string_literal: true
+
+require "digest"
+require "prism"
+
+module SixthSense
+  MatrixMutation = Struct.new(:id, :path, :line, :operator, :original, :replacement, :status, :metadata, keyword_init: true)
+
+  class MutationMatrixMutantGenerator
+    BUILTIN_OPERATORS = %w[
+      arithmetic_operator_replacement
+      boolean_flip
+      collection_literal_empty
+      collection_literal_replacement
+      comparison_operator_replacement
+      condition_negation
+      constant_replacement
+      logical_operator_replacement
+      loop_condition_negation
+      method_call_replacement
+      nil_replacement
+      numeric_literal_decrement
+      numeric_literal_increment
+      numeric_literal_negation
+      numeric_literal_one
+      numeric_literal_zero
+      predicate_method_replacement
+      range_operator_replacement
+      regexp_literal_empty
+      return_value_nil
+      string_literal_empty
+      string_literal_replacement
+      symbol_literal_replacement
+    ].freeze
+
+    METHOD_REPLACEMENTS = {
+      "__send__" => %w[public_send],
+      "all?" => %w[any? none?],
+      "any?" => %w[all? empty? none?],
+      "append" => %w[prepend],
+      "assoc" => %w[rassoc],
+      "at" => %w[fetch key?],
+      "bytes" => %w[chars],
+      "capitalize!" => %w[capitalize],
+      "chars" => %w[bytes],
+      "chomp!" => %w[chomp],
+      "chop!" => %w[chop],
+      "chunk" => %w[each],
+      "chunk_while" => %w[each],
+      "collect" => %w[each],
+      "collect!" => %w[collect],
+      "collect_concat" => %w[collect],
+      "compact!" => %w[compact],
+      "ceil" => %w[floor],
+      "count" => %w[size length],
+      "delete!" => %w[delete],
+      "delete_if" => %w[reject],
+      "detect" => %w[first last],
+      "downcase" => %w[upcase],
+      "downcase!" => %w[downcase],
+      "drop" => %w[take],
+      "each_cons" => %w[each],
+      "each_key" => %w[each_value],
+      "each_slice" => %w[each],
+      "each_value" => %w[each_key],
+      "each_with_index" => %w[each],
+      "each_with_object" => %w[each],
+      "empty?" => %w[any?],
+      "encode!" => %w[encode],
+      "end_with?" => %w[start_with?],
+      "even?" => %w[odd?],
+      "fetch" => %w[key?],
+      "filter" => %w[reject],
+      "filter!" => %w[filter],
+      "filter_map" => %w[map],
+      "find" => %w[first last],
+      "first" => %w[last],
+      "flat_map" => %w[map],
+      "flatten!" => %w[flatten],
+      "floor" => %w[ceil],
+      "grep" => %w[grep_v],
+      "grep_v" => %w[grep],
+      "gsub" => %w[sub],
+      "gsub!" => %w[gsub],
+      "include?" => %w[exclude?],
+      "is_a?" => %w[instance_of?],
+      "keep_if" => %w[select],
+      "key?" => %w[value?],
+      "keys" => %w[values],
+      "kind_of?" => %w[instance_of?],
+      "last" => %w[first],
+      "lstrip!" => %w[lstrip],
+      "map" => %w[each],
+      "map!" => %w[map],
+      "match" => %w[match?],
+      "max" => %w[first last min],
+      "max_by" => %w[first last min_by],
+      "merge!" => %w[merge],
+      "method" => %w[public_method],
+      "min" => %w[first last max],
+      "min_by" => %w[first last max_by],
+      "negative?" => %w[positive?],
+      "none?" => %w[any? all?],
+      "odd?" => %w[even?],
+      "pop" => %w[shift],
+      "positive?" => %w[negative?],
+      "pred" => %w[succ],
+      "prepend" => %w[append],
+      "push" => %w[unshift],
+      "rassoc" => %w[assoc],
+      "reject" => %w[select],
+      "reject!" => %w[reject],
+      "reverse!" => %w[reverse],
+      "reverse_each" => %w[each],
+      "reverse_map" => %w[map each],
+      "reverse_merge" => %w[merge],
+      "rotate!" => %w[rotate],
+      "rstrip!" => %w[rstrip],
+      "sample" => %w[first last],
+      "scrub!" => %w[scrub],
+      "select" => %w[reject],
+      "select!" => %w[select],
+      "send" => %w[public_send __send__],
+      "shift" => %w[pop],
+      "shuffle!" => %w[shuffle],
+      "slice_after" => %w[each],
+      "slice_before" => %w[each],
+      "slice_when" => %w[each],
+      "size" => %w[length count],
+      "sort!" => %w[sort],
+      "sort_by" => %w[sort],
+      "sort_by!" => %w[sort_by],
+      "squeeze!" => %w[squeeze],
+      "start_with?" => %w[end_with?],
+      "strip" => %w[lstrip rstrip],
+      "strip!" => %w[strip],
+      "sub!" => %w[sub],
+      "succ" => %w[pred],
+      "swapcase!" => %w[swapcase],
+      "take" => %w[drop],
+      "to_a" => %w[to_ary],
+      "to_f" => %w[to_i],
+      "to_h" => %w[to_hash],
+      "to_i" => %w[to_int],
+      "to_s" => %w[to_str],
+      "tr!" => %w[tr],
+      "tr_s!" => %w[tr_s],
+      "transform_keys" => %w[transform_values],
+      "transform_keys!" => %w[transform_keys],
+      "transform_values" => %w[transform_keys],
+      "transform_values!" => %w[transform_values],
+      "unicode_normalize!" => %w[unicode_normalize],
+      "uniq!" => %w[uniq],
+      "unshift" => %w[push],
+      "upcase" => %w[downcase],
+      "upcase!" => %w[upcase],
+      "values" => %w[keys],
+      "values_at" => %w[fetch_values],
+      "zero?" => %w[nonzero?]
+    }.freeze
+
+    def initialize(config: {})
+      @config = config
+    end
+
+    def generate(plan)
+      generated = generate_mutants(plan)
+      skipped, executable = generated.partition { |mutant| operator_excluded?(mutant.operator) }
+      selected, sampling = select_mutants(executable)
+      {
+        mutants: skipped.map { |mutant| mark_skipped(mutant) } + selected,
+        sampling: sampling.merge("excluded_count" => skipped.length)
+      }
+    end
+
+    private
+
+    def generate_mutants(plan)
+      plan.source_units.flat_map do |unit|
+        path = unit.fetch(:path) { unit["path"] }
+        next [] unless File.file?(path)
+
+        mutants_for_file(path)
+      end.flatten
+    end
+
+    def mutants_for_file(path)
+      source = File.read(path)
+      parsed = Prism.parse(source)
+      return [] unless parsed.success?
+
+      mutations = []
+      walk(parsed.value) do |node, parent|
+        mutations.concat(node_mutations(path, node, parent))
+      end
+      mutations.compact.sort_by { |mutant| [mutant.metadata.dig("range", "start"), mutant.operator, mutant.replacement] }
+    end
+
+    def walk(node, parent = nil, &block)
+      yield node, parent
+      node.each_child_node { |child| walk(child, node, &block) } if node.respond_to?(:each_child_node)
+    end
+
+    def node_mutations(path, node, parent)
+      case node
+      when Prism::StringNode then string_mutations(path, node)
+      when Prism::IntegerNode, Prism::FloatNode then numeric_mutations(path, node)
+      when Prism::TrueNode, Prism::FalseNode then boolean_mutations(path, node)
+      when Prism::IfNode, Prism::UnlessNode then conditional_mutations(path, node)
+      when Prism::WhileNode, Prism::UntilNode then loop_mutations(path, node)
+      when Prism::AndNode, Prism::OrNode then logical_mutations(path, node)
+      when Prism::NilNode then [range_mutation(path, "nil_replacement", node.location, "false")]
+      when Prism::ReturnNode then return_mutations(path, node)
+      when Prism::DefNode then implicit_return_mutations(path, node)
+      when Prism::SymbolNode then symbol_mutations(path, node)
+      when Prism::ArrayNode, Prism::HashNode then collection_mutations(path, node)
+      when Prism::RangeNode then range_operator_mutations(path, node)
+      when Prism::RegularExpressionNode then [range_mutation(path, "regexp_literal_empty", node.location, "//")]
+      when Prism::ConstantReadNode, Prism::ConstantPathNode then constant_mutations(path, node, parent)
+      when Prism::CallNode then call_mutations(path, node)
+      else []
+      end
+    end
+
+    def string_mutations(path, node)
+      delimiter = node.opening == "'" ? "'" : '"'
+      [
+        range_mutation(path, "string_literal_replacement", node.location, "#{delimiter}#{node.unescaped}__mutant__#{delimiter}"),
+        range_mutation(path, "string_literal_empty", node.location, "#{delimiter}#{delimiter}")
+      ]
+    end
+
+    def numeric_mutations(path, node)
+      value = numeric_value(node.slice)
+      [
+        range_mutation(path, "numeric_literal_increment", node.location, numeric_literal(value + 1)),
+        range_mutation(path, "numeric_literal_decrement", node.location, numeric_literal(value - 1)),
+        range_mutation(path, "numeric_literal_zero", node.location, "0"),
+        range_mutation(path, "numeric_literal_one", node.location, "1"),
+        range_mutation(path, "numeric_literal_negation", node.location, numeric_literal(-value))
+      ]
+    end
+
+    def boolean_mutations(path, node)
+      replacement = node.is_a?(Prism::TrueNode) ? "false" : "true"
+      [range_mutation(path, "boolean_flip", node.location, replacement)]
+    end
+
+    def conditional_mutations(path, node)
+      location = node.respond_to?(:if_keyword_loc) ? node.if_keyword_loc : node.keyword_loc
+      replacement = node.is_a?(Prism::UnlessNode) || location.slice == "unless" ? "if" : "unless"
+      [range_mutation(path, "condition_negation", location, replacement)]
+    end
+
+    def loop_mutations(path, node)
+      replacement = node.is_a?(Prism::WhileNode) ? "until" : "while"
+      [range_mutation(path, "loop_condition_negation", node.keyword_loc, replacement)]
+    end
+
+    def logical_mutations(path, node)
+      replacement = node.operator == "&&" || node.operator == "and" ? (node.operator == "and" ? "or" : "||") : (node.operator == "or" ? "and" : "&&")
+      [range_mutation(path, "logical_operator_replacement", node.operator_loc, replacement)]
+    end
+
+    def return_mutations(path, node)
+      return [] unless node.location.slice.match?(/\Areturn\b/)
+
+      [range_mutation(path, "return_value_nil", node.location, "return nil")]
+    end
+
+    def implicit_return_mutations(path, node)
+      statements = node.body&.body
+      return [] if statements.nil? || statements.empty?
+
+      last_statement = statements.last
+      return [] if last_statement.is_a?(Prism::NilNode) || last_statement.is_a?(Prism::ReturnNode)
+
+      [range_mutation(path, "return_value_nil", last_statement.location, "nil")]
+    end
+
+    def symbol_mutations(path, node)
+      return [] unless node.location.slice.start_with?(":")
+
+      [range_mutation(path, "symbol_literal_replacement", node.location, ":#{node.value}__mutant__")]
+    end
+
+    def collection_mutations(path, node)
+      literal = node.location.slice
+      replacement = node.is_a?(Prism::ArrayNode) ? "[]" : "{}"
+      mutations = [range_mutation(path, "collection_literal_replacement", node.location, "nil")]
+      mutations << range_mutation(path, "collection_literal_empty", node.location, replacement) unless literal == replacement
+      mutations
+    end
+
+    def range_operator_mutations(path, node)
+      replacement = node.operator == "..." ? ".." : "..."
+      [range_mutation(path, "range_operator_replacement", node.operator_loc, replacement)]
+    end
+
+    def constant_mutations(path, node, parent)
+      return [] if parent.is_a?(Prism::ClassNode) || parent.is_a?(Prism::ModuleNode)
+      return [] if node.location.slice == "Object"
+
+      [range_mutation(path, "constant_replacement", node.location, "Object")]
+    end
+
+    def call_mutations(path, node)
+      [
+        comparison_mutations(path, node),
+        arithmetic_mutations(path, node),
+        method_call_mutations(path, node),
+        predicate_method_mutations(path, node)
+      ].flatten.compact
+    end
+
+    def comparison_mutations(path, node)
+      replacements = {
+        "===" => ["is_a?"],
+        "=~" => ["match?"],
+        "==" => %w[!= eql? equal?],
+        "!=" => %w[== eql? equal?],
+        ">=" => %w[> == eql? equal?],
+        "<=" => %w[< == eql? equal?],
+        ">" => %w[== eql? equal?],
+        "<" => %w[== eql? equal?]
+      }[node.name.to_s]
+      return [] unless replacements
+
+      replacements.filter_map do |replacement|
+        call_operator_mutation(path, node, "comparison_operator_replacement", replacement)
+      end
+    end
+
+    def arithmetic_mutations(path, node)
+      replacement = {
+        "**" => "*",
+        "+" => "-",
+        "-" => "+",
+        "*" => "/",
+        "/" => "*",
+        "%" => "/",
+        "<<" => ">>",
+        ">>" => "<<",
+        "&" => %w[| ^],
+        "|" => %w[& ^],
+        "^" => %w[& |]
+      }[node.name.to_s]
+      return [] unless replacement
+
+      Array(replacement).map { |item| range_mutation(path, "arithmetic_operator_replacement", node.message_loc, item) }
+    end
+
+    def method_call_mutations(path, node)
+      return [] unless node.receiver
+
+      replacements = METHOD_REPLACEMENTS[node.name.to_s]
+      return [] unless replacements
+
+      replacements.filter_map do |replacement|
+        range_mutation(path, "method_call_replacement", node.message_loc, replacement)
+      end
+    end
+
+    def predicate_method_mutations(path, node)
+      return [] unless node.receiver && node.name.to_s.end_with?("?")
+
+      [
+        range_mutation(path, "predicate_method_replacement", node.location, "true"),
+        range_mutation(path, "predicate_method_replacement", node.location, "false")
+      ]
+    end
+
+    def call_operator_mutation(path, node, operator, replacement)
+      return range_mutation(path, operator, node.message_loc, replacement) if replacement.match?(/\A[^\w]+\z/)
+
+      source = method_call_source(node, replacement)
+      range_mutation(path, operator, node.location, source) if source
+    end
+
+    def method_call_source(node, method_name)
+      receiver = node.receiver&.slice
+      return unless receiver
+
+      args = Array(node.arguments&.arguments).map(&:slice).join(", ")
+      args.empty? ? "#{receiver}.#{method_name}" : "#{receiver}.#{method_name}(#{args})"
+    end
+
+    def numeric_value(source)
+      normalized = source.delete("_")
+      normalized.include?(".") ? normalized.to_f : normalized.to_i
+    end
+
+    def numeric_literal(value)
+      value.is_a?(Float) && value.to_i != value ? value.to_s : value.to_i.to_s
+    end
+
+    def range_mutation(path, operator, location, replacement)
+      return if location.nil?
+      return if location.slice == replacement
+
+      digest = Digest::SHA256.hexdigest([path, location.start_offset, location.end_offset, operator, replacement].join(":"))[0, 12]
+      MatrixMutation.new(
+        id: "m-#{digest}",
+        path: path,
+        line: location.start_line,
+        operator: operator,
+        original: location.slice,
+        replacement: replacement,
+        status: "active",
+        metadata: {
+          "rewrite" => "range",
+          "range" => {
+            "start" => location.start_offset,
+            "end" => location.end_offset
+          }
+        }
+      )
+    end
+
+    def operator_excluded?(operator)
+      operator_excludes.include?(operator.to_s)
+    end
+
+    def operator_excludes
+      operators = @config["operators"] || @config[:operators] || {}
+      Array(operators["exclude"] || operators[:exclude]).map(&:to_s)
+    end
+
+    def select_mutants(mutants)
+      return [mutants, sampling_metadata(mutants, mutants, sampled: false)] if mutants.length <= max_mutants
+
+      selected = []
+      grouped = mutants.group_by(&:operator).sort_by { |operator, _items| operator.to_s }
+      until selected.length >= max_mutants || grouped.empty?
+        grouped.each do |_operator, items|
+          selected << items.shift if items.any? && selected.length < max_mutants
+        end
+        grouped.reject! { |_operator, items| items.empty? }
+      end
+      [selected, sampling_metadata(mutants, selected, sampled: true)]
+    end
+
+    def sampling_metadata(generated, selected, sampled:)
+      {
+        "sampled" => sampled,
+        "strategy" => sampled ? "operator_round_robin" : "none",
+        "generated_count" => generated.length,
+        "selected_count" => selected.length
+      }
+    end
+
+    def max_mutants
+      [@config.fetch("max_mutants", 500).to_i, 1].max
+    end
+
+    def mark_skipped(mutant)
+      mutant.status = "skipped"
+      mutant.metadata = mutant.metadata.merge("skip_reason" => "operator_excluded")
+      mutant
+    end
+  end
+end