класс File

static VALUE
s_absolute_path(int c, const VALUE * v, VALUE _)
{
    return rb_file_s_absolute_path(c, v);
}

Преобразует имя пути в абсолютное имя пути. Относительные пути указываются относительно текущего рабочего каталога процесса, если не указана dir_string, в этом случае она будет использоваться в качестве начальной точки. Если заданное имя пути начинается с “~”, оно НЕ раскрывается, а рассматривается как обычное имя каталога.

File.absolute_path("~oracle/bin")       #=> "<relative_path>/~oracle/bin"

static VALUE
s_absolute_path_p(VALUE klass, VALUE fname)
{
    VALUE path = rb_get_path(fname);

    if (!rb_is_absolute_path(RSTRING_PTR(path))) return Qfalse;
    return Qtrue;
}

Возвращает true если file_name является абсолютным путем, и false в противном случае.

File.absolute_path?("c:/foo")     #=> false (on Linux), true (on Windows)

static VALUE
rb_file_s_atime(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 stat_atime(&st);
}

Возвращает время последнего доступа к указанному файлу в виде объекта Time.

file_name может быть объектом IO.

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

static VALUE
rb_file_s_basename(int argc, VALUE *argv, VALUE _)
{
    VALUE fname, fext, basename;
    const char *name, *p;
    long f, n;
    rb_encoding *enc;

    fext = Qnil;
    if (rb_check_arity(argc, 1, 2) == 2) {
        fext = argv[1];
        StringValue(fext);
        enc = check_path_encoding(fext);
    }
    fname = argv[0];
    FilePathStringValue(fname);
    if (NIL_P(fext) || !(enc = rb_enc_compatible(fname, fext))) {
        enc = rb_enc_get(fname);
        fext = Qnil;
    }
    if ((n = RSTRING_LEN(fname)) == 0 || !*(name = RSTRING_PTR(fname)))
        return rb_str_new_shared(fname);

    p = ruby_enc_find_basename(name, &f, &n, enc);
    if (n >= 0) {
        if (NIL_P(fext)) {
            f = n;
        }
        else {
            const char *fp;
            fp = StringValueCStr(fext);
            if (!(f = rmext(p, f, n, fp, RSTRING_LEN(fext), enc))) {
                f = n;
            }
            RB_GC_GUARD(fext);
        }
        if (f == RSTRING_LEN(fname)) return rb_str_new_shared(fname);
    }

    basename = rb_str_new(p, f);
    rb_enc_copy(basename, fname);
    return basename;
}

Возвращает последний компонент имени файла, указанного в file_name (после предварительного удаления конечных разделителей), который может быть сформирован с использованием как File::SEPARATOR, так и File::ALT_SEPARATOR в качестве разделителя, когда File::ALT_SEPARATOR не nil. Если suffix задан и присутствует в конце file_name, он удаляется. Если suffix — это “.*”, любое расширение будет удалено.

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

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;
}

Возвращает true если указанный файл является блочным устройством.

file_name может быть объектом IO.

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;
}

Возвращает true если указанный файл является символьным устройством.

file_name может быть объектом IO.

static VALUE
rb_file_s_chmod(int argc, VALUE *argv, VALUE _)
{
    mode_t mode;

    apply2args(1);
    mode = NUM2MODET(*argv++);

    return apply2files(chmod_internal, argc, argv, &mode);
}

Изменяет биты разрешений в указанных файлах на битовую маску, представленную mode_int. Фактические эффекты зависят от операционной системы (см. начало этого раздела). В Unix-системах, см. chmod(2) для подробностей. Возвращает количество обработанных файлов.

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

static VALUE
rb_file_s_chown(int argc, VALUE *argv, VALUE _)
{
    struct chown_args arg;

    apply2args(2);
    arg.owner = to_uid(*argv++);
    arg.group = to_gid(*argv++);

    return apply2files(chown_internal, argc, argv, &arg);
}

Изменяет владельца и группу указанных файлов на заданные числовые идентификаторы владельца и группы. Только процесс с правами суперпользователя может изменить владельца файла. Текущий владелец файла может изменить группу файла на любую группу, к которой принадлежит владелец. nil или -1 идентификатор владельца или группы игнорируется. Возвращает количество обработанных файлов.

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

