class Pathname

Returns a new Pathname object containing the path to the current working directory (equivalent to Pathname.new(Dir.getwd)):

Pathname.getwd # => #<Pathname:/home>

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

Selects filesystem entries based on the given keyword arguments base, flags, and sort; see Filename Globbing.

With no block given, returns an array of pathnames, each based on a selected filesystem entry.

With a block given, calls the block with pathnames, each based on a selected filesystem entry.

# File pathname_builtin.rb, line 2805
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

Creates:

• A temporary directory via Dir.mktmpdir.

• A Pathname object that contains the path to that directory.

With no block given, returns the created pathname; the caller should delete the created directory when it is no longer needed (FileUtils.rm_r is a convenient method for the deletion):

pathname = Pathname.mktmpdir
dirpath = pathname.to_s
Dir.exist?(dirpath) # => true
# Do something with the directory.
require 'fileutils'
FileUtils.rm_r(dirpath)

With a block given, calls the block with the created pathname; on block exit, automatically deletes the created directory and all its contents; returns the block’s exit value:

pathname = Pathname.mktmpdir do |p|
  # Do something with the directory.
  p
end
Dir.exist?(pathname.to_s) # => false

# File lib/pathname.rb, line 147
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

Returns a new Pathname object based on the given path, via File.path(path).dup. the path may be a String, a File, a Dir, or another Pathname; see File.path:

Pathname.new('.')               # => #<Pathname:.>
Pathname.new('/usr/bin')        # => #<Pathname:/usr/bin>
Pathname.new(File.new('LEGAL')) # => #<Pathname:LEGAL>
Pathname.new(Dir.new('.'))      # => #<Pathname:.>
Pathname.new(Pathname.new('.')) # => #<Pathname:.>

# File pathname_builtin.rb, line 385
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

Returns a new Pathname object based on the content of self and other; argument other may be a String, a File, a Dir, or another Pathname:

pn = Pathname('foo')     # => #<Pathname:foo>
pn + 'bar'               # => #<Pathname:foo/bar>
pn + File.new('LEGAL')   # => #<Pathname:foo/LEGAL>
pn + Dir.new('lib')      # => #<Pathname:foo/lib>
pn + Pathname('bar')     # => #<Pathname:foo/bar>

When other specifies a relative path (see relative?), it is combined with self to form a new pathname:

Pathname('/a/b') + 'c' # => #<Pathname:/a/b/c>

Extra component separators ('/') are removed:

Pathname('/a/b/') + 'c' # => #<Pathname:/a/b/c>

Extra current-directory components ('.') are removed:

Pathname('a') + '.' # => #<Pathname:a>
Pathname('.') + 'a' # => #<Pathname:a>
Pathname('.') + '.' # => #<Pathname:.>

Parent-directory components ('..') are:

• Resolved, when possible:

  Pathname('a')      + '..'      # => #<Pathname:.>
  Pathname('a/b')    + '..'      # => #<Pathname:a>
  Pathname('/')      + '../a'    # => #<Pathname:/a>
  Pathname('a')      + '../b'    # => #<Pathname:b>
  Pathname('a/b')    + '../c'    # => #<Pathname:a/c>
  Pathname('a//b/c') + '../d//e' # => #<Pathname:a//b/d//e>
  

• Removed, when not needed:

  Pathname('/') + '..' # => #<Pathname:/>
  

• Retained, when needed:

  Pathname('..') + '..'   # => #<Pathname:../..>
  Pathname('..') + '../a' # => #<Pathname:../../a>
  

When other specifies an absolute path (see absolute?), equivalent to Pathname(other.to_s):

Pathname('/a') + '/b/c' # => #<Pathname:/b/c>

Occurrences of '/', '.', and '..' are preserved:

Pathname('/a') + '//b//c/./../d' # => #<Pathname://b//c/./../d>

This method does not access the file system, so other need not represent an existing (or even a valid) file or directory path:

Pathname('/var') + 'nosuch:ever' # => #<Pathname:/var/nosuch:ever>

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

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

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);
}

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

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

Returns whether self contains an absolute path:

Pathname('/home').absolute? # => true
Pathname('lib').absolute?   # => false

The result is OS-dependent for some paths:

Pathname('C:/').absolute?   # => true   # On Windows.
Pathname('C:/').absolute?   # => false  # Elsewhere.

static VALUE
path_absolute_p(VALUE self)
{
    VALUE path = get_strpath(self);
    const char *ptr = RSTRING_PTR(path);
    rb_len_t len = RSTRING_LEN(path);
    if (len < 1) return Qfalse;
    if (drive_letter) {
        if (len >= 2 && ISALPHA(ptr[0]) && (ptr[1] == ':')) return Qtrue;
    }
    return RBOOL(isdirsep(ptr[0]));
}

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.

# File pathname_builtin.rb, line 837
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

Returns a new Time object containing the access time of the entry at the path in self, as reported by the filesystem; see File System Access Time.

For a file, the access time is established when the file is created, and may be updated with the file content is read:

filepath = '/tmp/t.tmp'
pn = Pathname(filepath)
pn.atime        # Raises Errno::ENOENT: No such file or directory.
pn.write('foo') # Establishes access time.
pn.atime        # => 2026-10-04 15:15:10.628255551 -0500
pn.read         # Updates access time.
pn.atime        # => 2026-10-04 15:15:19.770249225 -0500
pn.delete       # Clean up.

For a directory, the access time is established when the directory is created, and may be updated when its entries are read:

dirpath = '/tmp/dir'
pn = Pathname(dirpath)
pn.atime   # Raises Errno::ENOENT: No such file or directory.
pn.mkdir   # Establishes access time.
pn.atime   # => 2026-10-04 15:19:49.957848452 -0500
pn.entries # Updates access time.
pn.atime   # => 2026-10-04 15:20:05.677814625 -0500
pn.delete  # Clean up.

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

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>

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

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

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

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

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

