модуль FileUtils

# File lib/fileutils.rb, line 242
def cd(dir, verbose: nil, &block) # :yield: dir
  fu_output_message "cd #{dir}" if verbose
  result = Dir.chdir(dir, &block)
  fu_output_message 'cd -' if verbose and block
  result
end

Изменяет текущий рабочий каталог на указанный dir, который должен быть интерпретируем как путь:

Без блока, изменяет текущий каталог на каталог по dir; возвращает ноль:

FileUtils.pwd # => "/rdoc/fileutils"
FileUtils.cd('..')
FileUtils.pwd # => "/rdoc"
FileUtils.cd('fileutils')

С блоком, изменяет текущий каталог на каталог по dir, вызывает блок с аргументом dir, и восстанавливает исходный текущий каталог; возвращает значение блока:

FileUtils.pwd                                     # => "/rdoc/fileutils"
FileUtils.cd('..') { |arg| [arg, FileUtils.pwd] } # => ["..", "/rdoc"]
FileUtils.pwd                                     # => "/rdoc/fileutils"

Ключевые аргументы:

• verbose: true - выводит эквивалентную команду:

  FileUtils.cd('..')
  FileUtils.cd('fileutils')
  

  Вывод:

  cd ..
  cd fileutils

FileUtils.chdir является псевдонимом для FileUtils.cd.

Связанные: FileUtils.pwd.

# File lib/fileutils.rb, line 1815
def chmod(mode, list, noop: nil, verbose: nil)
  list = fu_list(list)
  fu_output_message sprintf('chmod %s %s', mode_to_s(mode), list.join(' ')) if verbose
  return if noop
  list.each do |path|
    Entry_.new(path).chmod(fu_mode(mode, path))
  end
end

Изменяет разрешения на записи для элементов по путям, указанным в list (один путь или массив путей) на разрешения, заданные mode; возвращает list если это массив, [list] в противном случае:

• Изменяет каждый элемент, являющийся обычным файлом, используя File.chmod.

• Изменяет каждый элемент, являющийся символической ссылкой, используя File.lchmod.

Аргумент list или его элементы должны быть интерпретируемы как пути.

Аргумент mode может быть целым числом или строкой:

• Целое число mode: представляет биты разрешений, которые должны быть установлены:

  FileUtils.chmod(0755, 'src0.txt')
  FileUtils.chmod(0644, ['src0.txt', 'src0.dat'])
  

