rspec-turbo 0.1.0

data/lib/rspec_turbo/runner.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module RSpecTurbo
+  # Top-level orchestration: parse argv, set up the test databases, discover
+  # and plan the spec files, hand execution to the Executor, then print the
+  # report and (optionally) merge coverage. Exits non-zero on any failure.
+  class Runner
+    def initialize(argv)
+      @options = Options.new(argv)
+      @workers = Config.workers
+    end
+
+    def run
+      FileUtils.mkdir_p(Config.log_dir)
+      print_header
+
+      setup_databases
+      planner = plan(discover_files)
+
+      FileUtils.rm_rf("coverage") if Config.coverage?
+
+      display = Display.new(planner)
+      executor = Executor.new(planner, display, @options.rspec_options)
+      results = executor.run
+      wall_total = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - executor.wall_started).round
+
+      display.print_report(results, wall_total, @workers)
+      merge_coverage if Config.coverage?
+
+      exit((results.any? { |r| r[:status] == "FAIL" }) ? 1 : 0)
+    end
+
+    private
+
+    def print_header
+      puts
+      puts Terminal::SEP_THICK
+      puts "  RSpec Turbo - Parallel"
+      puts Terminal::SEP_THICK
+      puts
+    end
+
+    def setup_databases
+      setup = DbSetup.new(@workers)
+      cached = !Config.force_setup? && setup.cached?
+      label = cached ? "DB cache hit" : "Setting up #{@workers} test DB(s)"
+
+      ok, elapsed = with_spinner(label) { setup.run! }
+
+      unless ok
+        print "\e[?25h" if Config::TTY
+        warn "✗ DB setup failed."
+        exit 2
+      end
+
+      puts "  #{Terminal.c("32", "✓")} #{@workers} DB(s) ready (#{Terminal.fmt_duration(elapsed)})"
+    end
+
+    def discover_files
+      files = FileDiscovery.new(@options.folders, exclude_patterns: @options.exclude_patterns).files
+
+      if files.empty?
+        puts "Nothing to run."
+        exit 0
+      end
+
+      files
+    end
+
+    def plan(files)
+      planner = nil
+
+      _, elapsed = with_spinner("Counting examples (#{files.size} files)") do
+        planner = BatchPlanner.new(files, num_workers: @workers, rspec_options: @options.rspec_options).plan!
+      end
+
+      total = planner.counts.values.sum
+      avg = planner.batches.empty? ? 0 : (total.to_f / planner.batches.size).round
+      pending_str = planner.pending_count.positive? ? " · #{planner.pending_count} pending" : ""
+
+      puts "  #{Terminal.c("32", "✓")} #{total} examples#{pending_str} · #{files.size} files · " \
+           "#{planner.batches.size} batches (~#{avg} each) (#{Terminal.fmt_duration(elapsed)})"
+      puts
+
+      planner
+    end
+
+    def merge_coverage
+      puts
+      print "  Merging coverage reports..."
+      $stdout.flush
+
+      merge_log = Config.coverage_merge_log
+      ok = system("RAILS_ENV=test bundle exec rake coverage:merge", out: merge_log, err: [:child, :out])
+
+      if ok
+        puts " #{Terminal.c("32", "✓")} done"
+      else
+        puts " #{Terminal.c("31", "✗")} failed (run `rake coverage:merge` manually)"
+        last_lines = File.exist?(merge_log) ? File.readlines(merge_log).last(10).join.strip : ""
+        warn last_lines unless last_lines.empty?
+      end
+    end
+
+    # Animated single-line spinner wrapping a block. On a TTY it shows a
+    # spinning animation and clears it on completion; on CI it just runs the
+    # block. Returns [block_result, elapsed_seconds].
+    def with_spinner(label)
+      t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      unless Config::TTY
+        result = yield
+
+        return [result, (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0).round]
+      end
+
+      frame = 0
+      running = true
+      print "\e[?25l"
+
+      thread = Thread.new do
+        while running
+          spin = Terminal::SPINNER_FRAMES[frame % Terminal::SPINNER_FRAMES.size]
+          print "\r  \e[36m#{spin}\e[0m #{label}..."
+          $stdout.flush
+          sleep 0.1
+          frame += 1
+        end
+      end
+
+      result = yield
+      running = false
+      thread.join
+      elapsed = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0).round
+      print "\r\e[2K"
+      print "\e[?25h"
+
+      [result, elapsed]
+    end
+  end
+end

