Struct Rel 

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

Link relation type.

WebFinger relation types are either absolute URI strings or IANA-registered relation type names. RFC 7033 requires each rel member to contain exactly one relation type, so this type rejects empty strings, relative URI references, and strings that try to carry multiple relation types.

Rel serializes as a JSON string and implements AsRef<str> for comparison or lookup without allocating. Builder methods accept strings for common use, but store this validated type so deserialized and programmatically built links use the same representation.

Registered relation type names use the reg-rel-type syntax from RFC 5988 section 5.3. URI-valued relation types are validated as absolute URI strings under RFC 3986, including the section 2.1 percent-encoding rule.

See RFC 7033 section 4.4.4.1.

Examples

use webfinger_rs::Rel;

let registered = Rel::try_new("author")?;
let uri = Rel::try_new("http://webfinger.net/rel/profile-page")?;

assert_eq!(registered.as_ref(), "author");
assert_eq!(uri.as_ref(), "http://webfinger.net/rel/profile-page");

Multiple relation types belong in multiple request rel parameters or multiple links, not in one Rel value:

use webfinger_rs::Rel;

assert!(Rel::try_new("author avatar").is_err());

Implementations

impl Rel

pub fn new<S: AsRef<str>>(rel: S) -> Self

Creates a link relation type.

This constructor is convenient for application-controlled relation strings. Use Rel::try_new when parsing external input.

Panics

Panics if rel is not a URI relation type or registered relation type name. Use Rel::try_new when handling untrusted input.

Examples found in repository

examples/actix.rs (line 77)

async fn webfinger(request: WebFingerRequest) -> actix_web::Result<WebFingerResponse> {
    info!("fetching webfinger resource: {:?}", request);
    let subject = request.resource.to_string();
    if subject != SUBJECT {
        let message = format!("{subject} does not exist");
        return Err(actix_web::error::ErrorNotFound(message))?;
    }
    let mut links = Vec::new();

    let profile_rel = Rel::new(PROFILE_PAGE_REL);
    if request.rels.is_empty() || request.rels.contains(&profile_rel) {
        links.push(
            Link::builder(profile_rel)
                .href(PROFILE_HREF)
                .title("en", "Carol's profile")
                .build(),
        );
    }

    let avatar_rel = Rel::new(AVATAR_REL);
    if request.rels.is_empty() || request.rels.contains(&avatar_rel) {
        links.push(
            Link::builder(avatar_rel)
                .href(AVATAR_HREF)
                .r#type("image/png")
                .build(),
        );
    }

    let response = WebFingerResponse::builder(subject)
        .alias(PROFILE_HREF)
        .property(ROLE_PROPERTY, "maintainer")
        .links(links)
        .build();
    Ok(response)
}

examples/axum.rs (line 80)

async fn webfinger(request: WebFingerRequest) -> axum::response::Result<WebFingerResponse> {
    info!("fetching webfinger resource: {:?}", request);
    let subject = request.resource.to_string();
    if subject != SUBJECT {
        let message = format!("{subject} does not exist");
        return Err((StatusCode::NOT_FOUND, message).into());
    }
    let mut links = Vec::new();

    let profile_rel = Rel::new(PROFILE_PAGE_REL);
    if request.rels.is_empty() || request.rels.contains(&profile_rel) {
        links.push(
            Link::builder(profile_rel)
                .href(PROFILE_HREF)
                .title("en", "Carol's profile")
                .build(),
        );
    }

    let avatar_rel = Rel::new(AVATAR_REL);
    if request.rels.is_empty() || request.rels.contains(&avatar_rel) {
        links.push(
            Link::builder(avatar_rel)
                .href(AVATAR_HREF)
                .r#type("image/png")
                .build(),
        );
    }

    let response = WebFingerResponse::builder(subject)
        .alias(PROFILE_HREF)
        .property(ROLE_PROPERTY, "maintainer")
        .links(links)
        .build();
    Ok(response)
}

pub fn try_new<S: AsRef<str>>(rel: S) -> Result<Self, Error>

Tries to create a link relation type.

URI relation types must be absolute URI strings. Registered relation type names follow the reg-rel-type syntax from RFC 5988: a lowercase ASCII letter followed by lowercase ASCII letters, digits, ., or -.

Trait Implementations

impl AsRef<str> for Rel

fn as_ref(&self) -> &str

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

impl Borrow<str> for Rel

fn borrow(&self) -> &str

Immutably borrows from an owned value.

impl Clone for Rel

fn clone(&self) -> Rel

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Rel

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Rel

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Rel

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

Formats the value using the given formatter.

impl Eq for Rel

impl From<Rel> for String

fn from(rel: Rel) -> Self

Converts to this type from the input type.

impl FromStr for Rel

type Err = Error

The associated error which can be returned from parsing.

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

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

impl Hash for Rel

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 Ord for Rel

fn cmp(&self, other: &Rel) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Rel

fn eq(&self, other: &Rel) -> 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 PartialOrd for Rel

fn partial_cmp(&self, other: &Rel) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Rel

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Rel

impl TryFrom<&str> for Rel

type Error = Error

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<String> for Rel

type Error = Error

The type returned in the event of a conversion error.

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

Performs the conversion.