класс Dir

Родитель:: Объект
Включенные модули:: Enumerable

Объекты класса Dir представляют собой потоки каталогов, отображающие каталоги в базовой файловой системе. Они предоставляют различные способы перечисления каталогов и их содержимого. См. также File.

Каталог, используемый в этих примерах, содержит две обычные файлы (config.h и main.rb), родительский каталог (..), и сам каталог (.).

Методы публичного класса

Dir[ string [, string ...] [, base: path] ] → массив Показать исходный код

static VALUE
dir_s_aref(int argc, VALUE *argv, VALUE obj)
{
    VALUE opts, base;
    argc = rb_scan_args(argc, argv, "*:", NULL, &opts);
    dir_glob_options(opts, &base, NULL);
    if (argc == 1) {
        return rb_push_glob(argv[0], base, 0);
    }
    return dir_globs(argc, argv, base, 0);
}

Эквивалентно вызову Dir.glob([string,...], 0).

chdir( [ string] ) → 0 Показать исходный код

chdir( [ string] ) {| path | block } → anObject

static VALUE
dir_s_chdir(int argc, VALUE *argv, VALUE obj)
{
    VALUE path = Qnil;

    if (rb_check_arity(argc, 0, 1) == 1) {
        path = rb_str_encode_ospath(rb_get_path(argv[0]));
    }
    else {
        const char *dist = getenv("HOME");
        if (!dist) {
            dist = getenv("LOGDIR");
            if (!dist) rb_raise(rb_eArgError, "HOME/LOGDIR not set");
        }
        path = rb_str_new2(dist);
    }

    if (chdir_blocking > 0) {
        if (!rb_block_given_p() || rb_thread_current() != chdir_thread)
            rb_warn("conflicting chdir during another chdir block");
    }

    if (rb_block_given_p()) {
        struct chdir_data args;

        args.old_path = rb_str_encode_ospath(rb_dir_getwd());
        args.new_path = path;
        args.done = FALSE;
        return rb_ensure(chdir_yield, (VALUE)&args, chdir_restore, (VALUE)&args);
    }
    else {
        char *p = RSTRING_PTR(path);
        int r = (int)(VALUE)rb_thread_call_without_gvl(nogvl_chdir, p,
                                                        RUBY_UBF_IO, 0);
        if (r < 0)
            rb_sys_fail_path(path);
    }

    return INT2FIX(0);
}

Изменяет текущий рабочий каталог процесса на указанную строку. Если вызывается без аргумента, изменяет каталог на значение переменной окружения HOME, или LOGDIR. SystemCallError (вероятно, Errno::ENOENT), если целевой каталог не существует.

Если задан блок, он получает имя нового текущего каталога, и блок выполняется с этим каталогом в качестве текущего. Исходный рабочий каталог восстанавливается после выхода из блока. Возвращаемое значение chdir — значение блока. chdir блоки могут быть вложены, но в многопоточной программе будет возбуждено исключение, если поток попытается открыть chdir блок, в то время как другой поток его уже открыл.

Dir.chdir("/var/spool/mail")
puts Dir.pwd
Dir.chdir("/tmp") do
  puts Dir.pwd
  Dir.chdir("/usr") do
    puts Dir.pwd
  end
  puts Dir.pwd
end
puts Dir.pwd

выводит:

/var/spool/mail
/tmp
/usr
/tmp
/var/spool/mail

children( dirname ) → массив Показать исходный код

children( dirname, encoding: enc ) → массив

static VALUE
dir_s_children(int argc, VALUE *argv, VALUE io)
{
    VALUE dir;

    dir = dir_open_dir(argc, argv);
    return rb_ensure(dir_collect_children, dir, dir_close, dir);
}

Возвращает массив, содержащий все имена файлов, кроме «.» и «..» в заданном каталоге. Возбудит исключение SystemCallError, если указанный каталог не существует.

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

Dir.children("testdir")   #=> ["config.h", "main.rb"]

chroot( string ) → 0 Показать исходный код

static VALUE
dir_s_chroot(VALUE dir, VALUE path)
{
    path = check_dirname(path);
    if (chroot(RSTRING_PTR(path)) == -1)
        rb_sys_fail_path(path);

    return INT2FIX(0);
}

Изменяет представление файловой системы корня для текущего процесса. Только привилегированный процесс может выполнить этот вызов. Не доступен на всех платформах. В системах Unix см. chroot(2) для получения дополнительной информации.