• Строка mode: представляет разрешения, которые должны быть установлены:

  Строка имеет вид [targets][[operator][perms[,perms]], где:

  • targets может быть любой комбинацией этих букв:

    • 'u': разрешения применяются к владельцу файла.

    • 'g': разрешения применяются к пользователям в группе файла.

    • 'o': разрешения применяются к другим пользователям, не входящим в группу файла.

    • 'a' (по умолчанию): разрешения применяются ко всем пользователям.

  • operator может быть одной из этих букв:

    • '+': добавляет разрешения.

    • '-': удаляет разрешения.

    • '=': устанавливает (заменяет) разрешения.

  • perms (может повторяться, с разделителями запятыми) может быть любой комбинацией этих букв:

    • 'r': Чтение.

    • 'w': Запись.

    • 'x': Выполнение (поиск, для каталога).

    • 'X': Поиск (только для каталогов; обязательно использовать с '+')

    • 's': Uid или gid.

    • 't': Бит "приклеивания" (sticky bit).

  Примеры:

  FileUtils.chmod('u=wrx,go=rx', 'src1.txt')
  FileUtils.chmod('u=wrx,go=rx', '/usr/bin/ruby')
  

Ключевые аргументы:

• noop: true - не изменяет разрешения; возвращает nil.

• verbose: true - выводит эквивалентную команду:

  FileUtils.chmod(0755, 'src0.txt', noop: true, verbose: true)
  FileUtils.chmod(0644, ['src0.txt', 'src0.dat'], noop: true, verbose: true)
  FileUtils.chmod('u=wrx,go=rx', 'src1.txt', noop: true, verbose: true)
  FileUtils.chmod('u=wrx,go=rx', '/usr/bin/ruby', noop: true, verbose: true)
  

  Вывод:

  chmod 755 src0.txt
  chmod 644 src0.txt src0.dat
  chmod u=wrx,go=rx src1.txt
  chmod u=wrx,go=rx /usr/bin/ruby

Связанные: FileUtils.chmod_R.

# File lib/fileutils.rb, line 1827
def chmod_R(mode, list, noop: nil, verbose: nil, force: nil)
  list = fu_list(list)
  fu_output_message sprintf('chmod -R%s %s %s',
                            (force ? 'f' : ''),
                            mode_to_s(mode), list.join(' ')) if verbose
  return if noop
  list.each do |root|
    Entry_.new(root).traverse do |ent|
      begin
        ent.chmod(fu_mode(mode, ent.path))
      rescue
        raise unless force
      end
    end
  end
end

Как FileUtils.chmod, но изменяет разрешения рекурсивно.

# File lib/fileutils.rb, line 1908
def chown(user, group, list, noop: nil, verbose: nil)
  list = fu_list(list)
  fu_output_message sprintf('chown %s %s',
                            (group ? "#{user}:#{group}" : user || ':'),
                            list.join(' ')) if verbose
  return if noop
  uid = fu_get_uid(user)
  gid = fu_get_gid(group)
  list.each do |path|
    Entry_.new(path).chown uid, gid
  end
end

Изменяет владельца и группу для элементов по путям, указанным в list (один путь или массив путей) на указанных user и group; возвращает list если это массив, [list] в противном случае:

• Изменяет каждый элемент, являющийся обычным файлом, используя File.chown.

• Изменяет каждый элемент, являющийся символической ссылкой, используя File.lchown.

Аргумент list или его элементы должны быть интерпретируемы как пути.

Пользователь и группа:

• Аргумент user может быть именем пользователя или идентификатором пользователя; если nil или -1, пользователь не меняется.

• Аргумент group может быть именем группы или идентификатором группы; если nil или -1, группа не меняется.

• Пользователь должен быть членом группы.

Примеры:

# One path.
# User and group as string names.
File.stat('src0.txt').uid # => 1004
File.stat('src0.txt').gid # => 1004
FileUtils.chown('user2', 'group1', 'src0.txt')
File.stat('src0.txt').uid # => 1006
File.stat('src0.txt').gid # => 1005

# User and group as uid and gid.
FileUtils.chown(1004, 1004, 'src0.txt')
File.stat('src0.txt').uid # => 1004
File.stat('src0.txt').gid # => 1004

# Array of paths.
FileUtils.chown(1006, 1005, ['src0.txt', 'src0.dat'])

# Directory (not recursive).
FileUtils.chown('user2', 'group1', '.')

Ключевые аргументы:

• noop: true - не изменяет разрешения; возвращает nil.

• verbose: true - выводит эквивалентную команду:

  FileUtils.chown('user2', 'group1', 'src0.txt', noop: true, verbose: true)
  FileUtils.chown(1004, 1004, 'src0.txt', noop: true, verbose: true)
  FileUtils.chown(1006, 1005, ['src0.txt', 'src0.dat'], noop: true, verbose: true)
  FileUtils.chown('user2', 'group1', path, noop: true, verbose: true)
  FileUtils.chown('user2', 'group1', '.', noop: true, verbose: true)
  

  Вывод:

  chown user2:group1 src0.txt
  chown 1004:1004 src0.txt
  chown 1006:1005 src0.txt src0.dat
  chown user2:group1 src0.txt
  chown user2:group1 .

Связанные: FileUtils.chown_R.

# File lib/fileutils.rb, line 1924
def chown_R(user, group, list, noop: nil, verbose: nil, force: nil)
  list = fu_list(list)
  fu_output_message sprintf('chown -R%s %s %s',
                            (force ? 'f' : ''),
                            (group ? "#{user}:#{group}" : user || ':'),
                            list.join(' ')) if verbose
  return if noop
  uid = fu_get_uid(user)
  gid = fu_get_gid(group)
  list.each do |root|
    Entry_.new(root).traverse do |ent|
      begin
        ent.chown uid, gid
      rescue
        raise unless force
      end
    end
  end
end

Как FileUtils.chown, но изменяет владельца и группу рекурсивно.

# File lib/fileutils.rb, line 2621
def self.collect_method(opt)
  OPT_TABLE.keys.select {|m| OPT_TABLE[m].include?(opt) }
end

Возвращает массив имён строковых методов, которые принимают данный ключевой параметр opt; аргумент должен быть символом:

FileUtils.collect_method(:preserve) # => ["cp", "copy", "cp_r", "install"]

# File lib/fileutils.rb, line 2582
def self.commands
  OPT_TABLE.keys
end

Возвращает массив имён строковых методов FileUtils, которые принимают один или несколько ключевых аргументов:

FileUtils.commands.sort.take(3) # => ["cd", "chdir", "chmod"]

# File lib/fileutils.rb, line 1525
def compare_file(a, b)
  return false unless File.size(a) == File.size(b)
  File.open(a, 'rb') {|fa|
    File.open(b, 'rb') {|fb|
      return compare_stream(fa, fb)
    }
  }
end

Возвращает true если содержимое файлов a и b идентичны, false в противном случае.

Аргументы a и b должны быть интерпретируемы как пути.

FileUtils.identical? и FileUtils.cmp являются псевдонимами для FileUtils.compare_file.

Связанные: FileUtils.compare_stream.

# File lib/fileutils.rb, line 1548
def compare_stream(a, b)
  bsize = fu_stream_blksize(a, b)

  sa = String.new(capacity: bsize)
  sb = String.new(capacity: bsize)

  begin
    a.read(bsize, sa)
    b.read(bsize, sb)
    return true if sa.empty? && sb.empty?
  end while sa == sb
  false
end

Возвращает true если содержимое потоков a и b идентичны, false в противном случае.

Аргументы a и b должны быть интерпретируемы как пути.

Связанные: FileUtils.compare_file.

# File lib/fileutils.rb, line 1050
def copy_entry(src, dest, preserve = false, dereference_root = false, remove_destination = false)
  if dereference_root
    src = File.realpath(src)
  end

  Entry_.new(src, nil, false).wrap_traverse(proc do |ent|
    destent = Entry_.new(dest, ent.rel, false)
    File.unlink destent.path if remove_destination && (File.file?(destent.path) || File.symlink?(destent.path))
    ent.copy destent.path
  end, proc do |ent|
    destent = Entry_.new(dest, ent.rel, false)
    ent.copy_metadata destent.path if preserve
  end)
end

Рекурсивно копирует файлы из src в dest.

Аргументы src и dest должны быть интерпретируемы как пути.

Если src — путь к файлу, копирует src в dest:

FileUtils.touch('src0.txt')
File.exist?('dest0.txt') # => false
FileUtils.copy_entry('src0.txt', 'dest0.txt')
File.file?('dest0.txt')  # => true

Если src — путь к каталогу, рекурсивно копирует src в dest:

tree('src1')
# => src1
#    |-- dir0
#    |   |-- src0.txt
#    |   `-- src1.txt
#    `-- dir1
#        |-- src2.txt
#        `-- src3.txt
FileUtils.copy_entry('src1', 'dest1')
tree('dest1')
# => dest1
#    |-- dir0
#    |   |-- src0.txt
#    |   `-- src1.txt
#    `-- dir1
#        |-- src2.txt
#        `-- src3.txt

Рекурсивное копирование сохраняет типы файлов для обычных файлов, каталогов и символических ссылок; другие типы файлов (FIFO потоки, файлы устройств и т. д.) не поддерживаются.

Ключевые аргументы:

• dereference_root: true — если src является символической ссылкой, следует за ссылкой.

• preserve: true — сохраняет временные метки файлов.

• remove_destination: true — удаляет dest перед копированием файлов.

Связанные: методы для копирования.

# File lib/fileutils.rb, line 1086
def copy_file(src, dest, preserve = false, dereference = true)
  ent = Entry_.new(src, nil, dereference)
  ent.copy_file dest
  ent.copy_metadata dest if preserve
end

Копирует файл из src в dest, которые не должны быть каталогами.

Аргументы src и dest должны быть интерпретируемы как пути.

Примеры:

FileUtils.touch('src0.txt')
FileUtils.copy_file('src0.txt', 'dest0.txt')
File.file?('dest0.txt') # => true

Ключевые аргументы:

• dereference: false — если src является символической ссылкой, не следует за ссылкой.

• preserve: true — сохраняет временные метки файлов.

• remove_destination: true — удаляет dest перед копированием файлов.

Связанные: методы для копирования.

# File lib/fileutils.rb, line 1098
def copy_stream(src, dest)
  IO.copy_stream(src, dest)
end

Копирует поток ввода-вывода src в поток ввода-вывода dest через IO.copy_stream.

Связанные: методы для копирования.

# File lib/fileutils.rb, line 883
def cp(src, dest, preserve: nil, noop: nil, verbose: nil)
  fu_output_message "cp#{preserve ? ' -p' : ''} #{[src,dest].flatten.join ' '}" if verbose
  return if noop
  fu_each_src_dest(src, dest) do |s, d|
    copy_file s, d, preserve
  end
end

Копирует файлы.

Аргументы src (один путь или массив путей) и dest (один путь) должны быть интерпретируемы как пути.

Если src — путь к файлу, а dest — не путь к каталогу, копирует src в dest:

FileUtils.touch('src0.txt')
File.exist?('dest0.txt') # => false
FileUtils.cp('src0.txt', 'dest0.txt')
File.file?('dest0.txt')  # => true

Если src — путь к файлу, а dest — путь к каталогу, копирует src в dest/src:

FileUtils.touch('src1.txt')
FileUtils.mkdir('dest1')
FileUtils.cp('src1.txt', 'dest1')
File.file?('dest1/src1.txt') # => true

Если src — массив путей к файлам, а dest — путь к каталогу, копирует из каждого src в dest:

src_file_paths = ['src2.txt', 'src2.dat']
FileUtils.touch(src_file_paths)
FileUtils.mkdir('dest2')
FileUtils.cp(src_file_paths, 'dest2')
File.file?('dest2/src2.txt') # => true
File.file?('dest2/src2.dat') # => true

Ключевые аргументы:

• preserve: true — сохраняет временные метки файлов.

• noop: true — не копирует файлы.

• verbose: true — печатает эквивалентную команду:

  FileUtils.cp('src0.txt', 'dest0.txt', noop: true, verbose: true)
  FileUtils.cp('src1.txt', 'dest1', noop: true, verbose: true)
  FileUtils.cp(src_file_paths, 'dest2', noop: true, verbose: true)
  

  Вывод:

  cp src0.txt dest0.txt
  cp src1.txt dest1
  cp src2.txt src2.dat dest2
  

Вызывает исключение, если src — это каталог.

FileUtils.copy — псевдоним для FileUtils.cp.

Связанные: методы для копирования.

# File lib/fileutils.rb, line 633
def cp_lr(src, dest, noop: nil, verbose: nil,
          dereference_root: true, remove_destination: false)
  fu_output_message "cp -lr#{remove_destination ? ' --remove-destination' : ''} #{[src,dest].flatten.join ' '}" if verbose
  return if noop
  fu_each_src_dest(src, dest) do |s, d|
    link_entry s, d, dereference_root, remove_destination
  end
end

Создаёт жёсткие ссылки.

Аргументы src (один путь или массив путей) и dest (один путь) должны быть интерпретируемы как пути.

Если src — путь к каталогу, а dest не существует, создаёт ссылки dest и потомков, указывающие на src и его потомков:

tree('src0')
# => src0
#    |-- sub0
#    |   |-- src0.txt
#    |   `-- src1.txt
#    `-- sub1
#        |-- src2.txt
#        `-- src3.txt
File.exist?('dest0') # => false
FileUtils.cp_lr('src0', 'dest0')
tree('dest0')
# => dest0
#    |-- sub0
#    |   |-- src0.txt
#    |   `-- src1.txt
#    `-- sub1
#        |-- src2.txt
#        `-- src3.txt

Если src и dest — оба пути к каталогам, создаёт ссылки dest/src и потомков, указывающие на src и его потомков:

tree('src1')
# => src1
#    |-- sub0
#    |   |-- src0.txt
#    |   `-- src1.txt
#    `-- sub1
#        |-- src2.txt
#        `-- src3.txt
FileUtils.mkdir('dest1')
FileUtils.cp_lr('src1', 'dest1')
tree('dest1')
# => dest1
#    `-- src1
#        |-- sub0
#        |   |-- src0.txt
#        |   `-- src1.txt
#        `-- sub1
#            |-- src2.txt
#            `-- src3.txt

Если src — массив путей к записям, а dest — путь к каталогу, для каждого пути filepath в src, создаёт ссылку в dest/filepath указывающую на этот путь:

tree('src2')
# => src2
#    |-- sub0
#    |   |-- src0.txt
#    |   `-- src1.txt
#    `-- sub1
#        |-- src2.txt
#        `-- src3.txt
FileUtils.mkdir('dest2')
FileUtils.cp_lr(['src2/sub0', 'src2/sub1'], 'dest2')
tree('dest2')
# => dest2
#    |-- sub0
#    |   |-- src0.txt
#    |   `-- src1.txt
#    `-- sub1
#        |-- src2.txt
#        `-- src3.txt

Ключевые аргументы:

• dereference_root: false — если src является символической ссылкой, не следует за ней.

• noop: true — не создавать ссылки.

• remove_destination: true — удаляет dest перед созданием ссылок.

• verbose: true — печатает эквивалентную команду:

  FileUtils.cp_lr('src0', 'dest0', noop: true, verbose: true)
  FileUtils.cp_lr('src1', 'dest1', noop: true, verbose: true)
  FileUtils.cp_lr(['src2/sub0', 'src2/sub1'], 'dest2', noop: true, verbose: true)
  

  Вывод:

  cp -lr src0 dest0
  cp -lr src1 dest1
  cp -lr src2/sub0 src2/sub1 dest2

Вызывает исключение, если dest — это существующий файл или каталог, и ключевой аргумент remove_destination: true не указан.

Связанные: методы для копирования.

# File lib/fileutils.rb, line 995
def cp_r(src, dest, preserve: nil, noop: nil, verbose: nil,
         dereference_root: true, remove_destination: nil)
  fu_output_message "cp -r#{preserve ? 'p' : ''}#{remove_destination ? ' --remove-destination' : ''} #{[src,dest].flatten.join ' '}" if verbose
  return if noop
  fu_each_src_dest(src, dest) do |s, d|
    copy_entry s, d, preserve, dereference_root, remove_destination
  end
end

Рекурсивно копирует файлы.

Аргументы src (один путь или массив путей) и dest (один путь) должны быть интерпретируемы как пути.

Режим, владелец и группа сохраняются в копии; для изменения их, используйте FileUtils.install вместо этого.

Если src — путь к файлу, а dest — не путь к каталогу, копирует src в dest:

FileUtils.touch('src0.txt')
File.exist?('dest0.txt') # => false
FileUtils.cp_r('src0.txt', 'dest0.txt')
File.file?('dest0.txt')  # => true

Если src — путь к файлу, а dest — путь к каталогу, копирует src в dest/src:

FileUtils.touch('src1.txt')
FileUtils.mkdir('dest1')
FileUtils.cp_r('src1.txt', 'dest1')
File.file?('dest1/src1.txt') # => true

Если src — путь к каталогу, а dest не существует, рекурсивно копирует src в dest:

tree('src2')
# => src2
#    |-- dir0
#    |   |-- src0.txt
#    |   `-- src1.txt
#    `-- dir1
#    |-- src2.txt
#    `-- src3.txt
FileUtils.exist?('dest2') # => false
FileUtils.cp_r('src2', 'dest2')
tree('dest2')
# => dest2
#    |-- dir0
#    |   |-- src0.txt
#    |   `-- src1.txt
#    `-- dir1
#    |-- src2.txt
#    `-- src3.txt

Если src и dest — пути к каталогам, рекурсивно копирует src в dest/src:

tree('src3')
# => src3
#    |-- dir0
#    |   |-- src0.txt
#    |   `-- src1.txt
#    `-- dir1
#    |-- src2.txt
#    `-- src3.txt
FileUtils.mkdir('dest3')
FileUtils.cp_r('src3', 'dest3')
tree('dest3')
# => dest3
#    `-- src3
#      |-- dir0
#      |   |-- src0.txt
#      |   `-- src1.txt
#      `-- dir1
#          |-- src2.txt
#          `-- src3.txt

Если src — массив путей и dest — каталог, рекурсивно копирует из каждого пути в src в dest; пути в src могут указывать на файлы и/или каталоги.

Ключевые аргументы:

• dereference_root: false — если src является символической ссылкой, не следует за ней.

• noop: true — не копировать файлы.

• preserve: true — сохраняет временные метки файлов.

• remove_destination: true — удаляет dest перед копированием файлов.

• verbose: true — печатает эквивалентную команду:

  FileUtils.cp_r('src0.txt', 'dest0.txt', noop: true, verbose: true)
  FileUtils.cp_r('src1.txt', 'dest1', noop: true, verbose: true)
  FileUtils.cp_r('src2', 'dest2', noop: true, verbose: true)
  FileUtils.cp_r('src3', 'dest3', noop: true, verbose: true)
  

  Вывод:

  cp -r src0.txt dest0.txt
  cp -r src1.txt dest1
  cp -r src2 dest2
  cp -r src3 dest3

Вызывает исключение, если src — путь к каталогу, а dest — путь к файлу.

Связанные: методы для копирования.

# File lib/fileutils.rb, line 2600
def self.have_option?(mid, opt)
  li = OPT_TABLE[mid.to_s] or raise ArgumentError, "no such method: #{mid}"
  li.include?(opt)
end

Возвращает true , если метод mid принимает заданный параметр opt, в противном случае false; аргументы могут быть строками или символами:

FileUtils.have_option?(:chmod, :noop) # => true
FileUtils.have_option?('chmod', 'secure') # => false

# File lib/fileutils.rb, line 1627
def install(src, dest, mode: nil, owner: nil, group: nil, preserve: nil,
            noop: nil, verbose: nil)
  if verbose
    msg = +"install -c"
    msg << ' -p' if preserve
    msg << ' -m ' << mode_to_s(mode) if mode
    msg << " -o #{owner}" if owner
    msg << " -g #{group}" if group
    msg << ' ' << [src,dest].flatten.join(' ')
    fu_output_message msg
  end
  return if noop
  uid = fu_get_uid(owner)
  gid = fu_get_gid(group)
  fu_each_src_dest(src, dest) do |s, d|
    st = File.stat(s)
    unless File.exist?(d) and compare_file(s, d)
      remove_file d, true
      copy_file s, d
      File.utime st.atime, st.mtime, d if preserve
      File.chmod fu_mode(mode, st), d if mode
      File.chown uid, gid, d if uid or gid
    end
  end
end

Копирует элемент файла. См. install(1).

Аргументы src (один путь или массив путей) и dest (один путь) должны быть интерпретируемы как пути;

Если элемент в dest не существует, копирует из src в dest:

File.read('src0.txt')    # => "aaa\n"
File.exist?('dest0.txt') # => false
FileUtils.install('src0.txt', 'dest0.txt')
File.read('dest0.txt')   # => "aaa\n"

Если dest — это элемент файла, копирует из src в dest, перезаписывая:

File.read('src1.txt')  # => "aaa\n"
File.read('dest1.txt') # => "bbb\n"
FileUtils.install('src1.txt', 'dest1.txt')
File.read('dest1.txt') # => "aaa\n"

Если dest — это элемент каталога, копирует из src в dest/src, перезаписывая при необходимости:

File.read('src2.txt')       # => "aaa\n"
File.read('dest2/src2.txt') # => "bbb\n"
FileUtils.install('src2.txt', 'dest2')
File.read('dest2/src2.txt') # => "aaa\n"

Если src — это массив путей, а dest указывает на каталог, копирует каждый путь path в src в dest/path:

File.file?('src3.txt') # => true
File.file?('src3.dat') # => true
FileUtils.mkdir('dest3')
FileUtils.install(['src3.txt', 'src3.dat'], 'dest3')
File.file?('dest3/src3.txt') # => true
File.file?('dest3/src3.dat') # => true

Ключевые аргументы:

• group: group — изменяет группу, если она не nil, используя File.chown.

• mode: permissions — изменяет разрешения. используя File.chmod.

• noop: true — не копирует элементы; возвращает nil.

• owner: owner — изменяет владельца, если он не nil, используя File.chown.

• preserve: true — сохраняет временные метки, используя File.utime.

• verbose: true — выводит эквивалентную команду:

  FileUtils.install('src0.txt', 'dest0.txt', noop: true, verbose: true)
  FileUtils.install('src1.txt', 'dest1.txt', noop: true, verbose: true)
  FileUtils.install('src2.txt', 'dest2', noop: true, verbose: true)
  

  Вывод:

  install -c src0.txt dest0.txt
  install -c src1.txt dest1.txt
  install -c src2.txt dest2

Связанные: методы для копирования.

# File lib/fileutils.rb, line 820
def link_entry(src, dest, dereference_root = false, remove_destination = false)
  Entry_.new(src, nil, dereference_root).traverse do |ent|
    destent = Entry_.new(dest, ent.rel, false)
    File.unlink destent.path if remove_destination && File.file?(destent.path)
    ent.link destent.path
  end
end

Создаёт жёсткие ссылки; возвращает nil.

Аргументы src и dest должны быть интерпретируемы как пути.

Если src — путь к файлу и dest не существует, создаёт жёсткую ссылку в dest, указывающую на src:

FileUtils.touch('src0.txt')
File.exist?('dest0.txt') # => false
FileUtils.link_entry('src0.txt', 'dest0.txt')
File.file?('dest0.txt')  # => true

Если src — путь к каталогу и dest не существует, рекурсивно создаёт жёсткие ссылки в dest, указывающие на пути в src:

FileUtils.mkdir_p(['src1/dir0', 'src1/dir1'])
src_file_paths = [
  'src1/dir0/t0.txt',
  'src1/dir0/t1.txt',
  'src1/dir1/t2.txt',
  'src1/dir1/t3.txt',
  ]
FileUtils.touch(src_file_paths)
File.directory?('dest1')        # => true
FileUtils.link_entry('src1', 'dest1')
File.file?('dest1/dir0/t0.txt') # => true
File.file?('dest1/dir0/t1.txt') # => true
File.file?('dest1/dir1/t2.txt') # => true
File.file?('dest1/dir1/t3.txt') # => true

Ключевые аргументы:

• dereference_root: true — де-реферирует src если это символическая ссылка.

• remove_destination: true — удаляет dest перед созданием ссылок.

Вызывает исключение, если dest — путь к существующему файлу или каталогу, и ключевой аргумент remove_destination: true не задан.

Связанные: FileUtils.ln (с другими параметрами).

# File lib/fileutils.rb, line 522
def ln(src, dest, force: nil, noop: nil, verbose: nil)
  fu_output_message "ln#{force ? ' -f' : ''} #{[src,dest].flatten.join ' '}" if verbose
  return if noop
  fu_each_src_dest0(src, dest) do |s,d|
    remove_file d, true if force
    File.link s, d
  end
end

Создаёт жёсткие ссылки.

Аргументы src (один путь или массив путей) и dest (один путь) должны быть интерпретируемы как пути.

Когда src — путь к существующему файлу и dest — путь к несуществующему файлу, создаёт жёсткую ссылку в dest, указывающую на src; возвращает ноль:

Dir.children('tmp0/')                    # => ["t.txt"]
Dir.children('tmp1/')                    # => []
FileUtils.ln('tmp0/t.txt', 'tmp1/t.lnk') # => 0
Dir.children('tmp1/')                    # => ["t.lnk"]

Когда src — путь к существующему файлу и dest — путь к существующему каталогу, создаёт жёсткую ссылку в dest/src, указывающую на src; возвращает ноль:

Dir.children('tmp2')               # => ["t.dat"]
Dir.children('tmp3')               # => []
FileUtils.ln('tmp2/t.dat', 'tmp3') # => 0
Dir.children('tmp3')               # => ["t.dat"]

Когда src — массив путей к существующим файлам, а dest — путь к существующему каталогу, то для каждого пути target в src, создаёт жёсткую ссылку в dest/target, указывающую на target; возвращает src:

Dir.children('tmp4/')                               # => []
FileUtils.ln(['tmp0/t.txt', 'tmp2/t.dat'], 'tmp4/') # => ["tmp0/t.txt", "tmp2/t.dat"]
Dir.children('tmp4/')                               # => ["t.dat", "t.txt"]

Ключевые аргументы:

• force: true — перезаписывает dest если оно существует.

• noop: true — не создавать ссылки.

• verbose: true — выводит эквивалентную команду:

  FileUtils.ln('tmp0/t.txt', 'tmp1/t.lnk', verbose: true)
  FileUtils.ln('tmp2/t.dat', 'tmp3', verbose: true)
  FileUtils.ln(['tmp0/t.txt', 'tmp2/t.dat'], 'tmp4/', verbose: true)
  

  Вывод:

  ln tmp0/t.txt tmp1/t.lnk
  ln tmp2/t.dat tmp3
  ln tmp0/t.txt tmp2/t.dat tmp4/

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

FileUtils#link является псевдонимом для FileUtils#ln.

Связанные: FileUtils.link_entry (с другими параметрами).

# File lib/fileutils.rb, line 714
def ln_s(src, dest, force: nil, relative: false, target_directory: true, noop: nil, verbose: nil)
  if relative
    return ln_sr(src, dest, force: force, noop: noop, verbose: verbose)
  end
  fu_output_message "ln -s#{force ? 'f' : ''} #{[src,dest].flatten.join ' '}" if verbose
  return if noop
  fu_each_src_dest0(src, dest) do |s,d|
    remove_file d, true if force
    File.symlink s, d
  end
end

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

Аргументы src (один путь или массив путей) и dest (один путь) должны быть интерпретируемы как пути.

Если src — путь к существующему файлу:

• Когда dest — путь к несуществующему файлу, создаёт символическую ссылку в dest, указывающую на src:

  FileUtils.touch('src0.txt')
  File.exist?('dest0.txt')   # => false
  FileUtils.ln_s('src0.txt', 'dest0.txt')
  File.symlink?('dest0.txt') # => true
  

• Когда dest — путь к существующему файлу, создаёт символическую ссылку в dest, указывающую на src только если задан ключевой аргумент force: true (в противном случае вызывает исключение):

  FileUtils.touch('src1.txt')
  FileUtils.touch('dest1.txt')
  FileUtils.ln_s('src1.txt', 'dest1.txt', force: true)
  FileTest.symlink?('dest1.txt') # => true
  
  FileUtils.ln_s('src1.txt', 'dest1.txt') # Raises Errno::EEXIST.
  

Если dest — путь к каталогу, создаёт символическую ссылку в dest/src, указывающую на src:

FileUtils.touch('src2.txt')
FileUtils.mkdir('destdir2')
FileUtils.ln_s('src2.txt', 'destdir2')
File.symlink?('destdir2/src2.txt') # => true

Если src — массив путей к существующим файлам, а dest — каталог, для каждого подэлемента child в src создаёт символическую ссылку dest/child, указывающую на child:

FileUtils.mkdir('srcdir3')
FileUtils.touch('srcdir3/src0.txt')
FileUtils.touch('srcdir3/src1.txt')
FileUtils.mkdir('destdir3')
FileUtils.ln_s(['srcdir3/src0.txt', 'srcdir3/src1.txt'], 'destdir3')
File.symlink?('destdir3/src0.txt') # => true
File.symlink?('destdir3/src1.txt') # => true

Ключевые аргументы:

• force: true — перезаписывает dest если оно существует.

• relative: false — создавать ссылки относительно dest.

• noop: true — не создавать ссылки.

• verbose: true — выводит эквивалентную команду:

  FileUtils.ln_s('src0.txt', 'dest0.txt', noop: true, verbose: true)
  FileUtils.ln_s('src1.txt', 'destdir1', noop: true, verbose: true)
  FileUtils.ln_s('src2.txt', 'dest2.txt', force: true, noop: true, verbose: true)
  FileUtils.ln_s(['srcdir3/src0.txt', 'srcdir3/src1.txt'], 'destdir3', noop: true, verbose: true)
  

  Вывод:

  ln -s src0.txt dest0.txt
  ln -s src1.txt destdir1
  ln -sf src2.txt dest2.txt
  ln -s srcdir3/src0.txt srcdir3/src1.txt destdir3

FileUtils.symlink является псевдонимом для FileUtils.ln_s.

Связанные: FileUtils.ln_sf.

# File lib/fileutils.rb, line 732
def ln_sf(src, dest, noop: nil, verbose: nil)
  ln_s src, dest, force: true, noop: noop, verbose: verbose
end

Подобно FileUtils.ln_s, но всегда с заданным ключевым аргументом force: true.

# File lib/fileutils.rb, line 739
def ln_sr(src, dest, target_directory: true, force: nil, noop: nil, verbose: nil)
  options = "#{force ? 'f' : ''}#{target_directory ? '' : 'T'}"
  dest = File.path(dest)
  srcs = Array(src)
  link = proc do |s, target_dir_p = true|
    s = File.path(s)
    if target_dir_p
      d = File.join(destdirs = dest, File.basename(s))
    else
      destdirs = File.dirname(d = dest)
    end
    destdirs = fu_split_path(File.realpath(destdirs))
    if fu_starting_path?(s)
      srcdirs = fu_split_path((File.realdirpath(s) rescue File.expand_path(s)))
      base = fu_relative_components_from(srcdirs, destdirs)
      s = File.join(*base)
    else
      srcdirs = fu_clean_components(*fu_split_path(s))
      base = fu_relative_components_from(fu_split_path(Dir.pwd), destdirs)
      while srcdirs.first&. == ".." and base.last&.!=("..") and !fu_starting_path?(base.last)
        srcdirs.shift
        base.pop
      end
      s = File.join(*base, *srcdirs)
    end
    fu_output_message "ln -s#{options} #{s} #{d}" if verbose
    next if noop
    remove_file d, true if force
    File.symlink s, d
  end
  case srcs.size
  when 0
  when 1
    link[srcs[0], target_directory && File.directory?(dest)]
  else
    srcs.each(&link)
  end
end

Аналогично FileUtils.ln_s, но создает ссылки, относительные к dest.

# File lib/fileutils.rb, line 320
def mkdir(list, mode: nil, noop: nil, verbose: nil)
  list = fu_list(list)
  fu_output_message "mkdir #{mode ? ('-m %03o ' % mode) : ''}#{list.join ' '}" if verbose
  return if noop

  list.each do |dir|
    fu_mkdir dir, mode
  end
end

Создаёт каталоги по указанным путям в list (один путь или массив путей); возвращает list при массиве, [list] в противном случае.

Аргумент list или его элементы должны быть интерпретируемы как пути.

Без ключевых аргументов создаёт каталог по каждому path в list, вызывая: Dir.mkdir(path, mode); см. Dir.mkdir:

FileUtils.mkdir(%w[tmp0 tmp1]) # => ["tmp0", "tmp1"]
FileUtils.mkdir('tmp4')        # => ["tmp4"]

Ключевые аргументы:

• mode: mode - также вызывает File.chmod(mode, path); см. File.chmod.

• noop: true - не создаёт каталоги.

• verbose: true - выводит эквивалентную команду:

  FileUtils.mkdir(%w[tmp0 tmp1], verbose: true)
  FileUtils.mkdir(%w[tmp2 tmp3], mode: 0700, verbose: true)
  

  Вывод:

  mkdir tmp0 tmp1
  mkdir -m 700 tmp2 tmp3

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

Связанно с: FileUtils.mkdir_p.

# File lib/fileutils.rb, line 369
def mkdir_p(list, mode: nil, noop: nil, verbose: nil)
  list = fu_list(list)
  fu_output_message "mkdir -p #{mode ? ('-m %03o ' % mode) : ''}#{list.join ' '}" if verbose
  return *list if noop

  list.each do |item|
    path = remove_trailing_slash(item)

    stack = []
    until File.directory?(path) || File.dirname(path) == path
      stack.push path
      path = File.dirname(path)
    end
    stack.reverse_each do |dir|
      begin
        fu_mkdir dir, mode
      rescue SystemCallError
        raise unless File.directory?(dir)
      end
    end
  end

  return *list
end

Создаёт каталоги по указанным путям в list (один путь или массив путей), также создавая необходимые предковые каталоги; возвращает list при массиве, [list] в противном случае.

Аргумент list или его элементы должны быть интерпретируемы как пути.

Без ключевых аргументов создаёт каталог по каждому path в list, а также любые необходимые предковые каталоги, вызывая: Dir.mkdir(path, mode); см. Dir.mkdir:

FileUtils.mkdir_p(%w[tmp0/tmp1 tmp2/tmp3]) # => ["tmp0/tmp1", "tmp2/tmp3"]
FileUtils.mkdir_p('tmp4/tmp5')             # => ["tmp4/tmp5"]

Ключевые аргументы:

• mode: mode - также вызывает File.chmod(mode, path); см. File.chmod.

• noop: true - не создаёт каталоги.

• verbose: true - выводит эквивалентную команду:

  FileUtils.mkdir_p(%w[tmp0 tmp1], verbose: true)
  FileUtils.mkdir_p(%w[tmp2 tmp3], mode: 0700, verbose: true)
  

  Вывод:

  mkdir -p tmp0 tmp1
  mkdir -p -m 700 tmp2 tmp3

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

FileUtils.mkpath и FileUtils.makedirs являются псевдонимами для FileUtils.mkdir_p.

Связанно с: FileUtils.mkdir.

# File lib/fileutils.rb, line 1169
def mv(src, dest, force: nil, noop: nil, verbose: nil, secure: nil)
  fu_output_message "mv#{force ? ' -f' : ''} #{[src,dest].flatten.join ' '}" if verbose
  return if noop
  fu_each_src_dest(src, dest) do |s, d|
    destent = Entry_.new(d, nil, true)
    begin
      if destent.exist?
        if destent.directory?
          raise Errno::EEXIST, d
        end
      end
      begin
        File.rename s, d
      rescue Errno::EXDEV,
             Errno::EPERM # move from unencrypted to encrypted dir (ext4)
        copy_entry s, d, true
        if secure
          remove_entry_secure s, force
        else
          remove_entry s, force
        end
      end
    rescue SystemCallError
      raise unless force
    end
  end
end

Перемещает записи.

Аргументы src (один путь или массив путей) и dest (один путь) должны быть интерпретируемы как пути.

Если src и dest находятся на разных файловых системах, сначала копирует, затем удаляет src.

Может привести к уязвимости на локальном уровне, если не вызван с ключевым аргументом secure: true; см. Предотвращение уязвимости TOCTTOU.

Если src является путём к единственному файлу или каталогу и dest не существует, перемещает src в dest:

tree('src0')
# => src0
#    |-- src0.txt
#    `-- src1.txt
File.exist?('dest0') # => false
FileUtils.mv('src0', 'dest0')
File.exist?('src0')  # => false
tree('dest0')
# => dest0
#    |-- src0.txt
#    `-- src1.txt

Если src является массивом путей к файлам и каталогам, а dest является путём к каталогу, копирует из каждого пути в массиве в dest:

File.file?('src1.txt') # => true
tree('src1')
# => src1
#    |-- src.dat
#    `-- src.txt
Dir.empty?('dest1')    # => true
FileUtils.mv(['src1.txt', 'src1'], 'dest1')
tree('dest1')
# => dest1
#    |-- src1
#    |   |-- src.dat
#    |   `-- src.txt
#    `-- src1.txt

Ключевые аргументы:

• force: true - если перемещение включает удаление src (то есть, если src и dest находятся на разных файловых системах), игнорирует исключения StandardError и его потомков.

• noop: true - не перемещает файлы.

• secure: true - удаляет src безопасно; см. детали в FileUtils.remove_entry_secure.

• verbose: true - выводит эквивалентную команду:

  FileUtils.mv('src0', 'dest0', noop: true, verbose: true)
  FileUtils.mv(['src1.txt', 'src1'], 'dest1', noop: true, verbose: true)
  

  Вывод:

  mv src0 dest0
  mv src1.txt src1 dest1
  

FileUtils.move является псевдонимом для FileUtils.mv.

# File lib/fileutils.rb, line 2590
def self.options
  OPT_TABLE.values.flatten.uniq.map {|sym| sym.to_s }
end

Возвращает массив строк с именами ключевых аргументов:

FileUtils.options.take(3) # => ["noop", "verbose", "force"]

# File lib/fileutils.rb, line 2611
def self.options_of(mid)
  OPT_TABLE[mid.to_s].map {|sym| sym.to_s }
end

Возвращает массив строк с именами ключевых аргументов для метода mid; аргумент может быть строкой или символом:

FileUtils.options_of(:rm) # => ["force", "noop", "verbose"]
FileUtils.options_of('mv') # => ["force", "noop", "verbose", "secure"]

# File lib/fileutils.rb, line 199
def pwd
  Dir.pwd
end

Возвращает строку, содержащую путь к текущей директории:

FileUtils.pwd # => "/rdoc/fileutils"

FileUtils.getwd является псевдонимом для FileUtils.pwd.

Связанно с: FileUtils.cd.

# File lib/fileutils.rb, line 1510
def remove_dir(path, force = false)
  remove_entry path, force   # FIXME?? check if it is a directory
end

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

Аргумент path должен быть интерпретируемым как путь.

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

Связанно с: методами удаления.

# File lib/fileutils.rb, line 1467
def remove_entry(path, force = false)
  Entry_.new(path).postorder_traverse do |ent|
    begin
      ent.remove
    rescue
      raise unless force
    end
  end
rescue
  raise unless force
end

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

Аргумент path должен быть интерпретируемым как путь.

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

Связанно с: FileUtils.remove_entry_secure.

# File lib/fileutils.rb, line 1369
def remove_entry_secure(path, force = false)
  unless fu_have_symlink?
    remove_entry path, force
    return
  end
  fullpath = File.expand_path(path)
  st = File.lstat(fullpath)
  unless st.directory?
    File.unlink fullpath
    return
  end
  # is a directory.
  parent_st = File.stat(File.dirname(fullpath))
  unless parent_st.world_writable?
    remove_entry path, force
    return
  end
  unless parent_st.sticky?
    raise ArgumentError, "parent directory is world writable, FileUtils#remove_entry_secure does not work; abort: #{path.inspect} (parent directory mode #{'%o' % parent_st.mode})"
  end

  # freeze tree root
  euid = Process.euid
  dot_file = fullpath + "/."
  begin
    File.open(dot_file) {|f|
      unless fu_stat_identical_entry?(st, f.stat)
        # symlink (TOC-to-TOU attack?)
        File.unlink fullpath
        return
      end
      f.chown euid, -1
      f.chmod 0700
    }
  rescue Errno::EISDIR # JRuby in non-native mode can't open files as dirs
    File.lstat(dot_file).tap {|fstat|
      unless fu_stat_identical_entry?(st, fstat)
        # symlink (TOC-to-TOU attack?)
        File.unlink fullpath
        return
      end
      File.chown euid, -1, dot_file
      File.chmod 0700, dot_file
    }
  end

  unless fu_stat_identical_entry?(st, File.lstat(fullpath))
    # TOC-to-TOU attack?
    File.unlink fullpath
    return
  end

  # ---- tree root is frozen ----
  root = Entry_.new(path)
  root.preorder_traverse do |ent|
    if ent.directory?
      ent.chown euid, -1
      ent.chmod 0700
    end
  end
  root.postorder_traverse do |ent|
    begin
      ent.remove
    rescue
      raise unless force
    end
  end
rescue
  raise unless force
end

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

Аргумент path должен быть интерпретируемым как путь.

Избегает локальной уязвимости, которая может возникнуть в определённых обстоятельствах; см. Предотвращение уязвимости TOCTTOU.

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

Связанно с: методами удаления.

# File lib/fileutils.rb, line 1491
def remove_file(path, force = false)
  Entry_.new(path).remove_file
rescue
  raise unless force
end

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

Аргумент path должен быть интерпретируемым как путь.

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

Связанно с: методами удаления.

# File lib/fileutils.rb, line 1230
def rm(list, force: nil, noop: nil, verbose: nil)
  list = fu_list(list)
  fu_output_message "rm#{force ? ' -f' : ''} #{list.join ' '}" if verbose
  return if noop

  list.each do |path|
    remove_file path, force
  end
end

Удаляет записи по указанным путям в переданном list (один путь или массив путей), возвращает list, если это массив, [list] в противном случае.

Аргумент list или его элементы должны быть интерпретируемыми как пути.

Без ключевых аргументов удаляет файлы по путям, указанным в list:

FileUtils.touch(['src0.txt', 'src0.dat'])
FileUtils.rm(['src0.dat', 'src0.txt']) # => ["src0.dat", "src0.txt"]

Ключевые аргументы:

• force: true - игнорирует поднятые исключения класса StandardError и его потомков.

• noop: true - не удаляет файлы; возвращает nil.

• verbose: true - печатает эквивалентную команду:

  FileUtils.rm(['src0.dat', 'src0.txt'], noop: true, verbose: true)
  

  Вывод:

  rm src0.dat src0.txt
  

FileUtils.remove является псевдонимом для FileUtils.rm.

Связанно с: методами удаления.

# File lib/fileutils.rb, line 1257
def rm_f(list, noop: nil, verbose: nil)
  rm list, force: true, noop: noop, verbose: verbose
end

Эквивалентно:

FileUtils.rm(list, force: true, **kwargs)

Аргумент list (один путь или массив путей) должен быть интерпретируемым как путь.

См. FileUtils.rm для ключевых аргументов.

FileUtils.safe_unlink является псевдонимом для FileUtils.rm_f.

Связанно с: методами удаления.

# File lib/fileutils.rb, line 1315
def rm_r(list, force: nil, noop: nil, verbose: nil, secure: nil)
  list = fu_list(list)
  fu_output_message "rm -r#{force ? 'f' : ''} #{list.join ' '}" if verbose
  return if noop
  list.each do |path|
    if secure
      remove_entry_secure path, force
    else
      remove_entry path, force
    end
  end
end

Удаляет записи по указанным путям в переданном list (один путь или массив путей); возвращает list, если это массив, [list] в противном случае.

Аргумент list или его элементы должны быть интерпретируемыми как пути.

Может вызвать локальную уязвимость, если не вызывается с ключевым аргументом secure: true; см. Предотвращение уязвимости TOCTTOU.

Для каждого пути к файлу удаляется файл по этому пути:

FileUtils.touch(['src0.txt', 'src0.dat'])
FileUtils.rm_r(['src0.dat', 'src0.txt'])
File.exist?('src0.txt') # => false
File.exist?('src0.dat') # => false

Для каждого пути к каталогу рекурсивно удаляются файлы и каталоги:

tree('src1')
# => src1
#    |-- dir0
#    |   |-- src0.txt
#    |   `-- src1.txt
#    `-- dir1
#        |-- src2.txt
#        `-- src3.txt
FileUtils.rm_r('src1')
File.exist?('src1') # => false

Ключевые аргументы:

• force: true - игнорирует поднятые исключения класса StandardError и его потомков.

• noop: true - не удаляет записи; возвращает nil.

• secure: true - удаляет src безопасно; см. подробности в FileUtils.remove_entry_secure.

• verbose: true - печатает эквивалентную команду:

  FileUtils.rm_r(['src0.dat', 'src0.txt'], noop: true, verbose: true)
  FileUtils.rm_r('src1', noop: true, verbose: true)
  

  Вывод:

  rm -r src0.dat src0.txt
  rm -r src1

Связанно с: методами удаления.

# File lib/fileutils.rb, line 1346
def rm_rf(list, noop: nil, verbose: nil, secure: nil)
  rm_r list, force: true, noop: noop, verbose: verbose, secure: secure
end

Эквивалентно:

FileUtils.rm_r(list, force: true, **kwargs)

Аргумент list или его элементы должны быть интерпретируемыми как пути.

Может вызвать локальную уязвимость, если не вызывается с ключевым аргументом secure: true; см. Предотвращение уязвимости TOCTTOU.

См. FileUtils.rm_r для ключевых аргументов.

FileUtils.rmtree является псевдонимом для FileUtils.rm_rf.

Связанно с: методами удаления.

# File lib/fileutils.rb, line 446
def rmdir(list, parents: nil, noop: nil, verbose: nil)
  list = fu_list(list)
  fu_output_message "rmdir #{parents ? '-p ' : ''}#{list.join ' '}" if verbose
  return if noop
  list.each do |dir|
    Dir.rmdir(dir = remove_trailing_slash(dir))
    if parents
      begin
        until (parent = File.dirname(dir)) == '.' or parent == dir
          dir = parent
          Dir.rmdir(dir)
        end
      rescue Errno::ENOTEMPTY, Errno::EEXIST, Errno::ENOENT
      end
    end
  end
end

Удаляет каталоги по указанным путям в переданном list (один путь или массив путей); возвращает list, если это массив, [list] в противном случае.

Аргумент list или его элементы должны быть интерпретируемыми как пути.

Без ключевых аргументов удаляет каталог по каждому path в list, вызывая: Dir.rmdir(path); см. Dir.rmdir:

FileUtils.rmdir(%w[tmp0/tmp1 tmp2/tmp3]) # => ["tmp0/tmp1", "tmp2/tmp3"]
FileUtils.rmdir('tmp4/tmp5')             # => ["tmp4/tmp5"]

Ключевые аргументы:

• parents: true - удаляет последовательные родительские каталоги, если они пустые.

• noop: true - не удаляет каталоги.

• verbose: true - печатает эквивалентную команду:

  FileUtils.rmdir(%w[tmp0/tmp1 tmp2/tmp3], parents: true, verbose: true)
  FileUtils.rmdir('tmp4/tmp5', parents: true, verbose: true)
  

  Вывод:

  rmdir -p tmp0/tmp1 tmp2/tmp3
  rmdir -p tmp4/tmp5

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

Связанно с: методами удаления.

# File lib/fileutils.rb, line 2018
def touch(list, noop: nil, verbose: nil, mtime: nil, nocreate: nil)
  list = fu_list(list)
  t = mtime
  if verbose
    fu_output_message "touch #{nocreate ? '-c ' : ''}#{t ? t.strftime('-t %Y%m%d%H%M.%S ') : ''}#{list.join ' '}"
  end
  return if noop
  list.each do |path|
    created = nocreate
    begin
      File.utime(t, t, path)
    rescue Errno::ENOENT
      raise if created
      File.open(path, 'a') {
        ;
      }
      created = true
      retry if t
    end
  end
end

Обновляет время изменения (mtime) и время доступа (atime) записей, указанных путями в list (один путь или массив путей); возвращает list если это массив, [list] в противном случае.

По умолчанию создаёт пустой файл для любого пути несуществующей записи; используйте ключевой аргумент nocreate для повышения исключения вместо этого.

Аргумент list или его элементы должны быть интерпретируемы как пути.

Примеры:

# Single path.
f = File.new('src0.txt') # Existing file.
f.atime # => 2022-06-10 11:11:21.200277 -0700
f.mtime # => 2022-06-10 11:11:21.200277 -0700
FileUtils.touch('src0.txt')
f = File.new('src0.txt')
f.atime # => 2022-06-11 08:28:09.8185343 -0700
f.mtime # => 2022-06-11 08:28:09.8185343 -0700

# Array of paths.
FileUtils.touch(['src0.txt', 'src0.dat'])

Ключевые аргументы:

• mtime: time — устанавливает mtime записи на заданное время вместо текущего.

• nocreate: true — вызывает исключение, если запись не существует.

• noop: true — не трогает записи; возвращает nil.

• verbose: true — печатает эквивалентную команду:

  FileUtils.touch('src0.txt', noop: true, verbose: true)
  FileUtils.touch(['src0.txt', 'src0.dat'], noop: true, verbose: true)
  FileUtils.touch(path, noop: true, verbose: true)
  

  Вывод:

  touch src0.txt
  touch src0.txt src0.dat
  touch src0.txt
  

Связанно с: FileUtils.uptodate?.

# File lib/fileutils.rb, line 268
def uptodate?(new, old_list)
  return false unless File.exist?(new)
  new_time = File.mtime(new)
  old_list.each do |old|
    if File.exist?(old)
      return false unless new_time > File.mtime(old)
    end
  end
  true
end

Возвращает true если файл по пути new новее всех файлов по путям в массиве old_list; false в противном случае.

Аргумент new и элементы old_list должны быть интерпретируемы как пути:

FileUtils.uptodate?('Rakefile', ['Gemfile', 'README.md']) # => true
FileUtils.uptodate?('Gemfile', ['Rakefile', 'README.md']) # => false

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

Связанно с: FileUtils.touch.

# File lib/fileutils.rb, line 242
def cd(dir, verbose: nil, &block) # :yield: dir
  fu_output_message "cd #{dir}" if verbose
  result = Dir.chdir(dir, &block)
  fu_output_message 'cd -' if verbose and block
  result
end

Изменяет рабочую директорию на заданную dir, которая должна быть интерпретируема как путь:

Без блока, изменяет текущую директорию на директорию в dir; возвращает ноль:

FileUtils.pwd # => "/rdoc/fileutils"
FileUtils.cd('..')
FileUtils.pwd # => "/rdoc"
FileUtils.cd('fileutils')

С блоком, изменяет текущую директорию на директорию в dir, вызывает блок с аргументом dir, и восстанавливает исходную текущую директорию; возвращает значение блока:

FileUtils.pwd                                     # => "/rdoc/fileutils"
FileUtils.cd('..') { |arg| [arg, FileUtils.pwd] } # => ["..", "/rdoc"]
FileUtils.pwd                                     # => "/rdoc/fileutils"

Ключевые аргументы:

• verbose: true - печатает эквивалентную команду:

  FileUtils.cd('..')
  FileUtils.cd('fileutils')
  

  Вывод:

  cd ..
  cd fileutils

FileUtils.chdir является псевдонимом для FileUtils.cd.

Связанные: FileUtils.pwd.

# File lib/fileutils.rb, line 1815
def chmod(mode, list, noop: nil, verbose: nil)
  list = fu_list(list)
  fu_output_message sprintf('chmod %s %s', mode_to_s(mode), list.join(' ')) if verbose
  return if noop
  list.each do |path|
    Entry_.new(path).chmod(fu_mode(mode, path))
  end
end

Изменяет разрешения на записи для элементов в указанных путях в list (один путь или массив путей) до разрешений, заданных в mode; возвращает list если это массив, [list] в противном случае:

• Изменяет каждый элемент, являющийся обычным файлом, используя File.chmod.

• Изменяет каждый элемент, являющийся символической ссылкой, используя File.lchmod.

Аргумент list или его элементы должны быть интерпретируемы как пути.

Аргумент mode может быть либо целым числом, либо строкой:

• Целое число mode: представляет биты разрешений, которые должны быть установлены:

  FileUtils.chmod(0755, 'src0.txt')
  FileUtils.chmod(0644, ['src0.txt', 'src0.dat'])
  

• Строка mode: представляет разрешения, которые должны быть установлены:

  Строка имеет вид [targets][[operator][perms[,perms]], где:

  • targets может быть любой комбинацией этих букв:

    • 'u': разрешения применяются к владельцу файла.

    • 'g': разрешения применяются к пользователям в группе файла.

    • 'o': разрешения применяются к другим пользователям, не входящим в группу файла.

    • 'a' (по умолчанию): разрешения применяются ко всем пользователям.

  • operator может быть одной из этих букв:

    • '+': добавляет разрешения.

    • '-': удаляет разрешения.

    • '=': устанавливает (заменяет) разрешения.

  • perms (может повторяться с разделителями запятыми) может быть любой комбинацией этих букв:

    • 'r': Чтение.

    • 'w': Запись.

    • 'x': Исполнение (поиск, для директории).

    • 'X': Поиск (только для директорий; должно использоваться с '+').

    • 's': Uid или gid.

    • 't': Бит «прилипания».

  Примеры:

  FileUtils.chmod('u=wrx,go=rx', 'src1.txt')
  FileUtils.chmod('u=wrx,go=rx', '/usr/bin/ruby')
  

Ключевые аргументы:

• noop: true - не изменяет разрешения; возвращает nil.

• verbose: true - печатает эквивалентную команду:

  FileUtils.chmod(0755, 'src0.txt', noop: true, verbose: true)
  FileUtils.chmod(0644, ['src0.txt', 'src0.dat'], noop: true, verbose: true)
  FileUtils.chmod('u=wrx,go=rx', 'src1.txt', noop: true, verbose: true)
  FileUtils.chmod('u=wrx,go=rx', '/usr/bin/ruby', noop: true, verbose: true)
  

  Вывод:

  chmod 755 src0.txt
  chmod 644 src0.txt src0.dat
  chmod u=wrx,go=rx src1.txt
  chmod u=wrx,go=rx /usr/bin/ruby

Связанные: FileUtils.chmod_R.

# File lib/fileutils.rb, line 1827
def chmod_R(mode, list, noop: nil, verbose: nil, force: nil)
  list = fu_list(list)
  fu_output_message sprintf('chmod -R%s %s %s',
                            (force ? 'f' : ''),
                            mode_to_s(mode), list.join(' ')) if verbose
  return if noop
  list.each do |root|
    Entry_.new(root).traverse do |ent|
      begin
        ent.chmod(fu_mode(mode, ent.path))
      rescue
        raise unless force
      end
    end
  end
end

Как FileUtils.chmod, но изменяет разрешения рекурсивно.

# File lib/fileutils.rb, line 1908
def chown(user, group, list, noop: nil, verbose: nil)
  list = fu_list(list)
  fu_output_message sprintf('chown %s %s',
                            (group ? "#{user}:#{group}" : user || ':'),
                            list.join(' ')) if verbose
  return if noop
  uid = fu_get_uid(user)
  gid = fu_get_gid(group)
  list.each do |path|
    Entry_.new(path).chown uid, gid
  end
end

Изменяет владельца и группу на записи в указанных путях в list (один путь или массив путей) на заданных user и group; возвращает list если это массив, [list] в противном случае:

• Изменяет каждый элемент, являющийся обычным файлом, используя File.chown.

• Изменяет каждый элемент, являющийся символической ссылкой, используя File.lchown.

Аргумент list или его элементы должны быть интерпретируемы как пути.

Пользователь и группа:

• Аргумент user может быть именем пользователя или идентификатором пользователя; если nil или -1, пользователь не изменяется.

• Аргумент group может быть именем группы или идентификатором группы; если nil или -1, группа не изменяется.

• Пользователь должен быть членом группы.

Примеры:

# One path.
# User and group as string names.
File.stat('src0.txt').uid # => 1004
File.stat('src0.txt').gid # => 1004
FileUtils.chown('user2', 'group1', 'src0.txt')
File.stat('src0.txt').uid # => 1006
File.stat('src0.txt').gid # => 1005

# User and group as uid and gid.
FileUtils.chown(1004, 1004, 'src0.txt')
File.stat('src0.txt').uid # => 1004
File.stat('src0.txt').gid # => 1004

# Array of paths.
FileUtils.chown(1006, 1005, ['src0.txt', 'src0.dat'])

# Directory (not recursive).
FileUtils.chown('user2', 'group1', '.')

Ключевые аргументы:

• noop: true - не изменяет разрешения; возвращает nil.

• verbose: true - печатает эквивалентную команду:

  FileUtils.chown('user2', 'group1', 'src0.txt', noop: true, verbose: true)
  FileUtils.chown(1004, 1004, 'src0.txt', noop: true, verbose: true)
  FileUtils.chown(1006, 1005, ['src0.txt', 'src0.dat'], noop: true, verbose: true)
  FileUtils.chown('user2', 'group1', path, noop: true, verbose: true)
  FileUtils.chown('user2', 'group1', '.', noop: true, verbose: true)
  

  Вывод:

  chown user2:group1 src0.txt
  chown 1004:1004 src0.txt
  chown 1006:1005 src0.txt src0.dat
  chown user2:group1 src0.txt
  chown user2:group1 .

Связанные: FileUtils.chown_R.

# File lib/fileutils.rb, line 1924
def chown_R(user, group, list, noop: nil, verbose: nil, force: nil)
  list = fu_list(list)
  fu_output_message sprintf('chown -R%s %s %s',
                            (force ? 'f' : ''),
                            (group ? "#{user}:#{group}" : user || ':'),
                            list.join(' ')) if verbose
  return if noop
  uid = fu_get_uid(user)
  gid = fu_get_gid(group)
  list.each do |root|
    Entry_.new(root).traverse do |ent|
      begin
        ent.chown uid, gid
      rescue
        raise unless force
      end
    end
  end
end

Как FileUtils.chown, но изменяет владельца и группу рекурсивно.

# File lib/fileutils.rb, line 1525
def compare_file(a, b)
  return false unless File.size(a) == File.size(b)
  File.open(a, 'rb') {|fa|
    File.open(b, 'rb') {|fb|
      return compare_stream(fa, fb)
    }
  }
end

Возвращает true если содержимое файлов a и b идентичны, false в противном случае.

Аргументы a и b должны быть интерпретируемы как путь.

FileUtils.identical? и FileUtils.cmp являются псевдонимами для FileUtils.compare_file.

Связанные: FileUtils.compare_stream.

# File lib/fileutils.rb, line 1548
def compare_stream(a, b)
  bsize = fu_stream_blksize(a, b)

  sa = String.new(capacity: bsize)
  sb = String.new(capacity: bsize)

  begin
    a.read(bsize, sa)
    b.read(bsize, sb)
    return true if sa.empty? && sb.empty?
  end while sa == sb
  false
end

Возвращает true если содержимое потоков a и b идентичны, false в противном случае.

Аргументы a и b должны быть интерпретируемы как путь.

Связанные: FileUtils.compare_file.

# File lib/fileutils.rb, line 1050
def copy_entry(src, dest, preserve = false, dereference_root = false, remove_destination = false)
  if dereference_root
    src = File.realpath(src)
  end

  Entry_.new(src, nil, false).wrap_traverse(proc do |ent|
    destent = Entry_.new(dest, ent.rel, false)
    File.unlink destent.path if remove_destination && (File.file?(destent.path) || File.symlink?(destent.path))
    ent.copy destent.path
  end, proc do |ent|
    destent = Entry_.new(dest, ent.rel, false)
    ent.copy_metadata destent.path if preserve
  end)
end

Рекурсивно копирует файлы из src в dest.

Аргументы src и dest должны быть интерпретируемы как пути.

Если src — путь к файлу, копирует src в dest:

FileUtils.touch('src0.txt')
File.exist?('dest0.txt') # => false
FileUtils.copy_entry('src0.txt', 'dest0.txt')
File.file?('dest0.txt')  # => true

Если src — это директория, рекурсивно копирует src в dest:

tree('src1')
# => src1
#    |-- dir0
#    |   |-- src0.txt
#    |   `-- src1.txt
#    `-- dir1
#        |-- src2.txt
#        `-- src3.txt
FileUtils.copy_entry('src1', 'dest1')
tree('dest1')
# => dest1
#    |-- dir0
#    |   |-- src0.txt
#    |   `-- src1.txt
#    `-- dir1
#        |-- src2.txt
#        `-- src3.txt

Рекурсивное копирование сохраняет типы файлов для обычных файлов, каталогов и символических ссылок; другие типы файлов (FIFO потоки, файлы устройств и т. д.) не поддерживаются.

Ключевые аргументы:

• dereference_root: true — если src — символическая ссылка, следует по ссылке.

• preserve: true — сохраняет временные метки файлов.

• remove_destination: true — удаляет dest перед копированием файлов.

Связанные: методы для копирования.

# File lib/fileutils.rb, line 1086
def copy_file(src, dest, preserve = false, dereference = true)
  ent = Entry_.new(src, nil, dereference)
  ent.copy_file dest
  ent.copy_metadata dest if preserve
end

Копирует файл из src в dest, которые не должны быть каталогами.

Аргументы src и dest должны быть интерпретируемы как пути.

Примеры:

FileUtils.touch('src0.txt')
FileUtils.copy_file('src0.txt', 'dest0.txt')
File.file?('dest0.txt') # => true

Ключевые аргументы:

• dereference: false — если src — символическая ссылка, не следует по ссылке.

• preserve: true — сохраняет временные метки файлов.

• remove_destination: true — удаляет dest перед копированием файлов.

Связанные: методы для копирования.

# File lib/fileutils.rb, line 1098
def copy_stream(src, dest)
  IO.copy_stream(src, dest)
end

Копирует поток ввода-вывода src в поток ввода-вывода dest через IO.copy_stream.

Связанные: методы для копирования.

# File lib/fileutils.rb, line 883
def cp(src, dest, preserve: nil, noop: nil, verbose: nil)
  fu_output_message "cp#{preserve ? ' -p' : ''} #{[src,dest].flatten.join ' '}" if verbose
  return if noop
  fu_each_src_dest(src, dest) do |s, d|
    copy_file s, d, preserve
  end
end

Копирует файлы.

Аргументы src (один путь или массив путей) и dest (один путь) должны быть интерпретируемы как пути.

Если src — путь к файлу, а dest — не путь к каталогу, копирует src в dest:

FileUtils.touch('src0.txt')
File.exist?('dest0.txt') # => false
FileUtils.cp('src0.txt', 'dest0.txt')
File.file?('dest0.txt')  # => true

Если src — путь к файлу, а dest — путь к каталогу, копирует src в dest/src:

FileUtils.touch('src1.txt')
FileUtils.mkdir('dest1')
FileUtils.cp('src1.txt', 'dest1')
File.file?('dest1/src1.txt') # => true

Если src — массив путей к файлам, а dest — путь к каталогу, копирует каждый src в dest:

src_file_paths = ['src2.txt', 'src2.dat']
FileUtils.touch(src_file_paths)
FileUtils.mkdir('dest2')
FileUtils.cp(src_file_paths, 'dest2')
File.file?('dest2/src2.txt') # => true
File.file?('dest2/src2.dat') # => true

Ключевые аргументы:

• preserve: true — сохраняет временные метки файлов.

• noop: true — не копирует файлы.

• verbose: true — печатает эквивалентную команду:

  FileUtils.cp('src0.txt', 'dest0.txt', noop: true, verbose: true)
  FileUtils.cp('src1.txt', 'dest1', noop: true, verbose: true)
  FileUtils.cp(src_file_paths, 'dest2', noop: true, verbose: true)
  

  Вывод:

  cp src0.txt dest0.txt
  cp src1.txt dest1
  cp src2.txt src2.dat dest2
  

Вызывает исключение, если src — это каталог.

FileUtils.copy — псевдоним для FileUtils.cp.

Связанные: методы для копирования.

# File lib/fileutils.rb, line 633
def cp_lr(src, dest, noop: nil, verbose: nil,
          dereference_root: true, remove_destination: false)
  fu_output_message "cp -lr#{remove_destination ? ' --remove-destination' : ''} #{[src,dest].flatten.join ' '}" if verbose
  return if noop
  fu_each_src_dest(src, dest) do |s, d|
    link_entry s, d, dereference_root, remove_destination
  end
end

Создаёт жёсткие ссылки.

Аргументы src (один путь или массив путей) и dest (один путь) должны быть интерпретируемы как пути.

Если src — путь к каталогу и dest не существует, создаёт ссылки dest и потомки, указывающие на src и его потомков:

tree('src0')
# => src0
#    |-- sub0
#    |   |-- src0.txt
#    |   `-- src1.txt
#    `-- sub1
#        |-- src2.txt
#        `-- src3.txt
File.exist?('dest0') # => false
FileUtils.cp_lr('src0', 'dest0')
tree('dest0')
# => dest0
#    |-- sub0
#    |   |-- src0.txt
#    |   `-- src1.txt
#    `-- sub1
#        |-- src2.txt
#        `-- src3.txt

Если src и dest — оба пути к каталогам, создаёт ссылки dest/src и потомки, указывающие на src и его потомков:

tree('src1')
# => src1
#    |-- sub0
#    |   |-- src0.txt
#    |   `-- src1.txt
#    `-- sub1
#        |-- src2.txt
#        `-- src3.txt
FileUtils.mkdir('dest1')
FileUtils.cp_lr('src1', 'dest1')
tree('dest1')
# => dest1
#    `-- src1
#        |-- sub0
#        |   |-- src0.txt
#        |   `-- src1.txt
#        `-- sub1
#            |-- src2.txt
#            `-- src3.txt

Если src — массив путей к записям и dest — путь к каталогу, для каждого пути filepath в src, создаёт ссылку в dest/filepath, указывающую на этот путь:

tree('src2')
# => src2
#    |-- sub0
#    |   |-- src0.txt
#    |   `-- src1.txt
#    `-- sub1
#        |-- src2.txt
#        `-- src3.txt
FileUtils.mkdir('dest2')
FileUtils.cp_lr(['src2/sub0', 'src2/sub1'], 'dest2')
tree('dest2')
# => dest2
#    |-- sub0
#    |   |-- src0.txt
#    |   `-- src1.txt
#    `-- sub1
#        |-- src2.txt
#        `-- src3.txt

Ключевые аргументы:

• dereference_root: false — если src — символическая ссылка, не делает дериференцирование.

• noop: true — не создаёт ссылки.

• remove_destination: true — удаляет dest перед созданием ссылок.

• verbose: true — печатает эквивалентную команду:

  FileUtils.cp_lr('src0', 'dest0', noop: true, verbose: true)
  FileUtils.cp_lr('src1', 'dest1', noop: true, verbose: true)
  FileUtils.cp_lr(['src2/sub0', 'src2/sub1'], 'dest2', noop: true, verbose: true)
  

  Вывод:

  cp -lr src0 dest0
  cp -lr src1 dest1
  cp -lr src2/sub0 src2/sub1 dest2

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

Связанные: методы для копирования.

# File lib/fileutils.rb, line 995
def cp_r(src, dest, preserve: nil, noop: nil, verbose: nil,
         dereference_root: true, remove_destination: nil)
  fu_output_message "cp -r#{preserve ? 'p' : ''}#{remove_destination ? ' --remove-destination' : ''} #{[src,dest].flatten.join ' '}" if verbose
  return if noop
  fu_each_src_dest(src, dest) do |s, d|
    copy_entry s, d, preserve, dereference_root, remove_destination
  end
end

Рекурсивно копирует файлы.

Аргументы src (один путь или массив путей) и dest (один путь) должны быть интерпретируемы как пути.

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

Если src — путь к файлу, а dest — не путь к каталогу, копирует src в dest:

FileUtils.touch('src0.txt')
File.exist?('dest0.txt') # => false
FileUtils.cp_r('src0.txt', 'dest0.txt')
File.file?('dest0.txt')  # => true

Если src — путь к файлу, а dest — путь к каталогу, копирует src в dest/src:

FileUtils.touch('src1.txt')
FileUtils.mkdir('dest1')
FileUtils.cp_r('src1.txt', 'dest1')
File.file?('dest1/src1.txt') # => true

Если src — путь к каталогу, а dest не существует, рекурсивно копирует src в dest:

tree('src2')
# => src2
#    |-- dir0
#    |   |-- src0.txt
#    |   `-- src1.txt
#    `-- dir1
#    |-- src2.txt
#    `-- src3.txt
FileUtils.exist?('dest2') # => false
FileUtils.cp_r('src2', 'dest2')
tree('dest2')
# => dest2
#    |-- dir0
#    |   |-- src0.txt
#    |   `-- src1.txt
#    `-- dir1
#    |-- src2.txt
#    `-- src3.txt

Если src и dest — пути к каталогам, рекурсивно копирует src в dest/src:

tree('src3')
# => src3
#    |-- dir0
#    |   |-- src0.txt
#    |   `-- src1.txt
#    `-- dir1
#    |-- src2.txt
#    `-- src3.txt
FileUtils.mkdir('dest3')
FileUtils.cp_r('src3', 'dest3')
tree('dest3')
# => dest3
#    `-- src3
#      |-- dir0
#      |   |-- src0.txt
#      |   `-- src1.txt
#      `-- dir1
#          |-- src2.txt
#          `-- src3.txt

Если src — массив путей и dest — каталог, рекурсивно копирует из каждого пути в src в dest; пути в src могут указывать на файлы и/или каталоги.

Ключевые аргументы:

• dereference_root: false — если src — символическая ссылка, не делает дериференцирование.

• noop: true — не копирует файлы.

• preserve: true — сохраняет временные метки файлов.

• remove_destination: true — удаляет dest перед копированием файлов.

• verbose: true — печатает эквивалентную команду:

  FileUtils.cp_r('src0.txt', 'dest0.txt', noop: true, verbose: true)
  FileUtils.cp_r('src1.txt', 'dest1', noop: true, verbose: true)
  FileUtils.cp_r('src2', 'dest2', noop: true, verbose: true)
  FileUtils.cp_r('src3', 'dest3', noop: true, verbose: true)
  

  Вывод:

  cp -r src0.txt dest0.txt
  cp -r src1.txt dest1
  cp -r src2 dest2
  cp -r src3 dest3

Вызывает исключение, если src — путь к каталогу, а dest — путь к файлу.

Связанные: методы для копирования.

# File lib/fileutils.rb, line 1627
def install(src, dest, mode: nil, owner: nil, group: nil, preserve: nil,
            noop: nil, verbose: nil)
  if verbose
    msg = +"install -c"
    msg << ' -p' if preserve
    msg << ' -m ' << mode_to_s(mode) if mode
    msg << " -o #{owner}" if owner
    msg << " -g #{group}" if group
    msg << ' ' << [src,dest].flatten.join(' ')
    fu_output_message msg
  end
  return if noop
  uid = fu_get_uid(owner)
  gid = fu_get_gid(group)
  fu_each_src_dest(src, dest) do |s, d|
    st = File.stat(s)
    unless File.exist?(d) and compare_file(s, d)
      remove_file d, true
      copy_file s, d
      File.utime st.atime, st.mtime, d if preserve
      File.chmod fu_mode(mode, st), d if mode
      File.chown uid, gid, d if uid or gid
    end
  end
end

Копирует запись файла. См. install(1).

Аргументы src (один путь или массив путей) и dest (один путь) должны быть интерпретируемы как пути;

Если записи в dest не существует, копирует из src в dest:

File.read('src0.txt')    # => "aaa\n"
File.exist?('dest0.txt') # => false
FileUtils.install('src0.txt', 'dest0.txt')
File.read('dest0.txt')   # => "aaa\n"

Если dest — запись файла, копирует из src в dest, перезаписывая:

File.read('src1.txt')  # => "aaa\n"
File.read('dest1.txt') # => "bbb\n"
FileUtils.install('src1.txt', 'dest1.txt')
File.read('dest1.txt') # => "aaa\n"

Если dest — запись каталога, копирует из src в dest/src, перезаписывая при необходимости:

File.read('src2.txt')       # => "aaa\n"
File.read('dest2/src2.txt') # => "bbb\n"
FileUtils.install('src2.txt', 'dest2')
File.read('dest2/src2.txt') # => "aaa\n"

Если src — массив путей, а dest указывает на каталог, копирует каждый путь path в src в dest/path:

File.file?('src3.txt') # => true
File.file?('src3.dat') # => true
FileUtils.mkdir('dest3')
FileUtils.install(['src3.txt', 'src3.dat'], 'dest3')
File.file?('dest3/src3.txt') # => true
File.file?('dest3/src3.dat') # => true

Ключевые аргументы:

• group: group — изменяет группу, если она не nil, используя File.chown.

• mode: permissions — изменяет права доступа, используя File.chmod.

• noop: true — не копирует записи; возвращает nil.

• owner: owner — изменяет владельца, если он не nil, используя File.chown.

• preserve: true — сохраняет временные метки, используя File.utime.

• verbose: true — выводит эквивалентную команду:

  FileUtils.install('src0.txt', 'dest0.txt', noop: true, verbose: true)
  FileUtils.install('src1.txt', 'dest1.txt', noop: true, verbose: true)
  FileUtils.install('src2.txt', 'dest2', noop: true, verbose: true)
  

  Вывод:

  install -c src0.txt dest0.txt
  install -c src1.txt dest1.txt
  install -c src2.txt dest2

Связанные: методы для копирования.

# File lib/fileutils.rb, line 820
def link_entry(src, dest, dereference_root = false, remove_destination = false)
  Entry_.new(src, nil, dereference_root).traverse do |ent|
    destent = Entry_.new(dest, ent.rel, false)
    File.unlink destent.path if remove_destination && File.file?(destent.path)
    ent.link destent.path
  end
end

Создаёт жёсткие ссылки; возвращает nil.

Аргументы src и dest должны быть интерпретируемы как пути.

Если src — путь к файлу, а dest не существует, создаёт жёсткую ссылку в dest, указывающую на src:

FileUtils.touch('src0.txt')
File.exist?('dest0.txt') # => false
FileUtils.link_entry('src0.txt', 'dest0.txt')
File.file?('dest0.txt')  # => true

Если src — путь к каталогу, а dest не существует, рекурсивно создаёт жёсткие ссылки в dest, указывающие на пути в src:

FileUtils.mkdir_p(['src1/dir0', 'src1/dir1'])
src_file_paths = [
  'src1/dir0/t0.txt',
  'src1/dir0/t1.txt',
  'src1/dir1/t2.txt',
  'src1/dir1/t3.txt',
  ]
FileUtils.touch(src_file_paths)
File.directory?('dest1')        # => true
FileUtils.link_entry('src1', 'dest1')
File.file?('dest1/dir0/t0.txt') # => true
File.file?('dest1/dir0/t1.txt') # => true
File.file?('dest1/dir1/t2.txt') # => true
File.file?('dest1/dir1/t3.txt') # => true

Ключевые аргументы:

• dereference_root: true — разыменовывает src , если это символическая ссылка.

• remove_destination: true — удаляет dest перед созданием ссылок.

Вызывает исключение, если dest — путь к существующему файлу или каталогу, а ключевой аргумент remove_destination: true не задан.

Связанные: FileUtils.ln (с разными опциями).

# File lib/fileutils.rb, line 522
def ln(src, dest, force: nil, noop: nil, verbose: nil)
  fu_output_message "ln#{force ? ' -f' : ''} #{[src,dest].flatten.join ' '}" if verbose
  return if noop
  fu_each_src_dest0(src, dest) do |s,d|
    remove_file d, true if force
    File.link s, d
  end
end

Создаёт жёсткие ссылки.

Аргументы src (один путь или массив путей) и dest (один путь) должны быть интерпретируемы как пути.

Когда src — путь к существующему файлу, а dest — путь к несуществующему файлу, создаёт жёсткую ссылку в dest , указывающую на src; возвращает ноль:

Dir.children('tmp0/')                    # => ["t.txt"]
Dir.children('tmp1/')                    # => []
FileUtils.ln('tmp0/t.txt', 'tmp1/t.lnk') # => 0
Dir.children('tmp1/')                    # => ["t.lnk"]

Когда src — путь к существующему файлу, а dest — путь к существующему каталогу, создаёт жёсткую ссылку в dest/src , указывающую на src; возвращает ноль:

Dir.children('tmp2')               # => ["t.dat"]
Dir.children('tmp3')               # => []
FileUtils.ln('tmp2/t.dat', 'tmp3') # => 0
Dir.children('tmp3')               # => ["t.dat"]

Когда src — массив путей к существующим файлам, а dest — путь к существующему каталогу, для каждого пути target в src, создаёт жёсткую ссылку в dest/target , указывающую на target; возвращает src:

Dir.children('tmp4/')                               # => []
FileUtils.ln(['tmp0/t.txt', 'tmp2/t.dat'], 'tmp4/') # => ["tmp0/t.txt", "tmp2/t.dat"]
Dir.children('tmp4/')                               # => ["t.dat", "t.txt"]

Ключевые аргументы:

• force: true — перезаписывает dest , если он существует.

• noop: true — не создаёт ссылки.

• verbose: true — выводит эквивалентную команду:

  FileUtils.ln('tmp0/t.txt', 'tmp1/t.lnk', verbose: true)
  FileUtils.ln('tmp2/t.dat', 'tmp3', verbose: true)
  FileUtils.ln(['tmp0/t.txt', 'tmp2/t.dat'], 'tmp4/', verbose: true)
  

  Вывод:

  ln tmp0/t.txt tmp1/t.lnk
  ln tmp2/t.dat tmp3
  ln tmp0/t.txt tmp2/t.dat tmp4/

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

FileUtils#link — псевдоним для FileUtils#ln.

Связанные: FileUtils.link_entry (с разными опциями).

# File lib/fileutils.rb, line 714
def ln_s(src, dest, force: nil, relative: false, target_directory: true, noop: nil, verbose: nil)
  if relative
    return ln_sr(src, dest, force: force, noop: noop, verbose: verbose)
  end
  fu_output_message "ln -s#{force ? 'f' : ''} #{[src,dest].flatten.join ' '}" if verbose
  return if noop
  fu_each_src_dest0(src, dest) do |s,d|
    remove_file d, true if force
    File.symlink s, d
  end
end

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

Аргументы src (один путь или массив путей) и dest (один путь) должны быть интерпретируемы как пути.

Если src — путь к существующему файлу:

• Когда dest — путь к несуществующему файлу, создаёт символическую ссылку в dest , указывающую на src:

  FileUtils.touch('src0.txt')
  File.exist?('dest0.txt')   # => false
  FileUtils.ln_s('src0.txt', 'dest0.txt')
  File.symlink?('dest0.txt') # => true
  

• Когда dest — путь к существующему файлу, создаёт символическую ссылку в dest , указывающую на src только если задан ключевой аргумент force: true (в противном случае вызывает исключение):

  FileUtils.touch('src1.txt')
  FileUtils.touch('dest1.txt')
  FileUtils.ln_s('src1.txt', 'dest1.txt', force: true)
  FileTest.symlink?('dest1.txt') # => true
  
  FileUtils.ln_s('src1.txt', 'dest1.txt') # Raises Errno::EEXIST.
  

Если dest — путь к каталогу, создаёт символическую ссылку в dest/src , указывающую на src:

FileUtils.touch('src2.txt')
FileUtils.mkdir('destdir2')
FileUtils.ln_s('src2.txt', 'destdir2')
File.symlink?('destdir2/src2.txt') # => true

Если src — массив путей к существующим файлам, а dest — каталог, для каждого дочернего элемента child в src создаёт символическую ссылку dest/child , указывающую на child:

FileUtils.mkdir('srcdir3')
FileUtils.touch('srcdir3/src0.txt')
FileUtils.touch('srcdir3/src1.txt')
FileUtils.mkdir('destdir3')
FileUtils.ln_s(['srcdir3/src0.txt', 'srcdir3/src1.txt'], 'destdir3')
File.symlink?('destdir3/src0.txt') # => true
File.symlink?('destdir3/src1.txt') # => true

Ключевые аргументы:

• force: true — перезаписывает dest , если он существует.

• relative: false — создаёт ссылки относительно dest.

• noop: true — не создаёт ссылки.

• verbose: true — выводит эквивалентную команду:

  FileUtils.ln_s('src0.txt', 'dest0.txt', noop: true, verbose: true)
  FileUtils.ln_s('src1.txt', 'destdir1', noop: true, verbose: true)
  FileUtils.ln_s('src2.txt', 'dest2.txt', force: true, noop: true, verbose: true)
  FileUtils.ln_s(['srcdir3/src0.txt', 'srcdir3/src1.txt'], 'destdir3', noop: true, verbose: true)
  

  Вывод:

  ln -s src0.txt dest0.txt
  ln -s src1.txt destdir1
  ln -sf src2.txt dest2.txt
  ln -s srcdir3/src0.txt srcdir3/src1.txt destdir3

FileUtils.symlink — псевдоним для FileUtils.ln_s.

Связанные: FileUtils.ln_sf.

# File lib/fileutils.rb, line 732
def ln_sf(src, dest, noop: nil, verbose: nil)
  ln_s src, dest, force: true, noop: noop, verbose: verbose
end

Подобно FileUtils.ln_s, но всегда с ключевым аргументом force: true.

# File lib/fileutils.rb, line 739
def ln_sr(src, dest, target_directory: true, force: nil, noop: nil, verbose: nil)
  options = "#{force ? 'f' : ''}#{target_directory ? '' : 'T'}"
  dest = File.path(dest)
  srcs = Array(src)
  link = proc do |s, target_dir_p = true|
    s = File.path(s)
    if target_dir_p
      d = File.join(destdirs = dest, File.basename(s))
    else
      destdirs = File.dirname(d = dest)
    end
    destdirs = fu_split_path(File.realpath(destdirs))
    if fu_starting_path?(s)
      srcdirs = fu_split_path((File.realdirpath(s) rescue File.expand_path(s)))
      base = fu_relative_components_from(srcdirs, destdirs)
      s = File.join(*base)
    else
      srcdirs = fu_clean_components(*fu_split_path(s))
      base = fu_relative_components_from(fu_split_path(Dir.pwd), destdirs)
      while srcdirs.first&. == ".." and base.last&.!=("..") and !fu_starting_path?(base.last)
        srcdirs.shift
        base.pop
      end
      s = File.join(*base, *srcdirs)
    end
    fu_output_message "ln -s#{options} #{s} #{d}" if verbose
    next if noop
    remove_file d, true if force
    File.symlink s, d
  end
  case srcs.size
  when 0
  when 1
    link[srcs[0], target_directory && File.directory?(dest)]
  else
    srcs.each(&link)
  end
end

Подобно FileUtils.ln_s, но создаёт ссылки относительно dest.

# File lib/fileutils.rb, line 320
def mkdir(list, mode: nil, noop: nil, verbose: nil)
  list = fu_list(list)
  fu_output_message "mkdir #{mode ? ('-m %03o ' % mode) : ''}#{list.join ' '}" if verbose
  return if noop

  list.each do |dir|
    fu_mkdir dir, mode
  end
end

Создаёт директории по указанным путям в переданном list (один путь или массив путей); возвращает list если это массив, [list] в противном случае.

Аргумент list или его элементы должны быть интерпретируемы как пути.

Без ключевых аргументов, создаёт директории по каждому path в list вызывая: Dir.mkdir(path, mode); см. Dir.mkdir:

FileUtils.mkdir(%w[tmp0 tmp1]) # => ["tmp0", "tmp1"]
FileUtils.mkdir('tmp4')        # => ["tmp4"]

Ключевые аргументы:

• mode: mode - также вызывает File.chmod(mode, path); см. File.chmod.

• noop: true - не создаёт директории.

• verbose: true - выводит эквивалентную команду:

  FileUtils.mkdir(%w[tmp0 tmp1], verbose: true)
  FileUtils.mkdir(%w[tmp2 tmp3], mode: 0700, verbose: true)
  

  Вывод:

  mkdir tmp0 tmp1
  mkdir -m 700 tmp2 tmp3

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

Связанные: FileUtils.mkdir_p.

# File lib/fileutils.rb, line 369
def mkdir_p(list, mode: nil, noop: nil, verbose: nil)
  list = fu_list(list)
  fu_output_message "mkdir -p #{mode ? ('-m %03o ' % mode) : ''}#{list.join ' '}" if verbose
  return *list if noop

  list.each do |item|
    path = remove_trailing_slash(item)

    stack = []
    until File.directory?(path) || File.dirname(path) == path
      stack.push path
      path = File.dirname(path)
    end
    stack.reverse_each do |dir|
      begin
        fu_mkdir dir, mode
      rescue SystemCallError
        raise unless File.directory?(dir)
      end
    end
  end

  return *list
end

Создаёт директории по указанным путям в переданном list (один путь или массив путей), также создавая необходимые родительские директории; возвращает list если это массив, [list] в противном случае.

Аргумент list или его элементы должны быть интерпретируемы как пути.

Без ключевых аргументов, создаёт директорию по каждому path в list, вместе с любыми необходимыми родительскими директориями, вызывая: Dir.mkdir(path, mode); см. Dir.mkdir:

FileUtils.mkdir_p(%w[tmp0/tmp1 tmp2/tmp3]) # => ["tmp0/tmp1", "tmp2/tmp3"]
FileUtils.mkdir_p('tmp4/tmp5')             # => ["tmp4/tmp5"]

Ключевые аргументы:

• mode: mode - также вызывает File.chmod(mode, path); см. File.chmod.

• noop: true - не создаёт директории.

• verbose: true - выводит эквивалентную команду:

  FileUtils.mkdir_p(%w[tmp0 tmp1], verbose: true)
  FileUtils.mkdir_p(%w[tmp2 tmp3], mode: 0700, verbose: true)
  

  Вывод:

  mkdir -p tmp0 tmp1
  mkdir -p -m 700 tmp2 tmp3

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

FileUtils.mkpath и FileUtils.makedirs являются псевдонимами для FileUtils.mkdir_p.

Связанные: FileUtils.mkdir.

# File lib/fileutils.rb, line 1169
def mv(src, dest, force: nil, noop: nil, verbose: nil, secure: nil)
  fu_output_message "mv#{force ? ' -f' : ''} #{[src,dest].flatten.join ' '}" if verbose
  return if noop
  fu_each_src_dest(src, dest) do |s, d|
    destent = Entry_.new(d, nil, true)
    begin
      if destent.exist?
        if destent.directory?
          raise Errno::EEXIST, d
        end
      end
      begin
        File.rename s, d
      rescue Errno::EXDEV,
             Errno::EPERM # move from unencrypted to encrypted dir (ext4)
        copy_entry s, d, true
        if secure
          remove_entry_secure s, force
        else
          remove_entry s, force
        end
      end
    rescue SystemCallError
      raise unless force
    end
  end
end

Перемещает записи.

Аргументы src (один путь или массив путей) и dest (один путь) должны быть интерпретируемы как пути.

Если src и dest находятся на разных файловых системах, сначала копирует, затем удаляет src.

Может привести к локальной уязвимости, если не вызывается с ключевым аргументом secure: true; см. Предотвращение уязвимости TOCTTOU.

Если src - путь к одному файлу или директории и dest не существует, перемещает src в dest:

tree('src0')
# => src0
#    |-- src0.txt
#    `-- src1.txt
File.exist?('dest0') # => false
FileUtils.mv('src0', 'dest0')
File.exist?('src0')  # => false
tree('dest0')
# => dest0
#    |-- src0.txt
#    `-- src1.txt

Если src - массив путей к файлам и директориям и dest - путь к директории, копирует из каждого пути в массиве в dest:

File.file?('src1.txt') # => true
tree('src1')
# => src1
#    |-- src.dat
#    `-- src.txt
Dir.empty?('dest1')    # => true
FileUtils.mv(['src1.txt', 'src1'], 'dest1')
tree('dest1')
# => dest1
#    |-- src1
#    |   |-- src.dat
#    |   `-- src.txt
#    `-- src1.txt

Ключевые аргументы:

• force: true - если перемещение включает удаление src (то есть, если src и dest находятся на разных файловых системах), игнорирует поднятые исключения StandardError и его потомков.

• noop: true - не перемещает файлы.

• secure: true - удаляет src безопасно; см. подробности в FileUtils.remove_entry_secure.

• verbose: true - выводит эквивалентную команду:

  FileUtils.mv('src0', 'dest0', noop: true, verbose: true)
  FileUtils.mv(['src1.txt', 'src1'], 'dest1', noop: true, verbose: true)
  

  Вывод:

  mv src0 dest0
  mv src1.txt src1 dest1
  

FileUtils.move является псевдонимом для FileUtils.mv.

# File lib/fileutils.rb, line 199
def pwd
  Dir.pwd
end

Возвращает строку, содержащую путь к текущей директории:

FileUtils.pwd # => "/rdoc/fileutils"

FileUtils.getwd является псевдонимом для FileUtils.pwd.

Связанные: FileUtils.cd.

# File lib/fileutils.rb, line 1510
def remove_dir(path, force = false)
  remove_entry path, force   # FIXME?? check if it is a directory
end

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

Аргумент path должен быть интерпретируем как путь.

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

Связанные: методы для удаления.

# File lib/fileutils.rb, line 1467
def remove_entry(path, force = false)
  Entry_.new(path).postorder_traverse do |ent|
    begin
      ent.remove
    rescue
      raise unless force
    end
  end
rescue
  raise unless force
end

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

Аргумент path должен быть интерпретируем как путь.

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

Связанные: FileUtils.remove_entry_secure.

# File lib/fileutils.rb, line 1369
def remove_entry_secure(path, force = false)
  unless fu_have_symlink?
    remove_entry path, force
    return
  end
  fullpath = File.expand_path(path)
  st = File.lstat(fullpath)
  unless st.directory?
    File.unlink fullpath
    return
  end
  # is a directory.
  parent_st = File.stat(File.dirname(fullpath))
  unless parent_st.world_writable?
    remove_entry path, force
    return
  end
  unless parent_st.sticky?
    raise ArgumentError, "parent directory is world writable, FileUtils#remove_entry_secure does not work; abort: #{path.inspect} (parent directory mode #{'%o' % parent_st.mode})"
  end

  # freeze tree root
  euid = Process.euid
  dot_file = fullpath + "/."
  begin
    File.open(dot_file) {|f|
      unless fu_stat_identical_entry?(st, f.stat)
        # symlink (TOC-to-TOU attack?)
        File.unlink fullpath
        return
      end
      f.chown euid, -1
      f.chmod 0700
    }
  rescue Errno::EISDIR # JRuby in non-native mode can't open files as dirs
    File.lstat(dot_file).tap {|fstat|
      unless fu_stat_identical_entry?(st, fstat)
        # symlink (TOC-to-TOU attack?)
        File.unlink fullpath
        return
      end
      File.chown euid, -1, dot_file
      File.chmod 0700, dot_file
    }
  end

  unless fu_stat_identical_entry?(st, File.lstat(fullpath))
    # TOC-to-TOU attack?
    File.unlink fullpath
    return
  end

  # ---- tree root is frozen ----
  root = Entry_.new(path)
  root.preorder_traverse do |ent|
    if ent.directory?
      ent.chown euid, -1
      ent.chmod 0700
    end
  end
  root.postorder_traverse do |ent|
    begin
      ent.remove
    rescue
      raise unless force
    end
  end
rescue
  raise unless force
end

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

Аргумент path должен быть интерпретируем как путь.

Избегает локальной уязвимости, которая может существовать в определённых обстоятельствах; см. Предотвращение уязвимости TOCTTOU.

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

Связанные: методы для удаления.

# File lib/fileutils.rb, line 1491
def remove_file(path, force = false)
  Entry_.new(path).remove_file
rescue
  raise unless force
end

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

Аргумент path должен быть интерпретируем как путь.

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

Связанные: методы для удаления.

# File lib/fileutils.rb, line 1230
def rm(list, force: nil, noop: nil, verbose: nil)
  list = fu_list(list)
  fu_output_message "rm#{force ? ' -f' : ''} #{list.join ' '}" if verbose
  return if noop

  list.each do |path|
    remove_file path, force
  end
end

Удаляет записи по путям в заданном list (один путь или массив путей), возвращает list, если это массив, [list] в противном случае.

Аргумент list или его элементы должны быть интерпретируемы как пути.

Без аргументов ключевых слов удаляет файлы по путям, указанным в list.

FileUtils.touch(['src0.txt', 'src0.dat'])
FileUtils.rm(['src0.dat', 'src0.txt']) # => ["src0.dat", "src0.txt"]

Аргументы ключевых слов:

• force: true - игнорирует возникающие исключения StandardError и его потомков.

• noop: true - не удаляет файлы; возвращает nil.

• verbose: true - выводит эквивалентную команду:

  FileUtils.rm(['src0.dat', 'src0.txt'], noop: true, verbose: true)
  

  Вывод:

  rm src0.dat src0.txt
  

FileUtils.remove является псевдонимом для FileUtils.rm.

Связанные: методы для удаления.

# File lib/fileutils.rb, line 1257
def rm_f(list, noop: nil, verbose: nil)
  rm list, force: true, noop: noop, verbose: verbose
end

Эквивалентно:

FileUtils.rm(list, force: true, **kwargs)

Аргумент list (один путь или массив путей) должен быть интерпретируем как пути.

См. FileUtils.rm для аргументов ключевых слов.

FileUtils.safe_unlink является псевдонимом для FileUtils.rm_f.

Связанные: методы для удаления.

# File lib/fileutils.rb, line 1315
def rm_r(list, force: nil, noop: nil, verbose: nil, secure: nil)
  list = fu_list(list)
  fu_output_message "rm -r#{force ? 'f' : ''} #{list.join ' '}" if verbose
  return if noop
  list.each do |path|
    if secure
      remove_entry_secure path, force
    else
      remove_entry path, force
    end
  end
end

Удаляет записи по путям в заданном list (один путь или массив путей); возвращает list, если это массив, [list] в противном случае.

Аргумент list или его элементы должны быть интерпретируемы как пути.

Может вызвать локальную уязвимость, если не вызывается с аргументом ключевого слова secure: true; см. Избегание уязвимости TOCTTOU.

Для каждого пути к файлу удаляет файл по этому пути:

FileUtils.touch(['src0.txt', 'src0.dat'])
FileUtils.rm_r(['src0.dat', 'src0.txt'])
File.exist?('src0.txt') # => false
File.exist?('src0.dat') # => false

Для каждого пути к директории рекурсивно удаляет файлы и директории:

tree('src1')
# => src1
#    |-- dir0
#    |   |-- src0.txt
#    |   `-- src1.txt
#    `-- dir1
#        |-- src2.txt
#        `-- src3.txt
FileUtils.rm_r('src1')
File.exist?('src1') # => false

Аргументы ключевых слов:

• force: true - игнорирует возникающие исключения StandardError и его потомков.

• noop: true - не удаляет записи; возвращает nil.

• secure: true - удаляет src безопасно; см. подробности в FileUtils.remove_entry_secure.

• verbose: true - выводит эквивалентную команду:

  FileUtils.rm_r(['src0.dat', 'src0.txt'], noop: true, verbose: true)
  FileUtils.rm_r('src1', noop: true, verbose: true)
  

  Вывод:

  rm -r src0.dat src0.txt
  rm -r src1

Связанные: методы для удаления.

# File lib/fileutils.rb, line 1346
def rm_rf(list, noop: nil, verbose: nil, secure: nil)
  rm_r list, force: true, noop: noop, verbose: verbose, secure: secure
end

Эквивалентно:

FileUtils.rm_r(list, force: true, **kwargs)

Аргумент list или его элементы должны быть интерпретируемы как пути.

Может вызвать локальную уязвимость, если не вызывается с аргументом ключевого слова secure: true; см. Избегание уязвимости TOCTTOU.

См. FileUtils.rm_r для аргументов ключевых слов.

FileUtils.rmtree является псевдонимом для FileUtils.rm_rf.

Связанные: методы для удаления.

# File lib/fileutils.rb, line 446
def rmdir(list, parents: nil, noop: nil, verbose: nil)
  list = fu_list(list)
  fu_output_message "rmdir #{parents ? '-p ' : ''}#{list.join ' '}" if verbose
  return if noop
  list.each do |dir|
    Dir.rmdir(dir = remove_trailing_slash(dir))
    if parents
      begin
        until (parent = File.dirname(dir)) == '.' or parent == dir
          dir = parent
          Dir.rmdir(dir)
        end
      rescue Errno::ENOTEMPTY, Errno::EEXIST, Errno::ENOENT
      end
    end
  end
end

Удаляет директории по путям в заданном list (один путь или массив путей); возвращает list, если это массив, [list] в противном случае.

Аргумент list или его элементы должны быть интерпретируемы как пути.

Без аргументов ключевых слов удаляет директорию по каждому path в list, вызывая: Dir.rmdir(path); см. Dir.rmdir:

FileUtils.rmdir(%w[tmp0/tmp1 tmp2/tmp3]) # => ["tmp0/tmp1", "tmp2/tmp3"]
FileUtils.rmdir('tmp4/tmp5')             # => ["tmp4/tmp5"]

Аргументы ключевых слов:

• parents: true - удаляет последующие родительские директории, если они пусты.

• noop: true - не удаляет директории.

• verbose: true - выводит эквивалентную команду:

  FileUtils.rmdir(%w[tmp0/tmp1 tmp2/tmp3], parents: true, verbose: true)
  FileUtils.rmdir('tmp4/tmp5', parents: true, verbose: true)
  

  Вывод:

  rmdir -p tmp0/tmp1 tmp2/tmp3
  rmdir -p tmp4/tmp5

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

Связанные: методы для удаления.

# File lib/fileutils.rb, line 2018
def touch(list, noop: nil, verbose: nil, mtime: nil, nocreate: nil)
  list = fu_list(list)
  t = mtime
  if verbose
    fu_output_message "touch #{nocreate ? '-c ' : ''}#{t ? t.strftime('-t %Y%m%d%H%M.%S ') : ''}#{list.join ' '}"
  end
  return if noop
  list.each do |path|
    created = nocreate
    begin
      File.utime(t, t, path)
    rescue Errno::ENOENT
      raise if created
      File.open(path, 'a') {
        ;
      }
      created = true
      retry if t
    end
  end
end

Обновляет время последней модификации (mtime) и время последнего доступа (atime) записей, заданных путями в list (один путь или массив путей); возвращает list, если это массив, [list] в противном случае.

По умолчанию создает пустой файл для любого пути к несуществующей записи; используйте аргумент ключевого слова nocreate для вызова исключения вместо этого.

Аргумент list или его элементы должны быть интерпретируемы как пути.

Примеры:

# Single path.
f = File.new('src0.txt') # Existing file.
f.atime # => 2022-06-10 11:11:21.200277 -0700
f.mtime # => 2022-06-10 11:11:21.200277 -0700
FileUtils.touch('src0.txt')
f = File.new('src0.txt')
f.atime # => 2022-06-11 08:28:09.8185343 -0700
f.mtime # => 2022-06-11 08:28:09.8185343 -0700

# Array of paths.
FileUtils.touch(['src0.txt', 'src0.dat'])

Аргументы ключевых слов:

• mtime: time - устанавливает mtime записи на заданное время, вместо текущего времени.

• nocreate: true - вызывает исключение, если запись не существует.

• noop: true - не изменяет записи; возвращает nil.

• verbose: true - выводит эквивалентную команду:

  FileUtils.touch('src0.txt', noop: true, verbose: true)
  FileUtils.touch(['src0.txt', 'src0.dat'], noop: true, verbose: true)
  FileUtils.touch(path, noop: true, verbose: true)
  

  Вывод:

  touch src0.txt
  touch src0.txt src0.dat
  touch src0.txt
  

Связанные: FileUtils.uptodate?.

# File lib/fileutils.rb, line 268
def uptodate?(new, old_list)
  return false unless File.exist?(new)
  new_time = File.mtime(new)
  old_list.each do |old|
    if File.exist?(old)
      return false unless new_time > File.mtime(old)
    end
  end
  true
end

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

Аргумент new и элементы old_list должны быть интерпретируемы как пути:

FileUtils.uptodate?('Rakefile', ['Gemfile', 'README.md']) # => true
FileUtils.uptodate?('Gemfile', ['Rakefile', 'README.md']) # => false

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

Связанно с: FileUtils.touch.