class Pathname

pathname.rb

Objektorientierte Pathname Klasse

Autor: Tanaka Akira <akr@m17n.org>
Dokumentation: Autor und Gavin Sinclair

Für Dokumentation siehe Klasse Pathname.

Pathname repräsentiert den Namen einer Datei oder eines Verzeichnisses im Dateisystem, aber nicht die Datei selbst.

Der Pfadname hängt vom Betriebssystem ab: Unix, Windows, etc. Diese Bibliothek arbeitet mit Pfadnamen des lokalen Betriebssystems, jedoch werden nicht-Unix-Pfadnamen experimentell unterstützt.

Ein Pathname kann relativ oder absolut sein. Erst wenn versucht wird, auf die Datei zu verweisen, spielt es eine Rolle, ob die Datei existiert oder nicht.

Pathname ist unveränderlich. Er hat keine Methode zur destruktiven Aktualisierung.

Das Ziel dieser Klasse ist es, Datei-Pfadinformationen auf eine übersichtlichere Weise zu manipulieren, als es das Standard-Ruby bietet. Die folgenden Beispiele demonstrieren den Unterschied.

Alle Funktionalitäten von File, FileTest und einige von Dir und FileUtils sind auf überraschende Weise enthalten. Es ist im Wesentlichen eine Fassade für all diese und mehr.

Beispiele

Beispiel 1: Verwendung von `Pathname`

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

Beispiel 2: Verwendung von Standard-Ruby

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

Beispiel 3: Spezielle Funktionen

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

Aufschlüsselung der Funktionalität

Diese Methoden manipulieren im Wesentlichen einen String, da ein Pfad nichts anderes ist. Keine dieser Methoden greift auf das Dateisystem zu, außer mountpoint?, children, each_child, realdirpath und realpath.

Prädikatmethoden für den `File`-Status

Diese Methoden sind eine Fassade für FileTest

Eigenschafts- und Manipulationsmethoden für `File`

Diese Methoden sind eine Fassade für File

Verzeichnismethoden

Diese Methoden sind eine Fassade für Dir

Dienstprogramme

Diese Methoden sind eine Mischung aus Find, FileUtils und anderen

Methodendokumentation

Wie der obige Abschnitt zeigt, sind die meisten Methoden in Pathname Fassaden. Die Dokumentation für diese Methoden sagt im Allgemeinen nur, zum Beispiel, „Siehe FileTest.writable?“, da Sie die Originalmethode ohnehin kennen sollten und deren Dokumentation (z. B. über ri) weitere Informationen enthält. In einigen Fällen folgt eine kurze Beschreibung.

Constants

ABSOLUTE_PATH: Regexp, das einen absoluten Pfad abgleicht.
SEPARATOR_LIST: Trennzeichen-Liste-String.
SEPARATOR_PAT: Regexp, das ein Trennzeichen abgleicht.
VERSION: Die Versionszeichenkette.

Öffentliche Klassenmethoden

getwd ()

Source

# File pathname_builtin.rb, line 1120
def Pathname.getwd() self.new(Dir.getwd) end

Siehe Dir.getwd. Gibt das aktuelle Arbeitsverzeichnis als Pathname zurück.

Auch alias genannt: pwd

glob (*args, **kwargs) { |pathname| ... }

Source

# File pathname_builtin.rb, line 1096
def Pathname.glob(*args, **kwargs) # :yield: pathname
  if block_given?
    Dir.glob(*args, **kwargs) {|f| yield self.new(f) }
  else
    Dir.glob(*args, **kwargs).map {|f| self.new(f) }
  end
end

Siehe Dir.glob. Gibt Pathname-Objekte zurück oder liefert sie.

mktmpdir () { |dir| ... }

Source

# File lib/pathname.rb, line 63
def self.mktmpdir
  require 'tmpdir' unless defined?(Dir.mktmpdir)
  if block_given?
    Dir.mktmpdir do |dir|
      dir = self.new(dir)
      yield dir
    end
  else
    self.new(Dir.mktmpdir)
  end
end

Erstellt ein temporäres Verzeichnis und verpackt den zurückgegebenen Pfad in ein Pathname-Objekt.

Beachten Sie, dass Sie 'pathname' erfordern müssen, um diese Methode zu verwenden.

Siehe Dir.mktmpdir

new (path)

Source

