evilution 0.16.1 → 0.18.0

data/lib/evilution/hooks/loader.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../hooks"
+
+class Evilution::Hooks::Loader
+  def self.call(registry, config_hooks = nil)
+    return registry if config_hooks.nil?
+
+    unless config_hooks.is_a?(Hash)
+      raise Evilution::ConfigError, "hooks must be a mapping of event names to file paths, got #{config_hooks.class}"
+    end
+    return registry if config_hooks.empty?
+
+    config_hooks.each do |event, paths|
+      event = event.to_sym
+      Array(paths).each do |path|
+        handler = load_hook_file(path)
+        registry.register(event) { |payload| handler.call(payload) }
+      end
+    end
+
+    registry
+  end
+
+  def self.load_hook_file(path)
+    raise Evilution::ConfigError, "hook file not found: #{path}" unless File.exist?(path)
+
+    result = Module.new.module_eval(File.read(path), path, 1)
+    raise Evilution::ConfigError, "hook file #{path} must return a Proc, got #{result.class}" unless result.is_a?(Proc)
+
+    result
+  end
+
+  private_class_method :load_hook_file
+end

data/lib/evilution/hooks/registry.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "../hooks"
+
+class Evilution::Hooks::Registry
+  def initialize(on_error: nil)
+    @handlers = Evilution::Hooks::EVENTS.to_h { |event| [event, []] }
+    @on_error = on_error
+  end
+
+  def register(event, &block)
+    validate_event!(event)
+    raise ArgumentError, "a block must be provided when registering handler for #{event}" unless block
+
+    @handlers[event] << block
+    self
+  end
+
+  def fire(event, **payload)
+    validate_event!(event)
+    errors = []
+
+    @handlers[event].each do |handler|
+      handler.call(payload)
+    rescue StandardError => e
+      errors << e
+      report_error(event, e)
+    end
+
+    errors
+  end
+
+  def clear(event = nil)
+    if event
+      validate_event!(event)
+      @handlers[event].clear
+    else
+      @handlers.each_value(&:clear)
+    end
+  end
+
+  def handlers_for(event)
+    validate_event!(event)
+    @handlers[event].dup
+  end
+
+  private
+
+  def validate_event!(event)
+    raise ArgumentError, "unknown hook event: #{event}" unless Evilution::Hooks::EVENTS.include?(event)
+  end
+
+  def report_error(event, error)
+    if @on_error
+      @on_error.call(event, error)
+    else
+      warn "[evilution] hook error in #{event}: #{error.message}"
+    end
+  end
+end

data/lib/evilution/hooks.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+class Evilution::Hooks
+  EVENTS = %i[
+    worker_process_start
+    mutation_insert_pre
+    mutation_insert_post
+    setup_integration_pre
+    setup_integration_post
+  ].freeze
+
+  def initialize
+    @handlers = EVENTS.to_h { |event| [event, []] }
+  end
+
+  def register(event, &block)
+    validate_event!(event)
+    raise ArgumentError, "a block must be provided when registering handler for #{event}" unless block
+
+    @handlers[event] << block
+    self
+  end
+
+  def fire(event, **payload)
+    validate_event!(event)
+    @handlers[event].each { |handler| handler.call(payload) }
+  end
+
+  def clear(event = nil)
+    if event
+      validate_event!(event)
+      @handlers[event].clear
+    else
+      @handlers.each_value(&:clear)
+    end
+  end
+
+  def handlers_for(event)
+    validate_event!(event)
+    @handlers[event].dup
+  end
+
+  def self.from_config(config_hooks)
+    hooks = new
+    return hooks if config_hooks.nil? || config_hooks.empty?
+
+    config_hooks.each do |event, callables|
+      Array(callables).each { |callable| hooks.register(event) { |payload| callable.call(payload) } }
+    end
+    hooks
+  end
+
+  private
+
+  def validate_event!(event)
+    raise ArgumentError, "unknown hook event: #{event}" unless EVENTS.include?(event)
+  end
+end

data/lib/evilution/integration/base.rb

@@ -3,6 +3,10 @@
 require_relative "../integration"
 
 class Evilution::Integration::Base
+  def initialize(hooks: nil)
+    @hooks = hooks
+  end
+
   def call(mutation)
     raise NotImplementedError, "#{self.class}#call must be implemented"
   end

data/lib/evilution/integration/rspec.rb

@@ -9,10 +9,10 @@ require_relative "../spec_resolver"
 require_relative "../integration"
 
 class Evilution::Integration::RSpec < Evilution::Integration::Base
-  def initialize(test_files: nil)
+  def initialize(test_files: nil, hooks: nil)
     @test_files = test_files
     @rspec_loaded = false
