pub trait PosixPathExt: Sealed {
    // Required methods
    fn posix_absolute(&self) -> Result<PathBuf>;
    fn posix_lexically_absolute(&self) -> Result<PathBuf>;
    fn posix_absolute_from(&self, path: &Path) -> Result<PathBuf>;
    fn posix_lexically_absolute_from(&self, cwd: &Path) -> Result<PathBuf>;
}

Required Methods§

source

fn posix_absolute(&self) -> Result<PathBuf>

[Unix only] Make a POSIX path absolute without changing its semantics.

Unlike canonicalize the path does not need to exist. Symlinks and .. components will not be resolved.

Example
#[cfg(unix)]
{
    use omnipath::posix::PosixPathExt;
    use std::path::Path;
    use std::env::current_dir;

    let path = Path::new(r"path/to/..//./file");
    assert_eq!(
        path.posix_absolute().unwrap(),
        current_dir().unwrap().join("path/to/../file")
    )
}
source

fn posix_lexically_absolute(&self) -> Result<PathBuf>

[Unix only] Make a POSIX path lexically absolute.

Unlike canonicalize the path does not need to exist. Symlinks will not be resolved. Unlike posix_absolute this resolves .. components by popping the parent component. This means that it may resolve to a different path than would be resolved by passing the path directly to the OS.

Usually this is not the preferred behaviour.

Example
#[cfg(unix)]
{
    use omnipath::posix::PosixPathExt;
    use std::path::Path;
    use std::env::current_dir;

    let path = Path::new(r"path/to/..//./file");
    assert_eq!(
        path.posix_lexically_absolute().unwrap(),
        current_dir().unwrap().join("path/file")
    )
}
source

fn posix_absolute_from(&self, path: &Path) -> Result<PathBuf>

[Unix only] Make a POSIX path absolute relative to a provided working directory without changing its semantics.

See PosixPathExt::posix_absolute for a version of this function that is relative to std::env::current_dir() instead.

Example
#[cfg(unix)]
{
    use omnipath::posix::PosixPathExt;
    use std::path::Path;
    let working_dir = Path::new("/tmp");
    let path = Path::new("path/to/..//./file");

    assert_eq!(
        &path.posix_absolute_from(working_dir).unwrap(),
        Path::new("/tmp/path/to/../file"),
    )
}
#[cfg(unix)]
{
    use omnipath::posix::PosixPathExt;
    use std::path::Path;
    use std::env::current_dir;
    let root = Path::new("/tmp/foo//.././bar");
    let path = Path::new(r"path/to/..//./file");
    assert_eq!(
        &path.posix_absolute_from(root).unwrap(),
        Path::new("/tmp/foo/../bar/path/to/../file"),
    );
}
source

fn posix_lexically_absolute_from(&self, cwd: &Path) -> Result<PathBuf>

[Unix only] Make a POSIX path lexically absolute relative to a provided current working directory.

Unlike canonicalize the path does not need to exist. Symlinks will not be resolved. Unlike posix_absolute this resolves .. components by popping the parent component. This means that it may resolve to a different path than would be resolved by passing the path directly to the OS.

Usually this is not the preferred behaviour.

See PosixPathExt::posix_lexically_absolute for a version of this function that is relative to std::env::current_dir() instead.

Example
#[cfg(unix)]
{
    use omnipath::posix::PosixPathExt;
    use std::path::Path;
    use std::env::current_dir;
    let root = Path::new("/tmp");
    let path = Path::new(r"path/to/..//./file");
    assert_eq!(
        &path.posix_lexically_absolute_from(root).unwrap(),
        Path::new("/tmp/path/file")
    );
}
#[cfg(unix)]
{
    use omnipath::posix::PosixPathExt;
    use std::path::Path;
    use std::env::current_dir;
    let root = Path::new("/tmp/foo//.././bar");
    let path = Path::new(r"path/to/..//./file");
    assert_eq!(
        &path.posix_lexically_absolute_from(root).unwrap(),
        Path::new("/tmp/bar/path/file")
    );
}

Implementations on Foreign Types§

source§

impl PosixPathExt for Path

Implementors§