evilution 0.13.0 → 0.15.0

data/lib/evilution/equivalent.rb

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

data/lib/evilution/git/changed_files.rb

@@ -2,53 +2,51 @@
 
 require "English"
 
-module Evilution
-  module Git
-    class ChangedFiles
-      MAIN_BRANCHES = %w[main master origin/main origin/master].freeze
-      SOURCE_PREFIXES = %w[lib/ app/].freeze
+require_relative "../git"
 
-      def call
-        main_branch = detect_main_branch
-        merge_base = run_git("merge-base", "HEAD", main_branch)
-        diff_output = run_git("diff", "--name-only", "--diff-filter=ACMR", "#{merge_base}..HEAD")
+class Evilution::Git::ChangedFiles
+  MAIN_BRANCHES = %w[main master origin/main origin/master].freeze
+  SOURCE_PREFIXES = %w[lib/ app/].freeze
 
-        files = diff_output.split("\n").select { |f| ruby_source_file?(f) }
-        raise Error, "no changed Ruby files found since merge base with #{main_branch}" if files.empty?
+  def call
+    main_branch = detect_main_branch
+    merge_base = run_git("merge-base", "HEAD", main_branch)
+    diff_output = run_git("diff", "--name-only", "--diff-filter=ACMR", "#{merge_base}..HEAD")
 
-        files
-      end
+    files = diff_output.split("\n").select { |f| ruby_source_file?(f) }
+    raise Evilution::Error, "no changed Ruby files found since merge base with #{main_branch}" if files.empty?
 
-      private
+    files
+  end
 
-      def detect_main_branch
-        MAIN_BRANCHES.each do |branch|
-          return branch if branch_exists?(branch)
-        end
+  private
 
-        raise Error, "could not detect main branch (tried #{MAIN_BRANCHES.join(", ")})"
-      end
+  def detect_main_branch
+    MAIN_BRANCHES.each do |branch|
+      return branch if branch_exists?(branch)
+    end
 
-      def branch_exists?(name)
-        run_git("rev-parse", "--verify", name)
-        true
-      rescue Error => e
-        raise if e.message.include?("not a git repository")
+    raise Evilution::Error, "could not detect main branch (tried #{MAIN_BRANCHES.join(", ")})"
+  end
 
-        false
-      end
+  def branch_exists?(name)
+    run_git("rev-parse", "--verify", name)
+    true
+  rescue Evilution::Error => e
+    raise if e.message.include?("not a git repository")
 
-      def ruby_source_file?(path)
-        path.end_with?(".rb") && SOURCE_PREFIXES.any? { |prefix| path.start_with?(prefix) }
-      end
+    false
+  end
 
-      def run_git(*args)
-        output = `git #{args.join(" ")} 2>&1`.strip
-        raise Error, "not a git repository" if output.include?("not a git repository")
-        raise Error, "git command failed: git #{args.join(" ")}: #{output}" unless $CHILD_STATUS.success?
+  def ruby_source_file?(path)
+    path.end_with?(".rb") && SOURCE_PREFIXES.any? { |prefix| path.start_with?(prefix) }
+  end
 
-        output
-      end
-    end
+  def run_git(*args)
+    output = `git #{args.join(" ")} 2>&1`.strip
+    raise Evilution::Error, "not a git repository" if output.include?("not a git repository")
+    raise Evilution::Error, "git command failed: git #{args.join(" ")}: #{output}" unless $CHILD_STATUS.success?
+
+    output
   end
 end

data/lib/evilution/git.rb

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

data/lib/evilution/integration/base.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
-module Evilution
-  module Integration
-    class Base
-      def call(mutation)
-        raise NotImplementedError, "#{self.class}#call must be implemented"
-      end
-    end
+require_relative "../integration"
+
+class Evilution::Integration::Base
+  def call(mutation)
+    raise NotImplementedError, "#{self.class}#call must be implemented"
   end
 end

data/lib/evilution/integration/rspec.rb

@@ -6,122 +6,120 @@ require "tmpdir"
 require_relative "base"
 require_relative "../spec_resolver"
 