-    super()
+    super(hooks: hooks)
   end
 
   def call(mutation)
@@ -20,7 +20,9 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     @temp_dir = nil
     @lock_file = nil
     ensure_rspec_loaded
+    @hooks.fire(:mutation_insert_pre, mutation: mutation, file_path: mutation.file_path) if @hooks
     apply_mutation(mutation)
+    @hooks.fire(:mutation_insert_post, mutation: mutation, file_path: mutation.file_path) if @hooks
     run_rspec(mutation)
   ensure
     restore_original(mutation)
@@ -33,8 +35,10 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
   def ensure_rspec_loaded
     return if @rspec_loaded
 
+    @hooks.fire(:setup_integration_pre, integration: :rspec) if @hooks
     require "rspec/core"
     @rspec_loaded = true
+    @hooks.fire(:setup_integration_post, integration: :rspec) if @hooks
   rescue LoadError => e
     raise Evilution::Error, "rspec-core is required but not available: #{e.message}"
   end

data/lib/evilution/isolation/fork.rb

@@ -9,6 +9,10 @@ require_relative "../isolation"
 class Evilution::Isolation::Fork
   GRACE_PERIOD = 2
 
+  def initialize(hooks: nil)
+    @hooks = hooks
+  end
+
   def call(mutation:, test_command:, timeout:)
     sandbox_dir = Dir.mktmpdir("evilution-run")
     start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
@@ -18,6 +22,7 @@ class Evilution::Isolation::Fork
       ENV["TMPDIR"] = sandbox_dir
       read_io.close
       suppress_child_output
+      @hooks.fire(:worker_process_start, mutation: mutation) if @hooks
       result = execute_in_child(mutation, test_command)
       Marshal.dump(result, write_io)
       write_io.close

data/lib/evilution/mcp/session_diff_tool.rb

@@ -3,6 +3,7 @@
 require "json"
 require "mcp"
 require_relative "../session/store"
+require_relative "../session/diff"
 
 require_relative "../mcp"
 
@@ -33,7 +34,10 @@ class Evilution::MCP::SessionDiffTool < MCP::Tool
       base_data = store.load(base)
       head_data = store.load(head)
 
-      ::MCP::Tool::Response.new([{ type: "text", text: ::JSON.generate(build_diff(base_data, head_data)) }])
+      diff = Evilution::Session::Diff.new
+      result = diff.call(base_data, head_data)
+
+      ::MCP::Tool::Response.new([{ type: "text", text: ::JSON.generate(result.to_h) }])
     rescue Evilution::Error => e
       error_response("not_found", e.message)
     rescue ::JSON::ParserError => e
@@ -45,40 +49,6 @@ class Evilution::MCP::SessionDiffTool < MCP::Tool
 
     private
 
