tikz-gallery-generator

 //! Macros for logging.
 //!
 //! This implementation should be thread safe (unlink an implementation using
 //! `println!` and `eprintln!`) because access to the global stdout/stderr
 //! handle is syncronized using a lock.
 use crossterm::style::Stylize;
 use std::{io::{self, Write}, fmt::Arguments};
 
 #[derive(Clone, Copy, Debug)]
 pub(crate) enum Level {
     Error,
     Info,
     Warn,
 }
 
 pub(crate) fn log(level: Level, args: &Arguments<'_>, newline: bool) {
     match level {
         Level::Error => {
             let mut stderr = io::stderr();
             let _ = write!(stderr, "{} ", "[ERROR]".red().bold());
             let _ = if newline {
                 writeln!(stderr, "{}", args)
             } else {
                 write!(stderr, "{}", args)
             };
             if !newline { let _ = stderr.flush(); }
         }
         Level::Info => {
             let mut stdout = io::stdout().lock();
             let _ = write!(stdout, "{} ", "[INFO]".green().bold());
             let _ = if newline {
                 writeln!(stdout, "{}", args)
             } else {
                 write!(stdout, "{}", args)
             };
             if !newline { let _ = stdout.flush(); }
         }
         Level::Warn => {
             let mut stdout = io::stdout().lock();
             let _ = write!(stdout, "{} ", "[WARNING]".yellow().bold());
             let _ = if newline {
                 writeln!(stdout, "{}", args)
             } else {
                 write!(stdout, "{}", args)
             };
             if !newline { let _ = stdout.flush(); }
         }
     }
 }
 
 #[macro_export]
 macro_rules! info {
     // info!("a {} event", "log");
     ($($arg:tt)+) => ({
         $crate::log::log(
             $crate::log::Level::Info,
             &std::format_args!($($arg)+),
             false,
         );
     });
 }
 
 #[macro_export]
 macro_rules! infoln {
     // infoln!("a {} event", "log");
     ($($arg:tt)+) => ({
         $crate::log::log(
             $crate::log::Level::Info,
             &std::format_args!($($arg)+),
             true,
         );
     });
 }
 
 #[macro_export]
 macro_rules! info_done {
     () => ({
         let _ = writeln!(io::stdout().lock(), " Done!");
     });
 
     // infoln!("a {} event", "log");
     ($($arg:tt)+) => ({
         let _ = writeln!(
             io::stdout().lock(),
             " {}",
             &std::format_args!($($arg)+)
         );
     });
 }
 
 #[macro_export]
 macro_rules! error {
     // info!("a {} event", "log");
     ($($arg:tt)+) => ({
         $crate::log::log(
             $crate::log::Level::Error,
             &std::format_args!($($arg)+),
             false,
         );
     });
 }
 
 #[macro_export]
 macro_rules! errorln {
     // errorln!("a {} event", "log");
     ($($arg:tt)+) => ({
         $crate::log::log(
             $crate::log::Level::Error,
             &std::format_args!($($arg)+),
             true,
         );
     });
 }
 
 #[macro_export]
 macro_rules! warnln {
     // info!("a {} event", "log");
     ($($arg:tt)+) => ({
         $crate::log::log(
             $crate::log::Level::Warn,
             &std::format_args!($($arg)+),
             true,
         );
     });
 }
 
 #[macro_export]
 macro_rules! usage {
     ($program:expr) => {
         let mut stderr = io::stderr();
         let _ = writeln!(
             stderr,
             "{usage_header_msg} {} config.yml [--full-build]",
             $program,
             usage_header_msg = "[USAGE]".yellow().bold()
         );
     };
 }
 
 #[macro_export]
 macro_rules! usage_config {
     () => {
         let mut stderr = io::stderr();
 
         let _ = writeln!(
             stderr,
             "{usage_header_msg} The YAML configuration file should look like this:",
             usage_header_msg = "[USAGE]".yellow().bold()
         );
         let _ = writeln!(
             stderr,
             "    - {path_attr} examples/images/grothendieck-riemann-roch.tex
       {license_attr} PD
       {author_attr} Alexander Grothendieck
       {alt_attr} A hand-drawn commutative diagram surrounded by fire and devils carrying forks
       {caption_attr} The infamous commutative diagram from Gothendieck's 1971 manuscript
 
     - {path_attr} examples/images/caleb-yau.png
       {license_attr} CC-BY-SA-2.5
       {author_attr} Lunch
       {alt_attr} A convoluted self-intersecting surface in pastel shades of pink and blue
       {caption_attr} A visual representation of the Calabi-Yau manifold",
             path_attr = "path:".green(),
             license_attr = "license:".green(),
             author_attr = "author:".green(),
             alt_attr = "alt:".green(),
             caption_attr = "caption:".green()
         );
 
         let _ = stderr.flush();
     }
 }