rbs-relaxed 3.9.0.1

data/stdlib/minitest/0/minitest.rbs

@@ -0,0 +1,115 @@
+# <!-- 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

data/stdlib/monitor/0/monitor.rbs

@@ -0,0 +1,363 @@
+# <!-- 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 -> nil
+  # -->
+  # Enters exclusive section.
+  #
+  def enter: () -> nil
+
+  # <!--
+  #   rdoc-file=ext/monitor/monitor.c
+  #   - exit -> nil
+  # -->
+  # Leaves exclusive section.
+  #
+  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()
+  # -->
+  # Creates a new MonitorMixin::ConditionVariable associated with the Monitor
+  # object.
+  #
+  def new_cond: () -> ::MonitorMixin::ConditionVariable
+
+  # <!--
+  #   rdoc-file=ext/monitor/monitor.c
+  #   - synchronize { } -> result of the block
+  # -->
+  # Enters exclusive section and executes the block.  Leaves the exclusive section
+  # automatically when the block exits.  See example under `MonitorMixin`.
+  #
+  def synchronize: [T] () { () -> T } -> T
+
+  # <!--
+  #   rdoc-file=ext/monitor/monitor.c
+  #   - try_enter -> true or false
+  # -->
+  # Attempts to enter exclusive section.  Returns `false` if lock fails.
+  #
+  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()
+  # -->
+  # Ensures that the MonitorMixin is owned by the current thread, otherwise raises
+  # an exception.
+  #
+  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

data/stdlib/mutex_m/0/mutex_m.rbs

@@ -0,0 +1,104 @@
+# <!-- 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

data/stdlib/net-http/0/manifest.yaml

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