evilution 0.27.0 → 0.29.0

data/lib/evilution/cli/parser.rb

@@ -20,7 +20,9 @@ class Evilution::CLI::Parser
 
     preprocess_flags
     remaining = OptionsBuilder.build(@options).parse!(@argv)
-    @files, @line_ranges = FileArgs.parse(remaining)
+    parsed_paths = FileArgs.parse(remaining)
+    @files = parsed_paths.files
+    @line_ranges = parsed_paths.ranges
     read_stdin_files if @options.delete(:stdin) && %i[run subjects].include?(@command)
     build_parsed_args
   end
@@ -37,27 +39,23 @@ class Evilution::CLI::Parser
   def preprocess_flags
     result = []
     i = 0
-    while i < @argv.length
-      arg = @argv[i]
-      if arg == "--fail-fast"
-        next_arg = @argv[i + 1]
+    i = consume_token(i, result) while i < @argv.length
+    @argv = result
+  end
 
-        if next_arg && next_arg.match?(/\A-?\d+\z/)
-          @options[:fail_fast] = next_arg
-          i += 2
-        else
-          result << arg
-          i += 1
-        end
-      elsif arg.start_with?("--fail-fast=")
-        @options[:fail_fast] = arg.delete_prefix("--fail-fast=")
-        i += 1
-      else
-        result << arg
-        i += 1
-      end
+  def consume_token(i, result)
+    arg = @argv[i]
+    next_arg = @argv[i + 1]
+    if arg == "--fail-fast" && !next_arg.nil? && next_arg.match?(/\A-?\d+\z/)
+      @options[:fail_fast] = next_arg
+      return i + 2
     end
-    @argv = result
+    if arg.start_with?("--fail-fast=")
+      @options[:fail_fast] = arg.delete_prefix("--fail-fast=")
+      return i + 1
+    end
+    result << arg
+    i + 1
   end
 
   def read_stdin_files

data/lib/evilution/cli/printers/environment.rb

@@ -3,6 +3,12 @@
 require_relative "../printers"
 
 class Evilution::CLI::Printers::Environment
+  PLAIN_SETTINGS = %i[
+    timeout format integration jobs isolation baseline incremental
+    verbose quiet progress min_score suggest_tests save_session
+    skip_heredoc_literals
+  ].freeze
+
   def initialize(config, config_file:)
     @config = config
     @config_file = config_file
@@ -30,24 +36,18 @@ class Evilution::CLI::Printers::Environment
   end
 
   def settings_lines
-    [
-      "  timeout: #{@config.timeout}",
-      "  format: #{@config.format}",
-      "  integration: #{@config.integration}",
-      "  jobs: #{@config.jobs}",
-      "  isolation: #{@config.isolation}",
-      "  baseline: #{@config.baseline}",
-      "  incremental: #{@config.incremental}",
-      "  verbose: #{@config.verbose}",
-      "  quiet: #{@config.quiet}",
-      "  progress: #{@config.progress}",
-      "  fail_fast: #{@config.fail_fast || "(disabled)"}",
-      "  min_score: #{@config.min_score}",
-      "  suggest_tests: #{@config.suggest_tests}",
-      "  save_session: #{@config.save_session}",
-      "  target: #{@config.target || "(all files)"}",
-      "  skip_heredoc_literals: #{@config.skip_heredoc_literals}",
-      "  ignore_patterns: #{@config.ignore_patterns.empty? ? "(none)" : @config.ignore_patterns.inspect}"
-    ]
+    plain_lines = PLAIN_SETTINGS.map { |k| setting_line(k, @config.public_send(k)) }
+    plain_lines.insert(10, setting_line(:fail_fast, @config.fail_fast || "(disabled)"))
+    plain_lines.insert(14, setting_line(:target, @config.target || "(all files)"))
+    plain_lines << setting_line(:ignore_patterns, format_ignore_patterns(@config.ignore_patterns))
+    plain_lines
+  end
+
+  def setting_line(key, value)
+    "  #{key}: #{value}"
+  end
+
+  def format_ignore_patterns(patterns)
+    patterns.empty? ? "(none)" : patterns.inspect
   end
 end

data/lib/evilution/cli/printers/session_diff.rb

@@ -32,16 +32,16 @@ class Evilution::CLI::Printers::SessionDiff
   end
 
   def print_summary(io, summary)
-    delta_str = format("%+.2f%%", summary.score_delta * 100)
     io.puts("Session Diff")
     io.puts("=" * 40)
