rspec-conductor 1.0.8 → 1.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91793bc12c3384342322b331ddbc5738dd448b92b18517f3de1a5f27b45b464d
-  data.tar.gz: 5daf14136401f25142f9d0393f8f427fd785245baff4eb6a026823549afa0e34
+  metadata.gz: 57c9a96bb487176dd0c40d962ef210ca3caf316fd5135d032cccded1a9726cae
+  data.tar.gz: 976c271c89bb8847a0e1cbcd2b80f544054fd8467e701225f1f146f14c081d2f
 SHA512:
-  metadata.gz: 48cc6ad36c65d3686da3a03bd87261c66a00d3d77c1e7156a4504eb6c2e2e1b16b2c6df999163e02aa8f603674fdbe8c081765a0ad3983e426e9f9e40f03be9a
-  data.tar.gz: f93a55a25e1a890d13b29216f2c454ccd8c8d2cb01dda643ff24ba514dbdcfc85331cfed134f3bd9ba9fc87491b79dbf70fab43e5037383425a522dc00af3d7e
+  metadata.gz: d4efec9193e711ff163176ef03edcd0a4566eb75f77b528d8a931d1e93c6718810c455d79c595c1c8c55fcddca00a60c40e65104439203605655ec5ae25e9026
+  data.tar.gz: 9ed9595a493bd54fe6d51d029a5bf693f166dad3d5a6144d0b2bd34f26824173056bae85b0a78ee04e12f4883640b007700e5d3a45e0e7946450c69c21b6c1d4

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [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
+- For the fancy formatter, allocate one line per stdout/stderr. Not ideal, but I'm not sure what layout I'm even looking for here, since allowing to freely put stuff into stdout/stderr breaks the TUI completely
+- Disable echo when running (also breaks the TUI). The side effect of this is that you probably lose ability to tactically use binding.irb in your specs, but you might want to drop into the regular rspec to do that anyway
+- Way better handling of SIGINT / Ctrl-C. Child processes used to just crash when terminated via signal, now they're safely terminating
+- Support double Ctrl-C to force-kill the workers (same as rspec)
+- When there are spec failures, include a rerun command for failed examples (e.g. `rspec spec/some_spec.rb:28 spec/other_spec.rb:42`). It should also be possible to use rspec-conductor for those, but in my personal practice, I prefer rspec because I also want to have some interactive console during the spec run, which is not going to be possible with forked children
+
 ## [1.0.8] - 2026-02-18
 
 - When --postfork-require is provided, use current dir instead of spec/

data/lib/rspec/conductor/ext/rspec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # RSpec doesn't provide us with a good way to handle before/after suite hooks,
 # doing what we can here
 class RSpec::Core::Configuration

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

@@ -2,65 +2,81 @@
 
 module RSpec
   module Conductor
-    class Base
-      include Util::ANSI
+    module Formatters
+      class Base
+        include Util::ANSI
 
-      def initialize(**_kwargs)
-      end
+        def initialize(**_kwargs)
+        end
 
-      def handle_worker_message(_worker_process, _message, _results)
-      end
+        def handle_worker_message(_worker_process, _message, _results)
+        end
 
-      def print_startup_banner(worker_count:, seed:, spec_files_count:)
-        puts "RSpec Conductor starting with #{worker_count} workers (seed: #{seed})"
-        puts "Running #{spec_files_count} spec files\n\n"
-      end
+        def print_startup_banner(worker_count:, seed:, spec_files_count:)
+          puts "RSpec Conductor starting with #{worker_count} workers (seed: #{seed})"
+          puts "Running #{spec_files_count} spec files\n\n"
+        end
 
-      def print_summary(results, seed:)
-        puts "\n\n"
-        puts "Randomized with seed #{seed}"
-        puts "#{colorize("#{results.passed} passed", :green)}, #{colorize("#{results.failed} failed", :red)}, #{colorize("#{results.pending} pending", :yellow)}"
-        puts colorize("Worker crashes: #{results.worker_crashes}", :red) if results.worker_crashes.positive?
+        def print_summary(results, 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?
 
-        if results.errors.any?
-          puts "\nFailures:\n\n"
-          results.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)
-            if error[:backtrace]&.any?
-              puts "     Backtrace:"
-              error[:backtrace].each { |line| puts "       #{line}" }
+          if results.errors.any?
+            puts "\nFailures:\n\n"
+            results.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)
+              if error[:backtrace]&.any?
+                puts "     Backtrace:"
+                error[:backtrace].each { |line| puts "       #{line}" }
+              end
+              puts
             end
