use std::{error::Error, fmt};
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum ErrorKind {
Empty,
TooLong,
InvalidScheme,
SchemeMissing,
InvalidChar(char),
InvalidPercentEncoding,
InvalidAuthority,
AuthorityMissing,
InvalidHost,
InvalidIpv4,
InvalidIpv6,
InvalidPort,
PortOutOfRange,
InvalidPath,
}
impl fmt::Display for ErrorKind {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
ErrorKind::Empty => f.write_str("empty string"),
ErrorKind::TooLong => f.write_str("url is too long"),
ErrorKind::InvalidScheme => f.write_str("invalid scheme"),
ErrorKind::SchemeMissing => f.write_str("scheme missing"),
ErrorKind::InvalidChar(c) => write!(f, "invalid character {c:?}"),
ErrorKind::InvalidPercentEncoding => f.write_str("invalid percent-encoding"),
ErrorKind::InvalidAuthority => f.write_str("invalid authority"),
ErrorKind::AuthorityMissing => f.write_str("authority missing"),
ErrorKind::InvalidHost => f.write_str("invalid host"),
ErrorKind::InvalidIpv4 => f.write_str("invalid IPv4 address"),
ErrorKind::InvalidIpv6 => f.write_str("invalid IPv6 address"),
ErrorKind::InvalidPort => f.write_str("invalid port"),
ErrorKind::PortOutOfRange => f.write_str("port out of range"),
ErrorKind::InvalidPath => f.write_str("invalid path"),
}
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub struct InvalidUrl {
kind: ErrorKind,
position: Option<usize>,
}
impl InvalidUrl {
pub(crate) const fn new(kind: ErrorKind) -> Self {
InvalidUrl {
kind,
position: None,
}
}
pub(crate) const fn at(kind: ErrorKind, position: usize) -> Self {
InvalidUrl {
kind,
position: Some(position),
}
}
pub(crate) fn offset(mut self, offset: usize) -> Self {
if let Some(pos) = self.position.as_mut() {
*pos += offset;
}
self
}
pub fn kind(&self) -> ErrorKind {
self.kind
}
pub fn position(&self) -> Option<usize> {
self.position
}
}
impl fmt::Display for InvalidUrl {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
if let Some(pos) = self.position {
write!(f, "{} at position {pos}", self.kind)
} else {
fmt::Display::fmt(&self.kind, f)
}
}
}
impl Error for InvalidUrl {}
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub struct InvalidUrlParts(InvalidUrl);
impl InvalidUrlParts {
pub fn kind(&self) -> ErrorKind {
self.0.kind
}
pub fn into_inner(self) -> InvalidUrl {
self.0
}
}
impl From<InvalidUrl> for InvalidUrlParts {
fn from(err: InvalidUrl) -> Self {
InvalidUrlParts(err)
}
}
impl fmt::Display for InvalidUrlParts {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "invalid url parts: {}", self.0)
}
}
impl Error for InvalidUrlParts {
fn source(&self) -> Option<&(dyn Error + 'static)> {
Some(&self.0)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn display() {
let cases = [
(ErrorKind::Empty, "empty string"),
(ErrorKind::TooLong, "url is too long"),
(ErrorKind::InvalidScheme, "invalid scheme"),
(ErrorKind::SchemeMissing, "scheme missing"),
(ErrorKind::InvalidChar('x'), "invalid character 'x'"),
(
ErrorKind::InvalidPercentEncoding,
"invalid percent-encoding",
),
(ErrorKind::InvalidAuthority, "invalid authority"),
(ErrorKind::AuthorityMissing, "authority missing"),
(ErrorKind::InvalidHost, "invalid host"),
(ErrorKind::InvalidIpv4, "invalid IPv4 address"),
(ErrorKind::InvalidIpv6, "invalid IPv6 address"),
(ErrorKind::InvalidPort, "invalid port"),
(ErrorKind::PortOutOfRange, "port out of range"),
(ErrorKind::InvalidPath, "invalid path"),
];
for (kind, msg) in cases {
assert_eq!(kind.to_string(), msg);
assert_eq!(InvalidUrl::new(kind).to_string(), msg);
}
let err = InvalidUrl::at(ErrorKind::InvalidPort, 3).offset(2);
assert_eq!(err.to_string(), "invalid port at position 5");
assert_eq!(InvalidUrl::new(ErrorKind::Empty).offset(2).position(), None);
let parts = InvalidUrlParts::from(err);
assert_eq!(parts.kind(), ErrorKind::InvalidPort);
assert_eq!(parts.into_inner(), err);
}
}