Class: File::Stat

Inherits:

Object

Object
File::Stat

show all

Includes:: Comparable

Defined in:: file.c

Overview

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.

Instance Method Summary collapse

#<=>(other_stat) ⇒ -1, ...

Compares File::Stat objects by comparing their respective modification times.
#atime ⇒ Time

Returns the last access time for this file as an object of class Time.
#blksize ⇒ Integer^?

Returns the native file system's block size.
#blockdev? ⇒ Boolean

Returns true if the file is a block device, false if it isn't or if the operating system doesn't support this feature.
#blocks ⇒ Integer^?

Returns the number of native file system blocks allocated for this file, or nil if the operating system doesn't support this feature.
#chardev? ⇒ Boolean

Returns true if the file is a character device, false if it isn't or if the operating system doesn't support this feature.
#ctime ⇒ Object

Returns the change time for stat (that is, the time directory information about the file was changed, not the file itself).
#dev ⇒ Fixnum

Returns an integer representing the device on which stat resides.
#dev_major ⇒ Fixnum

Returns the major part of File_Stat#dev or nil.
#dev_minor ⇒ Fixnum

Returns the minor part of File_Stat#dev or nil.
#directory?(file_name) ⇒ Boolean

Returns true if the named file is a directory, or a symlink that points at a directory, and false otherwise.
#executable? ⇒ Boolean

Returns true if stat is executable or if the operating system doesn't distinguish executable files from nonexecutable files.
#executable_real? ⇒ Boolean

Same as executable?, but tests using the real owner of the process.
#file? ⇒ Boolean

Returns true if stat is a regular file (not a device file, pipe, socket, etc.).
#ftype ⇒ String

Identifies the type of stat.
#gid ⇒ Fixnum

Returns the numeric group id of the owner of stat.
#grpowned? ⇒ Boolean

Returns true if the effective group id of the process is the same as the group id of stat.
#File::Stat.new(file_name) ⇒ Object constructor

