evilution 0.13.0 → 0.15.0

data/lib/evilution/config.rb

@@ -2,174 +2,179 @@
 
 require "yaml"
 
-module Evilution
-  class 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,
-      line_ranges: {},
-      spec_files: []
-    }.freeze
-
-    attr_reader :target_files, :timeout, :format,
-                :target, :min_score, :integration, :verbose, :quiet,
-                :jobs, :fail_fast, :baseline, :isolation, :incremental, :suggest_tests,
-                :line_ranges, :spec_files
-
-    def initialize(**options)
-      file_options = options.delete(:skip_config_file) ? {} : load_config_file
-      merged = DEFAULTS.merge(file_options).merge(options)
-      assign_attributes(merged)
-      freeze
-    end
+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,
+    save_session: false,
+    line_ranges: {},
+    spec_files: []
+  }.freeze
+
+  attr_reader :target_files, :timeout, :format,
+              :target, :min_score, :integration, :verbose, :quiet,
+              :jobs, :fail_fast, :baseline, :isolation, :incremental, :suggest_tests,
+              :save_session, :line_ranges, :spec_files
+
+  def initialize(**options)
+    file_options = options.delete(:skip_config_file) ? {} : load_config_file
+    merged = DEFAULTS.merge(file_options).merge(options)
+    assign_attributes(merged)
+    freeze
+  end
 
-    def json?
-      format == :json
-    end
+  def json?
+    format == :json
+  end
 
-    def text?
-      format == :text
-    end
+  def text?
+    format == :text
+  end
 
-    def html?
-      format == :html
-    end
+  def html?
+    format == :html
+  end
 
-    def line_ranges?
-      !line_ranges.empty?
-    end
+  def line_ranges?
+    !line_ranges.empty?
+  end
 
-    def target?
-      !target.nil?
-    end
+  def target?
+    !target.nil?
+  end
 
-    def fail_fast?
-      !fail_fast.nil?
-    end
+  def fail_fast?
+    !fail_fast.nil?
+  end
 
-    def baseline?
-      baseline
-    end
+  def baseline?
+    baseline
+  end
 
-    def incremental?
-      incremental
-    end
+  def incremental?
+    incremental
+  end
 
-    def suggest_tests?
-      suggest_tests
-    end
+  def suggest_tests?
+    suggest_tests
+  end
 
-    def self.file_options
-      CONFIG_FILES.each do |path|
-        next unless File.exist?(path)
+  def save_session?
+    save_session
+  end
 
-        data = YAML.safe_load_file(path, symbolize_names: true)
-        return data.is_a?(Hash) ? data : {}
-      rescue Psych::SyntaxError, Psych::DisallowedClass => e
-        raise ConfigError.new("failed to parse config file #{path}: #{e.message}", file: path)
-      rescue SystemCallError => e
-        raise ConfigError.new("cannot read config file #{path}: #{e.message}", file: path)
-      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
 
-    # Generates a default config file template.
-    def self.default_template
-      <<~YAML
-        # Evilution configuration
-        # See: https://github.com/marinazzio/evilution
+    {}
+  end
 
-        # Per-mutation timeout in seconds (default: 30)
-        # timeout: 30
+  # Generates a default config file template.
+  def self.default_template
+    <<~YAML
+      # Evilution configuration
+      # See: https://github.com/marinazzio/evilution
 
-        # Output format: text or json (default: text)
-        # format: text
+      # Per-mutation timeout in seconds (default: 30)
+      # timeout: 30
 
-        # Minimum mutation score to pass (0.0 to 1.0, default: 0.0)
-        # min_score: 0.0
+      # Output format: text or json (default: text)
+      # format: text
 
-        # Test integration: rspec (default: rspec)
-        # integration: rspec
+      # Minimum mutation score to pass (0.0 to 1.0, default: 0.0)
+      # min_score: 0.0
 
-        # Number of parallel workers (default: 1)
-        # jobs: 1
+      # Test integration: rspec (default: rspec)
+      # integration: rspec
 
-        # Stop after N surviving mutants (default: disabled)
-        # fail_fast: 1
+      # Number of parallel workers (default: 1)
+      # jobs: 1
 
-        # Generate concrete RSpec test code in suggestions (default: false)
-        # suggest_tests: false
-      YAML
-    end
+      # Stop after N surviving mutants (default: disabled)
+      # fail_fast: 1
 
