timers 4.1.2 → 4.3.2

data/Rakefile

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

data/spec/spec_helper.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require "coveralls"
-Coveralls.wear!
-
-require "bundler/setup"
-require "timers"
-
-# Level of accuracy enforced by tests (50ms)
-TIMER_QUANTUM = 0.05
-
-RSpec.configure do |config|
-  # Setting this config option `false` removes rspec-core's monkey patching of the
-  # top level methods like `describe`, `shared_examples_for` and `shared_context`
-  # on `main` and `Module`. The methods are always available through the `RSpec`
-  # module like `RSpec.describe` regardless of this setting.
-  # For backwards compatibility this defaults to `true`.
-  #
-  # https://relishapp.com/rspec/rspec-core/v/3-0/docs/configuration/global-namespace-dsl
-  config.expose_dsl_globally = false
-end

data/spec/timers/cancel_spec.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-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,56 +0,0 @@
-# frozen_string_literal: true
-
-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,33 +0,0 @@
-# frozen_string_literal: true
-
-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,255 +0,0 @@
-# frozen_string_literal: true
-
-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:[\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
-end

data/spec/timers/performance_spec.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-# 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
-  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(TIMER_QUANTUM).of(duration)
-  end
-
-  #   it "runs efficiently at high volume" do
-  #     results = []
-  #     range = (1..300)
-  #     groups = (1..20)
-  #     duration = 101
-  #
-  #     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(TIMER_QUANTUM).of(duration)
-  #   end
-end