rbs 3.10.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/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/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
 
@@ -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

data/stdlib/securerandom/0/securerandom.rbs

@@ -29,34 +29,21 @@
 # *   uuid
 #
 # These methods are usable as class methods of SecureRandom such as
-# `SecureRandom.hex`.
+# <code>SecureRandom.hex</code>.
 #
 # If a secure random number generator is not available, `NotImplementedError` is
 # raised.
 #
 module SecureRandom
-  extend Random::Formatter
-
   # <!--
   #   rdoc-file=lib/securerandom.rb
-  #   - alphanumeric(n = nil, chars: ALPHANUMERIC)
+  #   - bytes(n)
   # -->
-  # Compatibility methods for Ruby 3.2, we can remove this after dropping to
-  # support Ruby 3.2
+  # Returns a random binary string containing `size` bytes.
   #
-  def self.alphanumeric: (?Integer?) -> String
-
-  def self.base64: (?Integer?) -> String
-
-  def self.hex: (?Integer?) -> String
-
-  def self.random_bytes: (?Integer?) -> String
-
-  def self.random_number: () -> Float
-                        | (Integer) -> Integer
-                        | (Numeric) -> Numeric
-
-  def self.urlsafe_base64: (?Integer?, ?bool?) -> String
+  # See Random.bytes
+  #
+  def self.bytes: (Integer) -> String
 
-  def self.uuid: () -> String
+  extend Random::Formatter
 end

data/stdlib/shellwords/0/shellwords.rbs

@@ -4,8 +4,8 @@
 # This module manipulates strings according to the word parsing rules of the
 # UNIX Bourne shell.
 #
-# The `shellwords()` function was originally a port of shellwords.pl, but
-# modified to conform to [the Shell & Utilities volume of the IEEE Std
+# The <code>shellwords()</code> function was originally a port of shellwords.pl,
+# but modified to conform to [the Shell & Utilities volume of the IEEE Std
 # 1003.1-2008, 2016
 # Edition](http://pubs.opengroup.org/onlinepubs/9699919799/utilities/contents.ht
 # ml)

data/stdlib/socket/0/addrinfo.rbs

@@ -61,8 +61,8 @@ class Addrinfo
   #     #=> [#<Addrinfo: 203.178.141.194:80 TCP (www.kame.net)>,
   #     #    #<Addrinfo: [2001:200:dff:fff1:216:3eff:feb1:44d7]:80 TCP (www.kame.net)>]
   #
-  def self.getaddrinfo: (String nodename, ?String | Integer | nil service, ?Symbol? family, ?Symbol | Integer protocol) -> Array[Addrinfo]
-                      | (String? nodename, ?String | Integer service, ?Symbol? family, ?Symbol | Integer protocol) -> Array[Addrinfo]
+  def self.getaddrinfo: (String nodename, ?(String | Integer)? service, ?(Symbol | Integer)? family, ?Symbol | Integer protocol) -> Array[Addrinfo]
+                      | (String? nodename, ?(String | Integer) service, ?(Symbol | Integer)? family, ?Symbol | Integer protocol) -> Array[Addrinfo]
 
   # <!--
   #   rdoc-file=ext/socket/raddrinfo.c
@@ -634,13 +634,13 @@ class Addrinfo
   # sockaddr as generated by Socket.sockaddr_in or Socket.unpack_sockaddr_un.
   #
   # sockaddr examples:
-  # *   `["AF_INET", 46102, "localhost.localdomain", "127.0.0.1"]`
-  # *   `["AF_INET6", 42304, "ip6-localhost", "::1"]`
-  # *   `["AF_UNIX", "/tmp/sock"]`
-  # *   `Socket.sockaddr_in("smtp", "2001:DB8::1")`
-  # *   `Socket.sockaddr_in(80, "172.18.22.42")`
-  # *   `Socket.sockaddr_in(80, "www.ruby-lang.org")`
-  # *   `Socket.sockaddr_un("/tmp/sock")`
+  # *   <code>["AF_INET", 46102, "localhost.localdomain", "127.0.0.1"]</code>
+  # *   <code>["AF_INET6", 42304, "ip6-localhost", "::1"]</code>
+  # *   <code>["AF_UNIX", "/tmp/sock"]</code>
+  # *   <code>Socket.sockaddr_in("smtp", "2001:DB8::1")</code>
+  # *   <code>Socket.sockaddr_in(80, "172.18.22.42")</code>
+  # *   <code>Socket.sockaddr_in(80, "www.ruby-lang.org")</code>
+  # *   <code>Socket.sockaddr_un("/tmp/sock")</code>
   #
   # In an AF_INET/AF_INET6 sockaddr array, the 4th element, numeric IP address, is
   # used to construct socket address in the Addrinfo instance. If the 3rd element,

