rspec-conductor 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50d787ec617be586c7f66328850d62f2253bd5f1a50d1effb6417ccfdb4ee3a2
-  data.tar.gz: d71b0b92aa35eb18991ae91a2d3c95d532da79beb80e304e227da87dd214656a
+  metadata.gz: '082ad795d53684a33439d9c56e8d4ff175460d6b335bf25dfbc0114f913a764e'
+  data.tar.gz: ddedba7528e3cd7eaa045b55814c1a4d85a09bb69d9dcceb57c843d00244cec8
 SHA512:
-  metadata.gz: fe26f4f57787171577683b762e57ac8360b52d9949fbe1c6f4b6b8161da7747815e1b1296b1098ae05f9d32a605089847a0bb1c2f6f12f1273c50e7398118099
-  data.tar.gz: 6377b5235c007f274ad83778809319f7eee8e4cc484187202fb8919b8ef8e9ca7122e96e10b1948b6c9b7ca7db2e639bccc8d0e58c5781f17017cb40b119f1bd
+  metadata.gz: 9620094891ec8e360d4427f001711ea4b9e2393020f83706ba86840e135d636d04cb13f2442e97b71a8cbc4bbe12b75354ae86c7e3899fa06035a553b2a29377
+  data.tar.gz: 6842b752e4d66f10b5fed3070aa7fcb7edc7470c3b873fc5da9c8ec86f113e36d1743b0d4193c2966c80acb6638c4cb1b3626b1a2060e813334c2c62392b8d14

data/CHANGELOG.md

@@ -1,4 +1,11 @@
+## [1.0.3] - 2026-02-08
+
+- rake tasks for database preparation
+- some internal retooling for terminal ui inner machinery (mostly affecting the `fancy` formatter)
+
+
 ## [1.0.2] - 2026-01-09
+
 - Fix --postfork-require options
 - Fix worker crashes counter
 

data/Gemfile

@@ -10,3 +10,4 @@ if ENV["RSPEC_VERSION"].to_s.empty?
 else
   gem "rspec", "~> #{ENV["RSPEC_VERSION"]}"
 end
+gem "benchmark-ips"

data/README.md

@@ -31,20 +31,23 @@ rspec-conductor --workers 10 spec
 
 `--verbose` flag is especially useful for troubleshooting.
 
-To set up the databases (if you are using this with rails) you can use a rake task from the parallel_tests gem
+## Mechanics
 
-```bash
-rails 'parallel:drop[10]' 'parallel:setup[10]'
+Server process preloads the `rails_helper`, prepares a list of files to work, then spawns the workers, each with `ENV['TEST_ENV_NUMBER'] = <worker_number>` (same as parallel-tests). The two communicate over a standard unix socket. Message format is basically a tuple of `(size, json_payload)`. It should also be possible to run this process over the network, but I haven't found a solid usecase for this yet.
 
-# if you like the first-is-1 mode, keeping your parallel test envs separate from your regular env:
-PARALLEL_TEST_FIRST_IS_1=true rails 'parallel:drop[10]' 'parallel:setup[10]'
-```
+## Setting up the databases in Rails
 
-I might consider porting that rake task in the near future.
+In order to bootstrap the test environment, there is a rake task:
 
-## Mechanics
+```bash
+# Recreate and seed test databases with TEST_ENV_NUMBER 1 to 10
+rails rspec_conductor:setup[10]
+
+# If you like the first-is-1 mode, keeping your parallel test envs separate from your regular env:
+RSPEC_CONDUCTOR_FIRST_IS_1=1 rails rspec_conductor:setup[10]
+```
 
-Server process preloads the `rails_helper`, prepares a list of files to work, then spawns the workers, each with `ENV['TEST_ENV_NUMBER'] = <worker_number>` (same as parallel-tests). The two communicate over a standard unix socket. Message format is basically a tuple of `(size, json_payload)`. It should also be possible to run this process over the network, but I haven't found a solid usecase for this.
+You can also set the env variable `RSPEC_CONDUCTOR_DEFAULT_WORKER_COUNT` to change the default worker count to avoid typing the quotes for the rake task arguments in zsh.
 
 ## Development notes
 

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

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module RSpec
   module Conductor
     module Formatters
       class CI
-        include Conductor::ANSI
+        include Util::ANSI
 
         DEFAULT_PRINTOUT_INTERVAL = 10
 

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

@@ -1,160 +1,121 @@
+# frozen_string_literal: true
+
 require "pathname"
-require "set"
 
 module RSpec
   module Conductor
     module Formatters
       class Fancy
