timers 2.0.0 → 3.0.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1bb812d219dd39a2f06dbead6028d0a472d43358
-  data.tar.gz: 069ca7cb58645d3a4bc419166d67842eb482a375
+  metadata.gz: 3e9bfe42a47fd75ccdb65871da796a7f8fc34c06
+  data.tar.gz: 1b399be03f9c02b444b1564f63694bb41b81ecde
 SHA512:
-  metadata.gz: 49534f3d20dab0cff520e02592ed0f4850230454f6fae5165990df3ad71b408b54ffe1c3e362954dc4f0fa9271f5a436f31c6bdb50b40b83d44d3aaac180c1b1
-  data.tar.gz: b26cf3a87ac426cc12b336ef16f3081b302da9ebd8d5e631a7ddfc5c7aed64544c4d8e1aec13dd36f1e36771506a5e077b1b0a6dca91763d2a8eb40288047dc5
+  metadata.gz: 61ac36cb1df7d08dc523bd198d3cc510a7d59db6e21a25e7641b9bd3f8d3106518a99ec8691933c2ef64fd5d1abc43e3b2a7f5543baa4ebd7fb09fd5df7f07b0
+  data.tar.gz: c1679de4914d8d11ebccc3e8cc9ab833e9f14ca24ce5cd5bc601b40f5a6dac5cd42268375f15e04e157e8695f0d9ffd26f79c98aec25ac98a6682e7a725555c5

data/.rspec

@@ -1,4 +1,5 @@
 --color
 --format documentation
 --backtrace
---default_path spec
+--order random
+--warnings

data/.travis.yml

@@ -1,16 +1,17 @@
 rvm:
   - 1.9.3
   - 2.0.0
+  - 2.1.2
   - ruby-head
   - jruby
   - jruby-head
-  - rbx
+  - rbx-2
 
 matrix:
   allow_failures:
     - rvm: ruby-head
     - rvm: jruby-head
-    - rvm: rbx
+    - rvm: rbx-2
 
 notifications:
   irc: "irc.freenode.org#celluloid"

data/AUTHORS.md

@@ -0,0 +1,15 @@
+# The Celluloid timers gem is beamed directly to you from the minds of...
+
+- Tony Arcieri <bascule@gmail.com>
+- Jeremy Hinegardner
+- Sean Gregory
+- Chuck Remes
+- Utenmiki
+- Ron Evans
+- Larry Lv
+- Bruno Enten
+- Jesse Cooke
+- Nicholas Evans
+- Dimitrij Denissenko
+- Ryan LeCompte
+- Samuel G. D. Williams

data/CHANGES.md

@@ -1,3 +1,9 @@
+3.0.0.pre
+---------
+* Refactor `Timers` class into `Timers::Group`
+* Add `Timers::Timeout` class for implementing timeouts
+* Fix timer fudging
+
 2.0.0 (2013-12-30)
 ------------------
 * Switch to Hitimes for high precision monotonic counters

data/LICENSE

@@ -1,4 +1,5 @@
-Copyright (c) 2012 Tony Arcieri
+Copyright (c) 2012-14 The Celluloid Timers Developers: given in the file
+AUTHORS.md at https://github.com/celluloid/timers/blob/master/AUTHORS.md
 
 MIT License
 
@@ -19,4 +20,4 @@ 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.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -90,5 +90,7 @@ timers.continue
 License
 -------
 
-Copyright (c) 2012 Tony Arcieri. Distributed under the MIT License. See
-LICENSE for further details.
+Copyright (c) 2014 Celluloid timers project developers (given in the file
+AUTHORS.md).
+
+Distributed under the MIT License. See LICENSE file for further details.

data/lib/timers.rb

@@ -1,176 +1,9 @@
-require 'set'
-require 'forwardable'
-require 'timers/version'
-require 'hitimes'
 
 # Workaround for thread safety issues in SortedSet initialization
 # See: https://github.com/celluloid/timers/issues/20
 SortedSet.new
 
