timers 4.1.2 → 4.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 97c81b8ed305099faee9ecec3ee32f6960b70d54
-  data.tar.gz: 90d94a796bfe60e78963b0053648396aefdb19b6
+SHA256:
+  metadata.gz: e1665f074c230a801e0eb6648214a6d0248d4baada8da1f4e60abd0983bba517
+  data.tar.gz: de4eac12ecba1826d6ae5ef1d6958a451595b1a9e8e54dba7f1718d7f15182dd
 SHA512:
-  metadata.gz: dbea5311bcd5fb7bfe7c98191ac15146647b91ab5c994309f3bc14fe394ac97832361afa6ff7f257d844a802265125a5bafa051026fa1eed979f8310d8a21f87
-  data.tar.gz: 2097c9e9d6e838550fa3c4735db828173852dd5e598670a376a04de132274df6464687cfe0e72992c2469d5d355932808fe1147e44ec5f26e2162046267c37ad
+  metadata.gz: c0e005f02975d324b7fbe7d8e284a2d5318be78352e129ce00abf20594d3e6a18b30103e1137b2d9fe91bd5a2251e7b22fb5cdc255f5153f219bf90bd3b6160d
+  data.tar.gz: 64210a85d0a8efe2540d9ee6da050c5d8298a5332bd2ba14758bd784a7f991ad40b1f828b47320525ab025249859ca6419f172421492fe6ced56a76e34820541

data/.rspec

@@ -1,6 +1,3 @@
---color
 --format documentation
---backtrace
---order random
 --warnings
---require spec_helper
+--require spec_helper

data/.travis.yml

@@ -1,21 +1,19 @@
 language: ruby
 sudo: false
-
-bundler_args: --without development doc
-
-rvm:
-  - 2.0.0
-  - 2.1.10
-  - 2.2.6
-  - 2.3.3
-  - jruby-9.1.6.0
+dist: xenial
+cache: bundler
 
 matrix:
-  fast_finish: true
-
-branches:
-  only:
-    - master
-
-notifications:
-  irc: "irc.freenode.org#celluloid"
+  include:
+    - rvm: 2.3
+    - rvm: 2.4
+    - rvm: 2.5
+    - rvm: 2.6
+    - rvm: jruby-head
+    - rvm: truffleruby
+    - rvm: ruby-head
+    - rvm: rbx-3
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: rbx-3
+    - rvm: truffleruby

data/Gemfile

@@ -1,19 +1,15 @@
-# frozen_string_literal: true
-
-source "https://rubygems.org"
+source 'https://rubygems.org'
 
 gemspec
 
 group :development do
-  gem "pry", require: false
+	gem 'pry'
 end
 
 group :test do
-  gem "rspec", "~> 3", require: false
-  gem "rubocop", "0.45.0", require: false
-  gem "coveralls", require: false
-end
-
-group :development, :test do
-  gem "rake"
+	gem 'benchmark-ips'
+	gem "ruby-prof", platform: :mri
+	
+	gem 'simplecov'
+	gem 'coveralls'
 end

data/README.md

@@ -1,29 +1,28 @@
-# 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].
 