-        include Conductor::ANSI
+        include Util::ANSI
 
         def self.recommended?
           $stdout.tty? && $stdout.winsize[0] >= 30 && $stdout.winsize[1] >= 80
         end
 
-        def initialize
-          @worker_processes = Set.new
+        def initialize(worker_count:)
+          @worker_processes = {}
+          @terminal = Util::Terminal.new
           @last_rendered_lines = []
-          @dots = []
+          @dots_string = +""
           @last_error = nil
+
+          @progress_bar_line = @terminal.line
+          @terminal.puts
+          @workers_box = @terminal.box
+          @worker_lines = worker_count.times.to_h { |i| [i + 1, @workers_box.line] }
+          @terminal.puts
+          @dots_line = @terminal.line(truncate: false)
+          @terminal.puts
+          @last_error_line = @terminal.line(truncate: false)
         end
 
         def handle_worker_message(worker_process, message, results)
-          @worker_processes <<  worker_process
           public_send(message[:type], worker_process, message) if respond_to?(message[:type])
-          redraw(results)
+          redraw(worker_process, results)
         end
 
         def example_passed(_worker_process, _message)
-          @dots << { char: ".", color: :green }
+          dot ".", :green
         end
 
         def example_failed(_worker_process, message)
-          @dots << { char: "F", color: :red }
+          dot "F", :red
           @last_error = message.slice(:description, :location, :exception_class, :message, :backtrace)
         end
 
         def example_retried(_worker_process, _message)
-          @dots << { char: "R", color: :magenta }
+          dot "R", :magenta
         end
 
         def example_pending(_worker_process, _message)
-          @dots << { char: "*", color: :yellow }
+          dot "*", :yellow
         end
 
         private
 
-        def redraw(results)
-          print_cursor_up(rewrap_lines(@last_rendered_lines).length)
-
-          lines = []
-          lines << progress_bar(results)
-          lines << ""
-          lines.concat(worker_lines)
-          lines << ""
-          lines << @dots.map { |dot| colorize(dot[:char], dot[:color]) }.join
-          lines << ""
-          lines.concat(error_lines) if @last_error
-          lines = rewrap_lines(lines)
-
-          lines.each_with_index do |line, i|
-            if @last_rendered_lines[i] == line
-              print_cursor_down(1)
-            else
-              print_clear_line
-              puts line
-            end
-          end
+        def redraw(worker_process, results)
+          update_worker_status_line(worker_process)
+          update_results_line(results)
+          update_errors_line
+          @terminal.redraw
+          @terminal.scroll_to_bottom
+        end
 
-          if @last_rendered_lines.length && lines.length < @last_rendered_lines.length
-            (@last_rendered_lines.length - lines.length).times do
-              print_clear_line
-              puts
-            end
-            print_cursor_up(@last_rendered_lines.length - lines.length)
-          end
+        def dot(text, color)
+          @dots_string << colorize(text, color)
+          @dots_line.update(@dots_string, redraw: false)
+        end
 
-          @last_rendered_lines = lines
+        def update_worker_status_line(worker_process)
+          status = colorize("Worker #{worker_process.number}: ", :cyan)
+          status << if worker_process.status == :shut_down
+                      "(finished)"
+                    elsif worker_process.status == :terminated
+                      colorize("(terminated)", :red)
+                    elsif worker_process.current_spec
+                      relative_path(worker_process.current_spec)
+                    else
+                      "(idle)"
+                    end
+
+          @worker_lines[worker_process.number].update(status, redraw: false)
         end
 
-        def progress_bar(results)
+        def update_results_line(results)
           pct = results.spec_file_processed_percentage
           bar_width = [tty_width - 20, 20].max
-
           filled = (pct * bar_width).floor
           empty = bar_width - filled
 
-          bar = colorize("[", :reset) + colorize("▓" * filled, :green) + colorize(" " * empty, :reset) + colorize("]", :reset)
-          percentage = " #{(pct * 100).floor.to_s.rjust(3)}% (#{results.spec_files_processed}/#{results.spec_files_total})"
-
-          bar + percentage
-        end
+          percentage = " %3d%% (%d/%d)" % [(pct * 100).floor, results.spec_files_processed, results.spec_files_total]
+          bar = colorize("[", :reset) + colorize("▓", :green) * filled + colorize(" ", :reset) * empty + colorize("]", :reset)
 
