evilution 0.16.0 → 0.17.0

data/lib/evilution/ast/pattern/parser.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require_relative "matcher"
+
+class Evilution::AST::Pattern::Parser
+  def initialize(input)
+    @input = input.strip
+    @pos = 0
+  end
+
+  def parse
+    raise Evilution::ConfigError, "invalid pattern: empty string" if @input.empty?
+
+    result = parse_pattern
+    skip_whitespace
+    raise Evilution::ConfigError, "unexpected characters at position #{@pos}: #{@input[@pos..]}" unless @pos >= @input.length
+
+    result
+  end
+
+  private
+
+  def parse_pattern
+    skip_whitespace
+
+    if peek_string("**")
+      advance(2)
+      Evilution::AST::Pattern::DeepWildcardMatcher.new
+    elsif current_char == "_" && !identifier_continues?(1)
+      advance(1)
+      Evilution::AST::Pattern::AnyNodeMatcher.new
+    else
+      parse_node_pattern
+    end
+  end
+
+  def parse_node_pattern
+    node_type = consume_identifier
+    skip_whitespace
+
+    attributes = {}
+    if current_char == "{"
+      advance(1)
+      attributes = parse_attributes
+      skip_whitespace
+      expect_char("}")
+    end
+
+    Evilution::AST::Pattern::NodeMatcher.new(node_type, attributes)
+  end
+
+  def parse_attributes
+    attrs = {}
+    skip_whitespace
+
+    return attrs if current_char == "}"
+
+    loop do
+      skip_whitespace
+      name = consume_identifier
+      skip_whitespace
+      expect_char("=", "expected '=' after attribute name '#{name}'")
+      skip_whitespace
+      value = parse_value
+      attrs[name] = value
+      skip_whitespace
+
+      break unless current_char == ","
+
+      advance(1)
+    end
+
+    attrs
+  end
+
+  def parse_value
+    skip_whitespace
+
+    if current_char == "!"
+      advance(1)
+      skip_whitespace
+      inner = parse_value
+      Evilution::AST::Pattern::NegationMatcher.new(inner)
+    elsif current_char == "*" && !peek_string("**")
+      advance(1)
+      Evilution::AST::Pattern::WildcardValueMatcher.new
+    elsif peek_string("**")
+      advance(2)
+      Evilution::AST::Pattern::DeepWildcardMatcher.new
+    elsif current_char == "_" && !identifier_continues?(1)
+      advance(1)
+      Evilution::AST::Pattern::AnyNodeMatcher.new
+    else
+      parse_value_or_nested
+    end
+  end
+
+  def parse_value_or_nested
+    id = consume_identifier
+    skip_whitespace
+
+    if current_char == "{"
+      advance(1)
+      attrs = parse_attributes
+      skip_whitespace
+      expect_char("}")
+      Evilution::AST::Pattern::NodeMatcher.new(id, attrs)
+    else
+      parse_alternatives_from(id)
+    end
+  end
+
+  def parse_alternatives_from(first)
+    values = [first]
+
+    while current_char == "|"
+      advance(1)
+      skip_whitespace
+      if current_char == "*" && !peek_string("**")
+        advance(1)
+        values << "*"
+      else
+        values << consume_identifier
+      end
+    end
+
+    if values.length == 1
+      Evilution::AST::Pattern::ValueMatcher.new(first)
+    else
+      Evilution::AST::Pattern::AlternativesMatcher.new(values)
+    end
+  end
+
+  def consume_identifier
+    raise Evilution::ConfigError, "unexpected end of pattern at position #{@pos}" if current_char.nil?
+
+    unless current_char.match?(/[a-zA-Z_]/)
+      raise Evilution::ConfigError, "invalid identifier starting with '#{current_char}' at position #{@pos}"
+    end
+
+    start = @pos
+    advance(1)
+    advance(1) while @pos < @input.length && @input[@pos].match?(/[a-zA-Z0-9_]/)
+
+    @input[start...@pos]
+  end
+
+  def skip_whitespace
+    advance(1) while @pos < @input.length && @input[@pos] == " "
+  end
+
+  def current_char
+    @pos < @input.length ? @input[@pos] : nil
+  end
+
+  def peek_string(str)
+    @input[@pos, str.length] == str
+  end
+
+  def identifier_continues?(offset)
+    char = @input[@pos + offset]
+    char && char.match?(/[a-zA-Z0-9_]/)
+  end
+
+  def advance(n)
+    @pos += n
+  end
+
+  def expect_char(char, message = nil)
+    current = current_char
+
+    if current == char
+      advance(1)
+      return
+    end
+
+    if current.nil?
+      raise Evilution::ConfigError,
+            (message || "unexpected end of pattern, expected '#{char}' at position #{@pos}")
+    else
+      raise Evilution::ConfigError,
+            (message || "unexpected character '#{current}', expected '#{char}' at position #{@pos}")
+    end
+  end
+end