# File pathname_builtin.rb, line 214
def initialize(path)
  @path = File.path(path).dup
rescue TypeError => e
  raise e.class, "Pathname.new requires a String, #to_path or #to_str", cause: nil
end

Erstellt ein Pathname-Objekt aus dem angegebenen String (oder einem String-ähnlichen Objekt). Wenn path ein Nullzeichen (\0) enthält, wird ein ArgumentError ausgelöst.

pwd ()

Alias für: getwd

Öffentliche Instanzmethoden

+ (other)

Source

# File pathname_builtin.rb, line 665
def +(other)
  other = Pathname.new(other) unless Pathname === other
  Pathname.new(plus(@path, other.path))
end

Hängt einen Pfadfragment an self an, um ein neues Pathname-Objekt zu erzeugen. Da other als Pfad relativ zu self betrachtet wird, wird bei einem absoluten Pfad other das neue Pathname-Objekt nur aus other erstellt.

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

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

Diese Methode greift nicht auf das Dateisystem zu; sie ist reine String-Manipulation.

Auch alias genannt: /

/ (other)

Alias für: +

<=> (p1)

Source

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

Bietet einen case-sensitiven Vergleichsoperator für Pfadnamen.

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

Er gibt -1, 0 oder 1 zurück, abhängig vom Wert des linken Arguments im Verhältnis zum rechten Argument. Oder er gibt nil zurück, wenn die Argumente nicht vergleichbar sind.

== (other)

Source

# File pathname_builtin.rb, line 234
def ==(other)
  return false unless Pathname === other
  other.path == @path
end

Vergleicht diesen Pfadnamen mit other. Der Vergleich ist stringbasiert. Beachten Sie, dass zwei verschiedene Pfade (foo.txt und ./foo.txt) auf dieselbe Datei verweisen können.

Auch alias genannt: ===, eql?

=== (other)

Alias für: ==

absolute? ()

Source

# File pathname_builtin.rb, line 542
def absolute?
  ABSOLUTE_PATH.match? @path
end

Prädikatmethode zum Testen, ob ein Pfad absolut ist.

Sie gibt true zurück, wenn der Pfadname mit einem Schrägstrich beginnt.

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

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

ascend () { |self| ... }

Source

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

Iteriert über die Elemente des gegebenen Pfades in aufsteigender Reihenfolge und liefert für jedes Element ein neues Pathname-Objekt.

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

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

Gibt einen Enumerator zurück, wenn kein Block gegeben wurde.

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

Greift nicht auf das Dateisystem zu.

atime ()

Source

# File pathname_builtin.rb, line 898
def atime() File.atime(@path) end

Siehe File.atime. Gibt die letzte Zugriffszeit zurück.

basename (...)

Source

# File pathname_builtin.rb, line 972
def basename(...) self.class.new(File.basename(@path, ...)) end

Siehe File.basename. Gibt die letzte Komponente des Pfades zurück.

binread (...)

Source

# File pathname_builtin.rb, line 881
def binread(...) File.binread(@path, ...) end

Siehe File.binread. Gibt alle Bytes aus der Datei zurück oder die ersten N, falls angegeben.

binwrite (...)

Source

# File pathname_builtin.rb, line 895
def binwrite(...) File.binwrite(@path, ...) end

Schreibt contents in die Datei, die im Binärmodus geöffnet wird.

Siehe File.binwrite.

birthtime ()

Source

# File pathname_builtin.rb, line 904
def birthtime() File.birthtime(@path) end

Gibt die Erstellungszeit der Datei zurück. Wenn die Plattform keine Erstellungszeit hat, wird NotImplementedError ausgelöst.

Siehe File.birthtime.

blockdev? ()

Source

# File pathname_builtin.rb, line 1010
def blockdev?() FileTest.blockdev?(@path) end

Siehe FileTest.blockdev?.

chardev? ()

Source

# File pathname_builtin.rb, line 1013
def chardev?() FileTest.chardev?(@path) end

Siehe FileTest.chardev?.

children (with_directory=true)

Source

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

Gibt die Kinder des Verzeichnisses (Dateien und Unterverzeichnisse, nicht rekursiv) als Array von Pathname-Objekten zurück.

Standardmäßig enthalten die zurückgegebenen Pfadnamen genügend Informationen, um auf die Dateien zugreifen zu können. Wenn Sie with_directory auf false setzen, enthalten die zurückgegebenen Pfadnamen nur den Dateinamen.

