класс Pathname

Родитель:: Объект

Pathname представляет имя файла или каталога в файловой системе, но не сам файл.

Путь зависит от операционной системы: Unix, Windows и т. д. Эта библиотека работает с путями локальной ОС, однако пути, не являющиеся Unix-путями, поддерживаются экспериментально.

Pathname может быть относительным или абсолютным. Лишь при попытке обращения к файлу становится существенным, существует ли файл или нет.

Pathname неизменяем. У него нет методов для разрушающего обновления.

Цель этого класса — манипулировать информацией о пути к файлу более удобным способом, чем предоставляет стандартный Ruby. Примеры ниже демонстрируют разницу.

Все функциональные возможности из File, FileTest, а также некоторые из Dir и FileUtils включены, естественным образом. В сущности, это фронт для всех этих и других возможностей.

Примеры

Пример 1: Использование Pathname

require 'pathname'
pn = Pathname.new("/usr/bin/ruby")
size = pn.size              # 27662
isdir = pn.directory?       # false
dir  = pn.dirname           # Pathname:/usr/bin
base = pn.basename          # Pathname:ruby
dir, base = pn.split        # [Pathname:/usr/bin, Pathname:ruby]
data = pn.read
pn.open { |f| _ }
pn.each_line { |line| _ }

Пример 2: Использование стандартного Ruby

pn = "/usr/bin/ruby"
size = File.size(pn)        # 27662
isdir = File.directory?(pn) # false
dir  = File.dirname(pn)     # "/usr/bin"
base = File.basename(pn)    # "ruby"
dir, base = File.split(pn)  # ["/usr/bin", "ruby"]
data = File.read(pn)
File.open(pn) { |f| _ }
File.foreach(pn) { |line| _ }

Пример 3: Специальные возможности

p1 = Pathname.new("/usr/lib")   # Pathname:/usr/lib
p2 = p1 + "ruby/1.8"            # Pathname:/usr/lib/ruby/1.8
p3 = p1.parent                  # Pathname:/usr
p4 = p2.relative_path_from(p3)  # Pathname:lib/ruby/1.8
pwd = Pathname.pwd              # Pathname:/home/gavin
pwd.absolute?                   # true
p5 = Pathname.new "."           # Pathname:.
p5 = p5 + "music/../articles"   # Pathname:music/../articles
p5.cleanpath                    # Pathname:articles
p5.realpath                     # Pathname:/home/gavin/articles
p5.children                     # [Pathname:/home/gavin/articles/linux, ...]

Декомпозиция функциональности

Основные методы

Эти методы фактически манипулируют строкой, поскольку путь — это всего лишь строка. Ни один из этих методов не обращается к файловой системе, за исключением mountpoint?, children, each_child, realdirpath и realpath.

Методы-предикаты статуса файла File

Эти методы являются фасадом для FileTest:

Методы свойств и манипуляций с файлом File

Эти методы являются фасадом для File:

Методы каталога

Эти методы являются фасадом для Dir:

IO

Эти методы являются фасадом для IO:

Утилиты

Эти методы представляют собой смесь Find, FileUtils и других:

Документация по методам Метод

Как показано выше, большинство методов в Pathname являются фасадами. Документация по этим методам обычно просто указывает, например, «См. FileTest#writable?», так как вам должно быть знакомо оригинальное имя метода и его документация (например, через ri) содержит больше информации. В некоторых случаях последует краткое описание.

Константы

SAME_PATHS
SEPARATOR_LIST
SEPARATOR_PAT
TO_PATH: #to_path реализована таким образом, что объекты Pathname могут использоваться с File.open и т. д.

Публичные методы класса

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

static VALUE
path_s_getwd(VALUE klass)
{
    VALUE str;
    str = rb_funcall(rb_cDir, rb_intern("getwd"), 0);
    return rb_class_new_instance(1, &str, klass);
}

Возвращает текущий рабочий каталог в виде Pathname.

Pathname.getwd
    #=> #<Pathname:/home/zzak/projects/ruby>

См. Dir.getwd.

glob(p1, p2 = v2) Показать исходный код

static VALUE
path_s_glob(int argc, VALUE *argv, VALUE klass)
{
    VALUE args[2];
    int n;

    n = rb_scan_args(argc, argv, "11", &args[0], &args[1]);
    if (rb_block_given_p()) {
        return rb_block_call(rb_cDir, rb_intern("glob"), n, args, glob_i, klass);
    }
    else {
        VALUE ary;
        long i;
        ary = rb_funcall2(rb_cDir, rb_intern("glob"), n, args);
        ary = rb_convert_type(ary, T_ARRAY, "Array", "to_ary");
        for (i = 0; i < RARRAY_LEN(ary); i++) {
            VALUE elt = RARRAY_AREF(ary, i);
            elt = rb_class_new_instance(1, &elt, klass);
            rb_ary_store(ary, i, elt);
        }
        return ary;
    }
}

Возвращает или итерирует объекты Pathname.

Pathname.glob("config/" "*.rb")
    #=> [#<Pathname:config/environment.rb>, #<Pathname:config/routes.rb>, ..]

См. Dir.glob.

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

static VALUE
path_initialize(VALUE self, VALUE arg)
{
    VALUE str;
    if (RB_TYPE_P(arg, T_STRING)) {
        str = arg;
    }
    else {
        str = rb_check_funcall(arg, id_to_path, 0, NULL);
        if (str == Qundef)
            str = arg;
        StringValue(str);
    }
    if (memchr(RSTRING_PTR(str), '\0', RSTRING_LEN(str)))
        rb_raise(rb_eArgError, "pathname contains null byte");
    str = rb_obj_dup(str);

    set_strpath(self, str);
    OBJ_INFECT(self, str);
    return self;
}

