evilution 0.15.0 → 0.16.1

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::ExplicitSuperMutation < Evilution::Mutator::Base
+  def visit_super_node(node)
+    replace_with_zsuper(node)
+    args = node.arguments&.arguments
+    mutate_arguments(node, args) if args && !args.empty?
+
+    super
+  end
+
+  private
+
+  def replace_with_zsuper(node)
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: "super",
+      node: node
+    )
+  end
+
+  def mutate_arguments(node, args)
+    # Remove all arguments: super(a, b) -> super()
+    add_mutation(
+      offset: node.arguments.location.start_offset,
+      length: node.arguments.location.length,
+      replacement: "",
+      node: node
+    )
+
+    return unless args.length >= 2
+
+    # Remove individual arguments
+    args.each_index do |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
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::GlobalVariableWrite < Evilution::Mutator::Base
+  def visit_global_variable_write_node(node)
+    # Mutation 1: remove assignment, keep only the value expression
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: node.value.slice,
+      node: node
+    )
+
+    # Mutation 2: replace value with nil
+    add_mutation(
+      offset: node.value.location.start_offset,
+      length: node.value.location.length,
+      replacement: "nil",
+      node: node
+    )
+
+    super
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::InlineRescue < Evilution::Mutator::Base
+  def visit_rescue_modifier_node(node)
+    generate_rescue_removal(node)
+    generate_nil_fallback(node)
+
+    super
+  end
+
+  private
+
+  def generate_rescue_removal(node)
+    expr_end = node.expression.location.start_offset + node.expression.location.length
+    rescue_end = node.rescue_expression.location.start_offset + node.rescue_expression.location.length
+
+    add_mutation(
+      offset: expr_end,
+      length: rescue_end - expr_end,
+      replacement: "",
+      node: node
+    )
+  end
+
+  def generate_nil_fallback(node)
+    return if node.rescue_expression.is_a?(Prism::NilNode)
+
+    fallback_loc = node.rescue_expression.location
+
+    add_mutation(
+      offset: fallback_loc.start_offset,
+      length: fallback_loc.length,
+      replacement: "nil",
+      node: node
+    )
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::InstanceVariableWrite < Evilution::Mutator::Base
+  def visit_instance_variable_write_node(node)
+    # Mutation 1: remove assignment, keep only the value expression
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: node.value.slice,
+      node: node
+    )
+
+    # Mutation 2: replace value with nil
+    add_mutation(
+      offset: node.value.location.start_offset,
+      length: node.value.location.length,
+      replacement: "nil",
+      node: node
+    )
+
+    super
+  end
+end

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

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

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::NextStatement < Evilution::Mutator::Base
+  def visit_next_node(node)
+    generate_removal(node)
+    generate_nil_value(node)
+    generate_break_swap(node)
+
+    super
+  end
+
+  private
+
+  def generate_removal(node)
+    loc = node.location
+
+    add_mutation(
+      offset: loc.start_offset,
+      length: loc.length,
+      replacement: "nil",
+      node: node
+    )
+  end
+
+  def generate_nil_value(node)
+    return if node.arguments.nil?
+
+    args_loc = node.arguments.location
+
+    add_mutation(
+      offset: args_loc.start_offset,
+      length: args_loc.length,
+      replacement: "nil",
+      node: node
+    )
+  end
+
+  def generate_break_swap(node)
+    keyword_loc = node.keyword_loc
+
+    add_mutation(
+      offset: keyword_loc.start_offset,
+      length: keyword_loc.length,
+      replacement: "break",
+      node: node
+    )
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::RedoStatement < Evilution::Mutator::Base
+  def visit_redo_node(node)
+    loc = node.location
+
+    add_mutation(
+      offset: loc.start_offset,
+      length: loc.length,
+      replacement: "nil",
+      node: node
+    )
+
+    super
+  end
+end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::RescueBodyReplacement < Evilution::Mutator::Base
+  def visit_rescue_node(node)
+    generate_nil_replacement(node)
+    generate_raise_replacement(node)
+
+    super
+  end
+
+  private
+
+  def generate_nil_replacement(node)
+    return if node.statements.nil?
+
+    body_loc = node.statements.location
+    indent = " " * indentation_of(body_loc.start_offset)
+
+    add_mutation(
+      offset: body_loc.start_offset,
+      length: body_loc.length,
+      replacement: "#{indent}nil".lstrip,
+      node: node
+    )
+  end
+
+  def generate_raise_replacement(node)
+    return if bare_raise?(node)
+
+    if node.statements.nil?
+      insert_raise_into_empty(node)
+    else
+      replace_body_with_raise(node)
+    end
+  end
+
+  def replace_body_with_raise(node)
+    body_loc = node.statements.location
+    indent = " " * indentation_of(body_loc.start_offset)
+
+    add_mutation(
+      offset: body_loc.start_offset,
+      length: body_loc.length,
+      replacement: "#{indent}raise".lstrip,
+      node: node
+    )
+  end
+
+  def insert_raise_into_empty(node)
+    insert_offset = rescue_line_end(node)
+    indent = " " * (indentation_of(node.keyword_loc.start_offset) + 2)
+
+    add_mutation(
+      offset: insert_offset,
+      length: 0,
+      replacement: "\n#{indent}raise",
+      node: node
+    )
+  end
+
+  def bare_raise?(node)
+    return false if node.statements.nil?
+
+    body = node.statements.body
+    body.length == 1 &&
+      body.first.is_a?(Prism::CallNode) &&
+      body.first.name == :raise &&
+      body.first.arguments.nil? &&
+      body.first.receiver.nil?
+  end
+
+  def rescue_line_end(node)
+    if node.reference
+      node.reference.location.start_offset + node.reference.location.length
+    elsif node.exceptions.any?
+      last_exc = node.exceptions.last
+      last_exc.location.start_offset + last_exc.location.length
+    else
+      node.keyword_loc.start_offset + node.keyword_loc.length
+    end
+  end
+
+  def indentation_of(offset)
+    pos = offset - 1
+    col = 0
+    while pos >= 0 && @file_source[pos] != "\n"
+      col += 1
+      pos -= 1
+    end
+    col
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::RescueRemoval < Evilution::Mutator::Base
+  def visit_rescue_node(node)
+    remove_start = line_start_before(node.keyword_loc.start_offset)
+    remove_end = rescue_end_offset(node)
+
+    add_mutation(
+      offset: remove_start,
+      length: remove_end - remove_start,
+      replacement: "",
+      node: node
+    )
+
+    super
+  end
+
+  private
+
+  def rescue_end_offset(node)
+    if node.subsequent
+      line_start_before(node.subsequent.keyword_loc.start_offset)
+    elsif node.statements
+      node.statements.location.start_offset + node.statements.location.length
+    else
+      node.keyword_loc.start_offset + node.keyword_loc.length
+    end
+  end
+
+  def line_start_before(offset)
+    pos = offset - 1
+    pos -= 1 while pos.positive? && @file_source[pos] != "\n"
+    pos
+  end
+end

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

