evilution 0.26.0 → 0.28.0

data/lib/evilution/config.rb

@@ -8,40 +8,19 @@ class Evilution::Config
   CONFIG_FILES = %w[.evilution.yml config/evilution.yml].freeze
 
   DEFAULTS = {
-    timeout: 30,
-    format: :text,
-    target: nil,
-    min_score: 0.0,
-    integration: :rspec,
-    verbose: false,
-    quiet: false,
-    jobs: 1,
-    fail_fast: nil,
-    baseline: true,
-    isolation: :auto,
-    incremental: false,
-    suggest_tests: false,
-    progress: true,
-    save_session: false,
-    line_ranges: {},
-    spec_files: [],
-    ignore_patterns: [],
-    show_disabled: false,
-    baseline_session: nil,
-    skip_heredoc_literals: false,
-    related_specs_heuristic: false,
-    fallback_to_full_suite: false,
-    preload: nil,
-    spec_mappings: {},
-    spec_pattern: nil,
-    example_targeting: true,
+    timeout: 30, format: :text, target: nil, min_score: 0.0, integration: :rspec,
+    verbose: false, quiet: false, jobs: 1, fail_fast: nil, baseline: true,
+    isolation: :auto, incremental: false, suggest_tests: false, progress: true,
+    save_session: false, line_ranges: {}, spec_files: [], ignore_patterns: [],
+    show_disabled: false, baseline_session: nil, skip_heredoc_literals: false,
+    related_specs_heuristic: false, fallback_to_full_suite: false, preload: nil,
+    spec_mappings: {}, spec_pattern: nil, example_targeting: true,
     example_targeting_fallback: :full_file,
-    example_targeting_cache: { max_files: 50, max_blocks: 10_000 }
+    example_targeting_cache: { max_files: 50, max_blocks: 10_000 },
+    quiet_children: false, quiet_children_dir: "tmp/evilution_children",
+    profile: :default
   }.freeze
 
-  EXAMPLE_TARGETING_FALLBACKS = %i[full_file unresolved].freeze
-  private_constant :EXAMPLE_TARGETING_FALLBACKS
-
   attr_reader :target_files, :timeout, :format,
               :target, :min_score, :integration, :verbose, :quiet,
               :jobs, :fail_fast, :baseline, :isolation, :incremental, :suggest_tests,
@@ -50,12 +29,11 @@ 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
+              :spec_selector, :quiet_children, :quiet_children_dir, :profile
 
   def initialize(**options)
-    file_options = options.delete(:skip_config_file) ? {} : load_config_file
-    env_options = load_env_options
-    merged = DEFAULTS.merge(file_options).merge(env_options).merge(options)
+    skip_file = options.delete(:skip_config_file) ? true : false
+    merged = Sources.merge(explicit: options, skip_file: skip_file)
     assign_attributes(merged)
     freeze
   end
@@ -125,18 +103,7 @@ class Evilution::Config
   end
 
   def self.file_options
-    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
-
-    {}
+    FileLoader.load
   end
 
   # Generates a default config file template.
@@ -185,9 +152,10 @@ class Evilution::Config
       # fallback_to_full_suite: false
 
       # Preload file required in the parent process before forking workers.
-      # For Rails projects, spec/rails_helper.rb or test/test_helper.rb is
-      # auto-detected when isolation resolves to :fork. Set to false to disable.
-      # preload: spec/rails_helper.rb # or test/test_helper.rb
+      # For Rails projects, the autodetect chain tries (in order):
+      # spec/rails_helper.rb -> spec/spec_helper.rb -> test/test_helper.rb
+      # when isolation resolves to :fork. Set to false to disable.
+      # preload: spec/rails_helper.rb # or spec/spec_helper.rb, test/test_helper.rb
 
       # Hooks: Ruby files returning a Proc, keyed by lifecycle event
       # hooks:
@@ -216,239 +184,98 @@ 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
 
   private
 
