diff --git a/linux/changelog.d/4115.added.md b/linux/changelog.d/4115.added.md new file mode 100644 index 0000000000..01e35d6185 --- /dev/null +++ b/linux/changelog.d/4115.added.md @@ -0,0 +1 @@ +A favorite is renamed or deleted from the Favorites list, with a right click, F2 or Delete. diff --git a/linux/crates/app/src/ui/session_window/tests/mod.rs b/linux/crates/app/src/ui/session_window/tests/mod.rs index 178f484ab1..0c143b072b 100644 --- a/linux/crates/app/src/ui/session_window/tests/mod.rs +++ b/linux/crates/app/src/ui/session_window/tests/mod.rs @@ -3,7 +3,8 @@ mod open_file; mod other_databases; mod sessions; -use std::rc::Rc; +use std::cell::RefCell; +use std::rc::{Rc, Weak}; use std::sync::Arc; use std::time::Duration; @@ -14,7 +15,7 @@ use tablepro_core::credentials::{SecretError, SecretKind, SecretSave}; use tablepro_core::{AuthMode, DriverError, DriverRegistry, FileEndpoint, LivenessPolicy, TlsConfig}; use tablepro_session::fakes::{FakeConnector, FakeCredentialSource, FakeEstablish}; use tablepro_session::operation::DefaultDeadlines; -use tablepro_session::runtime::CountingHold; +use tablepro_session::runtime::{CountingHold, HoldToken, ProcessHold}; use tablepro_session::{ConnectError, CredentialSource, SessionKey}; use tablepro_storage::{SavedConnection, StoragePaths}; use tablepro_test_support::{ @@ -77,6 +78,7 @@ pub(crate) struct TestWindow { pub window: SessionWindow, pub services: Rc, pub hold: Rc, + pub hold_tokens: Rc>>>, pub connector: FakeConnector, pub saved: SavedConnection, /// The keyring every saved connection reads, unless the script @@ -87,6 +89,46 @@ pub(crate) struct TestWindow { _dir: tempfile::TempDir, } +struct TrackedHold { + count: Rc, + tokens: Rc>>>, +} + +impl TrackedHold { + fn new(count: Rc) -> Self { + Self { + count, + tokens: Rc::default(), + } + } +} + +impl ProcessHold for TrackedHold { + fn acquire(&self) -> HoldToken { + let identity = Rc::new(()); + self.tokens.borrow_mut().push(Rc::downgrade(&identity)); + HoldToken::new((self.count.acquire(), identity)) + } +} + +#[test] +fn hold_identity_distinguishes_a_released_write_from_other_live_work() { + let count = Rc::new(CountingHold::new()); + let hold = TrackedHold::new(count.clone()); + let write = hold.acquire(); + let identity = hold.tokens.borrow().last().expect("write token").clone(); + let cleanup = hold.acquire(); + assert!(identity.upgrade().is_some()); + drop(write); + assert_eq!(count.live(), 1); + assert!( + identity.upgrade().is_none(), + "cleanup must not keep the write's token alive" + ); + drop(cleanup); + assert_eq!(count.live(), 0); +} + impl TestWindow { pub(crate) fn picker(name: &str) -> Self { Self::with_script(name, Script::default()) @@ -150,6 +192,8 @@ impl TestWindow { let connector = FakeConnector::new(establish).always(FakeEstablish::Connect(connection)); let liveness = LivenessPolicy::DESKTOP; let hold = Rc::new(CountingHold::new()); + let tracked_hold = TrackedHold::new(hold.clone()); + let hold_tokens = tracked_hold.tokens.clone(); let parts = AppServicesParts { drivers, connector: Arc::new(connector.clone()), @@ -159,7 +203,7 @@ impl TestWindow { storage, tasks: runtime.tasks(), }; - let mut services = scripted_services(parts, hold.clone(), credentials, ssh); + let mut services = scripted_services(parts, Rc::new(tracked_hold), credentials, ssh); if let Some(revealer) = revealer { services.file_revealer = revealer; } @@ -170,6 +214,7 @@ impl TestWindow { window, services, hold, + hold_tokens, connector, saved, vault, @@ -287,7 +332,7 @@ fn write_unreadable_list(list_file: &std::path::Path) { fn scripted_services( parts: AppServicesParts, - hold: Rc, + hold: Rc, credentials: Option, ssh: Option, ) -> AppServices { diff --git a/linux/crates/app/src/ui/workspace/mod.rs b/linux/crates/app/src/ui/workspace/mod.rs index 97905d18c9..1546b9b017 100644 --- a/linux/crates/app/src/ui/workspace/mod.rs +++ b/linux/crates/app/src/ui/workspace/mod.rs @@ -1330,10 +1330,6 @@ impl WorkspaceModel { } } - #[expect( - clippy::too_many_lines, - reason = "Each workspace input dispatches to its own handler" - )] fn update(&mut self, msg: WorkspaceInput) { match msg { WorkspaceInput::HealthChanged(health) => self.refresh_health_banner(&health), diff --git a/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs b/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs index 6f7c41dbdf..504c13c2b8 100644 --- a/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs +++ b/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs @@ -6,25 +6,38 @@ use gtk4::{gio, glib}; use libadwaita as adw; use tablepro_storage::saved_queries::SavedQuery; -use crate::i18n::gettext; +use crate::i18n::{gettext, gettext_f}; const LIST: &str = "list"; const EMPTY: &str = "empty"; -type Opened = Rc; +#[derive(Debug, Clone)] +pub(crate) enum FavoriteAction { + Open(String), + Rename(SavedQuery), + Delete(SavedQuery), +} + +type Asked = Rc; + +const ROW: &str = "favorite-row"; +const RENAME: &str = "rename"; +const DELETE: &str = "delete"; +const KEYS: &str = "favorite-keys"; #[derive(Clone)] pub(crate) struct FavoritesPane { stack: gtk::Stack, store: gio::ListStore, selection: gtk::SingleSelection, + menu: gtk::PopoverMenu, error: adw::StatusPage, retry: gtk::Button, stale: adw::Banner, } impl FavoritesPane { - pub(crate) fn new(opened: impl Fn(String) + 'static, retry: impl Fn() + 'static) -> Self { + pub(crate) fn new(asked: impl Fn(FavoriteAction) + 'static, retry: impl Fn() + 'static) -> Self { let store = gio::ListStore::new::(); let selection = gtk::SingleSelection::builder() .model(&store) @@ -35,13 +48,15 @@ impl FavoritesPane { list.add_css_class("navigation-sidebar"); list.set_single_click_activate(true); list.update_property(&[gtk::accessible::Property::Label(&gettext("Favorites"))]); - let opened: Opened = Rc::new(opened); + let asked: Asked = Rc::new(asked); + let opened = asked.clone(); let model = store.clone(); list.connect_activate(move |_, position| { if let Some(favorite) = favorite_at(&model, position) { - opened(favorite.query); + opened(FavoriteAction::Open(favorite.query)); } }); + let menu = install_menu(&list, &store, &selection, &asked); let scrolled = gtk::ScrolledWindow::builder() .hscrollbar_policy(gtk::PolicyType::Never) .child(&list) @@ -96,6 +111,7 @@ impl FavoritesPane { stack, store, selection, + menu, error, retry: retry_button, stale, @@ -107,6 +123,7 @@ impl FavoritesPane { } pub(crate) fn clear(&self) { + self.menu.popdown(); self.store.remove_all(); self.stale.set_revealed(false); } @@ -144,6 +161,7 @@ impl FavoritesPane { } pub(crate) fn show(&self, favorites: Vec) { + self.menu.popdown(); let selected = favorite_at(&self.store, self.selection.selected()).map(|saved| saved.id); let selected_position = favorites.iter().position(|saved| Some(saved.id) == selected); let items: Vec = favorites.into_iter().map(glib::BoxedAnyObject::new).collect(); @@ -155,6 +173,14 @@ impl FavoritesPane { .set_visible_child_name(if items.is_empty() { EMPTY } else { LIST }); } + #[cfg(test)] + pub(crate) fn ids(&self) -> Vec { + (0..self.store.n_items()) + .filter_map(|position| favorite_at(&self.store, position)) + .map(|favorite| favorite.id) + .collect() + } + #[cfg(test)] pub(crate) fn names(&self) -> Vec { (0..self.store.n_items()) @@ -185,17 +211,26 @@ fn factory() -> gtk::SignalListItemFactory { .build(); summary.add_css_class("caption"); summary.add_css_class("dimmed"); - let row = gtk::Box::builder() + let labels = gtk::Box::builder() .orientation(gtk::Orientation::Vertical) .spacing(2) - .margin_top(6) - .margin_bottom(6) + .hexpand(true) + .valign(gtk::Align::Center) .build(); - row.append(&name); - row.append(&summary); + labels.append(&name); + labels.append(&summary); + let menu = gtk::MenuButton::builder() + .icon_name("view-more-symbolic") + .valign(gtk::Align::Center) + .build(); + menu.add_css_class("flat"); + let row = gtk::Box::builder().spacing(6).margin_top(6).margin_bottom(6).build(); + row.add_css_class(ROW); + row.append(&labels); + row.append(&menu); item.set_child(Some(&row)); }); - factory.connect_bind(|_, item| { + factory.connect_bind(move |_, item| { let Some(item) = item.downcast_ref::() else { return; }; @@ -203,18 +238,192 @@ fn factory() -> gtk::SignalListItemFactory { return; }; let favorite = object.borrow::().clone(); - if let (Some(name), Some(summary)) = ( - row.first_child().and_downcast::(), - row.last_child().and_downcast::(), - ) { - name.set_label(&favorite.name); - summary.set_label(favorite.summary()); + row.set_widget_name(&favorite.id.to_string()); + if let Some(labels) = row.first_child() { + if let Some(name) = labels.first_child().and_downcast::() { + name.set_label(&favorite.name); + } + if let Some(summary) = labels.last_child().and_downcast::() { + summary.set_label(favorite.summary()); + summary.set_visible(!favorite.summary().is_empty()); + } + } + if let Some(menu) = row.last_child().and_downcast::() { + let label = gettext_f("Options for “{name}”", &[("name", &favorite.name)]); + menu.set_tooltip_text(Some(&label)); + menu.update_property(&[gtk::accessible::Property::Label(&label)]); + menu.set_menu_model(Some(&menu_of(favorite.id))); } item.set_accessible_label(&favorite.name); }); + factory.connect_unbind(|_, item| { + let Some(row) = item.downcast_ref::().and_then(|item| item.child()) else { + return; + }; + row.set_widget_name(""); + if let Some(menu) = row.last_child().and_downcast::() { + menu.popdown(); + menu.set_menu_model(None::<&gio::MenuModel>); + } + }); factory } +fn install_menu( + list: >k::ListView, + store: &gio::ListStore, + selection: >k::SingleSelection, + asked: &Asked, +) -> gtk::PopoverMenu { + let actions = gio::SimpleActionGroup::new(); + for (name, make) in [ + (RENAME, FavoriteAction::Rename as fn(SavedQuery) -> FavoriteAction), + (DELETE, FavoriteAction::Delete), + ] { + let action = gio::SimpleAction::new(name, Some(glib::VariantTy::INT64)); + let (store, asked) = (store.clone(), asked.clone()); + action.connect_activate(move |_, target| { + let Some(id) = target.and_then(|target| target.get::()) else { + return; + }; + if let Some(favorite) = favorite_by_id(&store, id) { + asked(make(favorite)); + } + }); + actions.add_action(&action); + } + list.insert_action_group("favorite", Some(&actions)); + + let menu = gtk::PopoverMenu::from_model(None::<&gio::MenuModel>); + menu.set_has_arrow(false); + menu.set_parent(list); + let click = gtk::GestureClick::builder().button(gtk::gdk::BUTTON_SECONDARY).build(); + { + let (list, store, menu) = (list.downgrade(), store.clone(), menu.clone()); + click.connect_pressed(move |gesture, _, x, y| { + let Some(list) = list.upgrade() else { + return; + }; + let Some(favorite) = row_at(&list, &store, x, y) else { + return; + }; + gesture.set_state(gtk::EventSequenceState::Claimed); + menu.set_menu_model(Some(&menu_of(favorite.id))); + menu.set_pointing_to(Some(>k::gdk::Rectangle::new(x as i32, y as i32, 1, 1))); + menu.popup(); + }); + } + list.add_controller(click); + // GTK requires manually parented popovers to leave before their parent is finalized. + list.connect_destroy({ + let menu = menu.clone(); + move |_| menu.unparent() + }); + + install_keys(list, store, selection, asked, &menu); + menu +} + +fn install_keys( + list: >k::ListView, + store: &gio::ListStore, + selection: >k::SingleSelection, + asked: &Asked, + menu: >k::PopoverMenu, +) { + let keys = gtk::EventControllerKey::new(); + keys.set_name(Some(KEYS)); + let (selection, store, asked, menu_for_key, list_weak) = ( + selection.clone(), + store.clone(), + asked.clone(), + menu.clone(), + list.downgrade(), + ); + keys.connect_key_pressed(move |_, key, _, modifiers| { + let modifiers = modifiers.intersection(gtk::accelerator_get_default_mod_mask()); + let Some(favorite) = favorite_at(&store, selection.selected()) else { + return glib::Propagation::Proceed; + }; + if (key == gtk::gdk::Key::Menu && modifiers.is_empty()) + || (key == gtk::gdk::Key::F10 && modifiers == gtk::gdk::ModifierType::SHIFT_MASK) + { + let Some(list) = list_weak.upgrade() else { + return glib::Propagation::Proceed; + }; + let bounds = find_row(&list, favorite.id).and_then(|row| row.compute_bounds(&list)); + let anchor = bounds.map(|bounds| { + gtk::gdk::Rectangle::new( + bounds.x() as i32, + bounds.y() as i32, + bounds.width() as i32, + bounds.height() as i32, + ) + }); + menu_for_key.set_menu_model(Some(&menu_of(favorite.id))); + menu_for_key.set_pointing_to(anchor.as_ref()); + menu_for_key.popup(); + return glib::Propagation::Stop; + } + if !modifiers.is_empty() { + return glib::Propagation::Proceed; + } + match key { + gtk::gdk::Key::F2 => asked(FavoriteAction::Rename(favorite)), + gtk::gdk::Key::Delete | gtk::gdk::Key::KP_Delete => asked(FavoriteAction::Delete(favorite)), + _ => return glib::Propagation::Proceed, + } + glib::Propagation::Stop + }); + list.add_controller(keys); +} + +fn menu_of(id: i64) -> gio::Menu { + let menu = gio::Menu::new(); + for (label, action) in [(gettext("_Rename…"), RENAME), (gettext("_Delete…"), DELETE)] { + let item = gio::MenuItem::new(Some(&label), None); + item.set_action_and_target_value(Some(&format!("favorite.{action}")), Some(&id.to_variant())); + menu.append_item(&item); + } + menu +} + +fn favorite_by_id(store: &gio::ListStore, id: i64) -> Option { + (0..store.n_items()) + .filter_map(|position| favorite_at(store, position)) + .find(|favorite| favorite.id == id) +} + +fn row_at(list: >k::ListView, store: &gio::ListStore, x: f64, y: f64) -> Option { + let mut widget = list.pick(x, y, gtk::PickFlags::DEFAULT); + while let Some(candidate) = widget { + if candidate.has_css_class(ROW) { + return candidate + .widget_name() + .parse() + .ok() + .and_then(|id| favorite_by_id(store, id)); + } + widget = candidate.parent(); + } + None +} + +fn find_row(widget: &impl IsA, id: i64) -> Option { + let widget = widget.as_ref(); + if widget.has_css_class(ROW) && widget.widget_name() == id.to_string() { + return Some(widget.clone()); + } + let mut child = widget.first_child(); + while let Some(current) = child { + if let Some(row) = find_row(¤t, id) { + return Some(row); + } + child = current.next_sibling(); + } + None +} + #[cfg(test)] mod tests { use super::*; @@ -267,4 +476,189 @@ mod tests { pane.no_connection(); assert_eq!(pane.stack.visible_child_name().as_deref(), Some("disconnected")); } + + type Actions = Rc>>; + const WAIT: std::time::Duration = std::time::Duration::from_secs(30); + + fn shown() -> (FavoritesPane, crate::test_support::OwnedWindow, Actions) { + adw::init().expect("libadwaita"); + let actions = Actions::default(); + let sink = actions.clone(); + let pane = FavoritesPane::new(move |action| sink.borrow_mut().push(action), || {}); + pane.show(vec![saved(1, "One"), saved(2, "Two")]); + let window = gtk::Window::builder() + .default_width(360) + .default_height(360) + .child(&pane.widget()) + .build(); + let window = crate::test_support::OwnedWindow::presented(window); + crate::test_support::wait_until(WAIT, || find_row(&list(&pane), 2).is_some_and(|row| row.height() > 0)) + .expect("rows laid out"); + (pane, window, actions) + } + + fn list(pane: &FavoritesPane) -> gtk::ListView { + pane.menu + .parent() + .and_downcast::() + .expect("menu belongs to list") + } + + fn press(pane: &FavoritesPane, key: gtk::gdk::Key, modifiers: gtk::gdk::ModifierType) -> bool { + let controllers = list(pane).observe_controllers(); + let keys = (0..controllers.n_items()) + .filter_map(|position| controllers.item(position).and_downcast::()) + .find(|keys| keys.name().as_deref() == Some(KEYS)) + .expect("favorite key handler"); + keys.emit_by_name::("key-pressed", &[&key, &0u32, &modifiers]) + } + + fn target(menu: &impl IsA, position: i32) -> glib::Variant { + menu.as_ref() + .item_attribute_value(position, "target", None) + .expect("menu target") + } + + fn requested(actions: &Actions) -> Vec<(&'static str, i64, String)> { + actions + .borrow() + .iter() + .filter_map(|action| match action { + FavoriteAction::Rename(saved) => Some(("rename", saved.id, saved.name.clone())), + FavoriteAction::Delete(saved) => Some(("delete", saved.id, saved.name.clone())), + FavoriteAction::Open(_) => None, + }) + .collect() + } + + #[gtk4::test] + fn a_favorite_has_a_named_menu_button_that_acts_on_its_row() { + let (pane, _window, actions) = shown(); + let row = find_row(&list(&pane), 2).expect("second row"); + let button = row + .last_child() + .and_downcast::() + .expect("row menu button"); + assert_eq!(crate::test_support::assert_labelled(&button), Ok(())); + assert_eq!(button.tooltip_text().as_deref(), Some("Options for “Two”")); + button.popup(); + assert!(button.popover().expect("row popover").is_visible()); + let menu = button.menu_model().expect("row menu"); + assert_eq!(menu.n_items(), 2); + crate::test_support::assert_access_keys(&menu); + let action = menu + .item_attribute_value(0, "action", None) + .and_then(|value| value.get::()) + .expect("rename action"); + button + .activate_action(&action, Some(&target(&menu, 0))) + .expect("rename from menu"); + assert_eq!(requested(&actions), [("rename", 2, "Two".to_owned())]); + } + + #[gtk4::test] + fn favorite_shortcuts_use_selection_and_ignore_modifiers() { + use gtk::gdk::{Key, ModifierType}; + let (pane, _window, actions) = shown(); + pane.selection.set_selected(1); + for modifier in [ + ModifierType::SHIFT_MASK, + ModifierType::CONTROL_MASK, + ModifierType::ALT_MASK, + ModifierType::SUPER_MASK, + ] { + for key in [Key::F2, Key::Delete, Key::KP_Delete] { + assert!(!press(&pane, key, modifier)); + } + } + assert!(actions.borrow().is_empty()); + assert!(press(&pane, Key::F2, ModifierType::empty())); + assert!(press(&pane, Key::Delete, ModifierType::empty())); + assert!(press(&pane, Key::KP_Delete, ModifierType::empty())); + assert_eq!( + requested(&actions), + [ + ("rename", 2, "Two".to_owned()), + ("delete", 2, "Two".to_owned()), + ("delete", 2, "Two".to_owned()), + ] + ); + pane.selection.set_selected(gtk::INVALID_LIST_POSITION); + assert!(!press(&pane, Key::F2, ModifierType::empty())); + } + + #[gtk4::test] + fn the_keyboard_opens_the_selected_favorites_context_menu() { + use gtk::gdk::{Key, ModifierType}; + let (pane, _window, actions) = shown(); + pane.selection.set_selected(1); + for (key, modifiers) in [(Key::F10, ModifierType::SHIFT_MASK), (Key::Menu, ModifierType::empty())] { + assert!(press(&pane, key, modifiers)); + assert!(pane.menu.is_visible()); + let model = pane.menu.menu_model().expect("context menu"); + let target = target(&model, 1); + assert_eq!(target.get::(), Some(2)); + pane.menu.popdown(); + } + assert!(actions.borrow().is_empty()); + assert!(!press( + &pane, + Key::F10, + ModifierType::CONTROL_MASK | ModifierType::SHIFT_MASK + )); + } + + #[gtk4::test] + fn a_secondary_click_targets_the_clicked_favorite() { + let (pane, _window, actions) = shown(); + let list = list(&pane); + pane.selection.set_selected(0); + let row = find_row(&list, 2).expect("second row"); + let bounds = row.compute_bounds(&list).expect("row bounds"); + let controllers = list.observe_controllers(); + let click = (0..controllers.n_items()) + .filter_map(|position| controllers.item(position).and_downcast::()) + .find(|click| click.button() == gtk::gdk::BUTTON_SECONDARY) + .expect("secondary click"); + click.emit_by_name::<()>( + "pressed", + &[&1i32, &f64::from(bounds.x() + 4.0), &f64::from(bounds.y() + 4.0)], + ); + assert!(pane.menu.is_visible()); + let model = pane.menu.menu_model().expect("context menu"); + list.activate_action("favorite.delete", Some(&target(&model, 1))) + .expect("delete"); + assert_eq!(requested(&actions), [("delete", 2, "Two".to_owned())]); + } + + #[gtk4::test] + fn reordered_menu_targets_keep_their_id_and_removed_targets_do_nothing() { + let (pane, _window, actions) = shown(); + let list = list(&pane); + let previous = target(&menu_of(2), 0); + pane.selection.set_selected(1); + pane.show(vec![saved(2, "Renamed"), saved(1, "One")]); + list.activate_action("favorite.rename", Some(&previous)) + .expect("old action routed"); + assert_eq!(requested(&actions), [("rename", 2, "Renamed".to_owned())]); + assert!(press(&pane, gtk::gdk::Key::F2, gtk::gdk::ModifierType::empty())); + assert_eq!( + requested(&actions), + [("rename", 2, "Renamed".to_owned()), ("rename", 2, "Renamed".to_owned()),] + ); + let before_switch = target(&menu_of(2), 1); + pane.clear(); + list.activate_action("favorite.delete", Some(&before_switch)) + .expect("stale target routed"); + assert_eq!(actions.borrow().len(), 2); + pane.show(vec![saved(3, "Different connection")]); + list.activate_action("favorite.delete", Some(&before_switch)) + .expect("stale target routed"); + assert_eq!(actions.borrow().len(), 2); + let current = target(&menu_of(3), 1); + pane.show(vec![]); + list.activate_action("favorite.delete", Some(¤t)) + .expect("removed target routed"); + assert_eq!(actions.borrow().len(), 2); + } } diff --git a/linux/crates/app/src/ui/workspace/sidebar/mod.rs b/linux/crates/app/src/ui/workspace/sidebar/mod.rs index 92964f54ab..03bdd795c7 100644 --- a/linux/crates/app/src/ui/workspace/sidebar/mod.rs +++ b/linux/crates/app/src/ui/workspace/sidebar/mod.rs @@ -36,7 +36,7 @@ use tablepro_session::{ObjectListSnapshot, Session}; pub(super) use catalog_watch::{catalog_watch, reconnect_watch, spawn_local}; pub(crate) use connection_tree::{ConnectionTree, SessionRowState}; -pub(crate) use favorites_pane::FavoritesPane; +pub(crate) use favorites_pane::{FavoriteAction, FavoritesPane}; pub(crate) use key_listing::{KeySidebar, KeysListed}; pub(super) use sidebar_affordances::SidebarAffordances; use sidebar_index::SidebarIndex; diff --git a/linux/crates/app/src/ui/workspace/status_pages.rs b/linux/crates/app/src/ui/workspace/status_pages.rs index 86cc7fc4d5..54726a264f 100644 --- a/linux/crates/app/src/ui/workspace/status_pages.rs +++ b/linux/crates/app/src/ui/workspace/status_pages.rs @@ -355,6 +355,32 @@ mod tests { wait_until(WAIT, || favorites.names() == ["File query"]).expect("file query listed after reopen"); } + #[gtk4::test] + fn a_favorite_is_renamed_and_deleted_from_the_list() { + use gtk4::subclass::prelude::ObjectSubclassIsExt; + + let test = TestWindow::connected("FavoritesChange"); + let availability = test.services.history().availability(); + wait_until(WAIT, || availability.borrow().is_ready()).expect("the query database to open"); + let shell = test.window.shell().expect("the shell"); + let favorites = shell.imp().favorites.get().cloned().expect("the favorites pane"); + shell.imp().scope_toggle.set_active_name(Some("favorites")); + test.workspace() + .with_model(|model| model.on_save_query_named("Orders".to_owned(), "SELECT 1".to_owned())); + wait_until(WAIT, || favorites.names() == ["Orders"]).expect("the saved query to be listed"); + let id = favorites.ids()[0]; + wait_until(WAIT, || test.hold.live() == 0).expect("save complete"); + + shell.rename_favorite(id, "Weekly orders".to_owned()); + assert_eq!(test.hold.live(), 1); + wait_until(WAIT, || favorites.names() == ["Weekly orders"]).expect("the new name to be listed"); + + wait_until(WAIT, || test.hold.live() == 0).expect("rename complete"); + shell.delete_favorite(id); + assert_eq!(test.hold.live(), 1); + wait_until(WAIT, || favorites.names().is_empty()).expect("the favorite to go"); + } + #[gtk4::test] fn a_history_dialog_closed_by_hand_is_not_closed_again_on_disconnect() { use gtk4::glib; diff --git a/linux/crates/app/src/ui/workspace/workspace_shell.rs b/linux/crates/app/src/ui/workspace/workspace_shell.rs index 0909c2ac0c..329b375b39 100644 --- a/linux/crates/app/src/ui/workspace/workspace_shell.rs +++ b/linux/crates/app/src/ui/workspace/workspace_shell.rs @@ -9,8 +9,10 @@ use gtk4::glib; use gtk4::prelude::*; use gtk4::subclass::prelude::*; use libadwaita as adw; -use libadwaita::prelude::BinExt; +use libadwaita::prelude::{AdwDialogExt, AlertDialogExt, BinExt, PreferencesGroupExt}; use tablepro_core::DataModel; +use tablepro_storage::SavedQueries; +use tablepro_storage::saved_queries::SavedQuery; use uuid::Uuid; use super::health_banner::REVIEW_HOST_KEY; @@ -105,7 +107,7 @@ impl WorkspaceShell { glib::clone!( #[weak] shell, - move |sql| shell.open_favorite(sql) + move |action| shell.on_favorite_action(action) ), glib::clone!( #[weak] @@ -118,6 +120,7 @@ impl WorkspaceShell { let _ = imp.sidebar_stack.set(sidebar); let _ = imp.favorites.set(favorites); let _ = imp.favorites_source.set((services.history(), services.tasks.clone())); + let _ = imp.favorites_hold.set(services.hold()); imp.favorites_availability .replace(Some(tablepro_session::runtime::WatchForwarder::new( services.history().availability(), @@ -679,12 +682,124 @@ impl WorkspaceShell { } } - fn open_favorite(&self, sql: String) { - if let Some(sender) = self.front().and_then(|front| front.sender()) { - sender.deliver(super::WorkspaceInput::OpenHistoryQuery(sql)); + pub(super) fn on_favorite_action(&self, action: super::sidebar::FavoriteAction) { + use super::sidebar::FavoriteAction; + match action { + FavoriteAction::Open(sql) => { + if let Some(sender) = self.front().and_then(|front| front.sender()) { + sender.deliver(super::WorkspaceInput::OpenHistoryQuery(sql)); + } + } + FavoriteAction::Rename(favorite) => self.ask_favorite_name(favorite), + FavoriteAction::Delete(favorite) => self.ask_favorite_deletion(favorite), } } + fn ask_favorite_name(&self, favorite: SavedQuery) { + let dialog = adw::AlertDialog::new(Some(&gettext("Rename Favorite")), None); + let entry = adw::EntryRow::builder() + .title(gettext("Name")) + .activates_default(true) + .build(); + entry.set_text(&favorite.name); + let group = adw::PreferencesGroup::new(); + group.add(&entry); + dialog.set_extra_child(Some(&group)); + dialog.add_response("cancel", &gettext("Cancel")); + dialog.add_response("rename", &gettext("Rename")); + dialog.set_response_appearance("rename", adw::ResponseAppearance::Suggested); + dialog.set_default_response(Some("rename")); + dialog.set_close_response("cancel"); + crate::ui::name_entry::require_name(&dialog, "rename", &entry); + dialog.set_focus(Some(&entry)); + let shell = self.downgrade(); + dialog.connect_response(None, move |_, response| { + let name = entry.text().trim().to_owned(); + if let (true, Some(shell)) = ( + response == "rename" && !name.is_empty() && name != favorite.name, + shell.upgrade(), + ) { + shell.rename_favorite(favorite.id, name); + } + }); + dialog.present(self.imp().window.upgrade().as_ref()); + } + + fn ask_favorite_deletion(&self, favorite: SavedQuery) { + let dialog = adw::AlertDialog::new( + Some(&gettext_f("Delete “{name}”?", &[("name", &favorite.name)])), + Some(&gettext("The saved query is deleted. This cannot be undone.")), + ); + dialog.add_response("cancel", &gettext("Cancel")); + dialog.add_response("delete", &gettext("Delete")); + dialog.set_response_appearance("delete", adw::ResponseAppearance::Destructive); + dialog.set_default_response(Some("cancel")); + dialog.set_close_response("cancel"); + let shell = self.downgrade(); + dialog.connect_response(None, move |_, response| { + if let (true, Some(shell)) = (response == "delete", shell.upgrade()) { + shell.delete_favorite(favorite.id); + } + }); + dialog.present(self.imp().window.upgrade().as_ref()); + } + + pub(crate) fn rename_favorite(&self, id: i64, name: String) { + self.change_favorites( + async move |store| store.rename(id, &name).await, + gettext("Could not rename that saved query."), + ); + } + + pub(crate) fn delete_favorite(&self, id: i64) { + self.change_favorites( + async move |store| store.delete(id).await, + gettext("Could not delete that saved query."), + ); + } + + fn change_favorites(&self, change: impl FnOnce(SavedQueries) -> W + Send + 'static, failure: String) + where + W: std::future::Future> + Send + 'static, + { + let imp = self.imp(); + let Some((history, tasks)) = imp.favorites_source.get() else { + return; + }; + let Some(hold) = imp.favorites_hold.get() else { + return; + }; + let ready = history.ready_store(); + let (send, received) = tokio::sync::oneshot::channel(); + crate::runtime::spawn_held(tasks, hold.as_ref(), async move { + let result = match ready.await { + Some(history) => change(history.saved_queries()).await, + None => Err(tablepro_storage::StorageError::NotInitialised), + }; + let _ = send.send(result); + }); + let shell = self.downgrade(); + glib::spawn_future_local(async move { + let result = received.await; + let Some(shell) = shell.upgrade() else { + return; + }; + let message = match result { + Ok(Ok(())) => return, + Ok(Err(error)) => { + tracing::warn!(%error, "could not change a favorite"); + favorite_failure_text(&error, &failure) + } + Err(error) => { + tracing::warn!(%error, "favorite change did not finish"); + failure + } + }; + shell.toast_overlay().add_toast(crate::ui::plain_toast(&message)); + shell.reload_favorites(); + }); + } + fn on_front_changed(&self) { let imp = self.imp(); if let Some(front) = self.front() { @@ -863,6 +978,18 @@ impl WorkspaceShell { } } +fn favorite_failure_text(error: &tablepro_storage::StorageError, fallback: &str) -> String { + use tablepro_storage::StorageError; + match error { + StorageError::NameTaken => gettext("That name is already used by another saved query."), + StorageError::TooLarge { .. } => gettext("That name is too long."), + StorageError::EmptyName => gettext("Enter a name for the saved query."), + StorageError::NotFound => gettext("That saved query was deleted elsewhere."), + StorageError::NotInitialised => gettext("Saved queries are unavailable. Restart TablePro to try again."), + _ => fallback.to_owned(), + } +} + /// Whether `child` is one of `stack`'s pages: GTK logs a critical for a /// stack asked to show or drop a widget it does not hold. fn holds_child(stack: >k::Stack, child: &impl IsA) -> bool { @@ -940,6 +1067,136 @@ mod tests { use crate::config::RESOURCE_BASE_PATH; use crate::test_support::assert_access_keys; + fn saved_favorite(test: &crate::ui::session_window::tests::TestWindow, name: &str) -> SavedQuery { + use crate::test_support::{finish_on_main, wait_until}; + use crate::ui::session_window::tests::WAIT; + let availability = test.services.history().availability(); + wait_until(WAIT, || availability.borrow().is_ready()).expect("history ready"); + test.workspace() + .with_model(|model| model.on_save_query_named(name.to_owned(), "SELECT 1".to_owned())); + wait_until(WAIT, || test.hold.live() == 0).expect("save complete"); + let store = test.services.history().store().expect("history").saved_queries(); + let name = name.to_owned(); + let reading = test.services.tasks.spawn_task(async move { + store + .list(None) + .await + .expect("list") + .into_iter() + .find(|query| query.name == name) + }); + finish_on_main(WAIT, reading) + .expect("read complete") + .expect("task") + .expect("query") + } + + #[gtk4::test] + fn a_favorite_write_finishes_after_its_window_closes() { + use crate::test_support::{finish_on_main, wait_until}; + use crate::ui::session_window::tests::{TestWindow, WAIT}; + let test = TestWindow::connected("FavoriteWriteClosed"); + let favorite = saved_favorite(&test, "Before"); + let shell = test.window.shell().expect("shell"); + let (release, released) = tokio::sync::oneshot::channel(); + let id = favorite.id; + shell.change_favorites( + move |store| async move { + released.await.expect("release write"); + store.rename(id, "After close").await + }, + "Rename failed".to_owned(), + ); + assert_eq!(test.hold.live(), 1); + let write_hold = test.hold_tokens.borrow().last().expect("rename hold").clone(); + test.window.close(); + wait_until(WAIT, || !test.window.is_visible()).expect("window closed"); + assert!( + write_hold.upgrade().is_some(), + "closing the window released the rename's hold" + ); + release.send(()).expect("write still running"); + wait_until(WAIT, || write_hold.upgrade().is_none()).expect("rename hold released"); + wait_until(WAIT, || test.hold.live() == 0).expect("write complete"); + let store = test.services.history().store().expect("history").saved_queries(); + let reading = test.services.tasks.spawn_task(async move { store.get(id).await }); + let saved = finish_on_main(WAIT, reading) + .expect("read complete") + .expect("task") + .expect("get") + .expect("saved query"); + assert_eq!(saved.name, "After close"); + assert_eq!(saved.query, favorite.query); + assert_eq!(saved.connection_id, favorite.connection_id); + assert_eq!(saved.created_at, favorite.created_at); + } + + #[gtk4::test] + fn favorite_rename_rejects_blank_names_and_reports_collisions() { + use crate::test_support::{descendants, wait_until}; + use crate::ui::session_window::tests::{TestWindow, WAIT}; + use crate::workspace::{answer, visible_alert}; + let test = TestWindow::connected("FavoriteRenameErrors"); + let favorite = saved_favorite(&test, "Orders"); + saved_favorite(&test, "Taken"); + let shell = test.window.shell().expect("shell"); + shell.ask_favorite_name(favorite.clone()); + let dialog = visible_alert(&test.window).expect("rename prompt"); + let entry = descendants(&dialog) + .into_iter() + .find_map(|widget| widget.downcast::().ok()) + .expect("name entry"); + assert_eq!(entry.text(), "Orders"); + entry.set_text(" "); + assert!(!dialog.is_response_enabled("rename")); + answer(&test.window, "cancel"); + wait_until(WAIT, || visible_alert(&test.window).is_none()).expect("cancelled"); + shell.rename_favorite(favorite.id, "Taken".to_owned()); + assert_eq!(test.hold.live(), 1); + wait_until(WAIT, || { + descendants(&shell.toast_overlay()) + .iter() + .filter_map(|widget| widget.downcast_ref::()) + .any(|label| label.label() == "That name is already used by another saved query.") + }) + .expect("name conflict explained"); + wait_until(WAIT, || test.hold.live() == 0).expect("hold ended after failure"); + } + + #[gtk4::test] + fn favorite_deletion_requires_confirmation_and_holds_the_write() { + use crate::test_support::{finish_on_main, wait_until}; + use crate::ui::session_window::tests::{TestWindow, WAIT}; + use crate::workspace::{answer, visible_alert}; + let test = TestWindow::connected("FavoriteDeleteConfirmed"); + let favorite = saved_favorite(&test, "Orders"); + let shell = test.window.shell().expect("shell"); + let read = || { + let store = test.services.history().store().expect("history").saved_queries(); + let id = favorite.id; + let reading = test.services.tasks.spawn_task(async move { store.get(id).await }); + finish_on_main(WAIT, reading) + .expect("read complete") + .expect("task") + .expect("get") + }; + shell.ask_favorite_deletion(favorite.clone()); + let dialog = visible_alert(&test.window).expect("delete prompt"); + assert_eq!(dialog.default_response().as_deref(), Some("cancel")); + assert_eq!( + dialog.response_appearance("delete"), + adw::ResponseAppearance::Destructive + ); + answer(&test.window, "cancel"); + wait_until(WAIT, || visible_alert(&test.window).is_none()).expect("cancelled"); + assert!(read().is_some()); + shell.ask_favorite_deletion(favorite.clone()); + answer(&test.window, "delete"); + assert_eq!(test.hold.live(), 1); + wait_until(WAIT, || test.hold.live() == 0).expect("delete complete"); + assert!(read().is_none()); + } + #[gtk4::test] fn favorites_reject_old_reads_and_clear_rows_when_the_front_changes() { use crate::ui::session_window::tests::TestWindow; diff --git a/linux/crates/app/src/ui/workspace/workspace_shell_imp.rs b/linux/crates/app/src/ui/workspace/workspace_shell_imp.rs index eb34817a08..62cee3b795 100644 --- a/linux/crates/app/src/ui/workspace/workspace_shell_imp.rs +++ b/linux/crates/app/src/ui/workspace/workspace_shell_imp.rs @@ -124,6 +124,7 @@ pub struct WorkspaceShell { crate::services::history_service::HistoryService, tablepro_session::runtime::Tasks, )>, + pub(super) favorites_hold: OnceCell>, pub(super) favorites_generation: Cell, pub(super) favorites_connection: Cell>, pub(super) favorites_watch: RefCell>,