-Collections of one-shot and periodic timers, intended for use with event loops.
+[![Build Status](https://secure.travis-ci.org/socketry/timers.svg)](https://travis-ci.org/socketry/timers)
+[![Code Climate](https://codeclimate.com/github/socketry/timers.svg)](https://codeclimate.com/github/socketry/timers)
+[![Coverage Status](https://coveralls.io/repos/socketry/timers/badge.svg)](https://coveralls.io/r/socketry/timers)
 
-**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.
+[async]: https://github.com/socketry/async
 
-[Celluloid]: https://github.com/celluloid/celluloid/
+## Installation
 
-## Supported platforms
+Add this line to your application's Gemfile:
 
-* Ruby 2.0, 2.1, 2.2, and 2.3
-* JRuby 9000
+```ruby
+gem 'timers'
+```
+
+And then execute:
+
+	$ bundle
+
+Or install it yourself as:
+
+	$ gem install timers
 
 ## Usage
 
@@ -105,9 +104,46 @@ timers.resume
 10.times { timers.wait } # will fire all timers
 ```
 
-## License
+## Contributing
 
-Copyright (c) 2012-2016 Celluloid timers project developers (given in the file
-AUTHORS.md).
+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
+
+## License
 
-Distributed under the MIT License. See LICENSE file for further details.
+Released under the MIT license.
+
+Copyright, 2018, by [Samuel G. D. Williams](http://www.codeotaku.com/samuel-williams).  
+Copyright, 2016, by [Tony Arcieri](bascule@gmail.com).  
+Copyright, 2016, by Jeremy Hinegardner.  
+Copyright, 2016, by Sean Gregory.  
+Copyright, 2016, by Chuck Remes.  
+Copyright, 2016, by Utenmiki.  
+Copyright, 2016, by Ron Evans.  
+Copyright, 2016, by Larry Lv.  
+Copyright, 2016, by Bruno Enten.  
+Copyright, 2016, by Jesse Cooke.  
+Copyright, 2016, by Nicholas Evans.  
+Copyright, 2016, by Dimitrij Denissenko.  
+Copyright, 2016, by Ryan LeCompte.  
+
+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/Rakefile

@@ -1,10 +1,6 @@
-# frozen_string_literal: true
 require "bundler/gem_tasks"
-
 require "rspec/core/rake_task"
-RSpec::Core::RakeTask.new
 
-require "rubocop/rake_task"
-RuboCop::RakeTask.new
+RSpec::Core::RakeTask.new(:test)
 
-task default: %w(spec rubocop)
+task :default => :test

data/lib/timers.rb

@@ -1,4 +1,9 @@
 # frozen_string_literal: true
+#
+# This file is part of the "timers" project and released under the MIT license.
+#
+# Copyright, 2018, by Samuel Williams. All rights reserved.
+#
 
 require "timers/version"
 

data/lib/timers/events.rb

@@ -1,111 +1,113 @@
 # frozen_string_literal: true
+#
+# This file is part of the "timers" project and released under the MIT license.
+#
+# Copyright, 2018, by Samuel Williams. All rights reserved.
+#
 
-require "forwardable"
-require "hitimes"
-
-require "timers/timer"
+require_relative "timer"
 
 module Timers
-  # Maintains an ordered list of events, which can be cancelled.
-  class Events
-    # Represents a cancellable handle for a specific timer event.
-    class Handle
-      def initialize(time, callback)
-        @time = time
-        @callback = callback
-      end
-
-      # The absolute time that the handle should be fired at.
-      attr_reader :time
-
-      # Cancel this timer, O(1).
-      def cancel!
-        # The simplest way to keep track of cancelled status is to nullify the
-        # callback. This should also be optimal for garbage collection.
-        @callback = nil
-      end
-
-      # Has this timer been cancelled? Cancelled timer's don't fire.
-      def cancelled?
-        @callback.nil?
-      end
-
-      def >(other)
-        @time > other.to_f
-      end
-
-      def to_f
-        @time
-      end
-
-      # Fire the callback if not cancelled with the given time parameter.
-      def fire(time)
-        @callback.call(time) if @callback
-      end
-    end
-
-    def initialize
-      # A sequence of handles, maintained in sorted order, future to present.
-      # @sequence.last is the next event to be fired.
-      @sequence = []
-    end
-
-    # Add an event at the given time.
-    def schedule(time, callback)
-      handle = Handle.new(time.to_f, callback)
-
-      index = bisect_left(@sequence, handle)
-
-      # Maintain sorted order, O(logN) insertion time.
-      @sequence.insert(index, handle)
-
-      handle
-    end
-
-    # Returns the first non-cancelled handle.
-    def first
-      while (handle = @sequence.last)
-        return handle unless handle.cancelled?
-        @sequence.pop
-      end
-    end
-
-    # Returns the number of pending (possibly cancelled) events.
-    def size
-      @sequence.size
-    end
-
-    # Fire all handles for which Handle#time is less than the given time.
-    def fire(time)
-      pop(time).reverse_each do |handle|
-        handle.fire(time)
-      end
-    end
-
-    private
-
-    # Efficiently take k handles for which Handle#time is less than the given
-    # time.
-    def pop(time)
-      index = bisect_left(@sequence, time)
-
-      @sequence.pop(@sequence.size - index)
-    end
-
-    # Return the left-most index where to insert item e, in a list a, assuming
-    # a is sorted in descending order.
-    def bisect_left(a, e, l = 0, u = a.length)
-      while l < u
-        m = l + (u - l).div(2)
-
-        if a[m] > e
-          l = m + 1
-        else
-          u = m
-        end
-      end
-
-      l
-    end
-  end
+	# Maintains an ordered list of events, which can be cancelled.
+	class Events
+		# Represents a cancellable handle for a specific timer event.
+		class Handle
+			def initialize(time, callback)
+				@time = time
+				@callback = callback
+			end
+
+			# The absolute time that the handle should be fired at.
+			attr_reader :time
+
+			# Cancel this timer, O(1).
+			def cancel!
+				# The simplest way to keep track of cancelled status is to nullify the
+				# callback. This should also be optimal for garbage collection.
+				@callback = nil
+			end
+
+			# Has this timer been cancelled? Cancelled timer's don't fire.
+			def cancelled?
+				@callback.nil?
+			end
+
+			def >(other)
+				@time > other.to_f
+			end
+
+			def to_f
+				@time
+			end
+
+			# Fire the callback if not cancelled with the given time parameter.
+			def fire(time)
+				@callback.call(time) if @callback
+			end
+		end
+
+		def initialize
+			# A sequence of handles, maintained in sorted order, future to present.
+			# @sequence.last is the next event to be fired.
+			@sequence = []
+		end
+
+		# Add an event at the given time.
+		def schedule(time, callback)
+			handle = Handle.new(time.to_f, callback)
+
+			index = bisect_left(@sequence, handle)
+
+			# Maintain sorted order, O(logN) insertion time.
+			@sequence.insert(index, handle)
+
+			handle
+		end
+
+		# Returns the first non-cancelled handle.
+		def first
+			while (handle = @sequence.last)
+				return handle unless handle.cancelled?
+				@sequence.pop
+			end
+		end
+
+		# Returns the number of pending (possibly cancelled) events.
+		def size
+			@sequence.size
+		end
+
+		# Fire all handles for which Handle#time is less than the given time.
+		def fire(time)
+			pop(time).reverse_each do |handle|
+				handle.fire(time)
+			end
+		end
+
+		private
+
+		# Efficiently take k handles for which Handle#time is less than the given
+		# time.
+		def pop(time)
+			index = bisect_left(@sequence, time)
+
+			@sequence.pop(@sequence.size - index)
+		end
+
+		# Return the left-most index where to insert item e, in a list a, assuming
+		# a is sorted in descending order.
+		def bisect_left(a, e, l = 0, u = a.length)
+			while l < u
+				m = l + (u - l).div(2)
+
+				if a[m] > e
+					l = m + 1
+				else
+					u = m
+				end
+			end
+
+			l
+		end
+	end
 end

data/lib/timers/group.rb

@@ -1,127 +1,132 @@
 # frozen_string_literal: true
+#
+# This file is part of the "timers" project and released under the MIT license.
+#
+# Copyright, 2018, by Samuel Williams. All rights reserved.
+#
 
 require "set"
 require "forwardable"
-require "hitimes"
 
-require "timers/timer"
-require "timers/events"
+require_relative "interval"
+require_relative "timer"
+require_relative "events"
 
 module Timers
-  # A collection of timers which may fire at different times
-  class Group
-    include Enumerable
-
-    extend Forwardable
-    def_delegators :@timers, :each, :empty?
-
-    def initialize
-      @events = Events.new
-
-      @timers = Set.new
-      @paused_timers = Set.new
-
-      @interval = Hitimes::Interval.new
-      @interval.start
-    end
-
-    # Scheduled events:
-    attr_reader :events
-
-    # Active timers:
-    attr_reader :timers
-
-    # Paused timers:
-    attr_reader :paused_timers
-
-    # Call the given block after the given interval. The first argument will be
-    # the time at which the group was asked to fire timers for.
-    def after(interval, &block)
-      Timer.new(self, interval, false, &block)
-    end
-
-    # Call the given block immediately, and then after the given interval. The first
-    # argument will be the time at which the group was asked to fire timers for.
-    def now_and_after(interval, &block)
-      yield
-      after(interval, &block)
-    end
-
-    # Call the given block periodically at the given interval. The first
-    # argument will be the time at which the group was asked to fire timers for.
-    def every(interval, recur = true, &block)
-      Timer.new(self, interval, recur, &block)
-    end
-
-    # Call the given block immediately, and then periodically at the given interval. The first
-    # argument will be the time at which the group was asked to fire timers for.
-    def now_and_every(interval, recur = true, &block)
-      yield
-      every(interval, recur, &block)
-    end
-
-    # Wait for the next timer and fire it. Can take a block, which should behave
-    # like sleep(n), except that n may be nil (sleep forever) or a negative
-    # number (fire immediately after return).
-    def wait
-      if block_given?
-        yield wait_interval
-
-        while (interval = wait_interval) && interval > 0
-          yield interval
-        end
-      else
-        while (interval = wait_interval) && interval > 0
-          # We cannot assume that sleep will wait for the specified time, it might be +/- a bit.
-          sleep interval
-        end
-      end
-
-      fire
-    end
-
-    # Interval to wait until when the next timer will fire.
-    # - nil: no timers
-    # - -ve: timers expired already
-    # -   0: timers ready to fire
-    # - +ve: timers waiting to fire
-    def wait_interval(offset = current_offset)
-      handle = @events.first
-      handle.time - Float(offset) if handle
-    end
-
-    # Fire all timers that are ready.
-    def fire(offset = current_offset)
-      @events.fire(offset)
-    end
-
-    # Pause all timers.
-    def pause
-      @timers.dup.each(&:pause)
-    end
-
-    # Resume all timers.
-    def resume
-      @paused_timers.dup.each(&:resume)
-    end
-
-    alias continue resume
-
-    # Delay all timers.
-    def delay(seconds)
-      @timers.each do |timer|
-        timer.delay(seconds)
-      end
-    end
-
-    # Cancel all timers.
-    def cancel
-      @timers.dup.each(&:cancel)
-    end
-
-    # The group's current time.
-    def current_offset
-      @interval.to_f
-    end
-  end
+	# A collection of timers which may fire at different times
+	class Group
+		include Enumerable
+
+		extend Forwardable
+		def_delegators :@timers, :each, :empty?
+
+		def initialize
+			@events = Events.new
+
+			@timers = Set.new
+			@paused_timers = Set.new
+
+			@interval = Interval.new
+			@interval.start
+		end
+
+		# Scheduled events:
+		attr_reader :events
+
+		# Active timers:
+		attr_reader :timers
+
+		# Paused timers:
+		attr_reader :paused_timers
+
+		# Call the given block after the given interval. The first argument will be
+		# the time at which the group was asked to fire timers for.
+		def after(interval, &block)
+			Timer.new(self, interval, false, &block)
+		end
+
+		# Call the given block immediately, and then after the given interval. The first
+		# argument will be the time at which the group was asked to fire timers for.
+		def now_and_after(interval, &block)
+			yield
+			after(interval, &block)
+		end
+
+		# Call the given block periodically at the given interval. The first
+		# argument will be the time at which the group was asked to fire timers for.
+		def every(interval, recur = true, &block)
+			Timer.new(self, interval, recur, &block)
+		end
+
+		# Call the given block immediately, and then periodically at the given interval. The first
+		# argument will be the time at which the group was asked to fire timers for.
+		def now_and_every(interval, recur = true, &block)
+			yield
+			every(interval, recur, &block)
+		end
+
+		# Wait for the next timer and fire it. Can take a block, which should behave
+		# like sleep(n), except that n may be nil (sleep forever) or a negative
+		# number (fire immediately after return).
+		def wait
+			if block_given?
+				yield wait_interval
+
+				while (interval = wait_interval) && interval > 0
+					yield interval
+				end
+			else
+				while (interval = wait_interval) && interval > 0
+					# We cannot assume that sleep will wait for the specified time, it might be +/- a bit.
+					sleep interval
+				end
+			end
+
+			fire
+		end
+
+		# Interval to wait until when the next timer will fire.
+		# - nil: no timers
+		# - -ve: timers expired already
+		# -   0: timers ready to fire
+		# - +ve: timers waiting to fire
+		def wait_interval(offset = current_offset)
+			handle = @events.first
+			handle.time - Float(offset) if handle
+		end
+
+		# Fire all timers that are ready.
+		def fire(offset = current_offset)
+			@events.fire(offset)
+		end
+
+		# Pause all timers.
+		def pause
+			@timers.dup.each(&:pause)
+		end
+
+		# Resume all timers.
+		def resume
+			@paused_timers.dup.each(&:resume)
+		end
+
+		alias continue resume
+
+		# Delay all timers.
+		def delay(seconds)
+			@timers.each do |timer|
+				timer.delay(seconds)
+			end
+		end
+
+		# Cancel all timers.
+		def cancel
+			@timers.dup.each(&:cancel)
+		end
+
+		# The group's current time.
+		def current_offset
+			@interval.to_f
+		end
+	end
 end