-    private
+      # Generate concrete RSpec test code in suggestions (default: false)
+      # suggest_tests: false
+    YAML
+  end
 
-    def validate_fail_fast(value)
-      return nil if value.nil?
+  private
 
-      value = Integer(value)
-      raise ConfigError, "fail_fast must be a positive integer, got #{value}" unless value >= 1
+  def validate_fail_fast(value)
+    return nil if value.nil?
 
-      value
-    rescue ::ArgumentError, ::TypeError
-      raise ConfigError, "fail_fast must be a positive integer, got #{value.inspect}"
-    end
+    value = Integer(value)
+    raise Evilution::ConfigError, "fail_fast must be a positive integer, got #{value}" unless value >= 1
 
-    def assign_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
-      @integration = merged[:integration].to_sym
-      @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]
-      @line_ranges = merged[:line_ranges] || {}
-      @spec_files = Array(merged[:spec_files])
-    end
+    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 = merged[:integration].to_sym
+    @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]
+    @save_session = merged[:save_session]
+    @line_ranges = merged[:line_ranges] || {}
+    @spec_files = Array(merged[:spec_files])
+  end
 
-    def validate_isolation(value)
-      raise ConfigError, "isolation must be auto, fork, or in_process, got nil" if value.nil?
+  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 ConfigError, "isolation must be auto, fork, or in_process, got #{value.inspect}" unless %i[auto fork in_process].include?(value)
+    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
+    value
+  end
 
-    def validate_jobs(value)
-      raise ConfigError, "jobs must be a positive integer, got #{value.inspect}" if value.is_a?(Float)
+  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 ConfigError, "jobs must be a positive integer, got #{value}" unless value >= 1
+    value = Integer(value)
+    raise Evilution::ConfigError, "jobs must be a positive integer, got #{value}" unless value >= 1
 
-      value
-    rescue ::ArgumentError, ::TypeError
-      raise ConfigError, "jobs must be a positive integer, got #{value.inspect}"
-    end
+    value
+  rescue ::ArgumentError, ::TypeError
+    raise Evilution::ConfigError, "jobs must be a positive integer, got #{value.inspect}"
+  end
 
-    def load_config_file
-      self.class.file_options
-    end
+  def load_config_file
+    self.class.file_options
   end
 end

data/lib/evilution/equivalent/detector.rb

@@ -4,39 +4,41 @@ require_relative "heuristic/noop_source"
 require_relative "heuristic/method_body_nil"
 require_relative "heuristic/alias_swap"
 require_relative "heuristic/dead_code"
+require_relative "heuristic/arithmetic_identity"
+require_relative "heuristic/comment_marking"
 
-module Evilution
-  module Equivalent
-    class Detector
-      def initialize(heuristics: nil)
-        @heuristics = heuristics || default_heuristics
-      end
+require_relative "../equivalent"
 
-      def call(mutations)
-        equivalent = []
-        remaining = []
+class Evilution::Equivalent::Detector
+  def initialize(heuristics: nil)
+    @heuristics = heuristics || default_heuristics
+  end
 
-        mutations.each do |mutation|
-          if @heuristics.any? { |h| h.match?(mutation) }
-            equivalent << mutation
-          else
-            remaining << mutation
-          end
-        end
+  def call(mutations)
+    equivalent = []
+    remaining = []
 
-        [equivalent, remaining]
+    mutations.each do |mutation|
+      if @heuristics.any? { |h| h.match?(mutation) }
+        equivalent << mutation
+      else
+        remaining << mutation
       end
+    end
 
-      private
+    [equivalent, remaining]
+  end
 
-      def default_heuristics
-        [
-          Heuristic::NoopSource.new,
-          Heuristic::MethodBodyNil.new,
-          Heuristic::AliasSwap.new,
-          Heuristic::DeadCode.new
-        ]
-      end
-    end
+  private
+
+  def default_heuristics
+    [
+      Evilution::Equivalent::Heuristic::NoopSource.new,
+      Evilution::Equivalent::Heuristic::MethodBodyNil.new,
+      Evilution::Equivalent::Heuristic::AliasSwap.new,
+      Evilution::Equivalent::Heuristic::DeadCode.new,
+      Evilution::Equivalent::Heuristic::ArithmeticIdentity.new,
+      Evilution::Equivalent::Heuristic::CommentMarking.new
+    ]
   end
 end

