modul FileUtils

Namensraum für Hilfsprogrammmethoden zum Kopieren, Verschieben, Löschen usw.

Was gibt es hier

Zuerst, was anderswo ist. Modul FileUtils

Erbt von Klasse Object.
Ergänzt Klasse File (ist aber dort nicht enthalten oder erweitert).

Hier stellt das Modul FileUtils nützliche Methoden bereit für

Erstellen

::mkdir: Erstellt Verzeichnisse.
::mkdir_p, ::makedirs, ::mkpath: Erstellt Verzeichnisse und bei Bedarf auch Elternverzeichnisse.
::link_entry: Erstellt einen Hardlink.
::ln, ::link: Erstellt Hardlinks.
::ln_s, ::symlink: Erstellt symbolische Links.
::ln_sf: Erstellt symbolische Links, überschreibt bei Bedarf.
::ln_sr: Erstellt symbolische Links relativ zu Zielen

Löschen

::remove_dir: Entfernt ein Verzeichnis und seine Nachkommen.
::remove_entry: Entfernt einen Eintrag, einschließlich seiner Nachkommen, wenn es sich um ein Verzeichnis handelt.
::remove_entry_secure: Wie ::remove_entry, aber sicher.
::remove_file: Entfernt einen Dateieintrag.
::rm, ::remove: Entfernt Einträge.
::rm_f, ::safe_unlink: Wie ::rm, aber erzwingt das Entfernen.
::rm_r: Entfernt Einträge und ihre Nachkommen.
::rm_rf, ::rmtree: Wie ::rm_r, aber erzwingt das Entfernen.
::rmdir: Entfernt Verzeichnisse.

Abfragen

::pwd, ::getwd: Gibt den Pfad zum Arbeitsverzeichnis zurück.
::uptodate?: Gibt zurück, ob ein bestimmter Eintrag neuer ist als andere gegebene Einträge.

Einstellen

::cd, ::chdir: Setzt das Arbeitsverzeichnis.
::chmod: Setzt Berechtigungen für einen Eintrag.
::chmod_R: Setzt Berechtigungen für einen Eintrag und seine Nachkommen.
::chown: Setzt den Besitzer und die Gruppe für Einträge.
::chown_R: Setzt den Besitzer und die Gruppe für Einträge und ihre Nachkommen.
::touch: Setzt die Zugriffs- und Änderungszeiten für Einträge, erstellt sie bei Bedarf.

Vergleichen

::compare_file, ::cmp, ::identical?: Gibt zurück, ob zwei Einträge identisch sind.
::compare_stream: Gibt zurück, ob zwei Streams identisch sind.

Kopieren

::copy_entry: Kopiert einen Eintrag rekursiv.
::copy_file: Kopiert einen Eintrag.
::copy_stream: Kopiert einen Stream.
::cp, ::copy: Kopiert Dateien.
::cp_lr: Erstellt rekursiv Hardlinks.
::cp_r: Kopiert Dateien rekursiv und behält Modus, Besitzer und Gruppe bei.
::install: Kopiert Dateien rekursiv und setzt optional Modus, Besitzer und Gruppe.

Options

::collect_method: Gibt die Namen der Methoden zurück, die eine bestimmte Option akzeptieren.
::commands: Gibt die Namen der Methoden zurück, die Optionen akzeptieren.
::have_option?: Gibt zurück, ob eine bestimmte Methode eine bestimmte Option akzeptiert.
::options: Gibt alle Optionsnamen zurück.
::options_of: Gibt die Namen der Optionen für eine bestimmte Methode zurück.

Pfad-Argumente

Einige Methoden in FileUtils akzeptieren Pfad-Argumente, die als Pfade zu Dateisystemeinträgen interpretiert werden.

Wenn das Argument ein String ist, ist dieser Wert der Pfad.
Wenn das Argument die Methode :to_path hat, wird es über diese Methode konvertiert.
Wenn das Argument die Methode :to_str hat, wird es über diese Methode konvertiert.

Einige Beispiele hier beinhalten Baumstrukturen von Dateieinträgen. Dafür zeigen wir manchmal Bäume mit dem tree Kommandozeilen-Utility, einem rekursiven Verzeichnisauflistungs-Utility, das eine tiefenindizierte Liste von Dateien und Verzeichnissen ausgibt.

Wir verwenden eine Hilfsmethode, um den Befehl zu starten und das Format zu steuern

def tree(dirpath = '.')
  command = "tree --noreport --charset=ascii #{dirpath}"
  system(command)
end

Zur Veranschaulichung

tree('src0')
# => src0
#    |-- sub0
#    |   |-- src0.txt
#    |   `-- src1.txt
#    `-- sub1
#        |-- src2.txt
#        `-- src3.txt

Vermeidung der TOCTTOU-Schwachstelle

Für bestimmte Methoden, die Einträge rekursiv entfernen, gibt es eine potenzielle Schwachstelle namens Time-of-check to time-of-use (TOCTTOU), die auftreten kann, wenn

Ein Elternverzeichnis des Eintrags am Zielpfad beschreibbar ist; solche Verzeichnisse umfassen /tmp.
Der Verzeichnisbaum am Zielpfad enthält
- Ein beschreibbares Nachkommenverzeichnis.
- Ein symbolischer Link.

Um diese Schwachstelle zu vermeiden, können Sie diese Methode verwenden, um Einträge zu entfernen

FileUtils.remove_entry_secure: Entfernt rekursiv, wenn der Zielpfad auf ein Verzeichnis zeigt.

Ebenfalls verfügbar sind diese Methoden, die jeweils FileUtils.remove_entry_secure aufrufen

FileUtils.rm_r mit dem Schlüsselwortargument secure: true.
FileUtils.rm_rf mit dem Schlüsselwortargument secure: true.

Schließlich ruft diese Methode zum Verschieben von Einträgen FileUtils.remove_entry_secure auf, wenn Quelle und Ziel auf unterschiedlichen Dateisystemen liegen (was bedeutet, dass das "Verschieben" eigentlich ein Kopieren und Entfernen ist)

FileUtils.mv mit dem Schlüsselwortargument secure: true.

Die Methode FileUtils.remove_entry_secure entfernt sicher, indem sie eine spezielle Vorverarbeitung anwendet.

Wenn der Zielpfad auf ein Verzeichnis zeigt, verwendet diese Methode die Methoden File#chown und File#chmod beim Entfernen von Verzeichnissen.
Der Besitzer des Zielverzeichnisses muss entweder der aktuelle Prozess oder der Superuser (root) sein.

WARNUNG: Sie müssen sicherstellen, dass **ALLE** Elternverzeichnisse nicht von anderen nicht vertrauenswürdigen Benutzern verschoben werden können. Zum Beispiel sollten Elternverzeichnisse nicht von nicht vertrauenswürdigen Benutzern besessen werden und nicht beschreibbar sein, es sei denn, das Sticky-Bit ist gesetzt.

Details zu dieser Sicherheitslücke finden Sie in Perl-Fällen

Constants

VERSION: Die Versionsnummer.

Öffentliche Klassenmethoden

cd (dir, verbose: nil) { |dir| ... }

Source

# File lib/fileutils.rb, line 239
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

Ändert das Arbeitsverzeichnis zum angegebenen dir, das als Pfad interpretierbar sein sollte.

Ohne Block wird das aktuelle Verzeichnis in das Verzeichnis unter dir geändert; gibt Null zurück.

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

Mit einem Block wird das aktuelle Verzeichnis in das Verzeichnis unter dir geändert, der Block mit dem Argument dir aufgerufen und das ursprüngliche aktuelle Verzeichnis wiederhergestellt; gibt den Wert des Blocks zurück.

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

Schlüsselwortargumente

verbose: true - gibt einen äquivalenten Befehl aus.

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

Ausgabe

cd ..
cd fileutils

Zugehörig: FileUtils.pwd.

Auch alias genannt: chdir

chdir (dir, verbose: nil)

Alias für: cd

chmod (mode, list, noop: nil, verbose: nil)

Source

# File lib/fileutils.rb, line 1801
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

Ändert die Berechtigungen für die Einträge an den Pfaden in list (ein einzelner Pfad oder ein Array von Pfaden) auf die Berechtigungen, die von mode angegeben werden; gibt list zurück, wenn es ein Array ist, sonst [list].

Ändert jeden Eintrag, der eine reguläre Datei ist, unter Verwendung von File.chmod.
Ändert jeden Eintrag, der ein symbolischer Link ist, unter Verwendung von File.lchmod.

Das Argument list oder seine Elemente sollten als Pfade interpretierbar sein.

Das Argument mode kann entweder eine Ganzzahl oder ein String sein.

Ganzzahl mode: stellt die zu setzenden Berechtigungsbits dar.

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

String mode: stellt die zu setzenden Berechtigungen dar.