Returns a new Time object containing the creation time of the entry at the path in self; see File System Timestamps:

filepath = '/tmp/t.tmp'
pn = Pathname(filepath)
pn.birthtime # Raises Errno::ENOENT: No such file or directory.
pn.write('foo')
pn.birthtime # => 2026-10-05 13:45:54.459480484 -0500
pn.delete    # Clean up.

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

Returns whether the path in self points 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 filesystem-dependent; returns false on Windows or MacOS.

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

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 filesystem-dependent; on Windows, always false.

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

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.

# File pathname_builtin.rb, line 1018
def children(with_directory=true)
  with_directory = false if @path == '.'
  result = Dir.children(@path)
  if with_directory
    result.map! {|e| self.class.new(File.join(@path, e))}
  else
    result.map! {|e| self.class.new(e)}
  end
  result
end

Changes the mode of the entry at the path in self; returns 1. See Filesystem Modes and especially Filesystem Modes.

These examples use a Filesystem Modes, mode, that displays a mode both in octal digits and in characters:

dirpath = 'doc/foo'
dir_pn = Pathname(dirpath)
dir_pn.mkdir         # Create directory.
mode(dirpath)        # => "040775 drwxrwxr-x"
filepath = File.join(dirpath, 't.tmp')
file_pn = Pathname(filepath)
file_pn.write('bar') # Create file.
mode(filepath)       # => "100664 -rw-rw-r--"
file_pn.chmod(0755)  # Change file mode.
mode(filepath)       # => "100755 -rwxr-xr-x"
dir_pn.chmod(0644)   # Change directory mode.
mode(dirpath)        # => "040644 drw-r--r--"
dir_pn.rmtree        # Clean up.

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

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

# Super user; all privileges.
Process.uid                    # => 0
Process.gid                    # => 0

# Pathname for a (non-existent) directory.
dir_pn = Pathname('doc/foo')   # => #<Pathname:doc/foo>
# Create the directory; fetch original owner and group.
dir_pn.mkdir
dir_stat = dir_pn.stat
dir_stat.uid                   # => 0
dir_stat.gid                   # => 0
# Change owner; fetch current owner and group.
dir_pn.chown(1000, 1000)
dir_stat = dir_pn.stat
dir_stat.uid                   # => 1000
dir_stat.gid                   # => 1000

Pathname for a (non-existent) file in the directory.
file_pn = dir_pn.join('t.tmp') # => #<Pathname:doc/foo/t.tmp>
# Create the directory; fetch original owner and group.
file_pn.write('foo')
file_stat = file_pn.stat
file_stat.uid                  # => 0
file_stat.gid                  # => 0
# Change owner; fetch current owner and group.
file_pn.chown(1000, 1000)
file_stat = file_pn.stat
file_stat.uid                  # => 1000
file_stat.gid                  # => 1000
# Clean up.
file_pn.delete
dir_pn.rmdir

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.

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

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>

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

On Windows, returns the birthtime for the path in self.

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:

# A directory and its Pathname.
dir_path = '/tmp/dir'
dir_pn = Pathname(dir_path)
# Create directory; establishes directory ctime.
dir_pn.mkdir
dir_pn.ctime                     # => 2026-10-05 16:36:52.738405306 -0500
# A file therein and its Pathname.
file_path = dir_pn.join('t.tmp') # => #<Pathname:/tmp/dir/t.tmp>
file_pn = Pathname(file_path)
# Create file; establishes file ctime; updates directory ctime.
file_pn.write('foo')
file_pn.ctime                    # => 2026-10-05 16:38:35.076588258 -0500
dir_pn.ctime                     # => 2026-10-05 16:38:35.076588258 -0500
# Write file; updates file ctime; does not update directory ctime..
file_pn.write('bar')
file_pn.ctime                    # => 2026-10-05 16:39:57.842776244 -0500
dir_pn.ctime                     # => 2026-10-05 16:38:35.076588258 -0500
# Read file; updates neither ctime.
file_pn.read
file_pn.ctime                    # => 2026-10-05 16:39:57.842776244 -0500
dir_pn.ctime                     # => 2026-10-05 16:38:35.076588258 -0500
dir_pn.rmtree                    # Clean up.

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

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.

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

Returns whether the entry represented by self is a directory:

Pathname('/etc').directory?        # => true
Pathname('/etc/passwd').directory? # => false
Pathname($stdin).directory?        # => false
Pathname('nosuch').directory?      # => false

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

Returns a new pathname whose path is all but the last component of the path in self:

Pathname('/usr/lib/linux').basename # => #<Pathname:linux>
Pathname('/usr').basename           # => #<Pathname:usr>
Pathname('/').basename              # => #<Pathname:/>
Pathname('lib/').basename           # => #<Pathname:lib>
Pathname('nosuch').basename         # => #<Pathname:nosuch>

Components are delimited by File::SEPARATOR and, if non-nil, File::ALT_SEPARATOR.

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

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.

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

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.

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

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.

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

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.

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

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

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

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>]

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

Returns whether the entry represented by self exists and is executable by the effective owner/group of the current process.

Pathname('/bin/ruby').executable?   # => true
Pathname('/etc').executable?        # => true
Pathname('/etc/passwd').executable? # => false
Pathname('nosuch').executable?      # => false

Note that some filesystem settings may cause this method to return true even though the entry is not executable by the effective owner/group.

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

Like Pathname#executable?, but checks against the real owner/group instead of the effective owner/group.

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

Returns whether the entry represented by self exists:

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

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

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>

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

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.

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

Returns whether the entry at the path in self exists and is a regular file; see Pathname#ftype:

Pathname('/etc/passwd').file? # => true
Pathname('/etc').file?        # => false
Pathname('nosuch').file?      # => false

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

With a block given, performs a depth-first traversal of the path in self; calls the block with each found path:

paths = []
Pathname('lib').find {|path| paths << path }
paths.size  # => 909
paths.take(3)
# =>
# [#<Pathname:lib>,
#  #<Pathname:lib/English.gemspec>,
#  #<Pathname:lib/English.rb>]

