rbs 4.1.0.pre.2-java

data/core/dir.rbs

@@ -0,0 +1,993 @@
+# <!-- rdoc-file=dir.rb -->
+# An object of class Dir represents a directory in the underlying file system.
+#
+# It consists mainly of:
+#
+# *   A string *path*, given when the object is created, that specifies a
+#     directory in the underlying file system; method #path returns the path.
+# *   A collection of string *entry names*, each of which is the name of a
+#     directory or file in the underlying file system; the entry names may be
+#     retrieved in an [array-like fashion](rdoc-ref:Dir@Dir+As+Array-Like) or in
+#     a [stream-like fashion](rdoc-ref:Dir@Dir+As+Stream-Like).
+#
+# ## About the Examples
+#
+# Some examples on this page use this simple file tree:
+#
+#     example/
+#     ├── config.h
+#     ├── lib/
+#     │   ├── song/
+#     │   │   └── karaoke.rb
+#     │   └── song.rb
+#     └── main.rb
+#
+# Others use the file tree for the [Ruby project
+# itself](https://github.com/ruby/ruby).
+#
+# ## Dir As Array-Like
+#
+# A Dir object is in some ways array-like:
+#
+# *   It has instance methods #children, #each, and #each_child.
+# *   It includes [module Enumerable](rdoc-ref:Enumerable@What-27s+Here).
+#
+# ## Dir As Stream-Like
+#
+# A Dir object is in some ways stream-like.
+#
+# The stream is initially open for reading, but may be closed manually (using
+# method #close), and will be closed on block exit if created by Dir.open called
+# with a block. The closed stream may not be further manipulated, and may not be
+# reopened.
+#
+# The stream has a *position*, which is the index of an entry in the directory:
+#
+# *   The initial position is zero (before the first entry).
+# *   Method #tell (aliased as #pos) returns the position.
+# *   Method #pos= sets the position (but ignores a value outside the stream),
+#     and returns the position.
+# *   Method #seek is like #pos=, but returns `self` (convenient for chaining).
+# *   Method #read, if not at end-of-stream, reads the next entry and increments
+#     the position; if at end-of-stream, does not increment the position.
+# *   Method #rewind sets the position to zero.
+#
+# Examples (using the [simple file tree](rdoc-ref:Dir@About+the+Examples)):
+#
+#     dir = Dir.new('example') # => #<Dir:example>
+#     dir.pos                  # => 0
+#
+#     dir.read # => "."
+#     dir.read # => ".."
+#     dir.read # => "config.h"
+#     dir.read # => "lib"
+#     dir.read # => "main.rb"
+#     dir.pos  # => 5
+#     dir.read # => nil
+#     dir.pos  # => 5
+#
+#     dir.rewind # => #<Dir:example>
+#     dir.pos    # => 0
+#
+#     dir.pos = 3 # => 3
+#     dir.pos     # => 3
+#
+#     dir.seek(4) # => #<Dir:example>
+#     dir.pos     # => 4
+#
+#     dir.close # => nil
+#     dir.read  # Raises IOError.
+#
+# ## What's Here
+#
+# First, what's elsewhere. Class Dir:
+#
+# *   Inherits from [class Object](rdoc-ref:Object@What-27s+Here).
+# *   Includes [module Enumerable](rdoc-ref:Enumerable@What-27s+Here), which
+#     provides dozens of additional methods.
+#
+# Here, class Dir provides methods that are useful for:
+#
+# *   [Reading](rdoc-ref:Dir@Reading)
+# *   [Setting](rdoc-ref:Dir@Setting)
+# *   [Querying](rdoc-ref:Dir@Querying)
+# *   [Iterating](rdoc-ref:Dir@Iterating)
+# *   [Other](rdoc-ref:Dir@Other)
+#
+# ### Reading
+#
+# *   #close: Closes the directory stream for `self`.
+# *   #pos=: Sets the position in the directory stream for `self`.
+# *   #read: Reads and returns the next entry in the directory stream for
+#     `self`.
+# *   #rewind: Sets the position in the directory stream for `self` to the first
+#     entry.
+# *   #seek: Sets the position in the directory stream for `self` the entry at
+#     the given offset.
+#
+# ### Setting
+#
+# *   ::chdir: Changes the working directory of the current process to the given
+#     directory.
+# *   ::chroot: Changes the file-system root for the current process to the
+#     given directory.
+#
+# ### Querying
+#
+# *   ::[]: Same as ::glob without the ability to pass flags.
+# *   ::children: Returns an array of names of the children (both files and
+#     directories) of the given directory, but not including <code>.</code> or
+#     <code>..</code>.
+# *   ::empty?: Returns whether the given path is an empty directory.
+# *   ::entries: Returns an array of names of the children (both files and
+#     directories) of the given directory, including <code>.</code> and
+#     <code>..</code>.
+# *   ::exist?: Returns whether the given path is a directory.
+# *   ::getwd (aliased as #pwd): Returns the path to the current working
+#     directory.
+# *   ::glob: Returns an array of file paths matching the given pattern and
+#     flags.
+# *   ::home: Returns the home directory path for a given user or the current
+#     user.
+# *   #children: Returns an array of names of the children (both files and
+#     directories) of `self`, but not including <code>.</code> or
+#     <code>..</code>.
+# *   #fileno: Returns the integer file descriptor for `self`.
+# *   #path (aliased as #to_path): Returns the path used to create `self`.
+# *   #tell (aliased as #pos): Returns the integer position in the directory
+#     stream for `self`.
+#
+# ### Iterating
+#
+# *   ::each_child: Calls the given block with each entry in the given
+#     directory, but not including <code>.</code> or <code>..</code>.
+# *   ::foreach: Calls the given block with each entry in the given directory,
+#     including <code>.</code> and <code>..</code>.
+# *   #each: Calls the given block with each entry in `self`, including
+#     <code>.</code> and <code>..</code>.
+# *   #each_child: Calls the given block with each entry in `self`, but not
+#     including <code>.</code> or <code>..</code>.
+#
+# ### Other
+#
+# *   ::mkdir: Creates a directory at the given path, with optional permissions.
+# *   ::new: Returns a new Dir for the given path, with optional encoding.
+# *   ::open: Same as ::new, but if a block is given, yields the Dir to the
+#     block, closing it upon block exit.
+# *   ::unlink (aliased as ::delete and ::rmdir): Removes the given directory.
+# *   #inspect: Returns a string description of `self`.
+#
+class Dir
+  include Enumerable[String]
+
+  # <!--
+  #   rdoc-file=dir.rb
+  #   - Dir.new(dirpath) -> dir
+  #   - Dir.new(dirpath, encoding: nil) -> dir
+  # -->
+  # Returns a new Dir object for the directory at `dirpath`:
+  #
+  #     Dir.new('.') # => #<Dir:.>
+  #
+  # The value given with optional keyword argument `encoding` specifies the
+  # encoding for the directory entry names; if `nil` (the default), the file
+  # system's encoding is used:
+  #
+  #     Dir.new('.').read.encoding                       # => #<Encoding:UTF-8>
+  #     Dir.new('.', encoding: Encoding::US_ASCI).read.encoding # => #<Encoding:US-ASCII>
+  #
+  def initialize: (path dir, ?encoding: encoding?) -> void
+
+  # <!--
+  #   rdoc-file=dir.rb
+  #   - Dir[*patterns, base: nil, sort: true] -> array
+  # -->
+  # Calls Dir.glob with argument `patterns` and the values of keyword arguments
+  # `base` and `sort`; returns the array of selected entry names.
+  #
+  def self.[]: (*path patterns, ?base: path?, ?sort: bool) -> Array[String]
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - Dir.chdir(new_dirpath) -> 0
+  #   - Dir.chdir -> 0
+  #   - Dir.chdir(new_dirpath) {|new_dirpath| ... } -> object
+  #   - Dir.chdir {|cur_dirpath| ... } -> object
+  # -->
+  # Changes the current working directory.
+  #
+  # With argument `new_dirpath` and no block, changes to the given `dirpath`:
+  #
+  #     Dir.pwd         # => "/example"
+  #     Dir.chdir('..') # => 0
+  #     Dir.pwd         # => "/"
+  #
+  # With no argument and no block:
+  #
+  # *   Changes to the value of environment variable `HOME` if defined.
+  # *   Otherwise changes to the value of environment variable `LOGDIR` if
+  #     defined.
+  # *   Otherwise makes no change.
+  #
+  # With argument `new_dirpath` and a block, temporarily changes the working
+  # directory:
+  #
+  # *   Calls the block with the argument.
+  # *   Changes to the given directory.
+  # *   Executes the block (yielding the new path).
+  # *   Restores the previous working directory.
+  # *   Returns the block's return value.
+  #
+  # Example:
+  #
+  #     Dir.chdir('/var/spool/mail')
+  #     Dir.pwd   # => "/var/spool/mail"
+  #     Dir.chdir('/tmp') do
+  #       Dir.pwd # => "/tmp"
+  #     end
+  #     Dir.pwd   # => "/var/spool/mail"
+  #
+  # With no argument and a block, calls the block with the current working
+  # directory (string) and returns the block's return value.
+  #
+  # Calls to Dir.chdir with blocks may be nested:
+  #
+  #     Dir.chdir('/var/spool/mail')
+  #     Dir.pwd     # => "/var/spool/mail"
+  #     Dir.chdir('/tmp') do
+  #       Dir.pwd   # => "/tmp"
+  #       Dir.chdir('/usr') do
+  #         Dir.pwd # => "/usr"
+  #       end
+  #       Dir.pwd   # => "/tmp"
+  #     end
+  #     Dir.pwd     # => "/var/spool/mail"
+  #
+  # In a multi-threaded program an error is raised if a thread attempts to open a
+  # `chdir` block while another thread has one open, or a call to `chdir` without
+  # a block occurs inside a block passed to `chdir` (even in the same thread).
+  #
+  # Raises an exception if the target directory does not exist.
+  #
+  def self.chdir: (?path dir) -> 0
+                | [U] (?path dir) { (String dir) -> U } -> U
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - Dir.children(dirpath) -> array
+  #   - Dir.children(dirpath, encoding: 'UTF-8') -> array
+  # -->
+  # Returns an array of the entry names in the directory at `dirpath` except for
+  # <code>'.'</code> and <code>'..'</code>; sets the given encoding onto each
+  # returned entry name:
+  #
+  #     Dir.children('/example') # => ["config.h", "lib", "main.rb"]
+  #     Dir.children('/example').first.encoding
+  #     # => #<Encoding:UTF-8>
+  #     Dir.children('/example', encoding: 'US-ASCII').first.encoding
+  #     # => #<Encoding:US-ASCII>
+  #
+  # See [String Encoding](rdoc-ref:encodings.rdoc@String+Encoding).
+  #
+  # Raises an exception if the directory does not exist.
+  #
+  def self.children: (path dirname, ?encoding: encoding?) -> Array[String]
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - Dir.chroot(dirpath) -> 0
+  # -->
+  # Changes the root directory of the calling process to that specified in
+  # `dirpath`. The new root directory is used for pathnames beginning with
+  # <code>'/'</code>. The root directory is inherited by all children of the
+  # calling process.
+  #
+  # Only a privileged process may call `chroot`.
+  #
+  # See [Linux chroot](https://man7.org/linux/man-pages/man2/chroot.2.html).
+  #
+  def self.chroot: (path root) -> 0
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - Dir.rmdir(dirpath) -> 0
+  # -->
+  # Removes the directory at `dirpath` from the underlying file system:
+  #
+  #     Dir.rmdir('foo') # => 0
+  #
+  # Raises an exception if the directory is not empty.
+  #
+  def self.delete: (path dirname) -> 0
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - Dir.each_child(dirpath) {|entry_name| ... } -> nil
+  #   - Dir.each_child(dirpath, encoding: 'UTF-8') {|entry_name| ... }  -> nil
+  # -->
+  # Like Dir.foreach, except that entries <code>'.'</code> and <code>'..'</code>
+  # are not included.
+  #
+  def self.each_child: (path dirname, ?encoding: encoding?) -> Enumerator[String, nil]
+                     | (path dirname, ?encoding: encoding?) { (String filename) -> void } -> nil
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - Dir.empty?(dirpath) ->  true or false
+  # -->
+  # Returns whether `dirpath` specifies an empty directory:
+  #
+  #     dirpath = '/tmp/foo'
+  #     Dir.mkdir(dirpath)
+  #     Dir.empty?(dirpath)            # => true
+  #     Dir.empty?('/example')         # => false
+  #     Dir.empty?('/example/main.rb') # => false
+  #
+  # Raises an exception if `dirpath` does not specify a directory or file in the
+  # underlying file system.
+  #
+  def self.empty?: (path path_name) -> bool
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - Dir.entries(dirname, encoding: 'UTF-8') -> array
+  # -->
+  # Returns an array of the entry names in the directory at `dirpath`; sets the
+  # given encoding onto each returned entry name:
+  #
+  #     Dir.entries('/example') # => ["config.h", "lib", "main.rb", "..", "."]
+  #     Dir.entries('/example').first.encoding
+  #     # => #<Encoding:UTF-8>
+  #     Dir.entries('/example', encoding: 'US-ASCII').first.encoding
+  #     # => #<Encoding:US-ASCII>
+  #
+  # See [String Encoding](rdoc-ref:encodings.rdoc@String+Encoding).
+  #
+  # Raises an exception if the directory does not exist.
+  #
+  def self.entries: (path dirname, ?encoding: encoding?) -> Array[String]
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - Dir.exist?(dirpath) ->  true or false
+  # -->
+  # Returns whether `dirpath` is a directory in the underlying file system:
+  #
+  #     Dir.exist?('/example')         # => true
+  #     Dir.exist?('/nosuch')          # => false
+  #     Dir.exist?('/example/main.rb') # => false
+  #
+  # Same as File.directory?.
+  #
+  def self.exist?: (path | io file_name) -> bool
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - Dir.fchdir(fd) -> 0
+  #   - Dir.fchdir(fd) { ... } -> object
+  # -->
+  # Changes the current working directory to the directory specified by the
+  # integer file descriptor `fd`.
+  #
+  # When passing a file descriptor over a UNIX socket or to a child process, using
+  # `fchdir` instead of `chdir` avoids the [time-of-check to time-of-use
+  # vulnerability](https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use)
+  #
+  # With no block, changes to the directory given by `fd`:
+  #
+  #     Dir.chdir('/var/spool/mail')
+  #     Dir.pwd # => "/var/spool/mail"
+  #     dir  = Dir.new('/usr')
+  #     fd = dir.fileno
+  #     Dir.fchdir(fd)
+  #     Dir.pwd # => "/usr"
+  #
+  # With a block, temporarily changes the working directory:
+  #
+  # *   Calls the block with the argument.
+  # *   Changes to the given directory.
+  # *   Executes the block (yields no args).
+  # *   Restores the previous working directory.
+  # *   Returns the block's return value.
+  #
+  # Example:
+  #
+  #     Dir.chdir('/var/spool/mail')
+  #     Dir.pwd # => "/var/spool/mail"
+  #     dir  = Dir.new('/tmp')
+  #     fd = dir.fileno
+  #     Dir.fchdir(fd) do
+  #       Dir.pwd # => "/tmp"
+  #     end
+  #     Dir.pwd # => "/var/spool/mail"
+  #
+  # This method uses the
+  # [fchdir()](https://www.man7.org/linux/man-pages/man3/fchdir.3p.html) function
+  # defined by POSIX 2008; the method is not implemented on non-POSIX platforms
+  # (raises NotImplementedError).
+  #
+  # Raises an exception if the file descriptor is not valid.
+  #
+  # In a multi-threaded program an error is raised if a thread attempts to open a
+  # `chdir` block while another thread has one open, or a call to `chdir` without
+  # a block occurs inside a block passed to `chdir` (even in the same thread).
+  #
+  def self.fchdir: (int) -> Integer
+                 | [T] (int) { () -> T } -> T
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - Dir.foreach(dirpath, encoding: 'UTF-8') {|entry_name| ... }  -> nil
+  # -->
+  # Calls the block with each entry name in the directory at `dirpath`; sets the
+  # given encoding onto each passed `entry_name`:
+  #
+  #     Dir.foreach('/example') {|entry_name| p entry_name }
+  #
+  # Output:
+  #
+  #     "config.h"
+  #     "lib"
+  #     "main.rb"
+  #     ".."
+  #     "."
+  #
+  # Encoding:
+  #
+  #     Dir.foreach('/example') {|entry_name| p entry_name.encoding; break }
+  #     Dir.foreach('/example', encoding: 'US-ASCII') {|entry_name| p entry_name.encoding; break }
+  #
+  # Output:
+  #
+  #     #<Encoding:UTF-8>
+  #     #<Encoding:US-ASCII>
+  #
+  # See [String Encoding](rdoc-ref:encodings.rdoc@String+Encoding).
+  #
+  # Returns an enumerator if no block is given.
+  #
+  alias self.foreach self.each_child
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - Dir.for_fd(fd) -> dir
+  # -->
+  # Returns a new Dir object representing the directory specified by the given
+  # integer directory file descriptor `fd`:
+  #
+  #     d0 = Dir.new('..')
+  #     d1 = Dir.for_fd(d0.fileno)
+  #
+  # Note that the returned `d1` does not have an associated path:
+  #
+  #     d0.path # => '..'
+  #     d1.path # => nil
+  #
+  # This method uses the
+  # [fdopendir()](https://www.man7.org/linux/man-pages/man3/fdopendir.3p.html)
+  # function defined by POSIX 2008; the method is not implemented on non-POSIX
+  # platforms (raises NotImplementedError).
+  #
+  def self.for_fd: (int) -> Dir
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - Dir.pwd -> string
+  # -->
+  # Returns the path to the current working directory:
+  #
+  #     Dir.chdir("/tmp") # => 0
+  #     Dir.pwd           # => "/tmp"
+  #
+  def self.getwd: () -> String
+
+  # <!--
+  #   rdoc-file=dir.rb
+  #   - Dir.glob(patterns, flags: 0, base: nil, sort: true) -> array
+  #   - Dir.glob(patterns, flags: 0, base: nil, sort: true) {|entry_name| ... } -> nil
+  # -->
+  # Forms an array *entry_names* of the entry names selected by the arguments.
+  #
+  # Argument `patterns` is a string pattern or an array of string patterns; note
+  # that these are not regexps; see below.
+  #
+  # Notes for the following examples:
+  #
+  # *   <code>'*'</code> is the pattern that matches any entry name except those
+  #     that begin with <code>'.'</code>.
+  # *   We use method Array#take to shorten returned arrays that otherwise would
+  #     be very large.
+  #
+  # With no block, returns array *entry_names*; example (using the [simple file
+  # tree](rdoc-ref:Dir@About+the+Examples)):
+  #
+  #     Dir.glob('*') # => ["config.h", "lib", "main.rb"]
+  #
+  # With a block, calls the block with each of the *entry_names* and returns
+  # `nil`:
+  #
+  #     Dir.glob('*') {|entry_name| puts entry_name } # => nil
+  #
+  # Output:
+  #
+  #     config.h
+  #     lib
+  #     main.rb
+  #
+  # If optional keyword argument `flags` is given, the value modifies the
+  # matching; see below.
+  #
+  # If optional keyword argument `base` is given, its value specifies the base
+  # directory. Each pattern string specifies entries relative to the base
+  # directory; the default is <code>'.'</code>. The base directory is not
+  # prepended to the entry names in the result:
+  #
+  #     Dir.glob(pattern, base: 'lib').take(5)
+  #     # => ["abbrev.gemspec", "abbrev.rb", "base64.gemspec", "base64.rb", "benchmark.gemspec"]
+  #     Dir.glob(pattern, base: 'lib/irb').take(5)
+  #     # => ["cmd", "color.rb", "color_printer.rb", "completion.rb", "context.rb"]
+  #
+  # If optional keyword `sort` is given, its value specifies whether the array is
+  # to be sorted; the default is `true`. Passing value `false` with that keyword
+  # disables sorting (though the underlying file system may already have sorted
+  # the array).
+  #
+  # **Patterns**
+  #
+  # Each pattern string is expanded according to certain metacharacters; examples
+  # below use the [Ruby file tree](rdoc-ref:Dir@About+the+Examples):
+  #
+  # *   <code>'*'</code>: Matches any substring in an entry name, similar in
+  #     meaning to regexp <code>/.*/mx</code>; may be restricted by other values
+  #     in the pattern strings:
+  #
+  #     *   <code>'*'</code> matches all entry names:
+  #
+  #             Dir.glob('*').take(3)  # => ["BSDL", "CONTRIBUTING.md", "COPYING"]
+  #
+  #     *   <code>'c*'</code> matches entry names beginning with <code>'c'</code>:
+  #
+  #             Dir.glob('c*').take(3) # => ["CONTRIBUTING.md", "COPYING", "COPYING.ja"]
+  #
+  #     *   <code>'*c'</code> matches entry names ending with <code>'c'</code>:
+  #
+  #             Dir.glob('*c').take(3) # => ["addr2line.c", "array.c", "ast.c"]
+  #
+  #     *   <code>'*c*'</code> matches entry names that contain <code>'c'</code>,
+  #         even at the beginning or end:
+  #
+  #             Dir.glob('*c*').take(3) # => ["CONTRIBUTING.md", "COPYING", "COPYING.ja"]
+  #
+  #     Does not match Unix-like hidden entry names ("dot files"). To include
+  #     those in the matched entry names, use flag IO::FNM_DOTMATCH or something
+  #     like <code>'{*,.*}'</code>.
+  #
+  # *   <code>'**'</code>: Matches entry names recursively if followed by  the
+  #     slash character <code>'/'</code>:
+  #
+  #         Dir.glob('**/').take(3) # => ["basictest/", "benchmark/", "benchmark/gc/"]
+  #
+  #     If the string pattern contains other characters or is not followed by a
+  #     slash character, it is equivalent to <code>'*'</code>.
+  #
+  # *   <code>'?'</code> Matches any single character; similar in meaning to
+  #     regexp <code>/./</code>:
+  #
+  #         Dir.glob('io.?') # => ["io.c"]
+  #
+  # *   <code>'[_set_]'</code>: Matches any one character in the string *set*;
+  #     behaves like a [Regexp character
+  #     class](rdoc-ref:Regexp@Character+Classes), including set negation
+  #     (<code>'[^a-z]'</code>):
+  #
+  #         Dir.glob('*.[a-z][a-z]').take(3)
+  #         # => ["CONTRIBUTING.md", "COPYING.ja", "KNOWNBUGS.rb"]
+  #
+  # *   <code>'{_abc_,_xyz_}'</code>: Matches either string *abc* or string *xyz*;
+  #     behaves like [Regexp alternation](rdoc-ref:Regexp@Alternation):
+  #
+  #         Dir.glob('{LEGAL,BSDL}') # => ["LEGAL", "BSDL"]
+  #
+  #     More than two alternatives may be given.
+  #
+  # *   <code>\</code>: Escapes the following metacharacter.
+  #
+  #     Note that on Windows, the backslash character may not be used in a string
+  #     pattern: <code>Dir['c:\foo*']</code> will not work, use
+  #     <code>Dir['c:/foo*']</code> instead.
+  #
+  # More examples (using the [simple file tree](rdoc-ref:Dir@About+the+Examples)):
+  #
+  #     # We're in the example directory.
+  #     File.basename(Dir.pwd) # => "example"
+  #     Dir.glob('config.?')              # => ["config.h"]
+  #     Dir.glob('*.[a-z][a-z]')          # => ["main.rb"]
+  #     Dir.glob('*.[^r]*')               # => ["config.h"]
+  #     Dir.glob('*.{rb,h}')              # => ["main.rb", "config.h"]
+  #     Dir.glob('*')                     # => ["config.h", "lib", "main.rb"]
+  #     Dir.glob('*', File::FNM_DOTMATCH) # => [".", "config.h", "lib", "main.rb"]
+  #     Dir.glob(["*.rb", "*.h"])         # => ["main.rb", "config.h"]
+  #
+  #     Dir.glob('**/*.rb')
+  #     => ["lib/song/karaoke.rb", "lib/song.rb", "main.rb"]
+  #
+  #     Dir.glob('**/*.rb', base: 'lib')  #   => ["song/karaoke.rb", "song.rb"]
+  #
+  #     Dir.glob('**/lib')                # => ["lib"]
+  #
+  #     Dir.glob('**/lib/**/*.rb')        # => ["lib/song/karaoke.rb", "lib/song.rb"]
+  #
+  #     Dir.glob('**/lib/*.rb')           # => ["lib/song.rb"]
+  #
+  # **Flags**
+  #
+  # If optional keyword argument `flags` is given (the default is zero -- no
+  # flags), its value should be the bitwise OR of one or more of the constants
+  # defined in module File::Constants.
+  #
+  # Example:
+  #
+  #     flags = File::FNM_EXTGLOB | File::FNM_DOTMATCH
+  #
+  # Specifying flags can extend, restrict, or otherwise modify the matching.
+  #
+  # The flags for this method (other constants in File::Constants do not apply):
+  #
+  # *   File::FNM_DOTMATCH: specifies that entry names beginning with
+  #     <code>'.'</code> should be considered for matching:
+  #
+  #         Dir.glob('*').take(5)
+  #         # => ["BSDL", "CONTRIBUTING.md", "COPYING", "COPYING.ja", "GPL"]
+  #         Dir.glob('*', flags: File::FNM_DOTMATCH).take(5)
+  #         # => [".", ".appveyor.yml", ".cirrus.yml", ".dir-locals.el", ".document"]
+  #
+  # *   File::FNM_EXTGLOB: enables the pattern extension <code>'{_a_,_b_}'</code>,
+  #     which matches pattern *a* and pattern *b*; behaves like a [regexp
+  #     union](rdoc-ref:Regexp.union) (e.g., <code>'(?:_a_|_b_)'</code>):
+  #
+  #         pattern = '{LEGAL,BSDL}'
+  #         Dir.glob(pattern)      # => ["LEGAL", "BSDL"]
+  #
+  # *   File::FNM_NOESCAPE: specifies that escaping with the backslash character
+  #     <code>'\'</code> is disabled; the character is not an escape character.
+  #
+  # *   File::FNM_PATHNAME: specifies that metacharacters <code>'*'</code> and
+  #     <code>'?'</code> do not match directory separators.
+  #
+  # *   File::FNM_SHORTNAME: specifies that patterns may match short names if they
+  #     exist; Windows only.
+  #
+  def self.glob: (array[path] | path pattern, ?int flags, ?base: path?, ?sort: bool) -> Array[String]
+               | (array[path] | path pattern, ?int flags, ?base: path?, ?sort: bool) { (String pathname) -> void } -> nil
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - Dir.home(user_name = nil) -> dirpath
+  # -->
+  # Returns the home directory path of the user specified with `user_name` if it
+  # is not `nil`, or the current login user:
+  #
+  #     Dir.home         # => "/home/me"
+  #     Dir.home('root') # => "/root"
+  #
+  # Raises ArgumentError if `user_name` is not a user name.
+  #
+  def self.home: (?string? user) -> String
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - Dir.mkdir(dirpath, permissions = 0775) -> 0
+  # -->
+  # Creates a directory in the underlying file system at `dirpath` with the given
+  # `permissions`; returns zero:
+  #
+  #     Dir.mkdir('foo')
+  #     File.stat(Dir.new('foo')).mode.to_s(8)[1..4] # => "0755"
+  #     Dir.mkdir('bar', 0644)
+  #     File.stat(Dir.new('bar')).mode.to_s(8)[1..4] # => "0644"
+  #
+  # See [File Permissions](rdoc-ref:File@File+Permissions). Note that argument
+  # `permissions` is ignored on Windows.
+  #
+  def self.mkdir: (path dirname, ?int permissions) -> 0
+
+  # <!--
+  #   rdoc-file=dir.rb
+  #   - Dir.open(dirpath) -> dir
+  #   - Dir.open(dirpath, encoding: nil) -> dir
+  #   - Dir.open(dirpath) {|dir| ... } -> object
+  #   - Dir.open(dirpath, encoding: nil) {|dir| ... } -> object
+  # -->
+  # Creates a new Dir object *dir* for the directory at `dirpath`.
+  #
+  # With no block, the method equivalent to Dir.new(dirpath, encoding):
+  #
+  #     Dir.open('.') # => #<Dir:.>
+  #
+  # With a block given, the block is called with the created *dir*; on block exit
+  # *dir* is closed and the block's value is returned:
+  #
+  #     Dir.open('.') {|dir| dir.inspect } # => "#<Dir:.>"
+  #
+  # The value given with optional keyword argument `encoding` specifies the
+  # encoding for the directory entry names; if `nil` (the default), the file
+  # system's encoding is used:
+  #
+  #     Dir.open('.').read.encoding                       # => #<Encoding:UTF-8>
+  #     Dir.open('.', encoding: Encoding::US_ASCII).read.encoding # => #<Encoding:US-ASCII>
+  #
+  def self.open: (path dirname, ?encoding: encoding?) -> instance
+               | [U] (path dirname, ?encoding: encoding?) { (instance) -> U } -> U
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - Dir.pwd -> string
+  # -->
+  # Returns the path to the current working directory:
+  #
+  #     Dir.chdir("/tmp") # => 0
+  #     Dir.pwd           # => "/tmp"
+  #
+  alias self.pwd self.getwd
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - Dir.rmdir(dirpath) -> 0
+  # -->
+  # Removes the directory at `dirpath` from the underlying file system:
+  #
+  #     Dir.rmdir('foo') # => 0
+  #
+  # Raises an exception if the directory is not empty.
+  #
+  alias self.rmdir self.delete
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - Dir.rmdir(dirpath) -> 0
+  # -->
+  # Removes the directory at `dirpath` from the underlying file system:
+  #
+  #     Dir.rmdir('foo') # => 0
+  #
+  # Raises an exception if the directory is not empty.
+  #
+  alias self.unlink self.delete
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - chdir -> 0
+  #   - chdir { ... } -> object
+  # -->
+  # Changes the current working directory to `self`:
+  #
+  #     Dir.pwd # => "/"
+  #     dir = Dir.new('example')
+  #     dir.chdir
+  #     Dir.pwd # => "/example"
+  #
+  # With a block, temporarily changes the working directory:
+  #
+  # *   Calls the block.
+  # *   Changes to the given directory.
+  # *   Executes the block (yields no args).
+  # *   Restores the previous working directory.
+  # *   Returns the block's return value.
+  #
+  # Uses Dir.fchdir if available, and Dir.chdir if not, see those methods for
+  # caveats.
+  #
+  def chdir: () -> Integer
+           | [T] () { () -> T } -> T
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - children -> array
+  # -->
+  # Returns an array of the entry names in `self` except for <code>'.'</code> and
+  # <code>'..'</code>:
+  #
+  #     dir = Dir.new('/example')
+  #     dir.children # => ["config.h", "lib", "main.rb"]
+  #
+  def children: () -> Array[String]
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - close -> nil
+  # -->
+  # Closes the stream in `self`, if it is open, and returns `nil`; ignored if
+  # `self` is already closed:
+  #
+  #     dir = Dir.new('example')
+  #     dir.read     # => "."
+  #     dir.close     # => nil
+  #     dir.close     # => nil
+  #     dir.read # Raises IOError.
+  #
+  def close: () -> nil
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - each {|entry_name| ... } -> self
+  # -->
+  # Calls the block with each entry name in `self`:
+  #
+  #     Dir.new('example').each {|entry_name| p entry_name }
+  #
+  # Output:
+  #
+  #     "."
+  #     ".."
+  #     "config.h"
+  #     "lib"
+  #     "main.rb"
+  #
+  # With no block given, returns an Enumerator.
+  #
+  def each: () { (String) -> void } -> self
+          | () -> Enumerator[String, self]
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - each_child {|entry_name| ... } -> self
+  # -->
+  # Calls the block with each entry name in `self` except <code>'.'</code> and
+  # <code>'..'</code>:
+  #
+  #     dir = Dir.new('/example')
+  #     dir.each_child {|entry_name| p entry_name }
+  #
+  # Output:
+  #
+  #     "config.h"
+  #     "lib"
+  #     "main.rb"
+  #
+  # If no block is given, returns an enumerator.
+  #
+  def each_child: () { (String) -> void } -> self
+                | () -> Enumerator[String, self]
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - fileno -> integer
+  # -->
+  # Returns the file descriptor used in *dir*.
+  #
+  #     d = Dir.new('..')
+  #     d.fileno # => 8
+  #
+  # This method uses the
+  # [dirfd()](https://www.man7.org/linux/man-pages/man3/dirfd.3.html) function
+  # defined by POSIX 2008; the method is not implemented on non-POSIX platforms
+  # (raises NotImplementedError).
+  #
+  def fileno: () -> Integer
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - inspect -> string
+  # -->
+  # Returns a string description of `self`:
+  #
+  #     Dir.new('example').inspect # => "#<Dir:example>"
+  #
+  def inspect: () -> String
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - path -> string or nil
+  # -->
+  # Returns the `dirpath` string that was used to create `self` (or `nil` if
+  # created by method Dir.for_fd):
+  #
+  #     Dir.new('example').path # => "example"
+  #
+  def path: () -> String?
+
+  # <!-- rdoc-file=dir.c -->
+  # Returns the current position of `self`; see [Dir As
+  # Stream-Like](rdoc-ref:Dir@Dir+As+Stream-Like):
+  #
+  #     dir = Dir.new('example')
+  #     dir.tell  # => 0
+  #     dir.read  # => "."
+  #     dir.tell  # => 1
+  #
+  def pos: () -> Integer
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - pos = position -> integer
+  # -->
+  # Sets the position in `self` and returns `position`. The value of `position`
+  # should have been returned from an earlier call to #tell; if not, the return
+  # values from subsequent calls to #read are unspecified.
+  #
+  # See [Dir As Stream-Like](rdoc-ref:Dir@Dir+As+Stream-Like).
+  #
+  # Examples:
+  #
+  #     dir = Dir.new('example')
+  #     dir.pos      # => 0
+  #     dir.pos = 3  # => 3
+  #     dir.pos      # => 3
+  #     dir.pos = 30 # => 30
+  #     dir.pos      # => 5
+  #
+  def pos=: [U < _ToInt] (U pos) -> U
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - read -> string or nil
+  # -->
+  # Reads and returns the next entry name from `self`; returns `nil` if at
+  # end-of-stream; see [Dir As Stream-Like](rdoc-ref:Dir@Dir+As+Stream-Like):
+  #
+  #     dir = Dir.new('example')
+  #     dir.read # => "."
+  #     dir.read # => ".."
+  #     dir.read # => "config.h"
+  #
+  def read: () -> String?
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - rewind -> self
+  # -->
+  # Sets the position in `self` to zero; see [Dir As
+  # Stream-Like](rdoc-ref:Dir@Dir+As+Stream-Like):
+  #
+  #     dir = Dir.new('example')
+  #     dir.read    # => "."
+  #     dir.read    # => ".."
+  #     dir.pos     # => 2
+  #     dir.rewind  # => #<Dir:example>
+  #     dir.pos     # => 0
+  #
+  def rewind: () -> self
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - seek(position) -> self
+  # -->
+  # Sets the position in `self` and returns `self`. The value of `position` should
+  # have been returned from an earlier call to #tell; if not, the return values
+  # from subsequent calls to #read are unspecified.
+  #
+  # See [Dir As Stream-Like](rdoc-ref:Dir@Dir+As+Stream-Like).
+  #
+  # Examples:
+  #
+  #     dir = Dir.new('example')
+  #     dir.pos      # => 0
+  #     dir.seek(3)  # => #<Dir:example>
+  #     dir.pos      # => 3
+  #     dir.seek(30) # => #<Dir:example>
+  #     dir.pos      # => 5
+  #
+  def seek: (int pos) -> self
+
+  # <!--
+  #   rdoc-file=dir.c
+  #   - tell -> integer
+  # -->
+  # Returns the current position of `self`; see [Dir As
+  # Stream-Like](rdoc-ref:Dir@Dir+As+Stream-Like):
+  #
+  #     dir = Dir.new('example')
+  #     dir.tell  # => 0
+  #     dir.read  # => "."
+  #     dir.tell  # => 1
+  #
+  alias tell pos
+
+  # <!-- rdoc-file=dir.c -->
+  # Returns the `dirpath` string that was used to create `self` (or `nil` if
+  # created by method Dir.for_fd):
+  #
+  #     Dir.new('example').path # => "example"
+  #
+  alias to_path path
+end