diff --git a/src/main.rs b/src/main.rs index ed4dc1f..c9e3790 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,5 +1,5 @@ use std::cmp::Ordering; -use std::collections::{BTreeSet, HashMap, HashSet}; +use std::collections::{HashMap, HashSet}; use std::path::{Path, PathBuf}; use serde::{Deserialize, Serialize}; @@ -64,6 +64,8 @@ const FOLDER_NAME_INPUT: Id = Id::new("folder-name"); const PROFILE_NAME_INPUT: Id = Id::new("profile-name"); /// Folder shown for profiles that have not been put into a group. const DEFAULT_PROFILE_FOLDER: &str = "Ungrouped"; +/// Sentinel destination used to move folders outside any parent folder. +const ROOT_FOLDER_INDEX: usize = usize::MAX; fn main() -> iced::Result { iced::daemon(boot, update, view) @@ -637,6 +639,8 @@ struct Profile { start_path: String, private_key: String, glyph_color: Color, + /// UUID of the folder this profile belongs to. + folder_id: String, /// File this profile was loaded from or saved to. file: Option, } @@ -850,6 +854,8 @@ fn resolve_start_path(input: &str) -> PathBuf { /// paths such as `Work/Production`, which keeps selection index-based. #[derive(Debug, Clone)] struct ProfileFolder { + /// Stable identity that profile files reference. + id: String, /// Slash-separated path from the root, e.g. `Work/Production`. path: String, name: String, @@ -860,6 +866,10 @@ struct ProfileFolder { untracked: bool, } +fn new_folder_id() -> String { + uuid::Uuid::new_v4().to_string() +} + impl ProfileFolder { fn default_folder() -> Self { Self::from_path(DEFAULT_PROFILE_FOLDER.to_owned()) @@ -874,6 +884,7 @@ impl ProfileFolder { .to_owned(); Self { + id: new_folder_id(), path, name, profiles: Vec::new(), @@ -891,11 +902,33 @@ impl ProfileFolder { } } +/// One folder record in `profiles/folders.toml`. +#[derive(Debug, Clone, Serialize, Deserialize)] +struct FolderRecord { + #[serde(default = "new_folder_id")] + id: String, + #[serde(default)] + path: String, +} + +/// Accepts both the old `folders = ["Work"]` format and the UUID records. +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +enum FolderEntry { + Path(String), + Record(FolderRecord), +} + /// Contents of `profiles/folders.toml`. #[derive(Debug, Serialize, Deserialize)] struct FoldersFile { #[serde(default)] - folders: Vec, + folders: Vec, +} + +#[derive(Debug, Serialize)] +struct FoldersOutFile { + folders: Vec, } /// One `profiles/.toml` file. @@ -906,6 +939,8 @@ struct ProfileFile { #[serde(default)] folder: String, #[serde(default)] + folder_name: String, + #[serde(default)] kind: ProfileKind, #[serde(default)] session_end: SessionEnd, @@ -1003,7 +1038,8 @@ impl ProfileFile { fn from_profile(profile: &Profile, folder: &str) -> Self { Self { name: profile.name.clone(), - folder: folder.to_owned(), + folder: profile.folder_id.clone(), + folder_name: folder.to_owned(), kind: profile.kind, session_end: profile.session_end, host: profile.host.clone(), @@ -1031,6 +1067,7 @@ 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, file: None, } } @@ -1327,6 +1364,8 @@ struct Moorly { hovered_folder: Option, add_menu_open: bool, folder_dialog: Option, + folder_rename: Option<(usize, String)>, + folder_menu: Option<(usize, Point)>, profile_dialog: Option, dir_picker: Option, next_blank_tab: u32, @@ -1929,47 +1968,165 @@ fn normalize_folder_path(value: &str) -> String { /// Keep the default folder first, then sort the tree by path so parents come /// before their children. fn folder_order(a: &str, b: &str) -> Ordering { - let rank = |path: &str| usize::from(path != DEFAULT_PROFILE_FOLDER); + let rank = |path: &str| { + if path == DEFAULT_PROFILE_FOLDER { + 0 + } else if path.starts_with("Ungrouped/") { + 1 + } else { + 2 + } + }; rank(a).cmp(&rank(b)).then_with(|| a.cmp(b)) } -fn add_folder_and_parents(paths: &mut BTreeSet, path: &str) { - if path.is_empty() { - return; - } - +/// A folder is hidden when any ancestor folder is collapsed. +fn folder_visible(folders: &[ProfileFolder], index: usize) -> bool { + let Some(folder) = folders.get(index) else { + return false; + }; + let parts: Vec<&str> = folder + .path + .split('/') + .filter(|part| !part.is_empty()) + .collect(); let mut prefix = String::new(); - for part in path.split('/') { + + for part in parts.iter().take(parts.len().saturating_sub(1)) { if !prefix.is_empty() { prefix.push('/'); } prefix.push_str(part); - paths.insert(prefix.clone()); + + if let Some(ancestor) = folders.iter().find(|folder| folder.path == prefix) + && !ancestor.expanded + { + return false; + } } + + true } fn load_profiles() -> Vec { - profiles_dir() + let folders = profiles_dir() .map(|dir| load_profiles_from(&dir)) - .unwrap_or_else(|| vec![ProfileFolder::default_folder()]) + .unwrap_or_else(|| vec![ProfileFolder::default_folder()]); + + // Persist UUIDs generated for folders from the old path-only format. + save_folders(&folders); + folders +} + +/// Adds a path and any missing parents to the folder map. `id` is only used +/// for the full path; generated parents get fresh UUIDs. +fn insert_folder_path( + folders: &mut HashMap, + path: &str, + id: Option, + untracked: bool, +) { + let parts: Vec<&str> = path.split('/').filter(|part| !part.is_empty()).collect(); + let mut prefix = String::new(); + + for (index, part) in parts.iter().enumerate() { + if !prefix.is_empty() { + prefix.push('/'); + } + prefix.push_str(part); + + match folders.get_mut(&prefix) { + Some((_, existing_untracked)) => { + if !untracked { + *existing_untracked = false; + } + } + None => { + let folder_id = if index + 1 == parts.len() { + id.clone().unwrap_or_else(new_folder_id) + } else { + new_folder_id() + }; + + folders.insert(prefix.clone(), (folder_id, untracked)); + } + } + } +} + +/// Resolves a profile's stored folder UUID, falling back to the saved 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 fallback = if file.folder_name.trim().is_empty() { + DEFAULT_PROFILE_FOLDER.to_owned() + } else { + normalize_folder_path(&file.folder_name) + }; + + 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 path = normalize_folder_path(&file.folder); + if let Some((id, _)) = folders.get(&path) { + return (id.clone(), path); + } + + let id = new_folder_id(); + insert_folder_path(folders, &path, Some(id.clone()), true); + (id, path) } /// Rebuilds the folder tree and profile lists from the `profiles` directory. /// Folders referenced by a profile but missing from `folders.toml` are added /// as runtime-only folders. fn load_profiles_from(dir: &Path) -> Vec { - let mut tracked = BTreeSet::new(); - tracked.insert(DEFAULT_PROFILE_FOLDER.to_owned()); - let mut untracked = BTreeSet::new(); + let mut folder_map: HashMap = HashMap::new(); 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 { - add_folder_and_parents(&mut tracked, &normalize_folder_path(&folder)); + 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, + ); } } + insert_folder_path( + &mut folder_map, + DEFAULT_PROFILE_FOLDER, + Some(new_folder_id()), + false, + ); + let mut profiles = Vec::new(); if let Ok(entries) = std::fs::read_dir(dir) { @@ -1998,30 +2155,28 @@ fn load_profiles_from(dir: &Path) -> Vec { .unwrap_or_default(); } - let folder = normalize_folder_path(&file.folder); - add_missing_folder_and_parents(&tracked, &mut untracked, &folder); + let (folder_id, _) = resolve_profile_folder(&mut folder_map, &file); + let mut profile = file.into_profile(); + profile.folder_id = folder_id.clone(); profile.file = Some(path); - profiles.push((folder, profile)); + profiles.push((folder_id, profile)); } } - let mut folder_paths: Vec = tracked.into_iter().collect(); - folder_paths.extend(untracked.iter().cloned()); - folder_paths.sort_by(|a, b| folder_order(a, b)); - folder_paths.dedup(); - - let mut folders: Vec = folder_paths + let mut folders: Vec = folder_map .into_iter() - .map(|path| { + .map(|(path, (id, untracked))| { let mut folder = ProfileFolder::from_path(path); - folder.untracked = untracked.contains(&folder.path); + folder.id = id; + folder.untracked = untracked; folder }) .collect(); + folders.sort_by(|a, b| folder_order(&a.path, &b.path)); - for (folder_path, profile) in profiles { - if let Some(folder) = folders.iter_mut().find(|folder| folder.path == folder_path) { + for (folder_id, profile) in profiles { + if let Some(folder) = folders.iter_mut().find(|folder| folder.id == folder_id) { folder.profiles.push(profile); } } @@ -2029,27 +2184,6 @@ fn load_profiles_from(dir: &Path) -> Vec { folders } -/// Adds a profile's folder and any missing parents as runtime-only folders, -/// unless the path is already part of `folders.toml`. -fn add_missing_folder_and_parents( - tracked: &BTreeSet, - untracked: &mut BTreeSet, - path: &str, -) { - let mut prefix = String::new(); - - for part in path.split('/') { - if !prefix.is_empty() { - prefix.push('/'); - } - prefix.push_str(part); - - if !tracked.contains(&prefix) { - untracked.insert(prefix.clone()); - } - } -} - /// Adds a folder and any missing parents, then returns the folder's index. fn ensure_folder(folders: &mut Vec, path: &str) -> usize { add_folder_to_list(folders, path); @@ -2077,6 +2211,88 @@ fn add_folder_to_list(folders: &mut Vec, path: &str) { } } +fn rename_folder(state: &mut Moorly) -> Task { + let Some((index, draft)) = state.folder_rename.clone() else { + return Task::none(); + }; + let new_name = draft.trim().to_owned(); + let Some(folder) = state.profile_folders.get(index) else { + state.folder_rename = None; + return Task::none(); + }; + let old_path = folder.path.clone(); + + if new_name.is_empty() || new_name.contains('/') || old_path == DEFAULT_PROFILE_FOLDER { + return Task::none(); + } + + let parent = old_path + .rsplit_once('/') + .map(|(parent, _)| parent) + .unwrap_or(""); + let new_path = if parent.is_empty() { + new_name.clone() + } else { + format!("{parent}/{new_name}") + }; + + if new_path == old_path { + state.folder_rename = None; + return Task::none(); + } + + let affected: Vec<(usize, String)> = state + .profile_folders + .iter() + .enumerate() + .filter(|(_, folder)| is_folder_under(&folder.path, &old_path)) + .map(|(index, folder)| { + let suffix = folder.path.strip_prefix(&old_path).unwrap_or(""); + (index, format!("{new_path}{suffix}")) + }) + .collect(); + + // Do not let a rename collide with a folder outside the renamed subtree. + for (affected_index, path) in &affected { + let collides = state + .profile_folders + .iter() + .enumerate() + .any(|(index, folder)| { + index != *affected_index + && !affected.iter().any(|(affected, _)| *affected == index) + && folder.path == *path + }); + + if collides { + return Task::none(); + } + } + + for (folder_index, path) in &affected { + state.profile_folders[*folder_index].path = path.clone(); + if *folder_index == index { + state.profile_folders[*folder_index].name = new_name.clone(); + } + } + + // 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)); + + save_folders(&state.profile_folders); + state.folder_rename = None; + Task::none() +} + fn profile_file_stem(name: &str) -> String { let stem: String = name .trim() @@ -2160,15 +2376,18 @@ 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 paths: Vec = folders + let mut records: Vec = folders .iter() .filter(|folder| !folder.untracked) - .map(|folder| folder.path.clone()) + .map(|folder| FolderRecord { + id: folder.id.clone(), + path: folder.path.clone(), + }) .collect(); - paths.sort_by(|a, b| folder_order(a, b)); - paths.dedup(); + 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(&FoldersFile { folders: paths }).ok()?; + let text = toml::to_string_pretty(&FoldersOutFile { folders: records }).ok()?; std::fs::write(dir.join("folders.toml"), text).ok()?; Some(()) } @@ -2374,6 +2593,39 @@ fn checked_folder_roots(state: &Moorly) -> Vec { filtered } +fn default_transfer_destination(state: &Moorly) -> usize { + let roots = checked_folder_roots(state); + let individual = checked_profile_indices(state, &roots); + let root_available = + !roots.is_empty() && individual.is_empty() && roots.iter().any(|root| root.contains('/')); + let is_valid = |index: usize| { + state + .profile_folders + .get(index) + .is_some_and(|folder| !roots.iter().any(|root| is_folder_under(&folder.path, root))) + }; + let preferred = state.selected.and_then(|selection| match selection { + Selection::Folder(index) => Some(index), + Selection::Profile { folder, .. } => Some(folder), + }); + + if preferred.is_some_and(is_valid) { + return preferred.unwrap(); + } + + if root_available { + return ROOT_FOLDER_INDEX; + } + + state + .profile_folders + .iter() + .enumerate() + .find(|(index, _)| is_valid(*index)) + .map(|(index, _)| index) + .unwrap_or(0) +} + /// Checked profiles that are not already covered by a checked folder. fn checked_profile_indices(state: &Moorly, roots: &[String]) -> Vec<(usize, usize)> { let mut items = Vec::new(); @@ -2414,13 +2666,19 @@ fn remove_folders(state: &mut Moorly, roots: &[String]) { } fn apply_transfer(state: &mut Moorly, mode: TransferMode, destination: usize) { - let Some(destination_path) = state - .profile_folders - .get(destination) - .map(|folder| folder.path.clone()) - else { - state.transfer = None; - return; + let (destination_path, destination_id) = if destination == ROOT_FOLDER_INDEX { + (String::new(), None) + } else { + let Some((path, id)) = state + .profile_folders + .get(destination) + .map(|folder| (folder.path.clone(), folder.id.clone())) + else { + state.transfer = None; + return; + }; + + (path, Some(id)) }; let roots = checked_folder_roots(state); @@ -2435,7 +2693,15 @@ fn apply_transfer(state: &mut Moorly, mode: TransferMode, destination: usize) { } let leaf = root.rsplit('/').next().unwrap_or(root); - let new_root = format!("{destination_path}/{leaf}"); + let new_root = if destination_path.is_empty() { + leaf.to_owned() + } else { + format!("{destination_path}/{leaf}") + }; + + if new_root == *root { + continue; + } for folder in snapshot .iter() @@ -2444,9 +2710,16 @@ fn apply_transfer(state: &mut Moorly, mode: TransferMode, destination: usize) { let suffix = folder.path.strip_prefix(root).unwrap_or(""); let new_path = format!("{new_root}{suffix}"); add_folder_to_list(&mut state.profile_folders, &new_path); + let new_folder_id = state + .profile_folders + .iter() + .find(|folder| folder.path == new_path) + .map(|folder| folder.id.clone()) + .unwrap_or_default(); for source in &folder.profiles { let mut profile = source.clone(); + profile.folder_id = new_folder_id.clone(); match mode { TransferMode::Copy => { @@ -2462,6 +2735,20 @@ fn apply_transfer(state: &mut Moorly, mode: TransferMode, destination: usize) { moved_roots.push(root.clone()); } + let individual_path = if destination_path.is_empty() { + DEFAULT_PROFILE_FOLDER.to_owned() + } else { + destination_path.clone() + }; + let individual_id = destination_id.clone().unwrap_or_else(|| { + state + .profile_folders + .iter() + .find(|folder| folder.path == DEFAULT_PROFILE_FOLDER) + .map(|folder| folder.id.clone()) + .unwrap_or_default() + }); + for (folder_index, profile_index) in &individual { let Some(source) = snapshot .get(*folder_index) @@ -2470,15 +2757,16 @@ fn apply_transfer(state: &mut Moorly, mode: TransferMode, destination: usize) { continue; }; let mut profile = source.clone(); + profile.folder_id = individual_id.clone(); match mode { TransferMode::Copy => { - profile.file = write_profile(&profile, &destination_path); + profile.file = write_profile(&profile, &individual_path); } - TransferMode::Move => save_profile(&mut profile, &destination_path), + TransferMode::Move => save_profile(&mut profile, &individual_path), } - placements.push((destination_path.clone(), profile)); + placements.push((individual_path.clone(), profile)); } if mode == TransferMode::Move { @@ -2612,6 +2900,11 @@ fn apply_delete(state: &mut Moorly) { } let mut profile = profile.clone(); + profile.folder_id = kept_folders + .iter() + .find(|folder| folder.path == path) + .map(|folder| folder.id.clone()) + .unwrap_or_default(); if path != folder.path { save_profile(&mut profile, &path); } @@ -2692,6 +2985,12 @@ fn restore_trash_items(state: &mut Moorly) { } let mut restored_profile = profile.clone().into_profile(); + restored_profile.folder_id = state + .profile_folders + .iter() + .find(|folder| folder.path == folder_path) + .map(|folder| folder.id.clone()) + .unwrap_or_default(); let new_file = write_profile(&restored_profile, &folder_path); // Keep the trash entry if the profile could not be written back. @@ -3175,6 +3474,8 @@ impl Default for Moorly { hovered_folder: None, add_menu_open: false, folder_dialog: None, + folder_rename: None, + folder_menu: None, profile_dialog: None, dir_picker: None, next_blank_tab: 1, @@ -3295,6 +3596,15 @@ enum Message { FolderNameChanged(String), ConfirmFolder, CancelFolder, + OpenFolderMenu(window::Id, usize), + CloseFolderMenu, + FolderMenuCopy(usize), + FolderMenuMove(usize), + FolderMenuDelete(usize), + FolderMenuRename(usize), + FolderRenameChanged(String), + ConfirmFolderRename, + CancelFolderRename, Ignore, OpenShortcutCapture(ShortcutAction), CancelShortcut, @@ -3752,6 +4062,7 @@ fn update(state: &mut Moorly, message: Message) -> Task { window_state.active_tab = Some(tab); window_state.menu_open = false; window_state.tabs_submenu_open = false; + state.folder_menu = None; // New tabs land at the end, so bring that end into view. if is_new { @@ -3771,6 +4082,8 @@ fn update(state: &mut Moorly, message: Message) -> Task { ]); } Message::SelectSettingsSection(section) => { + state.folder_menu = None; + if section == state.settings_section && state.pending_settings_section.is_none() { // Already showing this section. } else if !state.fade_settings { @@ -3960,31 +4273,17 @@ fn update(state: &mut Moorly, message: Message) -> Task { } Message::CopyChecked => { if !state.checked.is_empty() { - let destination = state - .selected - .and_then(|selection| match selection { - Selection::Folder(index) => Some(index), - Selection::Profile { folder, .. } => Some(folder), - }) - .unwrap_or(0); state.transfer = Some(TransferDialog { mode: TransferMode::Copy, - destination, + destination: default_transfer_destination(state), }); } } Message::MoveChecked => { if !state.checked.is_empty() { - let destination = state - .selected - .and_then(|selection| match selection { - Selection::Folder(index) => Some(index), - Selection::Profile { folder, .. } => Some(folder), - }) - .unwrap_or(0); state.transfer = Some(TransferDialog { mode: TransferMode::Move, - destination, + destination: default_transfer_destination(state), }); } } @@ -4176,10 +4475,10 @@ fn update(state: &mut Moorly, message: Message) -> Task { let folder_index = draft .folder .min(state.profile_folders.len().saturating_sub(1)); - let Some(folder_path) = state + let Some((folder_path, folder_id)) = state .profile_folders .get(folder_index) - .map(|folder| folder.path.clone()) + .map(|folder| (folder.path.clone(), folder.id.clone())) else { return Task::none(); }; @@ -4203,6 +4502,7 @@ fn update(state: &mut Moorly, message: Message) -> Task { start_path: draft.start_path.clone(), private_key: draft.private_key.clone(), glyph_color: draft.glyph_color, + folder_id, file: existing_file, }; @@ -4262,6 +4562,57 @@ fn update(state: &mut Moorly, message: Message) -> Task { save_folders(&state.profile_folders); } Message::CancelFolder => state.folder_dialog = None, + Message::OpenFolderMenu(window, index) => { + if state + .profile_folders + .get(index) + .is_some_and(|folder| folder.path != DEFAULT_PROFILE_FOLDER) + { + let pointer = state + .windows + .get(&window) + .and_then(|window_state| window_state.pointer) + .unwrap_or(Point::new(0.0, 0.0)); + state.folder_menu = Some((index, pointer)); + state.selected = Some(Selection::Folder(index)); + } + } + Message::CloseFolderMenu => state.folder_menu = None, + Message::FolderMenuCopy(index) => { + state.folder_menu = None; + state.checked.clear(); + state.checked.insert(Selection::Folder(index)); + return update(state, Message::CopyChecked); + } + Message::FolderMenuMove(index) => { + state.folder_menu = None; + state.checked.clear(); + state.checked.insert(Selection::Folder(index)); + return update(state, Message::MoveChecked); + } + Message::FolderMenuDelete(index) => { + state.folder_menu = None; + state.checked.clear(); + state.checked.insert(Selection::Folder(index)); + return update(state, Message::DeleteChecked); + } + Message::FolderMenuRename(index) => { + state.folder_menu = None; + + let Some(folder) = state.profile_folders.get(index) else { + return Task::none(); + }; + + state.folder_rename = Some((index, folder.name.clone())); + return operation::focus(FOLDER_NAME_INPUT); + } + Message::FolderRenameChanged(value) => { + if let Some((_, draft)) = state.folder_rename.as_mut() { + *draft = value.chars().take(150).collect(); + } + } + Message::ConfirmFolderRename => return rename_folder(state), + Message::CancelFolderRename => state.folder_rename = None, Message::Ignore => {} Message::OpenShortcutCapture(action) => { state.shortcut_capture = Some(ShortcutCapture { @@ -5652,7 +6003,7 @@ fn profile_action_button<'a>( .into() } -fn profiles_panel(state: &Moorly, show_add: bool) -> Element<'_, Message> { +fn profiles_panel(state: &Moorly, window: window::Id, show_add: bool) -> Element<'_, Message> { let field = text_input("Filter", &state.profile_filter) .on_input(Message::ProfileFilterChanged) .padding(Padding { @@ -5732,16 +6083,23 @@ fn profiles_panel(state: &Moorly, show_add: bool) -> Element<'_, Message> { .width(Length::Fill); let mut list = column![].width(Length::Fill); + let mut first_visible = true; for (index, folder) in state.profile_folders.iter().enumerate() { - if index > 0 { + if !folder_visible(&state.profile_folders, index) { + continue; + } + + if !first_visible { list = list.push(rule::horizontal(1)); } + first_visible = false; list = list.push(profile_folder_row( index, folder, state.selected, &state.checked, state.hovered_folder, + window, show_add, )); } @@ -5760,6 +6118,7 @@ fn profiles_panel(state: &Moorly, show_add: bool) -> Element<'_, Message> { let base = base.push(list); let dialog_open = state.folder_dialog.is_some() + || state.folder_rename.is_some() || state.profile_dialog.is_some() || state.transfer.is_some() || state.trash_open @@ -5789,6 +6148,8 @@ fn profiles_panel(state: &Moorly, show_add: bool) -> Element<'_, Message> { Message::CloseTrash } else if state.folder_dialog.is_some() { Message::CancelFolder + } else if state.folder_rename.is_some() { + Message::CancelFolderRename } else if state.transfer.is_some() { Message::CancelTransfer } else if state.confirm_delete { @@ -5885,6 +6246,48 @@ fn profiles_panel(state: &Moorly, show_add: bool) -> Element<'_, Message> { layers = layers.push(dialog_layer); } + if let Some((_, draft)) = &state.folder_rename { + let dialog = container( + column![ + text("Rename folder").size(14), + text_input("Folder name", draft) + .id(FOLDER_NAME_INPUT) + .on_input(Message::FolderRenameChanged) + .on_submit(Message::ConfirmFolderRename) + .padding(6) + .style(theme::filter_field) + .width(Length::Fill), + row![ + space::horizontal(), + button("Cancel") + .on_press(Message::CancelFolderRename) + .style(theme::danger_option), + button("Rename") + .on_press_maybe( + (!draft.trim().is_empty()).then_some(Message::ConfirmFolderRename) + ) + .style(theme::positive_option), + ] + .spacing(8), + ] + .spacing(10) + .width(Length::Fill), + ) + .width(280) + .padding(12) + .style(theme::menu); + + let dialog = mouse_area(dialog).on_press(Message::Ignore); + + let dialog_layer = container(dialog) + .width(Length::Fill) + .height(Length::Fill) + .align_x(Alignment::Center) + .align_y(Alignment::Center); + + layers = layers.push(dialog_layer); + } + if state.trash_open { let dialog = trash_dialog_view(state); let dialog = mouse_area(dialog).on_press(Message::Ignore); @@ -5937,7 +6340,7 @@ fn profiles_panel(state: &Moorly, show_add: bool) -> Element<'_, Message> { } if let Some(transfer) = &state.transfer { - let dialog = transfer_dialog_view(transfer, &state.profile_folders); + let dialog = transfer_dialog_view(transfer, state); let dialog = mouse_area(dialog).on_press(Message::Ignore); let dialog_layer = container(dialog) @@ -6192,19 +6595,39 @@ fn trash_dialog_view(state: &Moorly) -> Element<'_, Message> { } /// Folder picker used by the "Copy to" and "Move to" actions. -fn transfer_dialog_view<'a>( - transfer: &TransferDialog, - folders: &'a [ProfileFolder], -) -> Element<'a, Message> { - let choices: Vec = folders +fn transfer_choices(state: &Moorly) -> Vec { + let roots = checked_folder_roots(state); + let individual = checked_profile_indices(state, &roots); + let mut choices: Vec = state + .profile_folders .iter() .enumerate() + .filter(|(_, folder)| !roots.iter().any(|root| is_folder_under(&folder.path, root))) .map(|(index, folder)| FolderChoice { index, name: folder.path.clone(), }) .collect(); - let selected = choices.get(transfer.destination).cloned(); + + if !roots.is_empty() && individual.is_empty() && roots.iter().any(|root| root.contains('/')) { + choices.insert( + 0, + FolderChoice { + index: ROOT_FOLDER_INDEX, + name: "Root".to_owned(), + }, + ); + } + + choices +} + +fn transfer_dialog_view<'a>(transfer: &TransferDialog, state: &'a Moorly) -> Element<'a, Message> { + let choices = transfer_choices(state); + let selected = choices + .iter() + .find(|choice| choice.index == transfer.destination) + .cloned(); container( column![ @@ -6575,6 +6998,7 @@ fn profile_folder_row<'a>( selected: Option, checked: &'a HashSet, hovered: Option, + window: window::Id, show_checks: bool, ) -> Element<'a, Message> { let is_selected = selected == Some(Selection::Folder(index)); @@ -6641,10 +7065,14 @@ fn profile_folder_row<'a>( style }); - let heading = mouse_area(heading) + let mut heading = mouse_area(heading) .on_enter(Message::HoverFolder(Some(index))) .on_exit(Message::HoverFolder(None)); + if show_checks { + heading = heading.on_right_press(Message::OpenFolderMenu(window, index)); + } + let folder_checked = checked.contains(&Selection::Folder(index)); let heading: Element<'_, Message> = if show_checks { @@ -6768,7 +7196,7 @@ fn start_page(state: &Moorly, window: window::Id) -> Element<'_, Message> { container( container( column![ - container(profiles_panel(state, false)) + container(profiles_panel(state, window, false)) .width(Length::Fill) .height(list_height), settings, @@ -6828,7 +7256,47 @@ fn appearance_panel(state: &Moorly) -> Element<'_, Message> { .into() } -fn settings_page(state: &Moorly) -> Element<'_, Message> { +fn folder_context_menu(state: &Moorly, window: window::Id) -> Option> { + if state.settings_section != SettingsSection::Profiles { + return None; + } + + let (index, pointer) = state.folder_menu?; + let window_state = state.windows.get(&window)?; + let width = 160.0; + let height = MENU_PADDING * 2.0 + 4.0 * MENU_ITEM_HEIGHT + 3.0 * 4.0; + let max_x = (window_state.size.width - width - 8.0).max(8.0); + let max_y = (window_state.size.height - height - 8.0).max(8.0); + + let menu = container( + column![ + menu_item("Copy to", None, Message::FolderMenuCopy(index)), + menu_item("Move to", None, Message::FolderMenuMove(index)), + menu_item("Delete", None, Message::FolderMenuDelete(index)), + menu_item("Rename", None, Message::FolderMenuRename(index)), + ] + .spacing(4), + ) + .width(width) + .padding(MENU_PADDING) + .style(theme::menu); + + Some( + container(menu) + .width(Length::Fill) + .height(Length::Fill) + .align_x(Alignment::Start) + .align_y(Alignment::Start) + .padding(Padding { + top: (pointer.y - MENUBAR_HEIGHT).clamp(8.0, max_y), + left: pointer.x.clamp(8.0, max_x), + ..Padding::ZERO + }) + .into(), + ) +} + +fn settings_page(state: &Moorly, window: window::Id) -> Element<'_, Message> { let accent = state.colors[ColorOption::Accent.index()]; let text_color = state.colors[ColorOption::Text.index()]; let main_background = state.colors[ColorOption::MainBackground.index()]; @@ -6877,7 +7345,7 @@ fn settings_page(state: &Moorly) -> Element<'_, Message> { content = content.push(shortcuts_panel(state)); } if state.settings_section == SettingsSection::Profiles { - content = content.push(profiles_panel(state, true)); + content = content.push(profiles_panel(state, window, true)); } let body: Element<'_, Message> = if scrolls { @@ -6971,6 +7439,22 @@ fn settings_page(state: &Moorly) -> Element<'_, Message> { frame.into() }; + let page: Element<'_, Message> = if let Some(menu) = folder_context_menu(state, window) { + let backdrop = mouse_area( + container(space::horizontal()) + .width(Length::Fill) + .height(Length::Fill), + ) + .on_press(Message::CloseFolderMenu); + + stack![page, backdrop, menu] + .width(Length::Fill) + .height(Length::Fill) + .into() + } else { + page + }; + if let Some(draft) = &state.theme_name_dialog { let dialog = container( column![ @@ -7211,7 +7695,7 @@ fn main_view(state: &Moorly, window: window::Id) -> Element<'_, Message> { let main_area: Element<'_, Message> = match active_tab { Some(Tab::Start) => start_page(state, window), - Some(Tab::Settings) => settings_page(state), + Some(Tab::Settings) => settings_page(state, window), _ => container(column![]) .width(Length::Fill) .height(Length::Fill) @@ -7577,6 +8061,8 @@ mod tests { hovered_folder: None, add_menu_open: false, folder_dialog: None, + folder_rename: None, + folder_menu: None, profile_dialog: None, dir_picker: None, next_blank_tab: 1, @@ -7597,6 +8083,7 @@ mod tests { start_path: String::new(), private_key: String::new(), glyph_color: iced::Color::WHITE, + folder_id: String::new(), file: None, } } @@ -9100,6 +9587,174 @@ mod tests { assert_eq!(moved.profiles[0].name, "Server"); } + #[test] + fn collapsing_a_folder_hides_its_descendants() { + let mut folders = vec![ + super::ProfileFolder::default_folder(), + super::ProfileFolder::from_path("Ungrouped/Work".to_owned()), + super::ProfileFolder::from_path("Ungrouped/Work/Sub".to_owned()), + super::ProfileFolder::from_path("Home".to_owned()), + ]; + folders[0].expanded = false; + + assert!(!super::folder_visible(&folders, 1)); + assert!(!super::folder_visible(&folders, 2)); + assert!(super::folder_visible(&folders, 3)); + } + + #[test] + fn moving_a_folder_under_ungrouped_nests_it() { + let mut state = state(); + state.profile_folders = vec![ + super::ProfileFolder::default_folder(), + super::ProfileFolder::from_path("Work".to_owned()), + super::ProfileFolder::from_path("Home".to_owned()), + ]; + state.profile_folders[1].profiles.push(profile("Server")); + state.checked.insert(super::Selection::Folder(1)); + + let _ = update(&mut state, Message::MoveChecked); + let _ = update( + &mut state, + Message::TransferFolderSelected(super::FolderChoice { + index: 0, + name: "Ungrouped".to_owned(), + }), + ); + let _ = update(&mut state, Message::ConfirmTransfer); + + let moved = state + .profile_folders + .iter() + .find(|folder| folder.path == "Ungrouped/Work") + .unwrap(); + assert_eq!(moved.depth(), 1); + assert_eq!(moved.profiles[0].name, "Server"); + assert!( + state + .profile_folders + .iter() + .all(|folder| folder.path != "Work") + ); + + let ungrouped = state + .profile_folders + .iter() + .position(|folder| folder.path == "Ungrouped") + .unwrap(); + assert_eq!( + state + .profile_folders + .iter() + .position(|folder| folder.path == "Ungrouped/Work"), + Some(ungrouped + 1) + ); + } + + #[test] + fn folder_transfer_excludes_the_source_and_offers_root() { + let mut state = state(); + state.profile_folders = vec![ + super::ProfileFolder::default_folder(), + super::ProfileFolder::from_path("Home".to_owned()), + super::ProfileFolder::from_path("Home/Work".to_owned()), + super::ProfileFolder::from_path("Home/Work/Sub".to_owned()), + super::ProfileFolder::from_path("Other".to_owned()), + ]; + state.checked.insert(super::Selection::Folder(2)); + + let choices = super::transfer_choices(&state); + + assert!( + !choices + .iter() + .any(|choice| choice.name == "Home/Work" || choice.name == "Home/Work/Sub") + ); + assert!(choices.iter().any(|choice| choice.name == "Other")); + assert!( + choices + .iter() + .any(|choice| choice.index == super::ROOT_FOLDER_INDEX && choice.name == "Root") + ); + } + + #[test] + fn moving_a_folder_to_root_makes_it_top_level() { + let mut state = state(); + state.profile_folders = vec![ + super::ProfileFolder::default_folder(), + super::ProfileFolder::from_path("Home".to_owned()), + super::ProfileFolder::from_path("Home/Work".to_owned()), + super::ProfileFolder::from_path("Home/Work/Sub".to_owned()), + ]; + state.profile_folders[2].profiles.push(profile("Server")); + state.checked.insert(super::Selection::Folder(2)); + + let _ = update(&mut state, Message::MoveChecked); + let _ = update(&mut state, Message::ConfirmTransfer); + + assert!( + state + .profile_folders + .iter() + .all(|folder| folder.path != "Home/Work") + ); + let moved = state + .profile_folders + .iter() + .find(|folder| folder.path == "Work") + .unwrap(); + assert_eq!(moved.profiles[0].name, "Server"); + assert!( + state + .profile_folders + .iter() + .any(|folder| folder.path == "Work/Sub") + ); + } + + #[test] + fn renaming_a_folder_updates_its_subtree_but_keeps_ids() { + let mut state = state(); + state.profile_folders = vec![ + super::ProfileFolder::default_folder(), + super::ProfileFolder::from_path("Work".to_owned()), + super::ProfileFolder::from_path("Work/Sub".to_owned()), + ]; + let work_id = state.profile_folders[1].id.clone(); + let sub_id = state.profile_folders[2].id.clone(); + let mut server = profile("Server"); + server.folder_id = work_id.clone(); + state.profile_folders[1].profiles.push(server); + let mut nested = profile("Nested"); + nested.folder_id = sub_id.clone(); + state.profile_folders[2].profiles.push(nested); + + let _ = update(&mut state, Message::OpenFolderMenu(test_window(), 1)); + assert_eq!(state.folder_menu.map(|(index, _)| index), Some(1)); + + let _ = update(&mut state, Message::FolderMenuRename(1)); + let _ = update( + &mut state, + Message::FolderRenameChanged("Office".to_owned()), + ); + let _ = update(&mut state, Message::ConfirmFolderRename); + + assert_eq!(state.profile_folders[1].path, "Office"); + assert_eq!(state.profile_folders[2].path, "Office/Sub"); + assert_eq!(state.profile_folders[1].id, work_id); + assert_eq!(state.profile_folders[2].id, sub_id); + assert_eq!(state.profile_folders[1].profiles[0].folder_id, work_id); + assert_eq!(state.profile_folders[2].profiles[0].folder_id, sub_id); + } + + #[test] + fn ungrouped_has_no_context_menu() { + let mut state = state(); + let _ = update(&mut state, Message::OpenFolderMenu(test_window(), 0)); + assert_eq!(state.folder_menu, None); + } + #[test] fn trash_timestamps_are_readable() { assert_eq!(super::format_timestamp(0), "1970-01-01 00:00:00"); @@ -9219,6 +9874,34 @@ mod tests { std::fs::remove_dir_all(&root).unwrap(); } + #[test] + fn profiles_load_by_folder_uuid() { + let stamp = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_nanos(); + 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(); + std::fs::write( + root.join("folders.toml"), + format!("[[folders]]\nid = \"{id}\"\npath = \"Work\"\n"), + ) + .unwrap(); + std::fs::write( + root.join("Server.toml"), + format!("name = \"Server\"\nfolder = \"{id}\"\nfolder_name = \"Work\"\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); + + std::fs::remove_dir_all(&root).unwrap(); + } + #[test] fn profile_files_store_the_folder_and_settings() { let stamp = std::time::SystemTime::now() @@ -9238,6 +9921,7 @@ mod tests { start_path: "/tmp".to_owned(), private_key: "/keys/id".to_owned(), glyph_color: iced::Color::WHITE, + folder_id: "folder-id".to_owned(), file: None, }; @@ -9245,7 +9929,8 @@ mod tests { assert_eq!(path.file_name().unwrap(), "Server_Test.toml"); let text = std::fs::read_to_string(&path).unwrap(); - assert!(text.contains("folder = \"Work/Production\"")); + assert!(text.contains("folder = \"folder-id\"")); + assert!(text.contains("folder_name = \"Work/Production\"")); assert!(text.contains("kind = \"ssh\"")); assert!(text.contains("session_end = \"reconnect\"")); assert!(text.contains("host = \"example.com\""));