When self contains '.', the found paths omit the leading './':

paths = []
Dir.chdir('lib') do
  Pathname('.').find {|path| paths << path }
end
paths.take(3)
# # =>
# [#<Pathname:.>,
#  #<Pathname:English.gemspec>,
#  #<Pathname:English.rb>]

This method calls method Find.find; therefore method Find.prune may be used in the block:

files = []
Pathname('.').find do |path|
  Find.prune if File.basename(path) == 'test'
  next unless File.file?(path) && File.extname(path) == '.rb'
  files << path
end
files.size # => 6690
files.take(3)
# # =>
# [#<Pathname:KNOWNBUGS.rb>,
#  #<Pathname:array.rb>,
#  #<Pathname:ast.rb>]

Raises an exception if the path in self cannot be read.

When keyword argument ignore_error is given as true (the default), certain exceptions during traversal are ignored (i.e., silently rescued): Errno::ENOENT, Errno::EACCES, Errno::ENOTDIR, Errno::ELOOP, Errno::ENAMETOOLONG, Errno::EINVAL; when given as false, no exceptions are rescued.

Note that these exceptions may be ignored only in Pathname#find traversal code; an exception raised before traversal begins, or raised while in the block is not ignored. Each of the calls below raises an Errno::ENOENT exception that is not ignored:

Pathname('nosuch').find { }
Pathname('lib').find {|entry| raise Errno::ENOENT }

With no block given, returns a new Enumerator.

# File lib/pathname.rb, line 74
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

Returns whether string pattern matches against the string path in self, under the control of the given flags; see Filename Matching.

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

Same as fnmatch.

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

Freezes self, preventing further modifications; see Frozen Objects.

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

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

• 'file'.

• 'directory'.

• 'characterSpecial'.

• 'blockSpecial'.

• 'fifo'.

• 'link'.

• 'socket'.

Examples:

Pathname('/etc/passwd').ftype # => "file"
Pathname('/etc').ftype        # => "directory"
Pathname('/dev/null').ftype   # => "characterSpecial"
Pathname('/dev/loop0').ftype  # => "blockSpecial"

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

File.symlink('/etc/passwd', '/tmp/link')
Pathname('/tmp/link').ftype   # => "link"

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

File.delete('/tmp/link', '/tmp/pipe', '/tmp/socket') # Clean up.

Returns 'unknown' if the type cannot be determined.

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

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.

# File pathname_builtin.rb, line 2820
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

Returns false on Windows.

On other systems, returns whether the effective group id of the calling process is the owner of the entry at the path in self:

# => "/tmp/t.tmp"
File.write(filepath, 'foo')
Pathname(filepath).grpowned?      # => true
Pathname('/etc').grpowned?        # => false
Pathname('/etc/passwd').grpowned? # => false
Pathname('nosuch').grpowned?      # => false
File.delete(filepath)             # Clean up.

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

With no arguments, returns self.

With arguments, joins the given components to the string path in self with character '/'; returns a new pathname containing the joined string:

pn = Pathname('foo')                      # => #<Pathname:foo>
# String arguments.
pn.join('bar')                            # => #<Pathname:foo/bar>
pn.join(*%w[bar baz bat])                 # => #<Pathname:foo/bar/baz/bat>
# Pathname arguments.
pn.join(Pathname('bar'), Pathname('baz')) # => #<Pathname:foo/bar/baz>

# File pathname_builtin.rb, line 978
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

Not supported on Linux or Windows (raises NotImplementedError).

When supported: like Pathname#chmod, but does not follow symbolic links, and therefore changes the mode of the entry specified by self:

“‘ruby file = Pathname(’t.tmp’) file.write(”) File.symlink(‘t.tmp’, ‘link’) symlink = Pathname(‘link’) file.lstat.mode.to_s(8) # => “100644” symlink.lstat.mode.to_s(8) # => “120755” symlink.lchmod(0777) file.lstat.mode.to_s(8) # => “100644” symlink.lstat.mode.to_s(8) # => “120777” file.delete symlink.delete ““

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

Not supported on some platforms (raises exception).

Calling process must have superuser privileges.

When supported: like Pathname#chown, but does not follow symbolic links, and therefore changes the ownership of the entry at the path in self:

# Super user; all privileges.
Process.uid # => 0
Process.gid # => 0
# Create regular file and symbolic link to it.
File.write('t.tmp', '')
File.symlink('t.tmp', 'link')
# Capture original statuses.
fstat0 = File.stat('t.tmp')  # Method ::stat; status of file.
lstat0 = File.lstat('link')  # Method ::lstat; status of link.
# Original user ids and group ids.
fstat0.uid # => 0
fstat0.gid # => 0
lstat0.uid # => 0
lstat0.gid # => 0
# Change ids for link.
Pathname('link').lchown(1000, 1000)
# Capture new statuses.
fstat1 = File.stat('t.tmp')
lstat1 = File.lstat('link')
# User id and group id for file not changed.
fstat1.uid # => 0
fstat1.gid # => 0
# User id and group id for link changed.
p lstat1.uid # => 1000
p lstat1.gid # => 1000
# Clean up.
File.delete('t.tmp')
File.delete('link')

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

Returns a new File::Stat object for the entry at the path in self. Unlike Pathname#stat, does not follow symbolic links; therefore the returned object contains information for that entry, regardless of whether it is a symbolic link:

file_pn = Pathname('/etc/passwd')
link_pn = Pathname('/tmp/foo')
link_pn.make_symlink(file_pn)
# Method lstat does not follow the symlink, so the birthtimes are different.
file_pn.lstat.birthtime # => 2025-06-10 11:10:47.358999941 -0500
link_pn.lstat.birthtime # => 2026-09-23 14:12:00.978946471 -0500
# Method stat follows the symlink, so the birthtimes are the same.
file_pn.stat.birthtime  # => 2025-06-10 11:10:47.358999941 -0500
link_pn.stat.birthtime  # => 2025-06-10 11:10:47.358999941 -0500
link_pn.delete          # Clean up.

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

