Struct GlobPath 

pub struct GlobPath(pub RelativePathBuf);

Tuple Fields

0: RelativePathBuf

Implementations

impl GlobPath

pub fn to_path_buf(&self) -> PathBuf

Methods from Deref<Target = RelativePathBuf>

pub fn as_relative_path(&self) -> &RelativePath

Coerce to a RelativePath slice.

Methods from Deref<Target = RelativePath>

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");

pub fn display(&self) -> Display<'_>

👎Deprecated: RelativePath implements std::fmt::Display directly

Returns an object that implements Display.

Examples

use relative_path::RelativePath;

let path = RelativePath::new("tmp/foo.rs");

println!("{}", path.display());

pub fn join<P>(&self, path: P) -> RelativePathBuf

where 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"));

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());

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)

pub fn to_relative_path_buf(&self) -> RelativePathBuf

Convert to an owned RelativePathBuf.

pub fn to_path<P>(&self, base: P) -> PathBuf

where P: AsRef<Path>,

Build an owned PathBuf relative to base for the current relative path.

Examples

use relative_path::RelativePath;
use std::path::Path;

let path = RelativePath::new("foo/bar").to_path(".");
assert_eq!(Path::new("./foo/bar"), path);

let path = RelativePath::new("foo/bar").to_path("");
assert_eq!(Path::new("foo/bar"), path);

Encoding an absolute path

Absolute paths are, in contrast to when using PathBuf::push ignored and will be added unchanged to the buffer.

This is to preserve the probability of a path conversion failing if the relative path contains platform-specific absolute path components.

use relative_path::RelativePath;
use std::path::Path;

if cfg!(windows) {
    let path = RelativePath::new("/bar/baz").to_path("foo");
    assert_eq!(Path::new("foo\\bar\\baz"), path);

    let path = RelativePath::new("c:\\bar\\baz").to_path("foo");
    assert_eq!(Path::new("foo\\c:\\bar\\baz"), path);
}

if cfg!(unix) {
    let path = RelativePath::new("/bar/baz").to_path("foo");
    assert_eq!(Path::new("foo/bar/baz"), path);

    let path = RelativePath::new("c:\\bar\\baz").to_path("foo");
    assert_eq!(Path::new("foo/c:\\bar\\baz"), path);
}

pub fn to_logical_path<P>(&self, base: P) -> PathBuf

where P: AsRef<Path>,

Build an owned PathBuf relative to base for the current relative path.

This is similar to to_path except that it doesn’t just unconditionally append one path to the other, instead it performs the following operations depending on its own components:

• Component::CurDir leaves the base unmodified.
• Component::ParentDir removes a component from base using path::PathBuf::pop.
• Component::Normal pushes the given path component onto base using the same mechanism as to_path.

Note that the exact semantics of the path operation is determined by the corresponding PathBuf operation. E.g. popping a component off a path like . will result in an empty path.

use relative_path::RelativePath;
use std::path::Path;

let path = RelativePath::new("..").to_logical_path(".");
assert_eq!(path, Path::new(""));

Examples

use relative_path::RelativePath;
use std::path::Path;

let path = RelativePath::new("..").to_logical_path("foo/bar");
assert_eq!(path, Path::new("foo"));

Encoding an absolute path

Behaves the same as to_path when encoding absolute paths.

Absolute paths are, in contrast to when using PathBuf::push ignored and will be added unchanged to the buffer.

This is to preserve the probability of a path conversion failing if the relative path contains platform-specific absolute path components.

use relative_path::RelativePath;
use std::path::Path;

if cfg!(windows) {
    let path = RelativePath::new("/bar/baz").to_logical_path("foo");
    assert_eq!(Path::new("foo\\bar\\baz"), path);

    let path = RelativePath::new("c:\\bar\\baz").to_logical_path("foo");
    assert_eq!(Path::new("foo\\c:\\bar\\baz"), path);

    let path = RelativePath::new("foo/bar").to_logical_path("");
    assert_eq!(Path::new("foo\\bar"), path);
}

if cfg!(unix) {
    let path = RelativePath::new("/bar/baz").to_logical_path("foo");
    assert_eq!(Path::new("foo/bar/baz"), path);

    let path = RelativePath::new("c:\\bar\\baz").to_logical_path("foo");
    assert_eq!(Path::new("foo/c:\\bar\\baz"), path);

    let path = RelativePath::new("foo/bar").to_logical_path("");
    assert_eq!(Path::new("foo/bar"), path);
}

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!(Some(RelativePath::new("")), RelativePath::new("foo").parent());
assert_eq!(None, RelativePath::new("").parent());

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());

pub fn strip_prefix<P>( &self, base: P, ) -> Result<&RelativePath, StripPrefixError>

where P: AsRef<RelativePath>,

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);

pub fn starts_with<P>(&self, base: P) -> bool

where 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"));

pub fn ends_with<P>(&self, child: P) -> bool

where 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"));

pub fn is_normalized(&self) -> bool

Determines whether self is normalized.

Examples

use relative_path::RelativePath;

