diff --git a/src/main.rs b/src/main.rs index 77c91e9..9180c6a 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,5 +1,5 @@ use std::cmp::Ordering; -use std::collections::{BTreeSet, HashMap}; +use std::collections::{BTreeSet, HashMap, HashSet}; use std::path::{Path, PathBuf}; use serde::{Deserialize, Serialize}; @@ -7,8 +7,8 @@ use serde::{Deserialize, Serialize}; use iced::time::{Duration, Instant}; use iced::widget::{Id, operation}; use iced::widget::{ - button, column, container, mouse_area, pick_list, responsive, row, rule, scrollable, space, - stack, text, text_input, toggler, tooltip, + button, checkbox, column, container, mouse_area, pick_list, responsive, row, rule, scrollable, + space, stack, text, text_input, toggler, tooltip, }; use iced::{ Alignment, Animation, Border, Color, Element, Font, Length, Padding, Point, Rectangle, Shadow, @@ -514,6 +514,8 @@ struct Profile { password: String, start_path: String, private_key: String, + /// File this profile was loaded from or saved to. + file: Option, } /// Editable state of the "add profile" dialog. @@ -747,7 +749,7 @@ struct FoldersFile { } /// One `profiles/.toml` file. -#[derive(Debug, Serialize, Deserialize)] +#[derive(Debug, Clone, Serialize, Deserialize)] struct ProfileFile { #[serde(default)] name: String, @@ -771,6 +773,74 @@ struct ProfileFile { start_path: String, #[serde(default)] private_key: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + trash: Option, +} + +/// Metadata added to a profile file after it is moved to `.trash`. +#[derive(Debug, Clone, Default, Serialize, Deserialize)] +struct TrashInfo { + #[serde(default)] + previous_path: String, + #[serde(default)] + deleted: String, +} + +/// One deleted folder recorded in `.trash/folders.toml`. +#[derive(Debug, Clone, Serialize, Deserialize)] +struct TrashFolder { + name: String, + #[serde(default)] + previous_path: String, + #[serde(default)] + deleted: String, +} + +#[derive(Debug, Default, Serialize, Deserialize)] +struct TrashFoldersFile { + #[serde(default)] + folders: Vec, +} + +#[derive(Debug, Clone)] +enum TrashEntry { + Folder(TrashFolder), + Profile { file: PathBuf, profile: ProfileFile }, +} + +impl TrashEntry { + fn name(&self) -> &str { + match self { + Self::Folder(folder) => &folder.name, + Self::Profile { profile, .. } => &profile.name, + } + } + + fn previous_path(&self) -> &str { + match self { + Self::Folder(folder) => &folder.previous_path, + Self::Profile { profile, .. } => profile + .trash + .as_ref() + .map(|trash| trash.previous_path.as_str()) + .unwrap_or_default(), + } + } + + fn deleted(&self) -> &str { + match self { + Self::Folder(folder) => &folder.deleted, + Self::Profile { profile, .. } => profile + .trash + .as_ref() + .map(|trash| trash.deleted.as_str()) + .unwrap_or_default(), + } + } + + fn is_folder(&self) -> bool { + matches!(self, Self::Folder(_)) + } } impl ProfileFile { @@ -787,6 +857,7 @@ impl ProfileFile { password: profile.password.clone(), start_path: profile.start_path.clone(), private_key: profile.private_key.clone(), + trash: None, } } @@ -802,6 +873,7 @@ impl ProfileFile { password: self.password, start_path: self.start_path, private_key: self.private_key, + file: None, } } } @@ -810,12 +882,40 @@ fn default_profile_port() -> String { "22".to_owned() } -#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] enum Selection { Folder(usize), Profile { folder: usize, profile: usize }, } +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum TransferMode { + Copy, + Move, +} + +impl TransferMode { + fn label(self) -> &'static str { + match self { + Self::Copy => "Copy to", + Self::Move => "Move to", + } + } + + fn action(self) -> &'static str { + match self { + Self::Copy => "Copy", + Self::Move => "Move", + } + } +} + +#[derive(Debug, Clone)] +struct TransferDialog { + mode: TransferMode, + destination: usize, +} + /// Per-window UI state: tabs, menus and tab-strip scrolling. struct WindowState { tabs: Vec, @@ -913,6 +1013,12 @@ struct Moorly { profile_filter: String, profile_folders: Vec, selected: Option, + checked: HashSet, + trash_open: bool, + trash_entries: Vec, + trash_checked: HashSet, + transfer: Option, + confirm_delete: bool, hovered_folder: Option, add_menu_open: bool, folder_dialog: Option, @@ -1579,7 +1685,9 @@ fn load_profiles_from(dir: &Path) -> Vec { let folder = normalize_folder_path(&file.folder); add_missing_folder_and_parents(&tracked, &mut untracked, &folder); - profiles.push((folder, file.into_profile())); + let mut profile = file.into_profile(); + profile.file = Some(path); + profiles.push((folder, profile)); } } @@ -1682,6 +1790,20 @@ fn profile_file_stem(name: &str) -> String { } } +fn write_profile_file(path: &Path, profile: &Profile, folder: &str) -> Option<()> { + let text = toml::to_string_pretty(&ProfileFile::from_profile(profile, folder)).ok()?; + std::fs::write(path, text).ok()?; + + // Profile files can contain passwords and keys; keep them private. + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o600)).ok()?; + } + + Some(()) +} + fn write_profile_to(dir: &Path, profile: &Profile, folder: &str) -> Option { std::fs::create_dir_all(dir).ok()?; @@ -1694,27 +1816,30 @@ fn write_profile_to(dir: &Path, profile: &Profile, folder: &str) -> Option Option<()> { +fn write_profile(profile: &Profile, folder: &str) -> Option { // Never let the unit tests write into the developer's real profile files. if cfg!(test) { - return Some(()); + return None; } - let dir = profiles_dir()?; - write_profile_to(&dir, profile, folder).map(|_| ()) + write_profile_to(&profiles_dir()?, profile, folder) +} + +/// Persists a profile at its existing file, or creates one if it has none. +fn save_profile(profile: &mut Profile, folder: &str) { + if cfg!(test) { + return; + } + + if let Some(file) = &profile.file { + let _ = write_profile_file(file, profile, folder); + } else if let Some(path) = write_profile(profile, folder) { + profile.file = Some(path); + } } fn write_folders_to(dir: &Path, folders: &[ProfileFolder]) -> Option<()> { @@ -1745,6 +1870,567 @@ fn save_folders(folders: &[ProfileFolder]) { let _ = write_folders_to(&dir, folders); } +fn trash_dir() -> Option { + config_path().and_then(|path| path.parent().map(|parent| parent.join(".trash"))) +} + +fn timestamp_now() -> String { + let seconds = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map(|duration| duration.as_secs()) + .unwrap_or_default(); + + format_timestamp(seconds) +} + +fn format_timestamp(seconds: u64) -> String { + let days = (seconds / 86_400) as i64; + let time = seconds % 86_400; + let z = days + 719_468; + let era = if z >= 0 { z } else { z - 146_096 } / 146_097; + let doe = z - era * 146_097; + let yoe = (doe - doe / 1_460 + doe / 36_524 - doe / 146_096) / 365; + let year = yoe + era * 400; + let doy = doe - (365 * yoe + yoe / 4 - yoe / 100); + let mp = (5 * doy + 2) / 153; + let day = doy - (153 * mp + 2) / 5 + 1; + let month = mp + if mp < 10 { 3 } else { -9 }; + let year = year + if month <= 2 { 1 } else { 0 }; + + format!( + "{year:04}-{month:02}-{day:02} {:02}:{:02}:{:02}", + time / 3_600, + (time % 3_600) / 60, + time % 60 + ) +} + +fn load_trash_entries() -> Vec { + trash_dir() + .map(|dir| load_trash_entries_from(&dir)) + .unwrap_or_default() +} + +fn load_trash_entries_from(dir: &Path) -> Vec { + let mut entries = Vec::new(); + + if let Ok(text) = std::fs::read_to_string(dir.join("folders.toml")) + && let Ok(file) = toml::from_str::(&text) + { + entries.extend(file.folders.into_iter().map(TrashEntry::Folder)); + } + + if let Ok(read) = std::fs::read_dir(dir) { + let mut files: Vec = read + .flatten() + .map(|entry| entry.path()) + .filter(|path| { + path.extension().and_then(|extension| extension.to_str()) == Some("toml") + && path.file_name().and_then(|name| name.to_str()) != Some("folders.toml") + }) + .collect(); + files.sort(); + + for file in files { + let Ok(text) = std::fs::read_to_string(&file) else { + continue; + }; + let Ok(profile) = toml::from_str::(&text) else { + continue; + }; + + if profile.trash.is_some() { + entries.push(TrashEntry::Profile { file, profile }); + } + } + } + + entries +} + +fn append_trash_folders(folders: &[TrashFolder]) { + if cfg!(test) || folders.is_empty() { + return; + } + + let Some(dir) = trash_dir() else { + return; + }; + let _ = std::fs::create_dir_all(&dir); + let path = dir.join("folders.toml"); + let mut file = std::fs::read_to_string(&path) + .ok() + .and_then(|text| toml::from_str::(&text).ok()) + .unwrap_or_default(); + file.folders.extend_from_slice(folders); + + if let Ok(text) = toml::to_string_pretty(&file) { + let _ = std::fs::write(path, text); + } +} + +fn save_trash_folders(folders: &[TrashFolder]) { + if cfg!(test) { + return; + } + + let Some(dir) = trash_dir() else { + return; + }; + let _ = std::fs::create_dir_all(&dir); + let file = TrashFoldersFile { + folders: folders.to_vec(), + }; + + if let Ok(text) = toml::to_string_pretty(&file) { + let _ = std::fs::write(dir.join("folders.toml"), text); + } +} + +fn move_profile_to_trash(profile: &Profile, folder: &str) -> Option { + if cfg!(test) { + return None; + } + + let dir = trash_dir()?; + std::fs::create_dir_all(&dir).ok()?; + + let stem = profile_file_stem(&profile.name); + let mut path = dir.join(format!("{stem}.toml")); + let mut suffix = 2; + + while path.exists() { + path = dir.join(format!("{stem}-{suffix}.toml")); + suffix += 1; + } + + let mut file = ProfileFile::from_profile(profile, folder); + file.trash = Some(TrashInfo { + previous_path: folder.to_owned(), + deleted: timestamp_now(), + }); + + let text = toml::to_string_pretty(&file).ok()?; + std::fs::write(&path, text).ok()?; + + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600)).ok()?; + } + + if let Some(original) = &profile.file { + let _ = std::fs::remove_file(original); + } + + Some(path) +} + +fn is_folder_under(path: &str, root: &str) -> bool { + path == root + || path + .strip_prefix(root) + .is_some_and(|rest| rest.starts_with('/')) +} + +fn checked_folder_roots(state: &Moorly) -> Vec { + let mut roots: Vec = state + .checked + .iter() + .filter_map(|item| match item { + Selection::Folder(index) => state + .profile_folders + .get(*index) + .map(|folder| folder.path.clone()), + Selection::Profile { .. } => None, + }) + .collect(); + + // A checked child folder is already covered by its checked parent. + roots.sort_by_key(|path| path.split('/').count()); + + let mut filtered: Vec = Vec::new(); + for root in roots { + if !filtered.iter().any(|parent| is_folder_under(&root, parent)) { + filtered.push(root); + } + } + + filtered +} + +/// 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(); + + for (folder_index, folder) in state.profile_folders.iter().enumerate() { + if roots.iter().any(|root| is_folder_under(&folder.path, root)) { + continue; + } + + for profile_index in 0..folder.profiles.len() { + if state.checked.contains(&Selection::Profile { + folder: folder_index, + profile: profile_index, + }) { + items.push((folder_index, profile_index)); + } + } + } + + items +} + +fn remove_folders(state: &mut Moorly, roots: &[String]) { + if roots.is_empty() { + return; + } + + let remove_paths: HashSet = state + .profile_folders + .iter() + .filter(|folder| roots.iter().any(|root| is_folder_under(&folder.path, root))) + .map(|folder| folder.path.clone()) + .collect(); + + state + .profile_folders + .retain(|folder| !remove_paths.contains(&folder.path)); +} + +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 roots = checked_folder_roots(state); + let individual = checked_profile_indices(state, &roots); + let snapshot = state.profile_folders.clone(); + let mut placements = Vec::new(); + let mut moved_roots = Vec::new(); + + for root in &roots { + if destination_path == *root || is_folder_under(&destination_path, root) { + continue; + } + + let leaf = root.rsplit('/').next().unwrap_or(root); + let new_root = format!("{destination_path}/{leaf}"); + + for folder in snapshot + .iter() + .filter(|folder| is_folder_under(&folder.path, root)) + { + 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); + + for source in &folder.profiles { + let mut profile = source.clone(); + + match mode { + TransferMode::Copy => { + profile.file = write_profile(&profile, &new_path); + } + TransferMode::Move => save_profile(&mut profile, &new_path), + } + + placements.push((new_path.clone(), profile)); + } + } + + moved_roots.push(root.clone()); + } + + for (folder_index, profile_index) in &individual { + let Some(source) = snapshot + .get(*folder_index) + .and_then(|folder| folder.profiles.get(*profile_index)) + else { + continue; + }; + let mut profile = source.clone(); + + match mode { + TransferMode::Copy => { + profile.file = write_profile(&profile, &destination_path); + } + TransferMode::Move => save_profile(&mut profile, &destination_path), + } + + placements.push((destination_path.clone(), profile)); + } + + if mode == TransferMode::Move { + // Removing by descending index keeps the remaining indices valid. + let mut sorted = individual; + sorted.sort_unstable_by(|a, b| b.cmp(a)); + + for (folder_index, profile_index) in sorted { + if let Some(folder) = state.profile_folders.get_mut(folder_index) + && profile_index < folder.profiles.len() + { + folder.profiles.remove(profile_index); + } + } + + remove_folders(state, &moved_roots); + } + + for (folder_path, profile) in placements { + if let Some(folder) = state + .profile_folders + .iter_mut() + .find(|folder| folder.path == folder_path) + { + folder.expanded = true; + folder.profiles.push(profile); + } + } + + add_folder_to_list(&mut state.profile_folders, DEFAULT_PROFILE_FOLDER); + state + .profile_folders + .sort_by(|a, b| folder_order(&a.path, &b.path)); + state.checked.clear(); + state.selected = None; + state.transfer = None; + save_folders(&state.profile_folders); +} + +fn promoted_path(path: &str, selected_folders: &HashSet) -> String { + let mut kept = Vec::new(); + let mut prefix = String::new(); + + for part in path.split('/') { + if !prefix.is_empty() { + prefix.push('/'); + } + prefix.push_str(part); + + if !selected_folders.contains(&prefix) { + kept.push(part); + } + } + + if kept.is_empty() { + DEFAULT_PROFILE_FOLDER.to_owned() + } else { + kept.join("/") + } +} + +fn apply_delete(state: &mut Moorly) { + let selected_folders: HashSet = state + .checked + .iter() + .filter_map(|item| match item { + Selection::Folder(index) => state + .profile_folders + .get(*index) + .map(|folder| folder.path.clone()), + Selection::Profile { .. } => None, + }) + .collect(); + let selected_profiles: HashSet<(usize, usize)> = state + .checked + .iter() + .filter_map(|item| match item { + Selection::Profile { folder, profile } => Some((*folder, *profile)), + Selection::Folder(_) => None, + }) + .collect(); + let timestamp = timestamp_now(); + let snapshot = state.profile_folders.clone(); + + let mut trash_folders = Vec::new(); + + for folder in &snapshot { + if !selected_folders.contains(&folder.path) { + continue; + } + + let previous_path = folder + .path + .rsplit_once('/') + .map(|(parent, _)| parent) + .unwrap_or(""); + trash_folders.push(TrashFolder { + name: folder.name.clone(), + previous_path: previous_path.to_owned(), + deleted: timestamp.clone(), + }); + } + + let mut kept_folders: Vec = Vec::new(); + + for folder in &snapshot { + if selected_folders.contains(&folder.path) { + continue; + } + + let path = promoted_path(&folder.path, &selected_folders); + if !kept_folders.iter().any(|folder| folder.path == path) { + let mut entry = folder.clone(); + entry.path = path; + entry.profiles.clear(); + kept_folders.push(entry); + } + } + + for (folder_index, folder) in snapshot.iter().enumerate() { + for (profile_index, profile) in folder.profiles.iter().enumerate() { + if selected_profiles.contains(&(folder_index, profile_index)) { + move_profile_to_trash(profile, &folder.path); + continue; + } + + let path = promoted_path(&folder.path, &selected_folders); + + if !kept_folders.iter().any(|folder| folder.path == path) { + kept_folders.push(ProfileFolder::from_path(path.clone())); + } + + let mut profile = profile.clone(); + if path != folder.path { + save_profile(&mut profile, &path); + } + + if let Some(target) = kept_folders.iter_mut().find(|folder| folder.path == path) { + target.profiles.push(profile); + } + } + } + + if !kept_folders + .iter() + .any(|folder| folder.path == DEFAULT_PROFILE_FOLDER) + { + kept_folders.push(ProfileFolder::default_folder()); + } + + kept_folders.sort_by(|a, b| folder_order(&a.path, &b.path)); + append_trash_folders(&trash_folders); + state.profile_folders = kept_folders; + state.checked.clear(); + state.selected = None; + state.confirm_delete = false; + save_folders(&state.profile_folders); +} + +fn restore_trash_items(state: &mut Moorly) { + if state.trash_checked.is_empty() { + return; + } + + let entries = state.trash_entries.clone(); + let mut remaining_folders = Vec::new(); + let mut removed_indices = HashSet::new(); + let mut restored = 0usize; + + // Restore folders first so their profiles have somewhere to go. + for (index, entry) in entries.iter().enumerate() { + let TrashEntry::Folder(folder) = entry else { + continue; + }; + + if state.trash_checked.contains(&index) { + let path = if folder.previous_path.is_empty() { + folder.name.clone() + } else { + format!("{}/{}", folder.previous_path, folder.name) + }; + add_folder_to_list(&mut state.profile_folders, &path); + removed_indices.insert(index); + restored += 1; + } else { + remaining_folders.push(folder.clone()); + } + } + + for (index, entry) in entries.iter().enumerate() { + let TrashEntry::Profile { file, profile } = entry else { + continue; + }; + + if !state.trash_checked.contains(&index) { + continue; + } + + let folder_path = profile + .trash + .as_ref() + .map(|trash| normalize_folder_path(&trash.previous_path)) + .unwrap_or_else(|| DEFAULT_PROFILE_FOLDER.to_owned()); + + if !state + .profile_folders + .iter() + .any(|folder| folder.path == folder_path) + { + add_folder_to_list(&mut state.profile_folders, &folder_path); + } + + let mut restored_profile = profile.clone().into_profile(); + let new_file = write_profile(&restored_profile, &folder_path); + + // Keep the trash entry if the profile could not be written back. + if !cfg!(test) && new_file.is_none() { + continue; + } + + restored_profile.file = new_file; + + if let Some(folder) = state + .profile_folders + .iter_mut() + .find(|folder| folder.path == folder_path) + { + folder.expanded = true; + folder.profiles.push(restored_profile); + removed_indices.insert(index); + restored += 1; + } + + if !cfg!(test) { + let _ = std::fs::remove_file(file); + } + } + + save_trash_folders(&remaining_folders); + state.trash_entries = entries + .into_iter() + .enumerate() + .filter(|(index, _)| !removed_indices.contains(index)) + .map(|(_, entry)| entry) + .collect(); + state.trash_checked.clear(); + + add_folder_to_list(&mut state.profile_folders, DEFAULT_PROFILE_FOLDER); + state + .profile_folders + .sort_by(|a, b| folder_order(&a.path, &b.path)); + save_folders(&state.profile_folders); + state.selected = None; + state.checked.clear(); + + let message = if restored == 1 { + "Restored 1 item from trash.".to_owned() + } else { + format!("Restored {restored} items from trash.") + }; + + state.notifications.add( + notifications::Notification::new(notifications::NotificationKind::Success, message) + .title("Restored"), + ); +} + fn apply_theme_choice(state: &mut Moorly, choice: ThemeChoice) { match &choice { ThemeChoice::BuiltIn(preference) => { @@ -2111,6 +2797,12 @@ impl Default for Moorly { profile_filter: String::new(), profile_folders: load_profiles(), selected: None, + checked: HashSet::new(), + trash_open: false, + trash_entries: Vec::new(), + trash_checked: HashSet::new(), + transfer: None, + confirm_delete: false, hovered_folder: None, add_menu_open: false, folder_dialog: None, @@ -2177,6 +2869,20 @@ enum Message { folder: usize, profile: usize, }, + ToggleChecked(Selection), + DeselectAll, + RestoreFromTrash, + ToggleTrashChecked(usize), + RestoreSelected, + CloseTrash, + CopyChecked, + MoveChecked, + DeleteChecked, + TransferFolderSelected(FolderChoice), + ConfirmTransfer, + CancelTransfer, + ConfirmDelete, + CancelDelete, OpenProfileDialog, ProfileNameChanged(String), ProfileKindSelected(ProfileKind), @@ -2710,6 +3416,75 @@ fn update(state: &mut Moorly, message: Message) -> Task { Message::SelectProfile { folder, profile } => { state.selected = Some(Selection::Profile { folder, profile }); } + Message::ToggleChecked(item) => { + if !state.checked.remove(&item) { + state.checked.insert(item); + } + } + Message::DeselectAll => state.checked.clear(), + Message::RestoreFromTrash => { + state.trash_entries = load_trash_entries(); + state.trash_checked.clear(); + state.trash_open = true; + } + Message::ToggleTrashChecked(index) => { + if !state.trash_checked.remove(&index) { + state.trash_checked.insert(index); + } + } + Message::RestoreSelected => restore_trash_items(state), + Message::CloseTrash => { + state.trash_open = false; + state.trash_checked.clear(); + } + 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, + }); + } + } + 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, + }); + } + } + Message::DeleteChecked => { + if !state.checked.is_empty() { + state.confirm_delete = true; + } + } + Message::TransferFolderSelected(choice) => { + if let Some(transfer) = state.transfer.as_mut() { + transfer.destination = choice.index; + } + } + Message::ConfirmTransfer => { + if let Some(transfer) = state.transfer.clone() { + apply_transfer(state, transfer.mode, transfer.destination); + } + } + Message::CancelTransfer => state.transfer = None, + Message::ConfirmDelete => apply_delete(state), + Message::CancelDelete => state.confirm_delete = false, Message::OpenProfileDialog => { let folder = match state.selected { Some(Selection::Folder(index)) => index, @@ -2871,7 +3646,7 @@ fn update(state: &mut Moorly, message: Message) -> Task { else { return Task::none(); }; - let profile = Profile { + let mut profile = Profile { name: draft.name.trim().to_owned(), kind: draft.kind, session_end: draft.session_end, @@ -2882,9 +3657,10 @@ fn update(state: &mut Moorly, message: Message) -> Task { password: draft.password.clone(), start_path: draft.start_path.clone(), private_key: draft.private_key.clone(), + file: None, }; - write_profile(&profile, &folder_path); + profile.file = write_profile(&profile, &folder_path); save_folders(&state.profile_folders); let Some(folder) = state.profile_folders.get_mut(folder_index) else { @@ -2923,6 +3699,7 @@ fn update(state: &mut Moorly, message: Message) -> Task { let path = normalize_folder_path(&name); let index = ensure_folder(&mut state.profile_folders, &path); + state.checked.clear(); state.selected = Some(Selection::Folder(index)); state.folder_dialog = None; save_folders(&state.profile_folders); @@ -4279,6 +5056,33 @@ fn shortcut_capture_panel(capture: &ShortcutCapture) -> Element<'_, Message> { .into() } +fn profile_action_button<'a>( + glyph: &'a str, + tip: &'a str, + message: Message, + enabled: bool, + danger: bool, +) -> Element<'a, Message> { + let glyph = text(glyph).size(16); + let glyph = if danger { + glyph.color(theme::DANGER.scale_alpha(if enabled { 1.0 } else { 0.4 })) + } else { + glyph + }; + + let button = button(glyph) + .on_press_maybe(enabled.then_some(message)) + .padding([6, 10]) + .style(theme::outlined_option); + + tooltip( + button, + container(text(tip).size(11)).padding(4), + tooltip::Position::Top, + ) + .into() +} + fn profiles_panel(state: &Moorly, show_add: bool) -> Element<'_, Message> { let field = text_input("Filter", &state.profile_filter) .on_input(Message::ProfileFilterChanged) @@ -4334,6 +5138,30 @@ fn profiles_panel(state: &Moorly, show_add: bool) -> Element<'_, Message> { row![filter].width(Length::Fill) }; + let has_checked = !state.checked.is_empty(); + let actions = row![ + profile_action_button( + "✕", + "Deselect all", + Message::DeselectAll, + has_checked, + false + ), + profile_action_button("⧉", "Copy to", Message::CopyChecked, has_checked, false), + profile_action_button("➜", "Move to", Message::MoveChecked, has_checked, false), + profile_action_button("🗑", "Delete", Message::DeleteChecked, has_checked, true), + space::horizontal(), + profile_action_button( + "🗑↗", + "Restore from trash", + Message::RestoreFromTrash, + true, + false + ), + ] + .spacing(6) + .width(Length::Fill); + let mut list = column![].width(Length::Fill); for (index, folder) in state.profile_folders.iter().enumerate() { if index > 0 { @@ -4343,6 +5171,7 @@ fn profiles_panel(state: &Moorly, show_add: bool) -> Element<'_, Message> { index, folder, state.selected, + &state.checked, state.hovered_folder, )); } @@ -4352,19 +5181,22 @@ fn profiles_panel(state: &Moorly, show_add: bool) -> Element<'_, Message> { .height(Length::Fill) .style(theme::settings_frame); - let base = column![filter_row, list] + let base = column![filter_row, actions, list] .spacing(12) .width(Length::Fill) .height(Length::Fill); - if !show_add { - return stack![base].into(); - } - let dialog_open = state.folder_dialog.is_some() || state.profile_dialog.is_some() + || state.transfer.is_some() + || state.trash_open + || state.confirm_delete || state.dir_picker.is_some(); + if !show_add && !dialog_open { + return stack![base].into(); + } + if !state.add_menu_open && !dialog_open { return stack![base].into(); } @@ -4377,8 +5209,14 @@ fn profiles_panel(state: &Moorly, show_add: bool) -> Element<'_, Message> { ) .on_press(if state.dir_picker.is_some() { Message::CancelDirectoryPicker + } else if state.trash_open { + Message::CloseTrash } else if state.folder_dialog.is_some() { Message::CancelFolder + } else if state.transfer.is_some() { + Message::CancelTransfer + } else if state.confirm_delete { + Message::CancelDelete } else if state.profile_dialog.is_some() { Message::CancelProfile } else { @@ -4387,7 +5225,7 @@ fn profiles_panel(state: &Moorly, show_add: bool) -> Element<'_, Message> { let mut layers = stack![base, backdrop]; - if state.add_menu_open { + if show_add && state.add_menu_open { let menu = container( column![ button( @@ -4471,6 +5309,70 @@ fn profiles_panel(state: &Moorly, show_add: bool) -> Element<'_, Message> { layers = layers.push(dialog_layer); } + if state.trash_open { + let dialog = trash_dialog_view(state); + 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 let Some(transfer) = &state.transfer { + let dialog = transfer_dialog_view(transfer, &state.profile_folders); + 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.confirm_delete { + let dialog = container( + column![ + text("Delete selected items?").size(14), + text(format!( + "{} selected item(s) will be moved to the trash and can be restored later.", + state.checked.len() + )) + .size(12), + row![ + space::horizontal(), + button("Cancel") + .on_press(Message::CancelDelete) + .style(theme::outlined_option), + button("Delete") + .on_press(Message::ConfirmDelete) + .style(theme::danger_option), + ] + .spacing(8), + ] + .spacing(10) + .width(Length::Fill), + ) + .width(320) + .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 let Some(draft) = &state.profile_dialog { let dialog = profile_dialog_view(draft, &state.profile_folders); let dialog = mouse_area(dialog).on_press(Message::Ignore); @@ -4594,6 +5496,123 @@ fn directory_picker_view(picker: &DirPicker) -> Element<'_, Message> { } /// The add-profile dialog: details on the left, type-specific view on the right. +/// Dialog listing everything currently in the `.trash` folder. +fn trash_dialog_view(state: &Moorly) -> Element<'_, Message> { + let restore_enabled = !state.trash_checked.is_empty(); + let header = row![ + button("Restore selected") + .on_press_maybe(restore_enabled.then_some(Message::RestoreSelected)) + .style(theme::positive_option), + space::horizontal(), + button("Close") + .on_press(Message::CloseTrash) + .style(theme::outlined_option), + ] + .spacing(8) + .width(Length::Fill); + + let columns = row![ + text("Name").size(11).width(Length::Fixed(200.0)), + text("Previous path").size(11).width(Length::Fixed(220.0)), + text("Deleted").size(11).width(Length::Fixed(160.0)), + ] + .spacing(8) + .padding([4, 0]); + + let mut rows = column![columns].spacing(2).width(Length::Fill); + + for (index, entry) in state.trash_entries.iter().enumerate() { + let checked = state.trash_checked.contains(&index); + let glyph = if entry.is_folder() { + "🗀\u{fe0e}" + } else { + "👤" + }; + let previous_path = if entry.previous_path().is_empty() { + "—" + } else { + entry.previous_path() + }; + + rows = rows.push( + row![ + checkbox(checked) + .size(16) + .on_toggle(move |_| Message::ToggleTrashChecked(index)), + container( + row![text(glyph).size(13), text(entry.name()).size(13)] + .spacing(6) + .align_y(Alignment::Center) + ) + .width(Length::Fixed(200.0)), + text(previous_path).size(12).width(Length::Fixed(220.0)), + text(entry.deleted()).size(12).width(Length::Fixed(160.0)), + ] + .spacing(8) + .align_y(Alignment::Center) + .padding([4, 0]), + ); + } + + if state.trash_entries.is_empty() { + rows = rows.push(container(text("Trash is empty.").size(13)).padding([8, 0])); + } + + let listing = container(scrollable(rows).width(Length::Fill).height(Length::Fill)) + .width(Length::Fill) + .height(360) + .style(theme::settings_frame); + + container( + column![text("Trash").size(16), header, listing] + .spacing(10) + .width(Length::Fill), + ) + .width(720) + .padding(16) + .style(theme::menu) + .into() +} + +/// 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 + .iter() + .enumerate() + .map(|(index, folder)| FolderChoice { + index, + name: folder.path.clone(), + }) + .collect(); + let selected = choices.get(transfer.destination).cloned(); + + container( + column![ + text(transfer.mode.label()).size(14), + pick_list(choices, selected, Message::TransferFolderSelected).width(Length::Fill), + row![ + space::horizontal(), + button("Cancel") + .on_press(Message::CancelTransfer) + .style(theme::outlined_option), + button(transfer.mode.action()) + .on_press(Message::ConfirmTransfer) + .style(theme::positive_option), + ] + .spacing(8), + ] + .spacing(10) + .width(Length::Fill), + ) + .width(320) + .padding(12) + .style(theme::menu) + .into() +} + fn profile_dialog_view<'a>( draft: &'a ProfileDraft, folders: &'a [ProfileFolder], @@ -4902,12 +5921,13 @@ fn private_key_field(draft: &ProfileDraft) -> Element<'_, Message> { /// One folder heading followed by its profiles. Clicking the heading toggles /// the profile list; clicking a row selects it. -fn profile_folder_row( +fn profile_folder_row<'a>( index: usize, - folder: &ProfileFolder, + folder: &'a ProfileFolder, selected: Option, + checked: &'a HashSet, hovered: Option, -) -> Element<'_, Message> { +) -> Element<'a, Message> { let is_selected = selected == Some(Selection::Folder(index)); let expanded = folder.expanded; let indent = folder.depth() as f32 * 18.0; @@ -4960,7 +5980,7 @@ fn profile_folder_row( top: 8.0, right: 10.0, bottom: 8.0, - left: 10.0 + indent, + left: 0.0, }) .style(move |theme, status| { let mut style = theme::selectable_row(theme, status, is_selected); @@ -4974,6 +5994,36 @@ fn profile_folder_row( .on_enter(Message::HoverFolder(Some(index))) .on_exit(Message::HoverFolder(None)); + let folder_checked = checked.contains(&Selection::Folder(index)); + let folder_checkbox: Element<'_, Message> = if folder.path == DEFAULT_PROFILE_FOLDER { + container(space::horizontal()) + .width(16) + .padding(Padding { + top: 8.0, + right: 6.0, + bottom: 8.0, + left: 10.0 + indent, + }) + .into() + } else { + container( + checkbox(folder_checked) + .size(16) + .on_toggle(move |_| Message::ToggleChecked(Selection::Folder(index))), + ) + .padding(Padding { + top: 8.0, + right: 6.0, + bottom: 8.0, + left: 10.0 + indent, + }) + .into() + }; + + let heading = row![folder_checkbox, heading] + .align_y(Alignment::Center) + .width(Length::Fill); + let mut rows = column![heading].width(Length::Fill); if expanded { @@ -4983,25 +6033,46 @@ fn profile_folder_row( folder: index, profile: profile_index, }); - - rows = rows.push( - button( - row![text("👤").size(13), text(profile.name.as_str()).size(13)] - .spacing(8) - .align_y(Alignment::Center), - ) - .on_press(Message::SelectProfile { - folder: index, - profile: profile_index, - }) - .width(Length::Fill) + let profile_checked = checked.contains(&Selection::Profile { + folder: index, + profile: profile_index, + }); + let profile_checkbox = + container(checkbox(profile_checked).size(16).on_toggle(move |_| { + Message::ToggleChecked(Selection::Profile { + folder: index, + profile: profile_index, + }) + })) .padding(Padding { top: 4.0, - right: 26.0, + right: 6.0, bottom: 4.0, left: 26.0 + indent, - }) - .style(move |theme, status| theme::selectable_row(theme, status, profile_selected)), + }); + + let profile_row = button( + row![text("👤").size(13), text(profile.name.as_str()).size(13)] + .spacing(8) + .align_y(Alignment::Center), + ) + .on_press(Message::SelectProfile { + folder: index, + profile: profile_index, + }) + .width(Length::Fill) + .padding(Padding { + top: 4.0, + right: 26.0, + bottom: 4.0, + left: 0.0, + }) + .style(move |theme, status| theme::selectable_row(theme, status, profile_selected)); + + rows = rows.push( + row![profile_checkbox, profile_row] + .align_y(Alignment::Center) + .width(Length::Fill), ); } } @@ -5699,6 +6770,12 @@ mod tests { profile_filter: String::new(), profile_folders: vec![super::ProfileFolder::default_folder()], selected: None, + checked: super::HashSet::new(), + trash_open: false, + trash_entries: Vec::new(), + trash_checked: super::HashSet::new(), + transfer: None, + confirm_delete: false, hovered_folder: None, add_menu_open: false, folder_dialog: None, @@ -5709,6 +6786,22 @@ mod tests { } } + fn profile(name: &str) -> super::Profile { + super::Profile { + name: name.to_owned(), + kind: super::ProfileKind::Ssh, + session_end: super::SessionEnd::Auto, + host: String::new(), + port: "22".to_owned(), + username: String::new(), + auth: super::AuthMethod::Password, + password: String::new(), + start_path: String::new(), + private_key: String::new(), + file: None, + } + } + #[test] fn start_tab_follows_the_saved_setting() { let (state, _) = super::boot(); @@ -6730,6 +7823,242 @@ mod tests { assert_eq!(state.selected, Some(super::Selection::Folder(1))); } + #[test] + fn checkboxes_toggle_and_clear() { + let mut state = state(); + + let _ = update( + &mut state, + Message::ToggleChecked(super::Selection::Folder(0)), + ); + assert!(state.checked.contains(&super::Selection::Folder(0))); + + let _ = update( + &mut state, + Message::ToggleChecked(super::Selection::Profile { + folder: 0, + profile: 0, + }), + ); + assert_eq!(state.checked.len(), 2); + + let _ = update(&mut state, Message::DeselectAll); + assert!(state.checked.is_empty()); + } + + #[test] + fn delete_removes_checked_profiles_and_folders() { + 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()), + ]; + state.profile_folders[0].profiles.push(profile("Loose")); + state.profile_folders[1].profiles.push(profile("Inside")); + state.profile_folders[2].profiles.push(profile("Nested")); + state.checked.insert(super::Selection::Profile { + folder: 0, + profile: 0, + }); + state.checked.insert(super::Selection::Folder(1)); + + let _ = update(&mut state, Message::DeleteChecked); + assert!(state.confirm_delete); + let _ = update(&mut state, Message::ConfirmDelete); + + assert!(state.checked.is_empty()); + assert!(!state.confirm_delete); + assert!( + state + .profile_folders + .iter() + .all(|folder| folder.path != "Work") + ); + + // Unchecked children move up instead of going with the deleted folder. + let sub = state + .profile_folders + .iter() + .find(|folder| folder.path == "Sub") + .unwrap(); + assert_eq!(sub.profiles.len(), 1); + assert_eq!(sub.profiles[0].name, "Nested"); + + let default = state + .profile_folders + .iter() + .find(|folder| folder.path == "Ungrouped") + .unwrap(); + assert_eq!(default.profiles.len(), 1); + assert_eq!(default.profiles[0].name, "Inside"); + } + + #[test] + fn copy_and_move_transfer_checked_profiles() { + let mut state = state(); + state.profile_folders = vec![ + super::ProfileFolder::default_folder(), + super::ProfileFolder::from_path("Work".to_owned()), + ]; + state.profile_folders[0].profiles.push(profile("Source")); + state.checked.insert(super::Selection::Profile { + folder: 0, + profile: 0, + }); + + let _ = update(&mut state, Message::CopyChecked); + let _ = update( + &mut state, + Message::TransferFolderSelected(super::FolderChoice { + index: 1, + name: "Work".to_owned(), + }), + ); + let _ = update(&mut state, Message::ConfirmTransfer); + + assert_eq!(state.profile_folders[0].profiles.len(), 1); + assert_eq!(state.profile_folders[1].profiles.len(), 1); + assert_eq!(state.profile_folders[1].profiles[0].name, "Source"); + + state.checked.insert(super::Selection::Profile { + folder: 0, + profile: 0, + }); + let _ = update(&mut state, Message::MoveChecked); + let _ = update( + &mut state, + Message::TransferFolderSelected(super::FolderChoice { + index: 1, + name: "Work".to_owned(), + }), + ); + let _ = update(&mut state, Message::ConfirmTransfer); + + assert!(state.profile_folders[0].profiles.is_empty()); + assert_eq!(state.profile_folders[1].profiles.len(), 2); + } + + #[test] + fn trash_restore_recreates_folders_and_profiles() { + let mut state = state(); + state.profile_folders = vec![super::ProfileFolder::default_folder()]; + let mut profile_file = super::ProfileFile::from_profile(&profile("Loose"), "Ungrouped"); + profile_file.trash = Some(super::TrashInfo { + previous_path: "Ungrouped".to_owned(), + deleted: "2026-11-07 12:00:00".to_owned(), + }); + state.trash_entries = vec![ + super::TrashEntry::Folder(super::TrashFolder { + name: "Work".to_owned(), + previous_path: String::new(), + deleted: "2026-11-07 12:00:00".to_owned(), + }), + super::TrashEntry::Profile { + file: std::path::PathBuf::from("/nonexistent/trash.toml"), + profile: profile_file, + }, + ]; + state.trash_checked.insert(0); + state.trash_checked.insert(1); + + let _ = update(&mut state, Message::RestoreSelected); + + assert!(state.trash_entries.is_empty()); + assert_eq!(state.profile_folders[0].profiles.len(), 1); + assert_eq!(state.profile_folders[0].profiles[0].name, "Loose"); + let work = state + .profile_folders + .iter() + .find(|folder| folder.path == "Work") + .unwrap(); + assert!(work.profiles.is_empty()); + } + + #[test] + fn moving_a_folder_moves_its_subtree() { + 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: 2, + name: "Home".to_owned(), + }), + ); + let _ = update(&mut state, Message::ConfirmTransfer); + + assert!( + state + .profile_folders + .iter() + .all(|folder| folder.path != "Work") + ); + let moved = state + .profile_folders + .iter() + .find(|folder| folder.path == "Home/Work") + .unwrap(); + assert_eq!(moved.profiles.len(), 1); + assert_eq!(moved.profiles[0].name, "Server"); + } + + #[test] + fn trash_timestamps_are_readable() { + assert_eq!(super::format_timestamp(0), "1970-01-01 00:00:00"); + assert_eq!( + super::format_timestamp(1_700_000_000), + "2023-11-14 22:13:20" + ); + } + + #[test] + fn trash_entries_load_from_folders_and_profiles() { + let stamp = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_nanos(); + let root = std::env::temp_dir().join(format!("moorly-trash-test-{stamp}")); + std::fs::create_dir_all(&root).unwrap(); + std::fs::write( + root.join("folders.toml"), + "[[folders]]\nname = \"Work\"\nprevious_path = \"\"\ndeleted = \"2026-11-07 12:00:00\"\n", + ) + .unwrap(); + + let mut profile_file = super::ProfileFile::from_profile(&profile("Server"), "Work"); + profile_file.trash = Some(super::TrashInfo { + previous_path: "Work".to_owned(), + deleted: "2026-11-07 12:01:00".to_owned(), + }); + let text = toml::to_string_pretty(&profile_file).unwrap(); + assert!(text.contains("[trash]")); + std::fs::write(root.join("Server.toml"), text).unwrap(); + + let entries = super::load_trash_entries_from(&root); + assert_eq!(entries.len(), 2); + + let folder = entries.iter().find(|entry| entry.is_folder()).unwrap(); + assert_eq!(folder.name(), "Work"); + assert_eq!(folder.previous_path(), ""); + assert_eq!(folder.deleted(), "2026-11-07 12:00:00"); + + let profile = entries.iter().find(|entry| !entry.is_folder()).unwrap(); + assert_eq!(profile.name(), "Server"); + assert_eq!(profile.previous_path(), "Work"); + assert_eq!(profile.deleted(), "2026-11-07 12:01:00"); + + std::fs::remove_dir_all(&root).unwrap(); + } + #[test] fn profiles_load_nested_folders_and_create_missing_parents() { let stamp = std::time::SystemTime::now() @@ -6819,6 +8148,7 @@ mod tests { password: "secret".to_owned(), start_path: "/tmp".to_owned(), private_key: "/keys/id".to_owned(), + file: None, }; let path = super::write_profile_to(&root, &profile, "Work/Production").unwrap();