oak-team/oak-gpui
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Get app running and test passing after gpui App+Platform restructure

Browse Source
This commit is contained in:
Max Brunsfeld
2021-04-09 16:56:32 -07:00
parent 4ecc17b1bb
commit 079050541f
17 changed files with 719 additions and 749 deletions
Download Patch File Download Diff File Expand all files Collapse all files
zed/src/workspace/mod.rs
+18 -10
View File
@@ -9,7 +9,7 @@ pub use workspace::*;
pub use workspace_view::*;
use crate::{settings::Settings, watch};
use gpui::{App, MutableAppContext};
use gpui::MutableAppContext;
use std::path::PathBuf;
pub fn init(app: &mut MutableAppContext) {
@@ -64,10 +64,10 @@ mod tests {
#[test]
fn test_open_paths_action() {
App::test((), |mut app| async move {
App::test((), |app| {
let settings = settings::channel(&app.font_cache()).unwrap().1;
init(&mut app);
init(app);
let dir = temp_tree(json!({
"a": {
@@ -94,7 +94,7 @@ mod tests {
settings: settings.clone(),
},
);
assert_eq!(app.window_ids().len(), 1);
assert_eq!(app.window_ids().count(), 1);
app.dispatch_global_action(
"workspace:open_paths",
@@ -103,11 +103,19 @@ mod tests {
settings: settings.clone(),
},
);
assert_eq!(app.window_ids().len(), 1);
let workspace_view_1 = app.root_view::<WorkspaceView>(app.window_ids()[0]).unwrap();
workspace_view_1.read(&app, |view, app| {
assert_eq!(view.workspace.as_ref(app).worktrees().len(), 2);
});
assert_eq!(app.window_ids().count(), 1);
let workspace_view_1 = app
.root_view::<WorkspaceView>(app.window_ids().next().unwrap())
.unwrap();
assert_eq!(
workspace_view_1
.as_ref(app)
.workspace
.as_ref(app)
.worktrees()
.len(),
2
);
app.dispatch_global_action(
"workspace:open_paths",
@@ -119,7 +127,7 @@ mod tests {
settings: settings.clone(),
},
);
assert_eq!(app.window_ids().len(), 2);
assert_eq!(app.window_ids().count(), 2);
});
}
}
zed/src/workspace/pane.rs
+1 -1
View File
@@ -5,7 +5,7 @@ use gpui::{
elements::*,
geometry::{rect::RectF, vector::vec2f},
keymap::Binding,
App, AppContext, Border, Entity, MutableAppContext, Quad, View, ViewContext,
AppContext, Border, Entity, MutableAppContext, Quad, View, ViewContext,
};
use std::cmp;
zed/src/workspace/workspace.rs
+23 -27
View File
@@ -200,23 +200,22 @@ impl Entity for Workspace {
#[cfg(test)]
pub trait WorkspaceHandle {
fn file_entries(&self, app: &gpui::App) -> Vec<(usize, usize)>;
fn file_entries(&self, app: &mut MutableAppContext) -> Vec<(usize, usize)>;
}
#[cfg(test)]
impl WorkspaceHandle for ModelHandle<Workspace> {
fn file_entries(&self, app: &gpui::App) -> Vec<(usize, usize)> {
self.read(&app, |w, app| {
w.worktrees()
.iter()
.flat_map(|tree| {
let tree_id = tree.id();
tree.as_ref(app)
.files()
.map(move |file| (tree_id, file.entry_id))
})
.collect::<Vec<_>>()
})
fn file_entries(&self, app: &mut MutableAppContext) -> Vec<(usize, usize)> {
self.as_ref(app)
.worktrees()
.iter()
.flat_map(|tree| {
let tree_id = tree.id();
tree.as_ref(app)
.files()
.map(move |file| (tree_id, file.entry_id))
})
.collect::<Vec<_>>()
}
}
@@ -228,8 +227,8 @@ mod tests {
use serde_json::json;
#[test]
fn test_open_entry() -> Result<(), Arc<anyhow::Error>> {
App::test((), |mut app| async move {
fn test_open_entry() {
App::test_async((), |app| async move {
let dir = temp_tree(json!({
"a": {
"aa": "aa contents",
@@ -241,32 +240,29 @@ mod tests {
app.finish_pending_tasks().await; // Open and populate worktree.
// Get the first file entry.
let entry = workspace.read(&app, |w, app| {
let tree = w.worktrees.iter().next().unwrap();
let entry_id = tree.as_ref(app).files().next().unwrap().entry_id;
(tree.id(), entry_id)
});
let tree = workspace.as_ref(app).worktrees.iter().next().unwrap();
let entry_id = tree.as_ref(app).files().next().unwrap().entry_id;
let entry = (tree.id(), entry_id);
// Open the same entry twice before it finishes loading.
let (future_1, future_2) = workspace.update(&mut app, |w, app| {
let (future_1, future_2) = workspace.update(app, |w, app| {
(
w.open_entry(entry, app).unwrap(),
w.open_entry(entry, app).unwrap(),
)
});
let handle_1 = future_1.await?;
let handle_2 = future_2.await?;
let handle_1 = future_1.await.unwrap();
let handle_2 = future_2.await.unwrap();
assert_eq!(handle_1.id(), handle_2.id());
// Open the same entry again now that it has loaded
let handle_3 = workspace
.update(&mut app, |w, app| w.open_entry(entry, app).unwrap())
.await?;
.update(app, |w, app| w.open_entry(entry, app).unwrap())
.await
.unwrap();
assert_eq!(handle_3.id(), handle_1.id());
Ok(())
})
}
}
zed/src/workspace/workspace_view.rs
+60 -53
View File
@@ -2,8 +2,8 @@ use super::{pane, Pane, PaneGroup, SplitDirection, Workspace};
use crate::{settings::Settings, watch};
use futures_core::future::LocalBoxFuture;
use gpui::{
color::rgbu, elements::*, json::to_string_pretty, keymap::Binding, AnyViewHandle, App,
AppContext, Entity, ModelHandle, MutableAppContext, View, ViewContext, ViewHandle,
color::rgbu, elements::*, json::to_string_pretty, keymap::Binding, AnyViewHandle, AppContext,
Entity, ModelHandle, MutableAppContext, View, ViewContext, ViewHandle,
};
use log::{error, info};
use std::{collections::HashSet, path::PathBuf};
@@ -389,13 +389,12 @@ impl View for WorkspaceView {
mod tests {
use super::{pane, Workspace, WorkspaceView};
use crate::{settings, test::temp_tree, workspace::WorkspaceHandle as _};
use anyhow::Result;
use gpui::App;
use serde_json::json;
#[test]
fn test_open_entry() -> Result<()> {
App::test((), |mut app| async move {
fn test_open_entry() {
App::test_async((), |app| async move {
let dir = temp_tree(json!({
"a": {
"aa": "aa contents",
@@ -407,64 +406,70 @@ mod tests {
let settings = settings::channel(&app.font_cache()).unwrap().1;
let workspace = app.add_model(|ctx| Workspace::new(vec![dir.path().into()], ctx));
app.finish_pending_tasks().await; // Open and populate worktree.
let entries = workspace.file_entries(&app);
let entries = workspace.file_entries(app);
let (_, workspace_view) =
app.add_window(|ctx| WorkspaceView::new(workspace.clone(), settings, ctx));
// Open the first entry
workspace_view.update(&mut app, |w, ctx| w.open_entry(entries[0], ctx));
workspace_view.update(app, |w, ctx| w.open_entry(entries[0], ctx));
app.finish_pending_tasks().await;
workspace_view.read(&app, |w, app| {
assert_eq!(w.active_pane().as_ref(app).items().len(), 1);
});
assert_eq!(
workspace_view
.as_ref(app)
.active_pane()
.as_ref(app)
.items()
.len(),
1
);
// Open the second entry
workspace_view.update(&mut app, |w, ctx| w.open_entry(entries[1], ctx));
workspace_view.update(app, |w, ctx| w.open_entry(entries[1], ctx));
app.finish_pending_tasks().await;
workspace_view.read(&app, |w, app| {
let active_pane = w.active_pane().as_ref(app);
assert_eq!(active_pane.items().len(), 2);
assert_eq!(
active_pane.active_item().unwrap().entry_id(app),
Some(entries[1])
);
});
let active_pane = workspace_view.as_ref(app).active_pane().as_ref(app);
assert_eq!(active_pane.items().len(), 2);
assert_eq!(
active_pane.active_item().unwrap().entry_id(app.as_ref()),
Some(entries[1])
);
// Open the first entry again
workspace_view.update(&mut app, |w, ctx| w.open_entry(entries[0], ctx));
workspace_view.update(app, |w, ctx| w.open_entry(entries[0], ctx));
app.finish_pending_tasks().await;
workspace_view.read(&app, |w, app| {
let active_pane = w.active_pane().as_ref(app);
assert_eq!(active_pane.items().len(), 2);
assert_eq!(
active_pane.active_item().unwrap().entry_id(app),
Some(entries[0])
);
});
let active_pane = workspace_view.as_ref(app).active_pane().as_ref(app);
assert_eq!(active_pane.items().len(), 2);
assert_eq!(
active_pane.active_item().unwrap().entry_id(app.as_ref()),
Some(entries[0])
);
// Open the third entry twice concurrently
workspace_view.update(&mut app, |w, ctx| {
workspace_view.update(app, |w, ctx| {
w.open_entry(entries[2], ctx);
w.open_entry(entries[2], ctx);
});
app.finish_pending_tasks().await;
workspace_view.read(&app, |w, app| {
assert_eq!(w.active_pane().as_ref(app).items().len(), 3);
});
Ok(())
})
assert_eq!(
workspace_view
.as_ref(app)
.active_pane()
.as_ref(app)
.items()
.len(),
3
);
});
}
#[test]
fn test_pane_actions() -> Result<()> {
App::test((), |mut app| async move {
pane::init(&mut app);
fn test_pane_actions() {
App::test_async((), |app| async move {
pane::init(app);
let dir = temp_tree(json!({
"a": {
@@ -474,35 +479,37 @@ mod tests {
},
}));
let settings = settings::channel(&app.font_cache()).unwrap().1;
let settings = settings::channel(app.font_cache()).unwrap().1;
let workspace = app.add_model(|ctx| Workspace::new(vec![dir.path().into()], ctx));
app.finish_pending_tasks().await; // Open and populate worktree.
let entries = workspace.file_entries(&app);
let entries = workspace.file_entries(app);
let (window_id, workspace_view) =
app.add_window(|ctx| WorkspaceView::new(workspace.clone(), settings, ctx));
workspace_view.update(&mut app, |w, ctx| w.open_entry(entries[0], ctx));
workspace_view.update(app, |w, ctx| w.open_entry(entries[0], ctx));
app.finish_pending_tasks().await;
let pane_1 = workspace_view.read(&app, |w, _| w.active_pane().clone());
let pane_1 = workspace_view.as_ref(app).active_pane().clone();
app.dispatch_action(window_id, vec![pane_1.id()], "pane:split_right", ());
let pane_2 = workspace_view.read(&app, |w, _| w.active_pane().clone());
let pane_2 = workspace_view.as_ref(app).active_pane().clone();
assert_ne!(pane_1, pane_2);
pane_2.read(&app, |p, app| {
assert_eq!(p.active_item().unwrap().entry_id(app), Some(entries[0]));
});
assert_eq!(
pane_2
.as_ref(app)
.active_item()
.unwrap()
.entry_id(app.downgrade()),
Some(entries[0])
);
app.dispatch_action(window_id, vec![pane_2.id()], "pane:close_active_item", ());
workspace_view.read(&app, |w, _| {
assert_eq!(w.panes.len(), 1);
assert_eq!(w.active_pane(), &pane_1)
});
Ok(())
})
let w = workspace_view.as_ref(app);
assert_eq!(w.panes.len(), 1);
assert_eq!(w.active_pane(), &pane_1);
});
}
}