evilution 0.13.0 → 0.15.0

data/lib/evilution/mutator/registry.rb

@@ -1,65 +1,65 @@
 # frozen_string_literal: true
 
-module Evilution
-  module Mutator
-    class Registry
-      def self.default
-        registry = new
-        [
-          Operator::ComparisonReplacement,
-          Operator::ArithmeticReplacement,
-          Operator::BooleanOperatorReplacement,
-          Operator::BooleanLiteralReplacement,
-          Operator::NilReplacement,
-          Operator::IntegerLiteral,
-          Operator::FloatLiteral,
-          Operator::StringLiteral,
-          Operator::ArrayLiteral,
-          Operator::HashLiteral,
-          Operator::SymbolLiteral,
-          Operator::ConditionalNegation,
-          Operator::ConditionalBranch,
-          Operator::StatementDeletion,
-          Operator::MethodBodyReplacement,
-          Operator::NegationInsertion,
-          Operator::ReturnValueRemoval,
-          Operator::CollectionReplacement,
-          Operator::MethodCallRemoval,
-          Operator::ArgumentRemoval,
-          Operator::BlockRemoval,
-          Operator::ConditionalFlip,
-          Operator::RangeReplacement,
-          Operator::RegexpMutation,
-          Operator::ReceiverReplacement,
-          Operator::SendMutation,
-          Operator::ArgumentNilSubstitution,
-          Operator::CompoundAssignment
-        ].each { |op| registry.register(op) }
-        registry
-      end
+require_relative "../mutator"
 
-      def initialize
-        @operators = []
-      end
-
-      def register(operator_class)
-        @operators << operator_class
-        self
-      end
+class Evilution::Mutator::Registry
+  def self.default
+    registry = new
+    [
+      Evilution::Mutator::Operator::ComparisonReplacement,
+      Evilution::Mutator::Operator::ArithmeticReplacement,
+      Evilution::Mutator::Operator::BooleanOperatorReplacement,
+      Evilution::Mutator::Operator::BooleanLiteralReplacement,
+      Evilution::Mutator::Operator::NilReplacement,
+      Evilution::Mutator::Operator::IntegerLiteral,
+      Evilution::Mutator::Operator::FloatLiteral,
+      Evilution::Mutator::Operator::StringLiteral,
+      Evilution::Mutator::Operator::ArrayLiteral,
+      Evilution::Mutator::Operator::HashLiteral,
+      Evilution::Mutator::Operator::SymbolLiteral,
+      Evilution::Mutator::Operator::ConditionalNegation,
+      Evilution::Mutator::Operator::ConditionalBranch,
+      Evilution::Mutator::Operator::StatementDeletion,
+      Evilution::Mutator::Operator::MethodBodyReplacement,
+      Evilution::Mutator::Operator::NegationInsertion,
+      Evilution::Mutator::Operator::ReturnValueRemoval,
+      Evilution::Mutator::Operator::CollectionReplacement,
+      Evilution::Mutator::Operator::MethodCallRemoval,
+      Evilution::Mutator::Operator::ArgumentRemoval,
+      Evilution::Mutator::Operator::BlockRemoval,
+      Evilution::Mutator::Operator::ConditionalFlip,
+      Evilution::Mutator::Operator::RangeReplacement,
+      Evilution::Mutator::Operator::RegexpMutation,
+      Evilution::Mutator::Operator::ReceiverReplacement,
+      Evilution::Mutator::Operator::SendMutation,
+      Evilution::Mutator::Operator::ArgumentNilSubstitution,
+      Evilution::Mutator::Operator::CompoundAssignment,
+      Evilution::Mutator::Operator::MixinRemoval,
+      Evilution::Mutator::Operator::SuperclassRemoval
+    ].each { |op| registry.register(op) }
+    registry
+  end
 
-      def mutations_for(subject)
-        @operators.flat_map do |operator_class|
-          operator_class.new.call(subject)
-        end
-      end
+  def initialize
+    @operators = []
+  end
 
-      def operator_count
-        @operators.length
-      end
+  def register(operator_class)
+    @operators << operator_class
+    self
+  end
 