Der String hat das Format [targets][[operator][perms[,perms]], wobei
- targets kann jede Kombination dieser Buchstaben sein.
  - 'u': Berechtigungen gelten für den Dateibesitzer.
  - 'g': Berechtigungen gelten für Benutzer in der Gruppe der Datei.
  - 'o': Berechtigungen gelten für andere Benutzer, die nicht zur Gruppe der Datei gehören.
  - 'a' (Standard): Berechtigungen gelten für alle Benutzer.
- operator kann einer dieser Buchstaben sein.
  - '+': fügt Berechtigungen hinzu.
  - '-': entfernt Berechtigungen.
  - '=': setzt (ersetzt) Berechtigungen.
- perms (kann wiederholt werden, mit trennenden Kommas) kann jede Kombination dieser Buchstaben sein.
  - 'r': Lesen.
  - 'w': Schreiben.
  - 'x': Ausführen (Suchen für ein Verzeichnis).
  - 'X': Suchen (nur für Verzeichnisse; muss mit '+' verwendet werden)
  - 's': Uid oder Gid.
  - 't': Sticky-Bit.
Beispiele
```
FileUtils.chmod('u=wrx,go=rx', 'src1.txt')
FileUtils.chmod('u=wrx,go=rx', '/usr/bin/ruby')
```

Schlüsselwortargumente

noop: true - ändert keine Berechtigungen; gibt nil zurück.

verbose: true - gibt einen äquivalenten Befehl aus.

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)

Ausgabe

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

Zugehörig: FileUtils.chmod_R.

chmod_R (mode, list, noop: nil, verbose: nil, force: nil)

Source

# File lib/fileutils.rb, line 1813
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

Wie FileUtils.chmod, ändert aber Berechtigungen rekursiv.

chown (user, group, list, noop: nil, verbose: nil)

Source

# File lib/fileutils.rb, line 1894
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

Ändert den Besitzer und die Gruppe für die Einträge an den Pfaden in list (ein einzelner Pfad oder ein Array von Pfaden) auf die angegebenen user und group; gibt list zurück, wenn es ein Array ist, sonst [list].

Ändert jeden Eintrag, der eine reguläre Datei ist, unter Verwendung von File.chown.
Ändert jeden Eintrag, der ein symbolischer Link ist, unter Verwendung von File.lchown.

Das Argument list oder seine Elemente sollten als Pfade interpretierbar sein.

Benutzer und Gruppe

Das Argument user kann ein Benutzername oder eine Benutzer-ID sein; wenn nil oder -1, wird der Benutzer nicht geändert.
Das Argument group kann ein Gruppenname oder eine Gruppen-ID sein; wenn nil oder -1, wird die Gruppe nicht geändert.
Der Benutzer muss Mitglied der Gruppe sein.

Beispiele

# 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', '.')

Schlüsselwortargumente

noop: true - ändert keine Berechtigungen; gibt nil zurück.

verbose: true - gibt einen äquivalenten Befehl aus.

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)

Ausgabe

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 .

Zugehörig: FileUtils.chown_R.

chown_R (user, group, list, noop: nil, verbose: nil, force: nil)

Source

# File lib/fileutils.rb, line 1910
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

Wie FileUtils.chown, ändert aber Besitzer und Gruppe rekursiv.

cmp (a, b)

Alias für: compare_file

collect_method (opt)

Source

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

Gibt ein Array von String-Methodennamen der Methoden zurück, die die gegebene Schlüsselwortoption opt akzeptieren; das Argument muss ein Symbol sein.

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

commands ()

Source

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

Gibt ein Array von String-Namen von FileUtils-Methoden zurück, die ein oder mehrere Schlüsselwortargumente akzeptieren.

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

compare_file (a, b)

Source

# File lib/fileutils.rb, line 1505
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

Gibt true zurück, wenn der Inhalt der Dateien a und b identisch ist, andernfalls false.

Die Argumente a und b sollten als Pfade interpretierbar sein.

FileUtils.identical? und FileUtils.cmp sind Aliase für FileUtils.compare_file.

Zugehörig: FileUtils.compare_stream.

Auch alias genannt: identical?, cmp

compare_stream (a, b)

Source

# File lib/fileutils.rb, line 1528
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

Gibt true zurück, wenn der Inhalt der Streams a und b identisch ist, andernfalls false.

Die Argumente a und b sollten als Pfade interpretierbar sein.

Zugehörig: FileUtils.compare_file.

copy (src, dest, preserve: nil, noop: nil, verbose: nil)

Alias für: cp

copy_entry (src, dest, preserve = false, dereference_root = false, remove_destination = false)

Source

# File lib/fileutils.rb, line 1037
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

Kopiert Dateien von src nach dest rekursiv.

Die Argumente src und dest sollten als Pfade interpretierbar sein.

Wenn src der Pfad zu einer Datei ist, kopiert es src nach dest.

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

Wenn src ein Verzeichnis ist, kopiert es src rekursiv nach 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

Die rekursive Kopie behält Dateitypen für reguläre Dateien, Verzeichnisse und symbolische Links bei; andere Dateitypen (FIFO-Streams, Gerätedateien usw.) werden nicht unterstützt.

Optionale Argumente

dereference_root - wenn src ein symbolischer Link ist, folgt es dem Link (standardmäßig false).
preserve - behält die Datei-Zeiten bei (standardmäßig false).
remove_destination - entfernt dest vor dem Kopieren von Dateien (standardmäßig false).

Zugehörig: Methoden zum Kopieren.

copy_file (src, dest, preserve = false, dereference = true)

Source

# File lib/fileutils.rb, line 1073
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

Kopiert eine Datei von src nach dest, was keine Verzeichnisse sein sollten.

Die Argumente src und dest sollten als Pfade interpretierbar sein.

Beispiele

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

Optionale Argumente

dereference - wenn src ein symbolischer Link ist, folgt es dem Link (standardmäßig true).
preserve - behält die Datei-Zeiten bei (standardmäßig false).
remove_destination - entfernt dest vor dem Kopieren von Dateien (standardmäßig false).

Zugehörig: Methoden zum Kopieren.

copy_stream (src, dest)

Source

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

Kopiert den IO-Stream src in den IO-Stream dest über IO.copy_stream.

Zugehörig: Methoden zum Kopieren.

cp (src, dest, preserve: nil, noop: nil, verbose: nil)

Source

# File lib/fileutils.rb, line 870
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

Kopiert Dateien.

Die Argumente src (ein einzelner Pfad oder ein Array von Pfaden) und dest (ein einzelner Pfad) sollten als Pfade interpretierbar sein.

Wenn src der Pfad zu einer Datei ist und dest nicht der Pfad zu einem Verzeichnis ist, wird src nach dest kopiert.

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

Wenn src der Pfad zu einer Datei ist und dest der Pfad zu einem Verzeichnis ist, wird src nach dest/src kopiert.

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

Wenn src ein Array von Pfaden zu Dateien ist und dest der Pfad zu einem Verzeichnis ist, wird von jeder src nach dest kopiert.

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

Schlüsselwortargumente

preserve: true - behält Datei-Zeiten bei.
noop: true - kopiert keine Dateien.

verbose: true - gibt einen äquivalenten Befehl aus.

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)

Ausgabe

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

Löst eine Ausnahme aus, wenn src ein Verzeichnis ist.

Zugehörig: Methoden zum Kopieren.

Auch alias genannt: copy

cp_lr (src, dest, noop: nil, verbose: nil, dereference_root: true, remove_destination: false)

Source

# File lib/fileutils.rb, line 628
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

Erstellt Hardlinks.

Die Argumente src (ein einzelner Pfad oder ein Array von Pfaden) und dest (ein einzelner Pfad) sollten als Pfade interpretierbar sein.

Wenn src der Pfad zu einem Verzeichnis ist und dest nicht existiert, werden Links dest und seine Nachkommen erstellt, die auf src und seine Nachkommen zeigen.

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

Wenn src und dest beide Pfade zu Verzeichnissen sind, werden Links dest/src und seine Nachkommen erstellt, die auf src und seine Nachkommen zeigen.

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

Wenn src ein Array von Pfaden zu Einträgen ist und dest der Pfad zu einem Verzeichnis ist, wird für jeden Pfad filepath in src ein Link unter dest/filepath erstellt, der auf diesen Pfad zeigt.

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

Schlüsselwortargumente

dereference_root: false - wenn src ein symbolischer Link ist, wird er nicht dereferenziert.
noop: true - erstellt keine Links.
remove_destination: true - entfernt dest vor dem Erstellen von Links.

verbose: true - gibt einen äquivalenten Befehl aus.

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)

Ausgabe

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

Löst eine Ausnahme aus, wenn dest der Pfad zu einer vorhandenen Datei oder einem vorhandenen Verzeichnis ist und das Schlüsselwortargument remove_destination: true nicht angegeben ist.

Zugehörig: Methoden zum Kopieren.

cp_r (src, dest, preserve: nil, noop: nil, verbose: nil, dereference_root: true, remove_destination: nil)

Source

# File lib/fileutils.rb, line 982
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

Kopiert Dateien rekursiv.

