evilution 1.0.0 → 1.2.0

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a whole method body with a bare `raise`: `def foo; body; end` becomes
+# `def foo; raise; end`.
+#
+# A survivor means no example ever calls the method on a path it asserts, so
+# the method is either dead or reached only where the suite looks away. Where
+# body-to-nil (MethodBodyReplacement) asks whether the return value matters,
+# this asks the prior question of whether the call happens at all — a method
+# whose result is discarded survives the nil mutation but not this one.
+class Evilution::Mutator::Operator::MethodBodyToRaise < Evilution::Mutator::Base
+  def visit_def_node(node)
+    replace_body_with_raise(node)
+    super
+  end
+
+  private
+
+  def replace_body_with_raise(node)
+    statements = body_statements(node.body)
+    return if statements.nil?
+    return if single_raise?(statements)
+
+    location = statements.location
+
+    add_mutation(
+      offset: location.start_offset,
+      length: location.length,
+      replacement: "raise",
+      node: node
+    )
+  end
+
+  # A method-level rescue/ensure (`def foo; stmts; rescue; ...; end`) makes the
+  # body a BeginNode whose location spans the entire `def...end`, keyword and
+  # matching `end` included. Replacing that range would delete the method
+  # framing and leave a bare `raise` at the enclosing scope, so only the leading
+  # statements are replaceable. Returns nil for a rescue/ensure-only body, where
+  # there are none, and for an empty method, whose body is nil outright.
+  def body_statements(body)
+    return body unless body.is_a?(Prism::BeginNode)
+
+    body.statements
+  end
+
+  # A body that already consists of one unconditional raise would mutate to a
+  # near-equivalent: `raise NotImplementedError` -> `raise` only changes the
+  # error class, which is what RaiseArgumentStrip (#1537) probes. Arguments are
+  # not inspected, so a bare raise is skipped on the same rule.
+  def single_raise?(statements)
+    body = statements.body
+    return false unless body.length == 1
+
+    only = body.first
+    only.is_a?(Prism::CallNode) && only.name == :raise && only.receiver.nil?
+  end
+end

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

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../operator"
+
+# Replace a whole method body with a bare `super`: `def foo; body; end` becomes
+# `def foo; super; end`.
+#
+# A survivor means the body adds nothing the suite asserts over whatever
+# ancestor implementation it might be overriding. MethodBodyReplacement emits
+# the same replacement, but only for a body that already calls super, so a plain
+# override — the case worth probing — is never reached by it.
+#
+# `super` needs somewhere to go: without one the mutant raises NoMethodError and
+# dies on contact, which scores a kill that proves nothing. Emission is
+# therefore limited to methods whose enclosing scope has a plausible super
+# chain: an explicit superclass, or a mixin in the right position for that kind
+# of method (include/prepend for instance methods, extend for singleton ones).
+# Whether an ancestor actually defines this method name cannot be known from the
+# source, so a class that inherits or mixes in anything qualifies.
+class Evilution::Mutator::Operator::MethodBodyToSuper < Evilution::Mutator::Base
+  INSTANCE_MIXINS = %i[include prepend].freeze
+  SINGLETON_MIXINS = %i[extend].freeze
+
+  def visit_def_node(node)
+    replace_body_with_super(node)
+    super
+  end
+
+  private
+
+  def replace_body_with_super(node)
+    statements = body_statements(node.body)
+    return if statements.nil?
+    return if calls_super?(statements)
+    return unless super_target?(node)
+
+    location = statements.location
+
+    add_mutation(
+      offset: location.start_offset,
+      length: location.length,
+      replacement: "super",
+      node: node
+    )
+  end
+
+  # A method-level rescue/ensure (`def foo; stmts; rescue; ...; end`) makes the
+  # body a BeginNode whose location spans the entire `def...end`, keyword and
+  # matching `end` included. Replacing that range would delete the method
+  # framing, so only the leading statements are replaceable. Returns nil for a
+  # rescue/ensure-only body and for an empty method, whose body is nil.
+  def body_statements(body)
+    return body unless body.is_a?(Prism::BeginNode)
+
+    body.statements
+  end
+
+  # MethodBodyReplacement owns bodies that already reach for the parent
+  # implementation; emitting here would attribute one mutation to two operators.
+  #
+  # The search stops at a nested def, whose `super` belongs to that method
+  # rather than to the body being mutated. A nested class or module would be a
+  # boundary too, but Ruby rejects both inside a method body, so a def is the
+  # only one reachable here. A block is not a boundary: `values.map { super }`
+  # still calls the enclosing method's parent.
+  def calls_super?(node)
+    return true if node.is_a?(Prism::SuperNode) || node.is_a?(Prism::ForwardingSuperNode)
+
+    node.child_nodes.any? do |child|
+      child && !child.is_a?(Prism::DefNode) && calls_super?(child)
+    end
+  end
+
+  # `def self.foo` and a def inside `class << self` both define singleton
+  # methods, which inherit through the singleton class: an explicit superclass
+  # carries them, `extend` mixes into them, `include`/`prepend` do not.
+  def super_target?(def_node)
+    scope = enclosing_scope(def_node)
+    return false unless scope
+
+    singleton = def_node.receiver || scope[:singleton]
+    return true if scope[:node].is_a?(Prism::ClassNode) && scope[:node].superclass
+
+    mixins = singleton ? SINGLETON_MIXINS : INSTANCE_MIXINS
+    mixin?(scope[:node], mixins)
+  end
+
+  # The innermost class or module containing the def. A `class << self` body is
+  # transparent to the search — the mixins that matter live in the class around
+  # it — but it marks everything inside as a singleton method.
+  def enclosing_scope(def_node)
+    tree = self.class.parsed_tree_for(@subject.file_path, @file_source)
+    finder = ScopeFinder.new(def_node.location.start_line)
+    finder.visit(tree)
+    finder.result
+  end
+
+  # A scope is only consulted once a def was found inside it, so its body is
+  # never nil here. A bare `include` with nothing to mix in parses with a nil
+  # arguments node, which is what separates it from a real mixin call.
+  def mixin?(scope_node, names)
+    scope_node.body.body.any? do |child|
+      child.is_a?(Prism::CallNode) && child.receiver.nil? &&
+        names.include?(child.name) && child.arguments
+    end
+  end
+
+  # Visitor that reports the innermost class/module enclosing a line, and
+  # whether that line sits inside a `class << self` body.
+  class ScopeFinder < Prism::Visitor
+    def initialize(target_line)
+      @target_line = target_line
+      @scope = nil
+      @singleton = false
+      super()
+    end
+
+    # The enclosing scope and the `class << self` flag are collected
+    # independently: the class node is visited before the singleton-class body
+    # inside it, so a flag read at that point would always be false.
+    def result
+      return nil unless @scope
+
+      { node: @scope, singleton: @singleton }
+    end
+
+    def visit_class_node(node)
+      @scope = node if covers?(node)
+      super
+    end
+
+    def visit_module_node(node)
+      @scope = node if covers?(node)
+      super
+    end
+
+    def visit_singleton_class_node(node)
+      @singleton = true if covers?(node)
+      super
+    end
+
+    private
+
+    def covers?(node)
+      @target_line.between?(node.location.start_line, node.location.end_line)
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../operator"
+
+# Reassign an optional parameter to its own default at the top of the body:
+# `def f(a = 1); body; end` becomes `def f(a = 1); a = 1; body; end`.
+#
+# Whatever a caller passed is overwritten, so the mutant survives only where
+# every example already passes the default — or passes a value the assertions
+# never distinguish from it. Where OptionalParameterToRequired asks whether the
+# default is ever used, this asks the opposite question: whether any other value
+# ever is.
+#
+# The parameter must be read somewhere in the body, otherwise overwriting it
+# changes nothing and the mutant would survive every suite. An endless method is
+# left alone: its body is a single expression, and putting a second statement in
+# front of it would change what the method returns rather than what it computes.
+# KeywordArgument owns optional keyword parameters, and a block's optional
+# parameter is left alone for the same reason it is elsewhere — a block ignores
+# arity, so the default is not a contract.
+class Evilution::Mutator::Operator::OptionalDefaultInjection < Evilution::Mutator::Base
+  def visit_def_node(node)
+    inject_defaults(node)
+    super
+  end
+
+  private
+
+  def inject_defaults(node)
+    return if node.equal_loc
+    return unless node.parameters
+
+    statements = body_statements(node.body)
+    return if statements.nil?
+
+    node.parameters.optionals.each { |optional| inject_default(optional, node.body, statements) }
+  end
+
+  # The read is looked for across the whole body, rescue and ensure clauses
+  # included, since a parameter read only in a rescue clause is still read. The
+  # injection itself goes ahead of the leading statements, which is the only
+  # place a statement can be added.
+  def inject_default(optional, body, statements)
+    name = optional.name.to_s
+    return if name.start_with?("_")
+    return unless Evilution::AST::LocalReads.new.call(body, name)
+
+    first = statements.body.first.location
+
+    add_mutation(
+      offset: first.start_offset,
+      length: 0,
+      replacement: "#{source_of(optional)}; ",
+      node: optional
+    )
+  end
+
+  # A method-level rescue/ensure (`def foo; stmts; rescue; ...; end`) makes the
+  # body a BeginNode whose location spans the entire `def...end`. The injection
+  # belongs ahead of the leading statements; returns nil for a rescue/ensure-only
+  # body and for an empty method, whose body is nil. A body that holds no
+  # statements is always nil rather than an empty StatementsNode, so a present
+  # node always has a first statement to inject ahead of.
+  def body_statements(body)
+    return body unless body.is_a?(Prism::BeginNode)
+
+    body.statements
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../operator"
+
+# Drop the default of an optional positional parameter, making it required:
+# `def f(a = 1)` becomes `def f(a)`.
+#
+# A survivor means no example calls the method without that argument, so the
+# default is never exercised and the value it supplies is unasserted. Callers
+# that pass the argument are unaffected, which is what separates this from a
+# mutation that breaks every call site.
+#
+# Ruby allows a required parameter to follow an optional one, so each optional
+# is mutated on its own and the rest of the signature stays as written.
+# KeywordArgument owns optional keyword parameters. Blocks are left alone: a
+# block ignores arity, so a missing argument arrives as nil rather than raising,
+# and making its parameter required would change nothing.
+class Evilution::Mutator::Operator::OptionalParameterToRequired < Evilution::Mutator::Base
+  def visit_def_node(node)
+    parameters = node.parameters
+    parameters.optionals.each { |optional| require_parameter(optional) } if parameters
+
+    super
+  end
+
+  private
+
+  def require_parameter(node)
+    location = node.location
+    name_loc = node.name_loc
+
+    add_mutation(
+      offset: location.start_offset,
+      length: location.length,
+      replacement: byteslice_source(name_loc.start_offset, name_loc.length),
+      node: node
+    )
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a one-line pattern match with `false`: `x in Integer` becomes
+# `false`.
+#
+# The mutant differs from the original only on inputs the pattern actually
+# matches, so a survivor means no test ever feeds it a matching value -- the
+# true path of the predicate is unexercised.
+#
+# Only Prism::MatchPredicateNode is mutated. Its sibling MatchRequiredNode
+# (`x => Integer`) raises NoMatchingPatternError rather than returning a
+# boolean, so `false` would not stand in for it.
+class Evilution::Mutator::Operator::PatternPredicate < Evilution::Mutator::Base
+  def visit_match_predicate_node(node)
+    location = node.location
+
+    add_mutation(
+      offset: location.start_offset,
+      length: location.length,
+      replacement: "false",
+      node: node
+    )
+
+    super
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../operator"
+
+# Replace a single-expression method body with the empty value of the type it
+# returns: `def names(users); users.map(&:name); end` becomes
+# `def names(users); []; end`.
+#
+# A survivor means the suite asserts the shape of the returned value but never
+# its content — a test that only checks `be_an(Array)`, or that calls the method
+# for its side effects and ignores what comes back.
+#
+# CollectionReturn and ScalarReturn do this for bodies of two or more
+# statements, and the literal operators (array_literal, hash_literal,
+# string_literal, integer_literal, float_literal) cover a body that is itself a
+# literal. What neither reaches is the single-expression body whose type is not
+# written down — the common shape of readers and builders — so the type is taken
+# from the trailing call's selector instead.
+#
+# Only selectors whose return type is fixed by Ruby (or a widely-used extension with a stable contract,
+# e.g. ActiveSupport's `index_by`) are listed.
+# A method of the same name defined elsewhere can still return something else,
+# in which case the mutant raises where it is consumed and dies on contact; the
+# table is kept narrow to make that rare.
+class Evilution::Mutator::Operator::TypedDefaultReturn < Evilution::Mutator::Base
+  SELECTOR_TYPES = {
+    "[]" => %i[map collect select filter reject sort sort_by to_a compact flatten values keys uniq],
+    "{}" => %i[to_h group_by tally index_by transform_values transform_keys],
+    "0" => %i[count size length],
+    '""' => %i[to_s join upcase downcase strip]
+  }.freeze
+
+  REPLACEMENT_BY_SELECTOR = SELECTOR_TYPES.flat_map do |replacement, selectors|
+    selectors.map { |selector| [selector, replacement] }
+  end.to_h.freeze
+  private_constant :REPLACEMENT_BY_SELECTOR
+
+  def visit_def_node(node)
+    replace_body_with_default(node)
+    super
+  end
+
+  private
+
+  def replace_body_with_default(node)
+    statements = body_statements(node.body)
+    return if statements.nil?
+    return unless statements.body.length == 1
+
+    replacement = default_for(statements.body.first)
+    return if replacement.nil?
+
+    location = statements.location
+
+    add_mutation(
+      offset: location.start_offset,
+      length: location.length,
+      replacement: replacement,
+      node: node
+    )
+  end
+
+  # A method-level rescue/ensure (`def foo; stmts; rescue; ...; end`) makes the
+  # body a BeginNode whose location spans the entire `def...end`, keyword and
+  # matching `end` included. Replacing that range would delete the method
+  # framing, so only the leading statements are replaceable. Returns nil for a
+  # rescue/ensure-only body and for an empty method, whose body is nil.
+  def body_statements(body)
+    return body unless body.is_a?(Prism::BeginNode)
+
+    body.statements
+  end
+
+  # A body that is already a literal is left to the literal operators, which
+  # emit the same empty value for it.
+  def default_for(node)
+    case node
+    when Prism::InterpolatedStringNode then '""'
+    when Prism::CallNode then REPLACEMENT_BY_SELECTOR[node.name]
+    end
+  end
+end

data/lib/evilution/mutator/primitives.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "../mutator"
+
+# Mutation shapes shared across the operator families: replacing an
+# expression with `nil`, and replacing an expression with the source of one
+# of its children. Both are built on Base#add_mutation, so the
+# equivalent-mutant filter and the heredoc-span guards still apply.
+#
+# Unlike a bare add_mutation call, these skip rather than emit when the
+# result would not parse in its surrounding context. A promotion that does
+# not parse is noise rather than signal, so it never reaches the
+# `unparseable` bucket the point operators still populate.
+module Evilution::Mutator::Primitives
+  private
+
+  # Replace `target`'s byte span with `nil`, attributing the mutation to
+  # `node`. `target` defaults to `node`; pass an inner node to nil out a body
+  # while keeping the reported location on the enclosing construct.
+  def mutate_to_nil(node, target: node)
+    replace_span(node: node, target: target, replacement: "nil")
+  end
+
+  # Replace `target`'s byte span with `child`'s source, verbatim. `child` may
+  # be nil — Prism leaves optional slots (a call's receiver, an if's else)
+  # empty — in which case there is nothing to promote.
+  def promote_child(node, child, target: node)
+    return nil if child.nil?
+
+    replace_span(node: node, target: target, replacement: source_of(child))
+  end
+
+  def replace_span(node:, target:, replacement:)
+    return nil if target.nil?
+
+    location = target.location
+    return nil if replacement == byteslice_source(location.start_offset, location.length)
+
+    add_mutation(
+      offset: location.start_offset,
+      length: location.length,
+      replacement: replacement,
+      node: node,
+      skip_unparseable: true
+    )
+  end
+
+  def source_of(child)
+    location = child.location
+    byteslice_source(location.start_offset, location.length)
+  end
+end