Создаёт объект Pathname из заданной строки (или объекта, подобного строке). Если path содержит символ NULL (\0), генерируется исключение ArgumentError.

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

static VALUE
path_s_getwd(VALUE klass)
{
    VALUE str;
    str = rb_funcall(rb_cDir, rb_intern("getwd"), 0);
    return rb_class_new_instance(1, &str, klass);
}

Возвращает текущий рабочий каталог в виде Pathname.

Pathname.getwd
    #=> #<Pathname:/home/zzak/projects/ruby>

См. Dir.getwd.

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

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

# File ext/pathname/lib/pathname.rb, line 348
def +(other)
  other = Pathname.new(other) unless Pathname === other
  Pathname.new(plus(@path, other.to_s))
end

Добавляет фрагмент пути к self для создания нового объекта Pathname.

p1 = Pathname.new("/usr")      # Pathname:/usr
p2 = p1 + "bin/ruby"           # Pathname:/usr/bin/ruby
p3 = p1 + "/etc/passwd"        # Pathname:/etc/passwd

# / is aliased to +.
p4 = p1 / "bin/ruby"           # Pathname:/usr/bin/ruby
p5 = p1 / "/etc/passwd"        # Pathname:/etc/passwd

Этот метод не обращается к файловой системе; это чистое манипулирование строками.

Также известен как: /

/(other)

Псевдоним для: +

<=>(p1) Показать исходный код

static VALUE
path_cmp(VALUE self, VALUE other)
{
    VALUE s1, s2;
    char *p1, *p2;
    char *e1, *e2;
    if (!rb_obj_is_kind_of(other, rb_cPathname))
        return Qnil;
    s1 = get_strpath(self);
    s2 = get_strpath(other);
    p1 = RSTRING_PTR(s1);
    p2 = RSTRING_PTR(s2);
    e1 = p1 + RSTRING_LEN(s1);
    e2 = p2 + RSTRING_LEN(s2);
    while (p1 < e1 && p2 < e2) {
        int c1, c2;
        c1 = (unsigned char)*p1++;
        c2 = (unsigned char)*p2++;
        if (c1 == '/') c1 = '\0';
        if (c2 == '/') c2 = '\0';
        if (c1 != c2) {
            if (c1 < c2)
                return INT2FIX(-1);
            else
                return INT2FIX(1);
        }
    }
    if (p1 < e1)
        return INT2FIX(1);
    if (p2 < e2)
        return INT2FIX(-1);
    return INT2FIX(0);
}

Обеспечивает оператор сравнения с учетом регистра для путей.

Pathname.new('/usr') <=> Pathname.new('/usr/bin')
    #=> -1
Pathname.new('/usr/bin') <=> Pathname.new('/usr/bin')
    #=> 0
Pathname.new('/usr/bin') <=> Pathname.new('/USR/BIN')
    #=> 1

Он вернет -1, 0 или 1 в зависимости от значения левого аргумента относительно правого аргумента. Или он вернет nil, если аргументы не сравнимы.

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

static VALUE
path_eq(VALUE self, VALUE other)
{
    if (!rb_obj_is_kind_of(other, rb_cPathname))
        return Qfalse;
    return rb_str_equal(get_strpath(self), get_strpath(other));
}

Сравнивает этот путь с other. Сравнение основано на строках. Имейте в виду, что два разных пути (foo.txt и ./foo.txt) могут ссылаться на один и тот же файл.

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

static VALUE
path_eq(VALUE self, VALUE other)
{
    if (!rb_obj_is_kind_of(other, rb_cPathname))
        return Qfalse;
    return rb_str_equal(get_strpath(self), get_strpath(other));
}

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

# File ext/pathname/lib/pathname.rb, line 223
def absolute?
  !relative?
end

Метод предиката для проверки того, является ли путь абсолютным.

Он возвращает true, если путь начинается со слеша.

p = Pathname.new('/im/sure')
p.absolute?
    #=> true

p = Pathname.new('not/so/sure')
p.absolute?
    #=> false

ascend() { |self| ... } Показать исходный код

# File ext/pathname/lib/pathname.rb, line 324
def ascend
  return to_enum(__method__) unless block_given?
  path = @path
  yield self
  while r = chop_basename(path)
    path, = r
    break if path.empty?
    yield self.class.new(del_trailing_separator(path))
  end
end

Итерирует и выдает новый объект Pathname для каждого элемента в заданном пути в восходящем порядке.

Pathname.new('/path/to/some/file.rb').ascend {|v| p v}
   #<Pathname:/path/to/some/file.rb>
   #<Pathname:/path/to/some>
   #<Pathname:/path/to>
   #<Pathname:/path>
   #<Pathname:/>

Pathname.new('path/to/some/file.rb').ascend {|v| p v}
   #<Pathname:path/to/some/file.rb>
   #<Pathname:path/to/some>
   #<Pathname:path/to>
   #<Pathname:path>

Возвращает Enumerator, если блок не был задан.

enum = Pathname.new("/usr/bin/ruby").ascend
  # ... do stuff ...
enum.each { |e| ... }
  # yields Pathnames /usr/bin/ruby, /usr/bin, /usr, and /.

Он не обращается к файловой системе.

atime → time Показать исходный код

static VALUE
path_atime(VALUE self)
{
    return rb_funcall(rb_cFile, rb_intern("atime"), 1, get_strpath(self));
}

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

См. File.atime.