Like Pathname#utime, but does not follow symbolic links, and therefore changes the times of the entry in self, regardless of whether it is a symbolic link:

# Create a file and a link to it.
file_path = 't.tmp'
link_path = 'link'
File.write(file_path, '')
File.symlink(file_path, link_path)
# Take snapshots of both.
file_stat = File.stat(file_path)
link_stat = File.lstat(link_path)
# Fetch access times and modification times of both.
file_stat.atime # => 2026-06-15 11:03:29.600373255 -0500
file_stat.mtime # => 2026-06-15 11:03:22.247352211 -0500
link_stat.atime # => 2026-06-15 11:03:29.251372254 -0500
link_stat.mtime # => 2026-06-15 11:03:26.66436484 -0500
# Update access time and modification time of the link.
pn = Pathname(link_path)
time = Time.now # => 2026-06-15 11:08:07.384287523 -0500
pn.lutime(time, time)
# Take fresh snapshots of both.
file_stat = File.stat(file_path)
link_stat = File.lstat(link_path)
# Fetch access time and modification time of file (not changed).
file_stat.atime # => 2026-06-15 11:03:29.600373255 -0500
file_stat.mtime # => 2026-06-15 11:03:22.247352211 -0500
# Fetch access time and modification time of link (changed).
link_stat.atime # => 2026-06-15 11:08:29.847301399 -0500
link_stat.mtime # => 2026-06-15 11:08:07.384287523 -0500
# Clean up.
File.delete(file_path)
File.delete(link_path)

Arguments atime and mtime may be Time objects (as above).

Either or both may be integers; when an integer i is passed, Time.new(i) is used.

Either or both may be nil, in which case Time.now is used.

See File System Timestamps.

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

Not available on some systems.

Creates a new entry at the path in self for the existing entry at path using a hard link:

File.write('doc/t.tmp', 'foo')
Pathname('lib/u.tmp').make_link('doc/t.tmp')
File.read('lib/u.tmp') # => "foo"
File.write('lib/u.tmp', 'bar')
File.read('doc/t.tmp') # => "bar"
File.delete('doc/t.tmp')
File.read('lib/u.tmp') # => "bar"
File.delete('lib/u.tmp')

Raises an exception if the entry at the path in self exists.

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

Not supported on some platforms.

Creates a symbolic link at the path in self to the entry at target_path:

file_pn = Pathname('/etc/passwd')
link_pn = Pathname('/tmp/foo')
link_pn.make_symlink(file_pn)
link_pn.readlink             # => #<Pathname:/etc/passwd>
file_pn.read == link_pn.read # => true

If the entry at target_path is itself a symbolic link, that link is not followed:

link2_pn = Pathname('/tmp/bar')
link2_pn.make_symlink(link_pn)
link2_pn.readlink             # => #<Pathname:/tmp/foo>
link2_pn.read == file_pn.read # => true
# Clean up.
link_pn.delete
link2_pn.delete

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

Creates a directory in the underlying file system at the path in self, with the given permissions; see File Permissions:

Dir.mkdir('foo')
File.stat(Dir.new('foo')).mode.to_s(8) # => "40775"
Dir.mkdir('bar', 0644)
File.stat(Dir.new('bar')).mode.to_s(8) # => "40644"
Dir.rmdir('foo')
Dir.rmdir('bar')

Argument permissions is ignored on Windows.

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

Creates a directory at the path in self; creates intermediate directories as needed:

pn = Pathname('foo/bar/baz')
pn.directory? # => false
pn.mkpath     # Creates directories 'foo', 'foo/bar', 'foo/bar/baz'.
pn.directory? # => true
pn.rmtree     # Clean up.

When mode is given, directories are created with those permissions; see File Permissions. The permissions for already-existing directories are not changed.

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

  stack = []
  until File.directory?(path) || (parent = File.dirname(path)) == path
    stack.push path
    path = parent
  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

Returns whether entry at the path in self is a mountpoint:

Pathname('/').mountpoint?      # => true
Pathname('/etc').mountpoint?   # => false
Pathname('nosuch').mountpoint? # => false

# File pathname_builtin.rb, line 725
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 a Time object containing the time of the most recent modification to the entry represented by self; see File System Timestamps:

# A directory and its Pathname.
dir_path = 'doc/foo'
dir_pn = Pathname(dir_path)
# Create directory; directory mtime established.
dir_pn.mkdir
dir_pn.mtime  # => 2026-06-28 16:38:02.675780521 -0500
# A file therein and its Pathname.
file_path = dir_pn.join('t.tmp')
file_pn = Pathname(file_path)
# Create file; file mtime established; directory mtime updated.
file_pn.write('foo')
dir_pn.mtime  # => 2026-06-28 16:41:23.107750483 -0500
file_pn.mtime # => 2026-06-28 16:41:23.107750483 -0500
# Modify file; file mtime updated; directory mtime unchanged.
file_pn.write('bar')
dir_pn.mtime  # => 2026-06-28 16:41:23.107750483 -0500
file_pn.mtime # => 2026-06-28 16:42:48.869163049 -0500
# Clean up.
dir_pn.rmtree

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

Creates a File object for the entry at the path in self and opens the file; see File.new for details.

With a block given, calls the block with the file; closes the file on block exit:

Pathname('README.md').open {|file| file.size } # => 3469

With no block given, returns the file:

file = Pathname('README.md').open # => #<File:README.md>
file.size                         # => 3469
file.close

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

Creates a Dir object dir for the directory at the path represented by self; opens dir.

With a block given, calls the block with dir; on block exit, closes dir and returns the block’s return value:

pn = Pathname('.')
pn.opendir {|dir| dir.entries.take(3) }
# => ["README.md", "html", ".git"]

With no block given, returns the open directory dir:

dir = pn.opendir    # => #<Dir:.>
dir.entries.take(3) # => ["README.md", "html", ".git"]
dir.close

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

Returns whether the entry at the path represented by self exists and is owned by the user of the current process:

pn = Pathname('doc/t.tmp')
pn.write('foo')
pn.owned?               # => true
pn.delete               # Clean up.
pn = Pathname('doc/tmp')
pn.mkdir
pn.owned?               # => true
pn.rmdir                # Clean up.
Pathname('/etc').owned? # => false

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

Returns a new pathname representing the parent directory of the entry represented by self:

pn = Pathname('/etc/passwd') # => #<Pathname:/etc/passwd>
pn.parent                    # => #<Pathname:/etc>

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

Returns whether the entry at the path in self is a pipe:

Pathname('.').pipe? # => false
path = '/tmp/foo'
File.mkfifo(path)
pn = Pathname(path) # => #<Pathname:/tmp/foo>
pn.pipe?            # => true
pn.delete           # Clean up.

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

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.

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

Returns whether the entry at the path in self exists and is readable by the owner and group of the current process; see Permissions:

pn = Pathname('/tmp/secret.txt')
pn.write('foo')
pn.readable?                 # => true
pn.chmod(0o000)
pn.readable?                 # => false
pn.delete                    # Clean up.
Pathname('nosuch').readable? # => false

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

Like readable?, but checks against the real user and group ids instead of the effective ids.

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

Returns an array of all lines read from the source at the path in self, which must be the path to a file.

Examples here use a file defined at IO Example Files.

With no arguments given, parses lines from the file at the given path, as determined by the default line separator, and returns those lines in an array:

pn = Pathname('t.txt')
ppn.readlines
# => ["First line\n", "Second line\n", "\n", "Fourth line\n", "Fifth line\n"]

With argument sep given, parses lines as determined by that line separator (see IO Line Separator):

pn.readlines('li')
# => ["First li", "ne\nSecond li", "ne\n\nFourth li", "ne\nFifth li", "ne\n"]
pn.readlines('')  # Special "paragraphs" separator value.
# => ["First line\nSecond line\n\n", "Fourth line\nFifth line\n"]
pn.readlines(nil) # Special "slurp" separator value.
# => ["First line\nSecond line\n\nFourth line\nFifth line\n"]

With argument limit given, parses lines as determined by the default line separator and the given line-length limit (see IO Line Separator and IO Line Limit):

pn.readlines(7)
# => ["First l", "ine\n", "Second ", "line\n", "\n", "Fourth ", "line\n", "Fifth l", "ine\n"]

With arguments sep and limit given, combines the two behaviors (see IO Line Separator and Line Limit).

Optional keyword arguments options specify:

• IO Open Options.

• Encoding options.

• IO Line Input Options.

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

Returns a new pathname containing the path stored in the symbolic link entry at the path stored in self:

file_pn = Pathname('doc/maintainers.md')
link_pn = Pathname('/tmp/link')
link_pn.make_symlink(file_pn)
link_pn.readlink # => #<Pathname:doc/maintainers.md>
link_pn.delete   # Clean up.

Raises Errno::EINVAL if the path in self is not the path to a symbolic link.

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

Returns a new pathname containing the real (absolute) pathname of the path in self; the new path is the path in the actual filesystem, and does not contain useless dot-entries ('.' or '..') or symbolic links:

Pathname('/etc/./passwd/../../var').realdirpath
# => #<Pathname:/var>

Only the last component of the new path may be nonexistent:

Pathname('/etc/./passwd/../../var/nosuch').realdirpath
# => #<Pathname:/var/nosuch>
Pathname('/etc/./passwd/../../var/nosuch/nosuch').realdirpath
# Raises Errno::ENOENT: No such file or directory.

Method realpath is similar, but requires all components to exist.

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

Returns a new pathname containing the real (absolute) pathname of the path in self; the new path is the path in the actual filesystem, and does not contain useless dot-entries ('.' or '..') or symbolic links:

Pathname('/etc/./passwd/../../var').realpath
# => #<Pathname:/var>

All components of the new path must exist:

Pathname('/etc/./passwd/../../var/nosuch').realpath
# Raises Errno::ENOENT: No such file or directory.

Method realdirpath is similar, but does not require the last component to exist.

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

Returns whether self contains a relative path:

Pathname('lib').relative?   # => true
Pathname('/home').relative? # => false

The result is OS-dependent for some paths:

Pathname('C:/').relative?   # => false # On Windows.
Pathname('C:/').relative?   # => true  # Elsewhere.

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

Returns a pathname containing the relative filesystem path from the given source to the path in self; source must be a directory path or a pathname containing a directory path:

Pathname('.').relative_path_from('doc/language')   # => #<Pathname:../..>
Pathname('doc/language').relative_path_from('.')   # => #<Pathname:doc/language>
Pathname('doc').relative_path_from('doc/language') # => #<Pathname:..>

The paths need not exist:

Pathname('nosuch').relative_path_from('nosuch/foo/bar/baz')
# => #<Pathname:../../..>

The two paths must be either both absolute or both relative:

Pathname('/var').relative_path_from('/etc') # => #<Pathname:../var>
Pathname('/var').relative_path_from('doc')  # Raises ArgumentError
Pathname('doc').relative_path_from('/etc')  # Raises ArgumentError

Raises an exception if there is no such relative path:

Pathname('foo').relative_path_from('..')    # Raises ArgumentError

# File pathname_builtin.rb, line 1102
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

Moves the entry at the path in self to the given new_path, which may be either a path or another pathname.

Does not follow symbolic links; if the entry is a symlink, the link itself is renamed.

The examples below use two temporary directories:

pn_srcdir = Pathname('/tmp/src/')  # => #<Pathname:/tmp/src/>
pn_dstdir = Pathname('/tmp/dst/')  # => #<Pathname:/tmp/dst/>
pn_srcdir.mkdir
pn_dstdir.mkdir

