turbo_tests2 3.1.14 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4031f877288b31974b622b8dffb0acffb1361ee96347d695ea69dd9c47a5950
-  data.tar.gz: 8bc186019f3b056c15dc2f68cf42b2062a68f4dc9d1fa34c397446933ac37999
+  metadata.gz: e208abc2c8f1bc3b6d9d8891911baf8874d3c8e5cfa097b108d3e71bd722ca13
+  data.tar.gz: b4f3f282c992f71ad38aaf07323fc635a3f980c37b6b062236e4eabd2eea4909
 SHA512:
-  metadata.gz: 9a28f75223e3bd926d6cc5ebf4e94bd0de1efa10b82eab792e595cedc73aa1a6bb398e2093058f170c4c7a2d5a76d4b7dc1e8edcc0d01971e4d03d7406d97170
-  data.tar.gz: 4eed7b464c8e3d26419a2822bdeed6c60084c5e25968352af3a053d728f25004b18383b4fed4ab13994f3dfcb28a02e23542560c51c1a1c73fbb3a03ffa90755
+  metadata.gz: 9b2880a10a0eba9651b65d450864fa5e7cf5fa327dc90a6554f5e812a9f5566d4bc46c8b12dc7c43e58834b7c77db51d87d34062c58b9566909d400ccaa913b2
+  data.tar.gz: e8b80088da4717d0db1fa889b038f3d8684d0262b6270750d6801cf2227d1e4b1d64233b0feafc035e3a9c38831e7ea488cc87ab6ba5ff206ddf72814308f6fb

data/CHANGELOG.md

@@ -30,6 +30,60 @@ Please file a bug if you notice a violation of semantic versioning.
 
 ### Security
 
+## [3.2.0] - 2026-07-18
+
+- TAG: [v3.2.0][3.2.0t]
+- COVERAGE: 96.88% -- 869/897 lines in 10 files
+- BRANCH COVERAGE: 84.44% -- 217/257 branches in 10 files
+- 34.69% documented
+
+### Added
+
+- `--count` is now accepted as an alias for `-n`, matching the
+  `parallel_tests` process-count option while keeping the existing
+  `-w` / `--workers` aliases.
+- Documented the supported `parallel_tests` option subset and clarified that
+  unsupported flags are not blindly passed through after `--`.
+- Added `--worker-output MODE` and `TURBO_TESTS2_WORKER_OUTPUT` support for
+  selecting raw worker stdout/stderr handling: `warnings`, `stream`, `buffered`,
+  or `quiet`.
+- `--group-by runtime|filesize|found` is now parsed explicitly and mapped to
+  `parallel_tests` grouping modes, including when supplied after the
+  compatibility `--` separator.
+- `--allowed-missing PERCENT` and `--unknown-runtime SECONDS` are now parsed
+  explicitly and mapped to `parallel_tests` runtime grouping tuning options,
+  including when supplied after the compatibility `--` separator.
+
+### Changed
+
+- Pull request engine workflows now keep JRuby and TruffleRuby coverage
+  available via branch opt-in prefixes: `jruby/*` runs JRuby workflows,
+  `truffleruby/*` runs TruffleRuby workflows, and `engines/*` runs all engine
+  workflows. Other pull request branches continue to run MRI checks without the
+  alternate engine jobs.
+- The delayed documentation formatter spec now lives under fixtures so the
+  normal suite does not pay its fixed load-time delay.
+
+### Fixed
+
+- Successful non-verbose runs now surface warning and deprecation lines emitted
+  as raw worker stdout/stderr without dumping all buffered worker output.
+- `heads.yml` and `dep-heads.yml` now gate JRuby and TruffleRuby PR coverage
+  at the job level, so non-matching PR branches skip those engine jobs before a
+  runner is provisioned.
+- Direct `turbo_tests2` runs now refresh the default
+  `tmp/turbo_rspec_runtime.log` timing log, and `--runtime-log` writes the
+  requested timing log even when the run groups by filesize.
+- `--only-group GROUP_INDEX[,GROUP_INDEX]` is now parsed explicitly and runs
+  only the selected 1-based `parallel_tests` group index(es), using filesize
+  grouping by default for selected-group reruns.
+- `--pattern PATTERN` is now parsed explicitly and mapped to `parallel_tests`
+  file discovery instead of being treated as a spec file when supplied after
+  `--`.
+- `--exclude-pattern PATTERN` is now parsed explicitly and mapped to
+  `parallel_tests` file discovery instead of being treated as a spec file when
+  supplied after `--`.
+
 ## [3.1.14] - 2026-07-17
 
 - TAG: [v3.1.14][3.1.14t]
