timers 4.1.1 → 4.2.0

data/lib/timers/group.rb

@@ -1,132 +1,132 @@
+# frozen_string_literal: true
+#
+# This file is part of the "timers" project and released under the MIT license.
+#
+# Copyright, 2018, by Samuel Williams. All rights reserved.
+#
 
-require 'set'
-require 'forwardable'
-require 'hitimes'
+require "set"
+require "forwardable"
 
-require 'timers/timer'
-require 'timers/events'
+require_relative "interval"
+require_relative "timer"
+require_relative "events"
 
 module Timers
-  class Group
-    include Enumerable
-
-    extend Forwardable
-    def_delegators :@timers, :each, :empty?
-
-    def initialize
-      @events = Events.new
-      
-      @timers = Set.new
-      @paused_timers = Set.new
-      
-      @interval = Hitimes::Interval.new
-      @interval.start
-    end
-
-    # Scheduled events:
-    attr :events
-    
-    # Active timers:
-    attr :timers
-    
-    # Paused timers:
-    attr :paused_timers
-
-    # Call the given block after the given interval. The first argument will be
-    # the time at which the group was asked to fire timers for.
-    def after(interval, &block)
-      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).
-    def wait(&block)
-      if block_given?
-        yield wait_interval
-        
-        while interval = wait_interval and interval > 0
-          yield interval
-        end
-      else
-        while interval = wait_interval and interval > 0
-          # We cannot assume that sleep will wait for the specified time, it might be +/- a bit.
-          sleep interval
-        end
-      end
-
-      return fire
-    end
-
-    # Interval to wait until when the next timer will fire.
-    # - nil: no timers
-    # - -ve: timers expired already
-    # -   0: timers ready to fire
-    # - +ve: timers waiting to fire
-    def wait_interval(offset = self.current_offset)
-      if handle = @events.first
-        return handle.time - Float(offset)
-      end
-    end
-
-    # Fire all timers that are ready.
-    def fire(offset = self.current_offset)
-      @events.fire(offset)
-    end
-
-    # Pause all timers.
-    def pause
-      @timers.dup.each do |timer|
-        timer.pause
-      end
-    end
-
-    # Resume all timers.
-    def resume
-      @paused_timers.dup.each do |timer|
-        timer.resume
-      end
-    end
-
-    alias_method :continue, :resume
-
-    # Delay all timers.
-    def delay(seconds)
-      @timers.each do |timer|
-        timer.delay(seconds)
-      end
-    end
-
-    # Cancel all timers.
-    def cancel
-      @timers.dup.each do |timer|
-        timer.cancel
-      end
-    end
-
-    # The group's current time.
-    def current_offset
-      @interval.to_f
-    end
-  end
+	# A collection of timers which may fire at different times
+	class Group
+		include Enumerable
+
+		extend Forwardable
+		def_delegators :@timers, :each, :empty?
+
+		def initialize
+			@events = Events.new
+
+			@timers = Set.new
+			@paused_timers = Set.new
+
+			@interval = Interval.new
+			@interval.start
+		end
+
+		# Scheduled events:
+		attr_reader :events
+
+		# Active timers:
+		attr_reader :timers
+
+		# Paused timers:
+		attr_reader :paused_timers
+
+		# Call the given block after the given interval. The first argument will be
+		# the time at which the group was asked to fire timers for.
+		def after(interval, &block)
+			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)
+			yield
+			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)
+			yield
+			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).
+		def wait
+			if block_given?
+				yield wait_interval
+
+				while (interval = wait_interval) && interval > 0
+					yield interval
+				end
+			else
+				while (interval = wait_interval) && interval > 0
+					# We cannot assume that sleep will wait for the specified time, it might be +/- a bit.
+					sleep interval
+				end
+			end
+
+			fire
+		end
+
+		# Interval to wait until when the next timer will fire.
+		# - nil: no timers
+		# - -ve: timers expired already
+		# -   0: timers ready to fire
+		# - +ve: timers waiting to fire
+		def wait_interval(offset = current_offset)
+			handle = @events.first
+			handle.time - Float(offset) if handle
+		end
+
+		# Fire all timers that are ready.
+		def fire(offset = current_offset)
+			@events.fire(offset)
+		end
+
+		# Pause all timers.
+		def pause
+			@timers.dup.each(&:pause)
+		end
+
+		# Resume all timers.
+		def resume
+			@paused_timers.dup.each(&:resume)
+		end
+
+		alias continue resume
+
+		# Delay all timers.
+		def delay(seconds)
+			@timers.each do |timer|
+				timer.delay(seconds)
+			end
+		end
+
+		# Cancel all timers.
+		def cancel
+			@timers.dup.each(&:cancel)
+		end
+
+		# The group's current time.
+		def current_offset
+			@interval.to_f
+		end
+	end
 end