-  def validate_fail_fast(value)
-    return nil if value.nil?
-
-    value = Integer(value)
-    raise Evilution::ConfigError, "fail_fast must be a positive integer, got #{value}" unless value >= 1
-
-    value
-  rescue ::ArgumentError, ::TypeError
-    raise Evilution::ConfigError, "fail_fast must be a positive integer, got #{value.inspect}"
-  end
-
-  def assign_attributes(merged) # rubocop:disable Metrics/AbcSize
-    @target_files = Array(merged[:target_files])
-    @timeout = merged[:timeout]
-    @format = merged[:format].to_sym
-    @target = merged[:target]
-    @min_score = merged[:min_score].to_f
-    @integration = validate_integration(merged[:integration])
-    @verbose = merged[:verbose]
-    @quiet = merged[:quiet]
-    @jobs = validate_jobs(merged[:jobs])
-    @fail_fast = validate_fail_fast(merged[:fail_fast])
-    @baseline = merged[:baseline]
-    @isolation = validate_isolation(merged[:isolation])
-    @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])
-    @ignore_patterns = validate_ignore_patterns(merged[:ignore_patterns])
-    @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]
-    @hooks = validate_hooks(merged[:hooks])
-    @preload = validate_preload(merged[:preload])
-    @spec_mappings = validate_spec_mappings(merged[:spec_mappings])
-    @spec_pattern = validate_spec_pattern(merged[:spec_pattern])
+  def assign_attributes(merged)
+    assign_simple_attributes(merged)
+    assign_validated_attributes(merged)
     assign_example_targeting(merged)