delete( string ) → 0 Показать исходный код

static VALUE
dir_s_rmdir(VALUE obj, VALUE dir)
{
    const char *p;
    int r;

    dir = check_dirname(dir);
    p = RSTRING_PTR(dir);
    r = (int)(VALUE)rb_thread_call_without_gvl(nogvl_rmdir, (void *)p, RUBY_UBF_IO, 0);
    if (r < 0)
        rb_sys_fail_path(dir);

    return INT2FIX(0);
}

Удаляет указанный каталог. Возбуждает подкласс SystemCallError, если каталог не пуст.

each_child( dirname ) {| filename | block } → nil Показать исходный код

each_child( dirname, encoding: enc ) {| filename | block } → nil

each_child( dirname ) → an_enumerator

each_child( dirname, encoding: enc ) → an_enumerator

static VALUE
dir_s_each_child(int argc, VALUE *argv, VALUE io)
{
    VALUE dir;

    RETURN_ENUMERATOR(io, argc, argv);
    dir = dir_open_dir(argc, argv);
    rb_ensure(dir_each_child, dir, dir_close, dir);
    return Qnil;
}

Вызывает блок один раз для каждой записи, кроме «.» и «..» в указанном каталоге, передавая имя файла каждой записи в качестве параметра блоку.

Если блок не задан, возвращается итератор.

Dir.each_child("testdir") {|x| puts "Got #{x}" }

выводит:

Got config.h
Got main.rb

empty?(path_name) → true или false Показать исходный код

static VALUE
rb_dir_s_empty_p(VALUE obj, VALUE dirname)
{
    VALUE result, orig;
    const char *path;
    enum {false_on_notdir = 1};

    FilePathValue(dirname);
    orig = rb_str_dup_frozen(dirname);
    dirname = rb_str_encode_ospath(dirname);
    dirname = rb_str_dup_frozen(dirname);
    path = RSTRING_PTR(dirname);

#if defined HAVE_GETATTRLIST && defined ATTR_DIR_ENTRYCOUNT
    {
        u_int32_t attrbuf[SIZEUP32(fsobj_tag_t)];
        struct attrlist al = {ATTR_BIT_MAP_COUNT, 0, ATTR_CMN_OBJTAG,};
        if (getattrlist(path, &al, attrbuf, sizeof(attrbuf), 0) != 0)
            rb_sys_fail_path(orig);
        if (*(const fsobj_tag_t *)(attrbuf+1) == VT_HFS) {
            al.commonattr = 0;
            al.dirattr = ATTR_DIR_ENTRYCOUNT;
            if (getattrlist(path, &al, attrbuf, sizeof(attrbuf), 0) == 0) {
                if (attrbuf[0] >= 2 * sizeof(u_int32_t))
                    return attrbuf[1] ? Qfalse : Qtrue;
                if (false_on_notdir) return Qfalse;
            }
            rb_sys_fail_path(orig);
        }
    }
#endif

    result = (VALUE)rb_thread_call_without_gvl(nogvl_dir_empty_p, (void *)path,
                                            RUBY_UBF_IO, 0);
    if (result == Qundef) {
        rb_sys_fail_path(orig);
    }
    return result;
}

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

entries( dirname ) → массив Показать исходный код

entries( dirname, encoding: enc ) → массив

static VALUE
dir_entries(int argc, VALUE *argv, VALUE io)
{
    VALUE dir;

    dir = dir_open_dir(argc, argv);
    return rb_ensure(dir_collect, dir, dir_close, dir);
}

Возвращает массив, содержащий все имена файлов в данном каталоге. Возбудит исключение SystemCallError, если указанный каталог не существует.

Dir.entries("testdir")   #=> [".", "..", "config.h", "main.rb"]

exist?(file_name) → true или false Показать исходный код

VALUE
rb_file_directory_p(void)
{
}

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

exists?(file_name) → true или false Показать исходный код

static VALUE
rb_dir_exists_p(VALUE obj, VALUE fname)
{
    rb_warning("Dir.exists? is a deprecated name, use Dir.exist? instead");
    return rb_file_directory_p(obj, fname);
}

Метод устарел. Не использовать.

foreach( dirname ) {| filename | block } → nil Показать исходный код

foreach( dirname, encoding: enc ) {| filename | block } → nil

