Class: File

Inherits:
IO show all
Defined in:
file.c

Overview

A File is an abstraction of any file object accessible by the program and is closely associated with class IO File includes the methods of module FileTest as class methods, allowing you to write (for example) File.exist?("foo").

In the description of File methods, permission bits are a platform-specific set of bits that indicate permissions of a file. On Unix-based systems, permissions are viewed as a set of three octets, for the owner, the group, and the rest of the world. For each of these entities, permissions may be set to read, write, or execute the file:

The permission bits 0644 (in octal) would thus be interpreted as read/write for owner, and read-only for group and other. Higher-order bits may also be used to indicate the type of file (plain, directory, pipe, socket, and so on) and various other special features. If the permissions are for a directory, the meaning of the execute bit changes; when set the directory can be searched.

On non-Posix operating systems, there may be only the ability to make a file read-only or read-write. In this case, the remaining permission bits will be synthesized to resemble typical values. For instance, on Windows NT the default permission bits are 0644, which means read/write for owner, read-only for all others. The only change that can be made is to make the file read-only, which is reported as 0444.

Defined Under Namespace

Modules: Constants Classes: Stat

Constant Summary collapse

Separator = 
separator
SEPARATOR = 
separator
ALT_SEPARATOR = 
Qnil
PATH_SEPARATOR = 
rb_obj_freeze(rb_str_new2(PATH_SEP))

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from IO

#stat

Class Method Details

.atime(file_name) ⇒ Time

Returns the last access time for the named file as a Time object).

File.atime("testfile")   #=> Wed Apr 09 08:51:48 CDT 2003

Returns:



1575
1576
1577
 
# File 'file.c', line 1575

static VALUE
rb_file_s_atime(klass, fname)
VALUE klass, fname;

.basename(file_name[, suffix]) ⇒ Object

Returns the last component of the filename given in file_name, which must be formed using forward slashes (“/”) regardless of the separator used on the local file system. If suffix is given and present at the end of file_name, it is removed.

File.basename("/home/gumby/work/ruby.rb")          #=> "ruby.rb"
File.basename("/home/gumby/work/ruby.rb", ".rb")   #=> "ruby"



2888
2889
2890
 
# File 'file.c', line 2888

static VALUE
rb_file_s_basename(argc, argv)
int argc;

.blockdev?(file_name) ⇒ Boolean

Returns true if the named file is a block device.

Returns:

  • (Boolean) 


1062
1063
1064
 
# File 'file.c', line 1062

static VALUE
test_b(obj, fname)
VALUE obj, fname;

.chardev?(file_name) ⇒ Boolean

Returns true if the named file is a character device.

Returns:

  • (Boolean) 


1090
1091
1092
 
# File 'file.c', line 1090

static VALUE
test_c(obj, fname)
VALUE obj, fname;

.chmod(mode_int, file_name, ...) ⇒ Integer

Changes permission bits on the named file(s) to the bit pattern represented by mode_int. Actual effects are operating system dependent (see the beginning of this section). On Unix systems, see chmod(2) for details. Returns the number of files processed.

File.chmod(0644, "testfile", "out")   #=> 2

Returns:



1727
1728
1729
 
# File 'file.c', line 1727

static VALUE
rb_file_s_chmod(argc, argv)
int argc;

.chown(owner_int, group_int, file_name, ...) ⇒ Integer

Changes the owner and group of the named file(s) to the given numeric owner and group id’s. Only a process with superuser privileges may change the owner of a file. The current owner of a file may change the file’s group to any group to which the owner belongs. A nil or -1 owner or group id is ignored. Returns the number of files processed.

File.chown(nil, 100, "testfile")

Returns:



1859
1860
1861
 
# File 'file.c', line 1859

static VALUE
rb_file_s_chown(argc, argv)
int argc;

.ctime(file_name) ⇒ Time

Returns the change time for the named file (the time at which directory information about the file was changed, not the file itself).

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

Returns:



1668
1669
1670
 
# File 'file.c', line 1668

static VALUE
rb_file_s_ctime(klass, fname)
VALUE klass, fname;

.delete(file_name, ...) ⇒ Integer .unlink(file_name, ...) ⇒ Integer

Deletes the named files, returning the number of names passed as arguments. Raises an exception on any error. See also Dir::rmdir.

Overloads:



2217
2218
2219
 
# File 'file.c', line 2217

