normalize reference to Timeout::Error

From: John Bachir <j@jjb.cc>

* bootstraptest/test_io.rb (assert_finish):
  normalize rescue for Timeout::Error
* lib/net/ftp.rb (Net#read_timeout): ditto for doc
* lib/resolv.rb (Resolv::ResolvTimeout): ditto for subclass
* lib/webrick/httprequest.rb (_read_data): ditto for rescue
* sample/timeout.rb (p timeout): ditto for call
* test/drb/drbtest.rb (test_06_timeout): ditto
* test/ruby/test_readpartial.rb (test_open_pipe): ditto
* test/thread/test_queue.rb (test_queue_thread_raise): ditto
* thread.c (rb_thread_s_handle_interrupt): ditto for doc
  [ruby-core:65481] [misc #10339]

TimeoutError is a legacy constant, Timeout::Error is the canonical constant.
This patch normalizes all code and comments to reference Timeout::Error.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@47838 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

1 files changed, 11 insertions, 11 deletions

diff --git a/thread.c b/thread.c
index 4365c1fa6d..aedd0c1e0e 100644
--- a/thread.c
+++ b/thread.c
@@ -1731,29 +1731,29 @@ handle_interrupt_arg_check_i(VALUE key, VALUE val)
  * resource allocation code. Then, the ensure block is where we can safely
  * deallocate your resources.
  *
- * ==== Guarding from TimeoutError
+ * ==== Guarding from Timeout::Error
  *
- * In the next example, we will guard from the TimeoutError exception. This
- * will help prevent from leaking resources when TimeoutError exceptions occur
+ * In the next example, we will guard from the Timeout::Error exception. This
+ * will help prevent from leaking resources when Timeout::Error exceptions occur
  * during normal ensure clause. For this example we use the help of the
  * standard library Timeout, from lib/timeout.rb
  *
  *   require 'timeout'
- *   Thread.handle_interrupt(TimeoutError => :never) {
+ *   Thread.handle_interrupt(Timeout::Error => :never) {
  *     timeout(10){
- *       # TimeoutError doesn't occur here
- *       Thread.handle_interrupt(TimeoutError => :on_blocking) {
- *         # possible to be killed by TimeoutError
+ *       # Timeout::Error doesn't occur here
+ *       Thread.handle_interrupt(Timeout::Error => :on_blocking) {
+ *         # possible to be killed by Timeout::Error
  *         # while blocking operation
  *       }
- *       # TimeoutError doesn't occur here
+ *       # Timeout::Error doesn't occur here
  *     }
  *   }
  *
- * In the first part of the +timeout+ block, we can rely on TimeoutError being
- * ignored. Then in the <code>TimeoutError => :on_blocking</code> block, any
+ * In the first part of the +timeout+ block, we can rely on Timeout::Error being
+ * ignored. Then in the <code>Timeout::Error => :on_blocking</code> block, any
  * operation that will block the calling thread is susceptible to a
- * TimeoutError exception being raised.
+ * Timeout::Error exception being raised.
  *
  * ==== Stack control settings
  *