foreach( dirname ) → an_enumerator

foreach( dirname, encoding: enc ) → an_enumerator

static VALUE
dir_foreach(int argc, VALUE *argv, VALUE io)
{
    VALUE dir;

    RETURN_ENUMERATOR(io, argc, argv);
    dir = dir_open_dir(argc, argv);
    rb_ensure(dir_each, dir, dir_close, dir);
    return Qnil;
}

Вызывает блок один раз для каждой записи в указанном каталоге, передавая имя файла каждой записи в качестве параметра блоку.

Если блок не задан, возвращается итератор.

Dir.foreach("testdir") {|x| puts "Got #{x}" }

выводит:

Got .
Got ..
Got config.h
Got main.rb

getwd → строка Показать исходный код

static VALUE
dir_s_getwd(VALUE dir)
{
    return rb_dir_getwd();
}

Возвращает путь к текущему рабочему каталогу этого процесса в виде строки.

Dir.chdir("/tmp")   #=> 0
Dir.getwd           #=> "/tmp"
Dir.pwd             #=> "/tmp"

glob( pattern, [flags], [base: path] ) → массив Показать исходный код

glob( pattern, [flags], [base: path] ) { |filename| block } → nil

static VALUE
dir_s_glob(int argc, VALUE *argv, VALUE obj)
{
    VALUE str, rflags, ary, opts, base;
    int flags;

    argc = rb_scan_args(argc, argv, "11:", &str, &rflags, &opts);
    if (argc == 2)
        flags = NUM2INT(rflags);
    else
        flags = 0;
    dir_glob_options(opts, &base, &flags);

    ary = rb_check_array_type(str);
    if (NIL_P(ary)) {
        ary = rb_push_glob(str, base, flags);
    }
    else {
        VALUE v = ary;
        ary = dir_globs(RARRAY_LEN(v), RARRAY_CONST_PTR(v), base, flags);
        RB_GC_GUARD(v);
    }

    if (rb_block_given_p()) {
        rb_ary_each(ary);
        return Qnil;
    }
    return ary;
}

Расширяет pattern, которая является строкой шаблона или массивом строк шаблонов, и возвращает массив, содержащий соответствующие имена файлов. Если задан блок, вызывает блок один раз для каждого соответствующего имени файла, передавая имя файла в качестве параметра блоку.

Необязательный ключевой параметр base указывает базовый каталог для интерпретации относительных путей вместо текущего рабочего каталога. Поскольку результаты в этом случае не предваряются именем базового каталога, вам необходимо добавить имя базового каталога, если вы хотите получить реальные пути.

Обратите внимание, что шаблон не является регулярным выражением, он ближе к оболочке glob. См. File::fnmatch для значения параметра flags. Чувствительность к регистру зависит от вашей системы (File::FNM_CASEFOLD игнорируется), как и порядок возврата результатов.

*

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

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

Обратите внимание, что это не соответствует скрытым файлам (файлам с точкой) в стиле Unix. Для включения их в результаты поиска необходимо использовать флаг File::FNM_DOTMATCH или что-то вроде "{*,.*}".

**

Поиск каталогов рекурсивно.

?

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

[set]

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

{p,q}

Соответствует либо литералу p или литералу q. Эквивалентно переключению шаблонов в регулярных выражениях.

Сопоставление литералов может быть более чем одним символом. Может быть указано более двух литералов.

\

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

Обратите внимание, что это означает, что вы не можете использовать обратную косую черту в Windows в качестве части glob, т.е. Dir["c:\foo*"] не будет работать, используйте Dir["c:/foo*"] вместо этого.

Примеры:

Dir["config.?"]                     #=> ["config.h"]
Dir.glob("config.?")                #=> ["config.h"]
Dir.glob("*.[a-z][a-z]")            #=> ["main.rb"]
Dir.glob("*.[^r]*")                 #=> ["config.h"]
Dir.glob("*.{rb,h}")                #=> ["main.rb", "config.h"]
Dir.glob("*")                       #=> ["config.h", "main.rb"]
Dir.glob("*", File::FNM_DOTMATCH)   #=> [".", "..", "config.h", "main.rb"]
Dir.glob(["*.rb", "*.h"])           #=> ["main.rb", "config.h"]