static VALUE
rb_file_s_unlink(klass, args)
VALUE klass, args;

.directory?(file_name) ⇒ Boolean

Returns true if the named file is a directory, false otherwise.

File.directory?(".")

Returns:

  • (Boolean) 


928
929
930
 
# File 'file.c', line 928

static VALUE
test_d(obj, fname)
VALUE obj, fname;

.dirname(file_name) ⇒ Object

Returns all components of the filename given in file_name except the last one. The filename must be formed using forward slashes (“/”) regardless of the separator used on the local file system.

File.dirname("/home/gumby/work/ruby.rb")   #=> "/home/gumby/work"



2966
2967
2968
 
# File 'file.c', line 2966

static VALUE
rb_file_s_dirname(klass, fname)
VALUE klass, fname;

.executable?(file_name) ⇒ Boolean

Returns true if the named file is executable by the effective user id of this process.

Returns:

  • (Boolean) 


1202
1203
1204
 
# File 'file.c', line 1202

static VALUE
test_x(obj, fname)
VALUE obj, fname;

.executable_real?(file_name) ⇒ Boolean

Returns true if the named file is executable by the real user id of this process.

Returns:

  • (Boolean) 


1219
1220
1221
 
# File 'file.c', line 1219

static VALUE
test_X(obj, fname)
VALUE obj, fname;

.exist?(file_name) ⇒ Boolean .exists?(file_name) ⇒ Boolean

Return true if the named file exists.

Overloads:

  • .exist?(file_name) ⇒ Boolean

    Returns:

    • (Boolean)
  • .exists?(file_name) ⇒ Boolean

    Returns:

    • (Boolean) 


1115
1116
1117
 
# File 'file.c', line 1115

static VALUE
test_e(obj, fname)
VALUE obj, fname;

.exist?(file_name) ⇒ Boolean .exists?(file_name) ⇒ Boolean

Return true if the named file exists.

Overloads:

  • .exist?(file_name) ⇒ Boolean

    Returns:

    • (Boolean)
  • .exists?(file_name) ⇒ Boolean

    Returns:

    • (Boolean) 


1115
1116
1117
 
# File 'file.c', line 1115

static VALUE
test_e(obj, fname)
VALUE obj, fname;

.expand_path(file_name[, dir_string]) ⇒ Object

Converts a pathname to an absolute pathname. Relative paths are referenced from the current working directory of the process unless dir_string is given, in which case it will be used as the starting point. The given pathname may start with a “~”, which expands to the process owner’s home directory (the environment variable HOME must be set correctly). “~user” expands to the named user’s home directory.

File.expand_path("~oracle/bin")           #=> "/home/oracle/bin"
File.expand_path("../../bin", "/tmp/x")   #=> "/bin"



2828
2829
2830
 
# File 'file.c', line 2828

VALUE
rb_file_s_expand_path(argc, argv)
int argc;

.extname(path) ⇒ String

Returns the extension (the portion of file name in path after the period).

File.extname("test.rb")         #=> ".rb"
File.extname("a/b/d/test.rb")   #=> ".rb"
File.extname("test")            #=> ""
File.extname(".profile")        #=> ""

Returns:



3019
3020
3021
 
# File 'file.c', line 3019

static VALUE
rb_file_s_extname(klass, fname)
VALUE klass, fname;

.file?(file_name) ⇒ Boolean

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

Returns:

  • (Boolean) 


1240
1241
1242
 
# File 'file.c', line 1240

static VALUE
test_f(obj, fname)
VALUE obj, fname;

.fnmatch(pattern, path, [flags]) ⇒ Boolean .fnmatch?(pattern, path, [flags]) ⇒ Boolean

Returns true if path matches against pattern The pattern is not a regular expression; instead it follows rules similar to shell filename globbing. It may contain the following metacharacters:

*

Matches any file. Can be restricted by other values in the glob. * will match all files; c* will match all files beginning with c; *c will match all files ending with c; and c will match all files that have c in them (including at the beginning or end). Equivalent to / .* /x in regexp.

**

Matches directories recursively or files expansively.

?

Matches any one character. Equivalent to /.{1}/ in regexp.

[set]

Matches any one character in set. Behaves exactly like character sets in Regexp, including set negation ([^a-z]).

<code></code>

Escapes the next metacharacter.

flags is a bitwise OR of the FNM_xxx parameters. The same glob pattern and flags are used by Dir::glob.

