use crate::emoji;
use anyhow::{bail, Error, Result};
use console::style;
use std::sync::atomic::{AtomicBool, AtomicU8, Ordering};
#[repr(u8)]
#[derive(Debug, Clone, Copy)]
pub enum LogLevel {
Error,
Warn,
Info,
}
impl std::str::FromStr for LogLevel {
type Err = Error;
fn from_str(s: &str) -> Result<Self> {
match s {
"error" => Ok(LogLevel::Error),
"warn" => Ok(LogLevel::Warn),
"info" => Ok(LogLevel::Info),
_ => bail!("Unknown log-level: {}", s),
}
}
}
pub struct ProgressOutput {
quiet: AtomicBool,
log_level: AtomicU8,
}
impl ProgressOutput {
pub const fn new() -> Self {
Self {
quiet: AtomicBool::new(false),
log_level: AtomicU8::new(LogLevel::Info as u8),
}
}
fn message(&self, message: &str) {
eprintln!("{}", message);
}
pub fn quiet(&self) -> bool {
self.quiet.load(Ordering::SeqCst)
}
pub fn set_quiet(&self, quiet: bool) {
self.quiet.store(quiet, Ordering::SeqCst);
}
pub fn is_log_enabled(&self, level: LogLevel) -> bool {
(level as u8) <= self.log_level.load(Ordering::SeqCst)
}
pub fn set_log_level(&self, log_level: LogLevel) {
self.log_level.store(log_level as u8, Ordering::SeqCst);
}
pub fn info(&self, message: &str) {
if !self.quiet() && self.is_log_enabled(LogLevel::Info) {
let info = format!("{}: {}", style("[INFO]").bold().dim(), message,);
self.message(&info);
}
}
pub fn warn(&self, message: &str) {
if !self.quiet() && self.is_log_enabled(LogLevel::Warn) {
let warn = format!(
"{}: {} {}",
style("[WARN]").bold().dim(),
emoji::WARN,
message
);
self.message(&warn);
}
}
pub fn error(&self, message: &str) {
if self.is_log_enabled(LogLevel::Error) {
let err = format!(
"{}: {} {}",
style("[ERR]").bold().dim(),
emoji::ERROR,
message
);
self.message(&err);
}
}
}
impl Default for ProgressOutput {
fn default() -> Self {
ProgressOutput::new()
}
}