spinoso_regexp/
error.rs

1use core::fmt;
2use std::borrow::Cow;
3use std::error;
4
5/// Sum type of all errors possibly returned from `Regexp` APIs.
6#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
7pub enum Error {
8    /// Error that indicates an argument parsing or value logic error occurred.
9    ///
10    /// See [`ArgumentError`].
11    Argument(ArgumentError),
12    /// Error that indicates a `Regexp` was malformed at runtime.
13    ///
14    /// See [`RegexpError`].
15    Regexp(RegexpError),
16    /// Error that indicates a given `Regexp` pattern could not be parsed when
17    /// given as a `/.../` literal in Ruby source code.
18    ///
19    /// See [`SyntaxError`].
20    Syntax(SyntaxError),
21}
22
23impl From<ArgumentError> for Error {
24    #[inline]
25    fn from(err: ArgumentError) -> Self {
26        Self::Argument(err)
27    }
28}
29
30impl From<RegexpError> for Error {
31    #[inline]
32    fn from(err: RegexpError) -> Self {
33        Self::Regexp(err)
34    }
35}
36
37impl From<SyntaxError> for Error {
38    #[inline]
39    fn from(err: SyntaxError) -> Self {
40        Self::Syntax(err)
41    }
42}
43
44impl fmt::Display for Error {
45    #[inline]
46    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
47        f.write_str("Regexp error")
48    }
49}
50
51impl error::Error for Error {
52    #[inline]
53    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
54        match self {
55            Self::Argument(err) => Some(err),
56            Self::Regexp(err) => Some(err),
57            Self::Syntax(err) => Some(err),
58        }
59    }
60}
61
62/// Error that indicates an argument parsing or value logic error occurred.
63///
64/// Argument errors have an associated message.
65///
66/// This error corresponds to the [Ruby `ArgumentError` Exception class].
67///
68/// # Examples
69///
70/// ```
71/// # use spinoso_regexp::ArgumentError;
72/// let err = ArgumentError::new();
73/// assert_eq!(err.message(), "ArgumentError");
74///
75/// let err = ArgumentError::with_message("invalid byte sequence in UTF-8");
76/// assert_eq!(err.message(), "invalid byte sequence in UTF-8");
77/// ```
78///
79/// [Ruby `ArgumentError` Exception class]: https://ruby-doc.org/core-3.1.2/ArgumentError.html
80#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
81pub struct ArgumentError(Cow<'static, str>);
82
83impl From<&'static str> for ArgumentError {
84    #[inline]
85    fn from(message: &'static str) -> Self {
86        Self::with_message(message)
87    }
88}
89
90impl From<String> for ArgumentError {
91    fn from(message: String) -> Self {
92        Self(Cow::Owned(message))
93    }
94}
95
96impl Default for ArgumentError {
97    #[inline]
98    fn default() -> Self {
99        Self::new()
100    }
101}
102
103impl fmt::Display for ArgumentError {
104    #[inline]
105    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
106        f.write_str(self.message())
107    }
108}
109
110impl error::Error for ArgumentError {}
111
112impl ArgumentError {
113    /// Construct a new, default argument error.
114    ///
115    /// # Examples
116    ///
117    /// ```
118    /// # use spinoso_regexp::ArgumentError;
119    /// const ERR: ArgumentError = ArgumentError::new();
120    /// assert_eq!(ERR.message(), "ArgumentError");
121    /// ```
122    #[inline]
123    #[must_use]
124    pub const fn new() -> Self {
125        Self(Cow::Borrowed("ArgumentError"))
126    }
127
128    /// Construct a new argument error with a message.
129    ///
130    /// # Examples
131    ///
132    /// ```
133    /// # use spinoso_regexp::ArgumentError;
134    /// const ERR: ArgumentError = ArgumentError::with_message("invalid byte sequence in UTF-8");
135    /// assert_eq!(ERR.message(), "invalid byte sequence in UTF-8");
136    /// ```
137    #[inline]
138    #[must_use]
139    pub const fn with_message(message: &'static str) -> Self {
140        Self(Cow::Borrowed(message))
141    }
142
143    #[must_use]
144    pub(crate) const fn unsupported_pattern_encoding() -> Self {
145        Self::with_message("Unsupported pattern encoding")
146    }
147
148    #[must_use]
149    pub(crate) const fn unsupported_haystack_encoding() -> Self {
150        Self::with_message("Unsupported haystack encoding")
151    }
152
153    /// Retrieve the exception message associated with this argument error.
154    ///
155    /// # Examples
156    ///
157    /// ```
158    /// # use spinoso_regexp::ArgumentError;
159    /// let err = ArgumentError::new();
160    /// assert_eq!(err.message(), "ArgumentError");
161    ///
162    /// let err = ArgumentError::with_message("invalid byte sequence in UTF-8");
163    /// assert_eq!(err.message(), "invalid byte sequence in UTF-8");
164    /// ```
165    #[inline]
166    #[must_use]
167    pub fn message(&self) -> &str {
168        self.0.as_ref()
169    }
170}
171
172/// Error that indicates a `Regexp` was malformed at runtime.
173///
174/// This error is typically generated by [`Regexp::compile`].
175///
176/// This error corresponds to the [Ruby `RegexpError` Exception class].
177///
178/// # Examples
179///
180/// ```
181/// # use spinoso_regexp::RegexpError;
182/// let err = RegexpError::new();
183/// assert_eq!(err.message(), "RegexpError");
184///
185/// let err = RegexpError::with_message(r"invalid multibyte character: /\xFF\xFE/");
186/// assert_eq!(err.message(), r"invalid multibyte character: /\xFF\xFE/");
187/// ```
188///
189/// [`Regexp::compile`]: https://ruby-doc.org/core-3.1.2/Regexp.html#method-c-compile
190/// [Ruby `RegexpError` Exception class]: https://ruby-doc.org/core-3.1.2/RegexpError.html
191#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
192pub struct RegexpError(Cow<'static, str>);
193
194impl From<&'static str> for RegexpError {
195    #[inline]
196    fn from(message: &'static str) -> Self {
197        Self::with_message(message)
198    }
199}
200
201impl From<String> for RegexpError {
202    fn from(message: String) -> Self {
203        Self(Cow::Owned(message))
204    }
205}
206
207impl fmt::Display for RegexpError {
208    #[inline]
209    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
210        f.write_str(self.message())
211    }
212}
213
214impl error::Error for RegexpError {}
215
216impl Default for RegexpError {
217    fn default() -> Self {
218        Self::new()
219    }
220}
221
222impl RegexpError {
223    /// Construct a new, default regexp error.
224    ///
225    /// # Examples
226    ///
227    /// ```
228    /// # use spinoso_regexp::RegexpError;
229    /// const ERR: RegexpError = RegexpError::new();
230    /// assert_eq!(ERR.message(), "RegexpError");
231    /// ```
232    #[inline]
233    #[must_use]
234    pub const fn new() -> Self {
235        Self(Cow::Borrowed("RegexpError"))
236    }
237
238    /// Construct a new regexp error with a message.
239    ///
240    /// # Examples
241    ///
242    /// ```
243    /// # use spinoso_regexp::RegexpError;
244    /// const ERR: RegexpError = RegexpError::with_message(r"invalid multibyte character: /\xFF\xFE/");
245    /// assert_eq!(ERR.message(), r"invalid multibyte character: /\xFF\xFE/");
246    /// ```
247    #[inline]
248    #[must_use]
249    pub const fn with_message(message: &'static str) -> Self {
250        Self(Cow::Borrowed(message))
251    }
252
253    /// Retrieve the exception message associated with this regexp error.
254    ///
255    /// # Examples
256    ///
257    /// ```
258    /// # use spinoso_regexp::RegexpError;
259    /// let err = RegexpError::new();
260    /// assert_eq!(err.message(), "RegexpError");
261    ///
262    /// let err = RegexpError::with_message(r"invalid multibyte character: /\xFF\xFE/");
263    /// assert_eq!(err.message(), r"invalid multibyte character: /\xFF\xFE/");
264    /// ```
265    #[inline]
266    #[must_use]
267    pub fn message(&self) -> &str {
268        &self.0
269    }
270}
271
272/// Error that indicates a given `Regexp` pattern could not be parsed when given
273/// as a `/.../` literal in Ruby source code.
274///
275/// This error is typically generated at parse-time.
276///
277/// This error corresponds to the [Ruby `SyntaxError` Exception class].
278///
279/// # Examples
280///
281/// ```
282/// # use spinoso_regexp::SyntaxError;
283/// let err = SyntaxError::new();
284/// assert_eq!(err.message(), "SyntaxError");
285///
286/// let err = SyntaxError::with_message("premature end of char-class");
287/// assert_eq!(err.message(), "premature end of char-class");
288/// ```
289///
290/// [Ruby `SyntaxError` Exception class]: https://ruby-doc.org/core-3.1.2/SyntaxError.html
291#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
292pub struct SyntaxError(Cow<'static, str>);
293
294impl From<&'static str> for SyntaxError {
295    #[inline]
296    fn from(message: &'static str) -> Self {
297        Self::with_message(message)
298    }
299}
300
301impl From<String> for SyntaxError {
302    fn from(message: String) -> Self {
303        Self(Cow::Owned(message))
304    }
305}
306
307impl fmt::Display for SyntaxError {
308    #[inline]
309    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
310        f.write_str(self.message())
311    }
312}
313
314impl error::Error for SyntaxError {}
315
316impl Default for SyntaxError {
317    fn default() -> Self {
318        Self::new()
319    }
320}
321
322impl SyntaxError {
323    /// Construct a new, default syntax error.
324    ///
325    /// # Examples
326    ///
327    /// ```
328    /// # use spinoso_regexp::SyntaxError;
329    /// const ERR: SyntaxError = SyntaxError::new();
330    /// assert_eq!(ERR.message(), "SyntaxError");
331    /// ```
332    #[inline]
333    #[must_use]
334    pub const fn new() -> Self {
335        Self(Cow::Borrowed("SyntaxError"))
336    }
337
338    /// Construct a new syntax error with a message.
339    ///
340    /// # Examples
341    ///
342    /// ```
343    /// # use spinoso_regexp::SyntaxError;
344    /// const ERR: SyntaxError = SyntaxError::with_message("premature end of char-class");
345    /// assert_eq!(ERR.message(), "premature end of char-class");
346    /// ```
347    #[inline]
348    #[must_use]
349    pub const fn with_message(message: &'static str) -> Self {
350        Self(Cow::Borrowed(message))
351    }
352
353    /// Retrieve the exception message associated with this syntax error.
354    ///
355    /// # Examples
356    ///
357    /// ```
358    /// # use spinoso_regexp::SyntaxError;
359    /// let err = SyntaxError::new();
360    /// assert_eq!(err.message(), "SyntaxError");
361    ///
362    /// let err = SyntaxError::with_message("premature end of char-class");
363    /// assert_eq!(err.message(), "premature end of char-class");
364    /// ```
365    #[inline]
366    #[must_use]
367    pub fn message(&self) -> &str {
368        &self.0
369    }
370}
spinoso_regexp/error.rs

spinoso_regexp/
error.rs
