timers 4.2.0 → 4.3.3

data/.rspec

@@ -1,3 +0,0 @@
---format documentation
---warnings
---require spec_helper

data/.travis.yml

@@ -1,19 +0,0 @@
-language: ruby
-sudo: false
-dist: xenial
-cache: bundler
-
-matrix:
-  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,15 +0,0 @@
-source 'https://rubygems.org'
-
-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,149 +0,0 @@
-# Timers
-
-Collections of one-shot and periodic timers, intended for use with event loops such as [async].
-
-[![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)
-
-[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`:
-
-```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
-```
-
-## 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,6 +0,0 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-
-RSpec::Core::RakeTask.new(:test)
-
-task :default => :test

data/spec/spec_helper.rb

@@ -1,38 +0,0 @@
-# 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.
-#
-
-# Level of accuracy enforced by tests (50ms)
-TIMER_QUANTUM = 0.05
-
-if ENV['COVERAGE'] || ENV['TRAVIS']
-	begin
-		require 'simplecov'
-		
-		SimpleCov.start do
-			add_filter "/spec/"
-		end
-		
-		if ENV['TRAVIS']
-			require 'coveralls'
-			Coveralls.wear!
-		end
-	rescue LoadError
-		warn "Could not load simplecov: #{$!}"
-	end
-end
-
-require "bundler/setup"
-require "timers"
-
-RSpec.configure do |config|
-	# Enable flags like --only-failures and --next-failure
-	config.example_status_persistence_file_path = ".rspec_status"
-
-	config.expect_with :rspec do |c|
-		c.syntax = :expect
-	end
-end

data/spec/timers/cancel_spec.rb

@@ -1,50 +0,0 @@
-# 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.
-#
-
-RSpec.describe Timers::Group do
-	it "should be able to cancel twice" do
-		fired = false
-
-		timer = subject.after(0.1) { fired = true }
-
-		2.times do
-			timer.cancel
-			subject.wait
-		end
-
-		expect(fired).to be false
-	end
-
-	it "should be possble to reset after cancel" do
-		fired = false
-
-		timer = subject.after(0.1) { fired = true }
-		timer.cancel
-
-		subject.wait
-
-		timer.reset
-
-		subject.wait
-
-		expect(fired).to be true
-	end
-
-	it "should cancel and remove one shot timers after they fire" do
-		x = 0
-
-		Timers::Wait.for(2) do |_remaining|
-			timer = subject.every(0.2) { x += 1 }
-			subject.after(0.1) { timer.cancel }
-
-			subject.wait
-		end
-
-		expect(subject.timers).to be_empty
-		expect(x).to be == 0
-	end
-end

data/spec/timers/events_spec.rb

@@ -1,61 +0,0 @@
-# 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.
-#
-
-RSpec.describe Timers::Events do
-	it "should register an event" do
-		fired = false
-
-		callback = proc do |_time|
-			fired = true
-		end
-
-		subject.schedule(0.1, callback)
-
-		expect(subject.size).to be == 1
-
-		subject.fire(0.15)
-
-		expect(subject.size).to be == 0
-
-		expect(fired).to be true
-	end
-
-	it "should register events in order" do
-		fired = []
-
-		times = [0.95, 0.1, 0.3, 0.5, 0.4, 0.2, 0.01, 0.9]
-
-		times.each do |requested_time|
-			callback = proc do |_time|
-				fired << requested_time
-			end
-
-			subject.schedule(requested_time, callback)
-		end
-
-		subject.fire(0.5)
-		expect(fired).to be == times.sort.first(6)
-
-		subject.fire(1.0)
-		expect(fired).to be == times.sort
-	end
-
-	it "should fire events with the time they were fired at" do
-		fired_at = :not_fired
-
-		callback = proc do |time|
-			# The time we actually were fired at:
-			fired_at = time
-		end
-
-		subject.schedule(0.5, callback)
-
-		subject.fire(1.0)
-
-		expect(fired_at).to be == 1.0
-	end
-end

data/spec/timers/every_spec.rb

@@ -1,38 +0,0 @@
-# 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.
-#
-
-RSpec.describe Timers::Group do
-	it "should fire several times" do
-		result = []
-
-		subject.every(0.7) { result << :a }
-		subject.every(2.3) { result << :b }
-		subject.every(1.3) { result << :c }
-		subject.every(2.4) { result << :d }
-
-		Timers::Wait.for(2.5) do |remaining|
-			subject.wait if subject.wait_interval < remaining
-		end
-
-		expect(result).to be == [:a, :c, :a, :a, :b, :d]
-	end
-
-	it "should fire immediately and then several times later" do
-		result = []
-
-		subject.every(0.7) { result << :a }
-		subject.every(2.3) { result << :b }
-		subject.now_and_every(1.3) { result << :c }
-		subject.now_and_every(2.4) { result << :d }
-
-		Timers::Wait.for(2.5) do |remaining|
-			subject.wait if subject.wait_interval < remaining
-		end
-
-		expect(result).to be == [:c, :d, :a, :c, :a, :a, :b, :d]
-	end
-end

data/spec/timers/group_spec.rb

@@ -1,260 +0,0 @@
-# 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.
-#
-
-RSpec.describe Timers::Group do
-	describe "#wait" do
-		it "calls the wait block with nil" do
-			called = false
-
-			subject.wait do |interval|
-				expect(interval).to be_nil
-				called = true
-			end
-
-			expect(called).to be true
-		end
-
-		it "calls the wait block with an interval" do
-			called = false
-			fired = false
-
-			subject.after(0.1) { fired = true }
-
-			subject.wait do |interval|
-				expect(interval).to be_within(TIMER_QUANTUM).of(0.1)
-				called = true
-				sleep 0.2
-			end
-
-			expect(called).to be true
-			expect(fired).to be true
-		end
-	end
-
-	it "sleeps until the next timer" do
-		interval   = TIMER_QUANTUM * 2
-		started_at = Time.now
-
-		fired = false
-		subject.after(interval) { fired = true }
-		subject.wait
-
-		expect(fired).to be true
-		expect(Time.now - started_at).to be_within(TIMER_QUANTUM).of interval
-	end
-
-	it "fires instantly when next timer is in the past" do
-		fired = false
-		subject.after(TIMER_QUANTUM) { fired = true }
-		sleep(TIMER_QUANTUM * 2)
-		subject.wait
-
-		expect(fired).to be true
-	end
-
-	it "calculates the interval until the next timer should fire" do
-		interval = 0.1
-
-		subject.after(interval)
-		expect(subject.wait_interval).to be_within(TIMER_QUANTUM).of interval
-
-		sleep(interval)
-		expect(subject.wait_interval).to be <= 0
-	end
-
-	it "fires timers in the correct order" do
-		result = []
-
-		subject.after(TIMER_QUANTUM * 2) { result << :two }
-		subject.after(TIMER_QUANTUM * 3) { result << :three }
-		subject.after(TIMER_QUANTUM * 1) { result << :one }
-
-		sleep TIMER_QUANTUM * 4
-		subject.fire
-
-		expect(result).to eq [:one, :two, :three]
-	end
-
-	it "raises TypeError if given an invalid time" do
-		expect do
-			subject.after(nil) { nil }
-		end.to raise_exception(TypeError)
-	end
-
-	describe "recurring timers" do
-		it "continues to fire the timers at each interval" do
-			result = []
-
-			subject.every(TIMER_QUANTUM * 2) { result << :foo }
-
-			sleep TIMER_QUANTUM * 3
-			subject.fire
-			expect(result).to eq [:foo]
-
-			sleep TIMER_QUANTUM * 5
-			subject.fire
-			expect(result).to eq [:foo, :foo]
-		end
-	end
-
-	it "calculates the proper interval to wait until firing" do
-		interval_ms = 25
-
-		subject.after(interval_ms / 1000.0)
-
-		expect(subject.wait_interval).to be_within(TIMER_QUANTUM).of(interval_ms / 1000.0)
-	end
-
-	describe "pause and continue timers" do
-		before(:each) do
-			@interval = TIMER_QUANTUM * 2
-
-			@fired = false
-			@timer = subject.after(@interval) { @fired = true }
-			@fired2 = false
-			@timer2 = subject.after(@interval) { @fired2 = true }
-		end
-
-		it "does not fire when paused" do
-			@timer.pause
-			subject.wait
-			expect(@fired).to be false
-		end
-
-		it "fires when continued after pause" do
-			@timer.pause
-			subject.wait
-			@timer.resume
-
-			sleep @timer.interval
-			subject.wait
-
-			expect(@fired).to be true
-		end
-
-		it "can pause all timers at once" do
-			subject.pause
-			subject.wait
-			expect(@fired).to be false
-			expect(@fired2).to be false
-		end
-
-		it "can continue all timers at once" do
-			subject.pause
-			subject.wait
-			subject.resume
-
-			# We need to wait until we are sure both timers will fire, otherwise highly accurate clocks
-			# (e.g. JVM)may only fire the first timer, but not the second, because they are actually
-			# schedueled at different times.
-			sleep TIMER_QUANTUM * 2
-			subject.wait
-
-			expect(@fired).to be true
-			expect(@fired2).to be true
-		end
-
-		it "can fire the timer directly" do
-			fired = false
-			timer = subject.after(TIMER_QUANTUM * 1) { fired = true }
-			timer.pause
-			subject.wait
-			expect(fired).not_to be true
-			timer.resume
-			expect(fired).not_to be true
-			timer.fire
-			expect(fired).to be true
-		end
-	end
-
-	describe "delay timer" do
-		it "adds appropriate amount of time to timer" do
-			timer = subject.after(10)
-			timer.delay(5)
-			expect(timer.offset - subject.current_offset).to be_within(TIMER_QUANTUM).of(15)
-		end
-	end
-
-	describe "delay timer collection" do
-		it "delay on set adds appropriate amount of time to all timers" do
-			timer = subject.after(10)
-			timer2 = subject.after(20)
-			subject.delay(5)
-			expect(timer.offset - subject.current_offset).to be_within(TIMER_QUANTUM).of(15)
-			expect(timer2.offset - subject.current_offset).to be_within(TIMER_QUANTUM).of(25)
-		end
-	end
-
-	describe "on delaying a timer" do
-		it "fires timers in the correct order" do
-			result = []
-
-			subject.after(TIMER_QUANTUM * 2) { result << :two }
-			subject.after(TIMER_QUANTUM * 3) { result << :three }
-			first = subject.after(TIMER_QUANTUM * 1) { result << :one }
-			first.delay(TIMER_QUANTUM * 3)
-
-			sleep TIMER_QUANTUM * 5
-			subject.fire
-
-			expect(result).to eq [:two, :three, :one]
-		end
-	end
-
-	describe "#inspect" do
-		it "before firing" do
-			fired = false
-			timer = subject.after(TIMER_QUANTUM * 5) { fired = true }
-			timer.pause
-			expect(fired).not_to be true
-			expect(timer.inspect).to match(/\A#<Timers::Timer:0x[\da-f]+ fires in [-\.\de]+ seconds>\Z/)
-		end
-
-		it "after firing" do
-			fired = false
-			timer = subject.after(TIMER_QUANTUM) { fired = true }
-
-			subject.wait
-
-			expect(fired).to be true
-			expect(timer.inspect).to match(/\A#<Timers::Timer:0x[\da-f]+ fired [-\.\de]+ seconds ago>\Z/)
-		end
-
-		it "recurring firing" do
-			result = []
-			timer = subject.every(TIMER_QUANTUM) { result << :foo }
-
-			subject.wait
-			expect(result).not_to be_empty
-			regex = /\A#<Timers::Timer:0x[\da-f]+ fires in [-\.\de]+ seconds, recurs every #{format("%0.2f", TIMER_QUANTUM)}>\Z/
-			expect(timer.inspect).to match(regex)
-		end
-	end
-
-	describe "#fires_in" do
-		let(:interval) { TIMER_QUANTUM * 2 }
-
-		it "calculates the interval until the next fire if it's recurring" do
-			timer = subject.every(interval) { true }
-			expect(timer.fires_in).to be_within(TIMER_QUANTUM).of(interval)
-		end
-
-		context "when timer is not recurring" do
-			let!(:timer) { subject.after(interval) { true } }
-
-			it "calculates the interval until the next fire if it hasn't already fired" do
-				expect(timer.fires_in).to be_within(TIMER_QUANTUM).of(interval)
-			end
-
-			it "calculates the interval since last fire if already fired" do
-				subject.wait
-				sleep(interval)
-				expect(timer.fires_in).to be_within(TIMER_QUANTUM).of(0 - interval)
-			end
-		end
-	end
-end