cookie_rs/cookie/parse/
error.rs

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