Max Brunsfeld created
Introduce a `gpui::test` macro for less ceremony when writing testsCargo.lock | 9
Cargo.toml | 2
gpui/Cargo.toml | 1
gpui/src/app.rs | 788 ++++-----
gpui/src/lib.rs | 1
gpui_macros/Cargo.toml | 11
gpui_macros/src/lib.rs | 57
zed/src/editor/buffer/mod.rs | 979 +++++------
zed/src/editor/buffer_view.rs | 2305 +++++++++++++--------------
zed/src/editor/display_map/fold_map.rs | 639 +++---
zed/src/editor/display_map/mod.rs | 101
zed/src/file_finder.rs | 382 ++--
zed/src/workspace.rs | 705 ++++----
zed/src/worktree.rs | 410 ++--
14 files changed, 3,137 insertions(+), 3,253 deletions(-)
@@ -1180,6 +1180,7 @@ dependencies = [
"etagere",
"font-kit",
"foreign-types",
+ "gpui_macros",
"log",
"metal",
"num_cpus",
@@ -1205,6 +1206,14 @@ dependencies = [
"usvg",
]
+[[package]]
+name = "gpui_macros"
+version = "0.1.0"
+dependencies = [
+ "quote",
+ "syn",
+]
+
[[package]]
name = "hashbrown"
version = "0.9.1"
@@ -1,5 +1,5 @@
[workspace]
-members = ["zed", "gpui", "fsevent", "scoped_pool"]
+members = ["zed", "gpui", "gpui_macros", "fsevent", "scoped_pool"]
[patch.crates-io]
async-task = {git = "https://github.com/zed-industries/async-task", rev = "341b57d6de98cdfd7b418567b8de2022ca993a6e"}
@@ -8,6 +8,7 @@ version = "0.1.0"
async-task = "4.0.3"
ctor = "0.1"
etagere = "0.2"
+gpui_macros = {path = "../gpui_macros"}
log = "0.4"
num_cpus = "1.13"
ordered-float = "2.1.1"
@@ -2797,8 +2797,8 @@ mod tests {
use crate::elements::*;
use smol::future::poll_once;
- #[test]
- fn test_model_handles() {
+ #[crate::test(self)]
+ fn test_model_handles(app: &mut MutableAppContext) {
struct Model {
other: Option<ModelHandle<Model>>,
events: Vec<String>,
@@ -2826,40 +2826,38 @@ mod tests {
}
}
- App::test((), |app| {
- let handle_1 = app.add_model(|ctx| Model::new(None, ctx));
- let handle_2 = app.add_model(|ctx| Model::new(Some(handle_1.clone()), ctx));
- assert_eq!(app.ctx.models.len(), 2);
+ let handle_1 = app.add_model(|ctx| Model::new(None, ctx));
+ let handle_2 = app.add_model(|ctx| Model::new(Some(handle_1.clone()), ctx));
+ assert_eq!(app.ctx.models.len(), 2);
- handle_1.update(app, |model, ctx| {
- model.events.push("updated".into());
- ctx.emit(1);
- ctx.notify();
- ctx.emit(2);
- });
- assert_eq!(handle_1.read(app).events, vec!["updated".to_string()]);
- assert_eq!(
- handle_2.read(app).events,
- vec![
- "observed event 1".to_string(),
- "notified".to_string(),
- "observed event 2".to_string(),
- ]
- );
-
- handle_2.update(app, |model, _| {
- drop(handle_1);
- model.other.take();
- });
+ handle_1.update(app, |model, ctx| {
+ model.events.push("updated".into());
+ ctx.emit(1);
+ ctx.notify();
+ ctx.emit(2);
+ });
+ assert_eq!(handle_1.read(app).events, vec!["updated".to_string()]);
+ assert_eq!(
+ handle_2.read(app).events,
+ vec![
+ "observed event 1".to_string(),
+ "notified".to_string(),
+ "observed event 2".to_string(),
+ ]
+ );
- assert_eq!(app.ctx.models.len(), 1);
- assert!(app.subscriptions.is_empty());
- assert!(app.model_observations.is_empty());
+ handle_2.update(app, |model, _| {
+ drop(handle_1);
+ model.other.take();
});
+
+ assert_eq!(app.ctx.models.len(), 1);
+ assert!(app.subscriptions.is_empty());
+ assert!(app.model_observations.is_empty());
}
- #[test]
- fn test_subscribe_and_emit_from_model() {
+ #[crate::test(self)]
+ fn test_subscribe_and_emit_from_model(app: &mut MutableAppContext) {
#[derive(Default)]
struct Model {
events: Vec<usize>,
@@ -2869,31 +2867,29 @@ mod tests {
type Event = usize;
}
- App::test((), |app| {
- let handle_1 = app.add_model(|_| Model::default());
- let handle_2 = app.add_model(|_| Model::default());
- let handle_2b = handle_2.clone();
+ let handle_1 = app.add_model(|_| Model::default());
+ let handle_2 = app.add_model(|_| Model::default());
+ let handle_2b = handle_2.clone();
- handle_1.update(app, |_, c| {
- c.subscribe(&handle_2, move |model: &mut Model, event, c| {
- model.events.push(*event);
+ handle_1.update(app, |_, c| {
+ c.subscribe(&handle_2, move |model: &mut Model, event, c| {
+ model.events.push(*event);
- c.subscribe(&handle_2b, |model, event, _| {
- model.events.push(*event * 2);
- });
+ c.subscribe(&handle_2b, |model, event, _| {
+ model.events.push(*event * 2);
});
});
+ });
- handle_2.update(app, |_, c| c.emit(7));
- assert_eq!(handle_1.read(app).events, vec![7]);
+ handle_2.update(app, |_, c| c.emit(7));
+ assert_eq!(handle_1.read(app).events, vec![7]);
- handle_2.update(app, |_, c| c.emit(5));
- assert_eq!(handle_1.read(app).events, vec![7, 10, 5]);
- })
+ handle_2.update(app, |_, c| c.emit(5));
+ assert_eq!(handle_1.read(app).events, vec![7, 10, 5]);
}
- #[test]
- fn test_observe_and_notify_from_model() {
+ #[crate::test(self)]
+ fn test_observe_and_notify_from_model(app: &mut MutableAppContext) {
#[derive(Default)]
struct Model {
count: usize,
@@ -2904,36 +2900,34 @@ mod tests {
type Event = ();
}
- App::test((), |app| {
- let handle_1 = app.add_model(|_| Model::default());
- let handle_2 = app.add_model(|_| Model::default());
- let handle_2b = handle_2.clone();
+ let handle_1 = app.add_model(|_| Model::default());
+ let handle_2 = app.add_model(|_| Model::default());
+ let handle_2b = handle_2.clone();
- handle_1.update(app, |_, c| {
- c.observe(&handle_2, move |model, observed, c| {
- model.events.push(observed.read(c).count);
- c.observe(&handle_2b, |model, observed, c| {
- model.events.push(observed.read(c).count * 2);
- });
+ handle_1.update(app, |_, c| {
+ c.observe(&handle_2, move |model, observed, c| {
+ model.events.push(observed.read(c).count);
+ c.observe(&handle_2b, |model, observed, c| {
+ model.events.push(observed.read(c).count * 2);
});
});
+ });
- handle_2.update(app, |model, c| {
- model.count = 7;
- c.notify()
- });
- assert_eq!(handle_1.read(app).events, vec![7]);
+ handle_2.update(app, |model, c| {
+ model.count = 7;
+ c.notify()
+ });
+ assert_eq!(handle_1.read(app).events, vec![7]);
- handle_2.update(app, |model, c| {
- model.count = 5;
- c.notify()
- });
- assert_eq!(handle_1.read(app).events, vec![7, 10, 5])
- })
+ handle_2.update(app, |model, c| {
+ model.count = 5;
+ c.notify()
+ });
+ assert_eq!(handle_1.read(app).events, vec![7, 10, 5])
}
- #[test]
- fn test_spawn_from_model() {
+ #[crate::test(self)]
+ async fn test_spawn_from_model(mut app: TestAppContext) {
#[derive(Default)]
struct Model {
count: usize,
@@ -2943,30 +2937,28 @@ mod tests {
type Event = ();
}
- App::test_async((), |mut app| async move {
- let handle = app.add_model(|_| Model::default());
- handle
- .update(&mut app, |_, c| {
- c.spawn(async { 7 }, |model, output, _| {
- model.count = output;
- })
+ let handle = app.add_model(|_| Model::default());
+ handle
+ .update(&mut app, |_, c| {
+ c.spawn(async { 7 }, |model, output, _| {
+ model.count = output;
})
- .await;
- app.read(|ctx| assert_eq!(handle.read(ctx).count, 7));
+ })
+ .await;
+ app.read(|ctx| assert_eq!(handle.read(ctx).count, 7));
- handle
- .update(&mut app, |_, c| {
- c.spawn(async { 14 }, |model, output, _| {
- model.count = output;
- })
+ handle
+ .update(&mut app, |_, c| {
+ c.spawn(async { 14 }, |model, output, _| {
+ model.count = output;
})
- .await;
- app.read(|ctx| assert_eq!(handle.read(ctx).count, 14));
- });
+ })
+ .await;
+ app.read(|ctx| assert_eq!(handle.read(ctx).count, 14));
}
- #[test]
- fn test_spawn_stream_local_from_model() {
+ #[crate::test(self)]
+ async fn test_spawn_stream_local_from_model(mut app: TestAppContext) {
#[derive(Default)]
struct Model {
events: Vec<Option<usize>>,
@@ -2976,27 +2968,21 @@ mod tests {
type Event = ();
}
- App::test_async((), |mut app| async move {
- let handle = app.add_model(|_| Model::default());
- handle
- .update(&mut app, |_, c| {
- c.spawn_stream(
- smol::stream::iter(vec![1, 2, 3]),
- |model, output, _| {
- model.events.push(Some(output));
- },
- |model, _| {
- model.events.push(None);
- },
- )
- })
- .await;
- app.read(|ctx| assert_eq!(handle.read(ctx).events, [Some(1), Some(2), Some(3), None]));
- })
+ let handle = app.add_model(|_| Model::default());
+ handle
+ .update(&mut app, |_, c| {
+ c.spawn_stream(
+ smol::stream::iter(vec![1, 2, 3]),
+ |model, output, _| model.events.push(Some(output)),
+ |model, _| model.events.push(None),
+ )
+ })
+ .await;
+ app.read(|ctx| assert_eq!(handle.read(ctx).events, [Some(1), Some(2), Some(3), None]));
}
- #[test]
- fn test_view_handles() {
+ #[crate::test(self)]
+ fn test_view_handles(app: &mut MutableAppContext) {
struct View {
other: Option<ViewHandle<View>>,
events: Vec<String>,
@@ -3030,39 +3016,37 @@ mod tests {
}
}
- App::test((), |app| {
- let (window_id, _) = app.add_window(|ctx| View::new(None, ctx));
- let handle_1 = app.add_view(window_id, |ctx| View::new(None, ctx));
- let handle_2 = app.add_view(window_id, |ctx| View::new(Some(handle_1.clone()), ctx));
- assert_eq!(app.ctx.views.len(), 3);
+ let (window_id, _) = app.add_window(|ctx| View::new(None, ctx));
+ let handle_1 = app.add_view(window_id, |ctx| View::new(None, ctx));
+ let handle_2 = app.add_view(window_id, |ctx| View::new(Some(handle_1.clone()), ctx));
+ assert_eq!(app.ctx.views.len(), 3);
- handle_1.update(app, |view, ctx| {
- view.events.push("updated".into());
- ctx.emit(1);
- ctx.emit(2);
- });
- assert_eq!(handle_1.read(app).events, vec!["updated".to_string()]);
- assert_eq!(
- handle_2.read(app).events,
- vec![
- "observed event 1".to_string(),
- "observed event 2".to_string(),
- ]
- );
+ handle_1.update(app, |view, ctx| {
+ view.events.push("updated".into());
+ ctx.emit(1);
+ ctx.emit(2);
+ });
+ assert_eq!(handle_1.read(app).events, vec!["updated".to_string()]);
+ assert_eq!(
+ handle_2.read(app).events,
+ vec![
+ "observed event 1".to_string(),
+ "observed event 2".to_string(),
+ ]
+ );
- handle_2.update(app, |view, _| {
- drop(handle_1);
- view.other.take();
- });
+ handle_2.update(app, |view, _| {
+ drop(handle_1);
+ view.other.take();
+ });
- assert_eq!(app.ctx.views.len(), 2);
- assert!(app.subscriptions.is_empty());
- assert!(app.model_observations.is_empty());
- })
+ assert_eq!(app.ctx.views.len(), 2);
+ assert!(app.subscriptions.is_empty());
+ assert!(app.model_observations.is_empty());
}
- #[test]
- fn test_subscribe_and_emit_from_view() {
+ #[crate::test(self)]
+ fn test_subscribe_and_emit_from_view(app: &mut MutableAppContext) {
#[derive(Default)]
struct View {
events: Vec<usize>,
@@ -3088,39 +3072,37 @@ mod tests {
type Event = usize;
}
- App::test((), |app| {
- let (window_id, handle_1) = app.add_window(|_| View::default());
- let handle_2 = app.add_view(window_id, |_| View::default());
- let handle_2b = handle_2.clone();
- let handle_3 = app.add_model(|_| Model);
+ let (window_id, handle_1) = app.add_window(|_| View::default());
+ let handle_2 = app.add_view(window_id, |_| View::default());
+ let handle_2b = handle_2.clone();
+ let handle_3 = app.add_model(|_| Model);
- handle_1.update(app, |_, c| {
- c.subscribe_to_view(&handle_2, move |me, _, event, c| {
- me.events.push(*event);
+ handle_1.update(app, |_, c| {
+ c.subscribe_to_view(&handle_2, move |me, _, event, c| {
+ me.events.push(*event);
- c.subscribe_to_view(&handle_2b, |me, _, event, _| {
- me.events.push(*event * 2);
- });
+ c.subscribe_to_view(&handle_2b, |me, _, event, _| {
+ me.events.push(*event * 2);
});
-
- c.subscribe_to_model(&handle_3, |me, _, event, _| {
- me.events.push(*event);
- })
});
- handle_2.update(app, |_, c| c.emit(7));
- assert_eq!(handle_1.read(app).events, vec![7]);
+ c.subscribe_to_model(&handle_3, |me, _, event, _| {
+ me.events.push(*event);
+ })
+ });
- handle_2.update(app, |_, c| c.emit(5));
- assert_eq!(handle_1.read(app).events, vec![7, 10, 5]);
+ handle_2.update(app, |_, c| c.emit(7));
+ assert_eq!(handle_1.read(app).events, vec![7]);
- handle_3.update(app, |_, c| c.emit(9));
- assert_eq!(handle_1.read(app).events, vec![7, 10, 5, 9]);
- })
+ handle_2.update(app, |_, c| c.emit(5));
+ assert_eq!(handle_1.read(app).events, vec![7, 10, 5]);
+
+ handle_3.update(app, |_, c| c.emit(9));
+ assert_eq!(handle_1.read(app).events, vec![7, 10, 5, 9]);
}
- #[test]
- fn test_dropping_subscribers() {
+ #[crate::test(self)]
+ fn test_dropping_subscribers(app: &mut MutableAppContext) {
struct View;
impl Entity for View {
@@ -3143,33 +3125,31 @@ mod tests {
type Event = ();
}
- App::test((), |app| {
- let (window_id, _) = app.add_window(|_| View);
- let observing_view = app.add_view(window_id, |_| View);
- let emitting_view = app.add_view(window_id, |_| View);
- let observing_model = app.add_model(|_| Model);
- let observed_model = app.add_model(|_| Model);
+ let (window_id, _) = app.add_window(|_| View);
+ let observing_view = app.add_view(window_id, |_| View);
+ let emitting_view = app.add_view(window_id, |_| View);
+ let observing_model = app.add_model(|_| Model);
+ let observed_model = app.add_model(|_| Model);
- observing_view.update(app, |_, ctx| {
- ctx.subscribe_to_view(&emitting_view, |_, _, _, _| {});
- ctx.subscribe_to_model(&observed_model, |_, _, _, _| {});
- });
- observing_model.update(app, |_, ctx| {
- ctx.subscribe(&observed_model, |_, _, _| {});
- });
+ observing_view.update(app, |_, ctx| {
+ ctx.subscribe_to_view(&emitting_view, |_, _, _, _| {});
+ ctx.subscribe_to_model(&observed_model, |_, _, _, _| {});
+ });
+ observing_model.update(app, |_, ctx| {
+ ctx.subscribe(&observed_model, |_, _, _| {});
+ });
- app.update(|| {
- drop(observing_view);
- drop(observing_model);
- });
+ app.update(|| {
+ drop(observing_view);
+ drop(observing_model);
+ });
- emitting_view.update(app, |_, ctx| ctx.emit(()));
- observed_model.update(app, |_, ctx| ctx.emit(()));
- })
+ emitting_view.update(app, |_, ctx| ctx.emit(()));
+ observed_model.update(app, |_, ctx| ctx.emit(()));
}
- #[test]
- fn test_observe_and_notify_from_view() {
+ #[crate::test(self)]
+ fn test_observe_and_notify_from_view(app: &mut MutableAppContext) {
#[derive(Default)]
struct View {
events: Vec<usize>,
@@ -3198,26 +3178,24 @@ mod tests {
type Event = ();
}
- App::test((), |app| {
- let (_, view) = app.add_window(|_| View::default());
- let model = app.add_model(|_| Model::default());
+ let (_, view) = app.add_window(|_| View::default());
+ let model = app.add_model(|_| Model::default());
- view.update(app, |_, c| {
- c.observe_model(&model, |me, observed, c| {
- me.events.push(observed.read(c).count)
- });
+ view.update(app, |_, c| {
+ c.observe_model(&model, |me, observed, c| {
+ me.events.push(observed.read(c).count)
});
+ });
- model.update(app, |model, c| {
- model.count = 11;
- c.notify();
- });
- assert_eq!(view.read(app).events, vec![11]);
- })
+ model.update(app, |model, c| {
+ model.count = 11;
+ c.notify();
+ });
+ assert_eq!(view.read(app).events, vec![11]);
}
- #[test]
- fn test_dropping_observers() {
+ #[crate::test(self)]
+ fn test_dropping_observers(app: &mut MutableAppContext) {
struct View;
impl Entity for View {
@@ -3240,30 +3218,28 @@ mod tests {
type Event = ();
}
- App::test((), |app| {
- let (window_id, _) = app.add_window(|_| View);
- let observing_view = app.add_view(window_id, |_| View);
- let observing_model = app.add_model(|_| Model);
- let observed_model = app.add_model(|_| Model);
+ let (window_id, _) = app.add_window(|_| View);
+ let observing_view = app.add_view(window_id, |_| View);
+ let observing_model = app.add_model(|_| Model);
+ let observed_model = app.add_model(|_| Model);
- observing_view.update(app, |_, ctx| {
- ctx.observe_model(&observed_model, |_, _, _| {});
- });
- observing_model.update(app, |_, ctx| {
- ctx.observe(&observed_model, |_, _, _| {});
- });
+ observing_view.update(app, |_, ctx| {
+ ctx.observe_model(&observed_model, |_, _, _| {});
+ });
+ observing_model.update(app, |_, ctx| {
+ ctx.observe(&observed_model, |_, _, _| {});
+ });
- app.update(|| {
- drop(observing_view);
- drop(observing_model);
- });
+ app.update(|| {
+ drop(observing_view);
+ drop(observing_model);
+ });
- observed_model.update(app, |_, ctx| ctx.notify());
- })
+ observed_model.update(app, |_, ctx| ctx.notify());
}
- #[test]
- fn test_focus() {
+ #[crate::test(self)]
+ fn test_focus(app: &mut MutableAppContext) {
struct View {
name: String,
events: Arc<Mutex<Vec<String>>>,
@@ -3291,40 +3267,38 @@ mod tests {
}
}
- App::test((), |app| {
- let events: Arc<Mutex<Vec<String>>> = Default::default();
- let (window_id, view_1) = app.add_window(|_| View {
- events: events.clone(),
- name: "view 1".to_string(),
- });
- let view_2 = app.add_view(window_id, |_| View {
- events: events.clone(),
- name: "view 2".to_string(),
- });
+ let events: Arc<Mutex<Vec<String>>> = Default::default();
+ let (window_id, view_1) = app.add_window(|_| View {
+ events: events.clone(),
+ name: "view 1".to_string(),
+ });
+ let view_2 = app.add_view(window_id, |_| View {
+ events: events.clone(),
+ name: "view 2".to_string(),
+ });
- view_1.update(app, |_, ctx| ctx.focus(&view_2));
- view_1.update(app, |_, ctx| ctx.focus(&view_1));
- view_1.update(app, |_, ctx| ctx.focus(&view_2));
- view_1.update(app, |_, _| drop(view_2));
-
- assert_eq!(
- *events.lock(),
- [
- "view 1 focused".to_string(),
- "view 1 blurred".to_string(),
- "view 2 focused".to_string(),
- "view 2 blurred".to_string(),
- "view 1 focused".to_string(),
- "view 1 blurred".to_string(),
- "view 2 focused".to_string(),
- "view 1 focused".to_string(),
- ],
- );
- })
+ view_1.update(app, |_, ctx| ctx.focus(&view_2));
+ view_1.update(app, |_, ctx| ctx.focus(&view_1));
+ view_1.update(app, |_, ctx| ctx.focus(&view_2));
+ view_1.update(app, |_, _| drop(view_2));
+
+ assert_eq!(
+ *events.lock(),
+ [
+ "view 1 focused".to_string(),
+ "view 1 blurred".to_string(),
+ "view 2 focused".to_string(),
+ "view 2 blurred".to_string(),
+ "view 1 focused".to_string(),
+ "view 1 blurred".to_string(),
+ "view 2 focused".to_string(),
+ "view 1 focused".to_string(),
+ ],
+ );
}
- #[test]
- fn test_spawn_from_view() {
+ #[crate::test(self)]
+ async fn test_spawn_from_view(mut app: TestAppContext) {
#[derive(Default)]
struct View {
count: usize,
@@ -3344,29 +3318,27 @@ mod tests {
}
}
- App::test_async((), |mut app| async move {
- let handle = app.add_window(|_| View::default()).1;
- handle
- .update(&mut app, |_, c| {
- c.spawn(async { 7 }, |me, output, _| {
- me.count = output;
- })
+ let handle = app.add_window(|_| View::default()).1;
+ handle
+ .update(&mut app, |_, c| {
+ c.spawn(async { 7 }, |me, output, _| {
+ me.count = output;
})
- .await;
- app.read(|ctx| assert_eq!(handle.read(ctx).count, 7));
- handle
- .update(&mut app, |_, c| {
- c.spawn(async { 14 }, |me, output, _| {
- me.count = output;
- })
+ })
+ .await;
+ app.read(|ctx| assert_eq!(handle.read(ctx).count, 7));
+ handle
+ .update(&mut app, |_, c| {
+ c.spawn(async { 14 }, |me, output, _| {
+ me.count = output;
})
- .await;
- app.read(|ctx| assert_eq!(handle.read(ctx).count, 14));
- });
+ })
+ .await;
+ app.read(|ctx| assert_eq!(handle.read(ctx).count, 14));
}
- #[test]
- fn test_spawn_stream_local_from_view() {
+ #[crate::test(self)]
+ async fn test_spawn_stream_local_from_view(mut app: TestAppContext) {
#[derive(Default)]
struct View {
events: Vec<Option<usize>>,
@@ -3386,28 +3358,26 @@ mod tests {
}
}
- App::test_async((), |mut app| async move {
- let (_, handle) = app.add_window(|_| View::default());
- handle
- .update(&mut app, |_, c| {
- c.spawn_stream(
- smol::stream::iter(vec![1_usize, 2, 3]),
- |me, output, _| {
- me.events.push(Some(output));
- },
- |me, _| {
- me.events.push(None);
- },
- )
- })
- .await;
+ let (_, handle) = app.add_window(|_| View::default());
+ handle
+ .update(&mut app, |_, c| {
+ c.spawn_stream(
+ smol::stream::iter(vec![1_usize, 2, 3]),
+ |me, output, _| {
+ me.events.push(Some(output));
+ },
+ |me, _| {
+ me.events.push(None);
+ },
+ )
+ })
+ .await;
- app.read(|ctx| assert_eq!(handle.read(ctx).events, [Some(1), Some(2), Some(3), None]))
- });
+ app.read(|ctx| assert_eq!(handle.read(ctx).events, [Some(1), Some(2), Some(3), None]))
}
- #[test]
- fn test_dispatch_action() {
+ #[crate::test(self)]
+ fn test_dispatch_action(app: &mut MutableAppContext) {
struct ViewA {
id: usize,
}
@@ -3448,81 +3418,79 @@ mod tests {
foo: String,
}
- App::test((), |app| {
- let actions = Rc::new(RefCell::new(Vec::new()));
+ let actions = Rc::new(RefCell::new(Vec::new()));
- let actions_clone = actions.clone();
- app.add_global_action("action", move |_: &ActionArg, _: &mut MutableAppContext| {
- actions_clone.borrow_mut().push("global a".to_string());
- });
-
- let actions_clone = actions.clone();
- app.add_global_action("action", move |_: &ActionArg, _: &mut MutableAppContext| {
- actions_clone.borrow_mut().push("global b".to_string());
- });
+ let actions_clone = actions.clone();
+ app.add_global_action("action", move |_: &ActionArg, _: &mut MutableAppContext| {
+ actions_clone.borrow_mut().push("global a".to_string());
+ });
- let actions_clone = actions.clone();
- app.add_action("action", move |view: &mut ViewA, arg: &ActionArg, ctx| {
- assert_eq!(arg.foo, "bar");
- ctx.propagate_action();
- actions_clone.borrow_mut().push(format!("{} a", view.id));
- });
+ let actions_clone = actions.clone();
+ app.add_global_action("action", move |_: &ActionArg, _: &mut MutableAppContext| {
+ actions_clone.borrow_mut().push("global b".to_string());
+ });
- let actions_clone = actions.clone();
- app.add_action("action", move |view: &mut ViewA, _: &ActionArg, ctx| {
- if view.id != 1 {
- ctx.propagate_action();
- }
- actions_clone.borrow_mut().push(format!("{} b", view.id));
- });
+ let actions_clone = actions.clone();
+ app.add_action("action", move |view: &mut ViewA, arg: &ActionArg, ctx| {
+ assert_eq!(arg.foo, "bar");
+ ctx.propagate_action();
+ actions_clone.borrow_mut().push(format!("{} a", view.id));
+ });
- let actions_clone = actions.clone();
- app.add_action("action", move |view: &mut ViewB, _: &ActionArg, ctx| {
+ let actions_clone = actions.clone();
+ app.add_action("action", move |view: &mut ViewA, _: &ActionArg, ctx| {
+ if view.id != 1 {
ctx.propagate_action();
- actions_clone.borrow_mut().push(format!("{} c", view.id));
- });
+ }
+ actions_clone.borrow_mut().push(format!("{} b", view.id));
+ });
- let actions_clone = actions.clone();
- app.add_action("action", move |view: &mut ViewB, _: &ActionArg, ctx| {
- ctx.propagate_action();
- actions_clone.borrow_mut().push(format!("{} d", view.id));
- });
+ let actions_clone = actions.clone();
+ app.add_action("action", move |view: &mut ViewB, _: &ActionArg, ctx| {
+ ctx.propagate_action();
+ actions_clone.borrow_mut().push(format!("{} c", view.id));
+ });
- let (window_id, view_1) = app.add_window(|_| ViewA { id: 1 });
- let view_2 = app.add_view(window_id, |_| ViewB { id: 2 });
- let view_3 = app.add_view(window_id, |_| ViewA { id: 3 });
- let view_4 = app.add_view(window_id, |_| ViewB { id: 4 });
+ let actions_clone = actions.clone();
+ app.add_action("action", move |view: &mut ViewB, _: &ActionArg, ctx| {
+ ctx.propagate_action();
+ actions_clone.borrow_mut().push(format!("{} d", view.id));
+ });
- app.dispatch_action(
- window_id,
- vec![view_1.id(), view_2.id(), view_3.id(), view_4.id()],
- "action",
- ActionArg { foo: "bar".into() },
- );
+ let (window_id, view_1) = app.add_window(|_| ViewA { id: 1 });
+ let view_2 = app.add_view(window_id, |_| ViewB { id: 2 });
+ let view_3 = app.add_view(window_id, |_| ViewA { id: 3 });
+ let view_4 = app.add_view(window_id, |_| ViewB { id: 4 });
- assert_eq!(
- *actions.borrow(),
- vec!["4 d", "4 c", "3 b", "3 a", "2 d", "2 c", "1 b"]
- );
+ app.dispatch_action(
+ window_id,
+ vec![view_1.id(), view_2.id(), view_3.id(), view_4.id()],
+ "action",
+ ActionArg { foo: "bar".into() },
+ );
- // Remove view_1, which doesn't propagate the action
- actions.borrow_mut().clear();
- app.dispatch_action(
- window_id,
- vec![view_2.id(), view_3.id(), view_4.id()],
- "action",
- ActionArg { foo: "bar".into() },
- );
+ assert_eq!(
+ *actions.borrow(),
+ vec!["4 d", "4 c", "3 b", "3 a", "2 d", "2 c", "1 b"]
+ );
- assert_eq!(
- *actions.borrow(),
- vec!["4 d", "4 c", "3 b", "3 a", "2 d", "2 c", "global b", "global a"]
- );
- })
+ // Remove view_1, which doesn't propagate the action
+ actions.borrow_mut().clear();
+ app.dispatch_action(
+ window_id,
+ vec![view_2.id(), view_3.id(), view_4.id()],
+ "action",
+ ActionArg { foo: "bar".into() },
+ );
+
+ assert_eq!(
+ *actions.borrow(),
+ vec!["4 d", "4 c", "3 b", "3 a", "2 d", "2 c", "global b", "global a"]
+ );
}
- #[test]
- fn test_dispatch_keystroke() {
+ #[crate::test(self)]
+ fn test_dispatch_keystroke(app: &mut MutableAppContext) {
use std::cell::Cell;
#[derive(Clone)]
@@ -3562,45 +3530,43 @@ mod tests {
}
}
- App::test((), |app| {
- let mut view_1 = View::new(1);
- let mut view_2 = View::new(2);
- let mut view_3 = View::new(3);
- view_1.keymap_context.set.insert("a".into());
- view_2.keymap_context.set.insert("b".into());
- view_3.keymap_context.set.insert("c".into());
-
- let (window_id, view_1) = app.add_window(|_| view_1);
- let view_2 = app.add_view(window_id, |_| view_2);
- let view_3 = app.add_view(window_id, |_| view_3);
-
- // This keymap's only binding dispatches an action on view 2 because that view will have
- // "a" and "b" in its context, but not "c".
- let binding = keymap::Binding::new("a", "action", Some("a && b && !c"))
- .with_arg(ActionArg { key: "a".into() });
- app.add_bindings(vec![binding]);
-
- let handled_action = Rc::new(Cell::new(false));
- let handled_action_clone = handled_action.clone();
- app.add_action("action", move |view: &mut View, arg: &ActionArg, _ctx| {
- handled_action_clone.set(true);
- assert_eq!(view.id, 2);
- assert_eq!(arg.key, "a");
- });
+ let mut view_1 = View::new(1);
+ let mut view_2 = View::new(2);
+ let mut view_3 = View::new(3);
+ view_1.keymap_context.set.insert("a".into());
+ view_2.keymap_context.set.insert("b".into());
+ view_3.keymap_context.set.insert("c".into());
+
+ let (window_id, view_1) = app.add_window(|_| view_1);
+ let view_2 = app.add_view(window_id, |_| view_2);
+ let view_3 = app.add_view(window_id, |_| view_3);
+
+ // This keymap's only binding dispatches an action on view 2 because that view will have
+ // "a" and "b" in its context, but not "c".
+ let binding = keymap::Binding::new("a", "action", Some("a && b && !c"))
+ .with_arg(ActionArg { key: "a".into() });
+ app.add_bindings(vec![binding]);
+
+ let handled_action = Rc::new(Cell::new(false));
+ let handled_action_clone = handled_action.clone();
+ app.add_action("action", move |view: &mut View, arg: &ActionArg, _ctx| {
+ handled_action_clone.set(true);
+ assert_eq!(view.id, 2);
+ assert_eq!(arg.key, "a");
+ });
- app.dispatch_keystroke(
- window_id,
- vec![view_1.id(), view_2.id(), view_3.id()],
- &Keystroke::parse("a").unwrap(),
- )
- .unwrap();
+ app.dispatch_keystroke(
+ window_id,
+ vec![view_1.id(), view_2.id(), view_3.id()],
+ &Keystroke::parse("a").unwrap(),
+ )
+ .unwrap();
- assert!(handled_action.get());
- });
+ assert!(handled_action.get());
}
- #[test]
- fn test_model_condition() {
+ #[crate::test(self)]
+ async fn test_model_condition(mut app: TestAppContext) {
struct Counter(usize);
impl super::Entity for Counter {
@@ -3614,62 +3580,56 @@ mod tests {
}
}
- App::test_async((), |mut app| async move {
- let model = app.add_model(|_| Counter(0));
+ let model = app.add_model(|_| Counter(0));
- let condition1 = model.condition(&app, |model, _| model.0 == 2);
- let condition2 = model.condition(&app, |model, _| model.0 == 3);
- smol::pin!(condition1, condition2);
+ let condition1 = model.condition(&app, |model, _| model.0 == 2);
+ let condition2 = model.condition(&app, |model, _| model.0 == 3);
+ smol::pin!(condition1, condition2);
- model.update(&mut app, |model, ctx| model.inc(ctx));
- assert_eq!(poll_once(&mut condition1).await, None);
- assert_eq!(poll_once(&mut condition2).await, None);
+ model.update(&mut app, |model, ctx| model.inc(ctx));
+ assert_eq!(poll_once(&mut condition1).await, None);
+ assert_eq!(poll_once(&mut condition2).await, None);
- model.update(&mut app, |model, ctx| model.inc(ctx));
- assert_eq!(poll_once(&mut condition1).await, Some(()));
- assert_eq!(poll_once(&mut condition2).await, None);
+ model.update(&mut app, |model, ctx| model.inc(ctx));
+ assert_eq!(poll_once(&mut condition1).await, Some(()));
+ assert_eq!(poll_once(&mut condition2).await, None);
- model.update(&mut app, |model, ctx| model.inc(ctx));
- assert_eq!(poll_once(&mut condition2).await, Some(()));
+ model.update(&mut app, |model, ctx| model.inc(ctx));
+ assert_eq!(poll_once(&mut condition2).await, Some(()));
- model.update(&mut app, |_, ctx| ctx.notify());
- });
+ model.update(&mut app, |_, ctx| ctx.notify());
}
- #[test]
+ #[crate::test(self)]
#[should_panic]
- fn test_model_condition_timeout() {
+ async fn test_model_condition_timeout(mut app: TestAppContext) {
struct Model;
impl super::Entity for Model {
type Event = ();
}
- App::test_async((), |mut app| async move {
- let model = app.add_model(|_| Model);
- model.condition(&app, |_, _| false).await;
- });
+ let model = app.add_model(|_| Model);
+ model.condition(&app, |_, _| false).await;
}
- #[test]
+ #[crate::test(self)]
#[should_panic(expected = "model dropped with pending condition")]
- fn test_model_condition_panic_on_drop() {
+ async fn test_model_condition_panic_on_drop(mut app: TestAppContext) {
struct Model;
impl super::Entity for Model {
type Event = ();
}
- App::test_async((), |mut app| async move {
- let model = app.add_model(|_| Model);
- let condition = model.condition(&app, |_, _| false);
- app.update(|_| drop(model));
- condition.await;
- });
+ let model = app.add_model(|_| Model);
+ let condition = model.condition(&app, |_, _| false);
+ app.update(|_| drop(model));
+ condition.await;
}
- #[test]
- fn test_view_condition() {
+ #[crate::test(self)]
+ async fn test_view_condition(mut app: TestAppContext) {
struct Counter(usize);
impl super::Entity for Counter {
@@ -24,6 +24,7 @@ pub mod color;
pub mod json;
pub mod keymap;
mod platform;
+pub use gpui_macros::test;
pub use platform::{Event, PathPromptOptions};
pub use presenter::{
AfterLayoutContext, Axis, DebugContext, EventContext, LayoutContext, PaintContext,
@@ -0,0 +1,11 @@
+[package]
+name = "gpui_macros"
+version = "0.1.0"
+edition = "2018"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = "1.0"
+quote = "1.0"
@@ -0,0 +1,57 @@
+use std::mem;
+
+use proc_macro::TokenStream;
+use quote::{format_ident, quote};
+use syn::{parse_macro_input, parse_quote, AttributeArgs, ItemFn, Meta, NestedMeta};
+
+#[proc_macro_attribute]
+pub fn test(args: TokenStream, function: TokenStream) -> TokenStream {
+ let mut namespace = format_ident!("gpui");
+
+ let args = syn::parse_macro_input!(args as AttributeArgs);
+ for arg in args {
+ match arg {
+ NestedMeta::Meta(Meta::Path(name))
+ if name.get_ident().map_or(false, |n| n == "self") =>
+ {
+ namespace = format_ident!("crate");
+ }
+ other => {
+ return TokenStream::from(
+ syn::Error::new_spanned(other, "invalid argument").into_compile_error(),
+ )
+ }
+ }
+ }
+
+ let mut inner_fn = parse_macro_input!(function as ItemFn);
+ let inner_fn_attributes = mem::take(&mut inner_fn.attrs);
+ let inner_fn_name = format_ident!("_{}", inner_fn.sig.ident);
+ let outer_fn_name = mem::replace(&mut inner_fn.sig.ident, inner_fn_name.clone());
+ let mut outer_fn: ItemFn = if inner_fn.sig.asyncness.is_some() {
+ parse_quote! {
+ #[test]
+ fn #outer_fn_name() {
+ #inner_fn
+
+ #namespace::App::test_async((), move |ctx| async {
+ #inner_fn_name(ctx).await;
+ });
+ }
+ }
+ } else {
+ parse_quote! {
+ #[test]
+ fn #outer_fn_name() {
+ #inner_fn
+
+ #namespace::App::test((), |ctx| {
+ #inner_fn_name(ctx);
+ });
+ }
+ }
+ };
+ outer_fn.attrs.extend(inner_fn_attributes);
+
+ TokenStream::from(quote!(#outer_fn))
+}
@@ -2393,259 +2393,245 @@ mod tests {
sync::atomic::{self, AtomicUsize},
};
- #[test]
- fn test_edit() {
- App::test((), |ctx| {
- ctx.add_model(|ctx| {
- let mut buffer = Buffer::new(0, "abc", ctx);
- assert_eq!(buffer.text(), "abc");
- buffer.edit(vec![3..3], "def", None).unwrap();
- assert_eq!(buffer.text(), "abcdef");
- buffer.edit(vec![0..0], "ghi", None).unwrap();
- assert_eq!(buffer.text(), "ghiabcdef");
- buffer.edit(vec![5..5], "jkl", None).unwrap();
- assert_eq!(buffer.text(), "ghiabjklcdef");
- buffer.edit(vec![6..7], "", None).unwrap();
- assert_eq!(buffer.text(), "ghiabjlcdef");
- buffer.edit(vec![4..9], "mno", None).unwrap();
- assert_eq!(buffer.text(), "ghiamnoef");
- buffer
- });
- })
+ #[gpui::test]
+ fn test_edit(ctx: &mut gpui::MutableAppContext) {
+ ctx.add_model(|ctx| {
+ let mut buffer = Buffer::new(0, "abc", ctx);
+ assert_eq!(buffer.text(), "abc");
+ buffer.edit(vec![3..3], "def", None).unwrap();
+ assert_eq!(buffer.text(), "abcdef");
+ buffer.edit(vec![0..0], "ghi", None).unwrap();
+ assert_eq!(buffer.text(), "ghiabcdef");
+ buffer.edit(vec![5..5], "jkl", None).unwrap();
+ assert_eq!(buffer.text(), "ghiabjklcdef");
+ buffer.edit(vec![6..7], "", None).unwrap();
+ assert_eq!(buffer.text(), "ghiabjlcdef");
+ buffer.edit(vec![4..9], "mno", None).unwrap();
+ assert_eq!(buffer.text(), "ghiamnoef");
+ buffer
+ });
}
- #[test]
- fn test_edit_events() {
- App::test((), |app| {
- let mut now = Instant::now();
- let buffer_1_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 buffer2 = app.add_model(|ctx| Buffer::new(1, "abcdef", ctx));
- let mut buffer_ops = Vec::new();
- buffer1.update(app, |buffer, ctx| {
- let buffer_1_events = buffer_1_events.clone();
- ctx.subscribe(&buffer1, move |_, event, _| {
- buffer_1_events.borrow_mut().push(event.clone())
- });
- let buffer_2_events = buffer_2_events.clone();
- ctx.subscribe(&buffer2, move |_, event, _| {
- buffer_2_events.borrow_mut().push(event.clone())
- });
+ #[gpui::test]
+ fn test_edit_events(app: &mut gpui::MutableAppContext) {
+ let mut now = Instant::now();
+ let buffer_1_events = Rc::new(RefCell::new(Vec::new()));
+ let buffer_2_events = Rc::new(RefCell::new(Vec::new()));
- // An edit emits an edited event, followed by a dirtied event,
- // since the buffer was previously in a clean state.
- let ops = buffer.edit(Some(2..4), "XYZ", Some(ctx)).unwrap();
- buffer_ops.extend_from_slice(&ops);
-
- // An empty transaction does not emit any events.
- buffer.start_transaction(None).unwrap();
- buffer.end_transaction(None, Some(ctx)).unwrap();
-
- // A transaction containing two edits emits one edited event.
- now += Duration::from_secs(1);
- buffer.start_transaction_at(None, now).unwrap();
- let ops = buffer.edit(Some(5..5), "u", Some(ctx)).unwrap();
- buffer_ops.extend_from_slice(&ops);
- let ops = buffer.edit(Some(6..6), "w", Some(ctx)).unwrap();
- buffer_ops.extend_from_slice(&ops);
- buffer.end_transaction_at(None, now, Some(ctx)).unwrap();
-
- // Undoing a transaction emits one edited event.
- let ops = buffer.undo(Some(ctx));
- buffer_ops.extend_from_slice(&ops);
+ let buffer1 = app.add_model(|ctx| Buffer::new(0, "abcdef", ctx));
+ let buffer2 = app.add_model(|ctx| Buffer::new(1, "abcdef", ctx));
+ let mut buffer_ops = Vec::new();
+ buffer1.update(app, |buffer, ctx| {
+ let buffer_1_events = buffer_1_events.clone();
+ ctx.subscribe(&buffer1, move |_, event, _| {
+ buffer_1_events.borrow_mut().push(event.clone())
});
-
- // Incorporating a set of remote ops emits a single edited event,
- // followed by a dirtied event.
- buffer2.update(app, |buffer, ctx| {
- buffer.apply_ops(buffer_ops, Some(ctx)).unwrap();
+ let buffer_2_events = buffer_2_events.clone();
+ ctx.subscribe(&buffer2, move |_, event, _| {
+ buffer_2_events.borrow_mut().push(event.clone())
});
- let buffer_1_events = buffer_1_events.borrow();
- assert_eq!(
- *buffer_1_events,
- vec![Event::Edited, Event::Dirtied, Event::Edited, Event::Edited]
- );
+ // An edit emits an edited event, followed by a dirtied event,
+ // since the buffer was previously in a clean state.
+ let ops = buffer.edit(Some(2..4), "XYZ", Some(ctx)).unwrap();
+ buffer_ops.extend_from_slice(&ops);
+
+ // An empty transaction does not emit any events.
+ buffer.start_transaction(None).unwrap();
+ buffer.end_transaction(None, Some(ctx)).unwrap();
+
+ // A transaction containing two edits emits one edited event.
+ now += Duration::from_secs(1);
+ buffer.start_transaction_at(None, now).unwrap();
+ let ops = buffer.edit(Some(5..5), "u", Some(ctx)).unwrap();
+ buffer_ops.extend_from_slice(&ops);
+ let ops = buffer.edit(Some(6..6), "w", Some(ctx)).unwrap();
+ buffer_ops.extend_from_slice(&ops);
+ buffer.end_transaction_at(None, now, Some(ctx)).unwrap();
+
+ // Undoing a transaction emits one edited event.
+ let ops = buffer.undo(Some(ctx));
+ buffer_ops.extend_from_slice(&ops);
+ });
- let buffer_2_events = buffer_2_events.borrow();
- assert_eq!(*buffer_2_events, vec![Event::Edited, Event::Dirtied]);
+ // Incorporating a set of remote ops emits a single edited event,
+ // followed by a dirtied event.
+ buffer2.update(app, |buffer, ctx| {
+ buffer.apply_ops(buffer_ops, Some(ctx)).unwrap();
});
+
+ let buffer_1_events = buffer_1_events.borrow();
+ assert_eq!(
+ *buffer_1_events,
+ vec![Event::Edited, Event::Dirtied, Event::Edited, Event::Edited]
+ );
+
+ let buffer_2_events = buffer_2_events.borrow();
+ assert_eq!(*buffer_2_events, vec![Event::Edited, Event::Dirtied]);
}
- #[test]
- fn test_random_edits() {
+ #[gpui::test]
+ fn test_random_edits(ctx: &mut gpui::MutableAppContext) {
for seed in 0..100 {
- App::test((), |ctx| {
- println!("{:?}", seed);
- let mut rng = &mut StdRng::seed_from_u64(seed);
-
- let reference_string_len = rng.gen_range(0..3);
- let mut reference_string = RandomCharIter::new(&mut rng)
- .take(reference_string_len)
- .collect::<String>();
- ctx.add_model(|ctx| {
- let mut buffer = Buffer::new(0, reference_string.as_str(), ctx);
- let mut buffer_versions = Vec::new();
- for _i in 0..10 {
- let (old_ranges, new_text, _) = buffer.randomly_mutate(rng, None);
- for old_range in old_ranges.iter().rev() {
- reference_string = [
- &reference_string[0..old_range.start],
- new_text.as_str(),
- &reference_string[old_range.end..],
- ]
- .concat();
- }
- assert_eq!(buffer.text(), reference_string);
+ println!("{:?}", seed);
+ let mut rng = &mut StdRng::seed_from_u64(seed);
- if rng.gen_bool(0.25) {
- buffer.randomly_undo_redo(rng);
- reference_string = buffer.text();
- }
+ let reference_string_len = rng.gen_range(0..3);
+ let mut reference_string = RandomCharIter::new(&mut rng)
+ .take(reference_string_len)
+ .collect::<String>();
+ ctx.add_model(|ctx| {
+ let mut buffer = Buffer::new(0, reference_string.as_str(), ctx);
+ let mut buffer_versions = Vec::new();
+ for _i in 0..10 {
+ let (old_ranges, new_text, _) = buffer.randomly_mutate(rng, None);
+ for old_range in old_ranges.iter().rev() {
+ reference_string = [
+ &reference_string[0..old_range.start],
+ new_text.as_str(),
+ &reference_string[old_range.end..],
+ ]
+ .concat();
+ }
+ assert_eq!(buffer.text(), reference_string);
- {
- let line_lengths = line_lengths_in_range(&buffer, 0..buffer.len());
+ if rng.gen_bool(0.25) {
+ buffer.randomly_undo_redo(rng);
+ reference_string = buffer.text();
+ }
- for (len, rows) in &line_lengths {
- for row in rows {
- assert_eq!(buffer.line_len(*row).unwrap(), *len);
- }
- }
+ {
+ let line_lengths = line_lengths_in_range(&buffer, 0..buffer.len());
- let (longest_column, longest_rows) =
- line_lengths.iter().next_back().unwrap();
- let rightmost_point = buffer.rightmost_point();
- assert_eq!(rightmost_point.column, *longest_column);
- assert!(longest_rows.contains(&rightmost_point.row));
+ for (len, rows) in &line_lengths {
+ for row in rows {
+ assert_eq!(buffer.line_len(*row).unwrap(), *len);
+ }
}
- for _ in 0..5 {
- let end = rng.gen_range(0..buffer.len() + 1);
- let start = rng.gen_range(0..end + 1);
-
- let line_lengths = line_lengths_in_range(&buffer, start..end);
- let (longest_column, longest_rows) =
- line_lengths.iter().next_back().unwrap();
- let range_sum = buffer.text_summary_for_range(start..end);
- assert_eq!(range_sum.rightmost_point.column, *longest_column);
- assert!(longest_rows.contains(&range_sum.rightmost_point.row));
- let range_text = &buffer.text()[start..end];
- assert_eq!(range_sum.chars, range_text.chars().count());
- assert_eq!(range_sum.bytes, range_text.len());
- }
+ let (longest_column, longest_rows) =
+ line_lengths.iter().next_back().unwrap();
+ let rightmost_point = buffer.rightmost_point();
+ assert_eq!(rightmost_point.column, *longest_column);
+ assert!(longest_rows.contains(&rightmost_point.row));
+ }
- if rng.gen_bool(0.3) {
- buffer_versions.push(buffer.clone());
- }
+ for _ in 0..5 {
+ let end = rng.gen_range(0..buffer.len() + 1);
+ let start = rng.gen_range(0..end + 1);
+
+ let line_lengths = line_lengths_in_range(&buffer, start..end);
+ let (longest_column, longest_rows) =
+ line_lengths.iter().next_back().unwrap();
+ let range_sum = buffer.text_summary_for_range(start..end);
+ assert_eq!(range_sum.rightmost_point.column, *longest_column);
+ assert!(longest_rows.contains(&range_sum.rightmost_point.row));
+ let range_text = &buffer.text()[start..end];
+ assert_eq!(range_sum.chars, range_text.chars().count());
+ assert_eq!(range_sum.bytes, range_text.len());
}
- for mut old_buffer in buffer_versions {
- let mut delta = 0_isize;
- for Edit {
- old_range,
- new_range,
- } in buffer.edits_since(old_buffer.version.clone())
- {
- let old_len = old_range.end - old_range.start;
- let new_len = new_range.end - new_range.start;
- let old_start = (old_range.start as isize + delta) as usize;
- let new_text: String =
- buffer.text_for_range(new_range).unwrap().collect();
- old_buffer
- .edit(Some(old_start..old_start + old_len), new_text, None)
- .unwrap();
-
- delta += new_len as isize - old_len as isize;
- }
- assert_eq!(old_buffer.text(), buffer.text());
+ if rng.gen_bool(0.3) {
+ buffer_versions.push(buffer.clone());
}
+ }
- buffer
- })
+ for mut old_buffer in buffer_versions {
+ let mut delta = 0_isize;
+ for Edit {
+ old_range,
+ new_range,
+ } in buffer.edits_since(old_buffer.version.clone())
+ {
+ let old_len = old_range.end - old_range.start;
+ let new_len = new_range.end - new_range.start;
+ let old_start = (old_range.start as isize + delta) as usize;
+ let new_text: String = buffer.text_for_range(new_range).unwrap().collect();
+ old_buffer
+ .edit(Some(old_start..old_start + old_len), new_text, None)
+ .unwrap();
+
+ delta += new_len as isize - old_len as isize;
+ }
+ assert_eq!(old_buffer.text(), buffer.text());
+ }
+
+ buffer
});
}
}
- #[test]
- fn test_line_len() {
- App::test((), |ctx| {
- ctx.add_model(|ctx| {
- let mut buffer = Buffer::new(0, "", ctx);
- buffer.edit(vec![0..0], "abcd\nefg\nhij", None).unwrap();
- buffer.edit(vec![12..12], "kl\nmno", None).unwrap();
- buffer.edit(vec![18..18], "\npqrs\n", None).unwrap();
- buffer.edit(vec![18..21], "\nPQ", None).unwrap();
-
- assert_eq!(buffer.line_len(0).unwrap(), 4);
- assert_eq!(buffer.line_len(1).unwrap(), 3);
- assert_eq!(buffer.line_len(2).unwrap(), 5);
- assert_eq!(buffer.line_len(3).unwrap(), 3);
- assert_eq!(buffer.line_len(4).unwrap(), 4);
- assert_eq!(buffer.line_len(5).unwrap(), 0);
- assert!(buffer.line_len(6).is_err());
- buffer
- });
+ #[gpui::test]
+ fn test_line_len(ctx: &mut gpui::MutableAppContext) {
+ ctx.add_model(|ctx| {
+ let mut buffer = Buffer::new(0, "", ctx);
+ buffer.edit(vec![0..0], "abcd\nefg\nhij", None).unwrap();
+ buffer.edit(vec![12..12], "kl\nmno", None).unwrap();
+ buffer.edit(vec![18..18], "\npqrs\n", None).unwrap();
+ buffer.edit(vec![18..21], "\nPQ", None).unwrap();
+
+ assert_eq!(buffer.line_len(0).unwrap(), 4);
+ assert_eq!(buffer.line_len(1).unwrap(), 3);
+ assert_eq!(buffer.line_len(2).unwrap(), 5);
+ assert_eq!(buffer.line_len(3).unwrap(), 3);
+ assert_eq!(buffer.line_len(4).unwrap(), 4);
+ assert_eq!(buffer.line_len(5).unwrap(), 0);
+ assert!(buffer.line_len(6).is_err());
+ buffer
});
}
- #[test]
- fn test_rightmost_point() {
- App::test((), |ctx| {
- ctx.add_model(|ctx| {
- let mut buffer = Buffer::new(0, "", ctx);
- assert_eq!(buffer.rightmost_point().row, 0);
- buffer.edit(vec![0..0], "abcd\nefg\nhij", None).unwrap();
- assert_eq!(buffer.rightmost_point().row, 0);
- buffer.edit(vec![12..12], "kl\nmno", None).unwrap();
- assert_eq!(buffer.rightmost_point().row, 2);
- buffer.edit(vec![18..18], "\npqrs", None).unwrap();
- assert_eq!(buffer.rightmost_point().row, 2);
- buffer.edit(vec![10..12], "", None).unwrap();
- assert_eq!(buffer.rightmost_point().row, 0);
- buffer.edit(vec![24..24], "tuv", None).unwrap();
- assert_eq!(buffer.rightmost_point().row, 4);
- buffer
- });
+ #[gpui::test]
+ fn test_rightmost_point(ctx: &mut gpui::MutableAppContext) {
+ ctx.add_model(|ctx| {
+ let mut buffer = Buffer::new(0, "", ctx);
+ assert_eq!(buffer.rightmost_point().row, 0);
+ buffer.edit(vec![0..0], "abcd\nefg\nhij", None).unwrap();
+ assert_eq!(buffer.rightmost_point().row, 0);
+ buffer.edit(vec![12..12], "kl\nmno", None).unwrap();
+ assert_eq!(buffer.rightmost_point().row, 2);
+ buffer.edit(vec![18..18], "\npqrs", None).unwrap();
+ assert_eq!(buffer.rightmost_point().row, 2);
+ buffer.edit(vec![10..12], "", None).unwrap();
+ assert_eq!(buffer.rightmost_point().row, 0);
+ buffer.edit(vec![24..24], "tuv", None).unwrap();
+ assert_eq!(buffer.rightmost_point().row, 4);
+ buffer
});
}
- #[test]
- fn test_text_summary_for_range() {
- App::test((), |ctx| {
- ctx.add_model(|ctx| {
- let buffer = Buffer::new(0, "ab\nefg\nhklm\nnopqrs\ntuvwxyz", ctx);
- let text = Text::from(buffer.text());
- assert_eq!(
- buffer.text_summary_for_range(1..3),
- text.slice(1..3).summary()
- );
- assert_eq!(
- buffer.text_summary_for_range(1..12),
- text.slice(1..12).summary()
- );
- assert_eq!(
- buffer.text_summary_for_range(0..20),
- text.slice(0..20).summary()
- );
- assert_eq!(
- buffer.text_summary_for_range(0..22),
- text.slice(0..22).summary()
- );
- assert_eq!(
- buffer.text_summary_for_range(7..22),
- text.slice(7..22).summary()
- );
- buffer
- });
+ #[gpui::test]
+ fn test_text_summary_for_range(ctx: &mut gpui::MutableAppContext) {
+ ctx.add_model(|ctx| {
+ let buffer = Buffer::new(0, "ab\nefg\nhklm\nnopqrs\ntuvwxyz", ctx);
+ let text = Text::from(buffer.text());
+ assert_eq!(
+ buffer.text_summary_for_range(1..3),
+ text.slice(1..3).summary()
+ );
+ assert_eq!(
+ buffer.text_summary_for_range(1..12),
+ text.slice(1..12).summary()
+ );
+ assert_eq!(
+ buffer.text_summary_for_range(0..20),
+ text.slice(0..20).summary()
+ );
+ assert_eq!(
+ buffer.text_summary_for_range(0..22),
+ text.slice(0..22).summary()
+ );
+ assert_eq!(
+ buffer.text_summary_for_range(7..22),
+ text.slice(7..22).summary()
+ );
+ buffer
});
}
- #[test]
- fn test_chars_at() {
- App::test((), |ctx| {
- ctx.add_model(|ctx| {
+ #[gpui::test]
+ fn test_chars_at(ctx: &mut gpui::MutableAppContext) {
+ ctx.add_model(|ctx| {
let mut buffer = Buffer::new(0, "", ctx);
buffer.edit(vec![0..0], "abcd\nefgh\nij", None).unwrap();
buffer.edit(vec![12..12], "kl\nmno", None).unwrap();
@@ -2677,7 +2663,6 @@ mod tests {
buffer
});
- });
}
// #[test]
@@ -2794,196 +2779,192 @@ mod tests {
}
}
- #[test]
- fn test_anchors() {
- App::test((), |ctx| {
- ctx.add_model(|ctx| {
- let mut buffer = Buffer::new(0, "", ctx);
- buffer.edit(vec![0..0], "abc", None).unwrap();
- let left_anchor = buffer.anchor_before(2).unwrap();
- let right_anchor = buffer.anchor_after(2).unwrap();
-
- buffer.edit(vec![1..1], "def\n", None).unwrap();
- assert_eq!(buffer.text(), "adef\nbc");
- assert_eq!(left_anchor.to_offset(&buffer).unwrap(), 6);
- assert_eq!(right_anchor.to_offset(&buffer).unwrap(), 6);
- assert_eq!(
- left_anchor.to_point(&buffer).unwrap(),
- Point { row: 1, column: 1 }
- );
- assert_eq!(
- right_anchor.to_point(&buffer).unwrap(),
- Point { row: 1, column: 1 }
- );
+ #[gpui::test]
+ fn test_anchors(ctx: &mut gpui::MutableAppContext) {
+ ctx.add_model(|ctx| {
+ let mut buffer = Buffer::new(0, "", ctx);
+ buffer.edit(vec![0..0], "abc", None).unwrap();
+ let left_anchor = buffer.anchor_before(2).unwrap();
+ let right_anchor = buffer.anchor_after(2).unwrap();
- buffer.edit(vec![2..3], "", None).unwrap();
- assert_eq!(buffer.text(), "adf\nbc");
- assert_eq!(left_anchor.to_offset(&buffer).unwrap(), 5);
- assert_eq!(right_anchor.to_offset(&buffer).unwrap(), 5);
- assert_eq!(
- left_anchor.to_point(&buffer).unwrap(),
- Point { row: 1, column: 1 }
- );
- assert_eq!(
- right_anchor.to_point(&buffer).unwrap(),
- Point { row: 1, column: 1 }
- );
+ buffer.edit(vec![1..1], "def\n", None).unwrap();
+ assert_eq!(buffer.text(), "adef\nbc");
+ assert_eq!(left_anchor.to_offset(&buffer).unwrap(), 6);
+ assert_eq!(right_anchor.to_offset(&buffer).unwrap(), 6);
+ assert_eq!(
+ left_anchor.to_point(&buffer).unwrap(),
+ Point { row: 1, column: 1 }
+ );
+ assert_eq!(
+ right_anchor.to_point(&buffer).unwrap(),
+ Point { row: 1, column: 1 }
+ );
- buffer.edit(vec![5..5], "ghi\n", None).unwrap();
- assert_eq!(buffer.text(), "adf\nbghi\nc");
- assert_eq!(left_anchor.to_offset(&buffer).unwrap(), 5);
- assert_eq!(right_anchor.to_offset(&buffer).unwrap(), 9);
- assert_eq!(
- left_anchor.to_point(&buffer).unwrap(),
- Point { row: 1, column: 1 }
- );
- assert_eq!(
- right_anchor.to_point(&buffer).unwrap(),
- Point { row: 2, column: 0 }
- );
+ buffer.edit(vec![2..3], "", None).unwrap();
+ assert_eq!(buffer.text(), "adf\nbc");
+ assert_eq!(left_anchor.to_offset(&buffer).unwrap(), 5);
+ assert_eq!(right_anchor.to_offset(&buffer).unwrap(), 5);
+ assert_eq!(
+ left_anchor.to_point(&buffer).unwrap(),
+ Point { row: 1, column: 1 }
+ );
+ assert_eq!(
+ right_anchor.to_point(&buffer).unwrap(),
+ Point { row: 1, column: 1 }
+ );
- buffer.edit(vec![7..9], "", None).unwrap();
- assert_eq!(buffer.text(), "adf\nbghc");
- assert_eq!(left_anchor.to_offset(&buffer).unwrap(), 5);
- assert_eq!(right_anchor.to_offset(&buffer).unwrap(), 7);
- assert_eq!(
- left_anchor.to_point(&buffer).unwrap(),
- Point { row: 1, column: 1 },
- );
- assert_eq!(
- right_anchor.to_point(&buffer).unwrap(),
- Point { row: 1, column: 3 }
- );
+ buffer.edit(vec![5..5], "ghi\n", None).unwrap();
+ assert_eq!(buffer.text(), "adf\nbghi\nc");
+ assert_eq!(left_anchor.to_offset(&buffer).unwrap(), 5);
+ assert_eq!(right_anchor.to_offset(&buffer).unwrap(), 9);
+ assert_eq!(
+ left_anchor.to_point(&buffer).unwrap(),
+ Point { row: 1, column: 1 }
+ );
+ assert_eq!(
+ right_anchor.to_point(&buffer).unwrap(),
+ Point { row: 2, column: 0 }
+ );
- // Ensure anchoring to a point is equivalent to anchoring to an offset.
- assert_eq!(
- buffer.anchor_before(Point { row: 0, column: 0 }).unwrap(),
- buffer.anchor_before(0).unwrap()
- );
- assert_eq!(
- buffer.anchor_before(Point { row: 0, column: 1 }).unwrap(),
- buffer.anchor_before(1).unwrap()
- );
- assert_eq!(
- buffer.anchor_before(Point { row: 0, column: 2 }).unwrap(),
- buffer.anchor_before(2).unwrap()
- );
- assert_eq!(
- buffer.anchor_before(Point { row: 0, column: 3 }).unwrap(),
- buffer.anchor_before(3).unwrap()
- );
- assert_eq!(
- buffer.anchor_before(Point { row: 1, column: 0 }).unwrap(),
- buffer.anchor_before(4).unwrap()
- );
- assert_eq!(
- buffer.anchor_before(Point { row: 1, column: 1 }).unwrap(),
- buffer.anchor_before(5).unwrap()
- );
- assert_eq!(
- buffer.anchor_before(Point { row: 1, column: 2 }).unwrap(),
- buffer.anchor_before(6).unwrap()
- );
- assert_eq!(
- buffer.anchor_before(Point { row: 1, column: 3 }).unwrap(),
- buffer.anchor_before(7).unwrap()
- );
- assert_eq!(
- buffer.anchor_before(Point { row: 1, column: 4 }).unwrap(),
- buffer.anchor_before(8).unwrap()
- );
+ buffer.edit(vec![7..9], "", None).unwrap();
+ assert_eq!(buffer.text(), "adf\nbghc");
+ assert_eq!(left_anchor.to_offset(&buffer).unwrap(), 5);
+ assert_eq!(right_anchor.to_offset(&buffer).unwrap(), 7);
+ assert_eq!(
+ left_anchor.to_point(&buffer).unwrap(),
+ Point { row: 1, column: 1 },
+ );
+ assert_eq!(
+ right_anchor.to_point(&buffer).unwrap(),
+ Point { row: 1, column: 3 }
+ );
- // Comparison between anchors.
- let anchor_at_offset_0 = buffer.anchor_before(0).unwrap();
- let anchor_at_offset_1 = buffer.anchor_before(1).unwrap();
- let anchor_at_offset_2 = buffer.anchor_before(2).unwrap();
+ // Ensure anchoring to a point is equivalent to anchoring to an offset.
+ assert_eq!(
+ buffer.anchor_before(Point { row: 0, column: 0 }).unwrap(),
+ buffer.anchor_before(0).unwrap()
+ );
+ assert_eq!(
+ buffer.anchor_before(Point { row: 0, column: 1 }).unwrap(),
+ buffer.anchor_before(1).unwrap()
+ );
+ assert_eq!(
+ buffer.anchor_before(Point { row: 0, column: 2 }).unwrap(),
+ buffer.anchor_before(2).unwrap()
+ );
+ assert_eq!(
+ buffer.anchor_before(Point { row: 0, column: 3 }).unwrap(),
+ buffer.anchor_before(3).unwrap()
+ );
+ assert_eq!(
+ buffer.anchor_before(Point { row: 1, column: 0 }).unwrap(),
+ buffer.anchor_before(4).unwrap()
+ );
+ assert_eq!(
+ buffer.anchor_before(Point { row: 1, column: 1 }).unwrap(),
+ buffer.anchor_before(5).unwrap()
+ );
+ assert_eq!(
+ buffer.anchor_before(Point { row: 1, column: 2 }).unwrap(),
+ buffer.anchor_before(6).unwrap()
+ );
+ assert_eq!(
+ buffer.anchor_before(Point { row: 1, column: 3 }).unwrap(),
+ buffer.anchor_before(7).unwrap()
+ );
+ assert_eq!(
+ buffer.anchor_before(Point { row: 1, column: 4 }).unwrap(),
+ buffer.anchor_before(8).unwrap()
+ );
- assert_eq!(
- anchor_at_offset_0
- .cmp(&anchor_at_offset_0, &buffer)
- .unwrap(),
- Ordering::Equal
- );
- assert_eq!(
- anchor_at_offset_1
- .cmp(&anchor_at_offset_1, &buffer)
- .unwrap(),
- Ordering::Equal
- );
- assert_eq!(
- anchor_at_offset_2
- .cmp(&anchor_at_offset_2, &buffer)
- .unwrap(),
- Ordering::Equal
- );
+ // Comparison between anchors.
+ let anchor_at_offset_0 = buffer.anchor_before(0).unwrap();
+ let anchor_at_offset_1 = buffer.anchor_before(1).unwrap();
+ let anchor_at_offset_2 = buffer.anchor_before(2).unwrap();
- assert_eq!(
- anchor_at_offset_0
- .cmp(&anchor_at_offset_1, &buffer)
- .unwrap(),
- Ordering::Less
- );
- assert_eq!(
- anchor_at_offset_1
- .cmp(&anchor_at_offset_2, &buffer)
- .unwrap(),
- Ordering::Less
- );
- assert_eq!(
- anchor_at_offset_0
- .cmp(&anchor_at_offset_2, &buffer)
- .unwrap(),
- Ordering::Less
- );
+ assert_eq!(
+ anchor_at_offset_0
+ .cmp(&anchor_at_offset_0, &buffer)
+ .unwrap(),
+ Ordering::Equal
+ );
+ assert_eq!(
+ anchor_at_offset_1
+ .cmp(&anchor_at_offset_1, &buffer)
+ .unwrap(),
+ Ordering::Equal
+ );
+ assert_eq!(
+ anchor_at_offset_2
+ .cmp(&anchor_at_offset_2, &buffer)
+ .unwrap(),
+ Ordering::Equal
+ );
- assert_eq!(
- anchor_at_offset_1
- .cmp(&anchor_at_offset_0, &buffer)
- .unwrap(),
- Ordering::Greater
- );
- assert_eq!(
- anchor_at_offset_2
- .cmp(&anchor_at_offset_1, &buffer)
- .unwrap(),
- Ordering::Greater
- );
- assert_eq!(
- anchor_at_offset_2
- .cmp(&anchor_at_offset_0, &buffer)
- .unwrap(),
- Ordering::Greater
- );
- buffer
- });
+ assert_eq!(
+ anchor_at_offset_0
+ .cmp(&anchor_at_offset_1, &buffer)
+ .unwrap(),
+ Ordering::Less
+ );
+ assert_eq!(
+ anchor_at_offset_1
+ .cmp(&anchor_at_offset_2, &buffer)
+ .unwrap(),
+ Ordering::Less
+ );
+ assert_eq!(
+ anchor_at_offset_0
+ .cmp(&anchor_at_offset_2, &buffer)
+ .unwrap(),
+ Ordering::Less
+ );
+
+ assert_eq!(
+ anchor_at_offset_1
+ .cmp(&anchor_at_offset_0, &buffer)
+ .unwrap(),
+ Ordering::Greater
+ );
+ assert_eq!(
+ anchor_at_offset_2
+ .cmp(&anchor_at_offset_1, &buffer)
+ .unwrap(),
+ Ordering::Greater
+ );
+ assert_eq!(
+ anchor_at_offset_2
+ .cmp(&anchor_at_offset_0, &buffer)
+ .unwrap(),
+ Ordering::Greater
+ );
+ buffer
});
}
- #[test]
- fn test_anchors_at_start_and_end() {
- App::test((), |ctx| {
- ctx.add_model(|ctx| {
- let mut buffer = Buffer::new(0, "", ctx);
- let before_start_anchor = buffer.anchor_before(0).unwrap();
- let after_end_anchor = buffer.anchor_after(0).unwrap();
-
- buffer.edit(vec![0..0], "abc", None).unwrap();
- assert_eq!(buffer.text(), "abc");
- assert_eq!(before_start_anchor.to_offset(&buffer).unwrap(), 0);
- assert_eq!(after_end_anchor.to_offset(&buffer).unwrap(), 3);
-
- let after_start_anchor = buffer.anchor_after(0).unwrap();
- let before_end_anchor = buffer.anchor_before(3).unwrap();
-
- buffer.edit(vec![3..3], "def", None).unwrap();
- buffer.edit(vec![0..0], "ghi", None).unwrap();
- assert_eq!(buffer.text(), "ghiabcdef");
- assert_eq!(before_start_anchor.to_offset(&buffer).unwrap(), 0);
- assert_eq!(after_start_anchor.to_offset(&buffer).unwrap(), 3);
- assert_eq!(before_end_anchor.to_offset(&buffer).unwrap(), 6);
- assert_eq!(after_end_anchor.to_offset(&buffer).unwrap(), 9);
- buffer
- });
+ #[gpui::test]
+ fn test_anchors_at_start_and_end(ctx: &mut gpui::MutableAppContext) {
+ ctx.add_model(|ctx| {
+ let mut buffer = Buffer::new(0, "", ctx);
+ let before_start_anchor = buffer.anchor_before(0).unwrap();
+ let after_end_anchor = buffer.anchor_after(0).unwrap();
+
+ buffer.edit(vec![0..0], "abc", None).unwrap();
+ assert_eq!(buffer.text(), "abc");
+ assert_eq!(before_start_anchor.to_offset(&buffer).unwrap(), 0);
+ assert_eq!(after_end_anchor.to_offset(&buffer).unwrap(), 3);
+
+ let after_start_anchor = buffer.anchor_after(0).unwrap();
+ let before_end_anchor = buffer.anchor_before(3).unwrap();
+
+ buffer.edit(vec![3..3], "def", None).unwrap();
+ buffer.edit(vec![0..0], "ghi", None).unwrap();
+ assert_eq!(buffer.text(), "ghiabcdef");
+ assert_eq!(before_start_anchor.to_offset(&buffer).unwrap(), 0);
+ assert_eq!(after_start_anchor.to_offset(&buffer).unwrap(), 3);
+ assert_eq!(before_end_anchor.to_offset(&buffer).unwrap(), 6);
+ assert_eq!(after_end_anchor.to_offset(&buffer).unwrap(), 9);
+ buffer
});
}
@@ -3105,115 +3086,111 @@ mod tests {
});
}
- #[test]
- fn test_undo_redo() {
- App::test((), |app| {
- app.add_model(|ctx| {
- let mut buffer = Buffer::new(0, "1234", ctx);
-
- let edit1 = buffer.edit(vec![1..1], "abx", None).unwrap();
- let edit2 = buffer.edit(vec![3..4], "yzef", None).unwrap();
- let edit3 = buffer.edit(vec![3..5], "cd", None).unwrap();
- assert_eq!(buffer.text(), "1abcdef234");
-
- buffer.undo_or_redo(edit1[0].edit_id().unwrap()).unwrap();
- assert_eq!(buffer.text(), "1cdef234");
- buffer.undo_or_redo(edit1[0].edit_id().unwrap()).unwrap();
- assert_eq!(buffer.text(), "1abcdef234");
-
- buffer.undo_or_redo(edit2[0].edit_id().unwrap()).unwrap();
- assert_eq!(buffer.text(), "1abcdx234");
- buffer.undo_or_redo(edit3[0].edit_id().unwrap()).unwrap();
- assert_eq!(buffer.text(), "1abx234");
- buffer.undo_or_redo(edit2[0].edit_id().unwrap()).unwrap();
- assert_eq!(buffer.text(), "1abyzef234");
- buffer.undo_or_redo(edit3[0].edit_id().unwrap()).unwrap();
- assert_eq!(buffer.text(), "1abcdef234");
-
- buffer.undo_or_redo(edit3[0].edit_id().unwrap()).unwrap();
- assert_eq!(buffer.text(), "1abyzef234");
- buffer.undo_or_redo(edit1[0].edit_id().unwrap()).unwrap();
- assert_eq!(buffer.text(), "1yzef234");
- buffer.undo_or_redo(edit2[0].edit_id().unwrap()).unwrap();
- assert_eq!(buffer.text(), "1234");
-
- buffer
- });
+ #[gpui::test]
+ fn test_undo_redo(app: &mut gpui::MutableAppContext) {
+ app.add_model(|ctx| {
+ let mut buffer = Buffer::new(0, "1234", ctx);
+
+ let edit1 = buffer.edit(vec![1..1], "abx", None).unwrap();
+ let edit2 = buffer.edit(vec![3..4], "yzef", None).unwrap();
+ let edit3 = buffer.edit(vec![3..5], "cd", None).unwrap();
+ assert_eq!(buffer.text(), "1abcdef234");
+
+ buffer.undo_or_redo(edit1[0].edit_id().unwrap()).unwrap();
+ assert_eq!(buffer.text(), "1cdef234");
+ buffer.undo_or_redo(edit1[0].edit_id().unwrap()).unwrap();
+ assert_eq!(buffer.text(), "1abcdef234");
+
+ buffer.undo_or_redo(edit2[0].edit_id().unwrap()).unwrap();
+ assert_eq!(buffer.text(), "1abcdx234");
+ buffer.undo_or_redo(edit3[0].edit_id().unwrap()).unwrap();
+ assert_eq!(buffer.text(), "1abx234");
+ buffer.undo_or_redo(edit2[0].edit_id().unwrap()).unwrap();
+ assert_eq!(buffer.text(), "1abyzef234");
+ buffer.undo_or_redo(edit3[0].edit_id().unwrap()).unwrap();
+ assert_eq!(buffer.text(), "1abcdef234");
+
+ buffer.undo_or_redo(edit3[0].edit_id().unwrap()).unwrap();
+ assert_eq!(buffer.text(), "1abyzef234");
+ buffer.undo_or_redo(edit1[0].edit_id().unwrap()).unwrap();
+ assert_eq!(buffer.text(), "1yzef234");
+ buffer.undo_or_redo(edit2[0].edit_id().unwrap()).unwrap();
+ assert_eq!(buffer.text(), "1234");
+
+ buffer
});
}
- #[test]
- fn test_history() {
- App::test((), |app| {
- app.add_model(|ctx| {
- let mut now = Instant::now();
- let mut buffer = Buffer::new(0, "123456", ctx);
-
- let (set_id, _) = buffer
- .add_selection_set(buffer.selections_from_ranges(vec![4..4]).unwrap(), None);
- buffer.start_transaction_at(Some(set_id), now).unwrap();
- buffer.edit(vec![2..4], "cd", None).unwrap();
- buffer.end_transaction_at(Some(set_id), now, None).unwrap();
- assert_eq!(buffer.text(), "12cd56");
- assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![4..4]);
-
- buffer.start_transaction_at(Some(set_id), now).unwrap();
- buffer
- .update_selection_set(
- set_id,
- buffer.selections_from_ranges(vec![1..3]).unwrap(),
- None,
- )
- .unwrap();
- buffer.edit(vec![4..5], "e", None).unwrap();
- buffer.end_transaction_at(Some(set_id), now, None).unwrap();
- assert_eq!(buffer.text(), "12cde6");
- assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![1..3]);
-
- now += UNDO_GROUP_INTERVAL + Duration::from_millis(1);
- buffer.start_transaction_at(Some(set_id), now).unwrap();
- buffer
- .update_selection_set(
- set_id,
- buffer.selections_from_ranges(vec![2..2]).unwrap(),
- None,
- )
- .unwrap();
- buffer.edit(vec![0..1], "a", None).unwrap();
- buffer.edit(vec![1..1], "b", None).unwrap();
- buffer.end_transaction_at(Some(set_id), now, None).unwrap();
- assert_eq!(buffer.text(), "ab2cde6");
- assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![3..3]);
-
- // Last transaction happened past the group interval, undo it on its
- // own.
- buffer.undo(None);
- assert_eq!(buffer.text(), "12cde6");
- assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![1..3]);
-
- // First two transactions happened within the group interval, undo them
- // together.
- buffer.undo(None);
- assert_eq!(buffer.text(), "123456");
- assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![4..4]);
-
- // Redo the first two transactions together.
- buffer.redo(None);
- assert_eq!(buffer.text(), "12cde6");
- assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![1..3]);
-
- // Redo the last transaction on its own.
- buffer.redo(None);
- assert_eq!(buffer.text(), "ab2cde6");
- assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![3..3]);
-
- buffer
- });
+ #[gpui::test]
+ fn test_history(app: &mut gpui::MutableAppContext) {
+ app.add_model(|ctx| {
+ let mut now = Instant::now();
+ let mut buffer = Buffer::new(0, "123456", ctx);
+
+ let (set_id, _) =
+ buffer.add_selection_set(buffer.selections_from_ranges(vec![4..4]).unwrap(), None);
+ buffer.start_transaction_at(Some(set_id), now).unwrap();
+ buffer.edit(vec![2..4], "cd", None).unwrap();
+ buffer.end_transaction_at(Some(set_id), now, None).unwrap();
+ assert_eq!(buffer.text(), "12cd56");
+ assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![4..4]);
+
+ buffer.start_transaction_at(Some(set_id), now).unwrap();
+ buffer
+ .update_selection_set(
+ set_id,
+ buffer.selections_from_ranges(vec![1..3]).unwrap(),
+ None,
+ )
+ .unwrap();
+ buffer.edit(vec![4..5], "e", None).unwrap();
+ buffer.end_transaction_at(Some(set_id), now, None).unwrap();
+ assert_eq!(buffer.text(), "12cde6");
+ assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![1..3]);
+
+ now += UNDO_GROUP_INTERVAL + Duration::from_millis(1);
+ buffer.start_transaction_at(Some(set_id), now).unwrap();
+ buffer
+ .update_selection_set(
+ set_id,
+ buffer.selections_from_ranges(vec![2..2]).unwrap(),
+ None,
+ )
+ .unwrap();
+ buffer.edit(vec![0..1], "a", None).unwrap();
+ buffer.edit(vec![1..1], "b", None).unwrap();
+ buffer.end_transaction_at(Some(set_id), now, None).unwrap();
+ assert_eq!(buffer.text(), "ab2cde6");
+ assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![3..3]);
+
+ // Last transaction happened past the group interval, undo it on its
+ // own.
+ buffer.undo(None);
+ assert_eq!(buffer.text(), "12cde6");
+ assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![1..3]);
+
+ // First two transactions happened within the group interval, undo them
+ // together.
+ buffer.undo(None);
+ assert_eq!(buffer.text(), "123456");
+ assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![4..4]);
+
+ // Redo the first two transactions together.
+ buffer.redo(None);
+ assert_eq!(buffer.text(), "12cde6");
+ assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![1..3]);
+
+ // Redo the last transaction on its own.
+ buffer.redo(None);
+ assert_eq!(buffer.text(), "ab2cde6");
+ assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![3..3]);
+
+ buffer
});
}
- #[test]
- fn test_random_concurrent_edits() {
+ #[gpui::test]
+ fn test_random_concurrent_edits(ctx: &mut gpui::MutableAppContext) {
use crate::test::Network;
const PEERS: usize = 5;
@@ -2511,222 +2511,207 @@ impl workspace::ItemView for BufferView {
mod tests {
use super::*;
use crate::{editor::Point, settings, test::sample_text};
- use gpui::App;
use unindent::Unindent;
- #[test]
- fn test_selection_with_mouse() {
- App::test((), |app| {
- let buffer =
- app.add_model(|ctx| Buffer::new(0, "aaaaaa\nbbbbbb\ncccccc\ndddddd\n", ctx));
- let settings = settings::channel(&app.font_cache()).unwrap().1;
- let (_, buffer_view) =
- app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
-
- buffer_view.update(app, |view, ctx| {
- view.begin_selection(DisplayPoint::new(2, 2), false, ctx);
- });
+ #[gpui::test]
+ fn test_selection_with_mouse(app: &mut gpui::MutableAppContext) {
+ let buffer = app.add_model(|ctx| Buffer::new(0, "aaaaaa\nbbbbbb\ncccccc\ndddddd\n", ctx));
+ let settings = settings::channel(&app.font_cache()).unwrap().1;
+ let (_, buffer_view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
- let view = buffer_view.read(app);
- let selections = view
- .selections_in_range(
- DisplayPoint::zero()..view.max_point(app.as_ref()),
- app.as_ref(),
- )
- .collect::<Vec<_>>();
- assert_eq!(
- selections,
- [DisplayPoint::new(2, 2)..DisplayPoint::new(2, 2)]
- );
+ buffer_view.update(app, |view, ctx| {
+ view.begin_selection(DisplayPoint::new(2, 2), false, ctx);
+ });
- buffer_view.update(app, |view, ctx| {
- view.update_selection(DisplayPoint::new(3, 3), Vector2F::zero(), ctx);
- });
+ let view = buffer_view.read(app);
+ let selections = view
+ .selections_in_range(
+ DisplayPoint::zero()..view.max_point(app.as_ref()),
+ app.as_ref(),
+ )
+ .collect::<Vec<_>>();
+ assert_eq!(
+ selections,
+ [DisplayPoint::new(2, 2)..DisplayPoint::new(2, 2)]
+ );
- let view = buffer_view.read(app);
- let selections = view
- .selections_in_range(
- DisplayPoint::zero()..view.max_point(app.as_ref()),
- app.as_ref(),
- )
- .collect::<Vec<_>>();
- assert_eq!(
- selections,
- [DisplayPoint::new(2, 2)..DisplayPoint::new(3, 3)]
- );
+ buffer_view.update(app, |view, ctx| {
+ view.update_selection(DisplayPoint::new(3, 3), Vector2F::zero(), ctx);
+ });
- buffer_view.update(app, |view, ctx| {
- view.update_selection(DisplayPoint::new(1, 1), Vector2F::zero(), ctx);
- });
+ let view = buffer_view.read(app);
+ let selections = view
+ .selections_in_range(
+ DisplayPoint::zero()..view.max_point(app.as_ref()),
+ app.as_ref(),
+ )
+ .collect::<Vec<_>>();
+ assert_eq!(
+ selections,
+ [DisplayPoint::new(2, 2)..DisplayPoint::new(3, 3)]
+ );
- let view = buffer_view.read(app);
- let selections = view
- .selections_in_range(
- DisplayPoint::zero()..view.max_point(app.as_ref()),
- app.as_ref(),
- )
- .collect::<Vec<_>>();
- assert_eq!(
- selections,
- [DisplayPoint::new(2, 2)..DisplayPoint::new(1, 1)]
- );
+ buffer_view.update(app, |view, ctx| {
+ view.update_selection(DisplayPoint::new(1, 1), Vector2F::zero(), ctx);
+ });
- buffer_view.update(app, |view, ctx| {
- view.end_selection(ctx);
- view.update_selection(DisplayPoint::new(3, 3), Vector2F::zero(), ctx);
- });
+ let view = buffer_view.read(app);
+ let selections = view
+ .selections_in_range(
+ DisplayPoint::zero()..view.max_point(app.as_ref()),
+ app.as_ref(),
+ )
+ .collect::<Vec<_>>();
+ assert_eq!(
+ selections,
+ [DisplayPoint::new(2, 2)..DisplayPoint::new(1, 1)]
+ );
- let view = buffer_view.read(app);
- let selections = view
- .selections_in_range(
- DisplayPoint::zero()..view.max_point(app.as_ref()),
- app.as_ref(),
- )
- .collect::<Vec<_>>();
- assert_eq!(
- selections,
- [DisplayPoint::new(2, 2)..DisplayPoint::new(1, 1)]
- );
+ buffer_view.update(app, |view, ctx| {
+ view.end_selection(ctx);
+ view.update_selection(DisplayPoint::new(3, 3), Vector2F::zero(), ctx);
+ });
- buffer_view.update(app, |view, ctx| {
- view.begin_selection(DisplayPoint::new(3, 3), true, ctx);
- view.update_selection(DisplayPoint::new(0, 0), Vector2F::zero(), ctx);
- });
+ let view = buffer_view.read(app);
+ let selections = view
+ .selections_in_range(
+ DisplayPoint::zero()..view.max_point(app.as_ref()),
+ app.as_ref(),
+ )
+ .collect::<Vec<_>>();
+ assert_eq!(
+ selections,
+ [DisplayPoint::new(2, 2)..DisplayPoint::new(1, 1)]
+ );
- let view = buffer_view.read(app);
- let selections = view
- .selections_in_range(
- DisplayPoint::zero()..view.max_point(app.as_ref()),
- app.as_ref(),
- )
- .collect::<Vec<_>>();
- assert_eq!(
- selections,
- [
- DisplayPoint::new(2, 2)..DisplayPoint::new(1, 1),
- DisplayPoint::new(3, 3)..DisplayPoint::new(0, 0)
- ]
- );
+ buffer_view.update(app, |view, ctx| {
+ view.begin_selection(DisplayPoint::new(3, 3), true, ctx);
+ view.update_selection(DisplayPoint::new(0, 0), Vector2F::zero(), ctx);
+ });
- buffer_view.update(app, |view, ctx| {
- view.end_selection(ctx);
- });
+ let view = buffer_view.read(app);
+ let selections = view
+ .selections_in_range(
+ DisplayPoint::zero()..view.max_point(app.as_ref()),
+ app.as_ref(),
+ )
+ .collect::<Vec<_>>();
+ assert_eq!(
+ selections,
+ [
+ DisplayPoint::new(2, 2)..DisplayPoint::new(1, 1),
+ DisplayPoint::new(3, 3)..DisplayPoint::new(0, 0)
+ ]
+ );
- let view = buffer_view.read(app);
- let selections = view
- .selections_in_range(
- DisplayPoint::zero()..view.max_point(app.as_ref()),
- app.as_ref(),
- )
- .collect::<Vec<_>>();
- assert_eq!(
- selections,
- [DisplayPoint::new(3, 3)..DisplayPoint::new(0, 0)]
- );
+ buffer_view.update(app, |view, ctx| {
+ view.end_selection(ctx);
});
+
+ let view = buffer_view.read(app);
+ let selections = view
+ .selections_in_range(
+ DisplayPoint::zero()..view.max_point(app.as_ref()),
+ app.as_ref(),
+ )
+ .collect::<Vec<_>>();
+ assert_eq!(
+ selections,
+ [DisplayPoint::new(3, 3)..DisplayPoint::new(0, 0)]
+ );
}
- #[test]
- fn test_canceling_pending_selection() {
- App::test((), |app| {
- let buffer =
- app.add_model(|ctx| Buffer::new(0, "aaaaaa\nbbbbbb\ncccccc\ndddddd\n", ctx));
- let settings = settings::channel(&app.font_cache()).unwrap().1;
- let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
+ #[gpui::test]
+ fn test_canceling_pending_selection(app: &mut gpui::MutableAppContext) {
+ let buffer = app.add_model(|ctx| Buffer::new(0, "aaaaaa\nbbbbbb\ncccccc\ndddddd\n", ctx));
+ let settings = settings::channel(&app.font_cache()).unwrap().1;
+ let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
- view.update(app, |view, ctx| {
- view.begin_selection(DisplayPoint::new(2, 2), false, ctx);
- });
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- [DisplayPoint::new(2, 2)..DisplayPoint::new(2, 2)]
- );
+ view.update(app, |view, ctx| {
+ view.begin_selection(DisplayPoint::new(2, 2), false, ctx);
+ });
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ [DisplayPoint::new(2, 2)..DisplayPoint::new(2, 2)]
+ );
- view.update(app, |view, ctx| {
- view.update_selection(DisplayPoint::new(3, 3), Vector2F::zero(), ctx);
- });
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- [DisplayPoint::new(2, 2)..DisplayPoint::new(3, 3)]
- );
+ view.update(app, |view, ctx| {
+ view.update_selection(DisplayPoint::new(3, 3), Vector2F::zero(), ctx);
+ });
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ [DisplayPoint::new(2, 2)..DisplayPoint::new(3, 3)]
+ );
- view.update(app, |view, ctx| {
- view.cancel(&(), ctx);
- view.update_selection(DisplayPoint::new(1, 1), Vector2F::zero(), ctx);
- });
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- [DisplayPoint::new(2, 2)..DisplayPoint::new(3, 3)]
- );
+ view.update(app, |view, ctx| {
+ view.cancel(&(), ctx);
+ view.update_selection(DisplayPoint::new(1, 1), Vector2F::zero(), ctx);
});
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ [DisplayPoint::new(2, 2)..DisplayPoint::new(3, 3)]
+ );
}
- #[test]
- fn test_cancel() {
- App::test((), |app| {
- let buffer =
- app.add_model(|ctx| Buffer::new(0, "aaaaaa\nbbbbbb\ncccccc\ndddddd\n", ctx));
- let settings = settings::channel(&app.font_cache()).unwrap().1;
- let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
+ #[gpui::test]
+ fn test_cancel(app: &mut gpui::MutableAppContext) {
+ let buffer = app.add_model(|ctx| Buffer::new(0, "aaaaaa\nbbbbbb\ncccccc\ndddddd\n", ctx));
+ let settings = settings::channel(&app.font_cache()).unwrap().1;
+ let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
- view.update(app, |view, ctx| {
- view.begin_selection(DisplayPoint::new(3, 4), false, ctx);
- view.update_selection(DisplayPoint::new(1, 1), Vector2F::zero(), ctx);
- view.end_selection(ctx);
+ view.update(app, |view, ctx| {
+ view.begin_selection(DisplayPoint::new(3, 4), false, ctx);
+ view.update_selection(DisplayPoint::new(1, 1), Vector2F::zero(), ctx);
+ view.end_selection(ctx);
- view.begin_selection(DisplayPoint::new(0, 1), true, ctx);
- view.update_selection(DisplayPoint::new(0, 3), Vector2F::zero(), ctx);
- view.end_selection(ctx);
- });
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- [
- DisplayPoint::new(0, 1)..DisplayPoint::new(0, 3),
- DisplayPoint::new(3, 4)..DisplayPoint::new(1, 1),
- ]
- );
+ view.begin_selection(DisplayPoint::new(0, 1), true, ctx);
+ view.update_selection(DisplayPoint::new(0, 3), Vector2F::zero(), ctx);
+ view.end_selection(ctx);
+ });
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ [
+ DisplayPoint::new(0, 1)..DisplayPoint::new(0, 3),
+ DisplayPoint::new(3, 4)..DisplayPoint::new(1, 1),
+ ]
+ );
- view.update(app, |view, ctx| view.cancel(&(), ctx));
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- [DisplayPoint::new(3, 4)..DisplayPoint::new(1, 1)]
- );
+ view.update(app, |view, ctx| view.cancel(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ [DisplayPoint::new(3, 4)..DisplayPoint::new(1, 1)]
+ );
- view.update(app, |view, ctx| view.cancel(&(), ctx));
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- [DisplayPoint::new(1, 1)..DisplayPoint::new(1, 1)]
- );
- });
+ view.update(app, |view, ctx| view.cancel(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ [DisplayPoint::new(1, 1)..DisplayPoint::new(1, 1)]
+ );
}
- #[test]
- fn test_layout_line_numbers() {
- App::test((), |app| {
- let layout_cache = TextLayoutCache::new(app.platform().fonts());
- let font_cache = app.font_cache().clone();
+ #[gpui::test]
+ fn test_layout_line_numbers(app: &mut gpui::MutableAppContext) {
+ let layout_cache = TextLayoutCache::new(app.platform().fonts());
+ 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(|ctx| Buffer::new(0, sample_text(6, 6), ctx));
- let settings = settings::channel(&font_cache).unwrap().1;
- let (_, view) =
- app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx));
+ let settings = settings::channel(&font_cache).unwrap().1;
+ let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx));
- let layouts = view
- .read(app)
- .layout_line_numbers(1000.0, &font_cache, &layout_cache, app.as_ref())
- .unwrap();
- assert_eq!(layouts.len(), 6);
- })
+ let layouts = view
+ .read(app)
+ .layout_line_numbers(1000.0, &font_cache, &layout_cache, app.as_ref())
+ .unwrap();
+ assert_eq!(layouts.len(), 6);
}
- #[test]
- fn test_fold() {
- App::test((), |app| {
- let buffer = app.add_model(|ctx| {
- Buffer::new(
- 0,
- "
+ #[gpui::test]
+ fn test_fold(app: &mut gpui::MutableAppContext) {
+ let buffer = app.add_model(|ctx| {
+ Buffer::new(
+ 0,
+ "
impl Foo {
// Hello!
@@ -2743,24 +2728,20 @@ mod tests {
}
}
"
- .unindent(),
- ctx,
- )
- });
- let settings = settings::channel(&app.font_cache()).unwrap().1;
- let (_, view) =
- app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx));
-
- view.update(app, |view, ctx| {
- view.select_display_ranges(
- &[DisplayPoint::new(8, 0)..DisplayPoint::new(12, 0)],
- ctx,
- )
+ .unindent(),
+ ctx,
+ )
+ });
+ let settings = settings::channel(&app.font_cache()).unwrap().1;
+ let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx));
+
+ view.update(app, |view, ctx| {
+ view.select_display_ranges(&[DisplayPoint::new(8, 0)..DisplayPoint::new(12, 0)], ctx)
.unwrap();
- view.fold(&(), ctx);
- assert_eq!(
- view.text(ctx.as_ref()),
- "
+ view.fold(&(), ctx);
+ assert_eq!(
+ view.text(ctx.as_ref()),
+ "
impl Foo {
// Hello!
@@ -2775,23 +2756,23 @@ mod tests {
}
}
"
- .unindent(),
- );
+ .unindent(),
+ );
- view.fold(&(), ctx);
- assert_eq!(
- view.text(ctx.as_ref()),
- "
+ view.fold(&(), ctx);
+ assert_eq!(
+ view.text(ctx.as_ref()),
+ "
impl Foo {…
}
"
- .unindent(),
- );
+ .unindent(),
+ );
- view.unfold(&(), ctx);
- assert_eq!(
- view.text(ctx.as_ref()),
- "
+ view.unfold(&(), ctx);
+ assert_eq!(
+ view.text(ctx.as_ref()),
+ "
impl Foo {
// Hello!
@@ -2806,1109 +2787,1055 @@ mod tests {
}
}
"
- .unindent(),
- );
+ .unindent(),
+ );
- view.unfold(&(), ctx);
- assert_eq!(view.text(ctx.as_ref()), buffer.read(ctx).text());
- });
+ view.unfold(&(), ctx);
+ assert_eq!(view.text(ctx.as_ref()), buffer.read(ctx).text());
});
}
- #[test]
- fn test_move_cursor() {
- App::test((), |app| {
- let buffer = app.add_model(|ctx| Buffer::new(0, sample_text(6, 6), ctx));
- let settings = settings::channel(&app.font_cache()).unwrap().1;
- let (_, view) =
- app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx));
-
- buffer.update(app, |buffer, ctx| {
- buffer
- .edit(
- vec![
- Point::new(1, 0)..Point::new(1, 0),
- Point::new(1, 1)..Point::new(1, 1),
- ],
- "\t",
- Some(ctx),
- )
- .unwrap();
- });
-
- view.update(app, |view, ctx| {
- view.move_down(&(), ctx);
- assert_eq!(
- view.selection_ranges(ctx.as_ref()),
- &[DisplayPoint::new(1, 0)..DisplayPoint::new(1, 0)]
- );
-
- view.move_right(&(), ctx);
- assert_eq!(
- view.selection_ranges(ctx.as_ref()),
- &[DisplayPoint::new(1, 4)..DisplayPoint::new(1, 4)]
- );
-
- view.move_left(&(), ctx);
- assert_eq!(
- view.selection_ranges(ctx.as_ref()),
- &[DisplayPoint::new(1, 0)..DisplayPoint::new(1, 0)]
- );
-
- view.move_up(&(), ctx);
- assert_eq!(
- view.selection_ranges(ctx.as_ref()),
- &[DisplayPoint::new(0, 0)..DisplayPoint::new(0, 0)]
- );
-
- view.move_to_end(&(), ctx);
- assert_eq!(
- view.selection_ranges(ctx.as_ref()),
- &[DisplayPoint::new(5, 6)..DisplayPoint::new(5, 6)]
- );
-
- view.move_to_beginning(&(), ctx);
- assert_eq!(
- view.selection_ranges(ctx.as_ref()),
- &[DisplayPoint::new(0, 0)..DisplayPoint::new(0, 0)]
- );
-
- view.select_display_ranges(
- &[DisplayPoint::new(0, 1)..DisplayPoint::new(0, 2)],
- ctx,
- )
- .unwrap();
- view.select_to_beginning(&(), ctx);
- assert_eq!(
- view.selection_ranges(ctx.as_ref()),
- &[DisplayPoint::new(0, 1)..DisplayPoint::new(0, 0)]
- );
-
- view.select_to_end(&(), ctx);
- assert_eq!(
- view.selection_ranges(ctx.as_ref()),
- &[DisplayPoint::new(0, 1)..DisplayPoint::new(5, 6)]
- );
- });
- });
- }
+ #[gpui::test]
+ fn test_move_cursor(app: &mut gpui::MutableAppContext) {
+ let buffer = app.add_model(|ctx| Buffer::new(0, sample_text(6, 6), ctx));
+ let settings = settings::channel(&app.font_cache()).unwrap().1;
+ let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx));
- #[test]
- fn test_beginning_end_of_line() {
- App::test((), |app| {
- let buffer = app.add_model(|ctx| Buffer::new(0, "abc\n def", ctx));
- let settings = settings::channel(&app.font_cache()).unwrap().1;
- let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
- view.update(app, |view, ctx| {
- view.select_display_ranges(
- &[
- DisplayPoint::new(0, 1)..DisplayPoint::new(0, 1),
- DisplayPoint::new(1, 4)..DisplayPoint::new(1, 4),
+ buffer.update(app, |buffer, ctx| {
+ buffer
+ .edit(
+ vec![
+ Point::new(1, 0)..Point::new(1, 0),
+ Point::new(1, 1)..Point::new(1, 1),
],
- ctx,
+ "\t",
+ Some(ctx),
)
.unwrap();
- });
-
- view.update(app, |view, ctx| view.move_to_beginning_of_line(&(), ctx));
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[
- DisplayPoint::new(0, 0)..DisplayPoint::new(0, 0),
- DisplayPoint::new(1, 2)..DisplayPoint::new(1, 2),
- ]
- );
+ });
- view.update(app, |view, ctx| view.move_to_beginning_of_line(&(), ctx));
+ view.update(app, |view, ctx| {
+ view.move_down(&(), ctx);
assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[
- DisplayPoint::new(0, 0)..DisplayPoint::new(0, 0),
- DisplayPoint::new(1, 0)..DisplayPoint::new(1, 0),
- ]
+ view.selection_ranges(ctx.as_ref()),
+ &[DisplayPoint::new(1, 0)..DisplayPoint::new(1, 0)]
);
- view.update(app, |view, ctx| view.move_to_beginning_of_line(&(), ctx));
+ view.move_right(&(), ctx);
assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[
- DisplayPoint::new(0, 0)..DisplayPoint::new(0, 0),
- DisplayPoint::new(1, 2)..DisplayPoint::new(1, 2),
- ]
+ view.selection_ranges(ctx.as_ref()),
+ &[DisplayPoint::new(1, 4)..DisplayPoint::new(1, 4)]
);
- view.update(app, |view, ctx| view.move_to_end_of_line(&(), ctx));
+ view.move_left(&(), ctx);
assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[
- DisplayPoint::new(0, 3)..DisplayPoint::new(0, 3),
- DisplayPoint::new(1, 5)..DisplayPoint::new(1, 5),
- ]
+ view.selection_ranges(ctx.as_ref()),
+ &[DisplayPoint::new(1, 0)..DisplayPoint::new(1, 0)]
);
- // Moving to the end of line again is a no-op.
- view.update(app, |view, ctx| view.move_to_end_of_line(&(), ctx));
+ view.move_up(&(), ctx);
assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[
- DisplayPoint::new(0, 3)..DisplayPoint::new(0, 3),
- DisplayPoint::new(1, 5)..DisplayPoint::new(1, 5),
- ]
+ view.selection_ranges(ctx.as_ref()),
+ &[DisplayPoint::new(0, 0)..DisplayPoint::new(0, 0)]
);
- view.update(app, |view, ctx| {
- view.move_left(&(), ctx);
- view.select_to_beginning_of_line(&true, ctx);
- });
+ view.move_to_end(&(), ctx);
assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[
- DisplayPoint::new(0, 2)..DisplayPoint::new(0, 0),
- DisplayPoint::new(1, 4)..DisplayPoint::new(1, 2),
- ]
+ view.selection_ranges(ctx.as_ref()),
+ &[DisplayPoint::new(5, 6)..DisplayPoint::new(5, 6)]
);
- view.update(app, |view, ctx| {
- view.select_to_beginning_of_line(&true, ctx)
- });
+ view.move_to_beginning(&(), ctx);
assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[
- DisplayPoint::new(0, 2)..DisplayPoint::new(0, 0),
- DisplayPoint::new(1, 4)..DisplayPoint::new(1, 0),
- ]
+ view.selection_ranges(ctx.as_ref()),
+ &[DisplayPoint::new(0, 0)..DisplayPoint::new(0, 0)]
);
- view.update(app, |view, ctx| {
- view.select_to_beginning_of_line(&true, ctx)
- });
+ view.select_display_ranges(&[DisplayPoint::new(0, 1)..DisplayPoint::new(0, 2)], ctx)
+ .unwrap();
+ view.select_to_beginning(&(), ctx);
assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[
- DisplayPoint::new(0, 2)..DisplayPoint::new(0, 0),
- DisplayPoint::new(1, 4)..DisplayPoint::new(1, 2),
- ]
+ view.selection_ranges(ctx.as_ref()),
+ &[DisplayPoint::new(0, 1)..DisplayPoint::new(0, 0)]
);
- view.update(app, |view, ctx| view.select_to_end_of_line(&(), ctx));
+ view.select_to_end(&(), ctx);
assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[
- DisplayPoint::new(0, 2)..DisplayPoint::new(0, 3),
- DisplayPoint::new(1, 4)..DisplayPoint::new(1, 5),
- ]
+ view.selection_ranges(ctx.as_ref()),
+ &[DisplayPoint::new(0, 1)..DisplayPoint::new(5, 6)]
);
+ });
+ }
- view.update(app, |view, ctx| view.delete_to_end_of_line(&(), ctx));
- assert_eq!(view.read(app).text(app.as_ref()), "ab\n de");
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
+ #[gpui::test]
+ fn test_beginning_end_of_line(app: &mut gpui::MutableAppContext) {
+ let buffer = app.add_model(|ctx| Buffer::new(0, "abc\n def", ctx));
+ let settings = settings::channel(&app.font_cache()).unwrap().1;
+ let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
+ view.update(app, |view, ctx| {
+ view.select_display_ranges(
&[
- DisplayPoint::new(0, 2)..DisplayPoint::new(0, 2),
+ DisplayPoint::new(0, 1)..DisplayPoint::new(0, 1),
DisplayPoint::new(1, 4)..DisplayPoint::new(1, 4),
- ]
- );
-
- view.update(app, |view, ctx| view.delete_to_beginning_of_line(&(), ctx));
- assert_eq!(view.read(app).text(app.as_ref()), "\n");
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[
- DisplayPoint::new(0, 0)..DisplayPoint::new(0, 0),
- DisplayPoint::new(1, 0)..DisplayPoint::new(1, 0),
- ]
- );
+ ],
+ ctx,
+ )
+ .unwrap();
});
- }
- #[test]
- fn test_prev_next_word_boundary() {
- App::test((), |app| {
- let buffer = app
- .add_model(|ctx| Buffer::new(0, "use std::str::{foo, bar}\n\n {baz.qux()}", ctx));
- let settings = settings::channel(&app.font_cache()).unwrap().1;
- let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
- view.update(app, |view, ctx| {
- view.select_display_ranges(
- &[
- DisplayPoint::new(0, 11)..DisplayPoint::new(0, 11),
- DisplayPoint::new(2, 4)..DisplayPoint::new(2, 4),
- ],
- ctx,
- )
- .unwrap();
- });
+ view.update(app, |view, ctx| view.move_to_beginning_of_line(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 0)..DisplayPoint::new(0, 0),
+ DisplayPoint::new(1, 2)..DisplayPoint::new(1, 2),
+ ]
+ );
- view.update(app, |view, ctx| {
- view.move_to_previous_word_boundary(&(), ctx)
- });
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[
- DisplayPoint::new(0, 9)..DisplayPoint::new(0, 9),
- DisplayPoint::new(2, 3)..DisplayPoint::new(2, 3),
- ]
- );
+ view.update(app, |view, ctx| view.move_to_beginning_of_line(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 0)..DisplayPoint::new(0, 0),
+ DisplayPoint::new(1, 0)..DisplayPoint::new(1, 0),
+ ]
+ );
- view.update(app, |view, ctx| {
- view.move_to_previous_word_boundary(&(), ctx)
- });
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[
- DisplayPoint::new(0, 7)..DisplayPoint::new(0, 7),
- DisplayPoint::new(2, 2)..DisplayPoint::new(2, 2),
- ]
- );
+ view.update(app, |view, ctx| view.move_to_beginning_of_line(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 0)..DisplayPoint::new(0, 0),
+ DisplayPoint::new(1, 2)..DisplayPoint::new(1, 2),
+ ]
+ );
- view.update(app, |view, ctx| {
- view.move_to_previous_word_boundary(&(), ctx)
- });
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[
- DisplayPoint::new(0, 4)..DisplayPoint::new(0, 4),
- DisplayPoint::new(2, 0)..DisplayPoint::new(2, 0),
- ]
- );
+ view.update(app, |view, ctx| view.move_to_end_of_line(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 3)..DisplayPoint::new(0, 3),
+ DisplayPoint::new(1, 5)..DisplayPoint::new(1, 5),
+ ]
+ );
- view.update(app, |view, ctx| {
- view.move_to_previous_word_boundary(&(), ctx)
- });
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[
- DisplayPoint::new(0, 3)..DisplayPoint::new(0, 3),
- DisplayPoint::new(1, 0)..DisplayPoint::new(1, 0),
- ]
- );
+ // Moving to the end of line again is a no-op.
+ view.update(app, |view, ctx| view.move_to_end_of_line(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 3)..DisplayPoint::new(0, 3),
+ DisplayPoint::new(1, 5)..DisplayPoint::new(1, 5),
+ ]
+ );
- view.update(app, |view, ctx| {
- view.move_to_previous_word_boundary(&(), ctx)
- });
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[
- DisplayPoint::new(0, 0)..DisplayPoint::new(0, 0),
- DisplayPoint::new(0, 24)..DisplayPoint::new(0, 24),
- ]
- );
+ view.update(app, |view, ctx| {
+ view.move_left(&(), ctx);
+ view.select_to_beginning_of_line(&true, ctx);
+ });
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 2)..DisplayPoint::new(0, 0),
+ DisplayPoint::new(1, 4)..DisplayPoint::new(1, 2),
+ ]
+ );
- view.update(app, |view, ctx| {
- view.move_to_previous_word_boundary(&(), ctx)
- });
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[
- DisplayPoint::new(0, 0)..DisplayPoint::new(0, 0),
- DisplayPoint::new(0, 23)..DisplayPoint::new(0, 23),
- ]
- );
+ view.update(app, |view, ctx| {
+ view.select_to_beginning_of_line(&true, ctx)
+ });
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 2)..DisplayPoint::new(0, 0),
+ DisplayPoint::new(1, 4)..DisplayPoint::new(1, 0),
+ ]
+ );
- view.update(app, |view, ctx| view.move_to_next_word_boundary(&(), ctx));
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[
- DisplayPoint::new(0, 3)..DisplayPoint::new(0, 3),
- DisplayPoint::new(0, 24)..DisplayPoint::new(0, 24),
- ]
- );
+ view.update(app, |view, ctx| {
+ view.select_to_beginning_of_line(&true, ctx)
+ });
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 2)..DisplayPoint::new(0, 0),
+ DisplayPoint::new(1, 4)..DisplayPoint::new(1, 2),
+ ]
+ );
- view.update(app, |view, ctx| view.move_to_next_word_boundary(&(), ctx));
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[
- DisplayPoint::new(0, 4)..DisplayPoint::new(0, 4),
- DisplayPoint::new(1, 0)..DisplayPoint::new(1, 0),
- ]
- );
+ view.update(app, |view, ctx| view.select_to_end_of_line(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 2)..DisplayPoint::new(0, 3),
+ DisplayPoint::new(1, 4)..DisplayPoint::new(1, 5),
+ ]
+ );
- view.update(app, |view, ctx| view.move_to_next_word_boundary(&(), ctx));
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[
- DisplayPoint::new(0, 7)..DisplayPoint::new(0, 7),
- DisplayPoint::new(2, 0)..DisplayPoint::new(2, 0),
- ]
- );
+ view.update(app, |view, ctx| view.delete_to_end_of_line(&(), ctx));
+ assert_eq!(view.read(app).text(app.as_ref()), "ab\n de");
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 2)..DisplayPoint::new(0, 2),
+ DisplayPoint::new(1, 4)..DisplayPoint::new(1, 4),
+ ]
+ );
- view.update(app, |view, ctx| view.move_to_next_word_boundary(&(), ctx));
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[
- DisplayPoint::new(0, 9)..DisplayPoint::new(0, 9),
- DisplayPoint::new(2, 2)..DisplayPoint::new(2, 2),
- ]
- );
+ view.update(app, |view, ctx| view.delete_to_beginning_of_line(&(), ctx));
+ assert_eq!(view.read(app).text(app.as_ref()), "\n");
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 0)..DisplayPoint::new(0, 0),
+ DisplayPoint::new(1, 0)..DisplayPoint::new(1, 0),
+ ]
+ );
+ }
- view.update(app, |view, ctx| {
- view.move_right(&(), ctx);
- view.select_to_previous_word_boundary(&(), ctx);
- });
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
+ #[gpui::test]
+ fn test_prev_next_word_boundary(app: &mut gpui::MutableAppContext) {
+ let buffer =
+ app.add_model(|ctx| Buffer::new(0, "use std::str::{foo, bar}\n\n {baz.qux()}", ctx));
+ let settings = settings::channel(&app.font_cache()).unwrap().1;
+ let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
+ view.update(app, |view, ctx| {
+ view.select_display_ranges(
&[
- DisplayPoint::new(0, 10)..DisplayPoint::new(0, 9),
- DisplayPoint::new(2, 3)..DisplayPoint::new(2, 2),
- ]
- );
+ DisplayPoint::new(0, 11)..DisplayPoint::new(0, 11),
+ DisplayPoint::new(2, 4)..DisplayPoint::new(2, 4),
+ ],
+ ctx,
+ )
+ .unwrap();
+ });
- view.update(app, |view, ctx| {
- view.select_to_previous_word_boundary(&(), ctx)
- });
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[
- DisplayPoint::new(0, 10)..DisplayPoint::new(0, 7),
- DisplayPoint::new(2, 3)..DisplayPoint::new(2, 0),
- ]
- );
+ view.update(app, |view, ctx| {
+ view.move_to_previous_word_boundary(&(), ctx)
+ });
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 9)..DisplayPoint::new(0, 9),
+ DisplayPoint::new(2, 3)..DisplayPoint::new(2, 3),
+ ]
+ );
- view.update(app, |view, ctx| view.select_to_next_word_boundary(&(), ctx));
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[
- DisplayPoint::new(0, 10)..DisplayPoint::new(0, 9),
- DisplayPoint::new(2, 3)..DisplayPoint::new(2, 2),
- ]
- );
+ view.update(app, |view, ctx| {
+ view.move_to_previous_word_boundary(&(), ctx)
+ });
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 7)..DisplayPoint::new(0, 7),
+ DisplayPoint::new(2, 2)..DisplayPoint::new(2, 2),
+ ]
+ );
- view.update(app, |view, ctx| view.delete_to_next_word_boundary(&(), ctx));
- assert_eq!(
- view.read(app).text(app.as_ref()),
- "use std::s::{foo, bar}\n\n {az.qux()}"
- );
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[
- DisplayPoint::new(0, 10)..DisplayPoint::new(0, 10),
- DisplayPoint::new(2, 3)..DisplayPoint::new(2, 3),
- ]
- );
+ view.update(app, |view, ctx| {
+ view.move_to_previous_word_boundary(&(), ctx)
+ });
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 4)..DisplayPoint::new(0, 4),
+ DisplayPoint::new(2, 0)..DisplayPoint::new(2, 0),
+ ]
+ );
- view.update(app, |view, ctx| {
- view.delete_to_previous_word_boundary(&(), ctx)
- });
- assert_eq!(
- view.read(app).text(app.as_ref()),
- "use std::::{foo, bar}\n\n az.qux()}"
- );
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[
- DisplayPoint::new(0, 9)..DisplayPoint::new(0, 9),
- DisplayPoint::new(2, 2)..DisplayPoint::new(2, 2),
- ]
- );
+ view.update(app, |view, ctx| {
+ view.move_to_previous_word_boundary(&(), ctx)
});
- }
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 3)..DisplayPoint::new(0, 3),
+ DisplayPoint::new(1, 0)..DisplayPoint::new(1, 0),
+ ]
+ );
- #[test]
- fn test_backspace() {
- App::test((), |app| {
- let buffer = app.add_model(|ctx| {
- Buffer::new(
- 0,
- "one two three\nfour five six\nseven eight nine\nten\n",
- ctx,
- )
- });
- let settings = settings::channel(&app.font_cache()).unwrap().1;
- let (_, view) =
- app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx));
-
- view.update(app, |view, ctx| {
- view.select_display_ranges(
- &[
- // an empty selection - the preceding character is deleted
- DisplayPoint::new(0, 2)..DisplayPoint::new(0, 2),
- // one character selected - it is deleted
- DisplayPoint::new(1, 4)..DisplayPoint::new(1, 3),
- // a line suffix selected - it is deleted
- DisplayPoint::new(2, 6)..DisplayPoint::new(3, 0),
- ],
- ctx,
- )
- .unwrap();
- view.backspace(&(), ctx);
- });
+ view.update(app, |view, ctx| {
+ view.move_to_previous_word_boundary(&(), ctx)
+ });
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 0)..DisplayPoint::new(0, 0),
+ DisplayPoint::new(0, 24)..DisplayPoint::new(0, 24),
+ ]
+ );
- assert_eq!(
- buffer.read(app).text(),
- "oe two three\nfou five six\nseven ten\n"
- );
- })
+ view.update(app, |view, ctx| {
+ view.move_to_previous_word_boundary(&(), ctx)
+ });
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 0)..DisplayPoint::new(0, 0),
+ DisplayPoint::new(0, 23)..DisplayPoint::new(0, 23),
+ ]
+ );
+
+ view.update(app, |view, ctx| view.move_to_next_word_boundary(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 3)..DisplayPoint::new(0, 3),
+ DisplayPoint::new(0, 24)..DisplayPoint::new(0, 24),
+ ]
+ );
+
+ view.update(app, |view, ctx| view.move_to_next_word_boundary(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 4)..DisplayPoint::new(0, 4),
+ DisplayPoint::new(1, 0)..DisplayPoint::new(1, 0),
+ ]
+ );
+
+ view.update(app, |view, ctx| view.move_to_next_word_boundary(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 7)..DisplayPoint::new(0, 7),
+ DisplayPoint::new(2, 0)..DisplayPoint::new(2, 0),
+ ]
+ );
+
+ view.update(app, |view, ctx| view.move_to_next_word_boundary(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 9)..DisplayPoint::new(0, 9),
+ DisplayPoint::new(2, 2)..DisplayPoint::new(2, 2),
+ ]
+ );
+
+ view.update(app, |view, ctx| {
+ view.move_right(&(), ctx);
+ view.select_to_previous_word_boundary(&(), ctx);
+ });
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 10)..DisplayPoint::new(0, 9),
+ DisplayPoint::new(2, 3)..DisplayPoint::new(2, 2),
+ ]
+ );
+
+ view.update(app, |view, ctx| {
+ view.select_to_previous_word_boundary(&(), ctx)
+ });
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 10)..DisplayPoint::new(0, 7),
+ DisplayPoint::new(2, 3)..DisplayPoint::new(2, 0),
+ ]
+ );
+
+ view.update(app, |view, ctx| view.select_to_next_word_boundary(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 10)..DisplayPoint::new(0, 9),
+ DisplayPoint::new(2, 3)..DisplayPoint::new(2, 2),
+ ]
+ );
+
+ view.update(app, |view, ctx| view.delete_to_next_word_boundary(&(), ctx));
+ assert_eq!(
+ view.read(app).text(app.as_ref()),
+ "use std::s::{foo, bar}\n\n {az.qux()}"
+ );
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 10)..DisplayPoint::new(0, 10),
+ DisplayPoint::new(2, 3)..DisplayPoint::new(2, 3),
+ ]
+ );
+
+ view.update(app, |view, ctx| {
+ view.delete_to_previous_word_boundary(&(), ctx)
+ });
+ assert_eq!(
+ view.read(app).text(app.as_ref()),
+ "use std::::{foo, bar}\n\n az.qux()}"
+ );
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 9)..DisplayPoint::new(0, 9),
+ DisplayPoint::new(2, 2)..DisplayPoint::new(2, 2),
+ ]
+ );
}
- #[test]
- fn test_delete() {
- App::test((), |app| {
- let buffer = app.add_model(|ctx| {
- Buffer::new(
- 0,
- "one two three\nfour five six\nseven eight nine\nten\n",
- ctx,
- )
- });
- let settings = settings::channel(&app.font_cache()).unwrap().1;
- let (_, view) =
- app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx));
-
- view.update(app, |view, ctx| {
- view.select_display_ranges(
- &[
- // an empty selection - the following character is deleted
- DisplayPoint::new(0, 2)..DisplayPoint::new(0, 2),
- // one character selected - it is deleted
- DisplayPoint::new(1, 4)..DisplayPoint::new(1, 3),
- // a line suffix selected - it is deleted
- DisplayPoint::new(2, 6)..DisplayPoint::new(3, 0),
- ],
- ctx,
- )
- .unwrap();
- view.delete(&(), ctx);
- });
+ #[gpui::test]
+ fn test_backspace(app: &mut gpui::MutableAppContext) {
+ let buffer = app.add_model(|ctx| {
+ Buffer::new(
+ 0,
+ "one two three\nfour five six\nseven eight nine\nten\n",
+ ctx,
+ )
+ });
+ let settings = settings::channel(&app.font_cache()).unwrap().1;
+ let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx));
- assert_eq!(
- buffer.read(app).text(),
- "on two three\nfou five six\nseven ten\n"
- );
- })
- }
-
- #[test]
- fn test_delete_line() {
- App::test((), |app| {
- let settings = settings::channel(&app.font_cache()).unwrap().1;
- let buffer = app.add_model(|ctx| Buffer::new(0, "abc\ndef\nghi\n", ctx));
- let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
- view.update(app, |view, ctx| {
- view.select_display_ranges(
- &[
- DisplayPoint::new(0, 1)..DisplayPoint::new(0, 1),
- DisplayPoint::new(1, 0)..DisplayPoint::new(1, 1),
- DisplayPoint::new(3, 0)..DisplayPoint::new(3, 0),
- ],
- ctx,
- )
- .unwrap();
- view.delete_line(&(), ctx);
- });
- assert_eq!(view.read(app).text(app.as_ref()), "ghi");
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- vec![
- DisplayPoint::new(0, 0)..DisplayPoint::new(0, 0),
- DisplayPoint::new(0, 1)..DisplayPoint::new(0, 1)
- ]
- );
+ view.update(app, |view, ctx| {
+ view.select_display_ranges(
+ &[
+ // an empty selection - the preceding character is deleted
+ DisplayPoint::new(0, 2)..DisplayPoint::new(0, 2),
+ // one character selected - it is deleted
+ DisplayPoint::new(1, 4)..DisplayPoint::new(1, 3),
+ // a line suffix selected - it is deleted
+ DisplayPoint::new(2, 6)..DisplayPoint::new(3, 0),
+ ],
+ ctx,
+ )
+ .unwrap();
+ view.backspace(&(), ctx);
+ });
- let settings = settings::channel(&app.font_cache()).unwrap().1;
- let buffer = app.add_model(|ctx| Buffer::new(0, "abc\ndef\nghi\n", ctx));
- let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
- view.update(app, |view, ctx| {
- view.select_display_ranges(
- &[DisplayPoint::new(2, 0)..DisplayPoint::new(0, 1)],
- ctx,
- )
- .unwrap();
- view.delete_line(&(), ctx);
- });
- assert_eq!(view.read(app).text(app.as_ref()), "ghi\n");
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- vec![DisplayPoint::new(0, 1)..DisplayPoint::new(0, 1)]
- );
+ assert_eq!(
+ buffer.read(app).text(),
+ "oe two three\nfou five six\nseven ten\n"
+ );
+ }
+
+ #[gpui::test]
+ fn test_delete(app: &mut gpui::MutableAppContext) {
+ let buffer = app.add_model(|ctx| {
+ Buffer::new(
+ 0,
+ "one two three\nfour five six\nseven eight nine\nten\n",
+ ctx,
+ )
+ });
+ let settings = settings::channel(&app.font_cache()).unwrap().1;
+ let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx));
+
+ view.update(app, |view, ctx| {
+ view.select_display_ranges(
+ &[
+ // an empty selection - the following character is deleted
+ DisplayPoint::new(0, 2)..DisplayPoint::new(0, 2),
+ // one character selected - it is deleted
+ DisplayPoint::new(1, 4)..DisplayPoint::new(1, 3),
+ // a line suffix selected - it is deleted
+ DisplayPoint::new(2, 6)..DisplayPoint::new(3, 0),
+ ],
+ ctx,
+ )
+ .unwrap();
+ view.delete(&(), ctx);
});
+
+ assert_eq!(
+ buffer.read(app).text(),
+ "on two three\nfou five six\nseven ten\n"
+ );
}
- #[test]
- fn test_duplicate_line() {
- App::test((), |app| {
- let settings = settings::channel(&app.font_cache()).unwrap().1;
- let buffer = app.add_model(|ctx| Buffer::new(0, "abc\ndef\nghi\n", ctx));
- let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
- view.update(app, |view, ctx| {
- view.select_display_ranges(
- &[
- DisplayPoint::new(0, 0)..DisplayPoint::new(0, 1),
- DisplayPoint::new(0, 2)..DisplayPoint::new(0, 2),
- DisplayPoint::new(1, 0)..DisplayPoint::new(1, 0),
- DisplayPoint::new(3, 0)..DisplayPoint::new(3, 0),
- ],
- ctx,
- )
- .unwrap();
- view.duplicate_line(&(), ctx);
- });
- assert_eq!(
- view.read(app).text(app.as_ref()),
- "abc\nabc\ndef\ndef\nghi\n\n"
- );
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- vec![
+ #[gpui::test]
+ fn test_delete_line(app: &mut gpui::MutableAppContext) {
+ let settings = settings::channel(&app.font_cache()).unwrap().1;
+ let buffer = app.add_model(|ctx| Buffer::new(0, "abc\ndef\nghi\n", ctx));
+ let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
+ view.update(app, |view, ctx| {
+ view.select_display_ranges(
+ &[
+ DisplayPoint::new(0, 1)..DisplayPoint::new(0, 1),
DisplayPoint::new(1, 0)..DisplayPoint::new(1, 1),
- DisplayPoint::new(1, 2)..DisplayPoint::new(1, 2),
DisplayPoint::new(3, 0)..DisplayPoint::new(3, 0),
- DisplayPoint::new(6, 0)..DisplayPoint::new(6, 0),
- ]
- );
+ ],
+ ctx,
+ )
+ .unwrap();
+ view.delete_line(&(), ctx);
+ });
+ assert_eq!(view.read(app).text(app.as_ref()), "ghi");
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ vec![
+ DisplayPoint::new(0, 0)..DisplayPoint::new(0, 0),
+ DisplayPoint::new(0, 1)..DisplayPoint::new(0, 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 (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
- view.update(app, |view, ctx| {
- view.select_display_ranges(
- &[
- DisplayPoint::new(0, 1)..DisplayPoint::new(1, 1),
- DisplayPoint::new(1, 2)..DisplayPoint::new(2, 1),
- ],
- ctx,
- )
+ let settings = settings::channel(&app.font_cache()).unwrap().1;
+ let buffer = app.add_model(|ctx| Buffer::new(0, "abc\ndef\nghi\n", ctx));
+ let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
+ view.update(app, |view, ctx| {
+ view.select_display_ranges(&[DisplayPoint::new(2, 0)..DisplayPoint::new(0, 1)], ctx)
.unwrap();
- view.duplicate_line(&(), ctx);
- });
- assert_eq!(
- view.read(app).text(app.as_ref()),
- "abc\ndef\nghi\nabc\ndef\nghi\n"
- );
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- vec![
- DisplayPoint::new(3, 1)..DisplayPoint::new(4, 1),
- DisplayPoint::new(4, 2)..DisplayPoint::new(5, 1),
- ]
- );
+ view.delete_line(&(), ctx);
});
+ assert_eq!(view.read(app).text(app.as_ref()), "ghi\n");
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ vec![DisplayPoint::new(0, 1)..DisplayPoint::new(0, 1)]
+ );
}
- #[test]
- fn test_move_line_up_down() {
- App::test((), |app| {
- let settings = settings::channel(&app.font_cache()).unwrap().1;
- let buffer = app.add_model(|ctx| Buffer::new(0, sample_text(10, 5), ctx));
- let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
- view.update(app, |view, ctx| {
- view.fold_ranges(
- vec![
- Point::new(0, 2)..Point::new(1, 2),
- Point::new(2, 3)..Point::new(4, 1),
- Point::new(7, 0)..Point::new(8, 4),
- ],
- ctx,
- );
- view.select_display_ranges(
- &[
- DisplayPoint::new(0, 1)..DisplayPoint::new(0, 1),
- DisplayPoint::new(3, 1)..DisplayPoint::new(3, 1),
- DisplayPoint::new(3, 2)..DisplayPoint::new(4, 2),
- DisplayPoint::new(5, 0)..DisplayPoint::new(5, 2),
- ],
- ctx,
- )
- .unwrap();
- });
- assert_eq!(
- view.read(app).text(app.as_ref()),
- "aa…bbb\nccc…eeee\nfffff\nggggg\n…i\njjjjj"
- );
+ #[gpui::test]
+ fn test_duplicate_line(app: &mut gpui::MutableAppContext) {
+ let settings = settings::channel(&app.font_cache()).unwrap().1;
+ let buffer = app.add_model(|ctx| Buffer::new(0, "abc\ndef\nghi\n", ctx));
+ let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
+ view.update(app, |view, ctx| {
+ view.select_display_ranges(
+ &[
+ DisplayPoint::new(0, 0)..DisplayPoint::new(0, 1),
+ DisplayPoint::new(0, 2)..DisplayPoint::new(0, 2),
+ DisplayPoint::new(1, 0)..DisplayPoint::new(1, 0),
+ DisplayPoint::new(3, 0)..DisplayPoint::new(3, 0),
+ ],
+ ctx,
+ )
+ .unwrap();
+ view.duplicate_line(&(), ctx);
+ });
+ assert_eq!(
+ view.read(app).text(app.as_ref()),
+ "abc\nabc\ndef\ndef\nghi\n\n"
+ );
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ vec![
+ DisplayPoint::new(1, 0)..DisplayPoint::new(1, 1),
+ DisplayPoint::new(1, 2)..DisplayPoint::new(1, 2),
+ DisplayPoint::new(3, 0)..DisplayPoint::new(3, 0),
+ DisplayPoint::new(6, 0)..DisplayPoint::new(6, 0),
+ ]
+ );
- view.update(app, |view, ctx| view.move_line_up(&(), ctx));
- assert_eq!(
- view.read(app).text(app.as_ref()),
- "aa…bbb\nccc…eeee\nggggg\n…i\njjjjj\nfffff"
- );
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- vec![
- DisplayPoint::new(0, 1)..DisplayPoint::new(0, 1),
- DisplayPoint::new(2, 1)..DisplayPoint::new(2, 1),
- DisplayPoint::new(2, 2)..DisplayPoint::new(3, 2),
- DisplayPoint::new(4, 0)..DisplayPoint::new(4, 2)
- ]
- );
+ let settings = settings::channel(&app.font_cache()).unwrap().1;
+ let buffer = app.add_model(|ctx| Buffer::new(0, "abc\ndef\nghi\n", ctx));
+ let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
+ view.update(app, |view, ctx| {
+ view.select_display_ranges(
+ &[
+ DisplayPoint::new(0, 1)..DisplayPoint::new(1, 1),
+ DisplayPoint::new(1, 2)..DisplayPoint::new(2, 1),
+ ],
+ ctx,
+ )
+ .unwrap();
+ view.duplicate_line(&(), ctx);
+ });
+ assert_eq!(
+ view.read(app).text(app.as_ref()),
+ "abc\ndef\nghi\nabc\ndef\nghi\n"
+ );
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ vec![
+ DisplayPoint::new(3, 1)..DisplayPoint::new(4, 1),
+ DisplayPoint::new(4, 2)..DisplayPoint::new(5, 1),
+ ]
+ );
+ }
- view.update(app, |view, ctx| view.move_line_down(&(), ctx));
- assert_eq!(
- view.read(app).text(app.as_ref()),
- "ccc…eeee\naa…bbb\nfffff\nggggg\n…i\njjjjj"
- );
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
+ #[gpui::test]
+ fn test_move_line_up_down(app: &mut gpui::MutableAppContext) {
+ let settings = settings::channel(&app.font_cache()).unwrap().1;
+ let buffer = app.add_model(|ctx| Buffer::new(0, sample_text(10, 5), ctx));
+ let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
+ view.update(app, |view, ctx| {
+ view.fold_ranges(
vec![
- DisplayPoint::new(1, 1)..DisplayPoint::new(1, 1),
- DisplayPoint::new(3, 1)..DisplayPoint::new(3, 1),
- DisplayPoint::new(3, 2)..DisplayPoint::new(4, 2),
- DisplayPoint::new(5, 0)..DisplayPoint::new(5, 2)
- ]
+ Point::new(0, 2)..Point::new(1, 2),
+ Point::new(2, 3)..Point::new(4, 1),
+ Point::new(7, 0)..Point::new(8, 4),
+ ],
+ ctx,
);
-
- view.update(app, |view, ctx| view.move_line_down(&(), ctx));
- assert_eq!(
- view.read(app).text(app.as_ref()),
- "ccc…eeee\nfffff\naa…bbb\nggggg\n…i\njjjjj"
- );
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- vec![
- DisplayPoint::new(2, 1)..DisplayPoint::new(2, 1),
+ view.select_display_ranges(
+ &[
+ DisplayPoint::new(0, 1)..DisplayPoint::new(0, 1),
DisplayPoint::new(3, 1)..DisplayPoint::new(3, 1),
DisplayPoint::new(3, 2)..DisplayPoint::new(4, 2),
- DisplayPoint::new(5, 0)..DisplayPoint::new(5, 2)
- ]
- );
-
- view.update(app, |view, ctx| view.move_line_up(&(), ctx));
- assert_eq!(
- view.read(app).text(app.as_ref()),
- "ccc…eeee\naa…bbb\nggggg\n…i\njjjjj\nfffff"
- );
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- vec![
- DisplayPoint::new(1, 1)..DisplayPoint::new(1, 1),
- DisplayPoint::new(2, 1)..DisplayPoint::new(2, 1),
- DisplayPoint::new(2, 2)..DisplayPoint::new(3, 2),
- DisplayPoint::new(4, 0)..DisplayPoint::new(4, 2)
- ]
- );
+ DisplayPoint::new(5, 0)..DisplayPoint::new(5, 2),
+ ],
+ ctx,
+ )
+ .unwrap();
});
+ assert_eq!(
+ view.read(app).text(app.as_ref()),
+ "aa…bbb\nccc…eeee\nfffff\nggggg\n…i\njjjjj"
+ );
+
+ view.update(app, |view, ctx| view.move_line_up(&(), ctx));
+ assert_eq!(
+ view.read(app).text(app.as_ref()),
+ "aa…bbb\nccc…eeee\nggggg\n…i\njjjjj\nfffff"
+ );
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ vec![
+ DisplayPoint::new(0, 1)..DisplayPoint::new(0, 1),
+ DisplayPoint::new(2, 1)..DisplayPoint::new(2, 1),
+ DisplayPoint::new(2, 2)..DisplayPoint::new(3, 2),
+ DisplayPoint::new(4, 0)..DisplayPoint::new(4, 2)
+ ]
+ );
+
+ view.update(app, |view, ctx| view.move_line_down(&(), ctx));
+ assert_eq!(
+ view.read(app).text(app.as_ref()),
+ "ccc…eeee\naa…bbb\nfffff\nggggg\n…i\njjjjj"
+ );
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ vec![
+ DisplayPoint::new(1, 1)..DisplayPoint::new(1, 1),
+ DisplayPoint::new(3, 1)..DisplayPoint::new(3, 1),
+ DisplayPoint::new(3, 2)..DisplayPoint::new(4, 2),
+ DisplayPoint::new(5, 0)..DisplayPoint::new(5, 2)
+ ]
+ );
+
+ view.update(app, |view, ctx| view.move_line_down(&(), ctx));
+ assert_eq!(
+ view.read(app).text(app.as_ref()),
+ "ccc…eeee\nfffff\naa…bbb\nggggg\n…i\njjjjj"
+ );
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ vec![
+ DisplayPoint::new(2, 1)..DisplayPoint::new(2, 1),
+ DisplayPoint::new(3, 1)..DisplayPoint::new(3, 1),
+ DisplayPoint::new(3, 2)..DisplayPoint::new(4, 2),
+ DisplayPoint::new(5, 0)..DisplayPoint::new(5, 2)
+ ]
+ );
+
+ view.update(app, |view, ctx| view.move_line_up(&(), ctx));
+ assert_eq!(
+ view.read(app).text(app.as_ref()),
+ "ccc…eeee\naa…bbb\nggggg\n…i\njjjjj\nfffff"
+ );
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ vec![
+ DisplayPoint::new(1, 1)..DisplayPoint::new(1, 1),
+ DisplayPoint::new(2, 1)..DisplayPoint::new(2, 1),
+ DisplayPoint::new(2, 2)..DisplayPoint::new(3, 2),
+ DisplayPoint::new(4, 0)..DisplayPoint::new(4, 2)
+ ]
+ );
}
- #[test]
- fn test_clipboard() {
- App::test((), |app| {
- let buffer = app.add_model(|ctx| Buffer::new(0, "one two three four five six ", ctx));
- let settings = settings::channel(&app.font_cache()).unwrap().1;
- let view = app
- .add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx))
- .1;
+ #[gpui::test]
+ fn test_clipboard(app: &mut gpui::MutableAppContext) {
+ let buffer = app.add_model(|ctx| Buffer::new(0, "one two three four five six ", ctx));
+ let settings = settings::channel(&app.font_cache()).unwrap().1;
+ let view = app
+ .add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx))
+ .1;
- // Cut with three selections. Clipboard text is divided into three slices.
- view.update(app, |view, ctx| {
- view.select_ranges(vec![0..4, 8..14, 19..24], false, ctx);
- view.cut(&(), ctx);
- });
- assert_eq!(view.read(app).text(app.as_ref()), "two four six ");
+ // Cut with three selections. Clipboard text is divided into three slices.
+ view.update(app, |view, ctx| {
+ view.select_ranges(vec![0..4, 8..14, 19..24], false, ctx);
+ view.cut(&(), ctx);
+ });
+ assert_eq!(view.read(app).text(app.as_ref()), "two four six ");
- // Paste with three cursors. Each cursor pastes one slice of the clipboard text.
- view.update(app, |view, ctx| {
- view.select_ranges(vec![4..4, 9..9, 13..13], false, ctx);
- view.paste(&(), ctx);
- });
- assert_eq!(
- view.read(app).text(app.as_ref()),
- "two one four three six five "
- );
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[
- DisplayPoint::new(0, 8)..DisplayPoint::new(0, 8),
- DisplayPoint::new(0, 19)..DisplayPoint::new(0, 19),
- DisplayPoint::new(0, 28)..DisplayPoint::new(0, 28)
- ]
- );
+ // Paste with three cursors. Each cursor pastes one slice of the clipboard text.
+ view.update(app, |view, ctx| {
+ view.select_ranges(vec![4..4, 9..9, 13..13], false, ctx);
+ view.paste(&(), ctx);
+ });
+ assert_eq!(
+ view.read(app).text(app.as_ref()),
+ "two one four three six five "
+ );
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 8)..DisplayPoint::new(0, 8),
+ DisplayPoint::new(0, 19)..DisplayPoint::new(0, 19),
+ DisplayPoint::new(0, 28)..DisplayPoint::new(0, 28)
+ ]
+ );
- // Paste again but with only two cursors. Since the number of cursors doesn't
- // match the number of slices in the clipboard, the entire clipboard text
- // is pasted at each cursor.
- view.update(app, |view, ctx| {
- view.select_ranges(vec![0..0, 28..28], false, ctx);
- view.insert(&"( ".to_string(), ctx);
- view.paste(&(), ctx);
- view.insert(&") ".to_string(), ctx);
- });
- assert_eq!(
- view.read(app).text(app.as_ref()),
- "( one three five ) two one four three six five ( one three five ) "
- );
+ // Paste again but with only two cursors. Since the number of cursors doesn't
+ // match the number of slices in the clipboard, the entire clipboard text
+ // is pasted at each cursor.
+ view.update(app, |view, ctx| {
+ view.select_ranges(vec![0..0, 28..28], false, ctx);
+ view.insert(&"( ".to_string(), ctx);
+ view.paste(&(), ctx);
+ view.insert(&") ".to_string(), ctx);
+ });
+ assert_eq!(
+ view.read(app).text(app.as_ref()),
+ "( one three five ) two one four three six five ( one three five ) "
+ );
- view.update(app, |view, ctx| {
- view.select_ranges(vec![0..0], false, ctx);
- view.insert(&"123\n4567\n89\n".to_string(), ctx);
- });
- assert_eq!(
- view.read(app).text(app.as_ref()),
- "123\n4567\n89\n( one three five ) two one four three six five ( one three five ) "
- );
+ view.update(app, |view, ctx| {
+ view.select_ranges(vec![0..0], false, ctx);
+ view.insert(&"123\n4567\n89\n".to_string(), ctx);
+ });
+ assert_eq!(
+ view.read(app).text(app.as_ref()),
+ "123\n4567\n89\n( one three five ) two one four three six five ( one three five ) "
+ );
- // Cut with three selections, one of which is full-line.
- view.update(app, |view, ctx| {
- view.select_display_ranges(
- &[
- DisplayPoint::new(0, 1)..DisplayPoint::new(0, 2),
- DisplayPoint::new(1, 1)..DisplayPoint::new(1, 1),
- DisplayPoint::new(2, 0)..DisplayPoint::new(2, 1),
- ],
- ctx,
- )
- .unwrap();
- view.cut(&(), ctx);
- });
- assert_eq!(
- view.read(app).text(app.as_ref()),
- "13\n9\n( one three five ) two one four three six five ( one three five ) "
- );
+ // Cut with three selections, one of which is full-line.
+ view.update(app, |view, ctx| {
+ view.select_display_ranges(
+ &[
+ DisplayPoint::new(0, 1)..DisplayPoint::new(0, 2),
+ DisplayPoint::new(1, 1)..DisplayPoint::new(1, 1),
+ DisplayPoint::new(2, 0)..DisplayPoint::new(2, 1),
+ ],
+ ctx,
+ )
+ .unwrap();
+ view.cut(&(), ctx);
+ });
+ assert_eq!(
+ view.read(app).text(app.as_ref()),
+ "13\n9\n( one three five ) two one four three six five ( one three five ) "
+ );
- // Paste with three selections, noticing how the copied selection that was full-line
- // gets inserted before the second cursor.
- view.update(app, |view, ctx| {
- view.select_display_ranges(
- &[
- DisplayPoint::new(0, 1)..DisplayPoint::new(0, 1),
- DisplayPoint::new(1, 1)..DisplayPoint::new(1, 1),
- DisplayPoint::new(2, 2)..DisplayPoint::new(2, 3),
- ],
- ctx,
- )
- .unwrap();
- view.paste(&(), ctx);
- });
- assert_eq!(
- view.read(app).text(app.as_ref()),
- "123\n4567\n9\n( 8ne three five ) two one four three six five ( one three five ) "
- );
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
+ // Paste with three selections, noticing how the copied selection that was full-line
+ // gets inserted before the second cursor.
+ view.update(app, |view, ctx| {
+ view.select_display_ranges(
&[
- DisplayPoint::new(0, 2)..DisplayPoint::new(0, 2),
- DisplayPoint::new(2, 1)..DisplayPoint::new(2, 1),
- DisplayPoint::new(3, 3)..DisplayPoint::new(3, 3),
- ]
- );
+ DisplayPoint::new(0, 1)..DisplayPoint::new(0, 1),
+ DisplayPoint::new(1, 1)..DisplayPoint::new(1, 1),
+ DisplayPoint::new(2, 2)..DisplayPoint::new(2, 3),
+ ],
+ ctx,
+ )
+ .unwrap();
+ view.paste(&(), ctx);
+ });
+ assert_eq!(
+ view.read(app).text(app.as_ref()),
+ "123\n4567\n9\n( 8ne three five ) two one four three six five ( one three five ) "
+ );
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(0, 2)..DisplayPoint::new(0, 2),
+ DisplayPoint::new(2, 1)..DisplayPoint::new(2, 1),
+ DisplayPoint::new(3, 3)..DisplayPoint::new(3, 3),
+ ]
+ );
- // Copy with a single cursor only, which writes the whole line into the clipboard.
- view.update(app, |view, ctx| {
- view.select_display_ranges(
- &[DisplayPoint::new(0, 1)..DisplayPoint::new(0, 1)],
- ctx,
- )
+ // Copy with a single cursor only, which writes the whole line into the clipboard.
+ view.update(app, |view, ctx| {
+ view.select_display_ranges(&[DisplayPoint::new(0, 1)..DisplayPoint::new(0, 1)], ctx)
.unwrap();
- view.copy(&(), ctx);
- });
+ view.copy(&(), ctx);
+ });
- // Paste with three selections, noticing how the copied full-line selection is inserted
- // before the empty selections but replaces the selection that is non-empty.
- view.update(app, |view, ctx| {
- view.select_display_ranges(
- &[
- DisplayPoint::new(0, 1)..DisplayPoint::new(0, 1),
- DisplayPoint::new(1, 0)..DisplayPoint::new(1, 2),
- DisplayPoint::new(2, 1)..DisplayPoint::new(2, 1),
- ],
- ctx,
- )
- .unwrap();
- view.paste(&(), ctx);
- });
- assert_eq!(
+ // Paste with three selections, noticing how the copied full-line selection is inserted
+ // before the empty selections but replaces the selection that is non-empty.
+ view.update(app, |view, ctx| {
+ view.select_display_ranges(
+ &[
+ DisplayPoint::new(0, 1)..DisplayPoint::new(0, 1),
+ DisplayPoint::new(1, 0)..DisplayPoint::new(1, 2),
+ DisplayPoint::new(2, 1)..DisplayPoint::new(2, 1),
+ ],
+ ctx,
+ )
+ .unwrap();
+ view.paste(&(), ctx);
+ });
+ assert_eq!(
view.read(app).text(app.as_ref()),
"123\n123\n123\n67\n123\n9\n( 8ne three five ) two one four three six five ( one three five ) "
);
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[
- DisplayPoint::new(1, 1)..DisplayPoint::new(1, 1),
- DisplayPoint::new(3, 0)..DisplayPoint::new(3, 0),
- DisplayPoint::new(5, 1)..DisplayPoint::new(5, 1),
- ]
- );
- });
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[
+ DisplayPoint::new(1, 1)..DisplayPoint::new(1, 1),
+ DisplayPoint::new(3, 0)..DisplayPoint::new(3, 0),
+ DisplayPoint::new(5, 1)..DisplayPoint::new(5, 1),
+ ]
+ );
}
- #[test]
- fn test_select_all() {
- App::test((), |app| {
- let buffer = app.add_model(|ctx| Buffer::new(0, "abc\nde\nfgh", ctx));
- let settings = settings::channel(&app.font_cache()).unwrap().1;
- let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
- view.update(app, |b, ctx| b.select_all(&(), ctx));
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- &[DisplayPoint::new(0, 0)..DisplayPoint::new(2, 3)]
- );
- });
+ #[gpui::test]
+ fn test_select_all(app: &mut gpui::MutableAppContext) {
+ let buffer = app.add_model(|ctx| Buffer::new(0, "abc\nde\nfgh", ctx));
+ let settings = settings::channel(&app.font_cache()).unwrap().1;
+ let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
+ view.update(app, |b, ctx| b.select_all(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ &[DisplayPoint::new(0, 0)..DisplayPoint::new(2, 3)]
+ );
}
- #[test]
- fn test_select_line() {
- App::test((), |app| {
- let settings = settings::channel(&app.font_cache()).unwrap().1;
- let buffer = app.add_model(|ctx| Buffer::new(0, sample_text(6, 5), ctx));
- let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
- view.update(app, |view, ctx| {
- view.select_display_ranges(
- &[
- DisplayPoint::new(0, 0)..DisplayPoint::new(0, 1),
- DisplayPoint::new(0, 2)..DisplayPoint::new(0, 2),
- DisplayPoint::new(1, 0)..DisplayPoint::new(1, 0),
- DisplayPoint::new(4, 2)..DisplayPoint::new(4, 2),
- ],
- ctx,
- )
- .unwrap();
- view.select_line(&(), ctx);
- });
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- vec![
- DisplayPoint::new(0, 0)..DisplayPoint::new(2, 0),
- DisplayPoint::new(4, 0)..DisplayPoint::new(5, 0),
- ]
- );
+ #[gpui::test]
+ fn test_select_line(app: &mut gpui::MutableAppContext) {
+ let settings = settings::channel(&app.font_cache()).unwrap().1;
+ let buffer = app.add_model(|ctx| Buffer::new(0, sample_text(6, 5), ctx));
+ let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
+ view.update(app, |view, ctx| {
+ view.select_display_ranges(
+ &[
+ DisplayPoint::new(0, 0)..DisplayPoint::new(0, 1),
+ DisplayPoint::new(0, 2)..DisplayPoint::new(0, 2),
+ DisplayPoint::new(1, 0)..DisplayPoint::new(1, 0),
+ DisplayPoint::new(4, 2)..DisplayPoint::new(4, 2),
+ ],
+ ctx,
+ )
+ .unwrap();
+ view.select_line(&(), ctx);
+ });
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ vec![
+ DisplayPoint::new(0, 0)..DisplayPoint::new(2, 0),
+ DisplayPoint::new(4, 0)..DisplayPoint::new(5, 0),
+ ]
+ );
- view.update(app, |view, ctx| view.select_line(&(), ctx));
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- vec![
- DisplayPoint::new(0, 0)..DisplayPoint::new(3, 0),
- DisplayPoint::new(4, 0)..DisplayPoint::new(5, 5),
- ]
- );
+ view.update(app, |view, ctx| view.select_line(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ vec![
+ DisplayPoint::new(0, 0)..DisplayPoint::new(3, 0),
+ DisplayPoint::new(4, 0)..DisplayPoint::new(5, 5),
+ ]
+ );
- view.update(app, |view, ctx| view.select_line(&(), ctx));
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- vec![DisplayPoint::new(0, 0)..DisplayPoint::new(5, 5)]
- );
- });
+ view.update(app, |view, ctx| view.select_line(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ vec![DisplayPoint::new(0, 0)..DisplayPoint::new(5, 5)]
+ );
}
- #[test]
- fn test_split_selection_into_lines() {
- App::test((), |app| {
- let settings = settings::channel(&app.font_cache()).unwrap().1;
- let buffer = app.add_model(|ctx| Buffer::new(0, sample_text(9, 5), ctx));
- let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
- view.update(app, |view, ctx| {
- view.fold_ranges(
- vec![
- Point::new(0, 2)..Point::new(1, 2),
- Point::new(2, 3)..Point::new(4, 1),
- Point::new(7, 0)..Point::new(8, 4),
- ],
- ctx,
- );
- view.select_display_ranges(
- &[
- DisplayPoint::new(0, 0)..DisplayPoint::new(0, 1),
- DisplayPoint::new(0, 2)..DisplayPoint::new(0, 2),
- DisplayPoint::new(1, 0)..DisplayPoint::new(1, 0),
- DisplayPoint::new(4, 2)..DisplayPoint::new(4, 2),
- ],
- ctx,
- )
- .unwrap();
- });
- assert_eq!(
- view.read(app).text(app.as_ref()),
- "aa…bbb\nccc…eeee\nfffff\nggggg\n…i"
- );
-
- view.update(app, |view, ctx| view.split_selection_into_lines(&(), ctx));
- assert_eq!(
- view.read(app).text(app.as_ref()),
- "aa…bbb\nccc…eeee\nfffff\nggggg\n…i"
+ #[gpui::test]
+ fn test_split_selection_into_lines(app: &mut gpui::MutableAppContext) {
+ let settings = settings::channel(&app.font_cache()).unwrap().1;
+ let buffer = app.add_model(|ctx| Buffer::new(0, sample_text(9, 5), ctx));
+ let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
+ view.update(app, |view, ctx| {
+ view.fold_ranges(
+ vec![
+ Point::new(0, 2)..Point::new(1, 2),
+ Point::new(2, 3)..Point::new(4, 1),
+ Point::new(7, 0)..Point::new(8, 4),
+ ],
+ ctx,
);
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- [
- DisplayPoint::new(0, 1)..DisplayPoint::new(0, 1),
+ view.select_display_ranges(
+ &[
+ DisplayPoint::new(0, 0)..DisplayPoint::new(0, 1),
DisplayPoint::new(0, 2)..DisplayPoint::new(0, 2),
DisplayPoint::new(1, 0)..DisplayPoint::new(1, 0),
- DisplayPoint::new(4, 2)..DisplayPoint::new(4, 2)
- ]
- );
+ DisplayPoint::new(4, 2)..DisplayPoint::new(4, 2),
+ ],
+ ctx,
+ )
+ .unwrap();
+ });
+ assert_eq!(
+ view.read(app).text(app.as_ref()),
+ "aa…bbb\nccc…eeee\nfffff\nggggg\n…i"
+ );
- view.update(app, |view, ctx| {
- view.select_display_ranges(
- &[DisplayPoint::new(4, 0)..DisplayPoint::new(0, 1)],
- ctx,
- )
+ view.update(app, |view, ctx| view.split_selection_into_lines(&(), ctx));
+ assert_eq!(
+ view.read(app).text(app.as_ref()),
+ "aa…bbb\nccc…eeee\nfffff\nggggg\n…i"
+ );
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ [
+ DisplayPoint::new(0, 1)..DisplayPoint::new(0, 1),
+ DisplayPoint::new(0, 2)..DisplayPoint::new(0, 2),
+ DisplayPoint::new(1, 0)..DisplayPoint::new(1, 0),
+ DisplayPoint::new(4, 2)..DisplayPoint::new(4, 2)
+ ]
+ );
+
+ view.update(app, |view, ctx| {
+ view.select_display_ranges(&[DisplayPoint::new(4, 0)..DisplayPoint::new(0, 1)], ctx)
.unwrap();
- view.split_selection_into_lines(&(), ctx);
- });
- assert_eq!(
- view.read(app).text(app.as_ref()),
- "aaaaa\nbbbbb\nccccc\nddddd\neeeee\nfffff\nggggg\n…i"
- );
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- [
- DisplayPoint::new(0, 1)..DisplayPoint::new(0, 1),
- DisplayPoint::new(1, 5)..DisplayPoint::new(1, 5),
- DisplayPoint::new(2, 5)..DisplayPoint::new(2, 5),
- DisplayPoint::new(3, 5)..DisplayPoint::new(3, 5),
- DisplayPoint::new(4, 5)..DisplayPoint::new(4, 5),
- DisplayPoint::new(5, 5)..DisplayPoint::new(5, 5),
- DisplayPoint::new(6, 5)..DisplayPoint::new(6, 5),
- DisplayPoint::new(7, 0)..DisplayPoint::new(7, 0)
- ]
- );
+ view.split_selection_into_lines(&(), ctx);
});
+ assert_eq!(
+ view.read(app).text(app.as_ref()),
+ "aaaaa\nbbbbb\nccccc\nddddd\neeeee\nfffff\nggggg\n…i"
+ );
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ [
+ DisplayPoint::new(0, 1)..DisplayPoint::new(0, 1),
+ DisplayPoint::new(1, 5)..DisplayPoint::new(1, 5),
+ DisplayPoint::new(2, 5)..DisplayPoint::new(2, 5),
+ DisplayPoint::new(3, 5)..DisplayPoint::new(3, 5),
+ DisplayPoint::new(4, 5)..DisplayPoint::new(4, 5),
+ DisplayPoint::new(5, 5)..DisplayPoint::new(5, 5),
+ DisplayPoint::new(6, 5)..DisplayPoint::new(6, 5),
+ DisplayPoint::new(7, 0)..DisplayPoint::new(7, 0)
+ ]
+ );
}
- #[test]
- fn test_add_selection_above_below() {
- App::test((), |app| {
- let settings = settings::channel(&app.font_cache()).unwrap().1;
- let buffer = app.add_model(|ctx| Buffer::new(0, "abc\ndefghi\n\njk\nlmno\n", ctx));
- let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
+ #[gpui::test]
+ fn test_add_selection_above_below(app: &mut gpui::MutableAppContext) {
+ let settings = settings::channel(&app.font_cache()).unwrap().1;
+ let buffer = app.add_model(|ctx| Buffer::new(0, "abc\ndefghi\n\njk\nlmno\n", ctx));
+ let (_, view) = app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));
- view.update(app, |view, ctx| {
- view.select_display_ranges(
- &[DisplayPoint::new(1, 3)..DisplayPoint::new(1, 3)],
- ctx,
- )
+ view.update(app, |view, ctx| {
+ view.select_display_ranges(&[DisplayPoint::new(1, 3)..DisplayPoint::new(1, 3)], ctx)
.unwrap();
- });
- view.update(app, |view, ctx| view.add_selection_above(&(), ctx));
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- vec![
- DisplayPoint::new(0, 3)..DisplayPoint::new(0, 3),
- DisplayPoint::new(1, 3)..DisplayPoint::new(1, 3)
- ]
- );
+ });
+ view.update(app, |view, ctx| view.add_selection_above(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ vec![
+ DisplayPoint::new(0, 3)..DisplayPoint::new(0, 3),
+ DisplayPoint::new(1, 3)..DisplayPoint::new(1, 3)
+ ]
+ );
- view.update(app, |view, ctx| view.add_selection_above(&(), ctx));
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- vec![
- DisplayPoint::new(0, 3)..DisplayPoint::new(0, 3),
- DisplayPoint::new(1, 3)..DisplayPoint::new(1, 3)
- ]
- );
+ view.update(app, |view, ctx| view.add_selection_above(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ vec![
+ DisplayPoint::new(0, 3)..DisplayPoint::new(0, 3),
+ DisplayPoint::new(1, 3)..DisplayPoint::new(1, 3)
+ ]
+ );
- view.update(app, |view, ctx| view.add_selection_below(&(), ctx));
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- vec![DisplayPoint::new(1, 3)..DisplayPoint::new(1, 3)]
- );
+ view.update(app, |view, ctx| view.add_selection_below(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ vec![DisplayPoint::new(1, 3)..DisplayPoint::new(1, 3)]
+ );
- view.update(app, |view, ctx| view.add_selection_below(&(), ctx));
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- vec![
- DisplayPoint::new(1, 3)..DisplayPoint::new(1, 3),
- DisplayPoint::new(4, 3)..DisplayPoint::new(4, 3)
- ]
- );
+ view.update(app, |view, ctx| view.add_selection_below(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ vec![
+ DisplayPoint::new(1, 3)..DisplayPoint::new(1, 3),
+ DisplayPoint::new(4, 3)..DisplayPoint::new(4, 3)
+ ]
+ );
- view.update(app, |view, ctx| view.add_selection_below(&(), ctx));
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- vec![
- DisplayPoint::new(1, 3)..DisplayPoint::new(1, 3),
- DisplayPoint::new(4, 3)..DisplayPoint::new(4, 3)
- ]
- );
+ view.update(app, |view, ctx| view.add_selection_below(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ vec![
+ DisplayPoint::new(1, 3)..DisplayPoint::new(1, 3),
+ DisplayPoint::new(4, 3)..DisplayPoint::new(4, 3)
+ ]
+ );
- view.update(app, |view, ctx| {
- view.select_display_ranges(
- &[DisplayPoint::new(1, 4)..DisplayPoint::new(1, 3)],
- ctx,
- )
+ view.update(app, |view, ctx| {
+ view.select_display_ranges(&[DisplayPoint::new(1, 4)..DisplayPoint::new(1, 3)], ctx)
.unwrap();
- });
- view.update(app, |view, ctx| view.add_selection_below(&(), ctx));
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- vec![
- DisplayPoint::new(1, 4)..DisplayPoint::new(1, 3),
- DisplayPoint::new(4, 4)..DisplayPoint::new(4, 3)
- ]
- );
+ });
+ view.update(app, |view, ctx| view.add_selection_below(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ vec![
+ DisplayPoint::new(1, 4)..DisplayPoint::new(1, 3),
+ DisplayPoint::new(4, 4)..DisplayPoint::new(4, 3)
+ ]
+ );
- view.update(app, |view, ctx| view.add_selection_below(&(), ctx));
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- vec![
- DisplayPoint::new(1, 4)..DisplayPoint::new(1, 3),
- DisplayPoint::new(4, 4)..DisplayPoint::new(4, 3)
- ]
- );
+ view.update(app, |view, ctx| view.add_selection_below(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ vec![
+ DisplayPoint::new(1, 4)..DisplayPoint::new(1, 3),
+ DisplayPoint::new(4, 4)..DisplayPoint::new(4, 3)
+ ]
+ );
- view.update(app, |view, ctx| view.add_selection_above(&(), ctx));
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- vec![DisplayPoint::new(1, 4)..DisplayPoint::new(1, 3)]
- );
+ view.update(app, |view, ctx| view.add_selection_above(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ vec![DisplayPoint::new(1, 4)..DisplayPoint::new(1, 3)]
+ );
- view.update(app, |view, ctx| view.add_selection_above(&(), ctx));
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- vec![DisplayPoint::new(1, 4)..DisplayPoint::new(1, 3)]
- );
+ view.update(app, |view, ctx| view.add_selection_above(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ vec![DisplayPoint::new(1, 4)..DisplayPoint::new(1, 3)]
+ );
- view.update(app, |view, ctx| {
- view.select_display_ranges(
- &[DisplayPoint::new(0, 1)..DisplayPoint::new(1, 4)],
- ctx,
- )
+ view.update(app, |view, ctx| {
+ view.select_display_ranges(&[DisplayPoint::new(0, 1)..DisplayPoint::new(1, 4)], ctx)
.unwrap();
- });
- view.update(app, |view, ctx| view.add_selection_below(&(), ctx));
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- vec![
- DisplayPoint::new(0, 1)..DisplayPoint::new(0, 3),
- DisplayPoint::new(1, 1)..DisplayPoint::new(1, 4),
- DisplayPoint::new(3, 1)..DisplayPoint::new(3, 2),
- ]
- );
+ });
+ view.update(app, |view, ctx| view.add_selection_below(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ vec![
+ DisplayPoint::new(0, 1)..DisplayPoint::new(0, 3),
+ DisplayPoint::new(1, 1)..DisplayPoint::new(1, 4),
+ DisplayPoint::new(3, 1)..DisplayPoint::new(3, 2),
+ ]
+ );
- view.update(app, |view, ctx| view.add_selection_below(&(), ctx));
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- vec![
- DisplayPoint::new(0, 1)..DisplayPoint::new(0, 3),
- DisplayPoint::new(1, 1)..DisplayPoint::new(1, 4),
- DisplayPoint::new(3, 1)..DisplayPoint::new(3, 2),
- DisplayPoint::new(4, 1)..DisplayPoint::new(4, 4),
- ]
- );
+ view.update(app, |view, ctx| view.add_selection_below(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ vec![
+ DisplayPoint::new(0, 1)..DisplayPoint::new(0, 3),
+ DisplayPoint::new(1, 1)..DisplayPoint::new(1, 4),
+ DisplayPoint::new(3, 1)..DisplayPoint::new(3, 2),
+ DisplayPoint::new(4, 1)..DisplayPoint::new(4, 4),
+ ]
+ );
- view.update(app, |view, ctx| view.add_selection_above(&(), ctx));
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- vec![
- DisplayPoint::new(0, 1)..DisplayPoint::new(0, 3),
- DisplayPoint::new(1, 1)..DisplayPoint::new(1, 4),
- DisplayPoint::new(3, 1)..DisplayPoint::new(3, 2),
- ]
- );
+ view.update(app, |view, ctx| view.add_selection_above(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ vec![
+ DisplayPoint::new(0, 1)..DisplayPoint::new(0, 3),
+ DisplayPoint::new(1, 1)..DisplayPoint::new(1, 4),
+ DisplayPoint::new(3, 1)..DisplayPoint::new(3, 2),
+ ]
+ );
- view.update(app, |view, ctx| {
- view.select_display_ranges(
- &[DisplayPoint::new(4, 3)..DisplayPoint::new(1, 1)],
- ctx,
- )
+ view.update(app, |view, ctx| {
+ view.select_display_ranges(&[DisplayPoint::new(4, 3)..DisplayPoint::new(1, 1)], ctx)
.unwrap();
- });
- view.update(app, |view, ctx| view.add_selection_above(&(), ctx));
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- vec![
- DisplayPoint::new(0, 3)..DisplayPoint::new(0, 1),
- DisplayPoint::new(1, 3)..DisplayPoint::new(1, 1),
- DisplayPoint::new(3, 2)..DisplayPoint::new(3, 1),
- DisplayPoint::new(4, 3)..DisplayPoint::new(4, 1),
- ]
- );
-
- view.update(app, |view, ctx| view.add_selection_below(&(), ctx));
- assert_eq!(
- view.read(app).selection_ranges(app.as_ref()),
- vec![
- DisplayPoint::new(1, 3)..DisplayPoint::new(1, 1),
- DisplayPoint::new(3, 2)..DisplayPoint::new(3, 1),
- DisplayPoint::new(4, 3)..DisplayPoint::new(4, 1),
- ]
- );
});
+ view.update(app, |view, ctx| view.add_selection_above(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ vec![
+ DisplayPoint::new(0, 3)..DisplayPoint::new(0, 1),
+ DisplayPoint::new(1, 3)..DisplayPoint::new(1, 1),
+ DisplayPoint::new(3, 2)..DisplayPoint::new(3, 1),
+ DisplayPoint::new(4, 3)..DisplayPoint::new(4, 1),
+ ]
+ );
+
+ view.update(app, |view, ctx| view.add_selection_below(&(), ctx));
+ assert_eq!(
+ view.read(app).selection_ranges(app.as_ref()),
+ vec![
+ DisplayPoint::new(1, 3)..DisplayPoint::new(1, 1),
+ DisplayPoint::new(3, 2)..DisplayPoint::new(3, 1),
+ DisplayPoint::new(4, 3)..DisplayPoint::new(4, 1),
+ ]
+ );
}
impl BufferView {
@@ -671,176 +671,163 @@ mod tests {
use super::*;
use crate::test::sample_text;
use buffer::ToPoint;
- use gpui::App;
- #[test]
- fn test_basic_folds() {
- App::test((), |app| {
- let buffer = app.add_model(|ctx| Buffer::new(0, sample_text(5, 6), ctx));
- let mut map = FoldMap::new(buffer.clone(), app.as_ref());
-
- map.fold(
- vec![
- Point::new(0, 2)..Point::new(2, 2),
- Point::new(2, 4)..Point::new(4, 1),
- ],
- app.as_ref(),
- )
- .unwrap();
- assert_eq!(map.text(app.as_ref()), "aa…cc…eeeee");
-
- buffer.update(app, |buffer, ctx| {
- buffer
- .edit(
- vec![
- Point::new(0, 0)..Point::new(0, 1),
- Point::new(2, 3)..Point::new(2, 3),
- ],
- "123",
- Some(ctx),
- )
- .unwrap();
- });
- assert_eq!(map.text(app.as_ref()), "123a…c123c…eeeee");
-
- buffer.update(app, |buffer, ctx| {
- let start_version = buffer.version.clone();
- buffer
- .edit(Some(Point::new(2, 6)..Point::new(4, 3)), "456", Some(ctx))
- .unwrap();
- buffer.edits_since(start_version).collect::<Vec<_>>()
- });
- assert_eq!(map.text(app.as_ref()), "123a…c123456eee");
+ #[gpui::test]
+ fn test_basic_folds(app: &mut gpui::MutableAppContext) {
+ let buffer = app.add_model(|ctx| Buffer::new(0, sample_text(5, 6), ctx));
+ let mut map = FoldMap::new(buffer.clone(), app.as_ref());
+
+ map.fold(
+ vec![
+ Point::new(0, 2)..Point::new(2, 2),
+ Point::new(2, 4)..Point::new(4, 1),
+ ],
+ app.as_ref(),
+ )
+ .unwrap();
+ assert_eq!(map.text(app.as_ref()), "aa…cc…eeeee");
+
+ buffer.update(app, |buffer, ctx| {
+ buffer
+ .edit(
+ vec![
+ Point::new(0, 0)..Point::new(0, 1),
+ Point::new(2, 3)..Point::new(2, 3),
+ ],
+ "123",
+ Some(ctx),
+ )
+ .unwrap();
+ });
+ assert_eq!(map.text(app.as_ref()), "123a…c123c…eeeee");
- map.unfold(Some(Point::new(0, 4)..Point::new(0, 5)), app.as_ref())
+ buffer.update(app, |buffer, ctx| {
+ let start_version = buffer.version.clone();
+ buffer
+ .edit(Some(Point::new(2, 6)..Point::new(4, 3)), "456", Some(ctx))
.unwrap();
- assert_eq!(map.text(app.as_ref()), "123aaaaa\nbbbbbb\nccc123456eee");
+ buffer.edits_since(start_version).collect::<Vec<_>>()
});
+ assert_eq!(map.text(app.as_ref()), "123a…c123456eee");
+
+ map.unfold(Some(Point::new(0, 4)..Point::new(0, 5)), app.as_ref())
+ .unwrap();
+ assert_eq!(map.text(app.as_ref()), "123aaaaa\nbbbbbb\nccc123456eee");
}
- #[test]
- fn test_adjacent_folds() {
- App::test((), |app| {
- let buffer = app.add_model(|ctx| Buffer::new(0, "abcdefghijkl", ctx));
+ #[gpui::test]
+ fn test_adjacent_folds(app: &mut gpui::MutableAppContext) {
+ let buffer = app.add_model(|ctx| Buffer::new(0, "abcdefghijkl", ctx));
- {
- let mut map = FoldMap::new(buffer.clone(), app.as_ref());
+ {
+ let mut map = FoldMap::new(buffer.clone(), app.as_ref());
- map.fold(vec![5..8], app.as_ref()).unwrap();
- map.check_invariants(app.as_ref());
- assert_eq!(map.text(app.as_ref()), "abcde…ijkl");
+ map.fold(vec![5..8], app.as_ref()).unwrap();
+ map.check_invariants(app.as_ref());
+ assert_eq!(map.text(app.as_ref()), "abcde…ijkl");
- // Create an fold adjacent to the start of the first fold.
- map.fold(vec![0..1, 2..5], app.as_ref()).unwrap();
- map.check_invariants(app.as_ref());
- assert_eq!(map.text(app.as_ref()), "…b…ijkl");
+ // Create an fold adjacent to the start of the first fold.
+ map.fold(vec![0..1, 2..5], app.as_ref()).unwrap();
+ map.check_invariants(app.as_ref());
+ assert_eq!(map.text(app.as_ref()), "…b…ijkl");
- // Create an fold adjacent to the end of the first fold.
- map.fold(vec![11..11, 8..10], app.as_ref()).unwrap();
- map.check_invariants(app.as_ref());
- assert_eq!(map.text(app.as_ref()), "…b…kl");
- }
+ // Create an fold adjacent to the end of the first fold.
+ map.fold(vec![11..11, 8..10], app.as_ref()).unwrap();
+ map.check_invariants(app.as_ref());
+ assert_eq!(map.text(app.as_ref()), "…b…kl");
+ }
- {
- let mut map = FoldMap::new(buffer.clone(), app.as_ref());
+ {
+ let mut map = FoldMap::new(buffer.clone(), app.as_ref());
- // Create two adjacent folds.
- map.fold(vec![0..2, 2..5], app.as_ref()).unwrap();
- map.check_invariants(app.as_ref());
- assert_eq!(map.text(app.as_ref()), "…fghijkl");
+ // Create two adjacent folds.
+ map.fold(vec![0..2, 2..5], app.as_ref()).unwrap();
+ map.check_invariants(app.as_ref());
+ assert_eq!(map.text(app.as_ref()), "…fghijkl");
- // Edit within one of the folds.
- buffer.update(app, |buffer, ctx| {
- let version = buffer.version();
- buffer.edit(vec![0..1], "12345", Some(ctx)).unwrap();
- buffer.edits_since(version).collect::<Vec<_>>()
- });
- map.check_invariants(app.as_ref());
- assert_eq!(map.text(app.as_ref()), "12345…fghijkl");
- }
- });
+ // Edit within one of the folds.
+ buffer.update(app, |buffer, ctx| {
+ let version = buffer.version();
+ buffer.edit(vec![0..1], "12345", Some(ctx)).unwrap();
+ buffer.edits_since(version).collect::<Vec<_>>()
+ });
+ map.check_invariants(app.as_ref());
+ assert_eq!(map.text(app.as_ref()), "12345…fghijkl");
+ }
}
- #[test]
- fn test_overlapping_folds() {
- App::test((), |app| {
- let buffer = app.add_model(|ctx| Buffer::new(0, sample_text(5, 6), ctx));
- let mut map = FoldMap::new(buffer.clone(), app.as_ref());
- map.fold(
- vec![
- Point::new(0, 2)..Point::new(2, 2),
- Point::new(0, 4)..Point::new(1, 0),
- Point::new(1, 2)..Point::new(3, 2),
- Point::new(3, 1)..Point::new(4, 1),
- ],
- app.as_ref(),
- )
- .unwrap();
- assert_eq!(map.text(app.as_ref()), "aa…eeeee");
- })
+ #[gpui::test]
+ fn test_overlapping_folds(app: &mut gpui::MutableAppContext) {
+ let buffer = app.add_model(|ctx| Buffer::new(0, sample_text(5, 6), ctx));
+ let mut map = FoldMap::new(buffer.clone(), app.as_ref());
+ map.fold(
+ vec![
+ Point::new(0, 2)..Point::new(2, 2),
+ Point::new(0, 4)..Point::new(1, 0),
+ Point::new(1, 2)..Point::new(3, 2),
+ Point::new(3, 1)..Point::new(4, 1),
+ ],
+ app.as_ref(),
+ )
+ .unwrap();
+ assert_eq!(map.text(app.as_ref()), "aa…eeeee");
}
- #[test]
- fn test_merging_folds_via_edit() {
- App::test((), |app| {
- let buffer = app.add_model(|ctx| Buffer::new(0, sample_text(5, 6), ctx));
- let mut map = FoldMap::new(buffer.clone(), app.as_ref());
-
- map.fold(
- vec![
- Point::new(0, 2)..Point::new(2, 2),
- Point::new(3, 1)..Point::new(4, 1),
- ],
- app.as_ref(),
- )
- .unwrap();
- assert_eq!(map.text(app.as_ref()), "aa…cccc\nd…eeeee");
-
- buffer.update(app, |buffer, ctx| {
- buffer
- .edit(Some(Point::new(2, 2)..Point::new(3, 1)), "", Some(ctx))
- .unwrap();
- });
- assert_eq!(map.text(app.as_ref()), "aa…eeeee");
+ #[gpui::test]
+ fn test_merging_folds_via_edit(app: &mut gpui::MutableAppContext) {
+ let buffer = app.add_model(|ctx| Buffer::new(0, sample_text(5, 6), ctx));
+ let mut map = FoldMap::new(buffer.clone(), app.as_ref());
+
+ map.fold(
+ vec![
+ Point::new(0, 2)..Point::new(2, 2),
+ Point::new(3, 1)..Point::new(4, 1),
+ ],
+ app.as_ref(),
+ )
+ .unwrap();
+ assert_eq!(map.text(app.as_ref()), "aa…cccc\nd…eeeee");
+
+ buffer.update(app, |buffer, ctx| {
+ buffer
+ .edit(Some(Point::new(2, 2)..Point::new(3, 1)), "", Some(ctx))
+ .unwrap();
});
+ assert_eq!(map.text(app.as_ref()), "aa…eeeee");
}
- #[test]
- fn test_folds_in_range() {
- App::test((), |app| {
- let buffer = app.add_model(|ctx| Buffer::new(0, sample_text(5, 6), ctx));
- let mut map = FoldMap::new(buffer.clone(), app.as_ref());
- let buffer = buffer.read(app);
-
- map.fold(
- vec![
- Point::new(0, 2)..Point::new(2, 2),
- Point::new(0, 4)..Point::new(1, 0),
- Point::new(1, 2)..Point::new(3, 2),
- Point::new(3, 1)..Point::new(4, 1),
- ],
- app.as_ref(),
- )
- .unwrap();
- let fold_ranges = map
- .folds_in_range(Point::new(1, 0)..Point::new(1, 3), app.as_ref())
- .unwrap()
- .map(|fold| {
- fold.start.to_point(buffer).unwrap()..fold.end.to_point(buffer).unwrap()
- })
- .collect::<Vec<_>>();
- assert_eq!(
- fold_ranges,
- vec![
- Point::new(0, 2)..Point::new(2, 2),
- Point::new(1, 2)..Point::new(3, 2)
- ]
- );
- });
+ #[gpui::test]
+ fn test_folds_in_range(app: &mut gpui::MutableAppContext) {
+ let buffer = app.add_model(|ctx| Buffer::new(0, sample_text(5, 6), ctx));
+ let mut map = FoldMap::new(buffer.clone(), app.as_ref());
+ let buffer = buffer.read(app);
+
+ map.fold(
+ vec![
+ Point::new(0, 2)..Point::new(2, 2),
+ Point::new(0, 4)..Point::new(1, 0),
+ Point::new(1, 2)..Point::new(3, 2),
+ Point::new(3, 1)..Point::new(4, 1),
+ ],
+ app.as_ref(),
+ )
+ .unwrap();
+ let fold_ranges = map
+ .folds_in_range(Point::new(1, 0)..Point::new(1, 3), app.as_ref())
+ .unwrap()
+ .map(|fold| fold.start.to_point(buffer).unwrap()..fold.end.to_point(buffer).unwrap())
+ .collect::<Vec<_>>();
+ assert_eq!(
+ fold_ranges,
+ vec![
+ Point::new(0, 2)..Point::new(2, 2),
+ Point::new(1, 2)..Point::new(3, 2)
+ ]
+ );
}
- #[test]
- fn test_random_folds() {
+ #[gpui::test]
+ fn test_random_folds(app: &mut gpui::MutableAppContext) {
use crate::editor::ToPoint;
use crate::util::RandomCharIter;
use rand::prelude::*;
@@ -863,203 +850,197 @@ mod tests {
dbg!(seed);
let mut rng = StdRng::seed_from_u64(seed);
- App::test((), |app| {
- let buffer = app.add_model(|ctx| {
- let len = rng.gen_range(0..10);
- let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();
- Buffer::new(0, text, ctx)
- });
- let mut map = FoldMap::new(buffer.clone(), app.as_ref());
-
- for _ in 0..operations {
- log::info!("text: {:?}", buffer.read(app).text());
- match rng.gen_range(0..=100) {
- 0..=34 => {
- let buffer = buffer.read(app);
- let mut to_fold = Vec::new();
- for _ in 0..rng.gen_range(1..=5) {
- let end = rng.gen_range(0..=buffer.len());
- let start = rng.gen_range(0..=end);
- to_fold.push(start..end);
- }
- log::info!("folding {:?}", to_fold);
- map.fold(to_fold, app.as_ref()).unwrap();
- }
- 35..=59 if !map.folds.is_empty() => {
- let buffer = buffer.read(app);
- let mut to_unfold = Vec::new();
- for _ in 0..rng.gen_range(1..=3) {
- let end = rng.gen_range(0..=buffer.len());
- let start = rng.gen_range(0..=end);
- to_unfold.push(start..end);
- }
- log::info!("unfolding {:?}", to_unfold);
- map.unfold(to_unfold, app.as_ref()).unwrap();
+ let buffer = app.add_model(|ctx| {
+ let len = rng.gen_range(0..10);
+ let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();
+ Buffer::new(0, text, ctx)
+ });
+ let mut map = FoldMap::new(buffer.clone(), app.as_ref());
+
+ for _ in 0..operations {
+ log::info!("text: {:?}", buffer.read(app).text());
+ match rng.gen_range(0..=100) {
+ 0..=34 => {
+ let buffer = buffer.read(app);
+ let mut to_fold = Vec::new();
+ for _ in 0..rng.gen_range(1..=5) {
+ let end = rng.gen_range(0..=buffer.len());
+ let start = rng.gen_range(0..=end);
+ to_fold.push(start..end);
}
- _ => {
- let edits = buffer.update(app, |buffer, ctx| {
- let start_version = buffer.version.clone();
- let edit_count = rng.gen_range(1..=5);
- buffer.randomly_edit(&mut rng, edit_count, Some(ctx));
- buffer.edits_since(start_version).collect::<Vec<_>>()
- });
- log::info!("editing {:?}", edits);
+ log::info!("folding {:?}", to_fold);
+ map.fold(to_fold, app.as_ref()).unwrap();
+ }
+ 35..=59 if !map.folds.is_empty() => {
+ let buffer = buffer.read(app);
+ let mut to_unfold = Vec::new();
+ for _ in 0..rng.gen_range(1..=3) {
+ let end = rng.gen_range(0..=buffer.len());
+ let start = rng.gen_range(0..=end);
+ to_unfold.push(start..end);
}
+ log::info!("unfolding {:?}", to_unfold);
+ map.unfold(to_unfold, app.as_ref()).unwrap();
}
- map.check_invariants(app.as_ref());
-
- 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;
- for fold_range in map.merged_fold_ranges(app.as_ref()).into_iter().rev() {
- let fold_start = buffer.point_for_offset(fold_range.start).unwrap();
- let fold_end = buffer.point_for_offset(fold_range.end).unwrap();
- expected_buffer_rows.extend((fold_end.row + 1..=next_row).rev());
- next_row = fold_start.row;
-
- expected_text.replace_range(fold_range.start..fold_range.end, "…");
+ _ => {
+ let edits = buffer.update(app, |buffer, ctx| {
+ let start_version = buffer.version.clone();
+ let edit_count = rng.gen_range(1..=5);
+ buffer.randomly_edit(&mut rng, edit_count, Some(ctx));
+ buffer.edits_since(start_version).collect::<Vec<_>>()
+ });
+ log::info!("editing {:?}", edits);
}
- expected_buffer_rows.extend((0..=next_row).rev());
- expected_buffer_rows.reverse();
-
- assert_eq!(map.text(app.as_ref()), expected_text);
+ }
+ map.check_invariants(app.as_ref());
- for (display_row, line) in expected_text.lines().enumerate() {
- let line_len = map.line_len(display_row as u32, app.as_ref()).unwrap();
- assert_eq!(line_len, line.chars().count() as u32);
- }
+ 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;
+ for fold_range in map.merged_fold_ranges(app.as_ref()).into_iter().rev() {
+ let fold_start = buffer.point_for_offset(fold_range.start).unwrap();
+ let fold_end = buffer.point_for_offset(fold_range.end).unwrap();
+ expected_buffer_rows.extend((fold_end.row + 1..=next_row).rev());
+ next_row = fold_start.row;
+
+ expected_text.replace_range(fold_range.start..fold_range.end, "…");
+ }
+ expected_buffer_rows.extend((0..=next_row).rev());
+ expected_buffer_rows.reverse();
- let mut display_point = DisplayPoint::new(0, 0);
- let mut display_offset = DisplayOffset(0);
- for c in expected_text.chars() {
- let buffer_point = map.to_buffer_point(display_point, app.as_ref());
- let buffer_offset = buffer_point.to_offset(buffer).unwrap();
- assert_eq!(
- map.to_display_point(buffer_point, app.as_ref()),
- display_point
- );
- assert_eq!(
- map.to_buffer_offset(display_point, app.as_ref()).unwrap(),
- buffer_offset
- );
- assert_eq!(
- map.to_display_offset(display_point, app.as_ref()).unwrap(),
- display_offset
- );
-
- if c == '\n' {
- *display_point.row_mut() += 1;
- *display_point.column_mut() = 0;
- } else {
- *display_point.column_mut() += 1;
- }
- display_offset.0 += 1;
- }
+ assert_eq!(map.text(app.as_ref()), expected_text);
- for _ in 0..5 {
- let row = rng.gen_range(0..=map.max_point(app.as_ref()).row());
- let column = rng.gen_range(0..=map.line_len(row, app.as_ref()).unwrap());
- let point = DisplayPoint::new(row, column);
- let offset = map.to_display_offset(point, app.as_ref()).unwrap().0;
- let len = rng.gen_range(0..=map.len(app.as_ref()) - offset);
- assert_eq!(
- map.snapshot(app.as_ref())
- .chars_at(point, app.as_ref())
- .unwrap()
- .take(len)
- .collect::<String>(),
- expected_text
- .chars()
- .skip(offset)
- .take(len)
- .collect::<String>()
- );
- }
+ for (display_row, line) in expected_text.lines().enumerate() {
+ let line_len = map.line_len(display_row as u32, app.as_ref()).unwrap();
+ assert_eq!(line_len, line.chars().count() as u32);
+ }
- for (idx, buffer_row) in expected_buffer_rows.iter().enumerate() {
- let display_row = map
- .to_display_point(Point::new(*buffer_row, 0), app.as_ref())
- .row();
- assert_eq!(
- map.snapshot(app.as_ref())
- .buffer_rows(display_row)
- .unwrap()
- .collect::<Vec<_>>(),
- expected_buffer_rows[idx..],
- );
- }
+ let mut display_point = DisplayPoint::new(0, 0);
+ let mut display_offset = DisplayOffset(0);
+ for c in expected_text.chars() {
+ let buffer_point = map.to_buffer_point(display_point, app.as_ref());
+ let buffer_offset = buffer_point.to_offset(buffer).unwrap();
+ assert_eq!(
+ map.to_display_point(buffer_point, app.as_ref()),
+ display_point
+ );
+ assert_eq!(
+ map.to_buffer_offset(display_point, app.as_ref()).unwrap(),
+ buffer_offset
+ );
+ assert_eq!(
+ map.to_display_offset(display_point, app.as_ref()).unwrap(),
+ display_offset
+ );
- for fold_range in map.merged_fold_ranges(app.as_ref()) {
- let display_point = map.to_display_point(
- fold_range.start.to_point(buffer).unwrap(),
- app.as_ref(),
- );
- assert!(map.is_line_folded(display_point.row(), app.as_ref()));
+ if c == '\n' {
+ *display_point.row_mut() += 1;
+ *display_point.column_mut() = 0;
+ } else {
+ *display_point.column_mut() += 1;
}
+ display_offset.0 += 1;
+ }
- for _ in 0..5 {
- let end = rng.gen_range(0..=buffer.len());
- let start = rng.gen_range(0..=end);
- let expected_folds = map
- .folds
- .items()
- .into_iter()
- .filter(|fold| {
- let start = buffer.anchor_before(start).unwrap();
- let end = buffer.anchor_after(end).unwrap();
- start.cmp(&fold.0.end, buffer).unwrap() == Ordering::Less
- && end.cmp(&fold.0.start, buffer).unwrap() == Ordering::Greater
- })
- .map(|fold| fold.0)
- .collect::<Vec<_>>();
-
- assert_eq!(
- map.folds_in_range(start..end, app.as_ref())
- .unwrap()
- .cloned()
- .collect::<Vec<_>>(),
- expected_folds
- );
- }
+ for _ in 0..5 {
+ let row = rng.gen_range(0..=map.max_point(app.as_ref()).row());
+ let column = rng.gen_range(0..=map.line_len(row, app.as_ref()).unwrap());
+ let point = DisplayPoint::new(row, column);
+ let offset = map.to_display_offset(point, app.as_ref()).unwrap().0;
+ let len = rng.gen_range(0..=map.len(app.as_ref()) - offset);
+ assert_eq!(
+ map.snapshot(app.as_ref())
+ .chars_at(point, app.as_ref())
+ .unwrap()
+ .take(len)
+ .collect::<String>(),
+ expected_text
+ .chars()
+ .skip(offset)
+ .take(len)
+ .collect::<String>()
+ );
}
- });
- }
- }
- #[test]
- fn test_buffer_rows() {
- App::test((), |app| {
- let text = sample_text(6, 6) + "\n";
- let buffer = app.add_model(|ctx| Buffer::new(0, text, ctx));
+ for (idx, buffer_row) in expected_buffer_rows.iter().enumerate() {
+ let display_row = map
+ .to_display_point(Point::new(*buffer_row, 0), app.as_ref())
+ .row();
+ assert_eq!(
+ map.snapshot(app.as_ref())
+ .buffer_rows(display_row)
+ .unwrap()
+ .collect::<Vec<_>>(),
+ expected_buffer_rows[idx..],
+ );
+ }
- let mut map = FoldMap::new(buffer.clone(), app.as_ref());
+ for fold_range in map.merged_fold_ranges(app.as_ref()) {
+ let display_point = map
+ .to_display_point(fold_range.start.to_point(buffer).unwrap(), app.as_ref());
+ assert!(map.is_line_folded(display_point.row(), app.as_ref()));
+ }
- map.fold(
- vec![
- Point::new(0, 2)..Point::new(2, 2),
- Point::new(3, 1)..Point::new(4, 1),
- ],
- app.as_ref(),
- )
- .unwrap();
+ for _ in 0..5 {
+ let end = rng.gen_range(0..=buffer.len());
+ let start = rng.gen_range(0..=end);
+ let expected_folds = map
+ .folds
+ .items()
+ .into_iter()
+ .filter(|fold| {
+ let start = buffer.anchor_before(start).unwrap();
+ let end = buffer.anchor_after(end).unwrap();
+ start.cmp(&fold.0.end, buffer).unwrap() == Ordering::Less
+ && end.cmp(&fold.0.start, buffer).unwrap() == Ordering::Greater
+ })
+ .map(|fold| fold.0)
+ .collect::<Vec<_>>();
+
+ assert_eq!(
+ map.folds_in_range(start..end, app.as_ref())
+ .unwrap()
+ .cloned()
+ .collect::<Vec<_>>(),
+ expected_folds
+ );
+ }
+ }
+ }
+ }
- assert_eq!(map.text(app.as_ref()), "aa…cccc\nd…eeeee\nffffff\n");
- assert_eq!(
- map.snapshot(app.as_ref())
- .buffer_rows(0)
- .unwrap()
- .collect::<Vec<_>>(),
- vec![0, 3, 5, 6]
- );
- assert_eq!(
- map.snapshot(app.as_ref())
- .buffer_rows(3)
- .unwrap()
- .collect::<Vec<_>>(),
- vec![6]
- );
- });
+ #[gpui::test]
+ fn test_buffer_rows(app: &mut gpui::MutableAppContext) {
+ let text = sample_text(6, 6) + "\n";
+ let buffer = app.add_model(|ctx| Buffer::new(0, text, ctx));
+
+ let mut map = FoldMap::new(buffer.clone(), app.as_ref());
+
+ map.fold(
+ vec![
+ Point::new(0, 2)..Point::new(2, 2),
+ Point::new(3, 1)..Point::new(4, 1),
+ ],
+ app.as_ref(),
+ )
+ .unwrap();
+
+ assert_eq!(map.text(app.as_ref()), "aa…cccc\nd…eeeee\nffffff\n");
+ assert_eq!(
+ map.snapshot(app.as_ref())
+ .buffer_rows(0)
+ .unwrap()
+ .collect::<Vec<_>>(),
+ vec![0, 3, 5, 6]
+ );
+ assert_eq!(
+ map.snapshot(app.as_ref())
+ .buffer_rows(3)
+ .unwrap()
+ .collect::<Vec<_>>(),
+ vec![6]
+ );
}
impl FoldMap {
@@ -339,53 +339,50 @@ pub fn collapse_tabs(
mod tests {
use super::*;
use crate::test::*;
- use gpui::App;
- #[test]
- fn test_chars_at() {
- App::test((), |app| {
- let text = sample_text(6, 6);
- let buffer = app.add_model(|ctx| Buffer::new(0, text, ctx));
- let map = DisplayMap::new(buffer.clone(), 4, app.as_ref());
- buffer
- .update(app, |buffer, ctx| {
- buffer.edit(
- vec![
- Point::new(1, 0)..Point::new(1, 0),
- Point::new(1, 1)..Point::new(1, 1),
- Point::new(2, 1)..Point::new(2, 1),
- ],
- "\t",
- Some(ctx),
- )
- })
- .unwrap();
-
- assert_eq!(
- map.snapshot(app.as_ref())
- .chars_at(DisplayPoint::new(1, 0), app.as_ref())
- .unwrap()
- .take(10)
- .collect::<String>(),
- " b bb"
- );
- assert_eq!(
- map.snapshot(app.as_ref())
- .chars_at(DisplayPoint::new(1, 2), app.as_ref())
- .unwrap()
- .take(10)
- .collect::<String>(),
- " b bbbb"
- );
- assert_eq!(
- map.snapshot(app.as_ref())
- .chars_at(DisplayPoint::new(1, 6), app.as_ref())
- .unwrap()
- .take(13)
- .collect::<String>(),
- " bbbbb\nc c"
- );
- });
+ #[gpui::test]
+ fn test_chars_at(app: &mut gpui::MutableAppContext) {
+ let text = sample_text(6, 6);
+ let buffer = app.add_model(|ctx| Buffer::new(0, text, ctx));
+ let map = DisplayMap::new(buffer.clone(), 4, app.as_ref());
+ buffer
+ .update(app, |buffer, ctx| {
+ buffer.edit(
+ vec![
+ Point::new(1, 0)..Point::new(1, 0),
+ Point::new(1, 1)..Point::new(1, 1),
+ Point::new(2, 1)..Point::new(2, 1),
+ ],
+ "\t",
+ Some(ctx),
+ )
+ })
+ .unwrap();
+
+ assert_eq!(
+ map.snapshot(app.as_ref())
+ .chars_at(DisplayPoint::new(1, 0), app.as_ref())
+ .unwrap()
+ .take(10)
+ .collect::<String>(),
+ " b bb"
+ );
+ assert_eq!(
+ map.snapshot(app.as_ref())
+ .chars_at(DisplayPoint::new(1, 2), app.as_ref())
+ .unwrap()
+ .take(10)
+ .collect::<String>(),
+ " b bbbb"
+ );
+ assert_eq!(
+ map.snapshot(app.as_ref())
+ .chars_at(DisplayPoint::new(1, 6), app.as_ref())
+ .unwrap()
+ .take(13)
+ .collect::<String>(),
+ " bbbbb\nc c"
+ );
}
#[test]
@@ -411,12 +408,10 @@ mod tests {
assert_eq!(collapse_tabs("\ta".chars(), 5, Bias::Right, 4), (2, 0));
}
- #[test]
- fn test_max_point() {
- App::test((), |app| {
- let buffer = app.add_model(|ctx| Buffer::new(0, "aaa\n\t\tbbb", ctx));
- let map = DisplayMap::new(buffer.clone(), 4, app.as_ref());
- assert_eq!(map.max_point(app.as_ref()), DisplayPoint::new(1, 11))
- });
+ #[gpui::test]
+ fn test_max_point(app: &mut gpui::MutableAppContext) {
+ let buffer = app.add_model(|ctx| Buffer::new(0, "aaa\n\t\tbbb", ctx));
+ let map = DisplayMap::new(buffer.clone(), 4, app.as_ref());
+ assert_eq!(map.max_point(app.as_ref()), DisplayPoint::new(1, 11))
}
}
@@ -453,220 +453,208 @@ impl FileFinder {
mod tests {
use super::*;
use crate::{editor, settings, test::temp_tree, workspace::Workspace};
- use gpui::App;
use serde_json::json;
use std::fs;
use tempdir::TempDir;
- #[test]
- fn test_matching_paths() {
- App::test_async((), |mut app| async move {
- let tmp_dir = TempDir::new("example").unwrap();
- fs::create_dir(tmp_dir.path().join("a")).unwrap();
- fs::write(tmp_dir.path().join("a/banana"), "banana").unwrap();
- fs::write(tmp_dir.path().join("a/bandana"), "bandana").unwrap();
- app.update(|ctx| {
- super::init(ctx);
- editor::init(ctx);
- });
-
- let settings = settings::channel(&app.font_cache()).unwrap().1;
- let (window_id, workspace) = app.add_window(|ctx| {
- let mut workspace = Workspace::new(0, settings, ctx);
- workspace.add_worktree(tmp_dir.path(), ctx);
- workspace
- });
- app.read(|ctx| workspace.read(ctx).worktree_scans_complete(ctx))
- .await;
- app.dispatch_action(
- window_id,
- vec![workspace.id()],
- "file_finder:toggle".into(),
- (),
- );
+ #[gpui::test]
+ async fn test_matching_paths(mut app: gpui::TestAppContext) {
+ let tmp_dir = TempDir::new("example").unwrap();
+ fs::create_dir(tmp_dir.path().join("a")).unwrap();
+ fs::write(tmp_dir.path().join("a/banana"), "banana").unwrap();
+ fs::write(tmp_dir.path().join("a/bandana"), "bandana").unwrap();
+ app.update(|ctx| {
+ super::init(ctx);
+ editor::init(ctx);
+ });
- let finder = app.read(|ctx| {
- workspace
- .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());
- app.dispatch_action(window_id, chain.clone(), "buffer:insert", "n".to_string());
- app.dispatch_action(window_id, chain.clone(), "buffer:insert", "a".to_string());
- finder
- .condition(&app, |finder, _| finder.matches.len() == 2)
- .await;
-
- let active_pane = app.read(|ctx| workspace.read(ctx).active_pane().clone());
- app.dispatch_action(
- window_id,
- vec![workspace.id(), finder.id()],
- "menu:select_next",
- (),
- );
- app.dispatch_action(
- window_id,
- vec![workspace.id(), finder.id()],
- "file_finder:confirm",
- (),
- );
- active_pane
- .condition(&app, |pane, _| pane.active_item().is_some())
- .await;
- app.read(|ctx| {
- let active_item = active_pane.read(ctx).active_item().unwrap();
- assert_eq!(active_item.title(ctx), "bandana");
- });
+ let settings = settings::channel(&app.font_cache()).unwrap().1;
+ let (window_id, workspace) = app.add_window(|ctx| {
+ let mut workspace = Workspace::new(0, settings, ctx);
+ workspace.add_worktree(tmp_dir.path(), ctx);
+ workspace
+ });
+ app.read(|ctx| workspace.read(ctx).worktree_scans_complete(ctx))
+ .await;
+ app.dispatch_action(
+ window_id,
+ vec![workspace.id()],
+ "file_finder:toggle".into(),
+ (),
+ );
+
+ let finder = app.read(|ctx| {
+ workspace
+ .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());
+ app.dispatch_action(window_id, chain.clone(), "buffer:insert", "n".to_string());
+ app.dispatch_action(window_id, chain.clone(), "buffer:insert", "a".to_string());
+ finder
+ .condition(&app, |finder, _| finder.matches.len() == 2)
+ .await;
+
+ let active_pane = app.read(|ctx| workspace.read(ctx).active_pane().clone());
+ app.dispatch_action(
+ window_id,
+ vec![workspace.id(), finder.id()],
+ "menu:select_next",
+ (),
+ );
+ app.dispatch_action(
+ window_id,
+ vec![workspace.id(), finder.id()],
+ "file_finder:confirm",
+ (),
+ );
+ active_pane
+ .condition(&app, |pane, _| pane.active_item().is_some())
+ .await;
+ app.read(|ctx| {
+ let active_item = active_pane.read(ctx).active_item().unwrap();
+ assert_eq!(active_item.title(ctx), "bandana");
});
}
- #[test]
- fn test_matching_cancellation() {
- App::test_async((), |mut app| async move {
- let tmp_dir = temp_tree(json!({
- "hello": "",
- "goodbye": "",
- "halogen-light": "",
- "happiness": "",
- "height": "",
- "hi": "",
- "hiccup": "",
- }));
- let settings = settings::channel(&app.font_cache()).unwrap().1;
- 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))
- .await;
- let (_, finder) =
- app.add_window(|ctx| FileFinder::new(settings, workspace.clone(), ctx));
-
- let query = "hi".to_string();
- finder.update(&mut app, |f, ctx| f.spawn_search(query.clone(), ctx));
- finder.condition(&app, |f, _| f.matches.len() == 5).await;
-
- finder.update(&mut app, |finder, ctx| {
- let matches = finder.matches.clone();
-
- // Simulate a search being cancelled after the time limit,
- // returning only a subset of the matches that would have been found.
- finder.spawn_search(query.clone(), ctx);
- finder.update_matches(
- (
- finder.latest_search_id,
- true, // did-cancel
- query.clone(),
- vec![matches[1].clone(), matches[3].clone()],
- ),
- ctx,
- );
-
- // Simulate another cancellation.
- finder.spawn_search(query.clone(), ctx);
- finder.update_matches(
- (
- finder.latest_search_id,
- true, // did-cancel
- query.clone(),
- vec![matches[0].clone(), matches[2].clone(), matches[3].clone()],
- ),
- ctx,
- );
+ #[gpui::test]
+ async fn test_matching_cancellation(mut app: gpui::TestAppContext) {
+ let tmp_dir = temp_tree(json!({
+ "hello": "",
+ "goodbye": "",
+ "halogen-light": "",
+ "happiness": "",
+ "height": "",
+ "hi": "",
+ "hiccup": "",
+ }));
+ let settings = settings::channel(&app.font_cache()).unwrap().1;
+ 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))
+ .await;
+ let (_, finder) = app.add_window(|ctx| FileFinder::new(settings, workspace.clone(), ctx));
+
+ let query = "hi".to_string();
+ finder.update(&mut app, |f, ctx| f.spawn_search(query.clone(), ctx));
+ finder.condition(&app, |f, _| f.matches.len() == 5).await;
+
+ finder.update(&mut app, |finder, ctx| {
+ let matches = finder.matches.clone();
+
+ // Simulate a search being cancelled after the time limit,
+ // returning only a subset of the matches that would have been found.
+ finder.spawn_search(query.clone(), ctx);
+ finder.update_matches(
+ (
+ finder.latest_search_id,
+ true, // did-cancel
+ query.clone(),
+ vec![matches[1].clone(), matches[3].clone()],
+ ),
+ ctx,
+ );
- assert_eq!(finder.matches, matches[0..4])
- });
+ // Simulate another cancellation.
+ finder.spawn_search(query.clone(), ctx);
+ finder.update_matches(
+ (
+ finder.latest_search_id,
+ true, // did-cancel
+ query.clone(),
+ vec![matches[0].clone(), matches[2].clone(), matches[3].clone()],
+ ),
+ ctx,
+ );
+
+ assert_eq!(finder.matches, matches[0..4])
});
}
- #[test]
- fn test_single_file_worktrees() {
- App::test_async((), |mut app| async move {
- let temp_dir = TempDir::new("test-single-file-worktrees").unwrap();
- let dir_path = temp_dir.path().join("the-parent-dir");
- let file_path = dir_path.join("the-file");
- fs::create_dir(&dir_path).unwrap();
- fs::write(&file_path, "").unwrap();
-
- let settings = settings::channel(&app.font_cache()).unwrap().1;
- 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))
- .await;
- let (_, finder) =
- app.add_window(|ctx| FileFinder::new(settings, workspace.clone(), ctx));
-
- // Even though there is only one worktree, that worktree's filename
- // is included in the matching, because the worktree is a single file.
- finder.update(&mut app, |f, ctx| f.spawn_search("thf".into(), ctx));
- finder.condition(&app, |f, _| f.matches.len() == 1).await;
-
- app.read(|ctx| {
- let finder = finder.read(ctx);
- let (file_name, file_name_positions, full_path, full_path_positions) =
- finder.labels_for_match(&finder.matches[0], ctx).unwrap();
-
- assert_eq!(file_name, "the-file");
- assert_eq!(file_name_positions, &[0, 1, 4]);
- assert_eq!(full_path, "the-file");
- assert_eq!(full_path_positions, &[0, 1, 4]);
- });
-
- // Since the worktree root is a file, searching for its name followed by a slash does
- // not match anything.
- finder.update(&mut app, |f, ctx| f.spawn_search("thf/".into(), ctx));
- finder.condition(&app, |f, _| f.matches.len() == 0).await;
+ #[gpui::test]
+ async fn test_single_file_worktrees(mut app: gpui::TestAppContext) {
+ let temp_dir = TempDir::new("test-single-file-worktrees").unwrap();
+ let dir_path = temp_dir.path().join("the-parent-dir");
+ let file_path = dir_path.join("the-file");
+ fs::create_dir(&dir_path).unwrap();
+ fs::write(&file_path, "").unwrap();
+
+ let settings = settings::channel(&app.font_cache()).unwrap().1;
+ 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))
+ .await;
+ let (_, finder) = app.add_window(|ctx| FileFinder::new(settings, workspace.clone(), ctx));
+
+ // Even though there is only one worktree, that worktree's filename
+ // is included in the matching, because the worktree is a single file.
+ finder.update(&mut app, |f, ctx| f.spawn_search("thf".into(), ctx));
+ finder.condition(&app, |f, _| f.matches.len() == 1).await;
+
+ app.read(|ctx| {
+ let finder = finder.read(ctx);
+ let (file_name, file_name_positions, full_path, full_path_positions) =
+ finder.labels_for_match(&finder.matches[0], ctx).unwrap();
+
+ assert_eq!(file_name, "the-file");
+ assert_eq!(file_name_positions, &[0, 1, 4]);
+ assert_eq!(full_path, "the-file");
+ assert_eq!(full_path_positions, &[0, 1, 4]);
+ });
+
+ // Since the worktree root is a file, searching for its name followed by a slash does
+ // not match anything.
+ finder.update(&mut app, |f, ctx| f.spawn_search("thf/".into(), ctx));
+ finder.condition(&app, |f, _| f.matches.len() == 0).await;
}
- #[test]
- fn test_multiple_matches_with_same_relative_path() {
- App::test_async((), |mut app| async move {
- let tmp_dir = temp_tree(json!({
- "dir1": { "a.txt": "" },
- "dir2": { "a.txt": "" }
- }));
- let settings = settings::channel(&app.font_cache()).unwrap().1;
+ #[gpui::test]
+ async fn test_multiple_matches_with_same_relative_path(mut app: gpui::TestAppContext) {
+ let tmp_dir = temp_tree(json!({
+ "dir1": { "a.txt": "" },
+ "dir2": { "a.txt": "" }
+ }));
+ let settings = settings::channel(&app.font_cache()).unwrap().1;
- let (_, workspace) = app.add_window(|ctx| Workspace::new(0, settings.clone(), ctx));
+ let (_, workspace) = app.add_window(|ctx| Workspace::new(0, settings.clone(), 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))
- .await;
-
- let (_, finder) =
- app.add_window(|ctx| FileFinder::new(settings, workspace.clone(), ctx));
-
- // Run a search that matches two files with the same relative path.
- finder.update(&mut app, |f, ctx| f.spawn_search("a.t".into(), ctx));
- finder.condition(&app, |f, _| f.matches.len() == 2).await;
-
- // Can switch between different matches with the same relative path.
- finder.update(&mut app, |f, ctx| {
- assert_eq!(f.selected_index(), 0);
- f.select_next(&(), ctx);
- assert_eq!(f.selected_index(), 1);
- f.select_prev(&(), ctx);
- assert_eq!(f.selected_index(), 0);
- });
+ 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))
+ .await;
+
+ let (_, finder) = app.add_window(|ctx| FileFinder::new(settings, workspace.clone(), ctx));
+
+ // Run a search that matches two files with the same relative path.
+ finder.update(&mut app, |f, ctx| f.spawn_search("a.t".into(), ctx));
+ finder.condition(&app, |f, _| f.matches.len() == 2).await;
+
+ // Can switch between different matches with the same relative path.
+ finder.update(&mut app, |f, ctx| {
+ assert_eq!(f.selected_index(), 0);
+ f.select_next(&(), ctx);
+ assert_eq!(f.selected_index(), 1);
+ f.select_prev(&(), ctx);
+ assert_eq!(f.selected_index(), 0);
});
}
}
@@ -729,398 +729,387 @@ impl WorkspaceHandle for ViewHandle<Workspace> {
mod tests {
use super::*;
use crate::{editor::BufferView, settings, test::temp_tree};
- use gpui::App;
use serde_json::json;
use std::collections::HashSet;
use tempdir::TempDir;
- #[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);
- });
- }
+ #[gpui::test]
+ fn test_open_paths_action(app: &mut gpui::MutableAppContext) {
+ let settings = settings::channel(&app.font_cache()).unwrap().1;
- #[test]
- fn test_open_entry() {
- App::test_async((), |mut app| async move {
- let dir = temp_tree(json!({
- "a": {
- "file1": "contents 1",
- "file2": "contents 2",
- "file3": "contents 3",
- },
- }));
-
- 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.path(), ctx);
- workspace
- });
+ init(app);
- app.read(|ctx| workspace.read(ctx).worktree_scans_complete(ctx))
- .await;
- let entries = app.read(|ctx| workspace.file_entries(ctx));
- let file1 = entries[0].clone();
- let file2 = entries[1].clone();
- let file3 = entries[2].clone();
+ 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);
+ }
- // Open the first entry
- workspace
- .update(&mut app, |w, ctx| w.open_entry(file1.clone(), ctx))
- .unwrap()
- .await;
- app.read(|ctx| {
- let pane = workspace.read(ctx).active_pane().read(ctx);
- assert_eq!(
- pane.active_item().unwrap().entry_id(ctx),
- Some(file1.clone())
- );
- assert_eq!(pane.items().len(), 1);
- });
+ #[gpui::test]
+ async fn test_open_entry(mut app: gpui::TestAppContext) {
+ let dir = temp_tree(json!({
+ "a": {
+ "file1": "contents 1",
+ "file2": "contents 2",
+ "file3": "contents 3",
+ },
+ }));
+
+ let settings = settings::channel(&app.font_cache()).unwrap().1;
- // Open the second entry
+ let (_, workspace) = app.add_window(|ctx| {
+ let mut workspace = Workspace::new(0, settings, ctx);
+ workspace.add_worktree(dir.path(), ctx);
workspace
- .update(&mut app, |w, ctx| w.open_entry(file2.clone(), ctx))
- .unwrap()
- .await;
- app.read(|ctx| {
- let pane = workspace.read(ctx).active_pane().read(ctx);
- assert_eq!(
- pane.active_item().unwrap().entry_id(ctx),
- Some(file2.clone())
- );
- assert_eq!(pane.items().len(), 2);
- });
-
- // Open the first entry again. The existing pane item is activated.
- workspace.update(&mut app, |w, ctx| {
- assert!(w.open_entry(file1.clone(), ctx).is_none())
- });
- app.read(|ctx| {
- let pane = workspace.read(ctx).active_pane().read(ctx);
- assert_eq!(
- pane.active_item().unwrap().entry_id(ctx),
- Some(file1.clone())
- );
- assert_eq!(pane.items().len(), 2);
- });
-
- // Split the pane with the first entry, then open the second entry again.
- workspace.update(&mut app, |w, ctx| {
- w.split_pane(w.active_pane().clone(), SplitDirection::Right, ctx);
- assert!(w.open_entry(file2.clone(), ctx).is_none());
- assert_eq!(
- w.active_pane()
- .read(ctx)
- .active_item()
- .unwrap()
- .entry_id(ctx.as_ref()),
- Some(file2.clone())
- );
- });
-
- // Open the third entry twice concurrently. Two pane items
- // are added.
- let (t1, t2) = workspace.update(&mut app, |w, ctx| {
- (
- w.open_entry(file3.clone(), ctx).unwrap(),
- w.open_entry(file3.clone(), ctx).unwrap(),
- )
- });
- t1.await;
- t2.await;
- app.read(|ctx| {
- let pane = workspace.read(ctx).active_pane().read(ctx);
- assert_eq!(
- pane.active_item().unwrap().entry_id(ctx),
- Some(file3.clone())
- );
- let pane_entries = pane
- .items()
- .iter()
- .map(|i| i.entry_id(ctx).unwrap())
- .collect::<Vec<_>>();
- assert_eq!(pane_entries, &[file1, file2, file3.clone(), file3]);
- });
});
- }
- #[test]
- fn test_open_paths() {
- App::test_async((), |mut app| async move {
- let dir1 = temp_tree(json!({
- "a.txt": "",
- }));
- let dir2 = temp_tree(json!({
- "b.txt": "",
- }));
-
- 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(dir1.path(), ctx);
- workspace
- });
- app.read(|ctx| workspace.read(ctx).worktree_scans_complete(ctx))
- .await;
-
- // Open a file within an existing worktree.
- app.update(|ctx| {
- workspace.update(ctx, |view, ctx| {
- view.open_paths(&[dir1.path().join("a.txt")], ctx)
- })
- })
+ app.read(|ctx| workspace.read(ctx).worktree_scans_complete(ctx))
.await;
- app.read(|ctx| {
- assert_eq!(
- workspace
- .read(ctx)
- .active_pane()
- .read(ctx)
- .active_item()
- .unwrap()
- .title(ctx),
- "a.txt"
- );
- });
+ let entries = app.read(|ctx| workspace.file_entries(ctx));
+ let file1 = entries[0].clone();
+ let file2 = entries[1].clone();
+ let file3 = entries[2].clone();
+
+ // Open the first entry
+ workspace
+ .update(&mut app, |w, ctx| w.open_entry(file1.clone(), ctx))
+ .unwrap()
+ .await;
+ app.read(|ctx| {
+ let pane = workspace.read(ctx).active_pane().read(ctx);
+ assert_eq!(
+ pane.active_item().unwrap().entry_id(ctx),
+ Some(file1.clone())
+ );
+ assert_eq!(pane.items().len(), 1);
+ });
- // Open a file outside of any existing worktree.
- app.update(|ctx| {
- workspace.update(ctx, |view, ctx| {
- view.open_paths(&[dir2.path().join("b.txt")], ctx)
- })
- })
+ // Open the second entry
+ workspace
+ .update(&mut app, |w, ctx| w.open_entry(file2.clone(), ctx))
+ .unwrap()
.await;
- app.read(|ctx| {
- let worktree_roots = workspace
+ app.read(|ctx| {
+ let pane = workspace.read(ctx).active_pane().read(ctx);
+ assert_eq!(
+ pane.active_item().unwrap().entry_id(ctx),
+ Some(file2.clone())
+ );
+ assert_eq!(pane.items().len(), 2);
+ });
+
+ // Open the first entry again. The existing pane item is activated.
+ workspace.update(&mut app, |w, ctx| {
+ assert!(w.open_entry(file1.clone(), ctx).is_none())
+ });
+ app.read(|ctx| {
+ let pane = workspace.read(ctx).active_pane().read(ctx);
+ assert_eq!(
+ pane.active_item().unwrap().entry_id(ctx),
+ Some(file1.clone())
+ );
+ assert_eq!(pane.items().len(), 2);
+ });
+
+ // Split the pane with the first entry, then open the second entry again.
+ workspace.update(&mut app, |w, ctx| {
+ w.split_pane(w.active_pane().clone(), SplitDirection::Right, ctx);
+ assert!(w.open_entry(file2.clone(), ctx).is_none());
+ assert_eq!(
+ w.active_pane()
.read(ctx)
- .worktrees()
- .iter()
- .map(|w| w.read(ctx).abs_path())
- .collect::<HashSet<_>>();
- assert_eq!(
- worktree_roots,
- vec![dir1.path(), &dir2.path().join("b.txt")]
- .into_iter()
- .collect(),
- );
- assert_eq!(
- workspace
- .read(ctx)
- .active_pane()
- .read(ctx)
- .active_item()
- .unwrap()
- .title(ctx),
- "b.txt"
- );
- });
+ .active_item()
+ .unwrap()
+ .entry_id(ctx.as_ref()),
+ Some(file2.clone())
+ );
+ });
+
+ // Open the third entry twice concurrently. Two pane items
+ // are added.
+ let (t1, t2) = workspace.update(&mut app, |w, ctx| {
+ (
+ w.open_entry(file3.clone(), ctx).unwrap(),
+ w.open_entry(file3.clone(), ctx).unwrap(),
+ )
+ });
+ t1.await;
+ t2.await;
+ app.read(|ctx| {
+ let pane = workspace.read(ctx).active_pane().read(ctx);
+ assert_eq!(
+ pane.active_item().unwrap().entry_id(ctx),
+ Some(file3.clone())
+ );
+ let pane_entries = pane
+ .items()
+ .iter()
+ .map(|i| i.entry_id(ctx).unwrap())
+ .collect::<Vec<_>>();
+ assert_eq!(pane_entries, &[file1, file2, file3.clone(), file3]);
});
}
- #[test]
- fn test_open_and_save_new_file() {
- App::test_async((), |mut app| async move {
- let dir = TempDir::new("test-new-file").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.path(), ctx);
- workspace
- });
- let tree = app.read(|ctx| {
+ #[gpui::test]
+ async fn test_open_paths(mut app: gpui::TestAppContext) {
+ let dir1 = temp_tree(json!({
+ "a.txt": "",
+ }));
+ let dir2 = temp_tree(json!({
+ "b.txt": "",
+ }));
+
+ 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(dir1.path(), ctx);
+ workspace
+ });
+ app.read(|ctx| workspace.read(ctx).worktree_scans_complete(ctx))
+ .await;
+
+ // Open a file within an existing worktree.
+ app.update(|ctx| {
+ workspace.update(ctx, |view, ctx| {
+ view.open_paths(&[dir1.path().join("a.txt")], ctx)
+ })
+ })
+ .await;
+ app.read(|ctx| {
+ assert_eq!(
workspace
.read(ctx)
- .worktrees()
- .iter()
- .next()
+ .active_pane()
+ .read(ctx)
+ .active_item()
.unwrap()
- .clone()
- });
- tree.flush_fs_events(&app).await;
+ .title(ctx),
+ "a.txt"
+ );
+ });
- // Create a new untitled buffer
- let editor = workspace.update(&mut app, |workspace, ctx| {
- workspace.open_new_file(&(), ctx);
- workspace
- .active_item(ctx)
- .unwrap()
- .to_any()
- .downcast::<BufferView>()
- .unwrap()
- });
- editor.update(&mut app, |editor, ctx| {
- assert!(!editor.is_dirty(ctx.as_ref()));
- assert_eq!(editor.title(ctx.as_ref()), "untitled");
- editor.insert(&"hi".to_string(), ctx);
- assert!(editor.is_dirty(ctx.as_ref()));
- });
-
- // Save the buffer. This prompts for a filename.
- workspace.update(&mut app, |workspace, ctx| {
- workspace.save_active_item(&(), ctx)
- });
- app.simulate_new_path_selection(|parent_dir| {
- assert_eq!(parent_dir, dir.path());
- Some(parent_dir.join("the-new-name"))
- });
- app.read(|ctx| {
- assert!(editor.is_dirty(ctx));
- assert_eq!(editor.title(ctx), "untitled");
- });
-
- // When the save completes, the buffer's title is updated.
- tree.update(&mut app, |tree, ctx| tree.next_scan_complete(ctx))
- .await;
- app.read(|ctx| {
- assert!(!editor.is_dirty(ctx));
- assert_eq!(editor.title(ctx), "the-new-name");
- });
-
- // Edit the file and save it again. This time, there is no filename prompt.
- editor.update(&mut app, |editor, ctx| {
- editor.insert(&" there".to_string(), ctx);
- assert_eq!(editor.is_dirty(ctx.as_ref()), true);
- });
- workspace.update(&mut app, |workspace, ctx| {
- workspace.save_active_item(&(), ctx)
- });
- assert!(!app.did_prompt_for_new_path());
- editor
- .condition(&app, |editor, ctx| !editor.is_dirty(ctx))
- .await;
- app.read(|ctx| assert_eq!(editor.title(ctx), "the-new-name"));
-
- // Open the same newly-created file in another pane item. The new editor should reuse
- // the same buffer.
- workspace.update(&mut app, |workspace, ctx| {
- workspace.open_new_file(&(), ctx);
- workspace.split_pane(workspace.active_pane().clone(), SplitDirection::Right, ctx);
- assert!(workspace
- .open_entry((tree.id(), Path::new("the-new-name").into()), ctx)
- .is_none());
- });
- let editor2 = workspace.update(&mut app, |workspace, ctx| {
+ // Open a file outside of any existing worktree.
+ app.update(|ctx| {
+ workspace.update(ctx, |view, ctx| {
+ view.open_paths(&[dir2.path().join("b.txt")], ctx)
+ })
+ })
+ .await;
+ app.read(|ctx| {
+ let worktree_roots = workspace
+ .read(ctx)
+ .worktrees()
+ .iter()
+ .map(|w| w.read(ctx).abs_path())
+ .collect::<HashSet<_>>();
+ assert_eq!(
+ worktree_roots,
+ vec![dir1.path(), &dir2.path().join("b.txt")]
+ .into_iter()
+ .collect(),
+ );
+ assert_eq!(
workspace
- .active_item(ctx)
- .unwrap()
- .to_any()
- .downcast::<BufferView>()
+ .read(ctx)
+ .active_pane()
+ .read(ctx)
+ .active_item()
.unwrap()
- });
- app.read(|ctx| {
- assert_eq!(editor2.read(ctx).buffer(), editor.read(ctx).buffer());
- })
+ .title(ctx),
+ "b.txt"
+ );
});
}
- #[test]
- fn test_pane_actions() {
- App::test_async((), |mut app| async move {
- app.update(|ctx| pane::init(ctx));
-
- let dir = temp_tree(json!({
- "a": {
- "file1": "contents 1",
- "file2": "contents 2",
- "file3": "contents 3",
- },
- }));
-
- let settings = settings::channel(&app.font_cache()).unwrap().1;
- 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))
- .await;
- let entries = app.read(|ctx| workspace.file_entries(ctx));
- let file1 = entries[0].clone();
+ #[gpui::test]
+ async fn test_open_and_save_new_file(mut app: gpui::TestAppContext) {
+ let dir = TempDir::new("test-new-file").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.path(), ctx);
+ workspace
+ });
+ let tree = app.read(|ctx| {
+ workspace
+ .read(ctx)
+ .worktrees()
+ .iter()
+ .next()
+ .unwrap()
+ .clone()
+ });
+ tree.flush_fs_events(&app).await;
- let pane_1 = app.read(|ctx| workspace.read(ctx).active_pane().clone());
+ // Create a new untitled buffer
+ let editor = workspace.update(&mut app, |workspace, ctx| {
+ workspace.open_new_file(&(), ctx);
+ workspace
+ .active_item(ctx)
+ .unwrap()
+ .to_any()
+ .downcast::<BufferView>()
+ .unwrap()
+ });
+ editor.update(&mut app, |editor, ctx| {
+ assert!(!editor.is_dirty(ctx.as_ref()));
+ assert_eq!(editor.title(ctx.as_ref()), "untitled");
+ editor.insert(&"hi".to_string(), ctx);
+ assert!(editor.is_dirty(ctx.as_ref()));
+ });
+ // Save the buffer. This prompts for a filename.
+ workspace.update(&mut app, |workspace, ctx| {
+ workspace.save_active_item(&(), ctx)
+ });
+ app.simulate_new_path_selection(|parent_dir| {
+ assert_eq!(parent_dir, dir.path());
+ Some(parent_dir.join("the-new-name"))
+ });
+ app.read(|ctx| {
+ assert!(editor.is_dirty(ctx));
+ assert_eq!(editor.title(ctx), "untitled");
+ });
+
+ // When the save completes, the buffer's title is updated.
+ tree.update(&mut app, |tree, ctx| tree.next_scan_complete(ctx))
+ .await;
+ app.read(|ctx| {
+ assert!(!editor.is_dirty(ctx));
+ assert_eq!(editor.title(ctx), "the-new-name");
+ });
+
+ // Edit the file and save it again. This time, there is no filename prompt.
+ editor.update(&mut app, |editor, ctx| {
+ editor.insert(&" there".to_string(), ctx);
+ assert_eq!(editor.is_dirty(ctx.as_ref()), true);
+ });
+ workspace.update(&mut app, |workspace, ctx| {
+ workspace.save_active_item(&(), ctx)
+ });
+ assert!(!app.did_prompt_for_new_path());
+ editor
+ .condition(&app, |editor, ctx| !editor.is_dirty(ctx))
+ .await;
+ app.read(|ctx| assert_eq!(editor.title(ctx), "the-new-name"));
+
+ // Open the same newly-created file in another pane item. The new editor should reuse
+ // the same buffer.
+ workspace.update(&mut app, |workspace, ctx| {
+ workspace.open_new_file(&(), ctx);
+ workspace.split_pane(workspace.active_pane().clone(), SplitDirection::Right, ctx);
+ assert!(workspace
+ .open_entry((tree.id(), Path::new("the-new-name").into()), ctx)
+ .is_none());
+ });
+ let editor2 = workspace.update(&mut app, |workspace, ctx| {
workspace
- .update(&mut app, |w, ctx| w.open_entry(file1.clone(), ctx))
+ .active_item(ctx)
.unwrap()
- .await;
- app.read(|ctx| {
- assert_eq!(
- pane_1.read(ctx).active_item().unwrap().entry_id(ctx),
- Some(file1.clone())
- );
- });
+ .to_any()
+ .downcast::<BufferView>()
+ .unwrap()
+ });
+ app.read(|ctx| {
+ assert_eq!(editor2.read(ctx).buffer(), editor.read(ctx).buffer());
+ })
+ }
+
+ #[gpui::test]
+ async fn test_pane_actions(mut app: gpui::TestAppContext) {
+ app.update(|ctx| pane::init(ctx));
+
+ let dir = temp_tree(json!({
+ "a": {
+ "file1": "contents 1",
+ "file2": "contents 2",
+ "file3": "contents 3",
+ },
+ }));
+
+ let settings = settings::channel(&app.font_cache()).unwrap().1;
+ 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))
+ .await;
+ let entries = app.read(|ctx| workspace.file_entries(ctx));
+ let file1 = entries[0].clone();
+
+ let pane_1 = app.read(|ctx| workspace.read(ctx).active_pane().clone());
+
+ workspace
+ .update(&mut app, |w, ctx| w.open_entry(file1.clone(), ctx))
+ .unwrap()
+ .await;
+ app.read(|ctx| {
+ assert_eq!(
+ pane_1.read(ctx).active_item().unwrap().entry_id(ctx),
+ Some(file1.clone())
+ );
+ });
- app.dispatch_action(window_id, vec![pane_1.id()], "pane:split_right", ());
- app.update(|ctx| {
- let pane_2 = workspace.read(ctx).active_pane().clone();
- assert_ne!(pane_1, pane_2);
+ app.dispatch_action(window_id, vec![pane_1.id()], "pane:split_right", ());
+ app.update(|ctx| {
+ let pane_2 = workspace.read(ctx).active_pane().clone();
+ assert_ne!(pane_1, pane_2);
- let pane2_item = pane_2.read(ctx).active_item().unwrap();
- assert_eq!(pane2_item.entry_id(ctx.as_ref()), Some(file1.clone()));
+ let pane2_item = pane_2.read(ctx).active_item().unwrap();
+ 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", ());
- let workspace_view = workspace.read(ctx);
- assert_eq!(workspace_view.panes.len(), 1);
- assert_eq!(workspace_view.active_pane(), &pane_1);
- });
+ ctx.dispatch_action(window_id, vec![pane_2.id()], "pane:close_active_item", ());
+ let workspace_view = workspace.read(ctx);
+ assert_eq!(workspace_view.panes.len(), 1);
+ assert_eq!(workspace_view.active_pane(), &pane_1);
});
}
}
@@ -1353,7 +1353,6 @@ mod tests {
use crate::editor::Buffer;
use crate::test::*;
use anyhow::Result;
- use gpui::App;
use rand::prelude::*;
use serde_json::json;
use std::env;
@@ -1361,248 +1360,237 @@ mod tests {
use std::os::unix;
use std::time::{SystemTime, UNIX_EPOCH};
- #[test]
- fn test_populate_and_search() {
- App::test_async((), |mut app| async move {
- let dir = temp_tree(json!({
- "root": {
- "apple": "",
- "banana": {
- "carrot": {
- "date": "",
- "endive": "",
- }
- },
- "fennel": {
- "grape": "",
+ #[gpui::test]
+ async fn test_populate_and_search(mut app: gpui::TestAppContext) {
+ let dir = temp_tree(json!({
+ "root": {
+ "apple": "",
+ "banana": {
+ "carrot": {
+ "date": "",
+ "endive": "",
}
+ },
+ "fennel": {
+ "grape": "",
}
- }));
+ }
+ }));
- let root_link_path = dir.path().join("root_link");
- unix::fs::symlink(&dir.path().join("root"), &root_link_path).unwrap();
- unix::fs::symlink(
- &dir.path().join("root/fennel"),
- &dir.path().join("root/finnochio"),
- )
- .unwrap();
+ let root_link_path = dir.path().join("root_link");
+ unix::fs::symlink(&dir.path().join("root"), &root_link_path).unwrap();
+ unix::fs::symlink(
+ &dir.path().join("root/fennel"),
+ &dir.path().join("root/finnochio"),
+ )
+ .unwrap();
- let tree = app.add_model(|ctx| Worktree::new(root_link_path, ctx));
+ let tree = app.add_model(|ctx| Worktree::new(root_link_path, ctx));
- app.read(|ctx| tree.read(ctx).scan_complete()).await;
- app.read(|ctx| {
- let tree = tree.read(ctx);
- assert_eq!(tree.file_count(), 5);
+ app.read(|ctx| tree.read(ctx).scan_complete()).await;
+ app.read(|ctx| {
+ let tree = tree.read(ctx);
+ assert_eq!(tree.file_count(), 5);
- assert_eq!(
- tree.inode_for_path("fennel/grape"),
- tree.inode_for_path("finnochio/grape")
- );
+ assert_eq!(
+ tree.inode_for_path("fennel/grape"),
+ tree.inode_for_path("finnochio/grape")
+ );
- let results = match_paths(
- Some(tree.snapshot()).iter(),
- "bna",
- false,
- false,
- false,
- 10,
- Default::default(),
- ctx.thread_pool().clone(),
- )
- .into_iter()
- .map(|result| result.path)
- .collect::<Vec<Arc<Path>>>();
- assert_eq!(
- results,
- vec![
- PathBuf::from("banana/carrot/date").into(),
- PathBuf::from("banana/carrot/endive").into(),
- ]
- );
- })
- });
+ let results = match_paths(
+ Some(tree.snapshot()).iter(),
+ "bna",
+ false,
+ false,
+ false,
+ 10,
+ Default::default(),
+ ctx.thread_pool().clone(),
+ )
+ .into_iter()
+ .map(|result| result.path)
+ .collect::<Vec<Arc<Path>>>();
+ assert_eq!(
+ results,
+ vec![
+ PathBuf::from("banana/carrot/date").into(),
+ PathBuf::from("banana/carrot/endive").into(),
+ ]
+ );
+ })
}
- #[test]
- fn test_save_file() {
- App::test_async((), |mut app| async move {
- let dir = temp_tree(json!({
- "file1": "the old contents",
- }));
+ #[gpui::test]
+ async fn test_save_file(mut app: gpui::TestAppContext) {
+ let dir = temp_tree(json!({
+ "file1": "the old contents",
+ }));
- let tree = app.add_model(|ctx| Worktree::new(dir.path(), ctx));
- app.read(|ctx| tree.read(ctx).scan_complete()).await;
- app.read(|ctx| assert_eq!(tree.read(ctx).file_count(), 1));
+ let tree = app.add_model(|ctx| Worktree::new(dir.path(), ctx));
+ app.read(|ctx| tree.read(ctx).scan_complete()).await;
+ app.read(|ctx| assert_eq!(tree.read(ctx).file_count(), 1));
- let buffer =
- app.add_model(|ctx| Buffer::new(1, "a line of text.\n".repeat(10 * 1024), ctx));
+ let buffer =
+ 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.files(0).next().unwrap().path().clone();
- assert_eq!(path.file_name().unwrap(), "file1");
- smol::block_on(tree.save(&path, buffer.read(ctx).snapshot(), ctx.as_ref()))
- .unwrap();
- path
- });
+ let path = tree.update(&mut app, |tree, ctx| {
+ let path = tree.files(0).next().unwrap().path().clone();
+ assert_eq!(path.file_name().unwrap(), "file1");
+ smol::block_on(tree.save(&path, buffer.read(ctx).snapshot(), ctx.as_ref())).unwrap();
+ path
+ });
- let history = app
- .read(|ctx| tree.read(ctx).load_history(&path, ctx))
- .await
- .unwrap();
- app.read(|ctx| {
- assert_eq!(history.base_text.as_ref(), buffer.read(ctx).text());
- });
+ let history = app
+ .read(|ctx| tree.read(ctx).load_history(&path, ctx))
+ .await
+ .unwrap();
+ app.read(|ctx| {
+ assert_eq!(history.base_text.as_ref(), buffer.read(ctx).text());
});
}
- #[test]
- fn test_save_in_single_file_worktree() {
- App::test_async((), |mut app| async move {
- let dir = temp_tree(json!({
- "file1": "the old contents",
- }));
-
- let tree = app.add_model(|ctx| Worktree::new(dir.path().join("file1"), ctx));
- app.read(|ctx| tree.read(ctx).scan_complete()).await;
- app.read(|ctx| assert_eq!(tree.read(ctx).file_count(), 1));
+ #[gpui::test]
+ async fn test_save_in_single_file_worktree(mut app: gpui::TestAppContext) {
+ let dir = temp_tree(json!({
+ "file1": "the old contents",
+ }));
- let buffer =
- app.add_model(|ctx| Buffer::new(1, "a line of text.\n".repeat(10 * 1024), ctx));
+ let tree = app.add_model(|ctx| Worktree::new(dir.path().join("file1"), ctx));
+ app.read(|ctx| tree.read(ctx).scan_complete()).await;
+ app.read(|ctx| assert_eq!(tree.read(ctx).file_count(), 1));
- let file = app.read(|ctx| tree.file("", ctx));
- app.update(|ctx| {
- assert_eq!(file.path().file_name(), None);
- smol::block_on(file.save(buffer.read(ctx).snapshot(), ctx.as_ref())).unwrap();
- });
+ let buffer =
+ app.add_model(|ctx| Buffer::new(1, "a line of text.\n".repeat(10 * 1024), ctx));
- let history = app.read(|ctx| file.load_history(ctx)).await.unwrap();
- app.read(|ctx| assert_eq!(history.base_text.as_ref(), buffer.read(ctx).text()));
+ let file = app.read(|ctx| tree.file("", ctx));
+ app.update(|ctx| {
+ assert_eq!(file.path().file_name(), None);
+ smol::block_on(file.save(buffer.read(ctx).snapshot(), ctx.as_ref())).unwrap();
});
+
+ let history = app.read(|ctx| file.load_history(ctx)).await.unwrap();
+ app.read(|ctx| assert_eq!(history.base_text.as_ref(), buffer.read(ctx).text()));
}
- #[test]
- fn test_rescan_simple() {
- App::test_async((), |mut app| async move {
- let dir = temp_tree(json!({
- "a": {
- "file1": "",
- "file2": "",
- "file3": "",
- },
- "b": {
- "c": {
- "file4": "",
- "file5": "",
- }
+ #[gpui::test]
+ async fn test_rescan_simple(mut app: gpui::TestAppContext) {
+ let dir = temp_tree(json!({
+ "a": {
+ "file1": "",
+ "file2": "",
+ "file3": "",
+ },
+ "b": {
+ "c": {
+ "file4": "",
+ "file5": "",
}
- }));
-
- let tree = app.add_model(|ctx| Worktree::new(dir.path(), ctx));
- let (file2, file3, file4, file5, non_existent_file) = app.read(|ctx| {
- (
- tree.file("a/file2", ctx),
- tree.file("a/file3", ctx),
- tree.file("b/c/file4", ctx),
- tree.file("b/c/file5", ctx),
- tree.file("a/filex", ctx),
- )
- });
+ }
+ }));
+
+ let tree = app.add_model(|ctx| Worktree::new(dir.path(), ctx));
+ let (file2, file3, file4, file5, non_existent_file) = app.read(|ctx| {
+ (
+ tree.file("a/file2", ctx),
+ tree.file("a/file3", ctx),
+ tree.file("b/c/file4", ctx),
+ tree.file("b/c/file5", ctx),
+ tree.file("a/filex", ctx),
+ )
+ });
- // The worktree hasn't scanned the directories containing these paths,
- // so it can't determine that the paths are deleted.
- assert!(!file2.is_deleted());
- assert!(!file3.is_deleted());
- assert!(!file4.is_deleted());
- assert!(!file5.is_deleted());
- assert!(!non_existent_file.is_deleted());
+ // The worktree hasn't scanned the directories containing these paths,
+ // so it can't determine that the paths are deleted.
+ assert!(!file2.is_deleted());
+ assert!(!file3.is_deleted());
+ assert!(!file4.is_deleted());
+ assert!(!file5.is_deleted());
+ assert!(!non_existent_file.is_deleted());
+
+ // After scanning, the worktree knows which files exist and which don't.
+ app.read(|ctx| tree.read(ctx).scan_complete()).await;
+ assert!(!file2.is_deleted());
+ assert!(!file3.is_deleted());
+ assert!(!file4.is_deleted());
+ assert!(!file5.is_deleted());
+ assert!(non_existent_file.is_deleted());
+
+ tree.flush_fs_events(&app).await;
+ std::fs::rename(dir.path().join("a/file3"), dir.path().join("b/c/file3")).unwrap();
+ std::fs::remove_file(dir.path().join("b/c/file5")).unwrap();
+ std::fs::rename(dir.path().join("b/c"), dir.path().join("d")).unwrap();
+ std::fs::rename(dir.path().join("a/file2"), dir.path().join("a/file2.new")).unwrap();
+ tree.update(&mut app, |tree, ctx| tree.next_scan_complete(ctx))
+ .await;
- // After scanning, the worktree knows which files exist and which don't.
- app.read(|ctx| tree.read(ctx).scan_complete()).await;
+ app.read(|ctx| {
+ assert_eq!(
+ tree.read(ctx)
+ .paths()
+ .map(|p| p.to_str().unwrap())
+ .collect::<Vec<_>>(),
+ vec![
+ "a",
+ "a/file1",
+ "a/file2.new",
+ "b",
+ "d",
+ "d/file3",
+ "d/file4"
+ ]
+ );
+
+ assert_eq!(file2.path().to_str().unwrap(), "a/file2.new");
+ assert_eq!(file4.path().as_ref(), Path::new("d/file4"));
+ assert_eq!(file5.path().as_ref(), Path::new("d/file5"));
assert!(!file2.is_deleted());
- assert!(!file3.is_deleted());
assert!(!file4.is_deleted());
- assert!(!file5.is_deleted());
- assert!(non_existent_file.is_deleted());
-
- tree.flush_fs_events(&app).await;
- std::fs::rename(dir.path().join("a/file3"), dir.path().join("b/c/file3")).unwrap();
- std::fs::remove_file(dir.path().join("b/c/file5")).unwrap();
- std::fs::rename(dir.path().join("b/c"), dir.path().join("d")).unwrap();
- std::fs::rename(dir.path().join("a/file2"), dir.path().join("a/file2.new")).unwrap();
- tree.update(&mut app, |tree, ctx| tree.next_scan_complete(ctx))
- .await;
-
- app.read(|ctx| {
- assert_eq!(
- tree.read(ctx)
- .paths()
- .map(|p| p.to_str().unwrap())
- .collect::<Vec<_>>(),
- vec![
- "a",
- "a/file1",
- "a/file2.new",
- "b",
- "d",
- "d/file3",
- "d/file4"
- ]
- );
+ assert!(file5.is_deleted());
- assert_eq!(file2.path().to_str().unwrap(), "a/file2.new");
- assert_eq!(file4.path().as_ref(), Path::new("d/file4"));
- assert_eq!(file5.path().as_ref(), Path::new("d/file5"));
- assert!(!file2.is_deleted());
- assert!(!file4.is_deleted());
- assert!(file5.is_deleted());
-
- // Right now, this rename isn't detected because the target path
- // no longer exists on the file system by the time we process the
- // rename event.
- assert_eq!(file3.path().as_ref(), Path::new("a/file3"));
- assert!(file3.is_deleted());
- });
+ // Right now, this rename isn't detected because the target path
+ // no longer exists on the file system by the time we process the
+ // rename event.
+ assert_eq!(file3.path().as_ref(), Path::new("a/file3"));
+ assert!(file3.is_deleted());
});
}
- #[test]
- fn test_rescan_with_gitignore() {
- App::test_async((), |mut app| async move {
- let dir = temp_tree(json!({
- ".git": {},
- ".gitignore": "ignored-dir\n",
- "tracked-dir": {
- "tracked-file1": "tracked contents",
- },
- "ignored-dir": {
- "ignored-file1": "ignored contents",
- }
- }));
-
- let tree = app.add_model(|ctx| Worktree::new(dir.path(), ctx));
- app.read(|ctx| tree.read(ctx).scan_complete()).await;
- tree.flush_fs_events(&app).await;
- app.read(|ctx| {
- let tree = tree.read(ctx);
- let tracked = tree.entry_for_path("tracked-dir/tracked-file1").unwrap();
- let ignored = tree.entry_for_path("ignored-dir/ignored-file1").unwrap();
- assert_eq!(tracked.is_ignored(), false);
- assert_eq!(ignored.is_ignored(), true);
- });
+ #[gpui::test]
+ async fn test_rescan_with_gitignore(mut app: gpui::TestAppContext) {
+ let dir = temp_tree(json!({
+ ".git": {},
+ ".gitignore": "ignored-dir\n",
+ "tracked-dir": {
+ "tracked-file1": "tracked contents",
+ },
+ "ignored-dir": {
+ "ignored-file1": "ignored contents",
+ }
+ }));
+
+ let tree = app.add_model(|ctx| Worktree::new(dir.path(), ctx));
+ app.read(|ctx| tree.read(ctx).scan_complete()).await;
+ tree.flush_fs_events(&app).await;
+ app.read(|ctx| {
+ let tree = tree.read(ctx);
+ let tracked = tree.entry_for_path("tracked-dir/tracked-file1").unwrap();
+ let ignored = tree.entry_for_path("ignored-dir/ignored-file1").unwrap();
+ assert_eq!(tracked.is_ignored(), false);
+ assert_eq!(ignored.is_ignored(), true);
+ });
- fs::write(dir.path().join("tracked-dir/tracked-file2"), "").unwrap();
- fs::write(dir.path().join("ignored-dir/ignored-file2"), "").unwrap();
- tree.update(&mut app, |tree, ctx| tree.next_scan_complete(ctx))
- .await;
- app.read(|ctx| {
- let tree = tree.read(ctx);
- let dot_git = tree.entry_for_path(".git").unwrap();
- let tracked = tree.entry_for_path("tracked-dir/tracked-file2").unwrap();
- let ignored = tree.entry_for_path("ignored-dir/ignored-file2").unwrap();
- assert_eq!(tracked.is_ignored(), false);
- assert_eq!(ignored.is_ignored(), true);
- assert_eq!(dot_git.is_ignored(), true);
- });
+ fs::write(dir.path().join("tracked-dir/tracked-file2"), "").unwrap();
+ fs::write(dir.path().join("ignored-dir/ignored-file2"), "").unwrap();
+ tree.update(&mut app, |tree, ctx| tree.next_scan_complete(ctx))
+ .await;
+ app.read(|ctx| {
+ let tree = tree.read(ctx);
+ let dot_git = tree.entry_for_path(".git").unwrap();
+ let tracked = tree.entry_for_path("tracked-dir/tracked-file2").unwrap();
+ let ignored = tree.entry_for_path("ignored-dir/ignored-file2").unwrap();
+ assert_eq!(tracked.is_ignored(), false);
+ assert_eq!(ignored.is_ignored(), true);
+ assert_eq!(dot_git.is_ignored(), true);
});
}