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

Remove unsafe code from App::test_async

Browse source 
I don't actually think it was correct to allow the future to borrow a mutable app reference. I went back to passing a wrapper around the refcell to async tests. They'll be a bit more annoying to write but also totally safe.
This commit is contained in:
Nathan Sobo 2021-04-10 00:05:09 -06:00
parent 448dace281
commit 97a8a8ed43
10 changed files with 317 additions and 315 deletions
Download patch file Download diff file Expand all files Collapse all files

210
gpui/src/app.rs
View file

@ -45,8 +45,8 @@ pub trait View: Entity {
}
}
pub trait ModelAsRef {
fn model<T: Entity>(&self, handle: &ModelHandle<T>) -> &T;
pub trait ReadModel {
fn read_model<T: Entity>(&self, handle: &ModelHandle<T>) -> &T;
}
pub trait UpdateModel {
@ -56,8 +56,8 @@ pub trait UpdateModel {
F: FnOnce(&mut T, &mut ModelContext<T>) -> S;
}
pub trait ViewAsRef {
fn view<T: View>(&self, handle: &ViewHandle<T>) -> &T;
pub trait ReadView {
fn read_view<T: View>(&self, handle: &ViewHandle<T>) -> &T;
}
pub trait UpdateView {
@ -84,6 +84,9 @@ pub enum MenuItem<'a> {
#[derive(Clone)]
pub struct App(Rc<RefCell<MutableAppContext>>);
#[derive(Clone)]
pub struct TestAppContext(Rc<RefCell<MutableAppContext>>);
impl App {
pub fn test<T, A: AssetSource, F: FnOnce(&mut MutableAppContext) -> T>(
asset_source: A,
@ -101,27 +104,21 @@ impl App {
f(&mut *ctx)
}
pub fn test_async<'a, T, F, A: AssetSource, Fn>(asset_source: A, f: Fn) -> T
pub fn test_async<T, F, A: AssetSource, Fn>(asset_source: A, f: Fn) -> T
where
Fn: FnOnce(&'a mut MutableAppContext) -> F,
F: Future<Output = T> + 'a,
Fn: FnOnce(TestAppContext) -> F,
F: Future<Output = T>,
{
let platform = platform::test::platform();
let foreground = Rc::new(executor::Foreground::test());
let ctx = Rc::new(RefCell::new(MutableAppContext::new(
let ctx = TestAppContext(Rc::new(RefCell::new(MutableAppContext::new(
foreground.clone(),
Rc::new(platform),
asset_source,
)));
let mut ctx_ref = ctx.borrow_mut();
ctx_ref.weak_self = Some(Rc::downgrade(&ctx));
let ctx = &mut *ctx_ref;
))));
ctx.0.borrow_mut().weak_self = Some(Rc::downgrade(&ctx.0));
// TODO - is there a better way of getting this to compile?
let ctx = unsafe { std::mem::transmute(ctx) };
let future = f(ctx);
drop(ctx_ref);
smol::block_on(foreground.run(future))
}
@ -208,42 +205,27 @@ impl App {
where
F: 'static + FnOnce(&mut MutableAppContext),
{
let platform = self.platform();
let platform = self.0.borrow().platform.clone();
platform.run(Box::new(move || {
let mut ctx = self.0.borrow_mut();
on_finish_launching(&mut *ctx);
}))
}
pub fn on_window_invalidated<F: 'static + FnMut(WindowInvalidation, &mut MutableAppContext)>(
&self,
window_id: usize,
callback: F,
) {
self.0
.borrow_mut()
.on_window_invalidated(window_id, callback);
pub fn font_cache(&self) -> Arc<FontCache> {
self.0.borrow().font_cache.clone()
}
pub fn add_action<S, V, T, F>(&self, name: S, handler: F)
where
S: Into<String>,
V: View,
T: Any,
F: 'static + FnMut(&mut V, &T, &mut ViewContext<V>),
{
self.0.borrow_mut().add_action(name, handler);
}
pub fn add_global_action<S, T, F>(&self, name: S, handler: F)
where
S: Into<String>,
T: 'static + Any,
F: 'static + FnMut(&T, &mut MutableAppContext),
{
self.0.borrow_mut().add_global_action(name, handler);
fn update<T, F: FnOnce(&mut MutableAppContext) -> T>(&mut self, callback: F) -> T {
let mut state = self.0.borrow_mut();
state.pending_flushes += 1;
let result = callback(&mut *state);
state.flush_effects();
result
}
}
impl TestAppContext {
pub fn dispatch_action<T: 'static + Any>(
&self,
window_id: usize,
@ -259,10 +241,6 @@ impl App {
);
}
pub fn add_bindings<T: IntoIterator<Item = keymap::Binding>>(&self, bindings: T) {
self.0.borrow_mut().add_bindings(bindings);
}
pub fn dispatch_keystroke(
&self,
window_id: usize,
@ -329,7 +307,7 @@ impl App {
handle
}
pub fn read<T, F: FnOnce(&AppContext) -> T>(&mut self, callback: F) -> T {
pub fn read<T, F: FnOnce(&AppContext) -> T>(&self, callback: F) -> T {
callback(self.0.borrow().downgrade())
}
@ -354,7 +332,7 @@ impl App {
}
}
impl UpdateModel for App {
impl UpdateModel for TestAppContext {
fn update_model<T, F, S>(&mut self, handle: &ModelHandle<T>, update: F) -> S
where
T: Entity,
@ -368,7 +346,7 @@ impl UpdateModel for App {
}
}
impl UpdateView for App {
impl UpdateView for TestAppContext {
fn update_view<T, F, S>(&mut self, handle: &ViewHandle<T>, update: F) -> S
where
T: View,
@ -1249,8 +1227,8 @@ impl MutableAppContext {
}
}
impl ModelAsRef for MutableAppContext {
fn model<T: Entity>(&self, handle: &ModelHandle<T>) -> &T {
impl ReadModel for MutableAppContext {
fn read_model<T: Entity>(&self, handle: &ModelHandle<T>) -> &T {
if let Some(model) = self.ctx.models.get(&handle.model_id) {
model
.as_any()
@ -1287,8 +1265,8 @@ impl UpdateModel for MutableAppContext {
}
}
impl ViewAsRef for MutableAppContext {
fn view<T: View>(&self, handle: &ViewHandle<T>) -> &T {
impl ReadView for MutableAppContext {
fn read_view<T: View>(&self, handle: &ViewHandle<T>) -> &T {
if let Some(window) = self.ctx.windows.get(&handle.window_id) {
if let Some(view) = window.views.get(&handle.view_id) {
view.as_any().downcast_ref().expect("Downcast is type safe")
@ -1387,8 +1365,8 @@ impl AppContext {
}
}
impl ModelAsRef for AppContext {
fn model<T: Entity>(&self, handle: &ModelHandle<T>) -> &T {
impl ReadModel for AppContext {
fn read_model<T: Entity>(&self, handle: &ModelHandle<T>) -> &T {
if let Some(model) = self.models.get(&handle.model_id) {
model
.as_any()
@ -1400,8 +1378,8 @@ impl ModelAsRef for AppContext {
}
}
impl ViewAsRef for AppContext {
fn view<T: View>(&self, handle: &ViewHandle<T>) -> &T {
impl ReadView for AppContext {
fn read_view<T: View>(&self, handle: &ViewHandle<T>) -> &T {
if let Some(window) = self.windows.get(&handle.window_id) {
if let Some(view) = window.views.get(&handle.view_id) {
view.as_any()
@ -1672,9 +1650,9 @@ impl<'a, T: Entity> ModelContext<'a, T> {
}
}
impl<M> ModelAsRef for ModelContext<'_, M> {
fn model<T: Entity>(&self, handle: &ModelHandle<T>) -> &T {
self.app.model(handle)
impl<M> ReadModel for ModelContext<'_, M> {
fn read_model<T: Entity>(&self, handle: &ModelHandle<T>) -> &T {
self.app.read_model(handle)
}
}
@ -1927,9 +1905,9 @@ impl<'a, T: View> ViewContext<'a, T> {
}
}
impl<V> ModelAsRef for ViewContext<'_, V> {
fn model<T: Entity>(&self, handle: &ModelHandle<T>) -> &T {
self.app.model(handle)
impl<V> ReadModel for ViewContext<'_, V> {
fn read_model<T: Entity>(&self, handle: &ModelHandle<T>) -> &T {
self.app.read_model(handle)
}
}
@ -1943,9 +1921,9 @@ impl<V: View> UpdateModel for ViewContext<'_, V> {
}
}
impl<V: View> ViewAsRef for ViewContext<'_, V> {
fn view<T: View>(&self, handle: &ViewHandle<T>) -> &T {
self.app.view(handle)
impl<V: View> ReadView for ViewContext<'_, V> {
fn read_view<T: View>(&self, handle: &ViewHandle<T>) -> &T {
self.app.read_view(handle)
}
}
@ -1994,8 +1972,8 @@ impl<T: Entity> ModelHandle<T> {
self.model_id
}
pub fn as_ref<'a, A: ModelAsRef>(&self, app: &'a A) -> &'a T {
app.model(self)
pub fn read<'a, A: ReadModel>(&self, app: &'a A) -> &'a T {
app.read_model(self)
}
pub fn update<A, F, S>(&self, app: &mut A, update: F) -> S
@ -2122,8 +2100,8 @@ impl<T: View> ViewHandle<T> {
self.view_id
}
pub fn as_ref<'a, A: ViewAsRef>(&self, app: &'a A) -> &'a T {
app.view(self)
pub fn read<'a, A: ReadView>(&self, app: &'a A) -> &'a T {
app.read_view(self)
}
pub fn update<A, F, S>(&self, app: &mut A, update: F) -> S
@ -2470,9 +2448,9 @@ mod tests {
ctx.notify();
ctx.emit(2);
});
assert_eq!(handle_1.as_ref(app).events, vec!["updated".to_string()]);
assert_eq!(handle_1.read(app).events, vec!["updated".to_string()]);
assert_eq!(
handle_2.as_ref(app).events,
handle_2.read(app).events,
vec![
"observed event 1".to_string(),
"notified".to_string(),
@ -2518,10 +2496,10 @@ mod tests {
});
handle_2.update(app, |_, c| c.emit(7));
assert_eq!(handle_1.as_ref(app).events, vec![7]);
assert_eq!(handle_1.read(app).events, vec![7]);
handle_2.update(app, |_, c| c.emit(5));
assert_eq!(handle_1.as_ref(app).events, vec![7, 10, 5]);
assert_eq!(handle_1.read(app).events, vec![7, 10, 5]);
})
}
@ -2544,9 +2522,9 @@ mod tests {
handle_1.update(app, |_, c| {
c.observe(&handle_2, move |model, observed, c| {
model.events.push(observed.as_ref(c).count);
model.events.push(observed.read(c).count);
c.observe(&handle_2b, |model, observed, c| {
model.events.push(observed.as_ref(c).count * 2);
model.events.push(observed.read(c).count * 2);
});
});
});
@ -2555,13 +2533,13 @@ mod tests {
model.count = 7;
c.notify()
});
assert_eq!(handle_1.as_ref(app).events, vec![7]);
assert_eq!(handle_1.read(app).events, vec![7]);
handle_2.update(app, |model, c| {
model.count = 5;
c.notify()
});
assert_eq!(handle_1.as_ref(app).events, vec![7, 10, 5])
assert_eq!(handle_1.read(app).events, vec![7, 10, 5])
})
}
@ -2576,25 +2554,25 @@ mod tests {
type Event = ();
}
App::test_async((), |app| async move {
App::test_async((), |mut app| async move {
let handle = app.add_model(|_| Model::default());
handle
.update(app, |_, c| {
.update(&mut app, |_, c| {
c.spawn(async { 7 }, |model, output, _| {
model.count = output;
})
})
.await;
assert_eq!(handle.as_ref(app).count, 7);
app.read(|ctx| assert_eq!(handle.read(ctx).count, 7));
handle
.update(app, |_, c| {
.update(&mut app, |_, c| {
c.spawn(async { 14 }, |model, output, _| {
model.count = output;
})
})
.await;
assert_eq!(handle.as_ref(app).count, 14);
app.read(|ctx| assert_eq!(handle.read(ctx).count, 14));
});
}
@ -2609,10 +2587,10 @@ mod tests {
type Event = ();
}
App::test_async((), |app| async move {
App::test_async((), |mut app| async move {
let handle = app.add_model(|_| Model::default());
handle
.update(app, |_, c| {
.update(&mut app, |_, c| {
c.spawn_stream(
smol::stream::iter(vec![1, 2, 3]),
|model, output, _| {
@ -2624,7 +2602,7 @@ mod tests {
)
})
.await;
assert_eq!(handle.as_ref(app).events, [Some(1), Some(2), Some(3), None])
app.read(|ctx| assert_eq!(handle.read(ctx).events, [Some(1), Some(2), Some(3), None]));
})
}
@ -2674,9 +2652,9 @@ mod tests {
ctx.emit(1);
ctx.emit(2);
});
assert_eq!(handle_1.as_ref(app).events, vec!["updated".to_string()]);
assert_eq!(handle_1.read(app).events, vec!["updated".to_string()]);
assert_eq!(
handle_2.as_ref(app).events,
handle_2.read(app).events,
vec![
"observed event 1".to_string(),
"observed event 2".to_string(),
@ -2742,13 +2720,13 @@ mod tests {
});
handle_2.update(app, |_, c| c.emit(7));
assert_eq!(handle_1.as_ref(app).events, vec![7]);
assert_eq!(handle_1.read(app).events, vec![7]);
handle_2.update(app, |_, c| c.emit(5));
assert_eq!(handle_1.as_ref(app).events, vec![7, 10, 5]);
assert_eq!(handle_1.read(app).events, vec![7, 10, 5]);
handle_3.update(app, |_, c| c.emit(9));
assert_eq!(handle_1.as_ref(app).events, vec![7, 10, 5, 9]);
assert_eq!(handle_1.read(app).events, vec![7, 10, 5, 9]);
})
}
@ -2837,7 +2815,7 @@ mod tests {
view.update(app, |_, c| {
c.observe(&model, |me, observed, c| {
me.events.push(observed.as_ref(c).count)
me.events.push(observed.read(c).count)
});
});
@ -2845,7 +2823,7 @@ mod tests {
model.count = 11;
c.notify();
});
assert_eq!(view.as_ref(app).events, vec![11]);
assert_eq!(view.read(app).events, vec![11]);
})
}
@ -2942,7 +2920,7 @@ mod tests {
});
assert_eq!(
view_1.as_ref(app).events,
view_1.read(app).events,
[
"self focused".to_string(),
"self blurred".to_string(),
@ -2975,24 +2953,24 @@ mod tests {
}
}
App::test_async((), |app| async move {
let (_, handle) = app.add_window(|_| View::default());
App::test_async((), |mut app| async move {
let handle = app.add_window(|_| View::default()).1;
handle
.update(app, |_, c| {
.update(&mut app, |_, c| {
c.spawn(async { 7 }, |me, output, _| {
me.count = output;
})
})
.await;
assert_eq!(handle.as_ref(app).count, 7);
app.read(|ctx| assert_eq!(handle.read(ctx).count, 7));
handle
.update(app, |_, c| {
.update(&mut app, |_, c| {
c.spawn(async { 14 }, |me, output, _| {
me.count = output;
})
})
.await;
assert_eq!(handle.as_ref(app).count, 14);
app.read(|ctx| assert_eq!(handle.read(ctx).count, 14));
});
}
@ -3017,10 +2995,10 @@ mod tests {
}
}
App::test_async((), |app| async move {
App::test_async((), |mut app| async move {
let (_, handle) = app.add_window(|_| View::default());
handle
.update(app, |_, c| {
.update(&mut app, |_, c| {
c.spawn_stream(
smol::stream::iter(vec![1_usize, 2, 3]),
|me, output, _| {
@ -3033,7 +3011,7 @@ mod tests {
})
.await;
assert_eq!(handle.as_ref(app).events, [Some(1), Some(2), Some(3), None])
app.read(|ctx| assert_eq!(handle.read(ctx).events, [Some(1), Some(2), Some(3), None]))
});
}
@ -3335,49 +3313,49 @@ mod tests {
type Event = ();
}
App::test_async((), |app| async move {
App::test_async((), |mut app| async move {
let model = app.add_model(|_| Model);
let (_, view) = app.add_window(|_| View);
model.update(app, |_, ctx| {
model.update(&mut app, |_, ctx| {
ctx.spawn(async {}, |_, _, _| {}).detach();
// Cancel this task
drop(ctx.spawn(async {}, |_, _, _| {}));
});
view.update(app, |_, ctx| {
view.update(&mut app, |_, ctx| {
ctx.spawn(async {}, |_, _, _| {}).detach();
// Cancel this task
drop(ctx.spawn(async {}, |_, _, _| {}));
});
assert!(!app.future_handlers.borrow().is_empty());
assert!(!app.0.borrow().future_handlers.borrow().is_empty());
app.finish_pending_tasks().await;
assert!(app.future_handlers.borrow().is_empty());
assert!(app.0.borrow().future_handlers.borrow().is_empty());
app.finish_pending_tasks().await; // Don't block if there are no tasks
model.update(app, |_, ctx| {
model.update(&mut app, |_, ctx| {
ctx.spawn_stream(smol::stream::iter(vec![1, 2, 3]), |_, _, _| {}, |_, _| {})
.detach();
// Cancel this task
drop(ctx.spawn_stream(smol::stream::iter(vec![1, 2, 3]), |_, _, _| {}, |_, _| {}));
});
view.update(app, |_, ctx| {
view.update(&mut app, |_, ctx| {
ctx.spawn_stream(smol::stream::iter(vec![1, 2, 3]), |_, _, _| {}, |_, _| {})
.detach();
// Cancel this task
drop(ctx.spawn_stream(smol::stream::iter(vec![1, 2, 3]), |_, _, _| {}, |_, _| {}));
});
assert!(!app.stream_handlers.borrow().is_empty());
assert!(!app.0.borrow().stream_handlers.borrow().is_empty());
app.finish_pending_tasks().await;
assert!(app.stream_handlers.borrow().is_empty());
assert!(app.0.borrow().stream_handlers.borrow().is_empty());
app.finish_pending_tasks().await; // Don't block if there are no tasks
// Tasks are considered finished when we drop handles
let mut tasks = Vec::new();
model.update(app, |_, ctx| {
model.update(&mut app, |_, ctx| {
tasks.push(Box::new(ctx.spawn(async {}, |_, _, _| {})));
tasks.push(Box::new(ctx.spawn_stream(
smol::stream::iter(vec![1, 2, 3]),
@ -3386,7 +3364,7 @@ mod tests {
)));
});
view.update(app, |_, ctx| {
view.update(&mut app, |_, ctx| {
tasks.push(Box::new(ctx.spawn(async {}, |_, _, _| {})));
tasks.push(Box::new(ctx.spawn_stream(
smol::stream::iter(vec![1, 2, 3]),
@ -3395,12 +3373,12 @@ mod tests {
)));
});
assert!(!app.stream_handlers.borrow().is_empty());
assert!(!app.0.borrow().stream_handlers.borrow().is_empty());
let finish_pending_tasks = app.finish_pending_tasks();
drop(tasks);
finish_pending_tasks.await;
assert!(app.stream_handlers.borrow().is_empty());
assert!(app.0.borrow().stream_handlers.borrow().is_empty());
app.finish_pending_tasks().await; // Don't block if there are no tasks
});
}

20
zed/src/editor/buffer_element.rs
View file

@ -37,7 +37,7 @@ impl BufferElement {
ctx: &mut EventContext,
) -> bool {
if paint.text_bounds.contains_point(position) {
let view = self.view.as_ref(ctx.app);
let view = self.view.read(ctx.app);
let position =
paint.point_for_position(view, layout, position, ctx.font_cache, ctx.app);
ctx.dispatch_action("buffer:select", SelectAction::Begin { position, add: cmd });
@ -48,7 +48,7 @@ impl BufferElement {
}
fn mouse_up(&self, _position: Vector2F, ctx: &mut EventContext) -> bool {
if self.view.as_ref(ctx.app).is_selecting() {
if self.view.read(ctx.app).is_selecting() {
ctx.dispatch_action("buffer:select", SelectAction::End);
true
} else {
@ -63,7 +63,7 @@ impl BufferElement {
paint: &mut PaintState,
ctx: &mut EventContext,
) -> bool {
let view = self.view.as_ref(ctx.app);
let view = self.view.read(ctx.app);
if view.is_selecting() {
let rect = paint.text_bounds;
@ -145,7 +145,7 @@ impl BufferElement {
return false;
}
let view = self.view.as_ref(ctx.app);
let view = self.view.read(ctx.app);
let font_cache = &ctx.font_cache;
let layout_cache = &ctx.text_layout_cache;
let max_glyph_width = view.em_width(font_cache);
@ -167,7 +167,7 @@ impl BufferElement {
}
fn paint_gutter(&mut self, rect: RectF, layout: &LayoutState, ctx: &mut PaintContext) {
let view = self.view.as_ref(ctx.app);
let view = self.view.read(ctx.app);
let line_height = view.line_height(ctx.font_cache);
let scroll_top = view.scroll_position().y() * line_height;
@ -197,7 +197,7 @@ impl BufferElement {
}
fn paint_text(&mut self, bounds: RectF, layout: &LayoutState, ctx: &mut PaintContext) {
let view = self.view.as_ref(ctx.app);
let view = self.view.read(ctx.app);
let line_height = view.line_height(ctx.font_cache);
let descent = view.font_descent(ctx.font_cache);
let start_row = view.scroll_position().y() as u32;
@ -313,14 +313,14 @@ impl Element for BufferElement {
let app = ctx.app;
let mut size = constraint.max;
if size.y().is_infinite() {
let view = self.view.as_ref(app);
let view = self.view.read(app);
size.set_y((view.max_point(app).row() + 1) as f32 * view.line_height(ctx.font_cache));
}
if size.x().is_infinite() {
unimplemented!("we don't yet handle an infinite width constraint on buffer elements");
}
let view = self.view.as_ref(app);
let view = self.view.read(app);
let font_cache = &ctx.font_cache;
let layout_cache = &ctx.text_layout_cache;
let line_height = view.line_height(font_cache);
@ -404,7 +404,7 @@ impl Element for BufferElement {
if let Some(layout) = layout {
let app = ctx.app.downgrade();
let view = self.view.as_ref(app);
let view = self.view.read(app);
view.clamp_scroll_left(
layout
.scroll_max(view, ctx.font_cache, ctx.text_layout_cache, app)
@ -437,7 +437,7 @@ impl Element for BufferElement {
layout.text_size,
);
if self.view.as_ref(ctx.app).is_gutter_visible() {
if self.view.read(ctx.app).is_gutter_visible() {
self.paint_gutter(gutter_bounds, layout, ctx);
}
self.paint_text(text_bounds, layout, ctx);

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

@ -125,7 +125,7 @@ impl BufferView {
});
ctx.observe(&display_map, Self::on_display_map_changed);
let buffer_ref = buffer.as_ref(ctx);
let buffer_ref = buffer.read(ctx);
Self {
handle: ctx.handle().downgrade(),
buffer,
@ -188,7 +188,7 @@ impl BufferView {
return false;
}
let map = self.display_map.as_ref(app);
let map = self.display_map.read(app);
let visible_lines = viewport_height / line_height;
let first_cursor_top = self
.selections
@ -238,7 +238,7 @@ impl BufferView {
layouts: &[Arc<text_layout::Line>],
app: &AppContext,
) {
let map = self.display_map.as_ref(app);
let map = self.display_map.read(app);
let mut target_left = std::f32::INFINITY;
let mut target_right = 0.0_f32;
@ -287,7 +287,7 @@ impl BufferView {
ctx.emit(Event::Activate);
}
let display_map = self.display_map.as_ref(ctx);
let display_map = self.display_map.read(ctx);
let cursor = display_map
.anchor_before(position, Bias::Left, ctx.app())
.unwrap();
@ -312,8 +312,8 @@ impl BufferView {
scroll_position: Vector2F,
ctx: &mut ViewContext<Self>,
) {
let buffer = self.buffer.as_ref(ctx);
let map = self.display_map.as_ref(ctx);
let buffer = self.buffer.read(ctx);
let map = self.display_map.read(ctx);
let cursor = map.anchor_before(position, Bias::Left, ctx.app()).unwrap();
if let Some(selection) = self.pending_selection.as_mut() {
selection.set_head(buffer, cursor);
@ -347,8 +347,8 @@ impl BufferView {
where
T: IntoIterator<Item = &'a Range<DisplayPoint>>,
{
let buffer = self.buffer.as_ref(ctx);
let map = self.display_map.as_ref(ctx);
let buffer = self.buffer.read(ctx);
let map = self.display_map.read(ctx);
let mut selections = Vec::new();
for range in ranges {
selections.push(Selection {
@ -366,7 +366,7 @@ impl BufferView {
}
fn insert(&mut self, text: &String, ctx: &mut ViewContext<Self>) {
let buffer = self.buffer.as_ref(ctx);
let buffer = self.buffer.read(ctx);
let mut offset_ranges = SmallVec::<[Range<usize>; 32]>::new();
for selection in &self.selections {
let start = selection.start.to_offset(buffer).unwrap();
@ -381,7 +381,7 @@ impl BufferView {
};
});
let buffer = self.buffer.as_ref(ctx);
let buffer = self.buffer.read(ctx);
let char_count = text.chars().count() as isize;
let mut delta = 0_isize;
self.selections = offset_ranges
@ -416,8 +416,8 @@ impl BufferView {
}
pub fn backspace(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
let buffer = self.buffer.as_ref(ctx);
let map = self.display_map.as_ref(ctx);
let buffer = self.buffer.read(ctx);
let map = self.display_map.read(ctx);
for selection in &mut self.selections {
if selection.range(buffer).is_empty() {
let head = selection.head().to_display_point(map, ctx.app()).unwrap();
@ -439,7 +439,7 @@ impl BufferView {
pub fn move_left(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
{
let app = ctx.app();
let map = self.display_map.as_ref(ctx);
let map = self.display_map.read(ctx);
for selection in &mut self.selections {
let start = selection.start.to_display_point(map, app).unwrap();
let end = selection.end.to_display_point(map, app).unwrap();
@ -462,8 +462,8 @@ impl BufferView {
pub fn select_left(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
{
let buffer = self.buffer.as_ref(ctx);
let map = self.display_map.as_ref(ctx);
let buffer = self.buffer.read(ctx);
let map = self.display_map.read(ctx);
for selection in &mut self.selections {
let head = selection.head().to_display_point(map, ctx.app()).unwrap();
let cursor = map
@ -483,7 +483,7 @@ impl BufferView {
pub fn move_right(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
{
let app = ctx.app();
let map = self.display_map.as_ref(app);
let map = self.display_map.read(app);
for selection in &mut self.selections {
let start = selection.start.to_display_point(map, app).unwrap();
let end = selection.end.to_display_point(map, app).unwrap();
@ -506,9 +506,9 @@ impl BufferView {
pub fn select_right(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
{
let buffer = self.buffer.as_ref(ctx);
let buffer = self.buffer.read(ctx);
let app = ctx.app();
let map = self.display_map.as_ref(app);
let map = self.display_map.read(app);
for selection in &mut self.selections {
let head = selection.head().to_display_point(map, ctx.app()).unwrap();
let cursor = map
@ -526,7 +526,7 @@ impl BufferView {
ctx.propagate_action();
} else {
let app = ctx.app();
let map = self.display_map.as_ref(app);
let map = self.display_map.read(app);
for selection in &mut self.selections {
let start = selection.start.to_display_point(map, app).unwrap();
let end = selection.end.to_display_point(map, app).unwrap();
@ -551,8 +551,8 @@ impl BufferView {
ctx.propagate_action();
} else {
let app = ctx.app();
let buffer = self.buffer.as_ref(app);
let map = self.display_map.as_ref(app);
let buffer = self.buffer.read(app);
let map = self.display_map.read(app);
for selection in &mut self.selections {
let head = selection.head().to_display_point(map, app).unwrap();
let (head, goal_column) =
@ -569,7 +569,7 @@ impl BufferView {
ctx.propagate_action();
} else {
let app = ctx.app();
let map = self.display_map.as_ref(app);
let map = self.display_map.read(app);
for selection in &mut self.selections {
let start = selection.start.to_display_point(map, app).unwrap();
let end = selection.end.to_display_point(map, app).unwrap();
@ -594,8 +594,8 @@ impl BufferView {
ctx.propagate_action();
} else {
let app = ctx.app();
let buffer = self.buffer.as_ref(ctx);
let map = self.display_map.as_ref(ctx);
let buffer = self.buffer.read(ctx);
let map = self.display_map.read(ctx);
for selection in &mut self.selections {
let head = selection.head().to_display_point(map, app).unwrap();
let (head, goal_column) =
@ -615,7 +615,7 @@ impl BufferView {
}
fn merge_selections(&mut self, ctx: &AppContext) {
let buffer = self.buffer.as_ref(ctx);
let buffer = self.buffer.read(ctx);
let mut i = 1;
while i < self.selections.len() {
if self.selections[i - 1]
@ -651,14 +651,14 @@ impl BufferView {
self.selections
.first()
.unwrap()
.display_range(self.display_map.as_ref(app), app)
.display_range(self.display_map.read(app), app)
}
pub fn last_selection(&self, app: &AppContext) -> Range<DisplayPoint> {
self.selections
.last()
.unwrap()
.display_range(self.display_map.as_ref(app), app)
.display_range(self.display_map.read(app), app)
}
pub fn selections_in_range<'a>(
@ -666,7 +666,7 @@ impl BufferView {
range: Range<DisplayPoint>,
app: &'a AppContext,
) -> impl 'a + Iterator<Item = Range<DisplayPoint>> {
let map = self.display_map.as_ref(app);
let map = self.display_map.read(app);
let start = map.anchor_before(range.start, Bias::Left, app).unwrap();
let start_index = self.selection_insertion_index(&start, app);
@ -686,7 +686,7 @@ impl BufferView {
}
fn selection_insertion_index(&self, start: &Anchor, app: &AppContext) -> usize {
let buffer = self.buffer.as_ref(app);
let buffer = self.buffer.read(app);
match self
.selections
@ -720,7 +720,7 @@ impl BufferView {
let mut fold_ranges = Vec::new();
let app = ctx.app();
let map = self.display_map.as_ref(app);
let map = self.display_map.read(app);
for selection in &self.selections {
let (start, end) = selection.display_range(map, app).sorted();
let buffer_start_row = start.to_buffer_point(map, Bias::Left, app).unwrap().row;
@ -750,8 +750,8 @@ impl BufferView {
use super::RangeExt;
let app = ctx.app();
let map = self.display_map.as_ref(app);
let buffer = self.buffer.as_ref(app);
let map = self.display_map.read(app);
let buffer = self.buffer.read(app);
let ranges = self
.selections
.iter()
@ -796,7 +796,7 @@ impl BufferView {
let mut is_blank = true;
for c in self
.display_map
.as_ref(app)
.read(app)
.chars_at(DisplayPoint::new(display_row, 0), app)?
{
if c == ' ' {
@ -810,7 +810,7 @@ impl BufferView {
}
fn foldable_range_for_line(&self, start_row: u32, app: &AppContext) -> Result<Range<Point>> {
let map = self.display_map.as_ref(app);
let map = self.display_map.read(app);
let max_point = self.max_point(app);
let (start_indent, _) = self.line_indent(start_row, app)?;
@ -831,7 +831,7 @@ impl BufferView {
pub fn fold_selected_ranges(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
self.display_map.update(ctx, |map, ctx| {
let buffer = self.buffer.as_ref(ctx);
let buffer = self.buffer.read(ctx);
let ranges = self
.selections
.iter()
@ -842,23 +842,23 @@ impl BufferView {
}
pub fn line(&self, display_row: u32, app: &AppContext) -> Result<String> {
self.display_map.as_ref(app).line(display_row, app)
self.display_map.read(app).line(display_row, app)
}
pub fn line_len(&self, display_row: u32, app: &AppContext) -> Result<u32> {
self.display_map.as_ref(app).line_len(display_row, app)
self.display_map.read(app).line_len(display_row, app)
}
pub fn rightmost_point(&self, app: &AppContext) -> DisplayPoint {
self.display_map.as_ref(app).rightmost_point()
self.display_map.read(app).rightmost_point()
}
pub fn max_point(&self, app: &AppContext) -> DisplayPoint {
self.display_map.as_ref(app).max_point(app)
self.display_map.read(app).max_point(app)
}
pub fn text(&self, app: &AppContext) -> String {
self.display_map.as_ref(app).text(app)
self.display_map.read(app).text(app)
}
pub fn font_size(&self) -> f32 {
@ -902,7 +902,7 @@ impl BufferView {
let font_size = settings.buffer_font_size;
let font_id =
font_cache.select_font(settings.buffer_font_family, &FontProperties::new())?;
let digit_count = ((self.buffer.as_ref(app).max_point().row + 1) as f32)
let digit_count = ((self.buffer.read(app).max_point().row + 1) as f32)
.log10()
.floor() as usize
+ 1;
@ -923,7 +923,7 @@ impl BufferView {
layout_cache: &TextLayoutCache,
app: &AppContext,
) -> Result<Vec<Arc<text_layout::Line>>> {
let display_map = self.display_map.as_ref(app);
let display_map = self.display_map.read(app);
let settings = smol::block_on(self.settings.read());
let font_size = settings.buffer_font_size;
@ -959,7 +959,7 @@ impl BufferView {
layout_cache: &TextLayoutCache,
app: &AppContext,
) -> Result<Vec<Arc<text_layout::Line>>> {
let display_map = self.display_map.as_ref(app);
let display_map = self.display_map.read(app);
rows.end = cmp::min(rows.end, display_map.max_point(app).row() + 1);
if rows.start >= rows.end {
@ -1149,7 +1149,7 @@ impl workspace::ItemView for BufferView {
}
fn title(&self, app: &AppContext) -> std::string::String {
if let Some(path) = self.buffer.as_ref(app).path(app) {
if let Some(path) = self.buffer.read(app).path(app) {
path.file_name()
.expect("buffer's path is always to a file")
.to_string_lossy()
@ -1160,7 +1160,7 @@ impl workspace::ItemView for BufferView {
}
fn entry_id(&self, app: &AppContext) -> Option<(usize, usize)> {
self.buffer.as_ref(app).entry_id()
self.buffer.read(app).entry_id()
}
fn clone_on_split(&self, ctx: &mut ViewContext<Self>) -> Option<Self>
@ -1177,7 +1177,7 @@ impl workspace::ItemView for BufferView {
}
fn is_dirty(&self, ctx: &AppContext) -> bool {
self.buffer.as_ref(ctx).is_dirty()
self.buffer.read(ctx).is_dirty()
}
}
@ -1255,7 +1255,7 @@ mod tests {
view.begin_selection(DisplayPoint::new(2, 2), false, ctx);
});
let view = buffer_view.as_ref(app);
let view = buffer_view.read(app);
let selections = view
.selections_in_range(
DisplayPoint::zero()..view.max_point(app.as_ref()),
@ -1271,7 +1271,7 @@ mod tests {
view.update_selection(DisplayPoint::new(3, 3), Vector2F::zero(), ctx);
});
let view = buffer_view.as_ref(app);
let view = buffer_view.read(app);
let selections = view
.selections_in_range(
DisplayPoint::zero()..view.max_point(app.as_ref()),
@ -1287,7 +1287,7 @@ mod tests {
view.update_selection(DisplayPoint::new(1, 1), Vector2F::zero(), ctx);
});
let view = buffer_view.as_ref(app);
let view = buffer_view.read(app);
let selections = view
.selections_in_range(
DisplayPoint::zero()..view.max_point(app.as_ref()),
@ -1304,7 +1304,7 @@ mod tests {
view.update_selection(DisplayPoint::new(3, 3), Vector2F::zero(), ctx);
});
let view = buffer_view.as_ref(app);
let view = buffer_view.read(app);
let selections = view
.selections_in_range(
DisplayPoint::zero()..view.max_point(app.as_ref()),
@ -1321,7 +1321,7 @@ mod tests {
view.update_selection(DisplayPoint::new(0, 0), Vector2F::zero(), ctx);
});
let view = buffer_view.as_ref(app);
let view = buffer_view.read(app);
let selections = view
.selections_in_range(
DisplayPoint::zero()..view.max_point(app.as_ref()),
@ -1340,7 +1340,7 @@ mod tests {
view.end_selection(ctx);
});
let view = buffer_view.as_ref(app);
let view = buffer_view.read(app);
let selections = view
.selections_in_range(
DisplayPoint::zero()..view.max_point(app.as_ref()),
@ -1367,7 +1367,7 @@ mod tests {
app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx));
let layouts = view
.as_ref(app)
.read(app)
.layout_line_numbers(1000.0, &font_cache, &layout_cache, app.as_ref())
.unwrap();
assert_eq!(layouts.len(), 6);
@ -1460,7 +1460,7 @@ mod tests {
);
view.unfold(&(), ctx);
assert_eq!(view.text(ctx.app()), buffer.as_ref(ctx).text());
assert_eq!(view.text(ctx.app()), buffer.read(ctx).text());
});
});
}
@ -1529,7 +1529,7 @@ mod tests {
});
assert_eq!(
buffer.as_ref(app).text(),
buffer.read(app).text(),
"oe two three\nfou five six\nseven ten\n"
);
})

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

@ -22,7 +22,7 @@ pub struct FoldMap {
impl FoldMap {
pub fn new(buffer: ModelHandle<Buffer>, app: &AppContext) -> Self {
let text_summary = buffer.as_ref(app).text_summary();
let text_summary = buffer.read(app).text_summary();
Self {
buffer,
folds: Vec::new(),
@ -72,7 +72,7 @@ impl FoldMap {
let offset = self.to_display_offset(point, app)?;
let mut cursor = self.transforms.cursor();
cursor.seek(&offset, SeekBias::Right);
let buffer = self.buffer.as_ref(app);
let buffer = self.buffer.read(app);
Ok(Chars {
cursor,
offset: offset.0,
@ -95,7 +95,7 @@ impl FoldMap {
app: &AppContext,
) -> Result<()> {
let mut edits = Vec::new();
let buffer = self.buffer.as_ref(app);
let buffer = self.buffer.read(app);
for range in ranges.into_iter() {
let start = range.start.to_offset(buffer)?;
let end = range.end.to_offset(buffer)?;
@ -124,7 +124,7 @@ impl FoldMap {
ranges: impl IntoIterator<Item = Range<T>>,
app: &AppContext,
) -> Result<()> {
let buffer = self.buffer.as_ref(app);
let buffer = self.buffer.read(app);
let mut edits = Vec::new();
for range in ranges.into_iter() {
@ -184,7 +184,7 @@ impl FoldMap {
.ok_or_else(|| anyhow!("display point {:?} is out of range", point))?;
assert!(transform.display_text.is_none());
let end_buffer_offset =
(cursor.start().buffer.lines + overshoot).to_offset(self.buffer.as_ref(app))?;
(cursor.start().buffer.lines + overshoot).to_offset(self.buffer.read(app))?;
offset += end_buffer_offset - cursor.start().buffer.chars;
}
Ok(DisplayOffset(offset))
@ -208,7 +208,7 @@ impl FoldMap {
}
pub fn apply_edits(&mut self, edits: &[Edit], app: &AppContext) -> Result<()> {
let buffer = self.buffer.as_ref(app);
let buffer = self.buffer.read(app);
let mut edits = edits.iter().cloned().peekable();
let mut new_transforms = SumTree::new();
@ -597,7 +597,7 @@ mod tests {
let mut map = FoldMap::new(buffer.clone(), app.as_ref());
{
let buffer = buffer.as_ref(app);
let buffer = buffer.read(app);
let fold_count = rng.gen_range(0..10);
let mut fold_ranges: Vec<Range<usize>> = Vec::new();
@ -632,7 +632,7 @@ mod tests {
map.apply_edits(&edits, app.as_ref()).unwrap();
let buffer = map.buffer.as_ref(app);
let buffer = map.buffer.read(app);
let mut expected_text = buffer.text();
let mut expected_buffer_rows = Vec::new();
let mut next_row = buffer.max_point().row;
@ -694,7 +694,7 @@ mod tests {
}
fn merged_fold_ranges(&self, app: &AppContext) -> Vec<Range<usize>> {
let buffer = self.buffer.as_ref(app);
let buffer = self.buffer.read(app);
let mut fold_ranges = self
.folds
.iter()

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

@ -108,7 +108,7 @@ impl DisplayMap {
app: &AppContext,
) -> Result<Anchor> {
self.buffer
.as_ref(app)
.read(app)
.anchor_before(point.to_buffer_point(self, bias, app)?)
}
@ -119,7 +119,7 @@ impl DisplayMap {
app: &AppContext,
) -> Result<Anchor> {
self.buffer
.as_ref(app)
.read(app)
.anchor_after(point.to_buffer_point(self, bias, app)?)
}
@ -206,7 +206,7 @@ impl Point {
impl Anchor {
pub fn to_display_point(&self, map: &DisplayMap, app: &AppContext) -> Result<DisplayPoint> {
self.to_point(map.buffer.as_ref(app))?
self.to_point(map.buffer.read(app))?
.to_display_point(map, app)
}
}
@ -314,7 +314,7 @@ mod tests {
})
.unwrap();
let map = map.as_ref(app);
let map = map.read(app);
assert_eq!(
map.chars_at(DisplayPoint::new(1, 0), app.as_ref())
.unwrap()
@ -368,7 +368,7 @@ mod tests {
let buffer = app.add_model(|_| Buffer::new(0, "aaa\n\t\tbbb"));
let map = app.add_model(|ctx| DisplayMap::new(buffer.clone(), 4, ctx));
assert_eq!(
map.as_ref(app).max_point(app.as_ref()),
map.read(app).max_point(app.as_ref()),
DisplayPoint::new(1, 11)
)
});

40
zed/src/file_finder.rs
View file

@ -114,7 +114,7 @@ impl FileFinder {
self.matches.len(),
move |mut range, items, app| {
let finder = handle.upgrade(app).unwrap();
let finder = finder.as_ref(app);
let finder = finder.read(app);
let start = range.start;
range.end = cmp::min(range.end, finder.matches.len());
items.extend(finder.matches[range].iter().enumerate().filter_map(
@ -287,7 +287,7 @@ impl FileFinder {
}
fn workspace_updated(&mut self, _: ModelHandle<Workspace>, ctx: &mut ViewContext<Self>) {
self.spawn_search(self.query_buffer.as_ref(ctx).text(ctx.app()), ctx);
self.spawn_search(self.query_buffer.read(ctx).text(ctx.app()), ctx);
}
fn on_query_buffer_event(
@ -299,7 +299,7 @@ impl FileFinder {
use buffer_view::Event::*;
match event {
Edited => {
let query = self.query_buffer.as_ref(ctx).text(ctx.app());
let query = self.query_buffer.read(ctx).text(ctx.app());
if query.is_empty() {
self.latest_search_id = util::post_inc(&mut self.search_count);
self.matches.clear();
@ -371,18 +371,18 @@ impl FileFinder {
fn worktree<'a>(&'a self, tree_id: usize, app: &'a AppContext) -> Option<&'a Worktree> {
self.workspace
.as_ref(app)
.read(app)
.worktrees()
.get(&tree_id)
.map(|worktree| worktree.as_ref(app))
.map(|worktree| worktree.read(app))
}
fn worktrees(&self, app: &AppContext) -> Vec<Worktree> {
self.workspace
.as_ref(app)
.read(app)
.worktrees()
.iter()
.map(|worktree| worktree.as_ref(app).clone())
.map(|worktree| worktree.read(app).clone())
.collect()
}
}
@ -400,7 +400,7 @@ mod tests {
#[test]
fn test_matching_paths() {
App::test_async((), |app| async move {
App::test_async((), |mut app| async move {
let tmp_dir = TempDir::new("example").unwrap();
fs::create_dir(tmp_dir.path().join("a")).await.unwrap();
fs::write(tmp_dir.path().join("a/banana"), "banana")
@ -409,8 +409,10 @@ mod tests {
fs::write(tmp_dir.path().join("a/bandana"), "bandana")
.await
.unwrap();
super::init(app);
editor::init(app);
app.update(|ctx| {
super::init(ctx);
editor::init(ctx);
});
let settings = settings::channel(&app.font_cache()).unwrap().1;
let workspace = app.add_model(|ctx| Workspace::new(vec![tmp_dir.path().into()], ctx));
@ -424,14 +426,16 @@ mod tests {
(),
);
let finder = workspace_view
.as_ref(app)
.modal()
.cloned()
.unwrap()
.downcast::<FileFinder>()
.unwrap();
let query_buffer = finder.as_ref(app).query_buffer.clone();
let finder = app.read(|ctx| {
workspace_view
.read(ctx)
.modal()
.cloned()
.unwrap()
.downcast::<FileFinder>()
.unwrap()
});
let query_buffer = app.read(|ctx| finder.read(ctx).query_buffer.clone());
let chain = vec![finder.id(), query_buffer.id()];
app.dispatch_action(window_id, chain.clone(), "buffer:insert", "b".to_string());

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

@ -109,9 +109,9 @@ mod tests {
.unwrap();
assert_eq!(
workspace_view_1
.as_ref(app)
.read(app)
.workspace
.as_ref(app)
.read(app)
.worktrees()
.len(),
2

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

@ -101,7 +101,7 @@ impl Workspace {
pub fn contains_path(&self, path: &Path, app: &AppContext) -> bool {
self.worktrees
.iter()
.any(|worktree| worktree.as_ref(app).contains_path(path))
.any(|worktree| worktree.read(app).contains_path(path))
}
pub fn open_paths(&mut self, paths: &[PathBuf], ctx: &mut ModelContext<Self>) {
@ -112,7 +112,7 @@ impl Workspace {
pub fn open_path<'a>(&'a mut self, path: PathBuf, ctx: &mut ModelContext<Self>) {
for tree in self.worktrees.iter() {
if tree.as_ref(ctx).contains_path(&path) {
if tree.read(ctx).contains_path(&path) {
return;
}
}
@ -200,18 +200,18 @@ impl Entity for Workspace {
#[cfg(test)]
pub trait WorkspaceHandle {
fn file_entries(&self, app: &mut MutableAppContext) -> Vec<(usize, usize)>;
fn file_entries(&self, app: &AppContext) -> Vec<(usize, usize)>;
}
#[cfg(test)]
impl WorkspaceHandle for ModelHandle<Workspace> {
fn file_entries(&self, app: &mut MutableAppContext) -> Vec<(usize, usize)> {
self.as_ref(app)
fn file_entries(&self, app: &AppContext) -> Vec<(usize, usize)> {
self.read(app)
.worktrees()
.iter()
.flat_map(|tree| {
let tree_id = tree.id();
tree.as_ref(app)
tree.read(app)
.files()
.map(move |file| (tree_id, file.entry_id))
})
@ -228,7 +228,7 @@ mod tests {
#[test]
fn test_open_entry() {
App::test_async((), |app| async move {
App::test_async((), |mut app| async move {
let dir = temp_tree(json!({
"a": {
"aa": "aa contents",
@ -240,12 +240,12 @@ mod tests {
app.finish_pending_tasks().await; // Open and populate worktree.
// Get the first file entry.
let tree = workspace.as_ref(app).worktrees.iter().next().unwrap();
let entry_id = tree.as_ref(app).files().next().unwrap().entry_id;
let tree = app.read(|ctx| workspace.read(ctx).worktrees.iter().next().unwrap().clone());
let entry_id = app.read(|ctx| tree.read(ctx).files().next().unwrap().entry_id);
let entry = (tree.id(), entry_id);
// Open the same entry twice before it finishes loading.
let (future_1, future_2) = workspace.update(app, |w, app| {
let (future_1, future_2) = workspace.update(&mut app, |w, app| {
(
w.open_entry(entry, app).unwrap(),
w.open_entry(entry, app).unwrap(),
@ -258,7 +258,7 @@ mod tests {
// Open the same entry again now that it has loaded
let handle_3 = workspace
.update(app, |w, app| w.open_entry(entry, app).unwrap())
.update(&mut app, |w, app| w.open_entry(entry, app).unwrap())
.await
.unwrap();

138
zed/src/workspace/workspace_view.rs
View file

@ -54,11 +54,11 @@ pub trait ItemViewHandle: Send + Sync {
impl<T: ItemView> ItemViewHandle for ViewHandle<T> {
fn title(&self, app: &AppContext) -> String {
self.as_ref(app).title(app)
self.read(app).title(app)
}
fn entry_id(&self, app: &AppContext) -> Option<(usize, usize)> {
self.as_ref(app).entry_id(app)
self.read(app).entry_id(app)
}
fn boxed_clone(&self) -> Box<dyn ItemViewHandle> {
@ -93,7 +93,7 @@ impl<T: ItemView> ItemViewHandle for ViewHandle<T> {
}
fn is_dirty(&self, ctx: &AppContext) -> bool {
self.as_ref(ctx).is_dirty(ctx)
self.read(ctx).is_dirty(ctx)
}
fn id(&self) -> usize {
@ -154,7 +154,7 @@ impl WorkspaceView {
}
pub fn contains_paths(&self, paths: &[PathBuf], app: &AppContext) -> bool {
self.workspace.as_ref(app).contains_paths(paths, app)
self.workspace.read(app).contains_paths(paths, app)
}
pub fn open_paths(&self, paths: &[PathBuf], app: &mut MutableAppContext) {
@ -228,8 +228,8 @@ impl WorkspaceView {
}
pub fn open_example_entry(&mut self, ctx: &mut ViewContext<Self>) {
if let Some(tree) = self.workspace.as_ref(ctx).worktrees().iter().next() {
if let Some(file) = tree.as_ref(ctx).files().next() {
if let Some(tree) = self.workspace.read(ctx).worktrees().iter().next() {
if let Some(file) = tree.read(ctx).files().next() {
info!("open_entry ({}, {})", tree.id(), file.entry_id);
self.open_entry((tree.id(), file.entry_id), ctx);
} else {
@ -322,7 +322,7 @@ impl WorkspaceView {
) -> ViewHandle<Pane> {
let new_pane = self.add_pane(ctx);
self.activate_pane(new_pane.clone(), ctx);
if let Some(item) = pane.as_ref(ctx).active_item() {
if let Some(item) = pane.read(ctx).active_item() {
if let Some(clone) = item.clone_on_split(ctx.app_mut()) {
self.add_item(clone, ctx);
}
@ -394,7 +394,7 @@ mod tests {
#[test]
fn test_open_entry() {
App::test_async((), |app| async move {
App::test_async((), |mut app| async move {
let dir = temp_tree(json!({
"a": {
"aa": "aa contents",
@ -406,70 +406,78 @@ mod tests {
let settings = settings::channel(&app.font_cache()).unwrap().1;
let workspace = app.add_model(|ctx| Workspace::new(vec![dir.path().into()], ctx));
app.finish_pending_tasks().await; // Open and populate worktree.
let entries = workspace.file_entries(app);
let entries = app.read(|ctx| workspace.file_entries(ctx));
let (_, workspace_view) =
app.add_window(|ctx| WorkspaceView::new(workspace.clone(), settings, ctx));
// Open the first entry
workspace_view.update(app, |w, ctx| w.open_entry(entries[0], ctx));
workspace_view.update(&mut app, |w, ctx| w.open_entry(entries[0], ctx));
app.finish_pending_tasks().await;
assert_eq!(
workspace_view
.as_ref(app)
.active_pane()
.as_ref(app)
.items()
.len(),
1
);
app.read(|ctx| {
assert_eq!(
workspace_view
.read(ctx)
.active_pane()
.read(ctx)
.items()
.len(),
1
)
});
// Open the second entry
workspace_view.update(app, |w, ctx| w.open_entry(entries[1], ctx));
workspace_view.update(&mut app, |w, ctx| w.open_entry(entries[1], ctx));
app.finish_pending_tasks().await;
let active_pane = workspace_view.as_ref(app).active_pane().as_ref(app);
assert_eq!(active_pane.items().len(), 2);
assert_eq!(
active_pane.active_item().unwrap().entry_id(app.as_ref()),
Some(entries[1])
);
app.read(|ctx| {
let active_pane = workspace_view.read(ctx).active_pane().read(ctx);
assert_eq!(active_pane.items().len(), 2);
assert_eq!(
active_pane.active_item().unwrap().entry_id(ctx),
Some(entries[1])
);
});
// Open the first entry again
workspace_view.update(app, |w, ctx| w.open_entry(entries[0], ctx));
workspace_view.update(&mut app, |w, ctx| w.open_entry(entries[0], ctx));
app.finish_pending_tasks().await;
let active_pane = workspace_view.as_ref(app).active_pane().as_ref(app);
assert_eq!(active_pane.items().len(), 2);
assert_eq!(
active_pane.active_item().unwrap().entry_id(app.as_ref()),
Some(entries[0])
);
app.read(|ctx| {
let active_pane = workspace_view.read(ctx).active_pane().read(ctx);
assert_eq!(active_pane.items().len(), 2);
assert_eq!(
active_pane.active_item().unwrap().entry_id(ctx),
Some(entries[0])
);
});
// Open the third entry twice concurrently
workspace_view.update(app, |w, ctx| {
workspace_view.update(&mut app, |w, ctx| {
w.open_entry(entries[2], ctx);
w.open_entry(entries[2], ctx);
});
app.finish_pending_tasks().await;
assert_eq!(
workspace_view
.as_ref(app)
.active_pane()
.as_ref(app)
.items()
.len(),
3
);
app.read(|ctx| {
assert_eq!(
workspace_view
.read(ctx)
.active_pane()
.read(ctx)
.items()
.len(),
3
);
});
});
}
#[test]
fn test_pane_actions() {
App::test_async((), |app| async move {
pane::init(app);
App::test_async((), |mut app| async move {
app.update(|ctx| pane::init(ctx));
let dir = temp_tree(json!({
"a": {
@ -479,37 +487,41 @@ 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));
app.finish_pending_tasks().await; // Open and populate worktree.
let entries = workspace.file_entries(app);
let entries = app.read(|ctx| workspace.file_entries(ctx));
let (window_id, workspace_view) =
app.add_window(|ctx| WorkspaceView::new(workspace.clone(), settings, ctx));
workspace_view.update(app, |w, ctx| w.open_entry(entries[0], ctx));
workspace_view.update(&mut app, |w, ctx| w.open_entry(entries[0], ctx));
app.finish_pending_tasks().await;
let pane_1 = workspace_view.as_ref(app).active_pane().clone();
let pane_1 = app.read(|ctx| workspace_view.read(ctx).active_pane().clone());
app.dispatch_action(window_id, vec![pane_1.id()], "pane:split_right", ());
let pane_2 = workspace_view.as_ref(app).active_pane().clone();
assert_ne!(pane_1, pane_2);
app.update(|ctx| {
let pane_2 = workspace_view.read(ctx).active_pane().clone();
assert_ne!(pane_1, pane_2);
assert_eq!(
pane_2
.as_ref(app)
.active_item()
.unwrap()
.entry_id(app.downgrade()),
Some(entries[0])
);
assert_eq!(
pane_2
.read(ctx)
.active_item()
.unwrap()
.entry_id(ctx.as_ref()),
Some(entries[0])
);
app.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 w = workspace_view.as_ref(app);
assert_eq!(w.panes.len(), 1);
assert_eq!(w.active_pane(), &pane_1);
app.read(|ctx| {
let w = workspace_view.read(ctx);
assert_eq!(w.panes.len(), 1);
assert_eq!(w.active_pane(), &pane_1);
})
});
}
}

60
zed/src/worktree/worktree.rs
View file

@ -409,7 +409,7 @@ pub trait WorktreeHandle {
impl WorktreeHandle for ModelHandle<Worktree> {
fn file(&self, entry_id: usize, app: &AppContext) -> Result<FileHandle> {
if entry_id >= self.as_ref(app).entry_count() {
if entry_id >= self.read(app).entry_count() {
return Err(anyhow!("Entry does not exist in tree"));
}
@ -461,15 +461,15 @@ pub struct FileHandle {
impl FileHandle {
pub fn path(&self, app: &AppContext) -> PathBuf {
self.worktree.as_ref(app).entry_path(self.entry_id).unwrap()
self.worktree.read(app).entry_path(self.entry_id).unwrap()
}
pub fn load_history(&self, app: &AppContext) -> impl Future<Output = Result<History>> {
self.worktree.as_ref(app).load_history(self.entry_id)
self.worktree.read(app).load_history(self.entry_id)
}
pub fn save<'a>(&self, content: Snapshot, ctx: &AppContext) -> Task<Result<()>> {
let worktree = self.worktree.as_ref(ctx);
let worktree = self.worktree.read(ctx);
worktree.save(self.entry_id, content, ctx)
}
@ -649,7 +649,7 @@ mod test {
#[test]
fn test_populate_and_search() {
App::test_async((), |app| async move {
App::test_async((), |mut app| async move {
let dir = temp_tree(json!({
"root": {
"apple": "",
@ -671,26 +671,28 @@ mod test {
let tree = app.add_model(|ctx| Worktree::new(1, root_link_path, Some(ctx)));
app.finish_pending_tasks().await;
let tree = tree.as_ref(app);
assert_eq!(tree.file_count(), 4);
let results = match_paths(&[tree.clone()], "bna", false, false, 10)
.iter()
.map(|result| tree.entry_path(result.entry_id))
.collect::<Result<Vec<PathBuf>, _>>()
.unwrap();
assert_eq!(
results,
vec![
PathBuf::from("root_link/banana/carrot/date"),
PathBuf::from("root_link/banana/carrot/endive"),
]
);
app.read(|ctx| {
let tree = tree.read(ctx);
assert_eq!(tree.file_count(), 4);
let results = match_paths(&[tree.clone()], "bna", false, false, 10)
.iter()
.map(|result| tree.entry_path(result.entry_id))
.collect::<Result<Vec<PathBuf>, _>>()
.unwrap();
assert_eq!(
results,
vec![
PathBuf::from("root_link/banana/carrot/date"),
PathBuf::from("root_link/banana/carrot/endive"),
]
);
})
});
}
#[test]
fn test_save_file() {
App::test_async((), |app| async move {
App::test_async((), |mut app| async move {
let dir = temp_tree(json!({
"file1": "the old contents",
}));
@ -698,17 +700,23 @@ mod test {
let tree = app.add_model(|ctx| Worktree::new(1, dir.path(), Some(ctx)));
app.finish_pending_tasks().await;
let entry = tree.as_ref(app).files().next().unwrap();
assert_eq!(entry.path.file_name().unwrap(), "file1");
let file_id = entry.entry_id;
let buffer = Buffer::new(1, "a line of text.\n".repeat(10 * 1024));
tree.update(app, |tree, ctx| {
let entry = app.read(|ctx| {
let entry = tree.read(ctx).files().next().unwrap();
assert_eq!(entry.path.file_name().unwrap(), "file1");
entry
});
let file_id = entry.entry_id;
tree.update(&mut app, |tree, ctx| {
smol::block_on(tree.save(file_id, buffer.snapshot(), ctx.app())).unwrap()
});
let history = tree.as_ref(app).load_history(file_id).await.unwrap();
let history = app
.read(|ctx| tree.read(ctx).load_history(file_id))
.await
.unwrap();
assert_eq!(history.base_text, buffer.text());
});
}