basename(p1 = v1) Показать исходный код

static VALUE
path_basename(int argc, VALUE *argv, VALUE self)
{
    VALUE str = get_strpath(self);
    VALUE fext;
    if (rb_scan_args(argc, argv, "01", &fext) == 0)
        str = rb_funcall(rb_cFile, rb_intern("basename"), 1, str);
    else
        str = rb_funcall(rb_cFile, rb_intern("basename"), 2, str, fext);
    return rb_class_new_instance(1, &str, rb_obj_class(self));
}

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

См. File.basename.

binread([length [, offset]]) → string Показать исходный код

static VALUE
path_binread(int argc, VALUE *argv, VALUE self)
{
    VALUE args[3];
    int n;

    args[0] = get_strpath(self);
    n = rb_scan_args(argc, argv, "02", &args[1], &args[2]);
    return rb_funcall2(rb_cIO, rb_intern("binread"), 1+n, args);
}

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

См. IO.binread.

binwrite(string, [offset] ) → fixnum Показать исходный код

binwrite(string, [offset], open_args ) → fixnum

static VALUE
path_binwrite(int argc, VALUE *argv, VALUE self)
{
    VALUE args[4];
    int n;

    args[0] = get_strpath(self);
    n = rb_scan_args(argc, argv, "03", &args[1], &args[2], &args[3]);
    return rb_funcall2(rb_cIO, rb_intern("binwrite"), 1+n, args);
}

Записывает contents в файл, открывая его в бинарном режиме.

См. IO.binwrite.

birthtime → time Показать исходный код

static VALUE
path_birthtime(VALUE self)
{
    return rb_funcall(rb_cFile, rb_intern("birthtime"), 1, get_strpath(self));
}

Возвращает время создания файла. Если платформа не имеет времени создания, вызывает NotImplementedError.

См. File.birthtime.

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

static VALUE
path_blockdev_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, rb_intern("blockdev?"), 1, get_strpath(self));
}

См. FileTest#blockdev?.

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

static VALUE
path_chardev_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, rb_intern("chardev?"), 1, get_strpath(self));
}

См. FileTest#chardev?.

children(with_directory=true) Показать исходный код

# File ext/pathname/lib/pathname.rb, line 439
def children(with_directory=true)
  with_directory = false if @path == '.'
  result = []
  Dir.foreach(@path) {|e|
    next if e == '.' || e == '..'
    if with_directory
      result << self.class.new(File.join(@path, e))
    else
      result << self.class.new(e)
    end
  }
  result
end

Возвращает дочерние элементы каталога (файлы и подкаталоги, не рекурсивно) в виде массива объектов Pathname.

По умолчанию возвращаемые пути будут содержать достаточно информации для доступа к файлам. Если вы установите with_directory в false, то возвращаемые пути будут содержать только имя файла.

Например:

pn = Pathname("/usr/lib/ruby/1.8")
pn.children
    # -> [ Pathname:/usr/lib/ruby/1.8/English.rb,
           Pathname:/usr/lib/ruby/1.8/Env.rb,
           Pathname:/usr/lib/ruby/1.8/abbrev.rb, ... ]
pn.children(false)
    # -> [ Pathname:English.rb, Pathname:Env.rb, Pathname:abbrev.rb, ... ]

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

chmod → integer Показать исходный код

static VALUE
path_chmod(VALUE self, VALUE mode)
{
    return rb_funcall(rb_cFile, rb_intern("chmod"), 2, mode, get_strpath(self));
}

Изменяет права доступа к файлу.

См. File.chmod.

chown → integer Показать исходный код

static VALUE
path_chown(VALUE self, VALUE owner, VALUE group)
{
    return rb_funcall(rb_cFile, rb_intern("chown"), 3, owner, group, get_strpath(self));
}

Изменяет владельца и группу файла.

См. File.chown.

cleanpath(consider_symlink=false) Показать исходный код

# File ext/pathname/lib/pathname.rb, line 83
def cleanpath(consider_symlink=false)
  if consider_symlink
    cleanpath_conservative
  else
    cleanpath_aggressive
  end
end

Возвращает очищенный путь self с удаленными последовательными слешами и бесполезными точками. Файловая система не используется.

Если consider_symlink равно true, то используется более консервативный алгоритм, чтобы избежать нарушения символических ссылок. Это может сохранить больше записей .., чем абсолютно необходимо, но без доступа к файловой системе этого избежать нельзя.

См. #realpath.

ctime → time Показать исходный код

static VALUE
path_ctime(VALUE self)
{
    return rb_funcall(rb_cFile, rb_intern("ctime"), 1, get_strpath(self));
}

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

См. File.ctime.

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

static VALUE
path_unlink(VALUE self)
{
    VALUE eENOTDIR = rb_const_get_at(rb_mErrno, rb_intern("ENOTDIR"));
    VALUE str = get_strpath(self);
    return rb_rescue2(unlink_body, str, unlink_rescue, str, eENOTDIR, (VALUE)0);
}

Удаляет файл или каталог, используя File.unlink, если self является файлом, или Dir.unlink по мере необходимости.

descend() { |v| ... } Показать исходный код

# File ext/pathname/lib/pathname.rb, line 291
def descend
  return to_enum(__method__) unless block_given?
  vs = []
  ascend {|v| vs << v }
  vs.reverse_each {|v| yield v }
  nil
end

Итерирует и выдает новый объект Pathname для каждого элемента в заданном пути в нисходящем порядке.

Pathname.new('/path/to/some/file.rb').descend {|v| p v}
   #<Pathname:/>
   #<Pathname:/path>
   #<Pathname:/path/to>
   #<Pathname:/path/to/some>
   #<Pathname:/path/to/some/file.rb>

