evilution 1.3.0 → 1.5.0

data/lib/evilution/ast/regexp_pattern.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "prism"
+require "regexp_parser"
+
+require_relative "../ast"
+
+# The pattern of a regexp literal, parsed with regexp_parser and addressed by
+# byte offsets into the file, for operators that mutate a regexp's structure.
+#
+# Edits are made by offsets into the original source, never by re-emitting the
+# pattern, so everything outside an edit stays byte for byte as written.
+#
+# regexp_parser counts offsets in characters; they are converted to bytes here
+# so they can go straight to source surgery. Prism accepts patterns whose
+# references point nowhere (`/(?:a)\1/`), so an edit has to be compiled before
+# it is emitted: `#compiles?` does that.
+class Evilution::AST::RegexpPattern
+  Token = Data.define(:type, :token, :text, :start_offset, :end_offset)
+
+  attr_reader :tokens
+
+  # Returns nil for anything but a plain regexp literal — interpolated
+  # patterns are only known at runtime — and when regexp_parser cannot read
+  # the pattern (including one that is not valid in its encoding), so callers
+  # simply emit no mutants.
+  def self.parse(node)
+    return nil unless node.is_a?(Prism::RegularExpressionNode)
+
+    new(node)
+  rescue Regexp::Parser::Error
+    nil
+  end
+
+  def initialize(node)
+    @text = node.content_loc.slice
+    @base_offset = node.content_loc.start_offset
+    @options = options_of(node)
+    @byte_offsets = byte_offsets_of(@text)
+    @tokens = scan_tokens
+    @root = Regexp::Parser.parse(@text, options: @options)
+  end
+
+  # Yields every expression of the parsed pattern with its start and end
+  # offsets in the file.
+  def each_expression
+    @root.each_expression do |expression, _index|
+      yield expression, *offsets(expression)
+    end
+  end
+
+  # An expression's start and end offsets in the file, quantifier included.
+  def offsets(expression)
+    [file_offset(expression.ts), file_offset(expression.ts + expression.full_length)]
+  end
+
+  # Whether the pattern still compiles once the span between the two file
+  # offsets is replaced.
+  def compiles?(start_offset, end_offset, replacement)
+    local_start = start_offset - @base_offset
+    mutated = @text.byteslice(0, local_start) + replacement + @text.byteslice((end_offset - @base_offset)..)
+    without_warnings { Regexp.new(mutated, @options) }
+    true
+  rescue RegexpError
+    false
+  end
+
+  private
+
+  # Only extended mode changes how a pattern is read: whitespace and `#`
+  # comments become tokens of their own. Case-insensitivity and multiline
+  # change what a pattern matches, not how it parses or whether it compiles.
+  def options_of(node)
+    node.extended? ? Regexp::EXTENDED : 0
+  end
+
+  # Bytes before each character position, one entry past the last character.
+  def byte_offsets_of(text)
+    offsets = [0]
+    text.each_char { |char| offsets << (offsets.last + char.bytesize) }
+    offsets
+  end
+
+  def file_offset(character_index)
+    @base_offset + @byte_offsets.fetch(character_index)
+  end
+
+  def scan_tokens
+    Regexp::Scanner.scan(@text, options: @options).map do |type, token, text, start_index, end_index|
+      Token.new(type: type, token: token, text: text,
+                start_offset: file_offset(start_index), end_offset: file_offset(end_index))
+    end
+  end
+
+  # Onigmo warns about patterns such as duplicated class ranges; a mutant can
+  # produce them, and the warning would land in the user's output.
+  def without_warnings
+    verbose = $VERBOSE
+    $VERBOSE = nil
+    yield
+  ensure
+    $VERBOSE = verbose
+  end
+end