data/stdlib/socket/0/basic_socket.rbs

@@ -325,7 +325,7 @@ class BasicSocket < IO
   #
   # By specifying a keyword argument *exception* to `false`, you can indicate that
   # recv_nonblock should not raise an IO::WaitReadable exception, but return the
-  # symbol `:wait_readable` instead.
+  # symbol <code>:wait_readable</code> instead.
   #
   # ### See
   # *   Socket#recvfrom
@@ -399,7 +399,7 @@ class BasicSocket < IO
   #
   # By specifying a keyword argument *exception* to `false`, you can indicate that
   # recvmsg_nonblock should not raise an IO::WaitReadable exception, but return
-  # the symbol `:wait_readable` instead.
+  # the symbol <code>:wait_readable</code> instead.
   #
   def recvmsg_nonblock: (?Integer dlen, ?Integer flags, ?Integer clen, ?exception: boolish, ?scm_rights: boolish) -> ([ String, Addrinfo, Integer?, Array[Socket::AncillaryData] ] | :wait_readable)
 
@@ -487,7 +487,7 @@ class BasicSocket < IO
   #
   # By specifying a keyword argument *exception* to `false`, you can indicate that
   # sendmsg_nonblock should not raise an IO::WaitWritable exception, but return
-  # the symbol `:wait_writable` instead.
+  # the symbol <code>:wait_writable</code> instead.
   #
   def sendmsg_nonblock: (String mesg, ?Integer flags, ?Addrinfo | String dest_sockaddr, *Socket::AncillaryData controls, ?exception: boolish) -> (Integer | :wait_writable)
 

data/stdlib/socket/0/ip_socket.rbs

@@ -22,10 +22,11 @@ class IPSocket < BasicSocket
   # Returns the local address as an array which contains address_family, port,
   # hostname and numeric_address.
   #
-  # If `reverse_lookup` is `true` or `:hostname`, hostname is obtained from
-  # numeric_address using reverse lookup. Or if it is `false`, or `:numeric`,
-  # hostname is the same as numeric_address. Or if it is `nil` or omitted, obeys
-  # to `ipsocket.do_not_reverse_lookup`. See `Socket.getaddrinfo` also.
+  # If `reverse_lookup` is `true` or <code>:hostname</code>, hostname is obtained
+  # from numeric_address using reverse lookup. Or if it is `false`, or
+  # <code>:numeric</code>, hostname is the same as numeric_address. Or if it is
+  # `nil` or omitted, obeys to <code>ipsocket.do_not_reverse_lookup</code>. See
+  # <code>Socket.getaddrinfo</code> also.
   #
   #     TCPSocket.open("www.ruby-lang.org", 80) {|sock|
   #       p sock.addr #=> ["AF_INET", 49429, "hal", "192.168.0.128"]
@@ -53,10 +54,11 @@ class IPSocket < BasicSocket
   # hostname and numeric_address. It is defined for connection oriented socket
   # such as TCPSocket.
   #
-  # If `reverse_lookup` is `true` or `:hostname`, hostname is obtained from
-  # numeric_address using reverse lookup. Or if it is `false`, or `:numeric`,
-  # hostname is the same as numeric_address. Or if it is `nil` or omitted, obeys
-  # to `ipsocket.do_not_reverse_lookup`. See `Socket.getaddrinfo` also.
+  # If `reverse_lookup` is `true` or <code>:hostname</code>, hostname is obtained
+  # from numeric_address using reverse lookup. Or if it is `false`, or
+  # <code>:numeric</code>, hostname is the same as numeric_address. Or if it is
+  # `nil` or omitted, obeys to <code>ipsocket.do_not_reverse_lookup</code>. See
+  # <code>Socket.getaddrinfo</code> also.
   #
   #     TCPSocket.open("www.ruby-lang.org", 80) {|sock|
   #       p sock.peeraddr #=> ["AF_INET", 80, "carbon.ruby-lang.org", "221.186.184.68"]

data/stdlib/socket/0/socket.rbs

@@ -16,20 +16,21 @@
 #
 # Sockets have their own vocabulary:
 #
