Struct Uri

Source

pub struct Uri(/* private fields */);

Expand description

Newtype struct around fluent_uri::Uri<String> with serialization implementations that use as_str() and ‘from_str()’ respectively.

Implementations§

Source §

impl Uri

Provide methods to Uri to fill blanks left by fluent_uri (the underlying type) especially when converting to and from file paths.

Source

pub fn to_file_path(&self) -> Option<Cow<'_, Path>>

Assuming the URL is in the file scheme or similar, convert its path to an absolute std::path::Path.

Note: This does not actually check the URL’s scheme, and may give nonsensical results for other schemes. It is the user’s responsibility to check the URL’s scheme before calling this.

e.g. Uri("file:///etc/passwd") becomes PathBuf("/etc/passwd")

Source

pub fn from_file_path<A: AsRef<Path>>(path: A) -> Option<Self>

Convert a file path to a Uri.

Returns None if the file does not exist.

Methods from Deref<Target = Uri<String>>§

Source

pub fn borrow(&self) -> Uri<&str>

Borrows this Uri<String> as Uri<&str>.

Source

pub fn as_str(&'i self) -> &'o str

Returns the URI as a string slice.

Source

pub fn scheme(&'i self) -> &'o Scheme

Returns the scheme component.

Note that the scheme component is case-insensitive. See the documentation of Scheme for more details on comparison.

§Examples

use fluent_uri::{component::Scheme, Uri};

const SCHEME_HTTP: &Scheme = Scheme::new_or_panic("http");

let uri = Uri::parse("http://example.com/")?;
assert_eq!(uri.scheme(), SCHEME_HTTP);

Source

pub fn authority(&'i self) -> Option<Authority<'o>>

Returns the optional authority component.

§Examples

use fluent_uri::Uri;

let uri = Uri::parse("http://example.com/")?;
assert!(uri.authority().is_some());

let uri = Uri::parse("mailto:user@example.com")?;
assert!(uri.authority().is_none());

Source

pub fn path(&'i self) -> &'o EStr<Path>

Returns the path component.

The path component is always present, although it may be empty.

The returned EStr slice has extension methods for the path component.

§Examples

use fluent_uri::Uri;

let uri = Uri::parse("http://example.com/")?;
assert_eq!(uri.path(), "/");

let uri = Uri::parse("mailto:user@example.com")?;
assert_eq!(uri.path(), "user@example.com");

let uri = Uri::parse("http://example.com")?;
assert_eq!(uri.path(), "");

Source

pub fn query(&'i self) -> Option<&'o EStr<Query>>

Returns the optional query component.

§Examples

use fluent_uri::{encoding::EStr, Uri};

let uri = Uri::parse("http://example.com/?lang=en")?;
assert_eq!(uri.query(), Some(EStr::new_or_panic("lang=en")));

let uri = Uri::parse("ftp://192.0.2.1/")?;
assert_eq!(uri.query(), None);

Source

pub fn fragment(&'i self) -> Option<&'o EStr<Fragment>>

Returns the optional fragment component.

§Examples

use fluent_uri::{encoding::EStr, Uri};

let uri = Uri::parse("http://example.com/#usage")?;
assert_eq!(uri.fragment(), Some(EStr::new_or_panic("usage")));

let uri = Uri::parse("ftp://192.0.2.1/")?;
assert_eq!(uri.fragment(), None);

Source

pub fn normalize(&self) -> Uri<String>

Normalizes the URI.

This method applies the syntax-based normalization described in Section 6.2.2 of RFC 3986 and Section 5.3.2 of RFC 3987, which is effectively equivalent to taking the following steps in order:

Decode any percent-encoded octets that correspond to an allowed character which is not reserved.
Uppercase the hexadecimal digits within all percent-encoded octets.
Lowercase all ASCII characters within the scheme and the host except the percent-encoded octets.
Turn any IPv6 literal address into its canonical form as per RFC 5952.
If the port is empty, remove its ':' delimiter.
If self contains a scheme and an absolute path, apply the remove_dot_segments algorithm to the path, taking account of percent-encoded dot segments as described at UriRef::resolve_against.
If self contains no authority and its path would start with "//", prepend "/." to the path.

This method is idempotent: self.normalize() equals self.normalize().normalize().

§Examples

use fluent_uri::Uri;

let uri = Uri::parse("eXAMPLE://a/./b/../b/%63/%7bfoo%7d")?;
assert_eq!(uri.normalize(), "example://a/b/c/%7Bfoo%7D");

Source

pub fn has_authority(&self) -> bool

Checks whether an authority component is present.

§Examples

use fluent_uri::Uri;

assert!(Uri::parse("http://example.com/")?.has_authority());
assert!(!Uri::parse("mailto:user@example.com")?.has_authority());

Source

pub fn has_query(&self) -> bool

Checks whether a query component is present.

§Examples

use fluent_uri::Uri;

assert!(Uri::parse("http://example.com/?lang=en")?.has_query());
assert!(!Uri::parse("ftp://192.0.2.1/")?.has_query());

Source

pub fn has_fragment(&self) -> bool

Checks whether a fragment component is present.

§Examples

use fluent_uri::Uri;

assert!(Uri::parse("http://example.com/#usage")?.has_fragment());
assert!(!Uri::parse("ftp://192.0.2.1/")?.has_fragment());

Source

pub fn with_fragment(&self, opt: Option<&EStr<Fragment>>) -> Uri<String>

Creates a new URI by replacing the fragment component of self with the given one.

The fragment component is removed when opt.is_none().

§Examples

use fluent_uri::{encoding::EStr, Uri};

let uri = Uri::parse("http://example.com/")?;
assert_eq!(
    uri.with_fragment(Some(EStr::new_or_panic("fragment"))),
    "http://example.com/#fragment"
);

let uri = Uri::parse("http://example.com/#fragment")?;
assert_eq!(
    uri.with_fragment(None),
    "http://example.com/"
);

Source

pub fn set_fragment(&mut self, opt: Option<&EStr<Fragment>>)

Replaces the fragment component of self with the given one.

The fragment component is removed when opt.is_none().

§Examples

use fluent_uri::{encoding::EStr, Uri};

let mut uri = Uri::parse("http://example.com/")?.to_owned();

uri.set_fragment(Some(EStr::new_or_panic("fragment")));
assert_eq!(uri, "http://example.com/#fragment");

uri.set_fragment(None);
assert_eq!(uri, "http://example.com/");