timers 4.3.0 → 4.3.5

data/spec/spec_helper.rb

@@ -1,40 +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'
-Bundler.require(:test)
-
-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

data/spec/timers/performance_spec.rb

@@ -1,124 +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.
-#
-
-require "spec_helper"
-
-# Event based timers:
-
-# Serviced 31812 events in 2.39075272 seconds, 13306.320832794887 e/s.
-# Thread ID: 7336700
-# Fiber ID: 30106340
-# Total: 2.384043
-# Sort by: self_time
-
-# %self      total      self      wait     child     calls  name
-# 13.48      0.510     0.321     0.000     0.189    369133  Timers::Events::Handle#<=>
-#  8.12      0.194     0.194     0.000     0.000    427278  Timers::Events::Handle#to_f
-#  4.55      0.109     0.109     0.000     0.000    427278  Float#<=>
-#  4.40      1.857     0.105     0.000     1.752    466376 *Timers::Events#bsearch
-#  4.30      0.103     0.103     0.000     0.000    402945  Float#to_f
-#  2.65      0.063     0.063     0.000     0.000     33812  Array#insert
-#  2.64      1.850     0.063     0.000     1.787     33812  Timers::Events#schedule
-#  2.40      1.930     0.057     0.000     1.873     33812  Timers::Timer#reset
-#  1.89      1.894     0.045     0.000     1.849     31812  Timers::Timer#fire
-#  1.69      1.966     0.040     0.000     1.926     31812  Timers::Events::Handle#fire
-#  1.35      0.040     0.032     0.000     0.008     33812  Timers::Events::Handle#initialize
-#  1.29      0.044     0.031     0.000     0.013     44451  Timers::Group#current_offset
-
-# SortedSet based timers:
-
-# Serviced 32516 events in 66.753277275 seconds, 487.1072288781219 e/s.
-# Thread ID: 15995640
-# Fiber ID: 38731780
-# Total: 66.716394
-# Sort by: self_time
-
-# %self      total      self      wait     child     calls  name
-# 54.73     49.718    36.513     0.000    13.205  57084873  Timers::Timer#<=>
-# 23.74     65.559    15.841     0.000    49.718     32534  Array#sort!
-# 19.79     13.205    13.205     0.000     0.000  57084873  Float#<=>
-
-# Max out events performance (on my computer):
-# Serviced 1142649 events in 11.194903921 seconds, 102068.70405115146 e/s.
-
-RSpec.describe Timers::Group do
-	context "with profiler" do
-		if defined? RubyProf
-			before(:each) do
-				# Running RubyProf makes the code slightly slower.
-				RubyProf.start
-				puts "*** Running with RubyProf reduces performance ***"
-			end
-
-			after(:each) do
-				if RubyProf.running?
-					# file = arg.metadata[:description].gsub(/\s+/, '-')
-
-					result = RubyProf.stop
-
-					printer = RubyProf::FlatPrinter.new(result)
-					printer.print($stderr, min_percent: 1.0)
-				end
-			end
-		end
-
-		it "runs efficiently" do
-			result = []
-			range = (1..500)
-			duration = 2.0
-
-			total = 0
-			range.each do |index|
-				offset = index.to_f / range.max
-				total += (duration / offset).floor
-
-				subject.every(index.to_f / range.max, :strict) { result << index }
-			end
-
-			subject.wait while result.size < total
-
-			rate = result.size.to_f / subject.current_offset
-			puts "Serviced #{result.size} events in #{subject.current_offset} seconds, #{rate} e/s."
-
-			expect(subject.current_offset).to be_within(20).percent_of(duration)
-		end
-	end
-	
-	it "runs efficiently at high volume" do
-		results = []
-		range = (1..300)
-		groups = (1..20)
-		duration = 11
-
-		timers = []
-		@mutex = Mutex.new
-		start = Time.now
-		groups.each do |gi|
-			timers << Thread.new {
-				result = []
-				timer = Timers::Group.new
-				total = 0
-				range.each do |ri|
-					offset = ri.to_f / range.max
-					total += (duration / offset).floor
-					timer.every(ri.to_f / range.max, :strict) { result << ri }
-				end
-				timer.wait while result.size < total
-				@mutex.synchronize { results += result }
-
-			}
-		end
-		timers.each { |t| t.join }
-		finish = Time.now
-
-		rate = results.size.to_f / ( runtime = finish - start )
-
-		puts "Serviced #{results.size} events in #{runtime} seconds, #{rate} e/s; across #{groups.max} timers."
-
-		expect(runtime).to be_within(20).percent_of(duration)
-	end
-end

data/spec/timers/strict_spec.rb

@@ -1,39 +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 not diverge too much" do
-		fired = :not_fired_yet
-		count = 0
-		quantum = 0.01
-
-		start_offset = subject.current_offset
-		Timers::Timer.new(subject, quantum, :strict, start_offset) do |offset|
-			fired = offset
-			count += 1
-		end
-
-		iterations = 1000
-		subject.wait while count < iterations
-
-		# In my testing on the JVM, without the :strict recurring, I noticed 60ms of error here.
-		expect(fired - start_offset).to be_within(quantum).of(iterations * quantum)
-	end
-
-	it "should only fire 0-interval timer once per iteration" do
-		count = 0
-		
-		start_offset = subject.current_offset
-		Timers::Timer.new(subject, 0, :strict, start_offset) do |offset, timer|
-			count += 1
-		end
-		
-		subject.wait
-		
-		expect(count).to be == 1
-	end
-end

data/spec/timers/wait_spec.rb

@@ -1,35 +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.
-#
-
-require "spec_helper"
-require "timers/wait"
-
-RSpec.describe Timers::Wait do
-	it "repeats until timeout expired" do
-		timeout = Timers::Wait.new(5)
-		count = 0
-
-		timeout.while_time_remaining do |remaining|
-			expect(remaining).to be_within(TIMER_QUANTUM).of(timeout.duration - count)
-
-			count += 1
-			sleep 1
-		end
-
-		expect(count).to eq(5)
-	end
-
-	it "yields results as soon as possible" do
-		timeout = Timers::Wait.new(5)
-
-		result = timeout.while_time_remaining do |_remaining|
-			break :done
-		end
-
-		expect(result).to eq(:done)
-	end
-end

data/timers.gemspec

@@ -1,33 +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.
-#
-
-require_relative 'lib/timers/version'
-
-Gem::Specification.new do |spec|
-	spec.name          = "timers"
-	spec.version       = Timers::VERSION
-	spec.authors       = ["Samuel Williams", "Tony Arcieri"]
-	spec.email         = ["samuel@codeotaku.com", "bascule@gmail.com"]
-	spec.licenses      = ["MIT"]
-	spec.homepage      = "https://github.com/socketry/timers"
-	spec.summary       = "Pure Ruby one-shot and periodic timers"
-	spec.description = <<-DESCRIPTION.strip.gsub(/\s+/, " ")
-		Schedule procs to run after a certain time, or at periodic intervals,
-		using any API that accepts a timeout.
-	DESCRIPTION
-
-	spec.files         = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
-	spec.executables   = spec.files.grep(%r{^bin/}).map { |f| File.basename(f) }
-	spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-	spec.require_paths = ["lib"]
-
-	spec.required_ruby_version = '>= 2.2.1'
-
-	spec.add_development_dependency "bundler"
-	spec.add_development_dependency "rspec", "~> 3.6"
-	spec.add_development_dependency "rake"
-end