W3cubDocs

/Crystal 0.31

struct Path

Overview

A Path represents a filesystem path and allows path-handling operations such as querying its components as well as semantic manipulations.

A path is hierarchical and composed of a sequence of directory and file name elements separated by a special separator or delimiter. A root component, that identifies a file system hierarchy, may also be present. The name element that is farthest from the root of the directory hierarchy is the name of a file or directory. The other name elements are directory names. A Path can represent a root, a root and a sequence of names, or simply one or more name elements. A Path is considered to be an empty path if it consists solely of one name element that is empty. Accessing a file using an empty path is equivalent to accessing the default directory of the process.

Examples

Path["foo/bar/baz.cr"].parent   # => Path["foo/bar"]
Path["foo/bar/baz.cr"].basename # => "baz.cr"
Path["./foo/../bar"].normalize  # => Path["bar"]
Path["~/bin"].expand            # => Path["/home/crystal/bin"]

For now, its methods are purely lexical, there is no direct filesystem access.

Path handling comes in different kinds depending on operating system:

# On POSIX system:
Path.new("foo", "bar", "baz.cr") == Path.posix("foo/bar/baz.cr")
# On Windows system:
Path.new("foo", "bar", "baz.cr") == Path.windows("foo\\bar\\baz.cr")

The main differences between Windows and POSIX paths:

  • POSIX paths use forward slash (#/) as only path separator, Windows paths use backslash (\) as default separator but also recognize forward slashes.
  • POSIX paths are generally case-sensitive, Windows paths case-insensitive (see #<=>).
  • A POSIX path is absolute if it begins with a forward slash (#/). A Windows path is absolute if it starts with a drive letter and root (C:\).
Path.posix("/foo/./bar").normalize   # => Path.posix("/foo/bar")
Path.windows("/foo/./bar").normalize # => Path.windows("\\foo\\bar")

Path.posix("/foo").absolute?   # => true
Path.windows("/foo").absolute? # => false

Path.posix("foo") == Path.posix("FOO")     # => false
Path.windows("foo") == Path.windows("FOO") # => true

Included Modules

Defined in:

path.cr

Constant Summary

SEPARATORS = separators(Kind.native)

The file/directory separator characters of the current platform. {'/'} on POSIX, {'\\', '/'} on Windows.

Constructors

Instance Method Summary

Constructor Detail

def self.[](parts : Enumerable) : PathSource

Creates a new Path of native kind.

When compiling for a windows target, this is equal to Path.windows(), otherwise Path.posix is used.

def self.[](name : String, *parts) : PathSource

Creates a new Path of native kind.

When compiling for a windows target, this is equal to Path.windows(), otherwise Path.posix is used.

def self.home : PathSource

Returns the path of the home directory of the current user.

def self.new(name : String = "") : PathSource

Creates a new Path of native kind.

When compiling for a windows target, this is equal to Path.windows(), otherwise Path.posix is used.

def self.new(parts : Enumerable) : PathSource

Creates a new Path of native kind.

When compiling for a windows target, this is equal to Path.windows(), otherwise Path.posix is used.

def self.new(name : String, *parts) : PathSource

Creates a new Path of native kind.

When compiling for a windows target, this is equal to Path.windows(), otherwise Path.posix is used.

def self.posix(name : String = "") : PathSource

Creates a new Path of POSIX kind.

def self.posix(parts : Enumerable) : PathSource

Creates a new Path of POSIX kind.

def self.posix(name : String, *parts) : PathSource

Creates a new Path of POSIX kind.

def self.windows(name : String = "") : PathSource

Creates a new Path of Windows kind.

def self.windows(parts : Enumerable) : PathSource

Creates a new Path of Windows kind.

def self.windows(name : String, *parts) : PathSource

Creates a new Path of Windows kind.

Instance Method Detail

def /(part : Path | String) : PathSource

Appends the given part to this path and returns the joined path.

Path["foo"] / "bar" / "baz"     # => Path["foo/bar/baz"]
Path["foo/"] / Path["/bar/baz"] # => Path["foo/bar/baz"]

def <=>(other : Path)Source

Compares this path to other.

The comparison is performed strictly lexically: foo and ./foo are not treated as equal. To compare paths semantically, they need to be normalized and converted to the same kind.

Path["foo"] <=> Path["foo"]               # => 0
Path["foo"] <=> Path["./foo"]             # => 1
Path.posix("foo") <=> Path.windows("foo") # => -1

Comparison is case-sensitive for POSIX paths and case-insensitive for Windows paths.

Path.posix("foo") <=> Path.posix("FOO")     # => 1
Path.windows("foo") <=> Path.windows("FOO") # => 0

def absolute? : BoolSource

Returns true if this path is absolute.

A POSIX path is absolute if it begins with a forward slash (#/). A Windows path is absolute if it begins with a drive letter and root (C:\) or with a UNC share (\\server\share\).

def anchor : Path?Source

Returns the concatenation of #drive and #root.

Path["/etc/"].anchor                           # => Path["/"]
Path.windows("C:Program Files").anchor         # => Path.windows("C:")
Path.windows("C:\\Program Files").anchor       # => Path.windows("C:\\")
Path.windows("\\\\host\\share\\folder").anchor # => Path.windows("\\\\host\\share\\")

def basename(suffix : String? = nil) : StringSource

Returns the last component of this path.

If suffix is given, it is stripped from the end.

Path["/foo/bar/file.cr"].basename # => "file.cr"
Path["/foo/bar/"].basename        # => "bar"
Path["/"].basename                # => "/"
Path[""].basename                 # => ""

def dirname : StringSource

Returns all components of this path except the last one.

Path["/foo/bar/file.cr"].dirname # => "/foo/bar"

def drive : Path?Source

Returns a path representing the drive component or nil if this path does not contain a drive.

See #anchor for the combination of drive and #root.

Path.windows("C:\\Program Files").drive       # => Path.windows("C:")
Path.windows("\\\\host\\share\\folder").drive # => Path.windows("\\\\host\\share")

NOTE Drives are only available for Windows paths. It can either be a drive letter (C:) or a UNC share (\\host\share).

def drive_and_root : Tuple(String?, String?)Source

Returns a tuple of #drive and #root as strings.

def each_parent(&block : Path -> )Source

Yields each parent of this path beginning with the topmost parent.

Path["foo/bar/file.cr"].each_parent { |parent| puts parent }
# Path["."]
# Path["foo"]
# Path["foo/bar"]

def each_part(&block)Source

Yields each component of this path as a String.

def ends_with_separator?Source

def expand(base : Path | String = Dir.current, *, home : String | Path | Nil = nil, expand_base = true) : PathSource

Converts this path to an absolute path. Relative paths are referenced from the current working directory of the process (Dir.current) unless base is given, in which case it will be used as the reference path.

Path["foo"].expand             # => Path["/current/path/foo"]
Path["~/crystal/foo"].expand   # => Path["/home/crystal/foo"]
Path["baz"].expand("/foo/bar") # => Path["/foo/bar/baz"]

home specifies the home directory which ~ will expand to. If not given (or nil is given) then Path.home will be used. If expand_base is true, base itself will be exanded in Dir.current if it is not an absolute path. This guarantees the method returns an absolute path (assuming that Dir.current is absolute).

def extension : StringSource

Returns the extension of this path, or an empty string if it has no extension.

Path["foo.cr"].extension # => ".cr"
Path["foo"].extension    # => ""

def inspect(io : IO)Source

Inspects this path to io.

def join(part) : PathSource

Appends the given part to this path and returns the joined path.

Path["foo"].join("bar")     # => Path["foo/bar"]
Path["foo/"].join("/bar")   # => Path["foo/bar"]
Path["/foo/"].join("/bar/") # => Path["/foo/bar/"]

def join(*parts) : PathSource

Appends the given parts to this path and returns the joined path.

Path["foo"].join("bar", "baz")       # => Path["foo/bar/baz"]
Path["foo/"].join("/bar/", "/baz")   # => Path["foo/bar/baz"]
Path["/foo/"].join("/bar/", "/baz/") # => Path["/foo/bar/baz/"]

def join(parts : Enumerable) : PathSource

Appends the given parts to this path and returns the joined path.

Path["foo"].join("bar", "baz")           # => Path["foo/bar/baz"]
Path["foo/"].join(Path["/bar/", "/baz"]) # => Path["foo/bar/baz"]
Path["/foo/"].join("/bar/", "/baz/")     # => Path["/foo/bar/baz/"]

Non-matching paths are implicitly converted to this path's kind.

Path.posix("foo/bar").join(Path.windows("baz\\baq")) # => Path.posix("foo/bar/baz/baq")
Path.windows("foo\\bar").join(Path.posix("baz/baq")) # => Path.windows("foo\\bar\\baz/baq")

def native? : BoolSource

Returns true if this is a native path for the target platform.

def normalize(*, remove_final_separator : Bool = true) : PathSource

Removes redundant elements from this path and returns the shortest equivalent path by purely lexical processing. It applies the following rules iteratively until no further processing can be done:

  1. Replace multiple slashes with a single slash.
  2. Eliminate each . path name element (the current directory).
  3. Eliminate each .. path name element (the parent directory) preceded
 by a non-`..` element along with the latter.
  1. Eliminate .. elements that begin a rooted path:
 that is, replace `"/.."` by `"/"` at the beginning of a path.

If the path turns to be empty, the current directory (".") is returned.

The returned path ends in a slash only if it is the root ("/", \, or C:\).

See also Rob Pike: Lexical File Names in Plan 9 or Getting Dot-Dot Right

def parent : PathSource

Returns the parent path of this path.

If the path is empty or ".", it returns ".". If the path is rooted and in the top-most hierarchy, the root path is returned.

Path["foo/bar/file.cr"].parent # => Path["foo/bar"]
Path["foo"].parent             # => Path["."]
Path["/foo"].parent            # => Path["/"]
Path["/"].parent               # => Path["/"]
Path[""].parent                # => Path["."]
Path["foo/bar/."].parent       # => Path["foo/bar"]

def parents : Array(Path)Source

Returns all parent paths of this path beginning with the topmost path.

Path["foo/bar/file.cr"].parents # => [Path["."], Path["foo"], Path["foo/bar"]]

def parts : Array(String)Source

Returns the components of this path as an Array(String).

def posix? : BoolSource

Returns true if this is a POSIX path.

def root : Path?Source

Returns the root path component of this path or nil if it is not rooted.

See #anchor for the combination of #drive and root.

Path["/etc/"].root                           # => Path["/"]
Path.windows("C:Program Files").root         # => nil
Path.windows("C:\\Program Files").root       # => Path.windows("\\")
Path.windows("\\\\host\\share\\folder").root # => Path.windows("\\")

def sibling(name : Path | String) : Path?Source

Resolves path name in this path's parent directory.

Raises Path::Error if #parent is nil.

def to_kind(kind)Source

Converts this path to the given kind.

See #to_windows and #to_posix for details.

def to_posix : PathSource

Converts this path to a POSIX path.

Path.windows("foo/bar\\baz").to_posix # => Path.posix("foo/bar/baz")
Path.posix("foo/bar").to_posix        # => Path.posix("foo/bar")
Path.posix("foo/bar\\baz").to_posix   # => Path.posix("foo/bar\\baz")

It returns a copy of this instance if it already has POSIX kind. Otherwise a new instance is created with Kind::POSIX and all occurences of backslash file separators (\\) replaced by forward slash (#/).

def to_s : StringSource

Returns the string representation of this path.

def to_s(io : IO)Source

Appends the string representation of this path to io.

def to_uri : URISource

Returns a new URI with file scheme from this path.

A URI can only be created with an absolute path. Raises Path::Error if this path is not absolute.

def to_windows : PathSource

Converts this path to a Windows path.

Path.posix("foo/bar").to_windows   # => Path.windows("foo/bar")
Path.windows("foo/bar").to_windows # => Path.windows("foo/bar")

This creates a new instance with the same string representation but with Kind::WINDOWS.

def windows? : BoolSource

Returns true if this is a Windows path.

© 2012–2019 Manas Technology Solutions.
Licensed under the Apache License, Version 2.0.
https://crystal-lang.org/api/0.31.1/Path.html