Zum Beispiel

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

Beachten Sie, dass die Ergebnisse niemals die Einträge . und .. im Verzeichnis enthalten, da diese keine Kinder sind.

chmod (mode)

Source

# File pathname_builtin.rb, line 913
def chmod(mode) File.chmod(mode, @path) end

Siehe File.chmod. Ändert Berechtigungen.

chown (owner, group)

Source

# File pathname_builtin.rb, line 919
def chown(owner, group) File.chown(owner, group, @path) end

Siehe File.chown. Ändert Eigentümer und Gruppe einer Datei.

cleanpath (consider_symlink=false)

Source

# File pathname_builtin.rb, line 403
def cleanpath(consider_symlink=false)
  if consider_symlink
    cleanpath_conservative
  else
    cleanpath_aggressive
  end
end

Gibt den bereinigten Pfadnamen von self mit aufeinanderfolgenden Schrägstrich-Zeichen und nutzlosen Punkten zurück. Das Dateisystem wird nicht abgerufen.

Wenn consider_symlink auf true gesetzt ist, wird ein konservativerer Algorithmus verwendet, um symbolische Verknüpfungen nicht zu unterbrechen. Dies kann mehr ..-Einträge enthalten, als unbedingt notwendig sind, aber ohne Zugriff auf das Dateisystem lässt sich dies nicht vermeiden.

Siehe Pathname#realpath.

ctime ()

Source

# File pathname_builtin.rb, line 907
def ctime() File.ctime(@path) end

Siehe File.ctime. Gibt die letzte (Verzeichniseintrag, nicht Datei) Änderungszeit zurück.

delete ()

Alias für: unlink

descend () { |v| ... }

Source

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

Iteriert über die Elemente des gegebenen Pfades in absteigender Reihenfolge und liefert für jedes Element ein neues Pathname-Objekt.

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

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

Gibt einen Enumerator zurück, wenn kein Block gegeben wurde.

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

Greift nicht auf das Dateisystem zu.

directory? ()

Source

# File pathname_builtin.rb, line 1039
def directory?() FileTest.directory?(@path) end

Siehe FileTest.directory?.

dirname ()

Source

# File pathname_builtin.rb, line 975
def dirname() self.class.new(File.dirname(@path)) end

Siehe File.dirname. Gibt alle Komponenten des Pfades außer der letzten zurück.

each_child (with_directory=true, &b)

Source

# File pathname_builtin.rb, line 808
def each_child(with_directory=true, &b)
  children(with_directory).each(&b)
end

Iteriert über die Kinder des Verzeichnisses (Dateien und Unterverzeichnisse, nicht rekursiv).

Es wird für jedes Kind ein Pathname-Objekt geliefert.

Standardmäßig enthalten die gelieferten Pfadnamen genügend Informationen, um auf die Dateien zugreifen zu können.

Wenn Sie with_directory auf false setzen, enthalten die zurückgegebenen Pfadnamen nur den Dateinamen.

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

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

Beachten Sie, dass die Ergebnisse niemals die Einträge . und .. im Verzeichnis enthalten, da diese keine Kinder sind.

Siehe Pathname#children

each_entry () { |pathname| ... }

Source

# File pathname_builtin.rb, line 1133
def each_entry(&block) # :yield: pathname
  return to_enum(__method__) unless block_given?
  Dir.foreach(@path) {|f| yield self.class.new(f) }
end

Iteriert über die Einträge (Dateien und Unterverzeichnisse) im Verzeichnis. Es wird für jeden Eintrag ein Pathname-Objekt geliefert.

Diese Methode existiert seit 1.8.1.

each_filename () { |filename| ... }

Source

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

Iteriert über jede Komponente des Pfades.

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

Gibt einen Enumerator zurück, wenn kein Block gegeben wurde.

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

each_line (...) { |line| ... }

Source

# File pathname_builtin.rb, line 871
def each_line(...) # :yield: line
  File.foreach(@path, ...)
end

each_line iteriert über die Zeilen in der Datei. Es wird für jede Zeile ein String-Objekt geliefert.

Diese Methode existiert seit 1.8.1.

empty? ()

Source

