rbs 4.0.0.dev.4 → 4.0.0

data/stdlib/random-formatter/0/random-formatter.rbs

@@ -0,0 +1,277 @@
+module RBS
+  module Unnamed
+    module Random_Formatter
+      # <!--
+      #   rdoc-file=lib/random/formatter.rb
+      #   - base64(n=nil)
+      # -->
+      # Generate a random base64 string.
+      #
+      # The argument *n* specifies the length, in bytes, of the random number to be
+      # generated. The length of the result string is about 4/3 of *n*.
+      #
+      # If *n* is not specified or is nil, 16 is assumed. It may be larger in the
+      # future.
+      #
+      # The result may contain A-Z, a-z, 0-9, "+", "/" and "=".
+      #
+      #     require 'random/formatter'
+      #
+      #     Random.base64 #=> "/2BuBuLf3+WfSKyQbRcc/A=="
+      #     # or
+      #     prng = Random.new
+      #     prng.base64 #=> "6BbW0pxO0YENxn38HMUbcQ=="
+      #
+      # See RFC 3548 for the definition of base64.
+      #
+      %a{annotate:rdoc:copy:Random::Formatter#base64}
+      def base64: (?Integer? n) -> String
+
+      # <!--
+      #   rdoc-file=lib/random/formatter.rb
+      #   - hex(n=nil)
+      # -->
+      # Generate a random hexadecimal string.
+      #
+      # The argument *n* specifies the length, in bytes, of the random number to be
+      # generated. The length of the resulting hexadecimal string is twice of *n*.
+      #
+      # If *n* is not specified or is nil, 16 is assumed. It may be larger in the
+      # future.
+      #
+      # The result may contain 0-9 and a-f.
+      #
+      #     require 'random/formatter'
+      #
+      #     Random.hex #=> "eb693ec8252cd630102fd0d0fb7c3485"
+      #     # or
+      #     prng = Random.new
+      #     prng.hex #=> "91dc3bfb4de5b11d029d376634589b61"
+      #
+      %a{annotate:rdoc:copy:Random::Formatter#hex}
+      def hex: (?Integer? n) -> String
+
+      # <!--
+      #   rdoc-file=lib/random/formatter.rb
+      #   - random_bytes(n=nil)
+      # -->
+      # Generate a random binary string.
+      #
+      # The argument *n* specifies the length of the result string.
+      #
+      # If *n* is not specified or is nil, 16 is assumed. It may be larger in future.
+      #
+      # The result may contain any byte: "x00" - "xff".
+      #
+      #     require 'random/formatter'
+      #
+      #     Random.random_bytes #=> "\xD8\\\xE0\xF4\r\xB2\xFC*WM\xFF\x83\x18\xF45\xB6"
+      #     # or
+      #     prng = Random.new
+      #     prng.random_bytes #=> "m\xDC\xFC/\a\x00Uf\xB2\xB2P\xBD\xFF6S\x97"
+      #
+      %a{annotate:rdoc:copy:Random::Formatter#random_bytes}
+      def random_bytes: (?Integer? n) -> String
+
+      # <!--
+      #   rdoc-file=lib/random/formatter.rb
+      #   - urlsafe_base64(n=nil, padding=false)
+      # -->
+      # Generate a random URL-safe base64 string.
+      #
+      # The argument *n* specifies the length, in bytes, of the random number to be
+      # generated. The length of the result string is about 4/3 of *n*.
+      #
+      # If *n* is not specified or is nil, 16 is assumed. It may be larger in the
+      # future.
+      #
+      # The boolean argument *padding* specifies the padding. If it is false or nil,
+      # padding is not generated. Otherwise padding is generated. By default, padding
+      # is not generated because "=" may be used as a URL delimiter.
+      #
+      # The result may contain A-Z, a-z, 0-9, "-" and "_". "=" is also used if
+      # *padding* is true.
+      #
+      #     require 'random/formatter'
+      #
+      #     Random.urlsafe_base64 #=> "b4GOKm4pOYU_-BOXcrUGDg"
+      #     # or
+      #     prng = Random.new
+      #     prng.urlsafe_base64 #=> "UZLdOkzop70Ddx-IJR0ABg"
+      #
+      #     prng.urlsafe_base64(nil, true) #=> "i0XQ-7gglIsHGV2_BNPrdQ=="
+      #     prng.urlsafe_base64(nil, true) #=> "-M8rLhr7JEpJlqFGUMmOxg=="
+      #
+      # See RFC 3548 for the definition of URL-safe base64.
+      #
+      %a{annotate:rdoc:copy:Random::Formatter#urlsafe_base64}
+      def urlsafe_base64: (?Integer? n, ?boolish padding) -> String
+
+      # <!--
+      #   rdoc-file=lib/random/formatter.rb
+      #   - uuid()
+      # -->
+      # Generate a random v4 UUID (Universally Unique IDentifier).
+      #
+      #     require 'random/formatter'
+      #
+      #     Random.uuid #=> "2d931510-d99f-494a-8c67-87feb05e1594"
+      #     Random.uuid #=> "bad85eb9-0713-4da7-8d36-07a8e4b00eab"
+      #     # or
+      #     prng = Random.new
+      #     prng.uuid #=> "62936e70-1815-439b-bf89-8492855a7e6b"
+      #
+      # The version 4 UUID is purely random (except the version). It doesn't contain
+      # meaningful information such as MAC addresses, timestamps, etc.
+      #
+      # The result contains 122 random bits (15.25 random bytes).
+      #
+      # See [RFC9562](https://www.rfc-editor.org/rfc/rfc9562) for details of UUIDv4.
+      #
+      %a{annotate:rdoc:copy:Random::Formatter#uuid}
+      def uuid: () -> String
+
+      # <!--
+      #   rdoc-file=lib/random/formatter.rb
+      #   - uuid_v4()
+      # -->
+      #
+      %a{annotate:rdoc:copy:Random::Formatter#uuid_v4}
+      alias uuid_v4 uuid
+
+      # <!--
+      #   rdoc-file=lib/random/formatter.rb
+      #   - uuid_v7(extra_timestamp_bits: 0)
+      # -->
+      # Generate a random v7 UUID (Universally Unique IDentifier).
+      #
+      #     require 'random/formatter'
+      #
+      #     Random.uuid_v7 # => "0188d4c3-1311-7f96-85c7-242a7aa58f1e"
+      #     Random.uuid_v7 # => "0188d4c3-16fe-744f-86af-38fa04c62bb5"
+      #     Random.uuid_v7 # => "0188d4c3-1af8-764f-b049-c204ce0afa23"
+      #     Random.uuid_v7 # => "0188d4c3-1e74-7085-b14f-ef6415dc6f31"
+      #     #                    |<--sorted-->| |<----- random ---->|
+      #
+      #     # or
+      #     prng = Random.new
+      #     prng.uuid_v7 # => "0188ca51-5e72-7950-a11d-def7ff977c98"
+      #
+      # The version 7 UUID starts with the least significant 48 bits of a 64 bit Unix
+      # timestamp (milliseconds since the epoch) and fills the remaining bits with
+      # random data, excluding the version and variant bits.
+      #
+      # This allows version 7 UUIDs to be sorted by creation time.  Time ordered UUIDs
+      # can be used for better database index locality of newly inserted records,
+      # which may have a significant performance benefit compared to random data
+      # inserts.
+      #
+      # The result contains 74 random bits (9.25 random bytes).
+      #
+      # Note that this method cannot be made reproducible because its output includes
+      # not only random bits but also timestamp.
+      #
+      # See [RFC9562](https://www.rfc-editor.org/rfc/rfc9562) for details of UUIDv7.
+      #
+      # #### Monotonicity
+      #
+      # UUIDv7 has millisecond precision by default, so multiple UUIDs created within
+      # the same millisecond are not issued in monotonically increasing order.  To
+      # create UUIDs that are time-ordered with sub-millisecond precision, up to 12
+      # bits of additional timestamp may added with `extra_timestamp_bits`.  The extra
+      # timestamp precision comes at the expense of random bits.  Setting
+      # <code>extra_timestamp_bits: 12</code> provides ~244ns of precision, but only
+      # 62 random bits (7.75 random bytes).
+      #
+      #     prng = Random.new
+      #     Array.new(4) { prng.uuid_v7(extra_timestamp_bits: 12) }
+      #     # =>
+      #     ["0188d4c7-13da-74f9-8b53-22a786ffdd5a",
+      #      "0188d4c7-13da-753b-83a5-7fb9b2afaeea",
+      #      "0188d4c7-13da-754a-88ea-ac0baeedd8db",
+      #      "0188d4c7-13da-7557-83e1-7cad9cda0d8d"]
+      #     # |<--- sorted --->| |<-- random --->|
+      #
+      #     Array.new(4) { prng.uuid_v7(extra_timestamp_bits: 8) }
+      #     # =>
+      #     ["0188d4c7-3333-7a95-850a-de6edb858f7e",
+      #      "0188d4c7-3333-7ae8-842e-bc3a8b7d0cf9",  # <- out of order
+      #      "0188d4c7-3333-7ae2-995a-9f135dc44ead",  # <- out of order
+      #      "0188d4c7-3333-7af9-87c3-8f612edac82e"]
+      #     # |<--- sorted -->||<---- random --->|
+      #
+      # Any rollbacks of the system clock will break monotonicity.  UUIDv7 is based on
+      # UTC, which excludes leap seconds and can rollback the clock.  To avoid this,
+      # the system clock can synchronize with an NTP server configured to use a "leap
+      # smear" approach.  NTP or PTP will also be needed to synchronize across
+      # distributed nodes.
+      #
+      # Counters and other mechanisms for stronger guarantees of monotonicity are not
+      # implemented.  Applications with stricter requirements should follow [Section
+      # 6.2](https://www.rfc-editor.org/rfc/rfc9562.html#name-monotonicity-and-counter
+      # s) of the specification.
+      #
+      %a{annotate:rdoc:copy:Random::Formatter#uuid_v7}
+      def uuid_v7: (?extra_timestamp_bits: Integer) -> String
+
+      # <!--
+      #   rdoc-file=lib/random/formatter.rb
+      #   - alphanumeric(n = nil, chars: ALPHANUMERIC)
+      # -->
+      # Generate a random alphanumeric string.
+      #
+      # The argument *n* specifies the length, in characters, of the alphanumeric
+      # string to be generated. The argument *chars* specifies the character list
+      # which the result is consist of.
+      #
+      # If *n* is not specified or is nil, 16 is assumed. It may be larger in the
+      # future.
+      #
+      # The result may contain A-Z, a-z and 0-9, unless *chars* is specified.
+      #
+      #     require 'random/formatter'
+      #
+      #     Random.alphanumeric     #=> "2BuBuLf3WfSKyQbR"
+      #     # or
+      #     prng = Random.new
+      #     prng.alphanumeric(10) #=> "i6K93NdqiH"
+      #
+      #     Random.alphanumeric(4, chars: [*"0".."9"]) #=> "2952"
+      #     # or
+      #     prng = Random.new
+      #     prng.alphanumeric(10, chars: [*"!".."/"]) #=> ",.,++%/''."
+      #
+      %a{annotate:rdoc:copy:Random::Formatter#alphanumeric}
+      def alphanumeric: (?Numeric?, ?chars: Array[String]) -> String
+
+      # <!--
+      #   rdoc-file=lib/random/formatter.rb
+      #   - gen_random(n)
+      # -->
+      # Internal interface to Random; Generate random data *n* bytes.
+      #
+      %a{annotate:rdoc:copy:Random::Formatter#gen_random}
+      private def gen_random: (Integer n) -> String
+
+      # <!--
+      #   rdoc-file=lib/random/formatter.rb
+      #   - choose(source, n)
+      # -->
+      # Generate a string that randomly draws from a source array of characters.
+      #
+      # The argument *source* specifies the array of characters from which to generate
+      # the string. The argument *n* specifies the length, in characters, of the
+      # string to be generated.
+      #
+      # The result may contain whatever characters are in the source array.
+      #
+      #     require 'random/formatter'
+      #
+      #     prng.choose([*'l'..'r'], 16) #=> "lmrqpoonmmlqlron"
+      #     prng.choose([*'0'..'9'], 5)  #=> "27309"
+      #
+      %a{annotate:rdoc:copy:Random::Formatter#choose}
+      private def choose: (Array[String] source, Integer n) -> String
+    end
+  end
+end

data/stdlib/rdoc/0/code_object.rbs

@@ -22,9 +22,10 @@ module RDoc
   #         *   RDoc::MetaMethod
   # *   RDoc::Alias
   # *   RDoc::Constant
+  # *   RDoc::Require
   # *   RDoc::Mixin
-  #     *   RDoc::Require
   #     *   RDoc::Include
+  #     *   RDoc::Extend
   #
   class CodeObject
     # <!-- rdoc-file=lib/rdoc/code_object.rb -->

data/stdlib/rdoc/0/parser.rbs

@@ -42,7 +42,7 @@ module RDoc
 
     # <!--
     #   rdoc-file=lib/rdoc/parser.rb
-    #   - new(top_level, file_name, content, options, stats)
+    #   - new(top_level, content, options, stats)
     # -->
     # Creates a new Parser storing `top_level`, `file_name`, `content`, `options`
     # and `stats` in instance variables.  In +@preprocess+ an

data/stdlib/rdoc/0/rdoc.rbs

@@ -84,7 +84,7 @@ module RDoc
     # -->
     # Starts collecting tokens
     #
-    def collect_tokens: () -> void
+    def collect_tokens: (Symbol) -> void
 
     # <!--
     #   rdoc-file=lib/rdoc/token_stream.rb

data/stdlib/rdoc/0/store.rbs

@@ -22,7 +22,7 @@ module RDoc
   class Store
     # <!--
     #   rdoc-file=lib/rdoc/store.rb
-    #   - new(path = nil, type = nil)
+    #   - new(options, path: nil, type: nil)
     # -->
     # Creates a new Store of `type` that will load or save to `path`
     #

data/stdlib/resolv/0/resolv.rbs

@@ -427,15 +427,9 @@ end
 class Resolv::DNS::Config::OtherResolvError < Resolv::ResolvError
 end
 
-# <!-- rdoc-file=lib/resolv.rb -->
-# Indicates that the DNS response was unable to be decoded.
-#
 class Resolv::DNS::DecodeError < StandardError
 end
 
-# <!-- rdoc-file=lib/resolv.rb -->
-# Indicates that the DNS request was unable to be encoded.
-#
 class Resolv::DNS::EncodeError < StandardError
 end
 
@@ -585,9 +579,6 @@ class Resolv::DNS::Message::MessageEncoder
   def initialize: () -> untyped
 end
 
-# <!-- rdoc-file=lib/resolv.rb -->
-# A representation of a DNS name.
-#
 class Resolv::DNS::Name
   # <!--
   #   rdoc-file=lib/resolv.rb
@@ -677,9 +668,6 @@ Resolv::DNS::OpCode::Status: Integer
 
 Resolv::DNS::OpCode::Update: Integer
 
-# <!-- rdoc-file=lib/resolv.rb -->
-# A DNS query abstract class.
-#
 class Resolv::DNS::Query
   def self.decode_rdata: (Resolv::DNS::Message::MessageDecoder msg) -> instance
 
@@ -817,9 +805,6 @@ class Resolv::DNS::Requester::UnconnectedUDP::Sender < Resolv::DNS::Requester::S
   def initialize: (Resolv::DNS::Message msg, String data, UDPSocket sock, String host, Integer port) -> untyped
 end
 
-# <!-- rdoc-file=lib/resolv.rb -->
-# A DNS resource abstract class.
-#
 class Resolv::DNS::Resource < Resolv::DNS::Query
   def self.decode_rdata: (Resolv::DNS::Message::MessageDecoder msg) -> instance
 
@@ -845,25 +830,16 @@ Resolv::DNS::Resource::ClassInsensitiveTypes: Array[singleton(Resolv::DNS::Resou
 
 Resolv::DNS::Resource::ClassValue: Integer?
 
-# <!-- rdoc-file=lib/resolv.rb -->
-# A Query type requesting any RR.
-#
 class Resolv::DNS::Resource::ANY < Resolv::DNS::Query
 end
 
 Resolv::DNS::Resource::ANY::TypeValue: Integer
 
-# <!-- rdoc-file=lib/resolv.rb -->
-# The canonical name for an alias.
-#
 class Resolv::DNS::Resource::CNAME < Resolv::DNS::Resource::DomainName
 end
 
 Resolv::DNS::Resource::CNAME::TypeValue: Integer
 
-# <!-- rdoc-file=lib/resolv.rb -->
-# Domain Name resource abstract class.
-#
 class Resolv::DNS::Resource::DomainName < Resolv::DNS::Resource
   def self.decode_rdata: (Resolv::DNS::Message::MessageDecoder msg) -> instance
 
@@ -885,9 +861,6 @@ class Resolv::DNS::Resource::DomainName < Resolv::DNS::Resource
   def initialize: (String name) -> untyped
 end
 
-# <!-- rdoc-file=lib/resolv.rb -->
-# A generic resource abstract class.
-#
 class Resolv::DNS::Resource::Generic < Resolv::DNS::Resource
   def self.create: (Integer type_value, Integer class_value) -> Class
 
@@ -911,9 +884,6 @@ class Resolv::DNS::Resource::Generic < Resolv::DNS::Resource
   def initialize: (String data) -> untyped
 end
 
-# <!-- rdoc-file=lib/resolv.rb -->
-# Host Information resource.
-#
 class Resolv::DNS::Resource::HINFO < Resolv::DNS::Resource
   def self.decode_rdata: (Resolv::DNS::Message::MessageDecoder msg) -> instance
 
@@ -942,17 +912,11 @@ end
 
 Resolv::DNS::Resource::HINFO::TypeValue: Integer
 
-# <!-- rdoc-file=lib/resolv.rb -->
-# module IN contains ARPA Internet specific RRs.
-#
 module Resolv::DNS::Resource::IN
 end
 
 Resolv::DNS::Resource::IN::ClassValue: Integer
 
-# <!-- rdoc-file=lib/resolv.rb -->
-# IPv4 Address resource
-#
 class Resolv::DNS::Resource::IN::A < Resolv::DNS::Resource
   def self.decode_rdata: (Resolv::DNS::Message::MessageDecoder msg) -> instance
 
@@ -978,9 +942,6 @@ Resolv::DNS::Resource::IN::A::ClassValue: Integer
 
 Resolv::DNS::Resource::IN::A::TypeValue: Integer
 
-# <!-- rdoc-file=lib/resolv.rb -->
-# An IPv6 address record.
-#
 class Resolv::DNS::Resource::IN::AAAA < Resolv::DNS::Resource
   def self.decode_rdata: (Resolv::DNS::Message::MessageDecoder msg) -> instance
 
@@ -1069,11 +1030,6 @@ Resolv::DNS::Resource::IN::SOA::ClassValue: Integer
 
 Resolv::DNS::Resource::IN::SOA::TypeValue: Integer
 
-# <!-- rdoc-file=lib/resolv.rb -->
-# SRV resource record defined in RFC 2782
-#
-# These records identify the hostname and port that a service is available at.
-#
 class Resolv::DNS::Resource::IN::SRV < Resolv::DNS::Resource
   def self.decode_rdata: (Resolv::DNS::Message::MessageDecoder msg) -> instance
 
@@ -1141,9 +1097,6 @@ Resolv::DNS::Resource::IN::TXT::ClassValue: Integer
 
 Resolv::DNS::Resource::IN::TXT::TypeValue: Integer
 
-# <!-- rdoc-file=lib/resolv.rb -->
-# Well Known Service resource.
-#
 class Resolv::DNS::Resource::IN::WKS < Resolv::DNS::Resource
   def self.decode_rdata: (Resolv::DNS::Message::MessageDecoder msg) -> instance
 
@@ -1182,9 +1135,6 @@ Resolv::DNS::Resource::IN::WKS::ClassValue: Integer
 
 Resolv::DNS::Resource::IN::WKS::TypeValue: Integer
 
-# <!-- rdoc-file=lib/resolv.rb -->
-# Location resource
-#
 class Resolv::DNS::Resource::LOC < Resolv::DNS::Resource
   def self.decode_rdata: (Resolv::DNS::Message::MessageDecoder msg) -> instance
 
@@ -1243,9 +1193,6 @@ end
 
 Resolv::DNS::Resource::LOC::TypeValue: Integer
 
-# <!-- rdoc-file=lib/resolv.rb -->
-# Mailing list or mailbox information.
-#
 class Resolv::DNS::Resource::MINFO < Resolv::DNS::Resource
   def self.decode_rdata: (Resolv::DNS::Message::MessageDecoder msg) -> instance
 
@@ -1273,9 +1220,6 @@ end
 
 Resolv::DNS::Resource::MINFO::TypeValue: Integer
 
-# <!-- rdoc-file=lib/resolv.rb -->
-# Mail Exchanger resource.
-#
 class Resolv::DNS::Resource::MX < Resolv::DNS::Resource
   def self.decode_rdata: (Resolv::DNS::Message::MessageDecoder msg) -> instance
 
@@ -1304,25 +1248,16 @@ end
 
 Resolv::DNS::Resource::MX::TypeValue: Integer
 
-# <!-- rdoc-file=lib/resolv.rb -->
-# An authoritative name server.
-#
 class Resolv::DNS::Resource::NS < Resolv::DNS::Resource::DomainName
 end
 
 Resolv::DNS::Resource::NS::TypeValue: Integer
 
-# <!-- rdoc-file=lib/resolv.rb -->
-# A Pointer to another DNS name.
-#
 class Resolv::DNS::Resource::PTR < Resolv::DNS::Resource::DomainName
 end
 
 Resolv::DNS::Resource::PTR::TypeValue: Integer
 
-# <!-- rdoc-file=lib/resolv.rb -->
-# Start Of Authority resource.
-#
 class Resolv::DNS::Resource::SOA < Resolv::DNS::Resource
   def self.decode_rdata: (Resolv::DNS::Message::MessageDecoder msg) -> instance
 
@@ -1380,9 +1315,6 @@ end
 
 Resolv::DNS::Resource::SOA::TypeValue: Integer
 
-# <!-- rdoc-file=lib/resolv.rb -->
-# Unstructured text resource.
-#
 class Resolv::DNS::Resource::TXT < Resolv::DNS::Resource
   def self.decode_rdata: (Resolv::DNS::Message::MessageDecoder msg) -> instance
 
@@ -1478,6 +1410,9 @@ class Resolv::Hosts
   def initialize: (?String filename) -> untyped
 end
 
+# <!-- rdoc-file=lib/resolv.rb -->
+# The default file name for host names
+#
 Resolv::Hosts::DefaultFileName: String
 
 # <!-- rdoc-file=lib/resolv.rb -->
@@ -1488,6 +1423,13 @@ class Resolv::IPv4
   #   rdoc-file=lib/resolv.rb
   #   - create(arg)
   # -->
+  # Creates a new IPv4 address from `arg` which may be:
+  #
+  # IPv4
+  # :   returns `arg`.
+  #
+  # String
+  # :   `arg` must match the IPv4::Regex constant
   #
   def self.create: (String | instance arg) -> instance
 
@@ -1519,6 +1461,9 @@ class Resolv::IPv4
   def initialize: (String address) -> untyped
 end
 
+# <!-- rdoc-file=lib/resolv.rb -->
+# Regular expression IPv4 addresses must match.
+#
 Resolv::IPv4::Regex: Regexp
 
 # <!-- rdoc-file=lib/resolv.rb -->
@@ -1649,10 +1594,14 @@ class Resolv::LOC::Alt
   #   rdoc-file=lib/resolv.rb
   #   - new(altitude)
   # -->
+  # Internal use; use self.create.
   #
   def initialize: (Integer altitude) -> untyped
 end
 
+# <!-- rdoc-file=lib/resolv.rb -->
+# Regular expression LOC Alt must match.
+#
 Resolv::LOC::Alt::Regex: Regexp
 
 # <!-- rdoc-file=lib/resolv.rb -->
@@ -1701,10 +1650,14 @@ class Resolv::LOC::Coord
   #   rdoc-file=lib/resolv.rb
   #   - new(coordinates,orientation)
   # -->
+  # Internal use; use self.create.
   #
   def initialize: (String coordinates, orientation orientation) -> untyped
 end
 
+# <!-- rdoc-file=lib/resolv.rb -->
+# Regular expression LOC Coord must match.
+#
 Resolv::LOC::Coord::Regex: Regexp
 
 # <!-- rdoc-file=lib/resolv.rb -->
@@ -1746,10 +1699,14 @@ class Resolv::LOC::Size
   #   rdoc-file=lib/resolv.rb
   #   - new(scalar)
   # -->
+  # Internal use; use self.create.
   #
   def initialize: (String scalar) -> untyped
 end
 
+# <!-- rdoc-file=lib/resolv.rb -->
+# Regular expression LOC size must match.
+#
 Resolv::LOC::Size::Regex: Regexp
 
 # <!-- rdoc-file=lib/resolv.rb -->

data/stdlib/ripper/0/ripper.rbs

@@ -31,23 +31,26 @@
 #               nil,
 #               nil]]]]
 #
-# You can see in the example above, the expression starts with `:program`.
+# You can see in the example above, the expression starts with
+# <code>:program</code>.
 #
-# From here, a method definition at `:def`, followed by the method's identifier
-# `:@ident`. After the method's identifier comes the parentheses `:paren` and
-# the method parameters under `:params`.
+# From here, a method definition at <code>:def</code>, followed by the method's
+# identifier <code>:@ident</code>. After the method's identifier comes the
+# parentheses <code>:paren</code> and the method parameters under
+# <code>:params</code>.
 #
-# Next is the method body, starting at `:bodystmt` (`stmt` meaning statement),
-# which contains the full definition of the method.
+# Next is the method body, starting at <code>:bodystmt</code> (`stmt` meaning
+# statement), which contains the full definition of the method.
 #
 # In our case, we're simply returning a String, so next we have the
-# `:string_literal` expression.
+# <code>:string_literal</code> expression.
 #
-# Within our `:string_literal` you'll notice two `@tstring_content`, this is the
-# literal part for `Hello, ` and `!`. Between the two `@tstring_content`
-# statements is a `:string_embexpr`, where *embexpr* is an embedded expression.
-# Our expression consists of a local variable, or `var_ref`, with the identifier
-# (`@ident`) of `world`.
+# Within our <code>:string_literal</code> you'll notice two
+# <code>@tstring_content</code>, this is the literal part for <code>Hello,
+# </code> and <code>!</code>. Between the two <code>@tstring_content</code>
+# statements is a <code>:string_embexpr</code>, where *embexpr* is an embedded
+# expression. Our expression consists of a local variable, or `var_ref`, with
+# the identifier (<code>@ident</code>) of `world`.
 #
 # ## Resources
 #
@@ -189,7 +192,7 @@ class Ripper
     #   - state()
     # -->
     # The scanner's state of the current token. This value is the bitwise OR of zero
-    # or more of the `Ripper::EXPR_*` constants.
+    # or more of the <code>Ripper::EXPR_*</code> constants.
     #
     def state: () -> Ripper::Lexer::State
 
@@ -247,8 +250,8 @@ class Ripper
       #   - to_a()
       # -->
       #
-      def to_a: () -> [ [ Integer, Integer ], Symbol, String, Ripper::Lexer::State, String ]
-              | () -> [ [ Integer, Integer ], Symbol, String, Ripper::Lexer::State ]
+      def to_a: () -> ( [ [ Integer, Integer ], Symbol, String, Ripper::Lexer::State, String ]
+                      | [ [ Integer, Integer ], Symbol, String, Ripper::Lexer::State ] )
     end
 
     class State
@@ -972,10 +975,10 @@ class Ripper
   #   - lex(src, filename = '-', lineno = 1, **kw)
   # -->
   # Tokenizes the Ruby program and returns an array of an array, which is
-  # formatted like `[[lineno, column], type, token, state]`. The `filename`
-  # argument is mostly ignored. By default, this method does not handle syntax
-  # errors in `src`, use the `raise_errors` keyword to raise a SyntaxError for an
-  # error in `src`.
+  # formatted like <code>[[lineno, column], type, token, state]</code>. The
+  # `filename` argument is mostly ignored. By default, this method does not handle
+  # syntax errors in `src`, use the `raise_errors` keyword to raise a SyntaxError
+  # for an error in `src`.
   #
   #     require 'ripper'
   #     require 'pp'

data/stdlib/securerandom/0/manifest.yaml

@@ -0,0 +1,2 @@
+dependencies:
+  - name: random-formatter