data/lib/evilution/ast/pattern.rb

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

data/lib/evilution/ast/source_surgeon.rb

@@ -4,8 +4,8 @@ require_relative "../ast"
 
 module Evilution::AST::SourceSurgeon
   def self.apply(source, offset:, length:, replacement:)
-    result = source.dup
-    result[offset, length] = replacement
-    result
+    binary = source.b
+    binary[offset, length] = replacement.b
+    binary.force_encoding(source.encoding)
   end
 end

data/lib/evilution/cli.rb

@@ -4,6 +4,9 @@ require "json"
 require "optparse"
 require_relative "version"
 require_relative "config"
+require_relative "hooks"
+require_relative "hooks/registry"
+require_relative "hooks/loader"
 require_relative "runner"
 
 class Evilution::CLI
@@ -434,7 +437,8 @@ class Evilution::CLI
 
     file_options = Evilution::Config.file_options
     config = Evilution::Config.new(**@options, target_files: @files, line_ranges: @line_ranges)
-    runner = Evilution::Runner.new(config: config)
+    hooks = build_hooks(config)
+    runner = Evilution::Runner.new(config: config, hooks: hooks)
     summary = runner.call
     summary.success?(min_score: config.min_score) ? 0 : 1
   rescue Evilution::Error => e
@@ -446,6 +450,14 @@ class Evilution::CLI
     2
   end
 
+  def build_hooks(config)
+    return nil if config.hooks.empty?
+
+    registry = Evilution::Hooks::Registry.new
+    Evilution::Hooks::Loader.call(registry, config.hooks)
+    registry
+  end
+
   def json_format?(config, file_options)
     return config.json? if config
 

data/lib/evilution/config.rb

@@ -22,13 +22,15 @@ class Evilution::Config
     progress: true,
     save_session: false,
     line_ranges: {},
-    spec_files: []
+    spec_files: [],
+    ignore_patterns: []
   }.freeze
 
   attr_reader :target_files, :timeout, :format,
               :target, :min_score, :integration, :verbose, :quiet,
               :jobs, :fail_fast, :baseline, :isolation, :incremental, :suggest_tests,
-              :progress, :save_session, :line_ranges, :spec_files
+              :progress, :save_session, :line_ranges, :spec_files, :hooks,
+              :ignore_patterns
 
   def initialize(**options)
     file_options = options.delete(:skip_config_file) ? {} : load_config_file
@@ -122,6 +124,17 @@ class Evilution::Config
 
       # Generate concrete RSpec test code in suggestions (default: false)
       # suggest_tests: false
+
+      # Hooks: Ruby files returning a Proc, keyed by lifecycle event
+      # hooks:
+      #   worker_process_start: config/evilution_hooks/worker_start.rb
+      #   mutation_insert_pre: config/evilution_hooks/mutation_pre.rb
+
+      # AST patterns to skip during mutation generation (default: [])
+      # See docs/ast_pattern_syntax.md for pattern syntax
+      # ignore_patterns:
+      #   - "call{name=info, receiver=call{name=logger}}"
+      #   - "call{name=debug|warn}"
     YAML
   end
 
@@ -157,6 +170,8 @@ class Evilution::Config
     @save_session = merged[:save_session]
     @line_ranges = merged[:line_ranges] || {}
     @spec_files = Array(merged[:spec_files])
+    @ignore_patterns = validate_ignore_patterns(merged[:ignore_patterns])
+    @hooks = validate_hooks(merged[:hooks])
   end
 
   def validate_isolation(value)
@@ -180,6 +195,24 @@ class Evilution::Config
     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_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
   end

data/lib/evilution/hooks/loader.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../hooks"
+
+class Evilution::Hooks::Loader
+  def self.call(registry, config_hooks = nil)
+    return registry if config_hooks.nil?
+
+    unless config_hooks.is_a?(Hash)
+      raise Evilution::ConfigError, "hooks must be a mapping of event names to file paths, got #{config_hooks.class}"
+    end
+    return registry if config_hooks.empty?
+
+    config_hooks.each do |event, paths|
+      event = event.to_sym
+      Array(paths).each do |path|
+        handler = load_hook_file(path)
+        registry.register(event) { |payload| handler.call(payload) }
+      end
+    end
+
+    registry
+  end
+
+  def self.load_hook_file(path)
+    raise Evilution::ConfigError, "hook file not found: #{path}" unless File.exist?(path)
+
+    result = Module.new.module_eval(File.read(path), path, 1)
+    raise Evilution::ConfigError, "hook file #{path} must return a Proc, got #{result.class}" unless result.is_a?(Proc)
+
+    result
+  end
+
+  private_class_method :load_hook_file
+end

