Na}{

File Content: `fileutils.rbs`

# # fileutils.rb
#
# Copyright (c) 2000-2007 Minero Aoki
#
# This program is free software. You can distribute/modify this program under
# the same terms of ruby.
#
# ## module FileUtils
#
# Namespace for several file utility methods for copying, moving, removing, etc.
#
# ### Module Functions
#
#     require 'fileutils'
#
#     FileUtils.cd(dir, **options)
#     FileUtils.cd(dir, **options) {|dir| block }
#     FileUtils.pwd()
#     FileUtils.mkdir(dir, **options)
#     FileUtils.mkdir(list, **options)
#     FileUtils.mkdir_p(dir, **options)
#     FileUtils.mkdir_p(list, **options)
#     FileUtils.rmdir(dir, **options)
#     FileUtils.rmdir(list, **options)
#     FileUtils.ln(target, link, **options)
#     FileUtils.ln(targets, dir, **options)
#     FileUtils.ln_s(target, link, **options)
#     FileUtils.ln_s(targets, dir, **options)
#     FileUtils.ln_sf(target, link, **options)
#     FileUtils.cp(src, dest, **options)
#     FileUtils.cp(list, dir, **options)
#     FileUtils.cp_r(src, dest, **options)
#     FileUtils.cp_r(list, dir, **options)
#     FileUtils.mv(src, dest, **options)
#     FileUtils.mv(list, dir, **options)
#     FileUtils.rm(list, **options)
#     FileUtils.rm_r(list, **options)
#     FileUtils.rm_rf(list, **options)
#     FileUtils.install(src, dest, **options)
#     FileUtils.chmod(mode, list, **options)
#     FileUtils.chmod_R(mode, list, **options)
#     FileUtils.chown(user, group, list, **options)
#     FileUtils.chown_R(user, group, list, **options)
#     FileUtils.touch(list, **options)
#
# Possible `options` are:
#
# `:force`
# :   forced operation (rewrite files if exist, remove directories if not empty,
#     etc.);
# `:verbose`
# :   print command to be run, in bash syntax, before performing it;
# `:preserve`
# :   preserve object's group, user and modification time on copying;
# `:noop`
# :   no changes are made (usable in combination with `:verbose` which will
#     print the command to run)
#
#
# Each method documents the options that it honours. See also ::commands,
# ::options and ::options_of methods to introspect which command have which
# options.
#
# All methods that have the concept of a "source" file or directory can take
# either one file or a list of files in that argument.  See the method
# documentation for examples.
#
# There are some `low level' methods, which do not accept keyword arguments:
#
#     FileUtils.copy_entry(src, dest, preserve = false, dereference_root = false, remove_destination = false)
#     FileUtils.copy_file(src, dest, preserve = false, dereference = true)
#     FileUtils.copy_stream(srcstream, deststream)
#     FileUtils.remove_entry(path, force = false)
#     FileUtils.remove_entry_secure(path, force = false)
#     FileUtils.remove_file(path, force = false)
#     FileUtils.compare_file(path_a, path_b)
#     FileUtils.compare_stream(stream_a, stream_b)
#     FileUtils.uptodate?(file, cmp_list)
#
# ## module FileUtils::Verbose
#
# This module has all methods of FileUtils module, but it outputs messages
# before acting.  This equates to passing the `:verbose` flag to methods in
# FileUtils.
#
# ## module FileUtils::NoWrite
#
# This module has all methods of FileUtils module, but never changes
# files/directories.  This equates to passing the `:noop` flag to methods in
# FileUtils.
#
# ## module FileUtils::DryRun
#
# This module has all methods of FileUtils module, but never changes
# files/directories.  This equates to passing the `:noop` and `:verbose` flags
# to methods in FileUtils.
#
module FileUtils
  VERSION: String

  type mode = Integer | String

  type path = string | _ToPath

  type pathlist = path | Array[path]

  # Changes the current directory to the directory `dir`.
  #
  # If this method is called with block, resumes to the previous working directory
  # after the block execution has finished.
  #
  #     FileUtils.cd('/')  # change directory
  #
  #     FileUtils.cd('/', verbose: true)   # change directory and report it
  #
  #     FileUtils.cd('/') do  # change directory
  #       # ...               # do something
  #     end                   # return to original directory
  #
  def self?.cd: (path dir, ?verbose: boolish) -> void
              | [X] (path dir, ?verbose: boolish) { (String) -> X } -> X

  alias self.chdir self.cd
  alias chdir cd

  # Changes permission bits on the named files (in `list`) to the bit pattern
  # represented by `mode`.
  #
  # `mode` is the symbolic and absolute mode can be used.
  #
  # Absolute mode is
  #     FileUtils.chmod 0755, 'somecommand'
  #     FileUtils.chmod 0644, %w(my.rb your.rb his.rb her.rb)
  #     FileUtils.chmod 0755, '/usr/bin/ruby', verbose: true
  #
  # Symbolic mode is
  #     FileUtils.chmod "u=wrx,go=rx", 'somecommand'
  #     FileUtils.chmod "u=wr,go=rr", %w(my.rb your.rb his.rb her.rb)
  #     FileUtils.chmod "u=wrx,go=rx", '/usr/bin/ruby', verbose: true
  #
  # "a"
  # :   is user, group, other mask.
  # "u"
  # :   is user's mask.
  # "g"
  # :   is group's mask.
  # "o"
  # :   is other's mask.
  # "w"
  # :   is write permission.
  # "r"
  # :   is read permission.
  # "x"
  # :   is execute permission.
  # "X"
  # :   is execute permission for directories only, must be used in conjunction
  #     with "+"
  # "s"
  # :   is uid, gid.
  # "t"
  # :   is sticky bit.
  # "+"
  # :   is added to a class given the specified mode.
  # "-"
  # :   Is removed from a given class given mode.
  # "="
  # :   Is the exact nature of the class will be given a specified mode.
  #
  def self?.chmod: (mode mode, pathlist list, ?noop: boolish, ?verbose: boolish) -> void

  # Changes permission bits on the named files (in `list`) to the bit pattern
  # represented by `mode`.
  #
  #     FileUtils.chmod_R 0700, "/tmp/app.#{$$}"
  #     FileUtils.chmod_R "u=wrx", "/tmp/app.#{$$}"
  #
  def self?.chmod_R: (mode mode, pathlist list, ?noop: boolish, ?verbose: boolish, ?force: boolish) -> void

  # Changes owner and group on the named files (in `list`) to the user `user` and
  # the group `group`.  `user` and `group` may be an ID (Integer/String) or a name
  # (String). If `user` or `group` is nil, this method does not change the
  # attribute.
  #
  #     FileUtils.chown 'root', 'staff', '/usr/local/bin/ruby'
  #     FileUtils.chown nil, 'bin', Dir.glob('/usr/bin/*'), verbose: true
  #
  def self?.chown: (String? user, String? group, pathlist list, ?noop: boolish, ?verbose: boolish) -> void

  # Changes owner and group on the named files (in `list`) to the user `user` and
  # the group `group` recursively. `user` and `group` may be an ID
  # (Integer/String) or a name (String).  If `user` or `group` is nil, this method
  # does not change the attribute.
  #
  #     FileUtils.chown_R 'www', 'www', '/var/www/htdocs'
  #     FileUtils.chown_R 'cvs', 'cvs', '/var/cvs', verbose: true
  #
  def self?.chown_R: (String? user, String? group, pathlist list, ?noop: boolish, ?verbose: boolish, ?force: boolish) -> void

  # Returns an Array of methods names which have the option `opt`.
  #
  #     p FileUtils.collect_method(:preserve) #=> ["cp", "cp_r", "copy", "install"]
  #
  def self.collect_method: (Symbol opt) -> Array[String]

  # Returns an Array of names of high-level methods that accept any keyword
  # arguments.
  #
  #     p FileUtils.commands  #=> ["chmod", "cp", "cp_r", "install", ...]
  #
  def self.commands: () -> Array[String]

  # Returns true if the contents of a file `a` and a file `b` are identical.
  #
  #     FileUtils.compare_file('somefile', 'somefile')       #=> true
  #     FileUtils.compare_file('/dev/null', '/dev/urandom')  #=> false
  #
  def self?.compare_file: (path a, path b) -> bool

  alias self.cmp self.compare_file
  alias cmp compare_file

  alias self.identical? self.compare_file
  alias identical? compare_file

  # Returns true if the contents of a stream `a` and `b` are identical.
  #
  def self?.compare_stream: (IO a, IO b) -> bool

  # Copies a file system entry `src` to `dest`. If `src` is a directory, this
  # method copies its contents recursively. This method preserves file types, c.f.
  # symlink, directory... (FIFO, device files and etc. are not supported yet)
  #
  # Both of `src` and `dest` must be a path name. `src` must exist, `dest` must
  # not exist.
  #
  # If `preserve` is true, this method preserves owner, group, and modified time.
  # Permissions are copied regardless `preserve`.
  #
  # If `dereference_root` is true, this method dereference tree root.
  #
  # If `remove_destination` is true, this method removes each destination file
  # before copy.
  #
  def self?.copy_entry: (path src, path dest, ?boolish preserve, ?boolish dereference_root, ?boolish remove_destination) -> void

  # Copies file contents of `src` to `dest`. Both of `src` and `dest` must be a
  # path name.
  #
  def self?.copy_file: (path src, path dest, ?boolish preserve, ?boolish dereference) -> void

  # Copies stream `src` to `dest`. `src` must respond to #read(n) and `dest` must
  # respond to #write(str).
  #
  def self?.copy_stream: (_Reader src, _Writer dest) -> void

  # Copies a file content `src` to `dest`.  If `dest` is a directory, copies `src`
  # to `dest/src`.
  #
  # If `src` is a list of files, then `dest` must be a directory.
  #
  #     FileUtils.cp 'eval.c', 'eval.c.org'
  #     FileUtils.cp %w(cgi.rb complex.rb date.rb), '/usr/lib/ruby/1.6'
  #     FileUtils.cp %w(cgi.rb complex.rb date.rb), '/usr/lib/ruby/1.6', verbose: true
  #     FileUtils.cp 'symlink', 'dest'   # copy content, "dest" is not a symlink
  #
  def self?.cp: (pathlist src, path dest, ?preserve: boolish, ?noop: boolish, ?verbose: boolish) -> void

  alias self.copy self.cp
  alias copy cp

  # Hard link `src` to `dest`. If `src` is a directory, this method links all its
  # contents recursively. If `dest` is a directory, links `src` to `dest/src`.
  #
  # `src` can be a list of files.
  #
  # If `dereference_root` is true, this method dereference tree root.
  #
  # If `remove_destination` is true, this method removes each destination file
  # before copy.
  #
  #     FileUtils.rm_r site_ruby + '/mylib', force: true
  #     FileUtils.cp_lr 'lib/', site_ruby + '/mylib'
  #
  #     # Examples of linking several files to target directory.
  #     FileUtils.cp_lr %w(mail.rb field.rb debug/), site_ruby + '/tmail'
  #     FileUtils.cp_lr Dir.glob('*.rb'), '/home/aamine/lib/ruby', noop: true, verbose: true
  #
  #     # If you want to link all contents of a directory instead of the
  #     # directory itself, c.f. src/x -> dest/x, src/y -> dest/y,
  #     # use the following code.
  #     FileUtils.cp_lr 'src/.', 'dest'  # cp_lr('src', 'dest') makes dest/src, but this doesn't.
  #
  def self?.cp_lr: (pathlist src, path dest, ?noop: boolish, ?verbose: boolish, ?dereference_root: boolish, ?remove_destination: boolish) -> void

  # Copies `src` to `dest`. If `src` is a directory, this method copies all its
  # contents recursively. If `dest` is a directory, copies `src` to `dest/src`.
  #
  # `src` can be a list of files.
  #
  # If `dereference_root` is true, this method dereference tree root.
  #
  # If `remove_destination` is true, this method removes each destination file
  # before copy.
  #
  #     # Installing Ruby library "mylib" under the site_ruby
  #     FileUtils.rm_r site_ruby + '/mylib', force: true
  #     FileUtils.cp_r 'lib/', site_ruby + '/mylib'
  #
  #     # Examples of copying several files to target directory.
  #     FileUtils.cp_r %w(mail.rb field.rb debug/), site_ruby + '/tmail'
  #     FileUtils.cp_r Dir.glob('*.rb'), '/home/foo/lib/ruby', noop: true, verbose: true
  #
  #     # If you want to copy all contents of a directory instead of the
  #     # directory itself, c.f. src/x -> dest/x, src/y -> dest/y,
  #     # use following code.
  #     FileUtils.cp_r 'src/.', 'dest'     # cp_r('src', 'dest') makes dest/src,
  #                                        # but this doesn't.
  #
  def self?.cp_r: (pathlist src, path dest, ?preserve: boolish, ?noop: boolish, ?verbose: boolish, ?dereference_root: boolish, ?remove_destination: boolish) -> void

  # Returns true if the method `mid` have an option `opt`.
  #
  #     p FileUtils.have_option?(:cp, :noop)     #=> true
  #     p FileUtils.have_option?(:rm, :force)    #=> true
  #     p FileUtils.have_option?(:rm, :preserve) #=> false
  #
  def self.have_option?: (Symbol mid, Symbol opt) -> bool

  # If `src` is not same as `dest`, copies it and changes the permission mode to
  # `mode`.  If `dest` is a directory, destination is `dest`/`src`. This method
  # removes destination before copy.
  #
  #     FileUtils.install 'ruby', '/usr/local/bin/ruby', mode: 0755, verbose: true
  #     FileUtils.install 'lib.rb', '/usr/local/lib/ruby/site_ruby', verbose: true
  #
  def self?.install: (path src, path dest, ?mode: mode?, ?owner: String?, ?group: String?, ?preserve: boolish, ?noop: boolish, ?verbose: boolish) -> void

  # Hard links a file system entry `src` to `dest`. If `src` is a directory, this
  # method links its contents recursively.
  #
  # Both of `src` and `dest` must be a path name. `src` must exist, `dest` must
  # not exist.
  #
  # If `dereference_root` is true, this method dereferences the tree root.
  #
  # If `remove_destination` is true, this method removes each destination file
  # before copy.
  #
  def self?.link_entry: (path src, path dest, ?boolish dereference_root, ?boolish remove_destination) -> void

  # In the first form, creates a hard link `link` which points to `target`. If
  # `link` already exists, raises Errno::EEXIST. But if the `force` option is set,
  # overwrites `link`.
  #
  #     FileUtils.ln 'gcc', 'cc', verbose: true
  #     FileUtils.ln '/usr/bin/emacs21', '/usr/bin/emacs'
  #
  # In the second form, creates a link `dir/target` pointing to `target`. In the
  # third form, creates several hard links in the directory `dir`, pointing to
  # each item in `targets`. If `dir` is not a directory, raises Errno::ENOTDIR.
  #
  #     FileUtils.cd '/sbin'
  #     FileUtils.ln %w(cp mv mkdir), '/bin'   # Now /sbin/cp and /bin/cp are linked.
  #
  def self?.ln: (pathlist src, path dest, ?force: boolish, ?noop: boolish, ?verbose: boolish) -> void

  alias self.link self.ln
  alias link ln

  # In the first form, creates a symbolic link `link` which points to `target`. If
  # `link` already exists, raises Errno::EEXIST. But if the `force` option is set,
  # overwrites `link`.
  #
  #     FileUtils.ln_s '/usr/bin/ruby', '/usr/local/bin/ruby'
  #     FileUtils.ln_s 'verylongsourcefilename.c', 'c', force: true
  #
  # In the second form, creates a link `dir/target` pointing to `target`. In the
  # third form, creates several symbolic links in the directory `dir`, pointing to
  # each item in `targets`. If `dir` is not a directory, raises Errno::ENOTDIR.
  #
  #     FileUtils.ln_s Dir.glob('/bin/*.rb'), '/home/foo/bin'
  #
  def self?.ln_s: (pathlist src, path dest, ?force: boolish, ?noop: boolish, ?verbose: boolish) -> void

  alias self.symlink self.ln_s
  alias symlink ln_s

  # Same as
  #
  #     FileUtils.ln_s(*args, force: true)
  #
  def self?.ln_sf: (pathlist src, path dest, ?noop: boolish, ?verbose: boolish) -> void

  # Creates one or more directories.
  #
  #     FileUtils.mkdir 'test'
  #     FileUtils.mkdir %w(tmp data)
  #     FileUtils.mkdir 'notexist', noop: true  # Does not really create.
  #     FileUtils.mkdir 'tmp', mode: 0700
  #
  def self?.mkdir: (pathlist list, ?mode: Integer?, ?noop: boolish, ?verbose: boolish) -> void

  # Creates a directory and all its parent directories. For example,
  #
  #     FileUtils.mkdir_p '/usr/local/lib/ruby'
  #
  # causes to make following directories, if they do not exist.
  #
  # *   /usr
  # *   /usr/local
  # *   /usr/local/lib
  # *   /usr/local/lib/ruby
  #
  #
  # You can pass several directories at a time in a list.
  #
  def self?.mkdir_p: (pathlist list, ?mode: mode?, ?noop: boolish, ?verbose: boolish) -> void

  alias self.makedirs self.mkdir_p
  alias makedirs mkdir_p

  alias self.mkpath self.mkdir_p
  alias mkpath mkdir_p

  # Moves file(s) `src` to `dest`.  If `file` and `dest` exist on the different
  # disk partition, the file is copied then the original file is removed.
  #
  #     FileUtils.mv 'badname.rb', 'goodname.rb'
  #     FileUtils.mv 'stuff.rb', '/notexist/lib/ruby', force: true  # no error
  #
  #     FileUtils.mv %w(junk.txt dust.txt), '/home/foo/.trash/'
  #     FileUtils.mv Dir.glob('test*.rb'), 'test', noop: true, verbose: true
  #
  def self?.mv: (pathlist src, path dest, ?force: boolish, ?noop: boolish, ?verbose: boolish, ?secure: boolish) -> void

  alias self.move self.mv
  alias move mv

  # Returns an Array of option names.
  #
  #     p FileUtils.options  #=> ["noop", "force", "verbose", "preserve", "mode"]
  #
  def self.options: () -> Array[String]

  # Returns an Array of option names of the method `mid`.
  #
  #     p FileUtils.options_of(:rm)  #=> ["noop", "verbose", "force"]
  #
  def self.options_of: (Symbol mid) -> Array[String]

  # Returns the name of the current directory.
  #
  def self?.pwd: () -> String

  alias self.getwd self.pwd
  alias getwd pwd

  # Removes a directory `dir` and its contents recursively. This method ignores
  # StandardError if `force` is true.
  #
  def self?.remove_dir: (path path, ?boolish force) -> void

  # This method removes a file system entry `path`. `path` might be a regular
  # file, a directory, or something. If `path` is a directory, remove it
  # recursively.
  #
  # See also remove_entry_secure.
  #
  def self?.remove_entry: (path path, ?boolish force) -> void

  # This method removes a file system entry `path`.  `path` shall be a regular
  # file, a directory, or something.  If `path` is a directory, remove it
  # recursively.  This method is required to avoid TOCTTOU
  # (time-of-check-to-time-of-use) local security vulnerability of rm_r. #rm_r
  # causes security hole when:
  #
  # *   Parent directory is world writable (including /tmp).
  # *   Removing directory tree includes world writable directory.
  # *   The system has symbolic link.
  #
  #
  # To avoid this security hole, this method applies special preprocess. If `path`
  # is a directory, this method chown(2) and chmod(2) all removing directories.
  # This requires the current process is the owner of the removing whole directory
  # tree, or is the super user (root).
  #
  # WARNING: You must ensure that **ALL** parent directories cannot be moved by
  # other untrusted users.  For example, parent directories should not be owned by
  # untrusted users, and should not be world writable except when the sticky bit
  # set.
  #
  # WARNING: Only the owner of the removing directory tree, or Unix super user
  # (root) should invoke this method.  Otherwise this method does not work.
  #
  # For details of this security vulnerability, see Perl's case:
  #
  # *   https://cve.mitre.org/cgi-bin/cvename.cgi?name=CAN-2005-0448
  # *   https://cve.mitre.org/cgi-bin/cvename.cgi?name=CAN-2004-0452
  #
  #
  # For fileutils.rb, this vulnerability is reported in [ruby-dev:26100].
  #
  def self?.remove_entry_secure: (path path, ?boolish force) -> void

  # Removes a file `path`. This method ignores StandardError if `force` is true.
  #
  def self?.remove_file: (path path, ?void force) -> void

  # Remove file(s) specified in `list`.  This method cannot remove directories.
  # All StandardErrors are ignored when the :force option is set.
  #
  #     FileUtils.rm %w( junk.txt dust.txt )
  #     FileUtils.rm Dir.glob('*.so')
  #     FileUtils.rm 'NotExistFile', force: true   # never raises exception
  #
  def self?.rm: (pathlist list, ?force: boolish, ?noop: boolish, ?verbose: boolish) -> void

  alias self.remove self.rm
  alias remove rm

  # Equivalent to
  #
  #     FileUtils.rm(list, force: true)
  #
  def self?.rm_f: (pathlist list, ?noop: boolish, ?verbose: boolish) -> void

  alias self.safe_unlink self.rm_f
  alias safe_unlink rm_f

  # remove files `list[0]` `list[1]`... If `list[n]` is a directory, removes its
  # all contents recursively. This method ignores StandardError when :force option
  # is set.
  #
  #     FileUtils.rm_r Dir.glob('/tmp/*')
  #     FileUtils.rm_r 'some_dir', force: true
  #
  # WARNING: This method causes local vulnerability if one of parent directories
  # or removing directory tree are world writable (including /tmp, whose
  # permission is 1777), and the current process has strong privilege such as Unix
  # super user (root), and the system has symbolic link.  For secure removing,
  # read the documentation of remove_entry_secure carefully, and set :secure
  # option to true. Default is `secure: false`.
  #
  # NOTE: This method calls remove_entry_secure if :secure option is set. See also
  # remove_entry_secure.
  #
  def self?.rm_r: (pathlist list, ?force: boolish, ?noop: boolish, ?verbose: boolish, ?secure: boolish) -> void

  # Equivalent to
  #
  #     FileUtils.rm_r(list, force: true)
  #
  # WARNING: This method causes local vulnerability. Read the documentation of
  # rm_r first.
  #
  def self?.rm_rf: (pathlist list, ?noop: boolish, ?verbose: boolish, ?secure: boolish) -> void

  alias self.rmtree self.rm_rf
  alias rmtree rm_rf

  # Removes one or more directories.
  #
  #     FileUtils.rmdir 'somedir'
  #     FileUtils.rmdir %w(somedir anydir otherdir)
  #     # Does not really remove directory; outputs message.
  #     FileUtils.rmdir 'somedir', verbose: true, noop: true
  #
  def self?.rmdir: (pathlist list, ?parents: boolish, ?noop: boolish, ?verbose: boolish) -> void

  # Updates modification time (mtime) and access time (atime) of file(s) in
  # `list`.  Files are created if they don't exist.
  #
  #     FileUtils.touch 'timestamp'
  #     FileUtils.touch Dir.glob('*.c');  system 'make'
  #
  def self?.touch: (pathlist list, ?noop: boolish, ?verbose: boolish, ?mtime: (Time | Numeric)?, ?nocreate: boolish) -> void

  # Returns true if `new` is newer than all `old_list`. Non-existent files are
  # older than any file.
  #
  #     FileUtils.uptodate?('hello.o', %w(hello.c hello.h)) or \
  #         system 'make hello.o'
  #
  def self?.uptodate?: (path new, pathlist old_list) -> bool
end
File Content: fileutils.rbs

File Content: `fileutils.rbs`
