Module: FileTest (Ruby 2.3.4)

    In Files

    • file.c

    Class/Module Index [+]

    Quicksearch

    FileTest

    FileTest implements file test operations similar to those used in File::Stat. It exists as a standalone module, and its methods are also insinuated into the File class. (Note that this is not done by inclusion: the interpreter cheats).

    Public Instance Methods

    blockdev?(file_name) → true or false click to toggle source

    Returns true if the named file is a block device.

    file_name can be an IO object.

     
                   static VALUE
    rb_file_blockdev_p(VALUE obj, VALUE fname)
    {
    #ifndef S_ISBLK
    #   ifdef S_IFBLK
    #       define S_ISBLK(m) (((m) & S_IFMT) == S_IFBLK)
    #   else
    #       define S_ISBLK(m) (0)  /* anytime false */
    #   endif
    #endif
    
    #ifdef S_ISBLK
        struct stat st;
    
        if (rb_stat(fname, &st) < 0) return Qfalse;
        if (S_ISBLK(st.st_mode)) return Qtrue;
    
    #endif
        return Qfalse;
    }
                
    chardev?(file_name) → true or false click to toggle source

    Returns true if the named file is a character device.

    file_name can be an IO object.

     
                   static VALUE
    rb_file_chardev_p(VALUE obj, VALUE fname)
    {
    #ifndef S_ISCHR
    #   define S_ISCHR(m) (((m) & S_IFMT) == S_IFCHR)
    #endif
    
        struct stat st;
    
        if (rb_stat(fname, &st) < 0) return Qfalse;
        if (S_ISCHR(st.st_mode)) return Qtrue;
    
        return Qfalse;
    }
                
    directory?(file_name) → true or false click to toggle source

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

    file_name can be an IO object.

    File.directory?(".")
    
     
                   VALUE
    rb_file_directory_p(VALUE obj, VALUE fname)
    {
    #ifndef S_ISDIR
    #   define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
    #endif
    
        struct stat st;
    
        if (rb_stat(fname, &st) < 0) return Qfalse;
        if (S_ISDIR(st.st_mode)) return Qtrue;
        return Qfalse;
    }
                
    executable?(file_name) → true or false click to toggle source

    Returns true if the named file is executable by the effective user and group id of this process. See eaccess(3).

     
                   static VALUE
    rb_file_executable_p(VALUE obj, VALUE fname)
    {
        FilePathValue(fname);
        fname = rb_str_encode_ospath(fname);
        if (eaccess(StringValueCStr(fname), X_OK) < 0) return Qfalse;
        return Qtrue;
    }
                
    executable_real?(file_name) → true or false click to toggle source

    Returns true if the named file is executable by the real user and group id of this process. See access(3).

     
                   static VALUE
    rb_file_executable_real_p(VALUE obj, VALUE fname)
    {
        FilePathValue(fname);
        fname = rb_str_encode_ospath(fname);
        if (access(StringValueCStr(fname), X_OK) < 0) return Qfalse;
        return Qtrue;
    }
                
    exist?(file_name) → true or false click to toggle source

    Return true if the named file exists.

    file_name can be an IO object.

    “file exists” means that stat() or fstat() system call is successful.

     
                   static VALUE
    rb_file_exist_p(VALUE obj, VALUE fname)
    {
        struct stat st;
    
        if (rb_stat(fname, &st) < 0) return Qfalse;
        return Qtrue;
    }
                
    exists?(file_name) → true or false click to toggle source

    Deprecated method. Don’t use.

     
                   static VALUE
    rb_file_exists_p(VALUE obj, VALUE fname)
    {
        const char *s = "FileTest#";
        if (obj == rb_mFileTest) {
            s = "FileTest.";
        }
        else if (obj == rb_cFile ||
                 (RB_TYPE_P(obj, T_CLASS) &&
                  RTEST(rb_class_inherited_p(obj, rb_cFile)))) {
            s = "File.";
        }
        rb_warning("%sexists? is a deprecated name, use %sexist? instead", s, s);
        return rb_file_exist_p(obj, fname);
    }
                
    file?(file) → true or false click to toggle source

    Returns true if the named file exists and is a regular file.

    file can be an IO object.

    If the file argument is a symbolic link, it will resolve the symbolic link and use the file referenced by the link.

     
                   static VALUE
    rb_file_file_p(VALUE obj, VALUE fname)
    {
        struct stat st;
    
        if (rb_stat(fname, &st) < 0) return Qfalse;
        if (S_ISREG(st.st_mode)) return Qtrue;
        return Qfalse;
    }
                
    grpowned?(file_name) → true or false click to toggle source

    Returns true if the named file exists and the effective group id of the calling process is the owner of the file. Returns false on Windows.

    file_name can be an IO object.

     
                   static VALUE
    rb_file_grpowned_p(VALUE obj, VALUE fname)
    {
    #ifndef _WIN32
        struct stat st;
    
        if (rb_stat(fname, &st) < 0) return Qfalse;
        if (rb_group_member(st.st_gid)) return Qtrue;
    #endif
        return Qfalse;
    }
                
    identical?(file_1, file_2) → true or false click to toggle source

    Returns true if the named files are identical.

    file_1 and file_2 can be an IO object.

    open("a", "w") {}
    p File.identical?("a", "a")      #=> true
    p File.identical?("a", "./a")    #=> true
    File.link("a", "b")
    p File.identical?("a", "b")      #=> true
    File.symlink("a", "c")
    p File.identical?("a", "c")      #=> true
    open("d", "w") {}
    p File.identical?("a", "d")      #=> false
    
     
                   static VALUE
    rb_file_identical_p(VALUE obj, VALUE fname1, VALUE fname2)
    {
    #ifndef _WIN32
        struct stat st1, st2;
    
        if (rb_stat(fname1, &st1) < 0) return Qfalse;
        if (rb_stat(fname2, &st2) < 0) return Qfalse;
        if (st1.st_dev != st2.st_dev) return Qfalse;
        if (st1.st_ino != st2.st_ino) return Qfalse;
        return Qtrue;
    #else
        BY_HANDLE_FILE_INFORMATION st1, st2;
        HANDLE f1 = 0, f2 = 0;
    
        f1 = w32_io_info(&fname1, &st1);
        if (f1 == INVALID_HANDLE_VALUE) return Qfalse;
        if (f1) {
            struct w32_io_info_args arg;
            arg.fname = &fname2;
            arg.st = &st2;
            f2 = (HANDLE)rb_ensure(call_w32_io_info, (VALUE)&arg, close_handle, (VALUE)f1);
        }
        else {
            f2 = w32_io_info(&fname2, &st2);
        }
        if (f2 == INVALID_HANDLE_VALUE) return Qfalse;
        if (f2) CloseHandle(f2);
    
        if (st1.dwVolumeSerialNumber == st2.dwVolumeSerialNumber &&
            st1.nFileIndexHigh == st2.nFileIndexHigh &&
            st1.nFileIndexLow == st2.nFileIndexLow)
            return Qtrue;
        return Qfalse;
    #endif
    }
                
    owned?(file_name) → true or false click to toggle source

    Returns true if the named file exists and the effective used id of the calling process is the owner of the file.

    file_name can be an IO object.

     
                   static VALUE
    rb_file_owned_p(VALUE obj, VALUE fname)
    {
        struct stat st;
    
        if (rb_stat(fname, &st) < 0) return Qfalse;
        if (st.st_uid == geteuid()) return Qtrue;
        return Qfalse;
    }
                
    pipe?(file_name) → true or false click to toggle source

    Returns true if the named file is a pipe.

    file_name can be an IO object.

     
                   static VALUE
    rb_file_pipe_p(VALUE obj, VALUE fname)
    {
    #ifdef S_IFIFO
    #  ifndef S_ISFIFO
    #    define S_ISFIFO(m) (((m) & S_IFMT) == S_IFIFO)
    #  endif
    
        struct stat st;
    
        if (rb_stat(fname, &st) < 0) return Qfalse;
        if (S_ISFIFO(st.st_mode)) return Qtrue;
    
    #endif
        return Qfalse;
    }
                
    readable?(file_name) → true or false click to toggle source

    Returns true if the named file is readable by the effective user and group id of this process. See eaccess(3).

     
                   static VALUE
    rb_file_readable_p(VALUE obj, VALUE fname)
    {
        FilePathValue(fname);
        fname = rb_str_encode_ospath(fname);
        if (eaccess(StringValueCStr(fname), R_OK) < 0) return Qfalse;
        return Qtrue;
    }
                
    readable_real?(file_name) → true or false click to toggle source

    Returns true if the named file is readable by the real user and group id of this process. See access(3).

     
                   static VALUE
    rb_file_readable_real_p(VALUE obj, VALUE fname)
    {
        FilePathValue(fname);
        fname = rb_str_encode_ospath(fname);
        if (access(StringValueCStr(fname), R_OK) < 0) return Qfalse;
        return Qtrue;
    }
                
    setgid?(file_name) → true or false click to toggle source

    Returns true if the named file has the setgid bit set.

     
                   static VALUE
    rb_file_sgid_p(VALUE obj, VALUE fname)
    {
    #ifdef S_ISGID
        return check3rdbyte(fname, S_ISGID);
    #else
        return Qfalse;
    #endif
    }
                
    setuid?(file_name) → true or false click to toggle source

    Returns true if the named file has the setuid bit set.

     
                   static VALUE
    rb_file_suid_p(VALUE obj, VALUE fname)
    {
    #ifdef S_ISUID
        return check3rdbyte(fname, S_ISUID);
    #else
        return Qfalse;
    #endif
    }
                
    size(file_name) → integer click to toggle source

    Returns the size of file_name.

    file_name can be an IO object.

     
                   static VALUE
    rb_file_s_size(VALUE klass, VALUE fname)
    {
        struct stat st;
    
        if (rb_stat(fname, &st) < 0) {
            int e = errno;
            FilePathValue(fname);
            rb_syserr_fail_path(e, fname);
        }
        return OFFT2NUM(st.st_size);
    }
                
    size?(file_name) → Integer or nil click to toggle source

    Returns nil if file_name doesn’t exist or has zero size, the size of the file otherwise.

    file_name can be an IO object.

     
                   static VALUE
    rb_file_size_p(VALUE obj, VALUE fname)
    {
        struct stat st;
    
        if (rb_stat(fname, &st) < 0) return Qnil;
        if (st.st_size == 0) return Qnil;
        return OFFT2NUM(st.st_size);
    }
                
    socket?(file_name) → true or false click to toggle source

    Returns true if the named file is a socket.

    file_name can be an IO object.

     
                   static VALUE
    rb_file_socket_p(VALUE obj, VALUE fname)
    {
    #ifndef S_ISSOCK
    #  ifdef _S_ISSOCK
    #    define S_ISSOCK(m) _S_ISSOCK(m)
    #  else
    #    ifdef _S_IFSOCK
    #      define S_ISSOCK(m) (((m) & S_IFMT) == _S_IFSOCK)
    #    else
    #      ifdef S_IFSOCK
    #        define S_ISSOCK(m) (((m) & S_IFMT) == S_IFSOCK)
    #      endif
    #    endif
    #  endif
    #endif
    
    #ifdef S_ISSOCK
        struct stat st;
    
        if (rb_stat(fname, &st) < 0) return Qfalse;
        if (S_ISSOCK(st.st_mode)) return Qtrue;
    
    #endif
        return Qfalse;
    }
                
    sticky?(file_name) → true or false click to toggle source

    Returns true if the named file has the sticky bit set.

     
                   static VALUE
    rb_file_sticky_p(VALUE obj, VALUE fname)
    {
    #ifdef S_ISVTX
        return check3rdbyte(fname, S_ISVTX);
    #else
        return Qnil;
    #endif
    }
                
    world_readable?(file_name) → fixnum or nil click to toggle source

    If file_name is readable by others, returns an integer representing the file permission bits of file_name. Returns nil otherwise. The meaning of the bits is platform dependent; on Unix systems, see stat(2).

    file_name can be an IO object.

    File.world_readable?("/etc/passwd")           #=> 420
    m = File.world_readable?("/etc/passwd")
    sprintf("%o", m)                              #=> "644"
    
     
                   static VALUE
    rb_file_world_readable_p(VALUE obj, VALUE fname)
    {
    #ifdef S_IROTH
        struct stat st;
    
        if (rb_stat(fname, &st) < 0) return Qnil;
        if ((st.st_mode & (S_IROTH)) == S_IROTH) {
            return UINT2NUM(st.st_mode & (S_IRUGO|S_IWUGO|S_IXUGO));
        }
    #endif
        return Qnil;
    }
                
    world_writable?(file_name) → fixnum or nil click to toggle source

    If file_name is writable by others, returns an integer representing the file permission bits of file_name. Returns nil otherwise. The meaning of the bits is platform dependent; on Unix systems, see stat(2).

    file_name can be an IO object.

    File.world_writable?("/tmp")                  #=> 511
    m = File.world_writable?("/tmp")
    sprintf("%o", m)                              #=> "777"
    
     
                   static VALUE
    rb_file_world_writable_p(VALUE obj, VALUE fname)
    {
    #ifdef S_IWOTH
        struct stat st;
    
        if (rb_stat(fname, &st) < 0) return Qnil;
        if ((st.st_mode & (S_IWOTH)) == S_IWOTH) {
            return UINT2NUM(st.st_mode & (S_IRUGO|S_IWUGO|S_IXUGO));
        }
    #endif
        return Qnil;
    }
                
    writable?(file_name) → true or false click to toggle source

    Returns true if the named file is writable by the effective user and group id of this process. See eaccess(3).

     
                   static VALUE
    rb_file_writable_p(VALUE obj, VALUE fname)
    {
        FilePathValue(fname);
        fname = rb_str_encode_ospath(fname);
        if (eaccess(StringValueCStr(fname), W_OK) < 0) return Qfalse;
        return Qtrue;
    }
                
    writable_real?(file_name) → true or false click to toggle source

    Returns true if the named file is writable by the real user and group id of this process. See access(3)

     
                   static VALUE
    rb_file_writable_real_p(VALUE obj, VALUE fname)
    {
        FilePathValue(fname);
        fname = rb_str_encode_ospath(fname);
        if (access(StringValueCStr(fname), W_OK) < 0) return Qfalse;
        return Qtrue;
    }
                
    zero?(file_name) → true or false click to toggle source

    Returns true if the named file exists and has a zero size.

    file_name can be an IO object.

     
                   static VALUE
    rb_file_zero_p(VALUE obj, VALUE fname)
    {
        struct stat st;
    
        if (rb_stat(fname, &st) < 0) return Qfalse;
        if (st.st_size == 0) return Qtrue;
        return Qfalse;
    }