data/lib/evilution/ast/round_half_mode.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "../ast"
+
+# The tie-breaking mode of a `round` call: the `:even` of
+# `amount.round(2, half: :even)`. Only a literal mode Ruby accepts counts; a
+# mode held in a variable, `nil` or an unknown symbol is not one.
+module Evilution::AST::RoundHalfMode
+  MODES = %i[up even down].freeze
+
+  # The symbol node holding the mode, or nil when node is not a `round` call
+  # with a literal mode.
+  def self.of(node)
+    return nil unless node.is_a?(Prism::CallNode) && node.name == :round
+
+    value = half_value(node.arguments)
+    value if value.is_a?(Prism::SymbolNode) && MODES.include?(value.unescaped.to_sym)
+  end
+
+  # The value given to `half:`, whatever it is.
+  def self.half_value(arguments)
+    return nil unless arguments
+
+    keywords = arguments.arguments.grep(Prism::KeywordHashNode).flat_map(&:elements)
+    pair = keywords.find { |element| half_key?(element) }
+    pair.value if pair
+  end
+
+  def self.half_key?(element)
+    return false unless element.is_a?(Prism::AssocNode)
+
+    key = element.key
+    key.is_a?(Prism::SymbolNode) && key.unescaped == "half"
+  end
+
+  private_class_method :half_value, :half_key?
+end

data/lib/evilution/ast/scope_declaration.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "../ast"
+require_relative "literal_callable"
+
+# An ActiveRecord scope declared with a literal body:
+# `scope :recent, -> { where(recent: true) }`, or with `lambda { }` /
+# `proc { }`. The body is what mutations go into; the name is the class
+# method the declaration defines.
+#
+# Only the receiver-less form written directly in a class body counts: that
+# is the call the mutated file re-runs to replace the scope, so the mutated
+# body takes effect. A scope whose body is an object or a variable has no
+# body of its own to mutate.
+module Evilution::AST::ScopeDeclaration
+  # The scope declarations among a class body's direct statements.
+  def self.in_body(body)
+    statements = body.is_a?(Prism::BeginNode) ? body.statements : body
+    return [] unless statements
+
+    statements.body.select { |node| body_of(node) }
+  end
+
+  # The node holding the scope's body -- a LambdaNode, or the BlockNode of a
+  # `lambda` / `proc` call -- or nil when node is not a scope declaration.
+  def self.body_of(node)
+    return nil unless scope_call?(node)
+
+    Evilution::AST::LiteralCallable.body_of(node.arguments.arguments[1])
+  end
+
+  def self.scope_name(node)
+    node.arguments.arguments.first.unescaped
+  end
+
+  def self.scope_call?(node)
+    return false unless node.is_a?(Prism::CallNode) && node.name == :scope && node.receiver.nil?
+
+    args = node.arguments ? node.arguments.arguments : []
+    args.length == 2 && args.first.is_a?(Prism::SymbolNode)
+  end
+
+  private_class_method :scope_call?
+end

data/lib/evilution/ast/source_surgeon.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
-require "prism"
-
 require_relative "../ast"
+require_relative "syntax_check"
 
 module Evilution::AST::SourceSurgeon
   Result = Struct.new(:source, :status, keyword_init: true) do
@@ -19,7 +18,7 @@ module Evilution::AST::SourceSurgeon
     binary = source.b
     binary[offset, length] = replacement.b
     mutated = binary.force_encoding(source.encoding)
-    status = Prism.parse(mutated).success? ? :ok : :unparseable
+    status = Evilution::AST::SyntaxCheck.valid?(mutated) ? :ok : :unparseable
     Result.new(source: mutated, status: status).freeze
   end
 end

