async 2.39.0 → 2.44.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d8427e86e8ab22c81e41dd6e7df7bd79087e3fa72ce786f07ae7b65d9d94545
-  data.tar.gz: 30e9e7e88b211aa21afe844e3f9510b5af39d2b4af1d97710ce533f581b5c57b
+  metadata.gz: 0a98ba175586bacb13a3f00ccb770083208e4c8381cbaf17ce4f59fdfc56a85a
+  data.tar.gz: 6a8614f33cbfa4230e66e12750308a1a339d9a2d6fe8a624b015498c5bc60928
 SHA512:
-  metadata.gz: 337694b65547afc0d4c1568a02c0c08d03d0d70a8b2319b9b9a77660ad9f37c82ff3ab49a3856ebee477657df6b254d62e59ca6b31e9312484c02e696deab007
-  data.tar.gz: e9bc3a1a27f9ba9ea6004dee40df9b385d7959c30e7059521805e91d1f64e9ed16bbc0920b4eb3b1dae8a727ab52ed8258f95bb2605e219f311920bf3fe2b031
+  metadata.gz: 0d3c4cd7e58f0eb601e37ffbf8d415c6b66349f268f2b9bec37ed4a945744409ecdb21f13e101cacba2794ea1dd3e6dd3be7a5cf7ca6cc5e67cd557bd65cd11e
+  data.tar.gz: dc2c1d73dc53df633260e279a20f8cbcb4c40c94b362fc383495e020f750807624c2de5bff446732585b5e2b4121b0ec382de65983db3af23301e937b96b4074

data/context/getting-started.md

