Returns whether the entry represented by self exists and is empty:

dir_pn = Pathname('example_dir')
dir_pn.empty?  # => false  # Dir does not exist.
dir_pn.mkdir
dir_pn.empty?  # => true   # Dir exists and is empty.

file_pn = Pathname('example_dir/example.txt')
file_pn.empty? # => false  # File does not exist.
file_pn.write('')
file_pn.empty? # => true   # File exists and is empty.
dir_pn.empty?  # => false  # Dir exists and is not empty.
file_pn.write('foo')
file_pn.empty? # => false  # File exists and is not empty.

file_pn.delete
dir_pn.delete

Returns true if self points to a mountpoint.

The opposite of #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

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

Alias for #+.

Compares the contents of self and other as strings; see String#<=>.

Returns:

• -1 if self's string is smaller than other's string.
• 0 if the two are equal.
• 1 if self's string is larger than other's string.
• nil if other is not a Pathname.

Examples:

Pathname('a')  <=> Pathname('b')  # => -1
Pathname('a')  <=> Pathname('ab') # => -1
Pathname('a')  <=> Pathname('a')  # => 0
Pathname('b')  <=> Pathname('a')  # => 1
Pathname('ab') <=> Pathname('a')  # => 1
Pathname('ab') <=> 'a'            # => nil

Two pathnames that are different may refer to the same entry in the filesystem:

Pathname('lib') <=> Pathname('./lib') # => 1

Returns whether the stored paths in self and other are equal:

pn = Pathname('lib')
pn == Pathname('lib')   # => true
pn == Pathname('./lib') # => false

Returns false if other is not a pathname:

pn == 'lib'             # => false

Alias for #==.

add_trailing_separator(path) -> path

With a block given, yields self, then a new pathname for each successive dirname in the stored path; see File.dirname:

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

With no block given, returns a new ::Enumerator.

Returns a new ::Time object containing the time of the most recent access (read or write) to the entry represented by self; see {File System Timestamps}:

# Work in a temporary directory.
require 'tmpdir'
Dir.mktmpdir do |tmpdirpath|
# A subdirectory therein, and its Pathname.
dirpath = File.join(tmpdirpath, 'subdir')
Dir.mkdir(dirpath)
dir_pn = Pathname(dirpath)
puts "Create directory; establishes atime for directory."
puts "  Directory atime: #{dir_pn.atime}"
sleep(1)

# A file in the subdirectory, and its Pathname.
filepath = File.join(dirpath, 't.txt')
puts "Create file; establishes atime for file, updates atime for directory."
File.write(filepath, 'foo')
file_pn = Pathname(filepath)
puts "  File atime:      #{file_pn.atime}"
puts "  Directory atime: #{dir_pn.atime}"
sleep(1)
puts "Write file; updates atimes for file and directory."
File.write(filepath, 'bar')
puts "  File atime:      #{file_pn.atime}"
puts "  Directory atime: #{dir_pn.atime}"
end

Output:

Create directory; establishes atime for directory.
Directory atime: 2026-05-14 14:36:43 +0100
Create file; establishes atime for file, updates atime for directory.
File atime:      2026-05-14 14:36:44 +0100
Directory atime: 2026-05-14 14:36:44 +0100
Write file; updates atimes for file and directory.
File atime:      2026-05-14 14:36:45 +0100
Directory atime: 2026-05-14 14:36:45 +0100

Returns a new Pathname object containing all or part of the last entry of the path represented by self. Entries are delimited by the value of constant File::SEPARATOR and, if non-nil, the value of constant File::ALT_SEPARATOR.

When suffix is the empty string '', returns all of the last entry:

Pathname.new('foo/bar/baz/bat.txt').basename # => #<Pathname:bat.txt>
Pathname.new('foo/bar/baz').basename         # => #<Pathname:baz>