The entry to be renamed may be a file:

# Create source pathname and file.
pn_srcfile = pn_srcdir.join('t.tmp') # => #<Pathname:/tmp/src/t.tmp>
pn_srcfile.write('foo')
# Create destination file pathname.
pn_dstfile = pn_dstdir.join('u.tmp') # => #<Pathname:/tmp/dst/u.tmp>
# Rename source file as destination file.
pn_srcfile.rename(pn_dstfile)
pn_srcfile.exist?                    # => false
pn_dstfile.exist?                    # => true
pn_srcfile                           # => #<Pathname:/tmp/src/t.tmp> # Not changed.
pn_dstfile.delete                    # Clean up.

The entry to be renames may be a symbolic link:

# Create source pathname and file.
pn_srcfile = pn_srcdir.join('t.tmp') # => #<Pathname:/tmp/src/t.tmp>
pn_srcfile.write('foo')
# Create link pathname and link.
pn_lnkfile = pn_dstdir.join('u.tmp') pn_lnkfile = pn_dstdir.join('u.tmp')
pn_lnkfile.make_symlink(pn_srcfile)
pn_lnkfile.readlink                  # => #<Pathname:/tmp/src/t.tmp>
pn_renamed = Pathname('lib/v.tmp')   # => #<Pathname:lib/v.tmp>
pn_lnkfile.rename(pn_renamed)        # Symlink not followed.
pn_renamed.symlink?                  # => true
pn_renamed.readlink                  # => #<Pathname:/tmp/src/t.tmp>
pn_lnkfile                           # => #<Pathname:/tmp/dst/u.tmp>  # Not changed.
# Clean up.
pn_renamed.delete
pn_srcfile.delete

The entry to be renamed may be a directory:

pn_renamed = Pathname('/tmp/foo') # => #<Pathname:/tmp/foo>
pn_dstdir.rename(pn_renamed)

Clean up:

pn_renamed.rmtree                 # => #<Pathname:/tmp/foo>
pn_srcdir.rmtree                  # => #<Pathname:/tmp/src/>

Raises SystemCallError if the entry cannot be renamed.

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

Deletes the directory at the path in self; returns 0:

pn = Pathname('doc/foo')
pn.mkdir
pn.rmdir

Raises an exception if the entry at the path in self is not a directory, or if the directory is not empty.

Use method rmtree to delete the entire filetree at the path.

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

Deletes the entire filetree at the path in self; returns self:

dir_pn = Pathname('foo/bar/baz') # => #<Pathname:foo/bar/baz>
dir_pn.mkpath                    # Create 'baz' and intermediate directories.
file_pn = dir_pn.join('t.tmp')   # => #<Pathname:foo/bar/baz/t.tmp>
file_pn.write('foo')             # Create file at nested directory 'baz'.
Pathname('foo').rmtree           # Delete the entire tree at directory 'foo'.
Pathname('foo').exist?           # => false

Use method rmdir to delete a single (empty) directory.

See FileUtils.rm_rf for keyword arguments.

# File lib/pathname.rb, line 108
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

Returns whether the path in self points to a root directory.

On a non-Windows system, a root directory path is one whose name begins with one or more slash characters (‘’/‘):

Pathname('/').root?       # => true
Pathname('////').root?    # => true
Pathname('/usr').root?    # => false
Pathname('foo').root?     # => false

Does not resolve dot directories:

Pathname('/usr/.').root?  # => false
Pathname('/usr/..').root? # => false

On a Windows system, a root directory path is one whose name begins as above, or with a device letter followed by a colon character (':') and one or more slash characters (‘’/‘):

Pathname('/').root?      # => true
Pathname('////').root?   # => true
Pathname('C:/').root?    # => true
Pathname('C:////').root? # => true
Pathname('c:/').root?    # => true
Pathname('H:/').root?    # => true
Pathname('C:/m').root?   # => false
Pathname('C:').root?     # => false

static VALUE
path_root_p(VALUE self)
{
    VALUE path = get_strpath(self);
    if (RSTRING_LEN(path) == 0) return Qfalse;
    const char *ptr = RSTRING_PTR(path), *end = RSTRING_END(path);
    rb_encoding *enc = rb_enc_get(path);
    const char *base = rb_enc_path_skip_prefix_root(ptr, end, enc);
    return RBOOL(base == end);
}

Returns whether the setgid bit is set in the special bits for the entry at the path in self:

pn = Pathname('doc/t.tmp')
pn.write('foo')
mode = pn.stat.mode.to_s(8) # => "100664"
pn.setgid?                  # => false
pn.chmod(0o2644)            # Set the bit.
mode = pn.stat.mode.to_s(8) # => "102644"
pn.setgid?                  # => true
pn.delete                   # Clean up.

On Windows, the bit is never set; the method always returns false.

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

Returns whether the setuid bit is set in the special bits for the entry at the path in self:

pn = Pathname('doc/t.tmp')
pn.write('foo')
mode = pn.stat.mode.to_s(8) # => "100664"
pn.setuid?                  # => false
pn.chmod(0o4644)            # Set the bit.
mode = pn.stat.mode.to_s(8) # => "104644"
pn.setuid?                  # => true
pn.delete                   # Clean up.

On Windows, the bit is never set; the method always returns false.

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

Returns the size in bytes of the entry at the path in self:

Pathname('doc/maintainers.md').size # => 14900  # Regular file.
Pathname('doc/syntax/').size        # => 4096   # Directory.

Raises an exception if the entry does not exist.

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

Returns the size in bytes of the entry at the path in self if the entry exists and has non-zero size, nil otherwise:

# Regular file.
pn = Pathname('/tmp/t.tmp')
pn.write('foo')
pn.size? # => 3     # Non-zero size.
pn.write('')
pn.size? # => nil   # Zero size.
pn.delete           # Clean up.
pn.size? # => nil   # Non-existent.
# Directory.
pn = Pathname('/tmp/foo/')
pn.mkdir
pn.size? # => 4096  # Non-zero size.
pn.delete           # Clean up.
pn.size? # => nil   # Non-existent.

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