-class Timers
-  include Enumerable
-  extend  Forwardable
-  def_delegators :@timers, :delete, :each, :empty?
-
-  def initialize
-    @timers = SortedSet.new
-    @paused_timers = SortedSet.new
-    @interval = Hitimes::Interval.new
-    @interval.start
-  end
-
-  # Call the given block after the given interval
-  def after(interval, &block)
-    Timer.new(self, interval, false, &block)
-  end
-
-  # Call the given block after the given interval has expired. +interval+
-  # is measured in milliseconds.
-  #
-  #  Timer.new.after_milliseconds(25) { puts "fired!" }
-  #
-  def after_milliseconds(interval, &block)
-    after(interval / 1000.0, &block)
-  end
-  alias_method :after_ms, :after_milliseconds
-
-  # Call the given block periodically at the given interval
-  def every(interval, &block)
-    Timer.new(self, interval, true, &block)
-  end
-
-  # Wait for the next timer and fire it
-  def wait
-    i = wait_interval
-    sleep i if i
-    fire
-  end
-
-  # Interval to wait until when the next timer will fire
-  def wait_interval(offset = self.current_offset)
-    timer = @timers.first
-    return unless timer
-    interval = timer.offset - Float(offset)
-    interval > 0 ? interval : 0
-  end
-
-  # Fire all timers that are ready
-  def fire(offset = self.current_offset)
-    time = Float(offset) + 0.001 # Fudge 1ms in case of clock imprecision
-    while (timer = @timers.first) && (time >= timer.offset)
-      @timers.delete timer
-      timer.fire(offset)
-    end
-  end
-
-  def add(timer)
-    raise TypeError, "not a Timers::Timer" unless timer.is_a? Timers::Timer
-    @timers.add(timer)
-  end
-
-  def pause(timer = nil)
-    return pause_all if timer.nil?
-    raise TypeError, "not a Timers::Timer" unless timer.is_a? Timers::Timer
-    @timers.delete timer
-    @paused_timers.add timer
-  end
-
-  def pause_all
-    @timers.each {|timer| timer.pause}
-  end
-
-  def continue(timer = nil)
-    return continue_all if timer.nil?
-    raise TypeError, "not a Timers::Timer" unless timer.is_a? Timers::Timer
-    @paused_timers.delete timer
-    @timers.add timer
-  end
-
-  def continue_all
-    @paused_timers.each {|timer| timer.continue}
-  end
-
-  def delay(seconds)
-    @timers.each {|timer| timer.delay(seconds)}
-  end
-
-  alias_method :cancel, :delete
-
-  def current_offset
-    @interval.to_f
-  end
-
-  # An individual timer set to fire a given proc at a given time
-  class Timer
-    include Comparable
-    attr_reader :interval, :offset, :recurring
-
-    def initialize(timers, interval, recurring = false, &block)
-      @timers, @interval, @recurring = timers, interval, recurring
-      @block  = block
-      @offset = nil
-
-      reset
-    end
-
-    def <=>(other)
-      @offset <=> other.offset
-    end
-
-    # Cancel this timer
-    def cancel
-      @timers.cancel self
-    end
-
-    # Extend this timer
-    def delay(seconds)
-      @timers.delete self
-      @offset += seconds
-      @timers.add self
-    end
-
-    # Reset this timer
-    def reset(offset = @timers.current_offset)
-      @timers.cancel self if @time
-      @offset = Float(offset) + @interval
-      @timers.add self
-    end
-
-    # Fire the block
-    def fire(offset = @timers.current_offset)
-      reset(offset) if recurring
-      @block.call
-    end
-    alias_method :call, :fire
-
-    # Pause this timer
-    def pause
-      @timers.pause self
-    end
-
-    # Continue this timer
-    def continue
-      @timers.continue self
-    end
-
-    # Inspect a timer
-    def inspect
-      str = "#<Timers::Timer:#{object_id.to_s(16)} "
-      offset = @timers.current_offset
-
-      if @offset
-        if @offset >= offset
-          str << "fires in #{@offset - offset} seconds"
-        else
-          str << "fired #{offset - @offset} seconds ago"
-        end
-
-        str << ", recurs every #{interval}" if recurring
-      else
-        str << "dead"
-      end
+require 'timers/version'
 
-      str << ">"
-    end
-  end
-end
+require 'timers/group'
+require 'timers/timeout'

data/lib/timers/group.rb