Die Argumente src (ein einzelner Pfad oder ein Array von Pfaden) und dest (ein einzelner Pfad) sollten als Pfade interpretierbar sein.

Der Modus, der Besitzer und die Gruppe werden in der Kopie beibehalten; um diese zu ändern, verwenden Sie stattdessen FileUtils.install.

Wenn src der Pfad zu einer Datei ist und dest nicht der Pfad zu einem Verzeichnis ist, wird src nach dest kopiert.

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

Wenn src der Pfad zu einer Datei ist und dest der Pfad zu einem Verzeichnis ist, wird src nach dest/src kopiert.

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

Wenn src der Pfad zu einem Verzeichnis ist und dest nicht existiert, wird src rekursiv nach dest kopiert.

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

Wenn src und dest Pfade zu Verzeichnissen sind, wird src rekursiv nach dest/src kopiert.

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

Wenn src ein Array von Pfaden ist und dest ein Verzeichnis ist, werden die Pfade aus src rekursiv nach dest kopiert; die Pfade in src können auf Dateien und/oder Verzeichnisse zeigen.

Schlüsselwortargumente

dereference_root: false - wenn src ein symbolischer Link ist, wird er nicht dereferenziert.
noop: true - kopiert keine Dateien.
preserve: true - behält Datei-Zeiten bei.
remove_destination: true - entfernt dest vor dem Kopieren von Dateien.

verbose: true - gibt einen äquivalenten Befehl aus.

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)

Ausgabe

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

Löst eine Ausnahme aus, wenn src der Pfad zu einem Verzeichnis ist und dest der Pfad zu einer Datei ist.

Zugehörig: Methoden zum Kopieren.

getwd ()

Alias für: pwd

have_option? (mid, opt)

Source

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

Gibt true zurück, wenn die Methode mid die gegebene Option opt akzeptiert, andernfalls false; die Argumente können Strings oder Symbole sein.

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

identical? (a, b)

Alias für: compare_file

install (src, dest, mode: nil, owner: nil, group: nil, preserve: nil, noop: nil, verbose: nil)

Source

# File lib/fileutils.rb, line 1607
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
      if d.end_with?('/')
        mkdir_p d
        copy_file s, d + File.basename(s)
      else
        mkdir_p File.expand_path('..', d)
        copy_file s, d
      end
      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

Kopiert einen Dateieintrag. Siehe install(1).

Die Argumente src (ein einzelner Pfad oder ein Array von Pfaden) und dest (ein einzelner Pfad) sollten als Pfade interpretierbar sein;

Wenn der Eintrag unter dest nicht existiert, wird von src nach dest kopiert.

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

Wenn dest eine Datei ist, wird von src nach dest kopiert und überschrieben.

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

Wenn dest ein Verzeichnis ist, wird von src nach dest/src kopiert und bei Bedarf überschrieben.

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"

Wenn src ein Array von Pfaden ist und dest auf ein Verzeichnis zeigt, wird jeder Pfad path in src nach dest/path kopiert.

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

Schlüsselwortargumente

group: group - ändert die Gruppe, wenn nicht nil ist, unter Verwendung von File.chown.
mode: permissions - ändert die Berechtigungen unter Verwendung von File.chmod.
noop: true - kopiert keine Einträge; gibt nil zurück.
owner: owner - ändert den Besitzer, wenn nicht nil ist, unter Verwendung von File.chown.
preserve: true - behält Zeitstempel bei unter Verwendung von File.utime.

verbose: true - gibt einen äquivalenten Befehl aus.

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)

Ausgabe

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

Zugehörig: Methoden zum Kopieren.

link (src, dest, force: nil, noop: nil, verbose: nil)

Alias für: ln

link_entry (src, dest, dereference_root = false, remove_destination = false)

Source

# File lib/fileutils.rb, line 809
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

Erstellt Hardlinks; gibt nil zurück.

Die Argumente src und dest sollten als Pfade interpretierbar sein.

Wenn src der Pfad zu einer Datei ist und dest nicht existiert, wird ein Hardlink unter dest erstellt, der auf src zeigt.

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

Wenn src der Pfad zu einem Verzeichnis ist und dest nicht existiert, werden rekursiv Hardlinks unter dest erstellt, die auf Pfade in src zeigen.

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

Optionale Argumente

dereference_root - dereferenziert src, wenn es ein symbolischer Link ist (standardmäßig false).
remove_destination - entfernt dest vor dem Erstellen von Links (standardmäßig false).

Löst eine Ausnahme aus, wenn dest der Pfad zu einer vorhandenen Datei oder einem vorhandenen Verzeichnis ist und das optionale Argument remove_destination nicht angegeben ist.

Zugehörig: FileUtils.ln (hat andere Optionen).

ln (src, dest, force: nil, noop: nil, verbose: nil)

Source

# File lib/fileutils.rb, line 517
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

Erstellt Hardlinks.

Die Argumente src (ein einzelner Pfad oder ein Array von Pfaden) und dest (ein einzelner Pfad) sollten als Pfade interpretierbar sein.

Wenn src der Pfad zu einer vorhandenen Datei ist und dest der Pfad zu einer nicht vorhandenen Datei ist, wird ein Hardlink unter dest erstellt, der auf src zeigt; gibt Null zurück.

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

Wenn src der Pfad zu einer vorhandenen Datei ist und dest der Pfad zu einem vorhandenen Verzeichnis ist, wird ein Hardlink unter dest/src erstellt, der auf src zeigt; gibt Null zurück.

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

Wenn src ein Array von Pfaden zu vorhandenen Dateien ist und dest der Pfad zu einem vorhandenen Verzeichnis ist, dann wird für jeden Pfad target in src ein Hardlink unter dest/target erstellt, der auf target zeigt; gibt src zurück.

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"]

Schlüsselwortargumente

force: true - überschreibt dest, wenn es existiert.
noop: true - erstellt keine Links.

verbose: true - gibt einen äquivalenten Befehl aus.

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)

Ausgabe

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

Löst eine Ausnahme aus, wenn dest der Pfad zu einer vorhandenen Datei ist und das Schlüsselwortargument force nicht true ist.

Zugehörig: FileUtils.link_entry (hat andere Optionen).

Auch alias genannt: link

ln_s (src, dest, force: nil, relative: false, target_directory: true, noop: nil, verbose: nil)

Source

# File lib/fileutils.rb, line 707
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, target_directory: target_directory, noop: noop, verbose: verbose)
  end
  fu_output_message "ln -s#{force ? 'f' : ''}#{
    target_directory ? '' : 'T'} #{[src,dest].flatten.join ' '}" if verbose
  return if noop
  fu_each_src_dest0(src, dest, target_directory) do |s,d|
    remove_file d, true if force
    File.symlink s, d
  end
end

Erstellt symbolische Links.

Die Argumente src (ein einzelner Pfad oder ein Array von Pfaden) und dest (ein einzelner Pfad) sollten als Pfade interpretierbar sein.

Wenn src der Pfad zu einer vorhandenen Datei ist

Wenn dest der Pfad zu einer nicht vorhandenen Datei ist, wird ein symbolischer Link unter dest erstellt, der auf src zeigt.

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

Wenn dest der Pfad zu einer vorhandenen Datei ist, wird ein symbolischer Link unter dest erstellt, der auf src zeigt, nur wenn das Schlüsselwortargument force: true gegeben ist (löst andernfalls eine Ausnahme aus).

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.

Wenn dest der Pfad zu einem Verzeichnis ist, wird ein symbolischer Link unter dest/src erstellt, der auf src zeigt.

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

Wenn src ein Array von Pfaden zu vorhandenen Dateien ist und dest ein Verzeichnis ist, wird für jedes Kind child in src ein symbolischer Link dest/child erstellt, der auf child zeigt.

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

Schlüsselwortargumente

force: true - überschreibt dest, wenn es existiert.
relative: false - erstellt Links relativ zu dest.
noop: true - erstellt keine Links.

verbose: true - gibt einen äquivalenten Befehl aus.

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)

Ausgabe

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

Zugehörig: FileUtils.ln_sf.

Auch alias genannt: symlink

ln_sf (src, dest, noop: nil, verbose: nil)

Source

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

Wie FileUtils.ln_s, aber immer mit dem Schlüsselwortargument force: true.

ln_sr (src, dest, target_directory: true, force: nil, noop: nil, verbose: nil)

Source