data/lib/rspec_turbo/slow_profile.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+# Opt-in slow-test profiler, loaded into each worker by Worker.spawn.
+#
+# Enable with RSPEC_PROFILE_SLOW=1 to print, at the end of the run:
+#   - Top 20 slowest / query-heaviest examples
+#   - TOP 15 FILES BY TIME  (parsed back by RSpecTurbo::Display for the report)
+#
+# Optional thresholds:
+#   RSPEC_PROFILE_THRESHOLD_TIME=0.2    # seconds; example must exceed to list
+#   RSPEC_PROFILE_THRESHOLD_QUERIES=30  # SQL queries; same idea
+#
+# Optional folder grouping:
+#   RSPEC_PROFILE_GROUP_BY=1
+#     Auto-detects the base from the rspec CLI args. Running `rspec
+#     spec/requests/v1` buckets examples by direct subfolder of that base.
+#     With multiple paths it uses their longest common directory.
+#   RSPEC_PROFILE_GROUP_BY=spec/requests/v1
+#     Explicit base path. Buckets by direct subfolder of that base.
+#   RSPEC_PROFILE_GROUP_BY=spec/requests/v1/items,spec/requests/v1/bins
+#     Explicit list of folders; each is its own bucket.
+#
+# Query counting relies on ActiveSupport::Notifications, so this block only
+# does work in a Rails app and only when explicitly enabled.
+
+return unless ENV["RSPEC_PROFILE_SLOW"] || ENV["RSPEC_PROFILE_GROUP_BY"]
+
+RSpec.configure do |config|
+  slow_tests = []
+  file_times = Hash.new(0.0)
+  file_query_counts = Hash.new(0)
+  folder_times = Hash.new(0.0)
+  folder_query_counts = Hash.new(0)
+  folder_example_counts = Hash.new(0)
+
+  threshold_time = Float(ENV["RSPEC_PROFILE_THRESHOLD_TIME"] || "0.2")
+  threshold_queries = Integer(ENV["RSPEC_PROFILE_THRESHOLD_QUERIES"] || "30")
+
+  blank = ->(str) { str.nil? || str.strip.empty? }
+
+  # Resolve grouping config from env into one of:
+  #   { mode: :subfolder, base: "spec/requests/v1" }  - bucket by direct subfolder
+  #   { mode: :list, bases: ["spec/foo", "spec/bar"] } - each folder is its own bucket
+  resolve_group_by = lambda do |raw|
+    next nil if blank.call(raw)
+
+    raw = raw.delete_suffix("/")
+
+    if raw.include?(",")
+      bases = raw.split(",").map { |p| p.strip.delete_prefix("./").delete_suffix("/") }.reject(&:empty?)
+      next nil if bases.empty?
+
+      next {mode: :list, bases: bases}
+    end
+
+    if ["1", "true", "auto"].include?(raw.downcase)
+      cli_paths = RSpec.configuration.files_to_run
+      next nil if cli_paths.empty?
+
+      dirs = cli_paths.map do |path|
+        cleaned = path.delete_prefix("./").sub(/:\d+\z/, "")
+        File.directory?(cleaned) ? cleaned : File.dirname(cleaned)
+      end.uniq
+
+      base =
+        if dirs.size == 1
+          dirs.first
+        else
+          parts = dirs.map { |d| d.split("/") }
+          common = []
+          parts.first.each_with_index do |segment, i|
+            break unless parts.all? { |p| p[i] == segment }
+
+            common << segment
+          end
+          common.empty? ? nil : common.join("/")
+        end
+
+      next nil if base.nil?
+
+      next {mode: :subfolder, base: base}
+    end
+
+    {mode: :subfolder, base: raw}
+  end
+
+  bucket_for = lambda do |file_path, group_config|
+    next nil unless group_config
+
+    normalized = file_path.to_s.delete_prefix("./")
+
+    case group_config[:mode]
+    when :subfolder
+      base = group_config[:base]
+      next nil unless normalized.start_with?("#{base}/")
+
+      rest = normalized[(base.length + 1)..]
+      first = rest.split("/").first
+      first ? "#{base}/#{first}" : nil
+    when :list
+      group_config[:bases].find { |b| normalized.start_with?("#{b}/") || normalized == b }
+    end
+  end
+
+  group_config = nil
+
+  config.before(:suite) do
+    group_config = resolve_group_by.call(ENV["RSPEC_PROFILE_GROUP_BY"])
+  end
+
+  # Query counting needs ActiveSupport; without it (non-Rails suites) we still
+  # profile by time and just report zero queries instead of crashing.
+  count_sql = defined?(ActiveSupport::Notifications)
+
+  config.around(:each) do |example|
+    query_count = 0
+    subscriber =
+      if count_sql
+        ActiveSupport::Notifications.subscribe("sql.active_record") do |_, _, _, _, payload|
+          next if payload[:name] == "SCHEMA"
+          next if /\A\s*(SAVEPOINT|RELEASE|ROLLBACK|BEGIN|COMMIT)/i.match?(payload[:sql])
+
+          query_count += 1
+        end
+      end
+
+    start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    example.run
+    duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+
+    ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+
+    file = example.metadata[:file_path]
+    file_times[file] += duration
+    file_query_counts[file] += query_count
+
+    if group_config
+      folder_key = bucket_for.call(file, group_config)
+
+      if folder_key
+        folder_times[folder_key] += duration
+        folder_query_counts[folder_key] += query_count
+        folder_example_counts[folder_key] += 1
+      end
+    end
+
+    next unless duration >= threshold_time || query_count >= threshold_queries
+
+    slow_tests << {
+      description: example.full_description,
+      duration: duration,
+      queries: query_count,
+      file: file
+    }
+  end
+
+  config.after(:suite) do
+    puts
+    puts
+    puts "#{"\e[34m=" * 96}\e[0m"
+    puts " \e[34mSLOW / EXPENSIVE EXAMPLES (time >= #{threshold_time}s OR queries >= #{threshold_queries})\e[0m"
+    puts "#{"\e[34m=" * 96}\e[0m"
+
+    puts "TIME     QUERIES FILE                                                         EXAMPLE"
+
+    slow_tests.sort_by { |t| -t[:duration] }.first(20).each do |t|
+      puts format(
+        "%6.3fs %4d     %-60s %s",
+        t[:duration],
+        t[:queries],
+        t[:file].to_s.sub(%r{^\./}, "").slice(0, 60),
+        t[:description].slice(0, 80)
+      )
+    end
+
+    puts
+    puts "#{"\e[31m=" * 96}\e[0m"
+    puts " \e[31mTOP 15 FILES BY TIME\e[0m"
+    puts "#{"\e[31m=" * 96}\e[0m"
+
+    puts "TIME     QUERIES  FILE"
+
+    file_times.sort_by { |_, t| -t }.first(15).each do |file, time|
+      puts format("%6.2fs %6d    %s", time, file_query_counts[file], file.to_s.sub(%r{^\./}, ""))
+    end
+
+    if group_config && folder_times.size > 1
+      label =
+        case group_config[:mode]
+        when :subfolder then "FOLDERS UNDER #{group_config[:base]} BY TIME"
+        when :list then "FOLDERS BY TIME"
+        end
+
+      puts
+      puts "#{"\e[33m=" * 96}\e[0m"
+      puts " \e[33m#{label}\e[0m"
+      puts "#{"\e[33m=" * 96}\e[0m"
+
+      puts "TIME     QUERIES  EXAMPLES FOLDER"
+
+      folder_times.sort_by { |_, t| -t }.each do |folder, time|
+        puts format("%6.2fs %6d    %4d      %s", time, folder_query_counts[folder], folder_example_counts[folder], folder)
+      end
+    end
+
+    puts
+  end
+end

data/lib/rspec_turbo/tasks.rake

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "rspec_turbo"
+
+namespace :spec do
+  desc "Run the full RSpec suite in parallel with rspec-turbo"
+  task :turbo do
+    # Runs the whole suite; the runner spawns its own per-worker rspec
+    # processes (so this task needs no :environment) and exits with the
+    # suite's status. For specific folders or flags, use `rspec-turbo` directly.
+    RSpecTurbo::Runner.new([]).run
+  end
+end
+
+namespace :coverage do
+  # Merge the per-worker SimpleCov result files into one report. Workers run
+  # with their own TEST_ENV_NUMBER, so each writes a separate .resultset.json
+  # (point them at coverage/$TEST_ENV_NUMBER/ in spec_helper — see the README).
+  # Invoked automatically by the runner when COVERAGE=1.
+  desc "Merge per-worker SimpleCov results (JSON on CI, HTML locally)"
+  task :merge do
+    begin
+      require "simplecov"
+      require "simplecov_json_formatter"
+    rescue LoadError => e
+      abort "coverage:merge needs `simplecov` and `simplecov_json_formatter` in your Gemfile — #{e.message}"
+    end
+
+    pattern = ENV.fetch("RSPEC_TURBO_COVERAGE_GLOB", "coverage/**/.resultset.json")
+    result_files = Dir[pattern]
+
+    if result_files.empty?
+      warn "coverage:merge: no result files matched #{pattern.inspect} — nothing to merge"
+      next
+    end
+
+    on_ci = %w[1 true].include?(ENV["CI"].to_s.downcase)
+    chosen_formatter = on_ci ? SimpleCov::Formatter::JSONFormatter : SimpleCov::Formatter::HTMLFormatter
+
+    puts "Merging #{result_files.size} coverage result file(s) → #{chosen_formatter}"
+
+    SimpleCov.collate(result_files) do
+      formatter chosen_formatter
+    end
+  end
+end

data/lib/rspec_turbo/terminal.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RSpecTurbo
+  # Pure presentation helpers shared across the reporting code: duration
+  # formatting, optional ANSI colour, spinner frames and rule separators.
+  #
+  # On CI (no TTY) colour is dropped and box-drawing characters fall back to
+  # plain ASCII, which CI log viewers render without mangling.
+  module Terminal
+    module_function
+
+    SPINNER_FRAMES = %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏].freeze
+
+    SEP_THIN = (Config::TTY ? "─" : "=") * 68
+    SEP_THICK = (Config::TTY ? "═" : "=") * 68
+
+    def fmt_duration(seconds)
+      minutes, secs = seconds.divmod(60)
+
+      minutes.positive? ? format("%dm%02ds", minutes, secs) : format("%ds", secs)
+    end
+
+    # Wraps text in an ANSI escape sequence only when running in a TTY.
+    def c(code, text) = Config::TTY ? "\e[#{code}m#{text}\e[0m" : text
+
+    def strip_ansi(text) = text.gsub(/\e\[[0-9;]*m/, "")
+  end
+end

data/lib/rspec_turbo/version.rb

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

data/lib/rspec_turbo/worker.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module RSpecTurbo
+  # A single RSpec process running one batch of work. Worker.spawn forks the
+  # process and returns a Worker the executor tracks until the process exits.
+  #
+  # Every worker is wired with two helper files shipped by the gem:
+  #   * progress_reporter.rb — a formatter that streams the example count to a
+  #     progress file so the parent can draw a global progress bar.
+  #   * slow_profile.rb      — an opt-in profiler (RSPEC_PROFILE_SLOW=1) that
+  #     emits the "TOP N FILES BY TIME" block the report aggregates. It is a
+  #     no-op when profiling is disabled, so requiring it is always safe.
+  class Worker
+    PROGRESS_REPORTER_PATH = File.expand_path("progress_reporter.rb", __dir__)
+    SLOW_PROFILE_PATH = File.expand_path("slow_profile.rb", __dir__)
+
+    attr_reader :pid, :label, :units, :slot, :started, :progress_file
+
+    def self.spawn(label:, units:, slot:, rspec_options:)
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      progress_file = Config.progress_path(slot)
+      File.write(progress_file, "0")
+
+      pid = Process.spawn(
+        env(slot, progress_file),
+        "bundle", "exec", "rspec", "--color", "--order", "random",
+        "--require", PROGRESS_REPORTER_PATH,
+        "--require", SLOW_PROFILE_PATH,
+        "--format", "progress",
+        "--format", "RSpecTurbo::ProgressReporter",
+        *junit_args(slot),
+        *rspec_options, *rspec_args(units),
+        out: Config.log_path(label), err: [:child, :out]
+      )
+
+      new(pid: pid, label: label, units: units, slot: slot, started: started, progress_file: progress_file)
+    end
+
+    def self.env(slot, progress_file)
+      {
+        "TEST_ENV_NUMBER" => slot.to_s,
+        "RSPEC_TURBO_PROGRESS_FILE" => progress_file,
+        "COVERAGE" => ENV.fetch("COVERAGE", "0")
+      }.merge(profile_env)
+    end
+
+    # Profiling is on by default: turbo flips RSPEC_PROFILE_SLOW=1 in the child
+    # unless the user set it themselves. RSPEC_TURBO_NO_PROFILE=1 hard-unsets the
+    # profiler envs in the child (nil = unset), winning over any inherited value.
+    def self.profile_env
+      return {"RSPEC_PROFILE_SLOW" => nil, "RSPEC_PROFILE_GROUP_BY" => nil} unless Config.profile?
+
+      {"RSPEC_PROFILE_SLOW" => ENV.fetch("RSPEC_PROFILE_SLOW", "1")}
+    end
+
+    # A unit is either a file path (String) or a pre-resolved list of example
+    # IDs (Array) — the latter is already in `spec/...[1:2]` form.
+    def self.rspec_args(units)
+      units.flat_map { |unit| unit.is_a?(Array) ? unit : ["spec/#{unit}"] }
+    end
+
+    def self.junit_args(slot)
+      dir = Config.junit_dir
+      return [] unless dir
+
+      FileUtils.mkdir_p(dir)
+
+      ["--require", "rspec_junit_formatter",
+        "--format", "RspecJunitFormatter",
+        "--out", File.join(dir, "rspec-turbo-#{slot}.xml")]
+    end
+
+    private_class_method :env, :profile_env, :rspec_args, :junit_args
+
+    def initialize(pid:, label:, units:, slot:, started:, progress_file:)
+      @pid = pid
+      @label = label
+      @units = units
+      @slot = slot
+      @started = started
+      @progress_file = progress_file
+    end
+
+    def duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - @started).round
+  end
+end

data/lib/rspec_turbo.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "rspec_turbo/version"
+require_relative "rspec_turbo/config"
+require_relative "rspec_turbo/terminal"
+require_relative "rspec_turbo/options"
+require_relative "rspec_turbo/db_setup"
+require_relative "rspec_turbo/file_discovery"
+require_relative "rspec_turbo/batch_planner"
+require_relative "rspec_turbo/display"
+require_relative "rspec_turbo/worker"
+require_relative "rspec_turbo/executor"
+require_relative "rspec_turbo/runner"
+
+# Parallel RSpec runner with smart, dry-run-based example balancing.
+#
+# progress_reporter.rb and slow_profile.rb are intentionally NOT required here:
+# they run inside the spawned worker processes (loaded by absolute path), not in
+# the orchestrator, so the parent never has to load rspec-core or ActiveSupport.
+module RSpecTurbo
+end
+
+# In a Rails app, register the `spec:turbo` Rake task (also reachable as
+# `rails spec:turbo`). Skipped entirely when Rails isn't loaded.
+require_relative "rspec_turbo/railtie" if defined?(Rails::Railtie)

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: rspec-turbo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- thadeu
+bindir: exe
+cert_chain: []
+date: 2026-06-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+- !ruby/object:Gem::Dependency
+  name: simplecov_json_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+description: |
+  rspec-turbo runs your RSpec suite across N processes like parallel_tests,
+  but balances work by actual example count (from a single --dry-run) using an
+  LPT bin-packing heuristic, splitting oversized files across workers. It ships
+  a live TTY dashboard, a CI-friendly progress mode, schema-fingerprinted test
+  DB setup caching, JUnit output, coverage merging, and a slowest folders/files
+  report.
+email:
+- tadeuu@gmail.com
+executables:
+- rspec-turbo
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- exe/rspec-turbo
+- lib/rspec-turbo.rb
+- lib/rspec_turbo.rb
+- lib/rspec_turbo/batch_planner.rb
+- lib/rspec_turbo/config.rb
+- lib/rspec_turbo/db_setup.rb
+- lib/rspec_turbo/display.rb
+- lib/rspec_turbo/executor.rb
+- lib/rspec_turbo/file_discovery.rb
+- lib/rspec_turbo/options.rb
+- lib/rspec_turbo/progress_reporter.rb
+- lib/rspec_turbo/railtie.rb
+- lib/rspec_turbo/runner.rb
+- lib/rspec_turbo/slow_profile.rb
+- lib/rspec_turbo/tasks.rake
+- lib/rspec_turbo/terminal.rb
+- lib/rspec_turbo/version.rb
+- lib/rspec_turbo/worker.rb
+homepage: https://github.com/thadeu/rspec-turbo
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/thadeu/rspec-turbo
+  changelog_uri: https://github.com/thadeu/rspec-turbo/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+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.6.2
+specification_version: 4
+summary: Parallel RSpec runner with smart, dry-run-based example balancing.
+test_files: []