data/lib/evilution/ast/syntax_check.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../ast"
+
+# Answers whether mutated source is Ruby the running interpreter will accept.
+#
+# Mutations are built and screened with Prism, but Prism and the older
+# parse.y parser do not agree on everything: Prism takes a bare constant
+# operator write inside a method (`def f; LIMIT ||= 1; end`) and a `nil[...]`
+# pattern, both of which parse.y rejects. An interpreter that compiles with
+# parse.y -- Ruby 3.3 by default, any later one started with
+# `--parser=parse.y` -- would be handed a mutant marked parseable and raise
+# SyntaxError evaluating it.
+#
+# So Prism decides first, and where the interpreter does not compile with
+# Prism, parse.y is asked as well. That second parse costs about what the
+# first does and is only paid on those interpreters.
+module Evilution::AST::SyntaxCheck
+  # How the interpreter says it compiles: `ruby 3.4.1 (...) +PRISM [...]`.
+  PRISM_INTERPRETER = RUBY_DESCRIPTION.include?("+PRISM")
+
+  def self.valid?(source, prism_interpreter: PRISM_INTERPRETER)
+    return false unless Prism.parse(source).success?
+
+    prism_interpreter || parse_y_accepts?(source)
+  end
+
+  # RubyVM::AbstractSyntaxTree is built on parse.y whatever the interpreter
+  # compiles with. It is CRuby's own: another implementation has no parse.y
+  # to ask, and there Prism's answer stands, as it does after a failure that
+  # is not about syntax.
+  def self.parse_y_accepts?(source)
+    return true unless defined?(RubyVM::AbstractSyntaxTree)
+
+    without_warnings { RubyVM::AbstractSyntaxTree.parse(source) }
+    true
+  rescue SyntaxError
+    false
+  rescue StandardError
+    true
+  end
+
+  # parse.y warns as it parses ("possibly useless use of == in void
+  # context"), which a mutant earns far more often than written code does.
+  def self.without_warnings
+    verbose = $VERBOSE
+    $VERBOSE = nil
+    yield
+  ensure
+    $VERBOSE = verbose
+  end
+
+  private_class_method :parse_y_accepts?, :without_warnings
+end

data/lib/evilution/ast/uncovered_code.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "../ast"
+require_relative "included_block"
+
+# The lines of a file that hold code no subject covers: statements written in
+# a class, module or `class << self` body, or at the top level, outside every
+# method -- callback macros, DSL calls, logical writes on a constant -- or in a
+# concern's `included` or `prepended` block, which is a class body written
+# elsewhere. Mutations are generated per subject, so a run aimed at these
+# lines generates none of its own, and saying so is the only way a reader can
+# tell "nothing to mutate" from "nothing reached".
+#
+# Visibility keywords without arguments (`private`) carry no behaviour of
+# their own and are left out, as are `require` and `require_relative`: loading
+# a file is not something a mutation of this one could test.
+#
+# A few operators do reach class-body statements -- an `alias_method`, an
+# `include` -- through the first method of the scope. A statement holding a
+# line a mutation was generated for is targeted after all, and is left out
+# whole.
+module Evilution::AST::UncoveredCode
+  SCOPE_NODES = [Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode].freeze
+  VISIBILITY_KEYWORDS = %i[private protected public module_function].freeze
+  LOAD_METHODS = %i[require require_relative].freeze
+  private_constant :SCOPE_NODES, :VISIBILITY_KEYWORDS, :LOAD_METHODS
+
+  # subjects: those parsed from file_path; lines: the Range to keep, or nil
+  # for the whole file; mutated_lines: the lines of file_path that mutations
+  # were generated for. Returns the uncovered lines as merged Ranges, in
+  # source order.
+  def self.call(file_path, subjects, lines:, mutated_lines: [])
+    covered = subjects.flat_map { |subject| subject_lines(subject) }.to_set
+    uncovered = code_lines(File.read(file_path), mutated_lines).reject { |line| covered.include?(line) }
+    uncovered = uncovered.select { |line| lines.cover?(line) } if lines
+    merge(uncovered.uniq)
+  end
+
+  def self.code_lines(source, mutated_lines)
+    statements(Prism.parse(source).value.statements)
+      .reject { |node| mutated_lines.any? { |line| line.between?(node.start_line, node.end_line) } }
+      .flat_map { |node| node_lines(node) }
+  end
+
+  def self.statements(body)
+    nodes = case body
+            when Prism::StatementsNode then body.body
+            when Prism::BeginNode then body.statements ? body.statements.body : []
+            else []
+            end
+    nodes.flat_map { |node| expand(node) }
+  end
+
+  def self.expand(node)
+    return statements(node.body) if SCOPE_NODES.any? { |type| node.is_a?(type) }
+
+    hook = Evilution::AST::IncludedBlock.of(node) || Evilution::AST::IncludedBlock.prepended(node)
+    return statements(hook.body) if hook
+    return [] if bare_visibility?(node) || load_call?(node)
+
+    [node]
+  end
+
+  def self.load_call?(node)
+    node.is_a?(Prism::CallNode) && node.receiver.nil? && LOAD_METHODS.include?(node.name)
+  end
+
+  def self.bare_visibility?(node)
+    node.is_a?(Prism::CallNode) && node.receiver.nil? && node.arguments.nil? &&
+      VISIBILITY_KEYWORDS.include?(node.name)
+  end
+
+  def self.node_lines(node)
+    (node.start_line..node.end_line).to_a
+  end
+
+  def self.subject_lines(subject)
+    (subject.line_number..(subject.line_number + subject.source.count("\n"))).to_a
+  end
+
+  def self.merge(lines)
+    lines.slice_when { |a, b| b != a + 1 }.map { |run| run.first..run.last }
+  end
+
+  private_class_method :code_lines, :statements, :expand, :bare_visibility?, :load_call?, :node_lines,
+                       :subject_lines, :merge
+end