File.fnmatch('cat',       'cat')        #=> true  : match entire string
File.fnmatch('cat',       'category')   #=> false : only match partial string
File.fnmatch('c{at,ub}s', 'cats')       #=> false : { } isn't supported

File.fnmatch('c?t',     'cat')          #=> true  : '?' match only 1 character
File.fnmatch('c??t',    'cat')          #=> false : ditto
File.fnmatch('c*',      'cats')         #=> true  : '*' match 0 or more characters
File.fnmatch('c*t',     'c/a/b/t')      #=> true  : ditto
File.fnmatch('ca[a-z]', 'cat')          #=> true  : inclusive bracket expression
File.fnmatch('ca[^t]',  'cat')          #=> false : exclusive bracket expression ('^' or '!')

File.fnmatch('cat', 'CAT')                     #=> false : case sensitive
File.fnmatch('cat', 'CAT', File::FNM_CASEFOLD) #=> true  : case insensitive

File.fnmatch('?',   '/', File::FNM_PATHNAME)  #=> false : wildcard doesn't match '/' on FNM_PATHNAME
File.fnmatch('*',   '/', File::FNM_PATHNAME)  #=> false : ditto
File.fnmatch('[/]', '/', File::FNM_PATHNAME)  #=> false : ditto

File.fnmatch('\?',   '?')                       #=> true  : escaped wildcard becomes ordinary
File.fnmatch('\a',   'a')                       #=> true  : escaped ordinary remains ordinary
File.fnmatch('\a',   '\a', File::FNM_NOESCAPE)  #=> true  : FNM_NOESACPE makes '\' ordinary
File.fnmatch('[\?]', '?')                       #=> true  : can escape inside bracket expression

File.fnmatch('*',   '.profile')                      #=> false : wildcard doesn't match leading
File.fnmatch('*',   '.profile', File::FNM_DOTMATCH)  #=> true    period by default.
File.fnmatch('.*',  '.profile')                      #=> true

rbfiles = '**' '/' '*.rb' # you don't have to do like this. just write in single string.
File.fnmatch(rbfiles, 'main.rb')                    #=> false
File.fnmatch(rbfiles, './main.rb')                  #=> false
File.fnmatch(rbfiles, 'lib/song.rb')                #=> true
File.fnmatch('**.rb', 'main.rb')                    #=> true
File.fnmatch('**.rb', './main.rb')                  #=> false
File.fnmatch('**.rb', 'lib/song.rb')                #=> true
File.fnmatch('*',           'dave/.profile')                      #=> true

pattern = '*' '/' '*'
File.fnmatch(pattern, 'dave/.profile', File::FNM_PATHNAME)  #=> false
File.fnmatch(pattern, 'dave/.profile', File::FNM_PATHNAME | File::FNM_DOTMATCH) #=> true

pattern = '**' '/' 'foo'
File.fnmatch(pattern, 'a/b/c/foo', File::FNM_PATHNAME)     #=> true
File.fnmatch(pattern, '/a/b/c/foo', File::FNM_PATHNAME)    #=> true
File.fnmatch(pattern, 'c:/a/b/c/foo', File::FNM_PATHNAME)  #=> true
File.fnmatch(pattern, 'a/.b/c/foo', File::FNM_PATHNAME)    #=> false
File.fnmatch(pattern, 'a/.b/c/foo', File::FNM_PATHNAME | File::FNM_DOTMATCH) #=> true

Overloads:

  • .fnmatch(pattern, path, [flags]) ⇒ Boolean

    Returns:

    • (Boolean)
  • .fnmatch?(pattern, path, [flags]) ⇒ Boolean

    Returns:

    • (Boolean) 


1926
1927
1928
 
# File 'dir.c', line 1926

static VALUE
file_s_fnmatch(argc, argv, obj)
int argc;

.fnmatch(pattern, path, [flags]) ⇒ Boolean .fnmatch?(pattern, path, [flags]) ⇒ Boolean

Returns true if path matches against pattern The pattern is not a regular expression; instead it follows rules similar to shell filename globbing. It may contain the following metacharacters:

*

Matches any file. Can be restricted by other values in the glob. * will match all files; c* will match all files beginning with c; *c will match all files ending with c; and c will match all files that have c in them (including at the beginning or end). Equivalent to / .* /x in regexp.

**

Matches directories recursively or files expansively.

?

Matches any one character. Equivalent to /.{1}/ in regexp.