data/lib/evilution/mutator/registry.rb

@@ -29,6 +29,8 @@ class Evilution::Mutator::Registry
       Evilution::Mutator::Operator::ComparisonReplacement,
       Evilution::Mutator::Operator::ArithmeticReplacement,
       Evilution::Mutator::Operator::BooleanOperatorReplacement,
+      Evilution::Mutator::Operator::BooleanOperandPromotion,
+      Evilution::Mutator::Operator::BooleanExpressionToNil,
       Evilution::Mutator::Operator::BooleanLiteralReplacement,
       Evilution::Mutator::Operator::NilReplacement,
       Evilution::Mutator::Operator::IntegerLiteral,
@@ -39,6 +41,7 @@ class Evilution::Mutator::Registry
       Evilution::Mutator::Operator::SymbolLiteral,
       Evilution::Mutator::Operator::ConditionalNegation,
       Evilution::Mutator::Operator::ConditionalBranch,
+      Evilution::Mutator::Operator::IfBranchSwap,
       Evilution::Mutator::Operator::LastExpressionRemoval,
       Evilution::Mutator::Operator::StatementDeletion,
       Evilution::Mutator::Operator::MethodBodyReplacement,
@@ -92,9 +95,20 @@ class Evilution::Mutator::Registry
       Evilution::Mutator::Operator::DefinedCheck,
       Evilution::Mutator::Operator::RegexCapture,
       Evilution::Mutator::Operator::LoopFlip,
