timers 4.1.2 → 4.2.0

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,129 +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
+	# 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
+		def initialize(group, interval, recurring = false, offset = nil, &block)
+			@group = group
 
-      @interval = interval
-      @recurring = recurring
-      @block = block
-      @offset = offset
+			@interval = interval
+			@recurring = recurring
+			@block = block
+			@offset = offset
 
-      @handle = nil
+			@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.
+		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 = "#<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,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.2"
+	VERSION = "4.2.0"
 end

data/lib/timers/wait.rb

@@ -1,47 +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 = 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

data/spec/spec_helper.rb

@@ -1,21 +1,38 @@
 # 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 "coveralls"
-Coveralls.wear!
+# Level of accuracy enforced by tests (50ms)
+TIMER_QUANTUM = 0.05
+
+if ENV['COVERAGE'] || ENV['TRAVIS']
+	begin
+		require 'simplecov'
+		
+		SimpleCov.start do
+			add_filter "/spec/"
+		end
+		
+		if ENV['TRAVIS']
+			require 'coveralls'
+			Coveralls.wear!
+		end
+	rescue LoadError
+		warn "Could not load simplecov: #{$!}"
+	end
+end
 
 require "bundler/setup"
 require "timers"
 
-# Level of accuracy enforced by tests (50ms)
-TIMER_QUANTUM = 0.05
-
 RSpec.configure do |config|
-  # Setting this config option `false` removes rspec-core's monkey patching of the
-  # top level methods like `describe`, `shared_examples_for` and `shared_context`
-  # on `main` and `Module`. The methods are always available through the `RSpec`
-  # module like `RSpec.describe` regardless of this setting.
-  # For backwards compatibility this defaults to `true`.
-  #
-  # https://relishapp.com/rspec/rspec-core/v/3-0/docs/configuration/global-namespace-dsl
-  config.expose_dsl_globally = false
+	# Enable flags like --only-failures and --next-failure
+	config.example_status_persistence_file_path = ".rspec_status"
+
+	config.expect_with :rspec do |c|
+		c.syntax = :expect
+	end
 end