-            puts
+          end
+
+          puts "Specs took: #{results.specs_runtime.round(2)}s"
+          puts "Total runtime: #{results.total_runtime.round(2)}s"
+          puts "Suite: #{success ? colorize("PASSED", :green) : colorize("FAILED", :red)}"
+
+          if results.errors.any?
+            puts ""
+            puts "To rerun failed examples:"
+            puts "  rspec #{results.errors.map { |e| e[:location] }.join(" ")}"
           end
         end
 
-        puts "Specs took: #{results.specs_runtime.round(2)}s"
-        puts "Total runtime: #{results.total_runtime.round(2)}s"
-        puts "Suite: #{results.success? ? colorize("PASSED", :green) : colorize("FAILED", :red)}"
-      end
+        def handle_worker_stdout(worker_number, string)
+          puts "[worker #{worker_number}] #{string}"
+        end
 
-      def print_debug(string)
-        $stderr.puts string
-      end
+        def handle_worker_stderr(worker_number, string)
+          $stderr.puts "[worker #{worker_number}] #{string}"
+        end
 
-      def print_retry_message(message)
-        puts <<~EOM
-          \nRetried: #{message[:description]}
-            #{message[:location]}
-            #{message[:exception_class]}: #{message[:message]}
-            Backtrace:
-          #{message[:backtrace].map { "    #{_1}" }.join("\n")}
-        EOM
-      end
+        def print_debug(string)
+          $stderr.puts string
+        end
 
-      def print_shut_down_banner
-        puts "Shutting down..."
-      end
+        def print_retry_message(message)
+          puts <<~EOM
+            \nRetried: #{message[:description]}
+              #{message[:location]}
+              #{message[:exception_class]}: #{message[:message]}
+              Backtrace:
+            #{message[:backtrace].map { "    #{_1}" }.join("\n")}
+          EOM
+        end
 
-      def colorize(string, colors, **kwargs)
-        $stdout.tty? ? super(string, colors, **kwargs) : string
+        def print_shutdown_banner
+          puts "Shutting down... (press ctrl-c again to force quit)"
+        end
+
+        def colorize(string, colors, **kwargs)
+          $stdout.tty? ? super(string, colors, **kwargs) : string
+        end
       end
     end
   end

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

@@ -26,7 +26,7 @@ module RSpec
           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.passed} passed, #{results.failed} failed, #{results.pending} pending"
+          puts "#{results.examples_passed} passed, #{results.examples_failed} failed, #{results.examples_pending} pending"
           if results.errors.any?
             puts "Failures:\n"
             results.errors.each_with_index do |error, i|

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

@@ -11,9 +11,7 @@ module RSpec
         end
 
         def initialize(worker_count:, **kwargs)
-          @worker_processes = {}
           @terminal = Util::Terminal.new
-          @last_rendered_lines = []
           @dots_string = +""
           @last_error = nil
 
@@ -25,6 +23,9 @@ module RSpec
           @dots_line = @terminal.line(truncate: false)
           @terminal.puts
           @last_error_line = @terminal.line(truncate: false)
+          @stdout_line = @terminal.puts nil
+          @stderr_line = @terminal.puts nil
+          @shutdown_line = @terminal.puts nil
 
           super(**kwargs)
         end
@@ -51,6 +52,18 @@ module RSpec
           dot "*", :yellow
         end
 
+        def handle_worker_stdout(worker_number, string)
+          @stdout_line.update("STDOUT: [worker #{worker_number}]: #{string}")
+        end
+
+        def handle_worker_stderr(worker_number, string)
+          @stderr_line.update("STDERR: [worker #{worker_number}]: #{string}")
+        end
+
+        def print_shutdown_banner
+          @shutdown_line.update("Shutting down... (press ctrl-c again to force quit)")
+        end
+
         private
 
         def redraw(worker_process, results)

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RSpec
   module Conductor
     module Formatters

data/lib/rspec/conductor/results.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 module RSpec
   module Conductor
     class Results
-      attr_accessor :passed, :failed, :pending, :worker_crashes, :errors, :started_at, :spec_files_total, :spec_files_processed
+      attr_accessor :examples_passed, :examples_failed, :examples_pending, :worker_crashes, :errors, :started_at, :spec_files_total, :spec_files_processed
 
       def initialize