@@ -74,6 +74,42 @@ end
 puts "The number was: #{task.wait}"
 ```
 
+### Comparing `Async` and `Sync`
+
+If you are familiar with JavaScript's `async`/`await`, `Async{...}` is similar to calling an asynchronous function: it starts the work and returns a promise-like {ruby Async::Task} that you can wait on later.
+
+```ruby
+task = Async do
+	bar
+end
+
+task.wait # Returns the value of bar.
+```
+
+This is similar to JavaScript code that keeps the promise:
+
+```javascript
+const promise = bar();
+
+await promise; // Returns the value of bar.
+```
+
+`Sync{...}` is similar to immediately awaiting that work: it runs the block in an event loop and returns the block's value directly.
+
+```ruby
+result = Sync do
+	bar
+end
+```
+
+This is similar to:
+
+```javascript
+const result = await bar();
+```
+
+The main difference is that JavaScript starts with an event loop already available, while Ruby code needs one to be provided by a fiber scheduler. `Sync{...}` is the usual way to create or reuse that event loop when the caller wants a direct return value instead of a task.
+
 ## Creating a Fiber Scheduler
 
 The first (top level) async block will also create an instance of {ruby Async::Reactor} which is a subclass of {ruby Async::Scheduler} to handle the event loop. You can also do this directly using {ruby Fiber.set_scheduler}:

data/context/index.yaml

@@ -3,6 +3,8 @@
 ---
 description: A concurrency framework for Ruby.
 metadata:
+  bug_tracker_uri: https://github.com/socketry/async/issues
+  changelog_uri: https://github.com/socketry/async/blob/main/releases.md
   documentation_uri: https://socketry.github.io/async/
   funding_uri: https://github.com/sponsors/ioquatix/
   source_code_uri: https://github.com/socketry/async.git

data/lib/async/condition.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2017-2025, by Samuel Williams.
+# Copyright, 2017-2026, by Samuel Williams.
 # Copyright, 2017, by Kent Gruber.
+# Copyright, 2026, by Robert Mosolgo.
 
 require "fiber"
 require_relative "list"
@@ -32,6 +33,11 @@ module Async
 			!self.empty?
 		end
 		
+		# @returns [Integer] Number of fibers waiting on this condition.
+		def waiting_count
+			@ready.num_waiting
+		end
+		
 		# Signal to a given task that it should resume operations.
 		# @parameter value [Object | Nil] The value to return to the waiting fibers.
 		def signal(value = nil)

data/lib/async/node.rb

@@ -5,6 +5,7 @@
 # Copyright, 2017, by Kent Gruber.
 # Copyright, 2022, by Shannon Skipper.
 # Copyright, 2025-2026, by Shopify Inc.
+# Copyright, 2026, by Kyle Tate.
 
 require "fiber/annotation"
 
@@ -283,9 +284,10 @@ module Async
 		# Attempt to cancel the current node immediately, including all non-transient children. Invokes {#stop_children} to cancel all children.
 		#
 		# @parameter later [Boolean] Whether to defer cancelling until some point in the future.
-		def cancel(later = false)
+		# @parameter cause [Exception | Nil] The cause of the cancel operation.
+		def cancel(later = false, cause: $!)
 			# The implementation of this method may defer calling `stop_children`.
-			stop_children(later)
+			stop_children(later, cause: cause)
 		end
 		
 		# Backward compatibility alias for {#cancel}.
@@ -295,9 +297,9 @@ module Async
 		end
 		
 		# Attempt to stop all non-transient children.
-		private def stop_children(later = false)
+		private def stop_children(later = false, cause:)
 			@children&.each do |child|
-				child.cancel(later) unless child.transient?
+				child.cancel(later, cause: cause) unless child.transient?
 			end
 		end
 		

data/lib/async/promise.rb

@@ -3,6 +3,7 @@
 # Released under the MIT License.
 # Copyright, 2025, by Shopify Inc.
 # Copyright, 2025-2026, by Samuel Williams.
+# Copyright, 2026, by Kyle Tate.
 
 require_relative "error"
 require_relative "deadline"
@@ -98,7 +99,9 @@ module Async
 			end
 			
 			# Wait with deadline tracking:
-			until @resolved
+			loop do
+				break if @resolved
+				
 				# Get remaining time for this wait iteration:
 				remaining = deadline.remaining
 				

data/lib/async/scheduler.rb

@@ -5,6 +5,7 @@
 # Copyright, 2020, by Jun Jiang.
 # Copyright, 2021, by Julien Portalier.
 # Copyright, 2025-2026, by Shopify Inc.
+# Copyright, 2026, by Kyle Tate.
 
 require_relative "clock"
 require_relative "task"
@@ -514,23 +515,40 @@ module Async
 		# Cancel all children, including transient children.
 		#
 		# @public Since *Async v1*.
-		def cancel
+		def cancel(later = false, cause: $!)
+			if @children and !cause
+				cause = Cancel::Cause.for("Cancelling task!")
+			end
+			
 			@children&.each do |child|
-				child.cancel
+				child.cancel(later, cause: cause)
 			end
 		end
 		
 		# Backward compatibility alias for cancel.
-		def stop
-			cancel
+		def stop(...)
+			cancel(...)
 		end
 		
-		private def run_loop(&block)
+		# Run the event loop, until the scheduler is interrupted or finished.
+		#
+		# @parameter initial [Proc | Nil] The initial block to execute before the first loop iteration.
+		# @yields {...} The block to execute on each loop iteration.
+		# @raises {Interrupt} If the scheduler is interrupted.
+		private def run_loop(initial = nil, &block)
 			interrupt = nil
 			
 			begin
 				# In theory, we could use Exception here to be a little bit safer, but we've only shown the case for SignalException to be a problem, so let's not over-engineer this.
 				Thread.handle_interrupt(::SignalException => :never) do
+					if initial
+						begin
+							initial.call
+						ensure
+							initial = nil
+						end
+					end
+					
 					until self.interrupted?
 						# If we are finished, we need to exit:
 						break unless yield
@@ -570,9 +588,15 @@ module Async
 			begin
 				@profiler&.start
 				
-				initial_task = self.async(...) if block_given?
+				initial_task = nil
 				
-				self.run_loop do
+				if block_given?
+					initial = proc do
+						initial_task = self.async(...)
+					end
+				end
+				
+				self.run_loop(initial) do
 					run_once
 				end
 				
@@ -661,6 +685,7 @@ module Async
 			@children = nil
 			@selector = nil
 			@timers = nil
+			@blocked = 0
 			
 			# Close the scheduler:
 			Fiber.set_scheduler(nil)

data/lib/async/task.rb

@@ -8,6 +8,7 @@
 # Copyright, 2023, by Math Ieu.
 # Copyright, 2025, by Shigeru Nakajima.
 # Copyright, 2025-2026, by Shopify Inc.
+# Copyright, 2026, by Kyle Tate.
 
 require "fiber"
 require "console"
@@ -333,7 +334,7 @@ module Async
 			
 			if self.cancelled?
 				# If the task is already cancelled, a `cancel` state transition re-enters the same state which is a no-op. However, we will also attempt to cancel any running children too. This can happen if the children did not cancel correctly the first time around. Doing this should probably be considered a bug, but it's better to be safe than sorry.
-				return cancelled!
+				return cancelled!(cause)
 			end
 			
 			# If the fiber is alive, we need to cancel it:
@@ -369,7 +370,7 @@ module Async
 				end
 			else
 				# We are not running, but children might be, so transition directly into cancelled state:
-				cancel!
+				cancel!(cause)
 			end
 		end
 		
@@ -479,7 +480,7 @@ module Async
 			@promise.reject(exception)
 		end
 		
-		def cancelled!
+		def cancelled!(cause = $!)
 			# Console.info(self, status:) {"Task #{self} was cancelled with #{@children&.size.inspect} children!"}
 			
 			# Cancel the promise, specify nil here so that no exception is raised when waiting on the promise:
@@ -489,15 +490,16 @@ module Async
 			
 			begin
 				# We are not running, but children might be so we should stop them:
-				stop_children(true)
-			rescue Cancel
+				stop_children(true, cause: cause)
+			rescue Cancel => exception
 				cancelled = true
+				cause ||= exception.cause || exception
 				# If we are cancelling children, and one of them tries to cancel the current task, we should ignore it. We will be cancelled later.
 				retry
 			end
 			
 			if cancelled
-				raise Cancel, "Cancelling current task!"
+				raise Cancel, "Cancelling current task!", cause: cause
 			end
 		end
 		
@@ -505,8 +507,8 @@ module Async
 			cancelled!
 		end
 		
-		def cancel!
-			cancelled!
+		def cancel!(cause = $!)
+			cancelled!(cause)
 			
 			finish!
 		end
@@ -519,8 +521,8 @@ module Async
 			@fiber = Fiber.new(annotation: self.annotation) do
 				begin
 					completed!(yield)
-				rescue Cancel
-					cancelled!
+				rescue Cancel => exception
+					cancelled!(exception.cause || exception)
 				rescue StandardError => error
 					failed!(error)
 				rescue Exception => exception

data/lib/async/version.rb

@@ -5,5 +5,5 @@
 
 # @namespace
 module Async
-	VERSION = "2.39.0"
+	VERSION = "2.44.1"
 end

data/lib/kernel/async.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2019-2024, by Samuel Williams.
+# Copyright, 2019-2026, by Samuel Williams.
+# Copyright, 2026, by Shopify Inc.
 
 require_relative "../async/reactor"
 
@@ -27,13 +28,15 @@ module Kernel
 		elsif scheduler = Fiber.scheduler
 			::Async::Task.run(scheduler, ...)
 		else
-			# This calls Fiber.set_scheduler(self):
-			reactor = ::Async::Reactor.new
-			
-			begin
-				return reactor.run(...)
-			ensure
-				Fiber.set_scheduler(nil)
+			Fiber.blocking do
+				# This calls Fiber.set_scheduler(self):
+				reactor = ::Async::Reactor.new
+				
+				begin
+					return reactor.run(...)
+				ensure
+					Fiber.set_scheduler(nil)
+				end
 			end
 		end
 	end

data/lib/kernel/sync.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2019-2025, by Samuel Williams.
+# Copyright, 2019-2026, by Samuel Williams.
 # Copyright, 2020, by Brian Morearty.
 # Copyright, 2024, by Patrik Wenger.
-# Copyright, 2025, by Shopify Inc.
+# Copyright, 2025-2026, by Shopify Inc.
 
 require_relative "../async/reactor"
 
@@ -27,16 +27,16 @@ module Kernel
 		elsif scheduler = Fiber.scheduler
 			::Async::Task.run(scheduler, &block).wait
 		else
-			# This calls Fiber.set_scheduler(self):
-			reactor = Async::Reactor.new
-			
-			begin
-				# Use finished: false to suppress warnings since we're handling exceptions explicitly
-				task = reactor.async(annotation: annotation, finished: false, &block)
-				reactor.run
-				return task.wait
-			ensure
-				Fiber.set_scheduler(nil)
+			Fiber.blocking do
+				# This calls Fiber.set_scheduler(self):
+				reactor = Async::Reactor.new
+				
+				begin
+					# Use finished: false to suppress warnings since we're handling exceptions explicitly
+					return reactor.run(annotation: annotation, finished: false, &block).wait
+				ensure
+					Fiber.set_scheduler(nil)
+				end
 			end
 		end
 	end

data/license.md

@@ -36,6 +36,8 @@ Copyright, 2025, by Josh Teeter.
 Copyright, 2025, by Jatin Goyal.  
 Copyright, 2025, by Yuhi Sato.  
 Copyright, 2026, by Tavian Barnes.  
+Copyright, 2026, by Robert Mosolgo.  
+Copyright, 2026, by Kyle Tate.  
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/readme.md

@@ -35,6 +35,26 @@ Please see the [project documentation](https://socketry.github.io/async/) for mo
 
 Please see the [project releases](https://socketry.github.io/async/releases/index) for all releases.
 
+### v2.44.0
+
+  - Fixed scheduler cleanup after forking while other fibers are blocked.
+
+### v2.43.0
+
+  - Propagate cancellation causes through task trees so child tasks observe the original cancellation cause.
+
+### v2.42.0
+
+  - `Sync` and `Async` can now be invoked from a non-blocking fiber that has no scheduler (e.g. inside an `Enumerator` or a bare `Fiber.new`). Previously this raised `RuntimeError: Running scheduler on non-blocking fiber!`. The reactor is now run within `Fiber.blocking`, so the scheduler always runs on a blocking fiber.
+
+### v2.41.0
+
+  - **Fixed**: Protect initial task from Interrupt exceptions.
+
+### v2.40.0
+
+  - Introduce `Async::Condition#waiting_count`. This allows you to see how many tasks are currently waiting on the condition, which can be useful for debugging and monitoring purposes.
+
 ### v2.39.0
 
   - `Async::Barrier#wait` now returns the number of tasks that were waited for, or `nil` if there were no tasks to wait for. This provides better feedback about the operation, and allows you to know how many tasks were involved in the wait.
