rspec-conductor 1.0.9 → 1.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 57c9a96bb487176dd0c40d962ef210ca3caf316fd5135d032cccded1a9726cae
-  data.tar.gz: 976c271c89bb8847a0e1cbcd2b80f544054fd8467e701225f1f146f14c081d2f
+  metadata.gz: 4a4f284fb6887972bbd325f6a5d6ce77b3c384d3cc7b8933c19bd04af2aa3ada
+  data.tar.gz: 733f1d8de0935949b77aa54374f37f97976a007c7dc53381b1dc8d8bb3e6922d
 SHA512:
-  metadata.gz: d4efec9193e711ff163176ef03edcd0a4566eb75f77b528d8a931d1e93c6718810c455d79c595c1c8c55fcddca00a60c40e65104439203605655ec5ae25e9026
-  data.tar.gz: 9ed9595a493bd54fe6d51d029a5bf693f166dad3d5a6144d0b2bd34f26824173056bae85b0a78ee04e12f4883640b007700e5d3a45e0e7946450c69c21b6c1d4
+  metadata.gz: e23c66e05afe4064b4a6062d6f7880429e641c5e2a3eac73f60a50ba5bd4c75ecb2b36a8484405200e9e8102f0cfd24b20fb99a0fbdf959be376e0087cf4006d
+  data.tar.gz: ebc3ad89f178da346ce4a5aee153e280b8b10b98f2c1d4e55894035237ee9f990e34206f272f35128d0e94da7c01847acd15225ab7a8db0516ceb674618f1887

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## [1.0.11] - 2026-08-03
+
+- Fix a bug in 2.x that would cause an exception because of the 3.x syntax usage (`_1`) in the formatter base
+- Remove a potential bottleneck when spec files run under 10ms on average
+- Fix performance issue with recalculating the file/location list over and over (which would coincidentally also take around 10ms for large directories)
+  - In other words, if you had a lot of super fast spec files, it will run them fast as well
+
+## [1.0.10] - 2026-03-08
+
+- Add --print-slowest cli param to display the slowest specs in the suite
+
 ## [1.0.9] - 2026-03-01
 
 - Handle workers stdout/stderr better. It is no longer necessary to use --verbose to see worker output. Verbose now only controls whether you see the debug output of the workers

data/lib/rspec/conductor/cli.rb

@@ -15,6 +15,7 @@ module RSpec
         display_retry_backtraces: false,
         prefork_require: 'config/application.rb',
         postfork_require: :spec_helper,
+        print_slowest_count: nil,
       }.freeze
 
       def self.run(argv)
@@ -97,6 +98,10 @@ module RSpec
             @conductor_options[:display_retry_backtraces] = true
           end
 
+          opts.on("--print-slowest COUNT", Integer, "Print slowest specs with their execution times") do |n|
+            @conductor_options[:print_slowest_count] = n
+          end
+
           opts.on("--verbose", "Enable debug output") do
             @conductor_options[:verbose] = true
           end
@@ -120,6 +125,7 @@ module RSpec
           rspec_args: @rspec_args,
           formatter: @conductor_options[:formatter],
           display_retry_backtraces: @conductor_options[:display_retry_backtraces],
+          print_slowest_count: @conductor_options[:print_slowest_count],
           verbose: @conductor_options[:verbose],
         ).run
       end

data/lib/rspec/conductor/formatters/base.rb

@@ -9,7 +9,7 @@ module RSpec
         def initialize(**_kwargs)
         end
 
-        def handle_worker_message(_worker_process, _message, _results)
+        def handle_worker_message(_worker_process, _message, _suite_run)
         end
 
         def print_startup_banner(worker_count:, seed:, spec_files_count:)
@@ -17,15 +17,15 @@ module RSpec
           puts "Running #{spec_files_count} spec files\n\n"
         end
 
-        def print_summary(results, seed:, success:)
+        def print_summary(suite_run, seed:, success:)
           puts "\n\n"
           puts "Randomized with seed #{seed}"
