Struct UrlPattern

pub struct UrlPattern<R: RegExp = Regex> {
    pub(crate) protocol: Component<R>,
    pub(crate) username: Component<R>,
    pub(crate) password: Component<R>,
    pub(crate) hostname: Component<R>,
    pub(crate) port: Component<R>,
    pub(crate) pathname: Component<R>,
    pub(crate) search: Component<R>,
    pub(crate) hash: Component<R>,
}

A UrlPattern that can be matched against.

Examples

use urlpattern::UrlPattern;
use urlpattern::UrlPatternInit;
use urlpattern::UrlPatternMatchInput;

// Create the UrlPattern to match against.
let init = UrlPatternInit {
  pathname: Some("/users/:id".to_owned()),
  ..Default::default()
};
let pattern = <UrlPattern>::parse(init, Default::default()).unwrap();

// Match the pattern against a URL.
let url = "https://example.com/users/123".parse().unwrap();
let result = pattern.exec(UrlPatternMatchInput::Url(url)).unwrap().unwrap();
assert_eq!(result.pathname.groups.get("id").unwrap().as_ref().unwrap(), "123");

Fields

protocol: Component<R>

username: Component<R>

password: Component<R>

hostname: Component<R>

port: Component<R>

pathname: Component<R>

search: Component<R>

hash: Component<R>

Implementations

impl<R: RegExp> UrlPattern<R>

pub fn parse( init: UrlPatternInit, options: UrlPatternOptions, ) -> Result<Self, Error>

Parse a UrlPatternInit into a UrlPattern.

pub(crate) fn parse_internal( init: UrlPatternInit, report_regex_errors: bool, options: UrlPatternOptions, ) -> Result<Self, Error>

pub fn protocol(&self) -> &str

The pattern used to match against the protocol of the URL.

pub fn username(&self) -> &str

The pattern used to match against the username of the URL.

pub fn password(&self) -> &str

The pattern used to match against the password of the URL.

pub fn hostname(&self) -> &str

The pattern used to match against the hostname of the URL.

pub fn port(&self) -> &str

The pattern used to match against the port of the URL.

pub fn pathname(&self) -> &str

The pattern used to match against the pathname of the URL.

pub fn search(&self) -> &str

The pattern used to match against the search string of the URL.

pub fn hash(&self) -> &str

The pattern used to match against the hash fragment of the URL.

pub fn has_regexp_groups(&self) -> bool

Returns whether the URLPattern contains one or more groups which uses regular expression matching.

pub fn test(&self, input: UrlPatternMatchInput) -> Result<bool, Error>

Test if a given [UrlPatternInput] (with optional base url), matches the pattern.

pub fn exec( &self, input: UrlPatternMatchInput, ) -> Result<Option<UrlPatternResult>, Error>

Execute the pattern against a [UrlPatternInput] (with optional base url), returning a UrlPatternResult if the pattern matches. If the pattern doesn’t match, returns None.

pub(crate) fn matches( &self, input: UrlPatternMatchInput, ) -> Result<Option<UrlPatternResult>, Error>

Trait Implementations

impl<R: Debug + RegExp> Debug for UrlPattern<R>

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

Formats the value using the given formatter.