@@ -0,0 +1,106 @@
+
+require 'set'
+require 'forwardable'
+require 'hitimes'
+
+require 'timers/timer'
+
+module Timers
+  class Group
+    include Enumerable
+    extend  Forwardable
+    def_delegators :@timers, :delete, :each, :empty?
+
+    def initialize
+      @timers = SortedSet.new
+      @paused_timers = SortedSet.new
+      @interval = Hitimes::Interval.new
+      @interval.start
+    end
+
+    # Call the given block after the given interval
+    def after(interval, &block)
+      Timer.new(self, interval, false, &block)
+    end
+
+    # Call the given block after the given interval has expired. +interval+
+    # is measured in milliseconds.
+    #
+    #  Timer.new.after_milliseconds(25) { puts "fired!" }
+    #
+    def after_milliseconds(interval, &block)
+      after(interval / 1000.0, &block)
+    end
+    alias_method :after_ms, :after_milliseconds
+
+    # Call the given block periodically at the given interval
+    def every(interval, &block)
+      Timer.new(self, interval, true, &block)
+    end
+
+    # Wait for the next timer and fire it
+    def wait
+      # Repeatedly call sleep until there is no longer any wait_interval:
+      while i = wait_interval
+        # We cannot assume that sleep will wait for the specified time, it might be +/- a bit.
+        sleep i
+      end
+      
+      fire
+    end
+
+    # Interval to wait until when the next timer will fire
+    def wait_interval(offset = self.current_offset)
+      timer = @timers.first
+      return unless timer
+      interval = timer.offset - Float(offset)
+      interval > 0 ? interval : nil
+    end
+
+    # Fire all timers that are ready
+    def fire(offset = self.current_offset)
+      time = Float(offset)
+      while (timer = @timers.first) && (time >= timer.offset)
+        @timers.delete timer
+        timer.fire(offset)
+      end
+    end
+
+    def add(timer)
+      raise TypeError, "not a Timers::Timer" unless timer.is_a? Timers::Timer
+      @timers.add(timer)
+    end
+
+    def pause(timer = nil)
+      return pause_all if timer.nil?
+      raise TypeError, "not a Timers::Timer" unless timer.is_a? Timers::Timer
+      @timers.delete timer
+      @paused_timers.add timer
+    end
+
+    def pause_all
+      @timers.each {|timer| timer.pause}
+    end
+
+    def continue(timer = nil)
+      return continue_all if timer.nil?
+      raise TypeError, "not a Timers::Timer" unless timer.is_a? Timers::Timer
+      @paused_timers.delete timer
+      @timers.add timer
+    end
+
+    def continue_all
+      @paused_timers.each {|timer| timer.continue}
+    end
+
+    def delay(seconds)
+      @timers.each {|timer| timer.delay(seconds)}
+    end
+
+    alias_method :cancel, :delete
+
+    def current_offset
+      @interval.to_f
+    end
+  end
+end

data/lib/timers/timeout.rb

@@ -0,0 +1,36 @@
+
+require 'hitimes'
+
+module Timers
+  # An exclusive, monotonic timeout class.
+  class Timeout
+    def initialize(duration)
+      @duration = duration
+      @remaining = true
+    end
+    
+    attr :duration
+    attr :remaining
+    
+    # Yields while time remains for work to be done:
+    def while_time_remaining(&block)
+      @interval = Hitimes::Interval.new
+      @interval.start
+      
+      while time_remaining?
+        yield @remaining
+      end
+    ensure
+      @interval.stop
+      @interval = nil
+    end
+    
+    private
+    
+    def time_remaining?
+      @remaining = (@duration - @interval.duration)
+    
+      return @remaining > 0
+    end
+  end
+end

data/lib/timers/timer.rb

@@ -0,0 +1,86 @@
+
+module Timers
+  # An individual timer set to fire a given proc at a given time
+  class Timer
+    include Comparable
+    attr_reader :interval, :offset, :recurring
+
+    def initialize(timers, interval, recurring = false, &block)
+      @timers, @interval, @recurring = timers, interval, recurring
+      @block  = block
+      @offset = nil
+
+      reset
+    end
+
+    def <=>(other)
+      @offset <=> other.offset
+    end
+
+    # Cancel this timer
+    def cancel
+      @timers.cancel self
+    end
+
+    # Extend this timer
+    def delay(seconds)
+      @timers.delete self
+      @offset += seconds
+      @timers.add self
+    end
+
+    # Reset this timer
+    def reset(offset = @timers.current_offset)
+      @timers.cancel self if @offset
+      @offset = Float(offset) + @interval
+      @timers.add self
+    end
+
+    # Fire the block
+    def fire(offset = @timers.current_offset)
+      if recurring
+        reset(offset)
+      else
+        @offset = offset
+      end
+      
+      @block.call
+    end
+    alias_method :call, :fire
+
+    # Pause this timer
+    def pause
+      @timers.pause self
+    end
+
+    # Continue this timer
+    def continue
+      @timers.continue self
+    end
+
+    # Number of seconds until next fire / since last fire
+    def fires_in
+      @offset - @timers.current_offset if @offset
+    end
+
+    # Inspect a timer
+    def inspect
+      str = "#<Timers::Timer:#{object_id.to_s(16)} "
+      offset = @timers.current_offset
+
+      if @offset
+        if fires_in >= 0
+          str << "fires in #{fires_in} seconds"
+        else
+          str << "fired #{fires_in.abs} seconds ago"
+        end
+
+        str << ", recurs every #{interval}" if recurring
+      else
+        str << "dead"
+      end
+
+      str << ">"
+    end
+  end
+end