Pathname.new('path/to/some/file.rb').descend {|v| p v}
   #<Pathname:path>
   #<Pathname:path/to>
   #<Pathname:path/to/some>
   #<Pathname:path/to/some/file.rb>

Возвращает Enumerator, если блок не был задан.

enum = Pathname.new("/usr/bin/ruby").descend
  # ... do stuff ...
enum.each { |e| ... }
  # yields Pathnames /, /usr, /usr/bin, and /usr/bin/ruby.

Он не обращается к файловой системе.

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

static VALUE
path_directory_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, rb_intern("directory?"), 1, get_strpath(self));
}

См. FileTest#directory?.

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

static VALUE
path_dirname(VALUE self)
{
    VALUE str = get_strpath(self);
    str = rb_funcall(rb_cFile, rb_intern("dirname"), 1, str);
    return rb_class_new_instance(1, &str, rb_obj_class(self));
}

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

См. File.dirname.

each_child(with_directory=true, &b) Показать исходный код

# File ext/pathname/lib/pathname.rb, line 489
def each_child(with_directory=true, &b)
  children(with_directory).each(&b)
end

Перебирает дочерние элементы каталога (файлы и подкаталоги, не рекурсивно).

Возвращает объект Pathname для каждого дочернего элемента.

По умолчанию, возвращаемые имена путей содержат достаточную информацию для доступа к файлам.

Если вы установите with_directory в false, возвращаемые имена путей будут содержать только имя файла.

Pathname("/usr/local").each_child {|f| p f }
#=> #<Pathname:/usr/local/share>
#   #<Pathname:/usr/local/bin>
#   #<Pathname:/usr/local/games>
#   #<Pathname:/usr/local/lib>
#   #<Pathname:/usr/local/include>
#   #<Pathname:/usr/local/sbin>
#   #<Pathname:/usr/local/src>
#   #<Pathname:/usr/local/man>

Pathname("/usr/local").each_child(false) {|f| p f }
#=> #<Pathname:share>
#   #<Pathname:bin>
#   #<Pathname:games>
#   #<Pathname:lib>
#   #<Pathname:include>
#   #<Pathname:sbin>
#   #<Pathname:src>
#   #<Pathname:man>

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

См. #children

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

static VALUE
path_each_entry(VALUE self)
{
    VALUE args[1];

    args[0] = get_strpath(self);
    return rb_block_call(rb_cDir, rb_intern("foreach"), 1, args, each_entry_i, rb_obj_class(self));
}

Перебирает элементы (файлы и подкаталоги) в каталоге, возвращая объект Pathname для каждого элемента.

each_filename() { |filename| ... } Показать исходный код

# File ext/pathname/lib/pathname.rb, line 259
def each_filename # :yield: filename
  return to_enum(__method__) unless block_given?
  _, names = split_names(@path)
  names.each {|filename| yield filename }
  nil
end

Перебирает каждый компонент пути.

Pathname.new("/usr/bin/ruby").each_filename {|filename| ... }
  # yields "usr", "bin", and "ruby".

Возвращает объект Enumerator, если блок не был задан.

enum = Pathname.new("/usr/bin/ruby").each_filename
  # ... do stuff ...
enum.each { |e| ... }
  # yields "usr", "bin", and "ruby".

each_line {|line| ... } Показать исходный код

each_line(sep=$/ [, open_args]) {|line| block } → nil

each_line(limit [, open_args]) {|line| block } → nil

each_line(sep, limit [, open_args]) {|line| block } → nil

each_line(...) → an_enumerator

static VALUE
path_each_line(int argc, VALUE *argv, VALUE self)
{
    VALUE args[4];
    int n;

    args[0] = get_strpath(self);
    n = rb_scan_args(argc, argv, "03", &args[1], &args[2], &args[3]);
    if (rb_block_given_p()) {
        return rb_block_call(rb_cIO, rb_intern("foreach"), 1+n, args, 0, 0);
    }
    else {
        return rb_funcall2(rb_cIO, rb_intern("foreach"), 1+n, args);
    }
}

Перебирает каждую строку в файле и возвращает объект String для каждой.

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

static VALUE
path_entries(VALUE self)
{
    VALUE klass, str, ary;
    long i;
    klass = rb_obj_class(self);
    str = get_strpath(self);
    ary = rb_funcall(rb_cDir, rb_intern("entries"), 1, str);
    ary = rb_convert_type(ary, T_ARRAY, "Array", "to_ary");
    for (i = 0; i < RARRAY_LEN(ary); i++) {
        VALUE elt = RARRAY_AREF(ary, i);
        elt = rb_class_new_instance(1, &elt, klass);
        rb_ary_store(ary, i, elt);
    }
    return ary;
}

Возвращает элементы (файлы и подкаталоги) в каталоге, каждый как объект Pathname.

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

pp Pathname.new('/usr/local').entries
#=> [#<Pathname:share>,
#    #<Pathname:lib>,
#    #<Pathname:..>,
#    #<Pathname:include>,
#    #<Pathname:etc>,
#    #<Pathname:bin>,
#    #<Pathname:man>,
#    #<Pathname:games>,
#    #<Pathname:.>,
#    #<Pathname:sbin>,
#    #<Pathname:src>]

Результат может содержать текущий каталог #<Pathname:.> и родительский каталог #<Pathname:..>.

Если вам не нужны . и .., и нужны каталоги, рассмотрите #children.

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