-          puts "#{colorize("#{results.examples_passed} passed", :green)}, #{colorize("#{results.examples_failed} failed", :red)}, #{colorize("#{results.examples_pending} pending", :yellow)}"
-          puts colorize("Worker crashes: #{results.worker_crashes}", :red) if results.worker_crashes.positive?
+          puts "#{colorize("#{suite_run.examples_passed} passed", :green)}, #{colorize("#{suite_run.examples_failed} failed", :red)}, #{colorize("#{suite_run.examples_pending} pending", :yellow)}"
+          puts colorize("Worker crashes: #{suite_run.worker_crashes}", :red) if suite_run.worker_crashes.positive?
 
-          if results.errors.any?
+          if suite_run.errors.any?
             puts "\nFailures:\n\n"
-            results.errors.each_with_index do |error, i|
+            suite_run.errors.each_with_index do |error, i|
               puts "  #{i + 1}) #{error[:description]}"
               puts colorize("     #{error[:message]}", :red) if error[:message]
               puts colorize("     #{error[:location]}", :cyan)
@@ -37,14 +37,22 @@ module RSpec
             end
           end
 
-          puts "Specs took: #{results.specs_runtime.round(2)}s"
-          puts "Total runtime: #{results.total_runtime.round(2)}s"
+          puts "Specs took: #{suite_run.specs_runtime.round(2)}s"
+          puts "Total runtime: #{suite_run.total_runtime.round(2)}s"
           puts "Suite: #{success ? colorize("PASSED", :green) : colorize("FAILED", :red)}"
 
-          if results.errors.any?
+          if suite_run.errors.any?
             puts ""
             puts "To rerun failed examples:"
-            puts "  rspec #{results.errors.map { |e| e[:location] }.join(" ")}"
+            puts "  rspec #{suite_run.errors.map { |e| e[:location] }.join(" ")}"
+          end
+        end
+
+        def print_slowest(suite_run, n)
+          puts "\n\n"
+          puts "Slowest #{n} specs:"
+          suite_run.example_stats.sort_by { |e| -e[:run_time] }.take(n).each_with_index do |e, i|
+            puts "%3d. (%8.2fms) %s @ %s" % [i + 1, e[:run_time] * 1000, colorize(e[:description], :dim), colorize(e[:location], :cyan)]
           end
         end
 
@@ -66,7 +74,7 @@ module RSpec
               #{message[:location]}
               #{message[:exception_class]}: #{message[:message]}
               Backtrace:
-            #{message[:backtrace].map { "    #{_1}" }.join("\n")}
+            #{message[:backtrace].map { |line| "    #{line}" }.join("\n")}
           EOM
         end
 

data/lib/rspec/conductor/formatters/ci.rb

@@ -14,22 +14,22 @@ module RSpec
           super(**kwargs)
         end
 
-        def handle_worker_message(_worker_process, message, results)
+        def handle_worker_message(_worker_process, message, suite_run)
           public_send(message[:type], message) if respond_to?(message[:type])
-          print_status(results) if @last_printout + @printout_interval < Time.now
+          print_status(suite_run) if @last_printout + @printout_interval < Time.now
         end
 
-        def print_status(results)
+        def print_status(suite_run)
           @last_printout = Time.now
-          pct = results.spec_file_processed_percentage
+          pct = suite_run.spec_file_processed_percentage
 
           puts "-" * tty_width
           puts "Current status [#{Time.now.strftime("%H:%M:%S")}]:"
-          puts "Processed: #{results.spec_files_processed} / #{results.spec_files_total} (#{(pct * 100).floor}%)"
-          puts "#{results.examples_passed} passed, #{results.examples_failed} failed, #{results.examples_pending} pending"
-          if results.errors.any?
+          puts "Processed: #{suite_run.spec_files_processed} / #{suite_run.spec_files_total} (#{(pct * 100).floor}%)"
+          puts "#{suite_run.examples_passed} passed, #{suite_run.examples_failed} failed, #{suite_run.examples_pending} pending"
+          if suite_run.errors.any?
             puts "Failures:\n"
-            results.errors.each_with_index do |error, i|
+            suite_run.errors.each_with_index do |error, i|
               puts "  #{i + 1}) #{error[:description]}"
               puts "     #{error[:location]}"
               puts "     #{error[:message]}" if error[:message]

data/lib/rspec/conductor/formatters/fancy.rb

@@ -30,9 +30,9 @@ module RSpec
           super(**kwargs)
         end
 
-        def handle_worker_message(worker_process, message, results)
+        def handle_worker_message(worker_process, message, suite_run)
           public_send(message[:type], worker_process, message) if respond_to?(message[:type])
