timers 1.1.0 → 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1bb812d219dd39a2f06dbead6028d0a472d43358
+  data.tar.gz: 069ca7cb58645d3a4bc419166d67842eb482a375
+SHA512:
+  metadata.gz: 49534f3d20dab0cff520e02592ed0f4850230454f6fae5165990df3ad71b408b54ffe1c3e362954dc4f0fa9271f5a436f31c6bdb50b40b83d44d3aaac180c1b1
+  data.tar.gz: b26cf3a87ac426cc12b336ef16f3081b302da9ebd8d5e631a7ddfc5c7aed64544c4d8e1aec13dd36f1e36771506a5e077b1b0a6dca91763d2a8eb40288047dc5

data/.coveralls.yml

@@ -0,0 +1 @@
+service-name: travis-pro

data/.travis.yml

@@ -1,10 +1,16 @@
 rvm:
-  - 1.8.7
   - 1.9.3
-  - ree
+  - 2.0.0
   - ruby-head
-  - jruby-18mode
-  - jruby-19mode
-#  - jruby-head segving o_O
-#  - rbx-18mode sporadic failures
-#  - rbx-19mode
+  - jruby
+  - jruby-head
+  - rbx
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
+    - rvm: rbx
+
+notifications:
+  irc: "irc.freenode.org#celluloid"

data/CHANGES.md

@@ -1,3 +1,9 @@
+2.0.0 (2013-12-30)
+------------------
+* Switch to Hitimes for high precision monotonic counters
+* Removed Timers#time. Replaced with Timers#current_offset which provides a
+  monotonic time counter.
+
 1.1.0
 -----
 * Timers#after_milliseconds and #after_ms for waiting in milliseconds

data/Gemfile

@@ -1,4 +1,6 @@
 source 'https://rubygems.org'
 
+gem 'coveralls', :require => false
+
 # Specify your gem's dependencies in timers.gemspec
 gemspec

data/README.md

@@ -1,13 +1,16 @@
 Timers
 ======