static VALUE
path_eq(VALUE self, VALUE other)
{
    if (!rb_obj_is_kind_of(other, rb_cPathname))
        return Qfalse;
    return rb_str_equal(get_strpath(self), get_strpath(other));
}

Сравнивает этот путь с other. Сравнение выполняется на основе строк. Имейте в виду, что два разных пути (foo.txt и ./foo.txt) могут ссылаться на один и тот же файл.

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

static VALUE
path_executable_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, rb_intern("executable?"), 1, get_strpath(self));
}

См. FileTest#executable?.

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

static VALUE
path_executable_real_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, rb_intern("executable_real?"), 1, get_strpath(self));
}

См. FileTest#executable_real?.

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

static VALUE
path_exist_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, rb_intern("exist?"), 1, get_strpath(self));
}

См. FileTest#exist?.

expand_path(p1 = v1) Показать исходный код

static VALUE
path_expand_path(int argc, VALUE *argv, VALUE self)
{
    VALUE str = get_strpath(self);
    VALUE dname;
    if (rb_scan_args(argc, argv, "01", &dname) == 0)
        str = rb_funcall(rb_cFile, rb_intern("expand_path"), 1, str);
    else
        str = rb_funcall(rb_cFile, rb_intern("expand_path"), 2, str, dname);
    return rb_class_new_instance(1, &str, rb_obj_class(self));
}

Возвращает абсолютный путь к файлу.

См. File.expand_path.

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

static VALUE
path_extname(VALUE self)
{
    VALUE str = get_strpath(self);
    return rb_funcall(rb_cFile, rb_intern("extname"), 1, str);
}

Возвращает расширение файла.

См. File.extname.

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

static VALUE
path_file_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, rb_intern("file?"), 1, get_strpath(self));
}

См. FileTest#file?.

find(ignore_error: true) { |pathname| ... } Показать исходный код

# File ext/pathname/lib/pathname.rb, line 557
def find(ignore_error: true) # :yield: pathname
  return to_enum(__method__, ignore_error: ignore_error) unless block_given?
  require 'find'
  if @path == '.'
    Find.find(@path, ignore_error: ignore_error) {|f| yield self.class.new(f.sub(%r{\A\./}, '')) }
  else
    Find.find(@path, ignore_error: ignore_error) {|f| yield self.class.new(f) }
  end
end

Перебирает дерево каталогов в порядке обхода в глубину, возвращая объект Pathname для каждого файла в подкаталогах текущего каталога.

Возвращает объект Enumerator, если блок не задан.

Поскольку он реализован модулем стандартной библиотеки Find, можно использовать Find#prune для управления обходом.

Если self равно ., возвращаемые объекты пути начинаются с имени файла в текущем каталоге, а не ./.

См. Find#find

fnmatch(pattern, [flags]) → string Показать исходный код

fnmatch?(pattern, [flags]) → string

static VALUE
path_fnmatch(int argc, VALUE *argv, VALUE self)
{
    VALUE str = get_strpath(self);
    VALUE pattern, flags;
    if (rb_scan_args(argc, argv, "11", &pattern, &flags) == 1)
        return rb_funcall(rb_cFile, rb_intern("fnmatch"), 2, pattern, str);
    else
        return rb_funcall(rb_cFile, rb_intern("fnmatch"), 3, pattern, str, flags);
}

Возвращает true, если получатель соответствует заданному шаблону.

См. File.fnmatch.

fnmatch?(pattern, [flags]) → string Показать исходный код

static VALUE
path_fnmatch(int argc, VALUE *argv, VALUE self)
{
    VALUE str = get_strpath(self);
    VALUE pattern, flags;
    if (rb_scan_args(argc, argv, "11", &pattern, &flags) == 1)
        return rb_funcall(rb_cFile, rb_intern("fnmatch"), 2, pattern, str);
    else
        return rb_funcall(rb_cFile, rb_intern("fnmatch"), 3, pattern, str, flags);
}

Возвращает true, если получатель соответствует заданному шаблону.

См. File.fnmatch.

freeze → obj Показать исходный код

static VALUE
path_freeze(VALUE self)
{
    rb_call_super(0, 0);
    rb_str_freeze(get_strpath(self));
    return self;
}

Замораживает этот объект Pathname.

См. Object#freeze.

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

static VALUE
path_ftype(VALUE self)
{
    return rb_funcall(rb_cFile, rb_intern("ftype"), 1, get_strpath(self));
}

Возвращает «тип» файла («файл», «каталог» и т. д.).

См. File.ftype.

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

static VALUE
path_grpowned_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, rb_intern("grpowned?"), 1, get_strpath(self));
}

См. FileTest#grpowned?.

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

# File ext/pathname/lib/pathname.rb, line 406
def join(*args)
  return self if args.empty?
  result = args.pop
  result = Pathname.new(result) unless Pathname === result
  return result if result.absolute?
  args.reverse_each {|arg|
    arg = Pathname.new(arg) unless Pathname === arg
    result = arg + result
    return result if result.absolute?
  }
  self + result
end

Присоединяет указанные пути к self для создания нового объекта Pathname.

path0 = Pathname.new("/usr")                # Pathname:/usr
path0 = path0.join("bin/ruby")              # Pathname:/usr/bin/ruby
    # is the same as
path1 = Pathname.new("/usr") + "bin/ruby"   # Pathname:/usr/bin/ruby
path0 == path1
    #=> true

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

static VALUE
path_lchmod(VALUE self, VALUE mode)
{
    return rb_funcall(rb_cFile, rb_intern("lchmod"), 2, mode, get_strpath(self));
}

Аналогично #chmod, но не следует символичным ссылкам.

