timers 4.1.2 → 4.3.5

data/lib/timers/timer.rb

@@ -1,129 +1,139 @@
 # frozen_string_literal: true
 
-module Timers
-  # An individual timer set to fire a given proc at a given time. A timer is
-  # always connected to a Timer::Group but it would ONLY be in @group.timers
-  # if it also has a @handle specified. Otherwise it is either PAUSED or has
-  # been FIRED and is not recurring. You can manually enter this state by
-  # calling #cancel and resume normal operation by calling #reset.
-  class Timer
-    include Comparable
-    attr_reader :interval, :offset, :recurring
-
-    def initialize(group, interval, recurring = false, offset = nil, &block)
-      @group = group
-
-      @interval = interval
-      @recurring = recurring
-      @block = block
-      @offset = offset
-
-      @handle = nil
-
-      # If a start offset was supplied, use that, otherwise use the current timers offset.
-      reset(@offset || @group.current_offset)
-    end
-
-    def paused?
-      @group.paused_timers.include? self
-    end
-
-    def pause
-      return if paused?
-
-      @group.timers.delete self
-      @group.paused_timers.add self
-
-      @handle.cancel! if @handle
-      @handle = nil
-    end
-
-    def resume
-      return unless paused?
-
-      @group.paused_timers.delete self
-
-      # This will add us back to the group:
-      reset
-    end
-
-    alias continue resume
-
-    # Extend this timer
-    def delay(seconds)
-      @handle.cancel! if @handle
-
-      @offset += seconds
-
-      @handle = @group.events.schedule(@offset, self)
-    end
+# Released under the MIT License.
+# Copyright, 2014-2022, by Samuel Williams.
+# Copyright, 2014-2017, by Tony Arcieri.
+# Copyright, 2014, by Utenmiki.
+# Copyright, 2014, by Lin Jen-Shin.
+# Copyright, 2017, by Vít Ondruch.
 
