@ai-ecoverse/wasix-ruby 3.4.11-2 → 3.4.11-4

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/stdlib/minitest/0/minitest.rbs

@@ -1,115 +0,0 @@
-# <!-- rdoc-file=lib/minitest.rb -->
-# The top-level namespace for Minitest. Also the location of the main runtime.
-# See `Minitest.run` for more information.
-#
-module Minitest
-  @@installed_at_exit: untyped
-
-  @@after_run: untyped
-
-  self.@extensions: untyped
-
-  def self.cattr_accessor: (untyped name) -> untyped
-
-  # <!--
-  #   rdoc-file=lib/minitest.rb
-  #   - autorun()
-  # -->
-  # Registers Minitest to run at process exit
-  #
-  def self.autorun: () -> untyped
-
-  # <!--
-  #   rdoc-file=lib/minitest.rb
-  #   - after_run(&block)
-  # -->
-  # A simple hook allowing you to run a block of code after everything is done
-  # running. Eg:
-  #
-  #     Minitest.after_run { p $debugging_info }
-  #
-  def self.after_run: () { (?) -> untyped } -> untyped
-
-  # <!--
-  #   rdoc-file=lib/minitest.rb
-  #   - register_plugin(name_or_mod)
-  # -->
-  # Register a plugin to be used. Does NOT require / load it.
-  #
-  def self.register_plugin: (untyped name_or_mod) -> nil
-
-  def self.load_plugins: () -> (nil | untyped)
-
-  def self.init_plugins: (untyped options) -> untyped
-
-  def self.process_args: (?untyped args) -> untyped
-
-  # <!--
-  #   rdoc-file=lib/minitest.rb
-  #   - run(args = [])
-  # -->
-  # This is the top-level run method. Everything starts from here. It tells each
-  # Runnable sub-class to run, and each of those are responsible for doing
-  # whatever they do.
-  #
-  # The overall structure of a run looks like this:
-  #
-  #     Minitest.autorun
-  #       Minitest.run(args)
-  #         Minitest.load_plugins
-  #         Minitest.process_args
-  #         Minitest.init_plugins
-  #         Minitest.__run(reporter, options)
-  #           Runnable.runnables.each
-  #             runnable_klass.run(reporter, options)
-  #               self.runnable_methods.each
-  #                 self.run_one_method(self, runnable_method, reporter)
-  #                   Minitest.run_one_method(klass, runnable_method)
-  #                     klass.new(runnable_method).run
-  #
-  def self.run: (?untyped args) -> untyped
-
-  def self.empty_run!: (untyped options) -> untyped
-
-  # <!--
-  #   rdoc-file=lib/minitest.rb
-  #   - __run(reporter, options)
-  # -->
-  # Internal run method. Responsible for telling all Runnable sub-classes to run.
-  #
-  def self.__run: (untyped reporter, untyped options) -> untyped
-
-  def self.filter_backtrace: (untyped bt) -> untyped
-
-  def self.run_one_method: (untyped klass, untyped method_name) -> untyped
-
-  def self.clock_time: () -> untyped
-
-  # <!--
-  #   rdoc-file=lib/minitest/manual_plugins.rb
-  #   - load(*names)
-  # -->
-  # Manually load plugins by name.
-  #
-  def self.load: (*untyped names) -> untyped
-
-  def self.plugin_pride_options: (untyped opts, untyped _options) -> untyped
-
-  def self.plugin_pride_init: (untyped options) -> (nil | untyped)
-
-  attr_accessor self.seed: untyped
-
-  attr_accessor self.parallel_executor: untyped
-
-  attr_accessor self.backtrace_filter: untyped
-
-  attr_accessor self.reporter: untyped
-
-  attr_accessor self.extensions: untyped
-
-  attr_accessor self.info_signal: untyped
-
-  attr_accessor self.allow_fork: untyped
-
-  VERSION: String
-end

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/stdlib/monitor/0/monitor.rbs

