class Pathname - Documentation for Ruby 4.1
Description: class Pathname: pathname. Tanaka Akira <akr@m17n.
Keywords: ruby,class,Pathname

🔍

No recent searches

# class Pathname

# pathname.rb

Object-Oriented `Pathname` Class

Author

  Tanaka Akira <akr@m17n.org>

Documentation

  Author and Gavin Sinclair

For documentation, see class `Pathname`.

A Pathname object contains a string directory path or filepath; it does not represent a corresponding actual file or directory – which in fact may or may not exist.

A Pathname object is immutable (except for method `freeze`).

A pathname may be relative or absolute:

    Pathname.new('lib')            # => #<Pathname:lib>
    Pathname.new('/usr/local/bin') # => #<Pathname:/usr/local/bin>

## About the Examples

Many examples here use these variables:

    # English text with newlines.
    text = <<~EOT
      First line
      Second line

      Fourth line
      Fifth line
    EOT

    # Japanese text.
    japanese = 'こんにちは'

    # Binary data.
    data = "\u9990\u9991\u9992\u9993\u9994"

    # Text file.
    File.write('t.txt', text)

    # File with Japanese text.
    File.write('t.ja', japanese)

    # File with binary data.
    f = File.new('t.dat', 'wb:UTF-16')
    f.write(data)
    f.close

## Convenience Methods

The class provides all functionality from class `File` and module `FileTest`, along with some functionality from class `Dir` and module `FileUtils`.

Here’s an example string path and corresponding Pathname object:

    path = 'lib/fileutils.rb'
    pn = Pathname.new(path) # => #<Pathname:lib/fileutils.rb>

Each of these method pairs (Pathname vs. File) gives exactly the same result:

    pn.size               # => 83777
    File.size(path)       # => 83777

    pn.directory?         # => false
    File.directory?(path) # => false

    pn.read.size          # => 81074
    File.read(path).size# # => 81074

Each of these method pairs gives similar results, but each Pathname method returns a more versatile Pathname object, instead of a string:

    pn.dirname          # => #<Pathname:lib>
    File.dirname(path)  # => "lib"

    pn.basename         # => #<Pathname:fileutils.rb>
    File.basename(path) # => "fileutils.rb"

    pn.split            # => [#<Pathname:lib>, #<Pathname:fileutils.rb>]
    File.split(path)    # => ["lib", "fileutils.rb"]

Each of these methods takes a block:

    pn.open do |file|
      p file
    end
    File.open(path) do |file|
      p file
    end

The outputs for each:

    #<File:lib/fileutils.rb (closed)>
    #<File:lib/fileutils.rb (closed)>

Each of these methods takes a block:

    pn.each_line do |line|
      p line
      break
    end
    File.foreach(path) do |line|
      p line
      break
    end

The outputs for each:

    "# frozen_string_literal: true\n"
    "# frozen_string_literal: true\n"

## More Methods

Here is a sampling of other available methods:

    p1 = Pathname.new('/usr/lib')  # => #<Pathname:/usr/lib>
    p1.absolute?                   # => true
    p2 = p1 + 'ruby/4.0'           # => #<Pathname:/usr/lib/ruby/4.0>
    p3 = p1.parent                 # => #<Pathname:/usr>
    p4 = p2.relative_path_from(p3) # => #<Pathname:lib/ruby/4.0>
    p4.absolute?                   # => false
    p5 = Pathname.new('.')         # => #<Pathname:.>
    p6 = p5 + 'usr/../var'         # => #<Pathname:usr/../var>
    p6.cleanpath                   # => #<Pathname:var>
    p6.realpath                    # => #<Pathname:/var>
    p6.children.take(2)
    # => [#<Pathname:usr/../var/local>, #<Pathname:usr/../var/spool>]

## Breakdown of functionality

### Core methods

These methods are effectively manipulating a `String`, because that’s all a path is. None of these access the file system except for `mountpoint?`, `children`, `each_child`, `realdirpath` and `realpath`.

- +

- `join`

- `parent`

- `root?`

- `absolute?`

- `relative?`

- `relative_path_from`

- `each_filename`

- `cleanpath`

- `realpath`

- `realdirpath`

- `children`