-          redraw(worker_process, results)
+          redraw(worker_process, suite_run)
         end
 
         def example_passed(_worker_process, _message)
@@ -66,9 +66,9 @@ module RSpec
 
         private
 
-        def redraw(worker_process, results)
+        def redraw(worker_process, suite_run)
           update_worker_status_line(worker_process)
-          update_results_line(results)
+          update_suite_run_line(suite_run)
           update_errors_line
           @terminal.redraw
           @terminal.scroll_to_bottom
@@ -94,13 +94,13 @@ module RSpec
           @worker_lines[worker_process.number].update(status, redraw: false)
         end
 
-        def update_results_line(results)
-          pct = results.spec_file_processed_percentage
+        def update_suite_run_line(suite_run)
+          pct = suite_run.spec_file_processed_percentage
           bar_width = [tty_width - 20, 20].max
           filled = (pct * bar_width).floor
           empty = bar_width - filled
 
-          percentage = " %3d%% (%d/%d)" % [(pct * 100).floor, results.spec_files_processed, results.spec_files_total]
+          percentage = " %3d%% (%d/%d)" % [(pct * 100).floor, suite_run.spec_files_processed, suite_run.spec_files_total]
           bar = colorize("[", :reset) + colorize("▓", :green) * filled + colorize(" ", :reset) * empty + colorize("]", :reset)
 
           @progress_bar_line.update(bar + percentage, redraw: false)

data/lib/rspec/conductor/formatters/plain.rb

@@ -4,7 +4,7 @@ module RSpec
   module Conductor
     module Formatters
       class Plain < Base
-        def handle_worker_message(_worker_process, message, _results)
+        def handle_worker_message(_worker_process, message, _suite_run)
           public_send(message[:type], message) if respond_to?(message[:type])
         end
 

data/lib/rspec/conductor/server.rb

@@ -1,14 +1,9 @@
 # frozen_string_literal: true
 
-require "English"
-require "socket"
-require "json"
-
 module RSpec
   module Conductor
     class Server
       MAX_SEED = 2**16
-      WORKER_POLL_INTERVAL = 0.01
 
       # @option worker_count [Integer] How many workers to spin
       # @option rspec_args [Array<String>] A list of rspec options
@@ -21,6 +16,7 @@ module RSpec
       # @option formatter [String] Use a certain formatter
       # @option verbose [Boolean] Use especially verbose output
       # @option display_retry_backtraces [Boolean] Display backtraces for specs retried via rspec-retry
+      # @option print_slowest_count [Integer] Print slowest specs in the end of the suite
       def initialize(worker_count:, rspec_args:, **opts)
         @worker_count = worker_count
         @worker_number_offset = opts.fetch(:worker_number_offset, 0)
@@ -30,11 +26,11 @@ module RSpec
         @seed = opts[:seed] || (Random.new_seed % MAX_SEED)
         @fail_fast_after = opts[:fail_fast_after]
         @display_retry_backtraces = opts.fetch(:display_retry_backtraces, false)
+        @print_slowest_count = opts.fetch(:print_slowest_count, nil)
         @verbose = opts.fetch(:verbose, false)
 
         @rspec_args = rspec_args
         @worker_processes = []
-        @dead_worker_processes = []
         @spec_queue = []
         @formatter_class = case opts[:formatter]
                            when "ci"
@@ -47,7 +43,7 @@ module RSpec
                              (!@verbose && Formatters::Fancy.recommended?) ? Formatters::Fancy : Formatters::Plain
                            end
         @formatter = @formatter_class.new(worker_count: @worker_count)
-        @results = Results.new
+        @suite_run = SuiteRun.new
 
         $stdout.sync = true
         $stdin.echo = false if $stdin.tty?
@@ -65,9 +61,10 @@ module RSpec
         start_workers
         run_event_loop
         wait_for_workers_to_exit
-        @results.suite_complete
+        @suite_run.suite_complete
 
-        @formatter.print_summary(@results, seed: @seed, success: success?)
+        @formatter.print_summary(@suite_run, seed: @seed, success: success?)
+        @formatter.print_slowest(@suite_run, @print_slowest_count) if @print_slowest_count
         exit_with_status
       end
 