File::SEPARATOR                              # => "/"
Pathname.new('foo/bar.txt////').basename     # => #<Pathname:bar.txt>
File::ALT_SEPARATOR # => "\\"                # On Windows.
Pathname.new('foo/bar.txt//\\\\//').basename # => #<Pathname:bar.txt>

When suffix is '.*', the last filename extension, if any, is removed:

Pathname.new('foo/bar.txt').basename('.*')     # => #<Pathname:bar>
Pathname.new('foo/bar.txt.old').basename('.*') # => #<Pathname:bar.txt>
Pathname.new('foo/bar').basename('.*')         # => #<Pathname:bar>

When suffix is any string other than '' or '.*', the matching trailing substring, if any, is removed:

Pathname.new('foo/bar.txt').basename('.txt') # => #<Pathname:bar>
Pathname.new('foo/bar.txt').basename('txt')  # => #<Pathname:bar.>
Pathname.new('foo/bar.txt').basename('*')    # => #<Pathname:bar.txt>
Pathname.new('foo/bar.txt').basename('.')    # => #<Pathname:bar.txt>

Behaves like #read, except that the file is opened in binary mode with ASCII-8BIT encoding.

Behaves like #write, except that the file is opened in binary mode with ASCII-8BIT encoding.

Returns a new ::Time object containing the create time of the entry represented by self; see {File System Timestamps}:

#### Work in a temporary directory.
Pathname.mktmpdir do |tmpdirpath|
  # A subdirectory therein, and its Pathname.
  dirpath = File.join(tmpdirpath, 'subdir')
  dir_pn = Pathname(dirpath)
  puts "Create directory; directory birthtime established."
  dir_pn.mkdir
  puts "  Directory birthtime: #{dir_pn.birthtime}"
  sleep(1)

  # A file in the subdirectory, and its Pathname.
  filepath = File.join(dirpath, 't.txt')
  file_pn = Pathname(filepath)
  puts "Create file; file birthtime established; directory birthtime not updated."
  file_pn.write('foo')
  puts "  File birthtime:      #{file_pn.birthtime}"
  puts "  Directory birthtime: #{dir_pn.birthtime}"
  sleep(1)
  puts "Write file; neither birthtime updated."
  file_pn.write('bar')
  puts "  File birthtime:      #{file_pn.birthtime}"
  puts "  Directory birthtime: #{dir_pn.birthtime}"
end

Output:

Create directory; directory birthtime established.
  Directory birthtime: 2026-05-14 23:41:12 +0100
Create file; file birthtime established; directory birthtime not updated.
  File birthtime:      2026-05-14 23:41:13 +0100
  Directory birthtime: 2026-05-14 23:41:12 +0100
Write file; neither birthtime updated.
  File birthtime:      2026-05-14 23:41:13 +0100
  Directory birthtime: 2026-05-14 23:41:12 +0100

Returns whether self represents a path to a block device (i.e., a direct-access device):

Pathname('/dev/nvme0n1').blockdev? # => true
Pathname('/dev/loop0').blockdev?   # => true
Pathname('/dev/tty').blockdev?     # => false
Pathname('/dev/null').blockdev?    # => false
Pathname('nosuch').blockdev?       # => false
Pathname($stdin).blockdev?         # => false

The returned value is OS-dependent; on Windows, almost always false.

Returns whether self represents a path to a character device (i.e., a sequential-access device):

Pathname('/dev/tty').chardev?     # => true
Pathname('/dev/null').chardev?    # => true
Pathname('/dev/nvme0n1').chardev? # => false
Pathname('/dev/loop0').chardev?   # => false
Pathname($stdin).chardev?         # => false
Pathname('nosuch').chardev?       # => false

The returned value is OS-dependent; on Windows, almost always false.

Returns an array of pathnames; each represents a child of the entry represented by self, which must be an existing directory in the underlying file system.

With with_dirnames given as true (the default), each pathname contains the full entry:

