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

Store a reference to the LangageRegistry on the Worktree

Browse source
This commit is contained in:
Nathan Sobo 2021-06-29 20:07:37 -06:00
parent 34963ac80d
commit bbf803d7dc
10 changed files with 84 additions and 106 deletions
Download patch file Download diff file Expand all files Collapse all files

2
zed/src/editor.rs
View file

@ -4003,7 +4003,7 @@ mod tests {
#[gpui::test] #[gpui::test]
async fn test_select_larger_smaller_syntax_node(mut cx: gpui::TestAppContext) { async fn test_select_larger_smaller_syntax_node(mut cx: gpui::TestAppContext) {
let app_state = cx.read(build_app_state); let app_state = cx.read(build_app_state);
let lang = app_state.language_registry.select_language("z.rs"); let lang = app_state.languages.select_language("z.rs");
let text = r#" let text = r#"
use mod1::mod2::{mod3, mod4}; use mod1::mod2::{mod3, mod4};

25
zed/src/editor/buffer.rs
View file

@ -2671,7 +2671,6 @@ impl ToPoint for usize {
mod tests { mod tests {
use super::*; use super::*;
use crate::{ use crate::{
language::LanguageRegistry,
test::{build_app_state, temp_tree}, test::{build_app_state, temp_tree},
util::RandomCharIter, util::RandomCharIter,
worktree::{Worktree, WorktreeHandle}, worktree::{Worktree, WorktreeHandle},
@ -3144,22 +3143,18 @@ mod tests {
#[gpui::test] #[gpui::test]
async fn test_is_dirty(mut cx: gpui::TestAppContext) { async fn test_is_dirty(mut cx: gpui::TestAppContext) {
let language_registry = Arc::new(LanguageRegistry::new());
let dir = temp_tree(json!({ let dir = temp_tree(json!({
"file1": "abc", "file1": "abc",
"file2": "def", "file2": "def",
"file3": "ghi", "file3": "ghi",
})); }));
let tree = cx.add_model(|cx| Worktree::local(dir.path(), cx)); let tree = cx.add_model(|cx| Worktree::local(dir.path(), Default::default(), cx));
tree.flush_fs_events(&cx).await; tree.flush_fs_events(&cx).await;
cx.read(|cx| tree.read(cx).as_local().unwrap().scan_complete()) cx.read(|cx| tree.read(cx).as_local().unwrap().scan_complete())
.await; .await;
let buffer1 = tree let buffer1 = tree
.update(&mut cx, |tree, cx| { .update(&mut cx, |tree, cx| tree.open_buffer("file1", cx))
tree.open_buffer("file1", language_registry.clone(), cx)
})
.await .await
.unwrap(); .unwrap();
let events = Rc::new(RefCell::new(Vec::new())); let events = Rc::new(RefCell::new(Vec::new()));
@ -3218,9 +3213,7 @@ mod tests {
// When a file is deleted, the buffer is considered dirty. // When a file is deleted, the buffer is considered dirty.
let events = Rc::new(RefCell::new(Vec::new())); let events = Rc::new(RefCell::new(Vec::new()));
let buffer2 = tree let buffer2 = tree
.update(&mut cx, |tree, cx| { .update(&mut cx, |tree, cx| tree.open_buffer("file2", cx))
tree.open_buffer("file2", language_registry.clone(), cx)
})
.await .await
.unwrap(); .unwrap();
buffer2.update(&mut cx, |_, cx| { buffer2.update(&mut cx, |_, cx| {
@ -3240,9 +3233,7 @@ mod tests {
// When a file is already dirty when deleted, we don't emit a Dirtied event. // When a file is already dirty when deleted, we don't emit a Dirtied event.
let events = Rc::new(RefCell::new(Vec::new())); let events = Rc::new(RefCell::new(Vec::new()));
let buffer3 = tree let buffer3 = tree
.update(&mut cx, |tree, cx| { .update(&mut cx, |tree, cx| tree.open_buffer("file3", cx))
tree.open_buffer("file3", language_registry.clone(), cx)
})
.await .await
.unwrap(); .unwrap();
buffer3.update(&mut cx, |_, cx| { buffer3.update(&mut cx, |_, cx| {
@ -3269,14 +3260,14 @@ mod tests {
async fn test_file_changes_on_disk(mut cx: gpui::TestAppContext) { async fn test_file_changes_on_disk(mut cx: gpui::TestAppContext) {
let initial_contents = "aaa\nbbbbb\nc\n"; let initial_contents = "aaa\nbbbbb\nc\n";
let dir = temp_tree(json!({ "the-file": initial_contents })); let dir = temp_tree(json!({ "the-file": initial_contents }));
let tree = cx.add_model(|cx| Worktree::local(dir.path(), cx)); let tree = cx.add_model(|cx| Worktree::local(dir.path(), Default::default(), cx));
cx.read(|cx| tree.read(cx).as_local().unwrap().scan_complete()) cx.read(|cx| tree.read(cx).as_local().unwrap().scan_complete())
.await; .await;
let abs_path = dir.path().join("the-file"); let abs_path = dir.path().join("the-file");
let buffer = tree let buffer = tree
.update(&mut cx, |tree, cx| { .update(&mut cx, |tree, cx| {
tree.open_buffer(Path::new("the-file"), Arc::new(LanguageRegistry::new()), cx) tree.open_buffer(Path::new("the-file"), cx)
}) })
.await .await
.unwrap(); .unwrap();
@ -3620,7 +3611,7 @@ mod tests {
#[gpui::test] #[gpui::test]
async fn test_reparse(mut cx: gpui::TestAppContext) { async fn test_reparse(mut cx: gpui::TestAppContext) {
let app_state = cx.read(build_app_state); let app_state = cx.read(build_app_state);
let rust_lang = app_state.language_registry.select_language("test.rs"); let rust_lang = app_state.languages.select_language("test.rs");
assert!(rust_lang.is_some()); assert!(rust_lang.is_some());
let buffer = cx.add_model(|cx| { let buffer = cx.add_model(|cx| {
@ -3761,7 +3752,7 @@ mod tests {
use unindent::Unindent as _; use unindent::Unindent as _;
let app_state = cx.read(build_app_state); let app_state = cx.read(build_app_state);
let rust_lang = app_state.language_registry.select_language("test.rs"); let rust_lang = app_state.languages.select_language("test.rs");
assert!(rust_lang.is_some()); assert!(rust_lang.is_some());
let buffer = cx.add_model(|cx| { let buffer = cx.add_model(|cx| {

14
zed/src/file_finder.rs
View file

@ -479,12 +479,8 @@ mod tests {
let app_state = cx.read(build_app_state); let app_state = cx.read(build_app_state);
let (window_id, workspace) = cx.add_window(|cx| { let (window_id, workspace) = cx.add_window(|cx| {
let mut workspace = Workspace::new( let mut workspace =
app_state.settings, Workspace::new(app_state.settings, app_state.languages, app_state.rpc, cx);
app_state.language_registry,
app_state.rpc,
cx,
);
workspace.add_worktree(tmp_dir.path(), cx); workspace.add_worktree(tmp_dir.path(), cx);
workspace workspace
}); });
@ -553,7 +549,7 @@ mod tests {
let (_, workspace) = cx.add_window(|cx| { let (_, workspace) = cx.add_window(|cx| {
let mut workspace = Workspace::new( let mut workspace = Workspace::new(
app_state.settings.clone(), app_state.settings.clone(),
app_state.language_registry.clone(), app_state.languages.clone(),
app_state.rpc.clone(), app_state.rpc.clone(),
cx, cx,
); );
@ -616,7 +612,7 @@ mod tests {
let (_, workspace) = cx.add_window(|cx| { let (_, workspace) = cx.add_window(|cx| {
let mut workspace = Workspace::new( let mut workspace = Workspace::new(
app_state.settings.clone(), app_state.settings.clone(),
app_state.language_registry.clone(), app_state.languages.clone(),
app_state.rpc.clone(), app_state.rpc.clone(),
cx, cx,
); );
@ -667,7 +663,7 @@ mod tests {
let (_, workspace) = cx.add_window(|cx| { let (_, workspace) = cx.add_window(|cx| {
Workspace::new( Workspace::new(
app_state.settings.clone(), app_state.settings.clone(),
app_state.language_registry.clone(), app_state.languages.clone(),
app_state.rpc.clone(), app_state.rpc.clone(),
cx, cx,
) )

6
zed/src/language.rs
View file

@ -90,6 +90,12 @@ impl LanguageRegistry {
} }
} }
impl Default for LanguageRegistry {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;

2
zed/src/lib.rs
View file

@ -17,7 +17,7 @@ pub mod worktree;
#[derive(Clone)] #[derive(Clone)]
pub struct AppState { pub struct AppState {
pub settings: postage::watch::Receiver<settings::Settings>, pub settings: postage::watch::Receiver<settings::Settings>,
pub language_registry: std::sync::Arc<language::LanguageRegistry>, pub languages: std::sync::Arc<language::LanguageRegistry>,
pub rpc: rpc::Client, pub rpc: rpc::Client,
} }

8
zed/src/main.rs
View file

@ -17,13 +17,13 @@ fn main() {
let app = gpui::App::new(assets::Assets).unwrap(); let app = gpui::App::new(assets::Assets).unwrap();
let (_, settings) = settings::channel(&app.font_cache()).unwrap(); let (_, settings) = settings::channel(&app.font_cache()).unwrap();
let language_registry = Arc::new(language::LanguageRegistry::new()); let languages = Arc::new(language::LanguageRegistry::new());
language_registry.set_theme(&settings.borrow().theme); languages.set_theme(&settings.borrow().theme);
let app_state = AppState { let app_state = AppState {
language_registry: language_registry.clone(), languages: languages.clone(),
settings, settings,
rpc: rpc::Client::new(language_registry), rpc: rpc::Client::new(languages),
}; };
app.run(move |cx| { app.run(move |cx| {

6
zed/src/rpc.rs
View file

@ -31,7 +31,7 @@ pub struct ClientState {
connection_id: Option<ConnectionId>, connection_id: Option<ConnectionId>,
pub remote_worktrees: HashMap<u64, WeakModelHandle<Worktree>>, pub remote_worktrees: HashMap<u64, WeakModelHandle<Worktree>>,
pub shared_buffers: HashMap<PeerId, HashMap<u64, ModelHandle<Buffer>>>, pub shared_buffers: HashMap<PeerId, HashMap<u64, ModelHandle<Buffer>>>,
pub language_registry: Arc<LanguageRegistry>, pub languages: Arc<LanguageRegistry>,
} }
impl ClientState { impl ClientState {
@ -54,14 +54,14 @@ impl ClientState {
} }
impl Client { impl Client {
pub fn new(language_registry: Arc<LanguageRegistry>) -> Self { pub fn new(languages: Arc<LanguageRegistry>) -> Self {
Self { Self {
peer: Peer::new(), peer: Peer::new(),
state: Arc::new(Mutex::new(ClientState { state: Arc::new(Mutex::new(ClientState {
connection_id: None, connection_id: None,
remote_worktrees: Default::default(), remote_worktrees: Default::default(),
shared_buffers: Default::default(), shared_buffers: Default::default(),
language_registry, languages,
})), })),
} }
} }

6
zed/src/test.rs
View file

@ -142,10 +142,10 @@ fn write_tree(path: &Path, tree: serde_json::Value) {
pub fn build_app_state(cx: &AppContext) -> AppState { pub fn build_app_state(cx: &AppContext) -> AppState {
let settings = settings::channel(&cx.font_cache()).unwrap().1; let settings = settings::channel(&cx.font_cache()).unwrap().1;
let language_registry = Arc::new(LanguageRegistry::new()); let languages = Arc::new(LanguageRegistry::new());
AppState { AppState {
settings, settings,
language_registry: language_registry.clone(), languages: languages.clone(),
rpc: rpc::Client::new(language_registry), rpc: rpc::Client::new(languages),
} }
} }

53
zed/src/workspace.rs
View file

@ -91,7 +91,7 @@ fn open_paths(params: &OpenParams, cx: &mut MutableAppContext) {
cx.add_window(|cx| { cx.add_window(|cx| {
let mut view = Workspace::new( let mut view = Workspace::new(
params.app_state.settings.clone(), params.app_state.settings.clone(),
params.app_state.language_registry.clone(), params.app_state.languages.clone(),
params.app_state.rpc.clone(), params.app_state.rpc.clone(),
cx, cx,
); );
@ -105,7 +105,7 @@ fn open_new(app_state: &AppState, cx: &mut MutableAppContext) {
cx.add_window(|cx| { cx.add_window(|cx| {
let mut view = Workspace::new( let mut view = Workspace::new(
app_state.settings.clone(), app_state.settings.clone(),
app_state.language_registry.clone(), app_state.languages.clone(),
app_state.rpc.clone(), app_state.rpc.clone(),
cx, cx,
); );
@ -312,7 +312,7 @@ pub struct State {
pub struct Workspace { pub struct Workspace {
pub settings: watch::Receiver<Settings>, pub settings: watch::Receiver<Settings>,
language_registry: Arc<LanguageRegistry>, languages: Arc<LanguageRegistry>,
rpc: rpc::Client, rpc: rpc::Client,
modal: Option<AnyViewHandle>, modal: Option<AnyViewHandle>,
center: PaneGroup, center: PaneGroup,
@ -329,7 +329,7 @@ pub struct Workspace {
impl Workspace { impl Workspace {
pub fn new( pub fn new(
settings: watch::Receiver<Settings>, settings: watch::Receiver<Settings>,
language_registry: Arc<LanguageRegistry>, languages: Arc<LanguageRegistry>,
rpc: rpc::Client, rpc: rpc::Client,
cx: &mut ViewContext<Self>, cx: &mut ViewContext<Self>,
) -> Self { ) -> Self {
@ -346,7 +346,7 @@ impl Workspace {
panes: vec![pane.clone()], panes: vec![pane.clone()],
active_pane: pane.clone(), active_pane: pane.clone(),
settings, settings,
language_registry, languages: languages,
rpc, rpc,
worktrees: Default::default(), worktrees: Default::default(),
items: Default::default(), items: Default::default(),
@ -462,7 +462,7 @@ impl Workspace {
path: &Path, path: &Path,
cx: &mut ViewContext<Self>, cx: &mut ViewContext<Self>,
) -> ModelHandle<Worktree> { ) -> ModelHandle<Worktree> {
let worktree = cx.add_model(|cx| Worktree::local(path, cx)); let worktree = cx.add_model(|cx| Worktree::local(path, self.languages.clone(), cx));
cx.observe_model(&worktree, |_, _, cx| cx.notify()); cx.observe_model(&worktree, |_, _, cx| cx.notify());
self.worktrees.insert(worktree.clone()); self.worktrees.insert(worktree.clone());
cx.notify(); cx.notify();
@ -558,13 +558,12 @@ impl Workspace {
if let Entry::Vacant(entry) = self.loading_items.entry(entry.clone()) { if let Entry::Vacant(entry) = self.loading_items.entry(entry.clone()) {
let (mut tx, rx) = postage::watch::channel(); let (mut tx, rx) = postage::watch::channel();
entry.insert(rx); entry.insert(rx);
let language_registry = self.language_registry.clone();
cx.as_mut() cx.as_mut()
.spawn(|mut cx| async move { .spawn(|mut cx| async move {
let buffer = worktree let buffer = worktree
.update(&mut cx, |worktree, cx| { .update(&mut cx, |worktree, cx| {
worktree.open_buffer(path.as_ref(), language_registry, cx) worktree.open_buffer(path.as_ref(), cx)
}) })
.await; .await;
*tx.borrow_mut() = Some( *tx.borrow_mut() = Some(
@ -714,6 +713,7 @@ impl Workspace {
fn join_worktree(&mut self, _: &(), cx: &mut ViewContext<Self>) { fn join_worktree(&mut self, _: &(), cx: &mut ViewContext<Self>) {
let rpc = self.rpc.clone(); let rpc = self.rpc.clone();
let languages = self.languages.clone();
let task = cx.spawn(|this, mut cx| async move { let task = cx.spawn(|this, mut cx| async move {
rpc.log_in_and_connect(&cx).await?; rpc.log_in_and_connect(&cx).await?;
@ -727,7 +727,8 @@ impl Workspace {
log::info!("read worktree url from clipboard: {}", worktree_url.text()); log::info!("read worktree url from clipboard: {}", worktree_url.text());
let worktree = let worktree =
Worktree::remote(rpc.clone(), worktree_id, access_token, &mut cx).await?; Worktree::remote(rpc.clone(), worktree_id, access_token, languages, &mut cx)
.await?;
this.update(&mut cx, |workspace, cx| { this.update(&mut cx, |workspace, cx| {
cx.observe_model(&worktree, |_, _, cx| cx.notify()); cx.observe_model(&worktree, |_, _, cx| cx.notify());
workspace.worktrees.insert(worktree); workspace.worktrees.insert(worktree);
@ -961,12 +962,8 @@ mod tests {
let app_state = cx.read(build_app_state); let app_state = cx.read(build_app_state);
let (_, workspace) = cx.add_window(|cx| { let (_, workspace) = cx.add_window(|cx| {
let mut workspace = Workspace::new( let mut workspace =
app_state.settings, Workspace::new(app_state.settings, app_state.languages, app_state.rpc, cx);
app_state.language_registry,
app_state.rpc,
cx,
);
workspace.add_worktree(dir.path(), cx); workspace.add_worktree(dir.path(), cx);
workspace workspace
}); });
@ -1069,12 +1066,8 @@ mod tests {
let app_state = cx.read(build_app_state); let app_state = cx.read(build_app_state);
let (_, workspace) = cx.add_window(|cx| { let (_, workspace) = cx.add_window(|cx| {
let mut workspace = Workspace::new( let mut workspace =
app_state.settings, Workspace::new(app_state.settings, app_state.languages, app_state.rpc, cx);
app_state.language_registry,
app_state.rpc,
cx,
);
workspace.add_worktree(dir1.path(), cx); workspace.add_worktree(dir1.path(), cx);
workspace workspace
}); });
@ -1142,12 +1135,8 @@ mod tests {
let app_state = cx.read(build_app_state); let app_state = cx.read(build_app_state);
let (window_id, workspace) = cx.add_window(|cx| { let (window_id, workspace) = cx.add_window(|cx| {
let mut workspace = Workspace::new( let mut workspace =
app_state.settings, Workspace::new(app_state.settings, app_state.languages, app_state.rpc, cx);
app_state.language_registry,
app_state.rpc,
cx,
);
workspace.add_worktree(dir.path(), cx); workspace.add_worktree(dir.path(), cx);
workspace workspace
}); });
@ -1192,7 +1181,7 @@ mod tests {
let (_, workspace) = cx.add_window(|cx| { let (_, workspace) = cx.add_window(|cx| {
let mut workspace = Workspace::new( let mut workspace = Workspace::new(
app_state.settings.clone(), app_state.settings.clone(),
app_state.language_registry.clone(), app_state.languages.clone(),
app_state.rpc.clone(), app_state.rpc.clone(),
cx, cx,
); );
@ -1315,12 +1304,8 @@ mod tests {
let app_state = cx.read(build_app_state); let app_state = cx.read(build_app_state);
let (window_id, workspace) = cx.add_window(|cx| { let (window_id, workspace) = cx.add_window(|cx| {
let mut workspace = Workspace::new( let mut workspace =
app_state.settings, Workspace::new(app_state.settings, app_state.languages, app_state.rpc, cx);
app_state.language_registry,
app_state.rpc,
cx,
);
workspace.add_worktree(dir.path(), cx); workspace.add_worktree(dir.path(), cx);
workspace workspace
}); });

68
zed/src/worktree.rs
View file

@ -74,14 +74,19 @@ impl Entity for Worktree {
} }
impl Worktree { impl Worktree {
pub fn local(path: impl Into<Arc<Path>>, cx: &mut ModelContext<Worktree>) -> Self { pub fn local(
Worktree::Local(LocalWorktree::new(path, cx)) path: impl Into<Arc<Path>>,
languages: Arc<LanguageRegistry>,
cx: &mut ModelContext<Worktree>,
) -> Self {
Worktree::Local(LocalWorktree::new(path, languages, cx))
} }
pub async fn remote( pub async fn remote(
rpc: rpc::Client, rpc: rpc::Client,
id: u64, id: u64,
access_token: String, access_token: String,
languages: Arc<LanguageRegistry>,
cx: &mut AsyncAppContext, cx: &mut AsyncAppContext,
) -> Result<ModelHandle<Self>> { ) -> Result<ModelHandle<Self>> {
let open_worktree_response = rpc let open_worktree_response = rpc
@ -103,6 +108,7 @@ impl Worktree {
worktree_message, worktree_message,
rpc.clone(), rpc.clone(),
replica_id as ReplicaId, replica_id as ReplicaId,
languages,
cx, cx,
)) ))
}) })
@ -149,14 +155,11 @@ impl Worktree {
pub fn open_buffer( pub fn open_buffer(
&mut self, &mut self,
path: impl AsRef<Path>, path: impl AsRef<Path>,
language_registry: Arc<LanguageRegistry>,
cx: &mut ModelContext<Self>, cx: &mut ModelContext<Self>,
) -> Task<Result<ModelHandle<Buffer>>> { ) -> Task<Result<ModelHandle<Buffer>>> {
match self { match self {
Worktree::Local(worktree) => worktree.open_buffer(path.as_ref(), language_registry, cx), Worktree::Local(worktree) => worktree.open_buffer(path.as_ref(), cx),
Worktree::Remote(worktree) => { Worktree::Remote(worktree) => worktree.open_buffer(path.as_ref(), cx),
worktree.open_buffer(path.as_ref(), language_registry, cx)
}
} }
} }
@ -241,10 +244,15 @@ pub struct LocalWorktree {
poll_scheduled: bool, poll_scheduled: bool,
rpc: Option<(rpc::Client, u64)>, rpc: Option<(rpc::Client, u64)>,
open_buffers: HashMap<usize, WeakModelHandle<Buffer>>, open_buffers: HashMap<usize, WeakModelHandle<Buffer>>,
languages: Arc<LanguageRegistry>,
} }
impl LocalWorktree { impl LocalWorktree {
fn new(path: impl Into<Arc<Path>>, cx: &mut ModelContext<Worktree>) -> Self { fn new(
path: impl Into<Arc<Path>>,
languages: Arc<LanguageRegistry>,
cx: &mut ModelContext<Worktree>,
) -> Self {
let abs_path = path.into(); let abs_path = path.into();
let (scan_state_tx, scan_state_rx) = smol::channel::unbounded(); let (scan_state_tx, scan_state_rx) = smol::channel::unbounded();
let id = cx.model_id(); let id = cx.model_id();
@ -268,11 +276,12 @@ impl LocalWorktree {
let tree = Self { let tree = Self {
snapshot, snapshot,
background_snapshot: background_snapshot.clone(), background_snapshot: background_snapshot.clone(),
open_buffers: Default::default(),
scan_state: watch::channel_with(ScanState::Scanning), scan_state: watch::channel_with(ScanState::Scanning),
_event_stream_handle: event_stream_handle, _event_stream_handle: event_stream_handle,
poll_scheduled: false, poll_scheduled: false,
open_buffers: Default::default(),
rpc: None, rpc: None,
languages,
}; };
std::thread::spawn(move || { std::thread::spawn(move || {
@ -313,7 +322,6 @@ impl LocalWorktree {
pub fn open_buffer( pub fn open_buffer(
&mut self, &mut self,
path: &Path, path: &Path,
language_registry: Arc<LanguageRegistry>,
cx: &mut ModelContext<Worktree>, cx: &mut ModelContext<Worktree>,
) -> Task<Result<ModelHandle<Buffer>>> { ) -> Task<Result<ModelHandle<Buffer>>> {
let handle = cx.handle(); let handle = cx.handle();
@ -333,6 +341,7 @@ impl LocalWorktree {
} }
}); });
let languages = self.languages.clone();
let path = Arc::from(path); let path = Arc::from(path);
cx.spawn(|this, mut cx| async move { cx.spawn(|this, mut cx| async move {
if let Some(existing_buffer) = existing_buffer { if let Some(existing_buffer) = existing_buffer {
@ -341,7 +350,7 @@ impl LocalWorktree {
let (file, contents) = this let (file, contents) = this
.update(&mut cx, |this, cx| this.as_local().unwrap().load(&path, cx)) .update(&mut cx, |this, cx| this.as_local().unwrap().load(&path, cx))
.await?; .await?;
let language = language_registry.select_language(&path).cloned(); let language = languages.select_language(&path).cloned();
let buffer = cx.add_model(|cx| { let buffer = cx.add_model(|cx| {
Buffer::from_history(0, History::new(contents.into()), Some(file), language, cx) Buffer::from_history(0, History::new(contents.into()), Some(file), language, cx)
}); });
@ -638,6 +647,7 @@ pub struct RemoteWorktree {
rpc: rpc::Client, rpc: rpc::Client,
replica_id: ReplicaId, replica_id: ReplicaId,
open_buffers: HashMap<usize, WeakModelHandle<Buffer>>, open_buffers: HashMap<usize, WeakModelHandle<Buffer>>,
languages: Arc<LanguageRegistry>,
} }
impl RemoteWorktree { impl RemoteWorktree {
@ -646,6 +656,7 @@ impl RemoteWorktree {
worktree: proto::Worktree, worktree: proto::Worktree,
rpc: rpc::Client, rpc: rpc::Client,
replica_id: ReplicaId, replica_id: ReplicaId,
languages: Arc<LanguageRegistry>,
cx: &mut ModelContext<Worktree>, cx: &mut ModelContext<Worktree>,
) -> Self { ) -> Self {
let root_char_bag: CharBag = worktree let root_char_bag: CharBag = worktree
@ -700,13 +711,13 @@ impl RemoteWorktree {
rpc, rpc,
replica_id, replica_id,
open_buffers: Default::default(), open_buffers: Default::default(),
languages,
} }
} }
pub fn open_buffer( pub fn open_buffer(
&mut self, &mut self,
path: &Path, path: &Path,
language_registry: Arc<LanguageRegistry>,
cx: &mut ModelContext<Worktree>, cx: &mut ModelContext<Worktree>,
) -> Task<Result<ModelHandle<Buffer>>> { ) -> Task<Result<ModelHandle<Buffer>>> {
let handle = cx.handle(); let handle = cx.handle();
@ -725,6 +736,7 @@ impl RemoteWorktree {
}); });
let rpc = self.rpc.clone(); let rpc = self.rpc.clone();
let languages = self.languages.clone();
let replica_id = self.replica_id; let replica_id = self.replica_id;
let remote_worktree_id = self.remote_id; let remote_worktree_id = self.remote_id;
let path = path.to_string_lossy().to_string(); let path = path.to_string_lossy().to_string();
@ -736,7 +748,7 @@ impl RemoteWorktree {
.read_with(&cx, |tree, _| tree.entry_for_path(&path).cloned()) .read_with(&cx, |tree, _| tree.entry_for_path(&path).cloned())
.ok_or_else(|| anyhow!("file does not exist"))?; .ok_or_else(|| anyhow!("file does not exist"))?;
let file = File::new(entry.id, handle, entry.path, entry.mtime); let file = File::new(entry.id, handle, entry.path, entry.mtime);
let language = language_registry.select_language(&path).cloned(); let language = languages.select_language(&path).cloned();
let response = rpc let response = rpc
.request(proto::OpenBuffer { .request(proto::OpenBuffer {
worktree_id: remote_worktree_id as u64, worktree_id: remote_worktree_id as u64,
@ -1880,11 +1892,7 @@ mod remote {
let buffer = worktree let buffer = worktree
.update(cx, |worktree, cx| { .update(cx, |worktree, cx| {
worktree.open_buffer( worktree.open_buffer(Path::new(&message.path), cx)
Path::new(&message.path),
state.language_registry.clone(),
cx,
)
}) })
.await?; .await?;
state state
@ -2026,7 +2034,7 @@ mod tests {
) )
.unwrap(); .unwrap();
let tree = cx.add_model(|cx| Worktree::local(root_link_path, cx)); let tree = cx.add_model(|cx| Worktree::local(root_link_path, Default::default(), cx));
cx.read(|cx| tree.read(cx).as_local().unwrap().scan_complete()) cx.read(|cx| tree.read(cx).as_local().unwrap().scan_complete())
.await; .await;
@ -2068,11 +2076,9 @@ mod tests {
let dir = temp_tree(json!({ let dir = temp_tree(json!({
"file1": "the old contents", "file1": "the old contents",
})); }));
let tree = cx.add_model(|cx| Worktree::local(dir.path(), cx)); let tree = cx.add_model(|cx| Worktree::local(dir.path(), app_state.languages, cx));
let buffer = tree let buffer = tree
.update(&mut cx, |tree, cx| { .update(&mut cx, |tree, cx| tree.open_buffer("file1", cx))
tree.open_buffer("file1", app_state.language_registry, cx)
})
.await .await
.unwrap(); .unwrap();
let save = buffer.update(&mut cx, |buffer, cx| { let save = buffer.update(&mut cx, |buffer, cx| {
@ -2093,15 +2099,13 @@ mod tests {
})); }));
let file_path = dir.path().join("file1"); let file_path = dir.path().join("file1");
let tree = cx.add_model(|cx| Worktree::local(file_path.clone(), cx)); let tree = cx.add_model(|cx| Worktree::local(file_path.clone(), app_state.languages, cx));
cx.read(|cx| tree.read(cx).as_local().unwrap().scan_complete()) cx.read(|cx| tree.read(cx).as_local().unwrap().scan_complete())
.await; .await;
cx.read(|cx| assert_eq!(tree.read(cx).file_count(), 1)); cx.read(|cx| assert_eq!(tree.read(cx).file_count(), 1));
let buffer = tree let buffer = tree
.update(&mut cx, |tree, cx| { .update(&mut cx, |tree, cx| tree.open_buffer("", cx))
tree.open_buffer("", app_state.language_registry, cx)
})
.await .await
.unwrap(); .unwrap();
let save = buffer.update(&mut cx, |buffer, cx| { let save = buffer.update(&mut cx, |buffer, cx| {
@ -2130,14 +2134,10 @@ mod tests {
} }
})); }));
let language_registry = Arc::new(LanguageRegistry::new()); let tree = cx.add_model(|cx| Worktree::local(dir.path(), Default::default(), cx));
let tree = cx.add_model(|cx| Worktree::local(dir.path(), cx));
let buffer_for_path = |path: &'static str, cx: &mut gpui::TestAppContext| { let buffer_for_path = |path: &'static str, cx: &mut gpui::TestAppContext| {
let buffer = tree.update(cx, |tree, cx| { let buffer = tree.update(cx, |tree, cx| tree.open_buffer(path, cx));
tree.open_buffer(path, language_registry.clone(), cx)
});
async move { buffer.await.unwrap() } async move { buffer.await.unwrap() }
}; };
let id_for_path = |path: &'static str, cx: &gpui::TestAppContext| { let id_for_path = |path: &'static str, cx: &gpui::TestAppContext| {
@ -2233,7 +2233,7 @@ mod tests {
} }
})); }));
let tree = cx.add_model(|cx| Worktree::local(dir.path(), cx)); let tree = cx.add_model(|cx| Worktree::local(dir.path(), Default::default(), cx));
cx.read(|cx| tree.read(cx).as_local().unwrap().scan_complete()) cx.read(|cx| tree.read(cx).as_local().unwrap().scan_complete())
.await; .await;
tree.flush_fs_events(&cx).await; tree.flush_fs_events(&cx).await;