From db6f03c3b2606241fa62e8a3e54b96545d6093ca Mon Sep 17 00:00:00 2001 From: squid Date: Sun, 8 Nov 2026 10:57:40 +0100 Subject: [PATCH] Updated folder structures to use UUID v4 for parent folder structure instead on folder name --- src/main.rs | 257 +++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 192 insertions(+), 65 deletions(-) diff --git a/src/main.rs b/src/main.rs index c9e3790..1c0a725 100644 --- a/src/main.rs +++ b/src/main.rs @@ -903,11 +903,19 @@ impl ProfileFolder { } /// One folder record in `profiles/folders.toml`. +/// +/// Folders are linked by UUID instead of by path, so two folders can share a +/// name. Root folders have no `parent_id`. #[derive(Debug, Clone, Serialize, Deserialize)] struct FolderRecord { #[serde(default = "new_folder_id")] id: String, #[serde(default)] + name: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + parent_id: Option, + /// Full path from files written before folders were linked by UUID. + #[serde(default, skip_serializing_if = "String::is_empty")] path: String, } @@ -936,9 +944,14 @@ struct FoldersOutFile { struct ProfileFile { #[serde(default)] name: String, + /// UUID of the folder that contains this profile. #[serde(default)] + parent_id: String, + /// Legacy name-based folder reference, still read but no longer written. + #[serde(default, skip_serializing)] folder: String, - #[serde(default)] + /// Legacy folder path fallback, still read but no longer written. + #[serde(default, skip_serializing)] folder_name: String, #[serde(default)] kind: ProfileKind, @@ -1038,6 +1051,7 @@ impl ProfileFile { fn from_profile(profile: &Profile, folder: &str) -> Self { Self { name: profile.name.clone(), + parent_id: profile.folder_id.clone(), folder: profile.folder_id.clone(), folder_name: folder.to_owned(), kind: profile.kind, @@ -1067,7 +1081,11 @@ impl ProfileFile { start_path: self.start_path, private_key: self.private_key, glyph_color: color_from_hex(&self.glyph_color).unwrap_or(Color::WHITE), - folder_id: self.folder, + folder_id: if self.parent_id.trim().is_empty() { + self.folder + } else { + self.parent_id + }, file: None, } } @@ -2054,39 +2072,126 @@ fn insert_folder_path( } } -/// Resolves a profile's stored folder UUID, falling back to the saved folder -/// name when the folder is missing from `folders.toml`. +/// Resolves a profile's folder UUID, falling back to the legacy folder name +/// when the folder is missing from `folders.toml`. fn resolve_profile_folder( folders: &mut HashMap, file: &ProfileFile, ) -> (String, String) { - if uuid::Uuid::parse_str(file.folder.trim()).is_ok() { - if let Some((path, _)) = folders.iter().find(|(_, (id, _))| id == &file.folder) { - return (file.folder.clone(), path.clone()); + let reference = if file.parent_id.trim().is_empty() { + file.folder.trim() + } else { + file.parent_id.trim() + }; + + if uuid::Uuid::parse_str(reference).is_ok() + && let Some((path, _)) = folders.iter().find(|(_, (id, _))| id == reference) + { + return (reference.to_owned(), path.clone()); + } + + // Legacy files used the folder path/name instead of its UUID. + let fallback = if !file.folder_name.trim().is_empty() { + normalize_folder_path(&file.folder_name) + } else if !reference.is_empty() && uuid::Uuid::parse_str(reference).is_err() { + normalize_folder_path(reference) + } else { + DEFAULT_PROFILE_FOLDER.to_owned() + }; + + if let Some((id, _)) = folders.get(&fallback) { + return (id.clone(), fallback); + } + + let id = if uuid::Uuid::parse_str(reference).is_ok() { + reference.to_owned() + } else { + new_folder_id() + }; + insert_folder_path(folders, &fallback, Some(id.clone()), true); + (id, fallback) +} + +/// Turns the IDs and `parent_id` links in `folders.toml` back into paths. +/// Records written before the UUID format carry a full `path` and are kept. +fn load_folder_records(folders: &mut HashMap, file: FoldersFile) { + let mut linked: HashMap)> = HashMap::new(); + + for entry in file.folders { + match entry { + FolderEntry::Path(path) => { + insert_folder_path( + folders, + &normalize_folder_path(&path), + Some(new_folder_id()), + false, + ); + } + FolderEntry::Record(record) => { + let id = if record.id.trim().is_empty() { + new_folder_id() + } else { + record.id + }; + + if record.name.trim().is_empty() && !record.path.trim().is_empty() { + insert_folder_path( + folders, + &normalize_folder_path(&record.path), + Some(id), + false, + ); + } else { + let parent_id = record.parent_id.filter(|parent| !parent.trim().is_empty()); + linked.insert(id, (record.name, parent_id)); + } + } + } + } + + // Insert parents first so `insert_folder_path` never invents a new UUID + // for a parent that is already in the file. + let mut paths: Vec<(String, String)> = linked + .keys() + .map(|id| (id.clone(), folder_path_from_records(id, &linked))) + .collect(); + paths.sort_by_key(|(_, path)| path.matches('/').count()); + + for (id, path) in paths { + insert_folder_path(folders, &normalize_folder_path(&path), Some(id), false); + } +} + +fn folder_path_from_records( + id: &str, + records: &HashMap)>, +) -> String { + let mut parts = Vec::new(); + let mut current = Some(id); + let mut seen = HashSet::new(); + + while let Some(id) = current { + if !seen.insert(id) { + break; } - let fallback = if file.folder_name.trim().is_empty() { - DEFAULT_PROFILE_FOLDER.to_owned() - } else { - normalize_folder_path(&file.folder_name) + let Some((name, parent_id)) = records.get(id) else { + break; }; - if let Some((id, _)) = folders.get(&fallback) { - return (id.clone(), fallback); + if !name.trim().is_empty() { + parts.push(name.trim().to_owned()); } - - insert_folder_path(folders, &fallback, Some(file.folder.clone()), true); - return (file.folder.clone(), fallback); + current = parent_id.as_deref(); } - let path = normalize_folder_path(&file.folder); - if let Some((id, _)) = folders.get(&path) { - return (id.clone(), path); - } + parts.reverse(); - let id = new_folder_id(); - insert_folder_path(folders, &path, Some(id.clone()), true); - (id, path) + if parts.is_empty() { + DEFAULT_PROFILE_FOLDER.to_owned() + } else { + parts.join("/") + } } /// Rebuilds the folder tree and profile lists from the `profiles` directory. @@ -2098,26 +2203,7 @@ fn load_profiles_from(dir: &Path) -> Vec { if let Ok(text) = std::fs::read_to_string(dir.join("folders.toml")) && let Ok(file) = toml::from_str::(&text) { - for folder in file.folders { - let (id, path) = match folder { - FolderEntry::Path(path) => (new_folder_id(), path), - FolderEntry::Record(record) => ( - if record.id.trim().is_empty() { - new_folder_id() - } else { - record.id - }, - record.path, - ), - }; - - insert_folder_path( - &mut folder_map, - &normalize_folder_path(&path), - Some(id), - false, - ); - } + load_folder_records(&mut folder_map, file); } insert_folder_path( @@ -2155,11 +2241,20 @@ fn load_profiles_from(dir: &Path) -> Vec { .unwrap_or_default(); } - let (folder_id, _) = resolve_profile_folder(&mut folder_map, &file); + let (folder_id, folder_path) = resolve_profile_folder(&mut folder_map, &file); + let needs_migration = file.parent_id.trim() != folder_id + || !file.folder.trim().is_empty() + || !file.folder_name.trim().is_empty(); let mut profile = file.into_profile(); profile.folder_id = folder_id.clone(); profile.file = Some(path); + + // Rewrite files that still place the profile by folder name. + if needs_migration { + save_profile(&mut profile, &folder_path); + } + profiles.push((folder_id, profile)); } } @@ -2276,14 +2371,6 @@ fn rename_folder(state: &mut Moorly) -> Task { } } - // Keep the folder-name fallback inside each profile file in sync. - for (folder_index, _) in &affected { - let folder_path = state.profile_folders[*folder_index].path.clone(); - for profile in &mut state.profile_folders[*folder_index].profiles { - save_profile(profile, &folder_path); - } - } - state .profile_folders .sort_by(|a, b| folder_order(&a.path, &b.path)); @@ -2376,16 +2463,37 @@ fn save_profile(profile: &mut Profile, folder: &str) { fn write_folders_to(dir: &Path, folders: &[ProfileFolder]) -> Option<()> { std::fs::create_dir_all(dir).ok()?; - let mut records: Vec = folders + let mut sorted: Vec<&ProfileFolder> = + folders.iter().filter(|folder| !folder.untracked).collect(); + sorted.sort_by(|a, b| folder_order(&a.path, &b.path)); + sorted.dedup_by(|a, b| a.path == b.path); + + let ids: HashMap<&str, &str> = sorted + .iter() + .map(|folder| (folder.path.as_str(), folder.id.as_str())) + .collect(); + + let records: Vec = sorted .iter() - .filter(|folder| !folder.untracked) .map(|folder| FolderRecord { id: folder.id.clone(), - path: folder.path.clone(), + name: if folder.name.trim().is_empty() { + folder + .path + .rsplit('/') + .next() + .unwrap_or(DEFAULT_PROFILE_FOLDER) + .to_owned() + } else { + folder.name.clone() + }, + parent_id: folder + .path + .rsplit_once('/') + .and_then(|(parent, _)| ids.get(parent).map(|id| (*id).to_owned())), + path: String::new(), }) .collect(); - records.sort_by(|a, b| folder_order(&a.path, &b.path)); - records.dedup_by(|a, b| a.path == b.path); let text = toml::to_string_pretty(&FoldersOutFile { folders: records }).ok()?; std::fs::write(dir.join("folders.toml"), text).ok()?; @@ -9868,7 +9976,10 @@ mod tests { super::write_folders_to(&root, &folders).unwrap(); let folders_text = std::fs::read_to_string(root.join("folders.toml")).unwrap(); - assert!(folders_text.contains("\"Work/Production\"")); + assert!(folders_text.contains("name = \"Work\"")); + assert!(folders_text.contains("name = \"Production\"")); + assert!(folders_text.contains(&format!("parent_id = \"{}\"", work.id))); + assert!(!folders_text.contains("path =")); assert!(!folders_text.contains("Missing")); std::fs::remove_dir_all(&root).unwrap(); @@ -9883,21 +9994,36 @@ mod tests { let root = std::env::temp_dir().join(format!("moorly-profile-uuid-test-{stamp}")); std::fs::create_dir_all(&root).unwrap(); let id = super::new_folder_id(); + let child = super::new_folder_id(); std::fs::write( root.join("folders.toml"), - format!("[[folders]]\nid = \"{id}\"\npath = \"Work\"\n"), + format!( + "[[folders]]\nid = \"{id}\"\nname = \"Work\"\n\n\ + [[folders]]\nid = \"{child}\"\nname = \"Production\"\nparent_id = \"{id}\"\n" + ), ) .unwrap(); std::fs::write( root.join("Server.toml"), - format!("name = \"Server\"\nfolder = \"{id}\"\nfolder_name = \"Work\"\n"), + format!("name = \"Server\"\nparent_id = \"{child}\"\n"), ) .unwrap(); let folders = super::load_profiles_from(&root); - let work = folders.iter().find(|folder| folder.path == "Work").unwrap(); - assert_eq!(work.id, id); - assert_eq!(work.profiles[0].folder_id, id); + let production = folders + .iter() + .find(|folder| folder.path == "Work/Production") + .unwrap(); + assert_eq!(production.id, child); + assert_eq!(production.profiles[0].folder_id, child); + assert_eq!( + folders + .iter() + .find(|folder| folder.path == "Work") + .unwrap() + .id, + id + ); std::fs::remove_dir_all(&root).unwrap(); } @@ -9929,8 +10055,9 @@ mod tests { assert_eq!(path.file_name().unwrap(), "Server_Test.toml"); let text = std::fs::read_to_string(&path).unwrap(); - assert!(text.contains("folder = \"folder-id\"")); - assert!(text.contains("folder_name = \"Work/Production\"")); + assert!(text.contains("parent_id = \"folder-id\"")); + assert!(!text.contains("folder =")); + assert!(!text.contains("folder_name =")); assert!(text.contains("kind = \"ssh\"")); assert!(text.contains("session_end = \"reconnect\"")); assert!(text.contains("host = \"example.com\""));