timers 4.1.2 → 4.2.0

data/spec/timers/cancel_spec.rb

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

data/spec/timers/events_spec.rb

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

data/spec/timers/every_spec.rb

@@ -1,33 +1,38 @@
 # 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 = []
+	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 }
+		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
+		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
+		expect(result).to be == [:a, :c, :a, :a, :b, :d]
+	end
 
-  it "should fire immediately and then several times later" do
-    result = []
+	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 }
+		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
+		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
+		expect(result).to be == [:c, :d, :a, :c, :a, :a, :b, :d]
+	end
 end

data/spec/timers/group_spec.rb

@@ -1,255 +1,260 @@
 # 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
+	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
+			subject.wait do |interval|
+				expect(interval).to be_nil
+				called = true
+			end
 
-      expect(called).to be true
-    end
+			expect(called).to be true
+		end
 
-    it "calls the wait block with an interval" do
-      called = false
-      fired = false
+		it "calls the wait block with an interval" do
+			called = false
+			fired = false
 
-      subject.after(0.1) { fired = true }
+			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
+			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
+			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
+	it "sleeps until the next timer" do
+		interval   = TIMER_QUANTUM * 2
+		started_at = Time.now
 
-    fired = false
-    subject.after(interval) { fired = true }
-    subject.wait
+		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:[\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:[\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:[\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
+		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