Returns whether entry at the path in self is a socket:

require 'socket'
sock_path = '/tmp/socket'
sock_pn = Pathname(sock_path)
sock_pn.exist?  # => false
sock_pn.socket? # => false
server = UNIXServer.new(sock_path)
sock_pn.exist?  # => true
sock_pn.socket? # => true
# Clean up.
server.close
sock_pn.delete
file_path = '/etc/passwd'
file_pn = Pathname(file_path)
file_pn.file?   # => true
file_pn.socket? # => false

Returns false on Windows.

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

Returns a 2-element array of pathnames containing the dirname and basename of the path in self:

Pathname('doc/maintainers.md').split # => [#<Pathname:doc>, #<Pathname:maintainers.md>]
Pathname('doc/').split               # => [#<Pathname:.>, #<Pathname:doc>]
Pathname('README.md').split          # => [#<Pathname:.>, #<Pathname:README.md>]
Pathname('/tmp/nosuch').split        # => [#<Pathname:/tmp>, #<Pathname:nosuch>]
Pathname('@@##$$/%%^^&&').split      # => [#<Pathname:@@##$$>, #<Pathname:%%^^&&>]

# File pathname_builtin.rb, line 2200
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

Returns a new File::Stat object for the entry at the path in self. Unlike Pathname#lstat, does follow symbolic links; therefore if the entry is a symbolic link, the returned object contains information for the target entry, not the symbolic link:

file_pn = Pathname('/etc/passwd')
link_pn = Pathname('/tmp/foo')
link_pn.make_symlink(file_pn)
# Method stat follows the symlink, so the birthtimes are the same.
file_pn.stat.birthtime  # => 2025-06-10 11:10:47.358999941 -0500
link_pn.stat.birthtime  # => 2025-06-10 11:10:47.358999941 -0500
# Method lstat does not follow the symlink, so the birthtimes are different.
file_pn.lstat.birthtime # => 2025-06-10 11:10:47.358999941 -0500
link_pn.lstat.birthtime # => 2026-09-23 14:12:00.978946471 -0500
link_pn.delete          # Clean up.

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

Returns whether the sticky bit is set in the special bits for the entry at the path in self:

pn = Pathname('/tmp/t.tmp')
pn.write('foo')
pn.stat.mode.to_s(8) # => "100664"
pn.sticky?           # => false
pn.chmod(01644)      # Set sticky bit.
pn.stat.mode.to_s(8) #  => "101644"
pn.sticky?           # => true
pn.delete # => 1     # Clean up.

Returns false on Windows.

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

Returns a new pathname whose path is the path in self, after the specified substitutions.

Argument pattern may be a string or a Regexp; argument replacement may be a string or a hash.

Varying types for the argument values makes this method very versatile.

Below are some simple examples; for many more related examples (using strings, not pathnames), see Substitution Methods.

With arguments pattern and string replacement given, replaces the first matching substring with the given replacement string:

pn = Pathname('abracadabra.txt') # => #<Pathname:abracadabra.txt>
pn.sub('bra', 'xyzzy')           # => #<Pathname:axyzzycadabra.txt>
pn.sub(/bra/, 'xyzzy')           # => #<Pathname:axyzzycadabra.txt>
pn.sub('nope', 'xyzzy')          # => #<Pathname:abracadabra.txt>

With arguments pattern and hash replacement given, replaces the first matching substring with a value from the given replacement hash, or removes it:

h = {'a' => 'A', 'b' => 'B', 'c' => 'C'}
pn.sub('b', h) # => #<Pathname:aBracadabra.txt>
pn.sub(/b/, h) # => #<Pathname:aBracadabra.txt>
pn.sub(/d/, h) # => #<Pathname:abracaabra.txt>  # 'd' removed.

With argument pattern and a block given, calls the block with the first matching substring; replaces that substring with the block’s return value:

pn.sub('b') {|match| match.upcase } # => #<Pathname:aBracadabra.txt>
pn.sub(/X/) {|match| match.upcase } # => #<Pathname:abracadabra.txt>

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));
}

Returns a new pathname whose path is the path in self, after specified changes:

Pathname('t.tmp').sub_ext('.txt') # => #<Pathname:t.txt>     # Extension replaced.
Pathname('temp').sub_ext('.txt')  # => #<Pathname:temp.txt>  # Extension added.
Pathname('t.tmp').sub_ext('')     # => #<Pathname:t>         # Extension removed.

static VALUE
path_sub_ext(VALUE self, VALUE repl)
{
    VALUE path = get_strpath(self);
    rb_len_t len = RSTRING_LEN(path);
    const char *ptr = RSTRING_PTR(path);
    const char *ext = ruby_enc_find_extname(ptr, &len, rb_enc_get(path));
    if (len > 0) {
        RUBY_ASSERT(ext, "should point the last dot");
        path = rb_str_subseq(path, 0, ext - ptr);
    }
    else {
        /* no dot or dotted file */
        path = rb_str_dup(path);
    }
    path = rb_str_append(path, repl);
    return rb_class_new_instance(1, &path, rb_obj_class(self));
}

Returns whether the entry at the path in self is a symbolic link:

file_pn = Pathname('/etc/passwd')
link_pn = Pathname('/tmp/foo')
link_pn.make_symlink(file_pn)
file_pn.symlink? # => false
link_pn.symlink? # => true
link_pn.delete   # Clean up.

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

Opens the file at the path in self with the given mode and permissions; returns the integer file descriptor.

If the file is to be readable, it must exist; if the file is to be writable and does not exist, it is created with the given permissions:

pn = Pathname('doc/t.tmp')
pn.write('foo')
fd = pn.sysopen             # => 5
IO.new(fd).close
fd = pn.sysopen('w')        # => 5
IO.new(fd).close
fd = pn.sysopen('r', 0o644) # => 5
IO.new(fd).close
pn.delete

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

