//! The tsv table generation use anyhow::{Context, Result}; use glob::glob; use regex::Captures; use std::{ cell::RefCell, fs::File, io::{Error, Write}, path::{Path, PathBuf}, }; use crate::{ table_structs::{ TableArgs, TableGenerationTarget, TableTargets, RE_MATHS, RE_PLUS_STARS, RE_STARS, STR_TO_TARGET_FULL, }, table_types::{ClassesArray, GenericArray, RecordClass, WriteTable}, Config, }; /// Generate the tables for the specified files /// /// In charge of the dispatch and the whole conversion pub fn table_gen(args: &TableArgs, config: &Config) -> Result<()> { let list_files = match args.kind { TableGenerationTarget::Classes => { println!("Processing files in the Tables/ subdirectory"); &mut list_dir("Tables/???-*.tsv") } TableGenerationTarget::Craft => { println!("Processing files in the Craft/ subdirectory"); &mut list_dir("Craft/???-*.tsv") } // Add the use of glob to save the poor windows users TableGenerationTarget::Files => { println!("Processing the files given as argument"); &mut args.filenames.iter().map(PathBuf::from).collect() } TableGenerationTarget::All => &mut { println!("Processing files in the Tables and Craft subdirectory"); let mut targets = list_dir("Tables/???-*.tsv"); targets.append(&mut list_dir("Craft/???-*.tsv")); targets }, }; if list_files.is_empty() { println!("No files to process ... skipping"); } // match args.kind { // TableGenerationTarget::Classes => process_files(list_files, args, config), // TableGenerationTarget::Craft => process_files(list_files, args, config), // // For now every file is considered as a class file // TableGenerationTarget::Files => process_files(list_files, args, config), // TableGenerationTarget::All =>process_files(list_files, args, config), // } process_files(list_files, args, config) } /// Process any type of file, one by one and call the right converter function fn process_files(list_files: &mut Vec, args: &TableArgs, config: &Config) -> Result<()> { for f in list_files { if let Err(e) = process_one_file(f, args, config) { println!("An error occured while processing the file {:?}\n{}", f, e) } } Ok(()) } /// Process one file fn process_one_file(f: &mut PathBuf, args: &TableArgs, config: &Config) -> Result<()> { let tt = extract_type(f)?; let tsv: Box = match tt { TableTargets::Classes => Box::new(read_tsv_classes(f)?), // TableTargets::Food => read_tsv::(f)?, // TableTargets::Alchemy => read_tsv::(f)?, // TableTargets::Forge => read_tsv::(f)?, _ => read_generic_tsv(f, tt)?, }; export_tsv(f, tsv, args, config) } #[inline] /// Extract the type of target of the given file fn extract_type(f: &Path) -> Result<&TableTargets> { let key = &f .file_name() .context("The filename of can't be extracted...skipping")? .to_str() .context("Can't convert filename to string")?[..3]; STR_TO_TARGET_FULL.get(key).with_context(|| { format!( "Could not find the type of file given based on the prefix of your file ({})\n\ Are you sure {:?} contains a viable identifying prefix ?\n\ The list of available prefixes is: [{:?}]", key, f, STR_TO_TARGET_FULL.keys() ) }) } /// List all files matching a pattern in the given directory #[inline] fn list_dir(pattern: &str) -> Vec { // println!("{}", pattern); // println!("{:?}", glob(pattern)); glob(pattern) .expect("Failed to read glob pattern") .flatten() .collect() } /// Converts a TSV file to LaTeX code. /// /// This function reads in a TSV file, processes its contents according to the provided configuration, /// and writes out the resulting LaTeX code as a string. If an error occurs during processing or writing, /// it will be returned as part of the result. pub fn export_tsv( f: &Path, tsv: Box, args: &TableArgs, config: &Config, ) -> Result<()> { let converted = tsv_to_string(tsv, config)?; if args.export { let name = &f .file_name() .context("Extracting old name")? .to_str() .context("Generating new name")?[4..]; let path = f.with_file_name(name).with_extension("tex"); println!("[Info] Writing to {:?}", path); let mut file = File::create(path)?; file.write_all(converted.as_bytes())?; } else { println!("###### [FILE:{:?}] ######", f); println!("{}", converted); } Ok(()) } /// Replace all instances of unrepresentable utf8 or non escaped characters with latex ones pub fn make_latex_string(arg: &str) -> String { let res = arg .replace('🩸', "\\blood{}") .replace('⚡', "\\gauge{}") .replace('☽', "\\slash{}") .replace('◅', "\\pierce{}") .replace('⧆', "\\blunt{}") .replace('Ø', "\\o{}") .replace('⌭', "\\torque{}") .replace('☆', "\\ddzero{}") .replace('🗘', "\\reload{}") .replace('½', "\\sfrac{1}{2}") .replace('&', "\\&"); let res = RE_PLUS_STARS.replace_all(&res, |caps: &Captures| { format!("\\ddmod{{{}}}{{{}}}", &caps[1], caps[2].chars().count()) }); let res = RE_STARS.replace_all(&res, |caps: &Captures| { format!("\\ddlvl{{{}}}", caps[0].chars().count()) }); let res = RE_MATHS.replace_all(&res, |caps: &Captures| format!("${}$", &caps[0])); res.to_string() } /// Reads a TSV file into a table. /// /// This function reads in a tab-separated values (TSV) file and returns it as a Table object, /// which can be used to generate LaTeX code or perform other operations on the data. fn read_tsv_classes(filename: &T) -> Result where T: AsRef, { let file = File::open(filename)?; let mut rdr = csv::ReaderBuilder::new() .has_headers(false) .delimiter(b'\t') .double_quote(false) .escape(Some(b'\\')) .flexible(true) .comment(Some(b'#')) .from_reader(file); let mut levels = Vec::with_capacity(8); let current_tier = RefCell::new(Vec::with_capacity(6)); for result in rdr.deserialize() { let result: RecordClass = result?; if result.technique.starts_with("Tier ") { // Getto way of knowing we have a new tier let old_tier = current_tier.replace(Vec::with_capacity(8)); levels.push(old_tier); } else if (result.technique == "Technique") | result.technique.is_empty() { // Skip this entry } else { current_tier.borrow_mut().push(result); } } Ok(ClassesArray { tiers: levels }) } /// Reads a TSV file into a table. /// /// Reads a tab-separated values (TSV) file and deserializes its contents into a table. fn read_generic_tsv(filename: &Path, craft_type: &TableTargets) -> Result> { let file = File::open(filename)?; let rdr = csv::ReaderBuilder::new() .has_headers(false) .delimiter(b'\t') .double_quote(false) .escape(Some(b'\\')) .flexible(true) .comment(Some(b'#')) .from_reader(file); let res = rdr .into_records() .map(|r| r.context("reading row").unwrap()) .collect(); let craft_array = GenericArray { row: res, craft_type: craft_type.clone(), }; let generic_array = Box::new(craft_array); Ok(generic_array) } /// Converts a table of data into a string representation. /// /// This function takes in a Table object and returns its contents as a formatted string, /// which can be used to generate LaTeX code or perform other operations on the data. pub(super) fn tsv_to_string(tsv: Box, config: &Config) -> Result { tsv.write_table(config) } // /// Reads a TSV file into a table. // /// // /// Reads a tab-separated values (TSV) file and deserializes its contents into a table. // fn read_tsv(filename: &Path) -> Result> // where // // TODO: Remove the static and do not return a Box // RecordType: for<'a> serde::Deserialize<'a> + WriteRow + 'static, // { // let file = File::open(filename)?; // let mut rdr = csv::ReaderBuilder::new() // .has_headers(false) // .delimiter(b'\t') // .double_quote(false) // .escape(Some(b'\\')) // .flexible(true) // .comment(Some(b'#')) // .from_reader(file); // let mut levels = Vec::with_capacity(30); // for result in rdr.deserialize().skip(2) { // let result: RecordType = result?; // levels.push(result); // } // let craft_array = CraftArray { row: levels }; // Ok(Box::new(craft_array)) // }