evilution 0.13.0 → 0.15.0

data/lib/evilution/baseline.rb

@@ -2,99 +2,97 @@
 
 require_relative "spec_resolver"
 
-module Evilution
-  class Baseline
-    Result = Struct.new(:failed_spec_files, :duration) do
-      def initialize(**)
-        super
-        freeze
-      end
-
-      def failed?
-        !failed_spec_files.empty?
-      end
+class Evilution::Baseline
+  Result = Struct.new(:failed_spec_files, :duration) do
+    def initialize(**)
+      super
+      freeze
     end
 
-    def initialize(spec_resolver: SpecResolver.new, timeout: 30)
-      @spec_resolver = spec_resolver
-      @timeout = timeout
+    def failed?
+      !failed_spec_files.empty?
     end
+  end
 
-    def call(subjects)
-      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      spec_files = resolve_unique_spec_files(subjects)
-      failed = Set.new
+  def initialize(spec_resolver: Evilution::SpecResolver.new, timeout: 30)
+    @spec_resolver = spec_resolver
+    @timeout = timeout
+  end
 
-      spec_files.each do |spec_file|
-        failed.add(spec_file) unless run_spec_file(spec_file)
-      end
+  def call(subjects)
+    start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    spec_files = resolve_unique_spec_files(subjects)
+    failed = Set.new
 
-      duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
-      Result.new(failed_spec_files: failed, duration: duration)
+    spec_files.each do |spec_file|
+      failed.add(spec_file) unless run_spec_file(spec_file)
     end
 
-    def run_spec_file(spec_file)
-      read_io, write_io = IO.pipe
-      pid = fork_spec_runner(spec_file, read_io, write_io)
-      write_io.close
-      read_result(read_io, pid)
-    rescue StandardError
-      false
-    ensure
-      read_io&.close
-      write_io&.close
-    end
+    duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+    Result.new(failed_spec_files: failed, duration: duration)
+  end
+
+  def run_spec_file(spec_file)
+    read_io, write_io = IO.pipe
+    pid = fork_spec_runner(spec_file, read_io, write_io)
+    write_io.close
+    read_result(read_io, pid)
+  rescue StandardError
+    false
+  ensure
+    read_io&.close
+    write_io&.close
+  end
 
-    def fork_spec_runner(spec_file, read_io, write_io)
-      Process.fork do
-        read_io.close
-        $stdout.reopen(File::NULL, "w")
-        $stderr.reopen(File::NULL, "w")
-
-        require "rspec/core"
-        ::RSpec.reset
-        status = ::RSpec::Core::Runner.run(
-          ["--format", "progress", "--no-color", "--order", "defined", spec_file]
-        )
-        Marshal.dump({ passed: status.zero? }, write_io)
-        write_io.close
-        exit!(status.zero? ? 0 : 1)
-      end
+  def fork_spec_runner(spec_file, read_io, write_io)
+    Process.fork do
+      read_io.close
+      $stdout.reopen(File::NULL, "w")
+      $stderr.reopen(File::NULL, "w")
+
+      require "rspec/core"
+      RSpec.reset
+      status = RSpec::Core::Runner.run(
+        ["--format", "progress", "--no-color", "--order", "defined", spec_file]
+      )
+      Marshal.dump({ passed: status.zero? }, write_io)
+      write_io.close
+      exit!(status.zero? ? 0 : 1)
     end
+  end
 
-    GRACE_PERIOD = 0.5
+  GRACE_PERIOD = 0.5
 
-    def read_result(read_io, pid)
-      if read_io.wait_readable(@timeout)
-        data = read_io.read
-        Process.wait(pid)
-        return false if data.empty?
+  def read_result(read_io, pid)
+    if read_io.wait_readable(@timeout)
+      data = read_io.read
+      Process.wait(pid)
+      return false if data.empty?
 
-        result = Marshal.load(data) # rubocop:disable Security/MarshalLoad
-        result[:passed]
-      else
-        terminate_child(pid)
-        false
-      end
+      result = Marshal.load(data) # rubocop:disable Security/MarshalLoad
+      result[:passed]
+    else
+      terminate_child(pid)
+      false
     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
+  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
+    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
+    Process.kill("KILL", pid) rescue nil # rubocop:disable Style/RescueModifier
+    Process.wait(pid) rescue nil # rubocop:disable Style/RescueModifier
+  end
 
-    private
+  private
 
-    def resolve_unique_spec_files(subjects)
-      subjects.map { |s| @spec_resolver.call(s.file_path) || "spec" }.uniq
-    end
+  def resolve_unique_spec_files(subjects)
+    subjects.map { |s| @spec_resolver.call(s.file_path) || "spec" }.uniq
   end
 end

data/lib/evilution/cache.rb

@@ -4,82 +4,80 @@ require "digest"
 require "json"
 require "fileutils"
 
