timers 4.1.1 → 4.1.2

data/lib/timers/timer.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 
 module Timers
-  # An individual timer set to fire a given proc at a given time. A timer is 
+  # 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
@@ -11,14 +12,14 @@ module Timers
 
     def initialize(group, interval, recurring = false, offset = nil, &block)
       @group = group
-      
+
       @interval = interval
       @recurring = recurring
       @block = block
       @offset = offset
-      
+
       @handle = nil
-      
+
       # If a start offset was supplied, use that, otherwise use the current timers offset.
       reset(@offset || @group.current_offset)
     end
@@ -29,41 +30,41 @@ module Timers
 
     def pause
       return if paused?
-      
+
       @group.timers.delete self
       @group.paused_timers.add self
-      
+
       @handle.cancel! if @handle
       @handle = nil
     end
 
     def resume
       return unless paused?
-      
+
       @group.paused_timers.delete self
-      
+
       # This will add us back to the group:
       reset
     end
 
-    alias_method :continue, :resume
+    alias continue resume
 
     # Extend this timer
     def delay(seconds)
       @handle.cancel! if @handle
-      
+
       @offset += seconds
-      
+
       @handle = @group.events.schedule(@offset, self)
     end
-    
+
     # 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 if @group
     end
@@ -77,9 +78,9 @@ module Timers
       else
         @group.timers << self
       end
-      
+
       @offset = Float(offset) + @interval
-      
+
       @handle = @group.events.schedule(@offset, self)
     end
 
@@ -95,11 +96,11 @@ module Timers
       end
 
       @block.call(offset)
-      
+
       cancel unless recurring
     end
 
-    alias_method :call, :fire
+    alias call fire
 
     # Number of seconds until next fire / since last fire
     def fires_in
@@ -108,14 +109,14 @@ module Timers
 
     # Inspect a timer
     def inspect
-      str = "#<Timers::Timer:#{object_id.to_s(16)} "
+      str = "#<Timers::Timer:#{object_id.to_s(16)} ".dup
 
       if @offset
-        if fires_in >= 0
-          str << "fires in #{fires_in} seconds"
-        else
-          str << "fired #{fires_in.abs} seconds ago"
-        end
+        str << if fires_in >= 0
+                 "fires in #{fires_in} seconds"
+               else
+                 "fired #{fires_in.abs} seconds ago"
+               end
 
         str << ", recurs every #{interval}" if recurring
       else

data/lib/timers/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Timers
-  VERSION = "4.1.1"
+  VERSION = "4.1.2"
 end

data/lib/timers/wait.rb

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

data/spec/spec_helper.rb

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

data/spec/{cancel_spec.rb → timers/cancel_spec.rb}

@@ -1,12 +1,11 @@
-
-require 'spec_helper'
+# 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
@@ -14,32 +13,32 @@ RSpec.describe Timers::Group do
 
     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|
+    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

data/spec/{events_spec.rb → timers/events_spec.rb}

@@ -1,57 +1,56 @@
-
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe Timers::Events do
   it "should register an event" do
     fired = false
-    
-    callback = proc do |time|
+
+    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|
+      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/{every_spec.rb → timers/every_spec.rb}

@@ -1,5 +1,4 @@
-
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe Timers::Group do
   it "should fire several times" do

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

@@ -1,19 +1,18 @@
-
-require 'spec_helper'
+# 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
+        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
@@ -30,7 +29,7 @@ RSpec.describe Timers::Group do
       expect(fired).to be true
     end
   end
-  
+
   it "sleeps until the next timer" do
     interval   = TIMER_QUANTUM * 2
     started_at = Time.now
@@ -107,7 +106,7 @@ RSpec.describe Timers::Group do
 
   describe "pause and continue timers" do
     before(:each) do
-      @interval   = TIMER_QUANTUM * 2
+      @interval = TIMER_QUANTUM * 2
 
       @fired = false
       @timer = subject.after(@interval) { @fired = true }
@@ -125,10 +124,10 @@ RSpec.describe Timers::Group do
       @timer.pause
       subject.wait
       @timer.resume
-      
+
       sleep @timer.interval
       subject.wait
-      
+
       expect(@fired).to be true
     end
 
@@ -143,18 +142,20 @@ RSpec.describe Timers::Group 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.
+
+      # 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 = subject.after(TIMER_QUANTUM * 1) { fired = true }
       timer.pause
       subject.wait
       expect(fired).not_to be true
@@ -163,7 +164,6 @@ RSpec.describe Timers::Group do
       timer.fire
       expect(fired).to be true
     end
-
   end
 
   describe "delay timer" do
@@ -200,7 +200,7 @@ RSpec.describe Timers::Group do
     end
   end
 
-  describe "Timer inspection" do
+  describe "#inspect" do
     it "before firing" do
       fired = false
       timer = subject.after(TIMER_QUANTUM * 5) { fired = true }
@@ -225,11 +225,12 @@ RSpec.describe Timers::Group do
 
       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", TIMER_QUANTUM)}>\Z/)
+      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
+  describe "#fires_in" do
     let(:interval) { TIMER_QUANTUM * 2 }
 
     it "calculates the interval until the next fire if it's recurring" do