-        @passed = 0
-        @failed = 0
-        @pending = 0
+        @examples_passed = 0
+        @examples_failed = 0
+        @examples_pending = 0
         @worker_crashes = 0
         @errors = []
         @started_at = Time.now
@@ -14,24 +16,23 @@ module RSpec
         @specs_completed_at = nil
         @spec_files_total = 0
         @spec_files_processed = 0
-        @shutting_down = false
       end
 
       def success?
-        @failed.zero? && @errors.empty? && @worker_crashes.zero? && !shutting_down?
+        @examples_failed.zero? && @errors.empty? && @worker_crashes.zero? && @spec_files_total == @spec_files_processed
       end
 
       def example_passed
-        @passed += 1
+        @examples_passed += 1
       end
 
       def example_failed(message)
-        @failed += 1
+        @examples_failed += 1
         @errors << message
       end
 
       def example_pending
-        @pending += 1
+        @examples_pending += 1
       end
 
       def spec_file_assigned
@@ -56,14 +57,6 @@ module RSpec
         @worker_crashes += 1
       end
 
-      def shut_down
-        @shutting_down = true
-      end
-
-      def shutting_down?
-        @shutting_down
-      end
-
       def suite_complete
         @specs_completed_at ||= Time.now
       end

data/lib/rspec/conductor/rspec_subscriber.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RSpec
   module Conductor
     # Technically this is a **Formatter**, as in RSpec Formatter, but that was too confusing,

data/lib/rspec/conductor/server.rb

@@ -33,7 +33,8 @@ module RSpec
         @verbose = opts.fetch(:verbose, false)
 
         @rspec_args = rspec_args
-        @worker_processes = {}
+        @worker_processes = []
+        @dead_worker_processes = []
         @spec_queue = []
         @formatter_class = case opts[:formatter]
                            when "ci"
@@ -48,8 +49,10 @@ module RSpec
         @formatter = @formatter_class.new(worker_count: @worker_count)
         @results = Results.new
 
+        $stdout.sync = true
+        $stdin.echo = false if $stdin.tty?
         Dir.chdir(Conductor.root)
-        ENV['PARALLEL_TEST_GROUPS'] = worker_count.to_s # parallel_tests backward-compatibility
+        ENV["PARALLEL_TEST_GROUPS"] = worker_count.to_s # parallel_tests backward-compatibility
       end
 
       def run
@@ -57,53 +60,27 @@ module RSpec
         build_spec_queue
         preload_application
 
-        $stdout.sync = true
         @formatter.print_startup_banner(worker_count: @worker_count, seed: @seed, spec_files_count: @spec_queue.size)
 
         start_workers
         run_event_loop
+        wait_for_workers_to_exit
         @results.suite_complete
 
-        @formatter.print_summary(@results, seed: @seed)
+        @formatter.print_summary(@results, seed: @seed, success: success?)
         exit_with_status
       end
 
       private
 
-      def preload_application
-        if !@prefork_require
-          debug "Prefork require not set, skipping..."
-          return
-        end
-
-        preload = File.expand_path(@prefork_require)
-
-        if File.exist?(preload)
-          debug "Preloading #{@prefork_require}..."
-          require preload
-        else
-          debug "#{@prefork_require} not found, skipping..."
-        end
-
-        debug "Application preloaded, autoload paths configured"
-      end
-
       def setup_signal_handlers
         %w[INT TERM].each do |signal|
           Signal.trap(signal) do
-            @worker_processes.any? ? initiate_shutdown : Kernel.exit(1)
+            @worker_processes.any?(&:running?) ? initiate_shutdown : Kernel.exit(1)
           end
         end
       end
 
-      def initiate_shutdown
-        return if @results.shutting_down?
-
-        @results.shut_down
-        @formatter.print_shut_down_banner
-        @worker_processes.each_value { |w| w.socket&.send_message({ type: :shutdown }) }
-      end
-
       def build_spec_queue
         config_options = RSpec::Core::ConfigurationOptions.new(@rspec_args)
         # a bit of a hack, but if they want to require something explicitly, they should use either --prefork-require or --postfork-require,
@@ -121,57 +98,68 @@ module RSpec
         @results.spec_files_total = @spec_queue.size
       end
 
-      def start_workers
-        @worker_count.times do |i|
-          spawn_worker(@worker_number_offset + i + 1)
+      def preload_application
+        if !@prefork_require
+          debug "Prefork require not set, skipping..."
+          return
         end
-      end
-
-      def spawn_worker(worker_number)
-        parent_socket, child_socket = Socket.pair(:UNIX, :STREAM, 0)
 
