timers 4.1.1 → 4.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 107c4a8a97789c9580117a8eca6cb72af1390d54
-  data.tar.gz: 6687f8c8b655ce609a3ecf0a4519dd001baf4e2b
+SHA256:
+  metadata.gz: 5f9fdee45ad2b102af90e2d529a1384a5f6b975d6ec3112dfafebac2d8574b0f
+  data.tar.gz: 5bec94f4fb24de10acaf4fba0e93514aa2912444f19188e6ecd1c6b6e3d25340
 SHA512:
-  metadata.gz: 5f838fdcc30e595940ffc40325aea12578b16bf91a279feeafa247eb2d349d2724ec96715ab6d392531efcf7ff9f9e9a44a19b977bfb13a32629ead0a4358bda
-  data.tar.gz: 1fba4a0bad3f7b284ed4a45e6cc1e156cf66082041ec7a767cad14471e3b82a0c4bf068ea874d5e9f6bb90e3a8a571c73ebb710cb50df0d809dc3d65b470fffb
+  metadata.gz: 712db02d6c449fca924459a952df2c9ae21058b7c492ce81d4b86f4989c69aa9ef90cc98ae421ab2f13934da6488d7d91a5718c2f1070714476147302c3d9b6e
+  data.tar.gz: c4a358d3bdc7e108afd016e42fdb478b8e717e3c400ae6cf0694e880b91112c9b118e7609d1c31143247d5d87db2577851b1e6002f2731e524a40d7e96c1cc28

data/lib/timers.rb

@@ -1,5 +1,26 @@
+# frozen_string_literal: true
 
-require 'timers/version'
+# Copyright, 2020, 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 'timers/group'
-require 'timers/wait'
+require_relative "timers/version"
+
+require_relative "timers/group"
+require_relative "timers/wait"

data/lib/timers/events.rb

@@ -1,116 +1,143 @@
+# frozen_string_literal: true
 
-require 'forwardable'
-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 'timers/timer'
+require_relative "timer"
 
 module Timers
-  # Maintains an ordered list of events, which can be cancelled.
-  class Events
-    # Represents a cancellable handle for a specific timer event.
-    class Handle
-      def initialize(time, callback)
-        @time = time
-        @callback = callback
-      end
-      
-      # The absolute time that the handle should be fired at.
-      attr :time
-      
-      # Cancel this timer, O(1).
-      def cancel!
-        # The simplest way to keep track of cancelled status is to nullify the
-        # callback. This should also be optimal for garbage collection.
-        @callback = nil
-      end
-      
-      # Has this timer been cancelled? Cancelled timer's don't fire.
-      def cancelled?
-        @callback.nil?
-      end
-      
-      def > other
-        @time > other.to_f
-      end
-      
-      def to_f
-        @time
-      end
-      
-      # Fire the callback if not cancelled with the given time parameter.
-      def fire(time)
-        if @callback
-          @callback.call(time)
-        end
-      end
-    end
-    
-    def initialize
-      # A sequence of handles, maintained in sorted order, future to present.
-      # @sequence.last is the next event to be fired.
-      @sequence = []
-    end
-    
-    # Add an event at the given time.
-    def schedule(time, callback)
-      handle = Handle.new(time.to_f, callback)
-      
-      index = bisect_left(@sequence, handle)
-      
-      # Maintain sorted order, O(logN) insertion time.
-      @sequence.insert(index, handle)
-      
-      return handle
-    end
-    
-    # Returns the first non-cancelled handle.
-    def first
-      while handle = @sequence.last
-        if handle.cancelled?
-          @sequence.pop
-        else
-          return handle
-        end
-      end
-      # @sequence.reverse.find { |handle| !handle.cancelled? }
-    end
-    
-    # Returns the number of pending (possibly cancelled) events.
-    def size
-      @sequence.size
-    end
-    
-    # Fire all handles for which Handle#time is less than the given time.
-    def fire(time)
-      pop(time).reverse_each do |handle|
-        handle.fire(time)
-      end
-    end
-
-    private
-
-    # Efficiently take k handles for which Handle#time is less than the given 
-    # time.
-    def pop(time)
-      index = bisect_left(@sequence, time)
-      
-      @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).div(2)
-        
-        if a[m] > e
-          l = m+1
-        else
-          u = m
-        end
-      end
-      
-      return l
-    end
-  end
+	# Maintains an ordered list of events, which can be cancelled.
+	class Events
+		# Represents a cancellable handle for a specific timer event.
+		class Handle
+			def initialize(time, callback)
+				@time = time
+				@callback = callback
+			end
+
+			# The absolute time that the handle should be fired at.
+			attr_reader :time
+
+			# Cancel this timer, O(1).
+			def cancel!
+				# The simplest way to keep track of cancelled status is to nullify the
+				# callback. This should also be optimal for garbage collection.
+				@callback = nil
+			end
+
+			# Has this timer been cancelled? Cancelled timer's don't fire.
+			def cancelled?
+				@callback.nil?
+			end
+
+			def > other
+				@time > other.to_f
+			end
+
+			def >= other
+				@time >= other.to_f
+			end
+
+			def to_f
+				@time
+			end
+
+			# Fire the callback if not cancelled with the given time parameter.
+			def fire(time)
+				@callback.call(time) if @callback
+			end
+		end
+
+		def initialize
+			# A sequence of handles, maintained in sorted order, future to present.
+			# @sequence.last is the next event to be fired.
+			@sequence = []
+			@queue = []
+		end
+
+		# Add an event at the given time.
+		def schedule(time, callback)
+			handle = Handle.new(time.to_f, callback)
+			
+			@queue << handle
+			
+			return handle
+		end
+
+		# Returns the first non-cancelled handle.
+		def first
+			merge!
+			
+			while (handle = @sequence.last)
+				return handle unless handle.cancelled?
+				@sequence.pop
+			end
+		end
+
+		# Returns the number of pending (possibly cancelled) events.
+		def size
+			@sequence.size + @queue.size
+		end
+
+		# Fire all handles for which Handle#time is less than the given time.
+		def fire(time)
+			merge!
+			
+			while handle = @sequence.last and handle.time <= time
+				@sequence.pop
+				handle.fire(time)
+			end
+		end
+
+		private
+
+		def merge!
+			while handle = @queue.pop
+				next if handle.cancelled?
+				
+				index = bisect_right(@sequence, handle)
+				
+				if current_handle = @sequence[index] and current_handle.cancelled?
+					# puts "Replacing handle at index: #{index} due to cancellation in array containing #{@sequence.size} item(s)."
+					@sequence[index] = handle
+				else
+					# puts "Inserting handle at index: #{index} in array containing #{@sequence.size} item(s)."
+					@sequence.insert(index, handle)
+				end
+			end
+		end
+
+		# Return the right-most index where to insert item e, in a list a, assuming
+		# a is sorted in descending order.
+		def bisect_right(a, e, l = 0, u = a.length)
+			while l < u
+				m = l + (u - l).div(2)
+
+				if a[m] >= e
+					l = m + 1
+				else
+					u = m
+				end
+			end
+
+			l
+		end
+	end
 end

data/lib/timers/group.rb

@@ -1,132 +1,147 @@
-
-require 'set'
-require 'forwardable'
-require 'hitimes'
-
-require 'timers/timer'
-require 'timers/events'
+# 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.
+
+require "set"
+require "forwardable"
+
+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