evilution 0.26.0 → 0.28.0

data/lib/evilution/compare/line_normalizer.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "../compare"
+
+# Collapses whitespace runs in source-code text while preserving the contents
+# of "..." and '...' string literals. Used for fingerprinting mutation diffs
+# so that whitespace-only differences do not cause false fingerprint mismatches
+# across tooling (evilution vs mutant).
+#
+# v1 limitation: only " and ' literals are preserved. Regex literals (/.../),
+# heredocs, %w[], %q{} forms are treated as ordinary code — whitespace runs
+# inside them collapse. A mutation touching whitespace inside a regex may
+# false-match across tools.
+class Evilution::Compare::LineNormalizer
+  QUOTES = ['"', "'"].freeze
+  WHITESPACE = [" ", "\t"].freeze
+  private_constant :QUOTES, :WHITESPACE
+
+  def call(line)
+    @chars = line.chars
+    @i = 0
+    @out = +""
+    @in_literal = nil
+    @last_was_space = false
+
+    @i += step while @i < @chars.length
+    result = @out.rstrip
+    @chars = nil
+    @out = nil
+    result
+  end
+
+  private
+
+  def step
+    ch = @chars[@i]
+    return step_in_literal(ch) if @in_literal
+    return step_open_quote(ch) if QUOTES.include?(ch)
+    return step_whitespace if WHITESPACE.include?(ch)
+
+    append_regular(ch)
+  end
+
+  def step_in_literal(ch)
+    @out << ch
+    if ch == "\\" && @i + 1 < @chars.length
+      @out << @chars[@i + 1]
+      return 2
+    end
+    @in_literal = nil if ch == @in_literal
+    1
+  end
+
+  def step_open_quote(ch)
+    @in_literal = ch
+    @out << ch
+    @last_was_space = false
+    1
+  end
+
+  def step_whitespace
+    @out << " " unless @last_was_space || @out.empty?
+    @last_was_space = true
+    1
+  end
+
+  def append_regular(ch)
+    @out << ch
+    @last_was_space = false
+    1
+  end
+end

data/lib/evilution/compare/normalizer.rb

@@ -3,6 +3,9 @@
 require_relative "../compare"
 require_relative "record"
 require_relative "fingerprint"
+require_relative "line_normalizer"
+require_relative "diff_extractor/evilution"
+require_relative "diff_extractor/mutant"
 
 class Evilution::Compare::Normalizer
   EVILUTION_BUCKETS = %w[killed survived timed_out errors neutral equivalent unresolved unparseable].freeze
@@ -17,6 +20,18 @@ class Evilution::Compare::Normalizer
     "unparseable" => :unparseable
   }.freeze
 
+  def initialize
+    line_normalizer = Evilution::Compare::LineNormalizer.new
+    @evilution_fingerprint = Evilution::Compare::Fingerprint.new(
+      extractor: Evilution::Compare::DiffExtractor::Evilution.new,
+      normalizer: line_normalizer
+    )
+    @mutant_fingerprint = Evilution::Compare::Fingerprint.new(
+      extractor: Evilution::Compare::DiffExtractor::Mutant.new,
+      normalizer: line_normalizer
+    )
+  end
+
   def from_evilution(json)
     records = []
     EVILUTION_BUCKETS.each do |bucket|
@@ -47,13 +62,12 @@ class Evilution::Compare::Normalizer
     diff = entry["diff"].to_s
     status = EVILUTION_STATUS_MAP[entry["status"]] ||
              raise(Evilution::Compare::InvalidInput.new("unknown status #{entry["status"].inspect}", index: index))
