ractor-pool 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 20f4d6392022d30bb6c629bcf5fc7e1de3cbc586a6bd111dfd1771a3ceb47845
+  data.tar.gz: c653cd83e3b363471d671e2515bf6597f19bb27190f80a6c89571ae97adfbd19
+SHA512:
+  metadata.gz: 97cdc940a685d8cf4522fa5b7e88ca64ba395eace72cbd84535d1b0021f03c1e8ac3823ac55b875390f7b5993832ee1b1aee706666a9f141edad3412c37a027f
+  data.tar.gz: e50b79953aa3521285c76e756c64e1342032ae3f299ca5f712f5785fec2ed3bb1189c9074267137978c1d9e35a2f2214c72fbc7bb809cc3ed1c75770024e5f98

data/.buildkite/pipeline.yml

@@ -0,0 +1,21 @@
+steps:
+  - label: ":ruby: Ruby master-dev"
+    commands:
+      - apt-get update && apt-get install -y libyaml-dev
+      - bundle install
+      - bundle exec rake
+    plugins:
+      - docker#v5.13.0:
+          image: "rubylang/ruby:master-dev"
+
+  # - label: ":ruby: Ruby {{matrix.ruby}}"
+  #   commands:
+  #     - bundle install
+  #     - bundle exec rake
+  #   matrix:
+  #     setup:
+  #       ruby:
+  #         - 3.5.0
+  #   plugins:
+  #     - docker#v5.13.0:
+  #         image: "ruby:{{matrix.ruby}}"

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-10-22
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Joshua Young
+
+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,70 @@
+# RactorPool
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+## Usage
+
+Calculating Fibonacci numbers in parallel:
+
+```ruby
+fib_worker = lambda do |index|
+  first, second = 0, 1
+  index.times { first, second = second, first + second }
+  [index, first]
+end
+results = []
+pool = RactorPool.new(size: 2, worker: fib_worker) { |result| results << result }
+
+25.times { |index| pool << index }
+pool.shutdown
+
+results.sort_by! { |index, _value| index }
+results.each { |index, value| puts "fib(#{index}) = #{value}" }
+
+#=> fib(0) = 0
+#=> fib(1) = 1
+#=> fib(2) = 1
+#=> fib(3) = 2
+#=> ...
+#=> fib(21) = 10946
+#=> fib(22) = 17711
+#=> fib(23) = 28657
+#=> fib(24) = 46368
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rake test` to run the
+tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/joshuay03/ractor-pool. This project is
+intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of
+conduct](https://github.com/joshuay03/ractor-pool/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the RactorPool project's codebases, issue trackers, chat rooms and mailing lists is expected to
+follow the [code of conduct](https://github.com/joshuay03/ractor-pool/blob/main/CODE_OF_CONDUCT.md).
+
+## Acknowledgements
+
+Thanks to [Gleb Sinyavskiy (zhulik)](https://github.com/zhulik) for graciously transferring ownership of the
+`ractor_pool` gem name, enabling this gem to be published as `ractor-pool`.

data/Rakefile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+namespace :rbs do
+  task :generate do
+    puts
+    sh "rm -rf sig && rbs-inline --opt-out --output lib && echo"
+  end
+end
+
+task build: :"rbs:generate"
+task default: %i[rbs:generate test]

data/lib/ractor-pool/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class RactorPool
+  VERSION = "0.1.0"
+end

data/lib/ractor-pool.rb

@@ -0,0 +1,266 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+require "warning"
+require "atomic-ruby/atom"
+
+Warning.ignore(/Ractor is experimental/, __FILE__)
+
+# A thread-safe, lock-free pool of Ractor workers with a coordinator pattern for distributing work.
+#
+# RactorPool manages a fixed number of worker ractors that process work items in parallel.
+# Work is distributed on-demand to idle workers, ensuring efficient utilisation. Results
+# are collected and passed to a result handler running in a separate thread.
+#
+# @example Basic usage
+#   results = []
+#   worker = -> (work) { work * 2 }
+#   pool = RactorPool.new(size: 4, worker: worker) { |result| results << result }
+#
+#   10.times { |index| pool << index }
+#   pool.shutdown
+#
+#   p results #=> [2, 0, 6, 4, 14, 10, 8, 16, 18, 12]
+#
+# @example Without result handler
+#   counter = Atom.new(0)
+#   worker = lambda do |work|
+#     counter.swap { |current_value| current_value + 1 }
+#     work * 2
+#   end
+#   pool = RactorPool.new(size: 4, worker: worker)
+#
+#   10.times { |index| pool << index }
+#   pool.shutdown
+#
+#   p counter.value #=> 10
+#
+# @see https://docs.ruby-lang.org/en/master/ractor_md.html Ractor Guide
+# @see https://docs.ruby-lang.org/en/master/Ractor.html Ractor API
+# @see https://docs.ruby-lang.org/en/master/Ractor/Port.html Ractor::Port API
+# @see https://github.com/joshuay03/atomic-ruby atomic-ruby gem
+#
+class RactorPool
+  class Error < StandardError; end
+
+  class EnqueuedWorkAfterShutdownError < Error
+    # @rbs () -> String
+    def message = "cannot queue work after shutdown"
+  end
+
+  SHUTDOWN = :shutdown
+
+  # @rbs @size: Integer
+  # @rbs @worker: ^(untyped) -> untyped
+  # @rbs @name: String?
+  # @rbs @result_handler: (^(untyped) -> void | nil)
+  # @rbs @state: Atom[Hash[Symbol, bool | Integer]]
+  # @rbs @result_port: Ractor::Port?
+  # @rbs @coordinator: Ractor
+  # @rbs @workers: Array[Ractor]
+  # @rbs @collector: Thread?
+
+  # Creates a new RactorPool with the specified number of workers.
+  #
+  # @param size [Integer] number of worker ractors to create
+  # @param worker [Proc] a shareable lambda that processes each work item
+  # @param name [String, nil] optional name for the pool, used in thread/ractor names
+  # @yieldparam result [Object] the result returned by the worker lambda
+  # @return [void]
+  # @raise [ArgumentError] if size is not a positive integer
+  # @raise [ArgumentError] if worker is not a lambda
+  #
+  # @example With result handler
+  #   pool = RactorPool.new(size: 4, worker: -> { it }) { |result| puts result }
+  #
+  # @example Without result handler
+  #   pool = RactorPool.new(size: 4, worker: -> { it })
+  #
+  # @rbs (?size: Integer, worker: ^(untyped) -> untyped, ?name: String?) ?{ (untyped) -> void } -> void
+  def initialize(size: Etc.nprocessors, worker:, name: nil, &result_handler)
+    raise ArgumentError, "size must be a positive Integer" unless size.is_a?(Integer) && size > 0
+    raise ArgumentError, "worker must be a lambda Proc" unless worker.lambda?
+
+    @size = size
+    @worker = Ractor.shareable_lambda(&worker)
+    @name = name
+    @result_handler = result_handler
+
+    @state = Atom.new(in_flight: 0, shutdown: false)
+
+    @result_port = Ractor::Port.new if result_handler
+    @coordinator = start_coordinator if size > 1
+    @workers = start_workers
+    @collector = start_collector
+  end
+
+  # Queues a work item to be processed by an available worker.
+  #
+  # @param work [Object] the work item to process
+  # @return [void]
+  # @raise [EnqueuedWorkAfterShutdownError] if the pool has been shut down
+  #
+  # @example
+  #   pool << "http://example.com/page1"
+  #   pool << "http://example.com/page2"
+  #
+  # @rbs (untyped work) -> void
+  def <<(work)
+    state = @state.swap do |current_state|
+      if current_state[:shutdown]
+        current_state
+      else
+        current_state.merge(in_flight: current_state[:in_flight] + 1)
+      end
+    end
+    raise EnqueuedWorkAfterShutdownError if state[:shutdown]
+
+    begin
+      (@coordinator || @workers.first).send(work, move: true)
+    ensure
+      @state.swap do |current_state|
+        current_state.merge(in_flight: current_state[:in_flight] - 1)
+      end
+    end
+  end
+
+  # Shuts down the pool gracefully.
+  #
+  # This method:
+  # 1. Prevents new work from being queued
+  # 2. Waits for all in-flight work submissions to complete
+  # 3. Allows all queued work to complete
+  # 4. Waits for all workers to finish
+  # 5. Waits for all results to be processed
+  #
+  # This method is idempotent and can be called multiple times safely.
+  #
+  # @return [void]
+  #
+  # @example
+  #   pool.shutdown
+  #
+  # @rbs () -> void
+  def shutdown
+    already_shutdown = false
+    @state.swap do |current_state|
+      if current_state[:shutdown]
+        already_shutdown = true
+        current_state
+      else
+        current_state.merge(shutdown: true)
+      end
+    end
+    return if already_shutdown
+
+    Thread.pass until @state.value[:in_flight] == 0
+
+    @coordinator&.send(SHUTDOWN, move: true) ||
+      (@workers.first.send(SHUTDOWN, move: true) && @result_port&.send(SHUTDOWN, move: true))
+    @workers.each(&:join)
+    @coordinator&.join
+    @collector&.join
+  end
+
+  private
+
+  # @rbs () -> Ractor
+  def start_coordinator
+    ractor_name = String.new("#{self.class.name} coordinator ractor")
+    ractor_name << " for #{@name}" if @name
+
+    Ractor.new(@size, @result_port, name: ractor_name) do |worker_count, result_port|
+      work_queue = []
+      waiting_workers = []
+      shutdown_received = false
+      workers_finished = 0
+
+      loop do
+        case data = Ractor.receive
+        when SHUTDOWN
+          shutdown_received = true
+
+          workers_finished += waiting_workers.size
+          waiting_workers.each { |worker| worker.send(SHUTDOWN, move: true) }
+          waiting_workers.clear
+          if workers_finished == worker_count
+            result_port&.send(SHUTDOWN, move: true)
+            break
+          end
+
+        when Ractor
+          ractor = data
+
+          if work_queue.any?
+            ractor.send(work_queue.shift, move: true)
+          elsif shutdown_received
+            ractor.send(SHUTDOWN, move: true)
+
+            workers_finished += 1
+            if workers_finished == worker_count
+              result_port&.send(SHUTDOWN, move: true)
+              break
+            end
+          else
+            waiting_workers << ractor
+          end
+
+        else
+          work = data
+
+          if waiting_workers.any?
+            waiting_workers.shift.send(work, move: true)
+          else
+            work_queue << work
+          end
+        end
+      end
+    end
+  end
+
+  # @rbs () -> Array[Ractor]
+  def start_workers
+    @size.times.map do |index|
+      ractor_name = String.new("#{self.class.name} ractor #{index}")
+      ractor_name << " for #{@name}" if @name
+
+      Ractor.new(@worker, @coordinator, @result_port, name: ractor_name) do |worker, coordinator, result_port|
+        loop do
+          coordinator&.send(Ractor.current, move: true)
+
+          work = Ractor.receive
+          break if work == SHUTDOWN
+
+          begin
+            result = worker.call(work)
+
+            result_port&.send(result, move: true)
+          rescue => error
+            puts "#{Ractor.current.name} rescued:"
+            puts "#{error.class}: #{error.message}"
+            puts error.backtrace.join("\n")
+          end
+        end
+      end
+    end
+  end
+
+  # @rbs () -> Thread?
+  def start_collector
+    return unless @result_handler
+
+    thread_name = String.new("#{self.class.name} collector thread")
+    thread_name << " for #{@name}" if @name
+
+    Thread.new(@result_port, @result_handler, thread_name) do |result_port, result_handler, name|
+      Thread.current.name = name
+
+      loop do
+        result = result_port.receive
+        break if result == SHUTDOWN
+
+        result_handler.call(result)
+      end
+    end
+  end
+end

data/sig/generated/ractor-pool/version.rbs

@@ -0,0 +1,5 @@
+# Generated from lib/ractor-pool/version.rb with RBS::Inline
+
+class RactorPool
+  VERSION: ::String
+end

data/sig/generated/ractor-pool.rbs

@@ -0,0 +1,126 @@
+# Generated from lib/ractor-pool.rb with RBS::Inline
+
+# A thread-safe, lock-free pool of Ractor workers with a coordinator pattern for distributing work.
+#
+# RactorPool manages a fixed number of worker ractors that process work items in parallel.
+# Work is distributed on-demand to idle workers, ensuring efficient utilisation. Results
+# are collected and passed to a result handler running in a separate thread.
+#
+# @example Basic usage
+#   results = []
+#   worker = -> (work) { work * 2 }
+#   pool = RactorPool.new(size: 4, worker: worker) { |result| results << result }
+#
+#   10.times { |index| pool << index }
+#   pool.shutdown
+#
+#   p results #=> [2, 0, 6, 4, 14, 10, 8, 16, 18, 12]
+#
+# @example Without result handler
+#   counter = Atom.new(0)
+#   worker = lambda do |work|
+#     counter.swap { |current_value| current_value + 1 }
+#     work * 2
+#   end
+#   pool = RactorPool.new(size: 4, worker: worker)
+#
+#   10.times { |index| pool << index }
+#   pool.shutdown
+#
+#   p counter.value #=> 10
+#
+# @see https://docs.ruby-lang.org/en/master/ractor_md.html Ractor Guide
+# @see https://docs.ruby-lang.org/en/master/Ractor.html Ractor API
+# @see https://docs.ruby-lang.org/en/master/Ractor/Port.html Ractor::Port API
+# @see https://github.com/joshuay03/atomic-ruby atomic-ruby gem
+class RactorPool
+  class Error < StandardError
+  end
+
+  class EnqueuedWorkAfterShutdownError < Error
+    # @rbs () -> String
+    def message: () -> String
+  end
+
+  SHUTDOWN: ::Symbol
+
+  @collector: Thread?
+
+  @workers: Array[Ractor]
+
+  @coordinator: Ractor
+
+  @result_port: Ractor::Port?
+
+  @state: Atom[Hash[Symbol, bool | Integer]]
+
+  @result_handler: ^(untyped) -> void | nil
+
+  @name: String?
+
+  @worker: ^(untyped) -> untyped
+
+  @size: Integer
+
+  # Creates a new RactorPool with the specified number of workers.
+  #
+  # @param size [Integer] number of worker ractors to create
+  # @param worker [Proc] a shareable lambda that processes each work item
+  # @param name [String, nil] optional name for the pool, used in thread/ractor names
+  # @yieldparam result [Object] the result returned by the worker lambda
+  # @return [void]
+  # @raise [ArgumentError] if size is not a positive integer
+  # @raise [ArgumentError] if worker is not a lambda
+  #
+  # @example With result handler
+  #   pool = RactorPool.new(size: 4, worker: -> { it }) { |result| puts result }
+  #
+  # @example Without result handler
+  #   pool = RactorPool.new(size: 4, worker: -> { it })
+  #
+  # @rbs (?size: Integer, worker: ^(untyped) -> untyped, ?name: String?) ?{ (untyped) -> void } -> void
+  def initialize: (worker: ^(untyped) -> untyped, ?size: Integer, ?name: String?) ?{ (untyped) -> void } -> void
+
+  # Queues a work item to be processed by an available worker.
+  #
+  # @param work [Object] the work item to process
+  # @return [void]
+  # @raise [EnqueuedWorkAfterShutdownError] if the pool has been shut down
+  #
+  # @example
+  #   pool << "http://example.com/page1"
+  #   pool << "http://example.com/page2"
+  #
+  # @rbs (untyped work) -> void
+  def <<: (untyped work) -> void
+
+  # Shuts down the pool gracefully.
+  #
+  # This method:
+  # 1. Prevents new work from being queued
+  # 2. Waits for all in-flight work submissions to complete
+  # 3. Allows all queued work to complete
+  # 4. Waits for all workers to finish
+  # 5. Waits for all results to be processed
+  #
+  # This method is idempotent and can be called multiple times safely.
+  #
+  # @return [void]
+  #
+  # @example
+  #   pool.shutdown
+  #
+  # @rbs () -> void
+  def shutdown: () -> void
+
+  private
+
+  # @rbs () -> Ractor
+  def start_coordinator: () -> Ractor
+
+  # @rbs () -> Array[Ractor]
+  def start_workers: () -> Array[Ractor]
+
+  # @rbs () -> Thread?
+  def start_collector: () -> Thread?
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: ractor-pool
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Joshua Young
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: warning
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: atomic-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+email:
+- djry1999@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".buildkite/pipeline.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/ractor-pool.rb
+- lib/ractor-pool/version.rb
+- sig/generated/ractor-pool.rbs
+- sig/generated/ractor-pool/version.rbs
+homepage: https://github.com/joshuay03/ractor-pool
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/joshuay03/ractor-pool
+  changelog_uri: https://github.com/joshuay03/ractor-pool/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.5.0.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.0.dev
+specification_version: 4
+summary: A thread-safe, lock-free pool of Ractor workers with a coordinator pattern
+  for distributing work
+test_files: []