@@ -95,7 +92,7 @@ module RSpec
         debug "RSpec config: #{config.inspect}"
         debug "Files to run: #{config.files_to_run}"
         @spec_queue = config.files_to_run.shuffle(random: Random.new(@seed))
-        @results.spec_files_total = @spec_queue.size
+        @suite_run.spec_files_total = @spec_queue.size
       end
 
       def preload_application
@@ -127,21 +124,18 @@ module RSpec
             @shutdown_status = :shutdown_messages_sent
             @formatter.print_shutdown_banner
             @worker_processes.select(&:running?).each do |worker_process|
-              worker_process.socket.send_message({ type: :shutdown })
+              worker_process.send_message({ type: :shutdown })
               cleanup_worker_process(worker_process)
             end
           end
 
-          worker_processes_by_io = @worker_processes.select(&:running?).to_h { |w| [w.socket.io, w] }
-          readable_ios, = IO.select(worker_processes_by_io.keys, nil, nil, 0)
-          readable_ios&.each { |io| handle_worker_message(worker_processes_by_io.fetch(io)) }
-          Util::ChildProcess.tick_all(@worker_processes.map(&:child_process))
+          WorkerProcess.tick_all(@worker_processes)
           reap_workers
         end
       end
 
       def wait_for_workers_to_exit
-        Util::ChildProcess.wait_all(@worker_processes.map(&:child_process))
+        WorkerProcess.wait_all(@worker_processes)
       end
 
       def spawn_worker(worker_number)