# File lib/fileutils.rb, line 733
def ln_sr(src, dest, target_directory: true, force: nil, noop: nil, verbose: nil)
  cmd = "ln -s#{force ? 'f' : ''}#{target_directory ? '' : 'T'}" if verbose
  fu_each_src_dest0(src, dest, target_directory) do |s,d|
    if target_directory
      parent = File.dirname(d)
      destdirs = fu_split_path(parent)
      real_ddirs = fu_split_path(File.realpath(parent))
    else
      destdirs ||= fu_split_path(dest)
      real_ddirs ||= fu_split_path(File.realdirpath(dest))
    end
    srcdirs = fu_split_path(s)
    i = fu_common_components(srcdirs, destdirs)
    n = destdirs.size - i
    n -= 1 unless target_directory
    link1 = fu_clean_components(*Array.new([n, 0].max, '..'), *srcdirs[i..-1])
    begin
      real_sdirs = fu_split_path(File.realdirpath(s)) rescue nil
    rescue
    else
      i = fu_common_components(real_sdirs, real_ddirs)
      n = real_ddirs.size - i
      n -= 1 unless target_directory
      link2 = fu_clean_components(*Array.new([n, 0].max, '..'), *real_sdirs[i..-1])
      link1 = link2 if link1.size > link2.size
    end
    s = File.join(link1)
    fu_output_message [cmd, s, d].flatten.join(' ') if verbose
    next if noop
    remove_file d, true if force
    File.symlink s, d
  end
end

Wie FileUtils.ln_s, aber erstellt Links relativ zu dest.

makedirs (list, mode: nil, noop: nil, verbose: nil)

Alias für: mkdir_p

mkdir (list, mode: nil, noop: nil, verbose: nil)

Source

# File lib/fileutils.rb, line 317
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

Erstellt Verzeichnisse an den Pfaden in der gegebenen list (ein einzelner Pfad oder ein Array von Pfaden); gibt list zurück, wenn es ein Array ist, sonst [list].

Das Argument list oder seine Elemente sollten als Pfade interpretierbar sein.

Ohne Schlüsselwortargumente wird unter jedem path in list ein Verzeichnis erstellt, indem aufgerufen wird: Dir.mkdir(path, mode); siehe Dir.mkdir.

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

Schlüsselwortargumente

mode: mode - ruft auch File.chmod(mode, path) auf; siehe File.chmod.
noop: true - erstellt keine Verzeichnisse.

verbose: true - gibt einen äquivalenten Befehl aus.

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

Ausgabe

mkdir tmp0 tmp1
mkdir -m 700 tmp2 tmp3

Löst eine Ausnahme aus, wenn ein Pfad auf eine vorhandene Datei oder ein vorhandenes Verzeichnis zeigt oder wenn aus irgendeinem Grund ein Verzeichnis nicht erstellt werden kann.

Zugehörig: FileUtils.mkdir_p.

mkdir_p (list, mode: nil, noop: nil, verbose: nil)

Source

# File lib/fileutils.rb, line 366
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

Erstellt Verzeichnisse an den Pfaden in der gegebenen list (ein einzelner Pfad oder ein Array von Pfaden) und erstellt bei Bedarf auch Elternverzeichnisse; gibt list zurück, wenn es ein Array ist, sonst [list].

Das Argument list oder seine Elemente sollten als Pfade interpretierbar sein.

Ohne Schlüsselwortargumente wird unter jedem path in list ein Verzeichnis erstellt, zusammen mit allen benötigten Elternverzeichnissen, indem aufgerufen wird: Dir.mkdir(path, mode); siehe Dir.mkdir.

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

Schlüsselwortargumente

mode: mode - ruft auch File.chmod(mode, path) auf; siehe File.chmod.
noop: true - erstellt keine Verzeichnisse.

verbose: true - gibt einen äquivalenten Befehl aus.

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

Ausgabe

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

Löst eine Ausnahme aus, wenn aus irgendeinem Grund ein Verzeichnis nicht erstellt werden kann.

FileUtils.mkpath und FileUtils.makedirs sind Aliase für FileUtils.mkdir_p.

Zugehörig: FileUtils.mkdir.

Auch alias genannt: mkpath, makedirs

mkpath (list, mode: nil, noop: nil, verbose: nil)

Alias für: mkdir_p

move (src, dest, force: nil, noop: nil, verbose: nil, secure: nil)

Alias für: mv

mv (src, dest, force: nil, noop: nil, verbose: nil, secure: nil)

Source

# File lib/fileutils.rb, line 1154
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

Verschiebt Einträge.

Die Argumente src (ein einzelner Pfad oder ein Array von Pfaden) und dest (ein einzelner Pfad) sollten als Pfade interpretierbar sein.

Wenn sich src und dest auf unterschiedlichen Dateisystemen befinden, wird zuerst kopiert, dann src entfernt.

Kann eine lokale Schwachstelle verursachen, wenn nicht mit dem Schlüsselwortargument secure: true aufgerufen; siehe Vermeidung der TOCTTOU-Schwachstelle.

Wenn src der Pfad zu einer einzelnen Datei oder einem einzelnen Verzeichnis ist und dest nicht existiert, wird src nach dest verschoben.

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

Wenn src ein Array von Pfaden zu Dateien und Verzeichnissen ist und dest der Pfad zu einem Verzeichnis ist, wird von jedem Pfad in dem Array nach dest kopiert.

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

Schlüsselwortargumente

force: true - wenn das Verschieben das Entfernen von src beinhaltet (d.h. wenn src und dest auf unterschiedlichen Dateisystemen liegen), ignoriert es ausgelöste Ausnahmen von StandardError und seinen Nachkommen.
noop: true - verschiebt keine Dateien.
secure: true - entfernt src sicher; siehe Details unter FileUtils.remove_entry_secure.

verbose: true - gibt einen äquivalenten Befehl aus.

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

Ausgabe

mv src0 dest0
mv src1.txt src1 dest1

Auch alias genannt: move

options ()

Source

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

Gibt ein Array von Schlüsselwortnamen als Zeichenfolgen zurück

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

options_of (mid)

Source

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

Gibt ein Array von Schlüsselwortnamen als Zeichenfolgen für die Methode mid zurück; das Argument kann eine Zeichenfolge oder ein Symbol sein

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

pwd ()

Source

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

Gibt eine Zeichenfolge mit dem Pfad zum aktuellen Verzeichnis zurück

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

Verwandt: FileUtils.cd.

Auch alias genannt: getwd

remove (list, force: nil, noop: nil, verbose: nil)

Alias für: rm

remove_dir (path, force = false)

Source

# File lib/fileutils.rb, line 1489
def remove_dir(path, force = false)
  raise Errno::ENOTDIR, path unless force or File.directory?(path)
  remove_entry path, force
end

Entfernt rekursiv den durch path gegebenen Verzeichniseintrag, der ein regulärer Dateieintrag, ein symbolischer Link oder ein Verzeichnis sein sollte.

Das Argument path sollte als Pfad interpretierbar sein.

Das optionale Argument force gibt an, ob Ausnahmen von StandardError und seinen Nachfolgern ignoriert werden sollen.

Verwandt: Methoden zum Löschen.

remove_entry (path, force = false)

Source

# File lib/fileutils.rb, line 1446
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

Entfernt den durch path gegebenen Eintrag, der ein regulärer Dateieintrag, ein symbolischer Link oder ein Verzeichnis sein sollte.

Das Argument path sollte als Pfad interpretierbar sein.

Das optionale Argument force gibt an, ob Ausnahmen von StandardError und seinen Nachfolgern ignoriert werden sollen.

Verwandt: FileUtils.remove_entry_secure.

remove_entry_secure (path, force = false)

Source

# File lib/fileutils.rb, line 1348
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

Entfernt den durch path gegebenen Eintrag sicher, der ein regulärer Dateieintrag, ein symbolischer Link oder ein Verzeichnis sein sollte.

Das Argument path sollte als Pfad interpretierbar sein.

Vermeidet eine lokale Schwachstelle, die unter bestimmten Umständen auftreten kann. Siehe Vermeiden der TOCTTOU-Schwachstelle.

Das optionale Argument force gibt an, ob Ausnahmen von StandardError und seinen Nachfolgern ignoriert werden sollen.

Verwandt: Methoden zum Löschen.

remove_file (path, force = false)

Source

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

Entfernt den durch path gegebenen Dateieintrag, der ein regulärer Dateieintrag oder ein symbolischer Link sein sollte.

Das Argument path sollte als Pfad interpretierbar sein.

Das optionale Argument force gibt an, ob Ausnahmen von StandardError und seinen Nachfolgern ignoriert werden sollen.

Verwandt: Methoden zum Löschen.

rm (list, force: nil, noop: nil, verbose: nil)

Source

# File lib/fileutils.rb, line 1213
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

Entfernt Einträge an den Pfaden in der gegebenen list (ein einzelner Pfad oder ein Array von Pfaden); gibt list zurück, wenn es ein Array ist, andernfalls [list].

Das Argument list oder seine Elemente sollten als Pfade interpretierbar sein.

Ohne Schlüsselwortargumente werden Dateien an den in list angegebenen Pfaden entfernt

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

Schlüsselwortargumente

force: true - ignoriert Ausnahmen von StandardError und seinen Nachfolgern.
noop: true - entfernt keine Dateien; gibt nil zurück.

verbose: true - gibt einen äquivalenten Befehl aus.

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

Ausgabe

rm src0.dat src0.txt

Verwandt: Methoden zum Löschen.

Auch alias genannt: remove

rm_f (list, noop: nil, verbose: nil)