Pathname('lib').children.size # => 72
Pathname('lib').children.take(3)
#### => [#<Pathname:lib/bundled_gems.rb>, #<Pathname:lib/bundler>, #<Pathname:lib/bundler.rb>]

With with_dirnames given as false, each pathname contains only the basename of the entry:

Pathname('lib').children(false).take(3)
#### => [#<Pathname:bundled_gems.rb>, #<Pathname:bundler>, #<Pathname:bundler.rb>]

Note that entries . and .. in directory are not actually children, and so are never included in the result.

Changes the mode (i.e., permissions) of the entry represented by self; see {File Permissions}; returns 1:

#### A helper method to make an integer mode display as octal.
def pretty(mode); '0' + (mode & 0777).to_s(8); end

#### Work in a temporary directory.
Pathname.mktmpdir do |tmpdirpath|
  # A subdirectory therein, and its Pathname.
  dirpath = File.join(tmpdirpath, 'subdir')
  dir_pn = Pathname(dirpath)
  dir_pn.mkdir
  # The directory mode.
  puts "Original directory mode: #{pretty(dir_pn.stat.mode)}"
  # Change the directory mode.
  dir_pn.chmod(0777)
  puts "New directory mode:      #{pretty(dir_pn.stat.mode)}"

  # A file in the subdirectory, and its Pathname.
  filepath = File.join(dirpath, 't.txt')
  file_pn = Pathname(filepath)
  # Create the file.
  file_pn.write('foo')
  # The file mode.
  puts "Original file mode:      #{pretty(file_pn.stat.mode)}"
  # Change the file modes.
  file_pn.chmod(0777)
  puts "New file mode:           #{pretty(file_pn.stat.mode)}"
end

Output:

Original directory mode: 0775
New directory mode:      0777
Original file mode:      0664
New file mode:           0777

chop_basename(path) -> [pre-basename, basename] or nil

Changes the owner and group of an entry (directory or file):

#### Work in a temporary directory.
Pathname.mktmpdir do |tmpdirpath|
  # A subdirectory therein, and its Pathname.
  dirpath = File.join(tmpdirpath, 'subdir')
  dir_pn = Pathname(dirpath)
  dir_pn.mkdir
  dir_stat = File.stat(dirpath)
  puts "Original directory owner: #{dir_stat.uid}"
  puts "Original directory group: #{dir_stat.gid}"
  dir_pn.chown(1000, 1000)
  dir_stat = File.stat(dirpath)
  puts "New directory owner:      #{dir_stat.uid}"
  puts "New directory group:      #{dir_stat.gid}"

  # A file in the subdirectory, and its Pathname.
  filepath = File.join(dirpath, 't.txt')
  file_pn = Pathname(filepath)
  # Create the file.
  file_pn.write('foo')
  file_stat = File.stat(filepath)
  puts "Original file owner:      #{file_stat.uid}"
  puts "Original file group:      #{file_stat.gid}"
  file_pn = Pathname(dirpath)
  file_pn.chown(1000, 1000)
  file_stat = File.stat(dirpath)
  puts "New file owner:           #{file_stat.uid}"
  puts "New file group:           #{file_stat.gid}"
end

Output:

Original directory owner: 0
Original directory group: 0
New directory owner:      1000
New directory group:      1000
Original file owner:      0
Original file group:      0
New file owner:           1000
New file group:           1000

Notes:

• On Windows, the owner and group are not changed.
• Only a process with superuser privileges can change the owner of an entry.
• The owner of an entry can change its group to any group to which the owner belongs.
• A nil or -1 owner or group id is ignored.
• The method follows symbolic links to the target entry.

Returns a new Pathname object, "cleaned" of unnecessary separators, single-dot entries, and double-dot entries.

When self is empty, returns a pathname with a single-dot entry:

Pathname('').cleanpath # => {#<}Pathname:.>

Separators

A lone separator is preserved:

Pathname('/').cleanpath # => {#<}Pathname:/>

