evilution 0.27.0 → 0.29.0

data/lib/evilution/mcp/session_tool.rb

@@ -50,8 +50,10 @@ class Evilution::MCP::SessionTool < MCP::Tool
 
   VALID_ACTIONS = %w[list show diff].freeze
 
+  LimitResult = Data.define(:limit, :error)
+  private_constant :LimitResult
+
   class << self
-    # rubocop:disable Lint/UnusedMethodArgument
     def call(server_context:, action: nil, results_dir: nil, limit: nil, path: nil, base: nil, head: nil)
       return error_response("config_error", "action is required") unless action
       return error_response("config_error", "unknown action: #{action}") unless VALID_ACTIONS.include?(action)
@@ -62,33 +64,32 @@ class Evilution::MCP::SessionTool < MCP::Tool
       when "diff" then diff_action(base: base, head: head, results_dir: results_dir)
       end
     end
-    # rubocop:enable Lint/UnusedMethodArgument
 
     private
 
     def list_action(results_dir:, limit:)
-      normalized_limit, limit_error = normalize_limit(limit)
-      return error_response("config_error", limit_error) if limit_error
+      result = normalize_limit(limit)
+      return error_response("config_error", result.error) if result.error
 
       store_opts = {}
       store_opts[:results_dir] = results_dir if results_dir
       store = Evilution::Session::Store.new(**store_opts)
       entries = store.list
-      entries = entries.first(normalized_limit) unless normalized_limit.nil?
+      entries = entries.first(result.limit) unless result.limit.nil?
 
       payload = entries.map { |e| e.transform_keys(&:to_s) }
       success_response(payload)
     end
 
     def normalize_limit(limit)
-      return [nil, nil] if limit.nil?
+      return LimitResult.new(limit: nil, error: nil) if limit.nil?
 
       coerced = Integer(limit)
-      return [nil, "limit must be a non-negative integer"] if coerced.negative?
+      return LimitResult.new(limit: nil, error: "limit must be a non-negative integer") if coerced.negative?
 
-      [coerced, nil]
+      LimitResult.new(limit: coerced, error: nil)
     rescue ArgumentError, TypeError
-      [nil, "limit must be a non-negative integer"]
+      LimitResult.new(limit: nil, error: "limit must be a non-negative integer")
     end
 
     def show_action(path:, results_dir:)
@@ -109,19 +110,11 @@ class Evilution::MCP::SessionTool < MCP::Tool
     end
 
     def diff_action(base:, head:, results_dir:)
-      return error_response("config_error", "base is required") unless base
-      return error_response("config_error", "head is required") unless head
-
       dir = results_dir || Evilution::Session::Store::DEFAULT_DIR
-      return error_response("config_error", "base must be under results directory") unless within?(base, dir)
-      return error_response("config_error", "head must be under results directory") unless within?(head, dir)
-
-      store = Evilution::Session::Store.new(results_dir: dir)
-      base_data = store.load(base)
-      head_data = store.load(head)
+      validation = validate_diff_args(base, head, dir)
+      return validation if validation
 
-      diff = Evilution::Session::Diff.new
-      result = diff.call(base_data, head_data)
+      result = load_and_diff(base, head, dir)
       success_response(result.to_h)
     rescue Evilution::Error => e
       error_response("not_found", e.message)
@@ -131,6 +124,20 @@ class Evilution::MCP::SessionTool < MCP::Tool
       error_response("runtime_error", e.message)
     end
 
+    def validate_diff_args(base, head, dir)
+      return error_response("config_error", "base is required") unless base
+      return error_response("config_error", "head is required") unless head
+      return error_response("config_error", "base must be under results directory") unless within?(base, dir)
+      return error_response("config_error", "head must be under results directory") unless within?(head, dir)
+
+      nil
+    end
+
+    def load_and_diff(base, head, dir)
+      store = Evilution::Session::Store.new(results_dir: dir)
+      Evilution::Session::Diff.new.call(store.load(base), store.load(head))
+    end
+
     def within?(path, results_dir)
       resolved_root = canonical_path(results_dir)
       resolved_path = canonical_path(path)

data/lib/evilution/mutation.rb

@@ -1,30 +1,53 @@
 # frozen_string_literal: true
 
 require "diff/lcs"
+require_relative "../evilution"
 
 class Evilution::Mutation