-    io.puts(format("Base score:  %<score>6.2f%%  (%<killed>d/%<total>d killed)",
-                   score: summary.base_score * 100, killed: summary.base_killed,
-                   total: summary.base_total))
-    io.puts(format("Head score:  %<score>6.2f%%  (%<killed>d/%<total>d killed)",
-                   score: summary.head_score * 100, killed: summary.head_killed,
-                   total: summary.head_total))
-    io.puts("Delta:       #{delta_str}")
+    io.puts(score_line("Base", summary.base_score, summary.base_killed, summary.base_total))
+    io.puts(score_line("Head", summary.head_score, summary.head_killed, summary.head_total))
+    io.puts("Delta:       #{format("%+.2f%%", summary.score_delta * 100)}")
+  end
+
+  def score_line(label, score, killed, total)
+    format("%<label>s score:  %<score>6.2f%%  (%<killed>d/%<total>d killed)",
+           label: label, score: score * 100, killed: killed, total: total)
   end
 
   def print_section(io, title, mutations, color)

data/lib/evilution/compare/diff_extractor/evilution.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../diff_extractor"
+
+# Extracts {minus:, plus:} payload arrays from Evilution-format diffs.
+# Evilution diffs use "- " / "+ " line prefixes (note the trailing space) and
+# do not carry unified-diff headers or hunk markers.
+class Evilution::Compare::DiffExtractor::Evilution
+  def call(diff)
+    minus = []
+    plus = []
+    diff.to_s.each_line do |line|
+      line = line.chomp
+      if line.start_with?("- ")
+        minus << line[2..]
+      elsif line.start_with?("+ ")
+        plus << line[2..]
+      end
+    end
+    { minus: minus, plus: plus }
+  end
+end

data/lib/evilution/compare/diff_extractor/mutant.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../diff_extractor"
+
+# Extracts {minus:, plus:} payload arrays from Mutant unified-diff format.
+# Skips the "--- <name>", "+++ <name>", and "@@ ... @@" header lines and
+# returns each remaining payload line with its single leading "-" or "+"
+# marker stripped.
+#
+# Header detection requires a trailing space after "---"/"+++" so that a
+# payload line whose mutated source starts with "--" (emitted as "---var")
+# or "++" (emitted as "+++var") is preserved rather than misclassified as
+# a header.
+class Evilution::Compare::DiffExtractor::Mutant
+  def call(diff)
+    minus = []
+    plus = []
+    diff.to_s.each_line do |line|
+      line = line.chomp
+      next if line.start_with?("--- ", "+++ ", "@@")
+
+      if line.start_with?("-")
+        minus << line[1..]
+      elsif line.start_with?("+")
+        plus << line[1..]
+      end
+    end
+    { minus: minus, plus: plus }
+  end
+end

data/lib/evilution/compare/diff_extractor.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "../compare"
+
+module Evilution::Compare::DiffExtractor
+end

data/lib/evilution/compare/fingerprint.rb

@@ -3,80 +3,23 @@
 require "digest"
 require_relative "../compare"
 
-module Evilution::Compare::Fingerprint
-  module_function
-
-  def extract_from_evilution_diff(diff)
-    minus = []
-    plus = []
-    diff.to_s.each_line do |line|
-      line = line.chomp
-      if line.start_with?("- ")
-        minus << line[2..]
-      elsif line.start_with?("+ ")
-        plus << line[2..]
-      end
-    end
-    { minus: minus, plus: plus }
-  end
-
-  def extract_from_mutant_diff(diff)
-    minus = []
-    plus = []
-    diff.to_s.each_line do |line|
-      line = line.chomp
-      next if line.start_with?("---", "+++", "@@")
-
-      if line.start_with?("-")
-        minus << line[1..]
-      elsif line.start_with?("+")
-        plus << line[1..]
-      end
-    end
-    { minus: minus, plus: plus }
-  end
-
-  # 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.
-  # rubocop:disable Metrics/PerceivedComplexity, Style/MultipleComparison
-  def normalize_line(line)
-    out = +""
-    i = 0
-    in_literal = nil
-    last_was_space = false
-    chars = line.chars
-    while i < chars.length
-      ch = chars[i]
-      if in_literal
-        out << ch
-        if ch == "\\" && i + 1 < chars.length
-          out << chars[i + 1]
-          i += 2
-          next
-        end
-        in_literal = nil if ch == in_literal
-      elsif ch == '"' || ch == "'"
-        in_literal = ch
-        out << ch
-        last_was_space = false
-      elsif ch == " " || ch == "\t"
-        out << " " unless last_was_space || out.empty?
-        last_was_space = true
-      else
-        out << ch
-        last_was_space = false
-      end
-      i += 1
-    end
-    out.rstrip
+# Composes a stable SHA256 fingerprint from a mutation diff for cross-tool
+# matching (Evilution vs Mutant). Orchestrates two collaborators along
+# distinct change axes:
+#
+#   - extractor: parses a tool-specific diff format into {minus:, plus:}
+#   - normalizer: collapses whitespace per line so cosmetic differences
+#                 don't perturb the hash
+class Evilution::Compare::Fingerprint
+  def initialize(extractor:, normalizer:)
+    @extractor = extractor
+    @normalizer = normalizer
   end
