Class Pathname
In: lib/pathname.rb
Parent: Object

Pathname

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.

Examples

Example 1: Using Pathname

  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| _ }

Example 2: Using standard Ruby

  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| _ }

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. Except for mountpoint?, children, and realpath, they don‘t access the filesystem.

File status predicate methods

These methods are a facade for FileTest:

  • blockdev?
  • chardev?
  • directory?
  • executable?
  • executable_real?
  • exist?
  • file?
  • grpowned?
  • owned?
  • pipe?
  • readable?
  • world_readable?
  • readable_real?
  • setgid?
  • setuid?
  • size
  • size?
  • socket?
  • sticky?
  • symlink?
  • writable?
  • world_writable?
  • writable_real?
  • zero?

File property and manipulation methods

These methods are a facade for File:

Directory methods

These methods are a facade for Dir:

IO

These methods are a facade for IO:

  • each_line(*args, &block)
  • read(*args)
  • readlines(*args)
  • sysopen(*args)

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.

Methods

Constants

SEPARATOR_PAT = /[#{Regexp.quote File::ALT_SEPARATOR}#{Regexp.quote File::SEPARATOR}]/
SEPARATOR_PAT = /#{Regexp.quote File::SEPARATOR}/

External Aliases

getwd -> pwd

Public Class methods

See Dir.getwd. Returns the current working directory as a Pathname.

[Source]

     # File lib/pathname.rb, line 941
941:   def Pathname.getwd() self.new(Dir.getwd) end

See Dir.glob. Returns or yields Pathname objects.

[Source]

     # File lib/pathname.rb, line 932
932:   def Pathname.glob(*args) # :yield: p
933:     if block_given?
934:       Dir.glob(*args) {|f| yield self.new(f) }
935:     else
936:       Dir.glob(*args).map {|f| self.new(f) }
937:     end
938:   end

Create a Pathname object from the given String (or String-like object). If path contains a NUL character (\0), an ArgumentError is raised.

[Source]

     # 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

Public Instance methods

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.

[Source]

     # 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.

[Source]

     # 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.

[Source]

     # File lib/pathname.rb, line 223
223:   def ==(other)
224:     return false unless Pathname === other
225:     other.to_s == @path
226:   end
===(other)

Alias for #==

TO_PATH()

Alias for to_s

Predicate method for testing whether a path is absolute. It returns true if the pathname begins with a slash.

[Source]

     # 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.

[Source]

     # 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.

[Source]

     # File lib/pathname.rb, line 762
762:   def atime() File.atime(@path) end

See File.basename. Returns the last component of the path.

[Source]

     # File lib/pathname.rb, line 823
823:   def basename(*args) self.class.new(File.basename(@path, *args)) end

See FileTest.blockdev?.

[Source]

     # File lib/pathname.rb, line 857
857:   def blockdev?() FileTest.blockdev?(@path) end

See FileTest.chardev?.

[Source]

     # File lib/pathname.rb, line 860
860:   def chardev?() FileTest.chardev?(@path) end

Pathname#chdir is obsoleted at 1.8.1.

[Source]

     # 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.

[Source]

     # 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.

[Source]

     # File lib/pathname.rb, line 771
771:   def chmod(mode) File.chmod(mode, @path) end

See File.chown. Change owner and group of file.

[Source]

     # 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.

[Source]

     # 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.

[Source]

     # 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.

[Source]

     # File lib/pathname.rb, line 765
765:   def ctime() File.ctime(@path) end
delete()

Alias for unlink

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.

[Source]

     # 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.

[Source]

     # 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?.

[Source]

     # 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.

[Source]

     # File lib/pathname.rb, line 826
826:   def dirname() self.class.new(File.dirname(@path)) 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.

[Source]

     # File lib/pathname.rb, line 964
964:   def each_entry(&block) # :yield: p
965:     Dir.foreach(@path) {|f| yield self.class.new(f) }
966:   end

Iterates over each component of the path.

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

[Source]

     # 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

each_line iterates over the line in the file. It yields a String object for each line.

This method has existed since 1.8.1.

[Source]

     # File lib/pathname.rb, line 737
737:   def each_line(*args, &block) # :yield: line
738:     IO.foreach(@path, *args, &block)
739:   end

Return the entries (files and subdirectories) in the directory, each as a Pathname object.

[Source]

     # File lib/pathname.rb, line 958
958:   def entries() Dir.entries(@path).map {|f| self.class.new(f) } end
eql?(other)

Alias for #==

See FileTest.executable?.

[Source]

     # File lib/pathname.rb, line 863
863:   def executable?() FileTest.executable?(@path) end

See FileTest.executable_real?.

[Source]

     # File lib/pathname.rb, line 866
866:   def executable_real?() FileTest.executable_real?(@path) end

See FileTest.exist?.

[Source]

     # File lib/pathname.rb, line 869
869:   def exist?() FileTest.exist?(@path) end

See File.expand_path.

[Source]

     # 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.

[Source]

     # File lib/pathname.rb, line 829
829:   def extname() File.extname(@path) end

See FileTest.file?.

[Source]

     # File lib/pathname.rb, line 878
878:   def file?() FileTest.file?(@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 ./.

[Source]

      # 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.

[Source]

     # File lib/pathname.rb, line 784
784:   def fnmatch(pattern, *args) File.fnmatch(pattern, @path, *args) end

See File.fnmatch? (same as fnmatch).

[Source]

     # 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.

[Source]

      # 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.

[Source]

     # 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

[Source]

     # File lib/pathname.rb, line 214
214:   def freeze() super; @path.freeze; self end

See File.ftype. Returns "type" of file ("file", "directory", etc).

[Source]

     # File lib/pathname.rb, line 791
791:   def ftype() File.ftype(@path) end

See FileTest.grpowned?.

[Source]

     # 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.

[Source]

     # 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.

[Source]

     # File lib/pathname.rb, line 774
774:   def lchmod(mode) File.lchmod(mode, @path) end

See File.lchown.

[Source]

     # 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.

[Source]

     # 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.lstat.

[Source]

     # File lib/pathname.rb, line 811
811:   def lstat() File.lstat(@path) end

See File.link. Creates a hard link.

[Source]

     # File lib/pathname.rb, line 794
794:   def make_link(old) File.link(old, @path) end

See File.symlink. Creates a symbolic link.

[Source]

     # File lib/pathname.rb, line 814
814:   def make_symlink(old) File.symlink(old, @path) end

See Dir.mkdir. Create the referenced directory.

[Source]

     # File lib/pathname.rb, line 975
975:   def mkdir(*args) Dir.mkdir(@path, *args) end

See FileUtils.mkpath. Creates a full path, including any intermediate directories that don‘t yet exist.

[Source]

      # 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.

[Source]

     # 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.

[Source]

     # File lib/pathname.rb, line 768
768:   def mtime() File.mtime(@path) end

See File.open. Opens the file for reading or writing.

[Source]

     # File lib/pathname.rb, line 797
797:   def open(*args, &block) # :yield: file
798:     File.open(@path, *args, &block)
799:   end

See Dir.open.

[Source]

     # File lib/pathname.rb, line 981
981:   def opendir(&block) # :yield: dir
982:     Dir.open(@path, &block)
983:   end

See FileTest.owned?.

[Source]

     # File lib/pathname.rb, line 887
887:   def owned?() FileTest.owned?(@path) end

parent returns the parent directory.

This is same as self + ’..’.

[Source]

     # File lib/pathname.rb, line 460
460:   def parent
461:     self + '..'
462:   end

See FileTest.pipe?.

[Source]

     # File lib/pathname.rb, line 881
881:   def pipe?() FileTest.pipe?(@path) end

See IO.read. Returns all the bytes from the file, or the first N if specified.

[Source]

     # File lib/pathname.rb, line 749
749:   def read(*args) IO.read(@path, *args) end

See FileTest.readable?.

[Source]

     # File lib/pathname.rb, line 890
890:   def readable?() FileTest.readable?(@path) end

See FileTest.readable_real?.

[Source]

     # 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.

[Source]

     # File lib/pathname.rb, line 752
752:   def readlines(*args) IO.readlines(@path, *args) end

See File.readlink. Read symbolic link.

[Source]

     # 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.

[Source]

     # 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?

[Source]

     # 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.

[Source]

     # 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.

[Source]

     # File lib/pathname.rb, line 805
805:   def rename(to) File.rename(@path, to) end

See Dir.rmdir. Remove the referenced directory.

[Source]

     # File lib/pathname.rb, line 978
978:   def rmdir() Dir.rmdir(@path) end

See FileUtils.rm_r. Deletes a directory and all beneath it.

[Source]

      # 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/...

[Source]

     # File lib/pathname.rb, line 483
483:   def root?
484:     !!(chop_basename(@path) == nil && /#{SEPARATOR_PAT}/o =~ @path)
485:   end

See FileTest.setgid?.

[Source]

     # File lib/pathname.rb, line 902
902:   def setgid?() FileTest.setgid?(@path) end

See FileTest.setuid?.

[Source]

     # File lib/pathname.rb, line 899
899:   def setuid?() FileTest.setuid?(@path) end

See FileTest.size.

[Source]

     # File lib/pathname.rb, line 905
905:   def size() FileTest.size(@path) end

See FileTest.size?.

[Source]

     # File lib/pathname.rb, line 908
908:   def size?() FileTest.size?(@path) end

See FileTest.socket?.

[Source]

     # 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.

[Source]

     # 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.

[Source]

     # File lib/pathname.rb, line 808
808:   def stat() File.stat(@path) end

See FileTest.sticky?.

[Source]

     # File lib/pathname.rb, line 911
911:   def sticky?() FileTest.sticky?(@path) end

Return a pathname which is substituted by String#sub.

[Source]

     # 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.

[Source]

     # 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?.

[Source]

     # File lib/pathname.rb, line 914
914:   def symlink?() FileTest.symlink?(@path) end

See IO.sysopen.

[Source]

     # File lib/pathname.rb, line 755
755:   def sysopen(*args) IO.sysopen(@path, *args) end

[Source]

     # File lib/pathname.rb, line 215
215:   def taint() super; @path.taint; self end

Return the path as a String.

[Source]

     # File lib/pathname.rb, line 241
241:   def to_s
242:     @path.dup
243:   end

See File.truncate. Truncate the file to length bytes.

[Source]

     # 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.

[Source]

      # 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

[Source]

     # File lib/pathname.rb, line 216
216:   def untaint() super; @path.untaint; self end

See File.utime. Update the access and modification times.

[Source]

     # File lib/pathname.rb, line 820
820:   def utime(atime, mtime) File.utime(atime, mtime, @path) end

See FileTest.world_readable?.

[Source]

     # File lib/pathname.rb, line 893
893:   def world_readable?() FileTest.world_readable?(@path) end

See FileTest.world_writable?.

[Source]

     # File lib/pathname.rb, line 920
920:   def world_writable?() FileTest.world_writable?(@path) end

See FileTest.writable?.

[Source]

     # File lib/pathname.rb, line 917
917:   def writable?() FileTest.writable?(@path) end

See FileTest.writable_real?.

[Source]

     # File lib/pathname.rb, line 923
923:   def writable_real?() FileTest.writable_real?(@path) end

See FileTest.zero?.

[Source]

     # File lib/pathname.rb, line 926
926:   def zero?() FileTest.zero?(@path) end

Private Instance methods

add_trailing_separator(path) -> path

[Source]

     # 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

[Source]

     # 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.

[Source]

     # 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

[Source]

     # 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

[Source]

     # 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

[Source]

     # 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

[Source]

     # 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

[Source]

     # 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

[Source]

     # 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, …]

[Source]

     # 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

[Validate]