rbfiles = File.join("**", "*.rb")
Dir.glob(rbfiles)                   #=> ["main.rb",
                                    #    "lib/song.rb",
                                    #    "lib/song/karaoke.rb"]

Dir.glob(rbfiles, base: "lib")      #=> ["song.rb",
                                    #    "song/karaoke.rb"]

libdirs = File.join("**", "lib")
Dir.glob(libdirs)                   #=> ["lib"]

librbfiles = File.join("**", "lib", "**", "*.rb")
Dir.glob(librbfiles)                #=> ["lib/song.rb",
                                    #    "lib/song/karaoke.rb"]

librbfiles = File.join("**", "lib", "*.rb")
Dir.glob(librbfiles)                #=> ["lib/song.rb"]

home() → "/home/me" Показать исходный код

home("root") → "/root"

static VALUE
dir_s_home(int argc, VALUE *argv, VALUE obj)
{
    VALUE user;
    const char *u = 0;

    rb_check_arity(argc, 0, 1);
    user = (argc > 0) ? argv[0] : Qnil;
    if (!NIL_P(user)) {
        SafeStringValue(user);
        rb_must_asciicompat(user);
        u = StringValueCStr(user);
        if (*u) {
            return rb_home_dir_of(user, rb_str_new(0, 0));
        }
    }
    return rb_default_home_dir(rb_str_new(0, 0));

}

Возвращает домашний каталог текущего пользователя или указанного пользователя, если он задан.

mkdir( string [, integer] ) → 0 Показать исходный код

static VALUE
dir_s_mkdir(int argc, VALUE *argv, VALUE obj)
{
    struct mkdir_arg m;
    VALUE path, vmode;
    int r;

    if (rb_scan_args(argc, argv, "11", &path, &vmode) == 2) {
        m.mode = NUM2MODET(vmode);
    }
    else {
        m.mode = 0777;
    }

    path = check_dirname(path);
    m.path = RSTRING_PTR(path);
    r = (int)(VALUE)rb_thread_call_without_gvl(nogvl_mkdir, &m, RUBY_UBF_IO, 0);
    if (r < 0)
        rb_sys_fail_path(path);

    return INT2FIX(0);
}

Создаёт новую директорию с именем, заданным в string, и разрешениями, указанными в необязательном параметре anInteger. Разрешения могут быть изменены значением File::umask, и игнорируются в NT. Вызывает исключение SystemCallError, если директория не может быть создана. См. также обсуждение разрешений в документации класса для File.

Dir.mkdir(File.join(Dir.home, ".foo"), 0700) #=> 0

mktmpdir(prefix_suffix=nil, *rest, **options) { |dup| ... } Показать исходный код

# File lib/tmpdir.rb, line 81
def self.mktmpdir(prefix_suffix=nil, *rest, **options)
  base = nil
  path = Tmpname.create(prefix_suffix || "d", *rest, **options) {|path, _, _, d|
    base = d
    mkdir(path, 0700)
  }
  if block_given?
    begin
      yield path.dup
    ensure
      unless base
        stat = File.stat(File.dirname(path))
        if stat.world_writable? and !stat.sticky?
          raise ArgumentError, "parent directory is world writable but not sticky"
        end
      end
      FileUtils.remove_entry path
    end
  else
    path
  end
end

Dir.mktmpdir создаёт временную директорию.

Директория создаётся с разрешениями 0700. Приложение не должно изменять разрешения, чтобы сделать временную директорию доступной для других пользователей.

Префикс и суффикс имени директории задаются необязательным первым аргументом prefix_suffix.

Если он не указан или равен nil, используется префикс “d” и нет суффикса.
Если это строка, она используется в качестве префикса и нет суффикса.
Если это массив, первый элемент используется в качестве префикса, а второй – в качестве суффикса.

Dir.mktmpdir {|dir| dir is ".../d..." }
Dir.mktmpdir("foo") {|dir| dir is ".../foo..." }
Dir.mktmpdir(["foo", "bar"]) {|dir| dir is ".../foo...bar" }

Директория создаётся в Dir.tmpdir или в необязательном втором аргументе tmpdir, если задано ненулевое значение.

Dir.mktmpdir {|dir| dir is "#{Dir.tmpdir}/d..." }
Dir.mktmpdir(nil, "/var/tmp") {|dir| dir is "/var/tmp/d..." }

