diff --git a/crates/project/src/environment.rs b/crates/project/src/environment.rs index c7b87ea8e35..9a5565eae43 100644 --- a/crates/project/src/environment.rs +++ b/crates/project/src/environment.rs @@ -66,6 +66,11 @@ impl ProjectEnvironment { } } + #[cfg(any(test, feature = "test-support"))] + pub fn inherited_cli_environment(&self) -> Option<&HashMap> { + self.cli_environment.as_ref() + } + /// Returns the inherited CLI environment, if this project was opened from the Zed CLI. pub(crate) fn get_cli_environment(&self) -> Option> { if cfg!(any(test, feature = "test-support")) { diff --git a/crates/workspace/src/persistence.rs b/crates/workspace/src/persistence.rs index d6ad1d8e949..b8cd6beb08a 100644 --- a/crates/workspace/src/persistence.rs +++ b/crates/workspace/src/persistence.rs @@ -1157,6 +1157,10 @@ impl WorkspaceDb { self.workspace_for_roots_internal(worktree_roots, None) } + pub fn has_workspace_for_roots>(&self, worktree_roots: &[P]) -> bool { + self.workspace_for_roots(worktree_roots).is_some() + } + pub(crate) fn remote_workspace_for_roots>( &self, worktree_roots: &[P], @@ -3017,10 +3021,11 @@ mod tests { use crate::ProjectGroupKey; use crate::RemovalIntent; use crate::{ + item::test::TestItem, multi_workspace::MultiWorkspace, persistence::{ model::{ - SerializedItem, SerializedPane, SerializedPaneGroup, SerializedWorkspace, + DockData, SerializedItem, SerializedPane, SerializedPaneGroup, SerializedWorkspace, SessionWorkspace, }, read_multi_workspace_state, @@ -3029,11 +3034,16 @@ mod tests { use gpui::TaskExt; use gpui::AppContext as _; + use language::Point; use pretty_assertions::assert_eq; - use project::Project; + use project::{ + Project, + debugger::breakpoint_store::{self, BreakpointEditAction, BreakpointWithPosition}, + }; use remote::SshConnectionOptions; use serde_json::json; - use std::{thread, time::Duration}; + use std::{cell::RefCell, rc::Rc, thread, time::Duration}; + use util::path; /// Creates a unique directory in a FakeFs, returning the path. /// Uses a UUID suffix to avoid collisions with other tests sharing the global DB. @@ -5476,6 +5486,374 @@ mod tests { ); } + #[gpui::test] + async fn test_restoring_workspace_saves_what_it_restores_and_what_was_added( + cx: &mut gpui::TestAppContext, + ) { + crate::tests::init_test(cx); + cx.update(crate::register_serializable_item::); + + let fs = fs::FakeFs::new(cx.executor()); + fs.insert_tree( + path!("/project"), + json!({ "saved.rs": "one\ntwo\n", "added.rs": "one\ntwo\n" }), + ) + .await; + let project = Project::test(fs.clone(), [path!("/project").as_ref()], cx).await; + let (multi_workspace, cx) = + cx.add_window_view(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx)); + let workspace = + multi_workspace.read_with(cx, |multi_workspace, _| multi_workspace.workspace().clone()); + let db = cx.update(|_, cx| WorkspaceDb::global(cx)); + let workspace_id = db.next_id().await.unwrap(); + workspace.update(cx, |workspace, _| workspace.set_database_id(workspace_id)); + + let added_item = cx.new(TestItem::new); + let added_item_id = added_item.entity_id().as_u64(); + workspace.update_in(cx, |workspace, window, cx| { + workspace.add_item_to_active_pane(Box::new(added_item.clone()), None, true, window, cx); + }); + let buffer = project + .update(cx, |project, cx| { + project.open_local_buffer(path!("/project/added.rs"), cx) + }) + .await + .unwrap(); + project.update(cx, |project, cx| { + let position = buffer.read(cx).anchor_before(Point::new(1, 0)); + project.bookmark_store().update(cx, |bookmark_store, cx| { + bookmark_store.toggle_bookmark(buffer.clone(), position, String::new(), cx); + }); + project + .breakpoint_store() + .update(cx, |breakpoint_store, cx| { + breakpoint_store.toggle_breakpoint( + buffer.clone(), + BreakpointWithPosition { + position, + bp: breakpoint_store::Breakpoint::new_standard(), + }, + BreakpointEditAction::Toggle, + cx, + ); + }); + }); + + let saved_path = Arc::::from(Path::new(path!("/project/saved.rs"))); + let added_path = Arc::::from(Path::new(path!("/project/added.rs"))); + let bookmark = |row| SerializedBookmark { + row, + label: String::new(), + }; + let breakpoint = |row, path: &Arc| SourceBreakpoint { + row, + path: path.clone(), + message: None, + condition: None, + hit_condition: None, + state: BreakpointState::Enabled, + }; + let saved_docks = DockStructure { + left: DockData { + visible: true, + active_panel: Some("SavedPanel".to_owned()), + zoom: false, + }, + ..Default::default() + }; + let restoring_from = SerializedWorkspace { + id: workspace_id, + paths: PathList::new(&[path!("/project")]), + identity_paths: None, + location: SerializedWorkspaceLocation::Local, + center_group: SerializedPaneGroup::Pane(SerializedPane::new( + vec![ + SerializedItem::new("Terminal", added_item_id, true, false), + SerializedItem::new("TestItem", added_item_id + 1, false, false), + ], + true, + 1, + )), + window_bounds: Default::default(), + display: Default::default(), + docks: saved_docks.clone(), + centered_layout: false, + bookmarks: BTreeMap::from_iter([(saved_path.clone(), vec![bookmark(0)])]), + breakpoints: BTreeMap::from_iter([( + saved_path.clone(), + vec![breakpoint(0, &saved_path)], + )]), + session_id: None, + window_id: None, + user_toolchains: Default::default(), + recent_navigation_history: Default::default(), + path_style: PathStyle::local(), + }; + workspace.update(cx, |workspace, _| { + workspace.restoring_workspace.set(true); + workspace.restoring_from.replace(Some(restoring_from)); + }); + multi_workspace + .update_in(cx, |multi_workspace, window, cx| { + multi_workspace.workspace().update(cx, |workspace, cx| { + workspace.flush_serialization(window, cx) + }) + }) + .await; + + let both_breakpoints = BTreeMap::from_iter([ + (added_path.clone(), vec![breakpoint(1, &added_path)]), + (saved_path.clone(), vec![breakpoint(0, &saved_path)]), + ]); + let saved = db.workspace_for_id(workspace_id).unwrap(); + assert_eq!( + ( + saved.center_group, + saved.docks, + saved.bookmarks, + saved.breakpoints + ), + ( + SerializedPaneGroup::Group { + axis: SerializedAxis(Axis::Horizontal), + children: vec![ + SerializedPaneGroup::Pane(SerializedPane::new( + vec![SerializedItem::new( + "TestItem", + added_item_id + 1, + false, + false + )], + false, + 0, + )), + SerializedPaneGroup::Pane(SerializedPane::new( + vec![SerializedItem::new("TestItem", added_item_id, true, false)], + true, + 0, + )), + ], + flexes: None, + }, + saved_docks, + BTreeMap::from_iter([ + (added_path.clone(), vec![bookmark(1)]), + (saved_path.clone(), vec![bookmark(0)]), + ]), + both_breakpoints.clone(), + ) + ); + + workspace.update(cx, |workspace, _| workspace.restoring_workspace.set(false)); + multi_workspace + .update_in(cx, |multi_workspace, window, cx| { + multi_workspace.workspace().update(cx, |workspace, cx| { + workspace.flush_serialization(window, cx) + }) + }) + .await; + + let saved = db.workspace_for_id(workspace_id).unwrap(); + assert_eq!( + ( + saved.center_group, + saved.docks, + saved.bookmarks, + saved.breakpoints + ), + ( + SerializedPaneGroup::Pane(SerializedPane::new( + vec![SerializedItem::new("TestItem", added_item_id, true, false)], + true, + 0, + )), + DockStructure::default(), + BTreeMap::from_iter([(added_path.clone(), vec![bookmark(1)])]), + both_breakpoints, + ) + ); + } + + #[test] + fn test_saved_layout_is_unchanged_when_nothing_was_opened_while_restoring() { + let saved = SerializedPaneGroup::Pane(SerializedPane::new( + vec![SerializedItem::new("Terminal", 5, true, false)], + true, + 1, + )); + let nothing_opened = SerializedPaneGroup::Pane(SerializedPane::new(Vec::new(), true, 0)); + + assert_eq!( + saved + .clone() + .with_panes_opened_while_restoring(nothing_opened), + saved + ); + } + + #[gpui::test] + async fn test_restoring_workspace_keeps_its_saved_breakpoints_until_they_are_loaded( + cx: &mut gpui::TestAppContext, + ) { + crate::tests::init_test(cx); + + let fs = fs::FakeFs::new(cx.executor()); + fs.insert_tree(path!("/project"), json!({ "saved.rs": "one\ntwo\n" })) + .await; + let project = Project::test(fs.clone(), [path!("/project").as_ref()], cx).await; + let (multi_workspace, cx) = + cx.add_window_view(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx)); + let workspace = + multi_workspace.read_with(cx, |multi_workspace, _| multi_workspace.workspace().clone()); + let db = cx.update(|_, cx| WorkspaceDb::global(cx)); + let workspace_id = db.next_id().await.unwrap(); + workspace.update(cx, |workspace, _| workspace.set_database_id(workspace_id)); + + let saved_path = Arc::::from(Path::new(path!("/project/saved.rs"))); + let saved_breakpoints = BTreeMap::from_iter([( + saved_path.clone(), + vec![SourceBreakpoint { + row: 1, + path: saved_path.clone(), + message: None, + condition: None, + hit_condition: None, + state: BreakpointState::Enabled, + }], + )]); + let restoring_from = SerializedWorkspace { + id: workspace_id, + paths: PathList::new(&[path!("/project")]), + identity_paths: None, + location: SerializedWorkspaceLocation::Local, + center_group: Default::default(), + window_bounds: Default::default(), + display: Default::default(), + docks: Default::default(), + centered_layout: false, + bookmarks: Default::default(), + breakpoints: saved_breakpoints.clone(), + session_id: None, + window_id: None, + user_toolchains: Default::default(), + recent_navigation_history: Default::default(), + path_style: PathStyle::local(), + }; + + let breakpoints_when_the_tabs_were_in_place = Rc::new(RefCell::new(None)); + let _tabs_in_place = cx.update(|_, cx| { + cx.observe(&workspace, { + let breakpoints_when_the_tabs_were_in_place = + breakpoints_when_the_tabs_were_in_place.clone(); + move |workspace, cx| { + let workspace = workspace.read(cx); + if !workspace.is_restoring() + && breakpoints_when_the_tabs_were_in_place.borrow().is_none() + { + let restoring_from = workspace.restoring_from.borrow(); + breakpoints_when_the_tabs_were_in_place.replace(Some( + restoring_from + .as_ref() + .map(|restoring_from| restoring_from.breakpoints.clone()), + )); + } + } + }) + }); + workspace.update(cx, |workspace, _| { + workspace.restoring_workspace.set(true); + workspace + .restoring_from + .replace(Some(restoring_from.clone())); + }); + workspace + .update_in(cx, |_, window, cx| { + crate::Workspace::load_workspace(restoring_from, Vec::new(), window, cx) + }) + .await + .unwrap(); + + let loaded_breakpoints = project.read_with(cx, |project, cx| { + project + .breakpoint_store() + .read(cx) + .all_source_breakpoints(cx) + }); + let still_restoring_from = workspace.read_with(cx, |workspace, _| { + workspace.restoring_from.borrow().is_some() + }); + assert_eq!( + ( + breakpoints_when_the_tabs_were_in_place.take(), + loaded_breakpoints, + still_restoring_from, + ), + ( + Some(Some(saved_breakpoints.clone())), + saved_breakpoints, + false + ) + ); + } + + #[gpui::test] + async fn test_workspace_whose_restore_is_cancelled_is_no_longer_restoring( + cx: &mut gpui::TestAppContext, + ) { + crate::tests::init_test(cx); + + let fs = fs::FakeFs::new(cx.executor()); + let project = Project::test(fs.clone(), [], cx).await; + let (multi_workspace, cx) = + cx.add_window_view(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx)); + let workspace = + multi_workspace.read_with(cx, |multi_workspace, _| multi_workspace.workspace().clone()); + let db = cx.update(|_, cx| WorkspaceDb::global(cx)); + let workspace_id = db.next_id().await.unwrap(); + workspace.update(cx, |workspace, _| { + workspace.set_database_id(workspace_id); + workspace.keeps_saved_state_while_restoring = true; + }); + + let restoring_from = SerializedWorkspace { + id: workspace_id, + paths: PathList::default(), + identity_paths: None, + location: SerializedWorkspaceLocation::Local, + center_group: Default::default(), + window_bounds: Default::default(), + display: Default::default(), + docks: Default::default(), + centered_layout: false, + bookmarks: Default::default(), + breakpoints: Default::default(), + session_id: None, + window_id: None, + user_toolchains: Default::default(), + recent_navigation_history: Default::default(), + path_style: PathStyle::local(), + }; + let restoring_state = |cx: &mut gpui::VisualTestContext| { + workspace.read_with(cx, |workspace, _| { + ( + workspace.is_restoring(), + workspace.restoring_from.borrow().is_some(), + ) + }) + }; + let restore = workspace.update_in(cx, |workspace, window, cx| { + crate::open_items(workspace, Some(restoring_from), Vec::new(), window, cx) + }); + let while_restoring = restoring_state(cx); + drop(restore); + cx.run_until_parked(); + + assert_eq!( + (while_restoring, restoring_state(cx)), + ((true, true), (false, false)) + ); + } + #[gpui::test] async fn test_pending_serialization_flushed_on_shutdown(cx: &mut gpui::TestAppContext) { crate::tests::init_test(cx); diff --git a/crates/workspace/src/persistence/model.rs b/crates/workspace/src/persistence/model.rs index 93f73bf1e5d..a422f05a06d 100644 --- a/crates/workspace/src/persistence/model.rs +++ b/crates/workspace/src/persistence/model.rs @@ -5,12 +5,12 @@ use crate::{ }; use anyhow::{Context, Result}; use async_recursion::async_recursion; -use collections::IndexSet; +use collections::{HashSet, IndexSet}; use db::sqlez::{ bindable::{Bind, Column, StaticColumnCount}, statement::Statement, }; -use gpui::{AsyncWindowContext, Entity, WeakEntity, WindowId}; +use gpui::{AsyncWindowContext, Axis, Entity, WeakEntity, WindowId}; use language::{Toolchain, ToolchainScope}; use project::{ @@ -242,6 +242,63 @@ pub(crate) enum SerializedPaneGroup { Pane(SerializedPane), } +impl SerializedPaneGroup { + pub(crate) fn with_panes_opened_while_restoring(mut self, mut opened: Self) -> Self { + let mut opened_item_ids = HashSet::default(); + let mut opened_pane_is_active = false; + opened.for_each_pane(&mut |pane| { + opened_item_ids.extend(pane.children.iter().map(|item| item.item_id)); + opened_pane_is_active |= pane.active; + }); + if opened_item_ids.is_empty() { + return self; + } + self.for_each_pane(&mut |pane| { + let replaced_pinned_items = pane + .children + .iter() + .take(pane.pinned_count) + .filter(|item| opened_item_ids.contains(&item.item_id)) + .count(); + pane.children + .retain(|item| !opened_item_ids.contains(&item.item_id)); + pane.pinned_count -= replaced_pinned_items; + pane.active &= !opened_pane_is_active; + }); + Self::Group { + axis: SerializedAxis(Axis::Horizontal), + children: vec![self, opened], + flexes: None, + } + } + + fn for_each_pane(&mut self, update: &mut impl FnMut(&mut SerializedPane)) { + match self { + Self::Pane(pane) => update(pane), + Self::Group { children, .. } => { + for child in children { + child.for_each_pane(update); + } + } + } + } +} + +pub(crate) fn add_saved_rows( + rows: &mut BTreeMap, Vec>, + saved_rows: BTreeMap, Vec>, + row: impl Fn(&T) -> u32, +) { + for (path, saved_rows) in saved_rows { + let rows = rows.entry(path).or_default(); + for saved_row in saved_rows { + if !rows.iter().any(|existing| row(existing) == row(&saved_row)) { + rows.push(saved_row); + } + } + } +} + #[cfg(test)] impl Default for SerializedPaneGroup { fn default() -> Self { diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs index 5695b84ab18..407784c0001 100644 --- a/crates/workspace/src/workspace.rs +++ b/crates/workspace/src/workspace.rs @@ -168,7 +168,7 @@ use crate::{dock::PanelSizeState, item::ItemBufferKind, notifications::Notificat use crate::{ persistence::{ SerializedAxis, - model::{SerializedItem, SerializedPane, SerializedPaneGroup}, + model::{SerializedItem, SerializedPane, SerializedPaneGroup, add_saved_rows}, }, security_modal::SecurityModal, }; @@ -1730,7 +1730,9 @@ pub struct Workspace { deferred_save_items: Vec>, persisted_recent_navigation_history: Vec, last_active_project_path: Option, - restoring_workspace: bool, + restoring_workspace: Rc>, + restoring_from: Rc>>, + keeps_saved_state_while_restoring: bool, } impl EventEmitter for Workspace {} @@ -2235,7 +2237,9 @@ impl Workspace { deferred_save_items: Vec::new(), persisted_recent_navigation_history: Vec::new(), last_active_project_path: None, - restoring_workspace: false, + restoring_workspace: Rc::new(Cell::new(false)), + restoring_from: Rc::default(), + keeps_saved_state_while_restoring: false, } } @@ -2463,8 +2467,8 @@ impl Workspace { let all_paths_resolved = project_paths.iter().all(|(_, path)| path.is_some()); let opened_items = window .update(cx, |_, window, cx| { - workspace.update(cx, |_workspace: &mut Workspace, cx| { - open_items(serialized_workspace, project_paths, window, cx) + workspace.update(cx, |workspace: &mut Workspace, cx| { + open_items(workspace, serialized_workspace, project_paths, window, cx) }) })? .await @@ -3006,12 +3010,12 @@ impl Workspace { } pub fn is_restoring(&self) -> bool { - self.restoring_workspace + self.restoring_workspace.get() } #[cfg(any(test, feature = "test-support"))] pub fn set_restoring_workspace(&mut self, restoring: bool) { - self.restoring_workspace = restoring; + self.restoring_workspace.set(restoring); } pub fn set_panels_task(&mut self, task: Task>) { @@ -3302,7 +3306,7 @@ impl Workspace { } fn remember_navigation_history_path(&mut self, project_path: &ProjectPath, cx: &App) -> bool { - if self.restoring_workspace { + if self.restoring_workspace.get() { return false; } let Some(absolute_path) = self.project.read(cx).absolute_path(project_path, cx) else { @@ -4250,6 +4254,8 @@ impl Workspace { let fs = self.app_state.fs.clone(); let caller_ordered_abs_paths = abs_paths.clone(); + let mut caller_indices = (0..abs_paths.len()).collect::>(); + caller_indices.sort_by(|left, right| abs_paths.get(*left).cmp(&abs_paths.get(*right))); // Sort the paths to ensure we add worktrees for parents before their children. abs_paths.sort_unstable(); @@ -4418,7 +4424,14 @@ impl Workspace { } } - results + let mut results_in_caller_order = (0..results.len()).map(|_| None).collect::>(); + for (caller_index, result) in caller_indices.into_iter().zip(results) { + if let Some(result_in_caller_order) = results_in_caller_order.get_mut(caller_index) + { + *result_in_caller_order = result; + } + } + results_in_caller_order }) } @@ -8043,7 +8056,6 @@ impl Workspace { let Some(database_id) = self.database_id() else { return Task::ready(()); }; - fn build_serialized_pane_group( pane_group: &Member, window: &mut Window, @@ -8079,14 +8091,14 @@ impl Workspace { match self.workspace_location(cx) { WorkspaceLocation::Location(location, paths) => { - let bookmarks = self.project.update(cx, |project, cx| { + let mut bookmarks = self.project.update(cx, |project, cx| { project .bookmark_store() .read(cx) .all_serialized_bookmarks(cx) }); - let breakpoints = self.project.update(cx, |project, cx| { + let mut breakpoints = self.project.update(cx, |project, cx| { project .breakpoint_store() .read(cx) @@ -8098,8 +8110,22 @@ impl Workspace { .user_toolchains(cx) .unwrap_or_default(); - let center_group = build_serialized_pane_group(&self.center.root, window, cx); - let docks = build_serialized_docks(self, window, cx); + let mut center_group = build_serialized_pane_group(&self.center.root, window, cx); + let mut docks = build_serialized_docks(self, window, cx); + if let Some(restoring_from) = self.restoring_from.borrow().clone() { + if self.restoring_workspace.get() { + center_group = restoring_from + .center_group + .with_panes_opened_while_restoring(center_group); + docks = restoring_from.docks; + add_saved_rows(&mut bookmarks, restoring_from.bookmarks, |bookmark| { + bookmark.row + }); + } + add_saved_rows(&mut breakpoints, restoring_from.breakpoints, |breakpoint| { + breakpoint.row + }); + } let default_docks = (paths.is_empty() && location == SerializedWorkspaceLocation::Local) .then(|| docks.clone()); @@ -8233,7 +8259,7 @@ impl Workspace { let recent_navigation_history = serialized_workspace.recent_navigation_history.clone(); workspace.update(cx, |workspace, _| { workspace.persisted_recent_navigation_history = recent_navigation_history; - workspace.restoring_workspace = true; + workspace.restoring_workspace.set(true); })?; let project = workspace.read_with(cx, |workspace, _| workspace.project().clone())?; @@ -8280,6 +8306,32 @@ impl Workspace { // Remove old panes from workspace panes list workspace.update_in(cx, |workspace, window, cx| { if let Some((center_group, active_pane)) = center_group { + let item_in_use = workspace.active_item(cx); + let panes_used_while_restoring = if workspace.restoring_from.borrow().is_some() + { + workspace + .center + .panes() + .into_iter() + .cloned() + .collect::>() + } else { + Vec::new() + }; + let mut items_opened_while_restoring = Vec::new(); + for pane in panes_used_while_restoring { + let items = pane + .read(cx) + .items() + .map(|item| item.boxed_clone()) + .collect::>(); + pane.update(cx, |pane, cx| { + for item in &items { + pane.remove_item(item.item_id(), false, false, window, cx); + } + }); + items_opened_while_restoring.extend(items); + } workspace.remove_panes(workspace.center.root.clone(), window, cx); // Swap workspace center group @@ -8293,6 +8345,50 @@ impl Workspace { } else { workspace.set_active_pane(&workspace.center.first_pane(), window, cx); } + + let restored_pane = workspace.active_pane.clone(); + let mut kept_item_in_use = None; + for item in items_opened_while_restoring { + let was_in_use = item_in_use + .as_ref() + .is_some_and(|item_in_use| item_in_use.item_id() == item.item_id()); + let restored_item = item.project_path(cx).and_then(|project_path| { + workspace.panes.iter().find_map(|pane| { + pane.read(cx).item_for_path(project_path.clone(), cx) + }) + }); + let kept_item = match restored_item { + Some(restored_item) => restored_item, + None => { + if let Some(serializable_item) = + item.to_serializable_item_handle(cx) + && let Some(item_ids) = item_ids_by_kind + .get_mut(&serializable_item.serialized_item_kind()) + { + item_ids.push(item.item_id().as_u64() as ItemId); + } + restored_pane.update(cx, |pane, cx| { + let end = pane.items_len(); + pane.add_item_inner( + item.boxed_clone(), + false, + false, + false, + Some(end), + window, + cx, + ); + }); + item + } + }; + if was_in_use { + kept_item_in_use = Some(kept_item); + } + } + if let Some(item) = kept_item_in_use { + workspace.activate_item(item.as_ref(), true, true, window, cx); + } } let docks = serialized_workspace.docks; @@ -8309,7 +8405,7 @@ impl Workspace { }); } - workspace.restoring_workspace = false; + workspace.restoring_workspace.set(false); cx.notify(); })?; @@ -8332,6 +8428,9 @@ impl Workspace { }) }) .await; + workspace.update(cx, |workspace, _| { + workspace.restoring_from.borrow_mut().take(); + })?; // Clean up all the items that have _not_ been loaded. Our ItemIds aren't stable. That means // after loading the items, we might have different items and in order to avoid @@ -9732,12 +9831,38 @@ fn window_bounds_env_override() -> Option> { }) } +struct StopRestoringOnDrop { + restoring_workspace: Rc>, + restoring_from: Rc>>, +} + +impl Drop for StopRestoringOnDrop { + fn drop(&mut self) { + self.restoring_workspace.set(false); + self.restoring_from.borrow_mut().take(); + } +} + fn open_items( + workspace: &mut Workspace, serialized_workspace: Option, mut project_paths_to_open: Vec<(PathBuf, Option)>, window: &mut Window, cx: &mut Context, ) -> impl 'static + Future>>>>> + use<> { + let restoring = serialized_workspace + .as_ref() + .filter(|_| workspace.keeps_saved_state_while_restoring) + .map(|serialized_workspace| { + workspace.restoring_workspace.set(true); + workspace + .restoring_from + .replace(Some(serialized_workspace.clone())); + StopRestoringOnDrop { + restoring_workspace: workspace.restoring_workspace.clone(), + restoring_from: workspace.restoring_from.clone(), + } + }); let restored_items = serialized_workspace.map(|serialized_workspace| { Workspace::load_workspace( serialized_workspace, @@ -9752,6 +9877,7 @@ fn open_items( }); cx.spawn_in(window, async move |workspace, cx| { + let _restoring = restoring; let mut opened_items = Vec::with_capacity(project_paths_to_open.len()); if let Some(restored_items) = restored_items { @@ -10729,26 +10855,9 @@ pub async fn restore_multiworkspace( state, } = multi_workspace; - let workspace_result = if active_workspace.paths.is_empty() { - cx.update(|cx| { - open_workspace_by_id(active_workspace.workspace_id, app_state.clone(), None, cx) - }) - .await - } else { - cx.update(|cx| { - Workspace::new_local( - active_workspace.paths.paths().to_vec(), - app_state.clone(), - None, - None, - None, - OpenMode::Add, - cx, - ) - }) - .await - .map(|result| result.window) - }; + let workspace_result = cx + .update(|cx| open_saved_workspace(&active_workspace, app_state.clone(), false, cx)) + .await; let window_handle = match workspace_result { Ok(handle) => { @@ -10806,6 +10915,44 @@ pub async fn restore_multiworkspace( Ok(window_handle) } +pub fn open_saved_workspace( + saved: &SessionWorkspace, + app_state: Arc, + keeps_saved_state_while_restoring: bool, + cx: &mut App, +) -> impl Future>> + use<> { + if saved.paths.is_empty() { + open_workspace_by_id( + saved.workspace_id, + app_state, + None, + keeps_saved_state_while_restoring, + cx, + ) + .left_future() + } else { + let init = keeps_saved_state_while_restoring.then(|| { + Box::new( + |workspace: &mut Workspace, _: &mut Window, _: &mut Context| { + workspace.keeps_saved_state_while_restoring = true; + }, + ) + as Box) + Send> + }); + Workspace::new_local( + saved.paths.paths().to_vec(), + app_state, + None, + None, + init, + OpenMode::Add, + cx, + ) + .map(|result| result.map(|result| result.window)) + .right_future() + } +} + pub async fn apply_restored_multiworkspace_state( window_handle: WindowHandle, state: &MultiWorkspaceState, @@ -10878,7 +11025,7 @@ pub async fn apply_restored_multiworkspace_state( } } -fn restore_native_window_state( +pub fn restore_native_window_state( window_handle: WindowHandle, workspace_id: WorkspaceId, cx: &mut AsyncApp, @@ -11584,6 +11731,7 @@ pub fn open_workspace_by_id( workspace_id: WorkspaceId, app_state: Arc, requesting_window: Option>, + keeps_saved_state_while_restoring: bool, cx: &mut App, ) -> Task>> { let project_handle = Project::local( @@ -11678,8 +11826,15 @@ pub fn open_workspace_by_id( // Restore items from the serialized workspace window .update(cx, |_, window, cx| { - workspace.update(cx, |_workspace, cx| { - open_items(Some(serialized_workspace), Vec::new(), window, cx) + workspace.update(cx, |workspace, cx| { + workspace.keeps_saved_state_while_restoring = keeps_saved_state_while_restoring; + open_items( + workspace, + Some(serialized_workspace), + Vec::new(), + window, + cx, + ) }) })? .await?; @@ -12116,8 +12271,14 @@ async fn open_remote_project_inner( let items = window .update(cx, |_, window, cx| { window.activate_window(); - workspace.update(cx, |_workspace, cx| { - open_items(serialized_workspace, project_paths_to_open, window, cx) + workspace.update(cx, |workspace, cx| { + open_items( + workspace, + serialized_workspace, + project_paths_to_open, + window, + cx, + ) }) })? .await?; diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs index 4057dd7a0db..1390452c1bd 100644 --- a/crates/zed/src/main.rs +++ b/crates/zed/src/main.rs @@ -27,11 +27,16 @@ use db::kvp::{GlobalKeyValueStore, KeyValueStore}; use editor::Editor; use extension::ExtensionHostProxy; use fs::{Fs, RealFs}; -use futures::{FutureExt, StreamExt, channel::oneshot, future}; +use futures::{ + FutureExt, StreamExt, + channel::{mpsc, oneshot}, + future::{self, FusedFuture}, +}; use git::GitHostingProviderRegistry; use git_ui::clone::clone_and_open; use gpui::{ - App, AppContext, Application, AsyncApp, QuitMode, Task, TaskExt, UpdateGlobal as _, block_on, + App, AppContext, Application, AsyncApp, EntityId, QuitMode, Task, TaskExt, UpdateGlobal as _, + WindowHandle, block_on, }; use gpui_platform; @@ -46,28 +51,31 @@ use reqwest_client::ReqwestClient; use assets::Assets; use node_runtime::{NodeBinaryOptions, NodeRuntime}; use parking_lot::Mutex; -use project::{project_settings::ProjectSettings, trusted_worktrees}; +use project::{Project, ProjectGroupKey, project_settings::ProjectSettings, trusted_worktrees}; use recent_projects::{RemoteSettings, open_remote_project}; use release_channel::{AppCommitSha, AppVersion, ReleaseChannel}; use session::{AppSession, Session}; use settings::{BaseKeymap, Settings, SettingsStore, watch_config_file}; use smol::future::poll_once; use std::{ - cell::RefCell, + cell::{Cell, RefCell}, env, io::{self, IsTerminal}, path::{Path, PathBuf}, process, rc::Rc, sync::{Arc, LazyLock, OnceLock}, - time::Instant, + time::{Duration, Instant}, }; use theme::{ActiveTheme, GlobalTheme, ThemeRegistry}; use theme_settings::load_user_theme; -use util::{ResultExt, maybe}; +use util::{ + ResultExt, maybe, + paths::{PathStyle, SanitizedPath}, +}; use uuid::Uuid; use workspace::{ - AppState, MultiWorkspace, SerializedWorkspaceLocation, SessionWorkspace, Toast, + AppState, MultiWorkspace, PathList, SerializedWorkspaceLocation, SessionWorkspace, Toast, WorkspaceSettings, WorkspaceStore, notifications::{NotificationId, NotifyResultExt}, restore_multiworkspace, @@ -75,7 +83,8 @@ use workspace::{ use zed::{ OpenListener, OpenRequest, RawOpenRequest, app_menus, build_window_options, derive_paths_with_position, edit_prediction_registry, handle_cli_connection, - handle_keymap_file_changes, initialize_workspace, open_paths_with_positions, + handle_cli_request, handle_keymap_file_changes, initialize_workspace, + open_paths_with_positions, }; use crate::zed::{CrashHandler, OpenRequestKind, eager_load_active_theme_and_icon_theme}; @@ -926,11 +935,14 @@ fn main() { ) }; - let restore_task = match open_rx + let initial_request = open_rx .try_recv() .ok() - .and_then(|request| OpenRequest::parse(request, cx).log_err()) - { + .and_then(|request| OpenRequest::parse(request, cx).log_err()); + let runs_full_restore = initial_request + .as_ref() + .is_none_or(|request| request.is_focus_app_only()); + let restore_task = match initial_request { Some(request) if request.is_focus_app_only() => cx.spawn({ let app_state = app_state.clone(); async move |cx| { @@ -940,8 +952,8 @@ fn main() { } }), Some(request) => { - handle_open_request(request, app_state.clone(), cx); - Task::ready(()) + let restore_wait = cx.background_executor().timer(STARTUP_RESTORE_WAIT); + open_startup_request(request, app_state.clone(), restore_wait, cx) } None => cx.spawn({ let app_state = app_state.clone(); @@ -956,7 +968,7 @@ fn main() { let (first_window_tx, first_window_rx) = oneshot::channel::<()>(); let first_window_tx = Rc::new(RefCell::new(Some(first_window_tx))); let _first_window_subscription = cx.observe_new::(move |_, _, _| { - if let Some(tx) = first_window_tx.borrow_mut().take() { + if runs_full_restore && let Some(tx) = first_window_tx.borrow_mut().take() { tx.send(()).ok(); } }); @@ -1005,6 +1017,485 @@ fn main() { }); } +const STARTUP_RESTORE_WAIT: Duration = Duration::from_secs(5); + +pub(crate) fn open_startup_request( + request: OpenRequest, + app_state: Arc, + restore_wait: impl Future + 'static, + cx: &mut App, +) -> Task<()> { + let is_cli_connection = matches!(request.kind, Some(OpenRequestKind::CliConnection(_))); + if !is_cli_connection && RequestedPaths::of_request(&request).is_none() { + handle_open_request(request, app_state, cx); + return Task::ready(()); + } + + cx.spawn(async move |cx| { + let restore_wait = restore_wait.fuse(); + futures::pin_mut!(restore_wait); + let Some(mut request) = + StartupRequest::read(request, &mut restore_wait, &app_state, cx).await + else { + return; + }; + let Some(requested) = cx.update(|cx| request.requested_paths(cx)) else { + request.open(app_state, cx); + return; + }; + + let mut requested = cx + .spawn({ + let fs = app_state.fs.clone(); + let db = cx.update(|cx| workspace::WorkspaceDb::global(cx)); + async move |_| RequestedProject::new(fs.as_ref(), &db, &requested).await + }) + .fuse(); + let requested = futures::select_biased! { + requested = requested => Some(requested), + () = restore_wait => None, + }; + let Some(requested) = requested else { + request.open(app_state, cx); + return; + }; + let joins_restored_windows = requested.joins_restored_windows; + let restored_in_time = + restore_local_windows(&app_state, requested, &mut restore_wait, cx).await; + if !joins_restored_windows || !restored_in_time { + request.open_in_new_window(); + } + request.open(app_state, cx); + }) +} + +enum StartupRequest { + Cli { + request: cli::CliRequest, + requests: mpsc::UnboundedReceiver, + responses: Box, + }, + Other(OpenRequest), +} + +impl StartupRequest { + async fn read( + request: OpenRequest, + mut restore_wait: &mut (impl FusedFuture + Unpin), + app_state: &Arc, + cx: &mut AsyncApp, + ) -> Option { + match request.kind { + Some(OpenRequestKind::CliConnection((mut requests, responses))) => { + let request = futures::select_biased! { + request = requests.next() => Some(request), + () = restore_wait => None, + }; + let Some(request) = request else { + cx.spawn({ + let app_state = app_state.clone(); + async move |cx| { + handle_cli_connection((requests, responses), app_state, cx).await + } + }) + .detach(); + return None; + }; + Some(Self::Cli { + request: request?, + requests, + responses, + }) + } + _ => Some(Self::Other(request)), + } + } + + fn requested_paths(&self, cx: &App) -> Option { + match self { + Self::Cli { request, .. } => RequestedPaths::of_cli_request(request, cx), + Self::Other(request) => RequestedPaths::of_request(request), + } + } + + fn open_in_new_window(&mut self) { + match self { + Self::Cli { + request: cli::CliRequest::Open { open_behavior, .. }, + .. + } => *open_behavior = cli::OpenBehavior::AlwaysNew, + Self::Cli { .. } => {} + Self::Other(request) => request.open_behavior = Some(cli::OpenBehavior::AlwaysNew), + } + } + + fn open(self, app_state: Arc, cx: &mut AsyncApp) { + match self { + Self::Cli { + request, + requests, + responses, + } => cx + .spawn(async move |cx| { + handle_cli_request(request, requests, responses, app_state, cx).await + }) + .detach(), + Self::Other(request) => cx.update(|cx| handle_open_request(request, app_state, cx)), + } + } +} + +struct RequestedPaths { + paths: Vec, + reuses_windows: bool, +} + +impl RequestedPaths { + fn of_request(request: &OpenRequest) -> Option { + let opens_local_paths = request.kind.is_none() + && request.remote_connection.is_none() + && request.open_channel_notes.is_empty() + && request.join_channel.is_none() + && (!request.open_paths.is_empty() || !request.diff_paths.is_empty()); + opens_local_paths.then(|| Self { + paths: request.open_paths.clone(), + reuses_windows: !request.open_paths.is_empty() + && request.diff_paths.is_empty() + && !request.dev_container + && matches!( + request.open_behavior, + None | Some(cli::OpenBehavior::Default | cli::OpenBehavior::ExistingWindow) + ), + }) + } + + fn of_cli_request(request: &cli::CliRequest, cx: &App) -> Option { + let cli::CliRequest::Open { + urls, + paths, + diff_paths, + diff_all, + wait, + wsl, + open_behavior, + dev_container, + env, + cwd, + .. + } = request + else { + return None; + }; + if *wait { + return None; + } + if !urls.is_empty() { + let request = OpenRequest::parse( + RawOpenRequest { + urls: urls.clone(), + diff_paths: diff_paths.clone(), + diff_all: *diff_all, + dev_container: *dev_container, + wsl: wsl.clone(), + open_behavior: Some(*open_behavior), + }, + cx, + ) + .ok()?; + return Self::of_request(&request); + } + if paths.is_empty() + && diff_paths.is_empty() + && *open_behavior != cli::OpenBehavior::AlwaysNew + { + return None; + } + let mut requested = paths.clone(); + if paths.is_empty() + && !diff_paths.is_empty() + && let Some(cwd) = cwd + { + requested.push(cwd.to_string_lossy().into_owned()); + } + Some(Self { + paths: requested, + reuses_windows: !paths.is_empty() + && diff_paths.is_empty() + && !dev_container + && env.is_none() + && matches!( + open_behavior, + cli::OpenBehavior::Default | cli::OpenBehavior::ExistingWindow + ), + }) + } +} + +struct RequestedProject { + paths: Vec, + roots: Vec, + repositories: PathList, + joins_restored_windows: bool, +} + +impl RequestedProject { + async fn new(fs: &dyn Fs, db: &workspace::WorkspaceDb, requested: &RequestedPaths) -> Self { + let paths = derive_paths_with_position(fs, &requested.paths) + .await + .into_iter() + .map(|path| path.path) + .collect::>(); + let mut joins_restored_windows = + requested.reuses_windows && !db.has_workspace_for_roots(&paths); + for path in &paths { + if fs.is_dir(path).await { + joins_restored_windows = false; + } + } + let paths = resolved_paths(fs, &paths).await; + let roots = outermost_paths(&paths); + let repositories = PathList::new(&repository_paths(fs, &roots).await); + Self { + paths, + roots, + repositories, + joins_restored_windows, + } + } + + async fn opens(&self, fs: &dyn Fs, roots: &[PathBuf]) -> bool { + if roots.is_empty() { + return false; + } + let roots = resolved_paths(fs, roots).await; + let outermost_roots = outermost_paths(&roots); + if outermost_roots.iter().all(|root| self.paths.contains(root)) + && self.roots.iter().all(|path| outermost_roots.contains(path)) + { + return true; + } + PathList::new(&repository_paths(fs, &roots).await) == self.repositories + } + + async fn window_to_restore( + &self, + fs: &dyn Fs, + mut multi_workspace: workspace::SerializedMultiWorkspace, + ) -> Option { + let saved = &multi_workspace.active_workspace; + if saved.location != SerializedWorkspaceLocation::Local { + return None; + } + if self.opens(fs, saved.paths.paths()).await { + return None; + } + let mut project_groups = Vec::new(); + for group in std::mem::take(&mut multi_workspace.state.project_groups) { + let key = ProjectGroupKey::from(group.clone()); + if key.host().is_some() || !self.opens(fs, key.path_list().paths()).await { + project_groups.push(group); + } + } + multi_workspace.state.project_groups = project_groups; + Some(multi_workspace) + } +} + +async fn restore_local_windows( + app_state: &Arc, + requested: RequestedProject, + mut restore_wait: &mut (impl FusedFuture + Unpin), + cx: &mut AsyncApp, +) -> bool { + let fs = app_state.fs.clone(); + let mut windows_to_restore = cx + .spawn({ + let app_state = app_state.clone(); + let fs = fs.clone(); + async move |cx| { + let mut multi_workspaces = restorable_workspaces(cx, &app_state).await?; + if requested.joins_restored_windows { + multi_workspaces.sort_by_key(|multi_workspace| { + let roots = multi_workspace.active_workspace.paths.paths(); + requested + .paths + .iter() + .any(|path| roots.iter().any(|root| path.starts_with(root))) + }); + } + let mut windows_to_restore = Vec::new(); + for multi_workspace in multi_workspaces { + windows_to_restore.extend( + requested + .window_to_restore(fs.as_ref(), multi_workspace) + .await, + ); + } + Some(windows_to_restore) + } + }) + .fuse(); + let windows_to_restore = futures::select_biased! { + windows_to_restore = windows_to_restore => windows_to_restore, + () = restore_wait => return false, + }; + + let mut error_count = 0; + let mut restored_in_time = true; + for multi_workspace in windows_to_restore.into_iter().flatten() { + let saved = multi_workspace.active_workspace; + let state = multi_workspace.state; + let restored_project = Rc::new(Cell::new(None)); + let project_created = cx.update(|cx| { + cx.observe_new::({ + let restored_project = restored_project.clone(); + move |_, _, cx| { + if restored_project.get().is_none() { + restored_project.set(Some(cx.entity_id())); + } + } + }) + }); + let restoring = + cx.update(|cx| workspace::open_saved_workspace(&saved, app_state.clone(), true, cx)); + drop(project_created); + let mut restoring = restoring + .then({ + let mut cx = cx.clone(); + let fs = fs.clone(); + let workspace_id = saved.workspace_id; + async move |window| { + let window = window?; + workspace::restore_native_window_state(window, workspace_id, &mut cx); + workspace::apply_restored_multiworkspace_state(window, &state, fs, &mut cx) + .await; + anyhow::Ok(window) + } + }) + .boxed_local() + .fuse(); + let restored = futures::select_biased! { + restored = restoring => Some(restored), + () = restore_wait => None, + }; + match restored { + Some(Ok(window)) => { + window + .update(cx, |_, window, _| window.activate_window()) + .log_err(); + } + Some(Err(error)) => { + log::error!("Failed to restore workspace: {error:#}"); + error_count += 1; + } + None => { + let window = restored_project + .get() + .and_then(|project| cx.update(|cx| window_of_project(project, cx))); + if let Some(window) = window { + window + .update(cx, |_, window, _| window.activate_window()) + .log_err(); + cx.spawn(async move |_| { + restoring.await.log_err(); + }) + .detach(); + } + restored_in_time = false; + break; + } + } + } + if error_count > 0 { + let message = restore_errors_message(error_count); + cx.update(|cx| show_toast_in_active_workspace(&message, cx)); + } + restored_in_time +} + +fn window_of_project(project: EntityId, cx: &App) -> Option> { + cx.windows() + .into_iter() + .filter_map(|window| window.downcast::()) + .find(|window| { + window.read(cx).is_ok_and(|multi_workspace| { + multi_workspace + .workspaces() + .any(|workspace| workspace.read(cx).project().entity_id() == project) + }) + }) +} + +async fn resolved_paths(fs: &dyn Fs, paths: &[PathBuf]) -> Vec { + let mut resolved = Vec::with_capacity(paths.len()); + for path in paths { + let path = fs.canonicalize(path).await.unwrap_or_else(|_| path.clone()); + resolved.push( + SanitizedPath::from_arc(Arc::from(path.as_path())) + .as_path() + .to_path_buf(), + ); + } + resolved +} + +fn outermost_paths(paths: &[PathBuf]) -> Vec { + paths + .iter() + .filter(|path| { + !paths + .iter() + .any(|other| other != *path && path.starts_with(other)) + }) + .cloned() + .collect() +} + +async fn repository_paths(fs: &dyn Fs, paths: &[PathBuf]) -> Vec { + let mut repositories = Vec::with_capacity(paths.len()); + for path in paths { + repositories.push( + match project::discover_root_repo_common_dir(path, fs).await { + Some(common_dir) if !project::is_submodule_git_dir(&common_dir) => { + project::repo_identity_path(&common_dir, PathStyle::local()).to_path_buf() + } + _ => path.clone(), + }, + ); + } + repositories +} + +fn restore_errors_message(error_count: usize) -> String { + if error_count == 1 { + "Failed to restore 1 workspace. Check logs for details.".to_string() + } else { + format!( + "Failed to restore {} workspaces. Check logs for details.", + error_count + ) + } +} + +fn show_toast_in_active_workspace(message: &str, cx: &mut App) -> bool { + if let Some(window) = cx.active_window() + && let Some(multi_workspace) = window.downcast::() + { + multi_workspace + .update(cx, |multi_workspace, _, cx| { + multi_workspace.workspace().update(cx, |workspace, cx| { + workspace.show_toast( + Toast::new(NotificationId::unique::<()>(), message.to_string()), + cx, + ) + }); + }) + .ok(); + return true; + } + false +} + fn handle_open_request(request: OpenRequest, app_state: Arc, cx: &mut App) { if let Some(kind) = request.kind { match kind { @@ -1485,34 +1976,10 @@ pub(crate) async fn restore_or_create_workspace( } if error_count > 0 { - let message = if error_count == 1 { - "Failed to restore 1 workspace. Check logs for details.".to_string() - } else { - format!( - "Failed to restore {} workspaces. Check logs for details.", - error_count - ) - }; + let message = restore_errors_message(error_count); // Try to find an active workspace to show the toast - let toast_shown = cx.update(|cx| { - if let Some(window) = cx.active_window() - && let Some(multi_workspace) = window.downcast::() - { - multi_workspace - .update(cx, |multi_workspace, _, cx| { - multi_workspace.workspace().update(cx, |workspace, cx| { - workspace.show_toast( - Toast::new(NotificationId::unique::<()>(), message.clone()), - cx, - ) - }); - }) - .ok(); - return true; - } - false - }); + let toast_shown = cx.update(|cx| show_toast_in_active_workspace(&message, cx)); // If we couldn't show a toast (no windows opened successfully), // open a fallback empty workspace and show the error there diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs index d22eb41563b..4f6f54711b2 100644 --- a/crates/zed/src/zed.rs +++ b/crates/zed/src/zed.rs @@ -2913,7 +2913,9 @@ mod tests { use serde_json::json; use settings::{SaturatingBool, SettingsStore, SplicingVec, watch_config_file}; use std::{ + cell::RefCell, path::{Path, PathBuf}, + rc::Rc, sync::Arc, time::Duration, }; @@ -8712,6 +8714,1970 @@ mod tests { }); } + async fn init_startup_test(cx: &mut TestAppContext) -> Arc { + cx.update(|cx| cx.set_global(db::AppDatabase::test_new())); + let app_state = init_test(cx); + cx.update(|cx| db::kvp::KeyValueStore::global(cx)) + .write_kvp(onboarding::FIRST_OPEN.to_owned(), "false".to_owned()) + .await + .unwrap(); + app_state + } + + async fn restart_startup_test_session(app_state: &Arc, cx: &mut TestAppContext) { + use session::Session; + + let session_id = cx.read(|cx| app_state.session.read(cx).id().to_owned()); + for window in cx.windows() { + let window = window.downcast::().unwrap(); + flush_workspace_serialization(&window, cx).await; + VisualTestContext::from_window(window.into(), cx).deactivate_window(); + window + .update(cx, |_, window, _| window.remove_window()) + .unwrap(); + } + cx.run_until_parked(); + assert_eq!(cx.read(|cx| cx.active_window()), None); + cx.update(|cx| { + app_state.session.update(cx, |session, _| { + session.replace_session_for_test(Session::test_with_old_session(session_id)); + }); + }); + } + + async fn add_unsaved_buffer( + window: WindowHandle, + text: &str, + cx: &mut TestAppContext, + ) { + let editor = window + .update(cx, |multi_workspace, window, cx| { + multi_workspace.workspace().update(cx, |workspace, cx| { + Editor::new_in_workspace(workspace, window, cx) + }) + }) + .unwrap() + .await + .unwrap(); + window + .update(cx, |_, window, cx| { + editor.update(cx, |editor, cx| editor.insert(text, window, cx)); + }) + .unwrap(); + cx.run_until_parked(); + } + + async fn save_project_and_other_session(cx: &mut TestAppContext) -> Arc { + let app_state = init_startup_test(cx).await; + app_state + .fs + .as_fake() + .insert_tree( + path!("/"), + json!({ + "other": { "note.txt": "note" }, + "project": { "file.txt": "project file" }, + "new": { "readme.txt": "readme" }, + "outside.txt": "outside", + }), + ) + .await; + open_test_workspace_paths(vec![PathBuf::from(path!("/other"))], app_state.clone(), cx) + .await; + let project_window = open_test_workspace_paths( + vec![PathBuf::from(path!("/project"))], + app_state.clone(), + cx, + ) + .await + .window; + add_unsaved_buffer(project_window, "project draft", cx).await; + restart_startup_test_session(&app_state, cx).await; + app_state + } + + async fn save_session_without_folders(cx: &mut TestAppContext) -> Arc { + let app_state = init_startup_test(cx).await; + app_state + .fs + .as_fake() + .insert_tree(path!("/"), json!({ "outside.txt": "outside" })) + .await; + cx.update(|cx| { + workspace::open_new( + Default::default(), + app_state.clone(), + cx, + |workspace, window, cx| { + Editor::new_file(workspace, &Default::default(), window, cx); + }, + ) + }) + .await + .unwrap(); + let window = cx.windows()[0].downcast::().unwrap(); + window + .update(cx, |multi_workspace, window, cx| { + multi_workspace + .active_item_as::(cx) + .unwrap() + .update(cx, |editor, cx| editor.insert("UNSAVED", window, cx)); + }) + .unwrap(); + cx.run_until_parked(); + restart_startup_test_session(&app_state, cx).await; + app_state + } + + async fn open_on_startup( + request: OpenRequest, + app_state: &Arc, + cx: &mut TestAppContext, + ) { + cx.update(|cx| { + crate::open_startup_request(request, app_state.clone(), futures::future::pending(), cx) + }) + .await; + cx.run_until_parked(); + } + + fn startup_windows(cx: &TestAppContext) -> Vec<(Vec, Vec<(String, bool)>)> { + let mut windows = cx + .windows() + .into_iter() + .map(|window| window_contents(window, cx)) + .collect::>(); + windows.sort(); + windows + } + + fn window_contents( + window: gpui::AnyWindowHandle, + cx: &TestAppContext, + ) -> (Vec, Vec<(String, bool)>) { + window + .downcast::() + .unwrap() + .read_with(cx, |multi_workspace, cx| { + let workspace = multi_workspace.workspace().read(cx); + let roots = workspace + .root_paths(cx) + .iter() + .map(|path| path.to_path_buf()) + .collect(); + let mut items = workspace + .items_of_type::(cx) + .map(|editor| { + let editor = editor.read(cx); + (editor.text(cx), editor.is_dirty(cx)) + }) + .collect::>(); + items.sort(); + (roots, items) + }) + .unwrap() + } + + fn active_window_roots(cx: &TestAppContext) -> Vec { + let active_window = cx.read(|cx| cx.active_window()).unwrap(); + window_contents(active_window, cx).0 + } + + fn cli_environment_of(root: &str, cx: &TestAppContext) -> Option { + cx.windows() + .into_iter() + .filter_map(|window| window.downcast::()) + .find_map(|window| { + window + .read_with(cx, |multi_workspace, cx| { + let workspace = multi_workspace.workspace().read(cx); + (workspace + .root_paths(cx) + .first() + .map(|path| path.to_path_buf()) + == Some(PathBuf::from(root))) + .then(|| { + workspace + .project() + .read(cx) + .environment() + .read(cx) + .inherited_cli_environment() + .and_then(|env| env.get("REVIEW_ENV").cloned()) + }) + }) + .unwrap() + }) + .unwrap() + } + + struct IgnoredCliResponses; + + impl cli::CliResponseSink for IgnoredCliResponses { + fn send(&self, _: cli::CliResponse) -> anyhow::Result<()> { + Ok(()) + } + } + + fn cli_request( + paths: &[&str], + open_behavior: cli::OpenBehavior, + ) -> (OpenRequest, mpsc::UnboundedSender) { + cli_connection(cli_open_request(paths, &[], open_behavior, None)) + } + + fn terminal_cli_request( + paths: &[&str], + open_behavior: cli::OpenBehavior, + ) -> (OpenRequest, mpsc::UnboundedSender) { + cli_connection(cli_open_request( + paths, + &[], + open_behavior, + Some(terminal_environment()), + )) + } + + fn terminal_environment() -> collections::HashMap { + collections::HashMap::from_iter([("REVIEW_ENV".to_owned(), "cli".to_owned())]) + } + + fn cli_open_request( + paths: &[&str], + urls: &[String], + open_behavior: cli::OpenBehavior, + env: Option>, + ) -> cli::CliRequest { + cli::CliRequest::Open { + paths: paths.iter().map(|path| path.to_string()).collect(), + urls: urls.to_vec(), + diff_paths: Vec::new(), + diff_all: false, + wsl: None, + wait: false, + open_behavior, + env, + user_data_dir: None, + dev_container: false, + cwd: None, + } + } + + fn cli_connection( + request: cli::CliRequest, + ) -> (OpenRequest, mpsc::UnboundedSender) { + let (cli_requests, cli_receiver) = mpsc::unbounded(); + cli_requests.unbounded_send(request).unwrap(); + let request = OpenRequest { + kind: Some(OpenRequestKind::CliConnection(( + cli_receiver, + Box::new(IgnoredCliResponses), + ))), + ..OpenRequest::default() + }; + (request, cli_requests) + } + + fn project_window_with(items: &[(&str, bool)]) -> (Vec, Vec<(String, bool)>) { + let mut items = items + .iter() + .map(|(text, dirty)| (text.to_string(), *dirty)) + .collect::>(); + items.sort(); + (vec![PathBuf::from(path!("/project"))], items) + } + + fn other_window() -> (Vec, Vec<(String, bool)>) { + (vec![PathBuf::from(path!("/other"))], Vec::new()) + } + + #[gpui::test] + async fn test_startup_file_request_opens_in_its_restored_project(cx: &mut TestAppContext) { + let app_state = save_project_and_other_session(cx).await; + let (request, _cli) = + cli_request(&[path!("/project/file.txt")], cli::OpenBehavior::Default); + open_on_startup(request, &app_state, cx).await; + + assert_eq!( + startup_windows(cx), + vec![ + other_window(), + project_window_with(&[("project draft", true), ("project file", false)]), + ] + ); + assert_eq!( + active_window_roots(cx), + vec![PathBuf::from(path!("/project"))] + ); + assert_eq!(cli_environment_of(path!("/project"), cx), None); + } + + #[gpui::test] + async fn test_startup_request_for_file_links_with_positions_puts_each_cursor_in_its_file( + cx: &mut TestAppContext, + ) { + let app_state = init_startup_test(cx).await; + app_state + .fs + .as_fake() + .insert_tree( + path!("/project"), + json!({ "a.txt": "a1\na2\na3\n", "b.txt": "b1\nb2\nb3\n" }), + ) + .await; + open_test_workspace_paths( + vec![PathBuf::from(path!("/project"))], + app_state.clone(), + cx, + ) + .await; + restart_startup_test_session(&app_state, cx).await; + + let file_link = |path_with_position: &str| { + format!("file://{}", urlencoding::encode(path_with_position)) + }; + let (request, _cli) = cli_connection(cli_open_request( + &[], + &[ + file_link(&format!("{}:3", path!("/project/b.txt"))), + file_link(&format!("{}:2", path!("/project/a.txt"))), + ], + cli::OpenBehavior::Default, + None, + )); + open_on_startup(request, &app_state, cx).await; + + let windows = cx.windows(); + assert_eq!(windows.len(), 1); + let mut cursor_lines = windows[0] + .downcast::() + .unwrap() + .update(cx, |multi_workspace, _, cx| { + let editors = multi_workspace + .workspace() + .read(cx) + .items_of_type::(cx) + .collect::>(); + editors + .into_iter() + .map(|editor| { + editor.update(cx, |editor, cx| { + let cursor_row = editor + .selections + .newest_adjusted(&editor.display_snapshot(cx)) + .head() + .row; + editor + .text(cx) + .lines() + .nth(cursor_row as usize) + .map(str::to_owned) + }) + }) + .collect::>() + }) + .unwrap(); + cursor_lines.sort(); + assert_eq!( + cursor_lines, + vec![Some("a2".to_owned()), Some("b3".to_owned())] + ); + } + + #[gpui::test] + async fn test_startup_file_link_from_the_cli_opens_in_its_restored_project( + cx: &mut TestAppContext, + ) { + let app_state = save_project_and_other_session(cx).await; + let (request, _cli) = cli_connection(cli_open_request( + &[], + &[project_file_link()], + cli::OpenBehavior::Default, + None, + )); + open_on_startup(request, &app_state, cx).await; + + assert_eq!( + startup_windows(cx), + vec![ + other_window(), + project_window_with(&[("project draft", true), ("project file", false)]), + ] + ); + } + + #[gpui::test] + async fn test_startup_file_request_without_the_cli_opens_in_its_restored_project( + cx: &mut TestAppContext, + ) { + let app_state = save_project_and_other_session(cx).await; + let request = OpenRequest { + open_paths: vec![path!("/project/file.txt").to_owned()], + ..OpenRequest::default() + }; + open_on_startup(request, &app_state, cx).await; + + assert_eq!( + startup_windows(cx), + vec![ + other_window(), + project_window_with(&[("project draft", true), ("project file", false)]), + ] + ); + } + + #[gpui::test] + async fn test_startup_file_request_joins_a_restored_window_without_folders( + cx: &mut TestAppContext, + ) { + let app_state = save_session_without_folders(cx).await; + let (request, _cli) = cli_request(&[path!("/outside.txt")], cli::OpenBehavior::Default); + open_on_startup(request, &app_state, cx).await; + + assert_eq!( + startup_windows(cx), + vec![( + Vec::new(), + vec![("UNSAVED".to_owned(), true), ("outside".to_owned(), false)] + )] + ); + } + + #[gpui::test] + async fn test_startup_file_request_without_a_saved_session_opens_only_the_file( + cx: &mut TestAppContext, + ) { + let app_state = init_startup_test(cx).await; + app_state + .fs + .as_fake() + .insert_tree(path!("/"), json!({ "outside.txt": "outside" })) + .await; + let (request, _cli) = + terminal_cli_request(&[path!("/outside.txt")], cli::OpenBehavior::Default); + open_on_startup(request, &app_state, cx).await; + + assert_eq!( + startup_windows(cx), + vec![( + vec![PathBuf::from(path!("/outside.txt"))], + vec![("outside".to_owned(), false)] + )] + ); + assert_eq!( + cli_environment_of(path!("/outside.txt"), cx), + Some("cli".to_owned()) + ); + } + + #[gpui::test] + async fn test_startup_folder_request_for_a_restored_folder_opens_it_once_with_its_environment( + cx: &mut TestAppContext, + ) { + let app_state = save_project_and_other_session(cx).await; + let (request, _cli) = + terminal_cli_request(&[path!("/project")], cli::OpenBehavior::Default); + open_on_startup(request, &app_state, cx).await; + + assert_eq!( + startup_windows(cx), + vec![ + other_window(), + project_window_with(&[("project draft", true)]), + ] + ); + assert_eq!( + cli_environment_of(path!("/project"), cx), + Some("cli".to_owned()) + ); + assert_eq!(cli_environment_of(path!("/other"), cx), None); + assert_eq!( + active_window_roots(cx), + vec![PathBuf::from(path!("/project"))] + ); + } + + #[gpui::test] + async fn test_startup_new_window_request_for_a_restored_folder_and_a_file_in_it_opens_it_once( + cx: &mut TestAppContext, + ) { + let app_state = save_project_and_other_session(cx).await; + let (request, _cli) = cli_request( + &[path!("/project"), path!("/project/file.txt")], + cli::OpenBehavior::AlwaysNew, + ); + open_on_startup(request, &app_state, cx).await; + + assert_eq!( + startup_windows(cx) + .into_iter() + .map(|(roots, _)| roots) + .collect::>(), + vec![ + vec![PathBuf::from(path!("/other"))], + vec![PathBuf::from(path!("/project"))], + ] + ); + } + + #[gpui::test] + async fn test_startup_folder_request_for_a_new_folder_opens_its_own_window( + cx: &mut TestAppContext, + ) { + let app_state = save_project_and_other_session(cx).await; + let (request, _cli) = + terminal_cli_request(&[path!("/new")], cli::OpenBehavior::ExistingWindow); + open_on_startup(request, &app_state, cx).await; + + assert_eq!( + startup_windows(cx), + vec![ + (vec![PathBuf::from(path!("/new"))], Vec::new()), + other_window(), + project_window_with(&[("project draft", true)]), + ] + ); + assert_eq!( + cli_environment_of(path!("/new"), cx), + Some("cli".to_owned()) + ); + assert_eq!(active_window_roots(cx), vec![PathBuf::from(path!("/new"))]); + } + + #[gpui::test] + async fn test_startup_folder_request_without_the_cli_opens_its_own_window( + cx: &mut TestAppContext, + ) { + let app_state = save_project_and_other_session(cx).await; + let request = OpenRequest { + open_paths: vec![path!("/new").to_owned()], + ..OpenRequest::default() + }; + open_on_startup(request, &app_state, cx).await; + + assert_eq!( + startup_windows(cx), + vec![ + (vec![PathBuf::from(path!("/new"))], Vec::new()), + other_window(), + project_window_with(&[("project draft", true)]), + ] + ); + assert_eq!(active_window_roots(cx), vec![PathBuf::from(path!("/new"))]); + } + + #[gpui::test] + async fn test_startup_new_window_request_restores_a_window_without_folders( + cx: &mut TestAppContext, + ) { + let app_state = save_session_without_folders(cx).await; + let (request, _cli) = cli_request(&[], cli::OpenBehavior::AlwaysNew); + open_on_startup(request, &app_state, cx).await; + + assert_eq!( + startup_windows(cx), + vec![ + (Vec::new(), vec![(String::new(), false)]), + (Vec::new(), vec![("UNSAVED".to_owned(), true)]), + ] + ); + } + + #[gpui::test] + async fn test_bare_startup_cli_request_restores_the_session_once(cx: &mut TestAppContext) { + let app_state = save_project_and_other_session(cx).await; + let (request, _cli) = cli_request(&[], cli::OpenBehavior::Default); + open_on_startup(request, &app_state, cx).await; + + assert_eq!( + startup_windows(cx), + vec![ + other_window(), + project_window_with(&[("project draft", true)]), + ] + ); + } + + #[gpui::test] + async fn test_startup_link_request_opens_only_its_window(cx: &mut TestAppContext) { + let app_state = save_project_and_other_session(cx).await; + let request = OpenRequest { + kind: Some(OpenRequestKind::GitCommit { + sha: "0123456789abcdef".to_owned(), + }), + open_paths: vec![path!("/new").to_owned()], + ..OpenRequest::default() + }; + open_on_startup(request, &app_state, cx).await; + + assert_eq!( + startup_windows(cx), + vec![(vec![PathBuf::from(path!("/new"))], Vec::new())] + ); + } + + async fn save_session_with_a_project_tab(cx: &mut TestAppContext) -> Arc { + let app_state = init_startup_test(cx).await; + let fs = app_state.fs.as_fake(); + fs.insert_tree( + path!("/"), + json!({ + "project": { "file.txt": "project file" }, + "new": { "readme.txt": "readme" }, + "outside.txt": "outside", + }), + ) + .await; + open_test_workspace_paths( + vec![ + PathBuf::from(path!("/project")), + PathBuf::from(path!("/project/file.txt")), + ], + app_state.clone(), + cx, + ) + .await; + restart_startup_test_session(&app_state, cx).await; + app_state + } + + fn run_until_a_window_opens(cx: &mut TestAppContext) { + let mut steps = 0; + while cx.windows().is_empty() { + steps += 1; + assert!(steps < 100_000, "no window was opened"); + if !cx.executor().tick() { + cx.executor().advance_clock(Duration::from_millis(1)); + } + } + } + + #[gpui::test] + async fn test_startup_file_request_opens_after_the_session_is_restored( + cx: &mut TestAppContext, + ) { + let app_state = save_session_with_a_project_tab(cx).await; + let (request, _cli) = cli_request(&[path!("/outside.txt")], cli::OpenBehavior::Default); + let mut ready = cx.update(|cx| { + crate::open_startup_request(request, app_state.clone(), futures::future::pending(), cx) + }); + run_until_a_window_opens(cx); + assert!((&mut ready).now_or_never().is_none()); + assert_eq!( + startup_windows(cx) + .into_iter() + .map(|(roots, _)| roots) + .collect::>(), + vec![vec![PathBuf::from(path!("/project"))]] + ); + + ready.await; + cx.run_until_parked(); + assert_eq!( + startup_windows(cx), + vec![project_window_with(&[ + ("outside", false), + ("project file", false) + ])] + ); + } + + #[gpui::test] + async fn test_startup_folder_request_does_not_join_an_open_window(cx: &mut TestAppContext) { + let app_state = init_startup_test(cx).await; + app_state + .fs + .as_fake() + .insert_tree( + path!("/"), + json!({ "open": { "a.txt": "" }, "new": { "readme.txt": "readme" } }), + ) + .await; + open_test_workspace_paths(vec![PathBuf::from(path!("/open"))], app_state.clone(), cx).await; + let (request, _cli) = cli_request(&[path!("/new")], cli::OpenBehavior::ExistingWindow); + open_on_startup(request, &app_state, cx).await; + + assert_eq!( + startup_windows(cx), + vec![ + (vec![PathBuf::from(path!("/new"))], Vec::new()), + (vec![PathBuf::from(path!("/open"))], Vec::new()), + ] + ); + } + + #[gpui::test] + async fn test_startup_new_window_file_request_opens_beside_the_restored_session( + cx: &mut TestAppContext, + ) { + let app_state = save_project_and_other_session(cx).await; + let (request, _cli) = + cli_request(&[path!("/project/file.txt")], cli::OpenBehavior::AlwaysNew); + open_on_startup(request, &app_state, cx).await; + + assert_eq!( + startup_windows(cx), + vec![ + other_window(), + project_window_with(&[("project draft", true)]), + ( + vec![PathBuf::from(path!("/project/file.txt"))], + vec![("project file".to_owned(), false)] + ), + ] + ); + assert_eq!( + active_window_roots(cx), + vec![PathBuf::from(path!("/project/file.txt"))] + ); + } + + #[gpui::test] + async fn test_startup_reuse_window_file_request_does_not_replace_a_restored_window( + cx: &mut TestAppContext, + ) { + let app_state = save_project_and_other_session(cx).await; + let (request, _cli) = cli_request(&[path!("/project/file.txt")], cli::OpenBehavior::Reuse); + open_on_startup(request, &app_state, cx).await; + + assert_eq!( + startup_windows(cx), + vec![ + other_window(), + project_window_with(&[("project draft", true)]), + ( + vec![PathBuf::from(path!("/project/file.txt"))], + vec![("project file".to_owned(), false)] + ), + ] + ); + } + + #[gpui::test] + async fn test_startup_file_request_reopens_its_own_saved_window_with_its_unsaved_edits( + cx: &mut TestAppContext, + ) { + let app_state = init_startup_test(cx).await; + app_state + .fs + .as_fake() + .insert_tree( + path!("/"), + json!({ + "project": { "file.txt": "project file" }, + "notes.txt": "notes", + }), + ) + .await; + open_test_workspace_paths( + vec![PathBuf::from(path!("/project"))], + app_state.clone(), + cx, + ) + .await; + let notes_window = open_test_workspace_paths( + vec![PathBuf::from(path!("/notes.txt"))], + app_state.clone(), + cx, + ) + .await + .window; + notes_window + .update(cx, |multi_workspace, window, cx| { + multi_workspace + .active_item_as::(cx) + .unwrap() + .update(cx, |editor, cx| editor.insert("unsaved ", window, cx)); + }) + .unwrap(); + cx.run_until_parked(); + let edited_notes = startup_windows(cx) + .into_iter() + .find(|(roots, _)| roots == &[PathBuf::from(path!("/notes.txt"))]) + .unwrap(); + assert!(edited_notes.1[0].1); + restart_startup_test_session(&app_state, cx).await; + + let (request, _cli) = cli_request(&[path!("/notes.txt")], cli::OpenBehavior::Default); + open_on_startup(request, &app_state, cx).await; + + assert_eq!( + startup_windows(cx), + vec![edited_notes, project_window_with(&[])] + ); + } + + #[gpui::test] + async fn test_startup_folder_request_takes_its_project_out_of_a_restored_sidebar( + cx: &mut TestAppContext, + ) { + use util::path_list::PathList; + use workspace::{OpenMode, ProjectGroupKey}; + + let app_state = init_startup_test(cx).await; + app_state + .fs + .as_fake() + .insert_tree( + path!("/"), + json!({ "project": { "file.txt": "" }, "other": { "note.txt": "" } }), + ) + .await; + let window = open_test_workspace_paths( + vec![PathBuf::from(path!("/project"))], + app_state.clone(), + cx, + ) + .await + .window; + window + .update(cx, |multi_workspace, window, cx| { + multi_workspace.open_project( + vec![path!("/other").into()], + OpenMode::Add, + window, + cx, + ) + }) + .unwrap() + .await + .unwrap(); + window + .update(cx, |multi_workspace, window, cx| { + let project_workspace = multi_workspace + .workspaces() + .find(|workspace| { + workspace.read(cx).root_paths(cx) + == [Arc::from(Path::new(path!("/project")))] + }) + .unwrap() + .clone(); + multi_workspace.activate(project_workspace, None, window, cx); + }) + .unwrap(); + cx.run_until_parked(); + let project_key = ProjectGroupKey::new(None, PathList::new(&[path!("/project")])); + let other_key = ProjectGroupKey::new(None, PathList::new(&[path!("/other")])); + let sidebar_projects = |cx: &TestAppContext| { + cx.windows() + .into_iter() + .filter_map(|window| window.downcast::()) + .map(|window| { + window + .read_with(cx, |multi_workspace, _| { + multi_workspace.project_group_keys() + }) + .unwrap() + }) + .collect::>() + }; + assert_eq!(sidebar_projects(cx).len(), 1); + assert!(sidebar_projects(cx)[0].contains(&project_key)); + assert!(sidebar_projects(cx)[0].contains(&other_key)); + restart_startup_test_session(&app_state, cx).await; + + let (request, _cli) = terminal_cli_request(&[path!("/other")], cli::OpenBehavior::Default); + open_on_startup(request, &app_state, cx).await; + + assert_eq!( + startup_windows(cx), + vec![ + (vec![PathBuf::from(path!("/other"))], Vec::new()), + (vec![PathBuf::from(path!("/project"))], Vec::new()), + ] + ); + let restored_sidebar = sidebar_projects(cx) + .into_iter() + .find(|projects| projects.contains(&project_key)) + .unwrap(); + assert_eq!(restored_sidebar, vec![project_key]); + } + + #[gpui::test] + async fn test_startup_folder_request_opens_once_a_folder_that_a_saved_window_now_links_to( + cx: &mut TestAppContext, + ) { + let app_state = init_startup_test(cx).await; + let fs = app_state.fs.as_fake(); + fs.insert_tree( + path!("/"), + json!({ "target": { "file.txt": "" }, "old": { "note.txt": "" } }), + ) + .await; + open_test_workspace_paths(vec![PathBuf::from(path!("/target"))], app_state.clone(), cx) + .await; + restart_startup_test_session(&app_state, cx).await; + open_test_workspace_paths(vec![PathBuf::from(path!("/old"))], app_state.clone(), cx).await; + restart_startup_test_session(&app_state, cx).await; + fs.remove_dir( + Path::new(path!("/old")), + fs::RemoveOptions { + recursive: true, + ignore_if_not_exists: false, + }, + ) + .await + .unwrap(); + fs.create_symlink(Path::new(path!("/old")), PathBuf::from(path!("/target"))) + .await + .unwrap(); + + let (request, _cli) = cli_request(&[path!("/target")], cli::OpenBehavior::AlwaysNew); + open_on_startup(request, &app_state, cx).await; + + assert_eq!( + startup_windows(cx), + vec![(vec![PathBuf::from(path!("/target"))], Vec::new())] + ); + } + + #[gpui::test] + async fn test_startup_folder_request_opens_once_a_folder_that_a_saved_window_now_lies_inside( + cx: &mut TestAppContext, + ) { + let app_state = init_startup_test(cx).await; + let fs = app_state.fs.as_fake(); + fs.insert_tree( + path!("/"), + json!({ + "target": { "file.txt": "", "sub": { "inner.txt": "" } }, + "old": { "note.txt": "" }, + }), + ) + .await; + let target_window = + open_test_workspace_paths(vec![PathBuf::from(path!("/target"))], app_state.clone(), cx) + .await + .window; + add_unsaved_buffer(target_window, "target draft", cx).await; + restart_startup_test_session(&app_state, cx).await; + open_test_workspace_paths( + vec![ + PathBuf::from(path!("/old")), + PathBuf::from(path!("/target/sub")), + ], + app_state.clone(), + cx, + ) + .await; + restart_startup_test_session(&app_state, cx).await; + fs.remove_dir( + Path::new(path!("/old")), + fs::RemoveOptions { + recursive: true, + ignore_if_not_exists: false, + }, + ) + .await + .unwrap(); + fs.create_symlink(Path::new(path!("/old")), PathBuf::from(path!("/target"))) + .await + .unwrap(); + + let (request, _cli) = cli_request(&[path!("/target")], cli::OpenBehavior::AlwaysNew); + open_on_startup(request, &app_state, cx).await; + + assert_eq!( + startup_windows(cx), + vec![( + vec![PathBuf::from(path!("/target"))], + vec![("target draft".to_owned(), true)] + )] + ); + } + + #[gpui::test] + async fn test_startup_request_opens_without_the_session_when_the_wait_is_over( + cx: &mut TestAppContext, + ) { + let app_state = save_project_and_other_session(cx).await; + let (request, _cli) = + cli_request(&[path!("/project/file.txt")], cli::OpenBehavior::Default); + cx.update(|cx| { + crate::open_startup_request(request, app_state.clone(), futures::future::ready(()), cx) + }) + .await; + cx.run_until_parked(); + + assert_eq!(startup_windows(cx), vec![project_file_window()]); + } + + #[gpui::test] + async fn test_startup_stops_restoring_a_window_that_has_not_opened_when_the_wait_ends( + cx: &mut TestAppContext, + ) { + let app_state = save_session_with_a_project_tab(cx).await; + let outside_window = ( + vec![PathBuf::from(path!("/outside.txt"))], + vec![("outside".to_owned(), false)], + ); + let (end_the_wait, mut wait_ended) = mpsc::unbounded::<()>(); + let _restore_started = cx.update(|cx| { + cx.observe_new::(move |_, _, _| { + end_the_wait.unbounded_send(()).ok(); + }) + }); + let (request, _cli) = cli_request(&[path!("/outside.txt")], cli::OpenBehavior::Default); + cx.update(|cx| { + crate::open_startup_request( + request, + app_state.clone(), + async move { + wait_ended.next().await; + }, + cx, + ) + }) + .await; + cx.run_until_parked(); + assert_eq!(startup_windows(cx), vec![outside_window.clone()]); + + let (request, _cli) = cli_request(&[], cli::OpenBehavior::ExistingWindow); + cx.update(|cx| crate::handle_open_request(request, app_state.clone(), cx)); + cx.run_until_parked(); + assert_eq!( + startup_windows(cx), + vec![ + outside_window, + project_window_with(&[("project file", false)]) + ] + ); + } + + #[gpui::test] + async fn test_startup_finishes_only_the_window_it_is_restoring_when_the_wait_ends( + cx: &mut TestAppContext, + ) { + let app_state = init_startup_test(cx).await; + app_state + .fs + .as_fake() + .insert_tree( + path!("/"), + json!({ + "other": { "note.txt": "note" }, + "project": { "file.txt": "project file" }, + "outside.txt": "outside", + }), + ) + .await; + for (root, file) in [ + (path!("/other"), path!("/other/note.txt")), + (path!("/project"), path!("/project/file.txt")), + ] { + open_test_workspace_paths( + vec![PathBuf::from(root), PathBuf::from(file)], + app_state.clone(), + cx, + ) + .await; + } + restart_startup_test_session(&app_state, cx).await; + + let (end_the_wait, mut wait_ended) = mpsc::unbounded::<()>(); + let _window_opened = cx.update(|cx| { + cx.observe_new::(move |_, _, _| { + end_the_wait.unbounded_send(()).ok(); + }) + }); + let (request, _cli) = cli_request(&[path!("/outside.txt")], cli::OpenBehavior::Default); + cx.update(|cx| { + crate::open_startup_request( + request, + app_state.clone(), + async move { + wait_ended.next().await; + }, + cx, + ) + }) + .await; + let windows = cx.windows(); + assert_eq!(windows.len(), 1); + assert_eq!(cx.read(|cx| cx.active_window()), Some(windows[0])); + let restored_roots = window_contents(windows[0], cx).0; + let restored_tab = if restored_roots == [PathBuf::from(path!("/other"))] { + "note" + } else { + "project file" + }; + + cx.run_until_parked(); + let mut expected_windows = vec![ + (restored_roots, vec![(restored_tab.to_owned(), false)]), + ( + vec![PathBuf::from(path!("/outside.txt"))], + vec![("outside".to_owned(), false)], + ), + ]; + expected_windows.sort(); + assert_eq!(startup_windows(cx), expected_windows); + assert_eq!( + active_window_roots(cx), + vec![PathBuf::from(path!("/outside.txt"))] + ); + } + + #[gpui::test] + async fn test_startup_wait_request_opens_without_the_session(cx: &mut TestAppContext) { + let app_state = save_project_and_other_session(cx).await; + let mut request = cli_open_request( + &[path!("/outside.txt")], + &[], + cli::OpenBehavior::Default, + None, + ); + if let cli::CliRequest::Open { wait, .. } = &mut request { + *wait = true; + } + let (request, _cli) = cli_connection(request); + open_on_startup(request, &app_state, cx).await; + + assert_eq!( + startup_windows(cx), + vec![( + vec![PathBuf::from(path!("/outside.txt"))], + vec![("outside".to_owned(), false)] + )] + ); + } + + #[gpui::test] + async fn test_startup_request_for_a_linked_worktree_leaves_its_repository_to_the_request( + cx: &mut TestAppContext, + ) { + let app_state = init_startup_test(cx).await; + let fs = app_state.fs.as_fake(); + fs.insert_tree( + path!("/"), + json!({ + "repo": { ".git": {}, "file.txt": "" }, + "other": { "note.txt": "" }, + }), + ) + .await; + fs.add_linked_worktree_for_repo( + Path::new(path!("/repo/.git")), + false, + git::repository::Worktree { + path: PathBuf::from(path!("/repo-wt")), + ref_name: Some("refs/heads/wt".into()), + sha: "aaa".into(), + is_main: false, + is_bare: false, + }, + ) + .await; + for root in [path!("/other"), path!("/repo")] { + open_test_workspace_paths(vec![PathBuf::from(root)], app_state.clone(), cx).await; + } + restart_startup_test_session(&app_state, cx).await; + + let (request, _cli) = + terminal_cli_request(&[path!("/repo-wt")], cli::OpenBehavior::Default); + open_on_startup(request, &app_state, cx).await; + + assert_eq!( + startup_windows(cx), + vec![ + (vec![PathBuf::from(path!("/other"))], Vec::new()), + (vec![PathBuf::from(path!("/repo-wt"))], Vec::new()), + ] + ); + } + + #[gpui::test] + async fn test_startup_request_is_handled_as_before_when_the_wait_ends_before_it_is_prepared( + cx: &mut TestAppContext, + ) { + let app_state = init_startup_test(cx).await; + app_state + .fs + .as_fake() + .insert_tree( + path!("/"), + json!({ "open": { "a.txt": "" }, "outside.txt": "outside" }), + ) + .await; + open_test_workspace_paths(vec![PathBuf::from(path!("/open"))], app_state.clone(), cx).await; + let (request, _cli) = cli_request(&[path!("/outside.txt")], cli::OpenBehavior::Default); + cx.update(|cx| { + crate::open_startup_request(request, app_state.clone(), futures::future::ready(()), cx) + }) + .await; + cx.run_until_parked(); + + assert_eq!( + startup_windows(cx), + vec![( + vec![PathBuf::from(path!("/open"))], + vec![("outside".to_owned(), false)] + )] + ); + } + + #[gpui::test] + async fn test_startup_finishes_a_window_restored_through_a_link_when_the_wait_ends( + cx: &mut TestAppContext, + ) { + let app_state = init_startup_test(cx).await; + let fs = app_state.fs.as_fake(); + fs.insert_tree( + path!("/"), + json!({ + "target": { "file.txt": "target file" }, + "old": { "note.txt": "" }, + "outside.txt": "outside", + }), + ) + .await; + open_test_workspace_paths( + vec![ + PathBuf::from(path!("/target")), + PathBuf::from(path!("/target/file.txt")), + ], + app_state.clone(), + cx, + ) + .await; + restart_startup_test_session(&app_state, cx).await; + open_test_workspace_paths(vec![PathBuf::from(path!("/old"))], app_state.clone(), cx).await; + restart_startup_test_session(&app_state, cx).await; + fs.remove_dir( + Path::new(path!("/old")), + fs::RemoveOptions { + recursive: true, + ignore_if_not_exists: false, + }, + ) + .await + .unwrap(); + fs.create_symlink(Path::new(path!("/old")), PathBuf::from(path!("/target"))) + .await + .unwrap(); + + let (end_the_wait, mut wait_ended) = mpsc::unbounded::<()>(); + let _window_opened = cx.update(|cx| { + cx.observe_new::(move |_, _, _| { + end_the_wait.unbounded_send(()).ok(); + }) + }); + let (request, _cli) = cli_request(&[path!("/outside.txt")], cli::OpenBehavior::Default); + cx.update(|cx| { + crate::open_startup_request( + request, + app_state.clone(), + async move { + wait_ended.next().await; + }, + cx, + ) + }) + .await; + cx.run_until_parked(); + + assert_eq!( + startup_windows(cx), + vec![ + ( + vec![PathBuf::from(path!("/outside.txt"))], + vec![("outside".to_owned(), false)] + ), + ( + vec![PathBuf::from(path!("/target"))], + vec![("target file".to_owned(), false)] + ), + ] + ); + } + + async fn start_with_a_project_window_that_is_still_restoring( + cx: &mut TestAppContext, + ) -> (Arc, WindowHandle) { + let app_state = save_session_with_a_project_tab(cx).await; + let project_window = start_until_the_project_window_is_restoring(&app_state, cx).await; + (app_state, project_window) + } + + async fn start_until_the_project_window_is_restoring( + app_state: &Arc, + cx: &mut TestAppContext, + ) -> WindowHandle { + let project_window = start_until_a_window_is_restoring(app_state, cx).await; + assert_eq!( + window_contents(project_window.into(), cx), + (vec![PathBuf::from(path!("/project"))], Vec::new()) + ); + project_window + } + + async fn start_until_a_window_is_restoring( + app_state: &Arc, + cx: &mut TestAppContext, + ) -> WindowHandle { + let (end_the_wait, mut wait_ended) = mpsc::unbounded::<()>(); + let _window_opened = cx.update(|cx| { + cx.observe_new::(move |_, _, _| { + end_the_wait.unbounded_send(()).ok(); + }) + }); + let (request, _cli) = cli_request(&[path!("/outside.txt")], cli::OpenBehavior::Default); + cx.update(|cx| { + crate::open_startup_request( + request, + app_state.clone(), + async move { + wait_ended.next().await; + }, + cx, + ) + }) + .await; + let windows = cx.windows(); + assert_eq!(windows.len(), 1); + windows[0].downcast::().unwrap() + } + + fn open_tab_with_text( + window: WindowHandle, + text: &str, + cx: &mut TestAppContext, + ) { + window + .update(cx, |multi_workspace, window, cx| { + multi_workspace.workspace().update(cx, |workspace, cx| { + let project = workspace.project().clone(); + let buffer = project.update(cx, |project, cx| { + project.create_local_buffer(text, None, false, cx) + }); + let editor = cx.new(|cx| Editor::for_buffer(buffer, Some(project), window, cx)); + workspace.add_item_to_active_pane(Box::new(editor), None, true, window, cx); + }) + }) + .unwrap(); + } + + fn project_windows(cx: &TestAppContext) -> Vec> { + startup_windows(cx) + .into_iter() + .filter(|(roots, _)| roots == &[PathBuf::from(path!("/project"))]) + .map(|(_, items)| items) + .collect() + } + + #[gpui::test] + async fn test_quitting_while_a_window_is_still_restoring_keeps_it_in_the_session_with_its_tabs( + cx: &mut TestAppContext, + ) { + let (app_state, _) = start_with_a_project_window_that_is_still_restoring(cx).await; + quit_without_finishing_restores(cx).await; + restart_startup_test_session(&app_state, cx).await; + + let (request, _cli) = cli_request(&[], cli::OpenBehavior::Default); + open_on_startup(request, &app_state, cx).await; + assert_eq!( + project_windows(cx), + vec![vec![("project file".to_owned(), false)]] + ); + } + + #[gpui::test] + async fn test_tab_opened_in_a_window_that_is_still_restoring_is_kept(cx: &mut TestAppContext) { + let (_app_state, project_window) = + start_with_a_project_window_that_is_still_restoring(cx).await; + open_tab_with_text(project_window, "opened meanwhile", cx); + cx.run_until_parked(); + + let mut texts = project_windows(cx) + .into_iter() + .flatten() + .map(|(text, _)| text) + .collect::>(); + texts.sort(); + assert_eq!(texts, vec!["opened meanwhile", "project file"]); + } + + #[gpui::test] + async fn test_plain_start_does_not_keep_tabs_opened_while_its_window_is_restoring( + cx: &mut TestAppContext, + ) { + let app_state = save_session_with_a_project_tab(cx).await; + let restore = cx.spawn({ + let app_state = app_state.clone(); + async move |mut cx| crate::restore_or_create_workspace(app_state, &mut cx).await + }); + run_until_a_window_opens(cx); + let project_window = cx.windows()[0].downcast::().unwrap(); + open_tab_with_text(project_window, "opened meanwhile", cx); + restore.await.unwrap(); + cx.run_until_parked(); + + assert_eq!( + project_windows(cx), + vec![vec![("project file".to_owned(), false)]] + ); + } + + #[gpui::test] + async fn test_tab_opened_in_a_window_without_folders_that_is_still_restoring_is_kept( + cx: &mut TestAppContext, + ) { + let app_state = save_session_without_folders(cx).await; + let window = start_until_a_window_is_restoring(&app_state, cx).await; + assert_eq!(window_contents(window.into(), cx), (Vec::new(), Vec::new())); + open_tab_with_text(window, "opened meanwhile", cx); + cx.run_until_parked(); + + let mut texts = window_contents(window.into(), cx) + .1 + .into_iter() + .map(|(text, _)| text) + .collect::>(); + texts.sort(); + assert_eq!(texts, vec!["UNSAVED", "opened meanwhile"]); + } + + #[gpui::test] + async fn test_tab_in_use_in_a_window_that_is_still_restoring_stays_active( + cx: &mut TestAppContext, + ) { + let (_app_state, project_window) = + start_with_a_project_window_that_is_still_restoring(cx).await; + open_tab_with_text(project_window, "in use", cx); + open_tab_with_text(project_window, "opened later", cx); + project_window + .update(cx, |multi_workspace, window, cx| { + let pane = multi_workspace.workspace().read(cx).active_pane().clone(); + pane.update(cx, |pane, cx| pane.activate_item(0, true, true, window, cx)); + }) + .unwrap(); + cx.run_until_parked(); + + let tabs = project_windows(cx) + .into_iter() + .flatten() + .map(|(text, _)| text) + .collect::>(); + assert_eq!(tabs, vec!["in use", "opened later", "project file"]); + let active_tab = project_window + .read_with(cx, |multi_workspace, cx| { + let active_editor = multi_workspace + .workspace() + .read(cx) + .active_item_as::(cx)?; + Some(active_editor.read(cx).text(cx)) + }) + .unwrap(); + assert_eq!(active_tab.as_deref(), Some("in use")); + } + + #[gpui::test(iterations = 10)] + async fn test_file_requested_in_a_window_that_is_still_restoring_gets_one_tab( + cx: &mut TestAppContext, + ) { + let (app_state, _) = start_with_a_project_window_that_is_still_restoring(cx).await; + let (request, _cli) = + cli_request(&[path!("/project/file.txt")], cli::OpenBehavior::Default); + cx.update(|cx| crate::handle_open_request(request, app_state.clone(), cx)); + cx.run_until_parked(); + + assert_eq!( + project_windows(cx), + vec![vec![("project file".to_owned(), false)]] + ); + } + + #[gpui::test] + async fn test_window_whose_restore_was_cancelled_is_saved_as_it_is(cx: &mut TestAppContext) { + let app_state = save_session_with_a_project_tab(cx).await; + let saved = crate::restorable_workspaces(&mut cx.to_async(), &app_state) + .await + .unwrap() + .remove(0) + .active_workspace; + let opening = + cx.update(|cx| workspace::open_saved_workspace(&saved, app_state.clone(), true, cx)); + run_until_a_window_opens(cx); + let window = cx.windows()[0].downcast::().unwrap(); + let is_restoring = |cx: &TestAppContext| { + window + .read_with(cx, |multi_workspace, cx| { + multi_workspace.workspace().read(cx).is_restoring() + }) + .unwrap() + }; + assert!(is_restoring(cx)); + + drop(opening); + cx.run_until_parked(); + assert!(!is_restoring(cx)); + + quit_without_finishing_restores(cx).await; + open_test_workspace_paths( + vec![PathBuf::from(path!("/project"))], + app_state.clone(), + cx, + ) + .await; + assert_eq!(project_windows(cx), vec![Vec::new()]); + } + + #[gpui::test(iterations = 20)] + async fn test_file_requested_in_a_window_that_is_still_restoring_leaves_pinned_tabs_in_place( + cx: &mut TestAppContext, + ) { + let app_state = init_startup_test(cx).await; + app_state + .fs + .as_fake() + .insert_tree( + path!("/"), + json!({ + "project": { "file.txt": "project file", "second.txt": "second" }, + "outside.txt": "outside", + }), + ) + .await; + let window = open_test_workspace_paths( + vec![ + PathBuf::from(path!("/project")), + PathBuf::from(path!("/project/file.txt")), + PathBuf::from(path!("/project/second.txt")), + ], + app_state.clone(), + cx, + ) + .await + .window; + let tabs_and_pinned_count = |window: WindowHandle, cx: &TestAppContext| { + window + .read_with(cx, |multi_workspace, cx| { + let pane = multi_workspace.workspace().read(cx).active_pane().read(cx); + let tabs = pane + .items() + .filter_map(|item| item.downcast::()) + .map(|editor| editor.read(cx).text(cx)) + .collect::>(); + (tabs, pane.pinned_count()) + }) + .unwrap() + }; + window + .update(cx, |multi_workspace, _, cx| { + let pane = multi_workspace.workspace().read(cx).active_pane().clone(); + pane.update(cx, |pane, _| pane.set_pinned_count(1)); + }) + .unwrap(); + cx.run_until_parked(); + let saved_tabs = tabs_and_pinned_count(window, cx); + assert_eq!(saved_tabs.0.len(), 2); + let pinned_file = if saved_tabs.0[0] == "project file" { + path!("/project/file.txt") + } else { + path!("/project/second.txt") + }; + restart_startup_test_session(&app_state, cx).await; + + let project_window = start_until_the_project_window_is_restoring(&app_state, cx).await; + let (request, _cli) = cli_request(&[pinned_file], cli::OpenBehavior::Default); + cx.update(|cx| crate::handle_open_request(request, app_state.clone(), cx)); + cx.run_until_parked(); + + assert_eq!(tabs_and_pinned_count(project_window, cx), saved_tabs); + } + + #[gpui::test] + async fn test_quitting_while_a_window_is_still_restoring_keeps_what_was_made_in_it( + cx: &mut TestAppContext, + ) { + let (app_state, project_window) = + start_with_a_project_window_that_is_still_restoring(cx).await; + project_window + .update(cx, |multi_workspace, window, cx| { + multi_workspace.workspace().update(cx, |workspace, cx| { + let project = workspace.project().clone(); + let buffer = project.update(cx, |project, cx| { + project.create_local_buffer("", None, false, cx) + }); + let editor = cx.new(|cx| Editor::for_buffer(buffer, Some(project), window, cx)); + editor.update(cx, |editor, cx| editor.insert("new draft", window, cx)); + workspace.add_item_to_active_pane(Box::new(editor), None, true, window, cx); + }) + }) + .unwrap(); + quit_without_finishing_restores(cx).await; + restart_startup_test_session(&app_state, cx).await; + + let (request, _cli) = cli_request(&[], cli::OpenBehavior::Default); + open_on_startup(request, &app_state, cx).await; + assert_eq!( + project_windows(cx), + vec![vec![ + ("new draft".to_owned(), true), + ("project file".to_owned(), false) + ]] + ); + } + + #[gpui::test(iterations = 30)] + async fn test_draft_made_in_a_window_that_is_still_restoring_is_kept_without_another_save( + cx: &mut TestAppContext, + ) { + let (app_state, project_window) = + start_with_a_project_window_that_is_still_restoring(cx).await; + project_window + .update(cx, |multi_workspace, window, cx| { + multi_workspace.workspace().update(cx, |workspace, cx| { + let project = workspace.project().clone(); + let buffer = project.update(cx, |project, cx| { + project.create_local_buffer("", None, false, cx) + }); + let editor = cx.new(|cx| Editor::for_buffer(buffer, Some(project), window, cx)); + editor.update(cx, |editor, cx| editor.insert("new draft", window, cx)); + workspace.add_item_to_active_pane(Box::new(editor), None, true, window, cx); + }) + }) + .unwrap(); + cx.run_until_parked(); + for window in cx.windows() { + VisualTestContext::from_window(window, cx).deactivate_window(); + window + .update(cx, |_, window, _| window.remove_window()) + .unwrap(); + } + cx.run_until_parked(); + restart_startup_test_session(&app_state, cx).await; + + let (request, _cli) = cli_request(&[], cli::OpenBehavior::Default); + open_on_startup(request, &app_state, cx).await; + let drafts = project_windows(cx) + .into_iter() + .flatten() + .filter(|(_, is_dirty)| *is_dirty) + .collect::>(); + assert_eq!(drafts, vec![("new draft".to_owned(), true)]); + } + + async fn quit_without_finishing_restores(cx: &mut TestAppContext) { + let mut flushes = Vec::new(); + for window in cx.windows() { + let window = window.downcast::().unwrap(); + flushes.extend( + window + .update(cx, |multi_workspace, window, cx| { + let mut flushes = multi_workspace + .workspaces() + .map(|workspace| { + workspace.update(cx, |workspace, cx| { + workspace.flush_serialization(window, cx) + }) + }) + .collect::>(); + flushes.push(multi_workspace.flush_serialization(cx)); + window.remove_window(); + flushes + }) + .unwrap(), + ); + } + futures::future::join_all(flushes).await; + cx.run_until_parked(); + } + + #[gpui::test] + async fn test_startup_request_for_more_folders_than_a_saved_window_restores_that_window( + cx: &mut TestAppContext, + ) { + let app_state = save_project_and_other_session(cx).await; + let (request, _cli) = cli_request( + &[path!("/new"), path!("/project")], + cli::OpenBehavior::AlwaysNew, + ); + open_on_startup(request, &app_state, cx).await; + + assert_eq!( + startup_windows(cx), + vec![ + ( + vec![ + PathBuf::from(path!("/new")), + PathBuf::from(path!("/project")) + ], + Vec::new() + ), + other_window(), + project_window_with(&[("project draft", true)]), + ] + ); + } + + fn project_file_link() -> String { + format!("file://{}", urlencoding::encode(path!("/project/file.txt"))) + } + + fn project_file_window() -> (Vec, Vec<(String, bool)>) { + ( + vec![PathBuf::from(path!("/project/file.txt"))], + vec![("project file".to_owned(), false)], + ) + } + + #[gpui::test] + async fn test_startup_file_request_from_a_terminal_opens_in_its_own_window_with_its_environment( + cx: &mut TestAppContext, + ) { + let app_state = save_project_and_other_session(cx).await; + let (request, _cli) = + terminal_cli_request(&[path!("/project/file.txt")], cli::OpenBehavior::Default); + open_on_startup(request, &app_state, cx).await; + + assert_eq!( + startup_windows(cx), + vec![ + other_window(), + project_window_with(&[("project draft", true)]), + project_file_window(), + ] + ); + assert_eq!( + cli_environment_of(path!("/project/file.txt"), cx), + Some("cli".to_owned()) + ); + assert_eq!(cli_environment_of(path!("/project"), cx), None); + assert_eq!( + active_window_roots(cx), + vec![PathBuf::from(path!("/project/file.txt"))] + ); + } + + #[gpui::test] + async fn test_startup_file_request_restores_local_windows_only( + cx: &mut TestAppContext, + server_cx: &mut TestAppContext, + ) { + let app_state = init_startup_test(cx).await; + server_cx.update(|cx| { + release_channel::init(Version::new(0, 0, 0), cx); + HeadlessProject::init(cx); + }); + let remote_fs = FakeFs::new(server_cx.executor()); + remote_fs.insert_tree(path!("/remote"), json!({})).await; + let (connection_options, server_session, connect_guard) = + RemoteClient::fake_server(cx, server_cx); + let _headless = server_cx.new(|cx| { + HeadlessProject::new( + HeadlessAppState { + session: server_session, + fs: remote_fs, + http_client: Arc::new(BlockedHttpClient), + node_runtime: NodeRuntime::unavailable(), + languages: Arc::new(LanguageRegistry::new(cx.background_executor().clone())), + extension_host_proxy: Arc::new(ExtensionHostProxy::new()), + startup_time: std::time::Instant::now(), + }, + false, + cx, + ) + }); + drop(connect_guard); + recent_projects::open_remote_project( + connection_options, + vec![PathBuf::from(path!("/remote"))], + app_state.clone(), + OpenOptions::default(), + &mut cx.to_async(), + ) + .await + .unwrap(); + app_state + .fs + .as_fake() + .insert_tree( + path!("/"), + json!({ "project": { "file.txt": "project file" } }), + ) + .await; + open_test_workspace_paths( + vec![PathBuf::from(path!("/project"))], + app_state.clone(), + cx, + ) + .await; + restart_startup_test_session(&app_state, cx).await; + cx.executor().advance_clock(Duration::from_millis(50)); + cx.run_until_parked(); + let saved = crate::restorable_workspaces(&mut cx.to_async(), &app_state) + .await + .unwrap(); + assert_eq!(saved.len(), 2); + + let (request, _cli) = + cli_request(&[path!("/project/file.txt")], cli::OpenBehavior::Default); + open_on_startup(request, &app_state, cx).await; + + assert_eq!( + startup_windows(cx), + vec![project_window_with(&[("project file", false)])] + ); + assert!(!cx.has_pending_prompt()); + } + + #[gpui::test] + async fn test_startup_stops_holding_later_requests_behind_a_silent_cli( + cx: &mut TestAppContext, + ) { + let app_state = init_startup_test(cx).await; + let (cli_requests, cli_receiver) = mpsc::unbounded::(); + let request = OpenRequest { + kind: Some(OpenRequestKind::CliConnection(( + cli_receiver, + Box::new(IgnoredCliResponses), + ))), + ..OpenRequest::default() + }; + let (end_the_wait, wait_ended) = futures::channel::oneshot::channel::<()>(); + let mut ready = cx.update(|cx| { + crate::open_startup_request( + request, + app_state.clone(), + async move { + wait_ended.await.ok(); + }, + cx, + ) + }); + cx.run_until_parked(); + assert!((&mut ready).now_or_never().is_none()); + + end_the_wait.send(()).unwrap(); + ready.await; + drop(cli_requests); + } + + #[gpui::test] + async fn test_startup_cli_request_that_comes_too_late_opens_without_the_session( + cx: &mut TestAppContext, + ) { + let app_state = save_project_and_other_session(cx).await; + let (cli_requests, cli_receiver) = mpsc::unbounded::(); + let request = OpenRequest { + kind: Some(OpenRequestKind::CliConnection(( + cli_receiver, + Box::new(IgnoredCliResponses), + ))), + ..OpenRequest::default() + }; + cx.update(|cx| { + crate::open_startup_request(request, app_state.clone(), futures::future::ready(()), cx) + }) + .await; + cx.run_until_parked(); + assert_eq!(startup_windows(cx), Vec::new()); + + cli_requests + .unbounded_send(cli_open_request( + &[path!("/outside.txt")], + &[], + cli::OpenBehavior::Default, + None, + )) + .unwrap(); + cx.run_until_parked(); + assert_eq!( + startup_windows(cx), + vec![( + vec![PathBuf::from(path!("/outside.txt"))], + vec![("outside".to_owned(), false)] + )] + ); + } + + #[gpui::test] + async fn test_startup_file_request_outside_restored_projects_opens_in_the_front_window( + cx: &mut TestAppContext, + ) { + let app_state = save_project_and_other_session(cx).await; + let front_window_roots = crate::restorable_workspaces(&mut cx.to_async(), &app_state) + .await + .unwrap() + .last() + .unwrap() + .active_workspace + .paths + .paths() + .to_vec(); + let (request, _cli) = cli_request(&[path!("/outside.txt")], cli::OpenBehavior::Default); + open_on_startup(request, &app_state, cx).await; + + let window_with_the_file = startup_windows(cx) + .into_iter() + .find(|(_, items)| items.contains(&("outside".to_owned(), false))) + .unwrap(); + assert_eq!(window_with_the_file.0, front_window_roots); + assert_eq!(startup_windows(cx).len(), 2); + } + + #[gpui::test] + async fn test_startup_folder_request_opens_after_the_session_is_restored( + cx: &mut TestAppContext, + ) { + let app_state = save_session_with_a_project_tab(cx).await; + let new_window = (vec![PathBuf::from(path!("/new"))], Vec::new()); + let (request, _cli) = cli_request(&[path!("/new")], cli::OpenBehavior::Default); + let mut ready = cx.update(|cx| { + crate::open_startup_request(request, app_state.clone(), futures::future::pending(), cx) + }); + run_until_a_window_opens(cx); + assert!((&mut ready).now_or_never().is_none()); + assert_eq!( + startup_windows(cx) + .into_iter() + .map(|(roots, _)| roots) + .collect::>(), + vec![vec![PathBuf::from(path!("/project"))]] + ); + + ready.await; + assert_eq!( + active_window_roots(cx), + vec![PathBuf::from(path!("/project"))] + ); + cx.run_until_parked(); + assert_eq!( + startup_windows(cx), + vec![new_window, project_window_with(&[("project file", false)])] + ); + assert_eq!(active_window_roots(cx), vec![PathBuf::from(path!("/new"))]); + } + + #[gpui::test] + async fn test_startup_file_request_restores_the_window_it_opens_in_last( + cx: &mut TestAppContext, + ) { + for file in [path!("/other/note.txt"), path!("/project/file.txt")] { + let app_state = save_project_and_other_session(cx).await; + let restored_roots = Rc::new(RefCell::new(Vec::new())); + let _subscription = cx.update(|cx| { + let restored_roots = restored_roots.clone(); + cx.observe_new::(move |multi_workspace, _, cx| { + let roots = multi_workspace.workspace().read(cx).root_paths(cx); + restored_roots.borrow_mut().push(roots); + }) + }); + let (request, _cli) = cli_request(&[file], cli::OpenBehavior::Default); + open_on_startup(request, &app_state, cx).await; + + let restored_roots = restored_roots.borrow(); + assert_eq!(restored_roots.len(), 2); + assert!(Path::new(file).starts_with(&restored_roots[1][0])); + for window in cx.windows() { + cx.update_window(window, |_, window, _| window.remove_window()) + .unwrap(); + } + cx.run_until_parked(); + } + } + fn has_view_item(cx: &mut App, item_name: &str) -> bool { cx.get_menus() .expect("reload_keymaps should populate the menu bar") diff --git a/crates/zed/src/zed/open_listener.rs b/crates/zed/src/zed/open_listener.rs index c4b08f4b804..c33f37cc5fb 100644 --- a/crates/zed/src/zed/open_listener.rs +++ b/crates/zed/src/zed/open_listener.rs @@ -601,117 +601,127 @@ pub async fn handle_cli_connection( cx: &mut AsyncApp, ) { if let Some(request) = requests.next().await { - match request { - CliRequest::Open { - urls, + handle_cli_request(request, requests, responses, app_state, cx).await; + } +} + +pub async fn handle_cli_request( + request: CliRequest, + mut requests: mpsc::UnboundedReceiver, + responses: Box, + app_state: Arc, + cx: &mut AsyncApp, +) { + match request { + CliRequest::Open { + urls, + paths, + diff_paths, + diff_all, + wait, + wsl, + mut open_behavior, + env, + user_data_dir: _, + dev_container, + cwd, + } => { + if !urls.is_empty() { + cx.update(|cx| { + match OpenRequest::parse( + RawOpenRequest { + urls, + diff_paths, + diff_all, + dev_container, + wsl, + open_behavior: Some(open_behavior), + }, + cx, + ) { + Ok(open_request) => { + cx.activate(true); + handle_open_request(open_request, app_state.clone(), cx); + responses.send(CliResponse::Exit { status: 0 }).log_err(); + } + Err(e) => { + responses + .send(CliResponse::Stderr { + message: format!("{e}"), + }) + .log_err(); + responses.send(CliResponse::Exit { status: 1 }).log_err(); + } + }; + }); + return; + } + + if open_behavior == cli::OpenBehavior::Default { + match resolve_open_behavior( + &paths, + &app_state, + responses.as_ref(), + &mut requests, + cx, + ) + .await + { + Some(settings::CliDefaultOpenBehavior::ExistingWindow) => { + open_behavior = cli::OpenBehavior::ExistingWindow; + } + Some(settings::CliDefaultOpenBehavior::NewWindow) => { + open_behavior = cli::OpenBehavior::PreferNewWindow; + } + None => {} + } + } + + if open_behavior == cli::OpenBehavior::Default { + open_behavior = cx.update(|cx| open_behavior_for_default_setting(cx)); + } + + cx.update(|cx| cx.activate(true)); + + let open_workspace_result = open_workspaces( paths, diff_paths, diff_all, + open_behavior, + responses.as_ref(), wait, - wsl, - mut open_behavior, - env, - user_data_dir: _, dev_container, + app_state.clone(), + env, cwd, - } => { - if !urls.is_empty() { - cx.update(|cx| { - match OpenRequest::parse( - RawOpenRequest { - urls, - diff_paths, - diff_all, - dev_container, - wsl, - open_behavior: Some(open_behavior), - }, - cx, - ) { - Ok(open_request) => { - cx.activate(true); - handle_open_request(open_request, app_state.clone(), cx); - responses.send(CliResponse::Exit { status: 0 }).log_err(); - } - Err(e) => { - responses - .send(CliResponse::Stderr { - message: format!("{e}"), - }) - .log_err(); - responses.send(CliResponse::Exit { status: 1 }).log_err(); - } - }; - }); - return; - } + cx, + ) + .await; - if open_behavior == cli::OpenBehavior::Default { - match resolve_open_behavior( - &paths, - &app_state, - responses.as_ref(), - &mut requests, - cx, - ) - .await - { - Some(settings::CliDefaultOpenBehavior::ExistingWindow) => { - open_behavior = cli::OpenBehavior::ExistingWindow; - } - Some(settings::CliDefaultOpenBehavior::NewWindow) => { - open_behavior = cli::OpenBehavior::PreferNewWindow; - } - None => {} - } - } - - if open_behavior == cli::OpenBehavior::Default { - open_behavior = cx.update(|cx| open_behavior_for_default_setting(cx)); - } - - cx.update(|cx| cx.activate(true)); - - let open_workspace_result = open_workspaces( - paths, - diff_paths, - diff_all, - open_behavior, - responses.as_ref(), - wait, - dev_container, - app_state.clone(), - env, - cwd, - cx, - ) - .await; - - let status = if open_workspace_result.is_err() { 1 } else { 0 }; - responses.send(CliResponse::Exit { status }).log_err(); - } - CliRequest::SetOpenBehavior { .. } => { - // We handle this case in a situation-specific way in - // resolve_open_behavior - debug_panic!("unexpected SetOpenBehavior message"); - } - CliRequest::DebugState => { - // Deliberately does not activate the app: activation redraws - // windows and would disturb the state being inspected. - let state = cx.update(|cx| cx.debug_state()); - let response = match serde_json::to_string_pretty(&state) { - Ok(message) => CliResponse::Stdout { message }, - Err(error) => CliResponse::Stderr { - message: format!("failed to serialize debug state: {error}"), - }, - }; - let status = match response { - CliResponse::Stdout { .. } => 0, - _ => 1, - }; - responses.send(response).log_err(); - responses.send(CliResponse::Exit { status }).log_err(); - } + let status = if open_workspace_result.is_err() { 1 } else { 0 }; + responses.send(CliResponse::Exit { status }).log_err(); + } + CliRequest::SetOpenBehavior { .. } => { + // We handle this case in a situation-specific way in + // resolve_open_behavior + debug_panic!("unexpected SetOpenBehavior message"); + } + CliRequest::DebugState => { + // Deliberately does not activate the app: activation redraws + // windows and would disturb the state being inspected. + let state = cx.update(|cx| cx.debug_state()); + let response = match serde_json::to_string_pretty(&state) { + Ok(message) => CliResponse::Stdout { message }, + Err(error) => CliResponse::Stderr { + message: format!("failed to serialize debug state: {error}"), + }, + }; + let status = match response { + CliResponse::Stdout { .. } => 0, + _ => 1, + }; + responses.send(response).log_err(); + responses.send(CliResponse::Exit { status }).log_err(); } } }