+      Evilution::Mutator::Operator::LoopBodyToRaise,
+      Evilution::Mutator::Operator::MethodBodyToRaise,
+      Evilution::Mutator::Operator::MethodBodyToSuper,
+      Evilution::Mutator::Operator::TypedDefaultReturn,
+      Evilution::Mutator::Operator::BlockParameterDrop,
+      Evilution::Mutator::Operator::OptionalParameterToRequired,
+      Evilution::Mutator::Operator::OptionalDefaultInjection,
+      Evilution::Mutator::Operator::BlockDestructuringExpansion,
+      Evilution::Mutator::Operator::ForwardingSuperToExplicit,
       Evilution::Mutator::Operator::StringInterpolation,
       Evilution::Mutator::Operator::RetryRemoval,
       Evilution::Mutator::Operator::CaseWhen,
+      Evilution::Mutator::Operator::CaseIn,
+      Evilution::Mutator::Operator::PatternPredicate,
       Evilution::Mutator::Operator::PredicateReplacement,
       Evilution::Mutator::Operator::EqualityToIdentity,
       Evilution::Mutator::Operator::LambdaBody,

data/lib/evilution/process_supervisor.rb

@@ -30,7 +30,9 @@ class Evilution::ProcessSupervisor
   # One tracked child: leader pid, its process-group id (== pid for a group
   # leader), the parent-side fds to close on reap, and an optional sandbox dir
   # to remove on reap.
