🔍

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

`Pathname` represents the name of a file or directory on the filesystem, but not the file itself.

The pathname depends on the Operating System: Unix, Windows, etc. This library works with pathnames of local OS, however non-Unix pathnames are supported experimentally.

A `Pathname` can be relative or absolute. It’s not until you try to reference the file that it even matters whether the file exists or not.

`Pathname` is immutable. It has no method for destructive update.

The goal of this class is to manipulate file path information in a neater way than standard Ruby provides. The examples below demonstrate the difference.

All functionality from `File`, `FileTest`, and some from `Dir` and `FileUtils` is included, in an unsurprising way. It is essentially a facade for all of these, and more.

## Examples

### Example 1: Using `Pathname`

    require 'pathname'
    pn = Pathname.new("/usr/bin/ruby")
    size = pn.size              # 27662
    isdir = pn.directory?       # false
    dir  = pn.dirname           # Pathname:/usr/bin
    base = pn.basename          # Pathname:ruby
    dir, base = pn.split        # [Pathname:/usr/bin, Pathname:ruby]
    data = pn.read
    pn.open { |f| _ }
    pn.each_line { |line| _ }

### Example 2: Using standard Ruby

    pn = "/usr/bin/ruby"
    size = File.size(pn)        # 27662
    isdir = File.directory?(pn) # false
    dir  = File.dirname(pn)     # "/usr/bin"
    base = File.basename(pn)    # "ruby"
    dir, base = File.split(pn)  # ["/usr/bin", "ruby"]
    data = File.read(pn)
    File.open(pn) { |f| _ }
    File.foreach(pn) { |line| _ }

### Example 3: Special features

    p1 = Pathname.new("/usr/lib")   # Pathname:/usr/lib
    p2 = p1 + "ruby/1.8"            # Pathname:/usr/lib/ruby/1.8
    p3 = p1.parent                  # Pathname:/usr
    p4 = p2.relative_path_from(p3)  # Pathname:lib/ruby/1.8
    pwd = Pathname.pwd              # Pathname:/home/gavin
    pwd.absolute?                   # true
    p5 = Pathname.new "."           # Pathname:.
    p5 = p5 + "music/../articles"   # Pathname:music/../articles
    p5.cleanpath                    # Pathname:articles
    p5.realpath                     # Pathname:/home/gavin/articles
    p5.children                     # [Pathname:/home/gavin/articles/linux, ...]

## Breakdown of functionality

### Core methods

These methods are effectively manipulating a `String`, because that’s all a path is. 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 ()
Source

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

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

Also aliased as: pwd
glob (*args, **kwargs) { |pathname| ... }
Source

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

See `Dir.glob`. Returns or yields `Pathname` objects.

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

    # File lib/pathname.rb, line 63
    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 tmp directory and wraps the returned path in a `Pathname` object.

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

See `Dir.mktmpdir`

new (path)
Source

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

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

pwd ()
Alias for: getwd

### Public Instance Methods

+ (other)
Source

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

Appends a pathname fragment to `self` to produce a new `Pathname` object. Since `other` is considered as a path relative to `self`, if `other` is an absolute path, the new `Pathname` object is created from just `other`.

    p1 = Pathname.new("/usr")      # Pathname:/usr
    p2 = p1 + "bin/ruby"           # Pathname:/usr/bin/ruby
    p3 = p1 + "/etc/passwd"        # Pathname:/etc/passwd

    # / is aliased to +.
    p4 = p1 / "bin/ruby"           # Pathname:/usr/bin/ruby
    p5 = p1 / "/etc/passwd"        # Pathname:/etc/passwd

This method doesn’t access the file system; it is pure string manipulation.

Also aliased as: /
/ (other)
Alias for: +
<=> (p1)
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);
    }

Provides a case-sensitive comparison operator for pathnames.

    Pathname.new('/usr') <=> Pathname.new('/usr/bin')
        #=> -1
    Pathname.new('/usr/bin') <=> Pathname.new('/usr/bin')
        #=> 0
    Pathname.new('/usr/bin') <=> Pathname.new('/USR/BIN')
        #=> 1

It will return `-1`, `0` or `1` depending on the value of the left argument relative to the right argument. Or it will return `nil` if the arguments are not comparable.

== (other)
Source

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

Compare this pathname with `other`. The comparison is string-based. Be aware that two different paths (`foo.txt` and `./foo.txt`) can refer to the same file.

Also aliased as: ===, eql?
=== (other)
Alias for: ==
absolute? ()
Source

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

Predicate method for testing whether a path is absolute.

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

    p = Pathname.new('/im/sure')
    p.absolute?
        #=> true

    p = Pathname.new('not/so/sure')
    p.absolute?
        #=> false

ascend () { |self| ... }
Source

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

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

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

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

Returns an `Enumerator` if no block was given.

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

It doesn’t access the filesystem.

atime ()
Source

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

See `File.atime`. Returns last access time.

basename (...)
Source

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

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