[set]

Matches any one character in set. Behaves exactly like character sets in Regexp, including set negation ([^a-z]).

<code></code>

Escapes the next metacharacter.

flags is a bitwise OR of the FNM_xxx parameters. The same glob pattern and flags are used by Dir::glob.

File.fnmatch('cat',       'cat')        #=> true  : match entire string
File.fnmatch('cat',       'category')   #=> false : only match partial string
File.fnmatch('c{at,ub}s', 'cats')       #=> false : { } isn't supported

File.fnmatch('c?t',     'cat')          #=> true  : '?' match only 1 character
File.fnmatch('c??t',    'cat')          #=> false : ditto
File.fnmatch('c*',      'cats')         #=> true  : '*' match 0 or more characters
File.fnmatch('c*t',     'c/a/b/t')      #=> true  : ditto
File.fnmatch('ca[a-z]', 'cat')          #=> true  : inclusive bracket expression
File.fnmatch('ca[^t]',  'cat')          #=> false : exclusive bracket expression ('^' or '!')

File.fnmatch('cat', 'CAT')                     #=> false : case sensitive
File.fnmatch('cat', 'CAT', File::FNM_CASEFOLD) #=> true  : case insensitive

File.fnmatch('?',   '/', File::FNM_PATHNAME)  #=> false : wildcard doesn't match '/' on FNM_PATHNAME
File.fnmatch('*',   '/', File::FNM_PATHNAME)  #=> false : ditto
File.fnmatch('[/]', '/', File::FNM_PATHNAME)  #=> false : ditto

File.fnmatch('\?',   '?')                       #=> true  : escaped wildcard becomes ordinary
File.fnmatch('\a',   'a')                       #=> true  : escaped ordinary remains ordinary
File.fnmatch('\a',   '\a', File::FNM_NOESCAPE)  #=> true  : FNM_NOESACPE makes '\' ordinary
File.fnmatch('[\?]', '?')                       #=> true  : can escape inside bracket expression

File.fnmatch('*',   '.profile')                      #=> false : wildcard doesn't match leading
File.fnmatch('*',   '.profile', File::FNM_DOTMATCH)  #=> true    period by default.
File.fnmatch('.*',  '.profile')                      #=> true

rbfiles = '**' '/' '*.rb' # you don't have to do like this. just write in single string.
File.fnmatch(rbfiles, 'main.rb')                    #=> false
File.fnmatch(rbfiles, './main.rb')                  #=> false
File.fnmatch(rbfiles, 'lib/song.rb')                #=> true
File.fnmatch('**.rb', 'main.rb')                    #=> true
File.fnmatch('**.rb', './main.rb')                  #=> false
File.fnmatch('**.rb', 'lib/song.rb')                #=> true
File.fnmatch('*',           'dave/.profile')                      #=> true

pattern = '*' '/' '*'
File.fnmatch(pattern, 'dave/.profile', File::FNM_PATHNAME)  #=> false
File.fnmatch(pattern, 'dave/.profile', File::FNM_PATHNAME | File::FNM_DOTMATCH) #=> true

pattern = '**' '/' 'foo'
File.fnmatch(pattern, 'a/b/c/foo', File::FNM_PATHNAME)     #=> true
File.fnmatch(pattern, '/a/b/c/foo', File::FNM_PATHNAME)    #=> true
File.fnmatch(pattern, 'c:/a/b/c/foo', File::FNM_PATHNAME)  #=> true
File.fnmatch(pattern, 'a/.b/c/foo', File::FNM_PATHNAME)    #=> false
File.fnmatch(pattern, 'a/.b/c/foo', File::FNM_PATHNAME | File::FNM_DOTMATCH) #=> true

Overloads:

  • .fnmatch(pattern, path, [flags]) ⇒ Boolean

    Returns:

    • (Boolean)
  • .fnmatch?(pattern, path, [flags]) ⇒ Boolean

    Returns:

    • (Boolean) 


1926
1927
1928
 
# File 'dir.c', line 1926

static VALUE
file_s_fnmatch(argc, argv, obj)
int argc;

.ftype(file_name) ⇒ String

Identifies the type of the named file; the return string is one of “file”, “directory”, “characterSpecial”, “blockSpecial”, “fifo”, “link”, “socket”, or “unknown”.

File.ftype("testfile")            #=> "file"
File.ftype("/dev/tty")            #=> "characterSpecial"
File.ftype("/tmp/.X11-unix/X0")   #=> "socket"