@@ -302,7 +356,9 @@ Please file a bug if you notice a violation of semantic versioning.
 
 - Initial release
 
-[Unreleased]: https://github.com/galtzo-floss/turbo_tests2/compare/v3.1.14...HEAD
+[Unreleased]: https://github.com/galtzo-floss/turbo_tests2/compare/v3.2.0...HEAD
+[3.2.0]: https://github.com/galtzo-floss/turbo_tests2/compare/v3.1.14...v3.2.0
+[3.2.0t]: https://github.com/galtzo-floss/turbo_tests2/releases/tag/v3.2.0
 [3.1.14]: https://github.com/galtzo-floss/turbo_tests2/compare/v3.1.13...v3.1.14
 [3.1.14t]: https://github.com/galtzo-floss/turbo_tests2/releases/tag/v3.1.14
 [3.1.13]: https://github.com/galtzo-floss/turbo_tests2/compare/v3.1.12...v3.1.13

data/README.md

@@ -196,14 +196,23 @@ Usage: turbo_tests2 [options]
   turbo_tests2 spec/bar spec/baz/xxx_spec.rb
 
 Options:
-    -n, -w, --workers [PROCESSES]    How many processes to use, default: available CPUs
+    -n, --count [PROCESSES]          How many processes to use, default: available CPUs
+    -w, --workers [PROCESSES]        Alias for -n, --count
     -r, --require PATH               Require a file.
     -f, --format FORMATTER           Choose a formatter. Available formatters: progress (p), documentation (d). Default: progress
     -t, --tag TAG                    Run examples with the specified tag.
     -o, --out FILE                   Write output to a file instead of $stdout
         --runtime-log FILE           Location of previously recorded test runtimes
         --example-status-log FILE    Use RSpec example status persistence timings for grouping
+        --pattern PATTERN            Run spec files matching this regex pattern
+        --exclude-pattern PATTERN    Exclude spec files matching this regex pattern
+        --only-group GROUP_INDEX[,GROUP_INDEX]
+                                      Run only the selected 1-based parallel_tests group index(es)
+        --group-by MODE              Group files by runtime, filesize, or found order
+        --allowed-missing PERCENT    Allowed percentage of missing runtimes for runtime grouping
+        --unknown-runtime SECONDS    Runtime in seconds to assign files missing runtime history
     -v, --verbose                    More output
+        --worker-output MODE         Raw worker output mode: warnings, stream, buffered, or quiet; env: TURBO_TESTS2_WORKER_OUTPUT
         --fail-fast=[N]
         --seed SEED                  Seed for RSpec
         --order ORDER                RSpec example order: random (default) or defined
@@ -217,12 +226,104 @@ By default, `turbo_tests2` generates one random RSpec seed, prints it, and passe
 that same seed to every worker process. Use `--seed SEED` to replay a run, or
 `--order defined` / `--no-random` when you want ordered examples without a seed.
 
-To pass any options supported by parallel_tests, use `--`:
+`turbo_tests2` supports selected `parallel_tests` options explicitly. It does
+not invoke the `parallel_tests` CLI directly, and it does not blindly pass
+unknown `parallel_tests` flags through after `--`. Options after `--` are parsed
+only when listed as supported below.
+
+To select or exclude files matching a regex:
+
+```bash
+bundle exec turbo_tests2 -n 4 --pattern spec/system
+bundle exec turbo_tests2 -n 4 --exclude-pattern spec/system
+```
+
+The compatibility separator also accepts supported options:
 
 ```bash
-bundle exec turbo_tests2 -n 4 -- --only-group 1 --pattern spec/system
+bundle exec turbo_tests2 -n 4 -- --pattern spec/system
+bundle exec turbo_tests2 -n 4 -- --exclude-pattern spec/system
 ```
 
