timers 4.1.2 → 4.3.2

data/lib/timers/interval.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 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.
+
+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,129 +1,150 @@
 # frozen_string_literal: true
 
-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
+# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 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.
 
-    def initialize(group, interval, recurring = false, offset = nil, &block)
-      @group = group
+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
 
-      @interval = interval
-      @recurring = recurring
-      @block = block
-      @offset = offset
+		def initialize(group, interval, recurring = false, offset = nil, &block)
+			@group = group
 
-      @handle = nil
+			@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
+			# 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
+		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.
+		# @param offset [Numeric] the duration to add to the timer.
+		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, self)
+
+			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 = "#<Timers::Timer:#{object_id.to_s(16)} ".dup
+		# 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
+			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 << ", recurs every #{interval}" if recurring
+			else
+				str << "dead"
+			end
 
-      str << ">"
-    end
-  end
+			str << ">"
+		end
+	end
 end

data/lib/timers/version.rb

@@ -1,5 +1,25 @@
 # frozen_string_literal: true
 
+# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 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.
+
 module Timers
-  VERSION = "4.1.2"
+	VERSION = "4.3.2"
 end

data/lib/timers/wait.rb

@@ -1,47 +1,67 @@
 # frozen_string_literal: true
 
-require "hitimes"
+# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 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.
+
+require_relative "interval"
 
 module Timers
-  # 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 = Hitimes::Interval.new
-      @interval.start
-
-      yield @remaining while time_remaining?
-    ensure
-      @interval.stop
-      @interval = nil
-    end
-
-    private
-
-    def time_remaining?
-      @remaining = (@duration - @interval.duration)
-
-      @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