-module Evilution
-  module Integration
-    class RSpec < Base
-      def initialize(test_files: nil)
-        @test_files = test_files
-        @rspec_loaded = false
-        super()
-      end
-
-      def call(mutation)
-        @original_content = nil
-        @temp_dir = nil
-        @lock_file = nil
-        ensure_rspec_loaded
-        apply_mutation(mutation)
-        run_rspec(mutation)
-      ensure
-        restore_original(mutation)
-      end
-
-      private
-
-      attr_reader :test_files
-
-      def ensure_rspec_loaded
-        return if @rspec_loaded
-
-        require "rspec/core"
-        @rspec_loaded = true
-      rescue LoadError => e
-        raise Evilution::Error, "rspec-core is required but not available: #{e.message}"
-      end
-
-      def apply_mutation(mutation)
-        subpath = resolve_require_subpath(mutation.file_path)
-
-        if subpath
-          @temp_dir = Dir.mktmpdir("evilution")
-          dest = File.join(@temp_dir, subpath)
-          FileUtils.mkdir_p(File.dirname(dest))
-          File.write(dest, mutation.mutated_source)
-          $LOAD_PATH.unshift(@temp_dir)
-        else
-          # Fallback: direct write when file isn't under any $LOAD_PATH entry.
-          # Acquire an exclusive lock to prevent concurrent workers from corrupting the file.
-          lock_path = File.join(Dir.tmpdir, "evilution-#{File.expand_path(mutation.file_path).hash.abs}.lock")
-          @lock_file = File.open(lock_path, File::CREAT | File::RDWR) # rubocop:disable Style/FileOpen
-          @lock_file.flock(File::LOCK_EX)
-          @original_content = File.read(mutation.file_path)
-          File.write(mutation.file_path, mutation.mutated_source)
-        end
-      end
-
-      def restore_original(mutation)
-        if @temp_dir
-          $LOAD_PATH.delete(@temp_dir)
-          $LOADED_FEATURES.reject! { |f| f.start_with?(@temp_dir) }
-          FileUtils.rm_rf(@temp_dir)
-          @temp_dir = nil
-        elsif @original_content
-          File.write(mutation.file_path, @original_content)
-          @lock_file&.flock(File::LOCK_UN)
-          @lock_file&.close
-          @lock_file = nil
-        end
-      end
-
-      def resolve_require_subpath(file_path)
-        absolute = File.expand_path(file_path)
-
-        $LOAD_PATH.each do |entry|
-          dir = File.expand_path(entry)
-          prefix = dir.end_with?("/") ? dir : "#{dir}/"
-          next unless absolute.start_with?(prefix)
-
-          return absolute.delete_prefix(prefix)
-        end
-
-        nil
-      end
-
-      def run_rspec(mutation)
-        # When used via the Runner with Isolation::Fork, each mutation is executed
-        # in its own forked child process, so RSpec state (loaded example groups,
-        # world, configuration) cannot accumulate across mutation runs — the child
-        # process exits after each run.
-        #
-        # This integration can also be invoked directly (e.g. in specs or alternative
-        # runners) without fork isolation. RSpec.reset is called here as
-        # defense-in-depth to clear RSpec state between mutation runs in those cases.
-        ::RSpec.reset
-
-        out = StringIO.new
-        err = StringIO.new
-        command = "rspec"
-        args = build_args(mutation)
-        command = "rspec #{args.join(" ")}"
-
-        status = ::RSpec::Core::Runner.run(args, out, err)
-
-        { passed: status.zero?, test_command: command }
-      rescue StandardError => e
-        { passed: false, error: e.message, test_command: command }
-      end
-
-      def build_args(mutation)
-        files = resolve_test_files(mutation)
-        ["--format", "progress", "--no-color", "--order", "defined", *files]
-      end
-
-      def resolve_test_files(mutation)
-        return test_files if test_files
-
-        resolved = SpecResolver.new.call(mutation.file_path)
-        resolved ? [resolved] : ["spec"]
-      end
+require_relative "../integration"
+
+class Evilution::Integration::RSpec < Evilution::Integration::Base
+  def initialize(test_files: nil)
+    @test_files = test_files
+    @rspec_loaded = false
+    super()
+  end
+
+  def call(mutation)
+    @original_content = nil
+    @temp_dir = nil
+    @lock_file = nil
+    ensure_rspec_loaded
+    apply_mutation(mutation)
+    run_rspec(mutation)
+  ensure
+    restore_original(mutation)
+  end
+
+  private
+
+  attr_reader :test_files
+
+  def ensure_rspec_loaded
+    return if @rspec_loaded
+
+    require "rspec/core"
+    @rspec_loaded = true
+  rescue LoadError => e
+    raise Evilution::Error, "rspec-core is required but not available: #{e.message}"
+  end
+
+  def apply_mutation(mutation)
+    subpath = resolve_require_subpath(mutation.file_path)
+
+    if subpath
+      @temp_dir = Dir.mktmpdir("evilution")
+      dest = File.join(@temp_dir, subpath)
+      FileUtils.mkdir_p(File.dirname(dest))
+      File.write(dest, mutation.mutated_source)
+      $LOAD_PATH.unshift(@temp_dir)
+    else
+      # Fallback: direct write when file isn't under any $LOAD_PATH entry.
+      # Acquire an exclusive lock to prevent concurrent workers from corrupting the file.
+      lock_path = File.join(Dir.tmpdir, "evilution-#{File.expand_path(mutation.file_path).hash.abs}.lock")
+      @lock_file = File.open(lock_path, File::CREAT | File::RDWR)
+      @lock_file.flock(File::LOCK_EX)
+      @original_content = File.read(mutation.file_path)
+      File.write(mutation.file_path, mutation.mutated_source)
+    end
+  end
+
+  def restore_original(mutation)
+    if @temp_dir
+      $LOAD_PATH.delete(@temp_dir)
+      $LOADED_FEATURES.reject! { |f| f.start_with?(@temp_dir) }
+      FileUtils.rm_rf(@temp_dir)
+      @temp_dir = nil
+    elsif @original_content
+      File.write(mutation.file_path, @original_content)
+      @lock_file&.flock(File::LOCK_UN)
+      @lock_file&.close
+      @lock_file = nil
     end
   end
