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 whether entry at the path in self is a mountpoint:

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

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.

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

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

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 creation time of the entry at the path in self; seeFile 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.

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.

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.

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 of the entry at the path in self; returns 1. See Filesystem Modes and especially Setting a Mode.

These examples use a helper method, 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.

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

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.

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 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; seeFile 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.

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('/etc/passwd').directory? # => false
Pathname($stdin).directory?        # => false
Pathname('nosuch').directory?      # => false

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.

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)
#### =>
#### ["<a href='COPYING.ja'>日本語</a>\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 exists and isexecutable 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.

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

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.

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

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

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

Same as #fnmatch.

Freezes self, preventing further modifications; see Frozen Objects.

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.

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.

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.

has_trailing_separator?(path) -> bool

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>

Not supported on Linux or Windows (raises ::NotImplementedError).

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

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

Not supported on some platforms (raises exception).

Calling process must have superuser privileges.

When supported: like Pathname#chown, but does not followsymbolic 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')

Returns a new ::File::Stat object for the entry at the path in self. Unlike #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.

Like #utime, but does not followsymbolic 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.

Not available on some systems.

Creates a new entry at the path in self for the existing entry at #path using ahard 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.

Not supported on some platforms.

Creates asymbolic 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

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.

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.

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

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

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

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

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>

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.

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

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

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

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

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 atIO 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 (seeIO 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 (seeIO Line Separator andIO 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 (seeIO Line Separator and Line Limit).

Optional keyword arguments options specify:

• IO Open Options.
• Encoding options.
• IO Line Input Options.