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

Merge pull request #34 from zed-industries/buffer-per-inode

Browse source 
Only open one buffer per inode, but associate each buffer view with its own path
This commit is contained in:
Max Brunsfeld 2021-05-04 14:37:27 -07:00 • committed by GitHub
commit 3d739b6621
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
10 changed files with 696 additions and 773 deletions
Download patch file Download diff file Expand all files Collapse all files

129
gpui/src/app.rs
View file

@ -379,7 +379,8 @@ pub struct MutableAppContext {
next_window_id: usize, next_window_id: usize,
next_task_id: usize, next_task_id: usize,
subscriptions: HashMap<usize, Vec<Subscription>>, subscriptions: HashMap<usize, Vec<Subscription>>,
observations: HashMap<usize, Vec<Observation>>, model_observations: HashMap<usize, Vec<ModelObservation>>,
view_observations: HashMap<usize, Vec<ViewObservation>>,
async_observations: HashMap<usize, postage::broadcast::Sender<()>>, async_observations: HashMap<usize, postage::broadcast::Sender<()>>,
window_invalidations: HashMap<usize, WindowInvalidation>, window_invalidations: HashMap<usize, WindowInvalidation>,
presenters_and_platform_windows: presenters_and_platform_windows:
@ -420,7 +421,8 @@ impl MutableAppContext {
next_window_id: 0, next_window_id: 0,
next_task_id: 0, next_task_id: 0,
subscriptions: HashMap::new(), subscriptions: HashMap::new(),
observations: HashMap::new(), model_observations: HashMap::new(),
view_observations: HashMap::new(),
async_observations: HashMap::new(), async_observations: HashMap::new(),
window_invalidations: HashMap::new(), window_invalidations: HashMap::new(),
presenters_and_platform_windows: HashMap::new(), presenters_and_platform_windows: HashMap::new(),
@ -871,13 +873,13 @@ impl MutableAppContext {
for model_id in dropped_models { for model_id in dropped_models {
self.ctx.models.remove(&model_id); self.ctx.models.remove(&model_id);
self.subscriptions.remove(&model_id); self.subscriptions.remove(&model_id);
self.observations.remove(&model_id); self.model_observations.remove(&model_id);
self.async_observations.remove(&model_id); self.async_observations.remove(&model_id);
} }
for (window_id, view_id) in dropped_views { for (window_id, view_id) in dropped_views {
self.subscriptions.remove(&view_id); self.subscriptions.remove(&view_id);
self.observations.remove(&view_id); self.model_observations.remove(&view_id);
self.async_observations.remove(&view_id); self.async_observations.remove(&view_id);
if let Some(window) = self.ctx.windows.get_mut(&window_id) { if let Some(window) = self.ctx.windows.get_mut(&window_id) {
self.window_invalidations self.window_invalidations
@ -1004,11 +1006,11 @@ impl MutableAppContext {
} }
fn notify_model_observers(&mut self, observed_id: usize) { fn notify_model_observers(&mut self, observed_id: usize) {
if let Some(observations) = self.observations.remove(&observed_id) { if let Some(observations) = self.model_observations.remove(&observed_id) {
if self.ctx.models.contains_key(&observed_id) { if self.ctx.models.contains_key(&observed_id) {
for mut observation in observations { for mut observation in observations {
let alive = match &mut observation { let alive = match &mut observation {
Observation::FromModel { model_id, callback } => { ModelObservation::FromModel { model_id, callback } => {
if let Some(mut model) = self.ctx.models.remove(model_id) { if let Some(mut model) = self.ctx.models.remove(model_id) {
callback(model.as_any_mut(), observed_id, self, *model_id); callback(model.as_any_mut(), observed_id, self, *model_id);
self.ctx.models.insert(*model_id, model); self.ctx.models.insert(*model_id, model);
@ -1017,7 +1019,7 @@ impl MutableAppContext {
false false
} }
} }
Observation::FromView { ModelObservation::FromView {
window_id, window_id,
view_id, view_id,
callback, callback,
@ -1049,7 +1051,7 @@ impl MutableAppContext {
}; };
if alive { if alive {
self.observations self.model_observations
.entry(observed_id) .entry(observed_id)
.or_default() .or_default()
.push(observation); .push(observation);
@ -1072,6 +1074,44 @@ impl MutableAppContext {
.updated .updated
.insert(view_id); .insert(view_id);
if let Some(observations) = self.view_observations.remove(&view_id) {
if self.ctx.models.contains_key(&view_id) {
for mut observation in observations {
let alive = if let Some(mut view) = self
.ctx
.windows
.get_mut(&observation.window_id)
.and_then(|w| w.views.remove(&observation.view_id))
{
(observation.callback)(
view.as_any_mut(),
view_id,
window_id,
self,
observation.window_id,
observation.view_id,
);
self.ctx
.windows
.get_mut(&observation.window_id)
.unwrap()
.views
.insert(observation.view_id, view);
true
} else {
false
};
if alive {
self.view_observations
.entry(view_id)
.or_default()
.push(observation);
}
}
}
}
if let Entry::Occupied(mut entry) = self.async_observations.entry(view_id) { if let Entry::Occupied(mut entry) = self.async_observations.entry(view_id) {
if entry.get_mut().blocking_send(()).is_err() { if entry.get_mut().blocking_send(()).is_err() {
entry.remove_entry(); entry.remove_entry();
@ -1576,10 +1616,10 @@ impl<'a, T: Entity> ModelContext<'a, T> {
F: 'static + FnMut(&mut T, ModelHandle<S>, &mut ModelContext<T>), F: 'static + FnMut(&mut T, ModelHandle<S>, &mut ModelContext<T>),
{ {
self.app self.app
.observations .model_observations
.entry(handle.model_id) .entry(handle.model_id)
.or_default() .or_default()
.push(Observation::FromModel { .push(ModelObservation::FromModel {
model_id: self.model_id, model_id: self.model_id,
callback: Box::new(move |model, observed_id, app, model_id| { callback: Box::new(move |model, observed_id, app, model_id| {
let model = model.downcast_mut().expect("downcast is type safe"); let model = model.downcast_mut().expect("downcast is type safe");
@ -1812,7 +1852,7 @@ impl<'a, T: View> ViewContext<'a, T> {
window_id: self.window_id, window_id: self.window_id,
view_id: self.view_id, view_id: self.view_id,
callback: Box::new(move |view, payload, app, window_id, view_id| { callback: Box::new(move |view, payload, app, window_id, view_id| {
if let Some(emitter_handle) = emitter_handle.upgrade(app.as_ref()) { if let Some(emitter_handle) = emitter_handle.upgrade(&app) {
let model = view.downcast_mut().expect("downcast is type safe"); let model = view.downcast_mut().expect("downcast is type safe");
let payload = payload.downcast_ref().expect("downcast is type safe"); let payload = payload.downcast_ref().expect("downcast is type safe");
let mut ctx = ViewContext::new(app, window_id, view_id); let mut ctx = ViewContext::new(app, window_id, view_id);
@ -1829,16 +1869,16 @@ impl<'a, T: View> ViewContext<'a, T> {
}); });
} }
pub fn observe<S, F>(&mut self, handle: &ModelHandle<S>, mut callback: F) pub fn observe_model<S, F>(&mut self, handle: &ModelHandle<S>, mut callback: F)
where where
S: Entity, S: Entity,
F: 'static + FnMut(&mut T, ModelHandle<S>, &mut ViewContext<T>), F: 'static + FnMut(&mut T, ModelHandle<S>, &mut ViewContext<T>),
{ {
self.app self.app
.observations .model_observations
.entry(handle.id()) .entry(handle.id())
.or_default() .or_default()
.push(Observation::FromView { .push(ModelObservation::FromView {
window_id: self.window_id, window_id: self.window_id,
view_id: self.view_id, view_id: self.view_id,
callback: Box::new(move |view, observed_id, app, window_id, view_id| { callback: Box::new(move |view, observed_id, app, window_id, view_id| {
@ -1850,6 +1890,38 @@ impl<'a, T: View> ViewContext<'a, T> {
}); });
} }
pub fn observe_view<S, F>(&mut self, handle: &ViewHandle<S>, mut callback: F)
where
S: View,
F: 'static + FnMut(&mut T, ViewHandle<S>, &mut ViewContext<T>),
{
self.app
.view_observations
.entry(handle.id())
.or_default()
.push(ViewObservation {
window_id: self.window_id,
view_id: self.view_id,
callback: Box::new(
move |view,
observed_view_id,
observed_window_id,
app,
observing_window_id,
observing_view_id| {
let view = view.downcast_mut().expect("downcast is type safe");
let observed_handle = ViewHandle::new(
observed_view_id,
observed_window_id,
&app.ctx.ref_counts,
);
let mut ctx = ViewContext::new(app, observing_window_id, observing_view_id);
callback(view, observed_handle, &mut ctx);
},
),
});
}
pub fn notify(&mut self) { pub fn notify(&mut self) {
self.app.notify_view(self.window_id, self.view_id); self.app.notify_view(self.window_id, self.view_id);
} }
@ -1918,6 +1990,12 @@ impl<'a, T: View> ViewContext<'a, T> {
} }
} }
impl AsRef<AppContext> for &AppContext {
fn as_ref(&self) -> &AppContext {
self
}
}
impl<M> AsRef<AppContext> for ViewContext<'_, M> { impl<M> AsRef<AppContext> for ViewContext<'_, M> {
fn as_ref(&self) -> &AppContext { fn as_ref(&self) -> &AppContext {
&self.app.ctx &self.app.ctx
@ -2346,8 +2424,9 @@ impl<T: View> WeakViewHandle<T> {
} }
} }
pub fn upgrade(&self, app: &AppContext) -> Option<ViewHandle<T>> { pub fn upgrade(&self, ctx: impl AsRef<AppContext>) -> Option<ViewHandle<T>> {
if app let ctx = ctx.as_ref();
if ctx
.windows .windows
.get(&self.window_id) .get(&self.window_id)
.and_then(|w| w.views.get(&self.view_id)) .and_then(|w| w.views.get(&self.view_id))
@ -2356,7 +2435,7 @@ impl<T: View> WeakViewHandle<T> {
Some(ViewHandle::new( Some(ViewHandle::new(
self.window_id, self.window_id,
self.view_id, self.view_id,
&app.ref_counts, &ctx.ref_counts,
)) ))
} else { } else {
None None
@ -2496,7 +2575,7 @@ enum Subscription {
}, },
} }
enum Observation { enum ModelObservation {
FromModel { FromModel {
model_id: usize, model_id: usize,
callback: Box<dyn FnMut(&mut dyn Any, usize, &mut MutableAppContext, usize)>, callback: Box<dyn FnMut(&mut dyn Any, usize, &mut MutableAppContext, usize)>,
@ -2508,6 +2587,12 @@ enum Observation {
}, },
} }
struct ViewObservation {
window_id: usize,
view_id: usize,
callback: Box<dyn FnMut(&mut dyn Any, usize, usize, &mut MutableAppContext, usize, usize)>,
}
type FutureHandler = Box<dyn FnOnce(Box<dyn Any>, &mut MutableAppContext) -> Box<dyn Any>>; type FutureHandler = Box<dyn FnOnce(Box<dyn Any>, &mut MutableAppContext) -> Box<dyn Any>>;
struct StreamHandler { struct StreamHandler {
@ -2639,7 +2724,7 @@ mod tests {
assert_eq!(app.ctx.models.len(), 1); assert_eq!(app.ctx.models.len(), 1);
assert!(app.subscriptions.is_empty()); assert!(app.subscriptions.is_empty());
assert!(app.observations.is_empty()); assert!(app.model_observations.is_empty());
}); });
} }
@ -2842,7 +2927,7 @@ mod tests {
assert_eq!(app.ctx.windows[&window_id].views.len(), 2); assert_eq!(app.ctx.windows[&window_id].views.len(), 2);
assert!(app.subscriptions.is_empty()); assert!(app.subscriptions.is_empty());
assert!(app.observations.is_empty()); assert!(app.model_observations.is_empty());
}) })
} }
@ -2988,7 +3073,7 @@ mod tests {
let model = app.add_model(|_| Model::default()); let model = app.add_model(|_| Model::default());
view.update(app, |_, c| { view.update(app, |_, c| {
c.observe(&model, |me, observed, c| { c.observe_model(&model, |me, observed, c| {
me.events.push(observed.read(c).count) me.events.push(observed.read(c).count)
}); });
}); });
@ -3032,7 +3117,7 @@ mod tests {
let observed_model = app.add_model(|_| Model); let observed_model = app.add_model(|_| Model);
observing_view.update(app, |_, ctx| { observing_view.update(app, |_, ctx| {
ctx.observe(&observed_model, |_, _, _| {}); ctx.observe_model(&observed_model, |_, _, _| {});
}); });
observing_model.update(app, |_, ctx| { observing_model.update(app, |_, ctx| {
ctx.observe(&observed_model, |_, _, _| {}); ctx.observe(&observed_model, |_, _, _| {});

129
zed/src/editor/buffer/mod.rs
View file

@ -18,16 +18,14 @@ use crate::{
worktree::FileHandle, worktree::FileHandle,
}; };
use anyhow::{anyhow, Result}; use anyhow::{anyhow, Result};
use gpui::{AppContext, Entity, ModelContext}; use gpui::{Entity, ModelContext};
use lazy_static::lazy_static; use lazy_static::lazy_static;
use rand::prelude::*; use rand::prelude::*;
use std::{ use std::{
cmp, cmp,
ffi::OsString,
hash::BuildHasher, hash::BuildHasher,
iter::{self, Iterator}, iter::{self, Iterator},
ops::{AddAssign, Range}, ops::{AddAssign, Range},
path::Path,
str, str,
sync::Arc, sync::Arc,
time::{Duration, Instant}, time::{Duration, Instant},
@ -59,7 +57,6 @@ type HashMap<K, V> = std::collections::HashMap<K, V>;
type HashSet<T> = std::collections::HashSet<T>; type HashSet<T> = std::collections::HashSet<T>;
pub struct Buffer { pub struct Buffer {
file: Option<FileHandle>,
fragments: SumTree<Fragment>, fragments: SumTree<Fragment>,
insertion_splits: HashMap<time::Local, SumTree<InsertionSplit>>, insertion_splits: HashMap<time::Local, SumTree<InsertionSplit>>,
pub version: time::Global, pub version: time::Global,
@ -354,29 +351,15 @@ pub struct UndoOperation {
} }
impl Buffer { impl Buffer {
pub fn new<T: Into<Arc<str>>>( pub fn new<T: Into<Arc<str>>>(replica_id: ReplicaId, base_text: T) -> Self {
replica_id: ReplicaId, Self::build(replica_id, History::new(base_text.into()))
base_text: T,
ctx: &mut ModelContext<Self>,
) -> Self {
Self::build(replica_id, None, History::new(base_text.into()), ctx)
} }
pub fn from_history( pub fn from_history(replica_id: ReplicaId, history: History) -> Self {
replica_id: ReplicaId, Self::build(replica_id, history)
file: FileHandle,
history: History,
ctx: &mut ModelContext<Self>,
) -> Self {
Self::build(replica_id, Some(file), history, ctx)
} }
fn build( fn build(replica_id: ReplicaId, history: History) -> Self {
replica_id: ReplicaId,
file: Option<FileHandle>,
history: History,
ctx: &mut ModelContext<Self>,
) -> Self {
let mut insertion_splits = HashMap::default(); let mut insertion_splits = HashMap::default();
let mut fragments = SumTree::new(); let mut fragments = SumTree::new();
@ -425,12 +408,7 @@ impl Buffer {
}); });
} }
if let Some(file) = file.as_ref() {
file.observe_from_model(ctx, |_, _, ctx| ctx.emit(Event::FileHandleChanged));
}
Self { Self {
file,
fragments, fragments,
insertion_splits, insertion_splits,
version: time::Global::new(), version: time::Global::new(),
@ -448,41 +426,27 @@ impl Buffer {
} }
} }
pub fn file_name(&self, ctx: &AppContext) -> Option<OsString> {
self.file.as_ref().and_then(|file| file.file_name(ctx))
}
pub fn path(&self) -> Option<Arc<Path>> {
self.file.as_ref().map(|file| file.path())
}
pub fn entry_id(&self) -> Option<(usize, Arc<Path>)> {
self.file.as_ref().map(|file| file.entry_id())
}
pub fn snapshot(&self) -> Snapshot { pub fn snapshot(&self) -> Snapshot {
Snapshot { Snapshot {
fragments: self.fragments.clone(), fragments: self.fragments.clone(),
} }
} }
pub fn save(&mut self, ctx: &mut ModelContext<Self>) -> LocalBoxFuture<'static, Result<()>> { pub fn save(
if let Some(file) = &self.file { &mut self,
dbg!(file.path()); file: &FileHandle,
ctx: &mut ModelContext<Self>,
let snapshot = self.snapshot(); ) -> LocalBoxFuture<'static, Result<()>> {
let version = self.version.clone(); let snapshot = self.snapshot();
let save_task = file.save(snapshot, ctx.as_ref()); let version = self.version.clone();
let task = ctx.spawn(save_task, |me, save_result, ctx| { let save_task = file.save(snapshot, ctx.as_ref());
if save_result.is_ok() { let task = ctx.spawn(save_task, |me, save_result, ctx| {
me.did_save(version, ctx); if save_result.is_ok() {
} me.did_save(version, ctx);
save_result }
}); save_result
Box::pin(task) });
} else { Box::pin(task)
Box::pin(async { Ok(()) })
}
} }
fn did_save(&mut self, version: time::Global, ctx: &mut ModelContext<Buffer>) { fn did_save(&mut self, version: time::Global, ctx: &mut ModelContext<Buffer>) {
@ -1763,7 +1727,6 @@ impl Buffer {
impl Clone for Buffer { impl Clone for Buffer {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self { Self {
file: self.file.clone(),
fragments: self.fragments.clone(), fragments: self.fragments.clone(),
insertion_splits: self.insertion_splits.clone(), insertion_splits: self.insertion_splits.clone(),
version: self.version.clone(), version: self.version.clone(),
@ -2333,8 +2296,8 @@ mod tests {
#[test] #[test]
fn test_edit() { fn test_edit() {
App::test((), |ctx| { App::test((), |ctx| {
ctx.add_model(|ctx| { ctx.add_model(|_| {
let mut buffer = Buffer::new(0, "abc", ctx); let mut buffer = Buffer::new(0, "abc");
assert_eq!(buffer.text(), "abc"); assert_eq!(buffer.text(), "abc");
buffer.edit(vec![3..3], "def", None).unwrap(); buffer.edit(vec![3..3], "def", None).unwrap();
assert_eq!(buffer.text(), "abcdef"); assert_eq!(buffer.text(), "abcdef");
@ -2358,8 +2321,8 @@ mod tests {
let buffer_1_events = Rc::new(RefCell::new(Vec::new())); let buffer_1_events = Rc::new(RefCell::new(Vec::new()));
let buffer_2_events = Rc::new(RefCell::new(Vec::new())); let buffer_2_events = Rc::new(RefCell::new(Vec::new()));
let buffer1 = app.add_model(|ctx| Buffer::new(0, "abcdef", ctx)); let buffer1 = app.add_model(|_| Buffer::new(0, "abcdef"));
let buffer2 = app.add_model(|ctx| Buffer::new(1, "abcdef", ctx)); let buffer2 = app.add_model(|_| Buffer::new(1, "abcdef"));
let mut buffer_ops = Vec::new(); let mut buffer_ops = Vec::new();
buffer1.update(app, |buffer, ctx| { buffer1.update(app, |buffer, ctx| {
let buffer_1_events = buffer_1_events.clone(); let buffer_1_events = buffer_1_events.clone();
@ -2445,8 +2408,8 @@ mod tests {
let mut reference_string = RandomCharIter::new(&mut rng) let mut reference_string = RandomCharIter::new(&mut rng)
.take(reference_string_len) .take(reference_string_len)
.collect::<String>(); .collect::<String>();
ctx.add_model(|ctx| { ctx.add_model(|_| {
let mut buffer = Buffer::new(0, reference_string.as_str(), ctx); let mut buffer = Buffer::new(0, reference_string.as_str());
let mut buffer_versions = Vec::new(); let mut buffer_versions = Vec::new();
for _i in 0..10 { for _i in 0..10 {
let (old_ranges, new_text, _) = buffer.randomly_mutate(rng, None); let (old_ranges, new_text, _) = buffer.randomly_mutate(rng, None);
@ -2531,8 +2494,8 @@ mod tests {
#[test] #[test]
fn test_line_len() { fn test_line_len() {
App::test((), |ctx| { App::test((), |ctx| {
ctx.add_model(|ctx| { ctx.add_model(|_| {
let mut buffer = Buffer::new(0, "", ctx); let mut buffer = Buffer::new(0, "");
buffer.edit(vec![0..0], "abcd\nefg\nhij", None).unwrap(); buffer.edit(vec![0..0], "abcd\nefg\nhij", None).unwrap();
buffer.edit(vec![12..12], "kl\nmno", None).unwrap(); buffer.edit(vec![12..12], "kl\nmno", None).unwrap();
buffer.edit(vec![18..18], "\npqrs\n", None).unwrap(); buffer.edit(vec![18..18], "\npqrs\n", None).unwrap();
@ -2553,8 +2516,8 @@ mod tests {
#[test] #[test]
fn test_rightmost_point() { fn test_rightmost_point() {
App::test((), |ctx| { App::test((), |ctx| {
ctx.add_model(|ctx| { ctx.add_model(|_| {
let mut buffer = Buffer::new(0, "", ctx); let mut buffer = Buffer::new(0, "");
assert_eq!(buffer.rightmost_point().row, 0); assert_eq!(buffer.rightmost_point().row, 0);
buffer.edit(vec![0..0], "abcd\nefg\nhij", None).unwrap(); buffer.edit(vec![0..0], "abcd\nefg\nhij", None).unwrap();
assert_eq!(buffer.rightmost_point().row, 0); assert_eq!(buffer.rightmost_point().row, 0);
@ -2574,8 +2537,8 @@ mod tests {
#[test] #[test]
fn test_text_summary_for_range() { fn test_text_summary_for_range() {
App::test((), |ctx| { App::test((), |ctx| {
ctx.add_model(|ctx| { ctx.add_model(|_| {
let buffer = Buffer::new(0, "ab\nefg\nhklm\nnopqrs\ntuvwxyz", ctx); let buffer = Buffer::new(0, "ab\nefg\nhklm\nnopqrs\ntuvwxyz");
let text = Text::from(buffer.text()); let text = Text::from(buffer.text());
assert_eq!( assert_eq!(
buffer.text_summary_for_range(1..3), buffer.text_summary_for_range(1..3),
@ -2605,8 +2568,8 @@ mod tests {
#[test] #[test]
fn test_chars_at() { fn test_chars_at() {
App::test((), |ctx| { App::test((), |ctx| {
ctx.add_model(|ctx| { ctx.add_model(|_| {
let mut buffer = Buffer::new(0, "", ctx); let mut buffer = Buffer::new(0, "");
buffer.edit(vec![0..0], "abcd\nefgh\nij", None).unwrap(); buffer.edit(vec![0..0], "abcd\nefgh\nij", None).unwrap();
buffer.edit(vec![12..12], "kl\nmno", None).unwrap(); buffer.edit(vec![12..12], "kl\nmno", None).unwrap();
buffer.edit(vec![18..18], "\npqrs", None).unwrap(); buffer.edit(vec![18..18], "\npqrs", None).unwrap();
@ -2628,7 +2591,7 @@ mod tests {
assert_eq!(chars.collect::<String>(), "PQrs"); assert_eq!(chars.collect::<String>(), "PQrs");
// Regression test: // Regression test:
let mut buffer = Buffer::new(0, "", ctx); let mut buffer = Buffer::new(0, "");
buffer.edit(vec![0..0], "[workspace]\nmembers = [\n \"xray_core\",\n \"xray_server\",\n \"xray_cli\",\n \"xray_wasm\",\n]\n", None).unwrap(); buffer.edit(vec![0..0], "[workspace]\nmembers = [\n \"xray_core\",\n \"xray_server\",\n \"xray_cli\",\n \"xray_wasm\",\n]\n", None).unwrap();
buffer.edit(vec![60..60], "\n", None).unwrap(); buffer.edit(vec![60..60], "\n", None).unwrap();
@ -2757,8 +2720,8 @@ mod tests {
#[test] #[test]
fn test_anchors() { fn test_anchors() {
App::test((), |ctx| { App::test((), |ctx| {
ctx.add_model(|ctx| { ctx.add_model(|_| {
let mut buffer = Buffer::new(0, "", ctx); let mut buffer = Buffer::new(0, "");
buffer.edit(vec![0..0], "abc", None).unwrap(); buffer.edit(vec![0..0], "abc", None).unwrap();
let left_anchor = buffer.anchor_before(2).unwrap(); let left_anchor = buffer.anchor_before(2).unwrap();
let right_anchor = buffer.anchor_after(2).unwrap(); let right_anchor = buffer.anchor_after(2).unwrap();
@ -2922,8 +2885,8 @@ mod tests {
#[test] #[test]
fn test_anchors_at_start_and_end() { fn test_anchors_at_start_and_end() {
App::test((), |ctx| { App::test((), |ctx| {
ctx.add_model(|ctx| { ctx.add_model(|_| {
let mut buffer = Buffer::new(0, "", ctx); let mut buffer = Buffer::new(0, "");
let before_start_anchor = buffer.anchor_before(0).unwrap(); let before_start_anchor = buffer.anchor_before(0).unwrap();
let after_end_anchor = buffer.anchor_after(0).unwrap(); let after_end_anchor = buffer.anchor_after(0).unwrap();
@ -2950,7 +2913,7 @@ mod tests {
#[test] #[test]
fn test_is_modified() { fn test_is_modified() {
App::test((), |app| { App::test((), |app| {
let model = app.add_model(|ctx| Buffer::new(0, "abc", ctx)); let model = app.add_model(|_| Buffer::new(0, "abc"));
let events = Rc::new(RefCell::new(Vec::new())); let events = Rc::new(RefCell::new(Vec::new()));
// initially, the buffer isn't dirty. // initially, the buffer isn't dirty.
@ -3037,8 +3000,8 @@ mod tests {
#[test] #[test]
fn test_undo_redo() { fn test_undo_redo() {
App::test((), |app| { App::test((), |app| {
app.add_model(|ctx| { app.add_model(|_| {
let mut buffer = Buffer::new(0, "1234", ctx); let mut buffer = Buffer::new(0, "1234");
let edit1 = buffer.edit(vec![1..1], "abx", None).unwrap(); let edit1 = buffer.edit(vec![1..1], "abx", None).unwrap();
let edit2 = buffer.edit(vec![3..4], "yzef", None).unwrap(); let edit2 = buffer.edit(vec![3..4], "yzef", None).unwrap();
@ -3074,9 +3037,9 @@ mod tests {
#[test] #[test]
fn test_history() { fn test_history() {
App::test((), |app| { App::test((), |app| {
app.add_model(|ctx| { app.add_model(|_| {
let mut now = Instant::now(); let mut now = Instant::now();
let mut buffer = Buffer::new(0, "123456", ctx); let mut buffer = Buffer::new(0, "123456");
let (set_id, _) = buffer let (set_id, _) = buffer
.add_selection_set(buffer.selections_from_ranges(vec![4..4]).unwrap(), None); .add_selection_set(buffer.selections_from_ranges(vec![4..4]).unwrap(), None);
@ -3161,7 +3124,7 @@ mod tests {
let mut network = Network::new(); let mut network = Network::new();
for i in 0..PEERS { for i in 0..PEERS {
let buffer = let buffer =
ctx.add_model(|ctx| Buffer::new(i as ReplicaId, base_text.as_str(), ctx)); ctx.add_model(|_| Buffer::new(i as ReplicaId, base_text.as_str()));
buffers.push(buffer); buffers.push(buffer);
replica_ids.push(i as u16); replica_ids.push(i as u16);
network.add_peer(i as u16); network.add_peer(i as u16);

131
zed/src/editor/buffer_view.rs
View file

@ -2,7 +2,7 @@ use super::{
buffer, movement, Anchor, Bias, Buffer, BufferElement, DisplayMap, DisplayPoint, Point, buffer, movement, Anchor, Bias, Buffer, BufferElement, DisplayMap, DisplayPoint, Point,
Selection, SelectionSetId, ToOffset, ToPoint, Selection, SelectionSetId, ToOffset, ToPoint,
}; };
use crate::{settings::Settings, watch, workspace}; use crate::{settings::Settings, watch, workspace, worktree::FileHandle};
use anyhow::Result; use anyhow::Result;
use futures_core::future::LocalBoxFuture; use futures_core::future::LocalBoxFuture;
use gpui::{ use gpui::{
@ -254,6 +254,7 @@ pub enum SelectAction {
pub struct BufferView { pub struct BufferView {
handle: WeakViewHandle<Self>, handle: WeakViewHandle<Self>,
buffer: ModelHandle<Buffer>, buffer: ModelHandle<Buffer>,
file: Option<FileHandle>,
display_map: ModelHandle<DisplayMap>, display_map: ModelHandle<DisplayMap>,
selection_set_id: SelectionSetId, selection_set_id: SelectionSetId,
pending_selection: Option<Selection>, pending_selection: Option<Selection>,
@ -275,20 +276,25 @@ struct ClipboardSelection {
impl BufferView { impl BufferView {
pub fn single_line(settings: watch::Receiver<Settings>, ctx: &mut ViewContext<Self>) -> Self { pub fn single_line(settings: watch::Receiver<Settings>, ctx: &mut ViewContext<Self>) -> Self {
let buffer = ctx.add_model(|ctx| Buffer::new(0, String::new(), ctx)); let buffer = ctx.add_model(|_| Buffer::new(0, String::new()));
let mut view = Self::for_buffer(buffer, settings, ctx); let mut view = Self::for_buffer(buffer, None, settings, ctx);
view.single_line = true; view.single_line = true;
view view
} }
pub fn for_buffer( pub fn for_buffer(
buffer: ModelHandle<Buffer>, buffer: ModelHandle<Buffer>,
file: Option<FileHandle>,
settings: watch::Receiver<Settings>, settings: watch::Receiver<Settings>,
ctx: &mut ViewContext<Self>, ctx: &mut ViewContext<Self>,
) -> Self { ) -> Self {
settings.notify_view_on_change(ctx); settings.notify_view_on_change(ctx);
ctx.observe(&buffer, Self::on_buffer_changed); if let Some(file) = file.as_ref() {
file.observe_from_view(ctx, |_, _, ctx| ctx.emit(Event::FileHandleChanged));
}
ctx.observe_model(&buffer, Self::on_buffer_changed);
ctx.subscribe_to_model(&buffer, Self::on_buffer_event); ctx.subscribe_to_model(&buffer, Self::on_buffer_event);
let display_map = ctx.add_model(|ctx| { let display_map = ctx.add_model(|ctx| {
DisplayMap::new( DisplayMap::new(
@ -297,7 +303,7 @@ impl BufferView {
ctx, ctx,
) )
}); });
ctx.observe(&display_map, Self::on_display_map_changed); ctx.observe_model(&display_map, Self::on_display_map_changed);
let (selection_set_id, _) = buffer.update(ctx, |buffer, ctx| { let (selection_set_id, _) = buffer.update(ctx, |buffer, ctx| {
buffer.add_selection_set( buffer.add_selection_set(
@ -313,6 +319,7 @@ impl BufferView {
Self { Self {
handle: ctx.handle().downgrade(), handle: ctx.handle().downgrade(),
buffer, buffer,
file,
display_map, display_map,
selection_set_id, selection_set_id,
pending_selection: None, pending_selection: None,
@ -577,7 +584,7 @@ impl BufferView {
Ok(()) Ok(())
} }
fn insert(&mut self, text: &String, ctx: &mut ViewContext<Self>) { pub fn insert(&mut self, text: &String, ctx: &mut ViewContext<Self>) {
let mut offset_ranges = SmallVec::<[Range<usize>; 32]>::new(); let mut offset_ranges = SmallVec::<[Range<usize>; 32]>::new();
{ {
let buffer = self.buffer.read(ctx); let buffer = self.buffer.read(ctx);
@ -2089,18 +2096,6 @@ impl View for BufferView {
} }
} }
impl workspace::Item for Buffer {
type View = BufferView;
fn build_view(
buffer: ModelHandle<Self>,
settings: watch::Receiver<Settings>,
ctx: &mut ViewContext<Self::View>,
) -> Self::View {
BufferView::for_buffer(buffer, settings, ctx)
}
}
impl workspace::ItemView for BufferView { impl workspace::ItemView for BufferView {
fn should_activate_item_on_event(event: &Self::Event) -> bool { fn should_activate_item_on_event(event: &Self::Event) -> bool {
matches!(event, Event::Activate) matches!(event, Event::Activate)
@ -2114,28 +2109,39 @@ impl workspace::ItemView for BufferView {
} }
fn title(&self, app: &AppContext) -> std::string::String { fn title(&self, app: &AppContext) -> std::string::String {
if let Some(name) = self.buffer.read(app).file_name(app) { let filename = self.file.as_ref().and_then(|file| file.file_name(app));
if let Some(name) = filename {
name.to_string_lossy().into() name.to_string_lossy().into()
} else { } else {
"untitled".into() "untitled".into()
} }
} }
fn entry_id(&self, app: &AppContext) -> Option<(usize, Arc<Path>)> { fn entry_id(&self, _: &AppContext) -> Option<(usize, Arc<Path>)> {
self.buffer.read(app).entry_id() self.file.as_ref().map(|file| file.entry_id())
} }
fn clone_on_split(&self, ctx: &mut ViewContext<Self>) -> Option<Self> fn clone_on_split(&self, ctx: &mut ViewContext<Self>) -> Option<Self>
where where
Self: Sized, Self: Sized,
{ {
let clone = BufferView::for_buffer(self.buffer.clone(), self.settings.clone(), ctx); let clone = BufferView::for_buffer(
self.buffer.clone(),
self.file.clone(),
self.settings.clone(),
ctx,
);
*clone.scroll_position.lock() = *self.scroll_position.lock(); *clone.scroll_position.lock() = *self.scroll_position.lock();
Some(clone) Some(clone)
} }
fn save(&self, ctx: &mut ViewContext<Self>) -> LocalBoxFuture<'static, Result<()>> { fn save(&self, ctx: &mut ViewContext<Self>) -> LocalBoxFuture<'static, Result<()>> {
self.buffer.update(ctx, |buffer, ctx| buffer.save(ctx)) if let Some(file) = self.file.as_ref() {
self.buffer
.update(ctx, |buffer, ctx| buffer.save(file, ctx))
} else {
Box::pin(async { Ok(()) })
}
} }
fn is_dirty(&self, ctx: &AppContext) -> bool { fn is_dirty(&self, ctx: &AppContext) -> bool {
@ -2153,11 +2159,10 @@ mod tests {
#[test] #[test]
fn test_selection_with_mouse() { fn test_selection_with_mouse() {
App::test((), |app| { App::test((), |app| {
let buffer = let buffer = app.add_model(|_| Buffer::new(0, "aaaaaa\nbbbbbb\ncccccc\ndddddd\n"));
app.add_model(|ctx| Buffer::new(0, "aaaaaa\nbbbbbb\ncccccc\ndddddd\n", ctx));
let settings = settings::channel(&app.font_cache()).unwrap().1; let settings = settings::channel(&app.font_cache()).unwrap().1;
let (_, buffer_view) = let (_, buffer_view) =
app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx)); app.add_window(|ctx| BufferView::for_buffer(buffer, None, settings, ctx));
buffer_view.update(app, |view, ctx| { buffer_view.update(app, |view, ctx| {
view.begin_selection(DisplayPoint::new(2, 2), false, ctx); view.begin_selection(DisplayPoint::new(2, 2), false, ctx);
@ -2268,11 +2273,11 @@ mod tests {
let layout_cache = TextLayoutCache::new(app.platform().fonts()); let layout_cache = TextLayoutCache::new(app.platform().fonts());
let font_cache = app.font_cache().clone(); let font_cache = app.font_cache().clone();
let buffer = app.add_model(|ctx| Buffer::new(0, sample_text(6, 6), ctx)); let buffer = app.add_model(|_| Buffer::new(0, sample_text(6, 6)));
let settings = settings::channel(&font_cache).unwrap().1; let settings = settings::channel(&font_cache).unwrap().1;
let (_, view) = let (_, view) =
app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx)); app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), None, settings, ctx));
let layouts = view let layouts = view
.read(app) .read(app)
@ -2285,7 +2290,7 @@ mod tests {
#[test] #[test]
fn test_fold() { fn test_fold() {
App::test((), |app| { App::test((), |app| {
let buffer = app.add_model(|ctx| { let buffer = app.add_model(|_| {
Buffer::new( Buffer::new(
0, 0,
" "
@ -2306,12 +2311,11 @@ mod tests {
} }
" "
.unindent(), .unindent(),
ctx,
) )
}); });
let settings = settings::channel(&app.font_cache()).unwrap().1; let settings = settings::channel(&app.font_cache()).unwrap().1;
let (_, view) = let (_, view) =
app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx)); app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), None, settings, ctx));
view.update(app, |view, ctx| { view.update(app, |view, ctx| {
view.select_display_ranges( view.select_display_ranges(
@ -2380,10 +2384,10 @@ mod tests {
#[test] #[test]
fn test_move_cursor() { fn test_move_cursor() {
App::test((), |app| { App::test((), |app| {
let buffer = app.add_model(|ctx| Buffer::new(0, sample_text(6, 6), ctx)); let buffer = app.add_model(|_| Buffer::new(0, sample_text(6, 6)));
let settings = settings::channel(&app.font_cache()).unwrap().1; let settings = settings::channel(&app.font_cache()).unwrap().1;
let (_, view) = let (_, view) =
app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx)); app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), None, settings, ctx));
buffer.update(app, |buffer, ctx| { buffer.update(app, |buffer, ctx| {
buffer buffer
@ -2458,9 +2462,10 @@ mod tests {
#[test] #[test]
fn test_beginning_end_of_line() { fn test_beginning_end_of_line() {
App::test((), |app| { App::test((), |app| {
let buffer = app.add_model(|ctx| Buffer::new(0, "abc\n def", ctx)); let buffer = app.add_model(|_| Buffer::new(0, "abc\n def"));
let settings = settings::channel(&app.font_cache()).unwrap().1; let settings = settings::channel(&app.font_cache()).unwrap().1;
let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx)); let (_, view) =
app.add_window(|ctx| BufferView::for_buffer(buffer, None, settings, ctx));
view.update(app, |view, ctx| { view.update(app, |view, ctx| {
view.select_display_ranges( view.select_display_ranges(
&[ &[
@ -2586,10 +2591,11 @@ mod tests {
#[test] #[test]
fn test_prev_next_word_boundary() { fn test_prev_next_word_boundary() {
App::test((), |app| { App::test((), |app| {
let buffer = app let buffer =
.add_model(|ctx| Buffer::new(0, "use std::str::{foo, bar}\n\n {baz.qux()}", ctx)); app.add_model(|_| Buffer::new(0, "use std::str::{foo, bar}\n\n {baz.qux()}"));
let settings = settings::channel(&app.font_cache()).unwrap().1; let settings = settings::channel(&app.font_cache()).unwrap().1;
let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx)); let (_, view) =
app.add_window(|ctx| BufferView::for_buffer(buffer, None, settings, ctx));
view.update(app, |view, ctx| { view.update(app, |view, ctx| {
view.select_display_ranges( view.select_display_ranges(
&[ &[
@ -2768,16 +2774,12 @@ mod tests {
#[test] #[test]
fn test_backspace() { fn test_backspace() {
App::test((), |app| { App::test((), |app| {
let buffer = app.add_model(|ctx| { let buffer = app.add_model(|_| {
Buffer::new( Buffer::new(0, "one two three\nfour five six\nseven eight nine\nten\n")
0,
"one two three\nfour five six\nseven eight nine\nten\n",
ctx,
)
}); });
let settings = settings::channel(&app.font_cache()).unwrap().1; let settings = settings::channel(&app.font_cache()).unwrap().1;
let (_, view) = let (_, view) =
app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx)); app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), None, settings, ctx));
view.update(app, |view, ctx| { view.update(app, |view, ctx| {
view.select_display_ranges( view.select_display_ranges(
@ -2805,16 +2807,12 @@ mod tests {
#[test] #[test]
fn test_delete() { fn test_delete() {
App::test((), |app| { App::test((), |app| {
let buffer = app.add_model(|ctx| { let buffer = app.add_model(|_| {
Buffer::new( Buffer::new(0, "one two three\nfour five six\nseven eight nine\nten\n")
0,
"one two three\nfour five six\nseven eight nine\nten\n",
ctx,
)
}); });
let settings = settings::channel(&app.font_cache()).unwrap().1; let settings = settings::channel(&app.font_cache()).unwrap().1;
let (_, view) = let (_, view) =
app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx)); app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), None, settings, ctx));
view.update(app, |view, ctx| { view.update(app, |view, ctx| {
view.select_display_ranges( view.select_display_ranges(
@ -2843,8 +2841,9 @@ mod tests {
fn test_delete_line() { fn test_delete_line() {
App::test((), |app| { App::test((), |app| {
let settings = settings::channel(&app.font_cache()).unwrap().1; let settings = settings::channel(&app.font_cache()).unwrap().1;
let buffer = app.add_model(|ctx| Buffer::new(0, "abc\ndef\nghi\n", ctx)); let buffer = app.add_model(|_| Buffer::new(0, "abc\ndef\nghi\n"));
let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx)); let (_, view) =
app.add_window(|ctx| BufferView::for_buffer(buffer, None, settings, ctx));
view.update(app, |view, ctx| { view.update(app, |view, ctx| {
view.select_display_ranges( view.select_display_ranges(
&[ &[
@ -2867,8 +2866,9 @@ mod tests {
); );
let settings = settings::channel(&app.font_cache()).unwrap().1; let settings = settings::channel(&app.font_cache()).unwrap().1;
let buffer = app.add_model(|ctx| Buffer::new(0, "abc\ndef\nghi\n", ctx)); let buffer = app.add_model(|_| Buffer::new(0, "abc\ndef\nghi\n"));
let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx)); let (_, view) =
app.add_window(|ctx| BufferView::for_buffer(buffer, None, settings, ctx));
view.update(app, |view, ctx| { view.update(app, |view, ctx| {
view.select_display_ranges( view.select_display_ranges(
&[DisplayPoint::new(2, 0)..DisplayPoint::new(0, 1)], &[DisplayPoint::new(2, 0)..DisplayPoint::new(0, 1)],
@ -2889,8 +2889,9 @@ mod tests {
fn test_duplicate_line() { fn test_duplicate_line() {
App::test((), |app| { App::test((), |app| {
let settings = settings::channel(&app.font_cache()).unwrap().1; let settings = settings::channel(&app.font_cache()).unwrap().1;
let buffer = app.add_model(|ctx| Buffer::new(0, "abc\ndef\nghi\n", ctx)); let buffer = app.add_model(|_| Buffer::new(0, "abc\ndef\nghi\n"));
let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx)); let (_, view) =
app.add_window(|ctx| BufferView::for_buffer(buffer, None, settings, ctx));
view.update(app, |view, ctx| { view.update(app, |view, ctx| {
view.select_display_ranges( view.select_display_ranges(
&[ &[
@ -2919,8 +2920,9 @@ mod tests {
); );
let settings = settings::channel(&app.font_cache()).unwrap().1; let settings = settings::channel(&app.font_cache()).unwrap().1;
let buffer = app.add_model(|ctx| Buffer::new(0, "abc\ndef\nghi\n", ctx)); let buffer = app.add_model(|_| Buffer::new(0, "abc\ndef\nghi\n"));
let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx)); let (_, view) =
app.add_window(|ctx| BufferView::for_buffer(buffer, None, settings, ctx));
view.update(app, |view, ctx| { view.update(app, |view, ctx| {
view.select_display_ranges( view.select_display_ranges(
&[ &[
@ -2949,10 +2951,10 @@ mod tests {
#[test] #[test]
fn test_clipboard() { fn test_clipboard() {
App::test((), |app| { App::test((), |app| {
let buffer = app.add_model(|ctx| Buffer::new(0, "one two three four five six ", ctx)); let buffer = app.add_model(|_| Buffer::new(0, "one two three four five six "));
let settings = settings::channel(&app.font_cache()).unwrap().1; let settings = settings::channel(&app.font_cache()).unwrap().1;
let view = app let view = app
.add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx)) .add_window(|ctx| BufferView::for_buffer(buffer.clone(), None, settings, ctx))
.1; .1;
// Cut with three selections. Clipboard text is divided into three slices. // Cut with three selections. Clipboard text is divided into three slices.
@ -3090,9 +3092,10 @@ mod tests {
#[test] #[test]
fn test_select_all() { fn test_select_all() {
App::test((), |app| { App::test((), |app| {
let buffer = app.add_model(|ctx| Buffer::new(0, "abc\nde\nfgh", ctx)); let buffer = app.add_model(|_| Buffer::new(0, "abc\nde\nfgh"));
let settings = settings::channel(&app.font_cache()).unwrap().1; let settings = settings::channel(&app.font_cache()).unwrap().1;
let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx)); let (_, view) =
app.add_window(|ctx| BufferView::for_buffer(buffer, None, settings, ctx));
view.update(app, |b, ctx| b.select_all(&(), ctx)); view.update(app, |b, ctx| b.select_all(&(), ctx));
assert_eq!( assert_eq!(
view.read(app).selection_ranges(app.as_ref()), view.read(app).selection_ranges(app.as_ref()),

14
zed/src/editor/display_map/fold_map.rs
View file

@ -505,7 +505,7 @@ mod tests {
#[test] #[test]
fn test_basic_folds() { fn test_basic_folds() {
App::test((), |app| { App::test((), |app| {
let buffer = app.add_model(|ctx| Buffer::new(0, sample_text(5, 6), ctx)); let buffer = app.add_model(|_| Buffer::new(0, sample_text(5, 6)));
let mut map = FoldMap::new(buffer.clone(), app.as_ref()); let mut map = FoldMap::new(buffer.clone(), app.as_ref());
map.fold( map.fold(
@ -556,7 +556,7 @@ mod tests {
#[test] #[test]
fn test_adjacent_folds() { fn test_adjacent_folds() {
App::test((), |app| { App::test((), |app| {
let buffer = app.add_model(|ctx| Buffer::new(0, "abcdefghijkl", ctx)); let buffer = app.add_model(|_| Buffer::new(0, "abcdefghijkl"));
{ {
let mut map = FoldMap::new(buffer.clone(), app.as_ref()); let mut map = FoldMap::new(buffer.clone(), app.as_ref());
@ -600,7 +600,7 @@ mod tests {
#[test] #[test]
fn test_overlapping_folds() { fn test_overlapping_folds() {
App::test((), |app| { App::test((), |app| {
let buffer = app.add_model(|ctx| Buffer::new(0, sample_text(5, 6), ctx)); let buffer = app.add_model(|_| Buffer::new(0, sample_text(5, 6)));
let mut map = FoldMap::new(buffer.clone(), app.as_ref()); let mut map = FoldMap::new(buffer.clone(), app.as_ref());
map.fold( map.fold(
vec![ vec![
@ -619,7 +619,7 @@ mod tests {
#[test] #[test]
fn test_merging_folds_via_edit() { fn test_merging_folds_via_edit() {
App::test((), |app| { App::test((), |app| {
let buffer = app.add_model(|ctx| Buffer::new(0, sample_text(5, 6), ctx)); let buffer = app.add_model(|_| Buffer::new(0, sample_text(5, 6)));
let mut map = FoldMap::new(buffer.clone(), app.as_ref()); let mut map = FoldMap::new(buffer.clone(), app.as_ref());
map.fold( map.fold(
@ -670,10 +670,10 @@ mod tests {
let mut rng = StdRng::seed_from_u64(seed); let mut rng = StdRng::seed_from_u64(seed);
App::test((), |app| { App::test((), |app| {
let buffer = app.add_model(|ctx| { let buffer = app.add_model(|_| {
let len = rng.gen_range(0..10); let len = rng.gen_range(0..10);
let text = RandomCharIter::new(&mut rng).take(len).collect::<String>(); let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();
Buffer::new(0, text, ctx) Buffer::new(0, text)
}); });
let mut map = FoldMap::new(buffer.clone(), app.as_ref()); let mut map = FoldMap::new(buffer.clone(), app.as_ref());
@ -749,7 +749,7 @@ mod tests {
fn test_buffer_rows() { fn test_buffer_rows() {
App::test((), |app| { App::test((), |app| {
let text = sample_text(6, 6) + "\n"; let text = sample_text(6, 6) + "\n";
let buffer = app.add_model(|ctx| Buffer::new(0, text, ctx)); let buffer = app.add_model(|_| Buffer::new(0, text));
let mut map = FoldMap::new(buffer.clone(), app.as_ref()); let mut map = FoldMap::new(buffer.clone(), app.as_ref());

4
zed/src/editor/display_map/mod.rs
View file

@ -324,7 +324,7 @@ mod tests {
fn test_chars_at() { fn test_chars_at() {
App::test((), |app| { App::test((), |app| {
let text = sample_text(6, 6); let text = sample_text(6, 6);
let buffer = app.add_model(|ctx| Buffer::new(0, text, ctx)); let buffer = app.add_model(|_| Buffer::new(0, text));
let map = app.add_model(|ctx| DisplayMap::new(buffer.clone(), 4, ctx)); let map = app.add_model(|ctx| DisplayMap::new(buffer.clone(), 4, ctx));
buffer buffer
.update(app, |buffer, ctx| { .update(app, |buffer, ctx| {
@ -391,7 +391,7 @@ mod tests {
#[test] #[test]
fn test_max_point() { fn test_max_point() {
App::test((), |app| { App::test((), |app| {
let buffer = app.add_model(|ctx| Buffer::new(0, "aaa\n\t\tbbb", ctx)); let buffer = app.add_model(|_| Buffer::new(0, "aaa\n\t\tbbb"));
let map = app.add_model(|ctx| DisplayMap::new(buffer.clone(), 4, ctx)); let map = app.add_model(|ctx| DisplayMap::new(buffer.clone(), 4, ctx));
assert_eq!( assert_eq!(
map.read(app).max_point(app.as_ref()), map.read(app).max_point(app.as_ref()),

96
zed/src/file_finder.rs
View file

@ -2,7 +2,7 @@ use crate::{
editor::{buffer_view, BufferView}, editor::{buffer_view, BufferView},
settings::Settings, settings::Settings,
util, watch, util, watch,
workspace::{Workspace, WorkspaceView}, workspace::Workspace,
worktree::{match_paths, PathMatch, Worktree}, worktree::{match_paths, PathMatch, Worktree},
}; };
use gpui::{ use gpui::{
@ -11,8 +11,8 @@ use gpui::{
fonts::{Properties, Weight}, fonts::{Properties, Weight},
geometry::vector::vec2f, geometry::vector::vec2f,
keymap::{self, Binding}, keymap::{self, Binding},
AppContext, Axis, Border, Entity, ModelHandle, MutableAppContext, View, ViewContext, AppContext, Axis, Border, Entity, MutableAppContext, View, ViewContext, ViewHandle,
ViewHandle, WeakViewHandle, WeakViewHandle,
}; };
use std::{ use std::{
cmp, cmp,
@ -26,7 +26,7 @@ use std::{
pub struct FileFinder { pub struct FileFinder {
handle: WeakViewHandle<Self>, handle: WeakViewHandle<Self>,
settings: watch::Receiver<Settings>, settings: watch::Receiver<Settings>,
workspace: ModelHandle<Workspace>, workspace: WeakViewHandle<Workspace>,
query_buffer: ViewHandle<BufferView>, query_buffer: ViewHandle<BufferView>,
search_count: usize, search_count: usize,
latest_search_id: usize, latest_search_id: usize,
@ -253,25 +253,21 @@ impl FileFinder {
}) })
} }
fn toggle(workspace_view: &mut WorkspaceView, _: &(), ctx: &mut ViewContext<WorkspaceView>) { fn toggle(workspace_view: &mut Workspace, _: &(), ctx: &mut ViewContext<Workspace>) {
workspace_view.toggle_modal(ctx, |ctx, workspace_view| { workspace_view.toggle_modal(ctx, |ctx, workspace_view| {
let handle = ctx.add_view(|ctx| { let workspace = ctx.handle();
Self::new( let finder =
workspace_view.settings.clone(), ctx.add_view(|ctx| Self::new(workspace_view.settings.clone(), workspace, ctx));
workspace_view.workspace.clone(), ctx.subscribe_to_view(&finder, Self::on_event);
ctx, finder
)
});
ctx.subscribe_to_view(&handle, Self::on_event);
handle
}); });
} }
fn on_event( fn on_event(
workspace_view: &mut WorkspaceView, workspace_view: &mut Workspace,
_: ViewHandle<FileFinder>, _: ViewHandle<FileFinder>,
event: &Event, event: &Event,
ctx: &mut ViewContext<WorkspaceView>, ctx: &mut ViewContext<Workspace>,
) { ) {
match event { match event {
Event::Selected(tree_id, path) => { Event::Selected(tree_id, path) => {
@ -288,10 +284,10 @@ impl FileFinder {
pub fn new( pub fn new(
settings: watch::Receiver<Settings>, settings: watch::Receiver<Settings>,
workspace: ModelHandle<Workspace>, workspace: ViewHandle<Workspace>,
ctx: &mut ViewContext<Self>, ctx: &mut ViewContext<Self>,
) -> Self { ) -> Self {
ctx.observe(&workspace, Self::workspace_updated); ctx.observe_view(&workspace, Self::workspace_updated);
let query_buffer = ctx.add_view(|ctx| BufferView::single_line(settings.clone(), ctx)); let query_buffer = ctx.add_view(|ctx| BufferView::single_line(settings.clone(), ctx));
ctx.subscribe_to_view(&query_buffer, Self::on_query_buffer_event); ctx.subscribe_to_view(&query_buffer, Self::on_query_buffer_event);
@ -301,7 +297,7 @@ impl FileFinder {
Self { Self {
handle: ctx.handle().downgrade(), handle: ctx.handle().downgrade(),
settings, settings,
workspace, workspace: workspace.downgrade(),
query_buffer, query_buffer,
search_count: 0, search_count: 0,
latest_search_id: 0, latest_search_id: 0,
@ -314,7 +310,7 @@ impl FileFinder {
} }
} }
fn workspace_updated(&mut self, _: ModelHandle<Workspace>, ctx: &mut ViewContext<Self>) { fn workspace_updated(&mut self, _: ViewHandle<Workspace>, ctx: &mut ViewContext<Self>) {
self.spawn_search(self.query_buffer.read(ctx).text(ctx.as_ref()), ctx); self.spawn_search(self.query_buffer.read(ctx).text(ctx.as_ref()), ctx);
} }
@ -390,9 +386,10 @@ impl FileFinder {
ctx.emit(Event::Selected(*tree_id, path.clone())); ctx.emit(Event::Selected(*tree_id, path.clone()));
} }
fn spawn_search(&mut self, query: String, ctx: &mut ViewContext<Self>) { fn spawn_search(&mut self, query: String, ctx: &mut ViewContext<Self>) -> Option<()> {
let snapshots = self let snapshots = self
.workspace .workspace
.upgrade(&ctx)?
.read(ctx) .read(ctx)
.worktrees() .worktrees()
.iter() .iter()
@ -420,6 +417,8 @@ impl FileFinder {
}); });
ctx.spawn(task, Self::update_matches).detach(); ctx.spawn(task, Self::update_matches).detach();
Some(())
} }
fn update_matches( fn update_matches(
@ -443,6 +442,7 @@ impl FileFinder {
fn worktree<'a>(&'a self, tree_id: usize, app: &'a AppContext) -> Option<&'a Worktree> { fn worktree<'a>(&'a self, tree_id: usize, app: &'a AppContext) -> Option<&'a Worktree> {
self.workspace self.workspace
.upgrade(app)?
.read(app) .read(app)
.worktrees() .worktrees()
.get(&tree_id) .get(&tree_id)
@ -453,11 +453,7 @@ impl FileFinder {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use crate::{ use crate::{editor, settings, test::temp_tree, workspace::Workspace};
editor, settings,
test::temp_tree,
workspace::{Workspace, WorkspaceView},
};
use gpui::App; use gpui::App;
use serde_json::json; use serde_json::json;
use std::fs; use std::fs;
@ -476,20 +472,22 @@ mod tests {
}); });
let settings = settings::channel(&app.font_cache()).unwrap().1; let settings = settings::channel(&app.font_cache()).unwrap().1;
let workspace = app.add_model(|ctx| Workspace::new(vec![tmp_dir.path().into()], ctx)); let (window_id, workspace) = app.add_window(|ctx| {
let (window_id, workspace_view) = let mut workspace = Workspace::new(0, settings, ctx);
app.add_window(|ctx| WorkspaceView::new(workspace.clone(), settings, ctx)); workspace.add_worktree(tmp_dir.path(), ctx);
workspace
});
app.read(|ctx| workspace.read(ctx).worktree_scans_complete(ctx)) app.read(|ctx| workspace.read(ctx).worktree_scans_complete(ctx))
.await; .await;
app.dispatch_action( app.dispatch_action(
window_id, window_id,
vec![workspace_view.id()], vec![workspace.id()],
"file_finder:toggle".into(), "file_finder:toggle".into(),
(), (),
); );
let finder = app.read(|ctx| { let finder = app.read(|ctx| {
workspace_view workspace
.read(ctx) .read(ctx)
.modal() .modal()
.cloned() .cloned()
@ -507,16 +505,16 @@ mod tests {
.condition(&app, |finder, _| finder.matches.len() == 2) .condition(&app, |finder, _| finder.matches.len() == 2)
.await; .await;
let active_pane = app.read(|ctx| workspace_view.read(ctx).active_pane().clone()); let active_pane = app.read(|ctx| workspace.read(ctx).active_pane().clone());
app.dispatch_action( app.dispatch_action(
window_id, window_id,
vec![workspace_view.id(), finder.id()], vec![workspace.id(), finder.id()],
"menu:select_next", "menu:select_next",
(), (),
); );
app.dispatch_action( app.dispatch_action(
window_id, window_id,
vec![workspace_view.id(), finder.id()], vec![workspace.id(), finder.id()],
"file_finder:confirm", "file_finder:confirm",
(), (),
); );
@ -543,7 +541,11 @@ mod tests {
"hiccup": "", "hiccup": "",
})); }));
let settings = settings::channel(&app.font_cache()).unwrap().1; let settings = settings::channel(&app.font_cache()).unwrap().1;
let workspace = app.add_model(|ctx| Workspace::new(vec![tmp_dir.path().into()], ctx)); let (_, workspace) = app.add_window(|ctx| {
let mut workspace = Workspace::new(0, settings.clone(), ctx);
workspace.add_worktree(tmp_dir.path(), ctx);
workspace
});
app.read(|ctx| workspace.read(ctx).worktree_scans_complete(ctx)) app.read(|ctx| workspace.read(ctx).worktree_scans_complete(ctx))
.await; .await;
let (_, finder) = let (_, finder) =
@ -596,7 +598,11 @@ mod tests {
fs::write(&file_path, "").unwrap(); fs::write(&file_path, "").unwrap();
let settings = settings::channel(&app.font_cache()).unwrap().1; let settings = settings::channel(&app.font_cache()).unwrap().1;
let workspace = app.add_model(|ctx| Workspace::new(vec![file_path], ctx)); let (_, workspace) = app.add_window(|ctx| {
let mut workspace = Workspace::new(0, settings.clone(), ctx);
workspace.add_worktree(&file_path, ctx);
workspace
});
app.read(|ctx| workspace.read(ctx).worktree_scans_complete(ctx)) app.read(|ctx| workspace.read(ctx).worktree_scans_complete(ctx))
.await; .await;
let (_, finder) = let (_, finder) =
@ -633,14 +639,20 @@ mod tests {
"dir2": { "a.txt": "" } "dir2": { "a.txt": "" }
})); }));
let settings = settings::channel(&app.font_cache()).unwrap().1; let settings = settings::channel(&app.font_cache()).unwrap().1;
let workspace = app.add_model(|ctx| {
Workspace::new( let (_, workspace) = app.add_window(|ctx| Workspace::new(0, settings.clone(), ctx));
vec![tmp_dir.path().join("dir1"), tmp_dir.path().join("dir2")],
ctx, workspace
) .update(&mut app, |workspace, ctx| {
}); workspace.open_paths(
&[tmp_dir.path().join("dir1"), tmp_dir.path().join("dir2")],
ctx,
)
})
.await;
app.read(|ctx| workspace.read(ctx).worktree_scans_complete(ctx)) app.read(|ctx| workspace.read(ctx).worktree_scans_complete(ctx))
.await; .await;
let (_, finder) = let (_, finder) =
app.add_window(|ctx| FileFinder::new(settings, workspace.clone(), ctx)); app.add_window(|ctx| FileFinder::new(settings, workspace.clone(), ctx));

483
zed/src/workspace/workspace_view.rs → zed/src/workspace.rs
View file

@ -1,25 +1,99 @@
use super::{pane, Pane, PaneGroup, SplitDirection, Workspace}; pub mod pane;
use crate::{settings::Settings, watch}; pub mod pane_group;
use futures_core::{future::LocalBoxFuture, Future}; pub use pane::*;
use gpui::{ pub use pane_group::*;
color::rgbu, elements::*, json::to_string_pretty, keymap::Binding, AnyViewHandle, AppContext,
ClipboardItem, Entity, EntityTask, ModelHandle, MutableAppContext, View, ViewContext,
ViewHandle,
};
use log::error;
use std::{
collections::HashSet,
path::{Path, PathBuf},
sync::Arc,
};
use crate::{
settings::Settings,
watch::{self, Receiver},
};
use gpui::{MutableAppContext, PathPromptOptions};
use std::path::PathBuf;
pub fn init(app: &mut MutableAppContext) { pub fn init(app: &mut MutableAppContext) {
app.add_action("workspace:save", WorkspaceView::save_active_item); app.add_global_action("workspace:open", open);
app.add_action("workspace:debug_elements", WorkspaceView::debug_elements); app.add_global_action("workspace:open_paths", open_paths);
app.add_global_action("app:quit", quit);
app.add_action("workspace:save", Workspace::save_active_item);
app.add_action("workspace:debug_elements", Workspace::debug_elements);
app.add_bindings(vec![ app.add_bindings(vec![
Binding::new("cmd-s", "workspace:save", None), Binding::new("cmd-s", "workspace:save", None),
Binding::new("cmd-alt-i", "workspace:debug_elements", None), Binding::new("cmd-alt-i", "workspace:debug_elements", None),
]); ]);
pane::init(app);
}
use crate::{
editor::{Buffer, BufferView},
time::ReplicaId,
worktree::{Worktree, WorktreeHandle},
};
use futures_core::{future::LocalBoxFuture, Future};
use gpui::{
color::rgbu, elements::*, json::to_string_pretty, keymap::Binding, AnyViewHandle, AppContext,
ClipboardItem, Entity, EntityTask, ModelHandle, View, ViewContext, ViewHandle,
};
use log::error;
use smol::prelude::*;
use std::{
collections::{hash_map::Entry, HashMap, HashSet},
path::Path,
sync::Arc,
};
pub struct OpenParams {
pub paths: Vec<PathBuf>,
pub settings: watch::Receiver<Settings>,
}
fn open(settings: &Receiver<Settings>, ctx: &mut MutableAppContext) {
let settings = settings.clone();
ctx.prompt_for_paths(
PathPromptOptions {
files: true,
directories: true,
multiple: true,
},
move |paths, ctx| {
if let Some(paths) = paths {
ctx.dispatch_global_action("workspace:open_paths", OpenParams { paths, settings });
}
},
);
}
fn open_paths(params: &OpenParams, app: &mut MutableAppContext) {
log::info!("open paths {:?}", params.paths);
// Open paths in existing workspace if possible
for window_id in app.window_ids().collect::<Vec<_>>() {
if let Some(handle) = app.root_view::<Workspace>(window_id) {
if handle.update(app, |view, ctx| {
if view.contains_paths(&params.paths, ctx.as_ref()) {
let open_paths = view.open_paths(&params.paths, ctx);
ctx.foreground().spawn(open_paths).detach();
log::info!("open paths on existing workspace");
true
} else {
false
}
}) {
return;
}
}
}
log::info!("open new workspace");
// Add a new workspace if necessary
app.add_window(|ctx| {
let mut view = Workspace::new(0, params.settings.clone(), ctx);
let open_paths = view.open_paths(&params.paths, ctx);
ctx.foreground().spawn(open_paths).detach();
view
});
}
fn quit(_: &(), app: &mut MutableAppContext) {
app.platform().quit();
} }
pub trait ItemView: View { pub trait ItemView: View {
@ -122,24 +196,27 @@ pub struct State {
pub center: PaneGroup, pub center: PaneGroup,
} }
pub struct WorkspaceView { pub struct Workspace {
pub workspace: ModelHandle<Workspace>,
pub settings: watch::Receiver<Settings>, pub settings: watch::Receiver<Settings>,
modal: Option<AnyViewHandle>, modal: Option<AnyViewHandle>,
center: PaneGroup, center: PaneGroup,
panes: Vec<ViewHandle<Pane>>, panes: Vec<ViewHandle<Pane>>,
active_pane: ViewHandle<Pane>, active_pane: ViewHandle<Pane>,
loading_entries: HashSet<(usize, Arc<Path>)>, loading_entries: HashSet<(usize, Arc<Path>)>,
replica_id: ReplicaId,
worktrees: HashSet<ModelHandle<Worktree>>,
buffers: HashMap<
(usize, u64),
postage::watch::Receiver<Option<Result<ModelHandle<Buffer>, Arc<anyhow::Error>>>>,
>,
} }
impl WorkspaceView { impl Workspace {
pub fn new( pub fn new(
workspace: ModelHandle<Workspace>, replica_id: ReplicaId,
settings: watch::Receiver<Settings>, settings: watch::Receiver<Settings>,
ctx: &mut ViewContext<Self>, ctx: &mut ViewContext<Self>,
) -> Self { ) -> Self {
ctx.observe(&workspace, Self::workspace_updated);
let pane = ctx.add_view(|_| Pane::new(settings.clone())); let pane = ctx.add_view(|_| Pane::new(settings.clone()));
let pane_id = pane.id(); let pane_id = pane.id();
ctx.subscribe_to_view(&pane, move |me, _, event, ctx| { ctx.subscribe_to_view(&pane, move |me, _, event, ctx| {
@ -147,29 +224,65 @@ impl WorkspaceView {
}); });
ctx.focus(&pane); ctx.focus(&pane);
WorkspaceView { Workspace {
workspace,
modal: None, modal: None,
center: PaneGroup::new(pane.id()), center: PaneGroup::new(pane.id()),
panes: vec![pane.clone()], panes: vec![pane.clone()],
active_pane: pane.clone(), active_pane: pane.clone(),
loading_entries: HashSet::new(), loading_entries: HashSet::new(),
settings, settings,
replica_id,
worktrees: Default::default(),
buffers: Default::default(),
} }
} }
pub fn worktrees(&self) -> &HashSet<ModelHandle<Worktree>> {
&self.worktrees
}
pub fn contains_paths(&self, paths: &[PathBuf], app: &AppContext) -> bool { pub fn contains_paths(&self, paths: &[PathBuf], app: &AppContext) -> bool {
self.workspace.read(app).contains_paths(paths, app) paths.iter().all(|path| self.contains_path(&path, app))
}
pub fn contains_path(&self, path: &Path, app: &AppContext) -> bool {
self.worktrees
.iter()
.any(|worktree| worktree.read(app).contains_abs_path(path))
}
pub fn worktree_scans_complete(&self, ctx: &AppContext) -> impl Future<Output = ()> + 'static {
let futures = self
.worktrees
.iter()
.map(|worktree| worktree.read(ctx).scan_complete())
.collect::<Vec<_>>();
async move {
for future in futures {
future.await;
}
}
} }
pub fn open_paths( pub fn open_paths(
&self, &mut self,
paths: &[PathBuf], paths: &[PathBuf],
ctx: &mut ViewContext<Self>, ctx: &mut ViewContext<Self>,
) -> impl Future<Output = ()> { ) -> impl Future<Output = ()> {
let entries = self let entries = paths
.workspace .iter()
.update(ctx, |workspace, ctx| workspace.open_paths(paths, ctx)); .cloned()
.map(|path| {
for tree in self.worktrees.iter() {
if let Ok(relative_path) = path.strip_prefix(tree.read(ctx).abs_path()) {
return (tree.id(), relative_path.into());
}
}
let worktree_id = self.add_worktree(&path, ctx);
(worktree_id, Path::new("").into())
})
.collect::<Vec<_>>();
let bg = ctx.background_executor().clone(); let bg = ctx.background_executor().clone();
let tasks = paths let tasks = paths
.iter() .iter()
@ -197,6 +310,15 @@ impl WorkspaceView {
} }
} }
pub fn add_worktree(&mut self, path: &Path, ctx: &mut ViewContext<Self>) -> usize {
let worktree = ctx.add_model(|ctx| Worktree::new(path, ctx));
let worktree_id = worktree.id();
ctx.observe_model(&worktree, |_, _, ctx| ctx.notify());
self.worktrees.insert(worktree);
ctx.notify();
worktree_id
}
pub fn toggle_modal<V, F>(&mut self, ctx: &mut ViewContext<Self>, add_view: F) pub fn toggle_modal<V, F>(&mut self, ctx: &mut ViewContext<Self>, add_view: F)
where where
V: 'static + View, V: 'static + View,
@ -241,31 +363,81 @@ impl WorkspaceView {
return None; return None;
} }
let (worktree_id, path) = entry.clone();
let worktree = match self.worktrees.get(&worktree_id).cloned() {
Some(worktree) => worktree,
None => {
log::error!("worktree {} does not exist", worktree_id);
return None;
}
};
let inode = match worktree.read(ctx).inode_for_path(&path) {
Some(inode) => inode,
None => {
log::error!("path {:?} does not exist", path);
return None;
}
};
let file = match worktree.file(path.clone(), ctx.as_ref()) {
Some(file) => file,
None => {
log::error!("path {:?} does not exist", path);
return None;
}
};
self.loading_entries.insert(entry.clone()); self.loading_entries.insert(entry.clone());
match self.workspace.update(ctx, |workspace, ctx| { if let Entry::Vacant(entry) = self.buffers.entry((worktree_id, inode)) {
workspace.open_entry(entry.clone(), ctx) let (mut tx, rx) = postage::watch::channel();
}) { entry.insert(rx);
Err(error) => { let history = file.load_history(ctx.as_ref());
error!("{}", error); let replica_id = self.replica_id;
None let buffer = ctx
} .background_executor()
Ok(item) => { .spawn(async move { Ok(Buffer::from_history(replica_id, history.await?)) });
let settings = self.settings.clone(); ctx.spawn(buffer, move |_, from_history_result, ctx| {
Some(ctx.spawn(item, move |me, item, ctx| { *tx.borrow_mut() = Some(match from_history_result {
me.loading_entries.remove(&entry); Ok(buffer) => Ok(ctx.add_model(|_| buffer)),
match item { Err(error) => Err(Arc::new(error)),
Ok(item) => { })
let item_view = item.add_view(ctx.window_id(), settings, ctx.as_mut()); })
me.add_item(item_view, ctx); .detach()
}
Err(error) => {
error!("{}", error);
}
}
}))
}
} }
let mut watch = self.buffers.get(&(worktree_id, inode)).unwrap().clone();
Some(ctx.spawn(
async move {
loop {
if let Some(load_result) = watch.borrow().as_ref() {
return load_result.clone();
}
watch.next().await;
}
},
move |me, load_result, ctx| {
me.loading_entries.remove(&entry);
match load_result {
Ok(buffer_handle) => {
let buffer_view = Box::new(ctx.add_view(|ctx| {
BufferView::for_buffer(
buffer_handle,
Some(file),
me.settings.clone(),
ctx,
)
}));
me.add_item(buffer_view, ctx);
}
Err(error) => {
log::error!("error opening item: {}", error);
}
}
},
))
} }
pub fn save_active_item(&mut self, _: &(), ctx: &mut ViewContext<Self>) { pub fn save_active_item(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
@ -299,10 +471,6 @@ impl WorkspaceView {
}; };
} }
fn workspace_updated(&mut self, _: ModelHandle<Workspace>, ctx: &mut ViewContext<Self>) {
ctx.notify();
}
fn add_pane(&mut self, ctx: &mut ViewContext<Self>) -> ViewHandle<Pane> { fn add_pane(&mut self, ctx: &mut ViewContext<Self>) -> ViewHandle<Pane> {
let pane = ctx.add_view(|_| Pane::new(self.settings.clone())); let pane = ctx.add_view(|_| Pane::new(self.settings.clone()));
let pane_id = pane.id(); let pane_id = pane.id();
@ -388,11 +556,11 @@ impl WorkspaceView {
} }
} }
impl Entity for WorkspaceView { impl Entity for Workspace {
type Event = (); type Event = ();
} }
impl View for WorkspaceView { impl View for Workspace {
fn ui_name() -> &'static str { fn ui_name() -> &'static str {
"Workspace" "Workspace"
} }
@ -414,13 +582,95 @@ impl View for WorkspaceView {
} }
} }
#[cfg(test)]
pub trait WorkspaceHandle {
fn file_entries(&self, app: &AppContext) -> Vec<(usize, Arc<Path>)>;
}
#[cfg(test)]
impl WorkspaceHandle for ViewHandle<Workspace> {
fn file_entries(&self, app: &AppContext) -> Vec<(usize, Arc<Path>)> {
self.read(app)
.worktrees()
.iter()
.flat_map(|tree| {
let tree_id = tree.id();
tree.read(app)
.files(0)
.map(move |f| (tree_id, f.path().clone()))
})
.collect::<Vec<_>>()
}
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::{pane, Workspace, WorkspaceView}; use super::*;
use crate::{settings, test::temp_tree, workspace::WorkspaceHandle as _}; use crate::{editor::BufferView, settings, test::temp_tree};
use gpui::App; use gpui::App;
use serde_json::json; use serde_json::json;
use std::collections::HashSet; use std::{collections::HashSet, os::unix};
#[test]
fn test_open_paths_action() {
App::test((), |app| {
let settings = settings::channel(&app.font_cache()).unwrap().1;
init(app);
let dir = temp_tree(json!({
"a": {
"aa": null,
"ab": null,
},
"b": {
"ba": null,
"bb": null,
},
"c": {
"ca": null,
"cb": null,
},
}));
app.dispatch_global_action(
"workspace:open_paths",
OpenParams {
paths: vec![
dir.path().join("a").to_path_buf(),
dir.path().join("b").to_path_buf(),
],
settings: settings.clone(),
},
);
assert_eq!(app.window_ids().count(), 1);
app.dispatch_global_action(
"workspace:open_paths",
OpenParams {
paths: vec![dir.path().join("a").to_path_buf()],
settings: settings.clone(),
},
);
assert_eq!(app.window_ids().count(), 1);
let workspace_view_1 = app
.root_view::<Workspace>(app.window_ids().next().unwrap())
.unwrap();
assert_eq!(workspace_view_1.read(app).worktrees().len(), 2);
app.dispatch_global_action(
"workspace:open_paths",
OpenParams {
paths: vec![
dir.path().join("b").to_path_buf(),
dir.path().join("c").to_path_buf(),
],
settings: settings.clone(),
},
);
assert_eq!(app.window_ids().count(), 2);
});
}
#[test] #[test]
fn test_open_entry() { fn test_open_entry() {
@ -434,7 +684,13 @@ mod tests {
})); }));
let settings = settings::channel(&app.font_cache()).unwrap().1; let settings = settings::channel(&app.font_cache()).unwrap().1;
let workspace = app.add_model(|ctx| Workspace::new(vec![dir.path().into()], ctx));
let (_, workspace) = app.add_window(|ctx| {
let mut workspace = Workspace::new(0, settings, ctx);
workspace.add_worktree(dir.path(), ctx);
workspace
});
app.read(|ctx| workspace.read(ctx).worktree_scans_complete(ctx)) app.read(|ctx| workspace.read(ctx).worktree_scans_complete(ctx))
.await; .await;
let entries = app.read(|ctx| workspace.file_entries(ctx)); let entries = app.read(|ctx| workspace.file_entries(ctx));
@ -442,12 +698,10 @@ mod tests {
let file2 = entries[1].clone(); let file2 = entries[1].clone();
let file3 = entries[2].clone(); let file3 = entries[2].clone();
let (_, workspace_view) = let pane = app.read(|ctx| workspace.read(ctx).active_pane().clone());
app.add_window(|ctx| WorkspaceView::new(workspace.clone(), settings, ctx));
let pane = app.read(|ctx| workspace_view.read(ctx).active_pane().clone());
// Open the first entry // Open the first entry
workspace_view workspace
.update(&mut app, |w, ctx| w.open_entry(file1.clone(), ctx)) .update(&mut app, |w, ctx| w.open_entry(file1.clone(), ctx))
.unwrap() .unwrap()
.await; .await;
@ -461,7 +715,7 @@ mod tests {
}); });
// Open the second entry // Open the second entry
workspace_view workspace
.update(&mut app, |w, ctx| w.open_entry(file2.clone(), ctx)) .update(&mut app, |w, ctx| w.open_entry(file2.clone(), ctx))
.unwrap() .unwrap()
.await; .await;
@ -475,7 +729,7 @@ mod tests {
}); });
// Open the first entry again. The existing pane item is activated. // Open the first entry again. The existing pane item is activated.
workspace_view.update(&mut app, |w, ctx| { workspace.update(&mut app, |w, ctx| {
assert!(w.open_entry(file1.clone(), ctx).is_none()) assert!(w.open_entry(file1.clone(), ctx).is_none())
}); });
app.read(|ctx| { app.read(|ctx| {
@ -488,7 +742,7 @@ mod tests {
}); });
// Open the third entry twice concurrently. Only one pane item is added. // Open the third entry twice concurrently. Only one pane item is added.
workspace_view workspace
.update(&mut app, |w, ctx| { .update(&mut app, |w, ctx| {
let task = w.open_entry(file3.clone(), ctx).unwrap(); let task = w.open_entry(file3.clone(), ctx).unwrap();
assert!(w.open_entry(file3.clone(), ctx).is_none()); assert!(w.open_entry(file3.clone(), ctx).is_none());
@ -516,22 +770,24 @@ mod tests {
"b.txt": "", "b.txt": "",
})); }));
let workspace = app.add_model(|ctx| Workspace::new(vec![dir1.path().into()], ctx));
let settings = settings::channel(&app.font_cache()).unwrap().1; let settings = settings::channel(&app.font_cache()).unwrap().1;
let (_, workspace_view) = let (_, workspace) = app.add_window(|ctx| {
app.add_window(|ctx| WorkspaceView::new(workspace.clone(), settings, ctx)); let mut workspace = Workspace::new(0, settings, ctx);
workspace.add_worktree(dir1.path(), ctx);
workspace
});
app.read(|ctx| workspace.read(ctx).worktree_scans_complete(ctx)) app.read(|ctx| workspace.read(ctx).worktree_scans_complete(ctx))
.await; .await;
// Open a file within an existing worktree. // Open a file within an existing worktree.
app.update(|ctx| { app.update(|ctx| {
workspace_view.update(ctx, |view, ctx| { workspace.update(ctx, |view, ctx| {
view.open_paths(&[dir1.path().join("a.txt")], ctx) view.open_paths(&[dir1.path().join("a.txt")], ctx)
}) })
}) })
.await; .await;
app.read(|ctx| { app.read(|ctx| {
workspace_view workspace
.read(ctx) .read(ctx)
.active_pane() .active_pane()
.read(ctx) .read(ctx)
@ -543,7 +799,7 @@ mod tests {
// Open a file outside of any existing worktree. // Open a file outside of any existing worktree.
app.update(|ctx| { app.update(|ctx| {
workspace_view.update(ctx, |view, ctx| { workspace.update(ctx, |view, ctx| {
view.open_paths(&[dir2.path().join("b.txt")], ctx) view.open_paths(&[dir2.path().join("b.txt")], ctx)
}) })
}) })
@ -563,7 +819,7 @@ mod tests {
); );
}); });
app.read(|ctx| { app.read(|ctx| {
workspace_view workspace
.read(ctx) .read(ctx)
.active_pane() .active_pane()
.read(ctx) .read(ctx)
@ -575,6 +831,67 @@ mod tests {
}); });
} }
#[test]
fn test_open_two_paths_to_the_same_file() {
use crate::workspace::ItemViewHandle;
App::test_async((), |mut app| async move {
// Create a worktree with a symlink:
// dir
// ├── hello.txt
// └── hola.txt -> hello.txt
let temp_dir = temp_tree(json!({ "hello.txt": "hi" }));
let dir = temp_dir.path();
unix::fs::symlink(dir.join("hello.txt"), dir.join("hola.txt")).unwrap();
let settings = settings::channel(&app.font_cache()).unwrap().1;
let (_, workspace) = app.add_window(|ctx| {
let mut workspace = Workspace::new(0, settings, ctx);
workspace.add_worktree(dir, ctx);
workspace
});
app.read(|ctx| workspace.read(ctx).worktree_scans_complete(ctx))
.await;
// Simultaneously open both the original file and the symlink to the same file.
app.update(|ctx| {
workspace.update(ctx, |view, ctx| {
view.open_paths(&[dir.join("hello.txt"), dir.join("hola.txt")], ctx)
})
})
.await;
// The same content shows up with two different editors.
let buffer_views = app.read(|ctx| {
workspace
.read(ctx)
.active_pane()
.read(ctx)
.items()
.iter()
.map(|i| i.to_any().downcast::<BufferView>().unwrap())
.collect::<Vec<_>>()
});
app.read(|ctx| {
assert_eq!(buffer_views[0].title(ctx), "hello.txt");
assert_eq!(buffer_views[1].title(ctx), "hola.txt");
assert_eq!(buffer_views[0].read(ctx).text(ctx), "hi");
assert_eq!(buffer_views[1].read(ctx).text(ctx), "hi");
});
// When modifying one buffer, the changes appear in both editors.
app.update(|ctx| {
buffer_views[0].update(ctx, |buf, ctx| {
buf.insert(&"oh, ".to_string(), ctx);
});
});
app.read(|ctx| {
assert_eq!(buffer_views[0].read(ctx).text(ctx), "oh, hi");
assert_eq!(buffer_views[1].read(ctx).text(ctx), "oh, hi");
});
});
}
#[test] #[test]
fn test_pane_actions() { fn test_pane_actions() {
App::test_async((), |mut app| async move { App::test_async((), |mut app| async move {
@ -589,17 +906,19 @@ mod tests {
})); }));
let settings = settings::channel(&app.font_cache()).unwrap().1; let settings = settings::channel(&app.font_cache()).unwrap().1;
let workspace = app.add_model(|ctx| Workspace::new(vec![dir.path().into()], ctx)); let (window_id, workspace) = app.add_window(|ctx| {
let mut workspace = Workspace::new(0, settings, ctx);
workspace.add_worktree(dir.path(), ctx);
workspace
});
app.read(|ctx| workspace.read(ctx).worktree_scans_complete(ctx)) app.read(|ctx| workspace.read(ctx).worktree_scans_complete(ctx))
.await; .await;
let entries = app.read(|ctx| workspace.file_entries(ctx)); let entries = app.read(|ctx| workspace.file_entries(ctx));
let file1 = entries[0].clone(); let file1 = entries[0].clone();
let (window_id, workspace_view) = let pane_1 = app.read(|ctx| workspace.read(ctx).active_pane().clone());
app.add_window(|ctx| WorkspaceView::new(workspace.clone(), settings, ctx));
let pane_1 = app.read(|ctx| workspace_view.read(ctx).active_pane().clone());
workspace_view workspace
.update(&mut app, |w, ctx| w.open_entry(file1.clone(), ctx)) .update(&mut app, |w, ctx| w.open_entry(file1.clone(), ctx))
.unwrap() .unwrap()
.await; .await;
@ -612,14 +931,14 @@ mod tests {
app.dispatch_action(window_id, vec![pane_1.id()], "pane:split_right", ()); app.dispatch_action(window_id, vec![pane_1.id()], "pane:split_right", ());
app.update(|ctx| { app.update(|ctx| {
let pane_2 = workspace_view.read(ctx).active_pane().clone(); let pane_2 = workspace.read(ctx).active_pane().clone();
assert_ne!(pane_1, pane_2); assert_ne!(pane_1, pane_2);
let pane2_item = pane_2.read(ctx).active_item().unwrap(); let pane2_item = pane_2.read(ctx).active_item().unwrap();
assert_eq!(pane2_item.entry_id(ctx.as_ref()), Some(file1.clone())); assert_eq!(pane2_item.entry_id(ctx.as_ref()), Some(file1.clone()));
ctx.dispatch_action(window_id, vec![pane_2.id()], "pane:close_active_item", ()); ctx.dispatch_action(window_id, vec![pane_2.id()], "pane:close_active_item", ());
let workspace_view = workspace_view.read(ctx); let workspace_view = workspace.read(ctx);
assert_eq!(workspace_view.panes.len(), 1); assert_eq!(workspace_view.panes.len(), 1);
assert_eq!(workspace_view.active_pane(), &pane_1); assert_eq!(workspace_view.active_pane(), &pane_1);
}); });

159
zed/src/workspace/mod.rs
View file

@ -1,159 +0,0 @@
pub mod pane;
pub mod pane_group;
pub mod workspace;
pub mod workspace_view;
pub use pane::*;
pub use pane_group::*;
pub use workspace::*;
pub use workspace_view::*;
use crate::{
settings::Settings,
watch::{self, Receiver},
};
use gpui::{MutableAppContext, PathPromptOptions};
use std::path::PathBuf;
pub fn init(app: &mut MutableAppContext) {
app.add_global_action("workspace:open", open);
app.add_global_action("workspace:open_paths", open_paths);
app.add_global_action("app:quit", quit);
pane::init(app);
workspace_view::init(app);
}
pub struct OpenParams {
pub paths: Vec<PathBuf>,
pub settings: watch::Receiver<Settings>,
}
fn open(settings: &Receiver<Settings>, ctx: &mut MutableAppContext) {
let settings = settings.clone();
ctx.prompt_for_paths(
PathPromptOptions {
files: true,
directories: true,
multiple: true,
},
move |paths, ctx| {
if let Some(paths) = paths {
ctx.dispatch_global_action("workspace:open_paths", OpenParams { paths, settings });
}
},
);
}
fn open_paths(params: &OpenParams, app: &mut MutableAppContext) {
log::info!("open paths {:?}", params.paths);
// Open paths in existing workspace if possible
for window_id in app.window_ids().collect::<Vec<_>>() {
if let Some(handle) = app.root_view::<WorkspaceView>(window_id) {
if handle.update(app, |view, ctx| {
if view.contains_paths(&params.paths, ctx.as_ref()) {
let open_paths = view.open_paths(&params.paths, ctx);
ctx.foreground().spawn(open_paths).detach();
log::info!("open paths on existing workspace");
true
} else {
false
}
}) {
return;
}
}
}
log::info!("open new workspace");
// Add a new workspace if necessary
let workspace = app.add_model(|ctx| Workspace::new(vec![], ctx));
app.add_window(|ctx| {
let view = WorkspaceView::new(workspace, params.settings.clone(), ctx);
let open_paths = view.open_paths(&params.paths, ctx);
ctx.foreground().spawn(open_paths).detach();
view
});
}
fn quit(_: &(), app: &mut MutableAppContext) {
app.platform().quit();
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{settings, test::*};
use gpui::App;
use serde_json::json;
#[test]
fn test_open_paths_action() {
App::test((), |app| {
let settings = settings::channel(&app.font_cache()).unwrap().1;
init(app);
let dir = temp_tree(json!({
"a": {
"aa": null,
"ab": null,
},
"b": {
"ba": null,
"bb": null,
},
"c": {
"ca": null,
"cb": null,
},
}));
app.dispatch_global_action(
"workspace:open_paths",
OpenParams {
paths: vec![
dir.path().join("a").to_path_buf(),
dir.path().join("b").to_path_buf(),
],
settings: settings.clone(),
},
);
assert_eq!(app.window_ids().count(), 1);
app.dispatch_global_action(
"workspace:open_paths",
OpenParams {
paths: vec![dir.path().join("a").to_path_buf()],
settings: settings.clone(),
},
);
assert_eq!(app.window_ids().count(), 1);
let workspace_view_1 = app
.root_view::<WorkspaceView>(app.window_ids().next().unwrap())
.unwrap();
assert_eq!(
workspace_view_1
.read(app)
.workspace
.read(app)
.worktrees()
.len(),
2
);
app.dispatch_global_action(
"workspace:open_paths",
OpenParams {
paths: vec![
dir.path().join("b").to_path_buf(),
dir.path().join("c").to_path_buf(),
],
settings: settings.clone(),
},
);
assert_eq!(app.window_ids().count(), 2);
});
}
}

298
zed/src/workspace/workspace.rs
View file

@ -1,298 +0,0 @@
use super::{ItemView, ItemViewHandle};
use crate::{
editor::{Buffer, History},
settings::Settings,
time::ReplicaId,
watch,
worktree::{Worktree, WorktreeHandle as _},
};
use anyhow::anyhow;
use gpui::{AppContext, Entity, Handle, ModelContext, ModelHandle, MutableAppContext, ViewContext};
use smol::prelude::*;
use std::{
collections::{HashMap, HashSet},
fmt::Debug,
path::{Path, PathBuf},
pin::Pin,
sync::Arc,
};
pub trait Item
where
Self: Sized,
{
type View: ItemView;
fn build_view(
handle: ModelHandle<Self>,
settings: watch::Receiver<Settings>,
ctx: &mut ViewContext<Self::View>,
) -> Self::View;
}
pub trait ItemHandle: Debug + Send + Sync {
fn add_view(
&self,
window_id: usize,
settings: watch::Receiver<Settings>,
app: &mut MutableAppContext,
) -> Box<dyn ItemViewHandle>;
fn id(&self) -> usize;
fn boxed_clone(&self) -> Box<dyn ItemHandle>;
}
impl<T: 'static + Item> ItemHandle for ModelHandle<T> {
fn add_view(
&self,
window_id: usize,
settings: watch::Receiver<Settings>,
app: &mut MutableAppContext,
) -> Box<dyn ItemViewHandle> {
Box::new(app.add_view(window_id, |ctx| T::build_view(self.clone(), settings, ctx)))
}
fn id(&self) -> usize {
Handle::id(self)
}
fn boxed_clone(&self) -> Box<dyn ItemHandle> {
Box::new(self.clone())
}
}
impl Clone for Box<dyn ItemHandle> {
fn clone(&self) -> Self {
self.boxed_clone()
}
}
pub type OpenResult = Result<Box<dyn ItemHandle>, Arc<anyhow::Error>>;
#[derive(Clone)]
enum OpenedItem {
Loading(watch::Receiver<Option<OpenResult>>),
Loaded(Box<dyn ItemHandle>),
}
pub struct Workspace {
replica_id: ReplicaId,
worktrees: HashSet<ModelHandle<Worktree>>,
items: HashMap<(usize, u64), OpenedItem>,
}
impl Workspace {
pub fn new(paths: Vec<PathBuf>, ctx: &mut ModelContext<Self>) -> Self {
let mut workspace = Self {
replica_id: 0,
worktrees: HashSet::new(),
items: HashMap::new(),
};
workspace.open_paths(&paths, ctx);
workspace
}
pub fn worktrees(&self) -> &HashSet<ModelHandle<Worktree>> {
&self.worktrees
}
pub fn worktree_scans_complete(&self, ctx: &AppContext) -> impl Future<Output = ()> + 'static {
let futures = self
.worktrees
.iter()
.map(|worktree| worktree.read(ctx).scan_complete())
.collect::<Vec<_>>();
async move {
for future in futures {
future.await;
}
}
}
pub fn contains_paths(&self, paths: &[PathBuf], app: &AppContext) -> bool {
paths.iter().all(|path| self.contains_path(&path, app))
}
pub fn contains_path(&self, path: &Path, app: &AppContext) -> bool {
self.worktrees
.iter()
.any(|worktree| worktree.read(app).contains_abs_path(path))
}
pub fn open_paths(
&mut self,
paths: &[PathBuf],
ctx: &mut ModelContext<Self>,
) -> Vec<(usize, Arc<Path>)> {
paths
.iter()
.cloned()
.map(move |path| self.open_path(path, ctx))
.collect()
}
fn open_path(&mut self, path: PathBuf, ctx: &mut ModelContext<Self>) -> (usize, Arc<Path>) {
for tree in self.worktrees.iter() {
if let Ok(relative_path) = path.strip_prefix(tree.read(ctx).abs_path()) {
return (tree.id(), relative_path.into());
}
}
let worktree = ctx.add_model(|ctx| Worktree::new(path.clone(), ctx));
let worktree_id = worktree.id();
ctx.observe(&worktree, Self::on_worktree_updated);
self.worktrees.insert(worktree);
ctx.notify();
(worktree_id, Path::new("").into())
}
pub fn open_entry(
&mut self,
(worktree_id, path): (usize, Arc<Path>),
ctx: &mut ModelContext<'_, Self>,
) -> anyhow::Result<Pin<Box<dyn Future<Output = OpenResult> + Send>>> {
let worktree = self
.worktrees
.get(&worktree_id)
.cloned()
.ok_or_else(|| anyhow!("worktree {} does not exist", worktree_id,))?;
let inode = worktree
.read(ctx)
.inode_for_path(&path)
.ok_or_else(|| anyhow!("path {:?} does not exist", path))?;
let item_key = (worktree_id, inode);
if let Some(item) = self.items.get(&item_key).cloned() {
return Ok(async move {
match item {
OpenedItem::Loaded(handle) => {
return Ok(handle);
}
OpenedItem::Loading(rx) => loop {
rx.updated().await;
if let Some(result) = smol::block_on(rx.read()).clone() {
return result;
}
},
}
}
.boxed());
}
let replica_id = self.replica_id;
let file = worktree.file(path.clone(), ctx.as_ref())?;
let history = file.load_history(ctx.as_ref());
let (mut tx, rx) = watch::channel(None);
self.items.insert(item_key, OpenedItem::Loading(rx));
ctx.spawn(
history,
move |me, history: anyhow::Result<History>, ctx| match history {
Ok(history) => {
let handle = Box::new(
ctx.add_model(|ctx| Buffer::from_history(replica_id, file, history, ctx)),
) as Box<dyn ItemHandle>;
me.items
.insert(item_key, OpenedItem::Loaded(handle.clone()));
ctx.spawn(
async move {
tx.update(|value| *value = Some(Ok(handle))).await;
},
|_, _, _| {},
)
.detach();
}
Err(error) => {
ctx.spawn(
async move {
tx.update(|value| *value = Some(Err(Arc::new(error)))).await;
},
|_, _, _| {},
)
.detach();
}
},
)
.detach();
self.open_entry((worktree_id, path), ctx)
}
fn on_worktree_updated(&mut self, _: ModelHandle<Worktree>, ctx: &mut ModelContext<Self>) {
ctx.notify();
}
}
impl Entity for Workspace {
type Event = ();
}
#[cfg(test)]
pub trait WorkspaceHandle {
fn file_entries(&self, app: &AppContext) -> Vec<(usize, Arc<Path>)>;
}
#[cfg(test)]
impl WorkspaceHandle for ModelHandle<Workspace> {
fn file_entries(&self, app: &AppContext) -> Vec<(usize, Arc<Path>)> {
self.read(app)
.worktrees()
.iter()
.flat_map(|tree| {
let tree_id = tree.id();
tree.read(app)
.files(0)
.map(move |f| (tree_id, f.path().clone()))
})
.collect::<Vec<_>>()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::test::temp_tree;
use gpui::App;
use serde_json::json;
#[test]
fn test_open_entry() {
App::test_async((), |mut app| async move {
let dir = temp_tree(json!({
"a": {
"aa": "aa contents",
"ab": "ab contents",
},
}));
let workspace = app.add_model(|ctx| Workspace::new(vec![dir.path().into()], ctx));
app.read(|ctx| workspace.read(ctx).worktree_scans_complete(ctx))
.await;
// Get the first file entry.
let tree = app.read(|ctx| workspace.read(ctx).worktrees.iter().next().unwrap().clone());
let path = app.read(|ctx| tree.read(ctx).files(0).next().unwrap().path().clone());
let entry = (tree.id(), path);
// Open the same entry twice before it finishes loading.
let (future_1, future_2) = workspace.update(&mut app, |w, app| {
(
w.open_entry(entry.clone(), app).unwrap(),
w.open_entry(entry.clone(), app).unwrap(),
)
});
let handle_1 = future_1.await.unwrap();
let handle_2 = future_2.await.unwrap();
assert_eq!(handle_1.id(), handle_2.id());
// Open the same entry again now that it has loaded
let handle_3 = workspace
.update(&mut app, |w, app| w.open_entry(entry, app).unwrap())
.await
.unwrap();
assert_eq!(handle_3.id(), handle_1.id());
})
}
}

26
zed/src/worktree.rs
View file

@ -7,9 +7,9 @@ use crate::{
sum_tree::{self, Cursor, Edit, SeekBias, SumTree}, sum_tree::{self, Cursor, Edit, SeekBias, SumTree},
}; };
use ::ignore::gitignore::Gitignore; use ::ignore::gitignore::Gitignore;
use anyhow::{anyhow, Context, Result}; use anyhow::{Context, Result};
pub use fuzzy::{match_paths, PathMatch}; pub use fuzzy::{match_paths, PathMatch};
use gpui::{scoped_pool, AppContext, Entity, ModelContext, ModelHandle, Task}; use gpui::{scoped_pool, AppContext, Entity, ModelContext, ModelHandle, Task, View, ViewContext};
use lazy_static::lazy_static; use lazy_static::lazy_static;
use parking_lot::Mutex; use parking_lot::Mutex;
use postage::{ use postage::{
@ -419,14 +419,14 @@ impl FileHandle {
(self.worktree.id(), self.path()) (self.worktree.id(), self.path())
} }
pub fn observe_from_model<T: Entity>( pub fn observe_from_view<T: View>(
&self, &self,
ctx: &mut ModelContext<T>, ctx: &mut ViewContext<T>,
mut callback: impl FnMut(&mut T, FileHandle, &mut ModelContext<T>) + 'static, mut callback: impl FnMut(&mut T, FileHandle, &mut ViewContext<T>) + 'static,
) { ) {
let mut prev_state = self.state.lock().clone(); let mut prev_state = self.state.lock().clone();
let cur_state = Arc::downgrade(&self.state); let cur_state = Arc::downgrade(&self.state);
ctx.observe(&self.worktree, move |observer, worktree, ctx| { ctx.observe_model(&self.worktree, move |observer, worktree, ctx| {
if let Some(cur_state) = cur_state.upgrade() { if let Some(cur_state) = cur_state.upgrade() {
let cur_state_unlocked = cur_state.lock(); let cur_state_unlocked = cur_state.lock();
if *cur_state_unlocked != prev_state { if *cur_state_unlocked != prev_state {
@ -1126,15 +1126,14 @@ struct UpdateIgnoreStatusJob {
} }
pub trait WorktreeHandle { pub trait WorktreeHandle {
fn file(&self, path: impl AsRef<Path>, app: &AppContext) -> Result<FileHandle>; fn file(&self, path: impl AsRef<Path>, app: &AppContext) -> Option<FileHandle>;
} }
impl WorktreeHandle for ModelHandle<Worktree> { impl WorktreeHandle for ModelHandle<Worktree> {
fn file(&self, path: impl AsRef<Path>, app: &AppContext) -> Result<FileHandle> { fn file(&self, path: impl AsRef<Path>, app: &AppContext) -> Option<FileHandle> {
let tree = self.read(app); let tree = self.read(app);
let entry = tree let entry = tree.entry_for_path(&path)?;
.entry_for_path(&path)
.ok_or_else(|| anyhow!("path does not exist in tree"))?;
let path = entry.path().clone(); let path = entry.path().clone();
let mut handles = tree.handles.lock(); let mut handles = tree.handles.lock();
let state = if let Some(state) = handles.get(&path).and_then(Weak::upgrade) { let state = if let Some(state) = handles.get(&path).and_then(Weak::upgrade) {
@ -1148,7 +1147,7 @@ impl WorktreeHandle for ModelHandle<Worktree> {
state state
}; };
Ok(FileHandle { Some(FileHandle {
worktree: self.clone(), worktree: self.clone(),
state, state,
}) })
@ -1347,8 +1346,7 @@ mod tests {
app.read(|ctx| tree.read(ctx).scan_complete()).await; app.read(|ctx| tree.read(ctx).scan_complete()).await;
app.read(|ctx| assert_eq!(tree.read(ctx).file_count(), 1)); app.read(|ctx| assert_eq!(tree.read(ctx).file_count(), 1));
let buffer = let buffer = app.add_model(|_| Buffer::new(1, "a line of text.\n".repeat(10 * 1024)));
app.add_model(|ctx| Buffer::new(1, "a line of text.\n".repeat(10 * 1024), ctx));
let path = tree.update(&mut app, |tree, ctx| { let path = tree.update(&mut app, |tree, ctx| {
let path = tree.files(0).next().unwrap().path().clone(); let path = tree.files(0).next().unwrap().path().clone();