data/lib/evilution/ast/value_object_definition.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "../ast"
+
+# A value-object definition: `Data.define(...)` or `Struct.new(...)` called on
+# the core class itself (`Data` or `::Data`, not `Foo::Data`), with or without
+# a block.
+module Evilution::AST::ValueObjectDefinition
+  DEFINERS = { Data: :define, Struct: :new }.freeze
+
+  def self.match?(node)
+    return false unless node.is_a?(Prism::CallNode) && core_constant?(node.receiver)
+
+    DEFINERS[node.receiver.name] == node.name
+  end
+
+  def self.core_constant?(node)
+    return true if node.is_a?(Prism::ConstantReadNode)
+
+    node.is_a?(Prism::ConstantPathNode) && node.parent.nil?
+  end
+
+  private_class_method :core_constant?
+end

data/lib/evilution/baseline/failure_formatter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "../baseline"
+
+# The lines that say why a spec file was red in the baseline, shared by the
+# warning printed during the run and the note in the final report.
+class Evilution::Baseline::FailureFormatter
+  NO_DETAIL = "no failure detail was captured"
+
+  def call(failure)
+    lines = error_lines(failure) + failure.examples.map { |example| example_line(example) }
+    remainder = failure.example_count - failure.examples.length
+    lines << "... and #{remainder} more failing" if remainder.positive?
+    lines.empty? ? [NO_DETAIL] : lines
+  end
+
+  private
+
+  def error_lines(failure)
+    failure.error ? failure.error.lines.map(&:chomp) : []
+  end
+
+  def example_line(example)
+    line = [example.id, example.description].reject(&:empty?).join(" ")
+    example.message.empty? ? line : "#{line} -- #{example.message}"
+  end
+end

data/lib/evilution/baseline/report.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "../baseline"
+
+# What a baseline run of one spec file sends back across the fork: whether it
+# passed and, when it did not, enough to say why. A plain hash of strings and
+# numbers, so it marshals over the pipe whatever the test framework is.
+#
+# The detail is bounded here, in the child: a spec file with a thousand failing
+# examples has nothing more to say after the first few. Their ids are kept in
+# far greater number, since a mutation run is compared against all of them.
+module Evilution::Baseline::Report
+  MAX_EXAMPLES = 10
+  MAX_IDS = 1000
+  MAX_MESSAGE_LENGTH = 300
+  MESSAGE_LINES = 3
+  ERROR_LINES = 5
+  ELLIPSIS = "..."
+
+  # failed_ids: every failing example, named so a mutation run can recognise
+  # it again (see Integration::RSpec::ExampleIds); empty where the framework
+  # does not provide such names.
+  def self.build(passed:, failures: [], error: nil, failed_ids: [])
+    {
+      passed: passed ? true : false,
+      failure_count: failures.length,
+      failures: failures.first(MAX_EXAMPLES).map { |failure| example(failure) },
+      error: error_excerpt(error),
+      failed_ids: failed_ids.first(MAX_IDS)
+    }
+  end
+
+  # A runner may still answer with a bare pass/fail.
+  def self.from(outcome)
+    outcome.is_a?(Hash) ? outcome : build(passed: outcome)
+  end
+
+  def self.example(failure)
+    {
+      id: failure[:id].to_s,
+      description: failure[:description].to_s,
+      message: truncate(lines_of(failure[:message]).first(MESSAGE_LINES).join(" "))
+    }
+  end
+  private_class_method :example
+
+  # Each line is cut on its own, so one long path does not cost the lines
+  # after it.
+  def self.error_excerpt(error)
+    lines = lines_of(error).first(ERROR_LINES)
+    lines.empty? ? nil : lines.map { |line| truncate(line) }.join("\n")
+  end
+  private_class_method :error_excerpt
+
+  def self.lines_of(text)
+    text.to_s.lines.map(&:strip).reject(&:empty?)
+  end
+  private_class_method :lines_of
+
+  def self.truncate(text)
+    return text if text.length <= MAX_MESSAGE_LENGTH
+
+    "#{text[0, MAX_MESSAGE_LENGTH - ELLIPSIS.length]}#{ELLIPSIS}"
+  end
+  private_class_method :truncate
+end