-  # rubocop:enable Metrics/PerceivedComplexity, Style/MultipleComparison
 
-  def compute(file_path:, line:, body:)
-    minus = body[:minus].map { |l| normalize_line(l) }
-    plus  = body[:plus].map  { |l| normalize_line(l) }
+  def call(diff:, file_path:, line:)
+    body = @extractor.call(diff)
+    minus = body[:minus].map { |l| @normalizer.call(l) }
+    plus  = body[:plus].map  { |l| @normalizer.call(l) }
     payload = [file_path, line.to_s, minus.join("\n"), plus.join("\n")].join("\x00")
     Digest::SHA256.hexdigest(payload)
   end

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|
@@ -42,24 +57,28 @@ class Evilution::Compare::Normalizer
   private
 
   def build_evilution_record(entry, index:)
-    file_path = entry["file"] or raise Evilution::Compare::InvalidInput.new("missing 'file' in record", index: index)
-    line = entry["line"] or raise Evilution::Compare::InvalidInput.new("missing 'line' in record", index: index)
-    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)
+    file_path, line, diff, status = extract_evilution_fields(entry, index)
     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
     )
   end
 
+  def extract_evilution_fields(entry, index)
+    file_path = entry["file"] or raise Evilution::Compare::InvalidInput.new("missing 'file' in record", index: index)
+    line = entry["line"] or raise Evilution::Compare::InvalidInput.new("missing 'line' in record", index: index)
+    diff = entry["diff"].to_s
+    status = EVILUTION_STATUS_MAP[entry["status"]] ||
+             raise(Evilution::Compare::InvalidInput.new("unknown status #{entry["status"].inspect}", index: index))
+    [file_path, line, diff, status]
+  end
+
   def build_mutant_record(cov, source_path:, index:)
     mr = cov["mutation_result"] or raise Evilution::Compare::InvalidInput.new("missing mutation_result", index: index)
     cr = cov["criteria_result"] or raise Evilution::Compare::InvalidInput.new("missing criteria_result", index: index)
@@ -67,13 +86,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/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.rb

@@ -17,7 +17,8 @@ class Evilution::Config
     spec_mappings: {}, spec_pattern: nil, example_targeting: true,
     example_targeting_fallback: :full_file,
     example_targeting_cache: { max_files: 50, max_blocks: 10_000 },
-    quiet_children: false, quiet_children_dir: "tmp/evilution_children"
+    quiet_children: false, quiet_children_dir: "tmp/evilution_children",
+    profile: :default
   }.freeze
 
   attr_reader :target_files, :timeout, :format,
@@ -28,7 +29,7 @@ class Evilution::Config
               :skip_heredoc_literals, :related_specs_heuristic,
               :fallback_to_full_suite, :preload, :spec_mappings, :spec_pattern,
               :example_targeting, :example_targeting_fallback, :example_targeting_cache,
-              :spec_selector, :quiet_children, :quiet_children_dir
+              :spec_selector, :quiet_children, :quiet_children_dir, :profile
 
   def initialize(**options)
     skip_file = options.delete(:skip_config_file) ? true : false
@@ -183,6 +184,11 @@ class Evilution::Config
       # ignore_patterns:
       #   - "call{name=info, receiver=call{name=logger}}"
       #   - "call{name=debug|warn}"
+
+      # Operator profile: default or strict (default: default).
+      # strict adds aggressive truthiness mutators (e.g. replaces
+      # `x.predicate?` with `nil`) intended for pre-merge audits.
+      # profile: default
     YAML
   end
 
@@ -200,40 +206,50 @@ class Evilution::Config
     )
   end
 
+  SIMPLE_ATTR_TRANSFORMS = {
+    target_files: ->(v) { Array(v) },
+    timeout: nil,
+    format: :to_sym.to_proc,
+    target: nil,
+    min_score: :to_f.to_proc,
+    verbose: nil,
+    quiet: nil,
+    baseline: nil,
+    incremental: nil,
+    suggest_tests: nil,
+    progress: nil,
+    save_session: nil,
+    line_ranges: ->(v) { v || {} },
+    spec_files: ->(v) { Array(v) },
+    show_disabled: nil,
+    baseline_session: nil,
+    skip_heredoc_literals: nil,
+    related_specs_heuristic: nil,
+    fallback_to_full_suite: nil,
+    quiet_children: nil,
+    quiet_children_dir: nil
+  }.freeze
+  private_constant :SIMPLE_ATTR_TRANSFORMS
+
   def assign_simple_attributes(merged)