data/lib/evilution/hooks/registry.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "../hooks"
+
+class Evilution::Hooks::Registry
+  def initialize(on_error: nil)
+    @handlers = Evilution::Hooks::EVENTS.to_h { |event| [event, []] }
+    @on_error = on_error
+  end
+
+  def register(event, &block)
+    validate_event!(event)
+    raise ArgumentError, "a block must be provided when registering handler for #{event}" unless block
+
+    @handlers[event] << block
+    self
+  end
+
+  def fire(event, **payload)
+    validate_event!(event)
+    errors = []
+
+    @handlers[event].each do |handler|
+      handler.call(payload)
+    rescue StandardError => e
+      errors << e
+      report_error(event, e)
+    end
+
+    errors
+  end
+
+  def clear(event = nil)
+    if event
+      validate_event!(event)
+      @handlers[event].clear
+    else
+      @handlers.each_value(&:clear)
+    end
+  end
+
+  def handlers_for(event)
+    validate_event!(event)
+    @handlers[event].dup
+  end
+
+  private
+
+  def validate_event!(event)
+    raise ArgumentError, "unknown hook event: #{event}" unless Evilution::Hooks::EVENTS.include?(event)
+  end
+
+  def report_error(event, error)
+    if @on_error
+      @on_error.call(event, error)
+    else
+      warn "[evilution] hook error in #{event}: #{error.message}"
+    end
+  end
+end

data/lib/evilution/hooks.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+class Evilution::Hooks
+  EVENTS = %i[
+    worker_process_start
+    mutation_insert_pre
+    mutation_insert_post
+    setup_integration_pre
+    setup_integration_post
+  ].freeze
+
+  def initialize
+    @handlers = EVENTS.to_h { |event| [event, []] }
+  end
+
+  def register(event, &block)
+    validate_event!(event)
+    raise ArgumentError, "a block must be provided when registering handler for #{event}" unless block
+
+    @handlers[event] << block
+    self
+  end
+
+  def fire(event, **payload)
+    validate_event!(event)
+    @handlers[event].each { |handler| handler.call(payload) }
+  end
+
+  def clear(event = nil)
+    if event
+      validate_event!(event)
+      @handlers[event].clear
+    else
+      @handlers.each_value(&:clear)
+    end
+  end
+
+  def handlers_for(event)
+    validate_event!(event)
+    @handlers[event].dup
+  end
+
+  def self.from_config(config_hooks)
+    hooks = new
+    return hooks if config_hooks.nil? || config_hooks.empty?
+
+    config_hooks.each do |event, callables|
+      Array(callables).each { |callable| hooks.register(event) { |payload| callable.call(payload) } }
+    end
+    hooks
+  end
+
+  private
+
+  def validate_event!(event)
+    raise ArgumentError, "unknown hook event: #{event}" unless EVENTS.include?(event)
+  end
+end

data/lib/evilution/integration/base.rb

@@ -3,6 +3,10 @@
 require_relative "../integration"
 
 class Evilution::Integration::Base
+  def initialize(hooks: nil)
+    @hooks = hooks
+  end
+
   def call(mutation)
     raise NotImplementedError, "#{self.class}#call must be implemented"
   end

data/lib/evilution/integration/rspec.rb

@@ -9,10 +9,10 @@ require_relative "../spec_resolver"
 require_relative "../integration"
 
 class Evilution::Integration::RSpec < Evilution::Integration::Base
-  def initialize(test_files: nil)
+  def initialize(test_files: nil, hooks: nil)
     @test_files = test_files
     @rspec_loaded = false
-    super()
+    super(hooks: hooks)
   end
 
   def call(mutation)
@@ -20,7 +20,9 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     @temp_dir = nil
     @lock_file = nil
     ensure_rspec_loaded
+    @hooks.fire(:mutation_insert_pre, mutation: mutation, file_path: mutation.file_path) if @hooks
     apply_mutation(mutation)
+    @hooks.fire(:mutation_insert_post, mutation: mutation, file_path: mutation.file_path) if @hooks
     run_rspec(mutation)
   ensure
     restore_original(mutation)
@@ -33,8 +35,10 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
   def ensure_rspec_loaded
     return if @rspec_loaded
 
+    @hooks.fire(:setup_integration_pre, integration: :rspec) if @hooks
     require "rspec/core"
     @rspec_loaded = true
+    @hooks.fire(:setup_integration_post, integration: :rspec) if @hooks
   rescue LoadError => e
     raise Evilution::Error, "rspec-core is required but not available: #{e.message}"
   end