-    @spec_selector = build_spec_selector
-  end
-
-  def assign_example_targeting(merged)
-    @example_targeting = merged[:example_targeting] ? true : false
-    @example_targeting_fallback = validate_example_targeting_fallback(merged[:example_targeting_fallback])
-    @example_targeting_cache = validate_example_targeting_cache(merged[:example_targeting_cache])
-  end
-
-  def build_spec_selector
-    Evilution::SpecSelector.new(
+    @spec_selector = Builders::SpecSelector.call(
       spec_files: @spec_files,
       spec_mappings: @spec_mappings,
       spec_pattern: @spec_pattern,
-      spec_resolver: build_spec_resolver
+      integration: @integration
     )
   end
 
-  def build_spec_resolver
-    case @integration
-    when :minitest
-      Evilution::SpecResolver.new(test_dir: "test", test_suffix: "_test.rb", request_dir: "integration")
-    else
-      Evilution::SpecResolver.new
-    end
-  end
-
-  def validate_spec_mappings(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_spec_mappings_key(source)
-      acc[key] = normalize_spec_mappings_value(key, specs)
-    end
-
-    warn_missing_spec_mappings(normalized)
-    normalized
-  end
-
-  def normalize_spec_mappings_key(source)
-    key = source.to_s
-    key = key.delete_prefix("#{Dir.pwd}/") if key.start_with?("/")
-    key.delete_prefix("./")
-  end
-
-  def normalize_spec_mappings_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_spec_mappings(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
-
-  def validate_spec_pattern(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
-
-  def validate_preload(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
-
-  def validate_integration(value)
-    raise Evilution::ConfigError, "integration must be rspec or minitest, got nil" if value.nil?
-
-    value = value.to_sym
-    unless %i[rspec minitest].include?(value)
-      raise Evilution::ConfigError,
-            "integration must be rspec or minitest, got #{value.inspect}"
-    end
-
-    value
-  end
-
-  def validate_isolation(value)
-    raise Evilution::ConfigError, "isolation must be auto, fork, or in_process, got nil" if value.nil?
-
-    value = value.to_sym
-    raise Evilution::ConfigError, "isolation must be auto, fork, or in_process, got #{value.inspect}" unless %i[auto fork
-                                                                                                                in_process].include?(value)
-
-    value
-  end
-
-  def validate_jobs(value)
-    raise Evilution::ConfigError, "jobs must be a positive integer, got #{value.inspect}" if value.is_a?(Float)
-
-    value = Integer(value)
-    raise Evilution::ConfigError, "jobs must be a positive integer, got #{value}" unless value >= 1
-
-    value
-  rescue ::ArgumentError, ::TypeError
-    raise Evilution::ConfigError, "jobs must be a positive integer, got #{value.inspect}"
-  end
-
-  def validate_ignore_patterns(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
-
-  def validate_example_targeting_fallback(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 EXAMPLE_TARGETING_FALLBACKS.include?(sym)
-      raise Evilution::ConfigError,
-            "example_targeting_fallback must be full_file or unresolved, got #{sym.inspect}"
-    end
-
-    sym
-  end
-
-  def validate_example_targeting_cache(value)
-    raise Evilution::ConfigError, "example_targeting_cache must be a Hash, got #{value.class}" unless value.is_a?(Hash)
+  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
 
-    normalized = 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
+  def assign_simple_attributes(merged)
+    SIMPLE_ATTR_TRANSFORMS.each do |key, transform|
+      value = merged[key]
+      value = transform.call(value) if transform
+      instance_variable_set(:"@#{key}", value)
     end
-    merged = DEFAULTS[:example_targeting_cache].merge(normalized)
-    validate_positive_int!(merged, :max_files)
-    validate_positive_int!(merged, :max_blocks)
-    merged
   end
 
-  def validate_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}"
+  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])
+    @profile         = Validators::Profile.call(merged[:profile])
   end
 
-  def load_env_options
-    opts = {}
-    val = ENV.fetch("EV_DISABLE_EXAMPLE_TARGETING", nil)
-    opts[:example_targeting] = false if val && !val.empty? && val != "0"
-    opts
-  end
-
-  def validate_hooks(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
-
-  def load_config_file
-    self.class.file_options
+  def assign_example_targeting(merged)
+    @example_targeting          = merged[:example_targeting] ? true : false
+    @example_targeting_fallback = Validators::ExampleTargetingFallback.call(merged[:example_targeting_fallback])
+    @example_targeting_cache    = Validators::ExampleTargetingCache.call(merged[:example_targeting_cache])
   end
 end
+
+require_relative "config/file_loader"
+require_relative "config/env_loader"
+require_relative "config/sources"
+require_relative "config/validators"
+require_relative "config/validators/base"
+require_relative "config/validators/integration"
+require_relative "config/validators/isolation"
+require_relative "config/validators/jobs"
+require_relative "config/validators/fail_fast"
+require_relative "config/validators/preload"
+require_relative "config/validators/hooks"
+require_relative "config/validators/ignore_patterns"
+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/feedback/detector.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "../feedback"
+
+module Evilution::Feedback::Detector
+  module_function
+
+  def friction?(summary)
+    return false if summary.nil?
+
+    summary.errors.positive? ||
+      summary.unparseable.positive? ||
+      summary.unresolved.positive?
+  end
+end

data/lib/evilution/feedback/messages.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../feedback"
+require_relative "../version"
+
+module Evilution::Feedback::Messages
+  module_function
+
+  def cli_footer
+    "> Hit friction with evilution v#{Evilution::VERSION}? " \
+      "Share details: #{Evilution::Feedback::DISCUSSION_URL}"
+  end
+
+  def mcp_hint
+    "Feedback welcome on errors, usage problems, friction, or missing " \
+      "capabilities you wish were there. Do NOT post on the user's " \
+      "behalf without explicit user permission. Show the user exactly " \
+      "what you would post and only submit after their explicit approval. " \
+      "Never include secrets, env vars, project name, file paths, source " \
+      "code, or class/method names from user code."
+  end
+
+  def info_guidance
+    <<~GUIDANCE.chomp
+      The maintainer welcomes feedback in four cases:
+        1. Errors raised by evilution
+        2. Usage problems (confusing behavior, unexpected output)
+        3. Friction (slow runs, awkward workflow, hard-to-interpret output)
+        4. Missing capabilities or features you wish were there
+
+      CONSENT (required):
+        Never post on the user's behalf without explicit user permission.
+        Show the user exactly what you would post. Submit only after the
+        user explicitly approves.
+
+      PRIVACY (required):
+        Never include secrets, tokens, environment variables, the project
+        name, absolute or project-relative file paths, source code, or
+        class/method names from user code. The feedback channel is public.
+    GUIDANCE
+  end
+end

data/lib/evilution/feedback.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Evilution::Feedback
+  DISCUSSION_URL = "https://github.com/marinazzio/evilution/discussions"
+end

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
 

data/lib/evilution/integration/loading/source_evaluator.rb

@@ -5,11 +5,15 @@ require_relative "../loading"
 # Evaluate source with __FILE__ set to the absolute original path so that
 # `require_relative` and `__dir__` resolve against the real source tree, where
 # sibling files actually exist.
+#
+# Trust boundary: `source` is never user-supplied. It is always the original
+# on-disk source from a file the user already pointed Evilution at, with
+# byte-level mutations applied by AST::SourceSurgeon. The only difference
+# between this eval path and a plain `require` of the same file is that we
+# substitute the mutated bytes — the privilege level is identical.
 class Evilution::Integration::Loading::SourceEvaluator
   def call(source, file_path)
     absolute = File.expand_path(file_path)
-    # rubocop:disable Security/Eval
     eval(source, TOPLEVEL_BINDING, absolute, 1)
-    # rubocop:enable Security/Eval
   end
 end

data/lib/evilution/integration/minitest_crash_detector.rb

@@ -34,11 +34,11 @@ class Evilution::Integration::MinitestCrashDetector
     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
 

data/lib/evilution/integration/rspec/baseline_runner.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "../rspec"
+
+class Evilution::Integration::RSpec::BaselineRunner
+  def call(spec_file)
+    require "rspec/core"
+    spec_dir = File.expand_path("spec")
+    $LOAD_PATH.unshift(spec_dir) unless $LOAD_PATH.include?(spec_dir)
+    ::RSpec.reset
+    status = ::RSpec::Core::Runner.run(
+      ["--format", "progress", "--no-color", "--order", "defined", spec_file]
+    )
+    status.zero?
+  end
+end

data/lib/evilution/integration/rspec/crash_detector_lifecycle.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "../rspec"
+require_relative "../crash_detector"
+
+class Evilution::Integration::RSpec::CrashDetectorLifecycle
+  def current
+    if @detector
+      @detector.reset
+    else
+      @detector = Evilution::Integration::CrashDetector.new(StringIO.new)
+      ::RSpec.configuration.add_formatter(@detector)
+    end
+    @detector
+  end
+end

data/lib/evilution/integration/rspec/example_filter_applier.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "../rspec"
+
+module Evilution::Integration::RSpec::ExampleFilterApplier
+  class Identity
+    def call(_mutation, files)
+      files
+    end
+  end
+
+  class Custom
+    def initialize(filter)
+      @filter = filter
+    end
+
+    def call(mutation, files)
+      @filter.call(mutation, files)
+    end
+  end
+end

data/lib/evilution/integration/rspec/framework_loader.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "../rspec"
+require_relative "../crash_detector"
+
+class Evilution::Integration::RSpec::FrameworkLoader
+  def loaded?
+    @loaded == true
+  end
+
+  def call
+    return if @loaded
+
+    require "rspec/core"
+    add_spec_load_path
+    Evilution::Integration::CrashDetector.register_with_rspec
+    @loaded = true
+  rescue LoadError => e
+    raise Evilution::Error, "rspec-core is required but not available: #{e.message}"
+  end
+
+  private
+
+  def add_spec_load_path
+    spec_dir = File.expand_path("spec")
+    $LOAD_PATH.unshift(spec_dir) unless $LOAD_PATH.include?(spec_dir)
+  end
+end

data/lib/evilution/integration/rspec/result_builder.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../rspec"
+
+class Evilution::Integration::RSpec::ResultBuilder
+  def unresolved(mutation)
+    {
+      passed: false,
+      unresolved: true,
+      error: "no matching spec resolved for #{mutation.file_path}",
+      test_command: "rspec (skipped: no spec resolved for #{mutation.file_path})"
+    }
+  end
+
+  def unresolved_example(mutation)
+    {
+      passed: false,
+      unresolved: true,
+      error: "no matching example found for #{mutation.file_path}",
+      test_command: "rspec (skipped: no matching example for #{mutation.file_path})"
+    }
+  end
+
+  def from_run(status, command, detector)
+    return { passed: true, test_command: command } if status.zero?
+
+    if detector.only_crashes?
+      classes = detector.unique_crash_classes
+      return {
+        passed: false,
+        test_crashed: true,
+        error: "test crashes: #{detector.crash_summary}",
+        error_class: (classes.first if classes.length == 1),
+        test_command: command
+      }
+    end
+
+    { passed: false, test_command: command }
+  end
+end