-        def worker_lines
-          @worker_processes.sort_by(&:number).map do |worker_process|
-            prefix = colorize("Worker #{worker_process.number}: ", :cyan)
-
-            if worker_process.status == :shut_down
-              prefix + "(finished)"
-            elsif worker_process.status == :terminated
-              prefix + colorize("(terminated)", :red)
-            elsif worker_process.current_spec
-              prefix + truncate(relative_path(worker_process.current_spec), tty_width - 15)
-            else
-              prefix + "(idle)"
-            end
-          end
+          @progress_bar_line.update(bar + percentage, redraw: false)
         end
 
-        def error_lines
-          return [] unless @last_error
+        def update_errors_line
+          return unless @last_error
 
-          lines = []
-          lines << colorize("Most recent failure:", :red)
-          lines << "  #{@last_error[:description]}"
-          lines << "  #{@last_error[:location]}"
+          error_components = []
+          error_components << colorize("Most recent failure:", :red)
+          error_components << "  #{@last_error[:description]}"
+          error_components << "  #{@last_error[:location]}"
 
           if @last_error[:exception_class] || @last_error[:message]
-            err_msg = [@last_error[:exception_class], @last_error[:message]].compact.join(": ")
-            lines << "  #{err_msg}"
+            error_components << "  #{[@last_error[:exception_class], visible_chars(@last_error[:message])].compact.join(": ")}"
           end
 
           if @last_error[:backtrace]&.any?
-            lines << "  Backtrace:"
-            @last_error[:backtrace].first(10).each { |l| lines << "    #{l}" }
+            error_components << "  Backtrace:"
+            @last_error[:backtrace].first(10).each { |l| error_components << "    #{l}" }
           end
 
-          lines
-        end
-
-        def rewrap_lines(lines)
-          lines.flat_map do |line|
-            _, indent, body = line.partition(/^\s*/)
-            max_width = tty_width - indent.size
-            split_visible_char_groups(body).each_slice(max_width).map { |chars| "#{indent}#{chars.join}" }
-          end
+          @last_error_line.update(error_components.join("\n"), redraw: false)
         end
 
         def relative_path(filename)
           Pathname(filename).relative_path_from(Conductor.root).to_s
         end
-
-        def truncate(str, max_length)
-          return "" unless str
-
-          str.length > max_length ? "...#{str[-(max_length - 3)..]}" : str
-        end
-
-        def print_cursor_up(n_lines)
-          print cursor_up(n_lines) if $stdout.tty?
-        end
-
-        def print_cursor_down(n_lines)
-          print cursor_down(n_lines) if $stdout.tty?
-        end
-
-        def print_clear_line
-          print clear_line if $stdout.tty?
-        end
       end
     end
   end

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

@@ -2,7 +2,7 @@ module RSpec
   module Conductor
     module Formatters
       class Plain
-        include Conductor::ANSI
+        include Util::ANSI
 
         def handle_worker_message(_worker_process, message, _results)
           public_send(message[:type], message) if respond_to?(message[:type])

data/lib/rspec/conductor/railtie.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Conductor
+    class Railtie < ::Rails::Railtie
+      rake_tasks do
+        load File.expand_path("../../../tasks/rspec_conductor.rake", __FILE__)
+      end
+    end
+  end
+end

data/lib/rspec/conductor/server.rb

@@ -3,7 +3,6 @@
 require "English"
 require "socket"
 require "json"
-require "io/console"
 
 module RSpec
   module Conductor
@@ -40,11 +39,11 @@ module RSpec
                      when "ci"
                        Formatters::CI.new
                      when "fancy"
-                       Formatters::Fancy.new
+                       Formatters::Fancy.new(worker_count: worker_count)
                      when "plain"
                        Formatters::Plain.new
                      else
-                       (!@verbose && Formatters::Fancy.recommended?) ? Formatters::Fancy.new : Formatters::Plain.new
+                       (!@verbose && Formatters::Fancy.recommended?) ? Formatters::Fancy.new(worker_count: worker_count) : Formatters::Plain.new
                      end
         @results = Results.new
       end
@@ -185,7 +184,7 @@ module RSpec
           @results.example_failed(message)
 
           if @fail_fast_after && @results.failed >= @fail_fast_after
-            debug "Shutting after #{@results.failed} failures"
+            debug "Shutting down after #{@results.failed} failures"
             initiate_shutdown
           end
         when :example_pending
@@ -211,13 +210,14 @@ module RSpec
       end
 
       def assign_work(worker_process)
-        if @spec_queue.empty? || @results.shutting_down?
+        spec_file = @spec_queue.shift
+
+        if @results.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)
         else
           @results.spec_file_assigned