Multiple trailing separators are removed:

Pathname('foo/////').cleanpath # => {#<}Pathname:foo>
Pathname('foo/').cleanpath     # => {#<}Pathname:foo>

Multiple embedded separators are reduced to a single separator:

Pathname('foo///bar').cleanpath # => {#<}Pathname:foo/bar>

Multiple leading separators are reduced:

#### On Windows, where {File.dirname}('//') == '//'.
Pathname('/////foo').cleanpath # => {#<}Pathname://foo>
Pathname('/////').cleanpath    # => {#<}Pathname://>
#### Otherwise, where {File.dirname}('//') == '/'.
Pathname('/////foo').cleanpath # => {#<}Pathname:/foo>
Pathname('/////').cleanpath    # => {#<}Pathname:/>

Single-Dot Entries

A lone single-dot entry is preserved:

Pathname('.').cleanpath  # => {#<}Pathname:.>

A non-lone single-dot entry, regardless of its location, is removed:

Pathname('foo/././././bar').cleanpath  # => {#<}Pathname:foo/bar>
Pathname('./foo/./././bar').cleanpath  # => {#<}Pathname:foo/bar>
Pathname('foo/./././bar/./').cleanpath # => {#<}Pathname:foo/bar>

Double-Dot Entries

A lone double-dot entry is preserved:

Pathname('..').cleanpath # => {#<}Pathname:..>

When a non-lone double-dot entry is preceded by a named entry, both are removed:

Pathname('foo/..').cleanpath          # => {#<}Pathname:.>
Pathname('foo/../bar').cleanpath      # => {#<}Pathname:bar>
Pathname('foo/../bar/..').cleanpath   # => {#<}Pathname:.>
Pathname('foo/bar/./../..').cleanpath # => {#<}Pathname:.>

When a non-lone double-dot entry is not preceded by a named entry, it is preserved:

Pathname('../..').cleanpath # => {#<}Pathname:../..>

A non-lone meaningless double-dot entry is removed:

Pathname('/..').cleanpath    # => {#<}Pathname:/>
Pathname('/../..').cleanpath # => {#<}Pathname:/>

Symbolic Links

If the path may contain symbolic links, consider give optional argument symlinks as true; the method then uses a more conservative algorithm that avoids breaking symbolic links. This may preserve more double-dot entries than are absolutely necessary, but without accessing the filesystem, this can't be avoided.

Examples:

Pathname('a/').cleanpath           # => {#<}Pathname:a>
Pathname('a/').cleanpath(true)     # => {#<}Pathname:a/>

Pathname('a/.').cleanpath          # => {#<}Pathname:a>
Pathname('a/.').cleanpath(true)    # => {#<}Pathname:a/.>

Pathname('a/./').cleanpath         # => {#<}Pathname:a>
Pathname('a/./').cleanpath(true)   # => {#<}Pathname:a/.>

Pathname('a/b/.').cleanpath        # => {#<}Pathname:a/b>
Pathname('a/b/.').cleanpath(true)  # => {#<}Pathname:a/b/.>

Pathname('a/../.').cleanpath       # => {#<}Pathname:.>
Pathname('a/../.').cleanpath(true) # => {#<}Pathname:a/..>

Pathname('a/b/../../../../c/../d').cleanpath
#### => {#<}Pathname:../../d>
Pathname('a/b/../../../../c/../d').cleanpath(true)
#### => {#<}Pathname:a/b/../../../../c/../d>

Clean the path simply by resolving and removing excess . and .. entries. Nothing more, nothing less.

On Windows, returns the #birthtime.

On other systems, returns a new ::Time object containing the time of the most recent metadata change to the entry represented by self; see {File System Timestamps}:

#### Work in a temporary directory.
Pathname.mktmpdir do |tmpdirpath|
  # A subdirectory therein, and its Pathname.
  dirpath = File.join(tmpdirpath, 'subdir')
  dir_pn = Pathname(dirpath)
  puts "Create directory; directory ctime established."
  dir_pn.mkdir
  puts "  Directory ctime: #{dir_pn.ctime}"
  sleep(1)

  # A file in the subdirectory, and its Pathname.
  filepath = File.join(dirpath, 't.txt')
  file_pn = Pathname(filepath)
  puts "Create file; file ctime established; directory ctime updated."
  file_pn.write('foo')
  puts "  File ctime:      #{file_pn.ctime}"
  puts "  Directory ctime: #{dir_pn.ctime}"
  sleep(1)
  puts "Write file; file ctime updated; directory ctime not updated."
  file_pn.write('bar')
  puts "  File ctime:      #{file_pn.ctime}"
  puts "  Directory ctime: #{dir_pn.ctime}"
  sleep(1)
  puts "Read file; neither ctime not updated."
  file_pn.read
  puts "  File ctime:      #{file_pn.ctime}"
  puts "  Directory ctime: #{dir_pn.ctime}"
end

Output:

Create directory; directory ctime established.
  Directory ctime: 2026-05-20 14:05:05 -0500
Create file; file ctime established; directory ctime updated.
  File ctime:      2026-05-20 14:05:06 -0500
  Directory ctime: 2026-05-20 14:05:06 -0500
Write file; file ctime updated; directory ctime not updated.
  File ctime:      2026-05-20 14:05:07 -0500
  Directory ctime: 2026-05-20 14:05:06 -0500
Read file; neither ctime not updated.
  File ctime:      2026-05-20 14:05:07 -0500
  Directory ctime: 2026-05-20 14:05:06 -0500

Alias for #unlink.

With a block given, yields a new pathname for each successive dirname in the stored path; see File.dirname:

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

With no block given, returns a new Enumerator.

Returns whether the entry represented by self is a directory:

Pathname('/etc').directory?      # => true
Pathname('lib').directory?       # => true
Pathname('README.md').directory? # => false
Pathname('nosuch').directory?    # => false

See File.dirname. Returns all but the last component of the path.

With a block given and with_dirnames given as true (the default), yields a new pathname for each child of the entry represented by self; returns an array of those pathnames:

Pathname('include').each_child {|child| p child }
#### #<Pathname:include/ruby>
#### #<Pathname:include/ruby.h>
#### => [#<Pathname:include/ruby>, #<Pathname:include/ruby.h>]

With a block given and with_dirnames given as false, yields a new pathname for each child of the entry represented by self with its dirname omitted; returns an array of those pathnames:

Pathname('include').each_child(false) {|child| p child }
#### #<Pathname:ruby>
#### #<Pathname:ruby.h>
#### => [#<Pathname:ruby>, #<Pathname:ruby.h>]

Note that entries '.' and '..' are not children.

With no block given, returns a new Enumerator.

With a block given, yields a new pathname for each entry in the entry represented by self; returns nil:

Pathname('include').each_entry {|entry| p entry }
#### #<Pathname:ruby>
#### #<Pathname:..>
#### #<Pathname:ruby.h>
#### #<Pathname:.>
#### => nil

With no block given, returns a new Enumerator.

With a block given, yields each component of the string path:

Pathname('/foo/bar/baz').each_filename {|filename| p filename }
#=> nil

Output:

"foo"
"bar"
"baz"

With no block given, returns a new Enumerator.

With a block given, calls the block with each line from the file represented by self; returns nil:

lines = []
Pathname('COPYING').each_line {|line| lines << line }
lines.take(3)
#### =>
#### ["{日本語}[rdoc-ref:COPYING.ja]\n",
####  "\n",
####  "Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.jp>.\n"]

The lines are read using IO.foreach, all arguments and options are passed to that method; see details at IO.foreach.

With no block given, returns a new Enumerator.

Returns an array of pathnames, one for each entry in the directory represented by self:

Pathname('.').entries.take(5)
#### =>
#### [#<Pathname:.>,
####  #<Pathname:..>,
####  #<Pathname:gc.rb>,
####  #<Pathname:yjit.rb>,
####  #<Pathname:iseq.h>]

Alias for #==.

Returns whether the entry represented by self is executable; calls FileTest#executable? with argument self.to_s:

Pathname('bin/gem').executable?   # => true
Pathname('README.md').executable? # => false

Returns whether the entry represented by self is executable by the real user and group id of the current process; calls FileTest#executable_real? with argument self.to_s:

pn = Pathname('example')
pn.write('')
pn.executable_real? # => false
pn.chmod(0100)
pn.executable_real? # => true

Returns whether the entry represented by self exists:

Pathname('.').exist?         # => true
Pathname('README.md').exist? # => true
Pathname('nosuch').exist?    # => false

Returns a new pathname containing the absolute path for self.

Evaluates a relative path with respect to the directory given by dirpath:

Dir.chdir('/snap')
#### Default dirpath.
Pathname('README').expand_path                  # => #<Pathname:/snap/README>
Pathname('bin').expand_path                     # => #<Pathname:/snap/bin>
Pathname('bin/../var').expand_path              # => #<Pathname:/snap/var>  # Cleaned.
#### Other dirpath.
Pathname('../zip').expand_path('/usr/bin/ruby') # => #<Pathname:/usr/bin/zip>
Dir.chdir('/usr/bin')
Pathname('../../snap').expand_path(__FILE__)    # => #<Pathname:/usr/snap>

Evaluates an absolute path without respect to dirpath:

Pathname('/snap').expand_path                       # => #<Pathname:/snap>
Pathname('/snap').expand_path.expand_path('nosuch') # => #<Pathname:/snap>
Pathname('/snap/../snap').expand_path               # => #<Pathname:/snap>  # Cleaned.

More examples:

{Dir.chdir}('/usr/bin')
Pathname('../../snap').expand_path(__FILE__) # => {#<}Pathname:/usr/snap>
Pathname('../../snap').expand_path           # => {#<}Pathname:/snap>

Returns the filename extension of self -- usually the portion of the string path beginning from the last period:

Pathname('t.rb').extname               # => ".rb"
Pathname('foo.bar.t.rb').extname       # => ".rb"
Pathname('foo/bar/t.rb').extname       # => ".rb"
Pathname('nosuch.txt').extname         # => ".txt"  # Path need not exist.

Returns the entire string when there is no period:

Pathname('foo').extname # => ""

Returns an empty string when the only period is the first character:

Pathname('.irbrc').extname # => ""

Returns an empty string or '.' when #path ends with a period:

Pathname('foo.').extname    # => ""   # On Windows.
Pathname('foo.').extname    # => "."  # Elsewhere.
Pathname('foo....').extname # => ""   # On Windows.
Pathname('foo....').extname # => "."  # Elsewhere.

See FileTest#file?.

See File.fnmatch. Return true if the receiver matches the given pattern.