# File pathname_builtin.rb, line 1018
def empty?
  if FileTest.directory?(@path)
    Dir.empty?(@path)
  else
    File.empty?(@path)
  end
end

Testet, ob die Datei leer ist.

Siehe Dir#empty? und FileTest.empty?.

entries ()

Source

# File pathname_builtin.rb, line 1127
def entries() Dir.entries(@path).map {|f| self.class.new(f) } end

Gibt die Einträge (Dateien und Unterverzeichnisse) im Verzeichnis zurück, jeweils als Pathname-Objekt.

eql? (other)

Alias für: ==

executable? ()

Source

# File pathname_builtin.rb, line 1027
def executable?() FileTest.executable?(@path) end

Siehe FileTest.executable?.

executable_real? ()

Source

# File pathname_builtin.rb, line 1030
def executable_real?() FileTest.executable_real?(@path) end

Siehe FileTest.executable_real?.

exist? ()

Source

# File pathname_builtin.rb, line 1033
def exist?() FileTest.exist?(@path) end

Siehe FileTest.exist?.

expand_path (...)

Source

# File pathname_builtin.rb, line 981
def expand_path(...) self.class.new(File.expand_path(@path, ...)) end

Siehe File.expand_path.

extname ()

Source

# File pathname_builtin.rb, line 978
def extname() File.extname(@path) end

Siehe File.extname. Gibt die Dateierweiterung zurück.

file? ()

Source

# File pathname_builtin.rb, line 1042
def file?() FileTest.file?(@path) end

Siehe FileTest.file?.

find (ignore_error: true) { |pathname| ... }

Source

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

Iteriert tiefenmäßig durch den Verzeichnisbaum und liefert für jede Datei unter "diesem" Verzeichnis einen Pathname.

Beachten Sie, dass Sie 'pathname' erfordern müssen, um diese Methode zu verwenden.

Gibt einen Enumerator zurück, wenn kein Block gegeben ist.

Da es vom Standardbibliotheksmodul Find implementiert wird, kann Find.prune verwendet werden, um die Traversierung zu steuern.

Wenn self . ist, beginnen die gelieferten Pfadnamen mit einem Dateinamen im aktuellen Verzeichnis, nicht mit ./.

Siehe Find.find

fnmatch (pattern, ...)

Source

# File pathname_builtin.rb, line 926
def fnmatch(pattern, ...) File.fnmatch(pattern, @path, ...) end

Siehe File.fnmatch. Gibt true zurück, wenn der Empfänger dem gegebenen Muster entspricht.

fnmatch? (pattern, ...)

Source

# File pathname_builtin.rb, line 929
def fnmatch?(pattern, ...) File.fnmatch?(pattern, @path, ...) end

Siehe File.fnmatch? (identisch mit fnmatch).

einfrieren ()

Source

# File pathname_builtin.rb, line 223
def freeze
  super
  @path.freeze
  self
end

Friert self ein.

Ruft die Superklassenmethode Object#freeze auf

ftype ()

Source

# File pathname_builtin.rb, line 933
def ftype() File.ftype(@path) end

Siehe File.ftype. Gibt den "Typ" der Datei zurück („file“, „directory“ usw.).

glob (*args, **kwargs) { |pathname| ... }

Source

# File pathname_builtin.rb, line 1111
def glob(*args, **kwargs) # :yield: pathname
  if block_given?
    Dir.glob(*args, **kwargs, base: @path) {|f| yield self + f }
  else
    Dir.glob(*args, **kwargs, base: @path).map {|f| self + f }
  end
end

Gibt Pathname-Objekte zurück oder liefert sie.

Pathname("ruby-2.4.2").glob("R*.md")
#=> [#<Pathname:ruby-2.4.2/README.md>, #<Pathname:ruby-2.4.2/README.ja.md>]

Siehe Dir.glob. Diese Methode verwendet das Schlüsselwortargument base von Dir.glob.

grpowned? ()

Source

# File pathname_builtin.rb, line 1036
def grpowned?() FileTest.grpowned?(@path) end

Siehe FileTest.grpowned?.

join (*args)

Source

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

Fügt die angegebenen Pfadnamen an self an, um ein neues Pathname-Objekt zu erstellen. Dies ist im Wesentlichen dasselbe wie die Verwendung von Pathname#+, um self und alle Argumente nacheinander anzuhängen.

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

lchmod (mode)