data/lib/timers/interval.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+#
+# This file is part of the "timers" project and released under the MIT license.
+#
+# Copyright, 2018, by Samuel Williams. All rights reserved.
+#
+
+module Timers
+	# A collection of timers which may fire at different times
+	class Interval
+		# Get the current elapsed monotonic time.
+		def initialize
+			@total = 0.0
+			@current = nil
+		end
+		
+		def start
+			return if @current
+			
+			@current = now
+		end
+		
+		def stop
+			return unless @current
+			
+			@total += duration
+			
+			@current = nil
+		end
+		
+		def to_f
+			@total + duration
+		end
+		
+		protected def duration
+			now - @current
+		end
+		
+		protected def now
+			::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+		end
+	end
+end

data/lib/timers/timer.rb

@@ -1,128 +1,134 @@
+# frozen_string_literal: true
+#
+# This file is part of the "timers" project and released under the MIT license.
+#
+# Copyright, 2018, by Samuel Williams. All rights reserved.
+#
 
 module Timers
-  # 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
-
-    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
-
-    def paused?
-      @group.paused_timers.include? self
-    end
-
-    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
-
-    # 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
-
-    # Reset this timer. Do not call while paused.
-    def reset(offset = @group.current_offset)
-      # 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.
-    def fire(offset = @group.current_offset)
-      if recurring == :strict
-        # ... make the next interval strictly the last offset + the interval:
-        reset(@offset)
-      elsif recurring
-        reset(offset)
-      else
-        @offset = offset
-      end
-
-      @block.call(offset)
-      
-      cancel unless recurring
-    end
-
-    alias_method :call, :fire
-
-    # Number of seconds until next fire / since last fire
-    def fires_in
-      @offset - @group.current_offset if @offset
-    end
-
-    # Inspect a timer
-    def inspect
-      str = "#<Timers::Timer:#{object_id.to_s(16)} "
-
-      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
+	# 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
+
+		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
+
+		def paused?
+			@group.paused_timers.include? self
+		end
+
+		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 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
+
+		# Reset this timer. Do not call while paused.
+		def reset(offset = @group.current_offset)
+			# 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.
+		def fire(offset = @group.current_offset)
+			if recurring == :strict
+				# ... make the next interval strictly the last offset + the interval:
+				reset(@offset)
+			elsif recurring
+				reset(offset)
+			else
+				@offset = offset
+			end
+
+			@block.call(offset)
+
+			cancel unless recurring
+		end
+
+		alias call fire
+
+		# Number of seconds until next fire / since last fire
+		def fires_in
+			@offset - @group.current_offset if @offset
+		end
+
+		# Inspect a timer
+		def inspect
+			str = "#{to_s[0..-2]} ".dup
+
+			if @offset
+				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
+				str << "dead"
+			end
+
+			str << ">"
+		end
+	end
 end

data/lib/timers/version.rb

@@ -1,3 +1,10 @@
+# frozen_string_literal: true
+#
+# This file is part of the "timers" project and released under the MIT license.
+#
+# Copyright, 2018, by Samuel Williams. All rights reserved.
+#
+
 module Timers
-  VERSION = "4.1.1"
+	VERSION = "4.2.0"
 end

data/lib/timers/wait.rb

@@ -1,48 +1,52 @@
+# frozen_string_literal: true
+#
+# This file is part of the "timers" project and released under the MIT license.
+#
+# Copyright, 2018, by Samuel Williams. All rights reserved.
+#
 
-require 'hitimes'
+require_relative "interval"
 
 module Timers
-  # An exclusive, monotonic timeout class.
-  class Wait
-    def self.for(duration, &block)
-      if duration
-        timeout = self.new(duration)
-        
-        timeout.while_time_remaining(&block)
-      else
-        while true
-          yield(nil)
-        end
-      end
-    end
-    
-    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
+	# An exclusive, monotonic timeout class.
+	class Wait
+		def self.for(duration, &block)
+			if duration
+				timeout = new(duration)
+
+				timeout.while_time_remaining(&block)
+			else
+				loop do
+					yield(nil)
+				end
+			end
+		end
+
+		def initialize(duration)
+			@duration = duration
+			@remaining = true
+		end
+
+		attr_reader :duration
+		attr_reader :remaining
+
+		# Yields while time remains for work to be done:
+		def while_time_remaining
+			@interval = Interval.new
+			@interval.start
+
+			yield @remaining while time_remaining?
+		ensure
+			@interval.stop
+			@interval = nil
+		end
+
+		private
+
+		def time_remaining?
+			@remaining = (@duration - @interval.to_f)
+
+			@remaining > 0
+		end
+	end
 end