@@ -58,27 +78,6 @@ Please see the [project releases](https://socketry.github.io/async/releases/inde
   - Introduce `Task#wait_all` which recursively waits for all children and self, excepting the current task.
   - Introduce `Task#join` as an alias for `Task#wait` for compatibility with `Thread#join` and similar interfaces.
 
-### v2.35.3
-
-  - `Async::Clock` now implements `#as_json` and `#to_json` for nicer log formatting.
-
-### v2.35.2
-
-  - Improved handling of `Process.fork` on Ruby 4+.
-  - Improve `@promise` state handling in `Task#initialize`, preventing incomplete instances being visible to the scheduler.
-
-### v2.35.1
-
-  - Fix incorrect handling of spurious wakeups in `Async::Promise#wait`, which could lead to premature (incorrect) resolution of the promise.
-
-### v2.35.0
-
-  - `Process.fork` is now properly handled by the Async fiber scheduler, ensuring that the scheduler state is correctly reset in the child process after a fork. This prevents issues where the child process inherits the scheduler state from the parent, which could lead to unexpected behavior.
-
-### v2.34.0
-
-  - [`Kernel::Barrier` Convenience Interface](https://socketry.github.io/async/releases/index#kernel::barrier-convenience-interface)
-
 ## See Also
 
   - [async-http](https://github.com/socketry/async-http) — Asynchronous HTTP client/server.
@@ -97,6 +96,22 @@ We welcome contributions to this project.
 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.

data/releases.md

@@ -1,5 +1,25 @@
 # Releases
 
+## v2.44.0
+
+  - Fixed scheduler cleanup after forking while other fibers are blocked.
+
+## v2.43.0
+
+  - Propagate cancellation causes through task trees so child tasks observe the original cancellation cause.
+
+## v2.42.0
+
+  - `Sync` and `Async` can now be invoked from a non-blocking fiber that has no scheduler (e.g. inside an `Enumerator` or a bare `Fiber.new`). Previously this raised `RuntimeError: Running scheduler on non-blocking fiber!`. The reactor is now run within `Fiber.blocking`, so the scheduler always runs on a blocking fiber.
+
+## v2.41.0
+
+  - **Fixed**: Protect initial task from Interrupt exceptions.
+
+## v2.40.0
+
+  - Introduce `Async::Condition#waiting_count`. This allows you to see how many tasks are currently waiting on the condition, which can be useful for debugging and monitoring purposes.
+
 ## v2.39.0
 
   - `Async::Barrier#wait` now returns the number of tasks that were waited for, or `nil` if there were no tasks to wait for. This provides better feedback about the operation, and allows you to know how many tasks were involved in the wait.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async
 version: !ruby/object:Gem::Version
-  version: 2.39.0
+  version: 2.44.1
 platform: ruby
 authors:
 - Samuel Williams
@@ -26,11 +26,13 @@ authors:
 - Julien Portalier
 - Jun Jiang
 - Ken Muryoi
+- Kyle Tate
 - Leon Löchner
 - Mark Montroy
 - Masafumi Okura
 - Masayuki Yamamoto
 - Math Ieu
+- Robert Mosolgo
 - Ryan Musgrave
 - Salim Semaoune
 - Shannon Skipper
@@ -115,34 +117,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.11'
-- !ruby/object:Gem::Dependency
-  name: metrics
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.12'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.12'
-- !ruby/object:Gem::Dependency
-  name: traces
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.18'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.18'
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -199,6 +173,8 @@ homepage: https://github.com/socketry/async
 licenses:
 - MIT
 metadata:
+  bug_tracker_uri: https://github.com/socketry/async/issues
+  changelog_uri: https://github.com/socketry/async/blob/main/releases.md
   documentation_uri: https://socketry.github.io/async/
   funding_uri: https://github.com/sponsors/ioquatix/
   source_code_uri: https://github.com/socketry/async.git
@@ -216,7 +192,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.10
 specification_version: 4
 summary: A concurrency framework for Ruby.
 test_files: []