- `each_child`

- `mountpoint?`

### `File` status predicate methods

These methods are a facade for FileTest:

- `blockdev?`

- `chardev?`

- `directory?`

- `executable?`

- `executable_real?`

- `exist?`

- `file?`

- `grpowned?`

- `owned?`

- `pipe?`

- `readable?`

- `world_readable?`

- `readable_real?`

- `setgid?`

- `setuid?`

- `size`

- `size?`

- `socket?`

- `sticky?`

- `symlink?`

- `writable?`

- `world_writable?`

- `writable_real?`

- `zero?`

### `File` property and manipulation methods

These methods are a facade for File:

- `each_line`(*args, &block)

- `read(*args)`

- `binread(*args)`

- `readlines(*args)`

- `sysopen(*args)`

- `write(*args)`

- `binwrite(*args)`

- `atime`

- `birthtime`

- `ctime`

- `mtime`

- `chmod(mode)`

- `lchmod(mode)`

- `chown(owner, group)`

- `lchown(owner, group)`

- `fnmatch(pattern, *args)`

- `fnmatch?(pattern, *args)`

- `ftype`

- `make_link(old)`

- `open`(*args, &block)

- `readlink`

- `rename(to)`

- `stat`

- `lstat`

- `make_symlink(old)`

- `truncate(length)`

- `utime(atime, mtime)`

- `lutime(atime, mtime)`

- `basename(*args)`

- `dirname`

- `extname`

- `expand_path(*args)`

- `split`

### Directory methods

These methods are a facade for Dir:

- `Pathname.glob(*args)`

- `Pathname.getwd` / `Pathname.pwd`

- `rmdir`

- `entries`

- `each_entry`(&block)

- `mkdir(*args)`

- `opendir(*args)`

### Utilities

These methods are a mixture of `Find`, `FileUtils`, and others:

- `find`(&block)

- `mkpath`

- `rmtree`

- `unlink` / `delete`

## Method documentation

As the above section shows, most of the methods in `Pathname` are facades. The documentation for these methods generally just says, for instance, “See `FileTest.writable?`”, as you should be familiar with the original method anyway, and its documentation (e.g. through `ri`) will contain more information. In some cases, a brief description will follow.

### Constants

ABSOLUTE_PATH

  `Regexp` that matches an absolute path.

SEPARATOR_LIST

  Separator list string.

SEPARATOR_PAT

  `Regexp` that matches a separator.

VERSION

  The version string.

### Public Class Methods

getwd → new_pathname
Source

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

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

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

Also aliased as: pwd
glob(patterns, **kwargs) → array_of_pathnames
glob(patterns, **kwargs) {|pathname| ... } → nil
Source

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

Calls `Dir.glob(patterns, **kwargs)`, which yields or returns entry names; see `Dir.glob`.

Required argument `patterns` is a string pattern or an array of string patterns; note that these patterns are not regexps.

Keyword arguments `**kwargs` are passed through to `Dir.glob`; see the documentation there.

With no block given, returns an array of Pathname objects; each is `Pathname.new(entry_name)` for an entry name returned by `Dir.glob`.

    Pathname.glob('*').take(3)
    # => [#<Pathname:BSDL>, #<Pathname:CONTRIBUTING.md>, #<Pathname:COPYING>]
    Pathname.glob(['o*', 'a*']).take(3)
    # => [#<Pathname:object.c>, #<Pathname:aclocal.m4>, #<Pathname:addr2line.c>]

With a block given, calls the block with each pathname `Pathname.new(entry_name)`, where each `entry_name` is a Pathname object created by the value yielded by `Dir.glob`.

    a = []
    Pathname.glob(['o*', 'a*']) {|pathname| a << pathname }
    a.take(3)
    # => [#<Pathname:object.c>, #<Pathname:aclocal.m4>, #<Pathname:addr2line.c>]

Optional keyword argument `base` is of particular interest. When it is given, its value specifies the base directory for the pathnames; each pattern string specifies entries relative to the base directory:

    Pathname.glob('*', base: 'lib').take(2)
    # => [#<Pathname:English.gemspec>, #<Pathname:English.rb>]
    Pathname.glob('*', base: 'lib/bundler').take(2)
    # => [#<Pathname:build_metadata.rb>, #<Pathname:bundler.gemspec>]