static VALUE
rb_file_s_ctime(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 stat_ctime(&st);
}

Возвращает время изменения для указанного файла (время, когда изменилась информация о каталоге файла, а не сам файл).

file_name может быть объектом IO.

Обратите внимание, что в Windows (NTFS) возвращает время создания (время рождения).

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

static VALUE
rb_file_s_unlink(int argc, VALUE *argv, VALUE klass)
{
    return apply2files(unlink_internal, argc, argv, 0);
}

Удаляет указанные файлы, возвращая количество имен, переданных в качестве аргументов. Вызывает исключение при любой ошибке. Поскольку базовая реализация основана на системном вызове unlink(2), тип вызываемого исключения зависит от его типа ошибки (см. linux.die.net/man/2/unlink) и имеет вид, например, Errno::ENOENT.

См. также Dir::rmdir.

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;
}

Возвращает true если указанный файл является каталогом или символической ссылкой, указывающей на каталог, и false в противном случае.

file_name может быть объектом IO.

File.directory?(".")

static VALUE
rb_file_s_dirname(VALUE klass, VALUE fname)
{
    return rb_file_dirname(fname);
}

Возвращает все компоненты имени файла, указанного в file_name, за исключением последнего (после предварительного удаления конечных разделителей). Имя файла может быть сформировано с использованием как File::SEPARATOR, так и File::ALT_SEPARATOR в качестве разделителя, когда File::ALT_SEPARATOR не nil.

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

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;
}

Возвращает true если указанный файл существует и имеет нулевой размер.

file_name может быть объектом IO.

static VALUE
rb_file_executable_p(VALUE obj, VALUE fname)
{
    if (rb_eaccess(fname, X_OK) < 0) return Qfalse;
    return Qtrue;
}

Возвращает true если указанный файл выполним для эффективного идентификатора пользователя и группы этого процесса. См. eaccess(3).

Windows не поддерживает разрешения на выполнение отдельно от разрешений на чтение. В Windows файл считается исполняемым, только если он заканчивается на .bat, .cmd, .com или .exe.

Обратите внимание, что некоторые функции безопасности на уровне ОС могут привести к возврату true, даже если файл не выполним для эффективного пользователя/группы.

static VALUE
rb_file_executable_real_p(VALUE obj, VALUE fname)
{
    if (rb_access(fname, X_OK) < 0) return Qfalse;
    return Qtrue;
}

Возвращает true если указанный файл выполним для реального идентификатора пользователя и группы этого процесса. См. access(3).

Windows не поддерживает разрешения на выполнение отдельно от разрешений на чтение. В Windows файл считается исполняемым, только если он заканчивается на .bat, .cmd, .com или .exe.

Обратите внимание, что некоторые функции безопасности на уровне ОС могут привести к возврату true, даже если файл не выполним для реального пользователя/группы.

static VALUE
rb_file_exist_p(VALUE obj, VALUE fname)
{
    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qfalse;
    return Qtrue;
}

Возвращает true если указанный файл существует.

file_name может быть объектом IO.

«Файл существует» означает, что системный вызов stat() или fstat() выполнен успешно.

static VALUE
s_expand_path(int c, const VALUE * v, VALUE _)
{
    return rb_file_s_expand_path(c, v);
}

Преобразует имя пути в абсолютный путь. Относительные пути ссылаются на текущий рабочий каталог процесса, если dir_string не указан, в противном случае он будет использован в качестве начальной точки. Указанное имя пути может начинаться с «~», которое расширяется до домашнего каталога владельца процесса (переменная среды HOME должна быть правильно установлена). «~user» расширяется до домашнего каталога указанного пользователя.

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

Простой пример использования dir_string:

File.expand_path("ruby", "/usr/bin")      #=> "/usr/bin/ruby"

Более сложный пример, который также разрешает родительский каталог: предположим, что мы находимся в bin/mygem и хотим получить абсолютный путь к lib/mygem.rb.

