use alloc::fmt;
use crate::errors::{
BunsenError,
BunsenErrorKind,
Multiple,
};
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum CatalogRule {
Parse,
Name,
Structure,
Conflict,
Reference,
Merge,
Facet,
Contract,
Tag,
Preset,
Release,
Dependency,
Lookup,
Selection,
}
impl fmt::Display for CatalogRule {
fn fmt(
&self,
f: &mut fmt::Formatter<'_>,
) -> fmt::Result {
let name = match self {
Self::Parse => "parse",
Self::Name => "name",
Self::Structure => "structure",
Self::Conflict => "conflict",
Self::Reference => "reference",
Self::Merge => "merge",
Self::Facet => "facet",
Self::Contract => "contract",
Self::Tag => "tag",
Self::Preset => "preset",
Self::Release => "release",
Self::Dependency => "dependency",
Self::Lookup => "lookup",
Self::Selection => "selection",
};
f.write_str(name)
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct CatalogProblem {
pub rule: CatalogRule,
pub message: String,
pub layer: Option<String>,
pub entry: Option<String>,
}
impl CatalogRule {
pub fn error_kind(self) -> BunsenErrorKind {
match self {
Self::Lookup => BunsenErrorKind::Lookup,
_ => BunsenErrorKind::Policy,
}
}
}
impl CatalogProblem {
pub fn new(
rule: CatalogRule,
message: impl Into<String>,
) -> Self {
Self {
rule,
message: message.into(),
layer: None,
entry: None,
}
}
#[track_caller]
pub fn into_error(self) -> BunsenError {
BunsenError::from_cause(self.rule.error_kind(), self)
}
}
impl fmt::Display for CatalogProblem {
fn fmt(
&self,
f: &mut fmt::Formatter<'_>,
) -> fmt::Result {
if let Some(layer) = &self.layer {
write!(f, "[{layer}] ")?;
}
if let Some(entry) = &self.entry {
write!(f, "`{entry}`: ")?;
}
write!(f, "{} ({})", self.message, self.rule)
}
}
impl core::error::Error for CatalogProblem {}
#[track_caller]
pub fn catalog_error(
rule: CatalogRule,
message: impl Into<String>,
) -> BunsenError {
CatalogProblem::new(rule, message).into_error()
}
#[track_caller]
pub fn catalog_errors(errors: Vec<BunsenError>) -> BunsenError {
match <[BunsenError; 1]>::try_from(errors) {
Ok([one]) => one,
Err(errors) => {
assert!(!errors.is_empty(), "a pass with no problems is no error");
let summary = format!("{} catalog problems", errors.len());
let members = errors.into_iter().map(|e| (String::new(), e)).collect();
let multiple = Multiple::new(summary, members);
let kind = multiple.kind();
BunsenError::from_detailed(kind, multiple)
}
}
}
pub trait CatalogErrorExt: Sized {
fn problems(&self) -> Vec<&CatalogProblem>;
#[must_use]
fn at(
self,
entry: impl fmt::Display,
) -> Self;
#[must_use]
fn in_layer(
self,
layer: &str,
) -> Self;
fn members(self) -> Vec<BunsenError>;
fn rule(&self) -> Option<CatalogRule> {
self.problems().first().map(|p| p.rule)
}
fn problem_message(&self) -> String;
fn has(
&self,
rule: CatalogRule,
) -> bool {
self.problems().iter().any(|p| p.rule == rule)
}
fn mentions(
&self,
text: &str,
) -> bool {
self.problems().iter().any(|p| p.message.contains(text))
}
fn problem_lines(&self) -> String {
self.problems()
.iter()
.map(ToString::to_string)
.collect::<Vec<_>>()
.join("\n")
}
}
impl CatalogErrorExt for BunsenError {
fn problems(&self) -> Vec<&CatalogProblem> {
if let Some(problem) = self.find::<CatalogProblem>() {
return vec![problem];
}
match self.find::<Multiple>() {
Some(multiple) => multiple
.members
.iter()
.flat_map(|(_, member)| member.problems())
.collect(),
None => Vec::new(),
}
}
fn at(
self,
entry: impl fmt::Display,
) -> Self {
let entry = entry.to_string();
self.placed(&|p| p.entry = Some(entry.clone()))
}
fn in_layer(
self,
layer: &str,
) -> Self {
self.placed(&|p| {
if p.layer.is_none() {
p.layer = Some(layer.to_string());
}
})
}
fn members(self) -> Vec<BunsenError> {
match self.find::<Multiple>() {
Some(multiple) if self.find::<CatalogProblem>().is_none() => {
multiple.members.iter().map(|(_, m)| m.clone()).collect()
}
_ => vec![self],
}
}
fn problem_message(&self) -> String {
self.problems()
.first()
.map_or_else(|| self.message().to_string(), |p| p.message.clone())
}
}
trait Placed {
fn placed(
self,
place: &dyn Fn(&mut CatalogProblem),
) -> Self;
}
impl Placed for BunsenError {
fn placed(
self,
place: &dyn Fn(&mut CatalogProblem),
) -> Self {
if let Some(problem) = self.find::<CatalogProblem>() {
let mut problem = problem.clone();
place(&mut problem);
return problem.into_error();
}
if let Some(multiple) = self.find::<Multiple>() {
let members = multiple
.members
.iter()
.map(|(_, member)| member.clone().placed(place))
.collect();
return catalog_errors(members);
}
self
}
}