timers 4.0.0 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aa56588795590f6b0772c42830b2969d4c18c31b
-  data.tar.gz: 203a266076597db814652c1b1e8d25fdca6808b2
+  metadata.gz: 8fd3554aab4028decec14d741c973f4ffe5d414a
+  data.tar.gz: 082bf7c3ec19a1d60df84d1b81a033a888e6b922
 SHA512:
-  metadata.gz: cf717b2718394941dc03bd9bd4184a790116fff7e936b07227fe64cec0d7801ff84903ba23efd5332751919d3a9acbbff95c3a1b53f8c150cd67a94c78531763
-  data.tar.gz: 26d41eddf5f924ac26860a09daba9af79203f32f0f7cefc93cafc5a46ffd95ad959f0281c6dbe619ca3ad8087c63e16c87ef1e860d297f6c30e98da3562c5be0
+  metadata.gz: 354c245b317b5cf5127b6bc0ce76d24c0c9c73f7a170afd4e2d7d286a007018a94ee9c628ce86793b799c71946e07a718d83154b3a8e1a25254adaea91e72725
+  data.tar.gz: 56d3a3b9d8e54171892347c7ab67dc936216c12bda07f910ddc3b766a99f7ccd8398179e980285ab7307d734a516d91623b93e68db1ae59cc3df686585f78f5f

data/.travis.yml

@@ -8,6 +8,7 @@ rvm:
   - rbx-2
 
 matrix:
+  fast_finish: true
   allow_failures:
     - rvm: ruby-head
     - rvm: jruby-head

data/CHANGES.md

@@ -1,3 +1,13 @@
+4.1.0 (2015-08-16)
+------------------
+* Addition of `now_and_every` method; fires block immediately, then sets recurring timer.
+* Includes `now_and_after` method; does the same as above for one-shot timers: essentially a "two-shot" timer.
+
+4.0.1 (2014-09-10)
+------------------
+* Memory leak fixes
+* mathn fix for those crazy enough to use it
+
 4.0.0 (2014-07-27)
 ------------------
 * Replace Timers::Timeout with Timers::Wait

data/README.md

@@ -50,6 +50,13 @@ every_five_seconds = timers.every(5) { puts "Another 5 seconds" }
 loop { timers.wait }
 ```
 
+You can also schedule a block to run immediately and periodically with `Timers::Group#now_and_every`:
+```ruby
+now_and_every_five_seconds = timers.now_and_every(5) { puts "Now and in another 5 seconds" }
+
+loop { timers.wait }
+```
+
 If you'd like another method to do the waiting for you, e.g. `Kernel.select`,
 you can use `Timers::Group#wait_interval` to obtain the amount of time to wait. When
 a timeout is encountered, you can fire all pending timers with `Timers::Group#fire`:

data/lib/timers/events.rb

@@ -72,6 +72,7 @@ module Timers
           return handle
         end
       end
+      # @sequence.reverse.find { |handle| !handle.cancelled? }
     end
     
     # Returns the number of pending (possibly cancelled) events.
@@ -93,14 +94,14 @@ module Timers
     def pop(time)
       index = bisect_left(@sequence, time)
       
-      return @sequence.pop(@sequence.size - index)
+      @sequence.pop(@sequence.size - index)
     end
     
     # Return the left-most index where to insert item e, in a list a, assuming 
     # a is sorted in descending order.
     def bisect_left(a, e, l = 0, u = a.length)
       while l < u
-        m = l + (u-l)/2
+        m = l + (u-l).div(2)
         
         if a[m] > e
           l = m+1

data/lib/timers/group.rb

@@ -38,12 +38,26 @@ module Timers
       Timer.new(self, interval, false, &block)
     end
 
+    # Call the given block immediately, and then after the given interval. The first
+    # argument will be the time at which the group was asked to fire timers for.
+    def now_and_after(interval, &block)
+      block.call
+      after(interval, &block)
+    end
+
     # Call the given block periodically at the given interval. The first 
     # argument will be the time at which the group was asked to fire timers for.
     def every(interval, recur = true, &block)
       Timer.new(self, interval, recur, &block)
     end
 
+    # Call the given block immediately, and then periodically at the given interval. The first
+    # argument will be the time at which the group was asked to fire timers for.
+    def now_and_every(interval, recur = true, &block)
+      block.call
+      every(interval, recur, &block)
+    end
+
     # Wait for the next timer and fire it. Can take a block, which should behave
     # like sleep(n), except that n may be nil (sleep forever) or a negative
     # number (fire immediately after return).