+To rerun one or more selected 1-based groups from a prior parallel split:
+
+```bash
+bundle exec turbo_tests2 -n 4 --only-group 2
+bundle exec turbo_tests2 -n 4 -- --only-group 1,3
+```
+
+To choose a supported `parallel_tests` grouping mode explicitly:
+
+```bash
+bundle exec turbo_tests2 -n 4 --group-by runtime
+bundle exec turbo_tests2 -n 4 --group-by filesize
+bundle exec turbo_tests2 -n 4 --group-by found
+bundle exec turbo_tests2 -n 4 -- --group-by runtime
+```
+
+`runtime` grouping uses the configured runtime log, which `turbo_tests2`
+continues to record by default. `filesize` and `found` do not use runtime
+history for the initial split, but worker runtime recording still runs so
+future runtime-based runs can use the updated log.
+
+Runtime grouping also supports the explicit `parallel_tests` tuning flags
+`--allowed-missing PERCENT` and `--unknown-runtime SECONDS`:
+
+```bash
+bundle exec turbo_tests2 -n 4 --group-by runtime --allowed-missing 25
+bundle exec turbo_tests2 -n 4 --group-by runtime --unknown-runtime 0.5
+bundle exec turbo_tests2 -n 4 -- --allowed-missing 25 --unknown-runtime 0.5
+```
+
+Selected group runs default to filesize grouping unless `--group-by` is
+provided.
+
+### Supported `parallel_tests` Options
+
+| `parallel_tests` option | Status | `turbo_tests2` equivalent | Notes |
+|-------------------------|--------|---------------------------|-------|
+| `-n`, `--count PROCESSES` | Supported natively | `-n`, `--count`; `-w`, `--workers` aliases | Parsed as a `turbo_tests2` option before any `--` separator. |
+| `-p`, `--pattern PATTERN` | Supported | `--pattern PATTERN` | May be supplied before or after `--`; mapped to `parallel_tests` file discovery. |
+| `--exclude-pattern PATTERN` | Supported | `--exclude-pattern PATTERN` | May be supplied before or after `--`; mapped to `parallel_tests` file discovery. |
+| `--only-group GROUP_INDEX[,GROUP_INDEX]` | Supported | `--only-group GROUP_INDEX[,GROUP_INDEX]` | May be supplied before or after `--`; uses 1-based `parallel_tests` group indexes. |
+| `--group-by runtime` | Supported | `--group-by runtime` | May be supplied before or after `--`; uses runtime-log grouping. |
+| `--group-by filesize` | Supported | `--group-by filesize` | May be supplied before or after `--`; groups by file size. |
+| `--group-by found` | Supported | `--group-by found` | May be supplied before or after `--`; keeps discovered file order. |
+| `--allowed-missing PERCENT` | Supported | `--allowed-missing PERCENT` | May be supplied before or after `--`; validates `0..100`. |
+| `--unknown-runtime SECONDS` | Supported | `--unknown-runtime SECONDS` | May be supplied before or after `--`; validates finite non-negative seconds. |
+| `--runtime-log PATH` | Supported natively | `--runtime-log FILE` | Parsed as a `turbo_tests2` option before any `--` separator. |
+| `--nice` | Supported natively | `--nice` | Parsed as a `turbo_tests2` option before any `--` separator. |
+| `--fail-fast` | Supported natively | `--fail-fast[=N]` | Uses `turbo_tests2` fail-fast handling and RSpec worker arguments. |
+| `--verbose` | Supported natively | `-v`, `--verbose` | Enables `turbo_tests2` verbose output. |
+| `--test-options`, `-o` | Not supported as pass-through | Use `turbo_tests2` RSpec-facing flags | `turbo_tests2` exposes selected RSpec options directly, such as `--seed`, `--order`, `--no-random`, `--tag`, `--format`, and `--out`. |
+| `--group-by default`, `steps`, `scenarios` | Not supported | None | `turbo_tests2` targets RSpec file grouping, not every `parallel_tests` framework mode. |
+| `--single`, `--isolate`, `--isolate-n` | Not supported | None | No first-class mapping yet. |
+| `--specify-groups` | Not supported | None | No first-class mapping yet. |
+| `-m`, `--multiply-processes` | Not supported | None | Use an explicit `-n`/`--count` value. |
+| `-e`, `--exec`, `--exec-args`, `--non-parallel` | Not supported | None | `turbo_tests2` runs RSpec workers, not arbitrary command groups. |
+| `--suffix`, `--type`, `--ignore-tags` | Not supported | None | `turbo_tests2` currently targets RSpec. |
+| `--serialize-stdout`, `--prefix-output-with-test-env-number`, `--combine-stderr`, `--quiet`, `--verbose-command`, `--verbose-process-command`, `--verbose-rerun-command` | Not supported | None | `turbo_tests2` owns worker output collection and formatter reporting. |
+| `--no-symlinks`, `--allow-duplicates`, `--first-is-1`, `--highest-exit-status`, `--failure-exit-code`, `--test-file-limit` | Not supported | None | These need explicit design and tests before they can be accepted. |
+
+### Worker Output Modes
+
+Raw worker stdout/stderr is separate from the parent process formatter output.
+The progress dot parade is reconstructed from JSON formatter events and already
+streams from the parent process as workers report examples. Use
+`--worker-output MODE`, or `TURBO_TESTS2_WORKER_OUTPUT=MODE`, to choose how raw
+worker stdout/stderr is handled. A CLI flag takes precedence over the
+environment variable.
+
+| Mode | Behavior |
+|------|----------|
+| `warnings` | Default. Buffer raw worker output, print warning/deprecation lines after successful runs, and print full buffered raw output on failures. |
+| `stream` | Stream raw worker stdout/stderr immediately without enabling verbose command logging. Buffered output is not replayed at the end. |
+| `buffered` | Buffer raw worker output and print all buffered output after the run completes. |
+| `quiet` | Suppress raw worker output on successful runs. Failed runs still print buffered raw output. |
+
+Known coverage formatter chatter remains collapsed into the concise coverage
+summary.
+
 `turbo_tests2` supports custom formatter such as Fuubar, but you might need to require it:
 
 ```bash
@@ -666,7 +767,7 @@ Thanks for RTFM. ☺️
 [📌gitmoji]: https://gitmoji.dev
 [📌gitmoji-img]: https://img.shields.io/badge/gitmoji_commits-%20%F0%9F%98%9C%20%F0%9F%98%8D-34495e.svg?style=flat-square
 [🧮kloc]: https://www.youtube.com/watch?v=dQw4w9WgXcQ
-[🧮kloc-img]: https://img.shields.io/badge/KLOC-0.779-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
+[🧮kloc-img]: https://img.shields.io/badge/KLOC-0.897-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
 [🔐security]: https://github.com/galtzo-floss/turbo_tests2/blob/main/SECURITY.md
 [🔐security-img]: https://img.shields.io/badge/security-policy-259D6C.svg?style=flat
 [📄copyright-notice-explainer]: https://opensource.stackexchange.com/questions/5778/why-do-licenses-such-as-the-mit-license-specify-a-single-year

data/lib/turbo_tests/cli.rb

@@ -25,6 +25,9 @@ module TurboTests
       print_failed_group = false
       create = false
       nice = false
+      worker_output = nil
+      parallel_options = {}
+      cli_args, parallel_args = split_parallel_args(@argv)
 
       OptionParser.new do |opts|
         opts.banner = <<~BANNER
@@ -42,7 +45,16 @@ module TurboTests
           Options:
         BANNER
 
-        opts.on("-n [PROCESSES]", "-w [PROCESSES]", "--workers [PROCESSES]", Integer, "How many processes to use, default: available CPUs") do |n|
+        opts.on(
+          "-n [PROCESSES]",
+          "--count [PROCESSES]",
+          Integer,
+          "How many processes to use, default: available CPUs"
+        ) do |n|
+          count = n
+        end
+
+        opts.on("-w [PROCESSES]", "--workers [PROCESSES]", Integer, "Alias for -n, --count") do |n|
           count = n
         end
 
@@ -83,10 +95,41 @@ module TurboTests
           example_status_log = filename
         end
 
+        opts.on("--pattern PATTERN", "Run spec files matching this regex pattern") do |pattern|
+          parallel_options[:pattern] = compile_pattern(pattern)
+        end
+
+        opts.on("--exclude-pattern PATTERN", "Exclude spec files matching this regex pattern") do |pattern|
+          parallel_options[:exclude_pattern] = compile_pattern(pattern)
+        end
+
+        opts.on("--only-group GROUP_INDEX[,GROUP_INDEX]", "Run only the selected 1-based parallel_tests group index(es)") do |groups|
+          parallel_options[:only_group] = parse_only_groups(groups)
+        end
+
+        opts.on("--group-by MODE", "Group files by runtime, filesize, or found order") do |mode|
+          parallel_options[:group_by] = parse_group_by(mode)
+        end
+
+        opts.on("--allowed-missing PERCENT", Integer, "Allowed percentage of missing runtimes for runtime grouping") do |percent|
+          parallel_options[:allowed_missing_percent] = parse_allowed_missing(percent)
+        end
+
+        opts.on("--unknown-runtime SECONDS", Float, "Runtime in seconds to assign files missing runtime history") do |seconds|
+          parallel_options[:unknown_runtime] = parse_unknown_runtime(seconds)
+        end
+
         opts.on("-v", "--verbose", "More output") do
           verbose = true
         end
 
+        opts.on(
+          "--worker-output MODE",
+          "Raw worker output mode: warnings, stream, buffered, or quiet; env: TURBO_TESTS2_WORKER_OUTPUT"
+        ) do |mode|
+          worker_output = mode
+        end
+
         opts.on("--fail-fast=[N]") do |n|
           n = begin
             Integer(n)
@@ -119,7 +162,9 @@ module TurboTests
         opts.on("--nice", "execute test commands with low priority") do
           nice = true
         end
-      end.parse!(@argv)
+      end.parse!(cli_args)
+
+      parse_parallel_args(parallel_args, parallel_options) unless parallel_args.empty?
 
       if create
         return TurboTests::Runner.create(count)
@@ -142,8 +187,7 @@ module TurboTests
 
       invoke_rake_hook("setup")
 
-      files = @argv.empty? ? nil : @argv
-      parallel_options = {}
+      files = cli_args.empty? ? nil : cli_args
 
       exitstatus = TurboTests::Runner.run(
         formatters: formatters,
@@ -158,6 +202,7 @@ module TurboTests
         order: order,
         nice: nice,
         print_failed_group: print_failed_group,
+        worker_output: worker_output,
         parallel_options: parallel_options
       )
 
@@ -177,12 +222,104 @@ module TurboTests
       @argv.first == "fan"
     end
 
+    def split_parallel_args(args)
+      separator_index = args.index("--")
+      return [args, []] unless separator_index
+
+      [
+        args[0...separator_index],
+        args[(separator_index + 1)..-1]
+      ]
+    end
+
+    def parse_parallel_args(args, parallel_options)
+      OptionParser.new do |opts|
+        opts.on("--pattern PATTERN", "Run spec files matching this regex pattern") do |pattern|
+          parallel_options[:pattern] = compile_pattern(pattern)
+        end
+
+        opts.on("--exclude-pattern PATTERN", "Exclude spec files matching this regex pattern") do |pattern|
+          parallel_options[:exclude_pattern] = compile_pattern(pattern)
+        end
+
+        opts.on("--only-group GROUP_INDEX[,GROUP_INDEX]", "Run only the selected 1-based parallel_tests group index(es)") do |groups|
+          parallel_options[:only_group] = parse_only_groups(groups)
+        end
+
+        opts.on("--group-by MODE", "Group files by runtime, filesize, or found order") do |mode|
+          parallel_options[:group_by] = parse_group_by(mode)
+        end
+
+        opts.on("--allowed-missing PERCENT", Integer, "Allowed percentage of missing runtimes for runtime grouping") do |percent|
+          parallel_options[:allowed_missing_percent] = parse_allowed_missing(percent)
+        end
+
+        opts.on("--unknown-runtime SECONDS", Float, "Runtime in seconds to assign files missing runtime history") do |seconds|
+          parallel_options[:unknown_runtime] = parse_unknown_runtime(seconds)
+        end
+      end.parse!(args)
+
+      return if args.empty?
+
+      raise OptionParser::InvalidArgument, "unsupported parallel_tests argument(s): #{args.join(" ")}"
+    end
+
+    def compile_pattern(pattern)
+      /#{pattern}/
+    rescue RegexpError => error
+      raise OptionParser::InvalidArgument, "invalid regex pattern #{pattern.inspect}: #{error.message}"
+    end
+
+    def parse_only_groups(groups)
+      groups.to_s.split(",").map do |group|
+        group = group.strip
+        raise OptionParser::InvalidArgument, "invalid group index #{group.inspect}" unless group.match?(/\A[1-9]\d*\z/)
+
+        group.to_i
+      end
+    end
+
+    def parse_group_by(mode)
+      value = mode.to_s.strip
+      supported_modes = %w[runtime filesize found]
+      unless supported_modes.include?(value)
+        raise OptionParser::InvalidArgument, "invalid group-by mode #{value.inspect}; expected one of: #{supported_modes.join(", ")}"
+      end
+
+      value.to_sym
+    end
+
+    def parse_allowed_missing(percent)
+      unless (0..100).cover?(percent)
+        raise OptionParser::InvalidArgument, "invalid allowed missing percent #{percent.inspect}; expected 0 through 100"
+      end
+
+      percent
+    end
+
+    def parse_unknown_runtime(seconds)
+      unless seconds.finite? && !seconds.negative?
+        raise OptionParser::InvalidArgument, "invalid unknown runtime #{seconds.inspect}; expected a finite non-negative number"
+      end
+
+      seconds
+    end
+
     def handle_fan_command
       args = @argv.drop(1)
       count = nil
       parser = OptionParser.new do |opts|
         opts.banner = "Usage: turbo_tests2 fan [options] COMMAND [ARGS]"
-        opts.on("-n [PROCESSES]", "-w [PROCESSES]", "--workers [PROCESSES]", Integer, "How many processes to use, default: available CPUs") do |n|
+        opts.on(
+          "-n [PROCESSES]",
+          "--count [PROCESSES]",
+          Integer,
+          "How many processes to use, default: available CPUs"
+        ) do |n|
+          count = n
+        end
+
+        opts.on("-w [PROCESSES]", "--workers [PROCESSES]", Integer, "Alias for -n, --count") do |n|
           count = n
         end
       end

data/lib/turbo_tests/runner.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require "fileutils"
 require "parallel_tests/rspec/runner"
 require "rspec/core"
 require "shellwords"
@@ -11,6 +12,9 @@ require_relative "../utils/hash_extension"
 module TurboTests
   class Runner
     using CoreExtensions
+    DEFAULT_RUNTIME_LOG = "tmp/turbo_rspec_runtime.log"
+    DEFAULT_WORKER_OUTPUT_MODE = :warnings
+    WORKER_OUTPUT_MODES = %i[warnings stream buffered quiet].freeze
 
     class << self
       def create(count)
@@ -33,7 +37,7 @@ module TurboTests
         parallel_options = opts[:parallel_options] || {}
 
         start_time = opts.fetch(:start_time) { RSpec::Core::Time.now }
-        runtime_log = opts.fetch(:runtime_log, nil)
+        runtime_log = opts.fetch(:runtime_log, nil) || DEFAULT_RUNTIME_LOG
         example_status_log = opts.fetch(:example_status_log, nil)
         verbose = opts.fetch(:verbose, false)
         fail_fast = opts.fetch(:fail_fast, nil)
@@ -44,17 +48,22 @@ module TurboTests
         seed = generate_seed if seed_used && seed.nil?
         print_failed_group = opts.fetch(:print_failed_group, false)
         nice = opts.fetch(:nice, false)
+        worker_output = normalize_worker_output_mode(
+          opts[:worker_output] || ENV["TURBO_TESTS2_WORKER_OUTPUT"]
+        )
 
         use_runtime_info = default_file_discovery
+        parallel_options[:runtime_log] ||= runtime_log
 
         if example_status_log
           runtime_log = runtime_log_from_example_status(example_status_log)
           parallel_options[:runtime_log] = runtime_log
         elsif use_runtime_info
-          parallel_options[:runtime_log] = runtime_log
+          parallel_options[:runtime_log] ||= runtime_log
         else
-          parallel_options[:group_by] = :filesize
+          parallel_options[:group_by] ||= :filesize
         end
+        parallel_options[:group_by] ||= :filesize if parallel_options[:only_group]
 
         warn("VERBOSE") if verbose
 
@@ -78,10 +87,22 @@ module TurboTests
           print_failed_group: print_failed_group,
           use_runtime_info: use_runtime_info,
           parallel_options: parallel_options,
-          nice: nice
+          nice: nice,
+          worker_output: worker_output
         ).run
       end
 
+      def normalize_worker_output_mode(mode)
+        value = mode.to_s.strip.downcase.tr("-", "_")
+        return DEFAULT_WORKER_OUTPUT_MODE if value.empty?
+
+        normalized = value.to_sym
+        return normalized if WORKER_OUTPUT_MODES.include?(normalized)
+
+        raise ArgumentError,
+          "Unsupported worker output mode #{mode.inspect}; expected one of: #{WORKER_OUTPUT_MODES.join(", ")}"
+      end
+
       def normalize_rspec_file_selection(files)
         selectors = {}
         files.each do |entry|
@@ -200,10 +221,10 @@ module TurboTests
 
       # Supports runtime_log as a top level option,
       #   but also nested inside parallel_options
-      @runtime_log = opts[:runtime_log] || "tmp/turbo_rspec_runtime.log"
+      @runtime_log = opts[:runtime_log] || DEFAULT_RUNTIME_LOG
       @parallel_options = opts.fetch(:parallel_options, {})
       @parallel_options[:runtime_log] ||= @runtime_log
-      @record_runtime = @parallel_options[:group_by] == :runtime
+      @record_runtime = true
 
       @messages = Thread::Queue.new
       @threads = []
@@ -214,10 +235,12 @@ module TurboTests
       @deferred_run_options_messages = Hash.new { |hash, message| hash[message] = [] }
       @error = false
       @print_failed_group = opts[:print_failed_group]
+      @worker_output_mode = self.class.normalize_worker_output_mode(opts.fetch(:worker_output, DEFAULT_WORKER_OUTPUT_MODE))
     end
 
     def run
-      tests_with_size = ParallelTests::RSpec::Runner.tests_with_size(@files, {})
+      parallel_tests_options = @parallel_options.reject { |key, _value| key == :only_group }
+      tests_with_size = ParallelTests::RSpec::Runner.tests_with_size(@files, parallel_tests_options)
       @num_processes = [
         ParallelTests.determine_number_of_processes(@count),
         tests_with_size.size
@@ -233,8 +256,9 @@ module TurboTests
         ParallelTests::RSpec::Runner.tests_in_groups(
           @files,
           @num_processes,
-          **@parallel_options
+          **parallel_tests_options
         )
+      tests_in_groups = selected_groups(tests_in_groups) if @parallel_options[:only_group]
       @tests_in_groups = tests_in_groups
 
       subprocess_opts = {
@@ -264,10 +288,11 @@ module TurboTests
           statuses = @wait_threads.map(&:value)
 
           if @reporter.failed_examples.empty? && statuses.all?(&:success?)
+            flush_successful_worker_output
             report_coverage = true
             exit_status = 0
           else
-            flush_worker_output
+            flush_worker_output unless stream_worker_output?
             # From https://github.com/galtzo-floss/turbo_tests2/pull/20/
             exit_status = statuses.map(&:exitstatus).max
           end
@@ -280,6 +305,18 @@ module TurboTests
 
     private
 
+    def selected_groups(tests_in_groups)
+      requested_groups = @parallel_options[:only_group]
+      missing_groups = requested_groups.select { |index| index > tests_in_groups.size }
+      unless missing_groups.empty?
+        raise ArgumentError,
+          "Selected group index(es) out of range: #{missing_groups.join(", ")} " \
+          "(available groups: #{tests_in_groups.size})"
+      end
+
+      requested_groups.map { |index| tests_in_groups[index - 1] }
+    end
+
     def handle_interrupt
       if @interrupt_handled
         Kernel.exit
@@ -337,6 +374,7 @@ module TurboTests
 
         record_runtime_options =
           if record_runtime
+            FileUtils.mkdir_p(File.dirname(@runtime_log))
             [
               "--format",
               "ParallelTests::RSpec::RuntimeLogger",
@@ -483,7 +521,25 @@ module TurboTests
       end
 
       io = (stream == :stderr) ? $stderr : $stdout
-      io.write(msg) if @verbose
+      io.write(msg) if stream_worker_output?
+    end
+
+    def stream_worker_output?
+      @verbose || @worker_output_mode == :stream
+    end
+
+    def flush_successful_worker_output
+      case @worker_output_mode
+      when :warnings
+        flush_worker_warnings unless stream_worker_output?
+      when :buffered
+        flush_worker_output unless stream_worker_output?
+      when :quiet, :stream
+        nil
+      else
+        raise ArgumentError,
+          "Unsupported worker output mode #{@worker_output_mode.inspect}; expected one of: #{WORKER_OUTPUT_MODES.join(", ")}"
+      end
     end
 
     def flush_worker_output
@@ -504,6 +560,43 @@ module TurboTests
       end
     end
 
+    def flush_worker_warnings
+      output_by_process = @worker_output_mutex.synchronize do
+        @worker_output.transform_values(&:dup)
+      end
+
+      output_by_process.each do |process_id, streams|
+        streams.each do |stream, output|
+          warnings = warning_lines(output)
+          next if warnings.empty?
+
+          io = (stream == :stderr) ? $stderr : $stdout
+          io.puts
+          io.puts("TurboTests worker #{process_id} #{stream} warnings:")
+          warnings.each { |line| io.puts(line) }
+        end
+      end
+    end
+
+    def warning_lines(output)
+      output.each_line.each_with_object([]) do |line, warnings|
+        stripped = line.strip
+        next if stripped.empty?
+        next unless warning_line?(stripped)
+        next if coverage_output_line?(stripped)
+
+        warnings << stripped
+      end
+    end
+
+    def warning_line?(line)
+      line.match?(/warning:/i) || line.match?(/deprecat/i)
+    end
+
+    def coverage_output_line?(line)
+      line.start_with?("Coverage report generated for ", "JSON Coverage report generated for ", "Line coverage:", "Branch coverage:", "Line Coverage:", "Branch Coverage:")
+    end
+
     def flush_coverage_summary
       line_coverage = nil
       branch_coverage = nil

data/lib/turbo_tests/version.rb

@@ -2,7 +2,7 @@
 
 module TurboTests
   module Version
-    VERSION = "3.1.14"
+    VERSION = "3.2.0"
   end
   VERSION = Version::VERSION # Traditional Constant Location
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: turbo_tests2
 version: !ruby/object:Gem::Version
-  version: 3.1.14
+  version: 3.2.0
 platform: ruby
 authors:
 - Illia
@@ -312,10 +312,10 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://turbo-tests2.galtzo.com
-  source_code_uri: https://github.com/galtzo-floss/turbo_tests2/tree/v3.1.14
-  changelog_uri: https://github.com/galtzo-floss/turbo_tests2/blob/v3.1.14/CHANGELOG.md
+  source_code_uri: https://github.com/galtzo-floss/turbo_tests2/tree/v3.2.0
+  changelog_uri: https://github.com/galtzo-floss/turbo_tests2/blob/v3.2.0/CHANGELOG.md
   bug_tracker_uri: https://github.com/galtzo-floss/turbo_tests2/issues
-  documentation_uri: https://www.rubydoc.info/gems/turbo_tests2/3.1.14
+  documentation_uri: https://www.rubydoc.info/gems/turbo_tests2/3.2.0
   funding_uri: https://github.com/sponsors/pboling
   wiki_uri: https://github.com/galtzo-floss/turbo_tests2/wiki
   news_uri: https://www.railsbling.com/tags/turbo_tests2