async-signals 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: da817e6b406c01f5ac110ec773c2500ffe01bf6f1715163583a702291512dffc
+  data.tar.gz: 0f0b1eb81532e10ae0b06871b1607458716c021ebc180a100707db1127c6e4d3
+SHA512:
+  metadata.gz: a158082bb2d16860eb6ade8b1ff4dfbb5270feda5b38300b027563de348244af545f7b2e0e547ed134d3ebb0b0dedd14adec3be9477148e6bbfc8bea5ffef2c5
+  data.tar.gz: d22714bf8e6421f7f762c4819fe3fc73c7ac3f702e8ff77c9ee13209341b9fb26448c01149bf4aa88253695a9c612a106afccb0cf3b5b19c01f47720292870d6

data/context/getting-started.md

@@ -0,0 +1,155 @@
+# Getting Started
+
+This guide explains how to get started with `async-signals`.
+
+## Installation
+
+Add the gem to your project:
+
+```bash
+$ bundle add async-signals
+```
+
+Then require it in your application:
+
+```ruby
+require "async/signals"
+```
+
+## Core Concepts
+
+Ruby signal handlers are process-wide. Calling `Signal.trap` for the same signal in two different parts of an application replaces the previous trap, which makes it easy for libraries and application code to accidentally interfere with each other.
+
+`async-signals` provides a small coordination layer around `Signal.trap`:
+
+- {ruby Async::Signals::Handlers} represents a configurable set of signal handlers for one consumer.
+- {ruby Async::Signals::Controller} owns the process-wide `Signal.trap` entries while handler sets are installed.
+- {ruby Async::Signals.install} installs a handler set using the default process-wide controller.
+- {ruby Async::Signals.reset!} removes all active handlers and restores the previous signal traps.
+
+Each handler set can trap or ignore signals independently. When multiple handler sets trap the same signal, `async-signals` installs one Ruby signal trap and dispatches the signal to each active handler.
+
+## Usage
+
+`async-signals` is useful when multiple parts of the same process need to observe or ignore signals without replacing each other's `Signal.trap` handlers.
+
+### Handling Shutdown Signals
+
+Use a handler set when one part of your application wants to respond to one or more signals without replacing traps installed by other code.
+
+```ruby
+require "async/signals"
+
+handlers = Async::Signals::Handlers.new
+
+handlers.trap(:TERM) do |signal|
+	puts "Received signal: #{signal}"
+end
+
+Async::Signals.install(handlers) do
+	# Signal handlers are active here.
+	sleep
+end
+```
+
+When the block exits, the handler set is removed and any previous signal trap is restored.
+
+### Multiple Consumers
+
+Multiple parts of an application can listen for the same signal. This is useful when a service, supervisor, and application component each need to observe shutdown signals without taking ownership of the process-wide trap.
+
+```ruby
+require "async/signals"
+
+supervisor = Async::Signals::Handlers.new
+supervisor.trap(:TERM) do
+	puts "Stopping supervisor..."
+end
+
+application = Async::Signals::Handlers.new
+application.trap(:TERM) do
+	puts "Stopping application..."
+end
+
+Async::Signals.install(supervisor) do
+	Async::Signals.install(application) do
+		Process.kill(:TERM, Process.pid)
+	end
+end
+```
+
+Both handlers are invoked for the same signal while both handler sets are installed.
+
+### Ignoring Signals
+
+Use {ruby Async::Signals::Handlers#ignore} when one consumer needs a signal to be ignored while it is installed. Ignoring a signal does not suppress handlers installed by other handler sets for the same signal.
+
+```ruby
+require "async/signals"
+
+ignored = Async::Signals::Handlers.new
+ignored.ignore(:INT)
+
+handled = Async::Signals::Handlers.new
+handled.trap(:INT) do
+	puts "Still handled by another consumer."
+end
+
+Async::Signals.install(ignored) do
+	Async::Signals.install(handled) do
+		Process.kill(:INT, Process.pid)
+	end
+end
+```
+
+If no active handler set traps the signal, the process-wide trap is set to ignore it for the duration of the installed ignore handler.
+
+### Manual Registration
+
+You can install handlers without a block when the handler lifetime is managed by a longer-lived object. The returned registration can be closed more than once.
+
+```ruby
+require "async/signals"
+
+handlers = Async::Signals::Handlers.new
+handlers.trap(:HUP) do
+	puts "Reloading..."
+end
+
+registration = Async::Signals.install(handlers)
+
+begin
+	# Run the application.
+	sleep
+ensure
+	registration.close
+end
+```
+
+The installed handlers are snapshotted when they are installed. Later changes to the handler set do not affect an existing registration.
+
+## Forking
+
+Signal traps are inherited across `fork`. On Ruby implementations that support `Process._fork`, `async-signals` automatically resets inherited signal state in the forked child so the child does not keep handler registrations from the parent process.
+
+If you need to clear all active handler sets explicitly, call:
+
+```ruby
+Async::Signals.reset!
+```
+
+This restores the process-wide signal traps that were active before `async-signals` installed its handlers.
+
+## Best Practices
+
+Use block-form installation when possible so registrations are closed automatically. Use manual registrations only when another object clearly owns the handler lifetime.
+
+Avoid calling `Signal.trap` for the same signals while `async-signals` handlers are installed. Direct calls to `Signal.trap` replace process-wide traps and can bypass the controller.
+
+Keep signal handlers thread safe. Ruby implementations may dispatch signal traps from an implementation-specific thread, so handlers should avoid mutating shared state directly. Prefer doing minimal work in the handler and forwarding the event to a thread-safe mechanism such as `Thread::Queue`.
+
+## Troubleshooting
+
+If a handler is not invoked, check that the handler set is installed at the time the signal is delivered. Handler sets are only active inside the `Async::Signals.install` block, or until the returned registration is closed.
+
+If a previous signal trap does not run after installation exits, make sure the registration was closed. Block-form installation handles this automatically.

data/context/index.yaml

@@ -0,0 +1,11 @@
+# Automatically generated context index for Utopia::Project guides.
+# Do not edit then files in this directory directly, instead edit the guides and then run `bake utopia:project:agent:context:update`.
+---
+description: Composable process signal handling for Ruby.
+metadata:
+  documentation_uri: https://socketry.github.io/async-signals/
+  source_code_uri: https://github.com/socketry/async-signals.git
+files:
+- path: getting-started.md
+  title: Getting Started
+  description: This guide explains how to get started with `async-signals`.

data/guides/getting-started/readme.md

@@ -0,0 +1,155 @@
+# Getting Started
+
+This guide explains how to get started with `async-signals`.
+
+## Installation
+
+Add the gem to your project:
+
+```bash
+$ bundle add async-signals
+```
+
+Then require it in your application:
+
+```ruby
+require "async/signals"
+```
+
+## Core Concepts
+
+Ruby signal handlers are process-wide. Calling `Signal.trap` for the same signal in two different parts of an application replaces the previous trap, which makes it easy for libraries and application code to accidentally interfere with each other.
+
+`async-signals` provides a small coordination layer around `Signal.trap`:
+
+- {ruby Async::Signals::Handlers} represents a configurable set of signal handlers for one consumer.
+- {ruby Async::Signals::Controller} owns the process-wide `Signal.trap` entries while handler sets are installed.
+- {ruby Async::Signals.install} installs a handler set using the default process-wide controller.
+- {ruby Async::Signals.reset!} removes all active handlers and restores the previous signal traps.
+
+Each handler set can trap or ignore signals independently. When multiple handler sets trap the same signal, `async-signals` installs one Ruby signal trap and dispatches the signal to each active handler.
+
+## Usage
+
+`async-signals` is useful when multiple parts of the same process need to observe or ignore signals without replacing each other's `Signal.trap` handlers.
+
+### Handling Shutdown Signals
+
+Use a handler set when one part of your application wants to respond to one or more signals without replacing traps installed by other code.
+
+```ruby
+require "async/signals"
+
+handlers = Async::Signals::Handlers.new
+
+handlers.trap(:TERM) do |signal|
+	puts "Received signal: #{signal}"
+end
+
+Async::Signals.install(handlers) do
+	# Signal handlers are active here.
+	sleep
+end
+```
+
+When the block exits, the handler set is removed and any previous signal trap is restored.
+
+### Multiple Consumers
+
+Multiple parts of an application can listen for the same signal. This is useful when a service, supervisor, and application component each need to observe shutdown signals without taking ownership of the process-wide trap.
+
+```ruby
+require "async/signals"
+
+supervisor = Async::Signals::Handlers.new
+supervisor.trap(:TERM) do
+	puts "Stopping supervisor..."
+end
+
+application = Async::Signals::Handlers.new
+application.trap(:TERM) do
+	puts "Stopping application..."
+end
+
+Async::Signals.install(supervisor) do
+	Async::Signals.install(application) do
+		Process.kill(:TERM, Process.pid)
+	end
+end
+```
+
+Both handlers are invoked for the same signal while both handler sets are installed.
+
+### Ignoring Signals
+
+Use {ruby Async::Signals::Handlers#ignore} when one consumer needs a signal to be ignored while it is installed. Ignoring a signal does not suppress handlers installed by other handler sets for the same signal.
+
+```ruby
+require "async/signals"
+
+ignored = Async::Signals::Handlers.new
+ignored.ignore(:INT)
+
+handled = Async::Signals::Handlers.new
+handled.trap(:INT) do
+	puts "Still handled by another consumer."
+end
+
+Async::Signals.install(ignored) do
+	Async::Signals.install(handled) do
+		Process.kill(:INT, Process.pid)
+	end
+end
+```
+
+If no active handler set traps the signal, the process-wide trap is set to ignore it for the duration of the installed ignore handler.
+
+### Manual Registration
+
+You can install handlers without a block when the handler lifetime is managed by a longer-lived object. The returned registration can be closed more than once.
+
+```ruby
+require "async/signals"
+
+handlers = Async::Signals::Handlers.new
+handlers.trap(:HUP) do
+	puts "Reloading..."
+end
+
+registration = Async::Signals.install(handlers)
+
+begin
+	# Run the application.
+	sleep
+ensure
+	registration.close
+end
+```
+
+The installed handlers are snapshotted when they are installed. Later changes to the handler set do not affect an existing registration.
+
+## Forking
+
+Signal traps are inherited across `fork`. On Ruby implementations that support `Process._fork`, `async-signals` automatically resets inherited signal state in the forked child so the child does not keep handler registrations from the parent process.
+
+If you need to clear all active handler sets explicitly, call:
+
+```ruby
+Async::Signals.reset!
+```
+
+This restores the process-wide signal traps that were active before `async-signals` installed its handlers.
+
+## Best Practices
+
+Use block-form installation when possible so registrations are closed automatically. Use manual registrations only when another object clearly owns the handler lifetime.
+
+Avoid calling `Signal.trap` for the same signals while `async-signals` handlers are installed. Direct calls to `Signal.trap` replace process-wide traps and can bypass the controller.
+
+Keep signal handlers thread safe. Ruby implementations may dispatch signal traps from an implementation-specific thread, so handlers should avoid mutating shared state directly. Prefer doing minimal work in the handler and forwarding the event to a thread-safe mechanism such as `Thread::Queue`.
+
+## Troubleshooting
+
+If a handler is not invoked, check that the handler set is installed at the time the signal is delivered. Handler sets are only active inside the `Async::Signals.install` block, or until the returned registration is closed.
+
+If a previous signal trap does not run after installation exits, make sure the registration was closed. Block-form installation handles this automatically.

data/guides/links.yaml

@@ -0,0 +1,2 @@
+getting-started:
+  order: 1

data/lib/async/signals/controller.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "thread"
+
+require_relative "handlers"
+
+module Async
+	module Signals
+		# Coordinates process-wide signal handlers for multiple consumers.
+		class Controller
+			# Represents the active handlers for a single process signal.
+			class State
+				# Initialize the signal state.
+				# @parameter previous [Object] The signal handler that was installed before this controller took ownership.
+				# @parameter handlers [Hash(Registration, Proc)] The active handlers for the signal.
+				# @parameter ignored [Hash(Registration, Nil)] The active ignored signals.
+				def initialize(previous, handlers = {}.compare_by_identity.freeze, ignored = {}.compare_by_identity.freeze)
+					@previous = previous
+					@handlers = handlers
+					@ignored = ignored
+				end
+				
+				# @attribute [Object] The signal handler that was installed before this controller took ownership.
+				attr :previous
+				
+				# @attribute [Hash(Registration, Proc)] The active handlers for the signal.
+				attr :handlers
+				
+				# @attribute [Hash(Registration, Nil)] The active ignored signals.
+				attr :ignored
+				
+				# Add a signal handler to this state.
+				# @parameter registration [Registration] The registration that owns the handler.
+				# @parameter handler [Proc | Nil] The handler to add, or `nil` to ignore the signal.
+				# @returns [State] The updated state.
+				def add(registration, handler)
+					if handler
+						handlers = @handlers.dup
+						handlers[registration] = handler
+						
+						State.new(@previous, handlers.freeze, @ignored)
+					else
+						ignored = @ignored.dup
+						ignored[registration] = nil
+						
+						State.new(@previous, @handlers, ignored.freeze)
+					end
+				end
+				
+				# Remove a signal handler from this state.
+				# @parameter registration [Registration] The registration that owns the handler.
+				# @returns [State] The updated state.
+				def remove(registration)
+					if @handlers.key?(registration)
+						handlers = @handlers.dup
+						handlers.delete(registration)
+						
+						return State.new(@previous, handlers.freeze, @ignored)
+					else
+						ignored = @ignored.dup
+						ignored.delete(registration)
+						
+						return State.new(@previous, @handlers, ignored.freeze)
+					end
+				end
+				
+				# Whether this state has any active handlers.
+				# @returns [Boolean] True if no handlers or ignored signals are active.
+				def empty?
+					@handlers.empty? && @ignored.empty?
+				end
+				
+				# The active callable signal handlers.
+				# @returns [Array(Proc)] The active handlers.
+				def callbacks
+					@handlers.values.freeze
+				end
+			end
+			
+			# Represents an installed set of signal handlers.
+			class Registration
+				# Initialize the registration.
+				# @parameter controller [Controller] The controller that owns this registration.
+				# @parameter handlers [Hash(String, Proc | Nil)] The handlers that were installed.
+				def initialize(controller, handlers)
+					@controller = controller
+					@handlers = handlers
+				end
+				
+				# Remove this registration from the controller.
+				def close
+					if handlers = @handlers
+						@handlers = nil
+						@controller.remove(self, handlers)
+					end
+				end
+			end
+			
+			# Initialize the controller.
+			def initialize
+				@mutex = ::Thread::Mutex.new
+				@states = {}
+				@dispatch = {}.freeze
+			end
+			
+			# Install signal handlers.
+			# @parameter handlers [Handlers] The handlers to install.
+			# @yields {|handlers| ...} The block to run while the handlers are installed.
+			# @returns [Registration] The active registration.
+			def install(handlers)
+				installed_handlers = handlers.to_h.freeze
+				registration = Registration.new(self, installed_handlers)
+				
+				@mutex.synchronize do
+					installed_handlers.each do |signal, handler|
+						add(signal, registration, handler)
+					end
+					
+					update_dispatch
+				end
+				
+				if block_given?
+					begin
+						return yield handlers
+					ensure
+						registration.close
+					end
+				else
+					return registration
+				end
+			end
+			
+			# Dispatch a signal to all currently active handlers.
+			# @parameter signal [String] The signal name to dispatch.
+			def dispatch(signal)
+				number = ::Signal.list.fetch(signal)
+				
+				@dispatch[signal]&.each do |handler|
+					begin
+						handler.call(number)
+					rescue Exception => error
+						warn "Async::Signals handler failed: #{error.class}: #{error.message}"
+					end
+				end
+			end
+			
+			# Remove a set of installed handlers.
+			# @parameter registration [Registration] The registration that owns the handlers.
+			# @parameter handlers [Hash(String, Proc | Nil)] The handlers to remove.
+			def remove(registration, handlers)
+				@mutex.synchronize do
+					handlers.each_key do |signal|
+						remove_signal(signal, registration)
+					end
+					
+					update_dispatch
+				end
+			end
+			
+			# Reset all installed signal handlers to their previous signal traps.
+			def reset!
+				@mutex.synchronize do
+					@states.each do |signal, state|
+						::Signal.trap(signal, state.previous)
+					end
+					
+					@states.clear
+					update_dispatch
+				end
+			end
+			
+			private
+			
+			def add(signal, registration, handler)
+				unless state = @states[signal]
+					previous = ::Signal.trap(signal, "IGNORE")
+					state = State.new(previous)
+				end
+				
+				@states[signal] = state.add(registration, handler)
+				
+				update_signal(signal)
+			end
+			
+			def remove_signal(signal, registration)
+				if state = @states[signal]
+					state = state.remove(registration)
+					
+					if state.empty?
+						::Signal.trap(signal, state.previous)
+						@states.delete(signal)
+					else
+						@states[signal] = state
+						update_signal(signal)
+					end
+				end
+			end
+			
+			def update_signal(signal)
+				state = @states.fetch(signal)
+				
+				if state.handlers.empty?
+					::Signal.trap(signal, "IGNORE")
+				else
+					::Signal.trap(signal) do
+						self.dispatch(signal)
+					end
+				end
+			end
+			
+			def update_dispatch
+				@dispatch = @states.each_with_object({}) do |(signal, state), dispatch|
+					unless state.handlers.empty?
+						dispatch[signal] = state.callbacks
+					end
+				end.freeze
+			end
+		end
+	end
+end

data/lib/async/signals/handlers.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+module Async
+	module Signals
+		# Represents a configurable set of signal handlers.
+		class Handlers
+			include Enumerable
+			
+			# Initialize the handlers.
+			def initialize
+				@signals = {}
+			end
+			
+			# Trap a signal while these handlers are installed.
+			# @parameter signal [Symbol | String | Integer] The signal to trap.
+			def trap(signal, &block)
+				@signals[normalize(signal)] = block
+			end
+			
+			# Ignore a signal while these handlers are installed.
+			# @parameter signal [Symbol | String | Integer] The signal to ignore.
+			def ignore(signal)
+				trap(signal)
+			end
+			
+			# Iterate over the configured signal handlers.
+			# @yields {|signal, handler| ...} The signal name and the handler, or `nil` if ignored.
+			def each(&block)
+				@signals.each(&block)
+			end
+			
+			private
+			
+			# Normalize signals so the controller has one portable key per OS signal.
+			# This ensures equivalent forms like `:USR1`, `"USR1"` and `"SIGUSR1"` share
+			# the same installed trap and restoration lifecycle.
+			def normalize(signal)
+				case signal
+				when Integer
+					::Signal.list.invert.fetch(signal) do
+						raise ArgumentError, "unsupported signal number `#{signal}'"
+					end
+				when Symbol, String
+					name = signal.to_s
+					name = name.delete_prefix("SIG")
+					
+					::Signal.list.fetch(name) do
+						raise ArgumentError, "unsupported signal `SIG#{name}'"
+					end
+					
+					name
+				else
+					raise ArgumentError, "bad signal type #{signal.class}"
+				end
+			end
+		end
+	end
+end

data/lib/async/signals/version.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+# @namespace
+module Async
+	# @namespace
+	module Signals
+		VERSION = "0.1.0"
+	end
+end

data/lib/async/signals.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require_relative "signals/version"
+require_relative "signals/handlers"
+require_relative "signals/controller"
+
+module Async
+	# Provides composable process signal handling.
+	module Signals
+		CONTROLLER = Controller.new
+		
+		# The default process-wide signal controller.
+		# @returns [Controller] The default signal controller.
+		def self.controller
+			CONTROLLER
+		end
+		
+		# Install signal handlers using the process-wide signal controller.
+		# @parameter handlers [Handlers] The handlers to install.
+		# @returns [Controller::Registration] The active registration.
+		def self.install(handlers, &block)
+			CONTROLLER.install(handlers, &block)
+		end
+		
+		# Reset the process-wide signal controller.
+		# @returns [void]
+		def self.reset!
+			CONTROLLER.reset!
+		end
+		
+		if ::Process.respond_to?(:_fork)
+			# Resets inherited signal state in forked children.
+			module ForkHook
+				# Fork the current process and reset inherited signal state in the child.
+				def _fork
+					pid = super
+					
+					if pid == 0
+						Async::Signals.reset!
+					end
+					
+					return pid
+				end
+			end
+			
+			::Process.singleton_class.prepend(ForkHook)
+		end
+	end
+end

data/license.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright, 2026, by Samuel Williams.  
+
+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,62 @@
+# Async::Signals
+
+Composable process signal handling for Ruby.
+
+[![Development Status](https://github.com/socketry/async-signals/workflows/Test/badge.svg)](https://github.com/socketry/async-signals/actions?workflow=Test)
+
+## Features
+
+  - Coordinates process-wide signal traps across multiple consumers.
+  - Supports overlapping signal handlers without replacing each other.
+  - Supports scoped ignore handlers for specific signals.
+  - Restores previous signal traps when handlers are removed.
+  - Resets inherited signal state in forked children on Ruby implementations with `Process._fork`.
+  - Documents thread-safe signal handler design for portable signal delivery.
+
+## Usage
+
+Please see the [project documentation](https://socketry.github.io/async-signals/) for more details.
+
+  - [Getting Started](https://socketry.github.io/async-signals/guides/getting-started/index) - This guide explains how to get started with `async-signals`.
+
+## Releases
+
+Please see the [project releases](https://socketry.github.io/async-signals/releases/index) for all releases.
+
+### v0.1.0
+
+  - Initial release.
+
+## Contributing
+
+We welcome contributions to this project.
+
+1.  Fork it.
+2.  Create your feature branch (`git checkout -b my-new-feature`).
+3.  Commit your changes (`git commit -am 'Add some feature'`).
+4.  Push to the branch (`git push origin my-new-feature`).
+5.  Create new Pull Request.
+
+### Running Tests
+
+To run the test suite:
+
+``` shell
+bundle exec sus
+```
+
+### Making Releases
+
+To make a new release:
+
+``` shell
+bundle exec bake gem:release:patch # or minor or major
+```
+
+### Developer Certificate of Origin
+
+In order to protect users of this project, we require all contributors to comply with the [Developer Certificate of Origin](https://developercertificate.org/). This ensures that all contributions are properly licensed and attributed.
+
+### Community Guidelines
+
+This project is best served by a collaborative and respectful environment. Treat each other professionally, respect differing viewpoints, and engage constructively. Harassment, discrimination, or harmful behavior is not tolerated. Communicate clearly, listen actively, and support one another. If any issues arise, please inform the project maintainers.

data/releases.md

@@ -0,0 +1,5 @@
+# Releases
+
+## v0.1.0
+
+  - Initial release.

data.tar.gz.sig

@@ -0,0 +1,3 @@
+5
+���}��yBYj����Ur��`�^���x3�+f*����q�m���&�KN�n�����Şap�>UfPա��s��9�T1f �+n۵rz3Î��Ԇ��d�a}�a[N�o�s�3��D/w¨F~2��"��>͎8���c�3�h�����d��
+k�obI��E�F7yB���BF+C�:����,�ƥ�:k�ۻc�W�ry��QQRU�u�	��:�d���	9w}q��2���6�@zy�.�<��?c�,n��H�`N6۹�/�m�7Y�B���z�SK5�$��T�~e��)-��-Kf����_%�O��<��L�u�K�1�;ޠS6:��-

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: async-signals
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Samuel Williams
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIE2DCCA0CgAwIBAgIBATANBgkqhkiG9w0BAQsFADBhMRgwFgYDVQQDDA9zYW11
+  ZWwud2lsbGlhbXMxHTAbBgoJkiaJk/IsZAEZFg1vcmlvbnRyYW5zZmVyMRIwEAYK
+  CZImiZPyLGQBGRYCY28xEjAQBgoJkiaJk/IsZAEZFgJuejAeFw0yMjA4MDYwNDUz
+  MjRaFw0zMjA4MDMwNDUzMjRaMGExGDAWBgNVBAMMD3NhbXVlbC53aWxsaWFtczEd
+  MBsGCgmSJomT8ixkARkWDW9yaW9udHJhbnNmZXIxEjAQBgoJkiaJk/IsZAEZFgJj
+  bzESMBAGCgmSJomT8ixkARkWAm56MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIB
+  igKCAYEAomvSopQXQ24+9DBB6I6jxRI2auu3VVb4nOjmmHq7XWM4u3HL+pni63X2
+  9qZdoq9xt7H+RPbwL28LDpDNflYQXoOhoVhQ37Pjn9YDjl8/4/9xa9+NUpl9XDIW
+  sGkaOY0eqsQm1pEWkHJr3zn/fxoKPZPfaJOglovdxf7dgsHz67Xgd/ka+Wo1YqoE
+  e5AUKRwUuvaUaumAKgPH+4E4oiLXI4T1Ff5Q7xxv6yXvHuYtlMHhYfgNn8iiW8WN
+  XibYXPNP7NtieSQqwR/xM6IRSoyXKuS+ZNGDPUUGk8RoiV/xvVN4LrVm9upSc0ss
+  RZ6qwOQmXCo/lLcDUxJAgG95cPw//sI00tZan75VgsGzSWAOdjQpFM0l4dxvKwHn
+  tUeT3ZsAgt0JnGqNm2Bkz81kG4A2hSyFZTFA8vZGhp+hz+8Q573tAR89y9YJBdYM
+  zp0FM4zwMNEUwgfRzv1tEVVUEXmoFCyhzonUUw4nE4CFu/sE3ffhjKcXcY//qiSW
+  xm4erY3XAgMBAAGjgZowgZcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0O
+  BBYEFO9t7XWuFf2SKLmuijgqR4sGDlRsMC4GA1UdEQQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MC4GA1UdEgQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MA0GCSqGSIb3DQEBCwUAA4IBgQB5sxkE
+  cBsSYwK6fYpM+hA5B5yZY2+L0Z+27jF1pWGgbhPH8/FjjBLVn+VFok3CDpRqwXCl
+  xCO40JEkKdznNy2avOMra6PFiQyOE74kCtv7P+Fdc+FhgqI5lMon6tt9rNeXmnW/
+  c1NaMRdxy999hmRGzUSFjozcCwxpy/LwabxtdXwXgSay4mQ32EDjqR1TixS1+smp
+  8C/NCWgpIfzpHGJsjvmH2wAfKtTTqB9CVKLCWEnCHyCaRVuKkrKjqhYCdmMBqCws
+  JkxfQWC+jBVeG9ZtPhQgZpfhvh+6hMhraUYRQ6XGyvBqEUe+yo6DKIT3MtGE2+CP
+  eX9i9ZWBydWb8/rvmwmX2kkcBbX0hZS1rcR593hGc61JR6lvkGYQ2MYskBveyaxt
+  Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
+  voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
+  -----END CERTIFICATE-----
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- context/getting-started.md
+- context/index.yaml
+- guides/getting-started/readme.md
+- guides/links.yaml
+- lib/async/signals.rb
+- lib/async/signals/controller.rb
+- lib/async/signals/handlers.rb
+- lib/async/signals/version.rb
+- license.md
+- readme.md
+- releases.md
+homepage: https://github.com/socketry/async-signals
+licenses:
+- MIT
+metadata:
+  documentation_uri: https://socketry.github.io/async-signals/
+  source_code_uri: https://github.com/socketry/async-signals.git
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Composable process signal handling for Ruby.
+test_files: []