@@ -14,13 +14,22 @@ class Evilution::Mutator::Operator::SendMutation < Evilution::Mutator::Base
     detect: [:find],
     find: [:detect],
     each_with_object: [:inject],
-    inject: [:each_with_object],
+    inject: %i[each_with_object sum],
     reverse_each: [:each],
     each: [:reverse_each],
     length: [:size],
     size: [:length],
     values_at: [:fetch_values],
-    fetch_values: [:values_at]
+    fetch_values: [:values_at],
+    sum: [:inject],
+    count: [:size],
+    select: [:filter],
+    filter: [:select],
+    to_s: [:to_i],
+    to_i: [:to_s],
+    to_f: [:to_i],
+    to_a: [:to_h],
+    to_h: [:to_a]
   }.freeze
 
   def visit_call_node(node)

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

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

data/lib/evilution/mutator/registry.rb

@@ -35,7 +35,23 @@ class Evilution::Mutator::Registry
       Evilution::Mutator::Operator::ArgumentNilSubstitution,
       Evilution::Mutator::Operator::CompoundAssignment,
       Evilution::Mutator::Operator::MixinRemoval,
-      Evilution::Mutator::Operator::SuperclassRemoval
+      Evilution::Mutator::Operator::SuperclassRemoval,
+      Evilution::Mutator::Operator::LocalVariableAssignment,
+      Evilution::Mutator::Operator::InstanceVariableWrite,
+      Evilution::Mutator::Operator::ClassVariableWrite,
+      Evilution::Mutator::Operator::GlobalVariableWrite,
+      Evilution::Mutator::Operator::RescueRemoval,
+      Evilution::Mutator::Operator::RescueBodyReplacement,
+      Evilution::Mutator::Operator::InlineRescue,
+      Evilution::Mutator::Operator::EnsureRemoval,
+      Evilution::Mutator::Operator::BreakStatement,
+      Evilution::Mutator::Operator::NextStatement,
+      Evilution::Mutator::Operator::RedoStatement,
+      Evilution::Mutator::Operator::BangMethod,
+      Evilution::Mutator::Operator::BitwiseReplacement,
+      Evilution::Mutator::Operator::BitwiseComplement,
+      Evilution::Mutator::Operator::ZsuperRemoval,
+      Evilution::Mutator::Operator::ExplicitSuperMutation
     ].each { |op| registry.register(op) }
     registry
   end

