Skip to main content

cookie_rs/cookie/parse/
error.rs

1use std::error::Error;
2use std::fmt;
3use std::num::ParseIntError;
4
5#[non_exhaustive]
6#[derive(Debug, Clone, PartialEq, Eq)]
7pub enum ParseError {
8    EmptyName,
9    MissingPair(MissingPair),
10    UnknownAttribute(String),
11    ParseMaxAgeError(ParseIntError),
12    ParseSameSiteError(ParseSameSiteError),
13    ParseDecodeError,
14}
15
16#[derive(Debug, Clone, PartialEq, Eq)]
17pub enum ParseSameSiteError {
18    UnknownValue(String),
19}
20
21#[derive(Debug, Clone, PartialEq, Eq)]
22pub enum MissingPair {
23    NameValue,
24    Domain,
25    Expires,
26    MaxAge,
27    Path,
28    SameSite,
29}
30
31impl Error for ParseError {}
32
33impl Error for ParseSameSiteError {}
34
35impl From<MissingPair> for ParseError {
36    fn from(value: MissingPair) -> Self {
37        Self::MissingPair(value)
38    }
39}
40
41impl From<ParseIntError> for ParseError {
42    fn from(value: ParseIntError) -> Self {
43        Self::ParseMaxAgeError(value)
44    }
45}
46
47impl From<ParseSameSiteError> for ParseError {
48    fn from(value: ParseSameSiteError) -> Self {
49        Self::ParseSameSiteError(value)
50    }
51}
52
53impl fmt::Display for ParseError {
54    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
55        match self {
56            ParseError::EmptyName => write!(f, "the provided name is empty."),
57            ParseError::MissingPair(pair) => write!(f, "missed pair: {pair}"),
58            ParseError::UnknownAttribute(attr) => write!(f, "unknown attribute: {attr}"),
59            ParseError::ParseMaxAgeError(err) => write!(f, "failed to parse Max-Age: {err}"),
60            ParseError::ParseSameSiteError(err) => write!(f, "failed to parse SameSite: {err}"),
61            ParseError::ParseDecodeError => write!(f, "failed to decode percent-encoded value."),
62        }
63    }
64}
65
66impl fmt::Display for ParseSameSiteError {
67    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
68        match self {
69            ParseSameSiteError::UnknownValue(value) => {
70                write!(f, "unknown SameSite value: {value}")
71            }
72        }
73    }
74}
75
76impl fmt::Display for MissingPair {
77    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
78        let pair_name = match self {
79            MissingPair::NameValue => "Name-Value",
80            MissingPair::Domain => "Domain",
81            MissingPair::Expires => "Expires",
82            MissingPair::MaxAge => "Max-Age",
83            MissingPair::Path => "Path",
84            MissingPair::SameSite => "SameSite",
85        };
86        write!(f, "{pair_name}")
87    }
88}