-module Evilution
-  class Cache
-    DEFAULT_DIR = "tmp/evilution_cache"
-
-    def initialize(cache_dir: DEFAULT_DIR)
-      @cache_dir = cache_dir
-    end
-
-    def fetch(mutation)
-      return nil if mutation.original_source.nil?
-
-      file_key = file_key(mutation)
-      entry_key = entry_key(mutation)
-      data = read_file(file_key)
-      return nil unless data
-
-      entry = data[entry_key]
-      return nil unless entry.is_a?(Hash) && entry["status"].is_a?(String)
-
-      { status: entry["status"].to_sym, duration: entry["duration"],
-        killing_test: entry["killing_test"], test_command: entry["test_command"] }
-    end
-
-    def store(mutation, result_data)
-      file_key = file_key(mutation)
-      entry_key = entry_key(mutation)
-      data = read_file(file_key) || {}
-
-      data[entry_key] = {
-        "status" => result_data[:status].to_s,
-        "duration" => result_data[:duration],
-        "killing_test" => result_data[:killing_test],
-        "test_command" => result_data[:test_command]
-      }
-
-      write_file(file_key, data)
-    end
-
-    def clear
-      FileUtils.rm_rf(@cache_dir)
-    end
-
-    private
-
-    def file_key(mutation)
-      content_hash = Digest::SHA256.hexdigest(mutation.original_source)
-      "#{safe_filename(mutation.file_path)}_#{content_hash[0, 16]}"
-    end
-
-    def entry_key(mutation)
-      "#{mutation.operator_name}:#{mutation.line}:#{mutation.column}"
-    end
-
-    def safe_filename(path)
-      path.gsub(%r{[/\\]}, "_").gsub(/[^a-zA-Z0-9._-]/, "")
-    end
-
-    def read_file(file_key)
-      path = cache_path(file_key)
-      return nil unless File.exist?(path)
-
-      JSON.parse(File.read(path))
-    rescue JSON::ParserError
-      nil
-    end
-
-    def write_file(file_key, data)
-      FileUtils.mkdir_p(@cache_dir)
-      path = cache_path(file_key)
-      tmp = "#{path}.#{Process.pid}.tmp"
-      File.write(tmp, JSON.generate(data))
-      File.rename(tmp, path)
-    end
-
-    def cache_path(file_key)
-      File.join(@cache_dir, "#{file_key}.json")
-    end
+class Evilution::Cache
+  DEFAULT_DIR = "tmp/evilution_cache"
+
+  def initialize(cache_dir: DEFAULT_DIR)
+    @cache_dir = cache_dir
+  end
+
+  def fetch(mutation)
+    return nil if mutation.original_source.nil?
+
+    file_key = file_key(mutation)
+    entry_key = entry_key(mutation)
+    data = read_file(file_key)
+    return nil unless data
+
+    entry = data[entry_key]
+    return nil unless entry.is_a?(Hash) && entry["status"].is_a?(String)
+
+    { status: entry["status"].to_sym, duration: entry["duration"],
+      killing_test: entry["killing_test"], test_command: entry["test_command"] }
+  end
+
+  def store(mutation, result_data)
+    file_key = file_key(mutation)
+    entry_key = entry_key(mutation)
+    data = read_file(file_key) || {}
+
+    data[entry_key] = {
+      "status" => result_data[:status].to_s,
+      "duration" => result_data[:duration],
+      "killing_test" => result_data[:killing_test],
+      "test_command" => result_data[:test_command]
+    }
+
+    write_file(file_key, data)
+  end
+
+  def clear
+    FileUtils.rm_rf(@cache_dir)
+  end
+
+  private
+
+  def file_key(mutation)
+    content_hash = Digest::SHA256.hexdigest(mutation.original_source)
+    "#{safe_filename(mutation.file_path)}_#{content_hash[0, 16]}"
+  end
+
+  def entry_key(mutation)
+    "#{mutation.operator_name}:#{mutation.line}:#{mutation.column}"
+  end
+
+  def safe_filename(path)
+    path.gsub(%r{[/\\]}, "_").gsub(/[^a-zA-Z0-9._-]/, "")
+  end
+
+  def read_file(file_key)
+    path = cache_path(file_key)
+    return nil unless File.exist?(path)
+
+    JSON.parse(File.read(path))
+  rescue JSON::ParserError
+    nil
+  end
+
+  def write_file(file_key, data)
+    FileUtils.mkdir_p(@cache_dir)
+    path = cache_path(file_key)
+    tmp = "#{path}.#{Process.pid}.tmp"
+    File.write(tmp, JSON.generate(data))
+    File.rename(tmp, path)
+  end
+
+  def cache_path(file_key)
+    File.join(@cache_dir, "#{file_key}.json")
   end
 end