См. File.lchmod.

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

static VALUE
path_lchown(VALUE self, VALUE owner, VALUE group)
{
    return rb_funcall(rb_cFile, rb_intern("lchown"), 3, owner, group, get_strpath(self));
}

Аналогично #chown, но не следует символичным ссылкам.

См. File.lchown.

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

static VALUE
path_lstat(VALUE self)
{
    return rb_funcall(rb_cFile, rb_intern("lstat"), 1, get_strpath(self));
}

См. File.lstat.

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

static VALUE
path_make_link(VALUE self, VALUE old)
{
    return rb_funcall(rb_cFile, rb_intern("link"), 2, old, get_strpath(self));
}

Создаёт жёсткую ссылку по адресу pathname.

См. File.link.

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

static VALUE
path_make_symlink(VALUE self, VALUE old)
{
    return rb_funcall(rb_cFile, rb_intern("symlink"), 2, old, get_strpath(self));
}

Создаёт символическую ссылку.

См. File.symlink.

mkdir(p1 = v1) Показать исходный код

static VALUE
path_mkdir(int argc, VALUE *argv, VALUE self)
{
    VALUE str = get_strpath(self);
    VALUE vmode;
    if (rb_scan_args(argc, argv, "01", &vmode) == 0)
        return rb_funcall(rb_cDir, rb_intern("mkdir"), 1, str);
    else
        return rb_funcall(rb_cDir, rb_intern("mkdir"), 2, str, vmode);
}

Создаёт указанную директорию.

См. Dir.mkdir.

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

# File ext/pathname/lib/pathname.rb, line 574
def mkpath
  require 'fileutils'
  FileUtils.mkpath(@path)
  nil
end

Создаёт полное имя пути, включая любые промежуточные директории, которых ещё нет.

См. FileUtils#mkpath и FileUtils#mkdir_p

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

# File ext/pathname/lib/pathname.rb, line 190
def mountpoint?
  begin
    stat1 = self.lstat
    stat2 = self.parent.lstat
    stat1.dev == stat2.dev && stat1.ino == stat2.ino ||
      stat1.dev != stat2.dev
  rescue Errno::ENOENT
    false
  end
end

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

mtime → время Показать исходный код

static VALUE
path_mtime(VALUE self)
{
    return rb_funcall(rb_cFile, rb_intern("mtime"), 1, get_strpath(self));
}

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

См. File.mtime.

open(p1 = v1, p2 = v2, p3 = v3) Показать исходный код

static VALUE
path_open(int argc, VALUE *argv, VALUE self)
{
    VALUE args[4];
    int n;

    args[0] = get_strpath(self);
    n = rb_scan_args(argc, argv, "03", &args[1], &args[2], &args[3]);
    if (rb_block_given_p()) {
        return rb_block_call(rb_cFile, rb_intern("open"), 1+n, args, 0, 0);
    }
    else {
        return rb_funcall2(rb_cFile, rb_intern("open"), 1+n, args);
    }
}

Открывает файл для чтения или записи.

См. File.open.

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

static VALUE
path_opendir(VALUE self)
{
    VALUE args[1];

    args[0] = get_strpath(self);
    return rb_block_call(rb_cDir, rb_intern("open"), 1, args, 0, 0);
}

Открывает указанную директорию.

См. Dir.open.

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

static VALUE
path_owned_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, rb_intern("owned?"), 1, get_strpath(self));
}

См. FileTest#owned?.

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

# File ext/pathname/lib/pathname.rb, line 185
def parent
  self + '..'
end

Возвращает родительскую директорию.

Это то же, что и self + '..'.

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

static VALUE
path_pipe_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, rb_intern("pipe?"), 1, get_strpath(self));
}

См. FileTest#pipe?.

read([length [, offset]]) → строка Показать исходный код

read([length [, offset]], open_args) → строка

static VALUE
path_read(int argc, VALUE *argv, VALUE self)
{
    VALUE args[4];
    int n;

    args[0] = get_strpath(self);
    n = rb_scan_args(argc, argv, "03", &args[1], &args[2], &args[3]);
    return rb_funcall2(rb_cIO, rb_intern("read"), 1+n, args);
}

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

См. IO.read.

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

static VALUE
path_readable_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, rb_intern("readable?"), 1, get_strpath(self));
}

См. FileTest#readable?.

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

static VALUE
path_readable_real_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, rb_intern("readable_real?"), 1, get_strpath(self));
}

См. FileTest#readable_real?.

readlines(sep=$/ [, open_args]) → массив Показать исходный код

readlines(limit [, open_args]) → массив

readlines(sep, limit [, open_args]) → массив

static VALUE
path_readlines(int argc, VALUE *argv, VALUE self)
{
    VALUE args[4];
    int n;

    args[0] = get_strpath(self);
    n = rb_scan_args(argc, argv, "03", &args[1], &args[2], &args[3]);
    return rb_funcall2(rb_cIO, rb_intern("readlines"), 1+n, args);
}

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

См. IO.readlines.

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

static VALUE
path_readlink(VALUE self)
{
    VALUE str;
    str = rb_funcall(rb_cFile, rb_intern("readlink"), 1, get_strpath(self));
    return rb_class_new_instance(1, &str, rb_obj_class(self));
}

Прочитать символическую ссылку.

См. File.readlink.

realdirpath(p1 = v1) Показать исходный код

static VALUE
path_realdirpath(int argc, VALUE *argv, VALUE self)
{
    VALUE basedir, str;
    rb_scan_args(argc, argv, "01", &basedir);
    str = rb_funcall(rb_cFile, rb_intern("realdirpath"), 2, get_strpath(self), basedir);
    return rb_class_new_instance(1, &str, rb_obj_class(self));
}

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

