/usr/share/doc/ruby-timers/README.md is in ruby-timers 4.1.1-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 | Timers
======
[](http://rubygems.org/gems/timers)
[](http://travis-ci.org/celluloid/timers)
[](https://codeclimate.com/github/celluloid/timers)
[](https://coveralls.io/r/celluloid/timers)
Ruby timer collections. Schedule several procs to fire after configurable delays
or at periodic intervals.
This gem is especially useful when you are faced with an API that accepts a
single timeout but you want to run multiple timers on top of it. An example of
such a library is [nio4r](https://github.com/celluloid/nio4r), a cross-platform
Ruby library for using system calls like epoll and kqueue.
Usage
-----
Create a new timer group with `Timers::Group.new`:
```ruby
require 'timers'
timers = Timers::Group.new
```
Schedule a proc to run after 5 seconds with `Timers::Group#after`:
```ruby
five_second_timer = timers.after(5) { puts "Take five" }
```
The `five_second_timer` variable is now bound to a Timers::Timer object. To
cancel a timer, use `Timers::Timer#cancel`
Once you've scheduled a timer, you can wait until the next timer fires with `Timers::Group#wait`:
```ruby
# Waits 5 seconds
timers.wait
# The script will now print "Take five"
```
You can schedule a block to run periodically with `Timers::Group#every`:
```ruby
every_five_seconds = timers.every(5) { puts "Another 5 seconds" }
loop { timers.wait }
```
You can also schedule a block to run immediately and periodically with `Timers::Group#now_and_every`:
```ruby
now_and_every_five_seconds = timers.now_and_every(5) { puts "Now and in another 5 seconds" }
loop { timers.wait }
```
If you'd like another method to do the waiting for you, e.g. `Kernel.select`,
you can use `Timers::Group#wait_interval` to obtain the amount of time to wait. When
a timeout is encountered, you can fire all pending timers with `Timers::Group#fire`:
```ruby
loop do
interval = timers.wait_interval
ready_readers, ready_writers = select readers, writers, nil, interval
if ready_readers || ready_writers
# Handle IO
...
else
# Timeout!
timers.fire
end
end
```
You can also pause and continue individual timers, or all timers:
```ruby
paused_timer = timers.every(5) { puts "I was paused" }
paused_timer.pause
10.times { timers.wait } # will not fire paused timer
paused_timer.resume
10.times { timers.wait } # will fire timer
timers.pause
10.times { timers.wait } # will not fire any timers
timers.resume
10.times { timers.wait } # will fire all timers
```
License
-------
Copyright (c) 2014 Celluloid timers project developers (given in the file
AUTHORS.md).
Distributed under the MIT License. See LICENSE file for further details.
|