File.expand_path("../../lib/mygem.rb", __FILE__)
#=> ".../path/to/project/lib/mygem.rb"

Итак, сначала он разрешает родительский каталог __FILE__, то есть bin/, затем переходит к родительскому каталогу, корню проекта и добавляет lib/mygem.rb.

static VALUE
rb_file_s_extname(VALUE klass, VALUE fname)
{
    const char *name, *e;
    long len;
    VALUE extname;

    FilePathStringValue(fname);
    name = StringValueCStr(fname);
    len = RSTRING_LEN(fname);
    e = ruby_enc_find_extname(name, &len, rb_enc_get(fname));
    if (len < 1)
        return rb_str_new(0, 0);
    extname = rb_str_subseq(fname, e - name, len); /* keep the dot, too! */
    return extname;
}

Возвращает расширение (часть имени файла в path, начиная с последней точки).

Если path является файлом с точкой или начинается с точки, то начальная точка не обрабатывается как начало расширения.

Также возвращается пустая строка, если точка является последним символом в path.

В Windows, завершающие точки усекаются.

File.extname("test.rb")         #=> ".rb"
File.extname("a/b/d/test.rb")   #=> ".rb"
File.extname(".a/b/d/test.rb")  #=> ".rb"
File.extname("foo.")            #=> "" on Windows
File.extname("foo.")            #=> "." on non-Windows
File.extname("test")            #=> ""
File.extname(".profile")        #=> ""
File.extname(".profile.sh")     #=> ".sh"

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;
}

Возвращает true, если указанный file существует и является обычным файлом.

file может быть объектом IO.

Если аргумент file является символьной ссылкой, он будет разрешать символьные ссылки и использовать файл, на который указывает ссылка.

static VALUE
file_s_fnmatch(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;

    StringValueCStr(pattern);
    FilePathStringValue(path);

    if (flags & FNM_EXTGLOB) {
        struct brace_args args;

        args.value = path;
        args.flags = flags;
        if (ruby_brace_expand(RSTRING_PTR(pattern), flags, fnmatch_brace,
                              (VALUE)&args, rb_enc_get(pattern), pattern) > 0)
            return Qtrue;
    }
    else {
        rb_encoding *enc = rb_enc_compatible(pattern, path);
        if (!enc) return Qfalse;
        if (fnmatch(RSTRING_PTR(pattern), enc, RSTRING_PTR(path), flags) == 0)
            return Qtrue;
    }
    RB_GC_GUARD(pattern);

    return Qfalse;
}

Возвращает true, если path соответствует pattern. Шаблон не является регулярным выражением; вместо этого он следует правилам, аналогичным оболочке shell для подстановок имен файлов. Он может содержать следующие метасимволы:

*

Соответствует любому файлу. Может быть ограничен другими значениями в шаблоне. Эквивалентно / .* /x в регулярных выражениях.

*

Соответствует всем обычным файлам

c*

Соответствует всем файлам, начинающимся с c

*c

Соответствует всем файлам, заканчивающимся на c

*c*

Соответствует всем файлам, содержащим c (включая начало или конец).

Чтобы сопоставить скрытые файлы (начинающиеся с .), установите флаг File::FNM_DOTMATCH.

**

Соответствует каталогам рекурсивно или файлам расширенно.

?

Соответствует любому символу. Эквивалентно /.{1}/ в регулярных выражениях.

[set]

Соответствует любому символу в set. Ведет себя точно так же, как множества символов в Regexp, включая отрицание множества ([^a-z]).

\

Экранирует следующий метасимвол.

{a,b}

Соответствует шаблону a и шаблону b, если установлен флаг File::FNM_EXTGLOB. Ведёт себя как объединение Regexp ((?:a|b)).

flags является битовым ИЛИ констант FNM_XXX. Тот же шаблон подстановки и флаги используются 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 by default
File.fnmatch('c{at,ub}s', 'cats', File::FNM_EXTGLOB) #=> true  # { } is supported on FNM_EXTGLOB

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('cat', 'CAT', File::FNM_SYSCASE)  #=> true or false # depends on the system default

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_NOESCAPE 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