Если задан блок, он вызывается с путём к директории. Директория и её содержимое удаляются с помощью FileUtils.remove_entry перед тем, как Dir.mktmpdir вернёт значение. Возвращается значение блока.

Dir.mktmpdir {|dir|
  # use the directory...
  open("#{dir}/foo", "w") { ... }
}

Если блок не задан, возвращается путь к директории. В этом случае Dir.mktmpdir не удаляет директорию.

dir = Dir.mktmpdir
begin
  # use the directory...
  open("#{dir}/foo", "w") { ... }
ensure
  # remove the directory.
  FileUtils.remove_entry dir
end

new( string ) → aDir Показать исходный код

new( string, encoding: enc ) → aDir

static VALUE
dir_initialize(int argc, VALUE *argv, VALUE dir)
{
    struct dir_data *dp;
    rb_encoding  *fsenc;
    VALUE dirname, opt, orig;
    static ID keyword_ids[1];
    const char *path;

    if (!keyword_ids[0]) {
        keyword_ids[0] = rb_id_encoding();
    }

    fsenc = rb_filesystem_encoding();

    rb_scan_args(argc, argv, "1:", &dirname, &opt);

    if (!NIL_P(opt)) {
        VALUE enc;
        rb_get_kwargs(opt, keyword_ids, 0, 1, &enc);
        if (enc != Qundef && !NIL_P(enc)) {
            fsenc = rb_to_encoding(enc);
        }
    }

    FilePathValue(dirname);
    orig = rb_str_dup_frozen(dirname);
    dirname = rb_str_encode_ospath(dirname);
    dirname = rb_str_dup_frozen(dirname);

    TypedData_Get_Struct(dir, struct dir_data, &dir_data_type, dp);
    if (dp->dir) closedir(dp->dir);
    dp->dir = NULL;
    RB_OBJ_WRITE(dir, &dp->path, Qnil);
    dp->enc = fsenc;
    path = RSTRING_PTR(dirname);
    dp->dir = opendir_without_gvl(path);
    if (dp->dir == NULL) {
        int e = errno;
        if (rb_gc_for_fd(e)) {
            dp->dir = opendir_without_gvl(path);
        }
#ifdef HAVE_GETATTRLIST
        else if (e == EIO) {
            u_int32_t attrbuf[1];
            struct attrlist al = {ATTR_BIT_MAP_COUNT, 0};
            if (getattrlist(path, &al, attrbuf, sizeof(attrbuf), FSOPT_NOFOLLOW) == 0) {
                dp->dir = opendir_without_gvl(path);
            }
        }
#endif
        if (dp->dir == NULL) {
            RB_GC_GUARD(dirname);
            rb_syserr_fail_path(e, orig);
        }
    }
    RB_OBJ_WRITE(dir, &dp->path, orig);

    return dir;
}

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

Необязательный ключевой аргумент encoding задаёт кодировку директории. Если не указан, используется кодировка файловой системы.

open( string ) → aDir Показать исходный код

open( string, encoding: enc ) → aDir

open( string ) {| aDir | block } → anObject

open( string, encoding: enc ) {| aDir | block } → anObject

static VALUE
dir_s_open(int argc, VALUE *argv, VALUE klass)
{
    struct dir_data *dp;
    VALUE dir = TypedData_Make_Struct(klass, struct dir_data, &dir_data_type, dp);

    dir_initialize(argc, argv, dir);
    if (rb_block_given_p()) {
        return rb_ensure(rb_yield, dir, dir_close, dir);
    }

    return dir;
}

Без блока open является синонимом для Dir::new. Если блок присутствует, ему передаётся aDir в качестве параметра. Директория закрывается в конце блока, и Dir::open возвращает значение блока.

pwd → string Показать исходный код

static VALUE
dir_s_getwd(VALUE dir)
{
    return rb_dir_getwd();
}

Возвращает путь к текущей рабочей директории данного процесса в виде строки.

Dir.chdir("/tmp")   #=> 0
Dir.getwd           #=> "/tmp"
Dir.pwd             #=> "/tmp"

rmdir( string ) → 0 Показать исходный код

static VALUE
dir_s_rmdir(VALUE obj, VALUE dir)
{
    const char *p;
    int r;

    dir = check_dirname(dir);
    p = RSTRING_PTR(dir);
    r = (int)(VALUE)rb_thread_call_without_gvl(nogvl_rmdir, (void *)p, RUBY_UBF_IO, 0);
    if (r < 0)
        rb_sys_fail_path(dir);

    return INT2FIX(0);
}

