evilution 0.24.0 → 0.26.0

data/lib/evilution/reporter/html/sections/unparseable_details.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "../sections"
+
+class Evilution::Reporter::HTML::Sections::UnparseableDetails < Evilution::Reporter::HTML::Section
+  template "unparseable_details"
+
+  def self.render_if(unparseable)
+    return "" if unparseable.empty?
+
+    new(unparseable).render
+  end
+
+  def initialize(unparseable)
+    @unparseable = unparseable
+  end
+
+  private
+
+  attr_reader :unparseable
+
+  def sorted
+    unparseable.sort_by { |r| [r.mutation.operator_name, r.mutation.line] }
+  end
+end

data/lib/evilution/reporter/html/sections/unresolved_details.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "../sections"
+
+class Evilution::Reporter::HTML::Sections::UnresolvedDetails < Evilution::Reporter::HTML::Section
+  template "unresolved_details"
+
+  def self.render_if(unresolved)
+    return "" if unresolved.empty?
+
+    new(unresolved).render
+  end
+
+  def initialize(unresolved)
+    @unresolved = unresolved
+  end
+
+  private
+
+  attr_reader :unresolved
+
+  def sorted
+    unresolved.sort_by { |r| [r.mutation.operator_name, r.mutation.line] }
+  end
+end

data/lib/evilution/reporter/html/templates/file_section.html.erb

@@ -6,4 +6,7 @@
   <div class="mutation-map"><%= map_html %></div>
   <%= survived_html %>
   <%= error_html %>
+  <%= neutral_html %>
+  <%= unresolved_html %>
+  <%= unparseable_html %>
 </section>

data/lib/evilution/reporter/html/templates/neutral_details.html.erb

@@ -0,0 +1,14 @@
+<div class="neutral-details">
+  <h3>Neutral (<%= neutral.length %>) — test infra error, excluded from score</h3>
+  <ul>
+    <%- sorted.each do |r| -%>
+    <li>
+      <span class="operator"><%= h(r.mutation.operator_name) %></span>
+      <span class="location"><%= h(r.mutation.file_path) %>:<%= r.mutation.line %></span>
+      <%- if r.error_class -%>
+      <span class="error-class">(<%= h(r.error_class) %>)</span>
+      <%- end -%>
+    </li>
+    <%- end -%>
+  </ul>
+</div>

data/lib/evilution/reporter/html/templates/summary_cards.html.erb

@@ -9,6 +9,9 @@
   <%- if @summary.unresolved.positive? -%>
   <div class="card"><span class="card-value"><%= @summary.unresolved %></span><span class="card-label">Unresolved</span></div>
   <%- end -%>
+  <%- if @summary.unparseable.positive? -%>
+  <div class="card"><span class="card-value"><%= @summary.unparseable %></span><span class="card-label">Unparseable</span></div>
+  <%- end -%>
   <%- if @summary.skipped.positive? -%>
   <div class="card"><span class="card-value"><%= @summary.skipped %></span><span class="card-label">Skipped</span></div>
   <%- end -%>

data/lib/evilution/reporter/html/templates/unparseable_details.html.erb

@@ -0,0 +1,11 @@
+<div class="unparseable-details">
+  <h3>Unparseable (<%= unparseable.length %>) — mutated source did not parse</h3>
+  <ul>
+    <%- sorted.each do |r| -%>
+    <li>
+      <span class="operator"><%= h(r.mutation.operator_name) %></span>
+      <span class="location"><%= h(r.mutation.file_path) %>:<%= r.mutation.line %></span>
+    </li>
+    <%- end -%>
+  </ul>
+</div>

data/lib/evilution/reporter/html/templates/unresolved_details.html.erb

@@ -0,0 +1,11 @@
+<div class="unresolved-details">
+  <h3>Unresolved (<%= unresolved.length %>) — no test file resolved</h3>
+  <ul>
+    <%- sorted.each do |r| -%>
+    <li>
+      <span class="operator"><%= h(r.mutation.operator_name) %></span>
+      <span class="location"><%= h(r.mutation.file_path) %>:<%= r.mutation.line %></span>
+    </li>
+    <%- end -%>
+  </ul>
+</div>

data/lib/evilution/reporter/json.rb

@@ -29,7 +29,8 @@ class Evilution::Reporter::JSON
       timed_out: map_details(summary.results.select(&:timeout?)),
       errors: map_details(summary.results.select(&:error?)),
       equivalent: map_details(summary.equivalent_results),