-  Handle = Struct.new(:pid, :pgid, :fds, :sandbox_dir, keyword_init: true)
+  # `status` is filled in when the child is reaped, so a caller that got no
+  # payload out of it can still say how it died.
+  Handle = Struct.new(:pid, :pgid, :fds, :sandbox_dir, :status, keyword_init: true)
 
   @registry = [].freeze
 
@@ -158,7 +160,7 @@ class Evilution::ProcessSupervisor
   # release the resources the handle owns: close parent-side fds, remove the
   # sandbox dir, and drop the handle from the registry.
   def reap(handle)
-    safe_wait(handle.pid)
+    handle.status = safe_wait(handle.pid)
   ensure
     release(handle)
   end
@@ -170,21 +172,28 @@ class Evilution::ProcessSupervisor
   # it releases the handle in the same step it reaps, so the process-global
   # registry never holds a stale, already-reaped pgid.
   def reap_nonblock(handle)
-    return false unless nonblocking_wait(handle.pid)
+    outcome = nonblocking_wait(handle.pid)
+    return false unless outcome
 
+    handle.status = outcome if outcome.is_a?(::Process::Status)
     release(handle)
     true
   end
 
   private
 
-  # WNOHANG wait: returns the pid once the child has exited, nil while it is
-  # still running, and -- treating an already-reaped child as exited -- the pid
-  # again on ECHILD so the caller still releases the handle.
+  # WNOHANG wait: returns the child's Process::Status once it has exited, nil
+  # while it is still running, and -- treating an already-reaped child as
+  # exited -- the :already_reaped sentinel on ECHILD so the caller still
+  # releases the handle. The sentinel is deliberately not a status: $? would
+  # then hold some earlier child's, and attributing that one's death to this
+  # child is worse than admitting the status is unknown.
   def nonblocking_wait(pid)