Удаляет указанную директорию. Вызывает исключение, являющееся подклассом SystemCallError, если директория не пуста.

tmpdir() Показать исходный код

# File lib/tmpdir.rb, line 21
def self.tmpdir
  tmp = nil
  [ENV['TMPDIR'], ENV['TMP'], ENV['TEMP'], @@systmpdir, '/tmp', '.'].each do |dir|
    next if !dir
    dir = File.expand_path(dir)
    if stat = File.stat(dir) and stat.directory? and stat.writable? and
        (!stat.world_writable? or stat.sticky?)
      tmp = dir
      break
    end rescue nil
  end
  raise ArgumentError, "could not find a temporary directory" unless tmp
  tmp
end

Возвращает путь к временной директории операционной системы.

unlink( string ) → 0 Показать исходный код

static VALUE
dir_s_rmdir(VALUE obj, VALUE dir)
{
    const char *p;
    int r;

    dir = check_dirname(dir);
    p = RSTRING_PTR(dir);
    r = (int)(VALUE)rb_thread_call_without_gvl(nogvl_rmdir, (void *)p, RUBY_UBF_IO, 0);
    if (r < 0)
        rb_sys_fail_path(dir);

    return INT2FIX(0);
}

Публичные методы экземпляра

children → массив Показать исходный код

static VALUE
dir_collect_children(VALUE dir)
{
    VALUE ary = rb_ary_new();
    dir_each_entry(dir, rb_ary_push, ary, TRUE);
    return ary;
}

Возвращает массив, содержащий все имена файлов, кроме «.» и «..», в этом каталоге.

d = Dir.new("testdir")
d.children   #=> ["config.h", "main.rb"]

close → null Показать исходный код

static VALUE
dir_close(VALUE dir)
{
    struct dir_data *dirp;

    dirp = dir_get(dir);
    if (!dirp->dir) return Qnil;
    closedir(dirp->dir);
    dirp->dir = NULL;

    return Qnil;
}

Закрывает поток каталога. Вызов этого метода для закрытого объекта Dir игнорируется начиная с Ruby 2.3.

d = Dir.new("testdir")
d.close   #=> nil

each { |filename| block } → dir Показать исходный код

each → перечислитель

static VALUE
dir_each(VALUE dir)
{
    RETURN_ENUMERATOR(dir, 0, 0);
    return dir_each_entry(dir, dir_yield, Qnil, FALSE);
}

Вызывает блок один раз для каждой записи в этом каталоге, передавая имя файла каждой записи в качестве параметра блоку.

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

d = Dir.new("testdir")
d.each  {|x| puts "Got #{x}" }

выводит:

Got .
Got ..
Got config.h
Got main.rb

each_child {| filename | block } → null Показать исходный код

each_child → перечислитель

static VALUE
dir_each_child_m(VALUE dir)
{
    RETURN_ENUMERATOR(dir, 0, 0);
    return dir_each_entry(dir, dir_yield, Qnil, TRUE);
}

Вызывает блок один раз для каждой записи, кроме «.» и «..», в этом каталоге, передавая имя файла каждой записи в качестве параметра блоку.

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

d = Dir.new("testdir")
d.each_child  {|x| puts "Got #{x}" }

выводит:

Got config.h
Got main.rb

fileno → целое число Показать исходный код

static VALUE
dir_fileno(VALUE dir)
{
    struct dir_data *dirp;
    int fd;

    GetDIR(dir, dirp);
    fd = dirfd(dirp->dir);
    if (fd == -1)
        rb_sys_fail("dirfd");
    return INT2NUM(fd);
}

Возвращает дескриптор файла, используемый в dir.

d = Dir.new("..")
d.fileno   #=> 8

Этот метод использует функцию dirfd(), определённую в POSIX 2008. NotImplementedError генерируется на других платформах, таких как Windows, которые не предоставляют эту функцию.

inspect → строка Показать исходный код

static VALUE
dir_inspect(VALUE dir)
{
    struct dir_data *dirp;

    TypedData_Get_Struct(dir, struct dir_data, &dir_data_type, dirp);
    if (!NIL_P(dirp->path)) {
        VALUE str = rb_str_new_cstr("#<");
        rb_str_append(str, rb_class_name(CLASS_OF(dir)));
        rb_str_cat2(str, ":");
        rb_str_append(str, dirp->path);
        rb_str_cat2(str, ">");
        return str;
    }
    return rb_funcallv(dir, idTo_s, 0, 0);
}