-      def operators
-        @operators.dup
-      end
+  def mutations_for(subject)
+    @operators.flat_map do |operator_class|
+      operator_class.new.call(subject)
     end
   end
+
+  def operator_count
+    @operators.length
+  end
+
+  def operators
+    @operators.dup
+  end
 end

data/lib/evilution/mutator.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module Evilution::Mutator
+end

data/lib/evilution/parallel/pool.rb

@@ -1,63 +1,61 @@
 # frozen_string_literal: true
 
-module Evilution
-  module Parallel
-    class 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
-      end
-
-      def map(items, &block)
-        results = []
-
-        items.each_slice(@size) do |batch|
-          results.concat(run_batch(batch, &block))
-        end
-
-        results
-      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
-      end
+require_relative "../parallel"
+
+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
+  end
+
+  def map(items, &block)
+    results = []
+
+    items.each_slice(@size) do |batch|
+      results.concat(run_batch(batch, &block))
+    end
+
+    results
+  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
   end
 end

data/lib/evilution/parallel.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module Evilution::Parallel
+end

data/lib/evilution/reporter/cli.rb

@@ -1,105 +1,103 @@
 # frozen_string_literal: true
 
-module Evilution
-  module Reporter
-    class CLI
-      SEPARATOR = "=" * 44
-
-      def call(summary)
-        lines = []
-        lines << header
-        lines << SEPARATOR
-        lines << ""
-        lines << mutations_line(summary)
-        lines << score_line(summary)
-        lines << duration_line(summary)
-        peak = summary.peak_memory_mb
-        lines << peak_memory_line(peak) if peak
-        append_survived(lines, summary)
-        append_neutral(lines, summary)
-        append_equivalent(lines, summary)
-        lines << ""
-        lines << "[TRUNCATED] Stopped early due to --fail-fast" if summary.truncated?
-        lines << result_line(summary)
-
-        lines.join("\n")
-      end
-
-      private
-
-      def append_survived(lines, summary)
-        return unless summary.survived_results.any?
-
-        lines << ""
-        lines << "Survived mutations:"
-        summary.survived_results.each { |result| lines << format_survived(result) }
-      end
-
-      def append_neutral(lines, summary)
-        return unless summary.neutral_results.any?
-
-        lines << ""
-        lines << "Neutral mutations (test already failing):"
-        summary.neutral_results.each { |result| lines << format_neutral(result) }
-      end
-
-      def append_equivalent(lines, summary)
-        return unless summary.equivalent_results.any?
-
-        lines << ""
-        lines << "Equivalent mutations (provably identical behavior):"
-        summary.equivalent_results.each { |result| lines << format_neutral(result) }
-      end
-
-      def header
-        "Evilution v#{Evilution::VERSION} — Mutation Testing Results"
-      end
-
-      def mutations_line(summary)
-        parts = "Mutations: #{summary.total} total, #{summary.killed} killed, " \
-                "#{summary.survived} survived, #{summary.timed_out} timed out"
-        parts += ", #{summary.neutral} neutral" if summary.neutral.positive?
-        parts += ", #{summary.equivalent} equivalent" if summary.equivalent.positive?
-        parts
-      end
-
-      def score_line(summary)
-        denominator = summary.total - summary.errors - summary.neutral - summary.equivalent
-        score_pct = format_pct(summary.score)
-        "Score: #{score_pct} (#{summary.killed}/#{denominator})"
-      end
-
-      def duration_line(summary)
-        "Duration: #{format("%.2f", summary.duration)}s"
-      end
-
-      def format_survived(result)
-        mutation = result.mutation
-        location = "#{mutation.file_path}:#{mutation.line}"
-        diff_lines = mutation.diff.split("\n").map { |l| "    #{l}" }.join("\n")
-        "  #{mutation.operator_name}: #{location}\n#{diff_lines}"
-      end
-
-      def format_neutral(result)
-        mutation = result.mutation
-        "  #{mutation.operator_name}: #{mutation.file_path}:#{mutation.line}"
-      end
-
-      def result_line(summary)
-        min_score = 0.8
-        pass_fail = summary.success?(min_score: min_score) ? "PASS" : "FAIL"
-        score_pct = format_pct(summary.score)
-        threshold_pct = format_pct(min_score)
-        "Result: #{pass_fail} (score #{score_pct} #{pass_fail == "PASS" ? ">=" : "<"} #{threshold_pct})"
-      end
-
-      def peak_memory_line(peak_mb)
-        format("Peak memory: %<mb>.1f MB", mb: peak_mb)
-      end
-
-      def format_pct(value)
-        format("%.2f%%", value * 100)
-      end
-    end
+require_relative "../reporter"
+
+class Evilution::Reporter::CLI
+  SEPARATOR = "=" * 44
+
+  def call(summary)
+    lines = []
+    lines << header
+    lines << SEPARATOR
+    lines << ""
+    lines << mutations_line(summary)
+    lines << score_line(summary)
+    lines << duration_line(summary)
+    peak = summary.peak_memory_mb
+    lines << peak_memory_line(peak) if peak
+    append_survived(lines, summary)
+    append_neutral(lines, summary)
+    append_equivalent(lines, summary)
+    lines << ""
+    lines << "[TRUNCATED] Stopped early due to --fail-fast" if summary.truncated?
+    lines << result_line(summary)
+
+    lines.join("\n")
+  end
+
+  private
+
+  def append_survived(lines, summary)
+    return unless summary.survived_results.any?
+
+    lines << ""
+    lines << "Survived mutations:"
+    summary.survived_results.each { |result| lines << format_survived(result) }
+  end
+
+  def append_neutral(lines, summary)
+    return unless summary.neutral_results.any?
+
+    lines << ""
+    lines << "Neutral mutations (test already failing):"
+    summary.neutral_results.each { |result| lines << format_neutral(result) }
+  end
+
+  def append_equivalent(lines, summary)
+    return unless summary.equivalent_results.any?
+
+    lines << ""
+    lines << "Equivalent mutations (provably identical behavior):"
+    summary.equivalent_results.each { |result| lines << format_neutral(result) }
+  end
+
+  def header
+    "Evilution v#{Evilution::VERSION} — Mutation Testing Results"
+  end
+
+  def mutations_line(summary)
+    parts = "Mutations: #{summary.total} total, #{summary.killed} killed, " \
+            "#{summary.survived} survived, #{summary.timed_out} timed out"
+    parts += ", #{summary.neutral} neutral" if summary.neutral.positive?
+    parts += ", #{summary.equivalent} equivalent" if summary.equivalent.positive?
+    parts
+  end
+
+  def score_line(summary)
+    denominator = summary.total - summary.errors - summary.neutral - summary.equivalent
+    score_pct = format_pct(summary.score)
+    "Score: #{score_pct} (#{summary.killed}/#{denominator})"
+  end
+
+  def duration_line(summary)
+    "Duration: #{format("%.2f", summary.duration)}s"
+  end
+
+  def format_survived(result)
+    mutation = result.mutation
+    location = "#{mutation.file_path}:#{mutation.line}"
+    diff_lines = mutation.diff.split("\n").map { |l| "    #{l}" }.join("\n")
+    "  #{mutation.operator_name}: #{location}\n#{diff_lines}"
+  end
+
+  def format_neutral(result)
+    mutation = result.mutation
+    "  #{mutation.operator_name}: #{mutation.file_path}:#{mutation.line}"
+  end
+
+  def result_line(summary)
+    min_score = 0.8
+    pass_fail = summary.success?(min_score: min_score) ? "PASS" : "FAIL"
+    score_pct = format_pct(summary.score)
+    threshold_pct = format_pct(min_score)
+    "Result: #{pass_fail} (score #{score_pct} #{pass_fail == "PASS" ? ">=" : "<"} #{threshold_pct})"
+  end
+
+  def peak_memory_line(peak_mb)
+    format("Peak memory: %<mb>.1f MB", mb: peak_mb)
+  end
+
+  def format_pct(value)
+    format("%.2f%%", value * 100)
   end
 end