Struct addr_spec::AddrSpec

source ·

pub struct AddrSpec { /* private fields */ }

Expand description

Address specification as defined in RFC 5322 with UTF-8 support as defined in RFC 6532.

Both the local part and the domain are normalized using the NFC as recommended in Section 3.1, RFC 6532. Address strings built using this crate work well for unique, UTF-8 identifiers.

Examples

use std::str::FromStr;

use addr_spec::AddrSpec;

let addr_spec = AddrSpec::from_str("test@example.com").unwrap();
assert_eq!(addr_spec.local_part(), "test");
assert_eq!(addr_spec.domain(), "example.com");
assert_eq!(addr_spec.is_literal(), false);
assert_eq!(addr_spec.to_string(), "test@example.com");

Quoted local parts will be unescaped if possible:

use std::str::FromStr;

use addr_spec::AddrSpec;

let addr_spec = AddrSpec::from_str(r#""test"@example.com"#).unwrap();
assert_eq!(addr_spec.local_part(), "test");
assert_eq!(addr_spec.domain(), "example.com");
assert_eq!(addr_spec.is_literal(), false);
assert_eq!(addr_spec.to_string(), "test@example.com");

Literal domains are also supported:

use std::str::FromStr;

use addr_spec::AddrSpec;

let addr_spec = AddrSpec::from_str("test@[IPv6:2001:db8::1]").unwrap();
assert_eq!(addr_spec.local_part(), "test");
assert_eq!(addr_spec.domain(), "IPv6:2001:db8::1");
assert_eq!(addr_spec.is_literal(), true);
assert_eq!(addr_spec.to_string(), "test@[IPv6:2001:db8::1]");

You can also create an address specification from its parts:

use addr_spec::AddrSpec;

let addr_spec = AddrSpec::new("test", "example.com").unwrap();
assert_eq!(addr_spec.local_part(), "test");
assert_eq!(addr_spec.domain(), "example.com");
assert_eq!(addr_spec.is_literal(), false);
assert_eq!(addr_spec.to_string(), "test@example.com");

If you want to just normalize an address, you can use the normalize function:

use addr_spec::AddrSpec;

assert_eq!(
    &AddrSpec::normalize("\"test\"@example.com").unwrap(),
    "test@example.com"
);

Implementations§

source §

impl AddrSpec

source

pub fn normalize<Address>(address: Address) -> Result<String, ParseError>where
Address: AsRef<str>,

Normalizes the address.

This is a convenience function that parses the address and then serializes it again.

It is equivalent to address.parse::<AddrSpec>()?.to_string().

pub fn new<LocalPart, Domain>(
 local_part: LocalPart,
 domain: Domain
) -> Result<Self, ParseError>where
 LocalPart: AsRef<str>,
 Domain: AsRef<str>,

Creates a new address specification. This will validate the local part and domain and perform NFC-normalization.

source

pub fn with_literal<LocalPart, Domain>(
 local_part: LocalPart,
 domain: Domain
) -> Result<Self, ParseError>where
 LocalPart: AsRef<str>,
 Domain: AsRef<str>,

Creates a new address specification with a literal domain. This will validate the local part and domain and perform NFC-normalization.

source

pub unsafe fn new_unchecked<LocalPart, Domain>(
 local_part: LocalPart,
 domain: Domain
) -> Selfwhere
 LocalPart: Into<String>,
 Domain: Into<String>,

Creates a new address specification without performing any validation or normalization.

This function is unsafe because it does not validate nor normalize the local part or domain. If the local part or domain contains invalid characters or is not NFC-normalized, the resulting address specification will be invalid.

Only use this function if you are sure that the local part and domain are valid and NFC-normalized. This is typically the case if you are getting them from a trusted source.

source

pub unsafe fn with_literal_unchecked<LocalPart, Domain>(
 local_part: LocalPart,
 domain: Domain
) -> Selfwhere
 LocalPart: Into<String>,
 Domain: Into<String>,

Creates a new address specification with a domain literal without performing any validation or normalization.

Safety

This function is unsafe because it does not validate nor normalize the local part or domain. If the local part or domain contains invalid characters or is not NFC-normalized, the resulting address specification will be invalid.

Only use this function if you are sure that the local part and domain are valid and NFC-normalized. This is typically the case if you are getting them from a trusted source.

source