// These are normalized.
assert!(RelativePath::new("").is_normalized());
assert!(RelativePath::new("baz.txt").is_normalized());
assert!(RelativePath::new("foo/bar/baz.txt").is_normalized());
assert!(RelativePath::new("..").is_normalized());
assert!(RelativePath::new("../..").is_normalized());
assert!(RelativePath::new("../../foo/bar/baz.txt").is_normalized());

// These are not normalized.
assert!(!RelativePath::new(".").is_normalized());
assert!(!RelativePath::new("./baz.txt").is_normalized());
assert!(!RelativePath::new("foo/..").is_normalized());
assert!(!RelativePath::new("foo/../baz.txt").is_normalized());
assert!(!RelativePath::new("foo/.").is_normalized());
assert!(!RelativePath::new("foo/./baz.txt").is_normalized());
assert!(!RelativePath::new("../foo/./bar/../baz.txt").is_normalized());

pub fn with_file_name<S>(&self, file_name: S) -> RelativePathBuf

where S: AsRef<str>,

Creates an owned RelativePathBuf like self but with the given file name.

See 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"));

pub fn file_stem(&self) -> Option<&str>

Extracts the stem (non-extension) portion of 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());

pub fn extension(&self) -> Option<&str>

Extracts the extension of 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());

pub fn with_extension<S>(&self, extension: S) -> RelativePathBuf

where S: AsRef<str>,

Creates an owned RelativePathBuf like self but with the given extension.

See 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"));

pub fn join_normalized<P>(&self, path: P) -> RelativePathBuf

where 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()
);

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 and does not guarantee that the constructed path corresponds to what the filesystem would do. On Linux for example symbolic links could mean that the logical path doesn’t correspond to the filesystem path.

Examples

use relative_path::RelativePath;

assert_eq!(
    "../foo/baz.txt",
    RelativePath::new("../foo/./bar/../baz.txt").normalize()
);

assert_eq!(
    "",
    RelativePath::new(".").normalize()
);

pub fn relative<P>(&self, path: P) -> RelativePathBuf

where P: AsRef<RelativePath>,

Constructs a relative path from the current path, to path.

This function will return the empty RelativePath "" if this source contains unnamed components like .. that would have to be traversed to reach the destination path. This is necessary since we have no way of knowing what the names of those components are when we’re building the new relative path.

use relative_path::RelativePath;

// Here we don't know what directories `../..` refers to, so there's no
// way to construct a path back to `bar` in the current directory from
// `../..`.
let from = RelativePath::new("../../foo/relative-path");
let to = RelativePath::new("bar");
assert_eq!("", from.relative(to));

One exception to this is when two paths contains a common prefix at which point there’s no need to know what the names of those unnamed components are.

use relative_path::RelativePath;

let from = RelativePath::new("../../foo/bar");
let to = RelativePath::new("../../foo/baz");

assert_eq!("../baz", from.relative(to));

let from = RelativePath::new("../a/../../foo/bar");
let to = RelativePath::new("../../foo/baz");

assert_eq!("../baz", from.relative(to));

Examples

use relative_path::RelativePath;

assert_eq!(
    "../../e/f",
    RelativePath::new("a/b/c/d").relative(RelativePath::new("a/b/e/f"))
);

assert_eq!(
    "../bbb",
    RelativePath::new("a/../aaa").relative(RelativePath::new("b/../bbb"))
);

let a = RelativePath::new("git/relative-path");
let b = RelativePath::new("git");
assert_eq!("relative-path", b.relative(a));
assert_eq!("..", a.relative(b));

let a = RelativePath::new("foo/bar/bap/foo.h");
let b = RelativePath::new("../arch/foo.h");
assert_eq!("../../../../../arch/foo.h", a.relative(b));
assert_eq!("", b.relative(a));

Trait Implementations

impl AsRef<Path> for GlobPath

fn as_ref(&self) -> &Path

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<str> for GlobPath

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for GlobPath

fn clone(&self) -> GlobPath

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GlobPath

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for GlobPath

fn default() -> GlobPath

Returns the “default value” for a type.

impl Deref for GlobPath

type Target = RelativePathBuf

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'de> Deserialize<'de> for GlobPath

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for GlobPath

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromStr for GlobPath

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(value: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for GlobPath

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Into<String> for GlobPath

fn into(self) -> String

Converts this type into the (usually inferred) input type.

impl PartialEq<&RelativePathBuf> for GlobPath

fn eq(&self, other: &&RelativePathBuf) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<&str> for GlobPath

fn eq(&self, other: &&str) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for GlobPath

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PortablePath for GlobPath

fn parse(value: impl AsRef<str>) -> Result<Self, ParseError>

fn parse_relative(path: impl AsRef<str>) -> Result<Self, ParseError>

impl Schematic for GlobPath

fn build_schema(schema: SchemaBuilder) -> Schema

Create and return a schema that models the structure of the implementing type. The schema can be used to generate code, documentation, or other artifacts.

fn schema_name() -> Option<String>

Define a name for this schema type. Names are required for non-primitive values as a means to link references, and avoid cycles.

impl Serialize for GlobPath

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&String> for GlobPath

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from(value: &String) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&str> for GlobPath

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from(value: &str) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<String> for GlobPath

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from(value: String) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for GlobPath