timers 4.1.2 → 4.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 97c81b8ed305099faee9ecec3ee32f6960b70d54
-  data.tar.gz: 90d94a796bfe60e78963b0053648396aefdb19b6
+SHA256:
+  metadata.gz: 52ef1e26aab6a7bbbf5c9d687028bdc36f52810dd7ebc0c76873b6bef9f30ca2
+  data.tar.gz: 26105fe04a6d2bfcdf9efb46ebd83d9562a08af3c2f113892a8be57713be6112
 SHA512:
-  metadata.gz: dbea5311bcd5fb7bfe7c98191ac15146647b91ab5c994309f3bc14fe394ac97832361afa6ff7f257d844a802265125a5bafa051026fa1eed979f8310d8a21f87
-  data.tar.gz: 2097c9e9d6e838550fa3c4735db828173852dd5e598670a376a04de132274df6464687cfe0e72992c2469d5d355932808fe1147e44ec5f26e2162046267c37ad
+  metadata.gz: 2a3ae0e0d9644627fef3aeffdfde86456d74c28ab89194486743fee2a25e8832c5aafb05f88174f6ee27d4f9402e05b4f80776c49cc34d70da527e63f9097685
+  data.tar.gz: 1f30b97aa11f6f42b3ce1786ae42f06334a86064306601635774b8d84cc88df765e8312a455798984520d44e3db35f8094fb23ec35cb736eb2191bfa27dece0c

data/lib/timers.rb

@@ -1,6 +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,111 +1,143 @@
 # frozen_string_literal: true
 
-require "forwardable"
-require "hitimes"
-
-require "timers/timer"
+# 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 "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_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 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 = []
-    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)
-
-      handle
-    end
-
-    # Returns the first non-cancelled handle.
-    def first
-      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
-    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
-
-      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,127 +1,147 @@
 # 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 "hitimes"
 
-require "timers/timer"
-require "timers/events"
+require_relative "interval"
+require_relative "timer"
+require_relative "events"
 
 module Timers
-  # 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 = Hitimes::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
+	# 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