data/lib/evilution/equivalent/heuristic/alias_swap.rb

@@ -1,37 +1,36 @@
 # frozen_string_literal: true
 
-module Evilution
-  module Equivalent
-    module Heuristic
-      class AliasSwap
-        ALIAS_PAIRS = Set[
-          Set[:detect, :find],
-          Set[:length, :size],
-          Set[:collect, :map]
-        ].freeze
-
-        def match?(mutation)
-          return false unless mutation.operator_name == "send_mutation"
-
-          diff = mutation.diff
-          removed = extract_method(diff, "- ")
-          added = extract_method(diff, "+ ")
-          return false unless removed && added
-
-          pair = Set[removed.to_sym, added.to_sym]
-          ALIAS_PAIRS.include?(pair)
-        end
-
-        private
-
-        def extract_method(diff, prefix)
-          line = diff.split("\n").find { |l| l.start_with?(prefix) }
-          return nil unless line
-
-          match = line.match(/\.(\w+)(?:[\s(]|$)/)
-          match && match[1]
-        end
-      end
-    end
+require_relative "../heuristic"
+
+class Evilution::Equivalent::Heuristic::AliasSwap
+  ALIAS_PAIRS = Set[
+    Set[:detect, :find],
+    Set[:length, :size],
+    Set[:collect, :map],
+    Set[:count, :length]
+  ].freeze
+
+  MATCHING_OPERATORS = Set["send_mutation", "collection_replacement"].freeze
+
+  def match?(mutation)
+    return false unless MATCHING_OPERATORS.include?(mutation.operator_name)
+
+    diff = mutation.diff
+    removed = extract_method(diff, "- ")
+    added = extract_method(diff, "+ ")
+    return false unless removed && added
+
+    pair = Set[removed.to_sym, added.to_sym]
+    ALIAS_PAIRS.include?(pair)
+  end
+
+  private
+
+  def extract_method(diff, prefix)
+    line = diff.split("\n").find { |l| l.start_with?(prefix) }
+    return nil unless line
+
+    match = line.match(/\.(\w+)(?:[\s(]|$)/)
+    match && match[1]
   end
 end

data/lib/evilution/equivalent/heuristic/arithmetic_identity.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../heuristic"
+
+class Evilution::Equivalent::Heuristic::ArithmeticIdentity
+  # Patterns where the original expression is an arithmetic identity operation.
+  # "x + 0" is identity (equals x), so mutating the 0 to something else means
+  # the original was a no-op — if the test doesn't catch it, it's likely equivalent.
+  ADDITIVE_IDENTITY = /[\w)\].]+\s*[+-]\s*0\b|\b0\s*\+\s*[\w(\[]/
+  MULTIPLICATIVE_IDENTITY = %r{[\w)\].]+\s*[*/]\s*1\b|\b1\s*\*\s*[\w(\[]}
+  EXPONENT_IDENTITY = /[\w)\].]+\s*\*\*\s*1\b/
+
+  def match?(mutation)
+    return false unless mutation.operator_name == "integer_literal"
+
+    removed = diff_line(mutation.diff, "- ")
+    return false unless removed
+
+    content = removed.sub(/^- /, "")
+    content.match?(ADDITIVE_IDENTITY) ||
+      content.match?(MULTIPLICATIVE_IDENTITY) ||
+      content.match?(EXPONENT_IDENTITY)
+  end
+
+  private
+
+  def diff_line(diff, prefix)
+    diff.split("\n").find { |l| l.start_with?(prefix) }
+  end
+end

data/lib/evilution/equivalent/heuristic/comment_marking.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "../heuristic"
+
+class Evilution::Equivalent::Heuristic::CommentMarking
+  MARKER = /#\s*evilution:equivalent\b/
+
+  def match?(mutation)
+    source = mutation.original_source
+    return false unless source
+
+    lines = source.lines
+    line_index = mutation.line - 1
+    return false if line_index.negative? || line_index >= lines.length
+
+    return true if lines[line_index].match?(MARKER)
+    return true if line_index.positive? && lines[line_index - 1].match?(MARKER)
+
+    false
+  end
+end

data/lib/evilution/equivalent/heuristic/dead_code.rb