data/lib/evilution/baseline/spec_failure.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../baseline"
+
+class Evilution::Baseline
+  ExampleFailure = Data.define(:id, :description, :message)
+
+  # Why one spec file was red in the baseline: the examples that failed, or the
+  # error that stopped it before any example could -- a load error, a runner
+  # that raised, a timeout. example_count is every failing example; examples
+  # holds only the first few, for display; failed_ids names all of them the
+  # way a mutation run does, for comparison.
+  SpecFailure = Data.define(:spec_file, :examples, :example_count, :error, :failed_ids) do
+    def self.from_report(spec_file, report)
+      examples = Array(report[:failures]).map { |failure| ExampleFailure.new(**failure) }
+      new(
+        spec_file: spec_file,
+        examples: examples,
+        example_count: report[:failure_count] || examples.length,
+        error: report[:error],
+        failed_ids: Array(report[:failed_ids])
+      )
+    end
+
+    def initialize(spec_file:, examples: [], example_count: 0, error: nil, failed_ids: [])
+      super
+    end
+
+    def to_h
+      {
+        spec_file: spec_file,
+        error: error,
+        failing_examples: example_count,
+        examples: examples.map(&:to_h)
+      }
+    end
+  end
+end

data/lib/evilution/baseline.rb

@@ -2,10 +2,11 @@
 
 require_relative "spec_resolver"
 require_relative "process_cleanup"
+require_relative "diagnostic"
 
 class Evilution::Baseline
-  Result = Struct.new(:failed_spec_files, :duration) do
-    def initialize(**)
+  Result = Struct.new(:failed_spec_files, :duration, :failures) do
+    def initialize(failed_spec_files:, duration:, failures: [])
       super
       freeze
     end
@@ -13,6 +14,11 @@ class Evilution::Baseline
     def failed?
       !failed_spec_files.empty?
     end
+
+    # Every example known to have failed before any mutation ran.
+    def failed_example_ids
+      failures.flat_map(&:failed_ids).to_set
+    end
   end
 
   # spec_selector: the object `run` resolves with (integration layout plus
@@ -37,18 +43,20 @@ class Evilution::Baseline
 
   def call(subjects)
     start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    spec_files = baseline_spec_files(subjects)
-    failed = Set.new
-
-    spec_files.each do |spec_file|
-      failed.add(spec_file) unless run_spec_file(spec_file)
-    end
+    failures = baseline_spec_files(subjects).filter_map { |spec_file| check_spec_file(spec_file) }
 
     duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
-    Result.new(failed_spec_files: failed, duration: duration)
+    Result.new(failed_spec_files: failures.to_set(&:spec_file), duration: duration, failures: failures)
   end
 
   def run_spec_file(spec_file)
+    check_spec_file(spec_file).nil?
+  end
+
+  # nil when the spec file passed, otherwise why it did not. Anything that
+  # stops the baseline from getting an answer counts as failing, and is
+  # recorded as the reason.
+  def check_spec_file(spec_file)
     raise Evilution::Error, "no baseline runner configured" unless @runner
 
     read_io, write_io = IO.pipe
@@ -57,11 +65,11 @@ class Evilution::Baseline
     read_result(read_io, pid, spec_file)
   rescue Evilution::Error
     raise
