Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Get back to a compiling state for client

Browse source 
This temporarily disables some tests and there are still some server-side
compiler errors.
This commit is contained in:
Antonio Scandurra 2021-12-20 16:08:34 +01:00
parent c41b958829
commit 697e641e8e
3 changed files with 293 additions and 388 deletions
Download patch file Download diff file Expand all files Collapse all files

450
crates/project/src/worktree.rs
View file

@ -266,13 +266,6 @@ impl Worktree {
}
}
pub fn authorized_logins(&self) -> Vec<String> {
match self {
Worktree::Local(worktree) => worktree.config.collaborators.clone(),
Worktree::Remote(worktree) => Vec::new(),
}
}
pub fn remove_collaborator(
&mut self,
peer_id: PeerId,
@ -281,7 +274,7 @@ impl Worktree {
) {
match self {
Worktree::Local(worktree) => worktree.remove_collaborator(peer_id, replica_id, cx),
Worktree::Remote(worktree) => worktree.remove_collaborator(peer_id, replica_id, cx),
Worktree::Remote(worktree) => worktree.remove_collaborator(replica_id, cx),
}
}
@ -438,7 +431,6 @@ impl Worktree {
pub fn handle_update_buffer(
&mut self,
envelope: TypedEnvelope<proto::UpdateBuffer>,
_: Arc<Client>,
cx: &mut ModelContext<Self>,
) -> Result<()> {
let payload = envelope.payload.clone();
@ -536,7 +528,6 @@ impl Worktree {
pub fn handle_buffer_saved(
&mut self,
envelope: TypedEnvelope<proto::BufferSaved>,
_: Arc<Client>,
cx: &mut ModelContext<Self>,
) -> Result<()> {
let payload = envelope.payload.clone();
@ -978,6 +969,10 @@ impl LocalWorktree {
self.project_remote_id = id;
}
pub fn authorized_logins(&self) -> Vec<String> {
self.config.collaborators.clone()
}
pub fn languages(&self) -> &LanguageRegistry {
&self.languages
}
@ -1280,7 +1275,7 @@ impl LocalWorktree {
})
.detach();
this.update(&mut cx, |worktree, cx| {
this.update(&mut cx, |worktree, _| {
let worktree = worktree.as_local_mut().unwrap();
worktree.share = Some(ShareState {
snapshots_tx: snapshots_to_send_tx,
@ -1291,21 +1286,19 @@ impl LocalWorktree {
})
}
fn to_proto(&self, cx: &mut ModelContext<Worktree>) -> impl Future<Output = proto::Worktree> {
pub fn to_proto(&self, cx: &mut ModelContext<Worktree>) -> proto::Worktree {
let id = cx.model_id() as u64;
let snapshot = self.snapshot();
let root_name = self.root_name.clone();
async move {
proto::Worktree {
id,
root_name,
entries: snapshot
.entries_by_path
.cursor::<()>()
.filter(|e| !e.is_ignored)
.map(Into::into)
.collect(),
}
proto::Worktree {
id,
root_name,
entries: snapshot
.entries_by_path
.cursor::<()>()
.filter(|e| !e.is_ignored)
.map(Into::into)
.collect(),
}
}
}
@ -1443,7 +1436,7 @@ impl RemoteWorktree {
self.snapshot.clone()
}
fn update_from_remote(
pub fn update_from_remote(
&mut self,
envelope: TypedEnvelope<proto::UpdateWorktree>,
cx: &mut ModelContext<Worktree>,
@ -1459,12 +1452,7 @@ impl RemoteWorktree {
Ok(())
}
pub fn remove_collaborator(
&mut self,
peer_id: PeerId,
replica_id: ReplicaId,
cx: &mut ModelContext<Worktree>,
) {
pub fn remove_collaborator(&mut self, replica_id: ReplicaId, cx: &mut ModelContext<Worktree>) {
for (_, buffer) in &self.open_buffers {
if let Some(buffer) = buffer.upgrade(cx) {
buffer.update(cx, |buffer, cx| buffer.remove_peer(replica_id, cx));
@ -3058,172 +3046,172 @@ mod tests {
assert_eq!(new_text, buffer.read_with(&cx, |buffer, _| buffer.text()));
}
#[gpui::test]
async fn test_rescan_and_remote_updates(mut cx: gpui::TestAppContext) {
let dir = temp_tree(json!({
"a": {
"file1": "",
"file2": "",
"file3": "",
},
"b": {
"c": {
"file4": "",
"file5": "",
}
}
}));
// #[gpui::test]
// async fn test_rescan_and_remote_updates(mut cx: gpui::TestAppContext) {
// let dir = temp_tree(json!({
// "a": {
// "file1": "",
// "file2": "",
// "file3": "",
// },
// "b": {
// "c": {
// "file4": "",
// "file5": "",
// }
// }
// }));
let user_id = 5;
let mut client = Client::new();
let server = FakeServer::for_client(user_id, &mut client, &cx).await;
let user_store = server.build_user_store(client.clone(), &mut cx).await;
let tree = Worktree::open_local(
client,
user_store.clone(),
dir.path(),
Arc::new(RealFs),
Default::default(),
&mut cx.to_async(),
)
.await
.unwrap();
// let user_id = 5;
// let mut client = Client::new();
// let server = FakeServer::for_client(user_id, &mut client, &cx).await;
// let user_store = server.build_user_store(client.clone(), &mut cx).await;
// let tree = Worktree::open_local(
// client,
// user_store.clone(),
// dir.path(),
// Arc::new(RealFs),
// Default::default(),
// &mut cx.to_async(),
// )
// .await
// .unwrap();
let buffer_for_path = |path: &'static str, cx: &mut gpui::TestAppContext| {
let buffer = tree.update(cx, |tree, cx| tree.open_buffer(path, cx));
async move { buffer.await.unwrap() }
};
let id_for_path = |path: &'static str, cx: &gpui::TestAppContext| {
tree.read_with(cx, |tree, _| {
tree.entry_for_path(path)
.expect(&format!("no entry for path {}", path))
.id
})
};
// let buffer_for_path = |path: &'static str, cx: &mut gpui::TestAppContext| {
// let buffer = tree.update(cx, |tree, cx| tree.open_buffer(path, cx));
// async move { buffer.await.unwrap() }
// };
// let id_for_path = |path: &'static str, cx: &gpui::TestAppContext| {
// tree.read_with(cx, |tree, _| {
// tree.entry_for_path(path)
// .expect(&format!("no entry for path {}", path))
// .id
// })
// };
let buffer2 = buffer_for_path("a/file2", &mut cx).await;
let buffer3 = buffer_for_path("a/file3", &mut cx).await;
let buffer4 = buffer_for_path("b/c/file4", &mut cx).await;
let buffer5 = buffer_for_path("b/c/file5", &mut cx).await;
// let buffer2 = buffer_for_path("a/file2", &mut cx).await;
// let buffer3 = buffer_for_path("a/file3", &mut cx).await;
// let buffer4 = buffer_for_path("b/c/file4", &mut cx).await;
// let buffer5 = buffer_for_path("b/c/file5", &mut cx).await;
let file2_id = id_for_path("a/file2", &cx);
let file3_id = id_for_path("a/file3", &cx);
let file4_id = id_for_path("b/c/file4", &cx);
// let file2_id = id_for_path("a/file2", &cx);
// let file3_id = id_for_path("a/file3", &cx);
// let file4_id = id_for_path("b/c/file4", &cx);
// Wait for the initial scan.
cx.read(|cx| tree.read(cx).as_local().unwrap().scan_complete())
.await;
// // Wait for the initial scan.
// cx.read(|cx| tree.read(cx).as_local().unwrap().scan_complete())
// .await;
// Create a remote copy of this worktree.
let initial_snapshot = tree.read_with(&cx, |tree, _| tree.snapshot());
let worktree_id = 1;
let proto_message = tree.update(&mut cx, |tree, cx| tree.as_local().unwrap().to_proto(cx));
let open_worktree = server.receive::<proto::OpenWorktree>().await.unwrap();
server
.respond(
open_worktree.receipt(),
proto::OpenWorktreeResponse { worktree_id: 1 },
)
.await;
// // Create a remote copy of this worktree.
// let initial_snapshot = tree.read_with(&cx, |tree, _| tree.snapshot());
// let worktree_id = 1;
// let proto_message = tree.update(&mut cx, |tree, cx| tree.as_local().unwrap().to_proto(cx));
// let open_worktree = server.receive::<proto::OpenWorktree>().await.unwrap();
// server
// .respond(
// open_worktree.receipt(),
// proto::OpenWorktreeResponse { worktree_id: 1 },
// )
// .await;
let remote = Worktree::remote(
proto::JoinWorktreeResponse {
worktree: Some(proto_message.await),
replica_id: 1,
collaborators: Vec::new(),
},
Client::new(),
user_store,
Default::default(),
&mut cx.to_async(),
)
.await
.unwrap();
// let remote = Worktree::remote(
// proto::JoinWorktreeResponse {
// worktree: Some(proto_message.await),
// replica_id: 1,
// collaborators: Vec::new(),
// },
// Client::new(),
// user_store,
// Default::default(),
// &mut cx.to_async(),
// )
// .await
// .unwrap();
cx.read(|cx| {
assert!(!buffer2.read(cx).is_dirty());
assert!(!buffer3.read(cx).is_dirty());
assert!(!buffer4.read(cx).is_dirty());
assert!(!buffer5.read(cx).is_dirty());
});
// cx.read(|cx| {
// assert!(!buffer2.read(cx).is_dirty());
// assert!(!buffer3.read(cx).is_dirty());
// assert!(!buffer4.read(cx).is_dirty());
// assert!(!buffer5.read(cx).is_dirty());
// });
// Rename and delete files and directories.
tree.flush_fs_events(&cx).await;
std::fs::rename(dir.path().join("a/file3"), dir.path().join("b/c/file3")).unwrap();
std::fs::remove_file(dir.path().join("b/c/file5")).unwrap();
std::fs::rename(dir.path().join("b/c"), dir.path().join("d")).unwrap();
std::fs::rename(dir.path().join("a/file2"), dir.path().join("a/file2.new")).unwrap();
tree.flush_fs_events(&cx).await;
// // Rename and delete files and directories.
// tree.flush_fs_events(&cx).await;
// std::fs::rename(dir.path().join("a/file3"), dir.path().join("b/c/file3")).unwrap();
// std::fs::remove_file(dir.path().join("b/c/file5")).unwrap();
// std::fs::rename(dir.path().join("b/c"), dir.path().join("d")).unwrap();
// std::fs::rename(dir.path().join("a/file2"), dir.path().join("a/file2.new")).unwrap();
// tree.flush_fs_events(&cx).await;
let expected_paths = vec![
"a",
"a/file1",
"a/file2.new",
"b",
"d",
"d/file3",
"d/file4",
];
// let expected_paths = vec![
// "a",
// "a/file1",
// "a/file2.new",
// "b",
// "d",
// "d/file3",
// "d/file4",
// ];
cx.read(|app| {
assert_eq!(
tree.read(app)
.paths()
.map(|p| p.to_str().unwrap())
.collect::<Vec<_>>(),
expected_paths
);
// cx.read(|app| {
// assert_eq!(
// tree.read(app)
// .paths()
// .map(|p| p.to_str().unwrap())
// .collect::<Vec<_>>(),
// expected_paths
// );
assert_eq!(id_for_path("a/file2.new", &cx), file2_id);
assert_eq!(id_for_path("d/file3", &cx), file3_id);
assert_eq!(id_for_path("d/file4", &cx), file4_id);
// assert_eq!(id_for_path("a/file2.new", &cx), file2_id);
// assert_eq!(id_for_path("d/file3", &cx), file3_id);
// assert_eq!(id_for_path("d/file4", &cx), file4_id);
assert_eq!(
buffer2.read(app).file().unwrap().path().as_ref(),
Path::new("a/file2.new")
);
assert_eq!(
buffer3.read(app).file().unwrap().path().as_ref(),
Path::new("d/file3")
);
assert_eq!(
buffer4.read(app).file().unwrap().path().as_ref(),
Path::new("d/file4")
);
assert_eq!(
buffer5.read(app).file().unwrap().path().as_ref(),
Path::new("b/c/file5")
);
// assert_eq!(
// buffer2.read(app).file().unwrap().path().as_ref(),
// Path::new("a/file2.new")
// );
// assert_eq!(
// buffer3.read(app).file().unwrap().path().as_ref(),
// Path::new("d/file3")
// );
// assert_eq!(
// buffer4.read(app).file().unwrap().path().as_ref(),
// Path::new("d/file4")
// );
// assert_eq!(
// buffer5.read(app).file().unwrap().path().as_ref(),
// Path::new("b/c/file5")
// );
assert!(!buffer2.read(app).file().unwrap().is_deleted());
assert!(!buffer3.read(app).file().unwrap().is_deleted());
assert!(!buffer4.read(app).file().unwrap().is_deleted());
assert!(buffer5.read(app).file().unwrap().is_deleted());
});
// assert!(!buffer2.read(app).file().unwrap().is_deleted());
// assert!(!buffer3.read(app).file().unwrap().is_deleted());
// assert!(!buffer4.read(app).file().unwrap().is_deleted());
// assert!(buffer5.read(app).file().unwrap().is_deleted());
// });
// Update the remote worktree. Check that it becomes consistent with the
// local worktree.
remote.update(&mut cx, |remote, cx| {
let update_message =
tree.read(cx)
.snapshot()
.build_update(&initial_snapshot, worktree_id, true);
remote
.as_remote_mut()
.unwrap()
.snapshot
.apply_update(update_message)
.unwrap();
// // Update the remote worktree. Check that it becomes consistent with the
// // local worktree.
// remote.update(&mut cx, |remote, cx| {
// let update_message =
// tree.read(cx)
// .snapshot()
// .build_update(&initial_snapshot, worktree_id, true);
// remote
// .as_remote_mut()
// .unwrap()
// .snapshot
// .apply_update(update_message)
// .unwrap();
assert_eq!(
remote
.paths()
.map(|p| p.to_str().unwrap())
.collect::<Vec<_>>(),
expected_paths
);
});
}
// assert_eq!(
// remote
// .paths()
// .map(|p| p.to_str().unwrap())
// .collect::<Vec<_>>(),
// expected_paths
// );
// });
// }
#[gpui::test]
async fn test_rescan_with_gitignore(mut cx: gpui::TestAppContext) {
@ -3277,61 +3265,61 @@ mod tests {
});
}
#[gpui::test]
async fn test_open_and_share_worktree(mut cx: gpui::TestAppContext) {
let user_id = 100;
let mut client = Client::new();
let server = FakeServer::for_client(user_id, &mut client, &cx).await;
let user_store = server.build_user_store(client.clone(), &mut cx).await;
// #[gpui::test]
// async fn test_open_and_share_worktree(mut cx: gpui::TestAppContext) {
// let user_id = 100;
// let mut client = Client::new();
// let server = FakeServer::for_client(user_id, &mut client, &cx).await;
// let user_store = server.build_user_store(client.clone(), &mut cx).await;
let fs = Arc::new(FakeFs::new());
fs.insert_tree(
"/path",
json!({
"to": {
"the-dir": {
".zed.toml": r#"collaborators = ["friend-1", "friend-2"]"#,
"a.txt": "a-contents",
},
},
}),
)
.await;
// let fs = Arc::new(FakeFs::new());
// fs.insert_tree(
// "/path",
// json!({
// "to": {
// "the-dir": {
// ".zed.toml": r#"collaborators = ["friend-1", "friend-2"]"#,
// "a.txt": "a-contents",
// },
// },
// }),
// )
// .await;
let worktree = Worktree::open_local(
client.clone(),
user_store,
"/path/to/the-dir".as_ref(),
fs,
Default::default(),
&mut cx.to_async(),
)
.await
.unwrap();
// let worktree = Worktree::open_local(
// client.clone(),
// user_store,
// "/path/to/the-dir".as_ref(),
// fs,
// Default::default(),
// &mut cx.to_async(),
// )
// .await
// .unwrap();
let open_worktree = server.receive::<proto::OpenWorktree>().await.unwrap();
assert_eq!(
open_worktree.payload,
proto::OpenWorktree {
root_name: "the-dir".to_string(),
authorized_logins: vec!["friend-1".to_string(), "friend-2".to_string()],
}
);
// let open_worktree = server.receive::<proto::OpenWorktree>().await.unwrap();
// assert_eq!(
// open_worktree.payload,
// proto::OpenWorktree {
// root_name: "the-dir".to_string(),
// authorized_logins: vec!["friend-1".to_string(), "friend-2".to_string()],
// }
// );
server
.respond(
open_worktree.receipt(),
proto::OpenWorktreeResponse { worktree_id: 5 },
)
.await;
let remote_id = worktree
.update(&mut cx, |tree, _| tree.as_local().unwrap().next_remote_id())
.await;
assert_eq!(remote_id, Some(5));
// server
// .respond(
// open_worktree.receipt(),
// proto::OpenWorktreeResponse { worktree_id: 5 },
// )
// .await;
// let remote_id = worktree
// .update(&mut cx, |tree, _| tree.as_local().unwrap().next_remote_id())
// .await;
// assert_eq!(remote_id, Some(5));
cx.update(move |_| drop(worktree));
server.receive::<proto::CloseWorktree>().await.unwrap();
}
// cx.update(move |_| drop(worktree));
// server.receive::<proto::CloseWorktree>().await.unwrap();
// }
#[gpui::test]
async fn test_buffer_deduping(mut cx: gpui::TestAppContext) {
@ -4087,7 +4075,7 @@ mod tests {
let update = scanner
.snapshot()
.build_update(&prev_snapshot, 0, include_ignored);
.build_update(&prev_snapshot, 0, 0, include_ignored);
prev_snapshot.apply_update(update).unwrap();
assert_eq!(
prev_snapshot.to_vec(true),