From cc5af1907c590892822b12b4b0d0fa57d6ade6da Mon Sep 17 00:00:00 2001 From: Dandaedre Date: Sun, 5 May 2024 20:25:10 +0200 Subject: [PATCH] Adds true generics and sorts some of the mess --- src/table_structs.rs | 1 + src/table_types.rs | 200 +++++++++++++++++++++++++++++-------------- src/tablegen.rs | 81 ++++++++++++++++-- 3 files changed, 214 insertions(+), 68 deletions(-) diff --git a/src/table_structs.rs b/src/table_structs.rs index 8c172c7..73986e3 100644 --- a/src/table_structs.rs +++ b/src/table_structs.rs @@ -40,6 +40,7 @@ static STR_TO_TARGET: phf::Map<&'static str, TargetType> = phf_map! { /// All the type of tsv that can be processed by the program // #[enum_dispatch] +#[derive(Clone)] pub enum TableTargets { /// A class tsv Classes, diff --git a/src/table_types.rs b/src/table_types.rs index 6a73e0a..7457a0f 100644 --- a/src/table_types.rs +++ b/src/table_types.rs @@ -1,6 +1,7 @@ //! Holds all the table base structure -use crate::{tablegen::make_latex_string, Config}; +use crate::{table_structs::TableTargets, tablegen::make_latex_string, Config}; use anyhow::{Context, Result}; +// use csv::StringRecord; use dynfmt::{Format, SimpleCurlyFormat}; use serde::Deserialize; use std::{ @@ -27,11 +28,21 @@ pub(crate) struct RecordClass { } impl WriteRow for RecordClass { - fn write_header(&self, _buffer: &mut BufWriter>, _configg: &Config) -> Result<()> { + fn write_header( + &self, + _buffer: &mut BufWriter>, + _config: &Config, + _format: &str, + ) -> Result<()> { unimplemented!() } - fn write_row(&self, buffer: &mut BufWriter>, _config: &Config) -> Result<()> { + fn write_row( + &self, + buffer: &mut BufWriter>, + _config: &Config, + _format: &str, + ) -> Result<()> { Ok(write!( buffer, " {}&{}&{}&{}{}&{} \\\\", @@ -44,7 +55,12 @@ impl WriteRow for RecordClass { )?) } - fn write_footer(&self, _buffer: &mut BufWriter>, _configg: &Config) -> Result<()> { + fn write_footer( + &self, + _buffer: &mut BufWriter>, + _config: &Config, + _format: &str, + ) -> Result<()> { unimplemented!() } } @@ -62,11 +78,26 @@ pub(crate) trait WriteTable { /// Trait needed to be writable as a LaTex table pub(crate) trait WriteRow { /// Write the header of the LaTex table - fn write_header(&self, buffer: &mut BufWriter>, config: &Config) -> Result<()>; + fn write_header( + &self, + buffer: &mut BufWriter>, + config: &Config, + format: &str, + ) -> Result<()>; /// Write the row of the LaTex table - fn write_row(&self, buffer: &mut BufWriter>, config: &Config) -> Result<()>; + fn write_row( + &self, + buffer: &mut BufWriter>, + config: &Config, + format: &str, + ) -> Result<()>; /// Write the row of the LaTex table - fn write_footer(&self, buffer: &mut BufWriter>, config: &Config) -> Result<()>; + fn write_footer( + &self, + buffer: &mut BufWriter>, + config: &Config, + format: &str, + ) -> Result<()>; } impl WriteTable for ClassesArray { @@ -80,7 +111,7 @@ impl WriteTable for ClassesArray { writeln!(buffer, "{}", formatted_header)?; writeln!(buffer, "{}", config.classes.row)?; for elem in tier { - elem.write_row(&mut buffer, config)? + elem.write_row(&mut buffer, config, NO_STRING)? } writeln!(buffer, "{}", config.classes.end)?; } @@ -103,14 +134,54 @@ where { fn write_table(&self, config: &Config) -> Result { let mut buffer = BufWriter::new(Vec::new()); - self.row[0].write_header(&mut buffer, config)?; + self.row[0].write_header(&mut buffer, config, NO_STRING)?; for row in self.row.iter() { - row.write_row(&mut buffer, config)?; + row.write_row(&mut buffer, config, NO_STRING)?; } - self.row[0].write_footer(&mut buffer, config)?; + self.row[0].write_footer(&mut buffer, config, NO_STRING)?; Ok(String::from_utf8(buffer.into_inner()?).unwrap()) } } +/// Represents the whole Craft Array, with a vec for every tier +pub(crate) struct GenericArray +where + RecordType: WriteRow, +{ + /// Every tier held as a vec of vec of rows + pub row: Vec, + /// Inner craft type, since the array is genric + pub craft_type: TableTargets, +} + +impl WriteTable for GenericArray +where + RecordType: WriteRow, +{ + fn write_table(&self, config: &Config) -> Result { + let mut buffer = BufWriter::new(Vec::new()); + let header = match self.craft_type { + TableTargets::Classes => unimplemented!(), + TableTargets::Food => &config.craft.header_food, + TableTargets::Alchemy => &config.craft.header_alchemy, + TableTargets::Forge => &config.craft.header_forge, + TableTargets::MPieges => &config.craft.header_mtrap, + TableTargets::Weapons => &config.craft.header_weapons, + TableTargets::Armors => &config.craft.header_armors, + TableTargets::Gadgets => &config.craft.header_gadgets, + TableTargets::Potions => &config.craft.header_potions, + TableTargets::Traps => &config.craft.header_traps, + }; + self.row[0].write_header(&mut buffer, config, header)?; + for row in self.row.iter().skip(2) { + row.write_row(&mut buffer, config, NO_STRING)?; + } + self.row[0].write_footer(&mut buffer, config, NO_STRING)?; + Ok(String::from_utf8(buffer.into_inner()?).unwrap()) + } +} + +/// Empty string +const NO_STRING: &String = &String::new(); /// This type is used to represent strings in LaTeX tables, where certain characters need to be escaped or replaced with special commands. #[derive(Deserialize)] @@ -160,12 +231,20 @@ pub(crate) struct RecordFood { } impl WriteRow for RecordFood { - fn write_header(&self, buffer: &mut BufWriter>, config: &Config) -> Result<()> { - writeln!(buffer, "{}", config.craft.header_food).context("Writing header") - - // Ok(String::from_utf8(buffer.into_inner()?).unwrap()) + fn write_header( + &self, + buffer: &mut BufWriter>, + _: &Config, + format: &str, + ) -> Result<()> { + writeln!(buffer, "{}", format).context("Writing header") } - fn write_row(&self, buffer: &mut BufWriter>, _config: &Config) -> Result<()> { + fn write_row( + &self, + buffer: &mut BufWriter>, + _config: &Config, + _format: &str, + ) -> Result<()> { writeln!( buffer, " {}&{}&{}{}&{}&{}&{}&{} \\\\", @@ -181,7 +260,12 @@ impl WriteRow for RecordFood { .context("Writing row") } - fn write_footer(&self, buffer: &mut BufWriter>, config: &Config) -> Result<()> { + fn write_footer( + &self, + buffer: &mut BufWriter>, + config: &Config, + _format: &str, + ) -> Result<()> { writeln!(buffer, "{}", config.craft.end).context("Writing footer") } } @@ -213,10 +297,20 @@ pub(crate) struct RecordAlchemy { } impl WriteRow for RecordAlchemy { - fn write_header(&self, buffer: &mut BufWriter>, config: &Config) -> Result<()> { + fn write_header( + &self, + buffer: &mut BufWriter>, + config: &Config, + _format: &str, + ) -> Result<()> { writeln!(buffer, "{}", config.craft.header_alchemy).context("Writing header") } - fn write_row(&self, buffer: &mut BufWriter>, _config: &Config) -> Result<()> { + fn write_row( + &self, + buffer: &mut BufWriter>, + _config: &Config, + _format: &str, + ) -> Result<()> { writeln!( buffer, " {}&{}&{}{}&{}&{}&{} \\\\", @@ -231,7 +325,12 @@ impl WriteRow for RecordAlchemy { .context("Writing row") } - fn write_footer(&self, buffer: &mut BufWriter>, config: &Config) -> Result<()> { + fn write_footer( + &self, + buffer: &mut BufWriter>, + config: &Config, + _format: &str, + ) -> Result<()> { writeln!(buffer, "{}", config.craft.end).context("Writing footer") } } @@ -269,10 +368,20 @@ pub(crate) struct RecordForge { } impl WriteRow for RecordForge { - fn write_header(&self, buffer: &mut BufWriter>, config: &Config) -> Result<()> { + fn write_header( + &self, + buffer: &mut BufWriter>, + config: &Config, + _format: &str, + ) -> Result<()> { writeln!(buffer, "{}", config.craft.header_forge).context("Writing header") } - fn write_row(&self, buffer: &mut BufWriter>, _config: &Config) -> Result<()> { + fn write_row( + &self, + buffer: &mut BufWriter>, + _config: &Config, + _format: &str, + ) -> Result<()> { writeln!( buffer, " {}&{}&{}&{}&{}{}&{}&{}&{} \\\\", @@ -289,47 +398,12 @@ impl WriteRow for RecordForge { .context("Writing row") } - fn write_footer(&self, buffer: &mut BufWriter>, config: &Config) -> Result<()> { + fn write_footer( + &self, + buffer: &mut BufWriter>, + config: &Config, + _format: &str, + ) -> Result<()> { writeln!(buffer, "{}", config.craft.end).context("Writing footer") } } - -// #[derive(Debug, Deserialize)] -// #[serde(rename_all = "PascalCase")] -// pub(crate) struct Weapons { -// name: String, -// rarity: CleanString, -// damage: String, -// damage_add: String, -// rmax: String, -// armorbreak: String, -// protection: String, -// integrity: String, -// twohanded: String, -// onehanded: String, -// dodge: String, -// } - -// impl WriteRow for Weapons { -// fn write_header(&self, buffer: &mut BufWriter>, config: &Config) -> Result<()> { -// writeln!(buffer, "{}", config.craft.header_alchemy).context("Writing header") -// } -// fn write_row(&self, buffer: &mut BufWriter>, _config: &Config) -> Result<()> { -// writeln!( -// buffer, -// " {}&{}&{}{}&{}&{}&{} \\\\", -// self.ingredient, -// self.part, -// self.rarity, -// self.effect_main, -// self.effect_secondary, -// self.difficulty, -// self.toxicity, -// ) -// .context("Writing row") -// } - -// fn write_footer(&self, buffer: &mut BufWriter>, config: &Config) -> Result<()> { -// writeln!(buffer, "{}", config.craft.end).context("Writing footer") -// } -// } diff --git a/src/tablegen.rs b/src/tablegen.rs index 543911a..f6c1c63 100644 --- a/src/tablegen.rs +++ b/src/tablegen.rs @@ -1,5 +1,6 @@ //! The tsv table generation use anyhow::{Context, Result}; +use csv::StringRecord; use glob::glob; use regex::Captures; use std::{ @@ -10,8 +11,8 @@ use std::{ }; use crate::table_types::{ - ClassesArray, CraftArray, RecordAlchemy, RecordClass, RecordFood, RecordForge, WriteRow, - WriteTable, + ClassesArray, CraftArray, GenericArray, RecordAlchemy, RecordClass, RecordFood, RecordForge, + WriteRow, WriteTable, }; use crate::{ table_structs::{TableArgs, TableTargets, TargetType, RE, STR_TO_TARGET_FULL}, @@ -58,9 +59,9 @@ fn process_one_file(f: &mut PathBuf, args: &TableArgs, config: &Config) -> Resul TableTargets::Food => read_tsv::(f)?, TableTargets::Alchemy => read_tsv::(f)?, TableTargets::Forge => read_tsv::(f)?, - TableTargets::MPieges => todo!(), - TableTargets::Weapons => todo!(), - TableTargets::Armors => todo!(), + TableTargets::MPieges => read_generic_tsv(f, tt)?, + TableTargets::Weapons => read_generic_tsv(f, tt)?, + TableTargets::Armors => read_generic_tsv(f, tt)?, TableTargets::Gadgets => todo!(), TableTargets::Potions => todo!(), TableTargets::Traps => todo!(), @@ -122,7 +123,14 @@ pub fn make_latex_string(arg: &str) -> String { let temp = arg .replace('🩸', "\\blood") .replace('⚡', "\\gauge") + .replace('☽', "\\tranchant") + .replace('◅', "\\percant") + .replace('⧆', "\\contondant") + .replace('Ø', "\\o{}") + .replace('⌭', "\\torque") .replace('☆', "\\star") + .replace('🗘', "\\reload") + .replace('½', "\\sfrac{1}{2}") .replace('&', "\\&"); let res = RE.replace_all(&temp, |caps: &Captures| { format!("\\dd{{{}}}", caps[0].chars().count()) @@ -193,6 +201,69 @@ where Ok(Box::new(craft_array)) } +/// 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(), + }; + Ok(Box::new(craft_array)) +} + +impl WriteRow for StringRecord { + fn write_header( + &self, + buffer: &mut std::io::BufWriter>, + _config: &Config, + format: &str, + ) -> Result<()> { + writeln!(buffer, "{}", format).context("Writing header") + } + + fn write_row( + &self, + buffer: &mut std::io::BufWriter>, + _config: &Config, + _format: &str, + ) -> Result<()> { + let mut itr = self.into_iter(); + write!( + buffer, + " {}", + itr.next().context("Writing firt element of row").unwrap() + )?; + for e in itr { + write!(buffer, " & {}", make_latex_string(e)).context("Writing row")? + } + writeln!(buffer).context("Writing row") + } + + fn write_footer( + &self, + buffer: &mut std::io::BufWriter>, + config: &Config, + _format: &str, + ) -> Result<()> { + writeln!(buffer, "{}", config.craft.end).context("Writing footer") + } +} /// Converts a table of data into a string representation. /// /// This function takes in a Table object and returns its contents as a formatted string,