Source

# File pathname_builtin.rb, line 916
def lchmod(mode) File.lchmod(mode, @path) end

Siehe File.lchmod.

lchown (owner, group)

Source

# File pathname_builtin.rb, line 922
def lchown(owner, group) File.lchown(owner, group, @path) end

Siehe File.lchown.

lstat ()

Source

# File pathname_builtin.rb, line 953
def lstat() File.lstat(@path) end

Siehe File.lstat.

lutime (atime, mtime)

Source

# File pathname_builtin.rb, line 969
def lutime(atime, mtime) File.lutime(atime, mtime, @path) end

Aktualisiert die Zugriffs- und Änderungszeiten der Datei.

Identisch mit Pathname#utime, aber folgt keinen symbolischen Links.

Siehe File.lutime.

make_link (old)

Source

# File pathname_builtin.rb, line 936
def make_link(old) File.link(old, @path) end

Siehe File.link. Erstellt einen Hardlink.

make_symlink (old)

Source

# File pathname_builtin.rb, line 956
def make_symlink(old) File.symlink(old, @path) end

Siehe File.symlink. Erstellt einen symbolischen Link.

mkdir (...)

Source

# File pathname_builtin.rb, line 1139
def mkdir(...) Dir.mkdir(@path, ...) end

Siehe Dir.mkdir. Erstellt das referenzierte Verzeichnis.

mkpath (mode: nil)

Source

# File pathname_builtin.rb, line 334
def mkpath(mode: nil)
  path = @path == '/' ? @path : @path.chomp('/')

  stack = []
  until File.directory?(path) || File.dirname(path) == path
    stack.push path
    path = File.dirname(path)
  end

  stack.reverse_each do |dir|
    dir = dir == '/' ? dir : dir.chomp('/')
    if mode
      Dir.mkdir dir, mode
      File.chmod mode, dir
    else
      Dir.mkdir dir
    end
  rescue SystemCallError
    raise unless File.directory?(dir)
  end

  self
end

Erstellt einen vollständigen Pfad, einschließlich aller zwischenliegenden Verzeichnisse, die noch nicht existieren.

Siehe FileUtils.mkpath und FileUtils.mkdir_p

mountpoint? ()

Source

# File pathname_builtin.rb, line 510
def mountpoint?
  begin
    stat1 = self.lstat
    stat2 = self.parent.lstat
    stat1.dev != stat2.dev || stat1.ino == stat2.ino
  rescue Errno::ENOENT
    false
  end
end

Gibt true zurück, wenn self auf einen Mountpoint zeigt.

mtime ()

Source

# File pathname_builtin.rb, line 910
def mtime() File.mtime(@path) end

Siehe File.mtime. Gibt die letzte Änderungszeit zurück.

open (...) { |file| ... }

Source

# File pathname_builtin.rb, line 939
def open(...) # :yield: file
  File.open(@path, ...)
end

Siehe File.open. Öffnet die Datei zum Lesen oder Schreiben.

opendir () { |dir| ... }

Source

# File pathname_builtin.rb, line 1145
def opendir(&block) # :yield: dir
  Dir.open(@path, &block)
end

Siehe Dir.open.

owned? ()

Source

# File pathname_builtin.rb, line 1051
def owned?() FileTest.owned?(@path) end

Siehe FileTest.owned?.

parent ()

Source

# File pathname_builtin.rb, line 505
def parent
  self + '..'
end

Gibt das übergeordnete Verzeichnis zurück.

Dies ist dasselbe wie self + '..'.

pipe? ()

Source

# File pathname_builtin.rb, line 1045
def pipe?() FileTest.pipe?(@path) end

Siehe FileTest.pipe?.

read (...)

Source

# File pathname_builtin.rb, line 877
def read(...) File.read(@path, ...) end

Siehe File.read. Gibt alle Daten aus der Datei zurück oder die ersten N Bytes, falls angegeben.

readable? ()

Source

# File pathname_builtin.rb, line 1054
def readable?() FileTest.readable?(@path) end

Siehe FileTest.readable?.

readable_real? ()

Source

# File pathname_builtin.rb, line 1060
def readable_real?() FileTest.readable_real?(@path) end

Siehe FileTest.readable_real?.

readlines (...)

Source

# File pathname_builtin.rb, line 884
def readlines(...) File.readlines(@path, ...) end