-    ::Process.waitpid(pid, ::Process::WNOHANG)
+    return nil unless ::Process.waitpid(pid, ::Process::WNOHANG)
+
+    ::Process.last_status
   rescue Errno::ECHILD
-    pid
+    :already_reaped
   end
 
   def release(handle)
@@ -229,8 +238,11 @@ class Evilution::ProcessSupervisor
     nil
   end
 
+  # Returns the reaped child's Process::Status, or nil when it was already
+  # reaped elsewhere and the status is no longer attributable.
   def safe_wait(pid)
     ::Process.wait(pid)
+    ::Process.last_status
   rescue Errno::ECHILD
     nil
   end

data/lib/evilution/reporter/cli/item_formatters/neutral_group.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "../item_formatters"
+require_relative "result_location"
+
+# The neutral mutations that share one reason, under a heading naming it.
+#
+# "Neutral" covers a spec that was already red and a test process that died on
+# infrastructure; grouping by reason is what tells the reader which of the two
+# they are looking at, and what to do about it (EV-5pob / GH #1606).
+class Evilution::Reporter::CLI::ItemFormatters::NeutralGroup
+  UNKNOWN_REASON = "reason not recorded"
+
+  def initialize(location: Evilution::Reporter::CLI::ItemFormatters::ResultLocation.new)
+    @location = location
+  end
+
+  def format(group)
+    reason, results = group
+    rows = results.map { |result| "  #{@location.format(result)}" }
+    ["  #{reason ? reason.to_s : UNKNOWN_REASON}:", *rows].join("\n")
+  end
+end

data/lib/evilution/reporter/cli/item_formatters/subject_score.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../item_formatters"
+require_relative "../pct"
+
+# One line per subject, under its file's heading: what the method scored and
+# what that score is made of.
+#
+# A subject nothing reached says so rather than showing a bare 0.00%, which
+# would read like a method whose mutations all survived (EV-nlx1 / GH #1605).
+class Evilution::Reporter::CLI::ItemFormatters::SubjectScore
+  UNREACHED_NOTE = "nothing reached this subject"
+
+  def initialize(pct: Evilution::Reporter::CLI::Pct.new)
+    @pct = pct
+  end
+
+  def format(score)
+    "    #{method_name(score.name)}  #{@pct.format(score.score)}  #{counts(score)}#{note(score)}"
+  end
+
+  private
+
+  # The file heading already carries the class, so the row keeps the part that
+  # tells the subjects apart, separator included: "#label_for", ".build".
+  def method_name(name)
+    boundary = name.rindex(/[#.]/)
+    boundary ? name[boundary..] : name
+  end
+
+  # Killed over what got a verdict — except where nothing did, in which case the
+  # mutations that exist are the more honest denominator.
+  def counts(score)
+    return "(0/#{score.total})" unless score.reached?
+
+    "(#{score.killed}/#{score.verified})"
+  end
+
+  def note(score)
+    score.reached? ? "" : "  #{UNREACHED_NOTE}"
+  end
+end

data/lib/evilution/reporter/cli/item_formatters/subject_score_group.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "../item_formatters"
+require_relative "subject_score"
+
+# The subjects of one file, under that file's name.
+class Evilution::Reporter::CLI::ItemFormatters::SubjectScoreGroup
+  def initialize(row: Evilution::Reporter::CLI::ItemFormatters::SubjectScore.new)
+    @row = row
+  end
+
+  def format(scores)
+    rows = scores.map { |score| @row.format(score) }
+    ["  #{scores.first.file_path}", *rows].join("\n")
+  end
+end