timeout 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 405263117245d6a9c981a56bc90cad374d50547078dbcfef1cb3fecca78bcece
-  data.tar.gz: 8eaeb608b52c8f273342746ff88f7e7b9458325e4a30e9f5605d62c749022ec0
+  metadata.gz: 31442005d41eeaddb46916ff83e27dc0198a3a0509c463d47d1fd4a9c7e0ec6d
+  data.tar.gz: bf8dff95c8356a47b513568f3c6890d2c1a9a74a6a364f5fa38d5e8f4b8e3c87
 SHA512:
-  metadata.gz: 1bf761aa173a75b2545088a1304eb8e8c2bc2df0b3223af738fd2c10f2170e4b140644aa9dc036835149ff1ca2cecf866cd782560b9e3856dc63491f6b357657
-  data.tar.gz: da2ec36df76ea4dc31c532a704d3ae102eac3dc60f4091e9d7dd072144353a1a38aa818ed15d36fb8c8a675b82a9ffa9eae85475e11346faafe48f6318602af8
+  metadata.gz: 3630c0c2b33659c650a9f4af7d5983dd303d174431c7d7c137292e4c702ac95afaab7434b4061bd6b013edc10343fa141e0969ac4188f671cbc84a14583c9986
+  data.tar.gz: b835d20514bda974bd0f5cd6473213bd429a9887503802dc2882ab25ae00be502f5df84642f305eb348866e33c9357130b985012d936ed48eebfea800458853c

data/lib/timeout.rb

@@ -20,7 +20,7 @@
 
 module Timeout
   # The version
-  VERSION = "0.6.0"
+  VERSION = "0.6.1"
 
   # Internal exception raised to when a timeout is triggered.
   class ExitException < Exception
@@ -212,17 +212,17 @@ module Timeout
   #         value of 0 or +nil+ will execute the block without any timeout.
   #         Any negative number will raise an ArgumentError.
   # +klass+:: Exception Class to raise if the block fails to terminate
-  #           in +sec+ seconds.  Omitting will use the default, Timeout::Error
+  #           in +sec+ seconds.  Omitting will use the default, Timeout::Error.
   # +message+:: Error message to raise with Exception Class.
-  #             Omitting will use the default, "execution expired"
+  #             Omitting will use the default, <tt>"execution expired"</tt>.
   #
   # Returns the result of the block *if* the block completed before
   # +sec+ seconds, otherwise raises an exception, based on the value of +klass+.
   #
   # The exception raised to terminate the given block is the given +klass+, or
   # Timeout::ExitException if +klass+ is not given. The reason for that behavior
-  # is that Timeout::Error inherits from RuntimeError and might be caught unexpectedly by `rescue`.
-  # Timeout::ExitException inherits from Exception so it will only be rescued by `rescue Exception`.
+  # is that Timeout::Error inherits from RuntimeError and might be caught unexpectedly by +rescue+.
+  # Timeout::ExitException inherits from Exception so it will only be rescued by <tt>rescue Exception</tt>.
   # Note that the Timeout::ExitException is translated to a Timeout::Error once it reaches the Timeout.timeout call,
   # so outside that call it will be a Timeout::Error.
   #
@@ -231,7 +231,7 @@ module Timeout
   # For those reasons, this method cannot be relied on to enforce timeouts for untrusted blocks.
   #
   # If a scheduler is defined, it will be used to handle the timeout by invoking
-  # Scheduler#timeout_after.
+  # Fiber::Scheduler#timeout_after.
   #
   # Note that this is both a method of module Timeout, so you can <tt>include
   # Timeout</tt> into your classes so they have a #timeout method, as well as
@@ -239,13 +239,13 @@ module Timeout
   #
   # ==== Ensuring the exception does not fire inside ensure blocks
   #
-  # When using Timeout.timeout it can be desirable to ensure the timeout exception does not fire inside an +ensure+ block.
-  # The simplest and best way to do so it to put the Timeout.timeout call inside the body of the begin/ensure/end:
+  # When using Timeout.timeout, it can be desirable to ensure the timeout exception does not fire inside an +ensure+ block.
+  # The simplest and best way to do so is to put the Timeout.timeout call inside the body of the +begin+/+ensure+/+end+:
   #
   #     begin
   #       Timeout.timeout(sec) { some_long_operation }
   #     ensure
-  #       cleanup # safe, cannot be interrupt by timeout
+  #       cleanup # safe, cannot be interrupted by timeout
   #     end
   #
   # If that is not feasible, e.g. if there are +ensure+ blocks inside +some_long_operation+,
@@ -263,17 +263,17 @@ module Timeout
   #       end
   #     }
   #
-  # An important thing to note is the need to pass an exception klass to Timeout.timeout,
-  # otherwise it does not work. Specifically, using +Thread.handle_interrupt(Timeout::ExitException => ...)+
+  # An important thing to note is the need to pass an exception +klass+ to Timeout.timeout,
+  # otherwise it does not work. Specifically, using <tt>Thread.handle_interrupt(Timeout::ExitException => ...)</tt>
   # is unsupported and causes subtle errors like raising the wrong exception outside the block, do not use that.
   #
   # Note that Thread.handle_interrupt is somewhat dangerous because if setup or cleanup hangs
   # then the current thread will hang too and the timeout will never fire.
   # Also note the block might run for longer than +sec+ seconds:
-  # e.g. some_long_operation executes for +sec+ seconds + whatever time cleanup takes.
+  # e.g. +some_long_operation+ executes for +sec+ seconds + whatever time cleanup takes.
   #
-  # If you want the timeout to only happen on blocking operations one can use :on_blocking
-  # instead of :immediate. However, that means if the block uses no blocking operations after +sec+ seconds,
+  # If you want the timeout to only happen on blocking operations, one can use +:on_blocking+
+  # instead of +:immediate+. However, that means if the block uses no blocking operations after +sec+ seconds,
   # the block will not be interrupted.
   def self.timeout(sec, klass = nil, message = nil, &block)   #:yield: +sec+
     return yield(sec) if sec == nil or sec.zero?
@@ -282,19 +282,21 @@ module Timeout
     message ||= "execution expired"
 
     if Fiber.respond_to?(:current_scheduler) && (scheduler = Fiber.current_scheduler)&.respond_to?(:timeout_after)
-      return scheduler.timeout_after(sec, klass || Error, message, &block)
-    end
-
-    state = State.instance
-    state.ensure_timeout_thread_created
-
-    perform = Proc.new do |exc|
-      request = Request.new(Thread.current, sec, exc, message)
-      state.add_request(request)
-      begin
-        return yield(sec)
-      ensure
-        request.finished
+      perform = Proc.new do |exc|
+        scheduler.timeout_after(sec, exc, message, &block)
+      end
+    else
+      state = State.instance
+      state.ensure_timeout_thread_created
+
+      perform = Proc.new do |exc|
+        request = Request.new(Thread.current, sec, exc, message)
+        state.add_request(request)
+        begin
+          return yield(sec)
+        ensure
+          request.finished
+        end
       end
     end
 
@@ -305,6 +307,7 @@ module Timeout
     end
   end
 
+  # See Timeout.timeout
   private def timeout(*args, &block)
     Timeout.timeout(*args, &block)
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: timeout
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Yukihiro Matsumoto
 bindir: bin
 cert_chain: []
-date: 2025-12-17 00:00:00.000000000 Z
+date: 2026-03-09 00:00:00.000000000 Z
 dependencies: []
 description: Auto-terminate potentially long-running operations in Ruby.
 email: