evilution 0.16.1 → 0.18.0

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::PatternMatchingArray < Evilution::Mutator::Base
+  def visit_array_pattern_node(node)
+    mutate_array_elements(node)
+    super
+  end
+
+  def visit_find_pattern_node(node)
+    mutate_find_elements(node)
+    super
+  end
+
+  private
+
+  def mutate_array_elements(node)
+    requireds = node.requireds
+    posts = node.posts
+    rest = node.rest
+    elements = requireds + posts
+    return if elements.empty?
+
+    elements.each_with_index do |_element, index|
+      remove_array_element(node, requireds, posts, rest, index) if elements.length > 1
+      wildcard_array_element(node, requireds, posts, rest, index)
+    end
+  end
+
+  def remove_array_element(node, requireds, posts, rest, skip_index)
+    parts = build_array_parts(requireds, posts, rest, skip_index: skip_index)
+    replace_pattern(node, parts)
+  end
+
+  def wildcard_array_element(node, requireds, posts, rest, wildcard_index)
+    parts = build_array_parts(requireds, posts, rest, wildcard_index: wildcard_index)
+    replace_pattern(node, parts)
+  end
+
+  def build_array_parts(requireds, posts, rest, skip_index: nil, wildcard_index: nil)
+    parts = []
+    requireds.each_with_index do |req, i|
+      next if i == skip_index
+
+      parts << (i == wildcard_index ? "_" : source_for(req))
+    end
+    parts << source_for(rest) if rest
+    posts.each_with_index do |post, i|
+      adjusted = requireds.length + i
+      next if adjusted == skip_index
+
+      parts << (adjusted == wildcard_index ? "_" : source_for(post))
+    end
+    parts
+  end
+
+  def mutate_find_elements(node)
+    return if node.requireds.empty?
+
+    node.requireds.each_with_index do |_element, index|
+      remove_find_element(node, index) if node.requireds.length > 1
+      wildcard_find_element(node, index)
+    end
+  end
+
+  def remove_find_element(node, skip_index)
+    parts = [source_for(node.left)]
+    node.requireds.each_with_index do |req, i|
+      parts << source_for(req) unless i == skip_index
+    end
+    parts << source_for(node.right)
+    replace_pattern(node, parts)
+  end
+
+  def wildcard_find_element(node, wildcard_index)
+    parts = [source_for(node.left)]
+    node.requireds.each_with_index do |req, i|
+      parts << (i == wildcard_index ? "_" : source_for(req))
+    end
+    parts << source_for(node.right)
+    replace_pattern(node, parts)
+  end
+
+  def replace_pattern(node, parts)
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: "[#{parts.join(", ")}]",
+      node: node
+    )
+  end
+
+  def source_for(node)
+    @file_source.byteslice(node.location.start_offset, node.location.length)
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::PatternMatchingGuard < Evilution::Mutator::Base
+  def visit_in_node(node)
+    pattern = node.pattern
+    mutate_guard(pattern, node) if guarded?(pattern)
+    super
+  end
+
+  private
+
+  def guarded?(pattern)
+    pattern.is_a?(Prism::IfNode) || pattern.is_a?(Prism::UnlessNode)
+  end
+
+  def mutate_guard(pattern, in_node)
+    guard_start = pattern.statements.location.start_offset + pattern.statements.location.length
+    guard_end = pattern.predicate.location.start_offset + pattern.predicate.location.length
+
+    remove_guard(guard_start, guard_end, in_node)
+    negate_guard(pattern, in_node)
+  end
+
+  def remove_guard(guard_start, guard_end, in_node)
+    add_mutation(
+      offset: guard_start,
+      length: guard_end - guard_start,
+      replacement: "",
+      node: in_node
+    )
+  end
+
+  def negate_guard(pattern, in_node)
+    pred_loc = pattern.predicate.location
+    add_mutation(
+      offset: pred_loc.start_offset,
+      length: pred_loc.length,
+      replacement: "!(#{@file_source.byteslice(pred_loc.start_offset, pred_loc.length)})",
+      node: in_node
+    )
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::RegexCapture < Evilution::Mutator::Base
+  def visit_numbered_reference_read_node(node)
+    mutate_replace_with_nil(node)
+    mutate_swap_number(node)
+
+    super
+  end
+
+  private
+
+  def mutate_replace_with_nil(node)
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: "nil",
+      node: node
+    )
+  end
+
+  def mutate_swap_number(node)
+    number = node.number
+
+    if number > 1
+      add_mutation(
+        offset: node.location.start_offset,
+        length: node.location.length,
+        replacement: "$#{number - 1}",
+        node: node
+      )
+    end
+
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: "$#{number + 1}",
+      node: node
+    )
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::ScalarReturn < 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 = scalar_replacement(return_node)
+
+      if replacement
+        add_mutation(
+          offset: body.location.start_offset,
+          length: body.location.length,
+          replacement: replacement,
+          node: node
+        )
+      end
+    end
+
+    super
+  end
+
+  private
+
+  def scalar_replacement(node)
+    case node
+    when Prism::StringNode
+      '""' unless node.content.empty?
+    when Prism::IntegerNode
+      "0" unless node.value.zero?
+    when Prism::FloatNode
+      "0.0" unless node.value.zero?
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::SplatOperator < Evilution::Mutator::Base
+  def visit_splat_node(node)
+    mutate_remove_splat(node) if node.expression
+
+    super
+  end
+
+  def visit_hash_node(node)
+    node.elements.each { |el| hash_elements.add(el) }
+    super
+  end
+
+  def visit_assoc_splat_node(node)
+    mutate_remove_double_splat(node) if node.value && !hash_elements.include?(node)
+
+    super
+  end
+
+  private
+
+  def hash_elements
+    @hash_elements ||= Set.new.compare_by_identity
+  end
+
+  def mutate_remove_splat(node)
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: node.expression.slice,
+      node: node
+    )
+  end
+
+  def mutate_remove_double_splat(node)
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: node.value.slice,
+      node: node
+    )
+  end
+end

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

