Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

Honor window preference when opening remote projects (#61048)

aetos2ec2997789ea
diff --git a/Cargo.lock b/Cargo.lock
index 280bc530a5d..96d2031998a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -23327,6 +23327,7 @@ dependencies = [
"recent_projects",
"release_channel",
"remote",
+ "remote_server",
"repl",
"reqwest_client",
"rope",
diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml
index de08b4c5bc2..9f3d0784810 100644
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -258,12 +258,15 @@ pkg-config = "0.3.22"
[dev-dependencies]
call = { workspace = true, features = ["test-support"] }
editor = { workspace = true, features = ["test-support"] }
+fs = { workspace = true, features = ["test-support"] }
gpui = { workspace = true, features = ["input-latency-histogram", "test-support"] }
image_viewer = { workspace = true, features = ["test-support"] }
itertools.workspace = true
language = { workspace = true, features = ["test-support"] }
pretty_assertions.workspace = true
project = { workspace = true, features = ["test-support"] }
+remote = { workspace = true, features = ["test-support"] }
+remote_server = { workspace = true, features = ["test-support"] }
semver.workspace = true
terminal_view = { workspace = true, features = ["test-support"] }
title_bar = { workspace = true, features = ["test-support"] }
diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs
index 72c6860c7d2..11aef1415ab 100644
--- a/crates/zed/src/zed.rs
+++ b/crates/zed/src/zed.rs
@@ -1098,6 +1098,12 @@ fn register_actions(
if workspace.project().read(cx).is_local() {
return;
}
+ let create_new_window = action.create_new_window.unwrap_or_else(|| {
+ matches!(
+ WorkspaceSettings::get_global(cx).default_open_behavior,
+ DefaultOpenBehavior::NewWindow
+ )
+ });
telemetry::event!("Project Opened");
let paths = workspace.prompt_for_open_path(
PathPromptOptions {
@@ -1116,7 +1122,13 @@ fn register_actions(
};
if let Some(task) = this
.update_in(cx, |this, window, cx| {
- open_new_ssh_project_from_project(this, paths, window, cx)
+ open_new_ssh_project_from_project(
+ this,
+ paths,
+ create_new_window,
+ window,
+ cx,
+ )
})
.log_err()
{
@@ -2413,6 +2425,7 @@ fn filter_disabled_ai_bindings(bindings: Vec<KeyBinding>, cx: &App) -> Vec<KeyBi
pub fn open_new_ssh_project_from_project(
workspace: &mut Workspace,
paths: Vec<PathBuf>,
+ create_new_window: bool,
window: &mut Window,
cx: &mut Context<Workspace>,
) -> Task<anyhow::Result<()>> {
@@ -2421,6 +2434,11 @@ pub fn open_new_ssh_project_from_project(
return Task::ready(Err(anyhow::anyhow!("Not an ssh project")));
};
let connection_options = ssh_client.read(cx).connection_options();
+ let requesting_window = if create_new_window {
+ None
+ } else {
+ window.window_handle().downcast::<MultiWorkspace>()
+ };
cx.spawn_in(window, async move |_, cx| {
open_remote_project(
connection_options,
@@ -2428,6 +2446,7 @@ pub fn open_new_ssh_project_from_project(
app_state,
workspace::OpenOptions {
workspace_matching: workspace::WorkspaceMatching::None,
+ requesting_window,
..Default::default()
},
cx,
@@ -2841,15 +2860,21 @@ mod tests {
use editor::{
DisplayPoint, Editor, MultiBufferOffset, SelectionEffects, display_map::DisplayRow,
};
+ use extension::ExtensionHostProxy;
+ use fs::FakeFs;
use gpui::{
Action, AnyWindowHandle, App, AssetSource, BorrowAppContext, Modifiers, TestAppContext,
UpdateGlobal, VisualTestContext, WindowHandle, actions, point, px,
};
+ use http_client::BlockedHttpClient;
use language::LanguageRegistry;
use languages::{markdown_lang, rust_lang};
+ use node_runtime::NodeRuntime;
use pretty_assertions::{assert_eq, assert_ne};
use project::{Project, ProjectPath};
use prompt_store::PromptBuilder;
+ use remote::RemoteClient;
+ use remote_server::{HeadlessAppState, HeadlessProject};
use semver::Version;
use serde_json::json;
use settings::{SaturatingBool, SettingsStore, watch_config_file};
@@ -2931,6 +2956,116 @@ mod tests {
.unwrap();
}
+ #[gpui::test]
+ async fn test_open_remote_from_existing_connection_reuses_window(
+ cx: &mut TestAppContext,
+ server_cx: &mut TestAppContext,
+ ) {
+ let app_state = init_test(cx);
+ let executor = cx.executor();
+
+ server_cx.update(|cx| {
+ release_channel::init(Version::new(0, 0, 0), cx);
+ });
+
+ let (connection_options, server_session, connect_guard) =
+ RemoteClient::fake_server(cx, server_cx);
+ let remote_fs = FakeFs::new(server_cx.executor());
+ remote_fs
+ .insert_tree(
+ path!("/"),
+ json!({
+ "project": {},
+ "other-project": {},
+ }),
+ )
+ .await;
+
+ server_cx.update(HeadlessProject::init);
+ let http_client = Arc::new(BlockedHttpClient);
+ let node_runtime = NodeRuntime::unavailable();
+ let languages = Arc::new(LanguageRegistry::new(server_cx.executor()));
+ let extension_host_proxy = Arc::new(ExtensionHostProxy::new());
+ let _headless = server_cx.new(|cx| {
+ HeadlessProject::new(
+ HeadlessAppState {
+ session: server_session,
+ fs: remote_fs,
+ http_client,
+ node_runtime,
+ languages,
+ extension_host_proxy,
+ startup_time: std::time::Instant::now(),
+ },
+ false,
+ cx,
+ )
+ });
+ drop(connect_guard);
+
+ let mut async_cx = cx.to_async();
+ open_remote_project(
+ connection_options,
+ vec![PathBuf::from(path!("/project"))],
+ app_state,
+ OpenOptions::default(),
+ &mut async_cx,
+ )
+ .await
+ .expect("opening the initial remote project should succeed");
+ executor.run_until_parked();
+
+ assert_eq!(cx.update(|cx| cx.windows().len()), 1);
+ let window = cx.update(|cx| cx.windows()[0].downcast::<MultiWorkspace>().unwrap());
+
+ window
+ .update(cx, |multi_workspace, _, cx| {
+ let workspace = multi_workspace.workspace().clone();
+ workspace.update(cx, |workspace, cx| {
+ let remote_client = workspace
+ .project()
+ .read(cx)
+ .remote_client()
+ .expect("initial project should have a remote client");
+ remote_client.update(cx, |remote_client, cx| {
+ remote_client.force_server_not_running(cx);
+ });
+ });
+ })
+ .unwrap();
+ executor.run_until_parked();
+
+ window
+ .update(cx, |multi_workspace, window, cx| {
+ multi_workspace.workspace().update(cx, |workspace, _cx| {
+ workspace.set_prompt_for_open_path(Box::new(|_, _, _, _| {
+ let (sender, receiver) = futures::channel::oneshot::channel();
+ sender
+ .send(Some(vec![PathBuf::from(path!("/other-project"))]))
+ .expect("path prompt receiver should be open");
+ receiver
+ }));
+ });
+ window.dispatch_action(
+ Box::new(zed_actions::OpenRemote {
+ from_existing_connection: true,
+ create_new_window: Some(false),
+ }),
+ cx,
+ );
+ })
+ .unwrap();
+ executor.run_until_parked();
+
+ assert_eq!(
+ cx.update(|cx| cx.windows().len()),
+ 1,
+ "create_new_window: false should reuse the current window"
+ );
+ cx.simulate_prompt_answer("Cancel");
+ executor.run_until_parked();
+ }
+
#[gpui::test]
async fn test_open_paths_action(cx: &mut TestAppContext) {
let app_state = init_test(cx);