Fixed bug serializing/deserializing workbooks

Author: margual56

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "turing-machine"
-version = "1.2.1"
+version = "1.2.1-rc2"
 edition = "2021"
 authors = ["Marcos Gutiérrez Alonso <[email protected]>"]
 description = "Turing Machine Simulator"

Cargo.toml

@@ -857,8 +857,11 @@ impl MyApp {
                             ui.label(t!("lbl.resumed", lang));
                         }
                         let b = ui.button(text);
-                        
-                        if (b.clicked() || ui.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Space)))
+
+                        if (b.clicked()
+                            || ui.input_mut(|i| {
+                                i.consume_key(egui::Modifiers::NONE, egui::Key::Space)
+                            }))
                             && !editor_focused
                         {
                             if self.tm.finished() {
@@ -896,19 +899,33 @@ impl eframe::App for MyApp {
 
         ctx.input_mut(|i| {
             // Check for keyboard shortcuts
-            if i.consume_shortcut(&egui::KeyboardShortcut::new(egui::Modifiers::COMMAND, egui::Key::S)){
+            if i.consume_shortcut(&egui::KeyboardShortcut::new(
+                egui::Modifiers::COMMAND,
+                egui::Key::S,
+            )) {
                 // Ctrl+S
                 debug!("Saving...");
                 self.save_file();
-            } else if i.consume_shortcut(&egui::KeyboardShortcut::new(egui::Modifiers::COMMAND, egui::Key::O)) {
+            } else if i.consume_shortcut(&egui::KeyboardShortcut::new(
+                egui::Modifiers::COMMAND,
+                egui::Key::O,
+            )) {
                 // Ctrl+O
                 debug!("Opening...");
                 self.load_file();
-            } else if i.modifiers.shift && i.consume_shortcut(&egui::KeyboardShortcut::new(egui::Modifiers::CTRL, egui::Key::S)) {
+            } else if i.modifiers.shift
+                && i.consume_shortcut(&egui::KeyboardShortcut::new(
+                    egui::Modifiers::CTRL,
+                    egui::Key::S,
+                ))
+            {
                 // Ctrl+Shift+S
                 debug!("Saving as...");
                 self.save_file_as();
-            } else if i.consume_shortcut(&egui::KeyboardShortcut::new(egui::Modifiers::COMMAND, egui::Key::R)) {
+            } else if i.consume_shortcut(&egui::KeyboardShortcut::new(
+                egui::Modifiers::COMMAND,
+                egui::Key::R,
+            )) {
                 // Ctrl+R
                 debug!("Restarting...");
                 self.tm = self.tm.restart(&self.code).unwrap();

src/window.rs

@@ -3,18 +3,18 @@ use serde::{self, Deserialize, Serialize};
 
 use crate::windows::workbook::raw_data_to_image;
 
-use super::{exercise::Exercise, load_workbook, MAX_IMG_SIZE};
+use super::{exercise::Exercise, load_workbook, Workbook, MAX_IMG_SIZE};
 
 #[derive(Serialize, Deserialize)]
 pub struct BookWindow {
     lang: String,
-    exercises: Vec<(String, Vec<Exercise>)>,
+    exercises: Workbook,
     selected: (usize, usize),
 }
 
 impl BookWindow {
     pub fn new(lang: &str) -> Self {
-        let exercises: Vec<(String, Vec<Exercise>)> = vec![
+        let exercises: Workbook = vec![
             (
                 "Chapter 1".to_string(),
                 vec![
@@ -96,7 +96,7 @@ impl BookWindow {
                     });
 
                     ui.vertical_centered_justified(|ui| {
-                        if let Some(img) = &self.get_exercise(self.selected).image {
+                        if let Some(img) = self.get_exercise(self.selected).get_cover() {
                             img.show_max_size(ui, MAX_IMG_SIZE);
 
                             // Add expandable empty space
@@ -137,7 +137,7 @@ impl BookWindow {
         (active, code)
     }
 
-    fn get_exercise(&self, i: (usize, usize)) -> &Exercise {
-        &self.exercises[i.0].1[i.1]
+    fn get_exercise(&mut self, i: (usize, usize)) -> &mut Exercise {
+        &mut self.exercises[i.0].1[i.1]
     }
 }

src/windows/workbook/book.rs

@@ -1,14 +1,11 @@
 use eframe::epaint::ColorImage;
 use egui_extras::RetainedImage;
-use serde::{
-    self,
-    de::{Error as SerdeError, SeqAccess, Visitor},
-    ser::SerializeStruct,
-    Deserialize, Deserializer, Serialize, Serializer,
-};
-use std::fmt;
+use serde::{self, Deserialize, Serialize};
+use std::fmt::{self, Debug};
 
+#[derive(Serialize, Deserialize)]
 pub struct Exercise {
+    #[serde(skip)]
     pub image: Option<RetainedImage>,
     original_image: Option<(usize, usize, Vec<u8>)>,
     pub title: String,
@@ -46,106 +43,27 @@ impl Exercise {
             img.pixels.iter().map(|p| p.to_array()).flatten().collect(),
         ));
     }
-}
-
-impl Serialize for Exercise {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let mut state = serializer.serialize_struct("Exercise", 4)?;
-
-        // Ensure title is valid UTF-8
-        let title = match String::from_utf8(self.title.clone().into_bytes()) {
-            Ok(valid_title) => valid_title,
-            Err(_) => {
-                // Handle the case where the title is not valid UTF-8, e.g., by replacing invalid sequences with � (U+FFFD)
-                String::from_utf8_lossy(&self.title.as_bytes()).to_string()
-            }
-        };
-
-        state.serialize_field("title", &title)?;
-        if let Some(img) = &self.original_image {
-            state.serialize_field("original_image", img)?;
-        }
-        state.serialize_field("code", &self.code)?;
-
-        state.end()
-    }
-}
-
-impl<'de> Deserialize<'de> for Exercise {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        struct ExerciseVisitor;
-
-        impl<'de> Visitor<'de> for ExerciseVisitor {
-            type Value = Exercise;
 
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("an Exercise in binary format")
-            }
-
-            fn visit_seq<A>(self, mut seq: A) -> Result<Exercise, A::Error>
-            where
-                A: SeqAccess<'de>,
-            {
-                let title: String = seq
-                    .next_element()?
-                    .ok_or_else(|| A::Error::invalid_length(0, &self))?;
-                let original_image: (usize, usize, Vec<u8>) = seq
-                    .next_element()?
-                    .ok_or_else(|| A::Error::invalid_length(1, &self))?;
-                let code: String = seq
-                    .next_element()?
-                    .ok_or_else(|| A::Error::invalid_length(2, &self))?;
-
-                Ok(Exercise::new(
-                    &title,
-                    Some(ColorImage::from_rgba_unmultiplied(
-                        [original_image.0 as usize, original_image.1 as usize],
-                        &original_image.2,
-                    )),
-                    code,
-                ))
+    pub fn get_cover(&mut self) -> Option<&RetainedImage> {
+        match self.image {
+            Some(ref img) => Some(img),
+            None => {
+                if let Some(img) = &self.original_image {
+                    self.set_cover(ColorImage::from_rgba_premultiplied([img.0, img.1], &img.2));
+                    self.image.as_ref()
+                } else {
+                    None
+                }
             }
         }
-
-        deserializer.deserialize_tuple(3, ExerciseVisitor)
     }
 }
 
-// Custom deserializer for the tuple (String, Vec<Exercise>)
-#[allow(dead_code)]
-fn deserialize_tuple<'de, D>(deserializer: D) -> Result<(String, Vec<Exercise>), D::Error>
-where
-    D: Deserializer<'de>,
-{
-    struct TupleVisitor;
-
-    impl<'de> Visitor<'de> for TupleVisitor {
-        type Value = (String, Vec<Exercise>);
-
-        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            formatter.write_str("a tuple (String, Vec<Exercise>) in binary format")
-        }
-
-        fn visit_seq<A>(self, mut seq: A) -> Result<(String, Vec<Exercise>), A::Error>
-        where
-            A: SeqAccess<'de>,
-        {
-            let key: String = seq
-                .next_element()?
-                .ok_or_else(|| A::Error::invalid_length(0, &self))?;
-            let value: Vec<Exercise> = seq
-                .next_element()?
-                .ok_or_else(|| A::Error::invalid_length(1, &self))?;
-
-            Ok((key, value))
-        }
+impl Debug for Exercise {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Exercise")
+            .field("title", &self.title)
+            .field("code", &self.code)
+            .finish()
     }
-
-    deserializer.deserialize_tuple(2, TupleVisitor)
 }

src/windows/workbook/exercise.rs

@@ -12,17 +12,20 @@ use eframe::egui;
 use self::exercise::Exercise;
 use eframe::epaint::ColorImage;
 
+type WorkbookChapter = (String, Vec<Exercise>);
+type Workbook = Vec<WorkbookChapter>;
+
 #[cfg(not(target_arch = "wasm32"))]
 use {
+    log::{debug, error},
     rfd,
     std::{fs::File, io::Write, path::PathBuf},
-    log::{debug, error}
 };
 
 #[cfg(target_arch = "wasm32")]
 use {
-    js_sys, web_sys, wasm_bindgen::prelude::*, wasm_bindgen::JsCast, 
-    base64::engine::general_purpose::STANDARD_NO_PAD as base64,
+    base64::engine::general_purpose::STANDARD_NO_PAD as base64, js_sys, wasm_bindgen::prelude::*,
+    wasm_bindgen::JsCast, web_sys,
 };
 
 const MAX_IMG_SIZE: egui::Vec2 = egui::Vec2::new(600.0, 250.0);
@@ -70,7 +73,7 @@ fn load_image() -> Option<ColorImage> {
     {
         /*
         FIXME: Not working
-         
+
         let window = web_sys::window().expect("Failed to get window");
         let document = window.document().expect("Failed to get document");
         let input = document
@@ -173,12 +176,12 @@ fn image_to_raw_data(color_image: &ColorImage) -> (usize, usize, Vec<u8>) {
     (size[0], size[1], raw_data.to_vec())
 }
 
-pub fn save_workbook(exercises: &Vec<(String, Vec<Exercise>)>) {
+pub fn save_workbook(exercises: &Workbook) {
     #[cfg(target_arch = "wasm32")]
     {
         /*
         FIXME: Not working
-         
+
         let data = bincode::serialize(&exercises).unwrap();
         let data_url = format!(
             "data:application/octet-stream;base64,{}",
@@ -202,19 +205,22 @@ pub fn save_workbook(exercises: &Vec<(String, Vec<Exercise>)>) {
             let data = bincode::serialize(&exercises).unwrap();
             let mut file = File::create(&f).unwrap();
             file.write_all(&data).unwrap();
+
             debug!("Workbook saved at {:?}", f);
+
+            drop(file);
         } else {
             error!("Cannot save workbook");
         }
     }
 }
 
-pub fn load_workbook() -> Option<Vec<(String, Vec<Exercise>)>> {
+pub fn load_workbook() -> Option<Workbook> {
     #[cfg(target_arch = "wasm32")]
     {
         /*
         FIXME: Not working
-         
+
         let window = web_sys::window().unwrap();
         let document = window.document().unwrap();
         let input = document
@@ -248,19 +254,19 @@ pub fn load_workbook() -> Option<Vec<(String, Vec<Exercise>)>> {
         let file_path = rfd::FileDialog::new()
             .add_filter("TuringMachine Workbook", &["wb"])
             .set_directory(&path)
-            .pick_files();
+            .pick_file();
 
         match file_path {
             Some(f) => {
-                let mut file = File::open(&f[0]).expect("File not found");
+                let mut file = File::open(&f).expect("File not found");
                 let mut reader: Vec<u8> = Vec::new();
                 file.read_to_end(&mut reader).expect("Could not read file");
 
+                debug!("Read {} bytes", reader.len());
 
-
-                match bincode::deserialize(&reader) {
+                match bincode::deserialize::<Workbook>(&reader) {
                     Ok(exercises) => {
-                        debug!("Workbook loaded from {:?}", f[0]);
+                        debug!("Workbook loaded from {:?}", &f);
                         Some(exercises)
                     }
                     Err(e) => {

src/windows/workbook/mod.rs

@@ -1,16 +1,18 @@
 use eframe::egui;
 
-use super::{exercise::Exercise, load_image, save_workbook, MAX_IMG_SIZE};
+use super::{
+    exercise::Exercise, load_image, save_workbook, Workbook, WorkbookChapter, MAX_IMG_SIZE,
+};
 
 pub struct WorkbookEditorWindow {
     lang: String,
-    chapters: Vec<(String, Vec<Exercise>)>,
+    chapters: Workbook,
     selected: (usize, usize),
 }
 
 impl WorkbookEditorWindow {
     pub fn new(lang: &str) -> Self {
-        let exercises: Vec<(String, Vec<Exercise>)> = vec![];
+        let exercises: Workbook = vec![];
 
         Self {
             lang: String::from(lang),
@@ -167,7 +169,7 @@ impl WorkbookEditorWindow {
         active
     }
 
-    fn new_chapter(chapters_len: usize, exercises_len: usize) -> (String, Vec<Exercise>) {
+    fn new_chapter(chapters_len: usize, exercises_len: usize) -> WorkbookChapter {
         (
             format!("New Chapter {}", chapters_len + 1),
             vec![WorkbookEditorWindow::new_exercise(exercises_len)],