use std::borrow::Cow;
use std::fmt;
use thiserror::Error;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum ParseErrorCode {
Required,
InvalidFormat,
InvalidValue,
TooLong,
}
impl ParseErrorCode {
#[must_use]
pub const fn as_str(self) -> &'static str {
match self {
Self::Required => "parse.required",
Self::InvalidFormat => "parse.invalid_format",
Self::InvalidValue => "parse.invalid_value",
Self::TooLong => "parse.too_long",
}
}
}
impl fmt::Display for ParseErrorCode {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct ParseErrorParameter {
name: Cow<'static, str>,
value: Cow<'static, str>,
}
impl ParseErrorParameter {
#[must_use]
pub fn name(&self) -> &str {
self.name.as_ref()
}
#[must_use]
pub fn value(&self) -> &str {
self.value.as_ref()
}
}
#[derive(Clone, Debug, Error, PartialEq, Eq)]
#[error("{code}")]
pub struct ParseError {
code: ParseErrorCode,
field: Option<Cow<'static, str>>,
parameters: Vec<ParseErrorParameter>,
}
impl ParseError {
#[must_use]
pub const fn new(code: ParseErrorCode) -> Self {
Self {
code,
field: None,
parameters: Vec::new(),
}
}
#[must_use]
pub fn for_field(field: impl Into<Cow<'static, str>>, code: ParseErrorCode) -> Self {
Self {
code,
field: Some(field.into()),
parameters: Vec::new(),
}
}
#[must_use]
pub fn with_parameter(
mut self,
name: impl Into<Cow<'static, str>>,
value: impl Into<Cow<'static, str>>,
) -> Self {
let name = name.into();
let value = value.into();
if let Some(parameter) = self
.parameters
.iter_mut()
.find(|parameter| parameter.name == name)
{
parameter.value = value;
} else {
self.parameters.push(ParseErrorParameter { name, value });
}
self
}
#[must_use]
pub const fn code(&self) -> ParseErrorCode {
self.code
}
#[must_use]
pub const fn code_str(&self) -> &'static str {
self.code.as_str()
}
#[must_use]
pub fn field(&self) -> Option<&str> {
self.field.as_deref()
}
#[must_use]
pub fn parameters(&self) -> &[ParseErrorParameter] {
self.parameters.as_slice()
}
#[must_use]
pub fn parameter(&self, name: &str) -> Option<&str> {
self.parameters
.iter()
.find(|parameter| parameter.name == name)
.map(ParseErrorParameter::value)
}
}
impl From<ParseErrorCode> for ParseError {
fn from(code: ParseErrorCode) -> Self {
Self::new(code)
}
}
pub type ParseResult<T> = Result<T, ParseError>;
#[cfg(test)]
mod tests {
use super::{ParseError, ParseErrorCode};
#[test]
fn exposes_stable_machine_readable_context() {
let error = ParseError::for_field("display_name", ParseErrorCode::TooLong)
.with_parameter("max", "40")
.with_parameter("actual", "41");
assert_eq!(error.code(), ParseErrorCode::TooLong);
assert_eq!(error.code_str(), "parse.too_long");
assert_eq!(error.to_string(), "parse.too_long");
assert_eq!(error.field(), Some("display_name"));
assert_eq!(error.parameter("max"), Some("40"));
assert_eq!(error.parameter("actual"), Some("41"));
assert_eq!(error.parameter("missing"), None);
}
#[test]
fn replaces_duplicate_parameters_without_reordering_them() {
let error = ParseError::new(ParseErrorCode::InvalidValue)
.with_parameter("expected", "first")
.with_parameter("other", "unchanged")
.with_parameter("expected", "replacement");
assert_eq!(error.field(), None);
assert_eq!(error.parameters().len(), 2);
assert_eq!(error.parameters()[0].name(), "expected");
assert_eq!(error.parameters()[0].value(), "replacement");
assert_eq!(error.parameters()[1].name(), "other");
}
#[test]
fn every_code_has_a_stable_namespace() {
for code in [
ParseErrorCode::Required,
ParseErrorCode::InvalidFormat,
ParseErrorCode::InvalidValue,
ParseErrorCode::TooLong,
] {
assert!(code.as_str().starts_with("parse."));
assert!(!code.as_str().contains(char::is_whitespace));
}
}
}