-    @target_files            = Array(merged[:target_files])
-    @timeout                 = merged[:timeout]
-    @format                  = merged[:format].to_sym
-    @target                  = merged[:target]
-    @min_score               = merged[:min_score].to_f
-    @verbose                 = merged[:verbose]
-    @quiet                   = merged[:quiet]
-    @baseline                = merged[:baseline]
-    @incremental             = merged[:incremental]
-    @suggest_tests           = merged[:suggest_tests]
-    @progress                = merged[:progress]
-    @save_session            = merged[:save_session]
-    @line_ranges             = merged[:line_ranges] || {}
-    @spec_files              = Array(merged[:spec_files])
-    @show_disabled           = merged[:show_disabled]
-    @baseline_session        = merged[:baseline_session]
-    @skip_heredoc_literals   = merged[:skip_heredoc_literals]
-    @related_specs_heuristic = merged[:related_specs_heuristic]
-    @fallback_to_full_suite  = merged[:fallback_to_full_suite]
-    @quiet_children          = merged[:quiet_children]
-    @quiet_children_dir      = merged[:quiet_children_dir]
+    SIMPLE_ATTR_TRANSFORMS.each do |key, transform|
+      value = merged[key]
+      value = transform.call(value) if transform
+      instance_variable_set(:"@#{key}", value)
+    end
   end
 
+  VALIDATED_ATTRS = %i[
+    integration jobs fail_fast isolation ignore_patterns
+    hooks preload spec_mappings spec_pattern profile
+  ].freeze
+  private_constant :VALIDATED_ATTRS
+
   def assign_validated_attributes(merged)
-    @integration     = Validators::Integration.call(merged[:integration])
-    @jobs            = Validators::Jobs.call(merged[:jobs])
-    @fail_fast       = Validators::FailFast.call(merged[:fail_fast])
-    @isolation       = Validators::Isolation.call(merged[:isolation])
-    @ignore_patterns = Validators::IgnorePatterns.call(merged[:ignore_patterns])
-    @hooks           = Validators::Hooks.call(merged[:hooks])
-    @preload         = Validators::Preload.call(merged[:preload])
-    @spec_mappings   = Validators::SpecMappings.call(merged[:spec_mappings])
-    @spec_pattern    = Validators::SpecPattern.call(merged[:spec_pattern])
+    VALIDATED_ATTRS.each do |key|
+      validator = Validators.const_get(key.to_s.split("_").map(&:capitalize).join)
+      instance_variable_set(:"@#{key}", validator.call(merged[key]))
+    end
   end
 
   def assign_example_targeting(merged)
@@ -259,6 +275,7 @@ require_relative "config/validators/spec_pattern"
 require_relative "config/validators/spec_mappings"
 require_relative "config/validators/example_targeting_fallback"
 require_relative "config/validators/example_targeting_cache"
+require_relative "config/validators/profile"
 require_relative "config/builders"
 require_relative "config/builders/spec_resolver"
 require_relative "config/builders/spec_selector"

data/lib/evilution/disable_comment.rb

@@ -20,21 +20,30 @@ class Evilution::DisableComment
   private
 
   def classify_comments(parse_result, source)
-    parse_result.comments.filter_map do |comment|
-      loc = comment.location
-      text = source.byteslice(loc.start_offset, loc.end_offset - loc.start_offset)
-                   .force_encoding(source.encoding)
-
-      if text.match?(DISABLE_MARKER)
-        line = source.lines[loc.start_line - 1]
-        standalone = line.strip == text.strip
-        { type: :disable, line: loc.start_line, standalone: standalone }
-      elsif text.match?(ENABLE_MARKER)
-        { type: :enable, line: loc.start_line }
-      end
+    parse_result.comments.filter_map { |comment| classify_comment(comment, source) }
+  end
+
+  def classify_comment(comment, source)
+    loc = comment.location
+    text = comment_text(loc, source)
+
+    if text.match?(DISABLE_MARKER)
+      disable_entry(loc, text, source)
+    elsif text.match?(ENABLE_MARKER)
+      { type: :enable, line: loc.start_line }
     end
   end
 
+  def comment_text(loc, source)
+    source.byteslice(loc.start_offset, loc.end_offset - loc.start_offset)
+          .force_encoding(source.encoding)
+  end
+
+  def disable_entry(loc, text, source)
+    standalone = source.lines[loc.start_line - 1].strip == text.strip
+    { type: :disable, line: loc.start_line, standalone: standalone }
+  end
+
   def scan_comments(comments, method_ranges, total_lines)
     disabled = []
     range_start = nil

data/lib/evilution/integration/crash_detector.rb

@@ -26,11 +26,11 @@ class Evilution::Integration::CrashDetector
     end
   end
 
-  def has_assertion_failure? # rubocop:disable Naming/PredicatePrefix
+  def assertion_failure?
     @assertion_failures.positive?
   end
 
-  def has_crash? # rubocop:disable Naming/PredicatePrefix
+  def crashed?
     @crashes.any?
   end