-        debug "Spawning worker #{worker_number}"
+        preload = File.expand_path(@prefork_require)
 
-        pid = fork do
-          parent_socket.close
-
-          ENV["TEST_ENV_NUMBER"] = if @first_is_1 || worker_number != 1
-                                     worker_number.to_s
-                                   else
-                                     ""
-                                   end
-
-          Worker.new(
-            worker_number: worker_number,
-            socket: Protocol::Socket.new(child_socket),
-            rspec_args: @rspec_args,
-            verbose: @verbose,
-            postfork_require: @postfork_require,
-          ).run
+        if File.exist?(preload)
+          debug "Preloading #{@prefork_require}..."
+          require preload
+        else
+          debug "#{@prefork_require} not found, skipping..."
         end
 
-        child_socket.close
-        debug "Worker #{worker_number} started with pid #{pid}"
+        debug "Application preloaded, autoload paths configured"
+      end
 
-        @worker_processes[pid] = WorkerProcess.new(
-          pid: pid,
-          number: worker_number,
-          status: :running,
-          socket: Protocol::Socket.new(parent_socket),
-          current_spec: nil,
-        )
-        assign_work(@worker_processes[pid])
+      def start_workers
+        @worker_processes = @worker_count.times.map { |i| spawn_worker(@worker_number_offset + i + 1) }
+        @worker_processes.each { |wp| assign_work(wp) }
       end
 
       def run_event_loop
-        until @worker_processes.empty?
-          worker_processes_by_io = @worker_processes.values.to_h { |w| [w.socket.io, w] }
-          readable_ios, = IO.select(worker_processes_by_io.keys, nil, nil, WORKER_POLL_INTERVAL)
+        until @worker_processes.select(&:running?).empty?
+          if @shutdown_status == :initiated_graceful
+            @shutdown_status = :shutdown_messages_sent
+            @formatter.print_shutdown_banner
+            @worker_processes.select(&:running?).each do |worker_process|
+              worker_process.socket.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))
           reap_workers
         end
       end
 
+      def wait_for_workers_to_exit
+        Util::ChildProcess.wait_all(@worker_processes.map(&:child_process))
+      end
+
+      def spawn_worker(worker_number)
+        debug "Spawning worker #{worker_number}"
+
+        worker_process = WorkerProcess.spawn(
+          number: worker_number,
+          test_env_number: (@first_is_1 || worker_number != 1) ? worker_number.to_s : "",
+          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,
+          rspec_args: @rspec_args,
+          postfork_require: @postfork_require,
+        )
+        debug "Worker #{worker_number} started with pid #{worker_process.pid}"
+        worker_process
+      end
+
       def handle_worker_message(worker_process)
         message = worker_process.socket.receive_message
         return unless message
@@ -184,8 +172,8 @@ module RSpec
         when :example_failed
           @results.example_failed(message)
 
-          if @fail_fast_after && @results.failed >= @fail_fast_after
-            debug "Shutting down after #{@results.failed} failures"
+          if @fail_fast_after && @results.examples_failed >= @fail_fast_after
+            debug "Shutting down after #{@results.examples_failed} failures"
             initiate_shutdown
           end
         when :example_pending
@@ -201,9 +189,6 @@ module RSpec
           debug "Spec error details: #{message[:error]}"
           worker_process.current_spec = nil
           assign_work(worker_process)
-        when :spec_interrupted
-          debug "Spec interrupted: #{message[:file]}"
-          worker_process.current_spec = nil
         end
         @formatter.handle_worker_message(worker_process, message, @results)
       end
@@ -211,7 +196,7 @@ module RSpec
       def assign_work(worker_process)
         spec_file = @spec_queue.shift
 
-        if @results.shutting_down? || !spec_file
+        if shutting_down? || !spec_file
           debug "No more work for worker #{worker_process.number}, sending shutdown"
           worker_process.socket.send_message({ type: :shutdown })
           cleanup_worker_process(worker_process)
@@ -226,19 +211,15 @@ module RSpec
       end
 
       def cleanup_worker_process(worker_process, status: :shut_down)
-        @worker_processes.delete(worker_process.pid)
-        worker_process.socket.close
-        worker_process.status = status
+        worker_process.shut_down(status)
         @formatter.handle_worker_message(worker_process, { type: :worker_shut_down }, @results)
-        Process.wait(worker_process.pid)
-      rescue Errno::ECHILD
-        nil
       end
 
       def reap_workers
