Class | Pathname |
In: |
lib/pathname.rb
|
Parent: | Object |
Pathname represents a pathname which locates a file in a filesystem. The pathname depends on OS: Unix, Windows, etc. Pathname library works with pathnames of local OS. However non-Unix pathnames are supported experimentally.
It does not represent the file itself. 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 value 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.
require 'pathname' p = Pathname.new("/usr/bin/ruby") size = p.size # 27662 isdir = p.directory? # false dir = p.dirname # Pathname:/usr/bin base = p.basename # Pathname:ruby dir, base = p.split # [Pathname:/usr/bin, Pathname:ruby] data = p.read p.open { |f| _ } p.each_line { |line| _ }
p = "/usr/bin/ruby" size = File.size(p) # 27662 isdir = File.directory?(p) # false dir = File.dirname(p) # "/usr/bin" base = File.basename(p) # "ruby" dir, base = File.split(p) # ["/usr/bin", "ruby"] data = File.read(p) File.open(p) { |f| _ } File.foreach(p) { |line| _ }
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, ...]
These methods are effectively manipulating a String, because that‘s all a path is. Except for mountpoint?, children, and realpath, they don‘t access the filesystem.
These methods are a facade for FileTest:
These methods are a facade for File:
These methods are a facade for Dir:
These methods are a facade for IO:
These methods are a mixture of Find, FileUtils, and others:
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.
SEPARATOR_PAT | = | /[#{Regexp.quote File::ALT_SEPARATOR}#{Regexp.quote File::SEPARATOR}]/ |
SEPARATOR_PAT | = | /#{Regexp.quote File::SEPARATOR}/ |
getwd | -> | pwd |
Create a Pathname object from the given String (or String-like object). If path contains a NUL character (\0), an ArgumentError is raised.
# File lib/pathname.rb, line 203 203: def initialize(path) 204: path = path.__send__(TO_PATH) if path.respond_to? TO_PATH 205: @path = path.dup 206: 207: if /\0/ =~ @path 208: raise ArgumentError, "pathname contains \\0: #{@path.inspect}" 209: end 210: 211: self.taint if @path.tainted? 212: end
Pathname#+ appends a pathname fragment to this one to produce a new Pathname object.
p1 = Pathname.new("/usr") # Pathname:/usr p2 = p1 + "bin/ruby" # Pathname:/usr/bin/ruby p3 = p1 + "/etc/passwd" # Pathname:/etc/passwd
This method doesn‘t access the file system; it is pure string manipulation.
# File lib/pathname.rb, line 581 581: def +(other) 582: other = Pathname.new(other) unless Pathname === other 583: Pathname.new(plus(@path, other.to_s)) 584: end
Provides for comparing pathnames, case-sensitively.
# File lib/pathname.rb, line 231 231: def <=>(other) 232: return nil unless Pathname === other 233: @path.tr('/', "\0") <=> other.to_s.tr('/', "\0") 234: 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 lib/pathname.rb, line 223 223: def ==(other) 224: return false unless Pathname === other 225: other.to_s == @path 226: end
Predicate method for testing whether a path is absolute. It returns true if the pathname begins with a slash.
# File lib/pathname.rb, line 489 489: def absolute? 490: !relative? 491: 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>
It doesn‘t access actual filesystem.
This method is available since 1.8.5.
# File lib/pathname.rb, line 561 561: def ascend 562: path = @path 563: yield self 564: while r = chop_basename(path) 565: path, name = r 566: break if path.empty? 567: yield self.class.new(del_trailing_separator(path)) 568: end 569: end
See File.atime. Returns last access time.
# File lib/pathname.rb, line 762 762: def atime() File.atime(@path) end
See File.basename. Returns the last component of the path.
# File lib/pathname.rb, line 823 823: def basename(*args) self.class.new(File.basename(@path, *args)) end
See FileTest.blockdev?.
# File lib/pathname.rb, line 857 857: def blockdev?() FileTest.blockdev?(@path) end
See FileTest.chardev?.
# File lib/pathname.rb, line 860 860: def chardev?() FileTest.chardev?(@path) end
Pathname#chdir is obsoleted at 1.8.1.
# File lib/pathname.rb, line 945 945: def chdir(&block) 946: warn "Pathname#chdir is obsoleted. Use Dir.chdir." 947: Dir.chdir(@path, &block) 948: 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:
p = Pathname("/usr/lib/ruby/1.8") p.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, ... ] p.children(false) # -> [ Pathname:English.rb, Pathname:Env.rb, Pathname:abbrev.rb, ... ]
Note that the result never contain the entries . and .. in the directory because they are not children.
This method has existed since 1.8.1.
# File lib/pathname.rb, line 668 668: def children(with_directory=true) 669: with_directory = false if @path == '.' 670: result = [] 671: Dir.foreach(@path) {|e| 672: next if e == '.' || e == '..' 673: if with_directory 674: result << self.class.new(File.join(@path, e)) 675: else 676: result << self.class.new(e) 677: end 678: } 679: result 680: end
See File.chmod. Changes permissions.
# File lib/pathname.rb, line 771 771: def chmod(mode) File.chmod(mode, @path) end
See File.chown. Change owner and group of file.
# File lib/pathname.rb, line 777 777: def chown(owner, group) File.chown(owner, group, @path) end
Pathname#chroot is obsoleted at 1.8.1.
# File lib/pathname.rb, line 951 951: def chroot 952: warn "Pathname#chroot is obsoleted. Use Dir.chroot." 953: Dir.chroot(@path) 954: 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 realpath.
# File lib/pathname.rb, line 306 306: def cleanpath(consider_symlink=false) 307: if consider_symlink 308: cleanpath_conservative 309: else 310: cleanpath_aggressive 311: end 312: end
See File.ctime. Returns last (directory entry, not file) change time.
# File lib/pathname.rb, line 765 765: def ctime() File.ctime(@path) 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>
It doesn‘t access actual filesystem.
This method is available since 1.8.5.
# File lib/pathname.rb, line 534 534: def descend 535: vs = [] 536: ascend {|v| vs << v } 537: vs.reverse_each {|v| yield v } 538: nil 539: end
Pathname#dir_foreach is obsoleted at 1.8.1.
# File lib/pathname.rb, line 969 969: def dir_foreach(*args, &block) 970: warn "Pathname#dir_foreach is obsoleted. Use Pathname#each_entry." 971: each_entry(*args, &block) 972: end
See FileTest.directory?.
# File lib/pathname.rb, line 875 875: def directory?() FileTest.directory?(@path) end
See File.dirname. Returns all but the last component of the path.
# File lib/pathname.rb, line 826 826: def dirname() self.class.new(File.dirname(@path)) end
Iterates over each component of the path.
Pathname.new("/usr/bin/ruby").each_filename {|filename| ... } # yields "usr", "bin", and "ruby".
# File lib/pathname.rb, line 508 508: def each_filename # :yield: filename 509: prefix, names = split_names(@path) 510: names.each {|filename| yield filename } 511: nil 512: end
See FileTest.executable?.
# File lib/pathname.rb, line 863 863: def executable?() FileTest.executable?(@path) end
See FileTest.executable_real?.
# File lib/pathname.rb, line 866 866: def executable_real?() FileTest.executable_real?(@path) end
See File.expand_path.
# File lib/pathname.rb, line 832 832: def expand_path(*args) self.class.new(File.expand_path(@path, *args)) end
See File.extname. Returns the file‘s extension.
# File lib/pathname.rb, line 829 829: def extname() File.extname(@path) end
Pathname#find is an iterator to traverse a directory tree in a depth first manner. It yields a Pathname for each file under "this" directory.
Since it is implemented by find.rb, Find.prune can be used to control the traverse.
If self is ., yielded pathnames begin with a filename in the current directory, not ./.
# File lib/pathname.rb, line 998 998: def find(&block) # :yield: p 999: require 'find' 1000: if @path == '.' 1001: Find.find(@path) {|f| yield self.class.new(f.sub(%r{\A\./}, '')) } 1002: else 1003: Find.find(@path) {|f| yield self.class.new(f) } 1004: end 1005: end
See File.fnmatch. Return true if the receiver matches the given pattern.
# File lib/pathname.rb, line 784 784: def fnmatch(pattern, *args) File.fnmatch(pattern, @path, *args) end
See File.fnmatch? (same as fnmatch).
# File lib/pathname.rb, line 787 787: def fnmatch?(pattern, *args) File.fnmatch?(pattern, @path, *args) end
This method is obsoleted at 1.8.1. Use each_line or each_entry.
# File lib/pathname.rb, line 1042 1042: def foreach(*args, &block) 1043: warn "Pathname#foreach is obsoleted. Use each_line or each_entry." 1044: if FileTest.directory? @path 1045: # For polymorphism between Dir.foreach and IO.foreach, 1046: # Pathname#foreach doesn't yield Pathname object. 1047: Dir.foreach(@path, *args, &block) 1048: else 1049: IO.foreach(@path, *args, &block) 1050: end 1051: end
Pathname#foreachline is obsoleted at 1.8.1. Use each_line.
# File lib/pathname.rb, line 742 742: def foreachline(*args, &block) 743: warn "Pathname#foreachline is obsoleted. Use Pathname#each_line." 744: each_line(*args, &block) 745: end
See File.ftype. Returns "type" of file ("file", "directory", etc).
# File lib/pathname.rb, line 791 791: def ftype() File.ftype(@path) end
See FileTest.grpowned?.
# File lib/pathname.rb, line 872 872: def grpowned?() FileTest.grpowned?(@path) end
Pathname#join joins pathnames.
path0.join(path1, …, pathN) is the same as path0 + path1 + … + pathN.
# File lib/pathname.rb, line 634 634: def join(*args) 635: args.unshift self 636: result = args.pop 637: result = Pathname.new(result) unless Pathname === result 638: return result if result.absolute? 639: args.reverse_each {|arg| 640: arg = Pathname.new(arg) unless Pathname === arg 641: result = arg + result 642: return result if result.absolute? 643: } 644: result 645: end
See File.lchmod.
# File lib/pathname.rb, line 774 774: def lchmod(mode) File.lchmod(mode, @path) end
See File.lchown.
# File lib/pathname.rb, line 780 780: def lchown(owner, group) File.lchown(owner, group, @path) end
Pathname#link is confusing and obsoleted because the receiver/argument order is inverted to corresponding system call.
# File lib/pathname.rb, line 840 840: def link(old) 841: warn 'Pathname#link is obsoleted. Use Pathname#make_link.' 842: File.link(old, @path) 843: end
See File.symlink. Creates a symbolic link.
# File lib/pathname.rb, line 814 814: def make_symlink(old) File.symlink(old, @path) end
See FileUtils.mkpath. Creates a full path, including any intermediate directories that don‘t yet exist.
# File lib/pathname.rb, line 1012 1012: def mkpath 1013: require 'fileutils' 1014: FileUtils.mkpath(@path) 1015: nil 1016: end
mountpoint? returns true if self points to a mountpoint.
# File lib/pathname.rb, line 465 465: def mountpoint? 466: begin 467: stat1 = self.lstat 468: stat2 = self.parent.lstat 469: stat1.dev == stat2.dev && stat1.ino == stat2.ino || 470: stat1.dev != stat2.dev 471: rescue Errno::ENOENT 472: false 473: end 474: end
See File.mtime. Returns last modification time.
# File lib/pathname.rb, line 768 768: def mtime() File.mtime(@path) end
See File.open. Opens the file for reading or writing.
# File lib/pathname.rb, line 797 797: def open(*args, &block) # :yield: file 798: File.open(@path, *args, &block) 799: end
See FileTest.readable?.
# File lib/pathname.rb, line 890 890: def readable?() FileTest.readable?(@path) end
See FileTest.readable_real?.
# File lib/pathname.rb, line 896 896: def readable_real?() FileTest.readable_real?(@path) end
See IO.readlines. Returns all the lines from the file.
# File lib/pathname.rb, line 752 752: def readlines(*args) IO.readlines(@path, *args) end
See File.readlink. Read symbolic link.
# File lib/pathname.rb, line 802 802: def readlink() self.class.new(File.readlink(@path)) end
Returns a real (absolute) pathname of self in the actual filesystem. The real pathname doesn‘t contain symlinks or useless dots.
No arguments should be given; the old behaviour is obsoleted.
# File lib/pathname.rb, line 446 446: def realpath 447: path = @path 448: prefix, names = split_names(path) 449: if prefix == '' 450: prefix, names2 = split_names(Dir.pwd) 451: names = names2 + names 452: end 453: prefix, *names = realpath_rec(prefix, names, {}) 454: self.class.new(prepend_prefix(prefix, File.join(*names))) 455: end
The opposite of absolute?
# File lib/pathname.rb, line 494 494: def relative? 495: path = @path 496: while r = chop_basename(path) 497: path, basename = r 498: end 499: path == '' 500: end
relative_path_from returns a relative path from the argument to the receiver. If self is absolute, the argument must be absolute too. If self is relative, the argument must be relative too.
relative_path_from doesn‘t access the filesystem. It assumes no symlinks.
ArgumentError is raised when it cannot find a relative path.
This method has existed since 1.8.1.
# File lib/pathname.rb, line 693 693: def relative_path_from(base_directory) 694: dest_directory = self.cleanpath.to_s 695: base_directory = base_directory.cleanpath.to_s 696: dest_prefix = dest_directory 697: dest_names = [] 698: while r = chop_basename(dest_prefix) 699: dest_prefix, basename = r 700: dest_names.unshift basename if basename != '.' 701: end 702: base_prefix = base_directory 703: base_names = [] 704: while r = chop_basename(base_prefix) 705: base_prefix, basename = r 706: base_names.unshift basename if basename != '.' 707: end 708: if dest_prefix != base_prefix 709: raise ArgumentError, "different prefix: #{dest_prefix.inspect} and #{base_directory.inspect}" 710: end 711: while !dest_names.empty? && 712: !base_names.empty? && 713: dest_names.first == base_names.first 714: dest_names.shift 715: base_names.shift 716: end 717: if base_names.include? '..' 718: raise ArgumentError, "base_directory has ..: #{base_directory.inspect}" 719: end 720: base_names.fill('..') 721: relpath_names = base_names + dest_names 722: if relpath_names.empty? 723: Pathname.new('.') 724: else 725: Pathname.new(File.join(*relpath_names)) 726: end 727: end
See File.rename. Rename the file.
# File lib/pathname.rb, line 805 805: def rename(to) File.rename(@path, to) end
See FileUtils.rm_r. Deletes a directory and all beneath it.
# File lib/pathname.rb, line 1019 1019: def rmtree 1020: # The name "rmtree" is borrowed from File::Path of Perl. 1021: # File::Path provides "mkpath" and "rmtree". 1022: require 'fileutils' 1023: FileUtils.rm_r(@path) 1024: nil 1025: end
root? is a predicate for root directories. I.e. it returns true if the pathname consists of consecutive slashes.
It doesn‘t access actual filesystem. So it may return false for some pathnames which points to roots such as /usr/...
# File lib/pathname.rb, line 483 483: def root? 484: !!(chop_basename(@path) == nil && /#{SEPARATOR_PAT}/o =~ @path) 485: end
See FileTest.setgid?.
# File lib/pathname.rb, line 902 902: def setgid?() FileTest.setgid?(@path) end
See FileTest.setuid?.
# File lib/pathname.rb, line 899 899: def setuid?() FileTest.setuid?(@path) end
See FileTest.size.
# File lib/pathname.rb, line 905 905: def size() FileTest.size(@path) end
See FileTest.size?.
# File lib/pathname.rb, line 908 908: def size?() FileTest.size?(@path) end
See FileTest.socket?.
# File lib/pathname.rb, line 884 884: def socket?() FileTest.socket?(@path) end
See File.split. Returns the dirname and the basename in an Array.
# File lib/pathname.rb, line 836 836: def split() File.split(@path).map {|f| self.class.new(f) } end
See File.stat. Returns a File::Stat object.
# File lib/pathname.rb, line 808 808: def stat() File.stat(@path) end
See FileTest.sticky?.
# File lib/pathname.rb, line 911 911: def sticky?() FileTest.sticky?(@path) end
Return a pathname which is substituted by String#sub.
# File lib/pathname.rb, line 253 253: def sub(pattern, *rest, &block) 254: self.class.new(@path.sub(pattern, *rest, &block)) 255: end
Pathname#symlink is confusing and obsoleted because the receiver/argument order is inverted to corresponding system call.
# File lib/pathname.rb, line 847 847: def symlink(old) 848: warn 'Pathname#symlink is obsoleted. Use Pathname#make_symlink.' 849: File.symlink(old, @path) 850: end
See FileTest.symlink?.
# File lib/pathname.rb, line 914 914: def symlink?() FileTest.symlink?(@path) end
See IO.sysopen.
# File lib/pathname.rb, line 755 755: def sysopen(*args) IO.sysopen(@path, *args) end
See File.truncate. Truncate the file to length bytes.
# File lib/pathname.rb, line 817 817: def truncate(length) File.truncate(@path, length) end
Removes a file or directory, using File.unlink or Dir.unlink as necessary.
# File lib/pathname.rb, line 1032 1032: def unlink() 1033: begin 1034: Dir.unlink @path 1035: rescue Errno::ENOTDIR 1036: File.unlink @path 1037: end 1038: end
See File.utime. Update the access and modification times.
# File lib/pathname.rb, line 820 820: def utime(atime, mtime) File.utime(atime, mtime, @path) end
See FileTest.world_readable?.
# File lib/pathname.rb, line 893 893: def world_readable?() FileTest.world_readable?(@path) end
See FileTest.world_writable?.
# File lib/pathname.rb, line 920 920: def world_writable?() FileTest.world_writable?(@path) end
See FileTest.writable?.
# File lib/pathname.rb, line 917 917: def writable?() FileTest.writable?(@path) end
See FileTest.writable_real?.
# File lib/pathname.rb, line 923 923: def writable_real?() FileTest.writable_real?(@path) end
add_trailing_separator(path) -> path
# File lib/pathname.rb, line 355 355: def add_trailing_separator(path) 356: if File.basename(path + 'a') == 'a' 357: path 358: else 359: File.join(path, "") # xxx: Is File.join is appropriate to add separator? 360: end 361: end
chop_basename(path) -> [pre-basename, basename] or nil
# File lib/pathname.rb, line 264 264: def chop_basename(path) 265: base = File.basename(path) 266: if /\A#{SEPARATOR_PAT}?\z/ =~ base 267: return nil 268: else 269: return path[0, path.rindex(base)], base 270: end 271: end
Clean the path simply by resolving and removing excess "." and ".." entries. Nothing more, nothing less.
# File lib/pathname.rb, line 318 318: def cleanpath_aggressive 319: path = @path 320: names = [] 321: pre = path 322: while r = chop_basename(pre) 323: pre, base = r 324: case base 325: when '.' 326: when '..' 327: names.unshift base 328: else 329: if names[0] == '..' 330: names.shift 331: else 332: names.unshift base 333: end 334: end 335: end 336: if /#{SEPARATOR_PAT}/o =~ File.basename(pre) 337: names.shift while names[0] == '..' 338: end 339: self.class.new(prepend_prefix(pre, File.join(*names))) 340: end
# File lib/pathname.rb, line 376 376: def cleanpath_conservative 377: path = @path 378: names = [] 379: pre = path 380: while r = chop_basename(pre) 381: pre, base = r 382: names.unshift base if base != '.' 383: end 384: if /#{SEPARATOR_PAT}/o =~ File.basename(pre) 385: names.shift while names[0] == '..' 386: end 387: if names.empty? 388: self.class.new(File.dirname(pre)) 389: else 390: if names.last != '..' && File.basename(path) == '.' 391: names << '.' 392: end 393: result = prepend_prefix(pre, File.join(*names)) 394: if /\A(?:\.|\.\.)\z/ !~ names.last && has_trailing_separator?(path) 395: self.class.new(add_trailing_separator(result)) 396: else 397: self.class.new(result) 398: end 399: end 400: end
# File lib/pathname.rb, line 364 364: def del_trailing_separator(path) 365: if r = chop_basename(path) 366: pre, basename = r 367: pre + basename 368: elsif /#{SEPARATOR_PAT}+\z/o =~ path 369: $` + File.dirname(path)[/#{SEPARATOR_PAT}*\z/o] 370: else 371: path 372: end 373: end
has_trailing_separator?(path) -> bool
# File lib/pathname.rb, line 344 344: def has_trailing_separator?(path) 345: if r = chop_basename(path) 346: pre, basename = r 347: pre.length + basename.length < path.length 348: else 349: false 350: end 351: end
# File lib/pathname.rb, line 586 586: def plus(path1, path2) # -> path 587: prefix2 = path2 588: index_list2 = [] 589: basename_list2 = [] 590: while r2 = chop_basename(prefix2) 591: prefix2, basename2 = r2 592: index_list2.unshift prefix2.length 593: basename_list2.unshift basename2 594: end 595: return path2 if prefix2 != '' 596: prefix1 = path1 597: while true 598: while !basename_list2.empty? && basename_list2.first == '.' 599: index_list2.shift 600: basename_list2.shift 601: end 602: break unless r1 = chop_basename(prefix1) 603: prefix1, basename1 = r1 604: next if basename1 == '.' 605: if basename1 == '..' || basename_list2.empty? || basename_list2.first != '..' 606: prefix1 = prefix1 + basename1 607: break 608: end 609: index_list2.shift 610: basename_list2.shift 611: end 612: r1 = chop_basename(prefix1) 613: if !r1 && /#{SEPARATOR_PAT}/o =~ File.basename(prefix1) 614: while !basename_list2.empty? && basename_list2.first == '..' 615: index_list2.shift 616: basename_list2.shift 617: end 618: end 619: if !basename_list2.empty? 620: suffix2 = path2[index_list2.first..-1] 621: r1 ? File.join(prefix1, suffix2) : prefix1 + suffix2 622: else 623: r1 ? prefix1 : File.dirname(prefix1) 624: end 625: end
# File lib/pathname.rb, line 285 285: def prepend_prefix(prefix, relpath) 286: if relpath.empty? 287: File.dirname(prefix) 288: elsif /#{SEPARATOR_PAT}/ =~ prefix 289: prefix = File.dirname(prefix) 290: prefix = File.join(prefix, "") if File.basename(prefix + 'a') != 'a' 291: prefix + relpath 292: else 293: prefix + relpath 294: end 295: end
# File lib/pathname.rb, line 403 403: def realpath_rec(prefix, unresolved, h) 404: resolved = [] 405: until unresolved.empty? 406: n = unresolved.shift 407: if n == '.' 408: next 409: elsif n == '..' 410: resolved.pop 411: else 412: path = prepend_prefix(prefix, File.join(*(resolved + [n]))) 413: if h.include? path 414: if h[path] == :resolving 415: raise Errno::ELOOP.new(path) 416: else 417: prefix, *resolved = h[path] 418: end 419: else 420: s = File.lstat(path) 421: if s.symlink? 422: h[path] = :resolving 423: link_prefix, link_names = split_names(File.readlink(path)) 424: if link_prefix == '' 425: prefix, *resolved = h[path] = realpath_rec(prefix, resolved + link_names, h) 426: else 427: prefix, *resolved = h[path] = realpath_rec(link_prefix, link_names, h) 428: end 429: else 430: resolved << n 431: h[path] = [prefix, *resolved] 432: end 433: end 434: end 435: end 436: return prefix, *resolved 437: end
split_names(path) -> prefix, [name, …]
# File lib/pathname.rb, line 275 275: def split_names(path) 276: names = [] 277: while r = chop_basename(path) 278: path, basename = r 279: names.unshift basename 280: end 281: return path, names 282: end