-          spec_file = @spec_queue.shift
           worker_process.current_spec = spec_file
           debug "Assigning #{spec_file} to worker #{worker_process.number}"
           message = { type: :worker_assigned_spec, file: spec_file }
@@ -277,7 +277,7 @@ module RSpec
       end
 
       def colorize(string, color)
-        $stdout.tty? ? ANSI.colorize(string, color) : string
+        $stdout.tty? ? Util::ANSI.colorize(string, color) : string
       end
 
       def exit_with_status

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "io/console"
+
+module RSpec
+  module Conductor
+    module Util
+      module ANSI
+        module_function
+
+        ANSI_SEQUENCE_REGEX = /\e\[[0-9;]*[a-zA-Z]/
+        VISIBLE_CHAR_GROUP_REGEX = /#{ANSI_SEQUENCE_REGEX}*[^\e]|#{ANSI_SEQUENCE_REGEX}+/
+        COLOR_CODES = {
+          # Reset
+          reset: "0",
+
+          # Styles
+          bold: "1",
+          dim: "2",
+          italic: "3",
+          underline: "4",
+          blink: "5",
+          inverse: "7",
+          hidden: "8",
+          strikethrough: "9",
+
+          # Foreground colors
+          black: "30",
+          red: "31",
+          green: "32",
+          yellow: "33",
+          blue: "34",
+          magenta: "35",
+          cyan: "36",
+          white: "37",
+
+          # Bright foreground colors
+          bright_black: "90",
+          bright_red: "91",
+          bright_green: "92",
+          bright_yellow: "93",
+          bright_blue: "94",
+          bright_magenta: "95",
+          bright_cyan: "96",
+          bright_white: "97",
+
+          # Background colors
+          bg_black: "40",
+          bg_red: "41",
+          bg_green: "42",
+          bg_yellow: "43",
+          bg_blue: "44",
+          bg_magenta: "45",
+          bg_cyan: "46",
+          bg_white: "47",
+
+          # Bright background colors
+          bg_bright_black: "100",
+          bg_bright_red: "101",
+          bg_bright_green: "102",
+          bg_bright_yellow: "103",
+          bg_bright_blue: "104",
+          bg_bright_magenta: "105",
+          bg_bright_cyan: "106",
+          bg_bright_white: "107",
+        }.freeze
+
+        def colorize(string, colors, reset: true)
+          [
+            "\e[",
+            Array(colors).map { |color| color_code(color) }.join(";"),
+            "m",
+            string,
+            reset ? "\e[#{color_code(:reset)}m" : nil,
+          ].join
+        end
+
+        def color_code(color)
+          COLOR_CODES.fetch(color, COLOR_CODES[:reset])
+        end
+
+        def cursor_up(n = 1)
+          n.positive? ? "\e[#{n}A" : ""
+        end
+
+        def cursor_down(n = 1)
+          n.positive? ? "\e[#{n}B" : ""
+        end
+
+        def cursor_forward(n = 1)
+          n.positive? ? "\e[#{n}C" : ""
+        end
+
+        def cursor_back(n = 1)
+          n.positive? ? "\e[#{n}D" : ""
+        end
+
+        def cursor_column(col)
+          "\e[#{col}G"
+        end
+
+        def cursor_end_of_line
+          "\e[999C"
+        end
+
+        def clear_line
+          "\e[2K\r"
+        end
+
+        def clear_line_forward
+          "\e[K"
+        end
+
+        # sticks invisible characters to visible ones when splitting (so that an ansi color code doesn't get split mid-way)
+        def split_visible_char_groups(string)
+          string.scan(VISIBLE_CHAR_GROUP_REGEX)
+        end
+
+        def visible_chars(string)
+          return unless string
+
+          string.gsub(ANSI_SEQUENCE_REGEX, '')
+        end
+
+        def tty_width(tty = $stdout)
+          return 80 unless tty.tty?
+
+          tty.winsize[1]
+        end
+
+        def tty_height(tty = $stdout)
+          return 50 unless tty.tty?
+
+          tty.winsize[0]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Conductor
+    module Util
+      class ChildProcess
+        attr_reader :pid, :exit_status
+
+        def self.fork(**args, &block)
+          new(**args).fork(&block)
+        end
+
+        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) }
+          end
+
+          processes.each(&:finalize)
+        end
+
+        def initialize(on_stdout: nil, on_stderr: nil)
+          @on_stdout = on_stdout
+          @on_stderr = on_stderr
+          @pid = nil
+          @exit_status = nil
+          @stdout_pipe = nil
+          @stderr_pipe = nil
+          @stdout_buffer = +""
+          @stderr_buffer = +""
+          @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
+
+          @stdout_pipe = stdout_read
+          @stderr_pipe = stderr_read
+
+          @pid = Kernel.fork do
+            stdout_read.close
+            stderr_read.close
+
+            $stdout = stdout_write
+            $stderr = stderr_write
+            STDOUT.reopen(stdout_write)
+            STDERR.reopen(stderr_write)
+
+            begin
+              yield
+            rescue => e
+              stderr_write.puts "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
+              exit 1
+            ensure
+              stdout_write.close
+              stderr_write.close
+            end
+
+            exit 0
+          end
+
+          stdout_write.close
+          stderr_write.close
+
+          self
+        end
+
+        def done?
+          @done
+        end
+
+        def read_available(pipe)
+          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
+          end
+
+          begin
+            data = pipe.read_nonblock(4096, exception: false)
+            if data == :wait_readable
+              return
+            elsif data.nil? || data.empty?
+              pipe.close
+            else
+              buffer << data
+              process_buffer(buffer, callback)
+            end
+          rescue IOError, EOFError
+            pipe.close
+          end
+        end
+
+        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
+          self
+        end
+
+        def wait
+          self.class.wait_all([self])
+        end
+
+        def success?
+          @exit_status == 0
+        end
+
+        private
+
+        def process_buffer(buffer, callback, partial: false)
+          return unless callback
+
+          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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Conductor
+    module Util
+      class ScreenBuffer
+        include Util::ANSI
+
+        def initialize(output = $stdout)
+          @output = output
+          @lines = []
+          @cursor_row = 0
+          @cursor_col = 0
+          @height = 1
+        end
+
+        # Accepts new state as an array of strings.
+        # Computes the minimal diff and writes ANSI escape sequences to @output.
+        def update(new_lines)
+          unless @output.tty?
+            @output.puts Array(new_lines).map { |line| visible_chars(line) }
+            return
+          end
+
+          new_lines = Array(new_lines)
+          ops = lines_diff(new_lines)
+          unless ops.empty?
+            @output.print(ops)
+            @output.flush
+          end
+          @lines = new_lines.dup
+        end
+
+        def scroll_to_bottom
+          @output.print move_cursor(@height, 0, resize_height: false)
+        end
+
+        private
+
+        def lines_diff(new_lines)
+          buf = +""
+
+          [new_lines.length, @lines.length].max.times do |row|
+            old_line = @lines[row] || ""
+            new_line = new_lines[row] || ""
+
+            next if old_line == new_line
+
+            old_line_char_groups = split_visible_char_groups(old_line)
+            new_line_char_groups = split_visible_char_groups(new_line)
+            first_diff_index = new_line_char_groups.size.times.detect { |i| new_line_char_groups[i] != old_line_char_groups[i] } || new_line_char_groups.size
+
+            changed_part = new_line_char_groups[first_diff_index..-1]
+            buf << move_cursor(row, first_diff_index)
+            buf << changed_part.join
+            buf << clear_line_forward if old_line_char_groups.size > new_line_char_groups.size
+
+            @cursor_col = new_line_char_groups.size
+          end
+
+          buf
+        end
+
+        def move_cursor(row, col, resize_height: true)
+          buf = +""
+
+          if row < @cursor_row
+            buf << cursor_up(@cursor_row - row)
+          elsif row > @cursor_row
+            # if our current screen buffer is shorter than the row we want to go to,
+            # then we need to output new lines until we reach the right height
+            buf << cursor_down([row - @cursor_row, @height - @cursor_row - 1].min)
+            newlines = row - @height + 1
+            if newlines > 0
+              buf << "\n" * newlines
+              @cursor_col = 0
+            end
+          end
+
+          buf << cursor_column(col + 1) if @cursor_col != col
+          @height = [@height, row + 1].max if resize_height
+          @cursor_row = row
+          @cursor_col = col
+          buf
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require_relative "screen_buffer"
+
+module RSpec
+  module Conductor
+    module Util
+      class Terminal
+        include Util::ANSI
+
+        INDENTATION_REGEX = /^(\s+)(.*)$/
+
+        class Line
+          attr_reader :content, :truncate
+
+          def initialize(terminal, content, truncate: true, redraw: true)
+            @terminal = terminal
+            @truncate = truncate
+            yield self if block_given?
+            update(content, redraw: redraw)
+          end
+
+          def update(new_content, redraw: true)
+            @content = new_content
+            @terminal.redraw if redraw
+          end
+
+          def to_s
+            @content
+          end
+
+          def lines
+            [self]
+          end
+        end
+
+        class Box
+          def initialize(terminal)
+            @terminal = terminal
+            @contents = []
+            yield self if block_given?
+          end
+
+          def line(content = "", truncate: true, redraw: true)
+            Line.new(@terminal, content, truncate: truncate, redraw: redraw) { |l| @contents << l }
+          end
+
+          def puts(content = "", redraw: true)
+            line(content, truncate: false, redraw: redraw)
+          end
+
+          def box
+            Box.new(@terminal) { |b| @contents << b }
+          end
+
+          def lines
+            @contents.flat_map(&:lines)
+          end
+        end
+
+        def initialize(output = $stdout, screen_buffer = ScreenBuffer.new(output))
+          @output = output
+          @screen_buffer = screen_buffer
+          @wrapper_box = Box.new(self)
+        end
+
+        def line(content = "", **kwargs)
+          @wrapper_box.line(content, **kwargs)
+        end
+
+        def puts(content = "", **kwargs)
+          @wrapper_box.puts(content, **kwargs)
+        end
+
+        def box
+          @wrapper_box.box
+        end
+
+        def scroll_to_bottom
+          @screen_buffer.scroll_to_bottom
+        end
+
+        def redraw
+          screen_lines = @wrapper_box.lines.flat_map { |line| line.truncate ? truncate_to_tty_width(line.content) : rewrap_to_tty_width(line.content) }
+          @screen_buffer.update(screen_lines.take(tty_height(@output) - 1))
+        end
+
+        private
+
+        def truncate_to_tty_width(string)
+          return string unless tty?
+
+          split_visible_char_groups(string).take(tty_width(@output)).join
+        end
+
+        def rewrap_to_tty_width(string)
+          return string unless tty?
+
+          string.split("\n").flat_map do |line|
+            indent, body = line.match(INDENTATION_REGEX)&.captures || ["", line]
+            max_width = tty_width(@output) - indent.size
+            split_visible_char_groups(body).each_slice(max_width).map { |chars| "#{indent}#{chars.join}" }
+          end
+        end
+
+        def tty?
+          @output.tty?
+        end
+      end
+    end
+  end
+end

