timers 4.1.2 → 4.3.5

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

data/spec/timers/strict_spec.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-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 once" do
-    fired = :not_fired_yet
-    count = 0
-
-    start_offset = subject.current_offset
-    Timers::Timer.new(subject, 0, :strict, start_offset) do |offset|
-      fired = offset
-      count += 1
-    end
-
-    subject.wait
-
-    expect(count).to be == 1
-  end
-end

data/spec/timers/wait_spec.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-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,26 +0,0 @@
-# -*- encoding: utf-8 -*-
-# frozen_string_literal: true
-
-require File.expand_path("../lib/timers/version", __FILE__)
-
-Gem::Specification.new do |gem|
-  gem.name          = "timers"
-  gem.version       = Timers::VERSION
-  gem.authors       = ["Tony Arcieri"]
-  gem.email         = ["bascule@gmail.com"]
-  gem.licenses      = ["MIT"]
-  gem.homepage      = "https://github.com/celluloid/timers"
-  gem.summary       = "Pure Ruby one-shot and periodic timers"
-  gem.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
-
-  gem.files         = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
-  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.require_paths = ["lib"]
-  gem.add_runtime_dependency "hitimes"
-
-  gem.add_development_dependency "bundler"
-end