use std::sync::{Arc, Mutex};
#[derive(Clone, Copy, PartialEq, Eq, Debug, PartialOrd, Ord)]
pub enum Level {
Note,
Warning,
Error,
}
impl Level {
pub fn prefix(self) -> &'static str {
match self {
Level::Note => "",
Level::Warning => "Warning: ",
Level::Error => "! ",
}
}
}
pub trait StatusBackend {
fn report(&mut self, level: Level, message: &str);
fn note(&mut self, message: &str) {
self.report(Level::Note, message)
}
fn warning(&mut self, message: &str) {
self.report(Level::Warning, message)
}
fn error(&mut self, message: &str) {
self.report(Level::Error, message)
}
}
#[derive(Default)]
pub struct TexStatus {
pub min_level: Option<Level>,
}
impl TexStatus {
pub fn new() -> Self {
Self::default()
}
pub fn quiet_below(level: Level) -> Self {
Self {
min_level: Some(level),
}
}
}
impl StatusBackend for TexStatus {
fn report(&mut self, level: Level, message: &str) {
if self.min_level.is_some_and(|min| level < min) {
return;
}
match level {
Level::Note => eprintln!("{message}"),
_ => eprintln!("{}{}.", level.prefix(), message.trim_end_matches('.')),
}
}
}
#[derive(Clone, Default)]
pub struct CollectingStatus {
messages: Arc<Mutex<Vec<(Level, String)>>>,
}
impl CollectingStatus {
pub fn new() -> Self {
Self::default()
}
pub fn messages(&self) -> Vec<(Level, String)> {
self.messages
.lock()
.unwrap_or_else(|e| e.into_inner())
.clone()
}
pub fn had_error(&self) -> bool {
self.messages().iter().any(|(l, _)| *l == Level::Error)
}
}
impl StatusBackend for CollectingStatus {
fn report(&mut self, level: Level, message: &str) {
self.messages
.lock()
.unwrap_or_else(|e| e.into_inner())
.push((level, message.to_string()));
}
}
pub struct SilentStatus;
impl StatusBackend for SilentStatus {
fn report(&mut self, _level: Level, _message: &str) {}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_collecting_backend_keeps_what_it_was_told_in_order() {
let mut status = CollectingStatus::new();
status.note("reading the file");
status.warning("a macro was redefined");
status.error("Undefined control sequence");
let got = status.messages();
assert_eq!(got.len(), 3);
assert_eq!(got[0], (Level::Note, "reading the file".to_string()));
assert_eq!(got[2].0, Level::Error);
assert!(status.had_error());
let mut clone = status.clone();
clone.note("from the clone");
assert_eq!(status.messages().len(), 4);
}
#[test]
fn a_run_with_nothing_wrong_reports_no_error() {
let mut status = CollectingStatus::new();
status.note("nothing to see");
assert!(!status.had_error());
}
#[test]
fn a_quiet_backend_still_reports_what_stopped_the_run() {
let mut status = TexStatus::quiet_below(Level::Error);
assert!(status.min_level.is_some_and(|l| l == Level::Error));
status.note("dropped");
status.error("kept");
assert_eq!(Level::Warning.prefix(), "Warning: ");
assert!(Level::Note < Level::Warning && Level::Warning < Level::Error);
assert_eq!(Level::Error.prefix(), "! ");
assert_eq!(Level::Note.prefix(), "");
}
}