Siehe File.readlines. Gibt alle Zeilen aus der Datei zurück.

readlink ()

Source

# File pathname_builtin.rb, line 944
def readlink() self.class.new(File.readlink(@path)) end

Siehe File.readlink. Liest symbolischen Link.

realdirpath (...)

Source

# File pathname_builtin.rb, line 1003
def realdirpath(...) self.class.new(File.realdirpath(@path, ...)) end

Gibt den realen (absoluten) Pfadnamen von self im tatsächlichen Dateisystem zurück.

Enthält keine Symlinks oder nutzlosen Punkte, .. und ..

Die letzte Komponente des realen Pfadnamens kann nicht existieren.

realpath (...)

Source

# File pathname_builtin.rb, line 996
def realpath(...) self.class.new(File.realpath(@path, ...)) end

Gibt den realen (absoluten) Pfadnamen für self im tatsächlichen Dateisystem zurück.

Enthält keine Symlinks oder nutzlosen Punkte, .. und ..

Alle Komponenten des Pfadnamens müssen vorhanden sein, wenn diese Methode aufgerufen wird.

relative? ()

Source

# File pathname_builtin.rb, line 557
def relative?
  !absolute?
end

Das Gegenteil von Pathname#absolute?

Es gibt false zurück, wenn der Pfadname mit einem Schrägstrich beginnt.

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

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

relative_path_from (base_directory)

Source

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

Gibt einen relativen Pfad vom angegebenen base_directory zum Empfänger zurück.

Wenn self absolut ist, muss base_directory ebenfalls absolut sein.

Wenn self relativ ist, muss base_directory ebenfalls relativ sein.

Diese Methode greift nicht auf das Dateisystem zu. Sie geht von keinen Symlinks aus.

ArgumentError wird ausgelöst, wenn kein relativer Pfad gefunden werden kann.

Beachten Sie, dass diese Methode keine Situationen behandelt, in denen die Groß- und Kleinschreibung des verwendeten Dateisystems vom Standard des Betriebssystems abweicht.

rename (to)

Source

# File pathname_builtin.rb, line 947
def rename(to) File.rename(@path, to) end

Siehe File.rename. Benennt die Datei um.

rmdir ()

Source

# File pathname_builtin.rb, line 1142
def rmdir() Dir.rmdir(@path) end

Siehe Dir.rmdir. Löscht das referenzierte Verzeichnis.

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

Source

# File lib/pathname.rb, line 48
def rmtree(noop: nil, verbose: nil, secure: nil)
  # The name "rmtree" is borrowed from File::Path of Perl.
  # File::Path provides "mkpath" and "rmtree".
  require 'fileutils'
  FileUtils.rm_rf(@path, noop: noop, verbose: verbose, secure: secure)
  self
end

Löscht rekursiv ein Verzeichnis, einschließlich aller darunter liegenden Verzeichnisse.

Beachten Sie, dass Sie 'pathname' erfordern müssen, um diese Methode zu verwenden.

Siehe FileUtils.rm_rf

root? ()

Source

# File pathname_builtin.rb, line 527
def root?
  chop_basename(@path) == nil && SEPARATOR_PAT.match?(@path)
end

Prädikatmethode für Wurzelverzeichnisse. Gibt true zurück, wenn der Pfadname aus aufeinanderfolgenden Schrägstrich-Zeichen besteht.

Sie greift nicht auf das Dateisystem zu. Daher kann sie für einige Pfadnamen, die auf Wurzeln zeigen, wie z. B. /usr/.., false zurückgeben.

setgid? ()

Source

# File pathname_builtin.rb, line 1066
def setgid?() FileTest.setgid?(@path) end

Siehe FileTest.setgid?.

setuid? ()

Source

# File pathname_builtin.rb, line 1063
def setuid?() FileTest.setuid?(@path) end

Siehe FileTest.setuid?.

size ()

Source

# File pathname_builtin.rb, line 1069
def size() FileTest.size(@path) end

Siehe FileTest.size.

size? ()

Source

# File pathname_builtin.rb, line 1072
def size?() FileTest.size?(@path) end

Siehe FileTest.size?.

socket? ()

Source

# File pathname_builtin.rb, line 1048
def socket?() FileTest.socket?(@path) end

Siehe FileTest.socket?.

split ()

Source