data/lib/evilution/isolation/fork.rb

@@ -9,6 +9,10 @@ require_relative "../isolation"
 class Evilution::Isolation::Fork
   GRACE_PERIOD = 2
 
+  def initialize(hooks: nil)
+    @hooks = hooks
+  end
+
   def call(mutation:, test_command:, timeout:)
     sandbox_dir = Dir.mktmpdir("evilution-run")
     start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
@@ -18,6 +22,7 @@ class Evilution::Isolation::Fork
       ENV["TMPDIR"] = sandbox_dir
       read_io.close
       suppress_child_output
+      @hooks.fire(:worker_process_start, mutation: mutation) if @hooks
       result = execute_in_child(mutation, test_command)
       Marshal.dump(result, write_io)
       write_io.close

data/lib/evilution/mutator/base.rb

@@ -13,10 +13,11 @@ class Evilution::Mutator::Base < Prism::Visitor
     @file_source = nil
   end
 
-  def call(subject)
+  def call(subject, filter: nil)
     @subject = subject
     @file_source = File.read(subject.file_path)
     @mutations = []
+    @filter = filter
     visit(subject.node)
     @mutations
   end
@@ -24,6 +25,8 @@ class Evilution::Mutator::Base < Prism::Visitor
   private
 
   def add_mutation(offset:, length:, replacement:, node:)
+    return if @filter && @filter.skip?(node)
+
     mutated_source = Evilution::AST::SourceSurgeon.apply(
       @file_source,
       offset: offset,

data/lib/evilution/mutator/operator/index_assignment_removal.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::IndexAssignmentRemoval < Evilution::Mutator::Base
+  def visit_call_node(node)
+    if node.name == :[]= && node.receiver
+      add_mutation(
+        offset: node.location.start_offset,
+        length: node.location.length,
+        replacement: "nil",
+        node: node
+      )
+    end
+
+    super
+  end
+end

data/lib/evilution/mutator/operator/index_to_dig.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::IndexToDig < Evilution::Mutator::Base
+  def initialize
+    super
+    @consumed = Set.new
+  end
+
+  def visit_call_node(node)
+    if chain_head?(node)
+      root, args = collect_chain(node)
+      root_source = @file_source[root.location.start_offset, root.location.length]
+      arg_sources = args.map { |a| @file_source[a.location.start_offset, a.location.length] }
+
+      add_mutation(
+        offset: node.location.start_offset,
+        length: node.location.length,
+        replacement: "#{root_source}.dig(#{arg_sources.join(", ")})",
+        node: node
+      )
+    end
+
+    super
+  end
+
+  private
+
+  def chain_head?(node)
+    return false if @consumed.include?(node.object_id)
+    return false unless single_arg_index?(node)
+    return false unless single_arg_index?(node.receiver)
+
+    true
+  end
+
+  def single_arg_index?(node)
+    node.is_a?(Prism::CallNode) &&
+      node.name == :[] &&
+      node.receiver &&
+      node.arguments &&
+      node.arguments.arguments.length == 1
+  end
+
+  def collect_chain(node)
+    args = []
+    current = node
+
+    while single_arg_index?(current)
+      @consumed.add(current.object_id)
+      args.unshift(current.arguments.arguments.first)
+      current = current.receiver
+    end
+
+    [current, args]
+  end
+end

data/lib/evilution/mutator/operator/index_to_fetch.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::IndexToFetch < Evilution::Mutator::Base
+  def visit_call_node(node)
+    if indexable?(node)
+      receiver_source = @file_source[node.receiver.location.start_offset, node.receiver.location.length]
+      arg_source = @file_source[node.arguments.location.start_offset, node.arguments.location.length]
+
+      add_mutation(
+        offset: node.location.start_offset,
+        length: node.location.length,
+        replacement: "#{receiver_source}.fetch(#{arg_source})",
+        node: node
+      )
+    end
+
+    super
+  end
+
+  private
+
+  def indexable?(node)
+    node.name == :[] &&
+      node.receiver &&
+      node.arguments &&
+      node.arguments.arguments.length == 1
+  end
+end

data/lib/evilution/mutator/operator/mixin_removal.rb

@@ -7,10 +7,11 @@ require_relative "../operator"
 class Evilution::Mutator::Operator::MixinRemoval < Evilution::Mutator::Base
   MIXIN_METHODS = %i[include extend prepend].freeze
 
-  def call(subject)
+  def call(subject, filter: nil)
     @subject = subject
     @file_source = File.read(subject.file_path)
     @mutations = []
+    @filter = filter
 
     tree = self.class.parsed_tree_for(subject.file_path, @file_source)
     enclosing = find_enclosing_scope(tree, subject.line_number)