-    # Cancel this timer. Do not call while paused.
-    def cancel
-      return unless @handle
-
-      @handle.cancel! if @handle
-      @handle = nil
-
-      # This timer is no longer valid:
-      @group.timers.delete self if @group
-    end
-
-    # Reset this timer. Do not call while paused.
-    def reset(offset = @group.current_offset)
-      # This logic allows us to minimise the interaction with @group.timers.
-      # A timer with a handle is always registered with the group.
-      if @handle
-        @handle.cancel!
-      else
-        @group.timers << self
-      end
-
-      @offset = Float(offset) + @interval
-
-      @handle = @group.events.schedule(@offset, self)
-    end
-
-    # Fire the block.
-    def fire(offset = @group.current_offset)
-      if recurring == :strict
-        # ... make the next interval strictly the last offset + the interval:
-        reset(@offset)
-      elsif recurring
-        reset(offset)
-      else
-        @offset = offset
-      end
-
-      @block.call(offset)
-
-      cancel unless recurring
-    end
-
-    alias call fire
-
-    # Number of seconds until next fire / since last fire
-    def fires_in
-      @offset - @group.current_offset if @offset
-    end
-
-    # Inspect a timer
-    def inspect
-      str = "#<Timers::Timer:#{object_id.to_s(16)} ".dup
-
-      if @offset
-        str << if fires_in >= 0
-                 "fires in #{fires_in} seconds"
-               else
-                 "fired #{fires_in.abs} seconds ago"
-               end
-
-        str << ", recurs every #{interval}" if recurring
-      else
-        str << "dead"
-      end
-
-      str << ">"
-    end
-  end
+module Timers
+	# An individual timer set to fire a given proc at a given time. A timer is
+	# always connected to a Timer::Group but it would ONLY be in @group.timers
+	# if it also has a @handle specified. Otherwise it is either PAUSED or has
+	# been FIRED and is not recurring. You can manually enter this state by
+	# calling #cancel and resume normal operation by calling #reset.
+	class Timer
+		include Comparable
+		attr_reader :interval, :offset, :recurring
+		
+		def initialize(group, interval, recurring = false, offset = nil, &block)
+			@group = group
+			
+			@interval = interval
+			@recurring = recurring
+			@block = block
+			@offset = offset
+			
+			@handle = nil
+			
+			# If a start offset was supplied, use that, otherwise use the current timers offset.
+			reset(@offset || @group.current_offset)
+		end
+		
+		def paused?
+			@group.paused_timers.include? self
+		end
+		
+		def pause
+			return if paused?
+			
+			@group.timers.delete self
+			@group.paused_timers.add self
+			
+			@handle.cancel! if @handle
+			@handle = nil
+		end
+		
+		def resume
+			return unless paused?
+			
+			@group.paused_timers.delete self
+			
+			# This will add us back to the group:
+			reset
+		end
+		
+		alias continue resume
+		
+		# Extend this timer
+		def delay(seconds)
+			@handle.cancel! if @handle
+			
+			@offset += seconds
+			
+			@handle = @group.events.schedule(@offset, self)
+		end
+		
+		# Cancel this timer. Do not call while paused.
+		def cancel
+			return unless @handle
+			
+			@handle.cancel! if @handle
+			@handle = nil
+			
+			# This timer is no longer valid:
+			@group.timers.delete self if @group
+		end
+		
+		# Reset this timer. Do not call while paused.
+		# @param offset [Numeric] the duration to add to the timer.
+		def reset(offset = @group.current_offset)
+			# This logic allows us to minimise the interaction with @group.timers.
+			# A timer with a handle is always registered with the group.
+			if @handle
+				@handle.cancel!
+			else
+				@group.timers << self
+			end
+			
+			@offset = Float(offset) + @interval
+			
+			@handle = @group.events.schedule(@offset, self)
+		end
+		
+		# Fire the block.
+		def fire(offset = @group.current_offset)
+			if recurring == :strict
+				# ... make the next interval strictly the last offset + the interval:
+				reset(@offset)
+			elsif recurring
+				reset(offset)
+			else
+				@offset = offset
+			end
+			
+			@block.call(offset, self)
+			
+			cancel unless recurring
+		end
+		
+		alias call fire
+		
+		# Number of seconds until next fire / since last fire
+		def fires_in
+			@offset - @group.current_offset if @offset
+		end
+		
+		# Inspect a timer
+		def inspect
+			buffer = "#{to_s[0..-2]} ".dup
+			
+			if @offset
+				if fires_in >= 0
+					buffer << "fires in #{fires_in} seconds"
+				else
+					buffer << "fired #{fires_in.abs} seconds ago"
+				end
+				
+				buffer << ", recurs every #{interval}" if recurring
+			else
+				buffer << "dead"
+			end
+			
+			buffer << ">"
+			
+			return buffer
+		end
+	end
 end

data/lib/timers/version.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+# Released under the MIT License.
+# Copyright, 2012-2016, by Tony Arcieri.
+# Copyright, 2014-2022, by Samuel Williams.
+# Copyright, 2015, by Donovan Keme.
+
 module Timers
-  VERSION = "4.1.2"
+	VERSION = "4.3.5"
 end

data/lib/timers/wait.rb

@@ -1,47 +1,53 @@
 # frozen_string_literal: true
 
-require "hitimes"
+# Released under the MIT License.
+# Copyright, 2014-2022, by Samuel Williams.
+# Copyright, 2014-2016, by Tony Arcieri.
+# Copyright, 2015, by Utenmiki.
+# Copyright, 2015, by Donovan Keme.
 
-module Timers
-  # An exclusive, monotonic timeout class.
-  class Wait
-    def self.for(duration, &block)
-      if duration
-        timeout = new(duration)
-
-        timeout.while_time_remaining(&block)
-      else
-        loop do
-          yield(nil)
-        end
-      end
-    end
-
-    def initialize(duration)
-      @duration = duration
-      @remaining = true
-    end
-
-    attr_reader :duration
-    attr_reader :remaining
-
-    # Yields while time remains for work to be done:
-    def while_time_remaining
-      @interval = Hitimes::Interval.new
-      @interval.start
+require_relative "interval"
 
