[−][src]Trait path_absolutize::Absolutize

pub trait Absolutize {
    fn absolutize(&self) -> Result<PathBuf>;

    fn absolutize_virtually<P: AsRef<Path>>(
        &self, 
        virtual_root: P
    ) -> Result<PathBuf>;
}

Make Path and PathBuf have absolutize and absolutize_virtually method.

Required methods

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

Get an absolute path. This works even if the path does not exist.

Please read the following examples to know the parsing rules.

Examples

The dots in a path will be parsed even if it is already an absolute path (which means the path starts with a MAIN_SEPARATOR on Unix-like systems).

extern crate path_absolutize;

use std::path::Path;

use path_absolutize::*;
if cfg!(not(windows)) {
    let p = Path::new("/path/to/123/456");

    assert_eq!("/path/to/123/456", p.absolutize().unwrap().to_str().unwrap());
}
extern crate path_absolutize;

use std::path::Path;

use path_absolutize::*;

if cfg!(not(windows)) {
    let p = Path::new("/path/to/./123/../456");

    assert_eq!("/path/to/456", p.absolutize().unwrap().to_str().unwrap());
}

If a path starts with a single dot, the dot means current working directory.

extern crate path_absolutize;

use std::path::Path;

use path_absolutize::*;

if cfg!(not(windows)) {
    let p = Path::new("./path/to/123/456");

    assert_eq!(
        Path::join(&CWD, Path::new("path/to/123/456")).to_str().unwrap(),
        p.absolutize().unwrap().to_str().unwrap()
    );
}

If a path starts with a pair of dots, the dots means the parent of current working directory. If current working directory is root, the parent is still root.

extern crate path_absolutize;

use std::path::Path;

use path_absolutize::*;

if cfg!(not(windows)) {
    let p = Path::new("../path/to/123/456");

    let cwd_parent = CWD.parent();

    match cwd_parent {
        Some(cwd_parent) => {
            assert_eq!(
                Path::join(&cwd_parent, Path::new("path/to/123/456")).to_str().unwrap(),
                p.absolutize().unwrap().to_str().unwrap()
            );
        }
        None => {
            assert_eq!(
                Path::join(Path::new("/"), Path::new("path/to/123/456")).to_str().unwrap(),
                p.absolutize().unwrap().to_str().unwrap()
            );
        }
    }
}

A path which does not start with a MAIN_SEPARATOR, Single Dot and Double Dots, will act like having a single dot at the start when absolutize method is used.

extern crate path_absolutize;

use std::path::Path;

use path_absolutize::*;

if cfg!(not(windows)) {
    let p = Path::new("path/to/123/456");

    assert_eq!(
        Path::join(&CWD, Path::new("path/to/123/456")).to_str().unwrap(),
        p.absolutize().unwrap().to_str().unwrap()
    );
}
extern crate path_absolutize;

use std::path::Path;

use path_absolutize::*;

if cfg!(not(windows)) {
    let p = Path::new("path/../../to/123/456");

    let cwd_parent = CWD.parent();

    match cwd_parent {
        Some(cwd_parent) => {
            assert_eq!(
                Path::join(&cwd_parent, Path::new("to/123/456")).to_str().unwrap(),
                p.absolutize().unwrap().to_str().unwrap()
            );
        }
        None => {
            assert_eq!(
                Path::join(Path::new("/"), Path::new("to/123/456")).to_str().unwrap(),
                p.absolutize().unwrap().to_str().unwrap()
            );
        }
    }
}

fn absolutize_virtually<P: AsRef<Path>>(
    &self,
    virtual_root: P
) -> Result<PathBuf>

Get an absolute path only under a specific directory. This works even if the path does not exist.

Please read the following examples to know the parsing rules.

Examples

The dots in a path will be parsed even if it is already an absolute path (which means the path starts with a MAIN_SEPARATOR on Unix-like systems).

extern crate path_absolutize;

use std::path::Path;

use path_absolutize::*;

if cfg!(not(windows)) {
    let p = Path::new("/path/to/123/456");

    assert_eq!("/path/to/123/456", p.absolutize_virtually("/").unwrap().to_str().unwrap());
}
extern crate path_absolutize;

use std::path::Path;

use path_absolutize::*;

if cfg!(not(windows)) {
    let p = Path::new("/path/to/./123/../456");

    assert_eq!("/path/to/456", p.absolutize_virtually("/").unwrap().to_str().unwrap());
}

Every absolute path should under the virtual root.

extern crate path_absolutize;

use std::path::Path;

use std::io::ErrorKind;

use path_absolutize::*;

if cfg!(not(windows)) {
    let p = Path::new("/path/to/123/456");

    assert_eq!(
        ErrorKind::InvalidInput,
        p.absolutize_virtually("/virtual/root").unwrap_err().kind()
    );
}

Every relative path should under the virtual root.

extern crate path_absolutize;

use std::path::Path;

use std::io::ErrorKind;

use path_absolutize::*;

if cfg!(not(windows)) {
    let p = Path::new("./path/to/123/456");

    assert_eq!(
        ErrorKind::InvalidInput,
        p.absolutize_virtually("/virtual/root").unwrap_err().kind()
    );
}
extern crate path_absolutize;

use std::path::Path;

use std::io::ErrorKind;

use path_absolutize::*;

if cfg!(not(windows)) {
    let p = Path::new("../path/to/123/456");

    assert_eq!(
        ErrorKind::InvalidInput,
        p.absolutize_virtually("/virtual/root").unwrap_err().kind()
    );
}

A path which does not start with a MAIN_SEPARATOR, Single Dot and Double Dots, will be located in the virtual root after the absolutize_virtually method is used.

extern crate path_absolutize;

use std::path::Path;

use path_absolutize::*;

if cfg!(not(windows)) {
    let p = Path::new("path/to/123/456");

    assert_eq!(
        "/virtual/root/path/to/123/456",
        p.absolutize_virtually("/virtual/root").unwrap().to_str().unwrap()
    );
}
extern crate path_absolutize;

use std::path::Path;

use path_absolutize::*;

if cfg!(not(windows)) {
    let p = Path::new("path/to/../../../../123/456");

    assert_eq!(
        "/virtual/root/123/456",
        p.absolutize_virtually("/virtual/root").unwrap().to_str().unwrap()
    );
}
Loading content...

Implementations on Foreign Types

impl Absolutize for PathBuf[src]

impl Absolutize for Path[src]

Loading content...

Implementors

Loading content...