-        dead_worker_processes = @worker_processes.each_with_object([]) do |(pid, worker), memo|
-          result = Process.waitpid(pid, Process::WNOHANG)
-          memo << [worker, $CHILD_STATUS] if result
+        dead_worker_processes = @worker_processes.select(&:running?).each_with_object([]) do |worker_process, memo|
+          result, status = Process.waitpid2(worker_process.pid, Process::WNOHANG)
+          memo << [worker_process, status] if result
+        rescue Errno::ECHILD
         end
 
         dead_worker_processes.each do |worker_process, exitstatus|
@@ -246,12 +227,27 @@ module RSpec
           @results.worker_crashed
           debug "Worker #{worker_process.number} exited with status #{exitstatus.exitstatus}, signal #{exitstatus.termsig}"
         end
-      rescue Errno::ECHILD
-        nil
+      end
+
+      def shutting_down?
+        !@shutdown_status.nil?
+      end
+
+      def initiate_shutdown
+        if @shutdown_status.nil?
+          @shutdown_status = :initiated_graceful
+        elsif @shutdown_status != :initiated_forced && @worker_processes.any?(&:running?)
+          @shutdown_status = :initiated_forced
+          Process.kill(:TERM, *@worker_processes.select(&:running?).map(&:pid))
+        end
+      end
+
+      def success?
+        @results.success? && !shutting_down?
       end
 
       def exit_with_status
-        Kernel.exit(@results.success? ? 0 : 1)
+        Kernel.exit(success? ? 0 : 1)
       end
 
       def debug(message)

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

@@ -4,6 +4,8 @@ module RSpec
   module Conductor
     module Util
       class ChildProcess
+        POLL_INTERVAL = 0.01
+
         attr_reader :pid, :exit_status
 
         def self.fork(**args, &block)
@@ -12,18 +14,24 @@ module RSpec
 
         def self.wait_all(processes)
           until processes.all?(&:done?)
-            pipe_to_process = processes.each_with_object({}) do |process, memo|
-              process.pipes.reject(&:closed?).each { |pipe| memo[pipe] = process }
-            end
-            break if pipe_to_process.empty?
-
-            ready, = IO.select(pipe_to_process.keys, nil, nil, 0.1)
-            ready&.each { |pipe| pipe_to_process[pipe].read_available(pipe) }
+            break unless tick_all(processes)
           end
 
           processes.each(&:finalize)
         end
 
+        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 }
+          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) }
+
+          true
+        end
+
         def initialize(on_stdout: nil, on_stderr: nil)
           @on_stdout = on_stdout
           @on_stderr = on_stderr
@@ -55,11 +63,13 @@ module RSpec
 
             $stdout = stdout_write
             $stderr = stderr_write
-            STDOUT.reopen(stdout_write)
-            STDERR.reopen(stderr_write)
+            $stdin = File.open("/dev/null")
+            STDOUT.reopen($stdout)
+            STDERR.reopen($stderr)
+            STDIN.reopen($stdin)
 
             begin
-              yield
+              yield self
             rescue => e
               stderr_write.puts "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
               exit 1
@@ -111,12 +121,17 @@ module RSpec
         def finalize
           return if done?
 
-          process_buffer(@stdout_buffer, @on_stdout, partial: true)
-          process_buffer(@stderr_buffer, @on_stderr, partial: true)
-
-          _, status = Process.wait2(@pid)
-          @exit_status = status.exitstatus
           @done = true
+
+          process_buffer(@stdout_buffer, @on_stdout, drain_remaining: true)
+          process_buffer(@stderr_buffer, @on_stderr, drain_remaining: true)
+
+          begin
+            _, status = Process.waitpid2(@pid)
+            @exit_status = status.exitstatus
+          rescue Errno::ECHILD
+          end
+
           self
         end
 
@@ -130,21 +145,17 @@ module RSpec
 
         private
 
-        def process_buffer(buffer, callback, partial: false)
-          return unless callback
+        def process_buffer(buffer, callback, drain_remaining: false)
+          while (newline_pos = buffer.index("\n"))
+            # String#slice! seems like it was invented specifically for this scenario,
+            # when you need to cut out a string fragment destructively
+            line = buffer.slice!(0..newline_pos).chomp
+            callback&.call(line)
+          end
 
