diff --git a/CHANGELOG.md b/CHANGELOG.md index b4cc6f99..1e5761cd 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,12 @@ Release dates use Australia/Brisbane time (UTC+10). ## [Unreleased] +### Fixed + +- Preserve editor scroll positions, selections, undo history, and search sessions when + switching request, response, or documentation tabs. Keep request-section and response + Inspect list scroll positions separate for each request. + ## [2.4.0] - 2026-10-29 ### Added diff --git a/crates/desktop/src/app/chrome/environments.rs b/crates/desktop/src/app/chrome/environments.rs index 7400550a..37810f52 100644 --- a/crates/desktop/src/app/chrome/environments.rs +++ b/crates/desktop/src/app/chrome/environments.rs @@ -980,7 +980,7 @@ impl ProbeApp { crate::app::documentation::documentation_text( dialog.draft().description.as_ref(), ), - description_id, + (description_id, None), "environment-manager-description", false, move |value, _, cx| { diff --git a/crates/desktop/src/app/documentation.rs b/crates/desktop/src/app/documentation.rs index 07777a8f..24bdca7a 100644 --- a/crates/desktop/src/app/documentation.rs +++ b/crates/desktop/src/app/documentation.rs @@ -182,7 +182,7 @@ impl ProbeApp { if self.pending_overview_targets(&pending).is_empty() && self.documentation_save_task.is_none() { - self.shell.close_overview(tab); + self.remove_open_tab(crate::shell::OpenTab::Overview(tab)); self.select_and_reveal_active_request_in_sidebar(); self.reveal_active_tab(); self.persist_session(cx); diff --git a/crates/desktop/src/app/mod.rs b/crates/desktop/src/app/mod.rs index d09a369c..e6338a80 100644 --- a/crates/desktop/src/app/mod.rs +++ b/crates/desktop/src/app/mod.rs @@ -292,6 +292,8 @@ pub(crate) struct ProbeApp { request_save_task: Option>, documentation_save_task: Option>, overview_drafts: BTreeMap, + overview_editors: + std::cell::RefCell>, pending_documentation_saves: std::collections::VecDeque, environment_save_task: Option>, environment_save_workspace_path: Option, @@ -337,12 +339,9 @@ pub(crate) struct ProbeApp { destination_scroll: ScrollHandle, revealed_destination: Option, tree_scroll: UniformListScrollHandle, - inspector_scroll: UniformListScrollHandle, environment_variables_scroll: UniformListScrollHandle, - request_section_scroll: ScrollHandle, request_list_scroll: components::ListScroll, environment_list_scroll: components::ListScroll, - request_section_scroll_owner: Cell>, send_and_save_generation: u64, send_and_save_targets: BTreeMap, inspector_list_width: f32, @@ -463,6 +462,7 @@ impl ProbeApp { request_save_task: None, documentation_save_task: None, overview_drafts: BTreeMap::new(), + overview_editors: Default::default(), pending_documentation_saves: std::collections::VecDeque::new(), environment_save_task: None, environment_save_workspace_path: None, @@ -505,12 +505,9 @@ impl ProbeApp { destination_scroll: ScrollHandle::new(), revealed_destination: None, tree_scroll: UniformListScrollHandle::new(), - inspector_scroll: UniformListScrollHandle::new(), environment_variables_scroll: UniformListScrollHandle::new(), - request_section_scroll: ScrollHandle::new(), request_list_scroll: cx.new(|_| components::ListScrollState::default()), environment_list_scroll: cx.new(|_| components::ListScrollState::default()), - request_section_scroll_owner: Cell::new(None), send_and_save_generation: 0, send_and_save_targets: BTreeMap::new(), inspector_list_width: DEFAULT_INSPECT_LIST_WIDTH, diff --git a/crates/desktop/src/app/render/documentation.rs b/crates/desktop/src/app/render/documentation.rs index 3f91849d..5128072f 100644 --- a/crates/desktop/src/app/render/documentation.rs +++ b/crates/desktop/src/app/render/documentation.rs @@ -6,6 +6,7 @@ pub(super) fn documentation_sections( first_label: &'static str, values: [Option<&str>; 2], ids: [gpui_kit::ElementId; 2], + editors: [components::RetainedEditorState; 2], on_change: impl Fn(bool, gpui_kit::SharedString, &mut Window, &mut gpui_kit::App) + 'static, ) -> gpui_kit::Div { let on_change = Rc::new(on_change); @@ -15,10 +16,10 @@ pub(super) fn documentation_sections( .flex() .flex_col() .gap(px(theme.metrics.spacing_2)); - for (index, ((label, text), id)) in [first_label, "Documentation"] + for (index, ((label, text), (id, editor))) in [first_label, "Documentation"] .into_iter() .zip(values) - .zip(ids) + .zip(ids.into_iter().zip(editors)) .enumerate() { let on_change = on_change.clone(); @@ -27,7 +28,7 @@ pub(super) fn documentation_sections( theme, label, text, - id, + (id, Some(editor)), if grow { "documentation-docs-editor" } else { @@ -47,11 +48,12 @@ pub(in crate::app) fn documentation_text_field( theme: Theme, label: &'static str, text: Option<&str>, - id: gpui_kit::ElementId, + editor: (gpui_kit::ElementId, Option), container_id: &'static str, grow: bool, on_change: impl Fn(gpui_kit::SharedString, &mut Window, &mut gpui_kit::App) + 'static, ) -> gpui_kit::Div { + let (id, editor) = editor; div() .min_h(px(0.0)) .when(!grow, |section| section.flex_none()) @@ -77,6 +79,7 @@ pub(in crate::app) fn documentation_text_field( .w_full() .child(components::documentation_text_input( theme, + editor, id, text.unwrap_or_default().to_owned(), label, @@ -181,6 +184,11 @@ impl ProbeApp { documentation_text(content.docs.as_ref()), ], ids, + self.overview_editors + .borrow_mut() + .entry(target.clone()) + .or_default() + .clone(), move |docs, value, _, cx| { let _ = edit_view.update(cx, |view, cx| { view.edit_overview(edit_target.clone(), docs, value.to_string(), cx) diff --git a/crates/desktop/src/app/render/request_editor.rs b/crates/desktop/src/app/render/request_editor.rs index 5fb1eaa9..71bfd88c 100644 --- a/crates/desktop/src/app/render/request_editor.rs +++ b/crates/desktop/src/app/render/request_editor.rs @@ -209,21 +209,12 @@ impl ProbeApp { section_kind, EditorSection::Body | EditorSection::Docs | EditorSection::WebSocketMessage ) && !section_kind.is_graphql(); - if section_scrolls && self.request_section_scroll_owner.get() != Some((key, section_kind)) { - self.request_section_scroll - .set_offset(point(px(0.0), px(0.0))); - self.request_section_scroll_owner - .set(Some((key, section_kind))); - } + let section_scroll = self.request_editor.scroll(key, section_kind); let list_scroll = section_scrolls.then_some(&self.request_list_scroll); let section = self.render_request_section(key, &request, theme, list_scroll, cx); let section = if section_scrolls { - components::list_scroll_region( - section, - &self.request_section_scroll, - &self.request_list_scroll, - ) - .into_any_element() + components::list_scroll_region(section, §ion_scroll, &self.request_list_scroll) + .into_any_element() } else { section }; @@ -469,7 +460,7 @@ impl ProbeApp { .when(section_scrolls, |content| { content .overflow_y_scroll() - .track_scroll(&self.request_section_scroll) + .track_scroll(§ion_scroll) }) .child(section), ) @@ -500,6 +491,10 @@ impl ProbeApp { ("request-description", key.slot()).into(), ("request-docs", key.slot()).into(), ], + [ + self.request_editor.editor(key, "request-description"), + self.request_editor.editor(key, "request-docs"), + ], move |docs, value, _, cx| { let _ = view.update(cx, |view, cx| { view.edit_request( diff --git a/crates/desktop/src/app/render/request_editor/body.rs b/crates/desktop/src/app/render/request_editor/body.rs index 3c2d5377..45eac30e 100644 --- a/crates/desktop/src/app/render/request_editor/body.rs +++ b/crates/desktop/src/app/render/request_editor/body.rs @@ -56,7 +56,16 @@ impl ProbeApp { .min_h(px(0.0)) .child(components::body_text_input( theme, - ("request-body", key.slot()), + self.request_editor.editor( + key, + match raw.kind { + RawBodyKind::Json => "body-json", + RawBodyKind::Xml => "body-xml", + RawBodyKind::Sparql => "body-sparql", + _ => "body-text", + }, + ), + format!("request-body-{}-{:?}", key.slot(), raw.kind), raw.data.clone(), match raw.kind { RawBodyKind::Json => components::BodySyntax::Json, diff --git a/crates/desktop/src/app/render/request_editor/graphql.rs b/crates/desktop/src/app/render/request_editor/graphql.rs index 0789ee87..113d4554 100644 --- a/crates/desktop/src/app/render/request_editor/graphql.rs +++ b/crates/desktop/src/app/render/request_editor/graphql.rs @@ -27,6 +27,7 @@ impl ProbeApp { .min_h(px(0.0)) .child(components::body_text_input( theme, + self.request_editor.editor(key, "graphql-query"), ("graphql-query", key.slot()), query.to_owned(), components::BodySyntax::Plain, @@ -74,6 +75,7 @@ impl ProbeApp { .min_h(px(0.0)) .child(components::body_text_input( theme, + self.request_editor.editor(key, "graphql-variables"), ("graphql-variables", key.slot()), variables, components::BodySyntax::Json, @@ -177,6 +179,7 @@ impl ProbeApp { .min_h(px(0.0)) .child(components::body_text_input( theme, + self.request_editor.editor(key, "graphql-extensions"), ("graphql-extensions", key.slot()), extensions, components::BodySyntax::Json, diff --git a/crates/desktop/src/app/render/request_editor/websocket.rs b/crates/desktop/src/app/render/request_editor/websocket.rs index 6f156e4c..f60fa7ea 100644 --- a/crates/desktop/src/app/render/request_editor/websocket.rs +++ b/crates/desktop/src/app/render/request_editor/websocket.rs @@ -105,6 +105,7 @@ impl ProbeApp { .min_h(px(0.0)) .child(components::body_text_input( theme, + self.request_editor.editor(key, "websocket-message"), ("websocket-message", key.slot()), message.data.clone(), match kind { diff --git a/crates/desktop/src/app/render/response.rs b/crates/desktop/src/app/render/response.rs index 62050fbc..da7dfaf4 100644 --- a/crates/desktop/src/app/render/response.rs +++ b/crates/desktop/src/app/render/response.rs @@ -896,7 +896,7 @@ impl ProbeApp { let list = match self.response_viewer.tab(key) { ResponseViewerTab::Assertions => self.render_assertion_results(key, theme, cx), - ResponseViewerTab::Headers => self.render_response_headers(theme, document, cx), + ResponseViewerTab::Headers => self.render_response_headers(theme, key, document, cx), ResponseViewerTab::Inspect => self.render_response_inspector(theme, key, document, cx), ResponseViewerTab::Pretty if document.is_image() => { self.render_response_image(theme, key, document) @@ -1076,7 +1076,14 @@ impl ProbeApp { .min_h(px(0.0)) .child(components::response_body_input( theme, - "response-body-editor", + self.response_viewer + .editor(key, self.response_viewer.tab(key)), + format!( + "response-body-editor-{}-{:?}-{:?}", + document.generation, + self.response_viewer.tab(key), + self.response_viewer.raw_view(key) + ), text, components::ResponseBodyInputOptions::new( if self.response_viewer.tab(key) == ResponseViewerTab::Pretty { @@ -1160,6 +1167,7 @@ impl ProbeApp { pub(super) fn render_response_headers( &self, theme: Theme, + key: probe_core::RequestKey, document: &PreparedDocument, cx: &mut Context, ) -> gpui_kit::AnyElement { @@ -1174,7 +1182,8 @@ impl ProbeApp { .min_h(px(0.0)) .child(components::response_headers_input( theme, - "response-headers-editor", + self.response_viewer.editor(key, ResponseViewerTab::Headers), + format!("response-headers-editor-{}", document.generation), &document.headers, move |range, cx| { #[cfg(test)] @@ -1203,7 +1212,8 @@ impl ProbeApp { if let Some(selection) = self.pending_inspector_reveal.take() && let Some(index) = inspect_row_index(&rows, selection) { - self.inspector_scroll + self.response_viewer + .inspector_scroll(key) .scroll_to_item(index, ScrollStrategy::Nearest); } let selected = self.response_viewer.inspection_selection(key); @@ -1234,7 +1244,7 @@ impl ProbeApp { }) }) .size_full() - .track_scroll(&self.inspector_scroll); + .track_scroll(self.response_viewer.inspector_scroll(key)); if row_count == 0 && !document.inspection_pending { return Self::inspect_tab_content_boundary( @@ -1299,7 +1309,8 @@ impl ProbeApp { .size_full() .child(components::response_inspector_input( theme, - "response-inspector-editor", + self.response_viewer.editor(key, ResponseViewerTab::Inspect), + format!("response-inspector-editor-{}", document.generation), detail, move |range, cx| { #[cfg(test)] diff --git a/crates/desktop/src/app/render/websocket.rs b/crates/desktop/src/app/render/websocket.rs index e8879793..ec5a7d1d 100644 --- a/crates/desktop/src/app/render/websocket.rs +++ b/crates/desktop/src/app/render/websocket.rs @@ -279,6 +279,7 @@ impl ProbeApp { .flex_col() .child(components::websocket_composer( theme, + self.request_editor.editor(key, "websocket-composer"), ("websocket-draft", key.slot()).into(), state.map(|s| s.draft.clone()).unwrap_or_default(), connected, diff --git a/crates/desktop/src/app/tabs.rs b/crates/desktop/src/app/tabs.rs index ec4ec7fe..394b1c85 100644 --- a/crates/desktop/src/app/tabs.rs +++ b/crates/desktop/src/app/tabs.rs @@ -219,8 +219,16 @@ impl ProbeApp { cx.notify(); } - fn remove_open_tab(&mut self, tab: crate::shell::OpenTab) { - self.shell.close(tab); + pub(super) fn remove_open_tab(&mut self, tab: crate::shell::OpenTab) { + if let crate::shell::OpenTab::Overview(overview) = tab + && let Some(target) = self.overview_target(overview) + { + self.overview_editors.get_mut().remove(&target); + } + match tab { + crate::shell::OpenTab::Overview(overview) => self.shell.close_overview(overview), + crate::shell::OpenTab::Request(_) => self.shell.close(tab), + } let crate::shell::OpenTab::Request(key) = tab else { return; }; @@ -754,7 +762,7 @@ impl ProbeApp { .map(crate::shell::OverviewTab::Folder), }; if let Some(tab) = tab { - self.shell.close_overview(tab); + self.remove_open_tab(crate::shell::OpenTab::Overview(tab)); } self.select_and_reveal_active_request_in_sidebar(); self.reveal_active_tab(); diff --git a/crates/desktop/src/app/tests.rs b/crates/desktop/src/app/tests.rs index 69968e69..84e66e8e 100644 --- a/crates/desktop/src/app/tests.rs +++ b/crates/desktop/src/app/tests.rs @@ -1400,6 +1400,7 @@ fn writable_structure_fixture(suffix: &str) -> PathBuf { mod assertions; mod curl_import; +mod editor_state; mod environments; mod graphql; mod interactions; diff --git a/crates/desktop/src/app/tests/editor_state.rs b/crates/desktop/src/app/tests/editor_state.rs new file mode 100644 index 00000000..8ca209eb --- /dev/null +++ b/crates/desktop/src/app/tests/editor_state.rs @@ -0,0 +1,450 @@ +use super::*; +use gpui_kit::{Entity, WindowHandle, base::input::EditorState}; +use probe_core::{ + Body, GraphqlBody, GraphqlBodyVariant, GraphqlOperation, RawBody, RawBodyKind, RequestBody, + RequestKind, +}; + +fn select_editor( + window: WindowHandle, + key: probe_core::RequestKey, + section: EditorSection, + slot: &'static str, + cx: &mut TestAppContext, +) -> Entity { + window + .update(cx, |view, _, cx| { + view.select_request(key, cx); + view.request_editor.set_section(key, section); + cx.notify(); + }) + .unwrap(); + cx.run_until_parked(); + window + .update(cx, |view, window, cx| { + let editor = view.request_editor.editor(key, slot).editor(cx); + editor.update(cx, |editor, cx| editor.focus(window, cx)); + editor + }) + .unwrap() +} + +fn editor_workspace( + cx: &mut TestAppContext, +) -> (WindowHandle, [probe_core::RequestKey; 3]) { + cx.update(Theme::init); + cx.update(bind_platform_hotkeys); + let window = cx.open_window(size(px(1180.0), px(780.0)), ProbeApp::new); + let fixture = bundled_fixture(); + let mut workspace = probe_opencollection::load_workspace(&fixture).unwrap(); + let http = workspace.requests()[0].key(); + let text = "needle row\n".repeat(100); + let request = workspace.request_mut(http).unwrap(); + request.kind = RequestKind::Http { + body: Some(RequestBody::Single(Body::Raw(RawBody { + kind: RawBodyKind::Text, + data: text.clone(), + }))), + }; + request.docs = Some(text.clone()); + let object = serde_json::from_value::>( + serde_json::json!({"rows": vec!["needle"; 100]}), + ) + .unwrap(); + let operation = GraphqlOperation { + query: Some(text.clone()), + variables: Some(object.clone()), + extensions: Some(object), + ..Default::default() + }; + let graphql = workspace.requests()[1].key(); + workspace.request_mut(graphql).unwrap().kind = RequestKind::Graphql { + body: Some(GraphqlBody::Variants( + [true, false] + .map(|selected| GraphqlBodyVariant { + title: "Same title".into(), + selected, + body: operation.clone(), + }) + .into(), + )), + }; + let websocket = workspace.add_detached_request(Request { + kind: RequestKind::WebSocket { + message: Some(probe_core::WebSocketMessageSet::Single( + probe_core::WebSocketMessage { + kind: probe_core::WebSocketMessageKind::Text, + data: text.clone(), + }, + )), + }, + ..Default::default() + }); + window + .update(cx, |view, _, cx| { + view.session_store = None; + view.set_workspace(fixture, workspace); + let (cancel, _) = oneshot::channel(); + view.websocket.begin(websocket, cancel); + let session = view.websocket.sessions.get_mut(&websocket).unwrap(); + session.state = crate::websocket::ConnectionState::Connected; + session.draft = text; + view.select_request(http, cx); + }) + .unwrap(); + cx.run_until_parked(); + + (window, [http, graphql, websocket]) +} + +#[gpui_kit::test] +fn request_editors_keep_sessions_across_sections_and_requests(cx: &mut TestAppContext) { + let (window, [http, graphql, websocket]) = editor_workspace(cx); + for (key, section, slot) in [ + (http, EditorSection::Body, "body-text"), + (http, EditorSection::Docs, "request-docs"), + (graphql, EditorSection::GraphqlQuery, "graphql-query"), + ( + graphql, + EditorSection::GraphqlVariables, + "graphql-variables", + ), + ( + graphql, + EditorSection::GraphqlExtensions, + "graphql-extensions", + ), + ( + websocket, + EditorSection::WebSocketMessage, + "websocket-message", + ), + ( + websocket, + EditorSection::WebSocketMessage, + "websocket-composer", + ), + ] { + let editor = select_editor(window, key, section, slot, cx); + // Exercise shared editor behavior once; other rows check their wiring. + let http_body = key == http && section == EditorSection::Body; + let original = editor.read_with(cx, |editor, _| editor.value()); + if http_body { + cx.simulate_input(window.into(), "edited"); + cx.simulate_keystrokes(window.into(), find_shortcut()); + cx.simulate_input(window.into(), "needle"); + cx.run_until_parked(); + editor.update(cx, |editor, cx| editor.next_search_match(cx)); + } + let selection = if http_body { 110..116 } else { 0..6 }; + editor.update(cx, |editor, cx| { + editor.set_selected_range(selection.clone(), cx) + }); + cx.run_until_parked(); + if http_body { + editor.update(cx, |editor, cx| { + editor.set_scroll_offset(point(px(0.0), px(-100.0)), cx) + }); + cx.run_until_parked(); + } + let (offset, match_index) = editor.read_with(cx, |editor, _| { + ( + editor.scroll_offset(), + editor.search_session().matcher.current_match_index(), + ) + }); + // Unmount the section, then leave the request. Each editor must retain + // its session through both transitions; restore it only once. + window + .update(cx, |view, _, cx| { + view.request_editor.set_section(key, EditorSection::Headers); + cx.notify(); + }) + .unwrap(); + cx.run_until_parked(); + window + .update(cx, |view, _, cx| { + view.select_request(if key == http { graphql } else { http }, cx); + }) + .unwrap(); + cx.run_until_parked(); + let restored = select_editor(window, key, section, slot, cx); + assert_eq!( + restored.read_with(cx, |state, _| state.selected_range()), + selection, + "{slot}" + ); + if http_body { + cx.run_until_parked(); + restored.read_with(cx, |editor, _| { + assert!(offset.y < px(0.0)); + assert!(match_index > 0); + assert_eq!(editor.scroll_offset(), offset); + assert!(editor.search_session().is_active()); + assert_eq!(editor.search_session().query, "needle"); + assert_eq!( + editor.search_session().matcher.current_match_index(), + match_index + ); + }); + let mut visual = VisualTestContext::from_window(window.into(), cx); + assert!(visual.debug_bounds("editor-search-card").is_some()); + cx.simulate_keystrokes(window.into(), "escape"); + window + .update(cx, |_, window, cx| { + window.dispatch_action(Box::new(gpui_kit::base::input::Undo), cx); + }) + .unwrap(); + cx.run_until_parked(); + assert_eq!(restored.read_with(cx, |editor, _| editor.value()), original); + } + } + let editor = select_editor(window, http, EditorSection::Body, "body-text", cx); + let weak = editor.downgrade(); + drop(editor); + window + .update(cx, |view, _, cx| { + view.remove_open_tab(crate::shell::OpenTab::Request(http)); + cx.notify(); + }) + .unwrap(); + cx.run_until_parked(); + assert!( + weak.upgrade().is_none(), + "closing the tab releases its native editor" + ); +} + +#[gpui_kit::test] +fn overview_editor_keeps_session_until_closed(cx: &mut TestAppContext) { + let (window, [request, ..]) = editor_workspace(cx); + let overview = crate::shell::OverviewTab::Collection; + window + .update(cx, |view, _, cx| { + view.select_open_tab(crate::shell::OpenTab::Overview(overview), cx); + }) + .unwrap(); + cx.run_until_parked(); + let target = super::super::documentation::OverviewTarget::Collection; + let editor = window + .update(cx, |view, window, cx| { + let editor = view.overview_editors.borrow()[&target][1].editor(cx); + editor.update(cx, |editor, cx| editor.focus(window, cx)); + editor + }) + .unwrap(); + cx.simulate_input(window.into(), "additional documentation"); + cx.run_until_parked(); + let selection = editor.read_with(cx, |editor, _| editor.selected_range()); + window + .update(cx, |view, _, cx| view.select_request(request, cx)) + .unwrap(); + cx.run_until_parked(); + window + .update(cx, |view, _, cx| { + view.select_open_tab(crate::shell::OpenTab::Overview(overview), cx) + }) + .unwrap(); + cx.run_until_parked(); + window + .read_with(cx, |view, cx| { + let restored = view.overview_editors.borrow()[&target][1].editor(cx); + assert_eq!(restored, editor); + assert_eq!(restored.read(cx).selected_range(), selection); + }) + .unwrap(); + window + .update(cx, |view, _, _| { + view.remove_open_tab(crate::shell::OpenTab::Overview(overview)); + assert!(!view.overview_editors.borrow().contains_key(&target)); + }) + .unwrap(); +} + +#[gpui_kit::test] +fn graphql_reload_keeps_unchanged_sessions_but_resets_changed_operations(cx: &mut TestAppContext) { + let (window, [_, key, _]) = editor_workspace(cx); + let fixture = bundled_fixture(); + let docs = select_editor(window, key, EditorSection::Docs, "request-description", cx); + cx.simulate_input(window.into(), "documentation"); + cx.run_until_parked(); + let docs_selection = docs.read_with(cx, |editor, _| editor.selected_range()); + let mut editors = Vec::new(); + for (section, slot) in [ + (EditorSection::GraphqlQuery, "graphql-query"), + (EditorSection::GraphqlVariables, "graphql-variables"), + (EditorSection::GraphqlExtensions, "graphql-extensions"), + ] { + let editor = select_editor(window, key, section, slot, cx); + if section != EditorSection::GraphqlQuery { + editor.update(cx, |editor, cx| { + editor.set_selected_range(0..editor.value().len(), cx) + }); + } + cx.simulate_input( + window.into(), + if section == EditorSection::GraphqlQuery { + "edited" + } else { + "invalid" + }, + ); + cx.run_until_parked(); + editors.push((section, slot, editor)); + } + let expected_query = editors[0].2.read_with(cx, |editor, _| editor.value()); + for changed in [false, true] { + let key = window + .update(cx, |view, _, cx| { + let mut fresh = probe_opencollection::load_workspace(&fixture).unwrap(); + let current = view.loaded_workspace.as_ref().unwrap(); + let mut request = current + .workspace() + .request(current.requests()[1].key()) + .unwrap() + .clone(); + if changed + && let RequestKind::Graphql { + body: Some(GraphqlBody::Variants(variants)), + } = &mut request.kind + { + // The new operation has identical text and a duplicate title. + variants[1].body = variants[0].body.clone(); + variants[0].selected = false; + variants[1].selected = true; + } + let key = fresh.requests()[1].key(); + *fresh.request_mut(key).unwrap() = request; + view.apply_reconciled_workspace(reconciled_workspace(fresh), cx); + key + }) + .unwrap(); + assert_eq!( + select_editor(window, key, EditorSection::Docs, "request-description", cx), + docs + ); + assert_eq!( + docs.read_with(cx, |editor, _| editor.selected_range()), + docs_selection + ); + for (section, slot, _) in &editors { + let restored = select_editor(window, key, *section, slot, cx); + if *section == EditorSection::GraphqlQuery { + window + .update(cx, |_, window, cx| { + window.dispatch_action(Box::new(gpui_kit::base::input::Undo), cx); + }) + .unwrap(); + cx.run_until_parked(); + if !changed { + assert_ne!( + restored.read_with(cx, |editor, _| editor.value()), + expected_query + ); + window + .update(cx, |_, window, cx| { + window.dispatch_action(Box::new(gpui_kit::base::input::Redo), cx); + }) + .unwrap(); + cx.run_until_parked(); + } + assert_eq!( + restored.read_with(cx, |editor, _| editor.value()), + expected_query + ); + } else { + assert_eq!( + restored.read_with(cx, |editor, _| editor.value()) == "invalid", + !changed, + "{slot}" + ); + } + } + } +} + +#[gpui_kit::test] +fn websocket_variant_reload_resets_message_undo_but_keeps_composer(cx: &mut TestAppContext) { + use probe_core::{ + WebSocketMessage, WebSocketMessageKind, WebSocketMessageSet, WebSocketMessageVariant, + }; + let (window, [key, ..]) = editor_workspace(cx); + let section = EditorSection::WebSocketMessage; + window + .update(cx, |view, _, _| { + let message = WebSocketMessage { + kind: WebSocketMessageKind::Text, + data: "message".into(), + }; + let loaded = view.loaded_workspace.as_mut().unwrap(); + loaded.request_mut(key).unwrap().kind = RequestKind::WebSocket { + message: Some(WebSocketMessageSet::Variants( + [true, false] + .map(|selected| WebSocketMessageVariant { + title: "Same title".into(), + selected, + message: message.clone(), + }) + .into(), + )), + }; + let (cancel, _) = oneshot::channel(); + view.websocket.begin(key, cancel); + let session = view.websocket.sessions.get_mut(&key).unwrap(); + session.state = crate::websocket::ConnectionState::Connected; + session.draft = "live draft".into(); + }) + .unwrap(); + let composer = select_editor(window, key, section, "websocket-composer", cx); + let message = select_editor(window, key, section, "websocket-message", cx); + cx.simulate_input(window.into(), "edited"); + cx.run_until_parked(); + let expected = message.read_with(cx, |editor, _| editor.value()); + let key = window + .update(cx, |view, _, cx| { + let mut fresh = probe_opencollection::load_workspace(bundled_fixture()).unwrap(); + let loaded = view.loaded_workspace.as_ref().unwrap(); + let mut request = loaded.workspace().request(key).unwrap().clone(); + let RequestKind::WebSocket { + message: Some(WebSocketMessageSet::Variants(variants)), + } = &mut request.kind + else { + panic!("expected configured message variants"); + }; + // Switch variants without changing the displayed text or title. + variants[1].message = variants[0].message.clone(); + variants[0].selected = false; + variants[1].selected = true; + let key = fresh.requests()[0].key(); + *fresh.request_mut(key).unwrap() = request; + view.apply_reconciled_workspace(reconciled_workspace(fresh), cx); + key + }) + .unwrap(); + assert_eq!( + select_editor(window, key, section, "websocket-composer", cx), + composer + ); + assert_eq!( + composer.read_with(cx, |editor, _| editor.value()), + "live draft" + ); + let restored = select_editor(window, key, section, "websocket-message", cx); + window + .update(cx, |_, window, cx| { + window.dispatch_action(Box::new(gpui_kit::base::input::Undo), cx) + }) + .unwrap(); + cx.run_until_parked(); + assert_eq!(restored.read_with(cx, |editor, _| editor.value()), expected); + window + .read_with(cx, |view, _| { + let loaded = view.loaded_workspace.as_ref().unwrap(); + let request = loaded.workspace().request(key).unwrap(); + assert_eq!( + request.selected_websocket_message().unwrap().unwrap().data, + expected.as_ref() + ); + }) + .unwrap(); +} diff --git a/crates/desktop/src/app/tests/response.rs b/crates/desktop/src/app/tests/response.rs index d2d3d1bc..5932d3c0 100644 --- a/crates/desktop/src/app/tests/response.rs +++ b/crates/desktop/src/app/tests/response.rs @@ -361,6 +361,7 @@ fn completed_response_renders_pretty_raw_headers_and_search(cx: &mut TestAppCont .expect("fixture should exist"); let workspace = probe_opencollection::load_workspace(&fixture).expect("fixture should load"); let request_key = workspace.requests()[0].key(); + let other_request = workspace.requests()[1].key(); window .update(cx, |view, _, cx| { view.session_store = None; @@ -368,7 +369,11 @@ fn completed_response_renders_pretty_raw_headers_and_search(cx: &mut TestAppCont view.select_request(request_key, cx); let (cancellation, _) = tokio::sync::oneshot::channel(); let generation = view.execution.begin(request_key, cancellation); - let body = br#"{"createdAt":1787482800,"ok":true}"#.to_vec(); + let body = format!( + r#"{{"createdAt":1787482800,"ok":true,"rows":{:?}}}"#, + (0..200).collect::>() + ) + .into_bytes(); view.complete_execution( request_key, generation, @@ -477,10 +482,57 @@ fn completed_response_renders_pretty_raw_headers_and_search(cx: &mut TestAppCont .expect("test window should remain open"); cx.simulate_keystrokes(window.into(), "o k"); cx.run_until_parked(); + let editor = window + .update(cx, |view, _, cx| { + let editor = view + .response_viewer + .editor(request_key, ResponseViewerTab::Pretty) + .editor(cx); + editor.update(cx, |editor, cx| { + editor.set_scroll_offset(gpui_kit::point(px(0.0), px(-400.0)), cx) + }); + editor + }) + .unwrap(); + cx.run_until_parked(); + let offset = editor.read_with(cx, |editor, _| editor.scroll_offset()); + assert!(offset.y < px(0.0)); + for response_tab in [ResponseViewerTab::Raw, ResponseViewerTab::Headers] { + window + .update(cx, |view, _, cx| view.set_response_tab(response_tab, cx)) + .unwrap(); + cx.run_until_parked(); + { + let mut visual = VisualTestContext::from_window(window.into(), cx); + assert!(visual.debug_bounds("editor-search-card").is_none()); + } + } + window + .update(cx, |view, _, cx| view.select_request(other_request, cx)) + .unwrap(); + cx.run_until_parked(); + window + .update(cx, |view, _, cx| { + view.select_request(request_key, cx); + view.set_response_tab(ResponseViewerTab::Pretty, cx); + }) + .unwrap(); + cx.run_until_parked(); + window + .update(cx, |view, _, cx| { + let restored = view + .response_viewer + .editor(request_key, ResponseViewerTab::Pretty) + .editor(cx); + assert_eq!(restored.read(cx).scroll_offset(), offset); + assert_eq!(restored.read(cx).search_session().query, "ok"); + }) + .unwrap(); + // Returning to a tab preserves its open search without stealing focus. { let mut visual = VisualTestContext::from_window(window.into(), cx); - assert!(visual.debug_bounds("editor-search-card").is_some()); - assert!(visual.debug_bounds("response-body").is_some()); + let input = visual.debug_bounds("editor-search-input").unwrap(); + visual.simulate_click(input.center(), Modifiers::default()); } cx.simulate_keystrokes(window.into(), "escape"); cx.run_until_parked(); diff --git a/crates/desktop/src/app/tests/workspace.rs b/crates/desktop/src/app/tests/workspace.rs index 84a02985..ca8556f4 100644 --- a/crates/desktop/src/app/tests/workspace.rs +++ b/crates/desktop/src/app/tests/workspace.rs @@ -394,9 +394,7 @@ fn new_request_tabs_are_in_memory_and_editable(cx: &mut TestAppContext) { #[gpui_kit::test] fn request_editor_lists_scroll_when_the_pointer_is_over_a_field(cx: &mut TestAppContext) { cx.update(Theme::init); - let window = cx.open_window(size(px(1180.0), px(780.0)), |window, cx| { - ProbeApp::new(window, cx) - }); + let window = cx.open_window(size(px(1180.0), px(780.0)), ProbeApp::new); let fixture = bundled_fixture().canonicalize().unwrap(); let workspace = probe_opencollection::load_workspace(&fixture).unwrap(); window @@ -448,7 +446,8 @@ fn request_editor_lists_scroll_when_the_pointer_is_over_a_field(cx: &mut TestApp .update(cx, |view, _, cx| { let key = view.shell.active_tab().unwrap(); view.request_editor.set_section(key, section); - view.request_section_scroll + view.request_editor + .scroll(key, section) .set_offset(point(px(0.0), px(0.0))); cx.notify(); }) @@ -480,13 +479,53 @@ fn request_editor_lists_scroll_when_the_pointer_is_over_a_field(cx: &mut TestApp }); assert_eq!( window - .update(cx, |view, _, _| view.request_section_scroll.offset().y) + .update(cx, |view, _, _| view + .request_editor + .scroll(view.shell.active_tab().unwrap(), section) + .offset() + .y) .unwrap(), px(-8.0), "scroll wiring for {section:?}, value column: {value_column}" ); } } + let (key, other) = window + .read_with(cx, |view, _| { + ( + view.shell.active_tab().unwrap(), + view.loaded_workspace.as_ref().unwrap().requests()[0].key(), + ) + }) + .unwrap(); + window + .update(cx, |view, _, cx| { + view.request_editor + .scroll(key, EditorSection::Headers) + .set_offset(point(px(0.0), px(-120.0))); + view.select_request(other, cx); + view.request_editor + .set_section(other, EditorSection::Headers); + }) + .unwrap(); + visual.run_until_parked(); + window + .update(cx, |view, _, cx| { + let other_headers = view.request_editor.scroll(other, EditorSection::Headers); + assert_eq!(other_headers.offset().y, px(0.0)); + view.select_request(key, cx); + view.request_editor.set_section(key, EditorSection::Headers); + }) + .unwrap(); + visual.run_until_parked(); + window + .read_with(cx, |view, _| { + let headers = view.request_editor.scroll(key, EditorSection::Headers); + let path = view.request_editor.scroll(key, EditorSection::Path); + assert_eq!(headers.offset().y, px(-120.0)); + assert_eq!(path.offset().y, px(-8.0)); + }) + .unwrap(); } #[gpui_kit::test] @@ -3143,10 +3182,18 @@ fn filesystem_reload_merges_against_disk_baselines_and_use_disk_discards_edits( cx: &mut TestAppContext, ) { cx.update(Theme::init); - let window = cx.open_window(size(px(900.0), px(640.0)), |window, cx| { - ProbeApp::new(window, cx) - }); + let window = cx.open_window(size(px(900.0), px(640.0)), ProbeApp::new); let fixture = writable_bundled_fixture("filesystem-reload"); + // Keep the GraphQL body unchanged on disk, so Use Disk must reset a + // rejected variables draft even though its model value never changed. + let source = fs::read_to_string(&fixture).unwrap(); + fs::write( + &fixture, + source + .replacen("type: http", "type: graphql", 1) + .replacen("http:", "graphql:", 1), + ) + .unwrap(); let workspace = probe_opencollection::load_workspace(&fixture).unwrap(); let selector = workspace.requests()[0].selector().to_owned(); let key = workspace.requests()[0].key(); @@ -3154,6 +3201,9 @@ fn filesystem_reload_merges_against_disk_baselines_and_use_disk_discards_edits( .update(cx, |view, _, cx| { view.session_store = None; view.set_workspace(fixture.clone(), workspace); + view.select_request(key, cx); + view.request_editor + .set_section(key, EditorSection::GraphqlVariables); view.edit_request( key, |request| request.url = Some("https://local.example/draft".to_owned()), @@ -3162,6 +3212,18 @@ fn filesystem_reload_merges_against_disk_baselines_and_use_disk_discards_edits( }) .unwrap(); + cx.run_until_parked(); + window + .update(cx, |view, window, cx| { + let editor = view + .request_editor + .editor(key, "graphql-variables") + .editor(cx); + editor.update(cx, |editor, cx| editor.focus(window, cx)); + }) + .unwrap(); + cx.simulate_input(window.into(), "invalid"); + cx.run_until_parked(); let source = fs::read_to_string(&fixture).unwrap(); fs::write(&fixture, source.replacen("method: GET", "method: PATCH", 1)).unwrap(); let fresh = probe_opencollection::load_workspace(&fixture).unwrap(); @@ -3194,19 +3256,30 @@ fn filesystem_reload_merges_against_disk_baselines_and_use_disk_discards_edits( view.application_dialog, Some(ApplicationDialog::FilesystemConflict { .. }) )); + let active = view.shell.active_tab().unwrap(); + let variables = view + .request_editor + .editor(active, "graphql-variables") + .editor(cx); + assert_eq!(variables.read(cx).value(), "invalid"); view.handle_application_dialog_action(ApplicationDialogAction::UseDisk, window, cx); }) .unwrap(); cx.run_until_parked(); window - .update(cx, |view, _, _| { + .update(cx, |view, _, cx| { let loaded = view.loaded_workspace.as_ref().unwrap(); let key = loaded.request_key(&selector).unwrap(); let request = loaded.workspace().request(key).unwrap(); assert_eq!(request.method.as_deref(), Some("PUT")); assert_eq!(request.url.as_deref(), Some("https://api.example.com/pets")); assert!(!view.persistence.is_dirty(key, request)); + let restored = view + .request_editor + .editor(key, "graphql-variables") + .editor(cx); + assert_eq!(restored.read(cx).value(), ""); }) .unwrap(); fs::remove_file(fixture).unwrap(); @@ -3936,13 +4009,11 @@ fn restored_active_tab_highlights_matching_sidebar_request(cx: &mut TestAppConte } #[gpui_kit::test] -fn workspace_reload_preserves_request_section_scroll_owner_after_multiple_remaps( +fn workspace_reload_preserves_request_section_scroll_after_multiple_remaps( cx: &mut TestAppContext, ) { cx.update(Theme::init); - let window = cx.open_window(size(px(900.0), px(640.0)), |window, cx| { - ProbeApp::new(window, cx) - }); + let window = cx.open_window(size(px(900.0), px(640.0)), ProbeApp::new); let fixture = writable_bundled_fixture("reload-scroll-owner-multi"); let workspace = probe_opencollection::load_workspace(&fixture).unwrap(); window @@ -3950,14 +4021,10 @@ fn workspace_reload_preserves_request_section_scroll_owner_after_multiple_remaps view.session_store = None; view.set_workspace(fixture.clone(), workspace); - let old = view.loaded_workspace.as_ref().unwrap(); - let old_key = old.requests()[0].key(); + let old_key = view.loaded_workspace.as_ref().unwrap().requests()[0].key(); view.select_request(old_key, cx); view.request_editor .set_section(old_key, EditorSection::Headers); - - view.request_section_scroll_owner - .set(Some((old_key, EditorSection::Headers))); }) .unwrap(); @@ -3965,13 +4032,18 @@ fn workspace_reload_preserves_request_section_scroll_owner_after_multiple_remaps window .update(cx, |view, _, _| { let old_key = view.shell.active_tab().unwrap(); + view.request_editor + .scroll(old_key, EditorSection::Headers) + .set_offset(point(px(0.0), px(-120.0))); let new_key = reload_unchanged_fixture(view, &fixture)[&old_key]; - let scroll_owner = view.request_section_scroll_owner.get(); assert_eq!( - scroll_owner, - Some((new_key, EditorSection::Headers)), - "scroll owner should be remapped after reload {iteration}" + view.request_editor + .scroll(new_key, EditorSection::Headers) + .offset() + .y, + px(-120.0), + "scroll position should be remapped after reload {iteration}" ); }) .unwrap(); diff --git a/crates/desktop/src/app/workspace.rs b/crates/desktop/src/app/workspace.rs index be901d23..70589e76 100644 --- a/crates/desktop/src/app/workspace.rs +++ b/crates/desktop/src/app/workspace.rs @@ -853,6 +853,13 @@ impl ProbeApp { .collect::>(); let result = reconcile(&clean_local, workspace, &BTreeMap::new()); if let ReconcileResult::Applied(reconciled) = result { + // Use Disk also discards rejected drafts that never reached + // the model. Detached requests are not replaced by disk. + if let Some(loaded) = &view.loaded_workspace { + for request in loaded.requests() { + view.request_editor.invalidate_editors(request.key()); + } + } view.apply_reconciled_workspace(*reconciled, cx); view.pending_environment_saves.clear(); view.failed_environment_saves.clear(); @@ -902,6 +909,7 @@ impl ProbeApp { } pub(super) fn reset_collection_ui(&mut self) { + self.overview_editors.get_mut().clear(); self.overview_drafts.clear(); self.pending_documentation_saves.clear(); self.documentation_save_task = None; @@ -1046,6 +1054,18 @@ impl ProbeApp { let new_key = workspace.add_detached_request(request); remaps.insert(old_key, new_key); } + // Changed protocol bodies may select a different variant with identical + // displayed text. Drop only their editors before remapping. + for (previous_key, current_key) in &remaps { + if let Some((previous, current)) = old + .workspace() + .request(*previous_key) + .zip(workspace.workspace().request(*current_key)) + { + self.request_editor + .invalidate_changed_editors(*previous_key, previous, current); + } + } self.detached_requests.remap(&remaps); self.persistence.reset(baselines); self.loaded_workspace = Some(workspace); @@ -1056,14 +1076,6 @@ impl ProbeApp { self.websocket.remap_requests(&remaps); self.response_viewer.remap_requests(&remaps); self.request_editor.remap_requests(&remaps); - if let Some((old_key, section)) = self.request_section_scroll_owner.get() { - self.request_section_scroll_owner.set( - remaps - .get(&old_key) - .copied() - .map(|new_key| (new_key, section)), - ); - } self.send_and_save_targets.retain(|_, key| { remaps.get(key).is_some_and(|new_key| { *key = *new_key; @@ -1191,6 +1203,7 @@ impl ProbeApp { let targets: BTreeMap<_, _> = self .overview_drafts .keys() + .chain(self.overview_editors.get_mut().keys()) .chain(self.pending_documentation_saves.iter()) .chain(match self.pending_close.as_ref() { Some(PendingClose::Overview(target)) => Some(target), @@ -1211,6 +1224,14 @@ impl ProbeApp { (target.clone(), mapped) }) .collect(); + *self.overview_editors.get_mut() = std::mem::take(self.overview_editors.get_mut()) + .into_iter() + .filter_map(|(target, editors)| { + let mapped = targets.get(&target)?; + (!matches!(mapped, OverviewTarget::DetachedFolder(_))) + .then(|| (mapped.clone(), editors)) + }) + .collect(); self.overview_drafts = std::mem::take(&mut self.overview_drafts) .into_iter() .map(|(target, draft)| (targets[&target].clone(), draft)) diff --git a/crates/desktop/src/components/components_tests.rs b/crates/desktop/src/components/components_tests.rs index bc96f822..e2444e88 100644 --- a/crates/desktop/src/components/components_tests.rs +++ b/crates/desktop/src/components/components_tests.rs @@ -743,6 +743,7 @@ impl Render for EditableEditorHarness { .flex_col() .child( ProbeEditor { + retained_state: None, theme, id: "editable-editor-regression".into(), value: self.value.clone(), @@ -991,6 +992,7 @@ impl Render for TextContextMenuHarness { input.into_any_element() } TextContextMenuHarnessKind::BodyEditor => ProbeEditor { + retained_state: None, theme, id: "context-body-editor".into(), value: "{\"ok\":true}".into(), @@ -1013,6 +1015,7 @@ impl Render for TextContextMenuHarness { } .into_any_element(), TextContextMenuHarnessKind::ResponseEditor => ProbeEditor { + retained_state: None, theme, id: "context-response-editor".into(), value: "{\"ok\":true}".into(), diff --git a/crates/desktop/src/components/editor.rs b/crates/desktop/src/components/editor.rs index 7ea40348..c0a1d1b5 100644 --- a/crates/desktop/src/components/editor.rs +++ b/crates/desktop/src/components/editor.rs @@ -11,7 +11,7 @@ mod variables; use core::ProbeEditor; #[cfg(test)] pub(super) use core::ProbeEditor; -pub(crate) use core::editor_paint_style; +pub(crate) use core::{RetainedEditorState, editor_paint_style}; pub(crate) use response::{ BodySyntax, body_text_input, curl_command_input, documentation_text_input, response_body_input, response_headers_input, response_inspector_input, websocket_composer, diff --git a/crates/desktop/src/components/editor/core.rs b/crates/desktop/src/components/editor/core.rs index d1fa438f..348d2f91 100644 --- a/crates/desktop/src/components/editor/core.rs +++ b/crates/desktop/src/components/editor/core.rs @@ -2,11 +2,36 @@ use super::*; use crate::app::{ShiftTabOrOutdent, TabOrIndent}; use gpui_kit::EntityInputHandler as _; +/// Keeps the native editor and search session alive while its tab or section is hidden. +#[derive(Clone, Debug, Default)] +pub(crate) struct RetainedEditorState(Rc>>); + +#[derive(Clone, Debug)] +struct EditorSession { + field: Entity, + search: Entity, +} + +impl RetainedEditorState { + #[cfg(test)] + pub(crate) fn editor(&self, cx: &App) -> Entity { + self.0 + .borrow() + .as_ref() + .expect("editor rendered") + .field + .read(cx) + .state + .clone() + } +} + struct EditorField { state: Entity, decorations: TextDecorationCollection, last_decorations: Vec, last_value: SharedString, + last_external_value: SharedString, on_change: Option, last_scroll_range: Option>, language: SharedString, @@ -59,6 +84,7 @@ pub(crate) fn editor_paint_style(theme: Theme) -> InputEditorStyle { #[derive(IntoElement)] pub(in crate::components) struct ProbeEditor { + pub(in crate::components) retained_state: Option, pub(in crate::components) theme: Theme, pub(in crate::components) id: ElementId, pub(in crate::components) value: SharedString, @@ -80,6 +106,25 @@ pub(in crate::components) struct ProbeEditor { pub(in crate::components) variables: Option, } +// Persistent sessions are owned by the tab, rather than by consecutive frames. +// Observe them in the same view as keyed state so editor events still redraw it. +fn session_state( + persistent: bool, + id: ElementId, + window: &mut Window, + cx: &mut App, + init: impl FnOnce(&mut Window, &mut Context) -> S, +) -> Entity { + if persistent { + let state = cx.new(|cx| init(window, cx)); + let view = window.current_view(); + cx.observe(&state, move |_, cx| cx.notify(view)).detach(); + state + } else { + window.use_keyed_state(id, cx, init) + } +} + impl RenderOnce for ProbeEditor { fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement { let component_id = self.id.clone(); @@ -100,53 +145,80 @@ impl RenderOnce for ProbeEditor { let soft_wrap = self.soft_wrap; let language = self.language.clone(); let editor_id = self.id.clone(); - let search_state = window.use_keyed_state( - ElementId::NamedChild( - Arc::new(editor_id.clone()), - SharedString::from("search-state"), - ), - cx, - |_, _| EditorSearchState::default(), - ); + let retained = self + .retained_state + .as_ref() + .and_then(|state| state.0.borrow().clone()); + let search_state = if let Some(session) = &retained { + session.search.clone() + } else { + session_state( + self.retained_state.is_some(), + ElementId::NamedChild( + Arc::new(editor_id.clone()), + SharedString::from("search-state"), + ), + window, + cx, + |_, _| EditorSearchState::default(), + ) + }; let scroll_to_range = self.scroll_to_range; - let field = window.use_keyed_state(self.id.clone(), cx, |window, cx| { - let state = cx.new(|cx| { - let mut editor = EditorState::new(window, cx) - .placeholder(placeholder.clone()) - // Kit 0.8 enables macOS bounce by default; keep Probe's - // existing request and response editor scrolling behavior. - .scroll_bounce(false) - .smart_indent(language.as_ref() == "json") - .folding(false) - // Let the shortcut reach Probe’s search card; the native - // session still owns matching, navigation, and painting. - .searchable(false) - .soft_wrap(soft_wrap) - .language(language.clone()); - editor.set_highlighter_factory(crate::syntax::factory(), cx); - editor.set_editor_style(paint_style.clone()); - editor - }); - state.update(cx, |editor, cx| { - editor.set_readonly(self.readonly, cx); - editor.set_value(self.value.clone(), window, cx); - }); - let decorations = state.update(cx, |editor, cx| { - editor.create_decorations_collection(Vec::new(), cx) + let field = if let Some(session) = retained { + session.field + } else { + session_state( + self.retained_state.is_some(), + self.id.clone(), + window, + cx, + |window, cx| { + let state = cx.new(|cx| { + let mut editor = EditorState::new(window, cx) + .placeholder(placeholder.clone()) + // Kit 0.8 enables macOS bounce by default; keep Probe's + // existing request and response editor scrolling behavior. + .scroll_bounce(false) + .smart_indent(language.as_ref() == "json") + .folding(false) + // Let the shortcut reach Probe’s search card; the native + // session still owns matching, navigation, and painting. + .searchable(false) + .soft_wrap(soft_wrap) + .language(language.clone()); + editor.set_highlighter_factory(crate::syntax::factory(), cx); + editor.set_editor_style(paint_style.clone()); + editor + }); + state.update(cx, |editor, cx| { + editor.set_readonly(self.readonly, cx); + editor.set_value(self.value.clone(), window, cx); + }); + let decorations = state.update(cx, |editor, cx| { + editor.create_decorations_collection(Vec::new(), cx) + }); + let subscription = cx.subscribe_in(&state, window, EditorField::on_event); + EditorField { + state, + decorations, + last_decorations: Vec::new(), + last_value: self.value.clone(), + last_external_value: self.value.clone(), + on_change: on_change.clone(), + last_scroll_range: None, + language: language.clone(), + soft_wrap, + _subscription: subscription, + } + }, + ) + }; + if let Some(retained) = self.retained_state { + *retained.0.borrow_mut() = Some(EditorSession { + field: field.clone(), + search: search_state.clone(), }); - let subscription = cx.subscribe_in(&state, window, EditorField::on_event); - EditorField { - state, - decorations, - last_decorations: Vec::new(), - last_value: self.value.clone(), - on_change: on_change.clone(), - last_scroll_range: None, - language: language.clone(), - soft_wrap, - _subscription: subscription, - } - }); + } field.update(cx, |field, cx| { field.on_change = self.on_change.clone(); let language_changed = field.language != self.language; @@ -158,9 +230,13 @@ impl RenderOnce for ProbeEditor { field.soft_wrap = self.soft_wrap; } let context_focus = field.state.read(cx).focus_handle(cx); - let open_context_menu = context_menu.clone(); - let context_editor = field.state.clone(); - let value_changed = field.last_value != self.value; + let open_context_menu = context_menu.downgrade(); + let context_editor = field.state.downgrade(); + // A rejected/incomplete draft (for example GraphQL variables while + // typing JSON) must survive remounts when the model has not changed. + let value_changed = + field.last_value != self.value && field.last_external_value != self.value; + field.last_external_value = self.value.clone(); if value_changed { field.last_value = self.value.clone(); } @@ -175,6 +251,11 @@ impl RenderOnce for ProbeEditor { editor.set_soft_wrap(self.soft_wrap, window, cx); } editor.on_context_menu(Rc::new(move |_, capabilities, position, window, cx| { + let (Some(open_context_menu), Some(context_editor)) = + (open_context_menu.upgrade(), context_editor.upgrade()) + else { + return; + }; context_focus.focus(window, cx); open_context_menu.update(cx, |state, cx| { state.position = Some(position); diff --git a/crates/desktop/src/components/editor/native_tests.rs b/crates/desktop/src/components/editor/native_tests.rs index 90721487..2c9008d8 100644 --- a/crates/desktop/src/components/editor/native_tests.rs +++ b/crates/desktop/src/components/editor/native_tests.rs @@ -14,6 +14,7 @@ impl Render for EditorHarness { fn render(&mut self, window: &mut Window, cx: &mut Context) -> impl IntoElement { let view = cx.weak_entity(); let element = ProbeEditor { + retained_state: None, theme: Theme::light(), id: "native-editor-test".into(), value: self.value.clone(), diff --git a/crates/desktop/src/components/editor/response.rs b/crates/desktop/src/components/editor/response.rs index 22ba8a40..f0d4efbe 100644 --- a/crates/desktop/src/components/editor/response.rs +++ b/crates/desktop/src/components/editor/response.rs @@ -19,12 +19,14 @@ pub(crate) enum BodySyntax { pub(crate) fn documentation_text_input( theme: Theme, + retained_state: Option, id: ElementId, value: String, placeholder: &'static str, on_value_change: impl Fn(SharedString, &mut Window, &mut App) + 'static, ) -> gpui_kit::AnyElement { ProbeEditor { + retained_state, theme, id, value: value.into(), @@ -56,6 +58,7 @@ pub(crate) fn curl_command_input( on_value_change: impl Fn(SharedString, &mut Window, &mut App) + 'static, ) -> gpui_kit::AnyElement { ProbeEditor { + retained_state: None, theme, id, value: value.into(), @@ -81,6 +84,7 @@ pub(crate) fn curl_command_input( pub(crate) fn websocket_composer( theme: Theme, + retained_state: RetainedEditorState, id: ElementId, value: String, enabled: bool, @@ -88,6 +92,7 @@ pub(crate) fn websocket_composer( on_change: impl Fn(SharedString, &mut Window, &mut App) + 'static, ) -> gpui_kit::AnyElement { ProbeEditor { + retained_state: Some(retained_state), theme, id, value: value.into(), @@ -118,6 +123,7 @@ pub(crate) fn websocket_composer( pub(crate) fn body_text_input( theme: Theme, + retained_state: RetainedEditorState, id: impl Into, value: impl Into, syntax: BodySyntax, @@ -133,6 +139,7 @@ pub(crate) fn body_text_input( |kind, name| placeholder_tone(&variables, kind, name), ); ProbeEditor { + retained_state: Some(retained_state), theme, id: id.into(), value, @@ -162,6 +169,7 @@ pub(crate) fn body_text_input( pub(crate) fn response_body_input( theme: Theme, + retained_state: RetainedEditorState, id: impl Into, text: SharedString, options: ResponseBodyInputOptions, @@ -234,6 +242,7 @@ pub(crate) fn response_body_input( response_editor( theme, + retained_state, id, ResponseEditorPresentation { value: text, @@ -268,6 +277,7 @@ fn cached_value_at_cursor( pub(crate) fn response_headers_input( theme: Theme, + retained_state: RetainedEditorState, id: impl Into, headers: &[probe_http::ResponseHeader], on_visible_range: impl Fn(Range, &mut App) + 'static, @@ -283,6 +293,7 @@ pub(crate) fn response_headers_input( } response_editor( theme, + retained_state, id, ResponseEditorPresentation { value: joined.text.into(), @@ -300,12 +311,14 @@ pub(crate) fn response_headers_input( pub(crate) fn response_inspector_input( theme: Theme, + retained_state: RetainedEditorState, id: impl Into, text: impl Into, on_visible_range: impl Fn(Range, &mut App) + 'static, ) -> gpui_kit::AnyElement { response_editor( theme, + retained_state, id, ResponseEditorPresentation { value: text.into(), @@ -332,6 +345,7 @@ struct ResponseEditorPresentation { fn response_editor( theme: Theme, + retained_state: RetainedEditorState, id: impl Into, presentation: ResponseEditorPresentation, on_visible_range: VisibleRangeHandler, @@ -339,6 +353,7 @@ fn response_editor( extra_context_menu_actions: Vec, ) -> gpui_kit::AnyElement { ProbeEditor { + retained_state: Some(retained_state), theme, id: id.into(), value: presentation.value, diff --git a/crates/desktop/src/components/mod.rs b/crates/desktop/src/components/mod.rs index 331f221f..7b3ea29c 100644 --- a/crates/desktop/src/components/mod.rs +++ b/crates/desktop/src/components/mod.rs @@ -119,3 +119,5 @@ pub(crate) fn menu_leading_slot(width: f32, content: impl IntoElement) -> gpui_k #[cfg(test)] mod components_tests; + +pub(crate) use editor::RetainedEditorState; diff --git a/crates/desktop/src/request_editor.rs b/crates/desktop/src/request_editor.rs index 1db51318..4d089039 100644 --- a/crates/desktop/src/request_editor.rs +++ b/crates/desktop/src/request_editor.rs @@ -1,5 +1,5 @@ use std::{ - cell::Cell, + cell::{Cell, RefCell}, collections::{BTreeMap, HashMap}, }; @@ -107,7 +107,7 @@ impl AssertionEdit { } } -#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)] +#[derive(Clone, Copy, Debug, Default, Eq, Ord, PartialEq, PartialOrd)] pub(crate) enum EditorSection { #[default] Path, @@ -305,12 +305,60 @@ const fn hex(byte: u8) -> Option { #[derive(Debug, Default)] pub(crate) struct RequestEditorState { sections: HashMap, + editors: RefCell>, + scrolls: RefCell>, assertion_focus: Cell>, body_drafts: BTreeMap<(RequestKey, BodyEditorKind), RequestBody>, } impl RequestEditorState { + pub(crate) fn editor( + &self, + key: RequestKey, + slot: &'static str, + ) -> crate::components::RetainedEditorState { + self.editors + .borrow_mut() + .entry((key, slot)) + .or_default() + .clone() + } + + pub(crate) fn invalidate_editors(&mut self, key: RequestKey) { + self.editors.get_mut().retain(|(owner, _), _| *owner != key); + } + + pub(crate) fn invalidate_changed_editors( + &mut self, + key: RequestKey, + previous: &Request, + current: &Request, + ) { + if (previous.kind.is_graphql() || current.kind.is_graphql()) + && previous.kind != current.kind + { + for slot in ["graphql-query", "graphql-variables", "graphql-extensions"] { + self.editors.get_mut().remove(&(key, slot)); + } + } + if (previous.kind.is_websocket() || current.kind.is_websocket()) + && previous.kind != current.kind + { + self.editors.get_mut().remove(&(key, "websocket-message")); + } + } + + pub(crate) fn scroll(&self, key: RequestKey, section: EditorSection) -> gpui_kit::ScrollHandle { + self.scrolls + .borrow_mut() + .entry((key, section)) + .or_default() + .clone() + } + pub(crate) fn clear(&mut self) { + self.editors.get_mut().clear(); + self.scrolls.get_mut().clear(); self.sections.clear(); self.assertion_focus.set(None); self.body_drafts.clear(); @@ -340,6 +388,8 @@ impl RequestEditorState { } pub(crate) fn remove(&mut self, key: RequestKey) { + self.invalidate_editors(key); + self.scrolls.get_mut().retain(|(owner, _), _| *owner != key); self.sections.remove(&key); if self .assertion_focus @@ -369,6 +419,16 @@ impl RequestEditorState { } pub(crate) fn remap_requests(&mut self, keys: &BTreeMap) { + *self.editors.get_mut() = std::mem::take(self.editors.get_mut()) + .into_iter() + .filter_map(|((key, slot), editor)| keys.get(&key).map(|new| ((*new, slot), editor))) + .collect(); + *self.scrolls.get_mut() = std::mem::take(self.scrolls.get_mut()) + .into_iter() + .filter_map(|((key, section), scroll)| { + keys.get(&key).map(|new| ((*new, section), scroll)) + }) + .collect(); self.assertion_focus.set( self.assertion_focus .get() diff --git a/crates/desktop/src/response_viewer/mod.rs b/crates/desktop/src/response_viewer/mod.rs index 65d50c64..56718a8a 100644 --- a/crates/desktop/src/response_viewer/mod.rs +++ b/crates/desktop/src/response_viewer/mod.rs @@ -164,6 +164,10 @@ pub(crate) struct ResponseViewerState { selections: std::collections::HashMap, documents: std::collections::BTreeMap, image_scrolls: std::collections::BTreeMap, + editors: std::collections::BTreeMap< + probe_core::RequestKey, + [crate::components::RetainedEditorState; 6], + >, next_generation: u64, } @@ -172,9 +176,32 @@ struct ResponseSelection { tab: ResponseViewerTab, raw_view: RawBodyView, assertion_scroll: ScrollHandle, + inspector_scroll: gpui_kit::UniformListScrollHandle, } impl ResponseViewerState { + pub(crate) fn editor( + &self, + key: probe_core::RequestKey, + tab: ResponseViewerTab, + ) -> crate::components::RetainedEditorState { + let index = match tab { + ResponseViewerTab::Pretty => 0, + ResponseViewerTab::Raw => match self.raw_view(key) { + RawBodyView::Text => 1, + RawBodyView::Base64 => 2, + RawBodyView::Hex => 3, + }, + ResponseViewerTab::Headers => 4, + ResponseViewerTab::Inspect => 5, + ResponseViewerTab::Assertions => unreachable!("assertions do not use a text editor"), + }; + self.editors + .get(&key) + .expect("response document owns editor state")[index] + .clone() + } + pub(crate) fn tab(&self, key: probe_core::RequestKey) -> ResponseViewerTab { self.selections .get(&key) @@ -193,6 +220,17 @@ impl ResponseViewerState { self.documents.get(&key) } + pub(crate) fn inspector_scroll( + &self, + key: probe_core::RequestKey, + ) -> &gpui_kit::UniformListScrollHandle { + &self + .selections + .get(&key) + .expect("response owns a selection") + .inspector_scroll + } + pub(crate) fn image_scroll(&self, key: probe_core::RequestKey) -> Option<&ScrollHandle> { self.image_scrolls.get(&key) } @@ -219,6 +257,8 @@ impl ResponseViewerState { } else { self.image_scrolls.remove(&key); } + self.selections.entry(key).or_default().inspector_scroll = Default::default(); + self.editors.insert(key, Default::default()); self.documents.insert(key, document); } @@ -236,10 +276,12 @@ impl ResponseViewerState { } pub(crate) fn remove(&mut self, key: probe_core::RequestKey) { + self.editors.remove(&key); self.documents.remove(&key); self.image_scrolls.remove(&key); if let Some(selection) = self.selections.get_mut(&key) { selection.assertion_scroll = ScrollHandle::new(); + selection.inspector_scroll = Default::default(); } } @@ -249,6 +291,7 @@ impl ResponseViewerState { pub(crate) fn clear(&mut self) { self.selections.clear(); + self.editors.clear(); self.documents.clear(); self.image_scrolls.clear(); } @@ -257,6 +300,10 @@ impl ResponseViewerState { &mut self, key_remaps: &std::collections::BTreeMap, ) { + self.editors = std::mem::take(&mut self.editors) + .into_iter() + .filter_map(|(key, editors)| key_remaps.get(&key).map(|new| (*new, editors))) + .collect(); self.selections = std::mem::take(&mut self.selections) .into_iter() .filter_map(|(key, selection)| key_remaps.get(&key).map(|new| (*new, selection))) diff --git a/crates/desktop/src/response_viewer/tests.rs b/crates/desktop/src/response_viewer/tests.rs index 7c061ad8..d4031043 100644 --- a/crates/desktop/src/response_viewer/tests.rs +++ b/crates/desktop/src/response_viewer/tests.rs @@ -696,3 +696,29 @@ fn results_for_replaced_or_closed_documents_are_ignored_after_a_reload() { assert!(viewer.document(old_key).is_none()); assert!(viewer.document(new_key).is_none()); } + +#[test] +fn inspector_scroll_is_per_request_survives_remaps_and_resets_with_response() { + use gpui_kit::{point, px}; + use std::collections::BTreeMap; + let first = request_key(); + let second = replacement_request_key(); + let document = prepare_document(&response(b"body", "text/plain"), 1).0; + let mut viewer = super::ResponseViewerState::default(); + viewer.insert(first, document.clone()); + viewer.insert(second, document.clone()); + let first_scroll = viewer.inspector_scroll(first); + let second_scroll = viewer.inspector_scroll(second); + first_scroll + .0 + .borrow() + .base_handle + .set_offset(point(px(0.0), px(-120.0))); + assert_eq!(second_scroll.0.borrow().base_handle.offset().y, px(0.0)); + viewer.remap_requests(&BTreeMap::from([(first, second)])); + let remapped = viewer.inspector_scroll(second); + assert_eq!(remapped.0.borrow().base_handle.offset().y, px(-120.0)); + viewer.insert(second, document); + let replacement = viewer.inspector_scroll(second); + assert_eq!(replacement.0.borrow().base_handle.offset().y, px(0.0)); +}