rutidy 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e0d758de435d37cd2be15dc16e6865d0684de10a1c2e068e51ae2cf614dc7935
+  data.tar.gz: 527576fa67e3ce5f23660e7783f903daf23b4926b6c0905cdc03cd11eb48e8cb
+SHA512:
+  metadata.gz: 4170b31d9a055204e77c1db26d36f6c3c82b75e00e379cbda4be2fa2b22508b0274fb9699b29fa104fa7494947593fcf6f8c1914f592fcd8546285f6b820e82f
+  data.tar.gz: 300a3e45166a8188afc0a82660501c4dec4fa97d0edb819beae01df55a11d0442abc6edc64bbd3478e9b049a0516016f6317f58afd2fa7eea65cf9280ef80915

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 John Woodell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,114 @@
+# rutidy
+
+[![Gem Version](https://img.shields.io/gem/v/rutidy)](https://rubygems.org/gems/rutidy)
+[![CI](https://github.com/woodie/rutidy/actions/workflows/ci.yml/badge.svg)](https://github.com/woodie/rutidy/actions/workflows/ci.yml)
+[![Release](https://img.shields.io/github/v/release/woodie/rutidy.svg)](https://github.com/woodie/rutidy/releases/latest)
+[![License](https://img.shields.io/github/license/woodie/rutidy.svg)](LICENSE)
+
+![Example Screenshot](docs/example.png)
+
+RSpec/Mocha/Vitest-style output for RSpec by hooking a real formatter into
+the same tree the runner already builds. See at a glance which spec
+actually failed, in whichever of the four familiar looks reads best for
+your team, without giving up RSpec's own assertions or your existing suite.
+
+## Installation
+
+```
+gem install rutidy
+```
+
+Or add it to your `Gemfile`:
+
+```ruby
+group :test do
+  gem "rutidy"
+end
+```
+
+## Usage
+
+Run as a wrapper around `rspec`, passing any arguments through:
+
+```
+rutidy
+rutidy spec/
+rutidy -fd spec/calculator_spec.rb
+```
+
+Or read stdin, piping RSpec's own output through `rutidy`'s formatter first:
+
+```
+rspec --require rutidy/formatter --format Rutidy::Formatter | rutidy -fs
+```
+
+Or format an existing report file directly:
+
+```
+rutidy report.json
+```
+
+Flags select the output style -- see [Output styles](#output-styles) below.
+
+### Version
+
+```
+rutidy --version
+```
+
+Prints the installed version and exits immediately, without waiting on
+stdin or running `rspec`.
+
+## Output styles
+
+Four named styles, each matching a convention from a familiar test runner.
+The first three end with the same shared footer; `-fv` ends with Vitest's
+own footer shape instead.
+
+| Flag | Convention | Look |
+|---|---|---|
+|   | Our base formatter | Glyph + `name (N seconds)`, failures add `(FAILED - N)` |
+| -fd | RSpec's own doc format | Plain colored name, yellow `(PENDING: reason)` |
+| -fs | Mocha's spec format | Green `✔` + gray name, red `✗ name (FAILED - N)` |
+| -fv | Vitest's own tree | Green `✓ name`, two-toned green `2ms`, red `× name`, dim gray `↓ name` |
+
+`-fv`'s `Test Files` line counts distinct `file_path`s across all examples --
+exact, since every example already carries its own real spec file path.
+
+## Things to know
+
+### Why a real formatter, not a text post-processor
+
+`gorderly`/`xctidy` parse `go test`/`xcodebuild`'s raw text output because
+that's all those tools expose. RSpec is different: its own `--format json`
+only reports a flattened `full_description` string (every `describe`/
+`context`/`it` joined with plain spaces, no separator at all) with no
+per-level boundaries -- reconstructing a real tree from that would mean
+guessing where one group's text ends and the next begins, the exact
+problem `xctidy` already has to solve for Quick/Nimble's comma-joined
+names, except worse, since RSpec doesn't even delimit with commas.
+
+`Rutidy::Formatter` sidesteps that entirely by hooking the same
+`example_group_started`/`example_group_finished` notifications RSpec's own
+`--format documentation` formatter uses internally -- the hierarchy comes
+from the real stack the runner already maintains, not a guess.
+
+### Limitations
+
+- `Rutidy::Formatter` must run inside the same `rspec` process as your
+  suite (via `--require`/`--format`, or `rutidy`'s own CLI wrapping
+  `rspec` for you) -- it can't be retrofitted onto RSpec's own stock
+  `--format json` output after the fact.
+- Shared examples (`it_behaves_like`) show up as their own nesting level
+  named after the shared group, matching what RSpec's own `--format
+  documentation` already does -- not a `rutidy`-specific quirk.
+
+## Development
+
+```
+make build    # gem build rutidy.gemspec
+make install  # rake install
+make test     # verbose, dogfoods rutidy on its own suite in -fd style
+make lint     # standardrb
+make check    # terse: silent on success, full log on failure
+```

data/exe/rutidy

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "rutidy"
+
+exit Rutidy::CLI.run(ARGV)

data/lib/rutidy/cli.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "json"
+require "tempfile"
+require "rutidy/version"
+require "rutidy/render"
+
+module Rutidy
+  # `rutidy`'s two modes, matching `gomeleon`'s own "wrap the CLI, or read
+  # its JSON report directly" duality:
+  #
+  #   rutidy                  # wraps `rspec` with no args
+  #   rutidy spec/foo_spec.rb # wraps `rspec spec/foo_spec.rb`
+  #   rutidy -fd spec/        # style flag + wrapped invocation
+  #   rutidy report.json      # formats an existing report file directly
+  #   rspec ... | rutidy -fs  # reads a piped report from stdin
+  #
+  # A single argument ending in `.json` is treated as an existing report to
+  # render; anything else on the command line is handed straight through to
+  # `rspec` (with `Formatter` inserted via `--require`/`--format`). Piped
+  # stdin with no arguments at all is read as a report too, the same way
+  # `gorderly`'s `openInput` treats piped stdin vs. shelling out to `go test`
+  # itself.
+  class CLI
+    STYLE_ALIASES = {
+      "documentation" => :fd,
+      "spec" => :fs,
+      "vitest" => :fv
+    }.freeze
+
+    def self.run(argv, out: $stdout, err: $stderr, stdin: $stdin)
+      new(argv, out: out, err: err, stdin: stdin).run
+    end
+
+    def initialize(argv, out:, err:, stdin:)
+      @argv = argv.dup
+      @out = out
+      @err = err
+      @stdin = stdin
+      @style = :classic
+      @color = @out.respond_to?(:tty?) && @out.tty? && ENV["NO_COLOR"].nil?
+    end
+
+    def run
+      if wants_version?
+        @out.puts("rutidy #{Rutidy::VERSION}")
+        return 0
+      end
+
+      rest = parse_flags!
+      examples = load_examples(rest)
+      return 1 if examples.nil?
+
+      Render.call(examples, style: @style, out: @out, color: @color).positive? ? 1 : 0
+    end
+
+    private
+
+    def wants_version?
+      @argv.include?("--version") || @argv.include?("-v")
+    end
+
+    def parse_flags!
+      rest = []
+      @argv.each do |arg|
+        case arg
+        when "-fd" then @style = :fd
+        when "-fs" then @style = :fs
+        when "-fv" then @style = :fv
+        when /\A--format[= ](\w+)\z/
+          @style = STYLE_ALIASES.fetch(Regexp.last_match(1)) do
+            @err.puts("rutidy: unknown --format #{Regexp.last_match(1)}")
+            @style
+          end
+        else rest << arg
+        end
+      end
+      rest
+    end
+
+    def load_examples(rest)
+      if rest.length == 1 && rest.first.end_with?(".json")
+        return parse_report(File.read(rest.first))
+      end
+
+      if rest.empty? && !@stdin.tty?
+        return parse_report(@stdin.read)
+      end
+
+      run_rspec(rest)
+    end
+
+    def parse_report(json_text)
+      JSON.parse(json_text, symbolize_names: true).fetch(:examples, [])
+    rescue JSON::ParserError => e
+      @err.puts("rutidy: couldn't parse report: #{e.message}")
+      nil
+    end
+
+    def run_rspec(args)
+      Tempfile.create(["rutidy", ".json"]) do |tmp|
+        cmd = [
+          "rspec", "--require", "rutidy/formatter", "--format", "Rutidy::Formatter",
+          "--out", tmp.path, *args
+        ]
+        # `rspec` exits non-zero whenever any example fails -- that's the
+        # normal case this tool exists to render, not an error. Only the
+        # report ending up empty (rspec never got far enough to write one --
+        # a load error, an unrecognized flag, no matching spec files) is a
+        # real problem worth surfacing here.
+        system(*cmd, out: @err, err: @err)
+
+        content = File.read(tmp.path)
+        if content.strip.empty?
+          @err.puts("rutidy: `#{cmd.join(" ")}` produced no report -- see rspec's own output above")
+          return nil
+        end
+
+        parse_report(content)
+      end
+    end
+  end
+end

data/lib/rutidy/formatter.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "json"
+require "rspec/core/formatters"
+require "rspec/core/formatters/base_formatter"
+require "rutidy/version"
+
+module Rutidy
+  # A real RSpec formatter (registered the same way RSpec's own built-in
+  # DocumentationFormatter is), not a post-processor of some other
+  # formatter's text output. `example_group_started`/`example_group_finished`
+  # fire as the runner actually descends/ascends the real describe/context
+  # tree, so `@hierarchy` always reflects genuine nesting -- unlike stock
+  # `rspec --format json`, whose `full_description` field is every group's
+  # description concatenated with plain spaces and no separator, which
+  # can't be split back into a tree without guessing. This formatter never
+  # needs to guess: every example gets its own `hierarchy` array straight
+  # from the stack RSpec itself maintains.
+  #
+  # Load with `rspec --require rutidy/formatter --format Rutidy::Formatter`,
+  # or let `rutidy`'s own CLI wrap that invocation for you.
+  class Formatter < RSpec::Core::Formatters::BaseFormatter
+    RSpec::Core::Formatters.register self,
+      :example_group_started, :example_group_finished,
+      :example_passed, :example_failed, :example_pending,
+      :dump_summary, :seed, :message, :close
+
+    def initialize(output)
+      super
+      @hierarchy = []
+      @output_hash = {version: Rutidy::VERSION}
+    end
+
+    def message(notification)
+      (@output_hash[:messages] ||= []) << notification.message
+    end
+
+    def example_group_started(notification)
+      @hierarchy << notification.group.description.strip
+    end
+
+    def example_group_finished(_notification)
+      @hierarchy.pop
+    end
+
+    def example_passed(notification)
+      record(notification.example)
+    end
+
+    def example_pending(notification)
+      record(notification.example)
+    end
+
+    def example_failed(notification)
+      record(notification.example, notification)
+    end
+
+    def dump_summary(summary)
+      @output_hash[:summary] = {
+        duration: summary.duration,
+        example_count: summary.example_count,
+        failure_count: summary.failure_count,
+        pending_count: summary.pending_count
+      }
+      @output_hash[:summary_line] = summary.totals_line
+    end
+
+    def seed(notification)
+      return unless notification.seed_used?
+
+      @output_hash[:seed] = notification.seed
+    end
+
+    def close(_notification)
+      output.write JSON.generate(@output_hash)
+    end
+
+    private
+
+    def record(example, failure_notification = nil)
+      (@output_hash[:examples] ||= []) << format_example(example, failure_notification)
+    end
+
+    # Same field set stock `rspec --format json` gives you (description,
+    # full_description, status, file_path, line_number, run_time,
+    # pending_message, exception) plus the one field it's missing:
+    # `hierarchy`, the real per-level nesting `render.rb` builds a tree from.
+    def format_example(example, failure_notification)
+      result = example.execution_result
+      hash = {
+        hierarchy: @hierarchy + [example.description.strip],
+        description: example.description,
+        full_description: example.full_description,
+        status: result.status.to_s,
+        file_path: example.metadata[:file_path],
+        line_number: example.metadata[:line_number],
+        run_time: result.run_time
+      }
+      hash[:pending_message] = result.pending_message if result.pending_message
+      hash[:exception] = format_exception(example.exception, failure_notification) if failure_notification
+      hash
+    end
+
+    def format_exception(exception, failure_notification)
+      {
+        class: exception.class.name,
+        message: exception.message,
+        backtrace: failure_notification.formatted_backtrace
+      }
+    end
+  end
+end

data/lib/rutidy/render.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module Rutidy
+  # Walks the leaves `Formatter` (or a real `rspec --format json` report
+  # extended with a `hierarchy` array) produced and renders them as a nested
+  # RSpec `-fd`-style tree, the same dedupe-shared-prefix walk `gorderly`'s
+  # `render.go` and `xctidy`'s `Engine.swift` use, just over each example's
+  # real `hierarchy` array instead of a `/`-split or comma-disambiguated
+  # string. Four styles (`:classic`/`:fd`/`:fs`/`:fv`) share one closing
+  # footer, except `:fv`, which closes with Vitest's own `Test Files`/
+  # `Tests`/`Duration` shape.
+  #
+  # Unlike `gorderly`, there's no fake "package path" label above the tree --
+  # RSpec has no equivalent concept, so the first top-level `describe` is
+  # just the first real node. A blank line still goes before every
+  # top-level group, including the first -- that's not a `gorderly`-style
+  # workaround here, it's genuine RSpec `-fd` behavior (its own
+  # `DocumentationFormatter#example_group_started` does `output.puts if
+  # @group_level == 0` unconditionally).
+  module Render
+    ANSI_PREFIX = "\e["
+    COLORS = {
+      red: "31",
+      green: "32",
+      bright_green: "92",
+      yellow: "33",
+      cyan: "36",
+      gray: "90"
+    }.freeze
+
+    FailureEntry = Struct.new(:n, :full, :output)
+
+    module_function
+
+    # @return [Integer] the number of failed examples (0 means a clean run)
+    def call(examples, style:, out:, color: true)
+      colorize = ->(name, text) { color ? "#{ANSI_PREFIX}#{COLORS.fetch(name)}m#{text}#{ANSI_PREFIX}0m" : text }
+
+      total = 0
+      pending = 0
+      failed_count = 0
+      total_elapsed = 0.0
+      failures = []
+      files_total = {}
+      files_failed = {}
+      prev_path = []
+
+      examples.each do |example|
+        hierarchy = example.fetch(:hierarchy)
+        path = hierarchy[0..-2]
+        leaf_name = hierarchy.last
+
+        shared = 0
+        shared += 1 while shared < prev_path.length && shared < path.length && prev_path[shared] == path[shared]
+
+        out.puts if shared.zero?
+        (shared...path.length).each { |i| out.puts("#{"  " * i}#{path[i]}") }
+
+        total += 1
+        total_elapsed += example[:run_time]
+        indent = "  " * path.length
+        file = example[:file_path]
+        files_total[file] = true if file
+
+        case example[:status]
+        when "failed"
+          failed_count += 1
+          files_failed[file] = true if file
+          n = failures.length + 1
+          failures << FailureEntry.new(n, hierarchy, format_backtrace(example))
+          out.puts("#{indent}#{colorize_fail(style, leaf_name, example, n, colorize)}")
+        when "pending"
+          pending += 1
+          out.puts("#{indent}#{colorize_pending(style, leaf_name, example, colorize)}")
+        else
+          out.puts("#{indent}#{colorize_pass(style, leaf_name, example, colorize)}")
+        end
+
+        prev_path = path
+      end
+      out.puts
+
+      if failures.any?
+        out.puts("Failures:")
+        failures.each do |f|
+          out.puts
+          out.puts("  #{f.n}) #{f.full.join(" ")}")
+          f.output.each { |line| out.puts("     #{line}") }
+        end
+        out.puts
+      end
+
+      if style == :fv
+        write_vitest_footer(
+          out, colorize,
+          total: total, failed_count: failed_count, pending: pending, total_elapsed: total_elapsed,
+          files_total: files_total.size, files_failed: files_failed.size
+        )
+      else
+        write_shared_footer(
+          out, colorize,
+          total: total, failed_count: failed_count, pending: pending, total_elapsed: total_elapsed
+        )
+      end
+
+      failed_count
+    end
+
+    def write_shared_footer(out, colorize, total:, failed_count:, pending:, total_elapsed:)
+      verdict = failed_count.positive? ? "Test Failed" : "Test Succeeded"
+      verdict_color = failed_count.positive? ? :red : :green
+      out.puts(colorize.call(verdict_color, verdict))
+      out.puts(colorize.call(
+        verdict_color,
+        format("Tests Passed: %d failed, %d pending, %d total (%s seconds)",
+          failed_count, pending, total, format_seconds(total_elapsed))
+      ))
+    end
+
+    def write_vitest_footer(out, colorize, total:, failed_count:, pending:, total_elapsed:, files_total:, files_failed:)
+      passed = total - failed_count - pending
+      files_passed = files_total - files_failed
+      out.puts(vitest_summary_line("Test Files", colorize, failed: files_failed, passed: files_passed, pending: 0, total: files_total))
+      out.puts(vitest_summary_line("Tests", colorize, failed: failed_count, passed: passed, pending: pending, total: total))
+      out.puts(format("%11s  %s", "Duration", format_vitest_duration(total_elapsed)))
+    end
+
+    def vitest_summary_line(label, colorize, failed:, passed:, pending:, total:)
+      parts = []
+      parts << colorize.call(:red, "#{failed} failed") if failed.positive?
+      parts << colorize.call(:green, "#{passed} passed") if passed.positive?
+      parts << colorize.call(:gray, "#{pending} pending") if pending.positive?
+      parts << "0 passed" if parts.empty?
+      format("%11s  %s (%d)", label, parts.join(" | "), total)
+    end
+
+    def colorize_pass(style, name, example, colorize)
+      case style
+      when :classic
+        "#{colorize.call(:green, "✔")} #{name} (#{colorize.call(:green, format_seconds(example[:run_time]))} seconds)"
+      when :fs
+        "#{colorize.call(:green, "✔")} #{colorize.call(:gray, name)}"
+      when :fv
+        number, unit = format_vitest_duration_parts(example[:run_time])
+        "#{colorize.call(:green, "✓")} #{name} #{colorize.call(:green, number)}#{colorize.call(:bright_green, unit)}"
+      else # :fd
+        colorize.call(:green, name)
+      end
+    end
+
+    def colorize_fail(style, name, example, n, colorize)
+      case style
+      when :classic
+        "#{colorize.call(:red, "✖")} #{name} (FAILED - #{n}) (#{colorize.call(:red, format_seconds(example[:run_time]))} seconds)"
+      when :fs
+        colorize.call(:red, "✗ #{name} (FAILED - #{n})")
+      when :fv
+        colorize.call(:red, "× #{name} #{format_vitest_duration(example[:run_time])}")
+      else # :fd
+        colorize.call(:red, "#{name} (FAILED - #{n})")
+      end
+    end
+
+    # RSpec's own vocabulary is "pending" -- not "skipped" the way Go/Ginkgo
+    # call it -- so every style says PENDING, matching what `rspec`'s real
+    # `-fd`/`--format documentation` would say for the same example. Include
+    # the pending reason where RSpec itself would (`-fd`/`-fs`); `:classic`
+    # and `:fv` stay terse (glyph/name/time only), matching how `gorderly`'s
+    # classic and Vitest's own tree both treat a skip.
+    def colorize_pending(style, name, example, colorize)
+      case style
+      when :classic
+        "#{colorize.call(:cyan, "⊘")} #{name} (#{colorize.call(:cyan, format_seconds(example[:run_time]))} seconds)"
+      when :fs
+        colorize.call(:cyan, "- #{name} #{pending_suffix(example)}")
+      when :fv
+        colorize.call(:gray, "↓ #{name}")
+      else # :fd
+        colorize.call(:yellow, "#{name} #{pending_suffix(example)}")
+      end
+    end
+
+    def pending_suffix(example)
+      reason = example[:pending_message]
+      reason ? "(PENDING: #{reason})" : "(PENDING)"
+    end
+
+    def format_backtrace(example)
+      exception = example[:exception]
+      return [] unless exception
+
+      ["#{exception[:class]}: #{exception[:message]}"] + Array(exception[:backtrace])
+    end
+
+    def format_seconds(seconds)
+      (seconds < 1) ? format("%.4f", seconds) : format("%.2f", seconds)
+    end
+
+    def format_vitest_duration_parts(seconds)
+      ms = seconds * 1000
+      return [format("%.2f", ms / 1000), "s"] if ms > 1000
+
+      [ms.round.to_s, "ms"]
+    end
+
+    def format_vitest_duration(seconds)
+      number, unit = format_vitest_duration_parts(seconds)
+      "#{number}#{unit}"
+    end
+  end
+end

data/lib/rutidy/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Rutidy
+  VERSION = "0.1.0"
+end

data/lib/rutidy.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "rutidy/version"
+require "rutidy/render"
+require "rutidy/cli"
+
+module Rutidy
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: rutidy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- John Woodell
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-08-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+description: A real RSpec formatter plus a small renderer that turns RSpec's own example
+  tree into the same classic/fd/fs/fv styles gorderly, kotidy, and xctidy already
+  share.
+email:
+- woodie@netpress.com
+executables:
+- rutidy
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- exe/rutidy
+- lib/rutidy.rb
+- lib/rutidy/cli.rb
+- lib/rutidy/formatter.rb
+- lib/rutidy/render.rb
+- lib/rutidy/version.rb
+homepage: https://github.com/woodie/rutidy
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/woodie/rutidy
+  source_code_uri: https://github.com/woodie/rutidy
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: RSpec/Mocha/Vitest-style output for RSpec
+test_files: []