static VALUE
file_s_fnmatch(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;

    StringValueCStr(pattern);
    FilePathStringValue(path);

    if (flags & FNM_EXTGLOB) {
        struct brace_args args;

        args.value = path;
        args.flags = flags;
        if (ruby_brace_expand(RSTRING_PTR(pattern), flags, fnmatch_brace,
                              (VALUE)&args, rb_enc_get(pattern), pattern) > 0)
            return Qtrue;
    }
    else {
        rb_encoding *enc = rb_enc_compatible(pattern, path);
        if (!enc) return Qfalse;
        if (fnmatch(RSTRING_PTR(pattern), enc, RSTRING_PTR(path), flags) == 0)
            return Qtrue;
    }
    RB_GC_GUARD(pattern);

    return Qfalse;
}

Возвращает true, если path соответствует pattern. Шаблон не является регулярным выражением; вместо этого он следует правилам, аналогичным оболочке shell для подстановок имен файлов. Он может содержать следующие метасимволы:

*

Соответствует любому файлу. Может быть ограничен другими значениями в шаблоне. Эквивалентно / .* /x в регулярных выражениях.

*

Соответствует всем обычным файлам

c*

Соответствует всем файлам, начинающимся с c

*c

Соответствует всем файлам, заканчивающимся на c

*c*

Соответствует всем файлам, содержащим c (включая начало или конец).

Чтобы сопоставить скрытые файлы (начинающиеся с .), установите флаг File::FNM_DOTMATCH.

**

Соответствует каталогам рекурсивно или файлам расширенно.

?

Соответствует любому символу. Эквивалентно /.{1}/ в регулярных выражениях.

[set]

Соответствует любому символу в set. Ведет себя точно так же, как множества символов в Regexp, включая отрицание множества ([^a-z]).

\

Экранирует следующий метасимвол.

{a,b}

Соответствует шаблону a и шаблону b, если установлен флаг File::FNM_EXTGLOB. Ведёт себя как объединение Regexp ((?:a|b)).

flags является битовым ИЛИ констант FNM_XXX. Тот же шаблон подстановки и флаги используются 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 by default
File.fnmatch('c{at,ub}s', 'cats', File::FNM_EXTGLOB) #=> true  # { } is supported on FNM_EXTGLOB

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('cat', 'CAT', File::FNM_SYSCASE)  #=> true or false # depends on the system default

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_NOESCAPE 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

static VALUE
rb_file_s_ftype(VALUE klass, VALUE fname)
{
    struct stat st;

    FilePathValue(fname);
    fname = rb_str_encode_ospath(fname);
    if (lstat_without_gvl(StringValueCStr(fname), &st) == -1) {
        rb_sys_fail_path(fname);
    }

    return rb_file_ftype(&st);
}

Определяет тип указанного файла; возвращаемая строка — одна из «file», «directory», «characterSpecial», «blockSpecial», «fifo», «link», «socket» или «unknown».

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

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;
}

Возвращает true, если указанный файл существует и эффективной группой идентификатора вызывающего процесса является владелец файла. Возвращает false в Windows.

file_name может быть объектом IO.

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
    extern VALUE rb_w32_file_identical_p(VALUE, VALUE);
    return rb_w32_file_identical_p(fname1, fname2);
#endif
}

Возвращает true, если указанные файлы идентичны.

file_1 и file_2 могут быть объектами IO.

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_s_join(VALUE klass, VALUE args)
{
    return rb_file_join(args);
}

Возвращает новую строку, образованную путём объединения строк с использованием "/".

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

static VALUE
rb_file_s_lchmod(int argc, VALUE *argv, VALUE _)
{
    mode_t mode;

    apply2args(1);
    mode = NUM2MODET(*argv++);

    return apply2files(lchmod_internal, argc, argv, &mode);
}

Эквивалентно File::chmod, но не следует за символичными ссылками (поэтому меняет разрешения, связанные со ссылкой, а не с файлом, на который ссылается ссылка). Часто недоступно.