Source

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

Entspricht

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

Das Argument list (ein einzelner Pfad oder ein Array von Pfaden) sollte als Pfade interpretierbar sein.

Siehe FileUtils.rm für Schlüsselwortargumente.

Verwandt: Methoden zum Löschen.

Auch alias genannt: safe_unlink

rm_r (list, force: nil, noop: nil, verbose: nil, secure: nil)

Source

# File lib/fileutils.rb, line 1296
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

Entfernt Einträge an den Pfaden in der gegebenen list (ein einzelner Pfad oder ein Array von Pfaden); gibt list zurück, wenn es ein Array ist, andernfalls [list].

Das Argument list oder seine Elemente sollten als Pfade interpretierbar sein.

Kann eine lokale Schwachstelle verursachen, wenn nicht mit dem Schlüsselwortargument secure: true aufgerufen; siehe Vermeidung der TOCTTOU-Schwachstelle.

Für jeden Dateipfad wird die Datei an diesem Pfad entfernt

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

Für jeden Verzeichnispfad werden Dateien und Verzeichnisse rekursiv entfernt

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

Schlüsselwortargumente

force: true - ignoriert Ausnahmen von StandardError und seinen Nachfolgern.
noop: true - entfernt keine Einträge; gibt nil zurück.
secure: true - entfernt src sicher; siehe Details unter FileUtils.remove_entry_secure.

verbose: true - gibt einen äquivalenten Befehl aus.

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

Ausgabe

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

Verwandt: Methoden zum Löschen.

rm_rf (list, noop: nil, verbose: nil, secure: nil)

Source

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

Entspricht

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

Das Argument list oder seine Elemente sollten als Pfade interpretierbar sein.

Kann eine lokale Schwachstelle verursachen, wenn nicht mit dem Schlüsselwortargument secure: true aufgerufen; siehe Vermeidung der TOCTTOU-Schwachstelle.

Siehe FileUtils.rm_r für Schlüsselwortargumente.

Verwandt: Methoden zum Löschen.

Auch alias genannt: rmtree

rmdir (list, parents: nil, noop: nil, verbose: nil)

Source

# File lib/fileutils.rb, line 443
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

Entfernt Verzeichnisse an den Pfaden in der gegebenen list (ein einzelner Pfad oder ein Array von Pfaden); gibt list zurück, wenn es ein Array ist, andernfalls [list].

Das Argument list oder seine Elemente sollten als Pfade interpretierbar sein.

Ohne Schlüsselwortargumente wird das Verzeichnis an jedem path in list entfernt, indem aufgerufen wird: Dir.rmdir(path); siehe Dir.rmdir

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

Schlüsselwortargumente

parents: true - entfernt aufeinanderfolgende übergeordnete Verzeichnisse, wenn sie leer sind.
noop: true - entfernt keine Verzeichnisse.

verbose: true - gibt einen äquivalenten Befehl aus.

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

Ausgabe

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

Löst eine Ausnahme aus, wenn ein Verzeichnis nicht existiert oder wenn aus irgendeinem Grund ein Verzeichnis nicht entfernt werden kann.

Verwandt: Methoden zum Löschen.

rmtree (list, noop: nil, verbose: nil, secure: nil)

Alias für: rm_rf

safe_unlink (list, noop: nil, verbose: nil)

Alias für: rm_f

symlink (src, dest, force: nil, relative: false, target_directory: true, noop: nil, verbose: nil)

Alias für: ln_s

touch (list, noop: nil, verbose: nil, mtime: nil, nocreate: nil)

Source

# File lib/fileutils.rb, line 2004
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

Aktualisiert die Änderungszeiten (mtime) und Zugriffszeiten (atime) der durch die Pfade in list gegebenen Einträge (ein einzelner Pfad oder ein Array von Pfaden); gibt list zurück, wenn es ein Array ist, andernfalls [list].

Erstellt standardmäßig eine leere Datei für jeden Pfad zu einem nicht vorhandenen Eintrag; verwenden Sie das Schlüsselwortargument nocreate, um stattdessen eine Ausnahme auszulösen.

Das Argument list oder seine Elemente sollten als Pfade interpretierbar sein.

Beispiele

# 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'])

Schlüsselwortargumente

mtime: time - setzt die mtime des Eintrags auf die angegebene Zeit anstelle der aktuellen Zeit.
nocreate: true - löst eine Ausnahme aus, wenn der Eintrag nicht existiert.
noop: true - berührt keine Einträge; gibt nil zurück.

verbose: true - gibt einen äquivalenten Befehl aus.

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)

Ausgabe

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

Verwandt: FileUtils.uptodate?.

uptodate? (new, old_list)

Source

# File lib/fileutils.rb, line 265
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

Gibt true zurück, wenn die Datei unter dem Pfad new neuer ist als alle Dateien unter den Pfaden im Array old_list; andernfalls false.

Das Argument new und die Elemente von old_list sollten als Pfade interpretierbar sein

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

Eine nicht existierende Datei gilt als unendlich alt.

Verwandt: FileUtils.touch.

Private Instanzmethoden

cd (dir, verbose: nil) { |dir| ... }

Source

# File lib/fileutils.rb, line 239
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

Ändert das Arbeitsverzeichnis zum angegebenen dir, das als Pfad interpretierbar sein sollte.

Ohne Block wird das aktuelle Verzeichnis in das Verzeichnis unter dir geändert; gibt Null zurück.

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

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

Schlüsselwortargumente

verbose: true - gibt einen äquivalenten Befehl aus.

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

Ausgabe

cd ..
cd fileutils

Zugehörig: FileUtils.pwd.

Auch alias genannt: chdir

chdir (dir, verbose: nil)

Alias für: cd

chmod (mode, list, noop: nil, verbose: nil)

Source

# File lib/fileutils.rb, line 1801
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

Ändert jeden Eintrag, der eine reguläre Datei ist, unter Verwendung von File.chmod.
Ändert jeden Eintrag, der ein symbolischer Link ist, unter Verwendung von File.lchmod.

Das Argument list oder seine Elemente sollten als Pfade interpretierbar sein.

Das Argument mode kann entweder eine Ganzzahl oder ein String sein.

Ganzzahl mode: stellt die zu setzenden Berechtigungsbits dar.

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

String mode: stellt die zu setzenden Berechtigungen dar.

Der String hat das Format [targets][[operator][perms[,perms]], wobei
- targets kann jede Kombination dieser Buchstaben sein.
  - 'u': Berechtigungen gelten für den Dateibesitzer.
  - 'g': Berechtigungen gelten für Benutzer in der Gruppe der Datei.
  - 'o': Berechtigungen gelten für andere Benutzer, die nicht zur Gruppe der Datei gehören.
  - 'a' (Standard): Berechtigungen gelten für alle Benutzer.
- operator kann einer dieser Buchstaben sein.
  - '+': fügt Berechtigungen hinzu.
  - '-': entfernt Berechtigungen.
  - '=': setzt (ersetzt) Berechtigungen.
- perms (kann wiederholt werden, mit trennenden Kommas) kann jede Kombination dieser Buchstaben sein.
  - 'r': Lesen.
  - 'w': Schreiben.
  - 'x': Ausführen (Suchen für ein Verzeichnis).
  - 'X': Suchen (nur für Verzeichnisse; muss mit '+' verwendet werden)
  - 's': Uid oder Gid.
  - 't': Sticky-Bit.
Beispiele
```
FileUtils.chmod('u=wrx,go=rx', 'src1.txt')
FileUtils.chmod('u=wrx,go=rx', '/usr/bin/ruby')
```

Schlüsselwortargumente

noop: true - ändert keine Berechtigungen; gibt nil zurück.

verbose: true - gibt einen äquivalenten Befehl aus.

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)

Ausgabe

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

Zugehörig: FileUtils.chmod_R.

chmod_R (mode, list, noop: nil, verbose: nil, force: nil)

Source

# File lib/fileutils.rb, line 1813
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

Wie FileUtils.chmod, ändert aber Berechtigungen rekursiv.

chown (user, group, list, noop: nil, verbose: nil)

Source

# File lib/fileutils.rb, line 1894
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

Ändert jeden Eintrag, der eine reguläre Datei ist, unter Verwendung von File.chown.
Ändert jeden Eintrag, der ein symbolischer Link ist, unter Verwendung von File.lchown.

Das Argument list oder seine Elemente sollten als Pfade interpretierbar sein.

Benutzer und Gruppe

Das Argument user kann ein Benutzername oder eine Benutzer-ID sein; wenn nil oder -1, wird der Benutzer nicht geändert.
Das Argument group kann ein Gruppenname oder eine Gruppen-ID sein; wenn nil oder -1, wird die Gruppe nicht geändert.
Der Benutzer muss Mitglied der Gruppe sein.

Beispiele

# 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', '.')

Schlüsselwortargumente

noop: true - ändert keine Berechtigungen; gibt nil zurück.

verbose: true - gibt einen äquivalenten Befehl aus.

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)

