Class: File
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))
Constants inherited from IO
IO::SEEK_CUR, IO::SEEK_END, IO::SEEK_SET
Class Method Summary collapse
-
.atime(file_name) ⇒ Time
Returns the last access time for the named file as a Time object).
-
.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. -
.chmod(mode_int, file_name, ...) ⇒ Integer
Changes permission bits on the named file(s) to the bit pattern represented by mode_int.
-
.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.
-
.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).
-
.delete ⇒ Object
Deletes the named files, returning the number of names passed as arguments.
-
.dirname(file_name) ⇒ Object
Returns all components of the filename given in file_name except the last one.
-
.expand_path(file_name[, dir_string]) ⇒ Object
Converts a pathname to an absolute pathname.
-
.extname(path) ⇒ String
Returns the extension (the portion of file name in path after the period).
-
.fnmatch ⇒ Object
Returns true if path matches against pattern The pattern is not a regular expression; instead it follows rules similar to shell filename globbing.
-
.fnmatch? ⇒ Object
Returns true if path matches against pattern The pattern is not a regular expression; instead it follows rules similar to shell filename globbing.
-
.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
". -
.join(string, ...) ⇒ Object
Returns a new string formed by joining the strings using
File::SEPARATOR
. -
.lchmod(mode_int, file_name, ...) ⇒ Integer
Equivalent to
File::chmod
, but does not follow symbolic links (so it will change the permissions associated with the link, not the file referenced by the link). -
.lchown(owner_int, group_int, file_name, ..) ⇒ Integer
Equivalent to
File::chown
, but does not follow symbolic links (so it will change the owner associated with the link, not the file referenced by the link). -
.link(old_name, new_name) ⇒ 0
Creates a new name for an existing file using a hard link.
-
.lstat(file_name) ⇒ Object
Same as
File::stat
, but does not follow the last symbolic link. -
.mtime(file_name) ⇒ Time
Returns the modification time for the named file as a Time object.
-
.readlink(link_name) ⇒ Object
Returns the name of the file referenced by the given link.
-
.rename(old_name, new_name) ⇒ 0
Renames the given file to the new name.
-
.split(file_name) ⇒ Array
Splits the given string into a directory and a file component and returns them in a two-element array.
-
.stat(file_name) ⇒ Object
Returns a
File::Stat
object for the named file (seeFile::Stat
). -
.symlink(old_name, new_name) ⇒ 0
Creates a symbolic link called new_name for the existing file old_name.
-
.truncate(file_name, integer) ⇒ 0
Truncates the file file_name to be at most integer bytes long.
-
.umask ⇒ Object
Returns the current umask value for this process.
-
.unlink ⇒ Object
Deletes the named files, returning the number of names passed as arguments.
-
.utime(atime, mtime, file_name, ...) ⇒ Integer
Sets the access and modification times of each named file to the first two arguments.
Instance Method Summary collapse
-
#atime ⇒ Time
Returns the last access time (a
Time
object) for file, or epoch if file has not been accessed. -
#chmod(mode_int) ⇒ 0
Changes permission bits on file to the bit pattern represented by mode_int.
-
#chown(owner_int, group_int) ⇒ 0
Changes the owner and group of file to the given numeric owner and group id's.
-
#ctime ⇒ Time
Returns the change time for file (that is, the time directory information about the file was changed, not the file itself).
-
#flock ⇒ Object
Locks or unlocks a file according to locking_constant (a logical or of the values in the table below).
-
#initialize ⇒ Object
constructor
Opens the file named by filename according to mode (default is "r") and returns a new
File
object. -
#lstat ⇒ Object
Same as
IO#stat
, but does not follow the last symbolic link. -
#mtime ⇒ Time
Returns the modification time for file.
-
#path ⇒ Object
Returns the pathname used to create file as a string.
-
#truncate(integer) ⇒ 0
Truncates file to at most integer bytes.
Methods inherited from IO
#<<, #binmode, #close, #close_read, #close_write, #closed?, #each, #each_byte, #each_line, #eof, #eof?, #fcntl, #fileno, #flush, for_fd, foreach, #fsync, #getc, #gets, #initialize_copy, #inspect, #ioctl, #isatty, #lineno, #lineno=, new, open, #pid, pipe, popen, #pos, #pos=, #print, #printf, #putc, #puts, read, #read, #read_nonblock, #readchar, #readline, #readlines, readlines, #readpartial, #reopen, #rewind, #seek, select, #stat, #sync, #sync=, sysopen, #sysread, #sysseek, #syswrite, #tell, #to_io, #tty?, #ungetc, #write, #write_nonblock
Methods included from Enumerable
#all?, #any?, #collect, #detect, #each_with_index, #entries, #find, #find_all, #grep, #include?, #inject, #map, #max, #member?, #min, #partition, #reject, #select, #sort, #sort_by, #to_a, #zip
Constructor Details
#new(filename, mode = "r") ⇒ File #new(filename[, mode [, perm]]) ⇒ File
Opens the file named by filename according to mode (default is "r") and returns a new File
object. See the description of class IO
for a description of mode. The file mode may optionally be specified as a Fixnum
by or-ing together the flags (O_RDONLY etc, again described under IO
). Optional permission bits may be given in perm. These mode and permission bits are platform dependent; on Unix systems, see open(2)
for details.
f = File.new("testfile", "r")
f = File.new("newfile", "w+")
f = File.new("newfile", File::CREAT|File::TRUNC|File::RDWR, 0644)
|
# File 'io.c'
static VALUE
rb_file_initialize(argc, argv, io)
int argc;
VALUE *argv;
VALUE io;
{
if (RFILE(io)->fptr) {
rb_raise(rb_eRuntimeError, "reinitializing File");
}
|
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
|
# File 'file.c'
static VALUE
rb_file_s_atime(klass, fname)
VALUE klass, fname;
{
struct stat st;
if (rb_stat(fname, &st) < 0)
rb_sys_fail(StringValueCStr(fname));
return rb_time_new(st.st_atime, 0);
}
|
.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"
|
# File 'file.c'
static VALUE
rb_file_s_basename(argc, argv)
int argc;
VALUE *argv;
{
VALUE fname, fext, basename;
char *name, *p;
#if defined DOSISH_DRIVE_LETTER || defined DOSISH_UNC
char *root;
#endif
int f, n;
if (rb_scan_args(argc, argv, "11", &fname, &fext) == 2) {
StringValue(fext);
}
|
.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
|
# File 'file.c'
static VALUE
rb_file_s_chmod(argc, argv)
int argc;
VALUE *argv;
{
VALUE vmode;
VALUE rest;
int mode;
long n;
rb_secure(2);
rb_scan_args(argc, argv, "1*", &vmode, &rest);
mode = NUM2INT(vmode);
n = apply2files(chmod_internal, rest, &mode);
return LONG2FIX(n);
}
|
.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")
|
# File 'file.c'
static VALUE
rb_file_s_chown(argc, argv)
int argc;
VALUE *argv;
{
VALUE o, g, rest;
struct chown_args arg;
long n;
rb_secure(2);
rb_scan_args(argc, argv, "2*", &o, &g, &rest);
if (NIL_P(o)) {
arg.owner = -1;
}
|
.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
|
# File 'file.c'
static VALUE
rb_file_s_ctime(klass, fname)
VALUE klass, fname;
{
struct stat st;
if (rb_stat(fname, &st) < 0)
rb_sys_fail(RSTRING(fname)->ptr);
return rb_time_new(st.st_ctime, 0);
}
|
.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
.
|
# File 'file.c'
static VALUE
rb_file_s_unlink(klass, args)
VALUE klass, args;
{
long n;
rb_secure(2);
n = apply2files(unlink_internal, args, 0);
return LONG2FIX(n);
}
|
.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"
|
# File 'file.c'
static VALUE
rb_file_s_dirname(klass, fname)
VALUE klass, fname;
{
const char *name, *root, *p;
VALUE dirname;
name = StringValueCStr(fname);
root = skiproot(name);
#ifdef DOSISH_UNC
if (root > name + 1 && isdirsep(*name))
root = skipprefix(name = root - 2);
#else
if (root > name + 1)
name = root - 1;
#endif
p = strrdirsep(root);
if (!p) {
p = root;
}
|
.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"
|
# File 'file.c'
VALUE
rb_file_s_expand_path(argc, argv)
int argc;
VALUE *argv;
{
VALUE fname, dname;
if (argc == 1) {
return rb_file_expand_path(argv[0], Qnil);
}
|
.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") #=> ""
|
# File 'file.c'
static VALUE
rb_file_s_extname(klass, fname)
VALUE klass, fname;
{
const char *name, *p, *e;
VALUE extname;
name = StringValueCStr(fname);
p = strrdirsep(name); /* get the last path component */
if (!p)
p = name;
else
name = ++p;
e = 0;
while (*p) {
if (*p == '.' || istrailinggabage(*p)) {
#if USE_NTFS
const char *last = p++, *dot = last;
while (istrailinggabage(*p)) {
if (*p == '.') dot = p;
p++;
}
|
.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 withc
;*c
will match all files ending withc
; andc
will match all files that havec
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
|
# File 'dir.c'
static VALUE
file_s_fnmatch(argc, argv, obj)
int argc;
VALUE *argv;
VALUE obj;
{
VALUE pattern, path;
VALUE rflags;
int flags;
if (rb_scan_args(argc, argv, "21", &pattern, &path, &rflags) == 3)
flags = NUM2INT(rflags);
else
flags = 0;
StringValue(pattern);
StringValue(path);
if (fnmatch(RSTRING(pattern)->ptr, RSTRING(path)->ptr, flags) == 0)
return Qtrue;
return Qfalse;
}
|
.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 withc
;*c
will match all files ending withc
; andc
will match all files that havec
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
|
# File 'dir.c'
static VALUE
file_s_fnmatch(argc, argv, obj)
int argc;
VALUE *argv;
VALUE obj;
{
VALUE pattern, path;
VALUE rflags;
int flags;
if (rb_scan_args(argc, argv, "21", &pattern, &path, &rflags) == 3)
flags = NUM2INT(rflags);
else
flags = 0;
StringValue(pattern);
StringValue(path);
if (fnmatch(RSTRING(pattern)->ptr, RSTRING(path)->ptr, flags) == 0)
return Qtrue;
return Qfalse;
}
|
.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"
|
# File 'file.c'
static VALUE
rb_file_s_ftype(klass, fname)
VALUE klass, fname;
{
struct stat st;
SafeStringValue(fname);
if (lstat(StringValueCStr(fname), &st) == -1) {
rb_sys_fail(RSTRING(fname)->ptr);
}
|
.join(string, ...) ⇒ Object
Returns a new string formed by joining the strings using File::SEPARATOR
.
File.join("usr", "mail", "gumby") #=> "usr/mail/gumby"
|
# File 'file.c'
static VALUE
rb_file_s_join(klass, args)
VALUE klass, args;
{
return rb_file_join(args, separator);
}
|
.lchmod(mode_int, file_name, ...) ⇒ Integer
Equivalent to File::chmod
, but does not follow symbolic links (so it will change the permissions associated with the link, not the file referenced by the link). Often not available.
|
# File 'file.c'
static VALUE
rb_file_s_lchmod(argc, argv)
int argc;
VALUE *argv;
{
VALUE vmode;
VALUE rest;
long mode, n;
rb_secure(2);
rb_scan_args(argc, argv, "1*", &vmode, &rest);
mode = NUM2INT(vmode);
n = apply2files(lchmod_internal, rest, (void *)(long)mode);
return LONG2FIX(n);
}
|
.lchown(owner_int, group_int, file_name, ..) ⇒ Integer
Equivalent to File::chown
, but does not follow symbolic links (so it will change the owner associated with the link, not the file referenced by the link). Often not available. Returns number of files in the argument list.
|
# File 'file.c'
static VALUE
rb_file_s_lchown(argc, argv)
int argc;
VALUE *argv;
{
VALUE o, g, rest;
struct chown_args arg;
long n;
rb_secure(2);
rb_scan_args(argc, argv, "2*", &o, &g, &rest);
if (NIL_P(o)) {
arg.owner = -1;
}
|
.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"
|
# File 'file.c'
static VALUE
rb_file_s_link(klass, from, to)
VALUE klass, from, to;
{
#ifdef HAVE_LINK
SafeStringValue(from);
SafeStringValue(to);
if (link(StringValueCStr(from), StringValueCStr(to)) < 0) {
sys_fail2(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
|
# File 'file.c'
static VALUE
rb_file_s_lstat(klass, fname)
VALUE klass, fname;
{
#ifdef HAVE_LSTAT
struct stat st;
SafeStringValue(fname);
if (lstat(StringValueCStr(fname), &st) == -1) {
rb_sys_fail(RSTRING(fname)->ptr);
}
|
.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
|
# File 'file.c'
static VALUE
rb_file_s_mtime(klass, fname)
VALUE klass, fname;
{
struct stat st;
if (rb_stat(fname, &st) < 0)
rb_sys_fail(RSTRING(fname)->ptr);
return rb_time_new(st.st_mtime, 0);
}
|
.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"
|
# File 'file.c'
static VALUE
rb_file_s_readlink(klass, path)
VALUE klass, path;
{
#ifdef HAVE_READLINK
char *buf;
int size = 100;
int rv;
VALUE v;
SafeStringValue(path);
buf = xmalloc(size);
while ((rv = readlink(RSTRING(path)->ptr, buf, size)) == size
#ifdef _AIX
|| (rv < 0 && errno == ERANGE) /* quirky behavior of GPFS */
#endif
) {
size *= 2;
buf = xrealloc(buf, size);
}
|
.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
|
# File 'file.c'
static VALUE
rb_file_s_rename(klass, from, to)
VALUE klass, from, to;
{
const char *src, *dst;
SafeStringValue(from);
SafeStringValue(to);
src = StringValueCStr(from);
dst = StringValueCStr(to);
#if defined __CYGWIN__
errno = 0;
#endif
if (rename(src, dst) < 0) {
#if defined DOSISH && !defined _WIN32
switch (errno) {
case EEXIST:
#if defined (__EMX__)
case EACCES:
#endif
if (chmod(dst, 0666) == 0 &&
unlink(dst) == 0 &&
rename(src, dst) == 0)
return INT2FIX(0);
}
|
.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"]
|
# File 'file.c'
static VALUE
rb_file_s_split(klass, path)
VALUE klass, path;
{
StringValue(path); /* get rid of converting twice */
return rb_assoc_new(rb_file_s_dirname(Qnil, path), rb_file_s_basename(1,&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
|
# File 'file.c'
static VALUE
rb_file_s_stat(klass, fname)
VALUE klass, fname;
{
struct stat st;
SafeStringValue(fname);
if (rb_stat(fname, &st) < 0) {
rb_sys_fail(StringValueCStr(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
|
# File 'file.c'
static VALUE
rb_file_s_symlink(klass, from, to)
VALUE klass, from, to;
{
#ifdef HAVE_SYMLINK
SafeStringValue(from);
SafeStringValue(to);
if (symlink(StringValueCStr(from), StringValueCStr(to)) < 0) {
sys_fail2(from, to);
}
|
.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
|
# File 'file.c'
static VALUE
rb_file_s_truncate(klass, path, len)
VALUE klass, path, len;
{
off_t pos;
rb_secure(2);
pos = NUM2OFFT(len);
SafeStringValue(path);
#ifdef HAVE_TRUNCATE
if (truncate(StringValueCStr(path), pos) < 0)
rb_sys_fail(RSTRING(path)->ptr);
#else
# ifdef HAVE_CHSIZE
{
int tmpfd;
# ifdef _WIN32
if ((tmpfd = open(StringValueCStr(path), O_RDWR)) < 0) {
rb_sys_fail(RSTRING(path)->ptr);
}
|
.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
|
# File 'file.c'
static VALUE
rb_file_s_umask(argc, argv)
int argc;
VALUE *argv;
{
int omask = 0;
rb_secure(2);
if (argc == 0) {
omask = umask(0);
umask(omask);
}
|
.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
.
|
# File 'file.c'
static VALUE
rb_file_s_unlink(klass, args)
VALUE klass, args;
{
long n;
rb_secure(2);
n = apply2files(unlink_internal, args, 0);
return LONG2FIX(n);
}
|
.utime(atime, mtime, file_name, ...) ⇒ Integer
Sets the access and modification times of each named file to the first two arguments. Returns the number of file names in the argument list.
|
# File 'file.c'
static VALUE
rb_file_s_utime(argc, argv)
int argc;
VALUE *argv;
{
VALUE atime, mtime, rest;
struct timeval tvs[2], *tvp = NULL;
long n;
rb_scan_args(argc, argv, "2*", &atime, &mtime, &rest);
if (!NIL_P(atime) || !NIL_P(mtime)) {
tvp = tvs;
tvp[0] = rb_time_timeval(atime);
tvp[1] = rb_time_timeval(mtime);
}
|
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
|
# File 'file.c'
static VALUE
rb_file_atime(obj)
VALUE obj;
{
OpenFile *fptr;
struct stat st;
GetOpenFile(obj, fptr);
if (fstat(fileno(fptr->f), &st) == -1) {
rb_sys_fail(fptr->path);
}
|
#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
|
# File 'file.c'
static VALUE
rb_file_chmod(obj, vmode)
VALUE obj, vmode;
{
OpenFile *fptr;
int mode;
rb_secure(2);
mode = NUM2INT(vmode);
GetOpenFile(obj, fptr);
#ifdef HAVE_FCHMOD
if (fchmod(fileno(fptr->f), mode) == -1)
rb_sys_fail(fptr->path);
#else
if (!fptr->path) return Qnil;
if (chmod(fptr->path, mode) == -1)
rb_sys_fail(fptr->path);
#endif
return INT2FIX(0);
}
|
#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)
|
# File 'file.c'
static VALUE
rb_file_chown(obj, owner, group)
VALUE obj, owner, group;
{
OpenFile *fptr;
int o, g;
rb_secure(2);
o = NIL_P(owner) ? -1 : NUM2INT(owner);
g = NIL_P(group) ? -1 : NUM2INT(group);
GetOpenFile(obj, fptr);
#if defined(DJGPP) || defined(__CYGWIN32__) || defined(_WIN32) || defined(__EMX__)
if (!fptr->path) return Qnil;
if (chown(fptr->path, o, g) == -1)
rb_sys_fail(fptr->path);
#else
if (fchown(fileno(fptr->f), o, g) == -1)
rb_sys_fail(fptr->path);
#endif
return INT2FIX(0);
}
|
#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
|
# File 'file.c'
static VALUE
rb_file_ctime(obj)
VALUE obj;
{
OpenFile *fptr;
struct stat st;
GetOpenFile(obj, fptr);
if (fstat(fileno(fptr->f), &st) == -1) {
rb_sys_fail(fptr->path);
}
|
#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
|
# File 'file.c'
static VALUE
rb_file_flock(obj, operation)
VALUE obj;
VALUE operation;
{
#ifndef __CHECKER__
OpenFile *fptr;
int op;
rb_secure(2);
op = NUM2INT(operation);
GetOpenFile(obj, fptr);
if (fptr->mode & FMODE_WRITABLE) {
fflush(GetWriteFile(fptr));
}
|
#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
|
# File 'file.c'
static VALUE
rb_file_lstat(obj)
VALUE obj;
{
#ifdef HAVE_LSTAT
OpenFile *fptr;
struct stat st;
rb_secure(2);
GetOpenFile(obj, fptr);
if (!fptr->path) return Qnil;
if (lstat(fptr->path, &st) == -1) {
rb_sys_fail(fptr->path);
}
|
#mtime ⇒ Time
Returns the modification time for file.
File.new("testfile").mtime #=> Wed Apr 09 08:53:14 CDT 2003
|
# File 'file.c'
static VALUE
rb_file_mtime(obj)
VALUE obj;
{
OpenFile *fptr;
struct stat st;
GetOpenFile(obj, fptr);
if (fstat(fileno(fptr->f), &st) == -1) {
rb_sys_fail(fptr->path);
}
|
#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"
|
# File 'file.c'
static VALUE
rb_file_path(obj)
VALUE obj;
{
OpenFile *fptr;
fptr = RFILE(rb_io_taint_check(obj))->fptr;
rb_io_check_initialized(fptr);
if (!fptr->path) return Qnil;
return rb_tainted_str_new2(fptr->path);
}
|
#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
|
# File 'file.c'
static VALUE
rb_file_truncate(obj, len)
VALUE obj, len;
{
OpenFile *fptr;
FILE *f;
off_t pos;
rb_secure(2);
pos = NUM2OFFT(len);
GetOpenFile(obj, fptr);
if (!(fptr->mode & FMODE_WRITABLE)) {
rb_raise(rb_eIOError, "not opened for writing");
}
|