data/lib/rspec/conductor/version.rb

@@ -2,6 +2,6 @@
 
 module RSpec
   module Conductor
-    VERSION = "1.0.2"
+    VERSION = "1.0.3"
   end
 end

data/lib/rspec/conductor.rb

@@ -2,6 +2,8 @@
 
 require "rspec/core"
 
+require_relative "conductor/util/ansi"
+require_relative "conductor/util/terminal"
 require_relative "conductor/version"
 require_relative "conductor/protocol"
 require_relative "conductor/server"
@@ -9,7 +11,6 @@ require_relative "conductor/worker"
 require_relative "conductor/results"
 require_relative "conductor/worker_process"
 require_relative "conductor/cli"
-require_relative "conductor/ansi"
 require_relative "conductor/rspec_subscriber"
 require_relative "conductor/formatters/plain"
 require_relative "conductor/formatters/ci"
@@ -26,3 +27,7 @@ module RSpec
     end
   end
 end
+
+if defined?(Rails)
+  require_relative "conductor/railtie"
+end

data/lib/tasks/rspec_conductor.rake

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Conductor
+    module DatabaseTasks
+      class << self
+        def default_worker_count
+          ENV['RSPEC_CONDUCTOR_DEFAULT_WORKER_COUNT']&.to_i || 4
+        end
+
+        def create_databases(count)
+          run_for_each_database(count, "Creating") do
+            db_configs.each { |config| ActiveRecord::Tasks::DatabaseTasks.create(config) }
+          end
+        end
+
+        def drop_databases(count)
+          run_for_each_database(count, "Dropping") do
+            db_configs.each { |config| ActiveRecord::Tasks::DatabaseTasks.drop(config) }
+          end
+        end
+
+        def setup_databases(count)
+          schema_format, schema_file = schema_format_and_file
+
+          run_for_each_database(count, "Setting up") do
+            puts "Dropping database(s)"
+            db_configs.each { |config| ActiveRecord::Tasks::DatabaseTasks.drop(config) }
+
+            puts "Creating database(s)"
+            db_configs.each { |config| ActiveRecord::Tasks::DatabaseTasks.create(config) }
+
+            puts "Loading schema"
+            db_configs.each { |config| ActiveRecord::Tasks::DatabaseTasks.load_schema(config, schema_format, schema_file) }
+
+            puts "Loading seed"
+            ActiveRecord::Tasks::DatabaseTasks.load_seed
+          end
+        end
+
+        private
+
+        def first_is_1?
+          ENV["RSPEC_CONDUCTOR_FIRST_IS_1"] == "1"
+        end
+
+        def db_configs
+          reload_database_configuration!
+
+          configs = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env)
+          raise ArgumentError, "could not find or parse configuration for the env #{Rails.env}" unless configs.any?
+
+          configs
+        end
+
+        def run_for_each_database(count, action)
+          raise ArgumentError, "count must be positive" if count < 1
+
+          puts "#{action} #{count} test databases in parallel..."
+          # Close connections before forking to avoid sharing file descriptors
+          ActiveRecord::Base.connection_pool.disconnect!
+
+          terminal = Conductor::Util::Terminal.new
+          children = count.times.map do |i|
+            worker_number = i + 1
+            env_number = (first_is_1? || worker_number != 1) ? worker_number.to_s: ""
+            line = terminal.line("#{worker_number}: starting...")
+            stderr_buffer = +""
+
+            on_stdout = ->(text) do
+              line.update("#{worker_number}: #{text}")
+            end
+            on_stderr = ->(text) do
+              stderr_buffer << "#{text}\n"
+              line.update("#{worker_number}: [STDERR] #{text}")
+            end
+
+            process = Conductor::Util::ChildProcess.fork(on_stdout: on_stdout, on_stderr: on_stderr) do
+              ENV["TEST_ENV_NUMBER"] = env_number
+              puts "#{action} test database #{worker_number} of #{count} (TEST_ENV_NUMBER=#{env_number.inspect})"
+              yield
+            end
+
+            { process: process, worker_number: worker_number, stderr: stderr_buffer }
+          end
+          Conductor::Util::ChildProcess.wait_all(children.map { |v| v[:process] })
+          terminal.scroll_to_bottom
+
+          failed_children = children.reject { |child| child[:process].success? }
+          if failed_children.none?
+            puts "\nSuccessfully completed #{action.downcase} for #{count} database(s)"
+          else
+            puts "\nCompleted with #{failed_children.length} error(s):"
+            failed_children.each do |child|
+              puts "Process #{child[:worker_number]}"
+              puts "STDERR output:"
+              child[:stderr].each_line { |line| puts "    #{line}" }
+              puts
+            end
+
+            raise "Database operation failed for #{failed_children.length} worker(s)"
+          end
+        end
+
+        def reload_database_configuration!
+          parsed_yaml = Rails.application.config.load_database_yaml
+          raise ArgumentError, "could not find database yaml or the yaml is empty" if parsed_yaml.empty?
+
+          ActiveRecord::Base.configurations = ActiveRecord::DatabaseConfigurations.new(parsed_yaml)
+        end
+
+        def schema_format_and_file
+          ruby_schema = File.join(Rails.root, "db", "schema.rb")
+          sql_schema = File.join(Rails.root, "db", "structure.sql")
+
+          if File.exist?(ruby_schema)
+            [:ruby, ruby_schema]
+          elsif File.exist?(sql_schema)
+            [:sql, sql_schema]
+          else
+            raise ArgumentError, "Neither db/schema.rb nor db/structure.sql found"
+          end
+        end
+      end
+    end
+  end
+end
+
+namespace :rspec_conductor do
+  desc "Create parallel test databases (default: #{RSpec::Conductor::DatabaseTasks.default_worker_count})"
+  task :create, [:count] => %w(set_rails_env_to_test environment) do |_t, args|
+    count = (args[:count] || RSpec::Conductor::DatabaseTasks.default_worker_count).to_i
+    RSpec::Conductor::DatabaseTasks.create_databases(count)
+  end
+
+  desc "Drop parallel test databases (default: #{RSpec::Conductor::DatabaseTasks.default_worker_count})"
+  task :drop, [:count] => %w(set_rails_env_to_test environment) do |_t, args|
+    count = (args[:count] || RSpec::Conductor::DatabaseTasks.default_worker_count).to_i
+    RSpec::Conductor::DatabaseTasks.drop_databases(count)
+  end
+
+  desc "Setup parallel test databases (drop + create + schema load + seed) (default: #{RSpec::Conductor::DatabaseTasks.default_worker_count})"
+  task :setup, [:count] => %w(set_rails_env_to_test environment) do |_t, args|
+    count = (args[:count] || RSpec::Conductor::DatabaseTasks.default_worker_count).to_i
+    RSpec::Conductor::DatabaseTasks.setup_databases(count)
+  end
+
+  # When RAILS_ENV is not set, Rails.env can default to development,
+  # which would have reaching consequences for our setup script.
+  # That's why we're forcing RAILS_ENV=test and spawning the rails task again.
+  task :set_rails_env_to_test do
+    if ENV['RAILS_ENV']
+      require_relative "../rspec/conductor/util/terminal"
+      require_relative "../rspec/conductor/util/child_process"
+    else
+      system({ "RAILS_ENV" => "test" }, "rake", *Rake.application.top_level_tasks)
+      exit
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-conductor
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Mark Abramov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-10 00:00:00.000000000 Z
+date: 2026-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec-core
@@ -40,19 +40,24 @@ files:
 - Rakefile
 - exe/rspec-conductor
 - lib/rspec/conductor.rb