static VALUE
rb_file_s_lchown(int argc, VALUE *argv, VALUE _)
{
    struct chown_args arg;

    apply2args(2);
    arg.owner = to_uid(*argv++);
    arg.group = to_gid(*argv++);

    return apply2files(lchown_internal, argc, argv, &arg);
}

Эквивалентно File::chown, но не следует за символичными ссылками (поэтому изменяет владельца, связанного со ссылкой, а не файл, на который ссылается ссылка). Часто недоступно. Возвращает количество файлов в списке аргументов.

static VALUE
rb_file_s_link(VALUE klass, VALUE from, VALUE to)
{
    FilePathValue(from);
    FilePathValue(to);
    from = rb_str_encode_ospath(from);
    to = rb_str_encode_ospath(to);

    if (link(StringValueCStr(from), StringValueCStr(to)) < 0) {
        sys_fail2(from, to);
    }
    return INT2FIX(0);
}

Создаёт новое имя для существующего файла с помощью жёсткой ссылки. Не перезапишет new_name, если оно уже существует (вызовет исключение, являющееся подклассом SystemCallError). Не доступно на всех платформах.

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

static VALUE
rb_file_s_lstat(VALUE klass, VALUE fname)
{
#ifdef HAVE_LSTAT
    struct stat st;

    FilePathValue(fname);
    fname = rb_str_encode_ospath(fname);
    if (lstat_without_gvl(StringValueCStr(fname), &st) == -1) {
        rb_sys_fail_path(fname);
    }
    return rb_stat_new(&st);
#else
    return rb_file_s_stat(klass, fname);
#endif
}

Аналогично File::stat, но не следует за последней символической ссылкой. Вместо этого сообщает о самой ссылке.

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

static VALUE
rb_file_s_lutime(int argc, VALUE *argv, VALUE _)
{
    return utime_internal_i(argc, argv, TRUE);
}

Устанавливает время доступа и изменения каждого указанного файла на первые два аргумента. Если файл является символической ссылкой, этот метод действует на саму ссылку, а не на её целевой объект; для обратного поведения см. File.utime. Возвращает количество имён файлов в списке аргументов.

static VALUE
rb_file_s_mkfifo(int argc, VALUE *argv, VALUE _)
{
    VALUE path;
    struct mkfifo_arg ma;

    ma.mode = 0666;
    rb_check_arity(argc, 1, 2);
    if (argc > 1) {
        ma.mode = NUM2MODET(argv[1]);
    }
    path = argv[0];
    FilePathValue(path);
    path = rb_str_encode_ospath(path);
    ma.path = RSTRING_PTR(path);
    if (rb_thread_call_without_gvl(nogvl_mkfifo, &ma, RUBY_UBF_IO, 0)) {
        rb_sys_fail_path(path);
    }
    return INT2FIX(0);
}

Создаёт специальный файл FIFO с именем file_name. mode задаёт разрешения FIFO. Он модифицируется маской процесса обычным образом: разрешения создаваемого файла равны (mode & ~umask).

static VALUE
rb_file_s_mtime(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 stat_mtime(&st);
}

Возвращает время изменения указанного файла в виде объекта Time.

file_name может быть объектом IO.

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

static VALUE
rb_file_initialize(int argc, VALUE *argv, VALUE io)
{
    if (RFILE(io)->fptr) {
        rb_raise(rb_eRuntimeError, "reinitializing File");
    }
    if (0 < argc && argc < 3) {
        VALUE fd = rb_check_to_int(argv[0]);

        if (!NIL_P(fd)) {
            argv[0] = fd;
            return rb_io_initialize(argc, argv, io);
        }
    }
    rb_open_file(argc, argv, io);

    return io;
}

Открывает файл, указанный по имени filename, согласно заданным mode, и возвращает новый объект File.

См. IO.new для описания mode и opt.

Если файл создаётся, биты разрешений могут быть заданы в perm. Эти биты режима и разрешений зависят от платформы; на системах Unix см. страницы руководства open(2) и chmod(2) для получения подробностей.

Новый объект File буферизован (или несинхронизирован), если filename не является tty. См. IO#flush, IO#fsync, IO#fdatasync и IO#sync= для информации о режиме синхронизации.