@@ -5,10 +5,11 @@ require "prism"
 require_relative "../operator"
 
 class Evilution::Mutator::Operator::SuperclassRemoval < Evilution::Mutator::Base
-  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_class(tree, subject.line_number)

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::YieldStatement < Evilution::Mutator::Base
+  def visit_yield_node(node)
+    mutate_remove_yield(node)
+
+    if node.arguments
+      mutate_remove_arguments(node)
+      mutate_replace_value_with_nil(node)
+    end
+
+    super
+  end
+
+  private
+
+  def mutate_remove_yield(node)
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: "nil",
+      node: node
+    )
+  end
+
+  def mutate_remove_arguments(node)
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: "yield",
+      node: node
+    )
+  end
+
+  def mutate_replace_value_with_nil(node)
+    replacement = if node.lparen_loc
+                    "yield(nil)"
+                  else
+                    "yield nil"
+                  end
+
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: replacement,
+      node: node
+    )
+  end
+end

data/lib/evilution/mutator/registry.rb

@@ -51,7 +51,21 @@ class Evilution::Mutator::Registry
       Evilution::Mutator::Operator::BitwiseReplacement,
       Evilution::Mutator::Operator::BitwiseComplement,
       Evilution::Mutator::Operator::ZsuperRemoval,
-      Evilution::Mutator::Operator::ExplicitSuperMutation
+      Evilution::Mutator::Operator::ExplicitSuperMutation,
+      Evilution::Mutator::Operator::IndexToFetch,
+      Evilution::Mutator::Operator::IndexToDig,
+      Evilution::Mutator::Operator::IndexAssignmentRemoval,
+      Evilution::Mutator::Operator::PatternMatchingGuard,
+      Evilution::Mutator::Operator::PatternMatchingAlternative,
+      Evilution::Mutator::Operator::PatternMatchingArray,
+      Evilution::Mutator::Operator::CollectionReturn,
+      Evilution::Mutator::Operator::ScalarReturn,
+      Evilution::Mutator::Operator::KeywordArgument,
+      Evilution::Mutator::Operator::MultipleAssignment,
+      Evilution::Mutator::Operator::YieldStatement,
+      Evilution::Mutator::Operator::SplatOperator,
+      Evilution::Mutator::Operator::DefinedCheck,
+      Evilution::Mutator::Operator::RegexCapture
     ].each { |op| registry.register(op) }
     registry
   end
@@ -65,9 +79,9 @@ class Evilution::Mutator::Registry
     self
   end
 