@@ -61,7 +75,7 @@ module Timers
         end
       end
 
-      fire
+      return fire
     end
 
     # Interval to wait until when the next timer will fire.

data/lib/timers/timer.rb

@@ -1,6 +1,10 @@
 
 module Timers
-  # An individual timer set to fire a given proc at a given time
+  # An individual timer set to fire a given proc at a given time. A timer is 
+  # always connected to a Timer::Group but it would ONLY be in @group.timers
+  # if it also has a @handle specified. Otherwise it is either PAUSED or has
+  # been FIRED and is not recurring. You can manually enter this state by
+  # calling #cancel and resume normal operation by calling #reset.
   class Timer
     include Comparable
     attr_reader :interval, :offset, :recurring
@@ -8,8 +12,6 @@ module Timers
     def initialize(group, interval, recurring = false, offset = nil, &block)
       @group = group
       
-      @group.timers << self
-      
       @interval = interval
       @recurring = recurring
       @block = block
@@ -38,9 +40,9 @@ module Timers
     def resume
       return unless paused?
       
-      @group.timers.add self
       @group.paused_timers.delete self
       
+      # This will add us back to the group:
       reset
     end
 
@@ -54,27 +56,34 @@ module Timers
       
       @handle = @group.events.schedule(@offset, self)
     end
-
-    # Cancel this timer
+    
+    # Cancel this timer. Do not call while paused.
     def cancel
+      return unless @handle
+      
       @handle.cancel! if @handle
       @handle = nil
       
       # This timer is no longer valid:
-      @group.timers.delete self
-      @group = nil
+      @group.timers.delete self if @group
     end
 
-    # Reset this timer
+    # Reset this timer. Do not call while paused.
     def reset(offset = @group.current_offset)
-      @handle.cancel! if @handle
+      # This logic allows us to minimise the interaction with @group.timers.
+      # A timer with a handle is always registered with the group.
+      if @handle
+        @handle.cancel!
+      else
+        @group.timers << self
+      end
       
       @offset = Float(offset) + @interval
       
       @handle = @group.events.schedule(@offset, self)
     end
 
-    # Fire the block
+    # Fire the block.
     def fire(offset = @group.current_offset)
       if recurring == :strict
         # ... make the next interval strictly the last offset + the interval:
@@ -86,6 +95,8 @@ module Timers
       end
 
       @block.call(offset)
+      
+      cancel unless recurring
     end
 
     alias_method :call, :fire

data/lib/timers/version.rb

@@ -1,3 +1,3 @@
 module Timers
-  VERSION = "4.0.0"
+  VERSION = "4.1.0"
 end

data/spec/cancel_spec.rb

@@ -0,0 +1,46 @@
+
+require 'spec_helper'
+
+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/events_spec.rb

@@ -9,7 +9,7 @@ RSpec.describe Timers::Events do
       fired = true
     end
     
-    handle = subject.schedule(0.1, callback)
+    subject.schedule(0.1, callback)
     
     expect(subject.size).to be == 1
     

data/spec/every_spec.rb

@@ -16,4 +16,19 @@ RSpec.describe Timers::Group do
 
     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/performance_spec.rb

@@ -60,7 +60,7 @@ RSpec.describe Timers::Group do
     end
   end
   
-  it "run efficiently" do
+  it "runs efficiently" do
     result = []
     range = (1..500)
     duration = 2.0
@@ -80,4 +80,41 @@ RSpec.describe Timers::Group do
     
     expect(subject.current_offset).to be_within(TIMER_QUANTUM).of(duration)
   end
+
+=begin
+  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
+
 end

metadata

@@ -1,24 +1,24 @@
 --- !ruby/object:Gem::Specification
 name: timers
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.1.0
 platform: ruby
 authors:
 - Tony Arcieri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-27 00:00:00.000000000 Z
+date: 2015-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hitimes
+  type: :runtime
+  prerelease: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
-  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -26,13 +26,13 @@ dependencies:
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
+  type: :development
+  prerelease: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
-  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -40,13 +40,13 @@ dependencies:
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
+  type: :development
+  prerelease: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 3.0.0
-  type: :development
-  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -75,6 +75,7 @@ files:
 - lib/timers/timer.rb
 - lib/timers/version.rb
 - lib/timers/wait.rb
+- spec/cancel_spec.rb
 - spec/events_spec.rb
 - spec/every_spec.rb
 - spec/group_spec.rb
@@ -103,12 +104,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.8
 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/cancel_spec.rb
 - spec/events_spec.rb
 - spec/every_spec.rb
 - spec/group_spec.rb