-# **domain:** The family of protocols:
+# <strong>domain:</strong> The family of protocols:
 # *   Socket::PF_INET
 # *   Socket::PF_INET6
 # *   Socket::PF_UNIX
 # *   etc.
 #
-# **type:** The type of communications between the two endpoints, typically
+# <strong>type:</strong> The type of communications between the two endpoints,
+# typically
 # *   Socket::SOCK_STREAM
 # *   Socket::SOCK_DGRAM.
 #
-# **protocol:** Typically *zero*. This may be used to identify a variant of a
-# protocol.
+# <strong>protocol:</strong> Typically *zero*. This may be used to identify a
+# variant of a protocol.
 #
-# **hostname:** The identifier of a network interface:
+# <strong>hostname:</strong> The identifier of a network interface:
 # *   a string (hostname, IPv4 or IPv6 address or `broadcast` which specifies a
 #     broadcast address)
 # *   a zero-length string which specifies INADDR_ANY
@@ -484,7 +485,7 @@ class Socket < BasicSocket
   #     The `connect_timeout` specifies the timeout in seconds from the start of
   #     the connection attempt to the last candidate.
   #     By default, all connection attempts continue until the timeout occurs.
-  #     When `fast_fallback:false` is explicitly specified,
+  #     When <code>fast_fallback:false</code> is explicitly specified,
   #     a timeout is set for each connection attempt and any connection attempt
   #     that exceeds its timeout will be canceled.
   #
@@ -845,7 +846,7 @@ class Socket < BasicSocket
   #
   # By specifying a keyword argument *exception* to `false`, you can indicate that
   # accept_nonblock should not raise an IO::WaitReadable exception, but return the
-  # symbol `:wait_readable` instead.
+  # symbol <code>:wait_readable</code> instead.
   #
   # ### See
   # *   Socket#accept
@@ -1099,7 +1100,7 @@ class Socket < BasicSocket
   #
   # By specifying a keyword argument *exception* to `false`, you can indicate that
   # connect_nonblock should not raise an IO::WaitWritable exception, but return
-  # the symbol `:wait_writable` instead.
+  # the symbol <code>:wait_writable</code> instead.
   #
   # ### See
   # *   Socket#connect
@@ -1357,7 +1358,7 @@ class Socket < BasicSocket
   #
   # By specifying a keyword argument *exception* to `false`, you can indicate that
   # recvfrom_nonblock should not raise an IO::WaitReadable exception, but return
-  # the symbol `:wait_readable` instead.
+  # the symbol <code>:wait_readable</code> instead.
   #
   # ### See
   # *   Socket#recvfrom

data/stdlib/socket/0/tcp_server.rbs

@@ -72,7 +72,7 @@ class TCPServer < TCPSocket
   #
   # By specifying a keyword argument *exception* to `false`, you can indicate that
   # accept_nonblock should not raise an IO::WaitReadable exception, but return the
-  # symbol `:wait_readable` instead.
+  # symbol <code>:wait_readable</code> instead.
   #
   # ### See
   # *   TCPServer#accept

data/stdlib/socket/0/tcp_socket.rbs

@@ -68,7 +68,7 @@ class TCPSocket < IPSocket
   #     The `connect_timeout` specifies the timeout in seconds from the start of
   #     the connection attempt to the last candidate.
   #     By default, all connection attempts continue until the timeout occurs.
-  #     When `fast_fallback:false` is explicitly specified,
+  #     When <code>fast_fallback:false</code> is explicitly specified,
   #     a timeout is set for each connection attempt and any connection attempt
   #     that exceeds its timeout will be canceled.
   #

data/stdlib/socket/0/udp_socket.rbs

@@ -81,7 +81,7 @@ class UDPSocket < IPSocket
   #
   # By specifying a keyword argument *exception* to `false`, you can indicate that
   # recvfrom_nonblock should not raise an IO::WaitReadable exception, but return
-  # the symbol `:wait_readable` instead.
+  # the symbol <code>:wait_readable</code> instead.
   #
   # ### See
   # *   Socket#recvfrom

data/stdlib/socket/0/unix_server.rbs

@@ -50,7 +50,7 @@ class UNIXServer < UNIXSocket
   #
   # By specifying a keyword argument *exception* to `false`, you can indicate that
   # accept_nonblock should not raise an IO::WaitReadable exception, but return the
-  # symbol `:wait_readable` instead.
+  # symbol <code>:wait_readable</code> instead.
   #
   # ### See
   # *   UNIXServer#accept