Create a File::Stat object for the given file name (raising an exception if the file doesn't exist).
#initialize_copy ⇒ Object

:nodoc:.
#ino ⇒ Fixnum

Returns the inode number for stat.
#inspect ⇒ String

Produce a nicely formatted description of stat.
#mode ⇒ Fixnum

Returns an integer representing the permission bits of stat.
#mtime ⇒ Object

Returns the modification time of stat.
#nlink ⇒ Fixnum

Returns the number of hard links to stat.
#owned? ⇒ Boolean

Returns true if the effective user id of the process is the same as the owner of stat.
#pipe? ⇒ Boolean

Returns true if the operating system supports pipes and stat is a pipe; false otherwise.
#rdev ⇒ Fixnum^?

Returns an integer representing the device type on which stat resides.
#rdev_major ⇒ Fixnum

Returns the major part of File_Stat#rdev or nil.
#rdev_minor ⇒ Fixnum

Returns the minor part of File_Stat#rdev or nil.
#readable? ⇒ Boolean

Returns true if stat is readable by the effective user id of this process.
#readable_real? ⇒ Boolean

Returns true if stat is readable by the real user id of this process.
#setgid? ⇒ Boolean

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.
#setuid? ⇒ Boolean

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.
#size ⇒ Fixnum

Returns the size of stat in bytes.
#size ⇒ Integer

Returns the size of stat in bytes.
#socket? ⇒ Boolean

Returns true if stat is a socket, false if it isn't or if the operating system doesn't support this feature.
#sticky? ⇒ Boolean

Returns true if stat has its sticky bit set, false if it doesn't or if the operating system doesn't support this feature.
#symlink? ⇒ Boolean

Returns true if stat is a symbolic link, false if it isn't or if the operating system doesn't support this feature.
#uid ⇒ Fixnum

Returns the numeric user id of the owner of stat.
#world_readable? ⇒ Fixnum^?

If stat is readable by others, returns an integer representing the file permission bits of stat.
#world_writable? ⇒ Fixnum^?

If stat is writable by others, returns an integer representing the file permission bits of stat.
#writable? ⇒ Boolean

Returns true if stat is writable by the effective user id of this process.
#writable_real? ⇒ Boolean

Returns true if stat is writable by the real user id of this process.
#zero? ⇒ Boolean

Returns true if stat is a zero-length file; false otherwise.

Methods included from Comparable

#<, #<=, #==, #>, #>=, #between?

Constructor Details

#File::Stat.new(file_name) ⇒ `Object`

Create a File::Stat object for the given file name (raising an exception if the file doesn't exist).

# File 'file.c'

/*
 * call-seq:
 *
 *   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).
 */

static VALUE
rb_stat_init(VALUE obj, VALUE fname)
{
    struct stat st, *nst;

    rb_secure(2);
    FilePathValue(fname);
    fname = rb_str_encode_ospath(fname);
    if (STAT(StringValueCStr(fname), &st) == -1) {
    rb_sys_fail(RSTRING_PTR(fname));
    }
    if (DATA_PTR(obj)) {
    xfree(DATA_PTR(obj));
    DATA_PTR(obj) = NULL;
    }
    nst = ALLOC(struct stat);
    *nst = st;
    DATA_PTR(obj) = nst;

    return Qnil;
}

Instance Method Details

#<=>(other_stat) ⇒ `-1`, ...

Compares File::Stat objects by comparing their respective modification times.

f1 = File.new("f1", "w")
sleep 1
f2 = File.new("f2", "w")
f1.stat <=> f2.stat   #=> -1

Returns:

(-1, 0, 1, nil)

# File 'file.c'

/*
 *  call-seq:
 *     stat <=> other_stat    -> -1, 0, 1, nil
 *
 *  Compares <code>File::Stat</code> objects by comparing their
 *  respective modification times.
 *
 *     f1 = File.new("f1", "w")
 *     sleep 1
 *     f2 = File.new("f2", "w")
 *     f1.stat <=> f2.stat   #=> -1
 */

static VALUE
rb_stat_cmp(VALUE self, VALUE other)
{
    if (rb_obj_is_kind_of(other, rb_obj_class(self))) {
        struct timespec ts1 = stat_mtimespec(get_stat(self));
        struct timespec ts2 = stat_mtimespec(get_stat(other));
        if (ts1.tv_sec == ts2.tv_sec) {
            if (ts1.tv_nsec == ts2.tv_nsec) return INT2FIX(0);
            if (ts1.tv_nsec < ts2.tv_nsec) return INT2FIX(-1);
            return INT2FIX(1);
        }
        if (ts1.tv_sec < ts2.tv_sec) return INT2FIX(-1);
        return INT2FIX(1);
    }
    return Qnil;
}

#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

Returns:

(Time)

# File 'file.c'

/*
 *  call-seq:
 *     stat.atime   -> time
 *
 *  Returns the last access time for this file as an object of class
 *  <code>Time</code>.
 *
 *     File.stat("testfile").atime   #=> Wed Dec 31 18:00:00 CST 1969
 *
 */

static VALUE
rb_stat_atime(VALUE self)
{
    return stat_atime(get_stat(self));
}

#blksize ⇒ `Integer`^?

Returns the native file system's block size. Will return nil on platforms that don't support this information.

File.stat("testfile").blksize   #=> 4096

Returns:

(Integer, nil)

# File 'file.c'

/*
 *  call-seq:
 *     stat.blksize   -> integer or nil
 *
 *  Returns the native file system's block size. Will return <code>nil</code>
 *  on platforms that don't support this information.
 *
 *     File.stat("testfile").blksize   #=> 4096
 *
 */

static VALUE
rb_stat_blksize(VALUE self)
{
#ifdef HAVE_ST_BLKSIZE
    return ULONG2NUM(get_stat(self)->st_blksize);
#else
    return Qnil;
#endif
}

#blockdev? ⇒ `Boolean`

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

Returns:

(Boolean)

# File 'file.c'

/*
 *  call-seq:
 *     stat.blockdev?   -> true or false
 *
 *  Returns <code>true</code> if the file is a block device,
 *  <code>false</code> 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
 *
 */

static VALUE
rb_stat_b(VALUE obj)
{
#ifdef S_ISBLK
    if (S_ISBLK(get_stat(obj)->st_mode)) return Qtrue;

#endif
    return Qfalse;
}

#blocks ⇒ `Integer`^?

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

Returns:

(Integer, nil)

# File 'file.c'

/*
 *  call-seq:
 *     stat.blocks    -> integer or nil
 *
 *  Returns the number of native file system blocks allocated for this
 *  file, or <code>nil</code> if the operating system doesn't
 *  support this feature.
 *
 *     File.stat("testfile").blocks   #=> 2
 */

static VALUE
rb_stat_blocks(VALUE self)
{
#ifdef HAVE_STRUCT_STAT_ST_BLOCKS
# if SIZEOF_STRUCT_STAT_ST_BLOCKS > SIZEOF_LONG
    return ULL2NUM(get_stat(self)->st_blocks);
# else
    return ULONG2NUM(get_stat(self)->st_blocks);
# endif
#else
    return Qnil;
#endif
}

#chardev? ⇒ `Boolean`

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

Returns:

(Boolean)

# File 'file.c'

/*
 *  call-seq:
 *     stat.chardev?    -> true or false
 *
 *  Returns <code>true</code> if the file is a character device,
 *  <code>false</code> if it isn't or if the operating system doesn't
 *  support this feature.
 *
 *     File.stat("/dev/tty").chardev?   #=> true
 *
 */

static VALUE
rb_stat_c(VALUE obj)
{
    if (S_ISCHR(get_stat(obj)->st_mode)) return Qtrue;

    return Qfalse;
}

#ctime ⇒ `Object`

Returns the change time for stat (that is, the time directory information about the file was changed, not the file itself).

File.stat("testfile").ctime   #=> Wed Apr 09 08:53:14 CDT 2003

# File 'file.c'

/*
 *  call-seq:
 *     stat.ctime  ->  aTime
 *
 *  Returns the change time for <i>stat</i> (that is, the time
 *  directory information about the file was changed, not the file
 *  itself).
 *
 *     File.stat("testfile").ctime   #=> Wed Apr 09 08:53:14 CDT 2003
 *
 */

static VALUE
rb_stat_ctime(VALUE self)
{
    return stat_ctime(get_stat(self));
}

#dev ⇒ `Fixnum`

Returns an integer representing the device on which stat resides.

File.stat("testfile").dev   #=> 774

Returns:

(Fixnum)

# File 'file.c'

/*
 *  call-seq:
 *     stat.dev    -> fixnum
 *
 *  Returns an integer representing the device on which <i>stat</i>
 *  resides.
 *
 *     File.stat("testfile").dev   #=> 774
 */

static VALUE
rb_stat_dev(VALUE self)
{
    return DEVT2NUM(get_stat(self)->st_dev);
}

#dev_major ⇒ `Fixnum`

Returns the major part of File_Stat#dev or nil.

File.stat("/dev/fd1").dev_major   #=> 2
File.stat("/dev/tty").dev_major   #=> 5

Returns:

(Fixnum)

# File 'file.c'

/*
 *  call-seq:
 *     stat.dev_major   -> fixnum
 *
 *  Returns the major part of <code>File_Stat#dev</code> or
 *  <code>nil</code>.
 *
 *     File.stat("/dev/fd1").dev_major   #=> 2
 *     File.stat("/dev/tty").dev_major   #=> 5
 */

static VALUE
rb_stat_dev_major(VALUE self)
{
#if defined(major)
    return INT2NUM(major(get_stat(self)->st_dev));
#else
    return Qnil;
#endif
}

#dev_minor ⇒ `Fixnum`

Returns the minor part of File_Stat#dev or nil.

File.stat("/dev/fd1").dev_minor   #=> 1
File.stat("/dev/tty").dev_minor   #=> 0

Returns:

(Fixnum)

# File 'file.c'

/*
 *  call-seq:
 *     stat.dev_minor   -> fixnum
 *
 *  Returns the minor part of <code>File_Stat#dev</code> or
 *  <code>nil</code>.
 *
 *     File.stat("/dev/fd1").dev_minor   #=> 1
 *     File.stat("/dev/tty").dev_minor   #=> 0
 */

static VALUE
rb_stat_dev_minor(VALUE self)
{
#if defined(minor)
    return INT2NUM(minor(get_stat(self)->st_dev));
#else
    return Qnil;
#endif
}

#directory?(file_name) ⇒ `Boolean`

Returns true if the named file is a directory, or a symlink that points at a directory, and false otherwise.

File.directory?(".")

Returns:

(Boolean)

# File 'file.c'

/*
 *  call-seq:
 *     stat.directory?   -> true or false
 *
 *  Returns <code>true</code> if <i>stat</i> is a directory,
 *  <code>false</code> otherwise.
 *
 *     File.stat("testfile").directory?   #=> false
 *     File.stat(".").directory?          #=> true
 */

static VALUE
rb_stat_d(VALUE obj)
{
    if (S_ISDIR(get_stat(obj)->st_mode)) return Qtrue;
    return Qfalse;
}

#executable? ⇒ `Boolean`

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

Returns:

(Boolean)

# File 'file.c'

/*
 *  call-seq:
 *     stat.executable?    -> true or false
 *
 *  Returns <code>true</code> if <i>stat</i> 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
 *
 */

static VALUE
rb_stat_x(VALUE obj)
{
    struct stat *st = get_stat(obj);

#ifdef USE_GETEUID
    if (geteuid() == 0) {
    return st->st_mode & S_IXUGO ? Qtrue : Qfalse;
    }
#endif
#ifdef S_IXUSR
    if (rb_stat_owned(obj))
    return st->st_mode & S_IXUSR ? Qtrue : Qfalse;
#endif
#ifdef S_IXGRP
    if (rb_stat_grpowned(obj))
    return st->st_mode & S_IXGRP ? Qtrue : Qfalse;
#endif
#ifdef S_IXOTH
    if (!(st->st_mode & S_IXOTH)) return Qfalse;
#endif
    return Qtrue;
}

#executable_real? ⇒ `Boolean`

Same as executable?, but tests using the real owner of the process.

Returns:

(Boolean)

# File 'file.c'

/*
 *  call-seq:
 *     stat.executable_real?    -> true or false
 *
 *  Same as <code>executable?</code>, but tests using the real owner of
 *  the process.
 */

static VALUE
rb_stat_X(VALUE obj)
{
    struct stat *st = get_stat(obj);

#ifdef USE_GETEUID
    if (getuid() == 0) {
    return st->st_mode & S_IXUGO ? Qtrue : Qfalse;
    }
#endif
#ifdef S_IXUSR
    if (rb_stat_rowned(obj))
    return st->st_mode & S_IXUSR ? Qtrue : Qfalse;
#endif
#ifdef S_IXGRP
    if (rb_group_member(get_stat(obj)->st_gid))
    return st->st_mode & S_IXGRP ? Qtrue : Qfalse;
#endif
#ifdef S_IXOTH
    if (!(st->st_mode & S_IXOTH)) return Qfalse;
#endif
    return Qtrue;
}

#file? ⇒ `Boolean`

Returns true if stat is a regular file (not a device file, pipe, socket, etc.).

File.stat("testfile").file?   #=> true

Returns:

(Boolean)

# File 'file.c'

/*
 *  call-seq:
 *     stat.file?    -> true or false
 *
 *  Returns <code>true</code> if <i>stat</i> is a regular file (not
 *  a device file, pipe, socket, etc.).
 *
 *     File.stat("testfile").file?   #=> true
 *
 */

static VALUE
rb_stat_f(VALUE obj)
{
    if (S_ISREG(get_stat(obj)->st_mode)) return Qtrue;
    return Qfalse;
}

#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"

Returns:

(String)

# File 'file.c'

/*
 *  call-seq:
 *     stat.ftype   -> string
 *
 *  Identifies the type of <i>stat</i>. The return string is one of:
 *  ``<code>file</code>'', ``<code>directory</code>'',
 *  ``<code>characterSpecial</code>'', ``<code>blockSpecial</code>'',
 *  ``<code>fifo</code>'', ``<code>link</code>'',
 *  ``<code>socket</code>'', or ``<code>unknown</code>''.
 *
 *     File.stat("/dev/tty").ftype   #=> "characterSpecial"
 *
 */

static VALUE
rb_stat_ftype(VALUE obj)
{
    return rb_file_ftype(get_stat(obj));
}

#gid ⇒ `Fixnum`

Returns the numeric group id of the owner of stat.

File.stat("testfile").gid   #=> 500

Returns:

(Fixnum)

# File 'file.c'

/*
 *  call-seq:
 *     stat.gid   -> fixnum
 *
 *  Returns the numeric group id of the owner of <i>stat</i>.
 *
 *     File.stat("testfile").gid   #=> 500
 *
 */

static VALUE
rb_stat_gid(VALUE self)
{
    return GIDT2NUM(get_stat(self)->st_gid);
}

#grpowned? ⇒ `Boolean`

Returns true if the effective group id of the process is the same as the group id of stat. On Windows NT, returns false.

File.stat("testfile").grpowned?      #=> true
File.stat("/etc/passwd").grpowned?   #=> false

Returns:

(Boolean)

# File 'file.c'

/*
 *  call-seq:
 *     stat.grpowned?   -> true or false
 *
 *  Returns true if the effective group id of the process is the same as
 *  the group id of <i>stat</i>. On Windows NT, returns <code>false</code>.
 *
 *     File.stat("testfile").grpowned?      #=> true
 *     File.stat("/etc/passwd").grpowned?   #=> false
 *
 */

static VALUE
rb_stat_grpowned(VALUE obj)
{
#ifndef _WIN32
    if (rb_group_member(get_stat(obj)->st_gid)) return Qtrue;
#endif
    return Qfalse;
}

#initialize_copy ⇒ `Object`

:nodoc:

# File 'file.c'

/* :nodoc: */
static VALUE
rb_stat_init_copy(VALUE copy, VALUE orig)
{
    struct stat *nst;

    if (copy == orig) return orig;
    rb_check_frozen(copy);
    /* need better argument type check */
    if (!rb_obj_is_instance_of(orig, rb_obj_class(copy))) {
    rb_raise(rb_eTypeError, "wrong argument class");
    }
    if (DATA_PTR(copy)) {
    xfree(DATA_PTR(copy));
    DATA_PTR(copy) = 0;
    }
    if (DATA_PTR(orig)) {
    nst = ALLOC(struct stat);
    *nst = *(struct stat*)DATA_PTR(orig);
    DATA_PTR(copy) = nst;
    }

    return copy;
}

#ino ⇒ `Fixnum`

Returns the inode number for stat.

File.stat("testfile").ino   #=> 1083669

Returns:

(Fixnum)

# File 'file.c'

/*
 *  call-seq:
 *     stat.ino   -> fixnum
 *
 *  Returns the inode number for <i>stat</i>.
 *
 *     File.stat("testfile").ino   #=> 1083669
 *
 */

static VALUE
rb_stat_ino(VALUE self)
{
#if SIZEOF_STRUCT_STAT_ST_INO > SIZEOF_LONG
    return ULL2NUM(get_stat(self)->st_ino);
#else
    return ULONG2NUM(get_stat(self)->st_ino);
#endif
}

#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>"

Returns:

(String)

# File 'file.c'

/*
 * call-seq:
 *   stat.inspect  ->  string
 *
 * Produce a nicely formatted description of <i>stat</i>.
 *
 *   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>"
 */

static VALUE
rb_stat_inspect(VALUE self)
{
    VALUE str;
    size_t i;
    static const struct {
    const char *name;
    VALUE (*func)(VALUE);
    } member[] = {
    {"dev",        rb_stat_dev},
    {"ino",        rb_stat_ino},
    {"mode",    rb_stat_mode},
    {"nlink",   rb_stat_nlink},
    {"uid",        rb_stat_uid},
    {"gid",        rb_stat_gid},
    {"rdev",    rb_stat_rdev},
    {"size",    rb_stat_size},
    {"blksize", rb_stat_blksize},
    {"blocks",  rb_stat_blocks},
    {"atime",   rb_stat_atime},
    {"mtime",   rb_stat_mtime},
    {"ctime",   rb_stat_ctime},
    };

    struct stat* st;
    TypedData_Get_Struct(self, struct stat, &stat_data_type, st);
    if (!st) {
        return rb_sprintf("#<%s: uninitialized>", rb_obj_classname(self));
    }

    str = rb_str_buf_new2("#<");
    rb_str_buf_cat2(str, rb_obj_classname(self));
    rb_str_buf_cat2(str, " ");

    for (i = 0; i < sizeof(member)/sizeof(member[0]); i++) {
    VALUE v;

    if (i > 0) {
        rb_str_buf_cat2(str, ", ");
    }
    rb_str_buf_cat2(str, member[i].name);
    rb_str_buf_cat2(str, "=");
    v = (*member[i].func)(self);
    if (i == 2) {      /* mode */
        rb_str_catf(str, "0%lo", (unsigned long)NUM2ULONG(v));
    }
    else if (i == 0 || i == 6) { /* dev/rdev */
        rb_str_catf(str, "0x%"PRI_DEVT_PREFIX"x", NUM2DEVT(v));
    }
    else {
        rb_str_append(str, rb_inspect(v));
    }
    }
    rb_str_buf_cat2(str, ">");
    OBJ_INFECT(str, self);

    return str;
}

#mode ⇒ `Fixnum`

Returns an integer representing the permission bits of stat. The meaning of the bits is platform dependent; on Unix systems, see stat(2).

File.chmod(0644, "testfile")   #=> 1
s = File.stat("testfile")
sprintf("%o", s.mode)          #=> "100644"

Returns:

(Fixnum)

# File 'file.c'

/*
 *  call-seq:
 *     stat.mode   -> fixnum
 *
 *  Returns an integer representing the permission bits of
 *  <i>stat</i>. 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"
 */

static VALUE
rb_stat_mode(VALUE self)
{
    return UINT2NUM(ST2UINT(get_stat(self)->st_mode));
}

#mtime ⇒ `Object`

Returns the modification time of stat.

File.stat("testfile").mtime   #=> Wed Apr 09 08:53:14 CDT 2003

# File 'file.c'

/*
 *  call-seq:
 *     stat.mtime  ->  aTime
 *
 *  Returns the modification time of <i>stat</i>.
 *
 *     File.stat("testfile").mtime   #=> Wed Apr 09 08:53:14 CDT 2003
 *
 */

static VALUE
rb_stat_mtime(VALUE self)
{
    return stat_mtime(get_stat(self));
}

#nlink ⇒ `Fixnum`

Returns the number of hard links to stat.

File.stat("testfile").nlink             #=> 1
File.link("testfile", "testfile.bak")   #=> 0
File.stat("testfile").nlink             #=> 2

Returns:

(Fixnum)

# File 'file.c'

/*
 *  call-seq:
 *     stat.nlink   -> fixnum
 *
 *  Returns the number of hard links to <i>stat</i>.
 *
 *     File.stat("testfile").nlink             #=> 1
 *     File.link("testfile", "testfile.bak")   #=> 0
 *     File.stat("testfile").nlink             #=> 2
 *
 */

static VALUE
rb_stat_nlink(VALUE self)
{
    return UINT2NUM(get_stat(self)->st_nlink);
}

#owned? ⇒ `Boolean`

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

Returns:

(Boolean)

# File 'file.c'

/*
 *  call-seq:
 *     stat.owned?    -> true or false
 *
 *  Returns <code>true</code> if the effective user id of the process is
 *  the same as the owner of <i>stat</i>.
 *
 *     File.stat("testfile").owned?      #=> true
 *     File.stat("/etc/passwd").owned?   #=> false
 *
 */

static VALUE
rb_stat_owned(VALUE obj)
{
    if (get_stat(obj)->st_uid == geteuid()) return Qtrue;
    return Qfalse;
}

#pipe? ⇒ `Boolean`

Returns true if the operating system supports pipes and stat is a pipe; false otherwise.

Returns:

(Boolean)

# File 'file.c'

/*
 *  call-seq:
 *     stat.pipe?    -> true or false
 *
 *  Returns <code>true</code> if the operating system supports pipes and
 *  <i>stat</i> is a pipe; <code>false</code> otherwise.
 */

static VALUE
rb_stat_p(VALUE obj)
{
#ifdef S_IFIFO
    if (S_ISFIFO(get_stat(obj)->st_mode)) return Qtrue;

#endif
    return Qfalse;
}

#rdev ⇒ `Fixnum`^?

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

Returns:

(Fixnum, nil)

# File 'file.c'

/*
 *  call-seq:
 *     stat.rdev   ->  fixnum or nil
 *
 *  Returns an integer representing the device type on which
 *  <i>stat</i> resides. Returns <code>nil</code> if the operating
 *  system doesn't support this feature.
 *
 *     File.stat("/dev/fd1").rdev   #=> 513
 *     File.stat("/dev/tty").rdev   #=> 1280
 */

static VALUE
rb_stat_rdev(VALUE self)
{
#ifdef HAVE_ST_RDEV
    return ULONG2NUM(get_stat(self)->st_rdev);
#else
    return Qnil;
#endif
}

#rdev_major ⇒ `Fixnum`

Returns the major part of File_Stat#rdev or nil.

File.stat("/dev/fd1").rdev_major   #=> 2
File.stat("/dev/tty").rdev_major   #=> 5

Returns:

(Fixnum)

# File 'file.c'

/*
 *  call-seq:
 *     stat.rdev_major   -> fixnum
 *
 *  Returns the major part of <code>File_Stat#rdev</code> or
 *  <code>nil</code>.
 *
 *     File.stat("/dev/fd1").rdev_major   #=> 2
 *     File.stat("/dev/tty").rdev_major   #=> 5
 */

static VALUE
rb_stat_rdev_major(VALUE self)
{
#if defined(HAVE_ST_RDEV) && defined(major)
    long rdev = get_stat(self)->st_rdev;
    return ULONG2NUM(major(rdev));
#else
    return Qnil;
#endif
}

#rdev_minor ⇒ `Fixnum`

Returns the minor part of File_Stat#rdev or nil.

File.stat("/dev/fd1").rdev_minor   #=> 1
File.stat("/dev/tty").rdev_minor   #=> 0

Returns:

(Fixnum)

# File 'file.c'

/*
 *  call-seq:
 *     stat.rdev_minor   -> fixnum
 *
 *  Returns the minor part of <code>File_Stat#rdev</code> or
 *  <code>nil</code>.
 *
 *     File.stat("/dev/fd1").rdev_minor   #=> 1
 *     File.stat("/dev/tty").rdev_minor   #=> 0
 */

static VALUE
rb_stat_rdev_minor(VALUE self)
{
#if defined(HAVE_ST_RDEV) && defined(minor)
    long rdev = get_stat(self)->st_rdev;
    return ULONG2NUM(minor(rdev));
#else
    return Qnil;
#endif
}

#readable? ⇒ `Boolean`

Returns true if stat is readable by the effective user id of this process.

File.stat("testfile").readable?   #=> true

Returns:

(Boolean)

# File 'file.c'

/*
 *  call-seq:
 *     stat.readable?    -> true or false
 *
 *  Returns <code>true</code> if <i>stat</i> is readable by the
 *  effective user id of this process.
 *
 *     File.stat("testfile").readable?   #=> true
 *
 */

static VALUE
rb_stat_r(VALUE obj)
{
    struct stat *st = get_stat(obj);

#ifdef USE_GETEUID
    if (geteuid() == 0) return Qtrue;
#endif
#ifdef S_IRUSR
    if (rb_stat_owned(obj))
    return st->st_mode & S_IRUSR ? Qtrue : Qfalse;
#endif
#ifdef S_IRGRP
    if (rb_stat_grpowned(obj))
    return st->st_mode & S_IRGRP ? Qtrue : Qfalse;
#endif
#ifdef S_IROTH
    if (!(st->st_mode & S_IROTH)) return Qfalse;
#endif
    return Qtrue;
}

#readable_real? ⇒ `Boolean`

Returns true if stat is readable by the real user id of this process.

File.stat("testfile").readable_real?   #=> true

Returns:

(Boolean)

# File 'file.c'

/*
 *  call-seq:
 *     stat.readable_real?  ->  true or false
 *
 *  Returns <code>true</code> if <i>stat</i> is readable by the real
 *  user id of this process.
 *
 *     File.stat("testfile").readable_real?   #=> true
 *
 */

static VALUE
rb_stat_R(VALUE obj)
{
    struct stat *st = get_stat(obj);

#ifdef USE_GETEUID
    if (getuid() == 0) return Qtrue;
#endif
#ifdef S_IRUSR
    if (rb_stat_rowned(obj))
    return st->st_mode & S_IRUSR ? Qtrue : Qfalse;
#endif
#ifdef S_IRGRP
    if (rb_group_member(get_stat(obj)->st_gid))
    return st->st_mode & S_IRGRP ? Qtrue : Qfalse;
#endif
#ifdef S_IROTH
    if (!(st->st_mode & S_IROTH)) return Qfalse;
#endif
    return Qtrue;
}

#setgid? ⇒ `Boolean`

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

Returns:

(Boolean)

# File 'file.c'

/*
 *  call-seq:
 *     stat.setgid?   -> true or false
 *
 *  Returns <code>true</code> if <i>stat</i> has the set-group-id
 *  permission bit set, <code>false</code> if it doesn't or if the
 *  operating system doesn't support this feature.
 *
 *     File.stat("/usr/sbin/lpc").setgid?   #=> true
 *
 */

static VALUE
rb_stat_sgid(VALUE obj)
{
#ifdef S_ISGID
    if (get_stat(obj)->st_mode & S_ISGID) return Qtrue;
#endif
    return Qfalse;
}

#setuid? ⇒ `Boolean`

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

Returns:

(Boolean)

# File 'file.c'

/*
 *  call-seq:
 *     stat.setuid?    -> true or false
 *
 *  Returns <code>true</code> if <i>stat</i> has the set-user-id
 *  permission bit set, <code>false</code> if it doesn't or if the
 *  operating system doesn't support this feature.
 *
 *     File.stat("/bin/su").setuid?   #=> true
 */

static VALUE
rb_stat_suid(VALUE obj)
{
#ifdef S_ISUID
    if (get_stat(obj)->st_mode & S_ISUID) return Qtrue;
#endif
    return Qfalse;
}

#size ⇒ `Fixnum`

Returns the size of stat in bytes.

File.stat("testfile").size   #=> 66

Returns:

(Fixnum)

# File 'file.c'

/*
 *  call-seq:
 *     stat.size    -> fixnum
 *
 *  Returns the size of <i>stat</i> in bytes.
 *
 *     File.stat("testfile").size   #=> 66
 */

static VALUE
rb_stat_size(VALUE self)
{
    return OFFT2NUM(get_stat(self)->st_size);
}

#size ⇒ `Integer`

Returns the size of stat in bytes.

File.stat("testfile").size   #=> 66

Returns:

(Integer)

# File 'file.c'

/*
 *  call-seq:
 *     state.size    -> integer
 *
 *  Returns the size of <i>stat</i> in bytes.
 *
 *     File.stat("testfile").size   #=> 66
 *
 */

static VALUE
rb_stat_s(VALUE obj)
{
    off_t size = get_stat(obj)->st_size;

    if (size == 0) return Qnil;
    return OFFT2NUM(size);
}

#socket? ⇒ `Boolean`

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

Returns:

(Boolean)

# File 'file.c'

/*
 *  call-seq:
 *     stat.socket?    -> true or false
 *
 *  Returns <code>true</code> if <i>stat</i> is a socket,
 *  <code>false</code> if it isn't or if the operating system doesn't
 *  support this feature.
 *
 *     File.stat("testfile").socket?   #=> false
 *
 */

static VALUE
rb_stat_S(VALUE obj)
{
#ifdef S_ISSOCK
    if (S_ISSOCK(get_stat(obj)->st_mode)) return Qtrue;

#endif
    return Qfalse;
}

#sticky? ⇒ `Boolean`

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

Returns:

(Boolean)

# File 'file.c'

/*
 *  call-seq:
 *     stat.sticky?    -> true or false
 *
 *  Returns <code>true</code> if <i>stat</i> has its sticky bit set,
 *  <code>false</code> if it doesn't or if the operating system doesn't
 *  support this feature.
 *
 *     File.stat("testfile").sticky?   #=> false
 *
 */

static VALUE
rb_stat_sticky(VALUE obj)
{
#ifdef S_ISVTX
    if (get_stat(obj)->st_mode & S_ISVTX) return Qtrue;
#endif
    return Qfalse;
}

#symlink? ⇒ `Boolean`

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

Returns:

(Boolean)

# File 'file.c'

/*
 *  call-seq:
 *     stat.symlink?    -> true or false
 *
 *  Returns <code>true</code> if <i>stat</i> is a symbolic link,
 *  <code>false</code> if it isn't or if the operating system doesn't
 *  support this feature. As <code>File::stat</code> automatically
 *  follows symbolic links, <code>symlink?</code> will always be
 *  <code>false</code> for an object returned by
 *  <code>File::stat</code>.
 *
 *     File.symlink("testfile", "alink")   #=> 0
 *     File.stat("alink").symlink?         #=> false
 *     File.lstat("alink").symlink?        #=> true
 *
 */

static VALUE
rb_stat_l(VALUE obj)
{
#ifdef S_ISLNK
    if (S_ISLNK(get_stat(obj)->st_mode)) return Qtrue;
#endif
    return Qfalse;
}

#uid ⇒ `Fixnum`

Returns the numeric user id of the owner of stat.

File.stat("testfile").uid   #=> 501

Returns:

(Fixnum)

# File 'file.c'

/*
 *  call-seq:
 *     stat.uid    -> fixnum
 *
 *  Returns the numeric user id of the owner of <i>stat</i>.
 *
 *     File.stat("testfile").uid   #=> 501
 *
 */

static VALUE
rb_stat_uid(VALUE self)
{
    return UIDT2NUM(get_stat(self)->st_uid);
}

#world_readable? ⇒ `Fixnum`^?

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 stat(2).

m = File.stat("/etc/passwd").world_readable?  #=> 420
sprintf("%o", m)                  #=> "644"

Returns:

(Fixnum, nil)

# File 'file.c'

/*
 * call-seq:
 *    stat.world_readable? -> fixnum or nil
 *
 * If <i>stat</i> is readable by others, returns an integer
 * representing the file permission bits of <i>stat</i>. Returns
 * <code>nil</code> 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"
 */

static VALUE
rb_stat_wr(VALUE obj)
{
#ifdef S_IROTH
    if ((get_stat(obj)->st_mode & (S_IROTH)) == S_IROTH) {
    return UINT2NUM(get_stat(obj)->st_mode & (S_IRUGO|S_IWUGO|S_IXUGO));
    }
    else {
    return Qnil;
    }
#endif
}

#world_writable? ⇒ `Fixnum`^?

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 stat(2).

m = File.stat("/tmp").world_writable?     #=> 511
sprintf("%o", m)                  #=> "777"

Returns:

(Fixnum, nil)

# File 'file.c'

/*
 * call-seq:
 *    stat.world_writable?  ->  fixnum or nil
 *
 * If <i>stat</i> is writable by others, returns an integer
 * representing the file permission bits of <i>stat</i>. Returns
 * <code>nil</code> 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"
 */

static VALUE
rb_stat_ww(VALUE obj)
{
#ifdef S_IROTH
    if ((get_stat(obj)->st_mode & (S_IWOTH)) == S_IWOTH) {
    return UINT2NUM(get_stat(obj)->st_mode & (S_IRUGO|S_IWUGO|S_IXUGO));
    }
    else {
    return Qnil;
    }
#endif
}

#writable? ⇒ `Boolean`

Returns true if stat is writable by the effective user id of this process.

File.stat("testfile").writable?   #=> true

Returns:

(Boolean)

# File 'file.c'

/*
 *  call-seq:
 *     stat.writable?  ->  true or false
 *
 *  Returns <code>true</code> if <i>stat</i> is writable by the
 *  effective user id of this process.
 *
 *     File.stat("testfile").writable?   #=> true
 *
 */

static VALUE
rb_stat_w(VALUE obj)
{
    struct stat *st = get_stat(obj);

#ifdef USE_GETEUID
    if (geteuid() == 0) return Qtrue;
#endif
#ifdef S_IWUSR
    if (rb_stat_owned(obj))
    return st->st_mode & S_IWUSR ? Qtrue : Qfalse;
#endif
#ifdef S_IWGRP
    if (rb_stat_grpowned(obj))
    return st->st_mode & S_IWGRP ? Qtrue : Qfalse;
#endif
#ifdef S_IWOTH
    if (!(st->st_mode & S_IWOTH)) return Qfalse;
#endif
    return Qtrue;
}

#writable_real? ⇒ `Boolean`

Returns true if stat is writable by the real user id of this process.

File.stat("testfile").writable_real?   #=> true

Returns:

(Boolean)

# File 'file.c'

/*
 *  call-seq:
 *     stat.writable_real?  ->  true or false
 *
 *  Returns <code>true</code> if <i>stat</i> is writable by the real
 *  user id of this process.
 *
 *     File.stat("testfile").writable_real?   #=> true
 *
 */

static VALUE
rb_stat_W(VALUE obj)
{
    struct stat *st = get_stat(obj);

#ifdef USE_GETEUID
    if (getuid() == 0) return Qtrue;
#endif
#ifdef S_IWUSR
    if (rb_stat_rowned(obj))
    return st->st_mode & S_IWUSR ? Qtrue : Qfalse;
#endif
#ifdef S_IWGRP
    if (rb_group_member(get_stat(obj)->st_gid))
    return st->st_mode & S_IWGRP ? Qtrue : Qfalse;
#endif
#ifdef S_IWOTH
    if (!(st->st_mode & S_IWOTH)) return Qfalse;
#endif
    return Qtrue;
}

#zero? ⇒ `Boolean`

Returns true if stat is a zero-length file; false otherwise.

File.stat("testfile").zero?   #=> false

Returns:

(Boolean)

# File 'file.c'

/*
 *  call-seq:
 *     stat.zero?    -> true or false
 *
 *  Returns <code>true</code> if <i>stat</i> is a zero-length file;
 *  <code>false</code> otherwise.
 *
 *     File.stat("testfile").zero?   #=> false
 *
 */

static VALUE
rb_stat_z(VALUE obj)
{
    if (get_stat(obj)->st_size == 0) return Qtrue;
    return Qfalse;
}

Class: File::Stat

Overview

Instance Method Summary collapse

Methods included from Comparable

Constructor Details

#File::Stat.new(file_name) ⇒ Object

Instance Method Details

#<=>(other_stat) ⇒ -1, ...

#atime ⇒ Time

#blksize ⇒ Integer?

#blockdev? ⇒ Boolean

#blocks ⇒ Integer?

#chardev? ⇒ Boolean

#ctime ⇒ Object

#dev ⇒ Fixnum

#dev_major ⇒ Fixnum

#dev_minor ⇒ Fixnum

#directory?(file_name) ⇒ Boolean

#executable? ⇒ Boolean

#executable_real? ⇒ Boolean

#file? ⇒ Boolean

#ftype ⇒ String

#gid ⇒ Fixnum

#grpowned? ⇒ Boolean

#initialize_copy ⇒ Object

#ino ⇒ Fixnum

#inspect ⇒ String

#mode ⇒ Fixnum

#mtime ⇒ Object

#nlink ⇒ Fixnum

#owned? ⇒ Boolean

#pipe? ⇒ Boolean

#rdev ⇒ Fixnum?

#rdev_major ⇒ Fixnum

#rdev_minor ⇒ Fixnum

#readable? ⇒ Boolean

#readable_real? ⇒ Boolean

#setgid? ⇒ Boolean

#setuid? ⇒ Boolean

#size ⇒ Fixnum

#size ⇒ Integer

#socket? ⇒ Boolean

#sticky? ⇒ Boolean

#symlink? ⇒ Boolean

#uid ⇒ Fixnum

#world_readable? ⇒ Fixnum?

#world_writable? ⇒ Fixnum?

#writable? ⇒ Boolean

#writable_real? ⇒ Boolean

#zero? ⇒ Boolean

#File::Stat.new(file_name) ⇒ `Object`

#<=>(other_stat) ⇒ `-1`, ...

#atime ⇒ `Time`

#blksize ⇒ `Integer`^?

#blockdev? ⇒ `Boolean`

#blocks ⇒ `Integer`^?

#chardev? ⇒ `Boolean`

#ctime ⇒ `Object`

#dev ⇒ `Fixnum`

#dev_major ⇒ `Fixnum`

#dev_minor ⇒ `Fixnum`

#directory?(file_name) ⇒ `Boolean`

#executable? ⇒ `Boolean`

#executable_real? ⇒ `Boolean`

#file? ⇒ `Boolean`

#ftype ⇒ `String`

#gid ⇒ `Fixnum`

#grpowned? ⇒ `Boolean`

#initialize_copy ⇒ `Object`

#ino ⇒ `Fixnum`

#inspect ⇒ `String`

#mode ⇒ `Fixnum`

#mtime ⇒ `Object`

#nlink ⇒ `Fixnum`

#owned? ⇒ `Boolean`

#pipe? ⇒ `Boolean`

#rdev ⇒ `Fixnum`^?

#rdev_major ⇒ `Fixnum`

#rdev_minor ⇒ `Fixnum`

#readable? ⇒ `Boolean`

#readable_real? ⇒ `Boolean`

#setgid? ⇒ `Boolean`

#setuid? ⇒ `Boolean`

#size ⇒ `Fixnum`

#size ⇒ `Integer`

#socket? ⇒ `Boolean`

#sticky? ⇒ `Boolean`

#symlink? ⇒ `Boolean`

#uid ⇒ `Fixnum`

#world_readable? ⇒ `Fixnum`^?

#world_writable? ⇒ `Fixnum`^?

#writable? ⇒ `Boolean`

#writable_real? ⇒ `Boolean`

#zero? ⇒ `Boolean`