lightning_ui_kit 0.3.3 → 0.3.5

data/vendor/bundle/ruby/3.4.0/gems/concurrent-ruby-1.3.6/lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb

@@ -0,0 +1,396 @@
+require 'thread'
+require 'concurrent/atomic/event'
+require 'concurrent/concern/logging'
+require 'concurrent/executor/ruby_executor_service'
+require 'concurrent/utility/monotonic_time'
+require 'concurrent/collection/timeout_queue'
+
+module Concurrent
+
+  # @!macro thread_pool_executor
+  # @!macro thread_pool_options
+  # @!visibility private
+  class RubyThreadPoolExecutor < RubyExecutorService
+    include Concern::Deprecation
+
+    # @!macro thread_pool_executor_constant_default_max_pool_size
+    DEFAULT_MAX_POOL_SIZE      = 2_147_483_647 # java.lang.Integer::MAX_VALUE
+
+    # @!macro thread_pool_executor_constant_default_min_pool_size
+    DEFAULT_MIN_POOL_SIZE      = 0
+
+    # @!macro thread_pool_executor_constant_default_max_queue_size
+    DEFAULT_MAX_QUEUE_SIZE     = 0
+
+    # @!macro thread_pool_executor_constant_default_thread_timeout
+    DEFAULT_THREAD_IDLETIMEOUT = 60
+
+    # @!macro thread_pool_executor_constant_default_synchronous
+    DEFAULT_SYNCHRONOUS = false
+
+    # @!macro thread_pool_executor_attr_reader_max_length
+    attr_reader :max_length
+
+    # @!macro thread_pool_executor_attr_reader_min_length
+    attr_reader :min_length
+
+    # @!macro thread_pool_executor_attr_reader_idletime
+    attr_reader :idletime
+
+    # @!macro thread_pool_executor_attr_reader_max_queue
+    attr_reader :max_queue
+
+    # @!macro thread_pool_executor_attr_reader_synchronous
+    attr_reader :synchronous
+
+    # @!macro thread_pool_executor_method_initialize
+    def initialize(opts = {})
+      super(opts)
+    end
+
+    # @!macro thread_pool_executor_attr_reader_largest_length
+    def largest_length
+      synchronize { @largest_length }
+    end
+
+    # @!macro thread_pool_executor_attr_reader_scheduled_task_count
+    def scheduled_task_count
+      synchronize { @scheduled_task_count }
+    end
+
+    # @!macro thread_pool_executor_attr_reader_completed_task_count
+    def completed_task_count
+      synchronize { @completed_task_count }
+    end
+
+    # @!macro thread_pool_executor_method_active_count
+    def active_count
+      synchronize do
+        @pool.length - @ready.length
+      end
+    end
+
+    # @!macro executor_service_method_can_overflow_question
+    def can_overflow?
+      synchronize { ns_limited_queue? }
+    end
+
+    # @!macro thread_pool_executor_attr_reader_length
+    def length
+      synchronize { @pool.length }
+    end
+
+    # @!macro thread_pool_executor_attr_reader_queue_length
+    def queue_length
+      synchronize { @queue.length }
+    end
+
+    # @!macro thread_pool_executor_attr_reader_remaining_capacity
+    def remaining_capacity
+      synchronize do
+        if ns_limited_queue?
+          @max_queue - @queue.length
+        else
+          -1
+        end
+      end
+    end
+
+    # removes the worker if it can be pruned
+    #
+    # @return [true, false] if the worker was pruned
+    #
+    # @!visibility private
+    def prune_worker(worker)
+      synchronize do
+        if ns_prunable_capacity > 0
+          remove_worker worker
+          true
+        else
+          false
+        end
+      end
+    end
+
+    # @!visibility private
+    def remove_worker(worker)
+      synchronize do
+        ns_remove_ready_worker worker
+        ns_remove_busy_worker worker
+      end
+    end
+
+    # @!visibility private
+    def ready_worker(worker, last_message)
+      synchronize { ns_ready_worker worker, last_message }
+    end
+
+    # @!visibility private
+    def worker_died(worker)
+      synchronize { ns_worker_died worker }
+    end
+
+    # @!visibility private
+    def worker_task_completed
+      synchronize { @completed_task_count += 1 }
+    end
+
+    # @!macro thread_pool_executor_method_prune_pool
+    def prune_pool
+      deprecated "#prune_pool has no effect and will be removed in next the release, see https://github.com/ruby-concurrency/concurrent-ruby/pull/1082."
+    end
+
+    private
+
+    # @!visibility private
+    def ns_initialize(opts)
+      @min_length      = opts.fetch(:min_threads, DEFAULT_MIN_POOL_SIZE).to_i
+      @max_length      = opts.fetch(:max_threads, DEFAULT_MAX_POOL_SIZE).to_i
+      @idletime        = opts.fetch(:idletime, DEFAULT_THREAD_IDLETIMEOUT).to_i
+      @max_queue       = opts.fetch(:max_queue, DEFAULT_MAX_QUEUE_SIZE).to_i
+      @synchronous     = opts.fetch(:synchronous, DEFAULT_SYNCHRONOUS)
+      @fallback_policy = opts.fetch(:fallback_policy, :abort)
+
+      raise ArgumentError.new("`synchronous` cannot be set unless `max_queue` is 0") if @synchronous && @max_queue > 0
+      raise ArgumentError.new("#{@fallback_policy} is not a valid fallback policy") unless FALLBACK_POLICIES.include?(@fallback_policy)
+      raise ArgumentError.new("`max_threads` cannot be less than #{DEFAULT_MIN_POOL_SIZE}") if @max_length < DEFAULT_MIN_POOL_SIZE
+      raise ArgumentError.new("`max_threads` cannot be greater than #{DEFAULT_MAX_POOL_SIZE}") if @max_length > DEFAULT_MAX_POOL_SIZE
+      raise ArgumentError.new("`min_threads` cannot be less than #{DEFAULT_MIN_POOL_SIZE}") if @min_length < DEFAULT_MIN_POOL_SIZE
+      raise ArgumentError.new("`min_threads` cannot be more than `max_threads`") if min_length > max_length
+
+      @pool                 = [] # all workers
+      @ready                = [] # used as a stash (most idle worker is at the start)
+      @queue                = [] # used as queue
+      # @ready or @queue is empty at all times
+      @scheduled_task_count = 0
+      @completed_task_count = 0
+      @largest_length       = 0
+      @workers_counter      = 0
+      @ruby_pid             = $$ # detects if Ruby has forked
+    end
+
+    # @!visibility private
+    def ns_limited_queue?
+      @max_queue != 0
+    end
+
+    # @!visibility private
+    def ns_execute(*args, &task)
+      ns_reset_if_forked
+
+      if ns_assign_worker(*args, &task) || ns_enqueue(*args, &task)
+        @scheduled_task_count += 1
+        nil
+      else
+        fallback_action(*args, &task)
+      end
+    end
+
+    # @!visibility private
+    def ns_shutdown_execution
+      ns_reset_if_forked
+
+      if @pool.empty?
+        # nothing to do
+        stopped_event.set
+      end
+
+      if @queue.empty?
+        # no more tasks will be accepted, just stop all workers
+        @pool.each(&:stop)
+      end
+    end
+
+    # @!visibility private
+    def ns_kill_execution
+      # TODO log out unprocessed tasks in queue
+      # TODO try to shutdown first?
+      @pool.each(&:kill)
+      @pool.clear
+      @ready.clear
+    end
+
+    # tries to assign task to a worker, tries to get one from @ready or to create new one
+    # @return [true, false] if task is assigned to a worker
+    #
+    # @!visibility private
+    def ns_assign_worker(*args, &task)
+      # keep growing if the pool is not at the minimum yet
+      worker, _ = (@ready.pop if @pool.size >= @min_length) || ns_add_busy_worker
+      if worker
+        worker << [task, args]
+        true
+      else
+        false
+      end
+    rescue ThreadError
+      # Raised when the operating system refuses to create the new thread
+      return false
+    end
+
+    # tries to enqueue task
+    # @return [true, false] if enqueued
+    #
+    # @!visibility private
+    def ns_enqueue(*args, &task)
+      return false if @synchronous
+
+      if !ns_limited_queue? || @queue.size < @max_queue
+        @queue << [task, args]
+        true
+      else
+        false
+      end
+    end
+
+    # @!visibility private
+    def ns_worker_died(worker)
+      ns_remove_busy_worker worker
+      replacement_worker = ns_add_busy_worker
+      ns_ready_worker replacement_worker, Concurrent.monotonic_time, false if replacement_worker
+    end
+
+    # creates new worker which has to receive work to do after it's added
+    # @return [nil, Worker] nil of max capacity is reached
+    #
+    # @!visibility private
+    def ns_add_busy_worker
+      return if @pool.size >= @max_length
+
+      @workers_counter += 1
+      @pool << (worker = Worker.new(self, @workers_counter))
+      @largest_length = @pool.length if @pool.length > @largest_length
+      worker
+    end
+
+    # handle ready worker, giving it new job or assigning back to @ready
+    #
+    # @!visibility private
+    def ns_ready_worker(worker, last_message, success = true)
+      task_and_args = @queue.shift
+      if task_and_args
+        worker << task_and_args
+      else
+        # stop workers when !running?, do not return them to @ready
+        if running?
+          raise unless last_message
+          @ready.push([worker, last_message])
+        else
+          worker.stop
+        end
+      end
+    end
+
+    # removes a worker which is not tracked in @ready
+    #
+    # @!visibility private
+    def ns_remove_busy_worker(worker)
+      @pool.delete(worker)
+      stopped_event.set if @pool.empty? && !running?
+      true
+    end
+
+    # @!visibility private
+    def ns_remove_ready_worker(worker)
+      if index = @ready.index { |rw, _| rw == worker }
+        @ready.delete_at(index)
+      end
+      true
+    end
+
+    # @return [Integer] number of excess idle workers which can be removed without
+    #                   going below min_length, or all workers if not running
+    #
+    # @!visibility private
+    def ns_prunable_capacity
+      if running?
+        [@pool.size - @min_length, @ready.size].min
+      else
+        @pool.size
+      end
+    end
+
+    # @!visibility private
+    def ns_reset_if_forked
+      if $$ != @ruby_pid
+        @queue.clear
+        @ready.clear
+        @pool.clear
+        @scheduled_task_count = 0
+        @completed_task_count = 0
+        @largest_length       = 0
+        @workers_counter      = 0
+        @ruby_pid             = $$
+      end
+    end
+
+    # @!visibility private
+    class Worker
+      include Concern::Logging
+
+      def initialize(pool, id)
+        # instance variables accessed only under pool's lock so no need to sync here again
+        @queue  = Collection::TimeoutQueue.new
+        @pool   = pool
+        @thread = create_worker @queue, pool, pool.idletime
+
+        if @thread.respond_to?(:name=)
+          @thread.name = [pool.name, 'worker', id].compact.join('-')
+        end
+      end
+
+      def <<(message)
+        @queue << message
+      end
+
+      def stop
+        @queue << :stop
+      end
+
+      def kill
+        @thread.kill
+      end
+
+      private
+
+      def create_worker(queue, pool, idletime)
+        Thread.new(queue, pool, idletime) do |my_queue, my_pool, my_idletime|
+          catch(:stop) do
+            prunable = true
+
+            loop do
+              timeout = prunable && my_pool.running? ? my_idletime : nil
+              case message = my_queue.pop(timeout: timeout)
+              when nil
+                throw :stop if my_pool.prune_worker(self)
+                prunable = false
+              when :stop
+                my_pool.remove_worker(self)
+                throw :stop
+              else
+                task, args = message
+                run_task my_pool, task, args
+                my_pool.ready_worker(self, Concurrent.monotonic_time)
+                prunable = true
+              end
+            end
+          end
+        end
+      end
+
+      def run_task(pool, task, args)
+        task.call(*args)
+        pool.worker_task_completed
+      rescue => ex
+        # let it fail
+        log DEBUG, ex
+      rescue Exception => ex
+        log ERROR, ex
+        pool.worker_died(self)
+        throw :stop
+      end
+    end
+
+    private_constant :Worker
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/concurrent-ruby-1.3.6/lib/concurrent-ruby/concurrent/executor/timer_set.rb