Примеры

f = File.new("testfile", "r")
f = File.new("newfile",  "w+")
f = File.new("newfile", File::CREAT|File::TRUNC|File::RDWR, 0644)

static VALUE
rb_io_s_open(int argc, VALUE *argv, VALUE klass)
{
    VALUE io = rb_class_new_instance_kw(argc, argv, klass, RB_PASS_CALLED_KEYWORDS);

    if (rb_block_given_p()) {
        return rb_ensure(rb_yield, io, io_close, io);
    }

    return io;
}

Без связанного блока File.open — это синоним для File.new. Если задан необязательный код блока, он будет передан открытому file в качестве аргумента, и объект File автоматически закроется по завершении блока. Значение блока будет возвращено из File.open.

Если файл создаётся, его начальные разрешения могут быть установлены с помощью параметра perm. См. File.new для получения дополнительной информации.

См. IO.new для описания параметров mode и opt.

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;
}

Возвращает true, если указанный файл существует и эффективный идентификатор пользователя вызывающего процесса является владельцем файла.

file_name может быть объектом IO.

static VALUE
rb_file_s_path(VALUE klass, VALUE fname)
{
    return rb_get_path(fname);
}

Возвращает строковое представление пути

File.path("/dev/null")          #=> "/dev/null"
File.path(Pathname.new("/tmp")) #=> "/tmp"

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;
}

Возвращает true, если указанный файл является FIFO.

file_name может быть объектом IO.

static VALUE
rb_file_readable_p(VALUE obj, VALUE fname)
{
    if (rb_eaccess(fname, R_OK) < 0) return Qfalse;
    return Qtrue;
}

Возвращает true если указанный файл читаем для эффективного пользователя и группы данного процесса. См. eaccess(3).

Обратите внимание, что некоторые функции безопасности на уровне операционной системы могут привести к возвращению true, даже если файл не читаем для эффективного пользователя/группы.

static VALUE
rb_file_readable_real_p(VALUE obj, VALUE fname)
{
    if (rb_access(fname, R_OK) < 0) return Qfalse;
    return Qtrue;
}

Возвращает true если указанный файл читаем для реального пользователя и группы данного процесса. См. access(3).

Обратите внимание, что некоторые функции безопасности на уровне операционной системы могут привести к возвращению true, даже если файл не читаем для реального пользователя/группы.

static VALUE
rb_file_s_readlink(VALUE klass, VALUE path)
{
    return rb_readlink(path, rb_filesystem_encoding());
}

Возвращает имя файла, на который ссылается данная ссылка. Не доступно на всех платформах.

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

static VALUE
rb_file_s_realdirpath(int argc, VALUE *argv, VALUE klass)
{
    VALUE basedir = (rb_check_arity(argc, 1, 2) > 1) ? argv[1] : Qnil;
    VALUE path = argv[0];
    FilePathValue(path);
    return rb_realpath_internal(basedir, path, 0);
}

Возвращает реальный (абсолютный) путь к pathname в файловой системе. Реальный путь не содержит символических ссылок или бесполезных точек.

Если dir_string задан, он используется в качестве базового каталога для интерпретации относительного пути вместо текущего каталога.

Последний компонент реального пути может быть несуществующим.

static VALUE
rb_file_s_realpath(int argc, VALUE *argv, VALUE klass)
{
    VALUE basedir = (rb_check_arity(argc, 1, 2) > 1) ? argv[1] : Qnil;
    VALUE path = argv[0];
    FilePathValue(path);
    return rb_realpath_internal(basedir, path, 1);
}

Возвращает реальный (абсолютный) путь к pathname в файловой системе, не содержащий символических ссылок или бесполезных точек.

Если dir_string задан, он используется в качестве базового каталога для интерпретации относительного пути вместо текущего каталога.

Все компоненты пути должны существовать при вызове этого метода.