Ausgabe

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 .

Zugehörig: FileUtils.chown_R.

chown_R (user, group, list, noop: nil, verbose: nil, force: nil)

Source

# File lib/fileutils.rb, line 1910
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

Wie FileUtils.chown, ändert aber Besitzer und Gruppe rekursiv.

cmp (a, b)

Alias für: compare_file

compare_file (a, b)

Source

# File lib/fileutils.rb, line 1505
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

Gibt true zurück, wenn der Inhalt der Dateien a und b identisch ist, andernfalls false.

Die Argumente a und b sollten als Pfade interpretierbar sein.

FileUtils.identical? und FileUtils.cmp sind Aliase für FileUtils.compare_file.

Zugehörig: FileUtils.compare_stream.

Auch alias genannt: identical?, cmp

compare_stream (a, b)

Source

# File lib/fileutils.rb, line 1528
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

Gibt true zurück, wenn der Inhalt der Streams a und b identisch ist, andernfalls false.

Die Argumente a und b sollten als Pfade interpretierbar sein.

Zugehörig: FileUtils.compare_file.

copy (src, dest, preserve: nil, noop: nil, verbose: nil)

Alias für: cp

copy_entry (src, dest, preserve = false, dereference_root = false, remove_destination = false)

Source

# File lib/fileutils.rb, line 1037
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

Kopiert Dateien von src nach dest rekursiv.

Die Argumente src und dest sollten als Pfade interpretierbar sein.

Wenn src der Pfad zu einer Datei ist, kopiert es src nach dest.

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

Wenn src ein Verzeichnis ist, kopiert es src rekursiv nach 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

Die rekursive Kopie behält Dateitypen für reguläre Dateien, Verzeichnisse und symbolische Links bei; andere Dateitypen (FIFO-Streams, Gerätedateien usw.) werden nicht unterstützt.

Optionale Argumente

dereference_root - wenn src ein symbolischer Link ist, folgt es dem Link (standardmäßig false).
preserve - behält die Datei-Zeiten bei (standardmäßig false).
remove_destination - entfernt dest vor dem Kopieren von Dateien (standardmäßig false).

Zugehörig: Methoden zum Kopieren.

copy_file (src, dest, preserve = false, dereference = true)

Source

# File lib/fileutils.rb, line 1073
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

Kopiert eine Datei von src nach dest, was keine Verzeichnisse sein sollten.

Die Argumente src und dest sollten als Pfade interpretierbar sein.

Beispiele

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

Optionale Argumente

dereference - wenn src ein symbolischer Link ist, folgt es dem Link (standardmäßig true).
preserve - behält die Datei-Zeiten bei (standardmäßig false).
remove_destination - entfernt dest vor dem Kopieren von Dateien (standardmäßig false).

Zugehörig: Methoden zum Kopieren.

copy_stream (src, dest)

Source

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

Kopiert den IO-Stream src in den IO-Stream dest über IO.copy_stream.

Zugehörig: Methoden zum Kopieren.

cp (src, dest, preserve: nil, noop: nil, verbose: nil)

Source

# File lib/fileutils.rb, line 870
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

Kopiert Dateien.

Die Argumente src (ein einzelner Pfad oder ein Array von Pfaden) und dest (ein einzelner Pfad) sollten als Pfade interpretierbar sein.

Wenn src der Pfad zu einer Datei ist und dest nicht der Pfad zu einem Verzeichnis ist, wird src nach dest kopiert.

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

Wenn src der Pfad zu einer Datei ist und dest der Pfad zu einem Verzeichnis ist, wird src nach dest/src kopiert.

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

Wenn src ein Array von Pfaden zu Dateien ist und dest der Pfad zu einem Verzeichnis ist, wird von jeder src nach dest kopiert.

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

Schlüsselwortargumente

preserve: true - behält Datei-Zeiten bei.
noop: true - kopiert keine Dateien.

verbose: true - gibt einen äquivalenten Befehl aus.

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)

Ausgabe

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

Löst eine Ausnahme aus, wenn src ein Verzeichnis ist.

Zugehörig: Methoden zum Kopieren.

Auch alias genannt: copy

cp_lr (src, dest, noop: nil, verbose: nil, dereference_root: true, remove_destination: false)

Source

# File lib/fileutils.rb, line 628
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

Erstellt Hardlinks.

Die Argumente src (ein einzelner Pfad oder ein Array von Pfaden) und dest (ein einzelner Pfad) sollten als Pfade interpretierbar sein.

Wenn src der Pfad zu einem Verzeichnis ist und dest nicht existiert, werden Links dest und seine Nachkommen erstellt, die auf src und seine Nachkommen zeigen.

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

Wenn src und dest beide Pfade zu Verzeichnissen sind, werden Links dest/src und seine Nachkommen erstellt, die auf src und seine Nachkommen zeigen.

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

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

Schlüsselwortargumente

dereference_root: false - wenn src ein symbolischer Link ist, wird er nicht dereferenziert.
noop: true - erstellt keine Links.
remove_destination: true - entfernt dest vor dem Erstellen von Links.

verbose: true - gibt einen äquivalenten Befehl aus.

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)

Ausgabe

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

Löst eine Ausnahme aus, wenn dest der Pfad zu einer vorhandenen Datei oder einem vorhandenen Verzeichnis ist und das Schlüsselwortargument remove_destination: true nicht angegeben ist.

Zugehörig: Methoden zum Kopieren.

cp_r (src, dest, preserve: nil, noop: nil, verbose: nil, dereference_root: true, remove_destination: nil)

Source

# File lib/fileutils.rb, line 982
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

Kopiert Dateien rekursiv.

Die Argumente src (ein einzelner Pfad oder ein Array von Pfaden) und dest (ein einzelner Pfad) sollten als Pfade interpretierbar sein.

Der Modus, der Besitzer und die Gruppe werden in der Kopie beibehalten; um diese zu ändern, verwenden Sie stattdessen FileUtils.install.

Wenn src der Pfad zu einer Datei ist und dest nicht der Pfad zu einem Verzeichnis ist, wird src nach dest kopiert.

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

Wenn src der Pfad zu einer Datei ist und dest der Pfad zu einem Verzeichnis ist, wird src nach dest/src kopiert.

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

Wenn src der Pfad zu einem Verzeichnis ist und dest nicht existiert, wird src rekursiv nach dest kopiert.

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

Wenn src und dest Pfade zu Verzeichnissen sind, wird src rekursiv nach dest/src kopiert.

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

Wenn src ein Array von Pfaden ist und dest ein Verzeichnis ist, werden die Pfade aus src rekursiv nach dest kopiert; die Pfade in src können auf Dateien und/oder Verzeichnisse zeigen.

Schlüsselwortargumente

dereference_root: false - wenn src ein symbolischer Link ist, wird er nicht dereferenziert.
noop: true - kopiert keine Dateien.
preserve: true - behält Datei-Zeiten bei.
remove_destination: true - entfernt dest vor dem Kopieren von Dateien.

verbose: true - gibt einen äquivalenten Befehl aus.

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)

Ausgabe

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

Löst eine Ausnahme aus, wenn src der Pfad zu einem Verzeichnis ist und dest der Pfad zu einer Datei ist.

Zugehörig: Methoden zum Kopieren.

getwd ()

Alias für: pwd

identical? (a, b)

Alias für: compare_file

install (src, dest, mode: nil, owner: nil, group: nil, preserve: nil, noop: nil, verbose: nil)

Source

# File lib/fileutils.rb, line 1607
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
      if d.end_with?('/')
        mkdir_p d
        copy_file s, d + File.basename(s)
      else
        mkdir_p File.expand_path('..', d)
        copy_file s, d
      end
      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

Kopiert einen Dateieintrag. Siehe install(1).

Die Argumente src (ein einzelner Pfad oder ein Array von Pfaden) und dest (ein einzelner Pfad) sollten als Pfade interpretierbar sein;

Wenn der Eintrag unter dest nicht existiert, wird von src nach dest kopiert.

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

Wenn dest eine Datei ist, wird von src nach dest kopiert und überschrieben.

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

Wenn dest ein Verzeichnis ist, wird von src nach dest/src kopiert und bei Bedarf überschrieben.

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"

Wenn src ein Array von Pfaden ist und dest auf ein Verzeichnis zeigt, wird jeder Pfad path in src nach dest/path kopiert.

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

Schlüsselwortargumente

group: group - ändert die Gruppe, wenn nicht nil ist, unter Verwendung von File.chown.
mode: permissions - ändert die Berechtigungen unter Verwendung von File.chmod.
noop: true - kopiert keine Einträge; gibt nil zurück.
owner: owner - ändert den Besitzer, wenn nicht nil ist, unter Verwendung von File.chown.
preserve: true - behält Zeitstempel bei unter Verwendung von File.utime.

verbose: true - gibt einen äquivalenten Befehl aus.

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)

Ausgabe

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

Zugehörig: Methoden zum Kopieren.

link (src, dest, force: nil, noop: nil, verbose: nil)

