diff --git a/linux/changelog.d/4121.added.md b/linux/changelog.d/4121.added.md new file mode 100644 index 0000000000..e323646d23 --- /dev/null +++ b/linux/changelog.d/4121.added.md @@ -0,0 +1 @@ +Open Quickly (Ctrl+Shift+O) finds tables and views across the connection’s schemas. diff --git a/linux/changelog.d/4133.added.md b/linux/changelog.d/4133.added.md new file mode 100644 index 0000000000..9abf596c23 --- /dev/null +++ b/linux/changelog.d/4133.added.md @@ -0,0 +1 @@ +Open Quickly finds saved queries by name and opens them in a new editor tab. diff --git a/linux/crates/app/src/application/accelerators.rs b/linux/crates/app/src/application/accelerators.rs index 938aa7d5b7..931064d13b 100644 --- a/linux/crates/app/src/application/accelerators.rs +++ b/linux/crates/app/src/application/accelerators.rs @@ -8,8 +8,8 @@ use AcceleratorScope::{Application, Component, Local, Stock}; use ShortcutListing::{Listed, Unlisted}; use ShortcutOwner::{ AssistantComposer, BrowseTab, CellEditor, ConnectionTree, DiagramCanvas, DiagramTab, EditorResults, FilterStrip, - Grid, GridCell, HistoryRow, InlineSuggestion, PickerPage, PickerRow, SqlEditor, SqlEditorCursors, SqlEditorTab, - StructureTab, WorkspaceShell, + Grid, GridCell, HistoryRow, InlineSuggestion, PickerPage, PickerRow, QuickOpen, SqlEditor, SqlEditorCursors, + SqlEditorTab, StructureTab, WorkspaceShell, }; use ShortcutSection::{BrowseTable, DataGrid, ErDiagram, General, TableStructure, Tabs}; @@ -73,6 +73,11 @@ pub const ACCELERATORS: &[Accelerator] = &[ application("app.new-window", &["n"], General), application("app.preferences", &["comma"], General), application("win.show-history", &["h"], General), + // Matches Open Quickly in the macOS app. + application("win.quick-open", &["o"], General), + component(QuickOpen, "quick-open.next", &["Down"], Unlisted), + component(QuickOpen, "quick-open.previous", &["Up"], Unlisted), + component(QuickOpen, "quick-open.structure", &["Return"], Unlisted), // As in GIMP and Inkscape. application("win.export-results", &["e"], General), // As in GNOME Files. @@ -88,8 +93,7 @@ pub const ACCELERATORS: &[Accelerator] = &[ application("win.reopen-closed-tab", &["t"], Tabs), // Ctrl+Tab stays the tab view's next tab, as across GNOME. application("win.switch-recent-tab", &["e"], Tabs), - // As in GNOME Web and Console. - application("win.show-tabs", &["o"], Tabs), + application("win.show-tabs", &["o"], Tabs), // AdwTabView's own controller, which runs in the capture phase. The // workspace removes its Ctrl+Home and Ctrl+End pairs, so the lists // and the editor inside the tabs keep those keys. @@ -563,6 +567,7 @@ pub fn local_shortcut_controller(owner: ShortcutOwner) -> gtk::ShortcutControlle /// The name `local_shortcut_controller` gives the owner's controller. pub const fn controller_name(owner: ShortcutOwner) -> &'static str { match owner { + QuickOpen => "tablepro-quick-open-shortcuts", WorkspaceShell => "tablepro-workspace-shell-shortcuts", BrowseTab => "tablepro-browse-tab-shortcuts", GridCell => "tablepro-grid-cell-shortcuts", diff --git a/linux/crates/app/src/application/shortcut_owner.rs b/linux/crates/app/src/application/shortcut_owner.rs index de8aeb5095..6d0d25471f 100644 --- a/linux/crates/app/src/application/shortcut_owner.rs +++ b/linux/crates/app/src/application/shortcut_owner.rs @@ -2,6 +2,7 @@ pub enum ShortcutOwner { WorkspaceShell, BrowseTab, + QuickOpen, /// A data grid's column view, ahead of the list's own key bindings. GridCell, /// A data grid's column view, after a focused editor had its turn. diff --git a/linux/crates/app/src/ui/mod.rs b/linux/crates/app/src/ui/mod.rs index 0d756a2ade..3bcf337369 100644 --- a/linux/crates/app/src/ui/mod.rs +++ b/linux/crates/app/src/ui/mod.rs @@ -40,6 +40,7 @@ mod name_entry; mod picker; mod plain_toast; mod preferences_dialog; +mod quick_open; mod result_pane; pub(crate) mod safe_mode; mod saved_queries_dialog; diff --git a/linux/crates/app/src/ui/quick_open/matching.rs b/linux/crates/app/src/ui/quick_open/matching.rs new file mode 100644 index 0000000000..db7a289083 --- /dev/null +++ b/linux/crates/app/src/ui/quick_open/matching.rs @@ -0,0 +1,75 @@ +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] +pub(super) struct Rank(u8, usize); + +pub(super) fn normalize(text: &str) -> Vec { + text.chars().flat_map(char::to_lowercase).collect() +} + +pub(super) fn rank(typed: &[char], name: &[char]) -> Option { + if typed.is_empty() || name.starts_with(typed) { + return Some(Rank(0, 0)); + } + if let Some(at) = name.windows(typed.len()).position(|window| window == typed) { + return Some(Rank(1, at)); + } + // A qualified name must not pick up letters from a different identifier. + if typed.contains(&'.') { + return None; + } + let mut wanted = typed.iter(); + let mut next = wanted.next(); + let mut first = None; + for (position, letter) in name.iter().enumerate() { + if next == Some(letter) { + first.get_or_insert(position); + next = wanted.next(); + if next.is_none() { + return Some(Rank(2, position - first.unwrap_or(position) + 1 - typed.len())); + } + } + } + None +} + +#[cfg(test)] +mod tests { + use super::*; + + fn score(typed: &str, name: &str) -> Option { + rank(&normalize(typed.trim()), &normalize(name)) + } + + #[test] + fn classes_never_overlap_even_for_long_names() { + let prefix = score("ab", "ab").unwrap(); + let inside = score("ab", &format!("{}ab", "x".repeat(2_000))).unwrap(); + let scattered = score("ab", "axb").unwrap(); + assert!(prefix < inside && inside < scattered); + } + + #[test] + fn whitespace_case_unicode_and_order() { + assert_eq!(score(" ", "orders"), Some(Rank(0, 0))); + assert_eq!(score(" ÉT ", "Études"), Some(Rank(0, 0))); + assert_eq!(score("ods", "orders"), Some(Rank(2, 3))); + assert_eq!(score("sro", "orders"), None); + assert_eq!(score("longer", "a"), None); + assert_eq!(score("x", ""), None); + } + + #[test] + fn dotted_searches_keep_the_identifier_contiguous() { + assert_eq!(score("sales.orders", "sales.orders"), Some(Rank(0, 0))); + assert_eq!(score("sales.ord", "sales.orders"), Some(Rank(0, 0))); + assert!(score("sales.orders", "SELECT * FROM sales.orders").is_some()); + assert_eq!(score("sales.orders", "sales.order_items"), None); + assert_eq!(score("sales.orders", "sales_archive.orders"), None); + assert!(score("ods", "orders").is_some()); + } + + #[test] + fn nearer_substrings_and_tighter_subsequences_rank_first() { + assert!(score("ar", "bar").unwrap() < score("ar", "xxbar").unwrap()); + assert!(score("ab", "axb").unwrap() < score("ab", "axxxb").unwrap()); + } +} diff --git a/linux/crates/app/src/ui/quick_open/mod.rs b/linux/crates/app/src/ui/quick_open/mod.rs new file mode 100644 index 0000000000..10c3525f12 --- /dev/null +++ b/linux/crates/app/src/ui/quick_open/mod.rs @@ -0,0 +1,736 @@ +mod matching; +mod query_source; +#[cfg(test)] +#[path = "tests/queries.rs"] +mod query_tests; +mod search_index; +#[cfg(test)] +mod tests; + +use std::cell::{Cell, OnceCell, RefCell}; +use std::rc::Rc; +use std::sync::Arc; + +use gtk4 as gtk; +use gtk4::prelude::*; +use gtk4::subclass::prelude::ObjectSubclassIsExt; +use gtk4::{gdk, gio, glib}; +use libadwaita as adw; +use libadwaita::prelude::*; +use tablepro_core::meta::{ObjectInfo, ObjectKind, ObjectScope, TableRef}; +use tablepro_session::runtime::{Tasks, WatchForwarder}; +use tablepro_session::{ObjectListSnapshot, Session}; + +use crate::i18n::{gettext, gettext_f}; +use crate::runtime::{RequestSequencer, spawn_and_deliver}; +use crate::ui::handler_guard::HandlerGuard; +use crate::ui::icons; +use query_source::QuerySource; +use search_index::{Candidate, SearchIndex}; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub(crate) enum Pick { + Table { table: TableRef, structure: bool }, + Query(String), +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +enum Request { + Index, + Search, + Queries, + Pick, +} + +struct Context { + session: Arc, + tasks: Tasks, + chosen: Rc, +} + +struct Widgets { + entry: gtk::SearchEntry, + store: gio::ListStore, + selection: gtk::SingleSelection, + list: gtk::ListView, + stack: gtk::Stack, + status: adw::StatusPage, + banner: adw::Banner, +} + +glib::wrapper! { + pub struct QuickOpen(ObjectSubclass) + @extends adw::Dialog, gtk::Widget, + @implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget; +} + +mod imp { + use super::*; + use gtk4::subclass::prelude::*; + use libadwaita::subclass::prelude::*; + + #[derive(Default)] + pub struct QuickOpen { + pub(super) widgets: OnceCell, + pub(super) context: RefCell>, + pub(super) watches: RefCell>, + pub(super) requests: RefCell>, + pub(super) index: RefCell>, + pub(super) indexed: Cell, + pub(super) objects: RefCell>, + pub(super) queries: RefCell>, + pub(super) catalog_error: Cell, + pub(super) generation: Cell>, + pub(super) rendered: RefCell>, + pub(super) pending_pick: Cell>, + pub(super) pending_steps: RefCell>, + pub(super) scroll_layout: RefCell>, + } + + #[glib::object_subclass] + impl ObjectSubclass for QuickOpen { + const NAME: &'static str = "TableProQuickOpen"; + type Type = super::QuickOpen; + type ParentType = adw::Dialog; + } + + impl ObjectImpl for QuickOpen { + fn dispose(&self) { + self.obj().stop(); + } + } + impl WidgetImpl for QuickOpen {} + impl AdwDialogImpl for QuickOpen {} +} + +impl QuickOpen { + pub(crate) fn new(session: Arc, tasks: Tasks, chosen: impl Fn(Pick) + 'static) -> Self { + let dialog: Self = glib::Object::new(); + dialog.set_title(&gettext("Open Quickly")); + dialog.set_content_width(520); + dialog.set_content_height(440); + dialog.build(); + dialog.imp().context.replace(Some(Context { + session: session.clone(), + tasks, + chosen: Rc::new(chosen), + })); + dialog.connect_closed(|dialog| dialog.stop()); + let weak = dialog.downgrade(); + let catalog = WatchForwarder::new( + session.subscribe_objects(ObjectScope::AllSchemas), + move |snapshot| { + if let Some(dialog) = weak.upgrade() { + dialog.catalog_changed(snapshot); + } + }, + spawn_local, + ); + let weak = dialog.downgrade(); + let mut link = *session.link_changes().borrow(); + let reconnect = WatchForwarder::new( + session.link_changes(), + move |generation| { + if generation != link { + link = generation; + if let Some(dialog) = weak.upgrade() { + dialog.load(false); + } + } + }, + spawn_local, + ); + dialog.imp().watches.replace(vec![catalog, reconnect]); + dialog.load(false); + dialog + } + + fn build(&self) { + let store = gio::ListStore::new::(); + let selection = gtk::SingleSelection::new(Some(store.clone())); + let list = gtk::ListView::new(Some(selection.clone()), Some(factory())); + list.add_css_class("navigation-sidebar"); + list.set_single_click_activate(true); + list.update_property(&[gtk::accessible::Property::Label(&gettext("Tables and views"))]); + let scrolled = gtk::ScrolledWindow::builder() + .hscrollbar_policy(gtk::PolicyType::Never) + .vexpand(true) + .child(&list) + .build(); + let status = adw::StatusPage::builder() + .title(gettext("Loading Tables and Views")) + .build(); + status.add_css_class("compact"); + let stack = gtk::Stack::new(); + stack.set_vexpand(true); + stack.add_named(&scrolled, Some("list")); + stack.add_named(&status, Some("status")); + stack.set_visible_child_name("status"); + let entry = gtk::SearchEntry::builder() + .placeholder_text(gettext("Search tables and views")) + .hexpand(true) + .margin_top(12) + .margin_bottom(6) + .margin_start(12) + .margin_end(12) + .build(); + entry.update_property(&[gtk::accessible::Property::Label(&gettext("Search tables and views"))]); + let banner = adw::Banner::builder() + .title(gettext("Could not load tables and views.")) + .button_label(gettext("Retry")) + .revealed(false) + .build(); + let body = gtk::Box::new(gtk::Orientation::Vertical, 0); + body.append(&entry); + body.append(&banner); + body.append(&stack); + let view = adw::ToolbarView::new(); + view.add_top_bar(&adw::HeaderBar::new()); + view.set_content(Some(&body)); + self.set_child(Some(&view)); + self.set_focus(Some(&entry)); + self.connect_controls(&entry, &list, &banner, &view); + self.connect_scroll_layout(&list); + let _ = self.imp().widgets.set(Widgets { + entry, + store, + selection, + list, + stack, + status, + banner, + }); + } + + fn connect_controls( + &self, + entry: >k::SearchEntry, + list: >k::ListView, + banner: &adw::Banner, + view: &adw::ToolbarView, + ) { + entry.connect_changed(glib::clone!( + #[weak(rename_to=dialog)] + self, + move |_| { + dialog.imp().pending_pick.set(None); + dialog.imp().pending_steps.borrow_mut().clear(); + dialog.imp().requests.borrow_mut().cancel(Request::Search); + dialog.imp().requests.borrow_mut().cancel(Request::Pick); + } + )); + entry.connect_search_changed(glib::clone!( + #[weak(rename_to=dialog)] + self, + move |_| dialog.search() + )); + entry.connect_activate(glib::clone!( + #[weak(rename_to=dialog)] + self, + move |_| dialog.activate(false) + )); + entry.connect_stop_search(glib::clone!( + #[weak(rename_to=dialog)] + self, + move |_| dialog.dismiss() + )); + entry.connect_next_match(glib::clone!( + #[weak(rename_to=dialog)] + self, + move |_| dialog.step(1) + )); + entry.connect_previous_match(glib::clone!( + #[weak(rename_to=dialog)] + self, + move |_| dialog.step(-1) + )); + list.connect_activate(glib::clone!( + #[weak(rename_to=dialog)] + self, + move |_, position| { + if !dialog.current() { + dialog.search(); + return; + } + if let Some(widgets) = dialog.imp().widgets.get() { + widgets.selection.set_selected(position); + } + dialog.activate(false); + } + )); + banner.connect_button_clicked(glib::clone!( + #[weak(rename_to=dialog)] + self, + move |_| dialog.load(true) + )); + let keys = gtk::EventControllerKey::new(); + keys.set_propagation_phase(gtk::PropagationPhase::Capture); + keys.connect_key_pressed(glib::clone!( + #[weak(rename_to=dialog)] + self, + #[upgrade_or] + glib::Propagation::Proceed, + move |_, key, _, modifiers| dialog.key(key, modifiers) + )); + view.add_controller(keys); + } + + fn connect_scroll_layout(&self, list: >k::ListView) { + list.connect_map(glib::clone!( + #[weak(rename_to=dialog)] + self, + move |_| dialog.scroll_selection_after_layout() + )); + list.connect_unmap(glib::clone!( + #[weak(rename_to=dialog)] + self, + move |_| { + dialog.imp().scroll_layout.borrow_mut().take(); + } + )); + } + + fn scroll_selection_after_layout(&self) { + let imp = self.imp(); + if imp.context.borrow().is_none() || imp.scroll_layout.borrow().is_some() { + return; + } + let Some(widgets) = imp.widgets.get().filter(|widgets| widgets.list.is_mapped()) else { + return; + }; + let Some(surface) = widgets.list.native().and_then(|native| native.surface()) else { + return; + }; + // GtkNative's earlier layout handler allocates rows before scrolling reads their geometry. + let handler = surface.connect_layout(glib::clone!( + #[weak(rename_to=dialog)] + self, + move |_, _, _| dialog.scroll_allocated_selection() + )); + imp.scroll_layout.replace(Some(HandlerGuard::new(&surface, handler))); + widgets.list.queue_allocate(); + surface.request_layout(); + } + + fn scroll_allocated_selection(&self) { + let imp = self.imp(); + let Some(widgets) = imp.widgets.get() else { + return; + }; + if imp.context.borrow().is_none() || !widgets.list.is_mapped() || !self.current() { + imp.scroll_layout.borrow_mut().take(); + return; + } + let allocated = widgets + .list + .hadjustment() + .is_some_and(|adjustment| adjustment.page_size() > 0.0) + && widgets + .list + .vadjustment() + .is_some_and(|adjustment| adjustment.page_size() > 0.0); + if !allocated { + return; + } + imp.scroll_layout.borrow_mut().take(); + let selected = widgets.selection.selected(); + if selected < widgets.store.n_items() { + widgets.list.scroll_to(selected, gtk::ListScrollFlags::NONE, None); + } + } + + fn key(&self, key: gdk::Key, modifiers: gdk::ModifierType) -> glib::Propagation { + let matches = |action| crate::application::component_matches(action, key, modifiers); + if matches("quick-open.structure") { + self.activate(true); + } else if self.entry_has_focus() && matches("quick-open.next") { + self.step(1); + } else if self.entry_has_focus() && matches("quick-open.previous") { + self.step(-1); + } else { + return glib::Propagation::Proceed; + } + glib::Propagation::Stop + } + + fn entry_has_focus(&self) -> bool { + self.imp().widgets.get().is_some_and(|w| { + self.focus() + .is_some_and(|focus| focus == w.entry || focus.is_ancestor(&w.entry)) + }) + } + + pub(crate) fn dismiss(&self) { + self.stop(); + if self.parent().is_some() { + self.close(); + } + } + + fn stop(&self) { + self.imp().scroll_layout.borrow_mut().take(); + self.imp().context.borrow_mut().take(); + self.imp().queries.borrow_mut().take(); + self.imp().watches.borrow_mut().clear(); + self.imp().requests.borrow_mut().cancel_all(); + self.imp().pending_pick.set(None); + self.imp().pending_steps.borrow_mut().clear(); + } + + fn load(&self, refresh: bool) { + let Some((session, tasks)) = self + .imp() + .context + .borrow() + .as_ref() + .map(|context| (context.session.clone(), context.tasks.clone())) + else { + return; + }; + if refresh { + self.imp().generation.set(None); + self.load_queries(); + } + let weak = self.downgrade(); + spawn_and_deliver( + &tasks, + async move { + if refresh { + session.refresh_objects(ObjectScope::AllSchemas).await + } else { + session.objects(ObjectScope::AllSchemas).await + } + }, + move |result| { + if let Err(error) = result { + tracing::warn!(%error, "could not load quick open catalog"); + if let Some(dialog) = weak.upgrade() { + dialog.search_failed(); + } + } + }, + ); + } + + fn catalog_changed(&self, snapshot: ObjectListSnapshot) { + let imp = self.imp(); + if imp.context.borrow().is_none() { + return; + } + let Some(widgets) = imp.widgets.get() else { + return; + }; + imp.catalog_error.set(snapshot.last_error.is_some()); + self.refresh_notice(); + if snapshot.generation == 0 { + if snapshot.last_error.is_some() { + widgets.status.set_title(&gettext("Could Not Load Tables and Views")); + widgets + .status + .set_description(Some(&gettext("Use Retry to try again."))); + } + return; + } + if imp.generation.replace(Some(snapshot.generation)) == Some(snapshot.generation) { + return; + } + imp.objects.replace(snapshot.objects); + self.rebuild_index(); + } + + fn rebuild_index(&self) { + let imp = self.imp(); + imp.requests.borrow_mut().cancel(Request::Search); + let ticket = imp.requests.borrow_mut().issue(Request::Index); + let Some(tasks) = imp.context.borrow().as_ref().map(|context| context.tasks.clone()) else { + return; + }; + let objects = imp.objects.borrow().clone(); + let queries = imp + .queries + .borrow() + .as_ref() + .map(|source| source.candidates.clone()) + .unwrap_or_default(); + let running = tasks.spawn_blocking_task(move || SearchIndex::new(&objects, queries.as_ref().clone())); + let weak = self.downgrade(); + glib::spawn_future_local(async move { + let result = running.await; + let Some(dialog) = weak.upgrade() else { + return; + }; + if !dialog.imp().requests.borrow_mut().accept(Request::Index, ticket.stamp) { + return; + } + match result { + Ok(index) => { + dialog.imp().indexed.set(true); + dialog.imp().index.replace(Arc::new(index)); + dialog.search(); + } + Err(error) => { + tracing::warn!(%error, "could not index quick open results"); + dialog.search_failed(); + } + } + }); + } + + fn search(&self) { + let imp = self.imp(); + let Some(widgets) = imp.widgets.get() else { + return; + }; + let Some(tasks) = imp.context.borrow().as_ref().map(|context| context.tasks.clone()) else { + return; + }; + if imp.requests.borrow().is_pending(Request::Index) + || imp.requests.borrow().is_pending(Request::Search) + || !imp.indexed.get() + { + return; + } + let text = widgets.entry.text().to_string(); + let ticket = imp.requests.borrow_mut().issue(Request::Search); + let index = imp.index.borrow().clone(); + let query = text.clone(); + let running = tasks.spawn_blocking_task(move || index.search(&query)); + let weak = self.downgrade(); + glib::spawn_future_local(async move { + let result = running.await; + let Some(dialog) = weak.upgrade() else { + return; + }; + if !dialog.imp().requests.borrow_mut().accept(Request::Search, ticket.stamp) { + return; + } + match result { + Ok(found) => dialog.show_results(text, found), + Err(error) => { + tracing::warn!(%error, "could not search quick open results"); + dialog.search_failed(); + } + } + }); + } + + fn search_failed(&self) { + self.imp().rendered.replace(None); + self.imp().pending_pick.set(None); + self.imp().pending_steps.borrow_mut().clear(); + if let Some(widgets) = self.imp().widgets.get() { + widgets.banner.set_revealed(true); + } + } + + fn selected(&self) -> Option { + let widgets = self.imp().widgets.get()?; + widgets + .selection + .selected_item() + .and_downcast::() + .map(|item| item.borrow::().clone()) + } + + fn show_results(&self, text: String, found: Vec) { + let imp = self.imp(); + let Some(widgets) = imp.widgets.get() else { + return; + }; + let previous = (imp.rendered.borrow().as_deref() == Some(text.as_str())) + .then(|| self.selected()) + .flatten() + .map(|candidate| candidate.identity()); + let selected = previous + .and_then(|target| found.iter().position(|candidate| candidate.identity() == target)) + .unwrap_or(0); + let items: Vec<_> = found.into_iter().map(glib::BoxedAnyObject::new).collect(); + widgets.store.splice(0, widgets.store.n_items(), &items); + widgets.selection.set_selected(if items.is_empty() { + gtk::INVALID_LIST_POSITION + } else { + u32::try_from(selected).unwrap_or(0) + }); + if items.is_empty() { + let loading = imp.requests.borrow().is_pending(Request::Queries) + || (imp.generation.get().is_none() && !imp.catalog_error.get()); + widgets.status.set_title(&if loading { + gettext("Loading Results") + } else { + gettext("No Matches") + }); + let description = (!loading).then(|| gettext("No results match what you typed.")); + widgets.status.set_description(description.as_deref()); + } + widgets + .stack + .set_visible_child_name(if items.is_empty() { "status" } else { "list" }); + imp.rendered.replace(Some(text)); + if !items.is_empty() { + self.scroll_selection_after_layout(); + } + let steps = std::mem::take(&mut *imp.pending_steps.borrow_mut()); + for by in steps { + self.step(by); + } + if let Some(structure) = imp.pending_pick.take() { + self.activate(structure); + } + } + + fn current(&self) -> bool { + let imp = self.imp(); + imp.widgets + .get() + .is_some_and(|widgets| imp.rendered.borrow().as_deref() == Some(widgets.entry.text().as_str())) + && !imp.requests.borrow().is_pending(Request::Index) + && !imp.requests.borrow().is_pending(Request::Search) + } + + fn activate(&self, structure: bool) { + if self.imp().context.borrow().is_none() { + return; + } + if !self.current() { + self.imp().pending_pick.set(Some(structure)); + self.search(); + return; + } + let Some(candidate) = self.selected() else { + return; + }; + match candidate { + Candidate::Table(object) => { + let allowed = self.imp().context.borrow().as_ref().is_some_and(|context| { + !structure + || (object.kind.is_structure_editable() + && context + .session + .current_dialect() + .is_some_and(|dialect| dialect.ddl().is_some())) + }); + if allowed { + self.finish_pick(Pick::Table { + table: TableRef::new(object.schema, object.name), + structure, + }); + } + } + Candidate::SavedQuery { id, .. } => self.choose_query(id), + } + } + + fn finish_pick(&self, pick: Pick) { + let Some(chosen) = self + .imp() + .context + .borrow() + .as_ref() + .map(|context| context.chosen.clone()) + else { + return; + }; + self.dismiss(); + chosen(pick); + } + + fn step(&self, by: i32) { + self.imp().requests.borrow_mut().cancel(Request::Pick); + if !self.current() { + self.imp().pending_steps.borrow_mut().push(by); + self.search(); + return; + } + let Some(widgets) = self.imp().widgets.get() else { + return; + }; + let count = widgets.selection.n_items(); + if count == 0 { + return; + } + let current = i64::from(widgets.selection.selected().min(count - 1)); + let next = (current + i64::from(by)).clamp(0, i64::from(count) - 1); + let position = u32::try_from(next).unwrap_or(0); + widgets.selection.set_selected(position); + self.scroll_selection_after_layout(); + } +} + +fn spawn_local(future: futures::future::LocalBoxFuture<'static, ()>) { + glib::spawn_future_local(future); +} +fn factory() -> gtk::SignalListItemFactory { + let factory = gtk::SignalListItemFactory::new(); + factory.connect_setup(|_, item| { + let Some(item) = item.downcast_ref::() else { + return; + }; + let icon = gtk::Image::new(); + icon.add_css_class("dimmed"); + icon.set_accessible_role(gtk::AccessibleRole::Presentation); + let name = gtk::Label::builder() + .xalign(0.0) + .hexpand(true) + .ellipsize(gtk::pango::EllipsizeMode::End) + .build(); + let place = gtk::Label::builder() + .xalign(1.0) + .ellipsize(gtk::pango::EllipsizeMode::End) + .build(); + place.add_css_class("dimmed"); + place.add_css_class("caption"); + let row = gtk::Box::builder() + .spacing(10) + .margin_top(6) + .margin_bottom(6) + .margin_start(6) + .margin_end(6) + .build(); + row.append(&icon); + row.append(&name); + row.append(&place); + item.set_child(Some(&row)); + }); + factory.connect_bind(|_, item| { + let Some(item) = item.downcast_ref::() else { + return; + }; + let (Some(object), Some(row)) = (item.item().and_downcast::(), item.child()) else { + return; + }; + let candidate = object.borrow::().clone(); + let (Some(icon), Some(name), Some(place)) = ( + row.first_child().and_downcast::(), + row.first_child() + .and_then(|icon| icon.next_sibling()) + .and_downcast::(), + row.last_child().and_downcast::(), + ) else { + return; + }; + let (symbol, kind, scope) = match &candidate { + Candidate::Table(object) => match object.kind { + ObjectKind::View | ObjectKind::MaterializedView => ( + icons::VIEW_GRID, + gettext("View"), + object.schema.as_deref().unwrap_or_default().to_owned(), + ), + _ => ( + icons::TABLE_RELATION, + gettext("Table"), + object.schema.as_deref().unwrap_or_default().to_owned(), + ), + }, + Candidate::SavedQuery { .. } => ("document-edit-symbolic", gettext("Saved Query"), gettext("Saved Query")), + }; + icon.set_icon_name(Some(symbol)); + name.set_label(candidate.name()); + place.set_label(&scope); + let described = gettext_f( + "{name}, {kind}, {scope}", + &[("name", candidate.name()), ("kind", &kind), ("scope", &scope)], + ); + item.set_accessible_label(&described); + }); + factory +} diff --git a/linux/crates/app/src/ui/quick_open/query_source.rs b/linux/crates/app/src/ui/quick_open/query_source.rs new file mode 100644 index 0000000000..ee8b8d4416 --- /dev/null +++ b/linux/crates/app/src/ui/quick_open/query_source.rs @@ -0,0 +1,190 @@ +use super::*; +use crate::services::history_service::HistoryService; +use uuid::Uuid; + +pub(super) struct QuerySource { + history: HistoryService, + connection: Uuid, + pub(super) candidates: Arc>, + error: Option, +} + +impl QuickOpen { + pub(crate) fn include_saved_queries(&self, history: HistoryService, connection: Uuid) { + self.imp().queries.replace(Some(QuerySource { + history, + connection, + candidates: Arc::default(), + error: None, + })); + if let Some(widgets) = self.imp().widgets.get() { + widgets + .entry + .set_placeholder_text(Some(&gettext("Search tables, views and saved queries"))); + widgets + .entry + .update_property(&[gtk::accessible::Property::Label(&gettext( + "Search tables, views and saved queries", + ))]); + widgets + .list + .update_property(&[gtk::accessible::Property::Label(&gettext( + "Tables, views and saved queries", + ))]); + } + self.load_queries(); + } + + pub(super) fn load_queries(&self) { + let imp = self.imp(); + let Some((history, connection)) = imp + .queries + .borrow() + .as_ref() + .map(|source| (source.history.clone(), source.connection)) + else { + return; + }; + let Some(tasks) = imp.context.borrow().as_ref().map(|context| context.tasks.clone()) else { + return; + }; + let ticket = imp.requests.borrow_mut().issue(Request::Queries); + let weak = self.downgrade(); + spawn_and_deliver( + &tasks, + async move { + let store = history.ready_store().await.ok_or_else(|| unavailable(&history))?; + let queries = store.saved_queries().list(Some(connection)).await.map_err(|error| { + tracing::warn!(%error, "could not list quick open saved queries"); + gettext("Could not load saved queries.") + })?; + Ok::<_, String>( + queries + .into_iter() + .map(|query| Candidate::SavedQuery { + id: query.id, + name: query.name, + }) + .collect::>(), + ) + }, + move |result| { + let Some(dialog) = weak.upgrade() else { + return; + }; + if !dialog + .imp() + .requests + .borrow_mut() + .accept(Request::Queries, ticket.stamp) + { + return; + } + let result = result.unwrap_or_else(|error| { + tracing::warn!(%error, "could not read quick open saved queries"); + Err(gettext("Could not load saved queries.")) + }); + { + let mut sources = dialog.imp().queries.borrow_mut(); + let Some(source) = sources.as_mut() else { + return; + }; + match result { + Ok(candidates) => { + source.candidates = Arc::new(candidates); + source.error = None; + } + Err(error) => source.error = Some(error), + } + } + dialog.refresh_notice(); + dialog.rebuild_index(); + }, + ); + } + + pub(super) fn choose_query(&self, id: i64) { + let imp = self.imp(); + let Some((history, connection)) = imp + .queries + .borrow() + .as_ref() + .map(|source| (source.history.clone(), source.connection)) + else { + return; + }; + let Some(tasks) = imp.context.borrow().as_ref().map(|context| context.tasks.clone()) else { + return; + }; + let ticket = imp.requests.borrow_mut().issue(Request::Pick); + let weak = self.downgrade(); + spawn_and_deliver( + &tasks, + async move { + let store = history.ready_store().await.ok_or_else(|| unavailable(&history))?; + match store.saved_queries().get(id).await { + Ok(Some(query)) if query.connection_id == connection => Ok(query.query), + Ok(_) => Err(gettext("This saved query is no longer available.")), + Err(error) => { + tracing::warn!(%error, "could not open saved query"); + Err(gettext("Could not open this saved query.")) + } + } + }, + move |result| { + let Some(dialog) = weak.upgrade() else { + return; + }; + if !dialog.imp().requests.borrow_mut().accept(Request::Pick, ticket.stamp) { + return; + } + match result { + Ok(Ok(sql)) => dialog.finish_pick(Pick::Query(sql)), + result => { + let error = match result { + Ok(Err(error)) => error, + Err(error) => { + tracing::warn!(%error, "could not read saved query"); + gettext("Could not open this saved query.") + } + Ok(Ok(_)) => return, + }; + if let Some(source) = dialog.imp().queries.borrow_mut().as_mut() { + source.error = Some(error); + } + dialog.refresh_notice(); + } + } + }, + ); + } + + pub(super) fn refresh_notice(&self) { + let Some(widgets) = self.imp().widgets.get() else { + return; + }; + let query_error = self + .imp() + .queries + .borrow() + .as_ref() + .and_then(|source| source.error.clone()); + let text = match (self.imp().catalog_error.get(), query_error) { + (true, Some(query)) => gettext_f("Could not load tables and views. {error}", &[("error", &query)]), + (true, None) => gettext("Could not load tables and views."), + (false, Some(query)) => query, + (false, None) => String::new(), + }; + widgets.banner.set_title(&text); + widgets.banner.set_revealed(!text.is_empty()); + } +} + +fn unavailable(history: &HistoryService) -> String { + history + .availability() + .borrow() + .failure() + .map(str::to_owned) + .unwrap_or_else(|| gettext("Saved queries are unavailable.")) +} diff --git a/linux/crates/app/src/ui/quick_open/search_index.rs b/linux/crates/app/src/ui/quick_open/search_index.rs new file mode 100644 index 0000000000..caff8704ba --- /dev/null +++ b/linux/crates/app/src/ui/quick_open/search_index.rs @@ -0,0 +1,179 @@ +use tablepro_core::meta::{ObjectInfo, TableRef}; + +use super::matching; + +pub(super) const LISTED: usize = 200; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub(super) enum Identity { + Table(TableRef), + SavedQuery(i64), +} + +#[derive(Debug, Clone)] +pub(super) enum Candidate { + Table(ObjectInfo), + SavedQuery { id: i64, name: String }, +} + +impl Candidate { + pub(super) fn identity(&self) -> Identity { + match self { + Self::Table(object) => Identity::Table(TableRef::new(object.schema.clone(), object.name.clone())), + Self::SavedQuery { id, .. } => Identity::SavedQuery(*id), + } + } + + pub(super) fn name(&self) -> &str { + match self { + Self::Table(object) => &object.name, + Self::SavedQuery { name, .. } => name, + } + } + + fn scope(&self) -> &str { + match self { + Self::Table(object) => object.schema.as_deref().unwrap_or_default(), + Self::SavedQuery { .. } => "", + } + } + + fn source_order(&self) -> u8 { + match self { + Self::Table(_) => 0, + Self::SavedQuery { .. } => 1, + } + } + + fn id_order(&self) -> i64 { + match self { + Self::Table(_) => 0, + Self::SavedQuery { id, .. } => *id, + } + } +} + +#[derive(Debug, Default)] +pub(super) struct SearchIndex { + entries: Vec<(Candidate, Vec, Vec)>, +} + +impl SearchIndex { + pub(super) fn new(objects: &[ObjectInfo], queries: Vec) -> Self { + let candidates = objects + .iter() + .filter(|object| object.kind.is_browsable()) + .cloned() + .map(Candidate::Table) + .chain(queries); + let mut entries: Vec<_> = candidates + .map(|candidate| { + let name = matching::normalize(candidate.name()); + let qualified = matching::normalize(&if candidate.scope().is_empty() { + candidate.name().to_owned() + } else { + format!("{}.{}", candidate.scope(), candidate.name()) + }); + (candidate, name, qualified) + }) + .collect(); + entries.sort_by(|(a, an, _), (b, bn, _)| { + an.cmp(bn) + .then_with(|| a.source_order().cmp(&b.source_order())) + .then_with(|| a.scope().cmp(b.scope())) + .then_with(|| a.name().cmp(b.name())) + .then_with(|| a.id_order().cmp(&b.id_order())) + }); + Self { entries } + } + + pub(super) fn search(&self, typed: &str) -> Vec { + let typed = matching::normalize(typed.trim()); + let mut found: Vec<_> = self + .entries + .iter() + .filter_map(|(candidate, name, qualified)| { + matching::rank(&typed, name) + .into_iter() + .chain(matching::rank(&typed, qualified)) + .min() + .map(|rank| (rank, candidate)) + }) + .collect(); + found.sort_by_key(|(rank, _)| *rank); + found + .into_iter() + .take(LISTED) + .map(|(_, candidate)| candidate.clone()) + .collect() + } +} + +#[cfg(test)] +mod tests { + use super::*; + use tablepro_core::meta::ObjectKind; + + fn object(schema: &str, name: &str, kind: ObjectKind) -> ObjectInfo { + ObjectInfo::new(Some(schema.to_owned()), name, kind) + } + + #[test] + fn browsable_objects_share_ranking_and_qualified_names() { + let index = SearchIndex::new( + &[ + object("public", "orders", ObjectKind::Table), + object("sales", "orders", ObjectKind::View), + object("sales", "order_items", ObjectKind::MaterializedView), + object("sales", "ordered", ObjectKind::Function), + ], + vec![], + ); + let names = |text| { + index + .search(text) + .into_iter() + .map(|c| c.name().to_owned()) + .collect::>() + }; + assert_eq!(names("ord"), ["order_items", "orders", "orders"]); + assert_eq!(names("sales.orders"), ["orders"]); + assert!(names("zzz").is_empty()); + } + + #[test] + fn the_cap_applies_after_matching_the_entire_catalog() { + let objects: Vec<_> = (0..50_000) + .map(|i| object("main", &format!("table_{i:05}"), ObjectKind::Table)) + .collect(); + let index = SearchIndex::new(&objects, vec![]); + assert_eq!(index.search("").len(), LISTED); + assert_eq!(index.search("table_49999")[0].name(), "table_49999"); + } + + #[test] + fn saved_queries_share_ranking_with_tables_and_have_stable_ties() { + let index = SearchIndex::new( + &[object("main", "orders", ObjectKind::Table)], + vec![ + Candidate::SavedQuery { + id: 2, + name: "orders".into(), + }, + Candidate::SavedQuery { + id: 1, + name: "orders".into(), + }, + Candidate::SavedQuery { + id: 3, + name: "other".into(), + }, + ], + ); + let found = index.search("ord"); + assert_eq!(found.len(), 3); + assert!(matches!(found[0], Candidate::Table(_))); + assert_eq!(found[1].identity(), Identity::SavedQuery(1)); + assert_eq!(found[2].identity(), Identity::SavedQuery(2)); + } +} diff --git a/linux/crates/app/src/ui/quick_open/tests.rs b/linux/crates/app/src/ui/quick_open/tests.rs new file mode 100644 index 0000000000..9009f2314f --- /dev/null +++ b/linux/crates/app/src/ui/quick_open/tests.rs @@ -0,0 +1,358 @@ +use std::cell::RefCell; +use std::rc::Rc; +use std::time::Duration; + +use tablepro_core::DriverError; +use tablepro_core::meta::ObjectInfo; +use tablepro_test_support::{ConnectionScript, FakeReply}; + +use super::*; +use crate::test_support::{FakeSession, finish_on_main, test_runtime, wait_until}; + +const WAIT: Duration = Duration::from_secs(5); + +fn object(name: &str, kind: ObjectKind) -> ObjectInfo { + ObjectInfo::new(Some("public".to_owned()), name, kind) +} + +type Fixture = ( + crate::runtime::AppRuntime, + FakeSession, + QuickOpen, + Rc>>, +); + +fn setup(objects: Vec) -> Fixture { + let mut script = ConnectionScript::default(); + script.list_objects.always(FakeReply::ok(objects)); + setup_script(script) +} + +fn setup_script(script: ConnectionScript) -> Fixture { + adw::init().expect("libadwaita"); + let runtime = test_runtime(); + let fake = FakeSession::start(script, [], runtime.tasks()); + let chosen = Rc::new(RefCell::new(Vec::new())); + let sink = chosen.clone(); + let dialog = QuickOpen::new(fake.session.clone(), runtime.tasks(), move |pick| { + sink.borrow_mut().push(pick) + }); + (runtime, fake, dialog, chosen) +} + +fn ready(dialog: &QuickOpen) { + wait_until(WAIT, || dialog.current()).expect("current search results"); +} + +#[gtk4::test] +fn an_unloaded_catalog_arrives_without_reopening() { + let (_runtime, _fake, dialog, _) = setup(vec![object("orders", ObjectKind::Table)]); + assert_eq!(dialog.imp().widgets.get().unwrap().store.n_items(), 0); + ready(&dialog); + assert_eq!(dialog.selected().unwrap().name(), "orders"); + dialog.dismiss(); +} + +#[gtk4::test] +fn enter_after_typing_uses_the_new_search() { + let (_runtime, _fake, dialog, chosen) = setup(vec![ + object("customers", ObjectKind::Table), + object("orders", ObjectKind::Table), + ]); + ready(&dialog); + let widgets = dialog.imp().widgets.get().unwrap(); + widgets.entry.set_text("orders"); + widgets.entry.emit_by_name::<()>("activate", &[]); + assert!(chosen.borrow().is_empty(), "the previous row opened"); + wait_until(WAIT, || !chosen.borrow().is_empty()).expect("deferred activation"); + assert_eq!( + chosen.borrow()[0], + Pick::Table { + table: tablepro_core::meta::TableRef::new(Some("public".to_owned()), "orders"), + structure: false + } + ); +} + +#[gtk4::test] +fn a_miss_cannot_activate_a_previous_result() { + let (_runtime, _fake, dialog, chosen) = setup(vec![object("orders", ObjectKind::Table)]); + ready(&dialog); + dialog.imp().widgets.get().unwrap().entry.set_text("missing"); + dialog.activate(false); + ready(&dialog); + assert!(chosen.borrow().is_empty()); + assert_eq!( + dialog + .imp() + .widgets + .get() + .unwrap() + .stack + .visible_child_name() + .as_deref(), + Some("status") + ); + dialog.dismiss(); +} + +#[gtk4::test] +fn keyboard_navigation_scrolls_and_keeps_search_focus() { + let (_runtime, _fake, dialog, _) = setup( + (0..100) + .map(|i| object(&format!("table_{i:03}"), ObjectKind::Table)) + .collect(), + ); + let window = adw::Window::new(); + window.set_default_size(800, 600); + window.present(); + dialog.present(Some(&window)); + ready(&dialog); + wait_until(WAIT, || dialog.entry_has_focus()).expect("search focus"); + for _ in 0..60 { + assert_eq!( + dialog.key(gdk::Key::Down, gdk::ModifierType::empty()), + glib::Propagation::Stop + ); + } + let widgets = dialog.imp().widgets.get().unwrap(); + assert_eq!(widgets.selection.selected(), 60); + assert!(dialog.entry_has_focus()); + let scrolled = widgets + .list + .parent() + .and_downcast::() + .expect("scroller"); + wait_until(WAIT, || scrolled.vadjustment().value() > 0.0).expect("selected row scrolled into view"); + wait_until(WAIT, || row_is_visible(&dialog, "table_060")).expect("selected row is visible"); + widgets.entry.emit_by_name::<()>("stop-search", &[]); + wait_until(WAIT, || dialog.parent().is_none()).expect("Escape closes"); + assert!(dialog.imp().context.borrow().is_none()); + window.destroy(); +} + +fn row_is_visible(dialog: &QuickOpen, name: &str) -> bool { + let list = &dialog.imp().widgets.get().unwrap().list; + crate::test_support::descendants(list) + .into_iter() + .filter_map(|widget| widget.downcast::().ok()) + .find(|label| label.text() == name) + .and_then(|label| label.compute_bounds(list)) + .is_some_and(|bounds| { + bounds.height() > 0.0 && bounds.y() >= 0.0 && bounds.y() + bounds.height() <= list.height() as f32 + }) +} + +#[gtk4::test] +fn selection_before_presentation_scrolls_after_layout() { + let (_runtime, _fake, dialog, _) = setup( + (0..100) + .map(|i| object(&format!("table_{i:03}"), ObjectKind::Table)) + .collect(), + ); + ready(&dialog); + let widgets = dialog.imp().widgets.get().unwrap(); + assert!(!widgets.list.is_mapped()); + dialog.step(60); + let window = adw::Window::new(); + window.set_default_size(800, 600); + window.present(); + dialog.present(Some(&window)); + dialog.step(-20); + assert_eq!(widgets.selection.selected(), 40); + wait_until(WAIT, || row_is_visible(&dialog, "table_040")).expect("latest selection visible after first layout"); + assert!(dialog.entry_has_focus()); + + dialog.step(30); + assert!(dialog.imp().scroll_layout.borrow().is_some()); + dialog.dismiss(); + assert!( + dialog.imp().scroll_layout.borrow().is_none(), + "close cancels pending scrolling" + ); + window.destroy(); +} + +#[gtk4::test] +fn replaced_results_scroll_after_layout_without_a_viewport_resize() { + let objects: Vec<_> = (0..100) + .map(|i| object(&format!("table_{i:03}"), ObjectKind::Table)) + .collect(); + let (_runtime, _fake, dialog, _) = setup(objects); + let window = adw::Window::new(); + window.set_default_size(800, 600); + window.present(); + dialog.present(Some(&window)); + ready(&dialog); + dialog.step(60); + wait_until(WAIT, || row_is_visible(&dialog, "table_060")).expect("initial selection visible"); + let widgets = dialog.imp().widgets.get().unwrap(); + let page_size = widgets.list.vadjustment().unwrap().page_size(); + let found = dialog.imp().index.borrow().search(""); + dialog.show_results(String::new(), found); + dialog.step(-40); + wait_until(WAIT, || row_is_visible(&dialog, "table_020")).expect("replacement selection visible"); + assert_eq!(widgets.list.vadjustment().unwrap().page_size(), page_size); + assert!(dialog.entry_has_focus()); + dialog.dismiss(); + window.destroy(); +} + +#[gtk4::test] +fn structure_is_not_offered_for_views_or_a_dialect_without_ddl() { + let (_runtime, _fake, dialog, chosen) = setup(vec![ + object("orders", ObjectKind::Table), + object("view", ObjectKind::View), + ]); + ready(&dialog); + assert_eq!( + dialog.key(gdk::Key::Return, gdk::ModifierType::CONTROL_MASK), + glib::Propagation::Stop + ); + assert!(chosen.borrow().is_empty(), "the fake dialect has no DDL"); + dialog.step(1); + dialog.activate(true); + assert!(chosen.borrow().is_empty()); + dialog.activate(false); + assert_eq!(chosen.borrow().len(), 1, "a view can still be browsed"); + assert!(matches!(chosen.borrow()[0], Pick::Table { structure: false, .. })); +} + +#[gtk4::test] +fn a_catalog_refresh_preserves_identity_and_removes_dropped_objects() { + let mut script = ConnectionScript::default(); + script + .list_objects + .once(FakeReply::ok(vec![ + object("orders", ObjectKind::Table), + object("users", ObjectKind::Table), + ])) + .always(FakeReply::ok(vec![ + object("aardvark", ObjectKind::Table), + object("users", ObjectKind::Table), + ])); + let (runtime, fake, dialog, _) = setup_script(script); + ready(&dialog); + dialog.step(1); + let session = fake.session.clone(); + finish_on_main( + WAIT, + runtime + .tasks() + .spawn_task(async move { session.refresh_objects(ObjectScope::AllSchemas).await }), + ) + .unwrap() + .unwrap() + .unwrap(); + wait_until(WAIT, || dialog.imp().generation.get() == Some(2) && dialog.current()).unwrap(); + assert_eq!(dialog.selected().unwrap().name(), "users"); + dialog.imp().widgets.get().unwrap().entry.set_text("orders"); + dialog.search(); + ready(&dialog); + assert!(dialog.selected().is_none()); + dialog.dismiss(); +} + +#[gtk4::test] +fn a_failed_read_has_retry_and_recovers() { + adw::init().expect("libadwaita"); + let runtime = test_runtime(); + let mut script = ConnectionScript::default(); + script.list_objects.once(FakeReply::err(DriverError::Cancelled)); + script + .list_objects + .always(FakeReply::ok(vec![object("orders", ObjectKind::Table)])); + let fake = FakeSession::start(script, [], runtime.tasks()); + let dialog = QuickOpen::new(fake.session, runtime.tasks(), |_| {}); + let widgets = dialog.imp().widgets.get().unwrap(); + wait_until(WAIT, || widgets.banner.is_revealed()).expect("read failure visible"); + widgets.banner.emit_by_name::<()>("button-clicked", &[]); + ready(&dialog); + assert_eq!(dialog.selected().unwrap().name(), "orders"); + assert!(!widgets.banner.is_revealed()); + dialog.dismiss(); +} + +#[gtk4::test] +fn a_closed_dialog_retained_by_its_workspace_stops_work() { + let (runtime, fake, dialog, chosen) = setup(vec![object("orders", ObjectKind::Table)]); + ready(&dialog); + dialog.imp().widgets.get().unwrap().entry.set_text("ord"); + dialog.activate(false); + dialog.dismiss(); + let generation = dialog.imp().generation.get(); + let session = fake.session.clone(); + finish_on_main( + WAIT, + runtime + .tasks() + .spawn_task(async move { session.refresh_objects(ObjectScope::AllSchemas).await }), + ) + .unwrap() + .unwrap() + .unwrap(); + crate::test_support::drain_main_context(); + assert_eq!(dialog.imp().generation.get(), generation); + assert!(dialog.imp().watches.borrow().is_empty()); + assert!(dialog.imp().context.borrow().is_none()); + assert!(chosen.borrow().is_empty()); +} + +#[gtk4::test] +fn control_enter_opens_table_structure_with_a_ddl_dialect() { + let mut script = ConnectionScript { + dialect: Arc::new(tablepro_driver_postgres::PgDialect::new( + &tablepro_core::ServerInfo::new("PostgreSQL", "18.0", 18, 0, 0), + )), + ..ConnectionScript::default() + }; + script + .list_objects + .always(FakeReply::ok(vec![object("orders", ObjectKind::Table)])); + let (_runtime, _fake, dialog, chosen) = setup_script(script); + ready(&dialog); + assert_eq!( + dialog.key(gdk::Key::Return, gdk::ModifierType::CONTROL_MASK), + glib::Propagation::Stop + ); + assert_eq!(chosen.borrow().len(), 1); + assert!(matches!(chosen.borrow()[0], Pick::Table { structure: true, .. })); +} + +#[gtk4::test] +fn clicking_a_stale_row_never_opens_a_different_search_result() { + let (_runtime, _fake, dialog, chosen) = setup(vec![ + object("customers", ObjectKind::Table), + object("orders", ObjectKind::Table), + ]); + ready(&dialog); + let widgets = dialog.imp().widgets.get().unwrap(); + widgets.entry.set_text("orders"); + widgets.list.emit_by_name::<()>("activate", &[&0u32]); + ready(&dialog); + assert!(chosen.borrow().is_empty()); + assert_eq!(dialog.selected().unwrap().name(), "orders"); + widgets.list.emit_by_name::<()>("activate", &[&0u32]); + assert_eq!(chosen.borrow().len(), 1); +} + +#[gtk4::test] +fn arrows_before_search_finishes_apply_before_enter() { + let (_runtime, _fake, dialog, chosen) = setup(vec![ + object("customers", ObjectKind::Table), + object("order_items", ObjectKind::Table), + object("orders", ObjectKind::Table), + ]); + ready(&dialog); + dialog.imp().widgets.get().unwrap().entry.set_text("ord"); + dialog.step(1); + dialog.activate(false); + wait_until(WAIT, || !chosen.borrow().is_empty()).expect("pending navigation and activation"); + assert_eq!( + chosen.borrow()[0], + Pick::Table { + table: tablepro_core::meta::TableRef::new(Some("public".to_owned()), "orders"), + structure: false + } + ); +} diff --git a/linux/crates/app/src/ui/quick_open/tests/queries.rs b/linux/crates/app/src/ui/quick_open/tests/queries.rs new file mode 100644 index 0000000000..863f450c41 --- /dev/null +++ b/linux/crates/app/src/ui/quick_open/tests/queries.rs @@ -0,0 +1,249 @@ +use std::time::Duration; + +use tablepro_core::DriverError; +use tablepro_storage::saved_queries::NewSavedQuery; +use tablepro_storage::{QueryHistory, StoragePaths}; +use tablepro_test_support::{ConnectionScript, FakeReply}; +use uuid::Uuid; + +use super::*; +use crate::services::history_preferences::HistoryPreferences; +use crate::services::history_service::HistoryService; +use crate::test_support::{FakeSession, finish_on_main, test_runtime, wait_until}; + +const WAIT: Duration = Duration::from_secs(5); + +fn history(tasks: &Tasks) -> (tempfile::TempDir, HistoryService, QueryHistory) { + let root = tempfile::tempdir().unwrap(); + let paths = StoragePaths::under(root.path(), "quick-open-test", "app.tablepro.TablePro.Devel"); + let history = HistoryService::start( + paths, + HistoryPreferences { + retention_days: tokio::sync::watch::channel(30).1, + save: tokio::sync::watch::channel(true).1, + }, + tasks, + ); + wait_until(WAIT, || history.availability().borrow().is_ready()).unwrap(); + let store = history.store().unwrap(); + (root, history, store) +} + +fn save(tasks: &Tasks, history: &QueryHistory, connection: Uuid, name: &str, sql: &str) -> i64 { + let saved = history.saved_queries(); + let query = NewSavedQuery { + name: name.into(), + query: sql.into(), + connection_id: connection, + connection_name: "Test".into(), + }; + finish_on_main(WAIT, tasks.spawn_task(async move { saved.save(query).await })) + .unwrap() + .unwrap() + .unwrap() + .id +} + +fn ready(dialog: &QuickOpen) { + wait_until(WAIT, || { + !dialog.imp().requests.borrow().is_pending(Request::Queries) && dialog.current() + }) + .unwrap(); +} + +#[gtk4::test] +fn saved_queries_work_when_the_catalog_fails_and_only_for_their_connection() { + adw::init().unwrap(); + let runtime = test_runtime(); + let (_root, history, store) = history(&runtime.tasks()); + let connection = Uuid::new_v4(); + save( + &runtime.tasks(), + &store, + connection, + "My orders", + "SELECT 1;\nSELECT 2;", + ); + save(&runtime.tasks(), &store, Uuid::new_v4(), "Other orders", "SELECT 3"); + let mut script = ConnectionScript::default(); + script.list_objects.always(FakeReply::err(DriverError::Cancelled)); + let fake = FakeSession::start(script, [], runtime.tasks()); + let chosen = Rc::new(RefCell::new(Vec::new())); + let sink = chosen.clone(); + let dialog = QuickOpen::new(fake.session, runtime.tasks(), move |pick| sink.borrow_mut().push(pick)); + dialog.include_saved_queries(history, connection); + ready(&dialog); + let widgets = dialog.imp().widgets.get().unwrap(); + assert_eq!(widgets.store.n_items(), 1); + assert!(widgets.banner.is_revealed()); + assert_eq!(dialog.selected().unwrap().name(), "My orders"); + dialog.activate(false); + wait_until(WAIT, || !chosen.borrow().is_empty()).unwrap(); + assert_eq!(chosen.borrow()[0], Pick::Query("SELECT 1;\nSELECT 2;".into())); +} + +#[gtk4::test] +fn choosing_a_saved_query_reads_its_current_sql() { + adw::init().unwrap(); + let runtime = test_runtime(); + let (_root, history, store) = history(&runtime.tasks()); + let connection = Uuid::new_v4(); + save(&runtime.tasks(), &store, connection, "Orders", "SELECT 1"); + let mut script = ConnectionScript::default(); + script.list_objects.always(FakeReply::ok(vec![])); + let fake = FakeSession::start(script, [], runtime.tasks()); + let chosen = Rc::new(RefCell::new(Vec::new())); + let sink = chosen.clone(); + let dialog = QuickOpen::new(fake.session, runtime.tasks(), move |pick| sink.borrow_mut().push(pick)); + dialog.include_saved_queries(history, connection); + ready(&dialog); + save(&runtime.tasks(), &store, connection, "Orders", "SELECT 42"); + dialog.activate(false); + wait_until(WAIT, || !chosen.borrow().is_empty()).unwrap(); + assert_eq!(chosen.borrow()[0], Pick::Query("SELECT 42".into())); +} + +#[gtk4::test] +fn closing_during_query_lookup_discards_the_reply() { + adw::init().unwrap(); + let runtime = test_runtime(); + let (_root, history, store) = history(&runtime.tasks()); + let connection = Uuid::new_v4(); + save(&runtime.tasks(), &store, connection, "Orders", "SELECT 42"); + let mut script = ConnectionScript::default(); + script.list_objects.always(FakeReply::ok(vec![])); + let fake = FakeSession::start(script, [], runtime.tasks()); + let chosen = Rc::new(RefCell::new(Vec::new())); + let sink = chosen.clone(); + let dialog = QuickOpen::new(fake.session, runtime.tasks(), move |pick| sink.borrow_mut().push(pick)); + dialog.include_saved_queries(history, connection); + ready(&dialog); + dialog.activate(false); + dialog.dismiss(); + crate::test_support::drain_main_context(); + assert!(chosen.borrow().is_empty()); + assert!(dialog.imp().queries.borrow().is_none()); + assert!(!dialog.imp().requests.borrow().is_pending(Request::Pick)); +} + +#[gtk4::test] +fn a_successful_catalog_refresh_keeps_a_saved_query_error_visible() { + adw::init().unwrap(); + let runtime = test_runtime(); + let root = tempfile::tempdir().unwrap(); + let paths = StoragePaths::under(root.path(), "quick-open-test", "app.tablepro.TablePro.Devel"); + std::fs::create_dir_all(paths.history_database()).unwrap(); + let history = HistoryService::start( + paths, + HistoryPreferences { + retention_days: tokio::sync::watch::channel(30).1, + save: tokio::sync::watch::channel(true).1, + }, + &runtime.tasks(), + ); + let mut script = ConnectionScript::default(); + script + .list_objects + .always(FakeReply::ok(vec![ObjectInfo::new(None, "orders", ObjectKind::Table)])); + let fake = FakeSession::start(script, [], runtime.tasks()); + let dialog = QuickOpen::new(fake.session.clone(), runtime.tasks(), |_| {}); + dialog.include_saved_queries(history, Uuid::new_v4()); + ready(&dialog); + let widgets = dialog.imp().widgets.get().unwrap(); + assert!(widgets.banner.is_revealed()); + let session = fake.session.clone(); + finish_on_main( + WAIT, + runtime + .tasks() + .spawn_task(async move { session.refresh_objects(ObjectScope::AllSchemas).await }), + ) + .unwrap() + .unwrap() + .unwrap(); + wait_until(WAIT, || dialog.imp().generation.get() == Some(2) && dialog.current()).unwrap(); + assert!(widgets.banner.is_revealed()); + assert_eq!(dialog.selected().unwrap().name(), "orders"); + dialog.dismiss(); +} + +#[gtk4::test] +fn saved_queries_arrive_before_the_catalog_and_survive_its_commit() { + adw::init().unwrap(); + let runtime = test_runtime(); + let (_root, history, store) = history(&runtime.tasks()); + let connection = Uuid::new_v4(); + save(&runtime.tasks(), &store, connection, "Saved orders", "SELECT 1"); + let release = tokio_util::sync::CancellationToken::new(); + let mut script = ConnectionScript::default(); + script.list_objects.always(FakeReply::UntilReleased { + release: release.clone(), + outcome: Ok(vec![ObjectInfo::new(None, "orders", ObjectKind::Table)]), + }); + let fake = FakeSession::start(script, [], runtime.tasks()); + let dialog = QuickOpen::new(fake.session, runtime.tasks(), |_| {}); + dialog.include_saved_queries(history, connection); + ready(&dialog); + assert_eq!(dialog.selected().unwrap().name(), "Saved orders"); + assert!(dialog.imp().generation.get().is_none()); + release.cancel(); + wait_until(WAIT, || dialog.imp().generation.get().is_some() && dialog.current()).unwrap(); + assert_eq!(dialog.imp().widgets.get().unwrap().store.n_items(), 2); + assert_eq!(dialog.selected().unwrap().name(), "Saved orders"); + dialog.dismiss(); +} + +#[gtk4::test] +fn a_deleted_saved_query_reports_an_error_without_opening_sql() { + adw::init().unwrap(); + let runtime = test_runtime(); + let (_root, history, store) = history(&runtime.tasks()); + let connection = Uuid::new_v4(); + let id = save(&runtime.tasks(), &store, connection, "Orders", "SELECT 1"); + let mut script = ConnectionScript::default(); + script.list_objects.always(FakeReply::ok(vec![])); + let fake = FakeSession::start(script, [], runtime.tasks()); + let chosen = Rc::new(RefCell::new(Vec::new())); + let sink = chosen.clone(); + let dialog = QuickOpen::new(fake.session, runtime.tasks(), move |pick| sink.borrow_mut().push(pick)); + dialog.include_saved_queries(history, connection); + ready(&dialog); + let saved = store.saved_queries(); + finish_on_main(WAIT, runtime.tasks().spawn_task(async move { saved.delete(id).await })) + .unwrap() + .unwrap() + .unwrap(); + dialog.activate(false); + let widgets = dialog.imp().widgets.get().unwrap(); + wait_until(WAIT, || widgets.banner.is_revealed()).unwrap(); + assert!(chosen.borrow().is_empty()); + assert!(dialog.imp().context.borrow().is_some()); + widgets.banner.emit_by_name::<()>("button-clicked", &[]); + ready(&dialog); + assert_eq!(widgets.store.n_items(), 0); + assert!(!widgets.banner.is_revealed()); + dialog.dismiss(); +} + +#[gtk4::test] +fn an_empty_query_source_does_not_report_no_matches_while_the_catalog_loads() { + adw::init().unwrap(); + let runtime = test_runtime(); + let (_root, history, _store) = history(&runtime.tasks()); + let release = tokio_util::sync::CancellationToken::new(); + let mut script = ConnectionScript::default(); + script.list_objects.always(FakeReply::UntilReleased { + release: release.clone(), + outcome: Ok(vec![]), + }); + let fake = FakeSession::start(script, [], runtime.tasks()); + let dialog = QuickOpen::new(fake.session, runtime.tasks(), |_| {}); + dialog.include_saved_queries(history, Uuid::new_v4()); + ready(&dialog); + let widgets = dialog.imp().widgets.get().unwrap(); + assert_eq!(widgets.status.title(), "Loading Results"); + release.cancel(); + wait_until(WAIT, || dialog.imp().generation.get().is_some() && dialog.current()).unwrap(); + assert_eq!(widgets.status.title(), "No Matches"); + dialog.dismiss(); +} diff --git a/linux/crates/app/src/ui/workspace/mod.rs b/linux/crates/app/src/ui/workspace/mod.rs index 0e99c0bf75..822871a9e7 100644 --- a/linux/crates/app/src/ui/workspace/mod.rs +++ b/linux/crates/app/src/ui/workspace/mod.rs @@ -66,6 +66,7 @@ pub(crate) use self::catalog_ops::DatabaseDrop; pub(crate) use self::database_transfer::TransferInput; pub(crate) use self::saves::SaveRequest; use self::session_watches::SessionWatches; +pub(crate) use self::status_pages::SearchInput; use self::tab_title::ConnectionLabel; pub(crate) use self::workspace_actions::show_transfer_actions; pub(crate) use self::workspace_shell::WorkspaceShell; @@ -180,6 +181,7 @@ pub(crate) struct WorkspaceModel { /// The CSV imports running into this workspace's tables. imports: Rc, history_dialog: Option, + quick_open_dialog: Option, saved_queries_dialog: Option, import_dialog: Option, driver_id: String, @@ -544,8 +546,7 @@ pub(crate) enum WorkspaceInput { WorkspaceLayoutReset(Result, crate::workspace::WorkspaceSaveError>), /// An editor draft failed to land after the last one did. DraftsNotSaved, - ShowHistory, - ShowSavedQueries, + Search(SearchInput), ActiveTab(workspace_tabs::ActiveTabCommand), ConfirmReplaceSavedQuery(tablepro_storage::saved_queries::NewSavedQuery), ReplaceSavedQuery(tablepro_storage::saved_queries::NewSavedQuery), @@ -813,11 +814,7 @@ impl Workspace { } = init; let workspace: Self = glib::Object::new(); let imp = workspace.imp(); - imp.shell.set(Some(&shell)); - let input = workspace.pump_inputs(); - let _ = imp.sender.set(input.clone()); - let _ = imp.key.set(key.clone()); - let _ = imp.connection_id.set(session.metadata().id); + let input = workspace.bind(&shell, &key, &session); let context = session_slot(&context, &session); let storage = services.storage.clone(); let tasks = services.tasks.clone(); @@ -894,6 +891,7 @@ impl Workspace { exports: exports.clone(), imports: imports.clone(), history_dialog: None, + quick_open_dialog: None, saved_queries_dialog: None, import_dialog: None, workspace: persistence, @@ -905,6 +903,16 @@ impl Workspace { workspace } + fn bind(&self, shell: &WorkspaceShell, key: &SessionKey, session: &Session) -> WorkspaceSender { + let imp = self.imp(); + imp.shell.set(Some(shell)); + let input = self.pump_inputs(); + let _ = imp.sender.set(input.clone()); + let _ = imp.key.set(key.clone()); + let _ = imp.connection_id.set(session.metadata().id); + input + } + /// Hold the model, and have every close of the window ask the /// `blockers` first. The session is named before the shell holds it, /// which titles its row and the header bars from these. @@ -1273,6 +1281,7 @@ impl WorkspaceModel { keys.stop_listing(); } self.sidebar.shutdown(); + self.close_quick_open(); // Their entries name this session's tables and queries. if let Some(dialog) = self.history_dialog.take() { close_if_presented(dialog.upcast_ref()); @@ -1397,8 +1406,7 @@ impl WorkspaceModel { WorkspaceInput::SavedConnectionsChanged => self.on_saved_connections_changed(), WorkspaceInput::WorkspaceLayoutReset(outcome) => self.on_workspace_layout_reset(outcome), WorkspaceInput::DraftsNotSaved => self.on_drafts_not_saved(), - WorkspaceInput::ShowHistory => self.on_show_history(), - WorkspaceInput::ShowSavedQueries => self.on_show_saved_queries(), + WorkspaceInput::Search(input) => self.on_search(input), WorkspaceInput::ImportCsvRequested { schema, table } => self.on_import_csv_requested(schema, table), WorkspaceInput::Transfer(input) => self.on_transfer(input), WorkspaceInput::ImportCsvReady { diff --git a/linux/crates/app/src/ui/workspace/status_pages.rs b/linux/crates/app/src/ui/workspace/status_pages.rs index 54726a264f..8e6f58e875 100644 --- a/linux/crates/app/src/ui/workspace/status_pages.rs +++ b/linux/crates/app/src/ui/workspace/status_pages.rs @@ -8,7 +8,26 @@ use super::{WorkspaceInput, WorkspaceModel}; use crate::runtime::DeliverInput; use crate::ui::plain_toast; +#[derive(Debug)] +pub(crate) enum SearchInput { + History, + SavedQueries, + QuickOpen, + CloseQuickOpen, + QuickOpenChosen(crate::ui::quick_open::Pick), +} + impl WorkspaceModel { + pub(super) fn on_search(&mut self, input: SearchInput) { + match input { + SearchInput::History => self.on_show_history(), + SearchInput::SavedQueries => self.on_show_saved_queries(), + SearchInput::QuickOpen => self.on_show_quick_open(), + SearchInput::CloseQuickOpen => self.close_quick_open(), + SearchInput::QuickOpenChosen(pick) => self.on_quick_open_chosen(pick), + } + } + pub(super) fn show_toast(&self, msg: &str) { self.add_toast(plain_toast(msg)); } @@ -85,6 +104,49 @@ impl WorkspaceModel { self.saved_queries_dialog = Some(dialog); } + pub(super) fn close_quick_open(&mut self) { + if let Some(dialog) = self.quick_open_dialog.take() { + dialog.dismiss(); + } + } + + pub(super) fn on_show_quick_open(&mut self) { + let Some(session) = self.context.active.get() else { + return; + }; + self.close_quick_open(); + let input = self.input.clone(); + let dialog = crate::ui::quick_open::QuickOpen::new(session, self.tasks.clone(), move |pick| { + input.deliver(WorkspaceInput::Search(SearchInput::QuickOpenChosen(pick))); + }); + if let Some(metadata) = self.context.active.metadata() { + dialog.include_saved_queries(self.history.clone(), metadata.id); + } + dialog.present(self.dialog_parent().as_ref()); + self.quick_open_dialog = Some(dialog); + } + + pub(super) fn on_quick_open_chosen(&mut self, pick: crate::ui::quick_open::Pick) { + if !self.is_front() { + return; + } + use crate::ui::quick_open::Pick; + self.update(match pick { + Pick::Query(sql) => WorkspaceInput::OpenHistoryQuery(sql), + Pick::Table { + table: tablepro_core::meta::TableRef { schema, name }, + structure, + } => match structure { + true => WorkspaceInput::EditStructureTab { schema, table: name }, + false => WorkspaceInput::SelectTable { + schema, + name, + open_mode: super::OpenMode::SwitchOrAppend, + }, + }, + }); + } + /// Ask what to call the SQL in front of the user, then keep it. /// /// The text is read now rather than when the dialog closes, so what @@ -241,6 +303,23 @@ mod tests { use crate::test_support::{finish_on_main, wait_until}; use crate::ui::session_window::tests::{TestWindow, WAIT}; + #[gtk4::test] + fn open_quickly_closes_on_disconnect() { + use gtk4::prelude::*; + let test = TestWindow::connected("QuickOpenDisconnect"); + let dialog = test + .workspace() + .with_model(|model| { + model.on_show_quick_open(); + model.quick_open_dialog.clone().expect("quick open") + }) + .expect("workspace"); + wait_until(WAIT, || dialog.parent().is_some()).expect("shown"); + test.window.send(crate::ui::SessionWindowInput::Disconnect); + wait_until(WAIT, || dialog.parent().is_none()).expect("dialog closed"); + wait_until(WAIT, || test.window.page_name() == "picker").expect("disconnected"); + } + #[gtk4::test] fn a_saved_query_is_written_under_a_hold() { let test = TestWindow::connected("SaveQueryHeld"); diff --git a/linux/crates/app/src/ui/workspace/tests/shell.rs b/linux/crates/app/src/ui/workspace/tests/shell.rs index 2b04b90626..603b8089e5 100644 --- a/linux/crates/app/src/ui/workspace/tests/shell.rs +++ b/linux/crates/app/src/ui/workspace/tests/shell.rs @@ -715,6 +715,38 @@ fn collect_actions(menu: &gio::MenuModel, actions: &mut Vec) { } } +#[gtk4::test] +fn open_quickly_closes_when_another_session_comes_forward() { + let sessions = super::two_sessions("QuickOpenFollowsFront", "Other"); + super::open_editor(&sessions.first); + let dialog = sessions + .first + .with_model(|model| { + model.on_show_quick_open(); + model.quick_open_dialog.clone().expect("quick open") + }) + .expect("workspace"); + wait_until(WAIT, || dialog.parent().is_some()).expect("shown"); + super::open_editor(&sessions.second); + wait_until(WAIT, || dialog.parent().is_none()).expect("old session dialog closed"); + assert_eq!(sessions.shell.front().as_ref(), Some(&sessions.second)); +} + +#[gtk4::test] +fn a_queued_quick_open_pick_does_not_reopen_a_background_session() { + let sessions = super::two_sessions("QuickOpenQueuedPick", "Other"); + super::open_editor(&sessions.second); + let before = sessions.shell.tab_view().n_pages(); + sessions.first.with_model(|model| { + model.on_quick_open_chosen(crate::ui::quick_open::Pick::Table { + table: tablepro_core::meta::TableRef::new(None, "orders"), + structure: false, + }) + }); + assert_eq!(sessions.shell.front().as_ref(), Some(&sessions.second)); + assert_eq!(sessions.shell.tab_view().n_pages(), before); +} + #[gtk4::test] fn the_header_refresh_follows_the_selected_tabs_capability() { use super::super::structure_target::StructureTarget; diff --git a/linux/crates/app/src/ui/workspace/workspace_actions.rs b/linux/crates/app/src/ui/workspace/workspace_actions.rs index 966a015f2a..5a9ecae891 100644 --- a/linux/crates/app/src/ui/workspace/workspace_actions.rs +++ b/linux/crates/app/src/ui/workspace/workspace_actions.rs @@ -23,7 +23,7 @@ type ActionInput = fn() -> WorkspaceInput; /// they are not left greyed out with no reason. const HISTORY_ACTIONS: [&str; 2] = ["show-history", "show-saved-queries"]; -const ENTRIES: [(&str, ActionInput); 9] = [ +const ENTRIES: [(&str, ActionInput); 10] = [ ("new-editor-tab", || WorkspaceInput::NewEditorTab), (EXPORT_DATABASE, || { WorkspaceInput::Transfer(TransferInput::ExportDatabase) @@ -36,8 +36,11 @@ const ENTRIES: [(&str, ActionInput); 9] = [ ("export-results", || { WorkspaceInput::ActiveTab(ActiveTabCommand::ExportResults) }), - ("show-history", || WorkspaceInput::ShowHistory), - ("show-saved-queries", || WorkspaceInput::ShowSavedQueries), + ("show-history", || WorkspaceInput::Search(super::SearchInput::History)), + ("show-saved-queries", || { + WorkspaceInput::Search(super::SearchInput::SavedQueries) + }), + ("quick-open", || WorkspaceInput::Search(super::SearchInput::QuickOpen)), (super::health_banner::REVIEW_HOST_KEY, || WorkspaceInput::ReviewHostKey), ]; diff --git a/linux/crates/app/src/ui/workspace/workspace_shell.rs b/linux/crates/app/src/ui/workspace/workspace_shell.rs index 0ae70b528f..07fe553d98 100644 --- a/linux/crates/app/src/ui/workspace/workspace_shell.rs +++ b/linux/crates/app/src/ui/workspace/workspace_shell.rs @@ -590,6 +590,13 @@ impl WorkspaceShell { if imp.front.borrow().as_ref() == workspace { return; } + let previous = imp.front.borrow().clone(); + if let Some(previous) = previous + && previous.with_model(|model| model.close_quick_open()).is_none() + && let Some(input) = previous.sender() + { + input.deliver(WorkspaceInput::Search(super::SearchInput::CloseQuickOpen)); + } imp.front.replace(workspace.cloned()); self.notify_front(); } diff --git a/linux/data/resources/gtk/menus.ui b/linux/data/resources/gtk/menus.ui index 19a4b6979d..c4e9d30aba 100644 --- a/linux/data/resources/gtk/menus.ui +++ b/linux/data/resources/gtk/menus.ui @@ -52,6 +52,11 @@
+ + _Open Quickly… + win.quick-open + action-missing + Query _History win.show-history diff --git a/linux/data/resources/shortcuts-dialog.ui b/linux/data/resources/shortcuts-dialog.ui index faac50372b..4ea257979d 100644 --- a/linux/data/resources/shortcuts-dialog.ui +++ b/linux/data/resources/shortcuts-dialog.ui @@ -27,6 +27,12 @@ <Primary>f + + + Open Quickly + win.quick-open + + Query History diff --git a/linux/docs/state-management.md b/linux/docs/state-management.md index 5aca04ebab..2ad2542ec2 100644 --- a/linux/docs/state-management.md +++ b/linux/docs/state-management.md @@ -150,6 +150,24 @@ Every `RunSummary` carries the session's `TransactionState`, and the last one a The tab emits `transaction-changed` when that flips, and the workspace reads `WorkspaceHandle::dirty_tabs` again. Through `TabDirectory::tabs` it lists the tab as `DirtyKind::OpenTransaction` when the tab has nothing else pending, so the page shows the unsaved icon and the close prompts ask about it. A close asks once: the tabs the user agreed to lose are not asked about again in that close. +## Open Quickly + +`QuickOpen` owns its session's catalog watch and explicitly reads all schemas when it opens. +Its pure `SearchIndex` prepares names and ranks candidates on a blocking worker, with a limit of +200 displayed results. Request stamps discard older index and search replies. A changed search +cannot activate the old selection; Enter waits for the current results. Catalog updates preserve +the selected object's identity, and failed reads retain the displayed content with Retry. + +The workspace closes the dialog when another session comes forward or the workspace shuts down. +Closing stops watches and cancels delivery even while the workspace still retains the widget. +Saved queries load independently for the active connection, through the same index and ranking. +Each source retains its own error, so a successful catalog refresh cannot hide a query read failure. +Choosing a saved query reads its current SQL by id, checks its connection, and opens a new editor +without running it. A reply after closing or switching connections is discarded. +Ctrl+Shift+O opens it, matching Open Quickly on macOS; Ctrl+Alt+O opens the tab overview. +Up and Down keep focus in the search entry and scroll the selection into view. Ctrl+Enter opens +structure only for objects and dialects that support it. + ## The query history dialog `HistoryDialog` reads the history a page of 100 at a time off the GTK thread, by the keyset [storage.md](storage.md#searching-the-history) describes. diff --git a/linux/po/POTFILES.in b/linux/po/POTFILES.in index 879e1aa5b7..e23f9e6500 100644 --- a/linux/po/POTFILES.in +++ b/linux/po/POTFILES.in @@ -497,6 +497,12 @@ crates/app/src/ui/preferences_dialog/history_group.rs crates/app/src/ui/preferences_dialog/imp.rs crates/app/src/ui/preferences_dialog/mcp_page.rs crates/app/src/ui/preferences_dialog/mod.rs +crates/app/src/ui/quick_open/matching.rs +crates/app/src/ui/quick_open/mod.rs +crates/app/src/ui/quick_open/query_source.rs +crates/app/src/ui/quick_open/search_index.rs +crates/app/src/ui/quick_open/tests.rs +crates/app/src/ui/quick_open/tests/queries.rs crates/app/src/ui/result_pane/mod.rs crates/app/src/ui/result_pane/result_limit_banner.rs crates/app/src/ui/result_pane/result_set_view.rs