-[![Build Status](https://secure.travis-ci.org/tarcieri/timers.png?branch=master)](http://travis-ci.org/tarcieri/timers)
+[![Gem Version](https://badge.fury.io/rb/timers.png)](http://rubygems.org/gems/timers)
+[![Build Status](https://secure.travis-ci.org/celluloid/timers.png?branch=master)](http://travis-ci.org/celluloid/timers)
+[![Code Climate](https://codeclimate.com/github/celluloid/timers.png)](https://codeclimate.com/github/celluloid/timers)
+[![Coverage Status](https://coveralls.io/repos/celluloid/timers/badge.png?branch=master)](https://coveralls.io/r/celluloid/timers)
 
 Pure Ruby timer collections. Schedule several procs to fire after configurable
 delays or at periodic intervals.
 
 This gem is especially useful when you are faced with an API that accepts a
 single timeout but you want to run multiple timers on top of it. An example of
-such a library is [nio4r](https://github.com/tarcieri/nio4r), a cross-platform
+such a library is [nio4r](https://github.com/celluloid/nio4r), a cross-platform
 Ruby library for using system calls like epoll and kqueue.
 
 Usage
@@ -66,6 +69,24 @@ loop do
 end
 ```
 
+You can also pause and continue individual timers, or all timers:
+
+```ruby
+paused_timer = timers.every(5) { puts "I was paused" }
+
+paused_timer.pause
+10.times { timers.wait } # will not fire paused timer
+
+paused_timer.continue
+10.times { timers.wait } # will fire timer
+
+timers.pause
+10.times { timers.wait } # will not fire any timers
+
+timers.continue
+10.times { timers.wait } # will fire all timers
+```
+
 License
 -------
 

data/lib/timers.rb

@@ -1,8 +1,12 @@
 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
 
-# Low precision timers implemented in pure Ruby
 class Timers
   include Enumerable
   extend  Forwardable
@@ -10,13 +14,16 @@ class Timers
 
   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.
   #
@@ -40,19 +47,19 @@ class Timers
   end
 
   # Interval to wait until when the next timer will fire
-  def wait_interval(now = Time.now)
+  def wait_interval(offset = self.current_offset)
     timer = @timers.first
     return unless timer
-    interval = timer.time - now
+    interval = timer.offset - Float(offset)
     interval > 0 ? interval : 0
   end
 
   # Fire all timers that are ready
-  def fire(now = Time.now)
-    time = now + 0.001 # Fudge 1ms in case of clock imprecision
-    while (timer = @timers.first) && (time >= timer.time)
+  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(now)
+      timer.fire(offset)
     end
   end
 
@@ -61,23 +68,53 @@ class Timers
     @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, :time, :recurring
+    attr_reader :interval, :offset, :recurring
 
     def initialize(timers, interval, recurring = false, &block)
       @timers, @interval, @recurring = timers, interval, recurring
-      @block = block
-      @time  = nil
+      @block  = block
+      @offset = nil
 
       reset
     end
 
     def <=>(other)
-      @time <=> other.time
+      @offset <=> other.offset
     end
 
     # Cancel this timer
@@ -85,30 +122,47 @@ class Timers
       @timers.cancel self
     end
 
+    # Extend this timer
+    def delay(seconds)
+      @timers.delete self
+      @offset += seconds
+      @timers.add self
+    end
+
     # Reset this timer
-    def reset(now = Time.now)
+    def reset(offset = @timers.current_offset)
       @timers.cancel self if @time
-      @time = now + @interval
+      @offset = Float(offset) + @interval
       @timers.add self
     end
 
     # Fire the block
-    def fire(now = Time.now)
-      reset(now) if recurring
+    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)} "
-      now = Time.now
+      offset = @timers.current_offset
 
-      if @time
-        if @time >= now
-          str << "fires in #{@time - now} seconds"
+      if @offset
+        if @offset >= offset
+          str << "fires in #{@offset - offset} seconds"
         else
-          str << "fired #{now - @time} seconds ago"
+          str << "fired #{offset - @offset} seconds ago"
         end
 
         str << ", recurs every #{interval}" if recurring

data/lib/timers/version.rb

@@ -1,3 +1,3 @@
 class Timers
-  VERSION = "1.1.0"
+  VERSION = "2.0.0"
 end

data/spec/spec_helper.rb

@@ -1,2 +1,4 @@
 require 'bundler/setup'
-require 'timers'
+require 'timers'
+require 'coveralls'
+Coveralls.wear!

data/spec/timers_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Timers do
-  # Level of accuracy enforced by most tests (50ms)
+  # Level of accuracy enforced by tests (50ms)
   Q = 0.05
 
   it "sleeps until the next timer" do
@@ -12,8 +12,8 @@ describe Timers do
     subject.after(interval) { fired = true }
     subject.wait
 
-    fired.should be_true
-    (Time.now - started_at).should be_within(Q).of interval
+    expect(fired).to be_true
+    expect(Time.now - started_at).to be_within(Q).of interval
   end
 
   it "fires instantly when next timer is in the past" do
@@ -22,17 +22,17 @@ describe Timers do
     sleep(Q * 2)
     subject.wait
 
-    fired.should 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)
-    subject.wait_interval.should be_within(Q).of interval
+    expect(subject.wait_interval).to be_within(Q).of interval
 
     sleep(interval)
-    subject.wait_interval.should be(0)
+    expect(subject.wait_interval).to be(0)
   end
 
   it "fires timers in the correct order" do
@@ -45,7 +45,13 @@ describe Timers do
     sleep Q * 4
     subject.fire
 
-    result.should == [:one, :two, :three]
+    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
@@ -56,14 +62,14 @@ describe Timers do
 
       sleep Q * 3
       subject.fire
-      result.should == [:foo]
+      expect(result).to eq [:foo]
 
       sleep Q * 5
       subject.fire
-      result.should == [:foo, :foo]
+      expect(result).to eq [:foo, :foo]
     end
   end
-  
+
   describe "millisecond timers" do
     it "calculates the proper interval to wait until firing" do
       interval_ms = 25
@@ -71,7 +77,125 @@ describe Timers do
       subject.after_milliseconds(interval_ms)
       expected_elapse = subject.wait_interval
 
-      subject.wait_interval.should be_within(Q).of (interval_ms / 1000.0)
+      expect(subject.wait_interval).to be_within(Q).of(interval_ms / 1000.0)
+    end
+  end
+
+  describe "pause and continue timers" do
+    before(:each) do
+      @interval   = Q * 2
+      started_at = Time.now
+
+      @fired = false
+      @timer = subject.every(@interval) { @fired = true }
+      @fired2 = false
+      @timer2 = subject.every(@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.continue
+      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.continue
+      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( Q * 1 ) { fired = true }
+      timer.pause
+      subject.wait
+      expect(fired).not_to be_true
+      timer.continue
+      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(Q).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(Q).of(15)
+      expect(timer2.offset - subject.current_offset).to be_within(Q).of(25)
+    end
+  end
+
+  describe "on delaying a timer" 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)
+
+      sleep Q * 5
+      subject.fire
+
+      expect(result).to eq [:two, :three, :one]
+    end
+  end
+
+  describe "Timer inspection" do
+    it "before firing" do
+      fired = false
+      timer = subject.after(Q * 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(Q) { 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(Q) { 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/)
     end
   end
 end

data/timers.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |gem|
   gem.email         = ["tony.arcieri@gmail.com"]
   gem.description   = "Pure Ruby one-shot and periodic timers"
   gem.summary       = "Schedule procs to run after a certain time, or at periodic intervals, using any API that accepts a timeout"
-  gem.homepage      = "https://github.com/tarcieri/timers"
+  gem.homepage      = "https://github.com/celluloid/timers"
 
   gem.files         = `git ls-files`.split($\)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
@@ -14,6 +14,9 @@ Gem::Specification.new do |gem|
   gem.name          = "timers"
   gem.require_paths = ["lib"]
   gem.version       = Timers::VERSION
+  gem.licenses      = ['MIT']
+
+  gem.add_runtime_dependency 'hitimes'
 
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rspec'

metadata

@@ -1,46 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: timers
 version: !ruby/object:Gem::Version
-  version: 1.1.0
-  prerelease: 
+  version: 2.0.0
 platform: ruby
 authors:
 - Tony Arcieri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-19 00:00:00.000000000 Z
+date: 2013-12-30 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: hitimes
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Pure Ruby one-shot and periodic timers
@@ -50,9 +59,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".coveralls.yml"
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - CHANGES.md
 - Gemfile
 - LICENSE
@@ -63,35 +73,29 @@ files:
 - spec/spec_helper.rb
 - spec/timers_spec.rb
 - timers.gemspec
-homepage: https://github.com/tarcieri/timers
-licenses: []
+homepage: https://github.com/celluloid/timers
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 1264960547307952819
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 1264960547307952819
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.2.0
 signing_key: 
-specification_version: 3
+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: