User interface (#3)

* Basic GUI layout

* Combobox

* Input file frames

* Finish creator front end

* Finalize report creation

* Proper error handling with anyhow

* Basic merge UI

* Error handling

* Finalize CSV processing

* Fixup compiler

* Remove compile command from the GUI

* Description

* Authors

* Progressbar and threading

* Environment setup script for Windows (bash)

* Expand license allowlist

* Waiting GIF

* LFS

* Add logo

* Change per review request

* Code review fixup

* Resolve code review requests

* Code review comments

Author: davidhozic

.gitattributes

@@ -0,0 +1 @@
+src/blob/ssfe.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -15,3 +15,4 @@ Cargo.lock
 
 # Compiled latex code
 *.pdf
+.vscode/settings.json

Cargo.toml

@@ -1,14 +1,32 @@
 [package]
 name = "cloggen"
 version = "1.4.0"
-edition = "2021"
+edition = "2024"
 license = "MIT"
+rust-version = "1.88"
+description = "Utility for automatic opinion generation for habilitation reports of the Student Council FE UL (ŠSFE)."
+authors = [
+    "David Hožič"
+]
 
 [dependencies]
-tectonic = {version = "0.15.0", features=["external-harfbuzz"]}
 clap = { version = "4.5.20", features = ["derive"] }
 encoding_rs = "0.8.35"
 serde_json = "1.0.132"
 csv = "1.3.0"
 rand = "0.8.5"
 glob = "0.3.2"
+tectonic = { version = "0.15.0", features = ["external-harfbuzz"] }
+anyhow = "1.0.100"
+
+# GUI dependencies
+egui = {version = "0.33.0", optional = true}
+eframe = {version = "0.33.0", optional = true}
+rfd = {version  = "0.15.4", optional = true}
+open = {version = "5.3.2", optional = true}
+egui_extras = { version = "0.33.0", features = ["gif", "http"], optional = true}
+image = { version = "0.25.8", default-features = false, features = ["png"], optional = true}
+
+[features]
+gui = ["dep:egui", "dep:eframe", "dep:rfd", "dep:open", "dep:egui_extras", "dep:image"]
+default = ["gui"]

README.md

@@ -1,6 +1,12 @@
 # CLOGGEN
 Generator študentskih mnenj (za habilitacijo).
 
+## Kloniranje repozitorija
+Za kloniranje repozitorija je predhodno potrebno namestiti [git-lfs](https://git-lfs.com/).
+
+Ob naloženih zahtevah je mogoče repozitorij klonirati z ukazom `git clone`.
+Nato je potrebno zagnati `git lfs pull`.
+
 ## Namestitev pisave (font)
 Generiran dokument uporablja pisavo *Roboto*. V primeru, da pisava na sistemu ni nameščena, se dokument ne bo generiral.
 Za namestitev uporabi datoteke v mapi ``mnenja-template/fonts/Roboto``. Namesti vse datoteke.
@@ -10,6 +16,8 @@ Za namestitev uporabi datoteke v mapi ``mnenja-template/fonts/Roboto``. Namesti
 Cloggen se zanaša na LaTeX prevajalnik imenovan [Tectonic](https://tectonic-typesetting.github.io/book/latest/index.html).
 Tectonic se zanaša na določene sistemske knjižnice, ki jih je potrebno predhodno namestiti.
 
+Neodvisno od operacijskega sistema je predhodno potrebno nastaviti C++ standard na C++17 (`CXXFLAGS=-std=c++17`).
+
 ### Linux
 Prevajanje na Linuxu je enostavno. Namestiti je potrebno pakete preko upravljalnika paketov:
 

about.toml

@@ -7,7 +7,12 @@ accepted = [
     "WTFPL",
     "CC0-1.0",
     "Artistic-2.0",
-    "ISC"
+    "ISC",
+    "Zlib",
+    "BSL-1.0",
+    "OFL-1.1",
+    "Ubuntu-font-1.0",
+    "BSD-2-Clause"
 ]
 
 ignore-build-dependencies = true

env-windows.sh

@@ -0,0 +1,7 @@
+# Bash script for setting up the environmental variables.
+# Before running this, install vcpkg and the required packages (see README.md).
+# To setup the environment, source this file.
+export VCPKG_ROOT=$(realpath "../vcpkg/")
+export RUSTFLAGS='-Ctarget-feature=+crt-static'
+export VCPKGRS_TRIPLET='x64-windows-static-release'
+export TECTONIC_DEP_BACKEND='vcpkg'

src/blob/ssfe.png

@@ -1,21 +1,27 @@
+use tectonic::driver::{OutputFormat, ProcessingSessionBuilder};
+use tectonic::status::termcolor::TermcolorStatusBackend;
+use tectonic::config::PersistentConfig;
+use tectonic::status::ChatterLevel;
+
+
 use std::fs::{read_to_string, File};
+use std::time::SystemTime;
 use std::path::PathBuf;
-use tectonic as tec;
 use std::io::Write;
 use std::env;
 
 use crate::with_parent_path;
 
 
 /// Modification of [`tectonic::latex_to_pdf`] which adds stdout print to the console.
-pub fn compile_latex(latex: impl AsRef<str>) -> Vec<u8> {
-    let mut status = tec::status::termcolor::TermcolorStatusBackend::new(tec::status::ChatterLevel::Minimal);
-    let config = tec::config::PersistentConfig::open(false).expect("could not open config");
-    let bundle = config.default_bundle(false, &mut status).expect("could not get bundle");
+pub fn compile_latex(latex: impl AsRef<str>) -> std::io::Result<Vec<u8>> {
+    let mut status = TermcolorStatusBackend::new(ChatterLevel::Normal);
+    let config = PersistentConfig::open(false)?;
+    let bundle = config.default_bundle(false, &mut status)?;
     let mut files = {
         let mut sess;
-        let mut sb = tec::driver::ProcessingSessionBuilder::default();
-        let format_cache_path = config.format_cache_path().expect("could not get format cache path");
+        let mut sb = ProcessingSessionBuilder::default();
+        let format_cache_path = config.format_cache_path()?;
         sb.bundle(bundle)
             .primary_input_buffer(latex.as_ref().as_bytes())
             .tex_input_name("texput.tex")
@@ -24,19 +30,21 @@ pub fn compile_latex(latex: impl AsRef<str>) -> Vec<u8> {
             .keep_logs(false)
             .keep_intermediates(false)
             .print_stdout(false)
-            .output_format(tec::driver::OutputFormat::Pdf)
+            .output_format(OutputFormat::Pdf)
+            .build_date(SystemTime::now())
             .do_not_write_output_files();
-        sess = sb.create(&mut status).unwrap();
-        sess.run(&mut status).unwrap();
+        sess = sb.create(&mut status)?;
+        sess.run(&mut status)?;        
         sess.into_file_data()
     };
-    files.remove("texput.pdf").expect("compilation was successful but file data was not created").data
+    Ok(files.remove("texput.pdf").expect("compilation was successful but file data was not created").data)
 }
 
 
-pub fn cmd_compile(path: &PathBuf) {
-    let fdata = read_to_string(path).expect("unable to read file");
-    let compiled = with_parent_path!(path, {compile_latex(fdata)});
-    let mut file = File::create(path.display().to_string() + ".pdf").expect("unable to create output file");
-    file.write_all(&compiled).expect("unable to write latex to file");
+pub fn cmd_compile(path: &PathBuf) -> std::io::Result<()> {
+    let fdata = read_to_string(path)?;
+    let compiled = with_parent_path!(path, {compile_latex(fdata)?});
+    let mut file = File::create(path.display().to_string() + ".pdf")?;
+    file.write_all(&compiled)?;
+    Ok(())
 }

src/compiler.rs

@@ -0,0 +1,23 @@
+//! Common configuration.
+/// Constants used for the Create command.
+#[allow(unused)]
+pub mod create {
+    use crate::create::OutputFormat;
+
+    /// Default section inside the CSV file to parse. STUDIS CSV files can have multiple sections ---
+    /// e.g., section about the subject, section about the teacher, etc.
+    pub const SECTION_DEFAULT: &str = "Anketa o izvajalcu";
+    
+    /// Default output format.
+    pub const FORMAT_DEFAULT: OutputFormat = OutputFormat::Pdf;
+    pub const FORMAT_DEFAULT_STR: &str = "pdf";
+}
+
+/// Constants used for the Merge command.
+pub mod merge {
+    /// Default section inside the CSV file to parse. STUDIS CSV files can have multiple sections ---
+    /// e.g., section about the subject, section about the teacher, etc.
+    pub const SECTION_DEFAULT: &str = super::create::SECTION_DEFAULT;
+    /// The default output file of the merged CSV data.
+    pub const OUTPUT_DEFAULT: &str = "merged.csv";
+}

src/config.rs

@@ -1,11 +1,14 @@
 /// Module related to the ``create`` command.
 
 use rand::distributions::Uniform;
-use std::path::{Path, PathBuf};
-use std::io::{Read, Write};
-use serde_json as sj;
 use rand::{thread_rng, Rng};
+
+use anyhow::{Context, Result, anyhow};
+use serde_json as sj;
 use clap::ValueEnum;
+
+use std::path::{Path, PathBuf};
+use std::io::{Read, Write};
 use std::fs::File;
 use std::time;
 use std::env;
@@ -30,10 +33,10 @@ pub fn command_create(
     studis_csv_filepath: &PathBuf,
     response_json_filepath: &PathBuf,
     tex_template_filepath: &PathBuf,
-    section: &String,
+    section: &str,
     format: &OutputFormat,
     output_filepath: &Option<PathBuf>
-) -> String {
+) -> Result<String> {
     const E_NOT_MAPPING: &str = "Not a JSON mapping";
 
     const C_MEAN_CSV_KEY: &str = "Povprečje";
@@ -48,25 +51,25 @@ pub fn command_create(
     let mut file: File;
     let mut output_fdata: String = String::new();
     let mut output_parts = Vec::new();
-    file = File::open(tex_template_filepath).expect(&format!("could not open tex file ({tex_template_filepath:?})"));
-    file.read_to_string(&mut output_fdata).expect(&format!("Unable to read file {tex_template_filepath:?}"));
+    file = File::open(tex_template_filepath).with_context(|| format!("could not open tex file ({tex_template_filepath:?})"))?;
+    file.read_to_string(&mut output_fdata).with_context(|| format!("Unable to read file {tex_template_filepath:?}"))?;
 
     if !output_fdata.contains(C_OUTPUT_LATEX_REPLACE_KEY) {
-        panic!(
+        return Err(anyhow!(
             "output file ({tex_template_filepath:?}) does not mark the location \
             of automatically-generated content (generated by this script). Mark it by writing \
             \"{C_OUTPUT_LATEX_REPLACE_KEY}\" somewhere in the file"
-        );
+        ));
     }
 
     // Process STUDIS CSV file.
-    let fdata = fs::read_file_universal(studis_csv_filepath).expect("unable to read STUDIS CSV");
-    let csvgrades = preproc::extract_section_columns(preproc::preprocess_candidate_csv(fdata), section);
+    let fdata = fs::read_file_universal(studis_csv_filepath).with_context(|| "unable to read STUDIS CSV")?;
+    let csvgrades = preproc::extract_section_columns(preproc::preprocess_candidate_csv(fdata), section)?;
 
     // Process JSON file. This is the file containing responses for each category and each grade.
-    file = File::open(response_json_filepath).expect(&format!("could not open responses file ({response_json_filepath:?})"));   
-    let json_map: sj::Map<_, _> = sj::from_reader(file).expect(E_NOT_MAPPING);
-    let categories: &sj::Map<_, _> = &json_map[C_JSON_MAP_QUESTION_KEY].as_object().expect(E_NOT_MAPPING);
+    file = File::open(response_json_filepath).with_context(|| format!("could not open responses file ({response_json_filepath:?})"))?;
+    let json_map: sj::Map<_, _> = sj::from_reader(file).with_context(|| E_NOT_MAPPING)?;
+    let categories: &sj::Map<_, _> = json_map[C_JSON_MAP_QUESTION_KEY].as_object().with_context(|| E_NOT_MAPPING)?;
     let mut idx: usize;
     let mut start_size: usize;
 
@@ -80,21 +83,22 @@ pub fn command_create(
     // Iterate each category/question of the JSON responses file
     for (cat, grades_json) in categories {
         // Get index of the question matching JSON category
-        idx = csvgrades.get(C_JSON_MAP_QUESTION_KEY).expect("CSV is missing questions key.")
-            .iter().position(|x| x == cat).expect(&format!("CSV is missing category \"{cat}\""));
+        idx = csvgrades.get(C_JSON_MAP_QUESTION_KEY).with_context(|| "CSV is missing questions key.")?
+            .iter().position(|x| x == cat).with_context(|| format!("CSV is missing category \"{cat}\""))?;
 
         // Read the String of the mean and std, then parse them to float
-        smean = &csvgrades.get(C_MEAN_CSV_KEY).expect("CSV is missing the mean grade value key")[idx];
-        mean = smean.parse().unwrap();
-        sstd = &csvgrades.get(C_STD_CSV_KEY).expect("CSV is missing the std of grade key")[idx];
-        // std = sstd.parse().unwrap();
+        smean = &csvgrades.get(C_MEAN_CSV_KEY).with_context(|| "CSV is missing the mean grade value key")?[idx];
+        mean = smean.parse().with_context(|| format!("failed to parse {smean} as a float"))?;
+        sstd = &csvgrades.get(C_STD_CSV_KEY).with_context(|| "CSV is missing the std of grade key")?[idx];
 
         // Obtain the mapping of min. grade => array of String responses
-        let grades_json = grades_json.as_object().cloned().expect(E_NOT_MAPPING);
-        let mut grades: Vec<(&String, f64)> = grades_json.keys().map(
-            // Save grades in format (String (original), parsed float)
-            |x| (x, x.parse().expect(&format!("grades must be floats (\"{x}\")")))
-        ).collect();
+        let grades_json = grades_json.as_object().cloned().with_context(|| E_NOT_MAPPING)?;
+        let mut grades = Vec::with_capacity(grades_json.len());
+        // Try to parse each grade into a float. If any fails, return the error.
+        for k in grades_json.keys() {
+            let parsed: f64 = k.parse().with_context(|| format!("grades must be floats (\"{k}\")"))?;
+            grades.push((k, parsed));
+        }
 
         // Sort the grades by the parsed value
         grades.sort_by(|(_, a), (_, b)| b.total_cmp(a));
@@ -110,26 +114,30 @@ pub fn command_create(
         let response_str;
         for (sgrade, grade) in grades.iter() {
             if (grade * 10000.0) as usize <= (mean * 10000.0) as usize {  // Prevent influence of numeric error
-                let v = grades_json.get(*sgrade).unwrap();
+                let v = &grades_json[*sgrade];  // no need to check existence,because grades is generated from grades_json
 
                 // Query elapsed nanoseconds in order to improve randomness.
                 epoch_ns = time::SystemTime::now()
-                    .duration_since(time::UNIX_EPOCH)
-                    .expect("SystemTime is before EPOCH!")
+                    .duration_since(time::UNIX_EPOCH)?
                     .as_nanos();
-                responses = v.as_array()
-                    .expect(&format!("value of Category->Grade->Value must be an array of strings. Found {v:?}"));
 
-                if responses.len() == 0 {
-                    panic!("there are no defined responses for grade {sgrade}, category {cat:?}");
+                // Try to parse the array of possible responses under the given grade.
+                responses = v.as_array().with_context(|| format!(
+                    "value of Category->Grade->Value must be an array of strings. Found {v:?}"
+                ))?;
+
+                if responses.is_empty() {
+                    return Err(anyhow!("there are no defined responses for grade {sgrade}, category {cat:?}"));
                 }
 
                 response_idx = (
                     (epoch_ns % responses.len() as u128
                     + rgn.sample(Uniform::new(0, responses.len())) as u128) % responses.len() as u128
                 ) as usize;
                 response = &responses[response_idx];
-                response_str = response.as_str().expect(&format!("responses must be strings ({response} is not)"));
+                response_str = response.as_str().with_context(
+                    || format!("responses must be strings ({response} is not)")
+                )?;
                 output_parts.push(
                     response_str.replace(C_OUTPUT_LATEX_MEAN_KEY, smean)
                                 .replace(C_OUTPUT_LATEX_STD_KEY, sstd)
@@ -140,7 +148,7 @@ pub fn command_create(
 
         // Check if loop was not break-ed;
         if start_size == output_parts.len() {
-            panic!("could not find grade below mean ({mean}) for category \"{cat}\"");
+            return Err(anyhow!("could not find grade below mean ({mean}) for category \"{cat}\""));
         }
     }
 
@@ -172,43 +180,19 @@ pub fn command_create(
                 output += ".tex";
             }
 
-            file = File::create(&output).expect("could not write output LaTex");
-            file.write_all(output_fdata.as_bytes()).unwrap();
+            file = File::create(&output).with_context(|| "could not write output LaTex")?;
+            file.write_all(output_fdata.as_bytes())?;
         },
         OutputFormat::Pdf => {
             if !output.ends_with(".pdf") {
                 output += ".pdf";
             }
 
-            let pdfdata = with_parent_path!(tex_template_filepath, {compiler::compile_latex(output_fdata)});
-            file = File::create(&output).expect("could not create final PDF");
-            file.write_all(&pdfdata).unwrap();
+            let pdfdata = with_parent_path!(tex_template_filepath, {compiler::compile_latex(output_fdata)?});
+            file = File::create(&output).with_context(|| "could not create final PDF")?;
+            file.write_all(&pdfdata)?;
         }
     }
 
-    return output;
-}
-
-
-#[cfg(test)]
-mod tests {
-    use std::path::PathBuf;
-    use super::*;
-
-    const CSV: &str = "anketa.csv";
-    const JSON: &str = "odzivi.json";
-    const LATEX: &str = "mnenja-template/mnenje.tex";
-
-    #[test]
-    fn test_create() {
-        let path = command_create(
-            &PathBuf::from(CSV),
-            &PathBuf::from(JSON),
-            &PathBuf::from(LATEX),
-            &"Anketa o izvajalcu".to_string(),
-            &OutputFormat::Pdf,
-            &None
-        );
-        std::fs::remove_file(path).expect("ouput PDF file not created");
-    }
+    Ok(output)
 }