@@ -0,0 +1,179 @@
+require 'concurrent/scheduled_task'
+require 'concurrent/atomic/event'
+require 'concurrent/collection/non_concurrent_priority_queue'
+require 'concurrent/executor/executor_service'
+require 'concurrent/executor/single_thread_executor'
+require 'concurrent/errors'
+require 'concurrent/options'
+
+module Concurrent
+
+  # Executes a collection of tasks, each after a given delay. A master task
+  # monitors the set and schedules each task for execution at the appropriate
+  # time. Tasks are run on the global thread pool or on the supplied executor.
+  # Each task is represented as a `ScheduledTask`.
+  #
+  # @see Concurrent::ScheduledTask
+  #
+  # @!macro monotonic_clock_warning
+  class TimerSet < RubyExecutorService
+
+    # Create a new set of timed tasks.
+    #
+    # @!macro executor_options
+    #
+    #   @param [Hash] opts the options used to specify the executor on which to perform actions
+    #   @option opts [Executor] :executor when set use the given `Executor` instance.
+    #     Three special values are also supported: `:task` returns the global task pool,
+    #     `:operation` returns the global operation pool, and `:immediate` returns a new
+    #     `ImmediateExecutor` object.
+    def initialize(opts = {})
+      super(opts)
+    end
+
+    # Post a task to be execute run after a given delay (in seconds). If the
+    # delay is less than 1/100th of a second the task will be immediately post
+    # to the executor.
+    #
+    # @param [Float] delay the number of seconds to wait for before executing the task.
+    # @param [Array<Object>] args the arguments passed to the task on execution.
+    #
+    # @yield the task to be performed.
+    #
+    # @return [Concurrent::ScheduledTask, false] IVar representing the task if the post
+    #   is successful; false after shutdown.
+    #
+    # @raise [ArgumentError] if the intended execution time is not in the future.
+    # @raise [ArgumentError] if no block is given.
+    def post(delay, *args, &task)
+      raise ArgumentError.new('no block given') unless block_given?
+      return false unless running?
+      opts = { executor:  @task_executor,
+               args:      args,
+               timer_set: self }
+      task = ScheduledTask.execute(delay, opts, &task) # may raise exception
+      task.unscheduled? ? false : task
+    end
+
+    # Begin an immediate shutdown. In-progress tasks will be allowed to
+    # complete but enqueued tasks will be dismissed and no new tasks
+    # will be accepted. Has no additional effect if the thread pool is
+    # not running.
+    def kill
+      shutdown
+      @timer_executor.kill
+    end
+
+    private :<<
+
+    private
+
+    # Initialize the object.
+    #
+    # @param [Hash] opts the options to create the object with.
+    # @!visibility private
+    def ns_initialize(opts)
+      @queue              = Collection::NonConcurrentPriorityQueue.new(order: :min)
+      @task_executor      = Options.executor_from_options(opts) || Concurrent.global_io_executor
+      @timer_executor     = SingleThreadExecutor.new
+      @condition          = Event.new
+      @ruby_pid           = $$ # detects if Ruby has forked
+    end
+
+    # Post the task to the internal queue.
+    #
+    # @note This is intended as a callback method from ScheduledTask
+    #   only. It is not intended to be used directly. Post a task
+    #   by using the `SchedulesTask#execute` method.
+    #
+    # @!visibility private
+    def post_task(task)
+      synchronize { ns_post_task(task) }
+    end
+
+    # @!visibility private
+    def ns_post_task(task)
+      return false unless ns_running?
+      ns_reset_if_forked
+      if (task.initial_delay) <= 0.01
+        task.executor.post { task.process_task }
+      else
+        @queue.push(task)
+        # only post the process method when the queue is empty
+        @timer_executor.post(&method(:process_tasks)) if @queue.length == 1
+        @condition.set
+      end
+      true
+    end
+
+    # Remove the given task from the queue.
+    #
+    # @note This is intended as a callback method from `ScheduledTask`
+    #   only. It is not intended to be used directly. Cancel a task
+    #   by using the `ScheduledTask#cancel` method.
+    #
+    # @!visibility private
+    def remove_task(task)
+      synchronize { @queue.delete(task) }
+    end
+
+    # `ExecutorService` callback called during shutdown.
+    #
+    # @!visibility private
+    def ns_shutdown_execution
+      ns_reset_if_forked
+      @queue.clear
+      @condition.set
+      @condition.reset
+      @timer_executor.shutdown
+      stopped_event.set
+    end
+
+    def ns_reset_if_forked
+      if $$ != @ruby_pid
+        @queue.clear
+        @condition.reset
+        @ruby_pid = $$
+      end
+    end
+
+    # Run a loop and execute tasks in the scheduled order and at the approximate
+    # scheduled time. If no tasks remain the thread will exit gracefully so that
+    # garbage collection can occur. If there are no ready tasks it will sleep
+    # for up to 60 seconds waiting for the next scheduled task.
+    #
+    # @!visibility private
+    def process_tasks
+      loop do
+        task = synchronize { @condition.reset; @queue.peek }
+        break unless task
+
+        now  = Concurrent.monotonic_time
+        diff = task.schedule_time - now
+
+        if diff <= 0
+          # We need to remove the task from the queue before passing
+          # it to the executor, to avoid race conditions where we pass
+          # the peek'ed task to the executor and then pop a different
+          # one that's been added in the meantime.
+          #
+          # Note that there's no race condition between the peek and
+          # this pop - this pop could retrieve a different task from
+          # the peek, but that task would be due to fire now anyway
+          # (because @queue is a priority queue, and this thread is
+          # the only reader, so whatever timer is at the head of the
+          # queue now must have the same pop time, or a closer one, as
+          # when we peeked).
+          task = synchronize { @queue.pop }
+          begin
+            task.executor.post { task.process_task }
+          rescue RejectedExecutionError
+            # ignore and continue
+          end
+        else
+          @condition.wait([diff, 60].min)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/concurrent-ruby-1.3.6/lib/concurrent-ruby/concurrent/executors.rb

@@ -0,0 +1,19 @@
+require 'concurrent/executor/abstract_executor_service'
+require 'concurrent/executor/cached_thread_pool'
+require 'concurrent/executor/executor_service'
+require 'concurrent/executor/fixed_thread_pool'
+require 'concurrent/executor/immediate_executor'
+require 'concurrent/executor/indirect_immediate_executor'
+require 'concurrent/executor/java_executor_service'
+require 'concurrent/executor/java_single_thread_executor'
+require 'concurrent/executor/java_thread_pool_executor'
+require 'concurrent/executor/ruby_executor_service'
+require 'concurrent/executor/ruby_single_thread_executor'
+require 'concurrent/executor/ruby_thread_pool_executor'
+require 'concurrent/executor/safe_task_executor'
+require 'concurrent/executor/serial_executor_service'
+require 'concurrent/executor/serialized_execution'
+require 'concurrent/executor/serialized_execution_delegator'
+require 'concurrent/executor/single_thread_executor'
+require 'concurrent/executor/thread_pool_executor'
+require 'concurrent/executor/timer_set'