ospaths2

nimony/lib/std/private/ospaths2.nim

• func normalizePathEnd(path: var string; trailingSep: bool)

  Ensures path has exactly 0 or 1 trailing DirSep, depending on trailingSep, and taking care of edge cases: it preservers whether a path is absolute or relative, and makes sure trailing sep is DirSep, not AltSep. Trailing /. are compressed, see examples.

• proc joinPath(head: string; tail: string): string

  Joins two directory names to one.

  returns normalized path concatenation of head and tail, preserving whether or not tail has a trailing slash (or, if tail if empty, whether head has one).

  See also:

  • joinPath(parts: varargs[string]) proc_
  • / proc_
  • splitPath proc_
  • uri.combine proc
  • uri./ proc
• proc /(head: string; tail: string): string

  The same as joinPath(head, tail) proc_.

  See also:

  • /../ proc_
  • joinPath(head, tail) proc_
  • joinPath(parts: varargs[string]) proc_
  • splitPath proc_
  • uri.combine proc
  • uri./ proc
• proc splitPath(path: string): tuple[head: string, tail: string]

  Splits a directory into (head, tail) tuple, so that head / tail == path (except for edge cases like "/usr").

  See also:

  • joinPath(head, tail) proc_
  • joinPath(parts: varargs[string]) proc_
  • / proc_
  • /../ proc_
  • relativePath proc_
• proc isAbsolute(path: string): bool

  Checks whether a given path is absolute.

  On Windows, network paths are considered absolute too.

• proc relativePath(path: string; base: string; sep: char): string

  Converts path to a path relative to base.

  The sep (default: DirSep_) is used for the path normalizations, this can be useful to ensure the relative path only contains '/' so that it can be used for URL constructions.

  On Windows, if a root of path and a root of base are different, returns path as is because it is impossible to make a relative path. That means an absolute path can be returned.

  See also:

  • splitPath proc_
  • parentDir proc_
  • tailDir proc_
• proc isRelativeTo(path: string; base: string): bool

  Returns true if path is relative to base.

• proc parentDir(path: string): string

  Returns the parent directory of path.

  This is similar to splitPath(path).head when path doesn't end in a dir separator, but also takes care of path normalizations. The remainder can be obtained with lastPathPart(path) proc_.

  See also:

  • relativePath proc_
  • splitPath proc_
  • tailDir proc_
  • parentDirs iterator_
• proc tailDir(path: string): string

  Returns the tail part of path.

  See also:

  • relativePath proc_
  • splitPath proc_
  • parentDir proc_
• proc isRootDir(path: string): bool

  Checks whether a given path is a root directory.

• iterator parentDirs(path: string; fromRoot: bool; inclusive: bool): string

  Walks over all parent directories of a given path.

  If fromRoot is true (default: false), the traversal will start from the file system root directory. If inclusive is true (default), the original argument will be included in the traversal.

  Relative paths won't be expanded by this iterator. Instead, it will traverse only the directories appearing in the relative path.

  See also:

  • parentDir proc_
• proc /../(head: string; tail: string): string

  The same as parentDir(head) / tail, unless there is no parent directory. Then head / tail is performed instead.

  See also:

  • / proc_
  • parentDir proc_
• func searchExtPos(path: string): int64

  Returns index of the '.' char in path if it signifies the beginning of the file extension. Returns -1 otherwise.

  See also:

  • splitFile proc_
  • extractFilename proc_
  • lastPathPart proc_
  • changeFileExt proc_
  • addFileExt proc_
• proc splitFile(path: string): tuple[dir: string, name: string, ext: string]

  Splits a filename into (dir, name, extension) tuple.

  dir does not end in DirSep_ unless it's /. extension includes the leading dot.

  If path has no extension, ext is the empty string. If path has no directory component, dir is the empty string. If path has no filename component, name and ext are empty strings.

  See also:

  • searchExtPos proc_
  • extractFilename proc_
  • lastPathPart proc_
  • changeFileExt proc_
  • addFileExt proc_
• proc extractFilename(path: string): string

  Extracts the filename of a given path.

  This is the same as name & ext from splitFile(path) proc_.

  See also:

  • searchExtPos proc_
  • splitFile proc_
  • lastPathPart proc_
  • changeFileExt proc_
  • addFileExt proc_
• proc lastPathPart(path: string): string

  Like extractFilename proc_, but ignores trailing dir separator; aka: baseName:idx: in some other languages.

  See also:

  • searchExtPos proc_
  • splitFile proc_
  • extractFilename proc_
  • changeFileExt proc_
  • addFileExt proc_
• proc changeFileExt(filename: string; ext: string): string

  Changes the file extension to ext.

  If the filename has no extension, ext will be added. If ext == "" then any extension is removed.

  Ext should be given without the leading '.', because some filesystems may use a different character. (Although I know of none such beast.)

  See also:

  • searchExtPos proc_
  • splitFile proc_
  • extractFilename proc_
  • lastPathPart proc_
  • addFileExt proc_
• proc addFileExt(filename: string; ext: string): string

  Adds the file extension ext to filename, unless filename already has an extension.

  Ext should be given without the leading '.', because some filesystems may use a different character. (Although I know of none such beast.)

  See also:

  • searchExtPos proc_
  • splitFile proc_
  • extractFilename proc_
  • lastPathPart proc_
  • changeFileExt proc_
• proc cmpPaths(pathA: string; pathB: string): int64

  Compares two paths.

  On a case-sensitive filesystem this is done case-sensitively otherwise case-insensitively. Returns:

  | 0 if pathA == pathB

  | < 0 if pathA < pathB

  | > 0 if pathA > pathB

• proc unixToNativePath(path: string; drive: string): string

  Converts an UNIX-like path to a native one.

  On an UNIX system this does nothing. Else it converts '/', '.', '..' to the appropriate things.

  On systems with a concept of "drives", drive is used to determine which drive label to use during absolute path conversion. drive defaults to the drive of the current working directory, and is ignored on systems that do not have a concept of "drives".

• proc getCurrentDir(): string

  Returns the current working directory:idx: i.e. where the built binary is run.

  So the path returned by this proc is determined at run time.

  See also:

  • getHomeDir proc_
  • getConfigDir proc_
  • getTempDir proc_
  • setCurrentDir proc_
  • currentSourcePath template
  • getProjectPath proc
• proc absolutePath(path: string; root: string): string

  Returns the absolute path of path, rooted at root (which must be absolute; default: current directory). If path is absolute, return it, ignoring root.

  See also:

  • normalizedPath proc_
  • normalizePath proc_
• proc normalizePath(path: var string)

  Normalize a path.

  Consecutive directory separators are collapsed, including an initial double slash.

  On relative paths, double dot (..) sequences are collapsed if possible. On absolute paths they are always collapsed.

  .. warning:: URL-encoded and Unicode attempts at directory traversal are not detected. Triple dot is not handled.

  See also:

  • absolutePath proc_
  • normalizedPath proc_ for outplace version
  • normalizeExe proc_
• proc normalizedPath(path: string): string

  Returns a normalized path for the current OS.

  See also:

  • absolutePath proc_
  • normalizePath proc_ for the in-place version
• proc normalizeExe(file: var string)

  on posix, prepends ./ if file doesn't contain / and is not "", ".", "..".

• proc sameFile(path1: string; path2: string): bool

  Returns true if both pathname arguments refer to the same physical file or directory.

  Raises OSError if any of the files does not exist or information about it can not be obtained.

  This proc will return true if given two alternative hard-linked or sym-linked paths to the same file or directory.

  See also:

  • sameFileContent proc_