rbs 4.1.0.pre.2-java

data/core/file_stat.rbs

@@ -0,0 +1,534 @@
+# <!-- rdoc-file=file.c -->
+# Objects of class File::Stat encapsulate common status information for File
+# objects. The information is recorded at the moment the File::Stat object is
+# created; changes made to the file after that point will not be reflected.
+# File::Stat objects are returned by IO#stat, File::stat, File#lstat, and
+# File::lstat. Many of these methods return platform-specific values, and not
+# all values are meaningful on all systems. See also Kernel#test.
+#
+class File::Stat
+  include Comparable
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - File::Stat.new(file_name)  -> stat
+  # -->
+  # Create a File::Stat object for the given file name (raising an exception if
+  # the file doesn't exist).
+  #
+  def initialize: (path file_name) -> void
+
+  def initialize_copy: (self other) -> void
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - self <=> other -> -1, 0, 1, or nil
+  # -->
+  # Compares `self` and `other`, by comparing their modification times; that is,
+  # by comparing <code>self.mtime</code> and <code>other.mtime</code>.
+  #
+  # Returns:
+  #
+  # *   <code>-1</code>, if <code>self.mtime</code> is earlier.
+  # *   `0`, if the two values are equal.
+  # *   `1`, if <code>self.mtime</code> is later.
+  # *   `nil`, if `other` is not a File::Stat object.
+  #
+  # Examples:
+  #
+  #     stat0 = File.stat('README.md')
+  #     stat1 = File.stat('NEWS.md')
+  #     stat0.mtime         # => 2025-12-20 15:33:05.6972341 -0600
+  #     stat1.mtime         # => 2025-12-20 16:02:08.2672945 -0600
+  #     stat0 <=> stat1     # => -1
+  #     stat0 <=> stat0.dup # => 0
+  #     stat1 <=> stat0     # => 1
+  #     stat0 <=> :foo      # => nil
+  #
+  # Class File::Stat includes module Comparable, each of whose methods uses
+  # File::Stat#<=> for comparison.
+  #
+  def <=>: (self other) -> (-1 | 0 | 1)
+         | (untyped) -> (-1 | 0 | 1)?
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.atime   -> time
+  # -->
+  # Returns the last access time for this file as an object of class Time.
+  #
+  #     File.stat("testfile").atime   #=> Wed Dec 31 18:00:00 CST 1969
+  #
+  def atime: () -> Time
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.birthtime  ->  time
+  # -->
+  # Returns the birth time for *stat*.
+  #
+  # If the platform doesn't have birthtime, raises NotImplementedError.
+  #
+  #     File.write("testfile", "foo")
+  #     sleep 10
+  #     File.write("testfile", "bar")
+  #     sleep 10
+  #     File.chmod(0644, "testfile")
+  #     sleep 10
+  #     File.read("testfile")
+  #     File.stat("testfile").birthtime   #=> 2014-02-24 11:19:17 +0900
+  #     File.stat("testfile").mtime       #=> 2014-02-24 11:19:27 +0900
+  #     File.stat("testfile").ctime       #=> 2014-02-24 11:19:37 +0900
+  #     File.stat("testfile").atime       #=> 2014-02-24 11:19:47 +0900
+  #
+  def birthtime: () -> Time
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.blksize   -> integer or nil
+  # -->
+  # Returns the native file system's block size. Will return `nil` on platforms
+  # that don't support this information.
+  #
+  #     File.stat("testfile").blksize   #=> 4096
+  #
+  def blksize: () -> Integer?
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.blockdev?   -> true or false
+  # -->
+  # Returns `true` if the file is a block device, `false` if it isn't or if the
+  # operating system doesn't support this feature.
+  #
+  #     File.stat("testfile").blockdev?    #=> false
+  #     File.stat("/dev/hda1").blockdev?   #=> true
+  #
+  def blockdev?: () -> bool
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.blocks    -> integer or nil
+  # -->
+  # Returns the number of native file system blocks allocated for this file, or
+  # `nil` if the operating system doesn't support this feature.
+  #
+  #     File.stat("testfile").blocks   #=> 2
+  #
+  def blocks: () -> Integer?
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.chardev?    -> true or false
+  # -->
+  # Returns `true` if the file is a character device, `false` if it isn't or if
+  # the operating system doesn't support this feature.
+  #
+  #     File.stat("/dev/tty").chardev?   #=> true
+  #
+  def chardev?: () -> bool
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.ctime  ->  time
+  # -->
+  # Returns the change time for *stat* (that is, the time directory information
+  # about the file was changed, not the file itself).
+  #
+  # Note that on Windows (NTFS), returns creation time (birth time).
+  #
+  #     File.stat("testfile").ctime   #=> Wed Apr 09 08:53:14 CDT 2003
+  #
+  def ctime: () -> Time
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.dev    -> integer
+  # -->
+  # Returns an integer representing the device on which *stat* resides.
+  #
+  #     File.stat("testfile").dev   #=> 774
+  #
+  def dev: () -> Integer
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.dev_major   -> integer
+  # -->
+  # Returns the major part of <code>File_Stat#dev</code> or `nil`.
+  #
+  #     File.stat("/dev/fd1").dev_major   #=> 2
+  #     File.stat("/dev/tty").dev_major   #=> 5
+  #
+  def dev_major: () -> Integer?
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.dev_minor   -> integer
+  # -->
+  # Returns the minor part of <code>File_Stat#dev</code> or `nil`.
+  #
+  #     File.stat("/dev/fd1").dev_minor   #=> 1
+  #     File.stat("/dev/tty").dev_minor   #=> 0
+  #
+  def dev_minor: () -> Integer?
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.directory?   -> true or false
+  # -->
+  # Returns `true` if *stat* is a directory, `false` otherwise.
+  #
+  #     File.stat("testfile").directory?   #=> false
+  #     File.stat(".").directory?          #=> true
+  #
+  def directory?: () -> bool
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.executable?    -> true or false
+  # -->
+  # Returns `true` if *stat* is executable or if the operating system doesn't
+  # distinguish executable files from nonexecutable files. The tests are made
+  # using the effective owner of the process.
+  #
+  #     File.stat("testfile").executable?   #=> false
+  #
+  def executable?: () -> bool
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.executable_real?    -> true or false
+  # -->
+  # Same as <code>executable?</code>, but tests using the real owner of the
+  # process.
+  #
+  def executable_real?: () -> bool
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.file?    -> true or false
+  # -->
+  # Returns `true` if *stat* is a regular file (not a device file, pipe, socket,
+  # etc.).
+  #
+  #     File.stat("testfile").file?   #=> true
+  #
+  def file?: () -> bool
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.ftype   -> string
+  # -->
+  # Identifies the type of *stat*. The return string is one of: ```file`'',
+  # ```directory`'', ```characterSpecial`'', ```blockSpecial`'', ```fifo`'',
+  # ```link`'', ```socket`'', or ```unknown`''.
+  #
+  #     File.stat("/dev/tty").ftype   #=> "characterSpecial"
+  #
+  def ftype: () -> File::ftype
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.gid   -> integer
+  # -->
+  # Returns the numeric group id of the owner of *stat*.
+  #
+  #     File.stat("testfile").gid   #=> 500
+  #
+  def gid: () -> Integer
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.grpowned?   -> true or false
+  # -->
+  # Returns true if the effective group id of the process is the same as the group
+  # id of *stat*. On Windows, returns `false`.
+  #
+  #     File.stat("testfile").grpowned?      #=> true
+  #     File.stat("/etc/passwd").grpowned?   #=> false
+  #
+  def grpowned?: () -> bool
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.ino   -> integer
+  # -->
+  # Returns the inode number for *stat*.
+  #
+  #     File.stat("testfile").ino   #=> 1083669
+  #
+  def ino: () -> Integer
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.inspect  ->  string
+  # -->
+  # Produce a nicely formatted description of *stat*.
+  #
+  #     File.stat("/etc/passwd").inspect
+  #        #=> "#<File::Stat dev=0xe000005, ino=1078078, mode=0100644,
+  #        #    nlink=1, uid=0, gid=0, rdev=0x0, size=1374, blksize=4096,
+  #        #    blocks=8, atime=Wed Dec 10 10:16:12 CST 2003,
+  #        #    mtime=Fri Sep 12 15:41:41 CDT 2003,
+  #        #    ctime=Mon Oct 27 11:20:27 CST 2003,
+  #        #    birthtime=Mon Aug 04 08:13:49 CDT 2003>"
+  #
+  def inspect: () -> String
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.mode   -> integer
+  # -->
+  # Returns an integer representing the permission bits of *stat*. The meaning of
+  # the bits is platform dependent; on Unix systems, see <code>stat(2)</code>.
+  #
+  #     File.chmod(0644, "testfile")   #=> 1
+  #     s = File.stat("testfile")
+  #     sprintf("%o", s.mode)          #=> "100644"
+  #
+  def mode: () -> Integer
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.mtime  ->  time
+  # -->
+  # Returns the modification time of *stat*.
+  #
+  #     File.stat("testfile").mtime   #=> Wed Apr 09 08:53:14 CDT 2003
+  #
+  def mtime: () -> Time
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.nlink   -> integer
+  # -->
+  # Returns the number of hard links to *stat*.
+  #
+  #     File.stat("testfile").nlink             #=> 1
+  #     File.link("testfile", "testfile.bak")   #=> 0
+  #     File.stat("testfile").nlink             #=> 2
+  #
+  def nlink: () -> Integer
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.owned?    -> true or false
+  # -->
+  # Returns `true` if the effective user id of the process is the same as the
+  # owner of *stat*.
+  #
+  #     File.stat("testfile").owned?      #=> true
+  #     File.stat("/etc/passwd").owned?   #=> false
+  #
+  def owned?: () -> bool
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.pipe?    -> true or false
+  # -->
+  # Returns `true` if the operating system supports pipes and *stat* is a pipe;
+  # `false` otherwise.
+  #
+  def pipe?: () -> bool
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.rdev   ->  integer or nil
+  # -->
+  # Returns an integer representing the device type on which *stat* resides.
+  # Returns `nil` if the operating system doesn't support this feature.
+  #
+  #     File.stat("/dev/fd1").rdev   #=> 513
+  #     File.stat("/dev/tty").rdev   #=> 1280
+  #
+  def rdev: () -> Integer?
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.rdev_major   -> integer
+  # -->
+  # Returns the major part of <code>File_Stat#rdev</code> or `nil`.
+  #
+  #     File.stat("/dev/fd1").rdev_major   #=> 2
+  #     File.stat("/dev/tty").rdev_major   #=> 5
+  #
+  def rdev_major: () -> Integer?
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.rdev_minor   -> integer
+  # -->
+  # Returns the minor part of <code>File_Stat#rdev</code> or `nil`.
+  #
+  #     File.stat("/dev/fd1").rdev_minor   #=> 1
+  #     File.stat("/dev/tty").rdev_minor   #=> 0
+  #
+  def rdev_minor: () -> Integer?
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.readable?    -> true or false
+  # -->
+  # Returns `true` if *stat* is readable by the effective user id of this process.
+  #
+  #     File.stat("testfile").readable?   #=> true
+  #
+  def readable?: () -> bool
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.readable_real?  ->  true or false
+  # -->
+  # Returns `true` if *stat* is readable by the real user id of this process.
+  #
+  #     File.stat("testfile").readable_real?   #=> true
+  #
+  def readable_real?: () -> bool
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.setgid?   -> true or false
+  # -->
+  # Returns `true` if *stat* has the set-group-id permission bit set, `false` if
+  # it doesn't or if the operating system doesn't support this feature.
+  #
+  #     File.stat("/usr/sbin/lpc").setgid?   #=> true
+  #
+  def setgid?: () -> bool
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.setuid?    -> true or false
+  # -->
+  # Returns `true` if *stat* has the set-user-id permission bit set, `false` if it
+  # doesn't or if the operating system doesn't support this feature.
+  #
+  #     File.stat("/bin/su").setuid?   #=> true
+  #
+  def setuid?: () -> bool
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.size    -> integer
+  # -->
+  # Returns the size of *stat* in bytes.
+  #
+  #     File.stat("testfile").size   #=> 66
+  #
+  def size: () -> Integer
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.size?    -> Integer or nil
+  # -->
+  # Returns `nil` if *stat* is a zero-length file, the size of the file otherwise.
+  #
+  #     File.stat("testfile").size?   #=> 66
+  #     File.stat(File::NULL).size?   #=> nil
+  #
+  def size?: () -> Integer?
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.socket?    -> true or false
+  # -->
+  # Returns `true` if *stat* is a socket, `false` if it isn't or if the operating
+  # system doesn't support this feature.
+  #
+  #     File.stat("testfile").socket?   #=> false
+  #
+  def socket?: () -> bool
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.sticky?    -> true or false
+  # -->
+  # Returns `true` if *stat* has its sticky bit set, `false` if it doesn't or if
+  # the operating system doesn't support this feature.
+  #
+  #     File.stat("testfile").sticky?   #=> false
+  #
+  def sticky?: () -> bool
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.symlink?    -> true or false
+  # -->
+  # Returns `true` if *stat* is a symbolic link, `false` if it isn't or if the
+  # operating system doesn't support this feature. As File::stat automatically
+  # follows symbolic links, #symlink? will always be `false` for an object
+  # returned by File::stat.
+  #
+  #     File.symlink("testfile", "alink")   #=> 0
+  #     File.stat("alink").symlink?         #=> false
+  #     File.lstat("alink").symlink?        #=> true
+  #
+  def symlink?: () -> bool
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.uid    -> integer
+  # -->
+  # Returns the numeric user id of the owner of *stat*.
+  #
+  #     File.stat("testfile").uid   #=> 501
+  #
+  def uid: () -> Integer
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.world_readable? -> integer or nil
+  # -->
+  # If *stat* is readable by others, returns an integer representing the file
+  # permission bits of *stat*. Returns `nil` otherwise. The meaning of the bits is
+  # platform dependent; on Unix systems, see <code>stat(2)</code>.
+  #
+  #     m = File.stat("/etc/passwd").world_readable?  #=> 420
+  #     sprintf("%o", m)                              #=> "644"
+  #
+  def world_readable?: () -> Integer?
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.world_writable?  ->  integer or nil
+  # -->
+  # If *stat* is writable by others, returns an integer representing the file
+  # permission bits of *stat*. Returns `nil` otherwise. The meaning of the bits is
+  # platform dependent; on Unix systems, see <code>stat(2)</code>.
+  #
+  #     m = File.stat("/tmp").world_writable?         #=> 511
+  #     sprintf("%o", m)                              #=> "777"
+  #
+  def world_writable?: () -> Integer?
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.writable?  ->  true or false
+  # -->
+  # Returns `true` if *stat* is writable by the effective user id of this process.
+  #
+  #     File.stat("testfile").writable?   #=> true
+  #
+  def writable?: () -> bool
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.writable_real?  ->  true or false
+  # -->
+  # Returns `true` if *stat* is writable by the real user id of this process.
+  #
+  #     File.stat("testfile").writable_real?   #=> true
+  #
+  def writable_real?: () -> bool
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.zero?    -> true or false
+  # -->
+  # Returns `true` if *stat* is a zero-length file; `false` otherwise.
+  #
+  #     File.stat("testfile").zero?   #=> false
+  #
+  def zero?: () -> bool
+end