timemachine 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2faa5eb5940725efe1ad79b7bbdc332744005dc51b82135428732ab29e173627
+  data.tar.gz: 781d8866427bf3eae6e55f444818d380618376c75b0b7da7b069d78b0a4e1eff
+SHA512:
+  metadata.gz: c04709eb092377f4fc184a1522e5a51bbacba3103008dcfee03e9841e7c8bb2055317994560d57cfcd085a52cb0e7f0ec91b422f3679838376dfc1bde56365d5
+  data.tar.gz: 0b321773be1198e5def0316f35cc220b985f9d2bd88a5e8b9bb92c8a6071dcbbcc1c3d7eb0e7590acf4b90454b91a5447ee192455e057b74e8ca849418fba59b

data/lib/executor.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module TimeMachine
+  module Executors
+    class Executor
+      def execute(&block)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/thread_executor.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'executor'
+
+module TimeMachine
+  module Executors
+    class ThreadExecutor < Executor
+      def execute(&block)
+        Thread.new(&block)
+      end
+    end
+  end
+end

data/lib/timemachine.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require 'thread_executor'
+
+module TimeMachine
+  TimedTask = Struct.new(:handle, :timeup, :block)
+  TaskResult = Struct.new(:handle, :status, :record_result, :result)
+
+  class DuplicateHandleError < RuntimeError; end
+
+  class TimeMachine
+    SCHEDULER_DEFAULT_TIMEOUT = 3
+    RANDOM_HANDLE_LENGTH = 16
+    private_constant :SCHEDULER_DEFAULT_TIMEOUT
+
+    public
+    def initialize(executor= Executors::ThreadExecutor.new, more_timely=false)
+      @running = false
+      @timeout_queue = []
+
+      @result_queue = {}
+      @pending_schedule_queue = []
+      @cancel_queue = []
+
+      @executor = executor
+      @scheduler_thread = nil
+      @scheduler_mut = if more_timely then Mutex.new else nil end
+      @user_mut = Mutex.new
+    end
+
+    def at(timeup, name: nil, record_result: false, &block)
+      handle = name || _generate_handle
+
+      @user_mut.synchronize do
+        raise DuplicateHandleError if @result_queue.key? handle
+        result_slot = TaskResult.new(handle, :UNSCHEDULED, record_result, nil)
+        @result_queue[handle] = result_slot
+        @pending_schedule_queue << TimedTask.new(
+          handle, timeup, block
+        )
+      end
+
+      _bg_wakeup
+      handle
+    end
+
+    def after(timeout, name: nil, record_result: false, &block)
+      at(Time.now + timeout, name: name, record_result: record_result, &block)
+    end
+
+    def get_result(handle)
+      @user_mut.synchronize do
+        @result_queue[handle]
+      end
+    end
+
+    def pop_result(handle)
+      @user_mut.synchronize do
+        res = @result_queue[handle]
+        if res&.status==:FINISHED || res&.status==:CANCELLED
+          @result_queue.delete(handle)
+        else
+          res
+        end
+      end
+    end
+
+    def cancel(handle)
+      @user_mut.synchronize do
+        @cancel_queue << handle
+      end
+      _bg_wakeup
+    end
+
+    def start()
+      @user_mut.synchronize do
+        return if @running
+        @running = true
+        @scheduler_thread = Thread.new { _bg_run() }
+      end
+    end
+
+    def stop()
+      @user_mut.synchronize do
+        return unless @running
+        @running = false
+        @result_queue.each_key { |h| @cancel_queue << h}
+      end
+      _bg_wakeup
+    end
+
+    private
+    def _generate_handle
+      h = (Time.now.to_f * 1000).to_i.to_s(36)
+      padding_len = RANDOM_HANDLE_LENGTH - h.size
+      randstr = Random.rand(('z'*padding_len).to_i(36))
+                  .to_s(36).rjust(padding_len, '0')
+      h + randstr
+    end
+
+    def _bg_wakeup
+      @scheduler_mut&.lock
+      @scheduler_thread.run
+      @scheduler_mut&.unlock
+    end
+
+    def _bg_run
+      @scheduler_mut&.lock
+      while @running
+        @user_mut.synchronize do
+          @cancel_queue.each { |h| _bg_cancelTask(h) }
+          @cancel_queue.clear
+          @pending_schedule_queue.each { |t| _bg_enqueueTask(t) }
+          @pending_schedule_queue.clear
+        end
+
+        abs_t = Time.now
+        ind = @timeout_queue.index { |t| t.timeup > abs_t } || @timeout_queue.size
+
+        @timeout_queue[0...ind].each do |t|
+          break if !@running
+          _bg_dispatchTask(t)
+        end
+
+        @timeout_queue = @timeout_queue[ind..]
+
+        timeout = (
+          @timeout_queue[0]&.timeup || 
+          (abs_t + SCHEDULER_DEFAULT_TIMEOUT)
+        ) - abs_t
+        timeout = 0 if timeout < 0
+
+        @scheduler_mut&.unlock
+        sleep timeout
+        @scheduler_mut&.lock        
+      end
+      @scheduler_mut&.unlock
+    end
+
+    def _bg_enqueueTask(task)
+      return if @result_queue[task.handle].status != :UNSCHEDULED
+
+      @result_queue[task.handle].status = :PENDING
+      @timeout_queue.insert(@timeout_queue.index do |t|
+        t.timeup > task.timeup
+      end || -1, task)
+    end
+
+    def _bg_cancelTask(handle)
+      result_slot = @result_queue[handle]
+      case result_slot&.status
+      when :UNSCHEDULED
+        result_slot.status = :CANCELLED
+      when :PENDING
+        result_slot.status = :CANCELLED
+        @timeout_queue.delete_if do |task|
+          task.handle == handle
+        end
+      end
+
+      @result_queue.delete(handle) unless result_slot.record_result
+    end
+
+    def _bg_dispatchTask(task)
+      return if !@running
+      result_slot = @result_queue[task.handle]
+      return if result_slot&.status != :PENDING
+
+      result_slot.status = :RUNNING
+      @executor.execute do
+        result_slot&.result = task.block.call
+        @user_mut.synchronize {
+          result_slot.record_result ? (result_slot&.status = :FINISHED) : @result_queue.delete(task.handle)
+        }
+      end
+    end
+  end
+  
+end

metadata

@@ -0,0 +1,42 @@
+--- !ruby/object:Gem::Specification
+name: timemachine
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- LTW
+bindir: bin
+cert_chain: []
+date: 2025-09-21 00:00:00.000000000 Z
+dependencies: []
+description: A library that executes task after timeup or timeout.
+email: ltwsamuel@outlook.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/executor.rb
+- lib/thread_executor.rb
+- lib/timemachine.rb
+homepage: https://github.com/LasSino/timemachine
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: A library that executes task after timeup or timeout.
+test_files: []