evilution 0.12.0 → 0.14.0

data/lib/evilution/ast/parser.rb

@@ -2,85 +2,86 @@
 
 require "prism"
 
-module Evilution
-  module AST
-    class Parser
-      def call(file_path)
-        raise ParseError.new("file not found: #{file_path}", file: file_path) unless File.exist?(file_path)
-
-        begin
-          source = File.read(file_path)
-        rescue SystemCallError => e
-          raise ParseError.new("cannot read #{file_path}: #{e.message}", file: file_path)
-        end
-        result = Prism.parse(source)
-
-        raise ParseError.new("failed to parse #{file_path}: #{result.errors.map(&:message).join(", ")}", file: file_path) if result.failure?
-
-        extract_subjects(result.value, source, file_path)
+module Evilution::AST
+  class Parser
+    def call(file_path)
+      raise Evilution::ParseError.new("file not found: #{file_path}", file: file_path) unless File.exist?(file_path)
+
+      begin
+        source = File.read(file_path)
+      rescue SystemCallError => e
+        raise Evilution::ParseError.new("cannot read #{file_path}: #{e.message}", file: file_path)
       end
+      result = Prism.parse(source)
 
-      private
-
-      def extract_subjects(tree, source, file_path)
-        finder = SubjectFinder.new(source, file_path)
-        finder.visit(tree)
-        finder.subjects
+      if result.failure?
+        raise Evilution::ParseError.new("failed to parse #{file_path}: #{result.errors.map(&:message).join(", ")}",
+                                        file: file_path)
       end
+
+      extract_subjects(result.value, source, file_path)
     end
 
-    class SubjectFinder < Prism::Visitor
-      attr_reader :subjects
+    private
 
-      def initialize(source, file_path)
-        @source = source
-        @file_path = file_path
-        @subjects = []
-        @context = []
-      end
+    def extract_subjects(tree, source, file_path)
+      finder = SubjectFinder.new(source, file_path)
+      finder.visit(tree)
+      finder.subjects
+    end
+  end
 
-      def visit_module_node(node)
-        @context.push(constant_name(node.constant_path))
-        super
-        @context.pop
-      end
+  class SubjectFinder < Prism::Visitor
+    attr_reader :subjects
 
-      def visit_class_node(node)
-        @context.push(constant_name(node.constant_path))
-        super
-        @context.pop
-      end
+    def initialize(source, file_path)
+      @source = source
+      @file_path = file_path
+      @subjects = []
+      @context = []
+    end
 
-      def visit_def_node(node)
-        scope = @context.join("::")
-        name = if scope.empty?
-                 "##{node.name}"
-               else
-                 "#{scope}##{node.name}"
-               end
-
-        loc = node.location
-        method_source = @source[loc.start_offset...loc.end_offset]
-
-        @subjects << Subject.new(
-          name: name,
-          file_path: @file_path,
-          line_number: loc.start_line,
-          source: method_source,
-          node: node
-        )
-
-        super
-      end
+    def visit_module_node(node)
+      @context.push(constant_name(node.constant_path))
+      super
+      @context.pop
+    end
+
+    def visit_class_node(node)
+      @context.push(constant_name(node.constant_path))
+      super
+      @context.pop
+    end
+
+    def visit_def_node(node)
+      scope = @context.join("::")
+      name = if scope.empty?
+               "##{node.name}"
+             else
+               "#{scope}##{node.name}"
+             end
+
+      loc = node.location
+      method_source = @source[loc.start_offset...loc.end_offset]
+
+      @subjects << Evilution::Subject.new(
+        name: name,
+        file_path: @file_path,
+        line_number: loc.start_line,
+        source: method_source,
+        node: node
+      )
+
+      super
+    end
 
-      private
+    private
 
-      def constant_name(node)
-        if node.respond_to?(:full_name)
-          node.full_name
-        else
-          node.name.to_s
-        end
+    def constant_name(node)
+      if node.respond_to?(:full_name)
+        node.full_name
+      else
+        node.name.to_s
       end
     end
   end

data/lib/evilution/ast/source_surgeon.rb

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 
-module Evilution
-  module AST
-    module SourceSurgeon
-      def self.apply(source, offset:, length:, replacement:)
-        result = source.dup
-        result[offset, length] = replacement
-        result
-      end
-    end
+require_relative "../ast"
+
+module Evilution::AST::SourceSurgeon
+  def self.apply(source, offset:, length:, replacement:)
+    result = source.dup
+    result[offset, length] = replacement
+    result
   end
 end

data/lib/evilution/ast.rb

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

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