-  def mutations_for(subject)
+  def mutations_for(subject, filter: nil)
     @operators.flat_map do |operator_class|
-      operator_class.new.call(subject)
+      operator_class.new.call(subject, filter: filter)
     end
   end
 

data/lib/evilution/parallel/pool.rb

@@ -1,61 +1,17 @@
 # frozen_string_literal: true
 
-require_relative "../parallel"
+require_relative "work_queue"
 
 class Evilution::Parallel::Pool
-  def initialize(size:)
-    raise ArgumentError, "pool size must be a positive integer, got #{size.inspect}" unless size.is_a?(Integer) && size >= 1
-
-    @size = size
+  def initialize(size:, hooks: nil)
+    @queue = Evilution::Parallel::WorkQueue.new(size: size, hooks: hooks)
   end
 
-  def map(items, &block)
-    results = []
-
-    items.each_slice(@size) do |batch|
-      results.concat(run_batch(batch, &block))
-    end
-
-    results
+  def map(items, &)
+    @queue.map(items, &)
   end
 
-  private
-
-  def run_batch(items, &block)
-    entries = items.map do |item|
-      read_io, write_io = IO.pipe
-      pid = fork_worker(item, read_io, write_io, &block)
-      write_io.close
-      { pid: pid, read_io: read_io }
-    end
-
-    collect_results(entries)
-  end
-
-  def fork_worker(item, read_io, write_io, &block)
-    Process.fork do
-      read_io.close
-      result = block.call(item)
-      Marshal.dump(result, write_io)
-    rescue Exception => e # rubocop:disable Lint/RescueException
-      Marshal.dump(e, write_io)
-    ensure
-      write_io.close
-      exit!
-    end
-  end
-
-  def collect_results(entries)
-    entries.map do |entry|
-      data = entry[:read_io].read
-      entry[:read_io].close
-      Process.wait(entry[:pid])
-      raise Evilution::Error, "worker process failed with no result" if data.empty?
-
-      result = Marshal.load(data) # rubocop:disable Security/MarshalLoad
-      raise result if result.is_a?(Exception)
-
-      result
-    end
+  def worker_stats
+    @queue.worker_stats
   end
 end

