timers 4.1.1 → 4.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 107c4a8a97789c9580117a8eca6cb72af1390d54
-  data.tar.gz: 6687f8c8b655ce609a3ecf0a4519dd001baf4e2b
+SHA256:
+  metadata.gz: e1665f074c230a801e0eb6648214a6d0248d4baada8da1f4e60abd0983bba517
+  data.tar.gz: de4eac12ecba1826d6ae5ef1d6958a451595b1a9e8e54dba7f1718d7f15182dd
 SHA512:
-  metadata.gz: 5f838fdcc30e595940ffc40325aea12578b16bf91a279feeafa247eb2d349d2724ec96715ab6d392531efcf7ff9f9e9a44a19b977bfb13a32629ead0a4358bda
-  data.tar.gz: 1fba4a0bad3f7b284ed4a45e6cc1e156cf66082041ec7a767cad14471e3b82a0c4bf068ea874d5e9f6bb90e3a8a571c73ebb710cb50df0d809dc3d65b470fffb
+  metadata.gz: c0e005f02975d324b7fbe7d8e284a2d5318be78352e129ce00abf20594d3e6a18b30103e1137b2d9fe91bd5a2251e7b22fb5cdc255f5153f219bf90bd3b6160d
+  data.tar.gz: 64210a85d0a8efe2540d9ee6da050c5d8298a5332bd2ba14758bd784a7f991ad40b1f828b47320525ab025249859ca6419f172421492fe6ced56a76e34820541

data/.rspec

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

data/.travis.yml

@@ -1,18 +1,19 @@
-rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1.2
-  - ruby-head
-  - jruby
-  - jruby-head
-  - rbx-2
+language: ruby
+sudo: false
+dist: xenial
+cache: bundler
 
 matrix:
-  fast_finish: true
+  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: jruby-head
-    - rvm: rbx-2
-
-notifications:
-  irc: "irc.freenode.org#celluloid"
+    - rvm: rbx-3
+    - rvm: truffleruby

data/Gemfile

@@ -1,6 +1,15 @@
 source 'https://rubygems.org'
 
-gem 'coveralls', :require => false
-
-# Specify your gem's dependencies in timers.gemspec
 gemspec
+
+group :development do
+	gem 'pry'
+end
+
+group :test do
+	gem 'benchmark-ips'
+	gem "ruby-prof", platform: :mri
+	
+	gem 'simplecov'
+	gem 'coveralls'
+end

data/README.md

@@ -1,20 +1,30 @@
-Timers
-======
-[![Gem Version](https://badge.fury.io/rb/timers.png)](http://rubygems.org/gems/timers)
-[![Build Status](https://secure.travis-ci.org/celluloid/timers.png?branch=master)](http://travis-ci.org/celluloid/timers)
-[![Code Climate](https://codeclimate.com/github/celluloid/timers.png)](https://codeclimate.com/github/celluloid/timers)
-[![Coverage Status](https://coveralls.io/repos/celluloid/timers/badge.png?branch=master)](https://coveralls.io/r/celluloid/timers)
+# Timers
 
-Ruby timer collections. Schedule several procs to fire after configurable delays
-or at periodic intervals.
+Collections of one-shot and periodic timers, intended for use with event loops such as [async].
 
-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.
+[![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)
 
-Usage
------
+[async]: https://github.com/socketry/async
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'timers'
+```
+
+And then execute:
+
+	$ bundle
+
+Or install it yourself as:
+
+	$ gem install timers
+
+## Usage
 
 Create a new timer group with `Timers::Group.new`:
 
@@ -94,10 +104,46 @@ 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.
+## Contributing
+
+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
+
+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,7 +1,6 @@
-#!/usr/bin/env rake
 require "bundler/gem_tasks"
-require 'rspec/core/rake_task'
+require "rspec/core/rake_task"
 
-RSpec::Core::RakeTask.new
+RSpec::Core::RakeTask.new(:test)
 
-task :default => :spec
+task :default => :test

data/lib/timers/events.rb

@@ -1,116 +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 :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)
-        if @callback
-          @callback.call(time)
-        end
-      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)
-      
-      return handle
-    end
-    
-    # Returns the first non-cancelled handle.
-    def first
-      while handle = @sequence.last
-        if handle.cancelled?
-          @sequence.pop
-        else
-          return handle
-        end
-      end
-      # @sequence.reverse.find { |handle| !handle.cancelled? }
-    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
-      
-      return 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