pathname.rb
Object-Oriented Pathname Class
- Author
-
Tanaka Akira <akr@m17n.org>
- Documentation
-
Author and Gavin Sinclair
For documentation, see class Pathname.
Pathname represents the name of a file or directory on the filesystem, but not the file itself.
The pathname depends on the Operating System: Unix, Windows, etc. This library works with pathnames of local OS, however non-Unix pathnames are supported experimentally.
A Pathname can be relative or absolute. It’s not until you try to reference the file that it even matters whether the file exists or not.
Pathname is immutable. It has no method for destructive update.
The goal of this class is to manipulate file path information in a neater way than standard Ruby provides. The examples below demonstrate the difference.
All functionality from File, FileTest, and some from Dir and FileUtils is included, in an unsurprising way. It is essentially a facade for all of these, and more.
Examples
Example 1: Using 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| _ }
Example 2: Using 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| _ }
Example 3: Special features
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, ...]
Breakdown of functionality
Core methods
These methods are effectively manipulating a String, because that’s all a path is. None of these access the file system except for mountpoint?, children, each_child, realdirpath and realpath.
-
+
File status predicate methods
These methods are a facade for FileTest:
File property and manipulation methods
These methods are a facade for File:
Directory methods
These methods are a facade for Dir:
-
each_entry(&block)
Utilities
These methods are a mixture of Find, FileUtils, and others:
Method documentation
As the above section shows, most of the methods in Pathname are facades. The documentation for these methods generally just says, for instance, “See FileTest.writable?”, as you should be familiar with the original method anyway, and its documentation (e.g. through ri) will contain more information. In some cases, a brief description will follow.
Regexp that matches an absolute path.
Separator list string.
Regexp that matches a separator.
The version string.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1120
def Pathname.getwd() self.new(Dir.getwd) end
# File tmp/rubies/ruby-4.0.0/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
# File tmp/rubies/ruby-4.0.0/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
Creates a tmp directory and wraps the returned path in a Pathname object.
Note that you need to require ‘pathname’ to use this method.
See Dir.mktmpdir
# File tmp/rubies/ruby-4.0.0/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
Create a Pathname object from the given String (or String-like object). If path contains a NUL character (\0), an ArgumentError is raised.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 665
def +(other)
other = Pathname.new(other) unless Pathname === other
Pathname.new(plus(@path, other.path))
end
Appends a pathname fragment to self to produce a new Pathname object. Since other is considered as a path relative to self, if other is an absolute path, the new Pathname object is created from just other.
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
This method doesn’t access the file system; it is pure string manipulation.
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);
}
Provides a case-sensitive comparison operator for pathnames.
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
It will return -1, 0 or 1 depending on the value of the left argument relative to the right argument. Or it will return nil if the arguments are not comparable.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 234
def ==(other)
return false unless Pathname === other
other.path == @path
end
Compare this pathname with other. The comparison is string-based. Be aware that two different paths (foo.txt and ./foo.txt) can refer to the same file.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 542
def absolute?
ABSOLUTE_PATH.match? @path
end
Predicate method for testing whether a path is absolute.
It returns true if the pathname begins with a slash.
p = Pathname.new('/im/sure') p.absolute? #=> true p = Pathname.new('not/so/sure') p.absolute? #=> false
# File tmp/rubies/ruby-4.0.0/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
Iterates over and yields a new Pathname object for each element in the given path in ascending order.
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>
Returns an Enumerator if no block was given.
enum = Pathname.new("/usr/bin/ruby").ascend
# ... do stuff ...
enum.each { |e| ... }
# yields Pathnames /usr/bin/ruby, /usr/bin, /usr, and /.
It doesn’t access the filesystem.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 898
def atime() File.atime(@path) end
See File.atime. Returns last access time.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 972
def basename(...) self.class.new(File.basename(@path, ...)) end
See File.basename. Returns the last component of the path.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 881
def binread(...) File.binread(@path, ...) end
See File.binread. Returns all the bytes from the file, or the first N if specified.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 895
def binwrite(...) File.binwrite(@path, ...) end
Writes contents to the file, opening it in binary mode.
See File.binwrite.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 904
def birthtime() File.birthtime(@path) end
Returns the birth time for the file. If the platform doesn’t have birthtime, raises NotImplementedError.
See File.birthtime.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1010
def blockdev?() FileTest.blockdev?(@path) end
See FileTest.blockdev?.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1013
def chardev?() FileTest.chardev?(@path) end
See FileTest.chardev?.
# File tmp/rubies/ruby-4.0.0/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
Returns the children of the directory (files and subdirectories, not recursive) as an array of Pathname objects.
By default, the returned pathnames will have enough information to access the files. If you set with_directory to false, then the returned pathnames will contain the filename only.
For example:
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, ... ]
Note that the results never contain the entries . and .. in the directory because they are not children.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 913
def chmod(mode) File.chmod(mode, @path) end
See File.chmod. Changes permissions.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 919
def chown(owner, group) File.chown(owner, group, @path) end
See File.chown. Change owner and group of file.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 403
def cleanpath(consider_symlink=false)
if consider_symlink
cleanpath_conservative
else
cleanpath_aggressive
end
end
Returns clean pathname of self with consecutive slashes and useless dots removed. The filesystem is not accessed.
If consider_symlink is true, then a more conservative algorithm is used to avoid breaking symbolic linkages. This may retain more .. entries than absolutely necessary, but without accessing the filesystem, this can’t be avoided.
See Pathname#realpath.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 907
def ctime() File.ctime(@path) end
See File.ctime. Returns last (directory entry, not file) change time.
# File tmp/rubies/ruby-4.0.0/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
Iterates over and yields a new Pathname object for each element in the given path in descending order.
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>
Returns an Enumerator if no block was given.
enum = Pathname.new("/usr/bin/ruby").descend
# ... do stuff ...
enum.each { |e| ... }
# yields Pathnames /, /usr, /usr/bin, and /usr/bin/ruby.
It doesn’t access the filesystem.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1039
def directory?() FileTest.directory?(@path) end
See FileTest.directory?.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 975
def dirname() self.class.new(File.dirname(@path)) end
See File.dirname. Returns all but the last component of the path.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 808
def each_child(with_directory=true, &b)
children(with_directory).each(&b)
end
Iterates over the children of the directory (files and subdirectories, not recursive).
It yields Pathname object for each child.
By default, the yielded pathnames will have enough information to access the files.
If you set with_directory to false, then the returned pathnames will contain the filename only.
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>
Note that the results never contain the entries . and .. in the directory because they are not children.
# File tmp/rubies/ruby-4.0.0/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
Iterates over the entries (files and subdirectories) in the directory. It yields a Pathname object for each entry.
This method has existed since 1.8.1.
# File tmp/rubies/ruby-4.0.0/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
Iterates over each component of the path.
Pathname.new("/usr/bin/ruby").each_filename {|filename| ... }
# yields "usr", "bin", and "ruby".
Returns an Enumerator if no block was given.
enum = Pathname.new("/usr/bin/ruby").each_filename
# ... do stuff ...
enum.each { |e| ... }
# yields "usr", "bin", and "ruby".
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 871
def each_line(...) # :yield: line
File.foreach(@path, ...)
end
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1018
def empty?
if FileTest.directory?(@path)
Dir.empty?(@path)
else
File.empty?(@path)
end
end
Tests the file is empty.
See Dir#empty? and FileTest.empty?.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1127
def entries() Dir.entries(@path).map {|f| self.class.new(f) } end
Return the entries (files and subdirectories) in the directory, each as a Pathname object.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1027
def executable?() FileTest.executable?(@path) end
See FileTest.executable?.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1030
def executable_real?() FileTest.executable_real?(@path) end
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1033
def exist?() FileTest.exist?(@path) end
See FileTest.exist?.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 981
def expand_path(...) self.class.new(File.expand_path(@path, ...)) end
See File.expand_path.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 978
def extname() File.extname(@path) end
See File.extname. Returns the file’s extension.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1042
def file?() FileTest.file?(@path) end
See FileTest.file?.
# File tmp/rubies/ruby-4.0.0/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
Iterates over the directory tree in a depth first manner, yielding a Pathname for each file under “this” directory.
Note that you need to require ‘pathname’ to use this method.
Returns an Enumerator if no block is given.
Since it is implemented by the standard library module Find, Find.prune can be used to control the traversal.
If self is ., yielded pathnames begin with a filename in the current directory, not ./.
See Find.find
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 926
def fnmatch(pattern, ...) File.fnmatch(pattern, @path, ...) end
See File.fnmatch. Return true if the receiver matches the given pattern.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 929
def fnmatch?(pattern, ...) File.fnmatch?(pattern, @path, ...) end
See File.fnmatch? (same as fnmatch).
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 223
def freeze
super
@path.freeze
self
end
Freze self.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 933
def ftype() File.ftype(@path) end
See File.ftype. Returns “type” of file (“file”, “directory”, etc).
# File tmp/rubies/ruby-4.0.0/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
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1036
def grpowned?() FileTest.grpowned?(@path) end
See FileTest.grpowned?.
# File tmp/rubies/ruby-4.0.0/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
Joins the given pathnames onto self to create a new Pathname object. This is effectively the same as using Pathname#+ to append self and all arguments sequentially.
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
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 916
def lchmod(mode) File.lchmod(mode, @path) end
See File.lchmod.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 922
def lchown(owner, group) File.lchown(owner, group, @path) end
See File.lchown.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 953
def lstat() File.lstat(@path) end
See File.lstat.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 969
def lutime(atime, mtime) File.lutime(atime, mtime, @path) end
Update the access and modification times of the file.
Same as Pathname#utime, but does not follow symbolic links.
See File.lutime.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 936
def make_link(old) File.link(old, @path) end
See File.link. Creates a hard link.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 956
def make_symlink(old) File.symlink(old, @path) end
See File.symlink. Creates a symbolic link.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1139
def mkdir(...) Dir.mkdir(@path, ...) end
See Dir.mkdir. Create the referenced directory.
# File tmp/rubies/ruby-4.0.0/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
Creates a full path, including any intermediate directories that don’t yet exist.
See FileUtils.mkpath and FileUtils.mkdir_p
# File tmp/rubies/ruby-4.0.0/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
Returns true if self points to a mountpoint.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 910
def mtime() File.mtime(@path) end
See File.mtime. Returns last modification time.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 939
def open(...) # :yield: file
File.open(@path, ...)
end
See File.open. Opens the file for reading or writing.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1145
def opendir(&block) # :yield: dir
Dir.open(@path, &block)
end
See Dir.open.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1051
def owned?() FileTest.owned?(@path) end
See FileTest.owned?.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 505
def parent
self + '..'
end
Returns the parent directory.
This is same as self + '..'.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1045
def pipe?() FileTest.pipe?(@path) end
See FileTest.pipe?.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 877
def read(...) File.read(@path, ...) end
See File.read. Returns all data from the file, or the first N bytes if specified.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1054
def readable?() FileTest.readable?(@path) end
See FileTest.readable?.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1060
def readable_real?() FileTest.readable_real?(@path) end
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 884
def readlines(...) File.readlines(@path, ...) end
See File.readlines. Returns all the lines from the file.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 944
def readlink() self.class.new(File.readlink(@path)) end
See File.readlink. Read symbolic link.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1003
def realdirpath(...) self.class.new(File.realdirpath(@path, ...)) end
Returns the real (absolute) pathname of self in the actual filesystem.
Does not contain symlinks or useless dots, .. and ..
The last component of the real pathname can be nonexistent.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 996
def realpath(...) self.class.new(File.realpath(@path, ...)) end
Returns the real (absolute) pathname for self in the actual filesystem.
Does not contain symlinks or useless dots, .. and ..
All components of the pathname must exist when this method is called.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 557
def relative?
!absolute?
end
The opposite of Pathname#absolute?
It returns false if the pathname begins with a slash.
p = Pathname.new('/im/sure') p.relative? #=> false p = Pathname.new('not/so/sure') p.relative? #=> true
# File tmp/rubies/ruby-4.0.0/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
Returns a relative path from the given base_directory to the receiver.
If self is absolute, then base_directory must be absolute too.
If self is relative, then base_directory must be relative too.
This method doesn’t access the filesystem. It assumes no symlinks.
ArgumentError is raised when it cannot find a relative path.
Note that this method does not handle situations where the case sensitivity of the filesystem in use differs from the operating system default.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 947
def rename(to) File.rename(@path, to) end
See File.rename. Rename the file.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1142
def rmdir() Dir.rmdir(@path) end
See Dir.rmdir. Remove the referenced directory.
# File tmp/rubies/ruby-4.0.0/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
Recursively deletes a directory, including all directories beneath it.
Note that you need to require ‘pathname’ to use this method.
See FileUtils.rm_rf
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 527
def root?
chop_basename(@path) == nil && SEPARATOR_PAT.match?(@path)
end
Predicate method for root directories. Returns true if the pathname consists of consecutive slashes.
It doesn’t access the filesystem. So it may return false for some pathnames which points to roots such as /usr/...
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1066
def setgid?() FileTest.setgid?(@path) end
See FileTest.setgid?.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1063
def setuid?() FileTest.setuid?(@path) end
See FileTest.setuid?.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1069
def size() FileTest.size(@path) end
See FileTest.size.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1072
def size?() FileTest.size?(@path) end
See FileTest.size?.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1048
def socket?() FileTest.socket?(@path) end
See FileTest.socket?.
# File tmp/rubies/ruby-4.0.0/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
See File.split. Returns the dirname and the basename in an Array.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 950
def stat() File.stat(@path) end
See File.stat. Returns a File::Stat object.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1075
def sticky?() FileTest.sticky?(@path) end
See FileTest.sticky?.
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));
}
Return a pathname which is substituted by String#sub.
path1 = Pathname.new('/usr/bin/perl') path1.sub('perl', 'ruby') #=> #<Pathname:/usr/bin/ruby>
# File tmp/rubies/ruby-4.0.0/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
Return a pathname with repl added as a suffix to the basename.
If self has no extension part, repl is appended.
Pathname.new('/usr/bin/shutdown').sub_ext('.rb') #=> #<Pathname:/usr/bin/shutdown.rb>
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1078
def symlink?() FileTest.symlink?(@path) end
See FileTest.symlink?.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 887
def sysopen(...) File.sysopen(@path, ...) end
See File.sysopen.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 254
def to_s
@path.dup
end
Return the path as a String.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 959
def truncate(length) File.truncate(@path, length) end
See File.truncate. Truncate the file to length bytes.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1153
def unlink()
Dir.unlink @path
rescue Errno::ENOTDIR
File.unlink @path
end
Removes a file or directory, using File.unlink or Dir.unlink as necessary.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 962
def utime(atime, mtime) File.utime(atime, mtime, @path) end
See File.utime. Update the access and modification times.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1057
def world_readable?() File.world_readable?(@path) end
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1084
def world_writable?() File.world_writable?(@path) end
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1081
def writable?() FileTest.writable?(@path) end
See FileTest.writable?.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1087
def writable_real?() FileTest.writable_real?(@path) end
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 890
def write(...) File.write(@path, ...) end
Writes contents to the file. See File.write.
# File tmp/rubies/ruby-4.0.0/pathname_builtin.rb, line 1090
def zero?() FileTest.zero?(@path) end
See FileTest.zero?.