Note that the base directory is not prepended to the entry names in the result.

mktmpdir → new_pathname
mktmpdir {|pathname| ... } → object
Source

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

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

new(path) → new_pathname
Source

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

pwd
Alias for: getwd

### Public Instance Methods

self + other → new_pathname
Source

    # File pathname_builtin.rb, line 838
    def +(other)
      other = Pathname.new(other) unless Pathname === other
      Pathname.new(plus(@path, other.path))
    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.new('foo') # => #<Pathname:foo>
    pn + 'bar'               # => #<Pathname:foo/bar>
    pn + File.new('LEGAL')   # => #<Pathname:foo/LEGAL>
    pn + Dir.new('lib')      # => #<Pathname:foo/lib>
    pn + Pathname.new('bar') # => #<Pathname:foo/bar>

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

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

Extra component separators (`'/'`) are removed:

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

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

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

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

- Resolved, when possible:

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

- Removed, when not needed:

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

- Retained, when needed:

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

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

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

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

    Pathname.new('/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.new('/var') + 'nosuch:ever' # => #<Pathname:/var/nosuch:ever>

Also aliased as: /
/
Alias for: +
self <=> other → -1, 0, 1, or nil
Source

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

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.new('a')  <=> Pathname.new('b')      # => -1
    Pathname.new('a')  <=> Pathname.new('ab')     # => -1
    Pathname.new('a')  <=> Pathname.new('a')      # => 0
    Pathname.new('b')  <=> Pathname.new('a')      # => 1
    Pathname.new('ab') <=> Pathname.new('a')      # => 1
    Pathname.new('ab') <=> 'a'                    # => nil

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

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

self == other → true or false
Source

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

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

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

Returns `false` if `other` is not a pathname:

    pn == 'lib'                 # => false

Also aliased as: ===, eql?
===
Alias for: ==
absolute? → true or false
Source

    # File pathname_builtin.rb, line 678
    def absolute?
      ABSOLUTE_PATH.match? @path
    end

Returns whether `self` contains an absolute path:

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

OS-dependent for some paths:

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

ascend {|entry| ... } → nil
ascend → new_enumerator
Source

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

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

    Pathname.new('/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`.

atime → new_time
Source

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

Returns a new `Time` object containing the time of the most recent access (read or write) to the entry represented by `self`:

    filepath = 't.tmp'
    pn = Pathname.new(filepath)
    File.exist?(filepath) # => false
    pn.atime              # Raises Errno::ENOENT: No such file or directory
    File.write(filepath, 'foo')
    pn.atime              # => 2026-03-22 13:49:44.5165608 -0500
    File.read(filepath)
    pn.atime              # => 2026-03-22 13:49:57.5359349 -0500
    File.delete(filepath)

    dirpath = 'tmp'
    Dir.mkdir(dirpath)
    pn = Pathname.new(dirpath)
    pn.atime            # => 2026-03-31 11:46:35.4813492 -0500
    Dir.empty?(dirname) # => true
    pn.atime            # => 2026-03-31 11:51:10.1210092 -0500
    Dir.delete(dirpath)

See File System Timestamps.

basename(path, suffix = '') → new_pathname
Source

    # File pathname_builtin.rb, line 1308
    def basename(...) self.class.new(File.basename(@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>

binread (...)
Source

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

See `File.binread`. Returns all the bytes from the file, or the first `N` if specified.

binwrite (...)
Source

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

Writes `contents` to the file, opening it in binary mode.

See `File.binwrite`.

birthtime → new_time
Source

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

Returns a new `Time` object containing the create time of the entry represented by `self`:

    filepath = 't.tmp'
    pn = Pathname.new(filepath)
    pn.birthtime   # Raises Errno::ENOENT: No such file or directory
    file = File.open(filepath, 'w')
    pn.birthtime   # => 2026-04-14 16:14:47.494846 -0500
    file.birthtime # => 2026-04-14 16:14:47.494846 -0500
    file.write('foo')
    pn.birthtime   # => 2026-04-14 16:14:47.494846 -0500
    file.close
    pn.birthtime   # => 2026-04-14 16:14:47.494846 -0500
    File.delete(filepath)
    pn.birthtime   # Raises Errno::ENOENT: No such file or directory

See File System Timestamps.

blockdev? ()
Source

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

See `FileTest.blockdev?`.

chardev? ()
Source

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

See `FileTest.chardev?`.

children (with_directory=true)
Source

    # File pathname_builtin.rb, line 932
    def children(with_directory=true)
      with_directory = false if @path == '.'
      result = []
      Dir.foreach(@path) {|e|
        next if e == '.' || e == '..'
        if with_directory
          result << self.class.new(File.join(@path, e))
        else
          result << self.class.new(e)
        end
      }
      result
    end

Returns the children of the directory (files and subdirectories, not recursive) as an array of `Pathname` objects.

By default, the returned pathnames will have enough information to access the files. If you set `with_directory` to `false`, then the returned pathnames will contain the filename only.

For example:

    pn = Pathname("/usr/lib/ruby/1.8")
    pn.children
        # -> [ Pathname:/usr/lib/ruby/1.8/English.rb,
               Pathname:/usr/lib/ruby/1.8/Env.rb,
               Pathname:/usr/lib/ruby/1.8/abbrev.rb, ... ]
    pn.children(false)
        # -> [ Pathname:English.rb, Pathname:Env.rb, Pathname:abbrev.rb, ... ]

Note that the results never contain the entries `.` and `..` in the directory because they are not children.

chmod (mode)
Source

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

See `File.chmod`. Changes permissions.

chown (owner, group)
Source

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

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

cleanpath(symlinks = false) → new_pathname
Source

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

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

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

    Pathname.new('').cleanpath # => #<Pathname:.>

Separators

A lone separator is preserved:

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

Non-lone trailing separators are removed:

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

Multiple embedded separators are reduced to a single separator:

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

Multiple leading separators are reduced:

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

Single-Dot Entries

A lone single-dot entry is preserved:

    Pathname.new('.').cleanpath  # => #<Pathname:.>

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

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

Double-Dot Entries

A lone double-dot entry is preserved:

    Pathname.new('..').cleanpath # => #<Pathname:..>

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

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

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

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

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

    Pathname.new('/..').cleanpath    # => #<Pathname:/>
    Pathname.new('/../..').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.new('a/').cleanpath           # => #<Pathname:a>
    Pathname.new('a/').cleanpath(true)     # => #<Pathname:a/>

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

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

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

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

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

ctime ()
Source

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

See `File.ctime`. Returns last (directory entry, not file) change time.

delete ()
Alias for: unlink
descend () { |v| ... }
Source

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

Iterates over and yields a new `Pathname` object for each element in the given path in descending order.

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

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

Returns an `Enumerator` if no block was given.

    enum = Pathname.new("/usr/bin/ruby").descend
      # ... do stuff ...
    enum.each { |e| ... }
      # yields Pathnames /, /usr, /usr/bin, and /usr/bin/ruby.

It doesn’t access the filesystem.

directory? ()
Source

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

See `FileTest.directory?`.

dirname ()
Source

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

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

each_child (with_directory=true, &b)
Source

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

Iterates over the children of the directory (files and subdirectories, not recursive).

It yields `Pathname` object for each child.

By default, the yielded pathnames will have enough information to access the files.

If you set `with_directory` to `false`, then the returned pathnames will contain the filename only.

    Pathname("/usr/local").each_child {|f| p f }
    #=> #<Pathname:/usr/local/share>
    #   #<Pathname:/usr/local/bin>
    #   #<Pathname:/usr/local/games>
    #   #<Pathname:/usr/local/lib>
    #   #<Pathname:/usr/local/include>
    #   #<Pathname:/usr/local/sbin>
    #   #<Pathname:/usr/local/src>
    #   #<Pathname:/usr/local/man>

    Pathname("/usr/local").each_child(false) {|f| p f }
    #=> #<Pathname:share>
    #   #<Pathname:bin>
    #   #<Pathname:games>
    #   #<Pathname:lib>
    #   #<Pathname:include>
    #   #<Pathname:sbin>
    #   #<Pathname:src>
    #   #<Pathname:man>

Note that the results never contain the entries `.` and `..` in the directory because they are not children.

See `Pathname#children`

each_entry () { |pathname| ... }
Source

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

Iterates over the entries (files and subdirectories) in the directory. It yields a `Pathname` object for each entry.

This method has existed since 1.8.1.

each_filename () { |filename| ... }
Source

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

Iterates over each component of the path.

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

Returns an `Enumerator` if no block was given.

    enum = Pathname.new("/usr/bin/ruby").each_filename
      # ... do stuff ...
    enum.each { |e| ... }
      # yields "usr", "bin", and "ruby".

each_line (...) { |line| ... }
Source

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

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

This method has existed since 1.8.1.

empty? ()
Source

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

Tests the file is empty.

See Dir#empty? and `FileTest.empty?`.

entries ()
Source

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

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

eql?
Alias for: ==
executable? ()
Source

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

See `FileTest.executable?`.

executable_real? ()
Source

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

See `FileTest.executable_real?`.

exist? ()
Source

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

See `FileTest.exist?`.

expand_path (...)
Source

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

See `File.expand_path`.

extname ()
Source

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

See `File.extname`. Returns the file’s extension.

file? ()
Source

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

See `FileTest.file?`.

find (ignore_error: true) { |pathname| ... }
Source

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

Iterates over the directory tree in a depth first manner, yielding a `Pathname` for each file under “this” directory.

Note that you need to require ‘pathname’ to use this method.

Returns an `Enumerator` if no block is given.

Since it is implemented by the standard library module `Find`, `Find.prune` can be used to control the traversal.

If `self` is `.`, yielded pathnames begin with a filename in the current directory, not `./`.

See `Find.find`

fnmatch (pattern, ...)
Source

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

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

fnmatch? (pattern, ...)
Source

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

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

freeze ()
Source

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

Freze self.

Calls superclass method `Object#freeze`
ftype ()
Source

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

See `File.ftype`. Returns “type” of file (“file”, “directory”, etc).

glob (*args, **kwargs) { |pathname| ... }
Source

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

grpowned? ()
Source

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

See `FileTest.grpowned?`.

join (*args)
Source

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

Joins the given pathnames onto `self` to create a new `Pathname` object. This is effectively the same as using `Pathname#+` to append `self` and all arguments sequentially.

    path0 = Pathname.new("/usr")                # Pathname:/usr
    path0 = path0.join("bin/ruby")              # Pathname:/usr/bin/ruby
        # is the same as
    path1 = Pathname.new("/usr") + "bin/ruby"   # Pathname:/usr/bin/ruby
    path0 == path1
        #=> true

lchmod (mode)
Source

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

See `File.lchmod`.

lchown (owner, group)
Source

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

See `File.lchown`.

lstat ()
Source

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

See `File.lstat`.

lutime (atime, mtime)
Source

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

Update the access and modification times of the file.

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

See `File.lutime`.

make_link (old)
Source

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

See `File.link`. Creates a hard link.

make_symlink (old)
Source

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

See `File.symlink`. Creates a symbolic link.

mkdir (...)
Source

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

See `Dir.mkdir`. Create the referenced directory.

mkpath (mode: nil)
Source

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

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

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

See `FileUtils.mkpath` and `FileUtils.mkdir_p`

mountpoint? ()
Source

    # File pathname_builtin.rb, line 644
    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 `true` if `self` points to a mountpoint.

mtime ()
Source

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

See `File.mtime`. Returns last modification time.

open (...) { |file| ... }
Source

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

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

opendir () { |dir| ... }
Source

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

See `Dir.open`.

owned? ()
Source

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

See `FileTest.owned?`.

parent ()
Source

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

Returns the parent directory.

This is same as `self + '..'`.

pipe? ()
Source

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

See `FileTest.pipe?`.

read(length = nil, offset = 0, **opts) → string or nil
Source

    # File pathname_builtin.rb, line 1106
    def read(...) File.read(@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.

readable? ()
Source

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

See `FileTest.readable?`.

readable_real? ()
Source

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

See `FileTest.readable_real?`.

readlines (...)
Source

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

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

readlink ()
Source

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

See `File.readlink`. Read symbolic link.

realdirpath (...)
Source

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

Returns the real (absolute) pathname of `self` in the actual filesystem.

Does not contain symlinks or useless dots, `..` and `.`.

The last component of the real pathname can be nonexistent.

realpath (...)
Source

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

Returns the real (absolute) pathname for `self` in the actual filesystem.

Does not contain symlinks or useless dots, `..` and `.`.

All components of the pathname must exist when this method is called.

relative? ()
Source

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

The opposite of `Pathname#absolute?`

It returns `false` if the pathname begins with a slash.

    p = Pathname.new('/im/sure')
    p.relative?
        #=> false

    p = Pathname.new('not/so/sure')
    p.relative?
        #=> true

relative_path_from (base_directory)
Source

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

Returns a relative path from the given `base_directory` to the receiver.

If `self` is absolute, then `base_directory` must be absolute too.

If `self` is relative, then `base_directory` must be relative too.

This method doesn’t access the filesystem. It assumes no symlinks.

`ArgumentError` is raised when it cannot find a relative path.

Note that this method does not handle situations where the case sensitivity of the filesystem in use differs from the operating system default.

rename (to)
Source

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

See `File.rename`. Rename the file.

rmdir ()
Source

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

See `Dir.rmdir`. Remove the referenced directory.

rmtree (noop: nil, verbose: nil, secure: nil)
Source

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

Recursively deletes a directory, including all directories beneath it.

Note that you need to require ‘pathname’ to use this method.

See `FileUtils.rm_rf`

root? ()
Source

    # File pathname_builtin.rb, line 661
    def root?
      chop_basename(@path) == nil && SEPARATOR_PAT.match?(@path)
    end

Predicate method for root directories. Returns `true` if the pathname consists of consecutive slashes.

It doesn’t access the filesystem. So it may return `false` for some pathnames which points to roots such as `/usr/..`.

setgid? ()
Source

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

See `FileTest.setgid?`.

setuid? ()
Source

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

See `FileTest.setuid?`.

size ()
Source

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

See `FileTest.size`.

size? ()
Source

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

See `FileTest.size?`.

socket? ()
Source

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

See `FileTest.socket?`.

split ()
Source

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

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

stat ()
Source

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

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

sticky? ()
Source

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

See `FileTest.sticky?`.

sub (*args)
Source

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

Return a pathname which is substituted by `String#sub`.

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

sub_ext (repl)
Source

    # File pathname_builtin.rb, line 336
    def sub_ext(repl)
      ext = File.extname(@path)

      # File.extname("foo.bar:stream") returns ".bar" on NTFS and not ".bar:stream"
      # (see ruby_enc_find_extname()).
      # The behavior of Pathname#sub_ext is to replace everything
      # from the start of the extname until the end of the path with repl.
      unless @path.end_with?(ext)
        ext = @path[@path.rindex(ext)..]
      end

      self.class.new(@path.chomp(ext) + repl)
    end

Return a pathname with `repl` added as a suffix to the basename.

If self has no extension part, `repl` is appended.

    Pathname.new('/usr/bin/shutdown').sub_ext('.rb')
        #=> #<Pathname:/usr/bin/shutdown.rb>

symlink? ()
Source

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

See `FileTest.symlink?`.

sysopen (...)
Source

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

See `File.sysopen`.

to_path ()

`to_path` is implemented so `Pathname` objects are usable with `File.open`, etc.

Alias for: to_s
to_s ()
Source

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

Return the path as a `String`.

Also aliased as: to_path
truncate (length)
Source

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

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

unlink ()
Source

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

Removes a file or directory, using `File.unlink` or `Dir.unlink` as necessary.

Also aliased as: delete
utime (atime, mtime)
Source

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

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

world_readable? ()
Source

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

See `FileTest.world_readable?`.

world_writable? ()
Source

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

See `FileTest.world_writable?`.

writable? ()
Source

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

See `FileTest.writable?`.

writable_real? ()
Source

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

See `FileTest.writable_real?`.

write(data, offset = 0, **opts) → nonnegative_integer
Source

    # File pathname_builtin.rb, line 1153
    def write(...) File.write(@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.

zero? ()
Source

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

See `FileTest.zero?`.