Returns:



1551
1552
1553
 
# File 'file.c', line 1551

static VALUE
rb_file_s_ftype(klass, fname)
VALUE klass, fname;

.grpowned?(file_name) ⇒ Boolean

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.

Returns:

  • (Boolean) 


1329
1330
1331
 
# File 'file.c', line 1329

static VALUE
test_grpowned(obj, fname)
VALUE obj, fname;

.identical?(file_1, file_2) ⇒ Boolean

Returns true if the named files are identical.

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

Returns:

  • (Boolean) 


1428
1429
1430
 
# File 'file.c', line 1428

static VALUE
test_identical(obj, fname1, fname2)
VALUE obj, fname1, fname2;

.join(string, ...) ⇒ Object

Returns a new string formed by joining the strings using File::SEPARATOR.

File.join("usr", "mail", "gumby")   #=> "usr/mail/gumby"



3174
3175
3176
 
# File 'file.c', line 3174

static VALUE
rb_file_s_join(klass, args)
VALUE klass, args;

.lchmod ⇒ Object 



1819
1820
1821
 
# File 'file.c', line 1819

static VALUE
rb_file_s_lchmod(argc, argv)
int argc;

.lchown ⇒ Object 



1977
1978
1979
 
# File 'file.c', line 1977

static VALUE
rb_file_s_lchown(argc, argv)
int argc;

.link(old_name, new_name) ⇒ 0

Creates a new name for an existing file using a hard link. Will not overwrite new_name if it already exists (raising a subclass of SystemCallError). Not available on all platforms.

File.link("testfile", ".testfile")   #=> 0
IO.readlines(".testfile")[0]         #=> "This is line one\n"

Returns:

  • (0) 


2104
2105
2106
 
# File 'file.c', line 2104

static VALUE
rb_file_s_link(klass, from, to)
VALUE klass, from, to;

.lstat(file_name) ⇒ Object

Same as File::stat, but does not follow the last symbolic link. Instead, reports on the link itself.

File.symlink("testfile", "link2test")   #=> 0
File.stat("testfile").size              #=> 66
File.lstat("link2test").size            #=> 8
File.stat("link2test").size             #=> 66



770
771
772
 
# File 'file.c', line 770

static VALUE
rb_file_s_lstat(klass, fname)
VALUE klass, fname;

.mtime(file_name) ⇒ Time

Returns the modification time for the named file as a Time object.

File.mtime("testfile")   #=> Tue Apr 08 12:58:04 CDT 2003

Returns:



1621
1622
1623
 
# File 'file.c', line 1621

static VALUE
rb_file_s_mtime(klass, fname)
VALUE klass, fname;

.owned?(file_name) ⇒ Boolean

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

Returns:

  • (Boolean) 


1298
1299
1300
 
# File 'file.c', line 1298

static VALUE
test_owned(obj, fname)
VALUE obj, fname;

.pipe?(file_name) ⇒ Boolean

Returns true if the named file is a pipe.

Returns:

  • (Boolean) 


950
951
952
 
# File 'file.c', line 950

static VALUE
test_p(obj, fname)
VALUE obj, fname;

.readable?(file_name) ⇒ Boolean

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

Returns:

  • (Boolean) 


1133
1134
1135
 
# File 'file.c', line 1133

static VALUE
test_r(obj, fname)
VALUE obj, fname;

.readable_real?(file_name) ⇒ Boolean

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

Returns:

  • (Boolean) 


1150
1151
1152
 
# File 'file.c', line 1150

static VALUE
test_R(obj, fname)
VALUE obj, fname;

.readlink(link_name) ⇒ Object

Returns the name of the file referenced by the given link. Not available on all platforms.

File.symlink("testfile", "link2test")   #=> 0
File.readlink("link2test")              #=> "testfile"



2163
2164
2165
 
# File 'file.c', line 2163

static VALUE
rb_file_s_readlink(klass, path)
VALUE klass, path;

.rename(old_name, new_name) ⇒ 0

Renames the given file to the new name. Raises a SystemCallError if the file cannot be renamed.

File.rename("afile", "afile.bak")   #=> 0

Returns:

  • (0) 


2238
2239
2240
 
# File 'file.c', line 2238

static VALUE
rb_file_s_rename(klass, from, to)
VALUE klass, from, to;

.setgid?(file_name) ⇒ Boolean

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

