Cli interface for stoik

Author: htmlcsjs

stoik-gui/src/app.rs

@@ -165,7 +165,7 @@ impl StoikApp {
                     .monospace(),
             );
         } else if !self.mode_data.lhs_mols.is_empty() && !self.mode_data.rhs_mols.is_empty() {
-            self.show_balance_summery(ui);
+            self.show_balance_summary(ui);
         }
     }
 
@@ -346,7 +346,7 @@ impl StoikApp {
         }
     }
 
-    fn show_balance_summery(&mut self, ui: &mut Ui) {
+    fn show_balance_summary(&mut self, ui: &mut Ui) {
         if self.mode_data.changed {
             self.mode_data.lhs.clear();
             self.mode_data.rhs.clear();
@@ -376,9 +376,9 @@ impl StoikApp {
         let balanced = self.mode_data.balanced.values().all(|x| *x);
 
         if balanced {
-            ui.heading("Your equasion is balanced");
+            ui.heading("Your equation is balanced");
         } else {
-            ui.heading("Your equasion is not balanced");
+            ui.heading("Your equation is not balanced");
         }
 
         if self.all_atoms || !balanced {

stoik/src/formula/mod.rs

@@ -1,4 +1,4 @@
-//! This module is the main module for parsing chemical equasions
+//! This module is the main module for parsing chemical equations
 //!
 //! See the documentaion for [`Molecule`], [`assemble_tree`], [`TokenStream`] for more info
 //! ```
@@ -56,7 +56,7 @@ pub enum SyntaxNode {
 /// It requires an iterator of [`Token`] passed to it, idealy to be
 /// based off of [`TokenStream`]
 ///
-/// # Exampless
+/// # Examples
 ///
 /// Basic usage:
 /// ```

stoik/src/help_msg.txt

@@ -0,0 +1,8 @@
+Usage: stoik [FLAGS] ... [EQUATION] ...
+Computes whether EQUATION is chemically balanced or not
+
+All non-flag args are concatonated together to form EQUATION
+e.g. `stoik A + B -> C + D` is the same as `stoik "A + B -> C + D"`
+
+  -t, --time           Shows the time taken for the processing of each formula
+  -h, --help           Shows this

stoik/src/main.rs

@@ -1,79 +1,247 @@
 mod err;
 mod formula;
 
-use std::{env, time::Instant};
-
-use crate::{
-    err::StoikError,
-    formula::{assemble_tree, Molecule, TokenStream},
+use std::{
+    collections::{hash_map::Entry, HashMap},
+    env,
+    time::Instant,
 };
 
-fn main() {
-    // troll Na15[Mo126Mo28O462H14(H2O)70][Mo124Mo28O457H14(H2O)68]
+use err::StoikError;
+use formula::{Molecule, TokenStream};
 
-    let total_inst = Instant::now();
+const HELP_MSG: &str = include_str!("help_msg.txt");
 
-    let args: Vec<String> = env::args().skip(1).collect();
-    let mut streams = Vec::new();
+fn main() {
+    // C30H64N2O2Si4 (s) + C8H4Cl2O2 (s) -> C26H38N2O4Si2 (s) + 2C6H15ClSi (s)
+    let mut time_mode = false;
+    let mut all_moles = false;
+    let mut equation = String::new();
+    let mut time_table = vec!["Formula", "Tokenise", "Tree building", "Parsing", "Total"]
+        .iter()
+        .map(|x| vec![x.to_string()])
+        .collect::<Vec<_>>();
 
-    let stream_inst = Instant::now();
-    for i in args.iter() {
-        streams.push(TokenStream::new(i).collect::<Vec<_>>().into_iter());
+    for arg in env::args().skip(1) {
+        if arg == "--time" || arg == "-t" {
+            time_mode = true;
+        } else if arg == "--help" || arg == "-h" {
+            println!("{}", HELP_MSG);
+            return;
+        } else if arg == "--all-moles" || arg == "-a" {
+            all_moles = true;
+        } else {
+            equation = format!("{equation} {arg}");
+        }
     }
-    println!("Took {:.3?} to tokenise", stream_inst.elapsed());
+    equation = equation.trim().to_string();
 
-    let mut trees = Vec::new();
-    let tree_inst = Instant::now();
-    for stream in streams {
-        trees.push(assemble_tree(stream));
+    if !(equation.contains("->") || equation.contains("=>")) {
+        println!("Products are not given, please use `=>` or `->` to seperate the two sides");
+        return;
     }
-    println!("Took {:.3?} to build trees", tree_inst.elapsed());
-
-    let filtered_trees = trees
-        .into_iter()
-        .enumerate()
-        .filter_map(|(i, tree)| match tree {
-            Ok(tree) => {
-                #[cfg(debug_assertions)]
-                println!("{}: Syntax tree built", &args[i]);
-                Some(tree)
+
+    let temp_equ = equation.replace("=>", "->");
+    let (mut reactants_str, mut products_str) = temp_equ.split_once("->").unwrap();
+
+    reactants_str = reactants_str.trim();
+    products_str = products_str.trim();
+
+    let mut reactants = Vec::new();
+    for formula in reactants_str.split('+').map(|x| x.trim()) {
+        match construct_mole(formula, time_mode, &mut time_table) {
+            Ok(mol) => reactants.push((mol, formula.to_string())),
+            Err(e) => {
+                println!("{}", generate_error_msg(e, formula));
+                return;
             }
+        }
+    }
+
+    let mut products = Vec::new();
+    for formula in products_str.split('+').map(|x| x.trim()) {
+        match construct_mole(formula, time_mode, &mut time_table) {
+            Ok(mol) => products.push((mol, formula.to_string())),
             Err(e) => {
-                let msg = match e {
-                    StoikError::InvalidToken(loc) => {
-                        loc.format_msg(&args[i], "Malformed formula", "Illegal token")
-                    }
-                    StoikError::NumberFirst(loc) => loc.format_msg(
-                        &args[i],
-                        "Malformed formula",
-                        "Compound groups cannot start with numbers",
-                    ),
-                    StoikError::UnpairedParenthesis(loc) => {
-                        loc.format_msg(&args[i], "Malformed formula", "Unpaired parenthesis")
-                    }
-                    StoikError::UnpairedBracket(loc) => {
-                        loc.format_msg(&args[i], "Malformed formula", "Unpaired bracket")
-                    }
-                    e => e.to_string(),
-                };
-                println!("{msg}");
-                None
+                println!("{}", generate_error_msg(e, formula));
+                return;
             }
-        })
-        .collect::<Vec<_>>();
+        }
+    }
+
+    let mut lhs = HashMap::new();
+    for mol in reactants {
+        extend_mol_map(&mut lhs, mol.0.get_map());
+    }
+
+    let mut rhs = HashMap::new();
+    for mol in products {
+        extend_mol_map(&mut rhs, mol.0.get_map());
+    }
+
+    let mut keys = lhs.keys().collect::<Vec<_>>();
+    let mut balanced = HashMap::new();
+    keys.extend(rhs.keys());
+    keys.dedup();
+
+    for key in keys {
+        balanced.insert(key.to_string(), lhs.get(key) == rhs.get(key));
+    }
+
+    let is_balanced = balanced.values().all(|x| *x);
+
+    if is_balanced {
+        println!("`{equation}` is balanced")
+    } else {
+        println!("`{equation}` is not balanced")
+    }
+
+    if !is_balanced || all_moles {
+        let mut table = vec!["Element", "Reactants", "Products", "Balanced"]
+            .iter()
+            .map(|x| vec![x.to_string()])
+            .collect::<Vec<_>>();
+        for (element, bal) in balanced {
+            if !bal || all_moles {
+                table[1].push(lhs[&element].to_string());
+                table[2].push(rhs[&element].to_string());
+                table[0].push(element);
+                table[3].push(bal.to_string());
+            }
+        }
+        print_table(table);
+    }
+
+    if time_mode {
+        println!("\nTime summary");
+        print_table(time_table);
+    }
+}
 
-    let mut molecules = Vec::new();
-    let molar_inst = Instant::now();
-    for tree in filtered_trees {
-        molecules.push(Molecule::construct_from_tree(tree));
+// Move to a pub func from being copy pasted here and in stoik-gui/src/main.rs
+fn generate_error_msg(e: StoikError, formula: &str) -> String {
+    match e {
+        StoikError::InvalidToken(loc) => {
+            loc.format_msg(formula, "Malformed formula", "Illegal token")
+        }
+        StoikError::NumberFirst(loc) => loc.format_msg(
+            formula,
+            "Malformed formula",
+            "Compound groups cannot start with numbers",
+        ),
+        StoikError::UnpairedParenthesis(loc) => {
+            loc.format_msg(formula, "Malformed formula", "Unpaired parenthesis")
+        }
+        StoikError::UnpairedBracket(loc) => {
+            loc.format_msg(formula, "Malformed formula", "Unpaired bracket")
+        }
+        e => e.to_string(),
     }
-    println!("Took {:.3?} to build molecules", molar_inst.elapsed());
+}
 
-    for (i, mole) in molecules.into_iter().enumerate() {
-        match mole {
-            Ok(mole) => println!("{} -> {mole}", args[i]),
-            Err(e) => println!("Error with {}: {e}", args[i]),
+// same as generate_error_msg
+fn extend_mol_map(main: &mut HashMap<String, i64>, mol: HashMap<String, i64>) {
+    for (key, mol_val) in mol {
+        if let Entry::Occupied(mut entry) = main.entry(key.clone()) {
+            *entry.get_mut() += mol_val;
+        } else {
+            main.insert(key, mol_val);
         }
     }
-    println!("Took {:.3?} in total", total_inst.elapsed());
+}
+
+// This is some *sus* code
+// im too tired to write nice code for it
+fn print_table(table: Vec<Vec<String>>) {
+    let widths = table
+        .iter()
+        .map(|x| x.iter().max_by(|x, y| x.len().cmp(&y.len())).unwrap())
+        .map(|x| x.len())
+        .collect::<Vec<usize>>();
+    println!(
+        "{}",
+        "╔═".to_string()
+            + &widths
+                .iter()
+                .map(|x| "═".repeat(*x))
+                .collect::<Vec<String>>()
+                .join("═╦═")
+            + "═╗"
+    );
+    println!(
+        "{}",
+        "║ ".to_string()
+            + &table
+                .iter()
+                .enumerate()
+                .map(|(pos, x)| pad_string(&x[0], widths[pos]))
+                .collect::<Vec<String>>()
+                .join(" ║ ")
+            + " ║"
+    );
+    println!(
+        "{}",
+        "╠═".to_string()
+            + &widths
+                .iter()
+                .map(|x| "═".repeat(*x))
+                .collect::<Vec<String>>()
+                .join("═╬═")
+            + "═╣"
+    );
+    for i in 1..table[0].len() {
+        println!(
+            "{}",
+            "║ ".to_string()
+                + &table
+                    .iter()
+                    .enumerate()
+                    .map(|(pos, x)| pad_string(&x[i], widths[pos]))
+                    .collect::<Vec<String>>()
+                    .join(" ║ ")
+                + " ║"
+        );
+    }
+    println!(
+        "{}",
+        "╚═".to_string()
+            + &widths
+                .iter()
+                .map(|x| "═".repeat(*x))
+                .collect::<Vec<String>>()
+                .join("═╩═")
+            + "═╝"
+    );
+}
+
+fn pad_string(input: &String, length: usize) -> String {
+    let pad_len = length - input.chars().count();
+    input.to_string() + &" ".repeat(pad_len)
+}
+
+fn construct_mole(
+    formula: &str,
+    time_mode: bool,
+    time_table: &mut Vec<Vec<String>>,
+) -> Result<Molecule, StoikError> {
+    if time_mode {
+        time_table[0].push(formula.to_string());
+
+        let tokenise_inst = Instant::now();
+        let tokenstream = TokenStream::new(formula);
+        time_table[1].push(format!("{:>09.3?}", tokenise_inst.elapsed()));
+
+        let tree_inst = Instant::now();
+        let root = formula::assemble_tree(tokenstream)?;
+        time_table[2].push(format!("{:>09.3?}", tree_inst.elapsed()));
+
+        let mol_inst = Instant::now();
+        let mol = Molecule::construct_from_tree(root)?;
+        time_table[3].push(format!("{:>09.3?}", mol_inst.elapsed()));
+
+        time_table[4].push(format!("{:>09.3?}", tokenise_inst.elapsed()));
+        Ok(mol)
+    } else {
+        Molecule::from_formula(formula)
+    }
 }