data/lib/timers/version.rb

@@ -1,3 +1,3 @@
-class Timers
-  VERSION = "2.0.0"
+module Timers
+  VERSION = "3.0.0.pre"
 end

data/spec/{timers_spec.rb → group_spec.rb}

@@ -1,48 +1,46 @@
-require 'spec_helper'
 
-describe Timers do
-  # Level of accuracy enforced by tests (50ms)
-  Q = 0.05
+require 'spec_helper'
 
+describe Timers::Group do
   it "sleeps until the next timer" do
-    interval   = Q * 2
+    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(Q).of interval
+    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(Q) { fired = true }
-    sleep(Q * 2)
+    subject.after(TIMER_QUANTUM) { fired = true }
+    sleep(TIMER_QUANTUM * 2)
     subject.wait
 
-    expect(fired).to be_true
+    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(Q).of interval
+    expect(subject.wait_interval).to be_within(TIMER_QUANTUM).of interval
 
     sleep(interval)
-    expect(subject.wait_interval).to be(0)
+    expect(subject.wait_interval).to be(nil)
   end
 
   it "fires timers in the correct order" do
     result = []
 
-    subject.after(Q * 2) { result << :two }
-    subject.after(Q * 3) { result << :three }
-    subject.after(Q * 1) { result << :one }
+    subject.after(TIMER_QUANTUM * 2) { result << :two }
+    subject.after(TIMER_QUANTUM * 3) { result << :three }
+    subject.after(TIMER_QUANTUM * 1) { result << :one }
 
-    sleep Q * 4
+    sleep TIMER_QUANTUM * 4
     subject.fire
 
     expect(result).to eq [:one, :two, :three]
@@ -58,13 +56,13 @@ describe Timers do
     it "continues to fire the timers at each interval" do
       result = []
 
-      subject.every(Q * 2) { result << :foo }
+      subject.every(TIMER_QUANTUM * 2) { result << :foo }
 
-      sleep Q * 3
+      sleep TIMER_QUANTUM * 3
       subject.fire
       expect(result).to eq [:foo]
 
-      sleep Q * 5
+      sleep TIMER_QUANTUM * 5
       subject.fire
       expect(result).to eq [:foo, :foo]
     end
@@ -77,13 +75,13 @@ describe Timers do
       subject.after_milliseconds(interval_ms)
       expected_elapse = subject.wait_interval
 
-      expect(subject.wait_interval).to be_within(Q).of(interval_ms / 1000.0)
+      expect(subject.wait_interval).to be_within(TIMER_QUANTUM).of(interval_ms / 1000.0)
     end
   end
 
   describe "pause and continue timers" do
     before(:each) do
-      @interval   = Q * 2
+      @interval   = TIMER_QUANTUM * 2
       started_at = Time.now
 
       @fired = false
@@ -95,7 +93,7 @@ describe Timers do
     it "does not fire when paused" do
       @timer.pause
       subject.wait
-      expect(@fired).to be_false
+      expect(@fired).to be false
     end
 
     it "fires when continued after pause" do
@@ -103,14 +101,14 @@ describe Timers do
       subject.wait
       @timer.continue
       subject.wait
-      expect(@fired).to be_true
+      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
+      expect(@fired).to be false
+      expect(@fired2).to be false
     end
 
     it "can continue all timers at once" do
@@ -118,20 +116,20 @@ describe Timers do
       subject.wait
       subject.continue
       subject.wait
-      expect(@fired).to be_true
-      expect(@fired2).to be_true
+      expect(@fired).to be true
+      expect(@fired2).to be true
     end
 
     it "can fire the timer directly" do
       fired = false
-      timer = subject.after( Q * 1 ) { fired = true }
+      timer = subject.after( TIMER_QUANTUM * 1 ) { fired = true }
       timer.pause
       subject.wait
-      expect(fired).not_to be_true
+      expect(fired).not_to be true
       timer.continue
-      expect(fired).not_to be_true
+      expect(fired).not_to be true
       timer.fire
-      expect(fired).to be_true
+      expect(fired).to be true
     end
 
   end
