Updated folder structures to use UUID v4 for parent folder structure instead on folder name
Moorly CI / windows-build (push) Successful in 2m53s
Moorly CI / linux-build (push) Successful in 3m33s

This commit is contained in:
Squid committed 2026-11-08 10:57:40 +01:00
1 parent 2ec496691c
commit db6f03c3b2
1 file changed
+187 -60
+187 -60
View File
@@ -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<String>,
/// 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<String, (String, bool)>,
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());
}
let fallback = if file.folder_name.trim().is_empty() {
DEFAULT_PROFILE_FOLDER.to_owned()
} else {
// 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);
}
insert_folder_path(folders, &fallback, Some(file.folder.clone()), true);
return (file.folder.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)
}
let path = normalize_folder_path(&file.folder);
if let Some((id, _)) = folders.get(&path) {
return (id.clone(), path);
/// 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<String, (String, bool)>, file: FoldersFile) {
let mut linked: HashMap<String, (String, Option<String>)> = 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));
}
}
}
}
let id = new_folder_id();
insert_folder_path(folders, &path, Some(id.clone()), true);
(id, path)
// 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, (String, Option<String>)>,
) -> 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 Some((name, parent_id)) = records.get(id) else {
break;
};
if !name.trim().is_empty() {
parts.push(name.trim().to_owned());
}
current = parent_id.as_deref();
}
parts.reverse();
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<ProfileFolder> {
if let Ok(text) = std::fs::read_to_string(dir.join("folders.toml"))
&& let Ok(file) = toml::from_str::<FoldersFile>(&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<ProfileFolder> {
.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<Message> {
}
}
// 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<FolderRecord> = 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<FolderRecord> = 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\""));