rspec-multicore 0.2.0.pre1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c5b4ba855f92f2fc6b231d2d57cb81a89c0f8ffc8c127a83b4d2f6d5470f0027
+  data.tar.gz: 55258d03db9e19e53d77ab967bc2a0f7c803f535abff99af1aa5a58f40ae7175
+SHA512:
+  metadata.gz: 76afdaeefbeb2b42a0f646c3b578fb002e54541fcd91d5170e6589f00ffb85cd6af5b986d7699681b64c7d70d88f09f76f7ec71fbcceb1024b2cf5add78523e7
+  data.tar.gz: 5255c15ae7b1adca839a178aaf18b87365d1d1507a112edb0eb7e7164cd251168791fdd93aa24a57b27e6169bac4c3186069f4995444b64e65737b02c002bfa2

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## 0.2.0.pre1
+
+- Uses one narrow `Runner#run_specs` patch and delegates suite ownership to RSpec.
+- Adds a bounded plain-value Channel, persistent process Pool, parent object registry, and standard-event snapshot bridge.
+- Adds `RSPEC_MULTICORE`, configurable workers, fork hooks, and reverse-order shutdown hooks.
+- Supports Ruby 3.2+ and RSpec 3.13.x.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025-2026 Sveta Markovic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,19 @@
+# rspec-multicore
+
+`rspec-multicore` runs RSpec 3.13 top-level example groups in persistent forked workers while the parent retains the real RSpec objects and reporter.
+
+```ruby
+require "rspec/multicore"
+
+RSpec::Multicore.configure { _1.workers = 8 }
+RSpec::Multicore.on_worker_fork { |slot| MyResource.connect(slot) }
+RSpec::Multicore.on_worker_shutdown { |slot| MyResults.finish(slot) }
+```
+
+Use `RSPEC_MULTICORE=8` for an explicit count, or `RSPEC_MULTICORE=0`, `false`, or `off` for native serial RSpec. Unset, `auto`, `true`, or `on` selects the configured count or CPU count.
+
+The gem patches only `RSpec::Core::Runner#run_specs`. It sends stable IDs and bounded result/exception snapshots between processes, supports only standard RSpec 3.13 reporter events, and replays events in seeded group order. Fail-fast and dry-run remain serial. Workers use `exit!`; inherited `at_exit` callbacks do not run.
+
+Application resources and coverage tools are configured explicitly through the lifecycle hooks. Serial coverage is the safe default.
+
+See the [project documentation](https://github.com/svetam/rspec-multicore) for details.

data/lib/rspec/multicore/channel.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module RSpec
+  module Multicore
+    # Transfers bounded plain-value frames over a local socket pair.
+    class Channel
+      HEADER_SIZE = 4
+      MAX_FRAME_SIZE = 10 * 1024 * 1024
+      PLAIN_VALUES = [NilClass, TrueClass, FalseClass, Integer, Float, String, Symbol].freeze
+
+      attr_reader :socket
+
+      def self.pair = UNIXSocket.pair.map { new(_1) }
+
+      def initialize(socket)
+        @socket = socket
+        @write_lock = Mutex.new
+      end
+
+      def write(value)
+        validate!(value)
+        payload = Marshal.dump(value)
+        raise Error, "Channel frame exceeds #{MAX_FRAME_SIZE} bytes" if payload.bytesize > MAX_FRAME_SIZE
+
+        @write_lock.synchronize { write_all([payload.bytesize].pack("N") + payload) }
+        nil
+      rescue IOError, SystemCallError => e
+        raise Error, "Channel write failed: #{e.message}"
+      end
+
+      def read
+        header = read_exactly(HEADER_SIZE)
+        return if header.nil?
+
+        length = header.unpack1("N")
+        raise Error, "Invalid Channel frame size: #{length}" unless length.between?(1, MAX_FRAME_SIZE)
+
+        payload = read_exactly(length, "frame")
+
+        value = Marshal.load(payload)
+        validate!(value)
+        value
+      rescue TypeError, ArgumentError => e
+        raise Error, "Invalid Channel frame: #{e.message}"
+      end
+
+      def close
+        socket.close unless socket.closed?
+      rescue IOError, SystemCallError
+        nil
+      end
+
+      def closed? = socket.closed?
+
+      private
+
+      def read_exactly(length, part = "header")
+        data = +""
+        while data.bytesize < length
+          chunk = socket.read(length - data.bytesize)
+          if chunk.nil? || chunk.empty?
+            return if data.empty? && part == "header"
+
+            raise Error, "Channel closed during #{part}"
+          end
+
+          data << chunk
+        end
+        data
+      rescue IOError, SystemCallError => e
+        raise Error, "Channel read failed: #{e.message}"
+      end
+
+      def write_all(data)
+        offset = 0
+        offset += socket.write(data.byteslice(offset..)) while offset < data.bytesize
+      end
+
+      def validate!(value)
+        return if PLAIN_VALUES.any? { value.is_a?(_1) }
+        return value.each { validate!(_1) } if value.is_a?(Array)
+
+        if value.is_a?(Hash)
+          return value.each do |key, item|
+            validate!(key)
+            validate!(item)
+          end
+        end
+
+        raise Error, "Channel cannot transfer #{value.class}"
+      end
+    end
+  end
+end

data/lib/rspec/multicore/configuration.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "etc"
+
+module RSpec
+  # Process configuration and lifecycle hooks for multicore RSpec execution.
+  module Multicore
+    # Resolves the worker count from the Ruby API and RSPEC_MULTICORE.
+    class Configuration
+      ENABLED_VALUES = %w[true on auto].freeze
+      DISABLED_VALUES = %w[0 false off].freeze
+
+      def workers
+        setting = env_value
+        case setting
+        when :disabled then 0
+        when Integer then setting
+        else @workers || Etc.nprocessors
+        end
+      end
+
+      def workers=(value)
+        unless value.nil? || (value.is_a?(Integer) && value.positive?)
+          raise ArgumentError, "workers must be a positive integer or nil"
+        end
+
+        @workers = value
+      end
+
+      private
+
+      def env_value
+        value = ENV.fetch("RSPEC_MULTICORE", nil)
+        return :default if value.nil? || ENABLED_VALUES.include?(value.downcase)
+        return :disabled if DISABLED_VALUES.include?(value.downcase)
+
+        workers = Integer(value, 10)
+        return workers if workers.positive?
+
+        raise ArgumentError
+      rescue ArgumentError
+        raise ArgumentError,
+              "RSPEC_MULTICORE must be auto, true, on, false, off, 0, or a positive integer"
+      end
+    end
+
+    # Stores process lifecycle hooks independently of RSpec configuration.
+    module Hooks
+      class << self
+        def on_fork(&block) = (fork_hooks << block if block)
+
+        def on_shutdown(&block) = (shutdown_hooks << block if block)
+
+        def run_fork(slot) = fork_hooks.each { _1.call(slot) }
+
+        def run_shutdown(slot)
+          shutdown_hooks.reverse_each.filter_map do |hook|
+            hook.call(slot)
+            nil
+          rescue StandardError => e
+            e
+          end
+        end
+
+        def clear!
+          fork_hooks.clear
+          shutdown_hooks.clear
+        end
+
+        private
+
+        def fork_hooks = @fork_hooks ||= []
+        def shutdown_hooks = @shutdown_hooks ||= []
+      end
+    end
+
+    class << self
+      def configuration = @configuration ||= Configuration.new
+
+      def configure = yield configuration
+
+      def workers = configuration.workers
+      def enabled? = workers.positive?
+      def on_worker_fork(&) = Hooks.on_fork(&)
+      def on_worker_shutdown(&) = Hooks.on_shutdown(&)
+    end
+  end
+end

data/lib/rspec/multicore/pool.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Multicore
+    # Schedules groups across persistent workers and replays ordered results.
+    class Pool
+      Worker = Struct.new(:pid, :slot, :channel, :assigned, :completed, :status, keyword_init: true)
+
+      attr_reader :workers
+
+      def initialize(reporter:, configuration:, workers: RSpec::Multicore.workers)
+        @reporter = reporter
+        @configuration = configuration
+        @worker_count = workers
+        @workers = []
+        @failures = []
+      end
+
+      def run(groups)
+        return [] if groups.empty?
+
+        prepare(groups)
+        spawn_workers
+        event_loop
+        reap_workers
+        report_failures
+        @results
+      rescue StandardError => e
+        @failures << e
+        report_failures
+        Array.new(groups.size, false)
+      ensure
+        cleanup
+      end
+
+      private
+
+      def prepare(groups)
+        @groups = groups
+        @queue = (0...groups.size).to_a
+        @results = Array.new(groups.size)
+        @buffers = Hash.new { |hash, key| hash[key] = [] }
+        @completed = {}
+        @next_replay = 0
+        registry = ObjectRegistry.new(groups)
+        @bridge = ReporterBridge.new(registry, @reporter)
+      end
+
+      def spawn_workers
+        [@worker_count, @groups.size].min.times do |index|
+          parent_channel, child_channel = Channel.pair
+          inherited_channels = workers.map(&:channel)
+          pid = fork_worker(index, parent_channel, child_channel, inherited_channels)
+          child_channel.close
+          workers << Worker.new(pid:, slot: index + 1, channel: parent_channel)
+        rescue StandardError
+          parent_channel&.close
+          child_channel&.close
+          raise
+        end
+      end
+
+      def fork_worker(index, parent_channel, child_channel, inherited_channels)
+        Process.fork do
+          parent_channel.close
+          inherited_channels.each(&:close)
+          worker_main(index + 1, child_channel)
+        end
+      end
+
+      def worker_main(slot, channel)
+        ENV["RSPEC_MULTICORE_WORKER"] = slot.to_s
+        writer = EventWriter.new(channel)
+        reporter = ReporterProxy.new(writer)
+        originals = install_worker_runtime(reporter, writer)
+        failed = false
+
+        begin
+          Hooks.run_fork(slot)
+          run_groups(channel, writer, reporter)
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          failed = true
+          safely_write(channel, [:worker_error, writer.group_index, Snapshot.failure(e)])
+        ensure
+          failed = shutdown_failed?(channel, slot) || failed
+          restore_worker_runtime(originals)
+          channel.close
+          Process.exit!(failed ? 1 : 0)
+        end
+      end
+
+      def install_worker_runtime(reporter, writer)
+        originals = [$stdout, $stderr, @configuration.instance_variable_get(:@reporter)]
+        $stdout = ProxyIO.new(writer, :stdout)
+        $stderr = ProxyIO.new(writer, :stderr)
+        @configuration.instance_variable_set(:@reporter, reporter)
+        originals
+      end
+
+      def restore_worker_runtime(originals)
+        $stdout, $stderr, reporter = originals
+        @configuration.instance_variable_set(:@reporter, reporter)
+      end
+
+      def run_groups(channel, writer, reporter)
+        loop do
+          channel.write([:request_group])
+          response = channel.read
+          break if response.nil? || response.first == :no_more_groups
+
+          index = response.fetch(1)
+          writer.group_index = index
+          result = @groups.fetch(index).run(reporter)
+          channel.write([:group_done, index, !!result])
+        end
+      end
+
+      def shutdown_failed?(channel, slot)
+        errors = Hooks.run_shutdown(slot)
+        errors.each { safely_write(channel, [:worker_error, nil, Snapshot.failure(_1)]) }
+        errors.any?
+      end
+
+      def safely_write(channel, frame)
+        channel.write(frame)
+      rescue StandardError
+        nil
+      end
+
+      def event_loop
+        active = workers.dup
+        until active.empty?
+          readable, = IO.select(active.map { _1.channel.socket })
+          readable.each do |socket|
+            worker = active.find { _1.channel.socket.equal?(socket) }
+            frame = worker.channel.read
+            frame ? process_frame(worker, frame) : disconnect(worker, active)
+          rescue StandardError => e
+            @failures << e
+            disconnect(worker, active)
+          end
+        end
+        flush_completed
+      end
+
+      def process_frame(worker, frame)
+        case frame.first
+        when :request_group then assign_group(worker)
+        when :event then buffer_event(frame)
+        when :group_done then complete_group(worker, frame)
+        when :worker_error then record_worker_error(worker, frame)
+        else raise Error, "Unknown worker frame: #{frame.first.inspect}"
+        end
+      end
+
+      def assign_group(worker)
+        index = @queue.shift
+        if index
+          worker.assigned = index
+          worker.channel.write([:run_group, index])
+        else
+          worker.assigned = nil
+          worker.channel.write([:no_more_groups])
+        end
+      end
+
+      def buffer_event(frame)
+        _, group_index, sequence, event, payload = frame
+        @buffers[group_index] << [sequence, event, payload]
+      end
+
+      def complete_group(worker, frame)
+        index = frame.fetch(1)
+        @results[index] = frame.fetch(2)
+        @completed[index] = true
+        worker.assigned = nil
+        flush_completed
+      end
+
+      def record_worker_error(worker, frame)
+        @failures << Snapshot.restore_failure(frame.fetch(2))
+        fail_group(worker.assigned || frame[1])
+        worker.assigned = nil
+      end
+
+      def disconnect(worker, active)
+        if worker.assigned
+          @failures << Error.new("Worker #{worker.slot} disconnected while running group #{worker.assigned}")
+        end
+        fail_group(worker.assigned)
+        worker.assigned = nil
+        worker.channel.close
+        active.delete(worker)
+      end
+
+      def fail_group(index)
+        return if index.nil?
+
+        @results[index] = false
+        @completed[index] = true
+        flush_completed
+      end
+
+      def flush_completed
+        while @completed[@next_replay]
+          Array(@buffers.delete(@next_replay)).sort_by(&:first).each do |_, event, payload|
+            @bridge.replay(event, payload)
+          end
+          @next_replay += 1
+        end
+      end
+
+      def reap_workers
+        workers.each do |worker|
+          _, status = Process.waitpid2(worker.pid)
+          worker.status = status
+          worker.completed = true
+          next if status.success?
+          next if @results.compact.include?(false) || @failures.any?
+
+          @failures << Error.new("Worker #{worker.slot} exited with status #{status.exitstatus}")
+        rescue Errno::ECHILD
+          nil
+        end
+        @results.map! { _1.nil? ? false : _1 }
+      end
+
+      def report_failures
+        @failures.each do |failure|
+          @reporter.notify_non_example_exception(failure, "An error occurred in RSpec::Multicore.")
+        end
+      end
+
+      def cleanup
+        workers.each do |worker|
+          next if worker.completed
+
+          worker.channel.close
+          Process.kill("TERM", worker.pid)
+        rescue Errno::ESRCH
+          nil
+        end
+        workers.each do |worker|
+          next if worker.completed
+
+          Process.waitpid(worker.pid)
+          worker.completed = true
+        rescue Errno::ECHILD
+          worker.completed = true
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rspec/multicore/reporter_bridge.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Multicore
+    # Retains the parent's original RSpec groups and examples by stable ID.
+    class ObjectRegistry
+      def initialize(top_groups)
+        groups = top_groups.flat_map { [_1, *_1.descendants] }.uniq(&:id)
+        @groups = groups.to_h { [_1.id, _1] }
+        @examples = groups.flat_map(&:examples).to_h { [_1.id, _1] }
+      end
+
+      def group(id) = @groups.fetch(id)
+      def example(id) = @examples.fetch(id)
+    end
+
+    # Represents a worker exception whose original class cannot be reconstructed.
+    class RemoteFailure < StandardError
+      attr_reader :original_class_name, :cause, :all_exceptions
+
+      def initialize(data, cause: nil, all_exceptions: [])
+        @original_class_name = data.fetch(:class)
+        @cause = cause
+        @all_exceptions = all_exceptions
+        super(data.fetch(:message))
+        set_backtrace(data[:backtrace])
+      end
+    end
+
+    # Converts execution results and exceptions to bounded plain-value state.
+    module Snapshot
+      RESULT_FIELDS = %i[status started_at finished_at run_time pending_message pending_fixed].freeze
+
+      module_function
+
+      def example(example, description: nil)
+        result = example.execution_result
+        data = RESULT_FIELDS.to_h { [_1, encode_value(result.public_send(_1))] }
+        data[:exception] = failure(result.exception)
+        data[:pending_exception] = failure(result.pending_exception)
+
+        { id: example.id, description:, result: data }
+      end
+
+      def apply_example(example, data)
+        description = data[:description]
+        apply_description(example, description) if description && !description.empty?
+
+        result = example.execution_result
+        RESULT_FIELDS.each do |field|
+          result.public_send("#{field}=", decode_value(data.fetch(:result)[field]))
+        end
+        result.exception = restore_failure(data.dig(:result, :exception))
+        result.pending_exception = restore_failure(data.dig(:result, :pending_exception))
+        example
+      end
+
+      def failure(exception, seen = {}.compare_by_identity)
+        return unless exception
+        return cycle_failure(exception) if seen[exception]
+
+        seen = seen.dup
+        seen[exception] = true
+        children = exception.respond_to?(:all_exceptions) ? exception.all_exceptions : []
+        {
+          class: exception.class.name,
+          message: exception.message,
+          backtrace: exception.backtrace,
+          cause: failure(exception.cause, seen),
+          children: children.map { failure(_1, seen) }
+        }
+      end
+
+      def restore_failure(data)
+        return unless data
+
+        cause = restore_failure(data[:cause])
+        children = Array(data[:children]).map { restore_failure(_1) }
+        exception = build_exception(data, children)
+        exception.set_backtrace(data[:backtrace])
+        attach_failure_details(exception, cause, children)
+      rescue StandardError
+        RemoteFailure.new(data, cause:, all_exceptions: children)
+      end
+
+      def encode_value(value) = value.is_a?(Time) ? { time: value.to_f } : value
+
+      def decode_value(value) = value.is_a?(Hash) && value.key?(:time) ? Time.at(value[:time]) : value
+
+      def runtime_description(example)
+        description = example.metadata[:description].to_s
+        return description unless description.empty?
+
+        RSpec::Matchers.generated_description.to_s if generated_description?
+      end
+
+      def apply_description(example, description)
+        metadata = example.metadata
+        if metadata[:description].to_s.empty?
+          metadata[:full_description] = "#{metadata[:full_description]}#{description}"
+        end
+        metadata[:description] = description
+      end
+
+      def generated_description?
+        defined?(RSpec::Matchers) && RSpec::Matchers.respond_to?(:generated_description) &&
+          !RSpec::Matchers.generated_description.to_s.empty?
+      end
+
+      def build_exception(data, children)
+        klass = Object.const_get(data.fetch(:class))
+        raise TypeError unless klass <= Exception
+
+        children.empty? ? klass.new(data.fetch(:message)) : klass.new(children)
+      rescue NameError, TypeError, ArgumentError
+        RemoteFailure.new(data, all_exceptions: children)
+      end
+
+      def attach_failure_details(exception, cause, children)
+        exception.define_singleton_method(:cause) { cause } if cause
+        if children.any? && !exception.respond_to?(:all_exceptions)
+          exception.define_singleton_method(:all_exceptions) { children }
+        end
+        exception
+      end
+
+      def cycle_failure(exception)
+        { class: exception.class.name, message: exception.message, backtrace: exception.backtrace,
+          cause: nil, children: [] }
+      end
+    end
+
+    # Serializes worker reporter events with a shared monotonic sequence.
+    class EventWriter
+      attr_accessor :group_index
+
+      def initialize(channel)
+        @channel = channel
+        @sequence = 0
+        @lock = Mutex.new
+      end
+
+      def emit(event, payload)
+        @lock.synchronize do
+          @sequence += 1
+          @channel.write([:event, group_index, @sequence, event, payload])
+        end
+      end
+    end
+
+    # Exposes only the reporter calls made by RSpec 3.13 example execution.
+    class ReporterProxy
+      GROUP_EVENTS = %i[example_group_started example_group_finished].freeze
+      EXAMPLE_EVENTS = %i[example_started example_finished example_passed example_failed example_pending].freeze
+
+      def initialize(writer)
+        @writer = writer
+        @descriptions = {}
+      end
+
+      GROUP_EVENTS.each do |event|
+        define_method(event) { |group| @writer.emit(event, group.id) }
+      end
+
+      EXAMPLE_EVENTS.each do |event|
+        define_method(event) { |example| @writer.emit(event, snapshot(example)) }
+      end
+
+      def message(message) = @writer.emit(:message, message.to_s)
+      def deprecation(*args) = @writer.emit(:deprecation, args)
+
+      def notify_non_example_exception(exception, context)
+        @writer.emit(:notify_non_example_exception, [Snapshot.failure(exception), context.to_s])
+      end
+
+      def fail_fast_limit_met? = false
+
+      def method_missing(name, *) = raise UnsupportedReporterEvent, "Unsupported RSpec reporter event: #{name}"
+
+      def respond_to_missing?(*, **) = false
+
+      private
+
+      def snapshot(example)
+        original = @descriptions.fetch(example.id) do
+          @descriptions[example.id] = example.metadata[:description].to_s
+        end
+        description = Snapshot.runtime_description(example)
+        description = nil if description == original
+        Snapshot.example(example, description:)
+      end
+    end
+
+    # Sends worker stdout and stderr through the same ordered event writer.
+    class ProxyIO
+      def initialize(writer, stream)
+        @writer = writer
+        @stream = stream
+      end
+
+      def write(data)
+        value = data.to_s
+        return 0 if value.empty?
+
+        @writer.emit(@stream, value)
+        value.bytesize
+      end
+
+      def <<(data) = write(data).then { self }
+      def flush = self
+      def print(*args) = args.each { write(_1) }.then { nil }
+      def printf(format, *args) = write(format % args).then { nil }
+      def puts(*args) = (args.empty? ? write("\n") : args.each { write("#{_1}\n") }).then { nil }
+      def tty? = false
+      alias isatty tty?
+      def sync = true
+
+      def sync=(_value)
+        true
+      end
+
+      def close = nil
+      def closed? = false
+    end
+
+    # Restores parent objects and invokes the real RSpec reporter.
+    class ReporterBridge
+      GROUP_EVENTS = ReporterProxy::GROUP_EVENTS
+      EXAMPLE_EVENTS = ReporterProxy::EXAMPLE_EVENTS
+
+      def initialize(registry, reporter, stdout: $stdout, stderr: $stderr)
+        @registry = registry
+        @reporter = reporter
+        @stdout = stdout
+        @stderr = stderr
+      end
+
+      def replay(event, payload)
+        case event
+        when *GROUP_EVENTS then @reporter.public_send(event, @registry.group(payload))
+        when *EXAMPLE_EVENTS then replay_example(event, payload)
+        when :message then @reporter.message(payload)
+        when :deprecation then @reporter.deprecation(*payload)
+        when :notify_non_example_exception then replay_error(payload)
+        when :stdout then @stdout.write(payload)
+        when :stderr then @stderr.write(payload)
+        else raise UnsupportedReporterEvent, "Unsupported RSpec reporter event: #{event}"
+        end
+      end
+
+      private
+
+      def replay_example(event, payload)
+        example = @registry.example(payload.fetch(:id))
+        @reporter.public_send(event, Snapshot.apply_example(example, payload))
+      end
+
+      def replay_error(payload)
+        @reporter.notify_non_example_exception(Snapshot.restore_failure(payload[0]),
+                                               payload[1])
+      end
+    end
+  end
+end

data/lib/rspec/multicore/runner_patch.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Multicore
+    # Enumerable wrapper that substitutes parallel work only for RSpec's map call.
+    class ParallelGroups
+      include Enumerable
+
+      def initialize(groups, configuration)
+        @groups = groups
+        @configuration = configuration
+      end
+
+      def each(&block) = block ? @groups.each(&block) : enum_for(:each)
+
+      def map
+        return enum_for(:map) unless block_given?
+
+        Pool.new(reporter: @configuration.reporter, configuration: @configuration).run(@groups)
+      end
+    end
+
+    # The only RSpec method override used by rspec-multicore.
+    module RunnerPatch
+      def run_specs(example_groups)
+        return super unless parallelize?(example_groups)
+
+        super(ParallelGroups.new(example_groups, @configuration))
+      end
+
+      private
+
+      def parallelize?(groups)
+        RSpec::Multicore.workers > 1 && groups.size > 1 && Process.respond_to?(:fork) &&
+          !@configuration.fail_fast && !@configuration.dry_run?
+      end
+    end
+  end
+end
+
+RSpec::Core::Runner.prepend(RSpec::Multicore::RunnerPatch) unless RSpec::Core::Runner < RSpec::Multicore::RunnerPatch

data/lib/rspec/multicore/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Multicore
+    VERSION = "0.2.0.pre1"
+  end
+end

data/lib/rspec/multicore.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "rspec/core/runner"
+
+module RSpec
+  module Multicore
+    class Error < StandardError; end
+    class UnsupportedReporterEvent < Error; end
+  end
+end
+
+require_relative "multicore/version"
+require_relative "multicore/configuration"
+require_relative "multicore/channel"
+require_relative "multicore/reporter_bridge"
+require_relative "multicore/pool"
+require_relative "multicore/runner_patch"

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: rspec-multicore
+version: !ruby/object:Gem::Version
+  version: 0.2.0.pre1
+platform: ruby
+authors:
+- Sveta Markovic
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+description: Single-boot, multi-process execution for RSpec on POSIX systems. The
+  parent loads RSpec once, then runs top-level groups in persistent forked workers.
+email:
+- svetam.sd@pm.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/rspec/multicore.rb
+- lib/rspec/multicore/channel.rb
+- lib/rspec/multicore/configuration.rb
+- lib/rspec/multicore/pool.rb
+- lib/rspec/multicore/reporter_bridge.rb
+- lib/rspec/multicore/runner_patch.rb
+- lib/rspec/multicore/version.rb
+homepage: https://github.com/svetam/rspec-multicore
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/svetam/rspec-multicore
+  source_code_uri: https://github.com/svetam/rspec-multicore/tree/master/rspec-multicore
+  changelog_uri: https://github.com/svetam/rspec-multicore/blob/master/rspec-multicore/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Multi-process parallelization for RSpec
+test_files: []