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

Get more integration tests passing

Browse source
This commit is contained in:
Antonio Scandurra 2021-12-21 09:50:11 +01:00
parent 1e8ef8a4c1
commit 40da3b233f
7 changed files with 58 additions and 71 deletions
Download patch file Download diff file Expand all files Collapse all files

67
crates/project/src/project.rs
View file

@ -25,7 +25,6 @@ pub use worktree::*;
pub struct Project { pub struct Project {
worktrees: Vec<ModelHandle<Worktree>>, worktrees: Vec<ModelHandle<Worktree>>,
active_worktree: Option<usize>,
active_entry: Option<ProjectEntry>, active_entry: Option<ProjectEntry>,
languages: Arc<LanguageRegistry>, languages: Arc<LanguageRegistry>,
client: Arc<client::Client>, client: Arc<client::Client>,
@ -170,7 +169,6 @@ impl Project {
_maintain_remote_id_task, _maintain_remote_id_task,
}, },
subscriptions: Vec::new(), subscriptions: Vec::new(),
active_worktree: None,
active_entry: None, active_entry: None,
languages, languages,
client, client,
@ -230,7 +228,6 @@ impl Project {
Ok(cx.add_model(|cx| Self { Ok(cx.add_model(|cx| Self {
worktrees, worktrees,
active_worktree: None,
active_entry: None, active_entry: None,
collaborators, collaborators,
languages, languages,
@ -270,6 +267,7 @@ impl Project {
client.subscribe_to_entity(remote_id, cx, Self::handle_remove_collaborator), client.subscribe_to_entity(remote_id, cx, Self::handle_remove_collaborator),
client.subscribe_to_entity(remote_id, cx, Self::handle_update_worktree), client.subscribe_to_entity(remote_id, cx, Self::handle_update_worktree),
client.subscribe_to_entity(remote_id, cx, Self::handle_update_buffer), client.subscribe_to_entity(remote_id, cx, Self::handle_update_buffer),
client.subscribe_to_entity(remote_id, cx, Self::handle_save_buffer),
client.subscribe_to_entity(remote_id, cx, Self::handle_buffer_saved), client.subscribe_to_entity(remote_id, cx, Self::handle_buffer_saved),
]); ]);
} }
@ -320,10 +318,10 @@ impl Project {
&self.worktrees &self.worktrees
} }
pub fn worktree_for_id(&self, id: usize) -> Option<ModelHandle<Worktree>> { pub fn worktree_for_id(&self, id: usize, cx: &AppContext) -> Option<ModelHandle<Worktree>> {
self.worktrees self.worktrees
.iter() .iter()
.find(|worktree| worktree.id() == id) .find(|worktree| worktree.read(cx).id() == id)
.cloned() .cloned()
} }
@ -346,18 +344,19 @@ impl Project {
} }
})?; })?;
rpc.send(proto::ShareProject { project_id }).await?; rpc.request(proto::ShareProject { project_id }).await?;
let mut tasks = Vec::new();
this.update(&mut cx, |this, cx| { this.update(&mut cx, |this, cx| {
for worktree in &this.worktrees { for worktree in &this.worktrees {
worktree.update(cx, |worktree, cx| { worktree.update(cx, |worktree, cx| {
worktree let worktree = worktree.as_local_mut().unwrap();
.as_local_mut() tasks.push(worktree.share(project_id, cx));
.unwrap()
.share(project_id, cx)
.detach();
}); });
} }
}); });
for task in tasks {
task.await?;
}
Ok(()) Ok(())
}) })
} }
@ -402,7 +401,7 @@ impl Project {
path: ProjectPath, path: ProjectPath,
cx: &mut ModelContext<Self>, cx: &mut ModelContext<Self>,
) -> Task<Result<ModelHandle<Buffer>>> { ) -> Task<Result<ModelHandle<Buffer>>> {
if let Some(worktree) = self.worktree_for_id(path.worktree_id) { if let Some(worktree) = self.worktree_for_id(path.worktree_id, cx) {
worktree.update(cx, |worktree, cx| worktree.open_buffer(path.path, cx)) worktree.update(cx, |worktree, cx| worktree.open_buffer(path.path, cx))
} else { } else {
cx.spawn(|_, _| async move { Err(anyhow!("no such worktree")) }) cx.spawn(|_, _| async move { Err(anyhow!("no such worktree")) })
@ -463,28 +462,13 @@ impl Project {
fn add_worktree(&mut self, worktree: ModelHandle<Worktree>, cx: &mut ModelContext<Self>) { fn add_worktree(&mut self, worktree: ModelHandle<Worktree>, cx: &mut ModelContext<Self>) {
cx.observe(&worktree, |_, _, cx| cx.notify()).detach(); cx.observe(&worktree, |_, _, cx| cx.notify()).detach();
if self.active_worktree.is_none() {
self.set_active_worktree(Some(worktree.id()), cx);
}
self.worktrees.push(worktree); self.worktrees.push(worktree);
cx.notify(); cx.notify();
} }
fn set_active_worktree(&mut self, worktree_id: Option<usize>, cx: &mut ModelContext<Self>) {
if self.active_worktree != worktree_id {
self.active_worktree = worktree_id;
cx.notify();
}
}
pub fn active_worktree(&self) -> Option<ModelHandle<Worktree>> {
self.active_worktree
.and_then(|worktree_id| self.worktree_for_id(worktree_id))
}
pub fn set_active_path(&mut self, entry: Option<ProjectPath>, cx: &mut ModelContext<Self>) { pub fn set_active_path(&mut self, entry: Option<ProjectPath>, cx: &mut ModelContext<Self>) {
let new_active_entry = entry.and_then(|project_path| { let new_active_entry = entry.and_then(|project_path| {
let worktree = self.worktree_for_id(project_path.worktree_id)?; let worktree = self.worktree_for_id(project_path.worktree_id, cx)?;
let entry = worktree.read(cx).entry_for_path(project_path.path)?; let entry = worktree.read(cx).entry_for_path(project_path.path)?;
Some(ProjectEntry { Some(ProjectEntry {
worktree_id: project_path.worktree_id, worktree_id: project_path.worktree_id,
@ -492,9 +476,6 @@ impl Project {
}) })
}); });
if new_active_entry != self.active_entry { if new_active_entry != self.active_entry {
if let Some(worktree_id) = new_active_entry.map(|e| e.worktree_id) {
self.set_active_worktree(Some(worktree_id), cx);
}
self.active_entry = new_active_entry; self.active_entry = new_active_entry;
cx.emit(Event::ActiveEntryChanged(new_active_entry)); cx.emit(Event::ActiveEntryChanged(new_active_entry));
} }
@ -637,7 +618,7 @@ impl Project {
_: Arc<Client>, _: Arc<Client>,
cx: &mut ModelContext<Self>, cx: &mut ModelContext<Self>,
) -> Result<()> { ) -> Result<()> {
if let Some(worktree) = self.worktree_for_id(envelope.payload.worktree_id as usize) { if let Some(worktree) = self.worktree_for_id(envelope.payload.worktree_id as usize, cx) {
worktree.update(cx, |worktree, cx| { worktree.update(cx, |worktree, cx| {
let worktree = worktree.as_remote_mut().unwrap(); let worktree = worktree.as_remote_mut().unwrap();
worktree.update_from_remote(envelope, cx) worktree.update_from_remote(envelope, cx)
@ -652,7 +633,7 @@ impl Project {
_: Arc<Client>, _: Arc<Client>,
cx: &mut ModelContext<Self>, cx: &mut ModelContext<Self>,
) -> Result<()> { ) -> Result<()> {
if let Some(worktree) = self.worktree_for_id(envelope.payload.worktree_id as usize) { if let Some(worktree) = self.worktree_for_id(envelope.payload.worktree_id as usize, cx) {
worktree.update(cx, |worktree, cx| { worktree.update(cx, |worktree, cx| {
worktree.handle_update_buffer(envelope, cx) worktree.handle_update_buffer(envelope, cx)
})?; })?;
@ -660,13 +641,27 @@ impl Project {
Ok(()) Ok(())
} }
pub fn handle_save_buffer(
&mut self,
envelope: TypedEnvelope<proto::SaveBuffer>,
rpc: Arc<Client>,
cx: &mut ModelContext<Self>,
) -> Result<()> {
if let Some(worktree) = self.worktree_for_id(envelope.payload.worktree_id as usize, cx) {
worktree.update(cx, |worktree, cx| {
worktree.handle_save_buffer(envelope, rpc, cx)
})?;
}
Ok(())
}
pub fn handle_open_buffer( pub fn handle_open_buffer(
&mut self, &mut self,
envelope: TypedEnvelope<proto::OpenBuffer>, envelope: TypedEnvelope<proto::OpenBuffer>,
rpc: Arc<Client>, rpc: Arc<Client>,
cx: &mut ModelContext<Self>, cx: &mut ModelContext<Self>,
) -> anyhow::Result<()> { ) -> anyhow::Result<()> {
if let Some(worktree) = self.worktree_for_id(envelope.payload.worktree_id as usize) { if let Some(worktree) = self.worktree_for_id(envelope.payload.worktree_id as usize, cx) {
return worktree.update(cx, |worktree, cx| { return worktree.update(cx, |worktree, cx| {
worktree.handle_open_buffer(envelope, rpc, cx) worktree.handle_open_buffer(envelope, rpc, cx)
}); });
@ -681,7 +676,7 @@ impl Project {
rpc: Arc<Client>, rpc: Arc<Client>,
cx: &mut ModelContext<Self>, cx: &mut ModelContext<Self>,
) -> anyhow::Result<()> { ) -> anyhow::Result<()> {
if let Some(worktree) = self.worktree_for_id(envelope.payload.worktree_id as usize) { if let Some(worktree) = self.worktree_for_id(envelope.payload.worktree_id as usize, cx) {
worktree.update(cx, |worktree, cx| { worktree.update(cx, |worktree, cx| {
worktree.handle_close_buffer(envelope, rpc, cx) worktree.handle_close_buffer(envelope, rpc, cx)
})?; })?;
@ -695,7 +690,7 @@ impl Project {
_: Arc<Client>, _: Arc<Client>,
cx: &mut ModelContext<Self>, cx: &mut ModelContext<Self>,
) -> Result<()> { ) -> Result<()> {
if let Some(worktree) = self.worktree_for_id(envelope.payload.worktree_id as usize) { if let Some(worktree) = self.worktree_for_id(envelope.payload.worktree_id as usize, cx) {
worktree.update(cx, |worktree, cx| { worktree.update(cx, |worktree, cx| {
worktree.handle_buffer_saved(envelope, cx) worktree.handle_buffer_saved(envelope, cx)
})?; })?;

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

@ -166,7 +166,7 @@ impl Worktree {
let worktree = cx.update(|cx| { let worktree = cx.update(|cx| {
cx.add_model(|cx: &mut ModelContext<Worktree>| { cx.add_model(|cx: &mut ModelContext<Worktree>| {
let snapshot = Snapshot { let snapshot = Snapshot {
id: cx.model_id(), id: remote_id as usize,
scan_id: 0, scan_id: 0,
abs_path: Path::new("").into(), abs_path: Path::new("").into(),
root_name, root_name,
@ -1034,12 +1034,12 @@ impl LocalWorktree {
path: &Path, path: &Path,
cx: &mut ModelContext<Worktree>, cx: &mut ModelContext<Worktree>,
) -> Option<ModelHandle<Buffer>> { ) -> Option<ModelHandle<Buffer>> {
let handle = cx.handle(); let worktree_id = self.id();
let mut result = None; let mut result = None;
self.open_buffers.retain(|_buffer_id, buffer| { self.open_buffers.retain(|_buffer_id, buffer| {
if let Some(buffer) = buffer.upgrade(cx.as_ref()) { if let Some(buffer) = buffer.upgrade(cx.as_ref()) {
if let Some(file) = buffer.read(cx.as_ref()).file() { if let Some(file) = buffer.read(cx.as_ref()).file() {
if file.worktree_id() == handle.id() && file.path().as_ref() == path { if file.worktree_id() == worktree_id && file.path().as_ref() == path {
result = Some(buffer); result = Some(buffer);
} }
} }
@ -1919,7 +1919,7 @@ impl language::File for File {
version: clock::Global, version: clock::Global,
cx: &mut MutableAppContext, cx: &mut MutableAppContext,
) -> Task<Result<(clock::Global, SystemTime)>> { ) -> Task<Result<(clock::Global, SystemTime)>> {
let worktree_id = self.worktree.id() as u64; let worktree_id = self.worktree.read(cx).id() as u64;
self.worktree.update(cx, |worktree, cx| match worktree { self.worktree.update(cx, |worktree, cx| match worktree {
Worktree::Local(worktree) => { Worktree::Local(worktree) => {
let rpc = worktree.client.clone(); let rpc = worktree.client.clone();

6
crates/project_panel/src/project_panel.rs
View file

@ -118,7 +118,7 @@ impl ProjectPanel {
worktree_id, worktree_id,
entry_id, entry_id,
} => { } => {
if let Some(worktree) = project.read(cx).worktree_for_id(*worktree_id) { if let Some(worktree) = project.read(cx).worktree_for_id(*worktree_id, cx) {
if let Some(entry) = worktree.read(cx).entry_for_id(*entry_id) { if let Some(entry) = worktree.read(cx).entry_for_id(*entry_id) {
workspace workspace
.open_entry( .open_entry(
@ -307,7 +307,7 @@ impl ProjectPanel {
fn selected_entry<'a>(&self, cx: &'a AppContext) -> Option<(&'a Worktree, &'a project::Entry)> { fn selected_entry<'a>(&self, cx: &'a AppContext) -> Option<(&'a Worktree, &'a project::Entry)> {
let selection = self.selection?; let selection = self.selection?;
let project = self.project.read(cx); let project = self.project.read(cx);
let worktree = project.worktree_for_id(selection.worktree_id)?.read(cx); let worktree = project.worktree_for_id(selection.worktree_id, cx)?.read(cx);
Some((worktree, worktree.entry_for_id(selection.entry_id)?)) Some((worktree, worktree.entry_for_id(selection.entry_id)?))
} }
@ -374,7 +374,7 @@ impl ProjectPanel {
fn expand_entry(&mut self, worktree_id: usize, entry_id: usize, cx: &mut ViewContext<Self>) { fn expand_entry(&mut self, worktree_id: usize, entry_id: usize, cx: &mut ViewContext<Self>) {
let project = self.project.read(cx); let project = self.project.read(cx);
if let Some((worktree, expanded_dir_ids)) = project if let Some((worktree, expanded_dir_ids)) = project
.worktree_for_id(worktree_id) .worktree_for_id(worktree_id, cx)
.zip(self.expanded_dir_ids.get_mut(&worktree_id)) .zip(self.expanded_dir_ids.get_mut(&worktree_id))
{ {
let worktree = worktree.read(cx); let worktree = worktree.read(cx);

1
crates/rpc/src/proto.rs
View file

@ -170,6 +170,7 @@ request_messages!(
(RegisterWorktree, Ack), (RegisterWorktree, Ack),
(SaveBuffer, BufferSaved), (SaveBuffer, BufferSaved),
(SendChannelMessage, SendChannelMessageResponse), (SendChannelMessage, SendChannelMessageResponse),
(ShareProject, Ack),
(ShareWorktree, Ack), (ShareWorktree, Ack),
(UpdateBuffer, Ack), (UpdateBuffer, Ack),
); );

1
crates/server/src/rpc.rs
View file

@ -244,6 +244,7 @@ impl Server {
) -> tide::Result<()> { ) -> tide::Result<()> {
self.state_mut() self.state_mut()
.share_project(request.payload.project_id, request.sender_id); .share_project(request.payload.project_id, request.sender_id);
self.peer.respond(request.receipt(), proto::Ack {}).await?;
Ok(()) Ok(())
} }

1
crates/workspace/Cargo.toml
View file

@ -11,6 +11,7 @@ test-support = ["client/test-support", "project/test-support"]
[dependencies] [dependencies]
client = { path = "../client" } client = { path = "../client" }
clock = { path = "../clock" }
gpui = { path = "../gpui" } gpui = { path = "../gpui" }
language = { path = "../language" } language = { path = "../language" }
project = { path = "../project" } project = { path = "../project" }

27
crates/workspace/src/workspace.rs
View file

@ -6,6 +6,7 @@ mod status_bar;
use anyhow::{anyhow, Result}; use anyhow::{anyhow, Result};
use client::{Authenticate, ChannelList, Client, User, UserStore}; use client::{Authenticate, ChannelList, Client, User, UserStore};
use clock::ReplicaId;
use gpui::{ use gpui::{
action, action,
color::Color, color::Color,
@ -641,7 +642,7 @@ impl Workspace {
let worktree = match self let worktree = match self
.project .project
.read(cx) .read(cx)
.worktree_for_id(project_path.worktree_id) .worktree_for_id(project_path.worktree_id, cx)
{ {
Some(worktree) => worktree, Some(worktree) => worktree,
None => { None => {
@ -1007,17 +1008,12 @@ impl Workspace {
Align::new( Align::new(
Flex::row() Flex::row()
.with_children(self.render_collaborators(theme, cx)) .with_children(self.render_collaborators(theme, cx))
.with_child( .with_child(self.render_avatar(
self.render_avatar(
self.user_store.read(cx).current_user().as_ref(), self.user_store.read(cx).current_user().as_ref(),
self.project self.project.read(cx).replica_id(),
.read(cx)
.active_worktree()
.map(|worktree| worktree.read(cx).replica_id()),
theme, theme,
cx, cx,
), ))
)
.with_children(self.render_connection_status()) .with_children(self.render_connection_status())
.boxed(), .boxed(),
) )
@ -1045,12 +1041,7 @@ impl Workspace {
collaborators collaborators
.into_iter() .into_iter()
.map(|collaborator| { .map(|collaborator| {
self.render_avatar( self.render_avatar(Some(&collaborator.user), collaborator.replica_id, theme, cx)
Some(&collaborator.user),
Some(collaborator.replica_id),
theme,
cx,
)
}) })
.collect() .collect()
} }
@ -1058,7 +1049,7 @@ impl Workspace {
fn render_avatar( fn render_avatar(
&self, &self,
user: Option<&Arc<User>>, user: Option<&Arc<User>>,
replica_id: Option<u16>, replica_id: ReplicaId,
theme: &Theme, theme: &Theme,
cx: &mut RenderContext<Self>, cx: &mut RenderContext<Self>,
) -> ElementBox { ) -> ElementBox {
@ -1076,9 +1067,7 @@ impl Workspace {
.boxed(), .boxed(),
) )
.with_child( .with_child(
AvatarRibbon::new(replica_id.map_or(Default::default(), |id| { AvatarRibbon::new(theme.editor.replica_selection_style(replica_id).cursor)
theme.editor.replica_selection_style(id).cursor
}))
.constrained() .constrained()
.with_width(theme.workspace.titlebar.avatar_ribbon.width) .with_width(theme.workspace.titlebar.avatar_ribbon.width)
.with_height(theme.workspace.titlebar.avatar_ribbon.height) .with_height(theme.workspace.titlebar.avatar_ribbon.height)