static VALUE
rb_file_s_rename(VALUE klass, VALUE from, VALUE to)
{
    struct rename_args ra;
    VALUE f, t;

    FilePathValue(from);
    FilePathValue(to);
    f = rb_str_encode_ospath(from);
    t = rb_str_encode_ospath(to);
    ra.src = StringValueCStr(f);
    ra.dst = StringValueCStr(t);
#if defined __CYGWIN__
    errno = 0;
#endif
    if ((int)(VALUE)rb_thread_call_without_gvl(no_gvl_rename, &ra,
                                         RUBY_UBF_IO, 0) < 0) {
        int e = errno;
#if defined DOSISH
        switch (e) {
          case EEXIST:
            if (chmod(ra.dst, 0666) == 0 &&
                unlink(ra.dst) == 0 &&
                rename(ra.src, ra.dst) == 0)
                return INT2FIX(0);
        }
#endif
        syserr_fail2(e, from, to);
    }

    return INT2FIX(0);
}

Переименовывает данный файл в новое имя. Вызовет SystemCallError, если файл нельзя переименовать.

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

static VALUE
rb_file_sgid_p(VALUE obj, VALUE fname)
{
#ifdef S_ISGID
    return check3rdbyte(fname, S_ISGID);
#else
    return Qfalse;
#endif
}

Возвращает true если у указанного файла установлен бит setgid.

file_name может быть объектом IO.

static VALUE
rb_file_suid_p(VALUE obj, VALUE fname)
{
#ifdef S_ISUID
    return check3rdbyte(fname, S_ISUID);
#else
    return Qfalse;
#endif
}

Возвращает true, если в указанном файле установлен бит setuid.

file_name может быть объектом IO.

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);
}

Возвращает размер file_name.

file_name может быть объектом IO.

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);
}

Возвращает размер файла, если он существует и имеет ненулевой размер; в противном случае возвращает nil.

file_name может быть объектом IO.

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;
}

Возвращает true, если указанный файл является сокетом.

file_name может быть объектом IO.

static VALUE
rb_file_s_split(VALUE klass, VALUE path)
{
    FilePathStringValue(path);          /* get rid of converting twice */
    return rb_assoc_new(rb_file_dirname(path), rb_file_s_basename(1,&path,Qundef));
}

Разбивает заданную строку на каталог и имя файла и возвращает их в массиве из двух элементов. См. также File::dirname и File::basename.

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

static VALUE
rb_file_s_stat(VALUE klass, VALUE fname)
{
    struct stat st;

    FilePathValue(fname);
    fname = rb_str_encode_ospath(fname);
    if (stat_without_gvl(RSTRING_PTR(fname), &st) < 0) {
        rb_sys_fail_path(fname);
    }
    return rb_stat_new(&st);
}

Возвращает объект File::Stat для указанного файла (см. File::Stat).

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

static VALUE
rb_file_sticky_p(VALUE obj, VALUE fname)
{
#ifdef S_ISVTX
    return check3rdbyte(fname, S_ISVTX);
#else
    return Qnil;
#endif
}

Возвращает true, если в указанном файле установлен бит sticky.

file_name может быть объектом IO.

static VALUE
rb_file_s_symlink(VALUE klass, VALUE from, VALUE to)
{
    FilePathValue(from);
    FilePathValue(to);
    from = rb_str_encode_ospath(from);
    to = rb_str_encode_ospath(to);

    if (symlink(StringValueCStr(from), StringValueCStr(to)) < 0) {
        sys_fail2(from, to);
    }
    return INT2FIX(0);
}

Создаёт символическую ссылку с именем new_name на существующий файл old_name. На платформах, не поддерживающих символические ссылки, генерируется исключение NotImplemented.

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

static VALUE
rb_file_symlink_p(VALUE obj, VALUE fname)
{
#ifndef S_ISLNK
#  ifdef _S_ISLNK
#    define S_ISLNK(m) _S_ISLNK(m)
#  else
#    ifdef _S_IFLNK
#      define S_ISLNK(m) (((m) & S_IFMT) == _S_IFLNK)
#    else
#      ifdef S_IFLNK
#        define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
#      endif
#    endif
#  endif
#endif

#ifdef S_ISLNK
    struct stat st;

    FilePathValue(fname);
    fname = rb_str_encode_ospath(fname);
    if (lstat_without_gvl(StringValueCStr(fname), &st) < 0) return Qfalse;
    if (S_ISLNK(st.st_mode)) return Qtrue;
#endif

    return Qfalse;
}