data/lib/evilution/parallel/work_queue.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require_relative "../parallel"
+
+class Evilution::Parallel::WorkQueue
+  SHUTDOWN = :__shutdown__
+
+  STATS = :__stats__
+
+  WorkerStat = Struct.new(:pid, :items_completed, :busy_time, :wall_time) do
+    def idle_time
+      wall_time - busy_time
+    end
+
+    def utilization
+      return 0.0 if wall_time.nil? || wall_time.zero?
+
+      busy_time / wall_time
+    end
+  end
+
+  def initialize(size:, hooks: nil, prefetch: 1)
+    raise ArgumentError, "pool size must be a positive integer, got #{size.inspect}" unless size.is_a?(Integer) && size >= 1
+    raise ArgumentError, "prefetch must be a positive integer, got #{prefetch.inspect}" unless prefetch.is_a?(Integer) && prefetch >= 1
+
+    @size = size
+    @hooks = hooks
+    @prefetch = prefetch
+    @worker_stats = []
+  end
+
+  def map(items, &)
+    return [] if items.empty?
+
+    worker_count = [@size, items.length].min
+    workers = spawn_workers(worker_count, &)
+
+    begin
+      distribute_and_collect(items, workers)
+    ensure
+      shutdown_workers(workers)
+      @worker_stats = build_worker_stats(workers)
+    end
+  end
+
+  def worker_stats
+    @worker_stats.map { |stat| stat.dup.freeze }
+  end
+
+  private
+
+  def spawn_workers(count, &)
+    count.times.map do
+      cmd_read, cmd_write = IO.pipe
+      res_read, res_write = IO.pipe
+
+      pid = Process.fork do
+        cmd_write.close
+        res_read.close
+        worker_loop(cmd_read, res_write, &)
+      end
+
+      cmd_read.close
+      res_write.close
+
+      { pid: pid, cmd_write: cmd_write, res_read: res_read, items_completed: 0 }
+    end
+  end
+
+  def worker_loop(cmd_read, res_write, &block)
+    @hooks.fire(:worker_process_start) if @hooks
+    start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    busy_time = 0.0
+
+    loop do
+      data = read_command(cmd_read)
+      break if data == SHUTDOWN
+
+      index, item = data
+      begin
+        t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        result = block.call(item)
+        busy_time += Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
+        write_message(res_write, [index, :ok, result])
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        busy_time += Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
+        write_message(res_write, [index, :error, e])
+      end
+    end
+
+    wall_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+    write_message(res_write, [STATS, busy_time, wall_time])
+  ensure
+    cmd_read.close
+    res_write.close
+    exit!
+  end
+
+  def distribute_and_collect(items, workers)
+    state = CollectionState.new(items.length)
+    seed_workers(items, workers, state)
+    collect_results(items, workers, state)
+    raise state.first_error if state.first_error
+
+    state.results
+  end
+
+  def seed_workers(items, workers, state)
+    @prefetch.times do
+      workers.each do |worker|
+        break unless state.next_index < items.length
+
+        send_item(worker, items, state)
+      end
+    end
+  end
+
+  def collect_results(items, workers, state)
+    io_to_worker = workers.to_h { |w| [w[:res_read], w] }
+    result_ios = io_to_worker.keys
+
+    while state.in_flight.positive?
+      readable, = IO.select(result_ios)
+      readable.each { |io| handle_result(io, io_to_worker[io], items, state) }
+    end
+  end
+
+  def handle_result(io, worker, items, state)
+    message = read_result(io)
+
+    if message.nil?
+      state.first_error = Evilution::Error.new("worker process exited unexpectedly") if state.first_error.nil?
+      state.in_flight -= 1
+      return
+    end
+
+    index, status, value = message
+    state.first_error = value if status == :error && state.first_error.nil?
+    state.results[index] = value if status == :ok
+    state.in_flight -= 1
+    worker[:items_completed] += 1
+
+    send_item(worker, items, state) if state.next_index < items.length && state.first_error.nil?
+  end
+
+  def send_item(worker, items, state)
+    write_message(worker[:cmd_write], [state.next_index, items[state.next_index]])
+    state.next_index += 1
+    state.in_flight += 1
+  end
+
+  def build_worker_stats(workers)
+    workers.map do |worker|
+      WorkerStat.new(worker[:pid], worker[:items_completed], worker[:busy_time] || 0.0, worker[:wall_time] || 0.0)
+    end
+  end
+
+  def shutdown_workers(workers)
+    workers.each do |worker|
+      write_message(worker[:cmd_write], SHUTDOWN)
+    rescue Errno::EPIPE
+      # Worker already exited
+    end
+
+    collect_worker_timing(workers)
+
+    workers.each do |worker|
+      worker[:cmd_write].close unless worker[:cmd_write].closed?
+      worker[:res_read].close unless worker[:res_read].closed?
+      Process.wait(worker[:pid])
+    rescue Errno::ECHILD
+      # Already reaped
+    end
+  end
+
+  def collect_worker_timing(workers)
+    workers.each do |worker|
+      message = read_result(worker[:res_read])
+      next if message.nil?
+
+      tag, busy_time, wall_time = message
+      next unless tag == STATS
+
+      worker[:busy_time] = busy_time
+      worker[:wall_time] = wall_time
+    end
+  end
+
+  def write_message(io, data)
+    payload = Marshal.dump(data)
+    io.write([payload.bytesize].pack("N"))
+    io.write(payload)
+    io.flush
+  end
+
+  def read_command(io)
+    header = io.read(4)
+    return SHUTDOWN if header.nil? || header.bytesize < 4
+
+    length = header.unpack1("N")
+    payload = io.read(length)
+    return SHUTDOWN if payload.nil? || payload.bytesize < length
+
+    Marshal.load(payload) # rubocop:disable Security/MarshalLoad
+  end
+
+  def read_result(io)
+    header = io.read(4)
+    return nil if header.nil? || header.bytesize < 4
+
+    length = header.unpack1("N")
+    payload = io.read(length)
+    return nil if payload.nil? || payload.bytesize < length
+
+    Marshal.load(payload) # rubocop:disable Security/MarshalLoad
+  end
+
+  CollectionState = Struct.new(:results, :in_flight, :next_index, :first_error) do
+    def initialize(item_count)
+      super(Array.new(item_count), 0, 0, nil)
+    end
+  end
+  private_constant :CollectionState
+end