Не содержит символических ссылок или бесполезных точек, .. и ..

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

realpath(p1 = v1) Показать исходный код

static VALUE
path_realpath(int argc, VALUE *argv, VALUE self)
{
    VALUE basedir, str;
    rb_scan_args(argc, argv, "01", &basedir);
    str = rb_funcall(rb_cFile, rb_intern("realpath"), 2, get_strpath(self), basedir);
    return rb_class_new_instance(1, &str, rb_obj_class(self));
}

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

Не содержит символических ссылок или бесполезных точек, .. и ..

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

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

# File ext/pathname/lib/pathname.rb, line 238
def relative?
  path = @path
  while r = chop_basename(path)
    path, = r
  end
  path == ''
end

Обратное #absolute?.

Возвращает false, если путь начинается с косой черты.

p = Pathname.new('/im/sure')
p.relative?
    #=> false

p = Pathname.new('not/so/sure')
p.relative?
    #=> true

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

# File ext/pathname/lib/pathname.rb, line 504
def relative_path_from(base_directory)
  dest_directory = self.cleanpath.to_s
  base_directory = base_directory.cleanpath.to_s
  dest_prefix = dest_directory
  dest_names = []
  while r = chop_basename(dest_prefix)
    dest_prefix, basename = r
    dest_names.unshift basename if basename != '.'
  end
  base_prefix = base_directory
  base_names = []
  while r = chop_basename(base_prefix)
    base_prefix, basename = r
    base_names.unshift basename if basename != '.'
  end
  unless SAME_PATHS[dest_prefix, base_prefix]
    raise ArgumentError, "different prefix: #{dest_prefix.inspect} and #{base_directory.inspect}"
  end
  while !dest_names.empty? &&
        !base_names.empty? &&
        SAME_PATHS[dest_names.first, base_names.first]
    dest_names.shift
    base_names.shift
  end
  if base_names.include? '..'
    raise ArgumentError, "base_directory has ..: #{base_directory.inspect}"
  end
  base_names.fill('..')
  relpath_names = base_names + dest_names
  if relpath_names.empty?
    Pathname.new('.')
  else
    Pathname.new(File.join(*relpath_names))
  end
end

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

Если self абсолютный, то base_directory тоже должен быть абсолютным.

Если self относительный, то base_directory тоже должен быть относительным.

Этот метод не обращается к файловой системе. Предполагается отсутствие символических ссылок.

ArgumentError возникает, когда относительный путь не может быть найден.

rename(p1) Show source

static VALUE
path_rename(VALUE self, VALUE to)
{
    return rb_funcall(rb_cFile, rb_intern("rename"), 2, get_strpath(self), to);
}

Переименовать файл.

См. File.rename.

rmdir() Show source

static VALUE
path_rmdir(VALUE self)
{
    return rb_funcall(rb_cDir, rb_intern("rmdir"), 1, get_strpath(self));
}

Удалить указанный каталог.

См. Dir.rmdir.

rmtree() Show source

# File ext/pathname/lib/pathname.rb, line 583
def rmtree
  # The name "rmtree" is borrowed from File::Path of Perl.
  # File::Path provides "mkpath" and "rmtree".
  require 'fileutils'
  FileUtils.rm_r(@path)
  nil
end

Рекурсивно удаляет каталог, включая все вложенные каталоги.

См. FileUtils#rm_r

root?() Show source

# File ext/pathname/lib/pathname.rb, line 208
def root?
  !!(chop_basename(@path) == nil && /#{SEPARATOR_PAT}/o =~ @path)
end

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

Он не обращается к файловой системе. Поэтому он может вернуть false для некоторых имен путей, указывающих на корни, такие как /usr/...

setgid?() Show source

static VALUE
path_setgid_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, rb_intern("setgid?"), 1, get_strpath(self));
}

См. FileTest#setgid?.

setuid?() Show source

static VALUE
path_setuid_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, rb_intern("setuid?"), 1, get_strpath(self));
}

См. FileTest#setuid?.

size() Show source

static VALUE
path_size(VALUE self)
{
    return rb_funcall(rb_mFileTest, rb_intern("size"), 1, get_strpath(self));
}

См. FileTest#size.

size?() Show source

static VALUE
path_size_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, rb_intern("size?"), 1, get_strpath(self));
}

См. FileTest#size?.

socket?() Show source

static VALUE
path_socket_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, rb_intern("socket?"), 1, get_strpath(self));
}

См. FileTest#socket?.

split() Show source

static VALUE
path_split(VALUE self)
{
    VALUE str = get_strpath(self);
    VALUE ary, dirname, basename;
    ary = rb_funcall(rb_cFile, rb_intern("split"), 1, str);
    ary = rb_check_array_type(ary);
    dirname = rb_ary_entry(ary, 0);
    basename = rb_ary_entry(ary, 1);
    dirname = rb_class_new_instance(1, &dirname, rb_obj_class(self));
    basename = rb_class_new_instance(1, &basename, rb_obj_class(self));
    return rb_ary_new3(2, dirname, basename);
}

Возвращает dirname и basename в массиве.

См. File.split.

stat() Show source

static VALUE
path_stat(VALUE self)
{
    return rb_funcall(rb_cFile, rb_intern("stat"), 1, get_strpath(self));
}

Возвращает объект File::Stat.

См. File.stat.

sticky?() Show source

static VALUE
path_sticky_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, rb_intern("sticky?"), 1, get_strpath(self));
}