-  attr_reader :subject, :operator_name, :original_source,
-              :mutated_source, :original_slice, :mutated_slice,
-              :file_path, :line, :column, :parse_status
-
-  # rubocop:disable Metrics/ParameterLists
-  def initialize(subject:, operator_name:, original_source:, mutated_source:,
-                 file_path:, line:, column: 0, original_slice: nil, mutated_slice: nil,
-                 parse_status: :ok)
-    # rubocop:enable Metrics/ParameterLists
+  Sources = Data.define(:original, :mutated)
+  Slice = Data.define(:original, :mutated)
+  Location = Data.define(:file_path, :line, :column)
+
+  attr_reader :subject, :operator_name, :parse_status, :location
+
+  def initialize(subject:, operator_name:, sources:, location:, slice: nil, parse_status: :ok)
     @subject = subject
     @operator_name = operator_name
-    @original_source = original_source
-    @mutated_source = mutated_source
-    @original_slice = original_slice
-    @mutated_slice = mutated_slice
-    @file_path = file_path
-    @line = line
-    @column = column
+    @sources = sources
+    @location = location
+    @slice = slice
     @parse_status = parse_status
     @diff = nil
   end
 
+  def original_source
+    @sources&.original
+  end
+
+  def mutated_source
+    @sources&.mutated
+  end
+
+  def original_slice
+    @slice&.original
+  end
+
+  def mutated_slice
+    @slice&.mutated
+  end
+
+  def file_path
+    @location.file_path
+  end
+
+  def line
+    @location.line
+  end
+
+  def column
+    @location.column
+  end
+
   def unparseable?
     @parse_status == :unparseable
   end
@@ -41,45 +64,46 @@ class Evilution::Mutation
 
   def strip_sources!
     diff # ensure diff is cached before clearing sources
-    @original_source = nil
-    @mutated_source = nil
+    @sources = nil
+  end
+
+  def to_s
+    "#{operator_name}: #{file_path}:#{line}"
   end
 
   private
 
   def compute_diff
-    original_lines = original_source.lines
-    mutated_lines = mutated_source.lines
-    diffs = ::Diff::LCS.diff(original_lines, mutated_lines)
-
+    diffs = ::Diff::LCS.diff(original_source.lines, mutated_source.lines)
     return "" if diffs.empty?
 
-    result = []
-    diffs.flatten(1).each do |change|
-      case change.action
-      when "-"
-        result << "- #{change.element.chomp}"
-      when "+"
-        result << "+ #{change.element.chomp}"
-      end
+    diffs.flatten(1).filter_map { |change| format_diff_change(change) }.join("\n")
+  end
+
+  def format_diff_change(change)
+    case change.action
+    when "-" then "- #{change.element.chomp}"
+    when "+" then "+ #{change.element.chomp}"
     end
-    result.join("\n")
   end
 
   def compute_unified_diff
-    return nil if @original_slice.nil? || @mutated_slice.nil?
+    return nil if @slice.nil?
 
-    original_lines = @original_slice.lines
-    mutated_lines = @mutated_slice.lines
-    body = ::Diff::LCS.sdiff(original_lines, mutated_lines).map { |c| format_sdiff_change(c) }.join("\n")
+    original_lines = @slice.original.lines
+    mutated_lines = @slice.mutated.lines
     [
       "--- a/#{file_path}",
       "+++ b/#{file_path}",
       "@@ -#{line},#{original_lines.length} +#{line},#{mutated_lines.length} @@",
-      body
+      unified_diff_body(original_lines, mutated_lines)
     ].reject(&:empty?).join("\n")
   end
 
+  def unified_diff_body(original_lines, mutated_lines)
+    ::Diff::LCS.sdiff(original_lines, mutated_lines).map { |c| format_sdiff_change(c) }.join("\n")
+  end
+
   def format_sdiff_change(change)
     case change.action
     when "=" then " #{change.old_element.chomp}"
@@ -88,10 +112,4 @@ class Evilution::Mutation
     when "!" then "-#{change.old_element.chomp}\n+#{change.new_element.chomp}"
     end
   end
-
-  public
-
-  def to_s
-    "#{operator_name}: #{file_path}:#{line}"
-  end
 end

data/lib/evilution/mutator/base.rb

@@ -5,6 +5,9 @@ require "prism"
 require_relative "../mutator"
 
 class Evilution::Mutator::Base < Prism::Visitor
+  AffectedSlices = Data.define(:original, :mutated)
+  private_constant :AffectedSlices
+
   attr_reader :mutations
 
   def initialize(**_options)
@@ -28,31 +31,30 @@ class Evilution::Mutator::Base < Prism::Visitor
     return if @filter && @filter.skip?(node)
 
     surgery = Evilution::AST::SourceSurgeon.apply(
-      @file_source,
-      offset: offset,
-      length: length,
-      replacement: replacement
+      @file_source, offset: offset, length: length, replacement: replacement
     )