-      unresolved: map_details(summary.unresolved_results)
+      unresolved: map_details(summary.unresolved_results),
+      unparseable: map_details(summary.unparseable_results)
     }
     append_disabled_to_report(report, summary)
     report
@@ -55,6 +56,7 @@ class Evilution::Reporter::JSON
       neutral: summary.neutral,
       equivalent: summary.equivalent,
       unresolved: summary.unresolved,
+      unparseable: summary.unparseable,
       score: summary.score.round(4),
       duration: summary.duration.round(4),
       killtime: summary.killtime.round(4),
@@ -78,7 +80,11 @@ class Evilution::Reporter::JSON
       duration: result.duration.round(4),
       diff: mutation.diff
     }
-    detail[:suggestion] = @suggestion.suggestion_for(mutation) if result.status == :survived
+    if result.status == :survived
+      detail[:suggestion] = @suggestion.suggestion_for(mutation)
+      unified = mutation.unified_diff
+      detail[:unified_diff] = unified if unified
+    end
     detail[:test_command] = result.test_command if result.test_command
     append_memory_fields(detail, result)
     append_error_fields(detail, result)

data/lib/evilution/reporter/suggestion/diff_helpers.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "../suggestion"
+
+module Evilution::Reporter::Suggestion::DiffHelpers
+  module_function
+
+  def parse_method_name(subject_name)
+    subject_name.split(/[#.]/).last
+  end
+
+  def sanitize_method_name(name)
+    name.gsub(/[^a-zA-Z0-9_]/, "_").gsub(/_+/, "_").gsub(/\A_|_\z/, "")
+  end
+
+  def extract_diff_lines(diff)
+    lines = diff.split("\n")
+    original = lines.find { |l| l.start_with?("- ") }
+    mutated = lines.find { |l| l.start_with?("+ ") }
+    [clean_diff_line(original, "- "), clean_diff_line(mutated, "+ ")]
+  end
+
+  def clean_diff_line(line, prefix)
+    return nil if line.nil?
+
+    line.sub(/^#{Regexp.escape(prefix)}/, "").strip
+  end
+end

data/lib/evilution/reporter/suggestion/registry.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "../suggestion"
+
+# rubocop:disable Style/OneClassPerFile
+module Evilution::Reporter::Suggestion::Templates
+end
+
+class Evilution::Reporter::Suggestion::Registry
+  # rubocop:enable Style/OneClassPerFile
+  def self.default
+    return @default if @default
+
+    require_relative "templates/generic"
+    require_relative "templates/rspec"
+    require_relative "templates/minitest"
+
+    registry = new
+    Evilution::Reporter::Suggestion::Templates::Generic::GENERIC_ENTRIES.each do |op, text|
+      registry.register_generic(op, text)
+    end
+    Evilution::Reporter::Suggestion::Templates::Rspec::RSPEC_ENTRIES.each do |op, blk|
+      registry.register_concrete(op, integration: :rspec, block: blk)
+    end
+    Evilution::Reporter::Suggestion::Templates::Minitest::MINITEST_ENTRIES.each do |op, blk|
+      registry.register_concrete(op, integration: :minitest, block: blk)
+    end
+
+    @default = registry
+  end
+
+  def self.reset!
+    @default = nil
+  end
+
+  def initialize
+    @generic = {}
+    @concrete = Hash.new { |h, k| h[k] = {} }
+  end
+
+  def register_generic(operator_name, text)
+    @generic[operator_name] = text
+    self
+  end
+
+  def register_concrete(operator_name, integration:, block:)
+    @concrete[integration][operator_name] = block
+    self
+  end
+
+  def generic(operator_name)
+    @generic[operator_name]
+  end
+
+  def concrete(operator_name, integration:)
+    @concrete.fetch(integration, {})[operator_name]
+  end
+
+  def each_generic_operator(&)
+    return @generic.each_key unless block_given?
+
+    @generic.each_key(&)
+  end
+end

data/lib/evilution/reporter/suggestion/templates/generic.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "../registry"
+
+module Evilution::Reporter::Suggestion::Templates::Generic
+  GENERIC_ENTRIES = {
+    "comparison_replacement" => "Add a test for the boundary condition where the comparison operand equals the threshold exactly",
+    "arithmetic_replacement" => "Add a test that verifies the arithmetic result, not just truthiness of the outcome",
+    "boolean_operator_replacement" => "Add a test where only one of the boolean conditions is true to distinguish && from ||",
+    "boolean_literal_replacement" => "Add a test that exercises the false/true branch explicitly",
+    "nil_replacement" => "Add a test that asserts the return value is not nil",
+    "integer_literal" => "Add a test that checks the exact numeric value, not just > 0 or truthy",
+    "float_literal" => "Add a test that checks the exact floating-point value returned",
+    "string_literal" => "Add a test that asserts the string content, not just its presence",
+    "array_literal" => "Add a test that verifies the array contents or length",
+    "hash_literal" => "Add a test that verifies the hash keys and values",
+    "symbol_literal" => "Add a test that checks the exact symbol returned",
+    "conditional_negation" => "Add tests for both the true and false branches of this conditional",
+    "conditional_branch" => "Add a test that exercises the removed branch of this conditional",
+    "statement_deletion" => "Add a test that depends on the side effect of this statement",
+    "method_body_replacement" => "Add a test that checks the method's return value or side effects",
+    "negation_insertion" => "Add a test where the predicate result matters (not just truthiness)",
+    "return_value_removal" => "Add a test that uses the return value of this method",
+    "collection_replacement" => "Add a test that checks the return value of the collection operation, not just side effects",
+    "method_call_removal" => "Add a test that depends on the return value or side effect of this method call",
+    "argument_removal" => "Add a test that verifies the correct arguments are passed to this method call",
+    "compound_assignment" => "Add a test that verifies the side effect of this compound assignment (the accumulated value matters)",
+    "superclass_removal" => "Add a test that exercises inherited behavior from the superclass",
+    "mixin_removal" => "Add a test that exercises behavior provided by the included/extended module",
+    "local_variable_assignment" => "Add a test that depends on the assigned variable being stored, not just the value expression",
+    "instance_variable_write" => "Add a test that verifies the instance variable is set correctly, not just the return value",
+    "class_variable_write" => "Add a test that verifies the class variable is set correctly and affects shared state",
+    "global_variable_write" => "Add a test that verifies the global variable is set correctly, not just the value expression",
+    "rescue_removal" => "Add a test that triggers the rescued exception and verifies the rescue handler behavior",
+    "rescue_body_replacement" => "Add a test that triggers the rescued exception and verifies the rescue body produces the correct result",
+    "inline_rescue" => "Add a test that triggers the inline rescue and verifies the fallback value is used correctly",
+    "ensure_removal" => "Add a test that verifies the ensure cleanup code runs and its side effects are observable",
+    "break_statement" => "Add a test that verifies the break condition and the value returned when the loop exits early",
+    "next_statement" => "Add a test that verifies the next condition and the value yielded when the iteration skips",
+    "redo_statement" => "Add a test that verifies the redo restarts the iteration and the retry logic is necessary",
+    "bang_method" => "Add a test that distinguishes in-place mutation from copy semantics (bang vs non-bang)",
+    "bitwise_replacement" => "Add a test that checks the exact bitwise result to distinguish &, |, and ^ operators",
+    "bitwise_complement" => "Add a test that verifies the bitwise complement (~) result, not just the sign or magnitude",
+    "zsuper_removal" => "Add a test that verifies inherited behavior from super is needed, not just the subclass logic",
+    "explicit_super_mutation" => "Add a test that verifies the correct arguments are passed to super and the inherited result matters",
+    "index_to_fetch" => "Add a test that distinguishes [] (returns nil for missing keys) from .fetch (raises KeyError)",
+    "index_to_dig" => "Add a test that verifies chained [] access returns the correct nested value",
+    "index_assignment_removal" => "Add a test that verifies the []= assignment side effect is observable (the collection is modified)",
+    "pattern_matching_guard" => "Add a test with input that matches the pattern but fails the guard to verify filtering",
+    "pattern_matching_alternative" => "Add a test with input that matches only one specific alternative to verify each branch is reachable",
+    "pattern_matching_array" => "Add a test that verifies each element position in the array pattern matches the expected type or value",
+    "collection_return" => "Add a test that verifies the method returns a non-empty collection, not just any array or hash",
+    "scalar_return" => "Add a test that verifies the method returns a non-zero/non-empty scalar value, not just any type"
+  }.freeze
+end