Returns:

  • (Boolean) 


1382
1383
1384
 
# File 'file.c', line 1382

static VALUE
test_sgid(obj, fname)
VALUE obj, fname;

.setuid?(file_name) ⇒ Boolean

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

Returns:

  • (Boolean) 


1364
1365
1366
 
# File 'file.c', line 1364

static VALUE
test_suid(obj, fname)
VALUE obj, fname;

.size(file_name) ⇒ Integer

Returns the size of file_name.

Returns:



1483
1484
1485
 
# File 'file.c', line 1483

static VALUE
rb_file_s_size(klass, fname)
VALUE klass, fname;

.size?(file_name) ⇒ Integer?

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

Returns:



1278
1279
1280
 
# File 'file.c', line 1278

static VALUE
test_s(obj, fname)
VALUE obj, fname;

.socket?(file_name) ⇒ Boolean

Returns true if the named file is a socket.

Returns:

  • (Boolean) 


1019
1020
1021
 
# File 'file.c', line 1019

static VALUE
test_S(obj, fname)
VALUE obj, fname;

.split(file_name) ⇒ Array

Splits the given string into a directory and a file component and returns them in a two-element array. See also File::dirname and File::basename.

File.split("/home/gumby/.profile")   #=> ["/home/gumby", ".profile"]

Returns:



3079
3080
3081
 
# File 'file.c', line 3079

static VALUE
rb_file_s_split(klass, path)
VALUE klass, path;

.stat(file_name) ⇒ Object

Returns a File::Stat object for the named file (see File::Stat).

File.stat("testfile").mtime   #=> Tue Apr 08 12:58:04 CDT 2003



714
715
716
 
# File 'file.c', line 714

static VALUE
rb_file_s_stat(klass, fname)
VALUE klass, fname;

.sticky?(file_name) ⇒ Boolean

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

Returns:

  • (Boolean) 


1400
1401
1402
 
# File 'file.c', line 1400

static VALUE
test_sticky(obj, fname)
VALUE obj, fname;

.symlink(old_name, new_name) ⇒ 0

Creates a symbolic link called new_name for the existing file old_name. Raises a NotImplemented exception on platforms that do not support symbolic links.

File.symlink("testfile", "link2test")   #=> 0

Returns:

  • (0) 


2134
2135
2136
 
# File 'file.c', line 2134

static VALUE
rb_file_s_symlink(klass, from, to)
VALUE klass, from, to;

.symlink?(file_name) ⇒ Boolean

Returns true if the named file is a symbolic link.

Returns:

  • (Boolean) 


975
976
977
 
# File 'file.c', line 975

static VALUE
test_l(obj, fname)
VALUE obj, fname;

.truncate(file_name, integer) ⇒ 0

Truncates the file file_name to be at most integer bytes long. Not available on all platforms.

f = File.new("out", "w")
f.write("1234567890")     #=> 10
f.close                   #=> nil
File.truncate("out", 5)   #=> 0
File.size("out")          #=> 5

Returns:

  • (0) 


3196
3197
3198
 
# File 'file.c', line 3196

static VALUE
rb_file_s_truncate(klass, path, len)
VALUE klass, path, len;

.umask ⇒ Integer .umask(integer) ⇒ Integer

Returns the current umask value for this process. If the optional argument is given, set the umask to that value and return the previous value. Umask values are subtracted from the default permissions, so a umask of 0222 would make a file read-only for everyone.

File.umask(0006)   #=> 18
File.umask         #=> 6

Overloads:



2285
2286
2287
 
# File 'file.c', line 2285

static VALUE
rb_file_s_umask(argc, argv)
int argc;

.delete(file_name, ...) ⇒ Integer .unlink(file_name, ...) ⇒ Integer

Deletes the named files, returning the number of names passed as arguments. Raises an exception on any error. See also Dir::rmdir.

Overloads:



2217
2218
2219
 
# File 'file.c', line 2217

static VALUE
rb_file_s_unlink(klass, args)
VALUE klass, args;

.utime ⇒ Object 



2052
2053
2054
 
# File 'file.c', line 2052

static VALUE
rb_file_s_utime(argc, argv)
int argc;

.writable?(file_name) ⇒ Boolean

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

Returns:

  • (Boolean) 


1168
1169
1170
 
# File 'file.c', line 1168

static VALUE
test_w(obj, fname)
VALUE obj, fname;