-    def build_diff(base_data, head_data)
-      base_survivors = base_data["survived"] || []
-      head_survivors = head_data["survived"] || []
-
-      base_keys = base_survivors.to_set { |m| mutation_key(m) }
-      head_keys = head_survivors.to_set { |m| mutation_key(m) }
-
-      {
-        "summary" => build_summary_diff(base_data, head_data),
-        "fixed" => base_survivors.reject { |m| head_keys.include?(mutation_key(m)) },
-        "new_survivors" => head_survivors.reject { |m| base_keys.include?(mutation_key(m)) },
-        "persistent" => head_survivors.select { |m| base_keys.include?(mutation_key(m)) }
-      }
-    end
-
-    def build_summary_diff(base_data, head_data)
-      base_summary = base_data["summary"] || {}
-      head_summary = head_data["summary"] || {}
-      base_score = base_summary["score"] || 0.0
-      head_score = head_summary["score"] || 0.0
-
-      {
-        "base_score" => base_score,
-        "head_score" => head_score,
-        "score_delta" => (head_score - base_score).round(4),
-        "base_survived" => base_summary["survived"] || 0,
-        "head_survived" => head_summary["survived"] || 0
-      }
-    end
-
-    def mutation_key(mutation)
-      [mutation["operator"], mutation["file"], mutation["line"], mutation["subject"]]
-    end
-
     def error_response(type, message)
       ::MCP::Tool::Response.new(
         [{ type: "text", text: ::JSON.generate({ error: { type: type, message: message } }) }],

data/lib/evilution/mutator/base.rb

@@ -13,10 +13,11 @@ class Evilution::Mutator::Base < Prism::Visitor
     @file_source = nil
   end
 
-  def call(subject)
+  def call(subject, filter: nil)
     @subject = subject
     @file_source = File.read(subject.file_path)
     @mutations = []
+    @filter = filter
     visit(subject.node)
     @mutations
   end
@@ -24,6 +25,8 @@ class Evilution::Mutator::Base < Prism::Visitor
   private
 
   def add_mutation(offset:, length:, replacement:, node:)
+    return if @filter && @filter.skip?(node)
+
     mutated_source = Evilution::AST::SourceSurgeon.apply(
       @file_source,
       offset: offset,

data/lib/evilution/mutator/operator/collection_return.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::CollectionReturn < Evilution::Mutator::Base
+  def visit_def_node(node)
+    body = node.body
+    if body.is_a?(Prism::StatementsNode) && body.body.length > 1
+      return_node = body.body.last
+      replacement = collection_replacement(return_node)
+
+      if replacement
+        add_mutation(
+          offset: body.location.start_offset,
+          length: body.location.length,
+          replacement: replacement,
+          node: node
+        )
+      end
+    end
+
+    super
+  end
+
+  def collection_replacement(node)
+    case node
+    when Prism::ArrayNode
+      "[]" if node.elements.any?
+    when Prism::HashNode
+      "{}" if node.elements.any?
+    end
+  end
+end

data/lib/evilution/mutator/operator/defined_check.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::DefinedCheck < Evilution::Mutator::Base
+  def visit_defined_node(node)
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: "true",
+      node: node
+    )
+
+    super
+  end
+end

data/lib/evilution/mutator/operator/index_assignment_removal.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::IndexAssignmentRemoval < Evilution::Mutator::Base
+  def visit_call_node(node)
+    if node.name == :[]= && node.receiver
+      add_mutation(
+        offset: node.location.start_offset,
+        length: node.location.length,
+        replacement: "nil",
+        node: node
+      )
+    end
+
+    super
+  end
+end

data/lib/evilution/mutator/operator/index_to_dig.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::IndexToDig < Evilution::Mutator::Base
+  def initialize
+    super
+    @consumed = Set.new
+  end
+
+  def visit_call_node(node)
+    if chain_head?(node)
+      root, args = collect_chain(node)
+      root_source = @file_source[root.location.start_offset, root.location.length]
+      arg_sources = args.map { |a| @file_source[a.location.start_offset, a.location.length] }
+
+      add_mutation(
+        offset: node.location.start_offset,
+        length: node.location.length,
+        replacement: "#{root_source}.dig(#{arg_sources.join(", ")})",
+        node: node
+      )
+    end
+
+    super
+  end
+
+  private
+
+  def chain_head?(node)
+    return false if @consumed.include?(node.object_id)
+    return false unless single_arg_index?(node)
+    return false unless single_arg_index?(node.receiver)
+
+    true
+  end
+
+  def single_arg_index?(node)
+    node.is_a?(Prism::CallNode) &&
+      node.name == :[] &&
+      node.receiver &&
+      node.arguments &&
+      node.arguments.arguments.length == 1
+  end
+
+  def collect_chain(node)
+    args = []
+    current = node
+
+    while single_arg_index?(current)
+      @consumed.add(current.object_id)
+      args.unshift(current.arguments.arguments.first)
+      current = current.receiver
+    end
+
+    [current, args]
+  end
+end

data/lib/evilution/mutator/operator/index_to_fetch.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::IndexToFetch < Evilution::Mutator::Base
+  def visit_call_node(node)
+    if indexable?(node)
+      receiver_source = @file_source[node.receiver.location.start_offset, node.receiver.location.length]
+      arg_source = @file_source[node.arguments.location.start_offset, node.arguments.location.length]
+
+      add_mutation(
+        offset: node.location.start_offset,
+        length: node.location.length,
+        replacement: "#{receiver_source}.fetch(#{arg_source})",
+        node: node
+      )
+    end
+
+    super
+  end
+
+  private
+
+  def indexable?(node)
+    node.name == :[] &&
+      node.receiver &&
+      node.arguments &&
+      node.arguments.arguments.length == 1
+  end
+end

data/lib/evilution/mutator/operator/keyword_argument.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::KeywordArgument < Evilution::Mutator::Base
+  def visit_def_node(node)
+    params = node.parameters
+    if params
+      mutate_optional_keyword_defaults(params)
+      mutate_optional_keyword_removal(params)
+      mutate_keyword_rest_removal(params)
+    end
+
+    super
+  end
+
+  private
+
+  def mutate_optional_keyword_defaults(params)
+    params.keywords.each do |kw|
+      next unless kw.is_a?(Prism::OptionalKeywordParameterNode)
+
+      name_loc = kw.name_loc
+      kw_loc = kw.location
+
+      add_mutation(
+        offset: kw_loc.start_offset,
+        length: kw_loc.length,
+        replacement: @file_source[name_loc.start_offset...name_loc.end_offset],
+        node: kw
+      )
+    end
+  end
+
+  def mutate_optional_keyword_removal(params)
+    all_params = collect_all_params(params)
+    return if all_params.length < 2
+
+    params.keywords.each do |kw|
+      next unless kw.is_a?(Prism::OptionalKeywordParameterNode)
+
+      remaining = all_params.reject { |p| p.equal?(kw) }
+      replacement = remaining.map(&:slice).join(", ")
+
+      add_mutation(
+        offset: params.location.start_offset,
+        length: params.location.length,
+        replacement: replacement,
+        node: kw
+      )
+    end
+  end
+
+  def mutate_keyword_rest_removal(params)
+    kr = params.keyword_rest
+    return unless kr.is_a?(Prism::KeywordRestParameterNode)
+
+    all_params = collect_all_params(params)
+
+    if all_params.length < 2
+      add_mutation(
+        offset: kr.location.start_offset,
+        length: kr.location.length,
+        replacement: "",
+        node: kr
+      )
+    else
+      remaining = all_params.reject { |p| p.equal?(kr) }
+      replacement = remaining.map(&:slice).join(", ")
+
+      add_mutation(
+        offset: params.location.start_offset,
+        length: params.location.length,
+        replacement: replacement,
+        node: kr
+      )
+    end
+  end
+
+  def collect_all_params(params)
+    result = []
+    result.concat(params.requireds)
+    result.concat(params.optionals)
+    result << params.rest if params.rest
+    result.concat(params.posts)
+    result.concat(params.keywords)
+    result << params.keyword_rest if params.keyword_rest
+    result << params.block if params.block
+    result
+  end
+end

data/lib/evilution/mutator/operator/mixin_removal.rb

@@ -7,10 +7,11 @@ require_relative "../operator"
 class Evilution::Mutator::Operator::MixinRemoval < Evilution::Mutator::Base
   MIXIN_METHODS = %i[include extend prepend].freeze
 
-  def call(subject)
+  def call(subject, filter: nil)
     @subject = subject
     @file_source = File.read(subject.file_path)
     @mutations = []
+    @filter = filter
 
     tree = self.class.parsed_tree_for(subject.file_path, @file_source)
     enclosing = find_enclosing_scope(tree, subject.line_number)

data/lib/evilution/mutator/operator/multiple_assignment.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::MultipleAssignment < Evilution::Mutator::Base
+  def visit_multi_write_node(node)
+    lefts = node.lefts
+    values = node.value.is_a?(Prism::ArrayNode) ? node.value.elements : nil
+
+    if values && lefts.length == values.length && lefts.length >= 2 && node.rest.nil?
+      mutate_target_removal(node, lefts, values)
+      mutate_swap(node, lefts, values) if lefts.length == 2
+    end
+
+    super
+  end
+
+  private
+
+  def mutate_target_removal(node, lefts, values)
+    lefts.each_index do |i|
+      remaining_lefts = lefts.each_with_index.filter_map { |l, j| l.slice if j != i }
+      remaining_values = values.each_with_index.filter_map { |v, j| v.slice if j != i }
+
+      replacement = "#{remaining_lefts.join(", ")} = #{remaining_values.join(", ")}"
+
+      add_mutation(
+        offset: node.location.start_offset,
+        length: node.location.length,
+        replacement: replacement,
+        node: node
+      )
+    end
+  end
+
+  def mutate_swap(node, lefts, values)
+    swapped_lefts = "#{lefts[1].slice}, #{lefts[0].slice}"
+    replacement = "#{swapped_lefts} = #{values.map(&:slice).join(", ")}"
+
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: replacement,
+      node: node
+    )
+  end
+end

data/lib/evilution/mutator/operator/pattern_matching_alternative.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::PatternMatchingAlternative < Evilution::Mutator::Base
+  def visit_alternation_pattern_node(node)
+    remove_left(node)
+    remove_right(node)
+    swap_order(node)
+    super
+  end
+
+  private
+
+  def remove_left(node)
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: source_for(node.right),
+      node: node
+    )
+  end
+
+  def remove_right(node)
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: source_for(node.left),
+      node: node
+    )
+  end
+
+  def swap_order(node)
+    operator = @file_source.byteslice(node.operator_loc.start_offset, node.operator_loc.length)
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: "#{source_for(node.right)} #{operator} #{source_for(node.left)}",
+      node: node
+    )
+  end
+
+  def source_for(node)
+    @file_source.byteslice(node.location.start_offset, node.location.length)
+  end
+end