-      yield @remaining while time_remaining?
-    ensure
-      @interval.stop
-      @interval = nil
-    end
-
-    private
-
-    def time_remaining?
-      @remaining = (@duration - @interval.duration)
-
-      @remaining > 0
-    end
-  end
+module Timers
+	# An exclusive, monotonic timeout class.
+	class Wait
+		def self.for(duration, &block)
+			if duration
+				timeout = new(duration)
+				
+				timeout.while_time_remaining(&block)
+			else
+				loop do
+					yield(nil)
+				end
+			end
+		end
+		
+		def initialize(duration)
+			@duration = duration
+			@remaining = true
+		end
+		
+		attr_reader :duration
+		attr_reader :remaining
+		
+		# Yields while time remains for work to be done:
+		def while_time_remaining
+			@interval = Interval.new
+			@interval.start
+			
+			yield @remaining while time_remaining?
+		ensure
+			@interval.stop
+			@interval = nil
+		end
+		
+		private
+		
+		def time_remaining?
+			@remaining = (@duration - @interval.to_f)
+			
+			@remaining > 0
+		end
+	end
 end

data/lib/timers.rb

@@ -1,6 +1,21 @@
 # frozen_string_literal: true
 
-require "timers/version"
+# Released under the MIT License.
+# Copyright, 2012-2016, by Tony Arcieri.
+# Copyright, 2012, by Ryan LeCompte.
+# Copyright, 2012, by Nicholas Evans.
+# Copyright, 2012, by Dimitrij Denissenko.
+# Copyright, 2013, by Chuck Remes.
+# Copyright, 2013, by Ron Evans.
+# Copyright, 2013, by Sean Gregory.
+# Copyright, 2013, by Utenmiki.
+# Copyright, 2013, by Jeremy Hinegardner.
+# Copyright, 2014, by Larry Lv.
+# Copyright, 2014, by Bruno Enten.
+# Copyright, 2014-2022, by Samuel Williams.
+# Copyright, 2014, by Mike Bourgeous.
 
-require "timers/group"
-require "timers/wait"
+require_relative "timers/version"
+
+require_relative "timers/group"
+require_relative "timers/wait"

data/license.md

@@ -0,0 +1,48 @@
+# MIT License
+
+Copyright, 2012-2017, by Tony Arcieri.  
+Copyright, 2012, by Ryan LeCompte.  
+Copyright, 2012, by Jesse Cooke.  
+Copyright, 2012, by Nicholas Evans.  
+Copyright, 2012, by Dimitrij Denissenko.  
+Copyright, 2013, by Chuck Remes.  
+Copyright, 2013, by Ron Evans.  
+Copyright, 2013, by Sean Gregory.  
+Copyright, 2013-2015, by Utenmiki.  
+Copyright, 2013, by Jeremy Hinegardner.  
+Copyright, 2014, by Larry Lv.  
+Copyright, 2014, by Bruno Enten.  
+Copyright, 2014-2022, by Samuel Williams.  
+Copyright, 2014, by Mike Bourgeous.  
+Copyright, 2014, by Klaus Trainer.  
+Copyright, 2014, by Lin Jen-Shin.  
+Copyright, 2014, by Lavir the Whiolet.  
+Copyright, 2015-2016, by Donovan Keme.  
+Copyright, 2015, by Tommy Ong Gia Phu.  
+Copyright, 2015, by Will Jessop.  
+Copyright, 2016, by Ryunosuke SATO.  
+Copyright, 2016, by Atul Bhosale.  
+Copyright, 2016, by Feram.  
+Copyright, 2017, by Vít Ondruch.  
+Copyright, 2017-2020, by Olle Jonsson.  
+Copyright, 2020, by Tim Smith.  
+Copyright, 2021, by Wander Hillen.  
+Copyright, 2022, by Yoshiki Takagi.  
+
+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 → readme.md}