binread (...)
Source

    # File pathname_builtin.rb, line 881
    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 895
    def binwrite(...) File.binwrite(@path, ...) end

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

See `File.binwrite`.

birthtime ()
Source

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

Returns the birth time for the file. If the platform doesn’t have birthtime, raises `NotImplementedError`.

See `File.birthtime`.

blockdev? ()
Source

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

See `FileTest.blockdev?`.

chardev? ()
Source

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

See `FileTest.chardev?`.

children (with_directory=true)
Source

    # File pathname_builtin.rb, line 758
    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 913
    def chmod(mode) File.chmod(mode, @path) end

See `File.chmod`. Changes permissions.

chown (owner, group)
Source

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

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

cleanpath (consider_symlink=false)
Source

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

Returns clean pathname of `self` with consecutive slashes and useless dots removed. The filesystem is not accessed.

If `consider_symlink` is `true`, then a more conservative algorithm is used to avoid breaking symbolic linkages. This may retain more `..` entries than absolutely necessary, but without accessing the filesystem, this can’t be avoided.

See `Pathname#realpath`.

ctime ()
Source

    # File pathname_builtin.rb, line 907
    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 606
    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 1039
    def directory?() FileTest.directory?(@path) end

See `FileTest.directory?`.

dirname ()
Source

    # File pathname_builtin.rb, line 975
    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 808
    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 1133
    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 574
    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 871
    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 1018
    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 1127
    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? (other)
Alias for: ==
executable? ()
Source

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

See `FileTest.executable?`.

executable_real? ()
Source

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

See `FileTest.executable_real?`.

exist? ()
Source

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

See `FileTest.exist?`.

expand_path (...)
Source

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

See `File.expand_path`.

extname ()
Source

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

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

file? ()
Source

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

See `FileTest.file?`.

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

    # File lib/pathname.rb, line 30
    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 926
    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 929
    def fnmatch?(pattern, ...) File.fnmatch?(pattern, @path, ...) end

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

freeze ()
Source

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

Freze self.

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

    # File pathname_builtin.rb, line 933
    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 1111
    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 1036
    def grpowned?() FileTest.grpowned?(@path) end

See `FileTest.grpowned?`.

join (*args)
Source

    # File pathname_builtin.rb, line 725
    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 916
    def lchmod(mode) File.lchmod(mode, @path) end

See `File.lchmod`.

lchown (owner, group)
Source

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

See `File.lchown`.

lstat ()
Source

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

See `File.lstat`.

lutime (atime, mtime)
Source

    # File pathname_builtin.rb, line 969
    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 936
    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 956
    def make_symlink(old) File.symlink(old, @path) end

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

mkdir (...)
Source

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

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

mkpath (mode: nil)
Source

    # File pathname_builtin.rb, line 334
    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 510
    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 910
    def mtime() File.mtime(@path) end

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

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

    # File pathname_builtin.rb, line 939
    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 1145
    def opendir(&block) # :yield: dir
      Dir.open(@path, &block)
    end

See `Dir.open`.

owned? ()
Source

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

See `FileTest.owned?`.

parent ()
Source

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

Returns the parent directory.

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

pipe? ()
Source

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

See `FileTest.pipe?`.

read (...)
Source

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

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

readable? ()
Source

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

See `FileTest.readable?`.

readable_real? ()
Source

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

See `FileTest.readable_real?`.

readlines (...)
Source

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

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

readlink ()
Source

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

See `File.readlink`. Read symbolic link.

realdirpath (...)
Source

    # File pathname_builtin.rb, line 1003
    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 996
    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 557
    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 826
    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 947
    def rename(to) File.rename(@path, to) end

See `File.rename`. Rename the file.

rmdir ()
Source

    # File pathname_builtin.rb, line 1142
    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 48
    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 527
    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 1066
    def setgid?() FileTest.setgid?(@path) end

See `FileTest.setgid?`.

setuid? ()
Source

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

See `FileTest.setuid?`.

size ()
Source

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

See `FileTest.size`.

size? ()
Source

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

See `FileTest.size?`.

socket? ()
Source

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

See `FileTest.socket?`.

split ()
Source

    # File pathname_builtin.rb, line 985
    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 950
    def stat() File.stat(@path) end

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

sticky? ()
Source

    # File pathname_builtin.rb, line 1075
    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 292
    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 1078
    def symlink?() FileTest.symlink?(@path) end

See `FileTest.symlink?`.

sysopen (...)
Source

    # File pathname_builtin.rb, line 887
    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 254
    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 959
    def truncate(length) File.truncate(@path, length) end

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

unlink ()
Source

    # File pathname_builtin.rb, line 1153
    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 962
    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 1057
    def world_readable?() File.world_readable?(@path) end

See `FileTest.world_readable?`.

world_writable? ()
Source

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

See `FileTest.world_writable?`.

writable? ()
Source

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

See `FileTest.writable?`.

writable_real? ()
Source

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

See `FileTest.writable_real?`.

write (...)
Source

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

Writes `contents` to the file. See `File.write`.

zero? ()
Source

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

See `FileTest.zero?`.