Alias für: ln

link_entry (src, dest, dereference_root = false, remove_destination = false)

Source

# File lib/fileutils.rb, line 809
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

Erstellt Hardlinks; gibt nil zurück.

Die Argumente src und dest sollten als Pfade interpretierbar sein.

Wenn src der Pfad zu einer Datei ist und dest nicht existiert, wird ein Hardlink unter dest erstellt, der auf src zeigt.

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

Wenn src der Pfad zu einem Verzeichnis ist und dest nicht existiert, werden rekursiv Hardlinks unter dest erstellt, die auf Pfade in src zeigen.

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

Optionale Argumente

dereference_root - dereferenziert src, wenn es ein symbolischer Link ist (standardmäßig false).
remove_destination - entfernt dest vor dem Erstellen von Links (standardmäßig false).

Löst eine Ausnahme aus, wenn dest der Pfad zu einer vorhandenen Datei oder einem vorhandenen Verzeichnis ist und das optionale Argument remove_destination nicht angegeben ist.

Zugehörig: FileUtils.ln (hat andere Optionen).

ln (src, dest, force: nil, noop: nil, verbose: nil)

Source

# File lib/fileutils.rb, line 517
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

Erstellt Hardlinks.

Die Argumente src (ein einzelner Pfad oder ein Array von Pfaden) und dest (ein einzelner Pfad) sollten als Pfade interpretierbar sein.

Wenn src der Pfad zu einer vorhandenen Datei ist und dest der Pfad zu einer nicht vorhandenen Datei ist, wird ein Hardlink unter dest erstellt, der auf src zeigt; gibt Null zurück.

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

Wenn src der Pfad zu einer vorhandenen Datei ist und dest der Pfad zu einem vorhandenen Verzeichnis ist, wird ein Hardlink unter dest/src erstellt, der auf src zeigt; gibt Null zurück.

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

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"]

Schlüsselwortargumente

force: true - überschreibt dest, wenn es existiert.
noop: true - erstellt keine Links.

verbose: true - gibt einen äquivalenten Befehl aus.

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)

Ausgabe

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

Löst eine Ausnahme aus, wenn dest der Pfad zu einer vorhandenen Datei ist und das Schlüsselwortargument force nicht true ist.

Zugehörig: FileUtils.link_entry (hat andere Optionen).

Auch alias genannt: link

ln_s (src, dest, force: nil, relative: false, target_directory: true, noop: nil, verbose: nil)

Source

# File lib/fileutils.rb, line 707
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, target_directory: target_directory, noop: noop, verbose: verbose)
  end
  fu_output_message "ln -s#{force ? 'f' : ''}#{
    target_directory ? '' : 'T'} #{[src,dest].flatten.join ' '}" if verbose
  return if noop
  fu_each_src_dest0(src, dest, target_directory) do |s,d|
    remove_file d, true if force
    File.symlink s, d
  end
end

Erstellt symbolische Links.

Die Argumente src (ein einzelner Pfad oder ein Array von Pfaden) und dest (ein einzelner Pfad) sollten als Pfade interpretierbar sein.

Wenn src der Pfad zu einer vorhandenen Datei ist

Wenn dest der Pfad zu einer nicht vorhandenen Datei ist, wird ein symbolischer Link unter dest erstellt, der auf src zeigt.

FileUtils.touch('src0.txt')
File.exist?('dest0.txt')   # => false
FileUtils.ln_s('src0.txt', 'dest0.txt')
File.symlink?('dest0.txt') # => 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.

Wenn dest der Pfad zu einem Verzeichnis ist, wird ein symbolischer Link unter dest/src erstellt, der auf src zeigt.

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

Wenn src ein Array von Pfaden zu vorhandenen Dateien ist und dest ein Verzeichnis ist, wird für jedes Kind child in src ein symbolischer Link dest/child erstellt, der auf child zeigt.

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

Schlüsselwortargumente

force: true - überschreibt dest, wenn es existiert.
relative: false - erstellt Links relativ zu dest.
noop: true - erstellt keine Links.

verbose: true - gibt einen äquivalenten Befehl aus.

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)

Ausgabe

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

Zugehörig: FileUtils.ln_sf.

Auch alias genannt: symlink

ln_sf (src, dest, noop: nil, verbose: nil)

Source

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

Wie FileUtils.ln_s, aber immer mit dem Schlüsselwortargument force: true.

ln_sr (src, dest, target_directory: true, force: nil, noop: nil, verbose: nil)

Source

# File lib/fileutils.rb, line 733
def ln_sr(src, dest, target_directory: true, force: nil, noop: nil, verbose: nil)
  cmd = "ln -s#{force ? 'f' : ''}#{target_directory ? '' : 'T'}" if verbose
  fu_each_src_dest0(src, dest, target_directory) do |s,d|
    if target_directory
      parent = File.dirname(d)
      destdirs = fu_split_path(parent)
      real_ddirs = fu_split_path(File.realpath(parent))
    else
      destdirs ||= fu_split_path(dest)
      real_ddirs ||= fu_split_path(File.realdirpath(dest))
    end
    srcdirs = fu_split_path(s)
    i = fu_common_components(srcdirs, destdirs)
    n = destdirs.size - i
    n -= 1 unless target_directory
    link1 = fu_clean_components(*Array.new([n, 0].max, '..'), *srcdirs[i..-1])
    begin
      real_sdirs = fu_split_path(File.realdirpath(s)) rescue nil
    rescue
    else
      i = fu_common_components(real_sdirs, real_ddirs)
      n = real_ddirs.size - i
      n -= 1 unless target_directory
      link2 = fu_clean_components(*Array.new([n, 0].max, '..'), *real_sdirs[i..-1])
      link1 = link2 if link1.size > link2.size
    end
    s = File.join(link1)
    fu_output_message [cmd, s, d].flatten.join(' ') if verbose
    next if noop
    remove_file d, true if force
    File.symlink s, d
  end
end

Wie FileUtils.ln_s, aber erstellt Links relativ zu dest.

makedirs (list, mode: nil, noop: nil, verbose: nil)

Alias für: mkdir_p

mkdir (list, mode: nil, noop: nil, verbose: nil)

Source

# File lib/fileutils.rb, line 317
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

Erstellt Verzeichnisse an den Pfaden in der gegebenen list (ein einzelner Pfad oder ein Array von Pfaden); gibt list zurück, wenn es ein Array ist, sonst [list].

Das Argument list oder seine Elemente sollten als Pfade interpretierbar sein.

Ohne Schlüsselwortargumente wird unter jedem path in list ein Verzeichnis erstellt, indem aufgerufen wird: Dir.mkdir(path, mode); siehe Dir.mkdir.

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

Schlüsselwortargumente

mode: mode - ruft auch File.chmod(mode, path) auf; siehe File.chmod.
noop: true - erstellt keine Verzeichnisse.

verbose: true - gibt einen äquivalenten Befehl aus.

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

Ausgabe

mkdir tmp0 tmp1
mkdir -m 700 tmp2 tmp3

Löst eine Ausnahme aus, wenn ein Pfad auf eine vorhandene Datei oder ein vorhandenes Verzeichnis zeigt oder wenn aus irgendeinem Grund ein Verzeichnis nicht erstellt werden kann.

Zugehörig: FileUtils.mkdir_p.

mkdir_p (list, mode: nil, noop: nil, verbose: nil)

Source

# File lib/fileutils.rb, line 366
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

Das Argument list oder seine Elemente sollten als Pfade interpretierbar sein.

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

Schlüsselwortargumente

mode: mode - ruft auch File.chmod(mode, path) auf; siehe File.chmod.
noop: true - erstellt keine Verzeichnisse.

verbose: true - gibt einen äquivalenten Befehl aus.

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

Ausgabe

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

Löst eine Ausnahme aus, wenn aus irgendeinem Grund ein Verzeichnis nicht erstellt werden kann.

FileUtils.mkpath und FileUtils.makedirs sind Aliase für FileUtils.mkdir_p.

Zugehörig: FileUtils.mkdir.

Auch alias genannt: mkpath, makedirs

mkpath (list, mode: nil, noop: nil, verbose: nil)

Alias für: mkdir_p

move (src, dest, force: nil, noop: nil, verbose: nil, secure: nil)

Alias für: mv

mv (src, dest, force: nil, noop: nil, verbose: nil, secure: nil)

Source

# File lib/fileutils.rb, line 1154
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

Verschiebt Einträge.

Die Argumente src (ein einzelner Pfad oder ein Array von Pfaden) und dest (ein einzelner Pfad) sollten als Pfade interpretierbar sein.

Wenn sich src und dest auf unterschiedlichen Dateisystemen befinden, wird zuerst kopiert, dann src entfernt.

Kann eine lokale Schwachstelle verursachen, wenn nicht mit dem Schlüsselwortargument secure: true aufgerufen; siehe Vermeidung der TOCTTOU-Schwachstelle.