# File pathname_builtin.rb, line 985
def split()
  array = File.split(@path)
  raise TypeError, 'wrong argument type nil (expected Array)' unless Array === array
  array.map {|f| self.class.new(f) }
end

Siehe File.split. Gibt den dirname und den basename in einem Array zurück.

stat ()

Source

# File pathname_builtin.rb, line 950
def stat() File.stat(@path) end

Siehe File.stat. Gibt ein File::Stat-Objekt zurück.

sticky? ()

Source

# File pathname_builtin.rb, line 1075
def sticky?() FileTest.sticky?(@path) end

Siehe FileTest.sticky?.

sub (*args)

Source

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

    if (rb_block_given_p()) {
        str = rb_block_call(str, id_sub, argc, argv, 0, 0);
    }
    else {
        str = rb_funcallv(str, id_sub, argc, argv);
    }
    return rb_class_new_instance(1, &str, rb_obj_class(self));
}

Gibt einen Pfadnamen zurück, der durch String#sub ersetzt wurde.

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

sub_ext (repl)

Source

# File pathname_builtin.rb, line 292
def sub_ext(repl)
  ext = File.extname(@path)

  # File.extname("foo.bar:stream") returns ".bar" on NTFS and not ".bar:stream"
  # (see ruby_enc_find_extname()).
  # The behavior of Pathname#sub_ext is to replace everything
  # from the start of the extname until the end of the path with repl.
  unless @path.end_with?(ext)
    ext = @path[@path.rindex(ext)..]
  end

  self.class.new(@path.chomp(ext) + repl)
end

Gibt einen Pfadnamen zurück, bei dem repl als Suffix an den Basenamen angehängt wird.

Wenn self keine Erweiterung hat, wird repl angehängt.

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

symlink? ()

Source

# File pathname_builtin.rb, line 1078
def symlink?() FileTest.symlink?(@path) end

Siehe FileTest.symlink?.

sysopen (...)

Source

# File pathname_builtin.rb, line 887
def sysopen(...) File.sysopen(@path, ...) end

Siehe File.sysopen.

to_path ()

to_path ist so implementiert, dass Pathname-Objekte mit File.open usw. verwendet werden können.

Alias für: to_s

to_s ()

Source

# File pathname_builtin.rb, line 254
def to_s
  @path.dup
end

Gibt den Pfad als String zurück.

Auch alias genannt: to_path

truncate (length)

Source

# File pathname_builtin.rb, line 959
def truncate(length) File.truncate(@path, length) end

Siehe File.truncate. Kürzt die Datei auf length Bytes.

unlink ()

Source

# File pathname_builtin.rb, line 1153
def unlink()
  Dir.unlink @path
rescue Errno::ENOTDIR
  File.unlink @path
end

Entfernt eine Datei oder ein Verzeichnis, indem bei Bedarf File.unlink oder Dir.unlink verwendet wird.

Auch alias genannt: delete

utime (atime, mtime)

Source

# File pathname_builtin.rb, line 962
def utime(atime, mtime) File.utime(atime, mtime, @path) end

Siehe File.utime. Aktualisiert die Zugriffs- und Änderungszeiten.

world_readable? ()

Source

# File pathname_builtin.rb, line 1057
def world_readable?() File.world_readable?(@path) end

Siehe FileTest.world_readable?.

world_writable? ()

Source

# File pathname_builtin.rb, line 1084
def world_writable?() File.world_writable?(@path) end

Siehe FileTest.world_writable?.

writable? ()

Source

# File pathname_builtin.rb, line 1081
def writable?() FileTest.writable?(@path) end

Siehe FileTest.writable?.

writable_real? ()

Source

# File pathname_builtin.rb, line 1087
def writable_real?() FileTest.writable_real?(@path) end

Siehe FileTest.writable_real?.

write (...)

Source

# File pathname_builtin.rb, line 890
def write(...) File.write(@path, ...) end

Schreibt contents in die Datei. Siehe File.write.

zero? ()

Source

# File pathname_builtin.rb, line 1090
def zero?() FileTest.zero?(@path) end

Siehe FileTest.zero?.

class Pathname

Prädikatmethoden für den File-Status

Eigenschafts- und Manipulationsmethoden für File

Prädikatmethoden für den `File`-Status

Eigenschafts- und Manipulationsmethoden für `File`