+
+  def resolve_require_subpath(file_path)
+    absolute = File.expand_path(file_path)
+
+    $LOAD_PATH.each do |entry|
+      dir = File.expand_path(entry)
+      prefix = dir.end_with?("/") ? dir : "#{dir}/"
+      next unless absolute.start_with?(prefix)
+
+      return absolute.delete_prefix(prefix)
+    end
+
+    nil
+  end
+
+  def run_rspec(mutation)
+    # When used via the Runner with Isolation::Fork, each mutation is executed
+    # in its own forked child process, so RSpec state (loaded example groups,
+    # world, configuration) cannot accumulate across mutation runs — the child
+    # process exits after each run.
+    #
+    # This integration can also be invoked directly (e.g. in specs or alternative
+    # runners) without fork isolation. RSpec.reset is called here as
+    # defense-in-depth to clear RSpec state between mutation runs in those cases.
+    ::RSpec.reset
+
+    out = StringIO.new
+    err = StringIO.new
+    command = "rspec"
+    args = build_args(mutation)
+    command = "rspec #{args.join(" ")}"
+
+    status = ::RSpec::Core::Runner.run(args, out, err)
+
+    { passed: status.zero?, test_command: command }
+  rescue StandardError => e
+    { passed: false, error: e.message, test_command: command }
+  end
+
+  def build_args(mutation)
+    files = resolve_test_files(mutation)
+    ["--format", "progress", "--no-color", "--order", "defined", *files]
+  end
+
+  def resolve_test_files(mutation)
+    return test_files if test_files
+
+    resolved = Evilution::SpecResolver.new.call(mutation.file_path)
+    resolved ? [resolved] : ["spec"]
+  end
 end

data/lib/evilution/integration.rb

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

data/lib/evilution/isolation/fork.rb

@@ -4,106 +4,104 @@ require "fileutils"
 require "tmpdir"
 require_relative "../memory"
 
