use std::{error::Error, fmt};
use crate::result::{ClassifyError, ErrorKind};
pub const MAX_SETTINGS_ISSUES: usize = 128;
const DEFAULT_SETTINGS_ISSUE_PATH: &str = "settings";
const DEFAULT_SETTINGS_ISSUE_MESSAGE: &str = "are invalid";
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct SettingsIssue {
path: String,
message: String,
}
impl SettingsIssue {
#[must_use]
pub fn new(path: impl Into<String>, message: impl Into<String>) -> Self {
Self {
path: normalize_issue_field(path, DEFAULT_SETTINGS_ISSUE_PATH),
message: normalize_issue_field(message, DEFAULT_SETTINGS_ISSUE_MESSAGE),
}
}
#[must_use]
pub fn path(&self) -> &str {
&self.path
}
#[must_use]
pub fn message(&self) -> &str {
&self.message
}
}
fn normalize_issue_field(value: impl Into<String>, fallback: &'static str) -> String {
let value = value.into().trim().to_owned();
if value.is_empty() {
fallback.to_owned()
} else {
value
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
#[non_exhaustive]
pub struct SettingsIssues {
issues: Vec<SettingsIssue>,
truncated: bool,
}
impl SettingsIssues {
#[must_use]
pub fn new() -> Self {
Self::default()
}
pub fn push(&mut self, path: impl Into<String>, message: impl Into<String>) {
self.push_issue(SettingsIssue::new(path, message));
}
pub fn require(
&mut self,
condition: bool,
path: impl Into<String>,
message: impl Into<String>,
) {
if !condition {
self.push(path, message);
}
}
pub fn require_non_empty(&mut self, path: impl Into<String>, value: &str) {
self.require(!value.trim().is_empty(), path, "must not be empty");
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.issues.is_empty()
}
#[must_use]
pub fn len(&self) -> usize {
self.issues.len()
}
#[must_use]
pub const fn is_truncated(&self) -> bool {
self.truncated
}
#[must_use]
pub fn as_slice(&self) -> &[SettingsIssue] {
&self.issues
}
pub fn extend(&mut self, error: SettingsValidationError) {
let nested = error.into_issues();
for issue in nested.issues {
self.push_issue(issue);
}
self.truncated |= nested.truncated;
}
pub fn extend_result(&mut self, result: Result<(), SettingsValidationError>) {
if let Err(error) = result {
self.extend(error);
}
}
pub fn into_result(self) -> Result<(), SettingsValidationError> {
if self.issues.is_empty() {
Ok(())
} else {
Err(SettingsValidationError { issues: self })
}
}
fn push_issue(&mut self, issue: SettingsIssue) {
if self.issues.len() < MAX_SETTINGS_ISSUES {
self.issues.push(issue);
} else {
self.truncated = true;
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct SettingsValidationError {
issues: SettingsIssues,
}
impl SettingsValidationError {
#[must_use]
pub fn new(mut issues: SettingsIssues) -> Self {
if issues.is_empty() {
issues.push(DEFAULT_SETTINGS_ISSUE_PATH, DEFAULT_SETTINGS_ISSUE_MESSAGE);
}
Self { issues }
}
#[must_use]
pub fn single(path: impl Into<String>, message: impl Into<String>) -> Self {
let mut issues = SettingsIssues::new();
issues.push(path, message);
Self { issues }
}
#[must_use]
pub fn issues(&self) -> &[SettingsIssue] {
self.issues.as_slice()
}
#[must_use]
pub fn into_issues(self) -> SettingsIssues {
self.issues
}
#[must_use]
pub const fn is_truncated(&self) -> bool {
self.issues.is_truncated()
}
}
impl fmt::Display for SettingsValidationError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("settings validation failed")?;
for issue in self.issues() {
write!(formatter, "\n- {}: {}", issue.path(), issue.message())?;
}
if self.issues.is_truncated() {
formatter.write_str("\n- additional issues omitted")?;
}
Ok(())
}
}
impl Error for SettingsValidationError {}
impl ClassifyError for SettingsValidationError {
fn error_kind(&self) -> ErrorKind {
ErrorKind::Validation
}
fn error_code(&self) -> crate::result::ErrorCode {
crate::result::ErrorCode::internal("settings_invalid")
}
}
impl From<&SettingsValidationError> for crate::result::Diagnostic {
fn from(value: &SettingsValidationError) -> Self {
let issue = &value.issues()[0];
Self::configuration("settings", format!("{}: {}", issue.path(), issue.message()))
}
}
impl From<SettingsValidationError> for crate::result::Diagnostic {
fn from(value: SettingsValidationError) -> Self {
Self::from(&value)
}
}