-          if partial
-            unless buffer.empty?
-              callback.call(buffer.chomp)
-              buffer.clear
-            end
-          else
-            while (newline_pos = buffer.index("\n"))
-              # String#slice! seems like it was invented specifically for this scenario,
-              # when you need to cut out a string fragment destructively
-              line = buffer.slice!(0..newline_pos).chomp
-              callback.call(line)
-            end
+          if drain_remaining && !buffer.empty?
+            callback&.call(buffer.chomp)
+            buffer.clear
           end
         end
       end

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "screen_buffer"
-
 module RSpec
   module Conductor
     module Util
@@ -30,7 +28,7 @@ module RSpec
           end
 
           def lines
-            [self]
+            @content ? [self] : []
           end
         end
 

data/lib/rspec/conductor/version.rb

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

data/lib/rspec/conductor/worker.rb

@@ -1,23 +1,20 @@
 # frozen_string_literal: true
 
-require_relative 'ext/rspec'
-
 module RSpec
   module Conductor
     class Worker
-      def initialize(worker_number:, socket:, rspec_args: [], verbose: false, postfork_require: :spec_helper)
+      def initialize(worker_number:, socket:, rspec_args: [], postfork_require: :spec_helper, debug_io: nil)
         @worker_number = worker_number
         @socket = socket
         @rspec_args = rspec_args
-        @verbose = verbose
         @postfork_require = postfork_require
-
+        @debug_io = debug_io
         @message_queue = []
       end
 
       def run
-        suppress_output unless @verbose
         debug "Worker #{@worker_number} starting"
+        setup_signal_handlers
         setup_load_path
         require_postfork_preloads
 
@@ -57,6 +54,11 @@ module RSpec
 
       private
 
+      def setup_signal_handlers
+        Signal.trap(:INT, :IGNORE)
+        Signal.trap(:TERM, :EXIT)
+      end
+
       def setup_load_path
         parsed_options.configure(RSpec.configuration)
         @default_path = RSpec.configuration.default_path || "spec"
@@ -75,12 +77,6 @@ module RSpec
         $LOAD_PATH.unshift(path)
       end
 
-      def suppress_output
-        $stdout.reopen(null_io_out)
-        $stderr.reopen(null_io_out)
-        $stdin.reopen(null_io_in)
-      end
-
       def require_postfork_preloads
         if @postfork_require == :spec_helper
           rails_helper = File.expand_path("rails_helper.rb", @default_full_path)
@@ -172,16 +168,12 @@ module RSpec
       end
 
       def debug(message)
-        $stderr.puts "[worker #{@worker_number}] #{message}"
+        @debug_io.puts message if @debug_io
       end
 
       def null_io_out
         @null_io_out ||= File.open(File::NULL, "w")
       end
-
-      def null_io_in
-        @null_io_in ||= File.open(File::NULL, "r")
-      end
     end
   end
 end

data/lib/rspec/conductor/worker_process.rb

@@ -1,6 +1,42 @@
+# frozen_string_literal: true
+
 module RSpec
   module Conductor
-    WorkerProcess = Struct.new(:pid, :number, :status, :socket, :current_spec, keyword_init: true) do
+    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
+          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
+        )
+      end
+
+      def shut_down(status)
+        return unless running?
+
+        self.status = status
+        socket.close
+      end
+
+      def running?
+        status == :running
+      end
+
       def hash
         [number].hash
       end

data/lib/rspec/conductor.rb

@@ -28,7 +28,9 @@ module RSpec
 end
 
 require_relative "conductor/util/ansi"
+require_relative "conductor/util/screen_buffer"
 require_relative "conductor/util/terminal"
+require_relative "conductor/util/child_process"
 require_relative "conductor/version"
 require_relative "conductor/protocol"
 require_relative "conductor/server"
@@ -42,6 +44,8 @@ require_relative "conductor/formatters/plain"
 require_relative "conductor/formatters/ci"
 require_relative "conductor/formatters/fancy"
 
+require_relative "conductor/ext/rspec"
+
 if defined?(Rails)
   require_relative "conductor/railtie"
 end

data/lib/tasks/rspec_conductor.rake

@@ -49,7 +49,7 @@ module RSpec
           configs
         end
 
-        def run_for_each_database(count, action)
+        def run_for_each_database(count, action, &block)
           raise ArgumentError, "count must be positive" if count < 1
 
           puts "#{action} #{count} test databases in parallel..."

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rspec-conductor
 version: !ruby/object:Gem::Version
-  version: 1.0.8
+  version: 1.0.9
 platform: ruby
 authors:
 - Mark Abramov
@@ -82,7 +82,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Queue-based parallel test runner for rspec
 test_files: []