-module Evilution
-  module Isolation
-    class Fork
-      GRACE_PERIOD = 2
-
-      def call(mutation:, test_command:, timeout:)
-        sandbox_dir = Dir.mktmpdir("evilution-run")
-        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        read_io, write_io = IO.pipe
-
-        pid = ::Process.fork do
-          ENV["TMPDIR"] = sandbox_dir
-          read_io.close
-          suppress_child_output
-          result = execute_in_child(mutation, test_command)
-          Marshal.dump(result, write_io)
-          write_io.close
-          exit!(result[:passed] ? 0 : 1)
-        end
-
-        write_io.close
-        result = wait_for_result(pid, read_io, timeout)
-        duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
-
-        build_mutation_result(mutation, result, duration)
-      ensure
-        read_io&.close
-        write_io&.close
-        restore_original_source(mutation)
-        FileUtils.rm_rf(sandbox_dir) if sandbox_dir
-      end
-
-      private
-
-      def restore_original_source(mutation)
-        return if File.read(mutation.file_path) == mutation.original_source
-
-        File.write(mutation.file_path, mutation.original_source)
-      rescue StandardError => e
-        warn("Warning: failed to restore #{mutation.file_path}: #{e.message}")
-      end
-
-      def suppress_child_output
-        $stdout.reopen(File::NULL, "w")
-        $stderr.reopen(File::NULL, "w")
-      end
-
-      def execute_in_child(mutation, test_command)
-        result = test_command.call(mutation)
-        { child_rss_kb: Memory.rss_kb }.merge(result)
-      rescue StandardError => e
-        { passed: false, error: e.message }
-      end
-
-      def wait_for_result(pid, read_io, timeout)
-        if read_io.wait_readable(timeout)
-          data = read_io.read
-          ::Process.wait(pid)
-          return { timeout: false }.merge(Marshal.load(data)) unless data.empty? # rubocop:disable Security/MarshalLoad
-
-          ::Process.wait(pid) rescue nil # rubocop:disable Style/RescueModifier
-          { timeout: false, passed: false, error: "empty result from child" }
-        else
-          terminate_child(pid)
-          { timeout: true }
-        end
-      end
-
-      def terminate_child(pid)
-        ::Process.kill("TERM", pid) rescue nil # rubocop:disable Style/RescueModifier
-        _, status = ::Process.waitpid2(pid, ::Process::WNOHANG)
-        return if status
-
-        sleep(GRACE_PERIOD)
-        _, status = ::Process.waitpid2(pid, ::Process::WNOHANG)
-        return if status
-
-        ::Process.kill("KILL", pid) rescue nil # rubocop:disable Style/RescueModifier
-        ::Process.wait(pid) rescue nil # rubocop:disable Style/RescueModifier
-      end
-
-      def build_mutation_result(mutation, result, duration)
-        status = if result[:timeout]
-                   :timeout
-                 elsif result[:error]
-                   :error
-                 elsif result[:passed]
-                   :survived
-                 else
-                   :killed
-                 end
-
-        Result::MutationResult.new(
-          mutation: mutation,
-          status: status,
-          duration: duration,
-          test_command: result[:test_command],
-          child_rss_kb: result[:child_rss_kb]
-        )
-      end
+require_relative "../isolation"
+
+class Evilution::Isolation::Fork
+  GRACE_PERIOD = 2
+
+  def call(mutation:, test_command:, timeout:)
+    sandbox_dir = Dir.mktmpdir("evilution-run")
+    start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    read_io, write_io = IO.pipe
+
+    pid = ::Process.fork do
+      ENV["TMPDIR"] = sandbox_dir
+      read_io.close
+      suppress_child_output
+      result = execute_in_child(mutation, test_command)
+      Marshal.dump(result, write_io)
+      write_io.close
+      exit!(result[:passed] ? 0 : 1)
     end
+
+    write_io.close
+    result = wait_for_result(pid, read_io, timeout)
+    duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+
+    build_mutation_result(mutation, result, duration)
+  ensure
+    read_io&.close
+    write_io&.close
+    restore_original_source(mutation)
+    FileUtils.rm_rf(sandbox_dir) if sandbox_dir
+  end
+
+  private
+
+  def restore_original_source(mutation)
+    return if File.read(mutation.file_path) == mutation.original_source
+
+    File.write(mutation.file_path, mutation.original_source)
+  rescue StandardError => e
+    warn("Warning: failed to restore #{mutation.file_path}: #{e.message}")
+  end
+
+  def suppress_child_output
+    $stdout.reopen(File::NULL, "w")
+    $stderr.reopen(File::NULL, "w")
+  end
+
+  def execute_in_child(mutation, test_command)
+    result = test_command.call(mutation)
+    { child_rss_kb: Evilution::Memory.rss_kb }.merge(result)
+  rescue StandardError => e
+    { passed: false, error: e.message }
+  end
+
+  def wait_for_result(pid, read_io, timeout)
+    if read_io.wait_readable(timeout)
+      data = read_io.read
+      ::Process.wait(pid)
+      return { timeout: false }.merge(Marshal.load(data)) unless data.empty? # rubocop:disable Security/MarshalLoad
+
+      ::Process.wait(pid) rescue nil # rubocop:disable Style/RescueModifier
+      { timeout: false, passed: false, error: "empty result from child" }
+    else
+      terminate_child(pid)
+      { timeout: true }
+    end
+  end
+
+  def terminate_child(pid)
+    ::Process.kill("TERM", pid) rescue nil # rubocop:disable Style/RescueModifier
+    _, status = ::Process.waitpid2(pid, ::Process::WNOHANG)
+    return if status
+
+    sleep(GRACE_PERIOD)
+    _, status = ::Process.waitpid2(pid, ::Process::WNOHANG)
+    return if status
+
+    ::Process.kill("KILL", pid) rescue nil # rubocop:disable Style/RescueModifier
+    ::Process.wait(pid) rescue nil # rubocop:disable Style/RescueModifier
+  end
+
+  def build_mutation_result(mutation, result, duration)
+    status = if result[:timeout]
+               :timeout
+             elsif result[:error]
+               :error
+             elsif result[:passed]
+               :survived
+             else
+               :killed
+             end
+
+    Evilution::Result::MutationResult.new(
+      mutation: mutation,
+      status: status,
+      duration: duration,
+      test_command: result[:test_command],
+      child_rss_kb: result[:child_rss_kb]
+    )
   end
 end