-    mutated_source = surgery.source
-
-    original_slice, mutated_slice = slice_affected_lines(
-      mutated_source: mutated_source,
+    slices = slice_affected_lines(
+      mutated_source: surgery.source,
       offset: offset,
       length: length,
       replacement_bytesize: replacement.bytesize
     )
 
-    @mutations << Evilution::Mutation.new(
+    @mutations << build_mutation_record(node, surgery, slices)
+  end
+
+  def build_mutation_record(node, surgery, slices)
+    Evilution::Mutation.new(
       subject: @subject,
       operator_name: self.class.operator_name,
-      original_source: @file_source,
-      mutated_source: mutated_source,
-      original_slice: original_slice,
-      mutated_slice: mutated_slice,
-      parse_status: surgery.status,
-      file_path: @subject.file_path,
-      line: node.location.start_line,
-      column: node.location.start_column
+      sources: Evilution::Mutation::Sources.new(original: @file_source, mutated: surgery.source),
+      slice: Evilution::Mutation::Slice.new(original: slices.original, mutated: slices.mutated),
+      location: Evilution::Mutation::Location.new(
+        file_path: @subject.file_path,
+        line: node.location.start_line,
+        column: node.location.start_column
+      ),
+      parse_status: surgery.status
     )
   end
 
@@ -64,10 +66,10 @@ class Evilution::Mutator::Base < Prism::Visitor
     orig_line_end = line_end_byte(@file_source, [offset + length - 1, line_start].max)
     mut_line_end = line_end_byte(mutated_source, [offset + replacement_bytesize - 1, line_start].max)
 
-    [
-      @file_source.byteslice(line_start, orig_line_end - line_start),
-      mutated_source.byteslice(line_start, mut_line_end - line_start)
-    ]
+    AffectedSlices.new(
+      original: @file_source.byteslice(line_start, orig_line_end - line_start),
+      mutated: mutated_source.byteslice(line_start, mut_line_end - line_start)
+    )
   end
 
   def line_start_byte(source, offset)

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

@@ -12,26 +12,23 @@ class Evilution::Mutator::Operator::ArgumentNilSubstitution < Evilution::Mutator
 
   def visit_call_node(node)
     args = node.arguments&.arguments
-
-    if mutable?(node, args)
-      args.each_index do |i|
-        parts = args.each_with_index.map { |a, j| j == i ? "nil" : a.slice }
-        replacement = parts.join(", ")
-
-        add_mutation(
-          offset: node.arguments.location.start_offset,
-          length: node.arguments.location.length,
-          replacement: replacement,
-          node: node
-        )
-      end
-    end
+    args.each_index { |i| emit_nil_substitution(node, args, i) } if mutable?(node, args)
 
     super
   end
 
   private
 
+  def emit_nil_substitution(node, args, i)
+    parts = args.each_with_index.map { |a, j| j == i ? "nil" : a.slice }
+    add_mutation(
+      offset: node.arguments.location.start_offset,
+      length: node.arguments.location.length,
+      replacement: parts.join(", "),
+      node: node
+    )
+  end
+
   def mutable?(node, args)
     args && args.length >= 1 && positional_only?(args) && node.name != :[]=
   end

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

@@ -12,26 +12,23 @@ class Evilution::Mutator::Operator::ArgumentRemoval < Evilution::Mutator::Base
 
   def visit_call_node(node)
     args = node.arguments&.arguments
-
-    if mutable?(node, args)
-      args.each_index do |i|
-        remaining = args.each_with_index.filter_map { |a, j| a.slice if j != i }
-        replacement = remaining.join(", ")
-
-        add_mutation(
-          offset: node.arguments.location.start_offset,
-          length: node.arguments.location.length,
-          replacement:,
-          node:
-        )
-      end
-    end
+    args.each_index { |i| emit_argument_removal(node, args, i) } if mutable?(node, args)
 
     super
   end
 
   private
 
+  def emit_argument_removal(node, args, i)
+    remaining = args.each_with_index.filter_map { |a, j| a.slice if j != i }
+    add_mutation(
+      offset: node.arguments.location.start_offset,
+      length: node.arguments.location.length,
+      replacement: remaining.join(", "),
+      node: node
+    )
+  end
+
   def mutable?(node, args)
     args && args.length >= 2 && positional_only?(args) && node.name != :[]=
   end

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

@@ -4,18 +4,30 @@ require_relative "../operator"
 
 class Evilution::Mutator::Operator::BeginUnwrap < Evilution::Mutator::Base
   def visit_begin_node(node)
-    return super if node.rescue_clause || node.else_clause || node.ensure_clause
-    return super if node.statements.nil?
-    return super if node.begin_keyword_loc.nil?
+    return super unless unwrappable?(node)
 
-    body_text = @file_source.byteslice(node.statements.location.start_offset, node.statements.location.length)
     add_mutation(
       offset: node.location.start_offset,
       length: node.location.length,
-      replacement: body_text,
+      replacement: body_text(node),
       node: node
     )
 
     super
   end
+
+  private
+
+  def unwrappable?(node)
+    return false if node.rescue_clause || node.else_clause || node.ensure_clause
+    return false if node.statements.nil?
+    return false if node.begin_keyword_loc.nil?
+
+    true
+  end
+
+  def body_text(node)
+    loc = node.statements.location
+    @file_source.byteslice(loc.start_offset, loc.length)
+  end
 end

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

@@ -5,27 +5,34 @@ require_relative "../operator"
 class Evilution::Mutator::Operator::BitwiseComplement < Evilution::Mutator::Base
   def visit_call_node(node)
     if node.name == :~ && node.receiver && node.arguments.nil?
-      loc = node.message_loc
-      receiver_loc = node.receiver.location
-
-      # Remove ~: replace entire ~expr with just the receiver expression
-      receiver_source = byteslice_source(receiver_loc.start_offset, receiver_loc.length)
-      add_mutation(
-        offset: node.location.start_offset,
-        length: node.location.length,
-        replacement: receiver_source,
-        node: node
-      )
-
-      # Swap ~ with unary minus
-      add_mutation(
-        offset: loc.start_offset,
-        length: loc.length,
-        replacement: "-",
-        node: node
-      )
+      emit_remove_complement(node)
+      emit_swap_to_minus(node)
     end
 
     super
   end
+
+  private
+
+  # Replace `~expr` with just `expr`.
+  def emit_remove_complement(node)
+    receiver_loc = node.receiver.location
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: byteslice_source(receiver_loc.start_offset, receiver_loc.length),
+      node: node
+    )
+  end
+
+  # Swap `~` with unary minus.
+  def emit_swap_to_minus(node)
+    loc = node.message_loc
+    add_mutation(
+      offset: loc.start_offset,
+      length: loc.length,
+      replacement: "-",
+      node: node
+    )
+  end
 end

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

@@ -38,14 +38,7 @@ class Evilution::Mutator::Operator::BlockParamRemoval < Evilution::Mutator::Base
   end
 
   def remove_block_param(node)
-    block_loc = node.parameters.block.location
-    params_text = @file_source.byteslice(node.parameters.location.start_offset, node.parameters.location.length)
-    block_rel = block_loc.start_offset - node.parameters.location.start_offset
-
-    # Find the comma before the block param and remove ", &block"
-    comma_pos = params_text.rindex(",", block_rel - 1)
-    remove_start = node.parameters.location.start_offset + comma_pos
-    remove_end = block_loc.start_offset + block_loc.length
+    remove_start, remove_end = block_param_removal_range(node)
 
     add_mutation(
       offset: remove_start,
@@ -54,4 +47,21 @@ class Evilution::Mutator::Operator::BlockParamRemoval < Evilution::Mutator::Base
       node: node
     )
   end
+
+  # Range covering ", &block" — from the comma before the block param to the end of the block param.
+  def block_param_removal_range(node)
+    params_loc = node.parameters.location
+    block_loc = node.parameters.block.location
+    comma_pos = params_text(params_loc).rindex(",", block_loc.start_offset - params_loc.start_offset - 1)
+
+    [params_loc.start_offset + comma_pos, end_offset(block_loc)]
+  end
+
+  def params_text(params_loc)
+    @file_source.byteslice(params_loc.start_offset, params_loc.length)
+  end
+
+  def end_offset(loc)
+    loc.start_offset + loc.length
+  end
 end

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

@@ -4,27 +4,31 @@ require_relative "../operator"
 
 class Evilution::Mutator::Operator::BlockPassRemoval < Evilution::Mutator::Base
   def visit_call_node(node)
-    if node.block.is_a?(Prism::BlockArgumentNode)
-      block_node = node.block
-      call_start = node.location.start_offset
-      node_end = call_start + node.location.length
-      block_end = block_node.location.start_offset + block_node.location.length
-
-      prefix = @file_source.byteslice(call_start...block_node.location.start_offset).rstrip
-      suffix = @file_source.byteslice(block_end...node_end)
-
-      # Clean up: remove trailing comma from prefix, remove empty parens
-      prefix = prefix.sub(/,\s*\z/, "")
-      replacement = "#{prefix}#{suffix}".sub(/\(\s*\)/, "")
-
+    block_node = node.block
+    if block_node.is_a?(Prism::BlockArgumentNode)
       add_mutation(
-        offset: call_start,
+        offset: node.location.start_offset,
         length: node.location.length,
-        replacement: replacement,
+        replacement: build_replacement(node, block_node),
         node: node
       )
     end
 
     super
   end
+
+  private
+
+  # Drop the block-pass argument plus the trailing comma it leaves behind, and
+  # collapse the resulting `()` if the block-pass was the only argument.
+  def build_replacement(node, block_node)
+    call_start = node.location.start_offset
+    node_end = call_start + node.location.length
+    block_start = block_node.location.start_offset
+    block_end = block_start + block_node.location.length
+
+    prefix = @file_source.byteslice(call_start...block_start).rstrip.sub(/,\s*\z/, "")
+    suffix = @file_source.byteslice(block_end...node_end)
+    "#{prefix}#{suffix}".sub(/\(\s*\)/, "")
+  end
 end

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

@@ -40,16 +40,18 @@ class Evilution::Mutator::Operator::CaseWhen < Evilution::Mutator::Base
   end
 
   def remove_else_branch(node)
-    return if node.else_clause.nil?
-    return if node.else_clause.statements.nil?
+    else_clause = node.else_clause
+    return if else_clause.nil? || else_clause.statements.nil?
+
+    start_offset = else_clause.else_keyword_loc.start_offset
+    stmts_loc = else_clause.statements.location
+    end_offset = stmts_loc.start_offset + stmts_loc.length
 
-    start_offset = node.else_clause.else_keyword_loc.start_offset
-    end_offset = node.else_clause.statements.location.start_offset + node.else_clause.statements.location.length
     add_mutation(
       offset: start_offset,
       length: end_offset - start_offset,
       replacement: "",
-      node: node.else_clause
+      node: else_clause
     )
   end
 end

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

@@ -4,29 +4,29 @@ require_relative "../operator"
 
 class Evilution::Mutator::Operator::ConditionalBranch < Evilution::Mutator::Base
   def visit_if_node(node)
-    if node.statements && node.subsequent.nil?
-      add_mutation(
-        offset: node.statements.location.start_offset,
-        length: node.statements.location.length,
-        replacement: "nil",
-        node: node
-      )
-    elsif node.statements && node.subsequent&.statements
-      add_mutation(
-        offset: node.statements.location.start_offset,
-        length: node.statements.location.length,
-        replacement: "nil",
-        node: node
-      )
-
-      add_mutation(
-        offset: node.subsequent.statements.location.start_offset,
-        length: node.subsequent.statements.location.length,
-        replacement: "nil",
-        node: node
-      )
-    end
+    return super unless node.statements
+
+    add_nil_mutation(node.statements, node)
+    add_nil_mutation_to_else(node.subsequent, node)
 
     super
   end
+
+  private
+
+  def add_nil_mutation_to_else(subsequent, node)
+    return unless subsequent.is_a?(Prism::ElseNode)
+    return if subsequent.statements.nil?
+
+    add_nil_mutation(subsequent.statements, node)
+  end
+
+  def add_nil_mutation(statements, node)
+    add_mutation(
+      offset: statements.location.start_offset,
+      length: statements.location.length,
+      replacement: "nil",
+      node: node
+    )
+  end
 end

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

@@ -5,9 +5,8 @@ require_relative "../operator"
 class Evilution::Mutator::Operator::EqualityToIdentity < Evilution::Mutator::Base
   def visit_call_node(node)
     if node.name == :== && node.receiver && node.arguments
-      receiver_text = @file_source.byteslice(node.receiver.location.start_offset, node.receiver.location.length)
-      arg = node.arguments.arguments.first
-      arg_text = @file_source.byteslice(arg.location.start_offset, arg.location.length)
+      receiver_text = loc_text(node.receiver.location)
+      arg_text = loc_text(node.arguments.arguments.first.location)
 
       add_mutation(
         offset: node.location.start_offset,
@@ -19,4 +18,10 @@ class Evilution::Mutator::Operator::EqualityToIdentity < Evilution::Mutator::Bas
 
     super
   end
+
+  private
+
+  def loc_text(loc)
+    @file_source.byteslice(loc.start_offset, loc.length)
+  end
 end