data/lib/evilution/reporter/progress_bar.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative "../reporter"
+
+class Evilution::Reporter::ProgressBar
+  attr_reader :total, :width, :completed, :killed, :survived
+
+  def initialize(total:, output: $stdout, width: 30)
+    @total = total
+    @output = output
+    @width = width
+    @completed = 0
+    @killed = 0
+    @survived = 0
+    @tty = self.class.tty?(output)
+    @start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+
+  def tick(status:)
+    @completed += 1
+    @killed += 1 if status == :killed
+    @survived += 1 if status == :survived
+    render
+  end
+
+  def render
+    line = "#{bar_string} #{stats_string} | #{time_string}"
+    if @tty
+      @output.print("\r#{line}")
+    else
+      @output.puts(line)
+    end
+  end
+
+  def finish
+    render
+    @output.print("\n") if @tty
+  end
+
+  def self.tty?(io)
+    io.respond_to?(:tty?) && io.tty?
+  end
+
+  private
+
+  def bar_string
+    fraction = @total.positive? ? @completed.to_f / @total : 0
+    raw_filled = (fraction * @width).to_i
+    filled = raw_filled.clamp(0, @width)
+
+    interior = if filled <= 0
+                 " " * @width
+               elsif filled >= @width
+                 "#{"=" * (@width - 1)}>"
+               else
+                 "#{"=" * (filled - 1)}>#{" " * (@width - filled)}"
+               end
+
+    "[#{interior}]"
+  end
+
+  def stats_string
+    "#{@completed}/#{@total} mutations | #{@killed} killed | #{@survived} survived"
+  end
+
+  def time_string
+    elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - @start_time
+    remaining = estimate_remaining(elapsed)
+    "#{format_time(elapsed)} elapsed | ~#{format_time(remaining)} remaining"
+  end
+
+  def estimate_remaining(elapsed)
+    return 0 unless @completed.positive?
+
+    remaining = (@total - @completed) * (elapsed / @completed)
+    [remaining, 0].max
+  end
+
+  def format_time(seconds)
+    mins = (seconds / 60).to_i
+    secs = (seconds % 60).to_i
+    format("%<mins>02d:%<secs>02d", mins: mins, secs: secs)
+  end
+end