diff --git a/src/makepdf.rs b/src/makepdf.rs index e6f7f39..7354a75 100644 --- a/src/makepdf.rs +++ b/src/makepdf.rs @@ -2,6 +2,7 @@ // use std::fmt::Display; use logos::{Lexer, Logos}; +use phf::phf_map; use std::str; use tokio::io::{AsyncBufReadExt, BufReader}; use tokio::process::Command; @@ -18,8 +19,59 @@ pub(crate) struct MakeConfig { /// The filename to compile pub(crate) filename: String, /// The verbosity level - #[arg(short, long, default_value_t = false)] - pub(crate) verbosity: bool, + #[arg(short, long, default_value = "warning")] + pub(crate) verbosity: VerboseLevel, + // /// The list of whitelisted verbosity levels + // pub(crate) whitelist: Vec, + // /// The list of blacklisted verbosity levels + // pub(crate) blacklist: Vec, +} + +/// The verbosity level +#[derive(Clone, Debug, PartialEq, PartialOrd)] +pub enum VerboseLevel { + /// Shouldn't be printed no matter what + None, + /// Garbage + Misc, + /// Boxness, barely above Misc + Box, + /// Context info (Debug info) + Context, + /// Usefull info + Info, + /// Important warnings + Warning, + /// Errors encountered requiring user input + Error, + /// Uncatachable errors + Critical, + /// Literrally uncatchable things + Uncatchable, +} + +static STR_TO_TARGET: phf::Map<&'static str, VerboseLevel> = phf_map! { + "misc" =>VerboseLevel::Misc, + "box" => VerboseLevel::Box, + "context" => VerboseLevel::Context, + "info" => VerboseLevel::Info, + "warning" => VerboseLevel::Warning, + "error" => VerboseLevel::Error, + "critical" => VerboseLevel::Critical, +}; + +impl From<&str> for VerboseLevel { + fn from(value: &str) -> Self { + if let Some(target) = STR_TO_TARGET.get(value).cloned() { + target + } else { + panic!( + "Invalid debug level {}. The debug level available are: {:?}", + value, + STR_TO_TARGET.keys() + ) + } + } } /// Make a pdf spawning a subprocess @@ -115,7 +167,7 @@ async fn launch_subprocess(args: &MakeConfig) -> Result { } }; // println!("Line: {:?}", s); - checkline(s, &mut status, &mut context).expect("Error while checking line"); + checkline(args, s, &mut status, &mut context).expect("Error while checking line"); } else { break; } @@ -130,7 +182,7 @@ async fn launch_subprocess(args: &MakeConfig) -> Result { #[derive(Debug, Logos, PartialEq)] #[logos(skip r"[) ]+")] enum LineType { - /// The tex building mode + /// The tex building mode : entering extended mode #[regex("entering[_ ]extended[_ ]mode")] Mode, /// Info level @@ -141,6 +193,7 @@ enum LineType { Info(String), /// Strange starting sequence + #[token("? ) [")] #[token("? [1{")] StartingSequence, @@ -158,7 +211,10 @@ enum LineType { /// Missing reference #[token(r"LaTeX Warning: Reference")] - MissingReference, + MissingReferencePrs, + + /// Missed reference, completed with all info + MissingReference(String), /// Generic Latex Warning #[regex(r"(LaTex |Warning:){2}[^\n]+", |lex| lex.slice()[14..].to_string())] @@ -172,6 +228,7 @@ enum LineType { PdfTexVersion, /// Context, mosty for boxes + // TODO: False positives / Reparsing Context("10") )) [107] (./Ecoles/Protecteur.tex #[regex(r"\[\d[^\]]+", |lex| lex.slice()[1..lex.slice().len()-1].to_string())] Context(String), @@ -254,6 +311,42 @@ enum LineType { Transcript, } +impl LineType { + /// Decides all verbose levels, for output + fn vlvl(&self) -> VerboseLevel { + match &self { + LineType::Mode => VerboseLevel::Misc, + LineType::Info(_) => VerboseLevel::Misc, + LineType::StartingSequence => VerboseLevel::Misc, + LineType::EndSequence => VerboseLevel::Misc, + LineType::MPSConverter => VerboseLevel::Misc, + LineType::Chapter(_) => VerboseLevel::Context, + LineType::MissingReferencePrs => VerboseLevel::Warning, + LineType::Warning(_) => VerboseLevel::Warning, + LineType::MissingReference(_) => VerboseLevel::Warning, + LineType::PdfTexVersion => VerboseLevel::Misc, + LineType::Context(_) => VerboseLevel::Misc, + LineType::BoxFullness => VerboseLevel::Box, + LineType::LaTexVersion => VerboseLevel::Misc, + LineType::WriteMode => VerboseLevel::Misc, + LineType::DocumentClass => VerboseLevel::Misc, + LineType::EnteringDocument(_) => VerboseLevel::Info, + LineType::Library(_) => VerboseLevel::Context, + LineType::PackageWarning(_) => VerboseLevel::Box, + LineType::PackageContextWarning(_) => VerboseLevel::Warning, + LineType::Loading(_) => VerboseLevel::Context, + LineType::Unknown(_) => VerboseLevel::Uncatchable, + LineType::PageGen => VerboseLevel::None, + LineType::Output => VerboseLevel::Misc, + LineType::Log => VerboseLevel::Misc, + LineType::Empty => VerboseLevel::None, + LineType::GeometryResolution => VerboseLevel::Misc, + LineType::GeometryFound => VerboseLevel::Misc, + LineType::Transcript => VerboseLevel::Misc, + } + } +} + /// Tries to split the token and return two string fn split_by(delim: &str, text: &str) -> Option<(String, String)> { let mut slice = text.split(delim); @@ -269,25 +362,68 @@ fn split_by(delim: &str, text: &str) -> Option<(String, String)> { } /// Check each line and changes the status and/or display according warnings -fn checkline(s: &str, status: &mut Status, context: &mut [String]) -> Result<()> { +fn checkline( + args: &MakeConfig, + orginal_line: &str, + status: &mut Status, + context: &mut [String], +) -> Result<()> { // Match the line to guess what is happening - let mut lex = LineType::lexer(s); - let line = match lex.next() { + let mut lex = LineType::lexer(orginal_line); + let parsed_line = match lex.next() { Some(Ok(m)) => m, None => LineType::Empty, - _ => LineType::Unknown(s.to_string()), + _ => LineType::Unknown(orginal_line.to_string()), }; - match line { - LineType::Unknown(w) => println!("[UKWN] {}", w), - LineType::Empty => (), - LineType::EnteringDocument(_) => println!("{:?}", line), - // LineType::TabWarn(_) => println!("{:?}", line), - // LineType::Library(_) => println!("{:?}", line), - // LineType::PackageWarning(_) => println!("{:?},{}", line, s), - LineType::PackageContextWarning(_) => println!("{:?}", line), - LineType::MissingReference => println!("{:?} {}", line, s), - // LineType::=> (), - _ => (), + + // Early exit if the verbosity level doenst match + if parsed_line.vlvl() < args.verbosity { + return Ok(()); + } + + // Post processing for some lines that can't be properly handlend by the lexer + let final_line = match parsed_line { + // LineType::Mode => todo!(), + // LineType::Info(_) => todo!(), + // LineType::StartingSequence => todo!(), + // LineType::EndSequence => todo!(), + // LineType::MPSConverter => todo!(), + // LineType::Chapter(_) => todo!(), + LineType::MissingReferencePrs => &LineType::MissingReference(orginal_line.to_string()), + // LineType::Warning(_) => todo!(), + // LineType::PdfTexVersion => todo!(), + // LineType::Context(_) => todo!(), + // TODO: Add + // LineType::BoxFullness => todo!(), + // LineType::LaTexVersion => todo!(), + // LineType::WriteMode => todo!(), + // LineType::DocumentClass => todo!(), + // LineType::EnteringDocument(_) => todo!(), + // LineType::Library(_) => todo!(), + // LineType::PackageWarning(_) => todo!(), + // LineType::PackageContextWarning(_) => todo!(), + // LineType::Loading(_) => todo!(), + // LineType::Unknown(_) => todo!(), + // LineType::PageGen => todo!(), + // LineType::Output => todo!(), + // LineType::Log => todo!(), + // LineType::Empty => todo!(), + // LineType::GeometryResolution => todo!(), + // LineType::GeometryFound => todo!(), + // LineType::Transcript => todo!(), + _ => &parsed_line, + }; + + match &parsed_line.vlvl() { + VerboseLevel::None => (), + VerboseLevel::Misc => println!("[MISC] {:?}", final_line), + VerboseLevel::Box => println!("[BOXX] {:?}", final_line), + VerboseLevel::Context => println!("[CNTX] {:?}", final_line), // Context tends to be shit ? + VerboseLevel::Info => println!("[INFO] {:?}", final_line), + VerboseLevel::Warning => println!("[WARN] {:?}", final_line), + VerboseLevel::Error => println!("[CRIT] {:?}", final_line), + VerboseLevel::Critical => println!("[CRIT] {:?}", final_line), + VerboseLevel::Uncatchable => println!("[UKNW] {}", orginal_line), } Ok(()) }