-    body = Evilution::Compare::Fingerprint.extract_from_evilution_diff(diff)
     Evilution::Compare::Record.new(
       source: :evilution,
       file_path: file_path,
       line: line,
       status: status,
-      fingerprint: Evilution::Compare::Fingerprint.compute(file_path: file_path, line: line, body: body),
+      fingerprint: @evilution_fingerprint.call(diff: diff, file_path: file_path, line: line),
       operator: entry["operator"],
       diff_body: diff,
       raw: entry
@@ -67,13 +81,12 @@ class Evilution::Compare::Normalizer
     line = parse_mutant_line(ident, index)
     diff = mr["mutation_diff"].to_s
     status = derive_mutant_status(mr, cr, index)
-    body = Evilution::Compare::Fingerprint.extract_from_mutant_diff(diff)
     Evilution::Compare::Record.new(
       source: :mutant,
       file_path: source_path,
       line: line,
       status: status,
-      fingerprint: Evilution::Compare::Fingerprint.compute(file_path: source_path, line: line, body: body),
+      fingerprint: @mutant_fingerprint.call(diff: diff, file_path: source_path, line: line),
       operator: nil,
       diff_body: diff,
       raw: { "mutation_result" => mr, "criteria_result" => cr, "source_path" => source_path }

data/lib/evilution/config/builders/spec_resolver.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "../builders"
+require_relative "../../spec_resolver"
+
+class Evilution::Config::Builders::SpecResolver
+  def self.call(integration:)
+    case integration
+    when :minitest
+      Evilution::SpecResolver.new(test_dir: "test", test_suffix: "_test.rb", request_dir: "integration")
+    else
+      Evilution::SpecResolver.new
+    end
+  end
+end

data/lib/evilution/config/builders/spec_selector.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "../builders"
+require_relative "spec_resolver"
+require_relative "../../spec_selector"
+
+class Evilution::Config::Builders::SpecSelector
+  def self.call(spec_files:, spec_mappings:, spec_pattern:, integration:)
+    Evilution::SpecSelector.new(
+      spec_files: spec_files,
+      spec_mappings: spec_mappings,
+      spec_pattern: spec_pattern,
+      spec_resolver: Evilution::Config::Builders::SpecResolver.call(integration: integration)
+    )
+  end
+end

data/lib/evilution/config/builders.rb

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

data/lib/evilution/config/env_loader.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Evilution::Config::EnvLoader
+  module_function
+
+  def load
+    opts = {}
+    val = ENV.fetch("EV_DISABLE_EXAMPLE_TARGETING", nil)
+    opts[:example_targeting] = false if val && !val.empty? && val != "0"
+    opts
+  end
+end

data/lib/evilution/config/file_loader.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Evilution::Config::FileLoader
+  module_function
+
+  def load
+    Evilution::Config::CONFIG_FILES.each do |path|
+      next unless File.exist?(path)
+
+      data = YAML.safe_load_file(path, symbolize_names: true)
+      return data.is_a?(Hash) ? data : {}
+    rescue Psych::SyntaxError, Psych::DisallowedClass => e
+      raise Evilution::ConfigError.new("failed to parse config file #{path}: #{e.message}", file: path)
+    rescue SystemCallError => e
+      raise Evilution::ConfigError.new("cannot read config file #{path}: #{e.message}", file: path)
+    end
+
+    {}
+  end
+end

data/lib/evilution/config/sources.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "file_loader"
+require_relative "env_loader"
+
+module Evilution::Config::Sources
+  module_function
+
+  def merge(explicit:, skip_file:)
+    file = skip_file ? {} : Evilution::Config::FileLoader.load
+    env  = Evilution::Config::EnvLoader.load
+    Evilution::Config::DEFAULTS.merge(file).merge(env).merge(explicit)
+  end
+end

data/lib/evilution/config/validators/base.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../validators"
+
+class Evilution::Config::Validators::Base
+  def self.call(_value)
+    raise NotImplementedError
+  end
+
+  class << self
+    private
+
+    def coerce_symbol!(value, allowed:, name:)
+      raise Evilution::ConfigError, "#{name} must be #{allowed.join(" or ")}, got nil" if value.nil?
+
+      unless value.is_a?(String) || value.is_a?(Symbol)
+        raise Evilution::ConfigError, "#{name} must be #{allowed.join(" or ")}, got #{value.inspect}"
+      end
+
+      sym = value.to_sym
+      return sym if allowed.include?(sym)
+
+      raise Evilution::ConfigError, "#{name} must be #{allowed.join(" or ")}, got #{sym.inspect}"
+    end
+
+    def coerce_positive_int!(value, name:)
+      raise Evilution::ConfigError, "#{name} must be a positive integer, got #{value.inspect}" if value.is_a?(Float)
+
+      int = Integer(value)
+      raise Evilution::ConfigError, "#{name} must be a positive integer, got #{int}" unless int >= 1
+
+      int
+    rescue ::ArgumentError, ::TypeError
+      raise Evilution::ConfigError, "#{name} must be a positive integer, got #{value.inspect}"
+    end
+  end
+end

data/lib/evilution/config/validators/example_targeting_cache.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Evilution::Config::Validators::ExampleTargetingCache < Evilution::Config::Validators::Base
+  def self.call(value)
+    raise Evilution::ConfigError, "example_targeting_cache must be a Hash, got #{value.class}" unless value.is_a?(Hash)
+
+    normalized = normalize_keys(value)
+    merged = Evilution::Config::DEFAULTS[:example_targeting_cache].merge(normalized)
+    require_positive_int!(merged, :max_files)
+    require_positive_int!(merged, :max_blocks)
+    merged
+  end
+
+  class << self
+    private
+
+    def normalize_keys(value)
+      value.each_with_object({}) do |(k, v), acc|
+        unless k.is_a?(String) || k.is_a?(Symbol)
+          raise Evilution::ConfigError,
+                "example_targeting_cache keys must be Strings or Symbols, got #{k.inspect}"
+        end
+        acc[k.to_sym] = v
+      end
+    end
+
+    def require_positive_int!(cache, key)
+      v = cache[key]
+      return if v.is_a?(Integer) && v >= 1
+
+      raise Evilution::ConfigError,
+            "example_targeting_cache.#{key} must be a positive integer, got #{v.inspect}"
+    end
+  end
+end

data/lib/evilution/config/validators/example_targeting_fallback.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Evilution::Config::Validators::ExampleTargetingFallback < Evilution::Config::Validators::Base
+  FALLBACKS = %i[full_file unresolved].freeze
+
+  def self.call(value)
+    unless value.is_a?(String) || value.is_a?(Symbol)
+      raise Evilution::ConfigError,
+            "example_targeting_fallback must be full_file or unresolved, got #{value.inspect}"
+    end
+
+    sym = value.to_sym
+    unless FALLBACKS.include?(sym)
+      raise Evilution::ConfigError,
+            "example_targeting_fallback must be full_file or unresolved, got #{sym.inspect}"
+    end
+
+    sym
+  end
+end

data/lib/evilution/config/validators/fail_fast.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Evilution::Config::Validators::FailFast < Evilution::Config::Validators::Base
+  def self.call(value)
+    return nil if value.nil?
+
+    coerce_positive_int!(value, name: "fail_fast")
+  end
+end

data/lib/evilution/config/validators/hooks.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Evilution::Config::Validators::Hooks < Evilution::Config::Validators::Base
+  def self.call(value)
+    return {} if value.nil?
+    raise Evilution::ConfigError, "hooks must be a mapping of event names to file paths, got #{value.class}" unless value.is_a?(Hash)
+
+    value
+  end
+end

data/lib/evilution/config/validators/ignore_patterns.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Evilution::Config::Validators::IgnorePatterns < Evilution::Config::Validators::Base
+  def self.call(value)
+    patterns = Array(value)
+    patterns.each do |pattern|
+      unless pattern.is_a?(String)
+        raise Evilution::ConfigError,
+              "ignore_patterns must be an array of strings, got #{pattern.class} (#{pattern.inspect})"
+      end
+    end
+    patterns
+  end
+end

data/lib/evilution/config/validators/integration.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Evilution::Config::Validators::Integration < Evilution::Config::Validators::Base
+  ALLOWED = %i[rspec minitest].freeze
+
+  def self.call(value)
+    coerce_symbol!(value, allowed: ALLOWED, name: "integration")
+  end
+end

data/lib/evilution/config/validators/isolation.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Evilution::Config::Validators::Isolation < Evilution::Config::Validators::Base
+  ALLOWED = %i[auto fork in_process].freeze
+  MESSAGE = "isolation must be auto, fork, or in_process"
+
+  def self.call(value)
+    raise Evilution::ConfigError, "#{MESSAGE}, got nil" if value.nil?
+
+    raise Evilution::ConfigError, "#{MESSAGE}, got #{value.inspect}" unless value.is_a?(String) || value.is_a?(Symbol)
+
+    sym = value.to_sym
+    return sym if ALLOWED.include?(sym)
+
+    raise Evilution::ConfigError, "#{MESSAGE}, got #{sym.inspect}"
+  end
+end

data/lib/evilution/config/validators/jobs.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Evilution::Config::Validators::Jobs < Evilution::Config::Validators::Base
+  def self.call(value)
+    coerce_positive_int!(value, name: "jobs")
+  end
+end

data/lib/evilution/config/validators/preload.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Evilution::Config::Validators::Preload < Evilution::Config::Validators::Base
+  def self.call(value)
+    return nil if value.nil?
+    return false if value == false
+    return value if value.is_a?(String)
+
+    raise Evilution::ConfigError, "preload must be nil, false, or a String path, got #{value.inspect}"
+  end
+end

data/lib/evilution/config/validators/profile.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Evilution::Config::Validators::Profile < Evilution::Config::Validators::Base
+  ALLOWED = %i[default strict].freeze
+
+  def self.call(value)
+    coerce_symbol!(value, allowed: ALLOWED, name: "profile")
+  end
+end

data/lib/evilution/config/validators/spec_mappings.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Evilution::Config::Validators::SpecMappings < Evilution::Config::Validators::Base
+  def self.call(value)
+    return {} if value.nil?
+
+    raise Evilution::ConfigError, "spec_mappings must be a Hash, got #{value.class}" unless value.is_a?(Hash)
+
+    normalized = value.each_with_object({}) do |(source, specs), acc|
+      key = normalize_key(source)
+      acc[key] = normalize_value(key, specs)
+    end
+
+    warn_missing(normalized)
+    normalized
+  end
+
+  class << self
+    private
+
+    def normalize_key(source)
+      key = source.to_s
+      key = key.delete_prefix("#{Dir.pwd}/") if key.start_with?("/")
+      key.delete_prefix("./")
+    end
+
+    def normalize_value(source, specs)
+      case specs
+      when String then [specs]
+      when Array
+        specs.each do |entry|
+          unless entry.is_a?(String)
+            raise Evilution::ConfigError,
+                  "spec_mappings[#{source.inspect}] entries must be string paths, got #{entry.class}"
+          end
+        end
+        specs
+      else
+        raise Evilution::ConfigError,
+              "spec_mappings[#{source.inspect}] must be a string or array of strings, got #{specs.class}"
+      end
+    end
+
+    def warn_missing(mappings)
+      mappings.each do |source, specs|
+        specs.each do |spec_path|
+          next if File.exist?(spec_path)
+
+          warn "[evilution] spec_mappings[#{source.inspect}]: #{spec_path} not found, skipping"
+        end
+      end
+    end
+  end
+end

data/lib/evilution/config/validators/spec_pattern.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Evilution::Config::Validators::SpecPattern < Evilution::Config::Validators::Base
+  def self.call(value)
+    return nil if value.nil?
+    return value if value.is_a?(String)
+
+    raise Evilution::ConfigError, "spec_pattern must be nil or a String glob, got #{value.class}"
+  end
+end

data/lib/evilution/config/validators.rb

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