-- lib/rspec/conductor/ansi.rb
 - lib/rspec/conductor/cli.rb
 - lib/rspec/conductor/ext/rspec.rb
 - lib/rspec/conductor/formatters/ci.rb
 - lib/rspec/conductor/formatters/fancy.rb
 - 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/util/ansi.rb
+- lib/rspec/conductor/util/child_process.rb
+- lib/rspec/conductor/util/screen_buffer.rb
+- lib/rspec/conductor/util/terminal.rb
 - lib/rspec/conductor/version.rb
 - lib/rspec/conductor/worker.rb
 - lib/rspec/conductor/worker_process.rb
+- lib/tasks/rspec_conductor.rake
 - rspec-conductor.gemspec
 homepage: https://github.com/markiz/rspec-conductor
 licenses:

data/lib/rspec/conductor/ansi.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-module RSpec
-  module Conductor
-    module ANSI
-      module_function
-
-      COLOR_CODES = {
-        # Reset
-        reset: "0",
-
-        # Styles
-        bold: "1",
-        dim: "2",
-        italic: "3",
-        underline: "4",
-        blink: "5",
-        inverse: "7",
-        hidden: "8",
-        strikethrough: "9",
-
-        # Foreground colors
-        black: "30",
-        red: "31",
-        green: "32",
-        yellow: "33",
-        blue: "34",
-        magenta: "35",
-        cyan: "36",
-        white: "37",
-
-        # Bright foreground colors
-        bright_black: "90",
-        bright_red: "91",
-        bright_green: "92",
-        bright_yellow: "93",
-        bright_blue: "94",
-        bright_magenta: "95",
-        bright_cyan: "96",
-        bright_white: "97",
-
-        # Background colors
-        bg_black: "40",
-        bg_red: "41",
-        bg_green: "42",
-        bg_yellow: "43",
-        bg_blue: "44",
-        bg_magenta: "45",
-        bg_cyan: "46",
-        bg_white: "47",
-
-        # Bright background colors
-        bg_bright_black: "100",
-        bg_bright_red: "101",
-        bg_bright_green: "102",
-        bg_bright_yellow: "103",
-        bg_bright_blue: "104",
-        bg_bright_magenta: "105",
-        bg_bright_cyan: "106",
-        bg_bright_white: "107",
-      }.freeze
-
-      def colorize(string, colors, reset: true)
-        [
-          "\e[",
-          Array(colors).map { |color| color_code(color) }.join(";"),
-          "m",
-          string,
-          reset ? "\e[#{color_code(:reset)}m" : nil,
-        ].join
-      end
-
-      def color_code(color)
-        COLOR_CODES.fetch(color, COLOR_CODES[:reset])
-      end
-
-      def cursor_up(n_lines)
-        n_lines.positive? ? "\e[#{n_lines}A" : ""
-      end
-
-      def cursor_down(n_lines)
-        n_lines.positive? ? "\e[#{n_lines}B" : ""
-      end
-
-      def clear_line
-        "\e[2K\r"
-      end
-
-      # sticks invisible characters to visible ones when splitting (so that an ansi color code doesn"t get split mid-way)
-      def split_visible_char_groups(string)
-        invisible = "(?:\\e\\[[0-9;]*[a-zA-Z])"
-        visible = "(?:[^\\e])"
-        scan_regex = Regexp.new("#{invisible}*#{visible}#{invisible}*|#{invisible}+")
-        string.scan(scan_regex)
-      end
-
-      def visible_chars(string)
-        string.gsub(/\e\[[0-9;]*[a-zA-Z]/, '')
-      end
-
-      def tty_width
-        $stdout.tty? ? $stdout.winsize[1] : 80
-      end
-    end
-  end
-end