twilight_mention/parse/
error.rs

1use std::fmt::Debug;
2use std::{
3    error::Error,
4    fmt::{Display, Formatter, Result as FmtResult},
5};
6
7/// Parsing a mention failed due to invalid syntax.
8#[derive(Debug)]
9pub struct ParseMentionError<'a> {
10    pub(super) kind: ParseMentionErrorType<'a>,
11    pub(super) source: Option<Box<dyn Error + Send + Sync>>,
12}
13
14impl<'a> ParseMentionError<'a> {
15    /// Immutable reference to the type of error that occurred.
16    #[must_use = "retrieving the type has no effect if left unused"]
17    pub const fn kind(&self) -> &ParseMentionErrorType<'_> {
18        &self.kind
19    }
20
21    /// Consume the error, returning the source error if there is any.
22    #[must_use = "consuming the error and retrieving the source has no effect if left unused"]
23    pub fn into_source(self) -> Option<Box<dyn Error + Send + Sync>> {
24        self.source
25    }
26
27    /// Consume the error, returning the owned error type and the source error.
28    #[must_use = "consuming the error into its parts has no effect if left unused"]
29    pub fn into_parts(
30        self,
31    ) -> (
32        ParseMentionErrorType<'a>,
33        Option<Box<dyn Error + Send + Sync>>,
34    ) {
35        (self.kind, self.source)
36    }
37
38    pub(super) fn trailing_arrow(found: Option<char>) -> Self {
39        Self {
40            kind: ParseMentionErrorType::TrailingArrow { found },
41            source: None,
42        }
43    }
44}
45
46impl Display for ParseMentionError<'_> {
47    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
48        match &self.kind {
49            ParseMentionErrorType::IdNotU64 { found, .. } => {
50                f.write_str("id portion ('")?;
51                Display::fmt(found, f)?;
52
53                f.write_str("') of mention is not a u64")
54            }
55            ParseMentionErrorType::ExtraneousPart { found } => {
56                f.write_str("found extraneous part ")?;
57                Debug::fmt(found, f)
58            }
59            ParseMentionErrorType::LeadingArrow { found } => {
60                f.write_str("expected to find a leading arrow ('<') but instead found ")?;
61
62                if let Some(c) = found {
63                    f.write_str("'")?;
64                    f.write_str(c.encode_utf8(&mut [0; 4]))?;
65
66                    f.write_str("'")
67                } else {
68                    f.write_str("nothing")
69                }
70            }
71            ParseMentionErrorType::PartMissing { expected, found } => {
72                f.write_str("expected ")?;
73                Display::fmt(expected, f)?;
74                f.write_str(" parts but only found ")?;
75
76                Display::fmt(found, f)
77            }
78            ParseMentionErrorType::Sigil { expected, found } => {
79                f.write_str("expected to find a mention sigil (")?;
80
81                for (idx, sigil) in expected.iter().enumerate() {
82                    f.write_str("'")?;
83                    f.write_str(sigil)?;
84                    f.write_str("'")?;
85
86                    if idx < expected.len() - 1 {
87                        f.write_str(", ")?;
88                    }
89                }
90
91                f.write_str(") but instead found ")?;
92
93                if let Some(c) = found {
94                    f.write_str("'")?;
95                    f.write_str(c.encode_utf8(&mut [0; 4]))?;
96
97                    f.write_str("'")
98                } else {
99                    f.write_str("nothing")
100                }
101            }
102            ParseMentionErrorType::TimestampStyleInvalid { found } => {
103                f.write_str("timestamp style value '")?;
104                f.write_str(found)?;
105
106                f.write_str("' is invalid")
107            }
108            ParseMentionErrorType::TrailingArrow { found } => {
109                f.write_str("expected to find a trailing arrow ('>') but instead found ")?;
110
111                if let Some(c) = found {
112                    f.write_str("'")?;
113                    f.write_str(c.encode_utf8(&mut [0; 4]))?;
114
115                    f.write_str("'")
116                } else {
117                    f.write_str("nothing")
118                }
119            }
120        }
121    }
122}
123
124impl Error for ParseMentionError<'_> {
125    fn source(&self) -> Option<&(dyn Error + 'static)> {
126        self.source
127            .as_ref()
128            .map(|source| &**source as &(dyn Error + 'static))
129    }
130}
131
132/// Type of [`ParseMentionError`] that occurred.
133#[derive(Debug, Eq, PartialEq)]
134#[non_exhaustive]
135pub enum ParseMentionErrorType<'a> {
136    /// ID portion of the mention isn't a u64.
137    IdNotU64 {
138        /// String that could not be parsed into a u64.
139        found: &'a str,
140    },
141    /// An extra part was found that shouldn't be present.
142    ExtraneousPart {
143        /// The extra part that was found.
144        found: &'a str,
145    },
146    /// Leading arrow (`<`) is not present.
147    LeadingArrow {
148        /// Character that was instead found where the leading arrow should be.
149        found: Option<char>,
150    },
151    /// One or more parts of the mention are missing.
152    ///
153    /// For example, an emoji mention - `<:name:id>` - has two parts: the `name`
154    /// and the `id`, separated by the sigil (`:`). If the second sigil denoting
155    /// the second part can't be found, then it is missing.
156    PartMissing {
157        /// Number of parts that are expected.
158        expected: usize,
159        /// Number of parts that have been found.
160        found: usize,
161    },
162    /// Mention's sigil is not present.
163    ///
164    /// Users, for example, have the sigil `@`.
165    Sigil {
166        /// Possible sigils that were expected for the mention type.
167        expected: &'a [&'a str],
168        /// Character that was instead found where the sigil should be.
169        found: Option<char>,
170    },
171    /// Timestamp style value is invalid.
172    TimestampStyleInvalid {
173        /// Value of the style.
174        found: &'a str,
175    },
176    /// Trailing arrow (`>`) is not present.
177    TrailingArrow {
178        /// Character that was instead found where the trailing arrow should be.
179        found: Option<char>,
180    },
181}
182
183#[cfg(test)]
184mod tests {
185    use super::{ParseMentionError, ParseMentionErrorType};
186    use static_assertions::{assert_fields, assert_impl_all};
187    use std::{error::Error, fmt::Debug};
188
189    assert_fields!(ParseMentionErrorType::IdNotU64: found);
190    assert_fields!(ParseMentionErrorType::ExtraneousPart: found);
191    assert_fields!(ParseMentionErrorType::LeadingArrow: found);
192    assert_fields!(ParseMentionErrorType::Sigil: expected, found);
193    assert_fields!(ParseMentionErrorType::TimestampStyleInvalid: found);
194    assert_fields!(ParseMentionErrorType::TrailingArrow: found);
195    assert_impl_all!(ParseMentionErrorType<'_>: Debug, Send, Sync);
196    assert_impl_all!(ParseMentionError<'_>: Debug, Error, Send, Sync);
197
198    #[allow(clippy::too_many_lines)]
199    #[test]
200    fn display() {
201        let mut expected = "id portion ('abcd') of mention is not a u64";
202        assert_eq!(
203            expected,
204            ParseMentionError {
205                kind: ParseMentionErrorType::IdNotU64 { found: "abcd" },
206                source: Some(Box::new("abcd".parse::<u64>().unwrap_err())),
207            }
208            .to_string(),
209        );
210
211        expected = "found extraneous part \"abc\"";
212        assert_eq!(
213            expected,
214            ParseMentionError {
215                kind: ParseMentionErrorType::ExtraneousPart { found: "abc" },
216                source: None
217            }
218            .to_string()
219        );
220
221        expected = "expected to find a leading arrow ('<') but instead found 'a'";
222        assert_eq!(
223            expected,
224            ParseMentionError {
225                kind: ParseMentionErrorType::LeadingArrow { found: Some('a') },
226                source: None,
227            }
228            .to_string(),
229        );
230
231        expected = "expected to find a leading arrow ('<') but instead found nothing";
232        assert_eq!(
233            expected,
234            ParseMentionError {
235                kind: ParseMentionErrorType::LeadingArrow { found: None },
236                source: None,
237            }
238            .to_string(),
239        );
240
241        expected = "expected to find a mention sigil ('@') but instead found '#'";
242        assert_eq!(
243            expected,
244            ParseMentionError {
245                kind: ParseMentionErrorType::Sigil {
246                    expected: &["@"],
247                    found: Some('#')
248                },
249                source: None,
250            }
251            .to_string(),
252        );
253
254        expected = "expected to find a mention sigil ('@') but instead found nothing";
255        assert_eq!(
256            expected,
257            ParseMentionError {
258                kind: ParseMentionErrorType::Sigil {
259                    expected: &["@"],
260                    found: None
261                },
262                source: None,
263            }
264            .to_string(),
265        );
266
267        expected = "expected to find a mention sigil ('@') but instead found '#'";
268        assert_eq!(
269            expected,
270            ParseMentionError {
271                kind: ParseMentionErrorType::Sigil {
272                    expected: &["@"],
273                    found: Some('#'),
274                },
275                source: None,
276            }
277            .to_string(),
278        );
279
280        expected = "expected to find a mention sigil ('@') but instead found nothing";
281        assert_eq!(
282            expected,
283            ParseMentionError {
284                kind: ParseMentionErrorType::Sigil {
285                    expected: &["@"],
286                    found: None
287                },
288                source: None,
289            }
290            .to_string(),
291        );
292        expected = "timestamp style value 'E' is invalid";
293        assert_eq!(
294            expected,
295            ParseMentionError {
296                kind: ParseMentionErrorType::TimestampStyleInvalid { found: "E" },
297                source: None,
298            }
299            .to_string(),
300        );
301
302        expected = "expected to find a trailing arrow ('>') but instead found 'a'";
303        assert_eq!(
304            expected,
305            ParseMentionError {
306                kind: ParseMentionErrorType::TrailingArrow { found: Some('a') },
307                source: None,
308            }
309            .to_string(),
310        );
311
312        expected = "expected to find a trailing arrow ('>') but instead found nothing";
313        assert_eq!(
314            expected,
315            ParseMentionError {
316                kind: ParseMentionErrorType::TrailingArrow { found: None },
317                source: None,
318            }
319            .to_string(),
320        );
321    }
322}
twilight_mention/parse/error.rs

twilight_mention/parse/
error.rs