@@ -150,6 +144,7 @@ module RSpec
         worker_process = WorkerProcess.spawn(
           number: worker_number,
           test_env_number: (@first_is_1 || worker_number != 1) ? worker_number.to_s : "",
+          on_message: ->(worker_process, message) { handle_worker_message(worker_process, message) },
           on_stdout: ->(string) { @formatter.handle_worker_stdout(worker_number, string) },
           on_stderr: ->(string) { @formatter.handle_worker_stderr(worker_number, string) },
           debug_io: @verbose ? $stderr : nil,
@@ -160,37 +155,34 @@ module RSpec
         worker_process
       end
 
-      def handle_worker_message(worker_process)
-        message = worker_process.socket.receive_message
-        return unless message
-
+      def handle_worker_message(worker_process, message)
         debug "Worker #{worker_process.number}: #{message[:type]}"
 
         case message[:type].to_sym
         when :example_passed
-          @results.example_passed
+          @suite_run.example_passed(message)
         when :example_failed
-          @results.example_failed(message)
+          @suite_run.example_failed(message)
 
-          if @fail_fast_after && @results.examples_failed >= @fail_fast_after
-            debug "Shutting down after #{@results.examples_failed} failures"
+          if @fail_fast_after && @suite_run.examples_failed >= @fail_fast_after
+            debug "Shutting down after #{@suite_run.examples_failed} failures"
             initiate_shutdown
           end
         when :example_pending
-          @results.example_pending
+          @suite_run.example_pending
         when :example_retried
           @formatter.print_retry_message(message) if @display_retry_backtraces
         when :spec_complete
-          @results.spec_file_complete
+          @suite_run.spec_file_complete
           worker_process.current_spec = nil
           assign_work(worker_process)
         when :spec_error
-          @results.spec_file_error(message)
+          @suite_run.spec_file_error(message)
           debug "Spec error details: #{message[:error]}"
           worker_process.current_spec = nil
           assign_work(worker_process)
         end
-        @formatter.handle_worker_message(worker_process, message, @results)
+        @formatter.handle_worker_message(worker_process, message, @suite_run)
       end
 
       def assign_work(worker_process)
@@ -198,21 +190,21 @@ module RSpec
 
         if shutting_down? || !spec_file
           debug "No more work for worker #{worker_process.number}, sending shutdown"
-          worker_process.socket.send_message({ type: :shutdown })
+          worker_process.send_message({ type: :shutdown })
           cleanup_worker_process(worker_process)
         else
-          @results.spec_file_assigned
+          @suite_run.spec_file_assigned
           worker_process.current_spec = spec_file
           debug "Assigning #{spec_file} to worker #{worker_process.number}"
           message = { type: :worker_assigned_spec, file: spec_file }
-          worker_process.socket.send_message(message)
-          @formatter.handle_worker_message(worker_process, message, @results)
+          worker_process.send_message(message)
+          @formatter.handle_worker_message(worker_process, message, @suite_run)
         end
       end
 
       def cleanup_worker_process(worker_process, status: :shut_down)
         worker_process.shut_down(status)
-        @formatter.handle_worker_message(worker_process, { type: :worker_shut_down }, @results)
+        @formatter.handle_worker_message(worker_process, { type: :worker_shut_down }, @suite_run)
       end
 
       def reap_workers
@@ -224,7 +216,7 @@ module RSpec
 
         dead_worker_processes.each do |worker_process, exitstatus|
           cleanup_worker_process(worker_process, status: :terminated)
-          @results.worker_crashed
+          @suite_run.worker_crashed
           debug "Worker #{worker_process.number} exited with status #{exitstatus.exitstatus}, signal #{exitstatus.termsig}"
         end
       end
@@ -243,7 +235,7 @@ module RSpec
       end
 
       def success?
-        @results.success? && !shutting_down?
+        @suite_run.success? && !shutting_down?
       end
 
       def exit_with_status

data/lib/rspec/conductor/{results.rb → suite_run.rb}

@@ -2,8 +2,8 @@
 
 module RSpec
   module Conductor
-    class Results
-      attr_accessor :examples_passed, :examples_failed, :examples_pending, :worker_crashes, :errors, :started_at, :spec_files_total, :spec_files_processed
+    class SuiteRun
+      attr_accessor :examples_passed, :examples_failed, :examples_pending, :worker_crashes, :errors, :started_at, :spec_files_total, :spec_files_processed, :example_stats
 
       def initialize
         @examples_passed = 0
@@ -16,17 +16,20 @@ module RSpec
         @specs_completed_at = nil
         @spec_files_total = 0
         @spec_files_processed = 0
+        @example_stats = []
       end
 
       def success?
         @examples_failed.zero? && @errors.empty? && @worker_crashes.zero? && @spec_files_total == @spec_files_processed
       end
 
-      def example_passed
+      def example_passed(message)
+        @example_stats << message.slice(:location, :run_time, :description)
         @examples_passed += 1
       end
 
       def example_failed(message)
+        @example_stats << message.slice(:location, :run_time, :description)
         @examples_failed += 1
         @errors << message
       end

data/lib/rspec/conductor/util/child_process.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
+require "socket"
+
 module RSpec
   module Conductor
     module Util
       class ChildProcess
         POLL_INTERVAL = 0.01
 
-        attr_reader :pid, :exit_status
+        attr_reader :pid, :message_socket, :exit_status, :ios
 
         def self.fork(**args, &block)
           new(**args).fork(&block)
@@ -22,44 +24,47 @@ module RSpec
 
         def self.tick_all(processes, poll_interval: POLL_INTERVAL)
           processes_by_io = processes.each_with_object({}) do |process, memo|
-            process.pipes.reject(&:closed?).each { |pipe| memo[pipe] = process }
+            process.ios.reject(&:closed?).each { |io| memo[io] = process }
           end
           return false if processes_by_io.empty?
 
           ready, = IO.select(processes_by_io.keys, nil, nil, poll_interval)
-          ready&.each { |pipe| processes_by_io[pipe].read_available(pipe) }
+          ready&.each { |io| processes_by_io[io].handle_available(io) }
 
           true
         end
 
-        def initialize(on_stdout: nil, on_stderr: nil)
+        def initialize(on_stdout: nil, on_stderr: nil, on_message: nil)
           @on_stdout = on_stdout
           @on_stderr = on_stderr
+          @on_message = on_message
           @pid = nil
           @exit_status = nil
           @stdout_pipe = nil
           @stderr_pipe = nil
           @stdout_buffer = +""
           @stderr_buffer = +""
+          @message_socket = nil
+          @ios = []
           @done = false
         end
 
-        def pipes
-          [@stdout_pipe, @stderr_pipe].compact
-        end
-
         def fork(&block)
           raise ArgumentError, '.fork should be called with a block' unless block_given?
 
           stdout_read, stdout_write = IO.pipe
           stderr_read, stderr_write = IO.pipe
+          parent_socket, child_socket = Socket.pair(:UNIX, :STREAM, 0) if @on_message
 
           @stdout_pipe = stdout_read
           @stderr_pipe = stderr_read
+          @message_socket = parent_socket
+          @ios = [@stdout_pipe, @stderr_pipe, @message_socket].compact
 
           @pid = Kernel.fork do
             stdout_read.close
             stderr_read.close
+            parent_socket&.close
 
             $stdout = stdout_write
             $stderr = stderr_write
@@ -69,13 +74,14 @@ module RSpec
             STDIN.reopen($stdin)
 
             begin
-              yield self
+              yield self, child_socket
             rescue => e
               stderr_write.puts "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
               exit 1
             ensure
               stdout_write.close
               stderr_write.close
+              child_socket&.close
             end
 
             exit 0
@@ -83,6 +89,7 @@ module RSpec
 
           stdout_write.close
           stderr_write.close
+          child_socket&.close
 
           self
         end
@@ -91,17 +98,27 @@ module RSpec
           @done
         end
 
-        def read_available(pipe)
+        def handle_available(io)
           return if done?
-          return if pipe.closed?
-
-          buffer, callback = if pipe == @stdout_pipe
-            [@stdout_buffer, @on_stdout]
-          elsif pipe == @stderr_pipe
-            [@stderr_buffer, @on_stderr]
-          else
-            return
+          return if io.closed?
+
+          case io
+          when @stdout_pipe, @stderr_pipe
+            read_pipe(io)
+          when @message_socket
+            @on_message&.call
           end
+        end
+
+        def read_pipe(pipe)
+          buffer, callback = case pipe
+                             when @stdout_pipe
+                               [@stdout_buffer, @on_stdout]
+                             when @stderr_pipe
+                               [@stderr_buffer, @on_stderr]
+                             else
+                               return
+                             end
 
           begin
             data = pipe.read_nonblock(4096, exception: false)
@@ -132,6 +149,8 @@ module RSpec
           rescue Errno::ECHILD
           end
 
+          @message_socket&.close
+
           self
         end
 

data/lib/rspec/conductor/version.rb

@@ -2,6 +2,6 @@
 
 module RSpec
   module Conductor
-    VERSION = "1.0.9"
+    VERSION = "1.0.11"
   end
 end

data/lib/rspec/conductor/worker.rb

@@ -48,8 +48,6 @@ module RSpec
         debug "Worker crashed: #{e.class}: #{e.message}"
         debug e.backtrace.join("\n")
         raise
-      ensure
-        @socket.close
       end
 
       private
@@ -109,12 +107,12 @@ module RSpec
       def run_spec(file)
         RSpec.world.reset
         RSpec.configuration.reset
-        RSpec.configuration.files_or_directories_to_run = [file]
         RSpec.configuration.output_stream = null_io_out
         RSpec.configuration.error_stream = null_io_out
         RSpec.configuration.formatter_loader.formatters.clear
         RSpec.configuration.add_formatter(RSpecSubscriber.new(@socket, file, -> { check_for_shutdown }))
         parsed_options.configure(RSpec.configuration)
+        RSpec.configuration.files_or_directories_to_run = location_entries_for(file)
         RSpec.configuration.files_to_run # this seemingly random line is necessary for rspec to set up the inclusion filters (e.g. hello_spec.rb:123 -> the :123 part is an inclusion filter)
 
         begin
@@ -133,7 +131,7 @@ module RSpec
 
           @socket.send_message(
             type: :spec_complete,
-            file: file
+            file: file,
           )
         rescue StandardError => e
           debug "Spec error: #{e.class}: #{e.message}"
@@ -167,6 +165,21 @@ module RSpec
         @parsed_options ||= RSpec::Core::ConfigurationOptions.new(@rspec_args).tap { |co| co.options.delete(:requires) }
       end
 
+      # Returns all the location entries for a filename
+      # RSpec syntax for locations:
+      # * ./a_spec.rb - run whole file
+      # * ./a_spec.rb:18 - run specific spec
+      # * ./a_spec.rb[1:2:1] - run specific spec group
+      # You can specify locations more than once for a single file, so you need to find all relevant entries in the runner
+      def location_entries_for(filename)
+        filename = File.expand_path(filename)
+        entries = Array(parsed_options.options[:files_or_directories_to_run]).select do |entry|
+          entry_filename = File.expand_path(entry.sub(/(\[\d+(:\d+)*\])+\z/, "").sub(/(:\d+)+\z/, ""))
+          entry_filename == filename
+        end
+        entries.empty? ? filename : entries
+      end
+
       def debug(message)
         @debug_io.puts message if @debug_io
       end

data/lib/rspec/conductor/worker_process.rb

@@ -2,35 +2,70 @@
 
 module RSpec
   module Conductor
-    WorkerProcess = Struct.new(:pid, :child_process, :number, :status, :socket, :current_spec, keyword_init: true) do
-      def self.spawn(number:, test_env_number:, on_stdout: nil, on_stderr: nil, **worker_init_args)
-        parent_socket, child_socket = Socket.pair(:UNIX, :STREAM, 0)
-        child_process = Util::ChildProcess.fork(on_stdout: on_stdout, on_stderr: on_stderr) do
+    class WorkerProcess
+      def self.spawn(number:, test_env_number:, on_message:, on_stdout: nil, on_stderr: nil, **worker_init_args)
+        worker_process = new(number: number, on_message: on_message)
+
+        child_process = Util::ChildProcess.fork(on_stdout: on_stdout, on_stderr: on_stderr, on_message: proc { worker_process.handle_message }) do |_, child_socket|
           ENV["TEST_ENV_NUMBER"] = test_env_number
-          parent_socket.close
           Worker.new(
             worker_number: number,
             socket: Protocol::Socket.new(child_socket),
             **worker_init_args
           ).run
         end
-        child_socket.close
 
-        new(
-          pid: child_process.pid,
-          child_process: child_process,
-          number: number,
-          status: :running,
-          socket: Protocol::Socket.new(parent_socket),
-          current_spec: nil
-        )
+        worker_process.child_process = child_process
+        worker_process
+      end
+
+      def self.tick_all(worker_processes)
+        Util::ChildProcess.tick_all(worker_processes.map(&:child_process))
+      end
+
+      def self.wait_all(worker_processes)
+        Util::ChildProcess.wait_all(worker_processes.map(&:child_process))
+      end
+
+      attr_reader :number
+      attr_accessor :current_spec, :child_process, :status
+
+      def initialize(number:, on_message: nil)
+        @number = number
+        @on_message = on_message
+        @status = :running
+      end
+
+      def handle_message
+        message = receive_message
+        unless message
+          socket.close
+          return
+        end
+
+        @on_message&.call(self, message)
+      end
+
+      def send_message(message)
+        socket.send_message(message)
+      end
+
+      def receive_message
+        socket.receive_message
+      end
+
+      def socket
+        @socket ||= Protocol::Socket.new(child_process.message_socket)
+      end
+
+      def pid
+        child_process.pid
       end
 
       def shut_down(status)
         return unless running?
 
-        self.status = status
-        socket.close
+        @status = status
       end
 
       def running?

data/lib/rspec/conductor.rb

@@ -35,7 +35,7 @@ require_relative "conductor/version"
 require_relative "conductor/protocol"
 require_relative "conductor/server"
 require_relative "conductor/worker"
-require_relative "conductor/results"
+require_relative "conductor/suite_run"
 require_relative "conductor/worker_process"
 require_relative "conductor/cli"
 require_relative "conductor/rspec_subscriber"

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-conductor
 version: !ruby/object:Gem::Version
-  version: 1.0.9
+  version: 1.0.11
 platform: ruby
 authors:
 - Mark Abramov
+autorequire:
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec-core
@@ -48,9 +49,9 @@ files:
 - lib/rspec/conductor/formatters/plain.rb
 - lib/rspec/conductor/protocol.rb
 - lib/rspec/conductor/railtie.rb
-- lib/rspec/conductor/results.rb
 - lib/rspec/conductor/rspec_subscriber.rb
 - lib/rspec/conductor/server.rb
+- lib/rspec/conductor/suite_run.rb
 - lib/rspec/conductor/util/ansi.rb
 - lib/rspec/conductor/util/child_process.rb
 - lib/rspec/conductor/util/screen_buffer.rb
@@ -68,6 +69,7 @@ metadata:
   homepage_uri: https://github.com/markiz/rspec-conductor
   source_code_uri: https://github.com/markiz/rspec-conductor
   changelog_uri: https://github.com/markiz/rspec-conductor/blob/master/CHANGELOG.md
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -82,7 +84,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 3.3.26
+signing_key:
 specification_version: 4
 summary: Queue-based parallel test runner for rspec
 test_files: []