Wenn src der Pfad zu einer einzelnen Datei oder einem einzelnen Verzeichnis ist und dest nicht existiert, wird src nach dest verschoben.

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

Wenn src ein Array von Pfaden zu Dateien und Verzeichnissen ist und dest der Pfad zu einem Verzeichnis ist, wird von jedem Pfad in dem Array nach dest kopiert.

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

Schlüsselwortargumente

force: true - wenn das Verschieben das Entfernen von src beinhaltet (d.h. wenn src und dest auf unterschiedlichen Dateisystemen liegen), ignoriert es ausgelöste Ausnahmen von StandardError und seinen Nachkommen.
noop: true - verschiebt keine Dateien.
secure: true - entfernt src sicher; siehe Details unter FileUtils.remove_entry_secure.

verbose: true - gibt einen äquivalenten Befehl aus.

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

Ausgabe

mv src0 dest0
mv src1.txt src1 dest1

Auch alias genannt: move

pwd ()

Source

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

Gibt eine Zeichenfolge mit dem Pfad zum aktuellen Verzeichnis zurück

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

Verwandt: FileUtils.cd.

Auch alias genannt: getwd

remove (list, force: nil, noop: nil, verbose: nil)

Alias für: rm

remove_dir (path, force = false)

Source

# File lib/fileutils.rb, line 1489
def remove_dir(path, force = false)
  raise Errno::ENOTDIR, path unless force or File.directory?(path)
  remove_entry path, force
end

Entfernt rekursiv den durch path gegebenen Verzeichniseintrag, der ein regulärer Dateieintrag, ein symbolischer Link oder ein Verzeichnis sein sollte.

Das Argument path sollte als Pfad interpretierbar sein.

Das optionale Argument force gibt an, ob Ausnahmen von StandardError und seinen Nachfolgern ignoriert werden sollen.

Verwandt: Methoden zum Löschen.

remove_entry (path, force = false)

Source

# File lib/fileutils.rb, line 1446
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

Entfernt den durch path gegebenen Eintrag, der ein regulärer Dateieintrag, ein symbolischer Link oder ein Verzeichnis sein sollte.

Das Argument path sollte als Pfad interpretierbar sein.

Das optionale Argument force gibt an, ob Ausnahmen von StandardError und seinen Nachfolgern ignoriert werden sollen.

Verwandt: FileUtils.remove_entry_secure.

remove_entry_secure (path, force = false)

Source

# File lib/fileutils.rb, line 1348
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

Entfernt den durch path gegebenen Eintrag sicher, der ein regulärer Dateieintrag, ein symbolischer Link oder ein Verzeichnis sein sollte.

Das Argument path sollte als Pfad interpretierbar sein.

Vermeidet eine lokale Schwachstelle, die unter bestimmten Umständen auftreten kann. Siehe Vermeiden der TOCTTOU-Schwachstelle.

Das optionale Argument force gibt an, ob Ausnahmen von StandardError und seinen Nachfolgern ignoriert werden sollen.

Verwandt: Methoden zum Löschen.

remove_file (path, force = false)

Source

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

Entfernt den durch path gegebenen Dateieintrag, der ein regulärer Dateieintrag oder ein symbolischer Link sein sollte.

Das Argument path sollte als Pfad interpretierbar sein.

Das optionale Argument force gibt an, ob Ausnahmen von StandardError und seinen Nachfolgern ignoriert werden sollen.

Verwandt: Methoden zum Löschen.

rm (list, force: nil, noop: nil, verbose: nil)

Source

# File lib/fileutils.rb, line 1213
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

Entfernt Einträge an den Pfaden in der gegebenen list (ein einzelner Pfad oder ein Array von Pfaden); gibt list zurück, wenn es ein Array ist, andernfalls [list].

Das Argument list oder seine Elemente sollten als Pfade interpretierbar sein.

Ohne Schlüsselwortargumente werden Dateien an den in list angegebenen Pfaden entfernt

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

Schlüsselwortargumente

force: true - ignoriert Ausnahmen von StandardError und seinen Nachfolgern.
noop: true - entfernt keine Dateien; gibt nil zurück.

verbose: true - gibt einen äquivalenten Befehl aus.

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

Ausgabe

rm src0.dat src0.txt

Verwandt: Methoden zum Löschen.

Auch alias genannt: remove

rm_f (list, noop: nil, verbose: nil)

Source

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

Entspricht

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

Das Argument list (ein einzelner Pfad oder ein Array von Pfaden) sollte als Pfade interpretierbar sein.

Siehe FileUtils.rm für Schlüsselwortargumente.

Verwandt: Methoden zum Löschen.

Auch alias genannt: safe_unlink

rm_r (list, force: nil, noop: nil, verbose: nil, secure: nil)

Source

# File lib/fileutils.rb, line 1296
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

Entfernt Einträge an den Pfaden in der gegebenen list (ein einzelner Pfad oder ein Array von Pfaden); gibt list zurück, wenn es ein Array ist, andernfalls [list].

Das Argument list oder seine Elemente sollten als Pfade interpretierbar sein.

Kann eine lokale Schwachstelle verursachen, wenn nicht mit dem Schlüsselwortargument secure: true aufgerufen; siehe Vermeidung der TOCTTOU-Schwachstelle.

Für jeden Dateipfad wird die Datei an diesem Pfad entfernt

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

Für jeden Verzeichnispfad werden Dateien und Verzeichnisse rekursiv entfernt

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

Schlüsselwortargumente

force: true - ignoriert Ausnahmen von StandardError und seinen Nachfolgern.
noop: true - entfernt keine Einträge; gibt nil zurück.
secure: true - entfernt src sicher; siehe Details unter FileUtils.remove_entry_secure.

verbose: true - gibt einen äquivalenten Befehl aus.

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

Ausgabe

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

Verwandt: Methoden zum Löschen.

rm_rf (list, noop: nil, verbose: nil, secure: nil)

Source

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

Entspricht

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

Das Argument list oder seine Elemente sollten als Pfade interpretierbar sein.

Kann eine lokale Schwachstelle verursachen, wenn nicht mit dem Schlüsselwortargument secure: true aufgerufen; siehe Vermeidung der TOCTTOU-Schwachstelle.

Siehe FileUtils.rm_r für Schlüsselwortargumente.

Verwandt: Methoden zum Löschen.

Auch alias genannt: rmtree

rmdir (list, parents: nil, noop: nil, verbose: nil)

Source

# File lib/fileutils.rb, line 443
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

Entfernt Verzeichnisse an den Pfaden in der gegebenen list (ein einzelner Pfad oder ein Array von Pfaden); gibt list zurück, wenn es ein Array ist, andernfalls [list].

Das Argument list oder seine Elemente sollten als Pfade interpretierbar sein.

Ohne Schlüsselwortargumente wird das Verzeichnis an jedem path in list entfernt, indem aufgerufen wird: Dir.rmdir(path); siehe Dir.rmdir

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

Schlüsselwortargumente

parents: true - entfernt aufeinanderfolgende übergeordnete Verzeichnisse, wenn sie leer sind.
noop: true - entfernt keine Verzeichnisse.

verbose: true - gibt einen äquivalenten Befehl aus.

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

Ausgabe

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

Löst eine Ausnahme aus, wenn ein Verzeichnis nicht existiert oder wenn aus irgendeinem Grund ein Verzeichnis nicht entfernt werden kann.

Verwandt: Methoden zum Löschen.

rmtree (list, noop: nil, verbose: nil, secure: nil)

Alias für: rm_rf

safe_unlink (list, noop: nil, verbose: nil)

Alias für: rm_f

symlink (src, dest, force: nil, relative: false, target_directory: true, noop: nil, verbose: nil)

Alias für: ln_s

touch (list, noop: nil, verbose: nil, mtime: nil, nocreate: nil)

Source

# File lib/fileutils.rb, line 2004
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

Erstellt standardmäßig eine leere Datei für jeden Pfad zu einem nicht vorhandenen Eintrag; verwenden Sie das Schlüsselwortargument nocreate, um stattdessen eine Ausnahme auszulösen.

Das Argument list oder seine Elemente sollten als Pfade interpretierbar sein.

Beispiele

# 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'])

Schlüsselwortargumente

mtime: time - setzt die mtime des Eintrags auf die angegebene Zeit anstelle der aktuellen Zeit.
nocreate: true - löst eine Ausnahme aus, wenn der Eintrag nicht existiert.
noop: true - berührt keine Einträge; gibt nil zurück.

verbose: true - gibt einen äquivalenten Befehl aus.

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)

Ausgabe

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

Verwandt: FileUtils.uptodate?.

uptodate? (new, old_list)

Source

# File lib/fileutils.rb, line 265
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

Gibt true zurück, wenn die Datei unter dem Pfad new neuer ist als alle Dateien unter den Pfaden im Array old_list; andernfalls false.

Das Argument new und die Elemente von old_list sollten als Pfade interpretierbar sein

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

Eine nicht existierende Datei gilt als unendlich alt.

Verwandt: FileUtils.touch.