.writable_real?(file_name) ⇒ Boolean

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

Returns:

  • (Boolean) 


1185
1186
1187
 
# File 'file.c', line 1185

static VALUE
test_W(obj, fname)
VALUE obj, fname;

.zero?(file_name) ⇒ Boolean

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

Returns:

  • (Boolean) 


1259
1260
1261
 
# File 'file.c', line 1259

static VALUE
test_z(obj, fname)
VALUE obj, fname;

Instance Method Details

#atime ⇒ Time

Returns the last access time (a Time object)

for <i>file</i>, or epoch if <i>file</i> has not been accessed.

  File.new("testfile").atime   #=> Wed Dec 31 18:00:00 CST 1969

Returns:



1597
1598
1599
 
# File 'file.c', line 1597

static VALUE
rb_file_atime(obj)
VALUE obj;

#chmod(mode_int) ⇒ 0

Changes permission bits on file to the bit pattern represented by mode_int. Actual effects are platform dependent; on Unix systems, see chmod(2) for details. Follows symbolic links. Also see File#lchmod.

f = File.new("out", "w");
f.chmod(0644)   #=> 0

Returns:

  • (0) 


1758
1759
1760
 
# File 'file.c', line 1758

static VALUE
rb_file_chmod(obj, vmode)
VALUE obj, vmode;

#chown(owner_int, group_int) ⇒ 0

Changes the owner and group of file to the given numeric owner and group id’s. Only a process with superuser privileges may change the owner of a file. The current owner of a file may change the file’s group to any group to which the owner belongs. A nil or -1 owner or group id is ignored. Follows symbolic links. See also File#lchown.

File.new("testfile").chown(502, 1000)

Returns:

  • (0) 


1902
1903
1904
 
# File 'file.c', line 1902

static VALUE
rb_file_chown(obj, owner, group)
VALUE obj, owner, group;

#ctime ⇒ Time

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

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

Returns:



1690
1691
1692
 
# File 'file.c', line 1690

static VALUE
rb_file_ctime(obj)
VALUE obj;

#flock ⇒ Object

Locks or unlocks a file according to locking_constant (a logical or of the values in the table below). Returns false if File::LOCK_NB is specified and the operation would otherwise have blocked. Not available on all platforms.

Locking constants (in class File):

LOCK_EX   | Exclusive lock. Only one process may hold an
          | exclusive lock for a given file at a time.
----------+------------------------------------------------
LOCK_NB   | Don't block when locking. May be combined
          | with other lock options using logical or.
----------+------------------------------------------------
LOCK_SH   | Shared lock. Multiple processes may each hold a
          | shared lock for a given file at the same time.
----------+------------------------------------------------
LOCK_UN   | Unlock.

Example:

File.new("testfile").flock(File::LOCK_UN)   #=> 0



3375
3376
3377
 
# File 'file.c', line 3375

static VALUE
rb_file_flock(obj, operation)
VALUE obj;

#lstat ⇒ Object

Same as IO#stat, but does not follow the last symbolic link. Instead, reports on the link itself.

File.symlink("testfile", "link2test")   #=> 0
File.stat("testfile").size              #=> 66
f = File.new("link2test")
f.lstat.size                            #=> 8
f.stat.size                             #=> 66



802
803
804
 
# File 'file.c', line 802

static VALUE
rb_file_lstat(obj)
VALUE obj;

#mtime ⇒ Time

Returns the modification time for file.

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

Returns:



1642
1643
1644
 
# File 'file.c', line 1642

static VALUE
rb_file_mtime(obj)
VALUE obj;

#path ⇒ Object

Returns the pathname used to create file as a string. Does not normalize the name.

File.new("testfile").path               #=> "testfile"
File.new("/tmp/../tmp/xxx", "w").path   #=> "/tmp/../tmp/xxx"



141
142
143
 
# File 'file.c', line 141

static VALUE
rb_file_path(obj)
VALUE obj;

#truncate(integer) ⇒ 0

Truncates file to at most integer bytes. The file must be opened for writing. Not available on all platforms.

f = File.new("out", "w")
f.syswrite("1234567890")   #=> 10
f.truncate(5)              #=> 0
f.close()                  #=> nil
File.size("out")           #=> 5

Returns:

  • (0) 


3250
3251
3252
 
# File 'file.c', line 3250

static VALUE
rb_file_truncate(obj, len)
VALUE obj, len;