Merge pull request #150 from j-mie6/main

v0.4.3

Author: AdamW1087

backend/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "dill"
-version = "0.4.0"
+version = "0.4.3"
 description = "A cross-platform debugging UI for `parsley-debug`"
 authors = ["Jamie Willis (@j-mie6)", "Josh Walker (@josh-ja-walker)", "Aniket Gupta (@aniket1101)", "Priyansh Chugh (@PriyanshC)", "Alejandro Perez Fadon (@Aito0)", "Riley Horrix (@Riley-horrix)", "Adam Watson (@AdamW1087)"]
 license = "BSD 3-Clause"

backend/Cargo.toml

@@ -8,7 +8,6 @@ pub fn handlers() -> impl Fn(tauri::ipc::Invoke) -> bool {
         fetch::fetch_debug_tree, 
         fetch::fetch_node_children, 
         save::save_tree, 
-        save::fetch_saved_tree_names, 
         save::load_saved_tree,
         save::delete_tree,
         breakpoint::skip_breakpoints,

backend/src/commands.rs

@@ -9,10 +9,10 @@ use crate::files::SAVED_TREE_DIR;
 
 /* Saves current tree to saved_trees/name.json */
 #[tauri::command]
-pub fn save_tree(state: tauri::State<AppState>, tree_name: String) -> Result<(), SaveTreeError> {
+pub fn save_tree(state: tauri::State<AppState>, tree_name: String) -> Result<String, SaveTreeError> {
     /* Access the `tree` field from the locked state */
     let saved_tree: SavedTree = SavedTree::from(state.get_tree()?); 
-    
+
     /* Get the serialised JSON */
     let tree_json: String = serde_json::to_string_pretty(&saved_tree)
         .map_err(|_| SaveTreeError::SerialiseFailed)?;
@@ -24,8 +24,12 @@ pub fn save_tree(state: tauri::State<AppState>, tree_name: String) -> Result<(),
 
     /* Write tree json to the json file */
     data_file.write(tree_json.as_bytes()).map_err(|_| SaveTreeError::WriteTreeFailed)?;
+    
+    /* Get a list of all saved tree names */
+    let tree_names: Vec<String> = state.add_tree(tree_name).map_err(|_| SaveTreeError::AddTreeFailed)?;
 
-    Ok(())
+    serde_json::to_string_pretty(&tree_names)
+        .map_err(|_| SaveTreeError::SerialiseFailed)
 }
 
 #[derive(Debug, serde::Serialize)]
@@ -35,6 +39,7 @@ pub enum SaveTreeError {
     SerialiseFailed,
     CreateDirFailed,
     WriteTreeFailed,
+    AddTreeFailed,
 }
 
 impl From<StateError> for SaveTreeError {
@@ -50,63 +55,49 @@ impl From<StateError> for SaveTreeError {
 
 /* Delete file associated with where tree is saved */
 #[tauri::command]
-pub fn delete_tree(tree_name: String) -> Result<(), DeleteTreeError> {
+pub fn delete_tree(state: tauri::State<AppState>, index: usize) -> Result<String, DeleteTreeError> {
+    /* Get the tree name given the index */
+    let tree_name: String = state.get_tree_name(index).map_err(|_| DeleteTreeError::NameRetrievalFail)?;
+
     /* Path to the json file used to store the tree */
     let file_path: String = format!("{}{}.json", SAVED_TREE_DIR, tree_name);
 
     /* Remove the file from the file system */
     fs::remove_file(file_path).map_err(|_| DeleteTreeError::TreeFileRemoveFail)?;
-    Ok(())
-}
-
-#[derive(Debug, serde::Serialize)]
-pub enum DeleteTreeError {
-    TreeFileRemoveFail,
-}
 
+    /* Returns a list of the tree names that are left */
+    let tree_names: Vec<String> = state.rmv_tree(index).map_err(|_| DeleteTreeError::TreeRemovalFail)?;
 
-/* Returns a list of filenames in saved_trees */
-#[tauri::command]
-pub fn fetch_saved_tree_names() -> Result<String, FetchTreeNameError>  {
-    /* Get all path names inside the saved_trees folder */
-    let paths: fs::ReadDir = fs::read_dir(SAVED_TREE_DIR).map_err(|_| FetchTreeNameError::ReadDirFailed)?;
-
-    /* Strip off the extension and add only the name to names */
-    let names: Vec<String> = paths.into_iter()
-        .map(|path| {
-            let path: fs::DirEntry = path.map_err(|_| FetchTreeNameError::ReadPathFailed)?;
-            let file_name: String = path.file_name().into_string().map_err(|_| FetchTreeNameError::StringContainsInvalidUnicode)?;
-            let name: &str = file_name.strip_suffix(".json").ok_or(FetchTreeNameError::SuffixNotFound)?;
-            Ok(name.to_string())
-        }).collect::<Result<Vec<String>, FetchTreeNameError>>()?;
-
-    /* Serialise names */
-    serde_json::to_string_pretty(&names)
-        .map_err(|_| FetchTreeNameError::SerialiseFailed)
+    serde_json::to_string_pretty(&tree_names)
+        .map_err(|_| DeleteTreeError::SerialiseFailed)
 }
 
 #[derive(Debug, serde::Serialize)]
-pub enum FetchTreeNameError {
-    ReadDirFailed,
-    ReadPathFailed,
-    StringContainsInvalidUnicode,
-    SuffixNotFound,
+pub enum DeleteTreeError {
+    TreeFileRemoveFail,
+    NameRetrievalFail,
+    TreeRemovalFail,
     SerialiseFailed,
 }
 
 
 /* Fetches a tree from saved_trees and resets the tree in the tauri state */
 #[tauri::command]
-pub fn load_saved_tree(tree_name: String, state: tauri::State<AppState>) -> Result<(), LoadTreeError>  {
+pub fn load_saved_tree(index: usize, state: tauri::State<AppState>) -> Result<(), LoadTreeError>  {
+    /* Get the tree name given the index */
+    let tree_name: String = state.get_tree_name(index).map_err(|_| LoadTreeError::NameRetrievalFail)?;
+
     /* Get the file path of the tree to be reloaded */
     let file_path: String = format!("{}{}.json", SAVED_TREE_DIR, tree_name);
-
+    
     /* Read the contents of the file as a string */
     let contents: String = fs::read_to_string(file_path)
         .map_err(|_| LoadTreeError::ReadFileFailed)?;
 
+
     /* Deserialize the tree into SavedTree, then convert to DebugTree */
     let saved_tree: SavedTree = serde_json::from_str(&contents).map_err(|_| LoadTreeError::DeserialiseFailed)?;
+
     let tree: DebugTree = DebugTree::from(saved_tree);
 
     /* Update the global tauri state with the reloaded tree */
@@ -118,6 +109,7 @@ pub fn load_saved_tree(tree_name: String, state: tauri::State<AppState>) -> Resu
 #[derive(Debug, serde::Serialize)]
 #[allow(clippy::enum_variant_names)]
 pub enum LoadTreeError {
+    NameRetrievalFail,
     LockFailed,
     ReadFileFailed,
     DeserialiseFailed,

backend/src/commands/save.rs

@@ -15,6 +15,7 @@ struct AppStateInternal {
     tree: Option<DebugTree>,        /* Parser tree that is posted to Server */
     map: HashMap<u32, DebugNode>,   /* Map from node_id to the respective node */
     skips_tx: TokioMutex<SkipsSender>, /* Transmitter how many breakpoints to skip, sent to parsley */
+    tab_names: Vec<String>,         /* List of saved tree names */
 }
 
 
@@ -31,6 +32,7 @@ impl AppState {
                     tree: None,
                     map: HashMap::new(),
                     skips_tx,
+                    tab_names: Vec::new(),
                 }
             )
         )
@@ -41,6 +43,39 @@ impl AppState {
         self.0.lock()
             .map_err(|_| StateError::LockFailed)
     }
+
+    /* Add tree name to tab_names */
+    pub fn add_tree(&self, new_tab: String) -> Result<Vec<String>, StateError> {
+        let mut state: MutexGuard<AppStateInternal> = self.inner()?;
+
+        /* Add new tree name and return all saved tree names */
+        state.tab_names.push(new_tab);
+
+        Ok(state.tab_names.clone())
+    }
+
+    /* Remove tree name from tab_names */
+    pub fn rmv_tree(&self, index: usize) -> Result<Vec<String>, StateError> {
+        let mut state: MutexGuard<AppStateInternal> = self.inner()?;
+
+        /* Remove tree name at index */
+        state.tab_names.remove(index);
+
+        /* If this was the final tree then the loaded tree needs to be removed */
+        if state.tab_names.is_empty() {
+            state.tree = None
+        }
+
+        Ok(state.tab_names.clone())
+    }
+
+    /* Given an index returns the tree name */
+    pub fn get_tree_name(&self, index: usize) -> Result<String, StateError> {
+        let state: MutexGuard<AppStateInternal> = self.inner()?;
+
+        /* Index will never be out of range as the frontend representation and the backend will be in sync */
+        Ok(state.tab_names[index].clone()) 
+    }
 }
 
 

backend/src/state/app_state.rs

@@ -1,7 +1,7 @@
 {
     "$schema": "../node_modules/@tauri-apps/cli/config.schema.json",
     "productName": "dill",
-    "version": "0.4.0",
+    "version": "0.4.3",
     "identifier": "com.dill.dev",
     "build": {
         "frontendDist": "../dist",

backend/tauri.conf.json

@@ -7,7 +7,7 @@ val Scala3 = "3.6.3"
 
 val scalatestVersion = "3.2.19"
 
-val Version = "0.4.0"
+val Version = "0.4.3"
 
 Global / onChangedBuildSource := ReloadOnSourceChanges
 Global / excludeLintKeys += dillFrontend / Compile / stMinimize

build.sbt

@@ -83,34 +83,27 @@ object Command {
                 def namedArgs: Map[String, Any] = Map("treeName" -> treeName)
         }
 
-        type Out = Unit
-    }
-
-    case object FetchSavedTreeNames extends Command("fetch_saved_tree_names") {
-        type In = Unit
-        given args: Args[In] = Args.noArgs 
-
         type Out = List[String]
     }
 
     case object LoadSavedTree extends Command("load_saved_tree") {
-        type In = String
-        given args: Args[String] {
-            extension (treeName: String)
-                def namedArgs: Map[String, Any] = Map("treeName" -> treeName)
+        type In = Int
+        given args: Args[Int] {
+            extension (index: Int)
+                def namedArgs: Map[String, Any] = Map("index" -> index)
         }
 
         type Out = Unit
     }
 
     case object DeleteTree extends Command("delete_tree") {
-        type In = String
-        given args: Args[String] {
-            extension (treeName: String)
-                def namedArgs: Map[String, Any] = Map("treeName" -> treeName)
+        type In = Int
+        given args: Args[Int] {
+            extension (index: Int)
+                def namedArgs: Map[String, Any] = Map("index" -> index)
         }
 
-        type Out = Unit
+        type Out = List[String]
     }
 
     case object SkipBreakpoints extends Command("skip_breakpoints") {

frontend/src/main/scala/controller/tauri/Command.scala

@@ -28,43 +28,30 @@ object TabViewController {
 
     /** Set file names */
     val setFileNames: Observer[List[String]] = fileNames.writer
-    
-    /** Add name to file names */
-    val addFileName: Observer[String] = fileNames.updater((names, name) => names :+ name)
-    
-    /** Fetches all tree names saved by the user from the backend */
-    def loadFileNames: EventStream[Either[DillException, List[String]]] = Tauri.invoke(Command.FetchSavedTreeNames, ())
 
     /** Returns true if there are no saved trees */
     def noSavedTrees: Signal[Boolean] = getFileNames.signal.map(_.isEmpty)
 
-    
+
     /* Index of tab that is currented selected */
     private lazy val selectedTab: Var[Int] = Var(0)
 
     /** Set current selected tab index */
     val setSelectedTab: Observer[Int] = selectedTab.writer
 
-    /** Get index of tab with associated name */
-    def getFileNameIndex(name: String): Signal[Int] = getFileNames.map(_.indexOf(name))
-            
     /** Get selected tab index */
     val getSelectedTab: Signal[Int] = selectedTab.signal
 
-    /** Get name of tree associated with selected tab */
-    def getSelectedFileName: Signal[String] = getSelectedTab.flatMapSwitch(getFileName)
-
     /** Checks if tab is currently selected */
     def tabSelected(index: Int): Signal[Boolean] = getSelectedTab.map(_ == index)
 
 
     /** Saves current tree to the backend with given name, returning assigned tab index  */
-    def saveTree(name: String): EventStream[Either[DillException, Unit]] = Tauri.invoke(Command.SaveTree, name)
+    def saveTree(name: String): EventStream[Either[DillException, List[String]]] = Tauri.invoke(Command.SaveTree, name)
 
     /** Loads a saved tree from the backend as DebugTree */
-    def loadSavedTree(name: String): EventStream[Either[DillException, Unit]] = Tauri.invoke(Command.LoadSavedTree, name)
+    def loadSavedTree(index: Int): EventStream[Either[DillException, Unit]] = Tauri.invoke(Command.LoadSavedTree, index)
 
     /** Delete tree loaded within tab, returning updated list of names */
-    def deleteSavedTree(name: String): EventStream[Either[DillException, Unit]] = Tauri.invoke(Command.DeleteTree, name)
-
+    def deleteSavedTree(index: Int): EventStream[Either[DillException, List[String]]] = Tauri.invoke(Command.DeleteTree, index)
 }