@@ -1,354 +0,0 @@
-# <!-- rdoc-file=ext/monitor/lib/monitor.rb -->
-# Use the Monitor class when you want to have a lock object for blocks with
-# mutual exclusion.
-#
-#     require 'monitor'
-#
-#     lock = Monitor.new
-#     lock.synchronize do
-#       # exclusive access
-#     end
-#
-class Monitor
-  # <!--
-  #   rdoc-file=ext/monitor/monitor.c
-  #   - enter()
-  # -->
-  #
-  def enter: () -> nil
-
-  # <!--
-  #   rdoc-file=ext/monitor/monitor.c
-  #   - exit()
-  # -->
-  #
-  def exit: () -> nil
-
-  # <!--
-  #   rdoc-file=ext/monitor/monitor.c
-  #   - mon_check_owner()
-  # -->
-  #
-  def mon_check_owner: () -> nil
-
-  # <!--
-  #   rdoc-file=ext/monitor/lib/monitor.rb
-  #   - mon_enter()
-  # -->
-  #
-  alias mon_enter enter
-
-  # <!--
-  #   rdoc-file=ext/monitor/lib/monitor.rb
-  #   - mon_exit()
-  # -->
-  #
-  alias mon_exit exit
-
-  # <!--
-  #   rdoc-file=ext/monitor/monitor.c
-  #   - mon_locked?()
-  # -->
-  #
-  def mon_locked?: () -> bool
-
-  # <!--
-  #   rdoc-file=ext/monitor/monitor.c
-  #   - mon_owned?()
-  # -->
-  #
-  def mon_owned?: () -> bool
-
-  # <!--
-  #   rdoc-file=ext/monitor/lib/monitor.rb
-  #   - mon_synchronize()
-  # -->
-  #
-  alias mon_synchronize synchronize
-
-  # <!--
-  #   rdoc-file=ext/monitor/lib/monitor.rb
-  #   - mon_try_enter()
-  # -->
-  #
-  alias mon_try_enter try_enter
-
-  # <!--
-  #   rdoc-file=ext/monitor/lib/monitor.rb
-  #   - new_cond()
-  # -->
-  #
-  def new_cond: () -> ::MonitorMixin::ConditionVariable
-
-  # <!--
-  #   rdoc-file=ext/monitor/monitor.c
-  #   - synchronize()
-  # -->
-  #
-  def synchronize: [T] () { () -> T } -> T
-
-  # <!--
-  #   rdoc-file=ext/monitor/monitor.c
-  #   - try_enter()
-  # -->
-  #
-  def try_enter: () -> bool
-
-  # <!-- rdoc-file=ext/monitor/lib/monitor.rb -->
-  # for compatibility
-  #
-  alias try_mon_enter try_enter
-
-  # <!--
-  #   rdoc-file=ext/monitor/monitor.c
-  #   - wait_for_cond(p1, p2)
-  # -->
-  #
-  def wait_for_cond: (::MonitorMixin::ConditionVariable, Numeric? timeout) -> untyped
-end
-
-# <!-- rdoc-file=ext/monitor/lib/monitor.rb -->
-# In concurrent programming, a monitor is an object or module intended to be
-# used safely by more than one thread. The defining characteristic of a monitor
-# is that its methods are executed with mutual exclusion. That is, at each point
-# in time, at most one thread may be executing any of its methods. This mutual
-# exclusion greatly simplifies reasoning about the implementation of monitors
-# compared to reasoning about parallel code that updates a data structure.
-#
-# You can read more about the general principles on the Wikipedia page for
-# [Monitors](https://en.wikipedia.org/wiki/Monitor_%28synchronization%29).
-#
-# ## Examples
-#
-# ### Simple object.extend
-#
-#     require 'monitor.rb'
-#
-#     buf = []
-#     buf.extend(MonitorMixin)
-#     empty_cond = buf.new_cond
-#
-#     # consumer
-#     Thread.start do
-#       loop do
-#         buf.synchronize do
-#           empty_cond.wait_while { buf.empty? }
-#           print buf.shift
-#         end
-#       end
-#     end
-#
-#     # producer
-#     while line = ARGF.gets
-#       buf.synchronize do
-#         buf.push(line)
-#         empty_cond.signal
-#       end
-#     end
-#
-# The consumer thread waits for the producer thread to push a line to buf while
-# `buf.empty?`. The producer thread (main thread) reads a line from ARGF and
-# pushes it into buf then calls `empty_cond.signal` to notify the consumer
-# thread of new data.
-#
-# ### Simple Class include
-#
-#     require 'monitor'
-#
-#     class SynchronizedArray < Array
-#
-#       include MonitorMixin
-#
-#       def initialize(*args)
-#         super(*args)
-#       end
-#
-#       alias :old_shift :shift
-#       alias :old_unshift :unshift
-#
-#       def shift(n=1)
-#         self.synchronize do
-#           self.old_shift(n)
-#         end
-#       end
-#
-#       def unshift(item)
-#         self.synchronize do
-#           self.old_unshift(item)
-#         end
-#       end
-#
-#       # other methods ...
-#     end
-#
-# `SynchronizedArray` implements an Array with synchronized access to items.
-# This Class is implemented as subclass of Array which includes the MonitorMixin
-# module.
-#
-module MonitorMixin
-  # <!--
-  #   rdoc-file=ext/monitor/lib/monitor.rb
-  #   - extend_object(obj)
-  # -->
-  #
-  def self.extend_object: (untyped obj) -> untyped
-
-  # <!--
-  #   rdoc-file=ext/monitor/lib/monitor.rb
-  #   - mon_enter()
-  # -->
-  # Enters exclusive section.
-  #
-  def mon_enter: () -> nil
-
-  # <!--
-  #   rdoc-file=ext/monitor/lib/monitor.rb
-  #   - mon_exit()
-  # -->
-  # Leaves exclusive section.
-  #
-  def mon_exit: () -> nil
-
-  # <!--
-  #   rdoc-file=ext/monitor/lib/monitor.rb
-  #   - mon_locked?()
-  # -->
-  # Returns true if this monitor is locked by any thread
-  #
-  def mon_locked?: () -> bool
-
-  # <!--
-  #   rdoc-file=ext/monitor/lib/monitor.rb
-  #   - mon_owned?()
-  # -->
-  # Returns true if this monitor is locked by current thread.
-  #
-  def mon_owned?: () -> bool
-
-  # <!--
-  #   rdoc-file=ext/monitor/lib/monitor.rb
-  #   - mon_synchronize(&b)
-  # -->
-  # Enters exclusive section and executes the block.  Leaves the exclusive section
-  # automatically when the block exits.  See example under `MonitorMixin`.
-  #
-  def mon_synchronize: [T] () { () -> T } -> T
-
-  # <!--
-  #   rdoc-file=ext/monitor/lib/monitor.rb
-  #   - mon_try_enter()
-  # -->
-  # Attempts to enter exclusive section.  Returns `false` if lock fails.
-  #
-  def mon_try_enter: () -> bool
-
-  # <!--
-  #   rdoc-file=ext/monitor/lib/monitor.rb
-  #   - new_cond()
-  # -->
-  # Creates a new MonitorMixin::ConditionVariable associated with the Monitor
-  # object.
-  #
-  def new_cond: () -> ::MonitorMixin::ConditionVariable
-
-  # <!--
-  #   rdoc-file=ext/monitor/lib/monitor.rb
-  #   - synchronize(&b)
-  # -->
-  #
-  alias synchronize mon_synchronize
-
-  # <!-- rdoc-file=ext/monitor/lib/monitor.rb -->
-  # For backward compatibility
-  #
-  alias try_mon_enter mon_try_enter
-
-  private
-
-  # <!--
-  #   rdoc-file=ext/monitor/lib/monitor.rb
-  #   - new(...)
-  # -->
-  # Use `extend MonitorMixin` or `include MonitorMixin` instead of this
-  # constructor.  Have look at the examples above to understand how to use this
-  # module.
-  #
-  def initialize: (*untyped) { (*untyped) -> untyped } -> void
-
-  # <!--
-  #   rdoc-file=ext/monitor/lib/monitor.rb
-  #   - mon_check_owner()
-  # -->
-  #
-  def mon_check_owner: () -> nil
-
-  # <!--
-  #   rdoc-file=ext/monitor/lib/monitor.rb
-  #   - mon_initialize()
-  # -->
-  # Initializes the MonitorMixin after being included in a class or when an object
-  # has been extended with the MonitorMixin
-  #
-  def mon_initialize: () -> untyped
-end
-
-# <!-- rdoc-file=ext/monitor/lib/monitor.rb -->
-# FIXME: This isn't documented in Nutshell.
-#
-# Since MonitorMixin.new_cond returns a ConditionVariable, and the example above
-# calls while_wait and signal, this class should be documented.
-#
-class MonitorMixin::ConditionVariable
-  # <!--
-  #   rdoc-file=ext/monitor/lib/monitor.rb
-  #   - broadcast()
-  # -->
-  # Wakes up all threads waiting for this lock.
-  #
-  def broadcast: () -> Thread::ConditionVariable
-
-  # <!--
-  #   rdoc-file=ext/monitor/lib/monitor.rb
-  #   - signal()
-  # -->
-  # Wakes up the first thread in line waiting for this lock.
-  #
-  def signal: () -> Thread::ConditionVariable
-
-  # <!--
-  #   rdoc-file=ext/monitor/lib/monitor.rb
-  #   - wait(timeout = nil)
-  # -->
-  # Releases the lock held in the associated monitor and waits; reacquires the
-  # lock on wakeup.
-  #
-  # If `timeout` is given, this method returns after `timeout` seconds passed,
-  # even if no other thread doesn't signal.
-  #
-  def wait: (?Numeric? timeout) -> untyped
-
-  # <!--
-  #   rdoc-file=ext/monitor/lib/monitor.rb
-  #   - wait_until()
-  # -->
-  # Calls wait repeatedly until the given block yields a truthy value.
-  #
-  def wait_until: () { () -> boolish } -> untyped
-
-  # <!--
-  #   rdoc-file=ext/monitor/lib/monitor.rb
-  #   - wait_while()
-  # -->
-  # Calls wait repeatedly while the given block yields a truthy value.
-  #
-  def wait_while: () { () -> boolish } -> untyped
-
-  private
-
-  # <!--
-  #   rdoc-file=ext/monitor/lib/monitor.rb
-  #   - new(monitor)
-  # -->
-  #
-  def initialize: (Monitor monitor) -> void
-end

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/stdlib/mutex_m/0/mutex_m.rbs