-  rescue StandardError
-    false
+  rescue StandardError => e
+    warned(SpecFailure.new(spec_file: spec_file, error: "#{e.class}: #{e.message}"))
   ensure
-    read_io&.close
-    write_io&.close
+    read_io.close if read_io
+    write_io.close if write_io
   end
 
   def fork_spec_runner(spec_file, read_io, write_io)
@@ -71,32 +79,28 @@ class Evilution::Baseline
       $stdout.reopen(File::NULL, "w")
       $stderr.reopen(File::NULL, "w")
 
-      passed = runner.call(spec_file)
-      Marshal.dump({ passed: passed }, write_io)
+      report = child_report(runner, spec_file)
+      Marshal.dump(report, write_io)
       write_io.close
-      exit!(passed ? 0 : 1)
+      exit!(report[:passed] ? 0 : 1)
     end
   end
 
   GRACE_PERIOD = 0.5
 
   def read_result(read_io, pid, spec_file)
-    if read_io.wait_readable(@timeout)
-      data = read_io.read
-      Process.wait(pid)
-      return false if data.empty?
-
-      result = Marshal.load(data)
-      result[:passed]
-    else
-      terminate_child(pid)
-      warn_timeout(spec_file)
-      false
-    end
+    return timed_out(pid, spec_file) unless read_io.wait_readable(@timeout)
+
+    data = read_io.read
+    _, status = Process.wait2(pid)
+    return warned(SpecFailure.new(spec_file: spec_file, error: unreported_error(status))) if data.empty?
+
+    report = Marshal.load(data)
+    report[:passed] ? nil : warned(SpecFailure.from_report(spec_file, report))
   end
 
   def warn_timeout(spec_file)
-    warn "[evilution] Baseline for #{spec_file} timed out after #{@timeout}s; treating it as failing."
+    Evilution::Diagnostic.warn("[evilution] Baseline for #{spec_file} timed out after #{@timeout}s; treating it as failing.")
   end
 
   def terminate_child(pid)
@@ -114,6 +118,35 @@ class Evilution::Baseline
 
   private
 
+  # Runs in the child. A runner that raises -- a spec helper that cannot load,
+  # a framework that is not there -- is a failure with a reason, not a child
+  # that dies without a word.
+  def child_report(runner, spec_file)
+    Report.from(runner.call(spec_file))
+  rescue StandardError, ScriptError => e
+    Report.build(passed: false, error: "#{e.class}: #{e.message}")
+  end
+
+  def timed_out(pid, spec_file)
+    terminate_child(pid)
+    warn_timeout(spec_file)
+    SpecFailure.new(spec_file: spec_file, error: "timed out after #{@timeout}s")
+  end
+
+  def unreported_error(status)
+    cause = status.signaled? ? "signal #{status.termsig}" : "exit status #{status.exitstatus}"
+    "baseline process ended without reporting (#{cause})"
+  end
+
+  def warned(failure)
+    detail = FailureFormatter.new.call(failure).map { |line| "  #{line}" }
+    Evilution::Diagnostic.warn(
+      ["[evilution] Baseline failed for #{failure.spec_file}; " \
+       "a mutation that fails only its already-failing examples will be reported neutral.", *detail].join("\n")
+    )
+    failure
+  end
+
   def baseline_spec_files(subjects)
     return Array(@test_files).uniq if @test_files && !@test_files.empty?
 
@@ -137,7 +170,7 @@ class Evilution::Baseline
 
   def warn_no_matching_test(file_path)
     action = @fallback_to_full_suite ? "running full suite" : "marking its mutations unresolved"
-    warn "[evilution] No matching test found for #{file_path}, #{action}. #{no_match_hint(file_path)}"
+    Evilution::Diagnostic.warn("[evilution] No matching test found for #{file_path}, #{action}. #{no_match_hint(file_path)}")
   end
 
   def no_match_hint(file_path)
@@ -150,3 +183,7 @@ class Evilution::Baseline
     @fallback_to_full_suite ? "#{hint}." : "#{hint}, or --fallback-full-suite to run the whole suite."
   end
 end
+
+require_relative "baseline/report"
+require_relative "baseline/spec_failure"
+require_relative "baseline/failure_formatter"