See File.fnmatch? (same as #fnmatch).

Freezes self, preventing further modifications; see Frozen Objects.

Returns the string type of the object at the path in self:

Pathname('README.md').ftype   # => "file"
Pathname('lib').ftype         # => "directory"
Pathname('/dev/null').ftype   # => "characterSpecial"
Pathname('/dev/loop0').ftype  # => "blockSpecial"

File.mkfifo('/tmp/pipe', 0666)
Pathname('/tmp/pipe').ftype   # => "fifo"

File.symlink('lib', 'lib_link')
Pathname('lib_link').ftype    # => "link"

require 'socket'
UNIXServer.new('/tmp/socket')
Pathname('/tmp/socket').ftype # => "socket"

Returns 'unknown' if the type cannot be determined.

Returns or yields Pathname objects.

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

See Dir.glob. This method uses the base keyword argument of Dir.glob.

See FileTest#grpowned?.

has_trailing_separator?(path) -> bool

Joins the given pathnames onto self to create a new Pathname object. This is effectively the same as using #+ 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

See File.lchmod.

See File.lchown.

See File.lstat.

Update the access and modification times of the file.

Same as #utime, but does not follow symbolic links.

See File.lutime.

See File.link. Creates a hard link.

See File.symlink. Creates a symbolic link.

See Dir.mkdir. Create the referenced directory.

Creates a full path, including any intermediate directories that don't yet exist.

See FileUtils.mkpath and FileUtils.mkdir_p

See File.mtime. Returns last modification time.

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

See Dir.open.

See FileTest#owned?.

Returns the parent directory.

This is same as self + '..'.

See FileTest#pipe?.

(path1, path2) -> path

Reads and returns some or all of the content of the file whose path is self.to_s.

With no arguments given, reads in text mode and returns the entire content of the file:

Pathname.new('t.txt').read
# => "First line\nSecond line\n\nFourth line\nFifth line\n"
Pathname.new('t.ja').read
# => "こんにちは"
Pathname.new('t.dat').read
# => "\xFE\xFF\x99\x90\x99\x91\x99\x92\x99\x93\x99\x94"

On Windows, text mode can terminate reading and leave bytes in the file unread when encountering certain special bytes. Consider using #binread if all bytes in the file should be read.

With argument length given, returns length bytes if available:

Pathname.new('t.txt').read(7)
# => "First l"
Pathname.new('t.ja').read(7)
# => "\xE3\x81\x93\xE3\x82\x93\xE3"
Pathname.new('t.dat').read(7)
# => "\xFE\xFF\x99\x90\x99\x91\x99"

Returns all bytes if length is larger than the files size:

Pathname.new('t.txt').read(700)
# => "First line\r\nSecond line\r\n\r\nFourth line\r\nFifth line\r\n"
Pathname.new('t.ja').read(700)
# => "\xE3\x81\x93\xE3\x82\x93\xE3\x81\xAB\xE3\x81\xA1\xE3\x81\xAF"
Pathname.new('t.dat').read(700)
# => "\xFE\xFF\x99\x90\x99\x91\x99\x92\x99\x93\x99\x94"

With arguments length and offset given, returns length bytes if available, beginning at the given offset:

Pathname.new('t.txt').read(10, 2)
# => "rst line\r\n"
Pathname.new('t.ja').read(10, 2)
# => "\x93\xE3\x82\x93\xE3\x81\xAB\xE3\x81\xA1"
Pathname.new('t.dat').read(10, 2)
# => "\x99\x90\x99\x91\x99\x92\x99\x93\x99\x94"

Returns nil if offset is past the end of the file:

Pathname.new('t.txt').read(10, 200) # => nil

Optional keyword arguments opts specify:

• Open Options.
• {Encoding options}.

See FileTest#readable?.

See FileTest#readable_real?.

See File.readlines. Returns all the lines from the file.

See File.readlink. Read symbolic link.

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.

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.

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.

See File.rename. Rename the file.

See Dir.rmdir. Remove the referenced directory.

See FileTest#setgid?.

See FileTest#setuid?.

See FileTest#size.

See FileTest#size?.

See FileTest#socket?.

See File.split. Returns the #dirname and the #basename in an ::Array.

split_names(path) -> prefix, [name, ...]

See File.stat. Returns a ::File::Stat object.

See FileTest#sticky?.

Return a pathname which is substituted by String#sub.

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

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>

See FileTest#symlink?.

See File.sysopen.

Alias for #to_s.

Return the path as a ::String.

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

Removes the file or directory represented by self, using:

• File.unlink, if self represents a file; returns 1.
• Dir.unlink, if self represents a directory; returns 0.

Examples:

Pathname(Tempfile.create).unlink   # => 1
Pathname(Pathname.mktmpdir).unlink # => 0