@@ -1,35 +1,30 @@
-# Timers for Ruby [![Gem Version][gem-image]][gem-link] [![Build Status][build-image]][build-link] [![Code Climate][codeclimate-image]][codeclimate-link] [![Coverage Status][coverage-image]][coverage-link] [![MIT licensed][license-image]][license-link]
+# Timers
 
-[gem-image]: https://badge.fury.io/rb/timers.svg
-[gem-link]: http://rubygems.org/gems/timers
-[build-image]: https://secure.travis-ci.org/celluloid/timers.svg?branch=master
-[build-link]: https://travis-ci.org/celluloid/timers
-[codeclimate-image]: https://codeclimate.com/github/celluloid/timers.svg
-[codeclimate-link]: https://codeclimate.com/github/celluloid/timers
-[coverage-image]: https://coveralls.io/repos/celluloid/timers/badge.svg?branch=master
-[coverage-link]: https://coveralls.io/r/celluloid/timers
-[license-image]: https://img.shields.io/badge/license-MIT-blue.svg
-[license-link]: https://github.com/celluloid/timers/master/LICENSE.txt
+Collections of one-shot and periodic timers, intended for use with event loops such as [async](https://github.com/socketry/async).
 
-Collections of one-shot and periodic timers, intended for use with event loops.
+[![Development Status](https://github.com/socketry/timers/workflows/Test/badge.svg)](https://github.com/socketry/timers/actions?workflow=Test)
 
-**Does not require Celluloid!** Though this gem was originally written
-to provide the timer subsystem for [Celluloid], it can be used independently
-in any sort of event loop context, or can provide a purely timer-based event
-loop itself.
+## Installation
 
-[Celluloid]: https://github.com/celluloid/celluloid/
+Add this line to your application's Gemfile:
 
-## Supported platforms
+``` ruby
+gem 'timers'
+```
+
+And then execute:
+
+    $ bundle
 
-* Ruby 2.0, 2.1, 2.2, and 2.3
-* JRuby 9000
+Or install it yourself as:
+
+    $ gem install timers
 
 ## Usage
 
 Create a new timer group with `Timers::Group.new`:
 
-```ruby
+``` ruby
 require 'timers'
 
 timers = Timers::Group.new
@@ -37,7 +32,7 @@ timers = Timers::Group.new
 
 Schedule a proc to run after 5 seconds with `Timers::Group#after`:
 
-```ruby
+``` ruby
 five_second_timer = timers.after(5) { puts "Take five" }
 ```
 
@@ -46,7 +41,7 @@ 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
+``` ruby
 # Waits 5 seconds
 timers.wait
 
@@ -55,14 +50,15 @@ timers.wait
 
 You can schedule a block to run periodically with `Timers::Group#every`:
 
-```ruby
+``` 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
+
+``` ruby
 now_and_every_five_seconds = timers.now_and_every(5) { puts "Now and in another 5 seconds" }
 
 loop { timers.wait }
@@ -72,7 +68,7 @@ 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
+``` ruby
 loop do
   interval = timers.wait_interval
   ready_readers, ready_writers = select readers, writers, nil, interval
@@ -89,7 +85,7 @@ end
 
 You can also pause and continue individual timers, or all timers:
 
-```ruby
+``` ruby
 paused_timer = timers.every(5) { puts "I was paused" }
 
 paused_timer.pause
@@ -105,9 +101,10 @@ timers.resume
 10.times { timers.wait } # will fire all timers
 ```
 
-## License
-
-Copyright (c) 2012-2016 Celluloid timers project developers (given in the file
-AUTHORS.md).
+## Contributing
 
-Distributed under the MIT License. See LICENSE file for further details.
+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