@@ -140,7 +138,7 @@ describe Timers 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(Q).of(15)
+      expect(timer.offset - subject.current_offset).to be_within(TIMER_QUANTUM).of(15)
     end
   end
 
@@ -149,8 +147,8 @@ describe Timers do
       timer = subject.after(10)
       timer2 = subject.after(20)
       subject.delay(5)
-      expect(timer.offset - subject.current_offset).to be_within(Q).of(15)
-      expect(timer2.offset - subject.current_offset).to be_within(Q).of(25)
+      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
 
@@ -158,12 +156,12 @@ describe Timers do
     it "fires timers in the correct order" do
       result = []
 
-      second = subject.after(Q * 2) { result << :two }
-      third = subject.after(Q * 3) { result << :three }
-      first = subject.after(Q * 1) { result << :one }
-      first.delay(Q * 3)
+      second = subject.after(TIMER_QUANTUM * 2) { result << :two }
+      third = subject.after(TIMER_QUANTUM * 3) { result << :three }
+      first = subject.after(TIMER_QUANTUM * 1) { result << :one }
+      first.delay(TIMER_QUANTUM * 3)
 
-      sleep Q * 5
+      sleep TIMER_QUANTUM * 5
       subject.fire
 
       expect(result).to eq [:two, :three, :one]
@@ -173,29 +171,52 @@ describe Timers do
   describe "Timer inspection" do
     it "before firing" do
       fired = false
-      timer = subject.after(Q * 5) { fired = true }
+      timer = subject.after(TIMER_QUANTUM * 5) { fired = true }
       timer.pause
-      expect(fired).not_to be_true
+      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(Q) { fired = true }
+      timer = subject.after(TIMER_QUANTUM) { fired = true }
 
       subject.wait
 
-      expect(fired).to be_true
+      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(Q) { result << :foo }
+      timer = subject.every(TIMER_QUANTUM) { result << :foo }
 
       subject.wait
       expect(result).not_to be_empty
-      expect(timer.inspect).to match(/\A#<Timers::Timer:[\da-f]+ fires in [-\.\de]+ seconds, recurs every #{sprintf("%0.2f", Q)}>\Z/)
+      expect(timer.inspect).to match(/\A#<Timers::Timer:[\da-f]+ fires in [-\.\de]+ seconds, recurs every #{sprintf("%0.2f", TIMER_QUANTUM)}>\Z/)
+    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/spec_helper.rb

@@ -1,4 +1,8 @@
-require 'bundler/setup'
-require 'timers'
 require 'coveralls'
 Coveralls.wear!
+
+require 'bundler/setup'
+require 'timers'
+
+# Level of accuracy enforced by tests (50ms)
+TIMER_QUANTUM = 0.05

data/spec/timeout_spec.rb

@@ -0,0 +1,29 @@
+
+require 'spec_helper'
+require 'timers/timeout'
+
+describe Timers::Timeout do
+  it "repeats until timeout expired" do
+    timeout = Timers::Timeout.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::Timeout.new(5)
+    
+    result = timeout.while_time_remaining do |remaining|
+      break :done
+    end
+    
+    expect(result).to eq(:done)
+  end
+end

data/timers.gemspec

@@ -19,5 +19,5 @@ Gem::Specification.new do |gem|
   gem.add_runtime_dependency 'hitimes'
 
   gem.add_development_dependency 'rake'
-  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'rspec', '~> 3.0.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timers
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 3.0.0.pre
 platform: ruby
 authors:
 - Tony Arcieri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-30 00:00:00.000000000 Z
+date: 2014-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hitimes
@@ -42,16 +42,16 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.0.0
 description: Pure Ruby one-shot and periodic timers
 email:
 - tony.arcieri@gmail.com
@@ -63,15 +63,20 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- AUTHORS.md
 - CHANGES.md
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
 - lib/timers.rb
+- lib/timers/group.rb
+- lib/timers/timeout.rb
+- lib/timers/timer.rb
 - lib/timers/version.rb
+- spec/group_spec.rb
 - spec/spec_helper.rb
-- spec/timers_spec.rb
+- spec/timeout_spec.rb
 - timers.gemspec
 homepage: https://github.com/celluloid/timers
 licenses:
@@ -88,16 +93,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Schedule procs to run after a certain time, or at periodic intervals, using
   any API that accepts a timeout
 test_files:
+- spec/group_spec.rb
 - spec/spec_helper.rb
-- spec/timers_spec.rb
+- spec/timeout_spec.rb