См. FileTest#sticky?.

sub(*args) Show source

static VALUE
path_sub(int argc, VALUE *argv, VALUE self)
{
    VALUE str = get_strpath(self);

    if (rb_block_given_p()) {
        str = rb_block_call(str, rb_intern("sub"), argc, argv, 0, 0);
    }
    else {
        str = rb_funcall2(str, rb_intern("sub"), argc, argv);
    }
    return rb_class_new_instance(1, &str, rb_obj_class(self));
}

Возвращает имя пути, которое заменено с помощью String#sub.

path1 = Pathname.new('/usr/bin/perl')
path1.sub('perl', 'ruby')
    #=> #<Pathname:/usr/bin/ruby>

sub_ext(p1) Show source

static VALUE
path_sub_ext(VALUE self, VALUE repl)
{
    VALUE str = get_strpath(self);
    VALUE str2;
    long extlen;
    const char *ext;
    const char *p;

    StringValue(repl);
    p = RSTRING_PTR(str);
    extlen = RSTRING_LEN(str);
    ext = ruby_enc_find_extname(p, &extlen, rb_enc_get(str));
    if (ext == NULL) {
        ext = p + RSTRING_LEN(str);
    }
    else if (extlen <= 1) {
        ext += extlen;
    }
    str2 = rb_str_subseq(str, 0, ext-p);
    rb_str_append(str2, repl);
    OBJ_INFECT(str2, str);
    return rb_class_new_instance(1, &str2, rb_obj_class(self));
}

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

Если self не имеет расширения, добавляется repl.

Pathname.new('/usr/bin/shutdown').sub_ext('.rb')
    #=> #<Pathname:/usr/bin/shutdown.rb>

symlink?() Show source

static VALUE
path_symlink_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, rb_intern("symlink?"), 1, get_strpath(self));
}

См. FileTest#symlink?.

sysopen([mode, [perm]]) → fixnum Show source

static VALUE
path_sysopen(int argc, VALUE *argv, VALUE self)
{
    VALUE args[3];
    int n;

    args[0] = get_strpath(self);
    n = rb_scan_args(argc, argv, "02", &args[1], &args[2]);
    return rb_funcall2(rb_cIO, rb_intern("sysopen"), 1+n, args);
}

См. IO.sysopen.

taint → obj Show source

static VALUE
path_taint(VALUE self)
{
    rb_call_super(0, 0);
    rb_obj_taint(get_strpath(self));
    return self;
}

Заражает это Pathname.

См. Object#taint.

to_path → string Show source

static VALUE
path_to_s(VALUE self)
{
    return rb_obj_dup(get_strpath(self));
}

Возвращает путь в виде строки.

#to_path реализован, поэтому объекты Pathname могут использоваться с File.open и т.д.

to_s → string Show source

static VALUE
path_to_s(VALUE self)
{
    return rb_obj_dup(get_strpath(self));
}

Возвращает путь в виде строки.

#to_path реализован, поэтому объекты Pathname могут использоваться с File.open и т.д.

truncate(p1) Show source

static VALUE
path_truncate(VALUE self, VALUE length)
{
    return rb_funcall(rb_cFile, rb_intern("truncate"), 2, get_strpath(self), length);
}

Усекает файл до length байт.

См. File.truncate.

unlink() Show source

static VALUE
path_unlink(VALUE self)
{
    VALUE eENOTDIR = rb_const_get_at(rb_mErrno, rb_intern("ENOTDIR"));
    VALUE str = get_strpath(self);
    return rb_rescue2(unlink_body, str, unlink_rescue, str, eENOTDIR, (VALUE)0);
}

Удаляет файл или каталог, используя File.unlink, если self является файлом, или Dir.unlink по мере необходимости.

untaint → obj Show source

static VALUE
path_untaint(VALUE self)
{
    rb_call_super(0, 0);
    rb_obj_untaint(get_strpath(self));
    return self;
}

Очищает от taint это Pathname.

См. Object#untaint.

utime(p1, p2) Show source

static VALUE
path_utime(VALUE self, VALUE atime, VALUE mtime)
{
    return rb_funcall(rb_cFile, rb_intern("utime"), 3, atime, mtime, get_strpath(self));
}

Обновляет время доступа и изменения файла.

См. File.utime.

world_readable?() Show source

static VALUE
path_world_readable_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, rb_intern("world_readable?"), 1, get_strpath(self));
}

См. FileTest#world_readable?.

world_writable?() Show source

static VALUE
path_world_writable_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, rb_intern("world_writable?"), 1, get_strpath(self));
}

См. FileTest#world_writable?.

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

static VALUE
path_writable_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, rb_intern("writable?"), 1, get_strpath(self));
}

См. FileTest#writable?.

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

static VALUE
path_writable_real_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, rb_intern("writable_real?"), 1, get_strpath(self));
}

См. FileTest#writable_real?.

write(string, [offset] ) → fixnum Показать исходный код

write(string, [offset], open_args ) → fixnum

static VALUE
path_write(int argc, VALUE *argv, VALUE self)
{
    VALUE args[4];
    int n;

    args[0] = get_strpath(self);
    n = rb_scan_args(argc, argv, "03", &args[1], &args[2], &args[3]);
    return rb_funcall2(rb_cIO, rb_intern("write"), 1+n, args);
}

Записывает contents в файл.

См. IO.write.

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

static VALUE
path_zero_p(VALUE self)
{
    return rb_funcall(rb_mFileTest, rb_intern("zero?"), 1, get_strpath(self));
}

См. FileTest#zero?.

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