pub struct RelativePath { /* private fields */ }Expand description
A borrowed, immutable relative path.
Implementations§
Source§impl RelativePath
impl RelativePath
Sourcepub fn new<S>(s: &S) -> &RelativePath
pub fn new<S>(s: &S) -> &RelativePath
Directly wraps a string slice as a RelativePath slice.
Sourcepub fn as_str(&self) -> &str
pub fn as_str(&self) -> &str
Yields the underlying str slice.
§Examples
use relative_path::RelativePath;
assert_eq!(RelativePath::new("foo.txt").as_str(), "foo.txt");Sourcepub fn join<P>(&self, path: P) -> RelativePathBufwhere
P: AsRef<RelativePath>,
pub fn join<P>(&self, path: P) -> RelativePathBufwhere
P: AsRef<RelativePath>,
Creates an owned RelativePathBuf with path adjoined to self.
§Examples
use relative_path::RelativePath;
let path = RelativePath::new("foo/bar");
assert_eq!("foo/bar/baz", path.join("baz"));Sourcepub fn components(&self) -> Components<'_>
pub fn components(&self) -> Components<'_>
Iterate over all components in this relative path.
§Examples
use relative_path::{Component, RelativePath};
let path = RelativePath::new("foo/bar/baz");
let mut it = path.components();
assert_eq!(Some(Component::Normal("foo")), it.next());
assert_eq!(Some(Component::Normal("bar")), it.next());
assert_eq!(Some(Component::Normal("baz")), it.next());
assert_eq!(None, it.next());Sourcepub fn iter(&self) -> Iter<'_>
pub fn iter(&self) -> Iter<'_>
Produces an iterator over the path’s components viewed as str
slices.
For more information about the particulars of how the path is separated
into components, see components.
§Examples
use relative_path::RelativePath;
let mut it = RelativePath::new("/tmp/foo.txt").iter();
assert_eq!(it.next(), Some("tmp"));
assert_eq!(it.next(), Some("foo.txt"));
assert_eq!(it.next(), None)Sourcepub fn to_relative_path_buf(&self) -> RelativePathBuf
pub fn to_relative_path_buf(&self) -> RelativePathBuf
Convert to an owned RelativePathBuf.
Sourcepub fn to_path<P>(&self, relative_to: P) -> PathBuf
pub fn to_path<P>(&self, relative_to: P) -> PathBuf
Build an owned PathBuf relative to path for the current relative path.
§Examples
use relative_path::RelativePath;
use std::path::Path;
let path = RelativePath::new("foo/bar").to_path(Path::new("."));
assert_eq!(Path::new("./foo/bar"), path);Sourcepub fn parent(&self) -> Option<&RelativePath>
pub fn parent(&self) -> Option<&RelativePath>
Returns a relative path, without its final component if there is one.
§Examples
use relative_path::RelativePath;
assert_eq!(Some(RelativePath::new("foo")), RelativePath::new("foo/bar").parent());
assert_eq!(None, RelativePath::new("foo").parent());
assert_eq!(None, RelativePath::new("").parent());Sourcepub fn file_name(&self) -> Option<&str>
pub fn file_name(&self) -> Option<&str>
Returns the final component of the RelativePath, if there is one.
If the path is a normal file, this is the file name. If it’s the path of a directory, this is the directory name.
Returns None If the path terminates in ...
§Examples
use relative_path::RelativePath;
assert_eq!(Some("bin"), RelativePath::new("usr/bin/").file_name());
assert_eq!(Some("foo.txt"), RelativePath::new("tmp/foo.txt").file_name());
assert_eq!(Some("foo.txt"), RelativePath::new("tmp/foo.txt/").file_name());
assert_eq!(Some("foo.txt"), RelativePath::new("foo.txt/.").file_name());
assert_eq!(Some("foo.txt"), RelativePath::new("foo.txt/.//").file_name());
assert_eq!(None, RelativePath::new("foo.txt/..").file_name());
assert_eq!(None, RelativePath::new("/").file_name());Sourcepub fn strip_prefix<'a, P>(
&'a self,
base: &'a P,
) -> Result<&'a RelativePath, StripPrefixError>
pub fn strip_prefix<'a, P>( &'a self, base: &'a P, ) -> Result<&'a RelativePath, StripPrefixError>
Returns a relative path that, when joined onto base, yields self.
§Errors
If base is not a prefix of self (i.e. starts_with
returns false), returns Err.
§Examples
use relative_path::RelativePath;
let path = RelativePath::new("test/haha/foo.txt");
assert_eq!(path.strip_prefix("test"), Ok(RelativePath::new("haha/foo.txt")));
assert_eq!(path.strip_prefix("test").is_ok(), true);
assert_eq!(path.strip_prefix("haha").is_ok(), false);Sourcepub fn starts_with<P>(&self, base: P) -> boolwhere
P: AsRef<RelativePath>,
pub fn starts_with<P>(&self, base: P) -> boolwhere
P: AsRef<RelativePath>,
Determines whether base is a prefix of self.
Only considers whole path components to match.
§Examples
use relative_path::RelativePath;
let path = RelativePath::new("etc/passwd");
assert!(path.starts_with("etc"));
assert!(!path.starts_with("e"));Sourcepub fn ends_with<P>(&self, child: P) -> boolwhere
P: AsRef<RelativePath>,
pub fn ends_with<P>(&self, child: P) -> boolwhere
P: AsRef<RelativePath>,
Determines whether child is a suffix of self.
Only considers whole path components to match.
§Examples
use relative_path::RelativePath;
let path = RelativePath::new("etc/passwd");
assert!(path.ends_with("passwd"));Sourcepub fn with_file_name<S>(&self, file_name: S) -> RelativePathBuf
pub fn with_file_name<S>(&self, file_name: S) -> RelativePathBuf
Creates an owned RelativePathBuf like self but with the given file name.
See RelativePathBuf::set_file_name for more details.
§Examples
use relative_path::{RelativePath, RelativePathBuf};
let path = RelativePath::new("tmp/foo.txt");
assert_eq!(path.with_file_name("bar.txt"), RelativePathBuf::from("tmp/bar.txt"));
let path = RelativePath::new("tmp");
assert_eq!(path.with_file_name("var"), RelativePathBuf::from("var"));Sourcepub fn file_stem(&self) -> Option<&str>
pub fn file_stem(&self) -> Option<&str>
Extracts the stem (non-extension) portion of self.file_name.
The stem is:
None, if there is no file name;- The entire file name if there is no embedded
.; - The entire file name if the file name begins with
.and has no other.s within; - Otherwise, the portion of the file name before the final
.
§Examples
use relative_path::RelativePath;
let path = RelativePath::new("foo.rs");
assert_eq!("foo", path.file_stem().unwrap());Sourcepub fn extension(&self) -> Option<&str>
pub fn extension(&self) -> Option<&str>
Extracts the extension of self.file_name, if possible.
The extension is:
None, if there is no file name;None, if there is no embedded.;None, if the file name begins with.and has no other.s within;- Otherwise, the portion of the file name after the final
.
§Examples
use relative_path::RelativePath;
assert_eq!(Some("rs"), RelativePath::new("foo.rs").extension());
assert_eq!(None, RelativePath::new(".rs").extension());
assert_eq!(Some("rs"), RelativePath::new("foo.rs/.").extension());Sourcepub fn with_extension<S>(&self, extension: S) -> RelativePathBuf
pub fn with_extension<S>(&self, extension: S) -> RelativePathBuf
Creates an owned RelativePathBuf like self but with the given extension.
See RelativePathBuf::set_extension for more details.
§Examples
use relative_path::{RelativePath, RelativePathBuf};
let path = RelativePath::new("foo.rs");
assert_eq!(path.with_extension("txt"), RelativePathBuf::from("foo.txt"));Sourcepub fn join_normalized<P>(&self, path: P) -> RelativePathBufwhere
P: AsRef<RelativePath>,
pub fn join_normalized<P>(&self, path: P) -> RelativePathBufwhere
P: AsRef<RelativePath>,
Build an owned RelativePathBuf, joined with the given path and normalized.
§Examples
use relative_path::RelativePath;
assert_eq!(
RelativePath::new("foo/baz.txt"),
RelativePath::new("foo/bar").join_normalized("../baz.txt").as_relative_path()
);
assert_eq!(
RelativePath::new("../foo/baz.txt"),
RelativePath::new("../foo/bar").join_normalized("../baz.txt").as_relative_path()
);Sourcepub fn normalize(&self) -> RelativePathBuf
pub fn normalize(&self) -> RelativePathBuf
Return an owned RelativePathBuf, with all non-normal components moved to the beginning of
the path.
This permits for a normalized representation of different relative components.
Normalization is a destructive operation if the path references an actual filesystem
path.
An example of this is symlinks under unix, a path like foo/../bar might reference a
different location other than ./bar.
Normalization is a logical operation that is only valid if the relative path is part of some context which doesn’t have semantics that causes it to break, like symbolic links.
§Examples
use relative_path::RelativePath;
assert_eq!(
RelativePath::new("../foo/baz.txt"),
RelativePath::new("../foo/./bar/../baz.txt").normalize().as_relative_path()
);