Возвращает строку, описывающую этот объект Dir.

path → строка или null Показать исходный код

static VALUE
dir_path(VALUE dir)
{
    struct dir_data *dirp;

    TypedData_Get_Struct(dir, struct dir_data, &dir_data_type, dirp);
    if (NIL_P(dirp->path)) return Qnil;
    return rb_str_dup(dirp->path);
}

Возвращает параметр пути, переданный конструктору dir.

d = Dir.new("..")
d.path   #=> ".."

pos → целое число Показать исходный код

static VALUE
dir_tell(VALUE dir)
{
    struct dir_data *dirp;
    long pos;

    GetDIR(dir, dirp);
    pos = telldir(dirp->dir);
    return rb_int2inum(pos);
}

Возвращает текущую позицию в dir. Также см. Dir#seek.

d = Dir.new("testdir")
d.tell   #=> 0
d.read   #=> "."
d.tell   #=> 12

pos = целое число → целое число Показать исходный код

static VALUE
dir_set_pos(VALUE dir, VALUE pos)
{
    dir_seek(dir, pos);
    return pos;
}

Синоним для Dir#seek, но возвращает параметр позиции.

d = Dir.new("testdir")   #=> #<Dir:0x401b3c40>
d.read                   #=> "."
i = d.pos                #=> 12
d.read                   #=> ".."
d.pos = i                #=> 12
d.read                   #=> ".."

read → строка или null Показать исходный код

static VALUE
dir_read(VALUE dir)
{
    struct dir_data *dirp;
    struct dirent *dp;

    GetDIR(dir, dirp);
    errno = 0;
    if ((dp = READDIR(dirp->dir, dirp->enc)) != NULL) {
        return rb_external_str_new_with_enc(dp->d_name, NAMLEN(dp), dirp->enc);
    }
    else {
        int e = errno;
        if (e != 0) rb_syserr_fail(e, 0);
        return Qnil;           /* end of stream */
    }
}

Считывает следующую запись из dir и возвращает её как строку. Возвращает nil в конце потока.

d = Dir.new("testdir")
d.read   #=> "."
d.read   #=> ".."
d.read   #=> "config.h"

rewind → dir Показать исходный код

static VALUE
dir_rewind(VALUE dir)
{
    struct dir_data *dirp;

    GetDIR(dir, dirp);
    rewinddir(dirp->dir);
    return dir;
}

Перемещает dir в первую запись.

d = Dir.new("testdir")
d.read     #=> "."
d.rewind   #=> #<Dir:0x401b3fb0>
d.read     #=> "."

seek( целое число ) → dir Показать исходный код

static VALUE
dir_seek(VALUE dir, VALUE pos)
{
    struct dir_data *dirp;
    long p = NUM2LONG(pos);

    GetDIR(dir, dirp);
    seekdir(dirp->dir, p);
    return dir;
}

Перемещает указатель в определённое место в dir. целое число должно быть значением, возвращаемым Dir#tell.

d = Dir.new("testdir")   #=> #<Dir:0x401b3c40>
d.read                   #=> "."
i = d.tell               #=> 12
d.read                   #=> ".."
d.seek(i)                #=> #<Dir:0x401b3c40>
d.read                   #=> ".."

tell → целое число Показать исходный код

static VALUE
dir_tell(VALUE dir)
{
    struct dir_data *dirp;
    long pos;

    GetDIR(dir, dirp);
    pos = telldir(dirp->dir);
    return rb_int2inum(pos);
}

Возвращает текущую позицию в dir. Также см. Dir#seek.

d = Dir.new("testdir")
d.tell   #=> 0
d.read   #=> "."
d.tell   #=> 12

to_path → строка или null Показать исходный код

static VALUE
dir_path(VALUE dir)
{
    struct dir_data *dirp;

    TypedData_Get_Struct(dir, struct dir_data, &dir_data_type, dirp);
    if (NIL_P(dirp->path)) return Qnil;
    return rb_str_dup(dirp->path);
}

Возвращает параметр пути, переданный конструктору dir.

d = Dir.new("..")
d.path   #=> ".."

Ruby Core © 1993–2017 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.