@@ -1,104 +0,0 @@
-# <!-- rdoc-file=lib/mutex_m.rb -->
-# # mutex_m.rb
-#
-# When 'mutex_m' is required, any object that extends or includes Mutex_m will
-# be treated like a Mutex.
-#
-# Start by requiring the standard library Mutex_m:
-#
-#     require "mutex_m.rb"
-#
-# From here you can extend an object with Mutex instance methods:
-#
-#     obj = Object.new
-#     obj.extend Mutex_m
-#
-# Or mixin Mutex_m into your module to your class inherit Mutex instance methods
-# --- remember to call super() in your class initialize method.
-#
-#     class Foo
-#       include Mutex_m
-#       def initialize
-#         # ...
-#         super()
-#       end
-#       # ...
-#     end
-#     obj = Foo.new
-#     # this obj can be handled like Mutex
-#
-module Mutex_m
-  def self.append_features: (Module cl) -> untyped
-
-  def self.define_aliases: (Module cl) -> untyped
-
-  def self.extend_object: (Object obj) -> untyped
-
-  def mu_extended: () -> untyped
-
-  # <!--
-  #   rdoc-file=lib/mutex_m.rb
-  #   - mu_lock()
-  # -->
-  # See Thread::Mutex#lock
-  #
-  def mu_lock: () -> Thread::Mutex
-
-  # <!--
-  #   rdoc-file=lib/mutex_m.rb
-  #   - mu_locked?()
-  # -->
-  # See Thread::Mutex#locked?
-  #
-  def mu_locked?: () -> bool
-
-  # <!--
-  #   rdoc-file=lib/mutex_m.rb
-  #   - mu_synchronize(&block)
-  # -->
-  # See Thread::Mutex#synchronize
-  #
-  def mu_synchronize: [T] () { () -> T } -> T
-
-  # <!--
-  #   rdoc-file=lib/mutex_m.rb
-  #   - mu_try_lock()
-  # -->
-  # See Thread::Mutex#try_lock
-  #
-  def mu_try_lock: () -> bool
-
-  # <!--
-  #   rdoc-file=lib/mutex_m.rb
-  #   - mu_unlock()
-  # -->
-  # See Thread::Mutex#unlock
-  #
-  def mu_unlock: () -> Thread::Mutex
-
-  # <!--
-  #   rdoc-file=lib/mutex_m.rb
-  #   - sleep(timeout = nil)
-  # -->
-  # See Thread::Mutex#sleep
-  #
-  def sleep: (?Numeric timeout) -> Integer?
-
-  alias locked? mu_locked?
-
-  alias lock mu_lock
-
-  alias unlock mu_unlock
-
-  alias try_lock mu_try_lock
-
-  alias synchronize mu_synchronize
-
-  private
-
-  def initialize: (*untyped args) -> untyped
-
-  def mu_initialize: () -> untyped
-end
-
-Mutex_m::VERSION: String

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/stdlib/net-http/0/manifest.yaml

@@ -1,3 +0,0 @@
-dependencies:
-  - name: net-protocol
-  - name: uri