@@ -1,51 +1,47 @@
 # frozen_string_literal: true
 
-module Evilution
-  module Equivalent
-    module Heuristic
-      class DeadCode
-        def match?(mutation)
-          return false unless mutation.operator_name == "statement_deletion"
-
-          node = mutation.subject.node
-          return false unless node
-
-          body = node.body
-          return false unless body.is_a?(Prism::StatementsNode)
-
-          statements = body.body
-          unreachable_lines = find_unreachable_lines(statements)
-          unreachable_lines.include?(mutation.line)
-        end
-
-        private
-
-        def find_unreachable_lines(statements)
-          lines = Set.new
-          found_unconditional_return = false
-
-          statements.each do |stmt|
-            if found_unconditional_return
-              collect_lines(stmt, lines)
-            elsif unconditional_return?(stmt)
-              found_unconditional_return = true
-            end
-          end
-
-          lines
-        end
-
-        def unconditional_return?(node)
-          node.is_a?(Prism::ReturnNode) ||
-            (node.is_a?(Prism::CallNode) && node.name == :raise)
-        end
-
-        def collect_lines(node, lines)
-          start_line = node.location.start_line
-          end_line = node.location.end_line
-          (start_line..end_line).each { |l| lines.add(l) }
-        end
+require_relative "../heuristic"
+
+class Evilution::Equivalent::Heuristic::DeadCode
+  def match?(mutation)
+    return false unless mutation.operator_name == "statement_deletion"
+
+    node = mutation.subject.node
+    return false unless node
+
+    body = node.body
+    return false unless body.is_a?(Prism::StatementsNode)
+
+    statements = body.body
+    unreachable_lines = find_unreachable_lines(statements)
+    unreachable_lines.include?(mutation.line)
+  end
+
+  private
+
+  def find_unreachable_lines(statements)
+    lines = Set.new
+    found_unconditional_return = false
+
+    statements.each do |stmt|
+      if found_unconditional_return
+        collect_lines(stmt, lines)
+      elsif unconditional_return?(stmt)
+        found_unconditional_return = true
       end
     end
+
+    lines
+  end
+
+  def unconditional_return?(node)
+    node.is_a?(Prism::ReturnNode) ||
+      (node.is_a?(Prism::CallNode) && node.name == :raise)
+  end
+
+  def collect_lines(node, lines)
+    start_line = node.location.start_line
+    end_line = node.location.end_line
+    (start_line..end_line).each { |l| lines.add(l) }
   end
 end

data/lib/evilution/equivalent/heuristic/method_body_nil.rb

@@ -1,23 +1,19 @@
 # frozen_string_literal: true
 
-module Evilution
-  module Equivalent
-    module Heuristic
-      class MethodBodyNil
-        def match?(mutation)
-          return false unless mutation.operator_name == "method_body_replacement"
+require_relative "../heuristic"
 
-          node = mutation.subject.node
-          return false unless node
+class Evilution::Equivalent::Heuristic::MethodBodyNil
+  def match?(mutation)
+    return false unless mutation.operator_name == "method_body_replacement"
 
-          body = node.body
-          return true if body.nil? || body.is_a?(Prism::NilNode)
+    node = mutation.subject.node
+    return false unless node
 
-          return body.body.first.is_a?(Prism::NilNode) if body.is_a?(Prism::StatementsNode) && body.body.length == 1
+    body = node.body
+    return true if body.nil? || body.is_a?(Prism::NilNode)
 
-          false
-        end
-      end
-    end
+    return body.body.first.is_a?(Prism::NilNode) if body.is_a?(Prism::StatementsNode) && body.body.length == 1
+
+    false
   end
 end

data/lib/evilution/equivalent/heuristic/noop_source.rb

@@ -1,13 +1,9 @@
 # frozen_string_literal: true
 
-module Evilution
-  module Equivalent
-    module Heuristic
-      class NoopSource
-        def match?(mutation)
-          mutation.original_source == mutation.mutated_source
-        end
-      end
-    end
+require_relative "../heuristic"
+
+class Evilution::Equivalent::Heuristic::NoopSource
+  def match?(mutation)
+    mutation.original_source == mutation.mutated_source
   end
 end

data/lib/evilution/equivalent/heuristic.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "../equivalent"
+
+module Evilution::Equivalent::Heuristic
+end