Возвращает true, если указанный файл является символической ссылкой.

static VALUE
rb_file_s_truncate(VALUE klass, VALUE path, VALUE len)
{
    struct truncate_arg ta;
    int r;

    ta.pos = NUM2POS(len);
    FilePathValue(path);
    path = rb_str_encode_ospath(path);
    ta.path = StringValueCStr(path);

    r = (int)(VALUE)rb_thread_call_without_gvl(nogvl_truncate, &ta,
                                                RUBY_UBF_IO, NULL);
    if (r < 0)
        rb_sys_fail_path(path);
    return INT2FIX(0);
#undef NUM2POS
}

Усекает файл file_name до целого числа байт. Доступно не на всех платформах.

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

static VALUE
rb_file_s_umask(int argc, VALUE *argv, VALUE _)
{
    mode_t omask = 0;

    switch (argc) {
      case 0:
        omask = umask(0);
        umask(omask);
        break;
      case 1:
        omask = umask(NUM2MODET(argv[0]));
        break;
      default:
        rb_error_arity(argc, 0, 1);
    }
    return MODET2NUM(omask);
}

Возвращает текущее значение umask для данного процесса. Если задан необязательный аргумент, устанавливает umask на это значение и возвращает предыдущее значение. Значения umask вычитаются из стандартных разрешений, так что umask 0222 сделает файл только для чтения для всех.

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

static VALUE
rb_file_s_unlink(int argc, VALUE *argv, VALUE klass)
{
    return apply2files(unlink_internal, argc, argv, 0);
}

Удаляет указанные файлы, возвращая количество переданных имён файлов в качестве аргументов. При ошибке генерирует исключение. Так как реализация основана на системном вызове unlink(2), тип генерируемого исключения зависит от типа ошибки (см. linux.die.net/man/2/unlink) и имеет вид, например, Errno::ENOENT.

См. также Dir::rmdir.

static VALUE
rb_file_s_utime(int argc, VALUE *argv, VALUE _)
{
    return utime_internal_i(argc, argv, FALSE);
}

Устанавливает время доступа и изменения каждого указанного файла на значения первых двух аргументов. Если файл — символическая ссылка, этот метод действует на целевой файл, а не на саму ссылку; для обратного поведения см. File.lutime. Возвращает количество имён файлов в списке аргументов.

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;
}

Если файл file_name доступен для чтения другими пользователями, возвращает целое число, представляющее биты разрешений файла file_name. В противном случае возвращает nil. Значение битов зависит от платформы; на системах Unix см. stat(2).

file_name может быть объектом IO.

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

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;
}

Если файл file_name доступен для записи другими пользователями, возвращает целое число, представляющее биты разрешений файла file_name. В противном случае возвращает nil. Значение битов зависит от платформы; на системах Unix см. stat(2).

file_name может быть объектом IO.

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

static VALUE
rb_file_writable_p(VALUE obj, VALUE fname)
{
    if (rb_eaccess(fname, W_OK) < 0) return Qfalse;
    return Qtrue;
}

Возвращает true, если указанный файл доступен для записи эффективным пользователем и группой процесса. См. eaccess(3).

Обратите внимание, что некоторые функции безопасности на уровне ОС могут привести к возврату true, даже если файл недоступен для записи эффективным пользователем/группой.

static VALUE
rb_file_writable_real_p(VALUE obj, VALUE fname)
{
    if (rb_access(fname, W_OK) < 0) return Qfalse;
    return Qtrue;
}

Возвращает true, если указанный файл доступен для записи реальным пользователем и группой процесса. См. access(3).

Обратите внимание, что некоторые функции безопасности на уровне ОС могут привести к возврату true, даже если файл недоступен для записи реальным пользователем/группой.

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;
}

Возвращает true, если указанный файл существует и имеет нулевой размер.

file_name может быть объектом IO.