Returns a copy of the string path in self:

Pathname('nosuch/foo/bar').to_s # => "nosuch/foo/bar"

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

Adjusts the size of file at the path in self to the given size:

pn = Pathname('/tmp/t.tmp')
pn.write('0123456789')
pn.read   # => "0123456789"
pn.truncate(5)
pn.read   # => "01234"

Pads with null characters if necessary:

pn.truncate(10)
pn.read   # => "01234\u0000\u0000\u0000\u0000\u0000"
pn.delete # Clean up.

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

Removes the entry (hard link) at the path in self; returns 0 if a directory, 1 otherwise:

pn_file = Pathname('/tmp/t.txt')
pn_file.write('foo')
pn_file.unlink # => 1
pn_dir = Pathname('/tmp/foo')
pn_dir.mkdir
pn_dir.unlink  # => 0

If the removed hard link is the last one associated the inode, also removes the inode; otherwise, not. See hard link.

Does not follow symbolic links; if the entry is a symbolic link, removes the entry itself (not the link target).

pn_file = Pathname('/tmp/t.txt')
pn_link = Pathname('/tmp/link')
pn_file.write('foo')
pn_link.make_symlink(pn_file)
pn_link.unlink # => 1
pn_file.exist? # => true  # Link was not followed.
pn_file.unlink # => 1

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

For the entry at the path in self, updates its access time to the given atime and its modification time to the given mtime; each given time may be a Time object, an integer representing a time, or nil (meaning Time.now):

pn = Pathname('/tmp/t.tmp')
pn.write('foo')
pn.atime  # => 2026-09-30 09:00:02.465505713 -0500
pn.mtime  # => 2026-09-30 09:00:02.465505713 -0500
time = Time.now
pn.utime(time, time)
pn.atime  # => 2026-09-30 09:00:23.848023883 -0500
pn.mtime  # => 2026-09-30 09:00:23.848023883 -0500
pn.utime(0, 0)
pn.atime  # => 1969-12-31 18:00:00 -0600
pn.mtime  # => 1969-12-31 18:00:00 -0600
pn.utime(nil, nil)
pn.atime  # => 2026-09-30 09:01:02.492202169 -0500
pn.mtime  # => 2026-09-30 09:01:02.492202169 -0500
pn.delete # Clean up.

Follows symbolic links; use Pathname#lutime to update the times for a symbolic link.

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

If the entry at the path in self exists and is readable by others, returns the integer permissions for the entry; otherwise, returns nil:

pn = Pathname('/tmp/t.tmp')
pn.world_readable?                    # => nil    # Does not exist.
pn.write('foo')                                   # Create file.
pn.world_readable?.to_s(8)            # => "664"  # World-readable.
pn.chmod(0o000)                                   # Change to unreadable.
pn.world_readable?                    # => nil    # Not readable.
pn.delete                                         # Clean up.
Pathname('.').world_readable?.to_s(8) # => "775"  # Directory.

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

If the entry at the path in self exists and is writable by others, returns the integer permissions for the entry; otherwise, returns nil:

pn = Pathname('/tmp/t.tmp')
pn.world_writable?                        # => nil    # Non-existent.
pn.write('foo')                                       # Create file.
pn.world_writable?                        # => nil    # Not world-writable.
pn.chmod(0o777)                                       # Make world-writable.
pn.world_writable?.to_s(8)                # => "511"  # World-writable.
pn.delete                                             # Clean up.
Pathname('/tmp').world_writable?.to_s(8)  # => "777"  # Directory.

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

Returns whether entry at the path in self exists and is writable by the effective owner and group of the current process:

pn = Pathname('/tmp/secret.txt')
pn.writable?                # => false  # Non-existent.
pn.write('foo')                         # Create the file.
pn.writable?                # => true   # Writable.
pn.chmod(0o000)                         # Make non-writable.
pn.writable?                # => false  # Not writable.
pn.delete                               # Clean up.
Pathname('/etc/').writable? # => false  # Directory.

Note that filesystem security features may cause this method to return true even when the entry is not writable by the effective owner and group.

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

Like Pathname#writable?, but checks against the real owner and group instead of the effective owner and group.

Note that filesystem security features may cause this method to return true even when the entry at the path in self is not writable by the real owner and group.

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

Opens the file at self.to_s, writes the given data to it, and closes the file; returns the number of bytes written.

With only argument data given, writes the given data to the file:

path = 't.tmp'
pn = Pathname.new(path)
pn.write('foo') # => 3
File.read(path) # => "foo"

If offset is zero (the default), the file is overwritten:

pn.write('bar')
File.read(path) # => "bar"

If offset in within the file content, the file is partly overwritten:

pn.write('foobarbaz')
pn.write('BAR', 3)
File.read(path) # => "fooBARbaz"

If offset is outside the file content, the file is padded with null characters "\u0000":

pn.write('bat', 12)
File.read(path) # => "fooBARbaz\u0000\u0000\u0000bat"

Optional keyword arguments opts specify:

• Open Options.

• Encoding options.

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

Returns whether the entry at the path in self exists and has size zero.

The entry may be a file:

pn = Pathname('/tmp/t.tmp')
pn.write('foo')
pn.zero?                # => false
pn.truncate(0) pn.zero? # => true
pn.delete               # Clean up.

The entry may be a directory:

dir_pn = Pathname('/tmp/foo')
dir_pn.mkdir
dir_pn.children.size       # => 0
# Size is filesystem-dependent; may or may not be zero.
dir_pn.size                # => 4096
dir_pn.zero?               # => false
file_pn = dir_pn / 't.tmp' # => #<Pathname:/tmp/foo/t.tmp>
file_pn.write('foo')       # Add a file.
dir_pn.children.size       # => 1
dir_pn.size                # => 4096
dir_pn.zero?               # => false
dir_pn.rmtree

The entry may be neither of the above:

Pathname('nosuch').zero?   # => false

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