use anyhow::anyhow;use gpui::{AppContext, SharedString, Task, WeakEntity};use project::ProjectPath;use std::collections::VecDeque;use ui::{App, IntoElement, Label, ParentElement, Styled, v_flex};use workspace::{ Workspace, notifications::{NotificationId, simple_message_notification::MessageNotification},}; const MAX_UNDO_OPERATIONS: usize = 10_000; #[derive(Clone)]pub enum ProjectPanelOperation { Batch(Vec<ProjectPanelOperation>), Create { project_path: ProjectPath, }, Rename { old_path: ProjectPath, new_path: ProjectPath, },} pub struct UndoManager { workspace: WeakEntity<Workspace>, stack: VecDeque<ProjectPanelOperation>, /// Maximum number of operations to keep on the undo stack. limit: usize,} impl UndoManager { pub fn new(workspace: WeakEntity<Workspace>) -> Self { Self::new_with_limit(workspace, MAX_UNDO_OPERATIONS) } pub fn new_with_limit(workspace: WeakEntity<Workspace>, limit: usize) -> Self { Self { workspace, limit, stack: VecDeque::new(), } } pub fn can_undo(&self) -> bool { !self.stack.is_empty() } pub fn undo(&mut self, cx: &mut App) { if let Some(operation) = self.stack.pop_back() { let task = self.revert_operation(operation, cx); let workspace = self.workspace.clone(); cx.spawn(async move |cx| { let errors = task.await; if !errors.is_empty() { cx.update(|cx| { let messages = errors .iter() .map(|err| SharedString::from(err.to_string())) .collect(); Self::show_errors(workspace, messages, cx) }) } }) .detach(); } } pub fn record(&mut self, operation: ProjectPanelOperation) { if self.stack.len() >= self.limit { self.stack.pop_front(); } self.stack.push_back(operation); } pub fn record_batch(&mut self, operations: impl IntoIterator<Item = ProjectPanelOperation>) { let mut operations = operations.into_iter().collect::<Vec<_>>(); let operation = match operations.len() { 0 => return, 1 => operations.pop().unwrap(), _ => ProjectPanelOperation::Batch(operations), }; self.record(operation); } /// Attempts to revert the provided `operation`, returning a vector of errors /// in case there was any failure while reverting the operation. /// /// For all operations other than [`crate::undo::ProjectPanelOperation::Batch`], a maximum /// of one error is returned. fn revert_operation( &self, operation: ProjectPanelOperation, cx: &mut App, ) -> Task<Vec<anyhow::Error>> { match operation { ProjectPanelOperation::Create { project_path } => { let Some(workspace) = self.workspace.upgrade() else { return Task::ready(vec![anyhow!("Failed to obtain workspace.")]); }; let result = workspace.update(cx, |workspace, cx| { workspace.project().update(cx, |project, cx| { let entry_id = project .entry_for_path(&project_path, cx) .map(|entry| entry.id) .ok_or_else(|| anyhow!("No entry for path."))?; project .delete_entry(entry_id, true, cx) .ok_or_else(|| anyhow!("Failed to trash entry.")) }) }); let task = match result { Ok(task) => task, Err(err) => return Task::ready(vec![err]), }; cx.spawn(async move |_| match task.await { Ok(_) => vec![], Err(err) => vec![err], }) } ProjectPanelOperation::Rename { old_path, new_path } => { let Some(workspace) = self.workspace.upgrade() else { return Task::ready(vec![anyhow!("Failed to obtain workspace.")]); }; let result = workspace.update(cx, |workspace, cx| { workspace.project().update(cx, |project, cx| { let entry_id = project .entry_for_path(&new_path, cx) .map(|entry| entry.id) .ok_or_else(|| anyhow!("No entry for path."))?; Ok(project.rename_entry(entry_id, old_path.clone(), cx)) }) }); let task = match result { Ok(task) => task, Err(err) => return Task::ready(vec![err]), }; cx.spawn(async move |_| match task.await { Ok(_) => vec![], Err(err) => vec![err], }) } ProjectPanelOperation::Batch(operations) => { // When reverting operations in a batch, we reverse the order of // operations to handle dependencies between them. For example, // if a batch contains the following order of operations: // // 1. Create `src/` // 2. Create `src/main.rs` // // If we first try to revert the directory creation, it would // fail because there's still files inside the directory. // Operations are also reverted sequentially in order to avoid // this same problem. let tasks: Vec<_> = operations .into_iter() .rev() .map(|operation| self.revert_operation(operation, cx)) .collect(); cx.spawn(async move |_| { let mut errors = Vec::new(); for task in tasks { errors.extend(task.await); } errors }) } } } /// Displays a notification with the list of provided errors ensuring that, /// when more than one error is provided, which can be the case when dealing /// with undoing a [`crate::undo::ProjectPanelOperation::Batch`], a list is /// displayed with each of the errors, instead of a single message. fn show_errors(workspace: WeakEntity<Workspace>, messages: Vec<SharedString>, cx: &mut App) { workspace .update(cx, move |workspace, cx| { let notification_id = NotificationId::Named(SharedString::new_static("project_panel_undo")); workspace.show_notification(notification_id, cx, move |cx| { cx.new(|cx| { if let [err] = messages.as_slice() { MessageNotification::new(err.to_string(), cx) .with_title("Failed to undo Project Panel Operation") } else { MessageNotification::new_from_builder(cx, move |_, _| { v_flex() .gap_1() .children( messages .iter() .map(|message| Label::new(format!("- {message}"))), ) .into_any_element() }) .with_title("Failed to undo Project Panel Operations") } }) }) }) .ok(); }} #[cfg(test)]mod test { use crate::{ ProjectPanel, project_panel_tests, undo::{ProjectPanelOperation, UndoManager}, }; use gpui::{Entity, TestAppContext, VisualTestContext}; use project::{FakeFs, Project, ProjectPath}; use std::sync::Arc; use util::rel_path::rel_path; use workspace::MultiWorkspace; struct TestContext { project: Entity<Project>, panel: Entity<ProjectPanel>, } async fn init_test(cx: &mut TestAppContext) -> TestContext { project_panel_tests::init_test(cx); let fs = FakeFs::new(cx.executor()); let project = Project::test(fs.clone(), ["/root".as_ref()], cx).await; let window = cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx)); let workspace = window .read_with(cx, |mw, _| mw.workspace().clone()) .unwrap(); let cx = &mut VisualTestContext::from_window(window.into(), cx); let panel = workspace.update_in(cx, ProjectPanel::new); cx.run_until_parked(); TestContext { project, panel } } #[gpui::test] async fn test_limit(cx: &mut TestAppContext) { let test_context = init_test(cx).await; let worktree_id = test_context.project.update(cx, |project, cx| { project.visible_worktrees(cx).next().unwrap().read(cx).id() }); let build_create_operation = |file_name: &str| ProjectPanelOperation::Create { project_path: ProjectPath { path: Arc::from(rel_path(file_name)), worktree_id, }, }; // Since we're updating the `ProjectPanel`'s undo manager with one whose // limit is 3 operations, we only need to create 4 operations which // we'll record, in order to confirm that the oldest operation is // evicted. let operation_a = build_create_operation("file_a.txt"); let operation_b = build_create_operation("file_b.txt"); let operation_c = build_create_operation("file_c.txt"); let operation_d = build_create_operation("file_d.txt"); test_context.panel.update(cx, move |panel, _cx| { panel.undo_manager = UndoManager::new_with_limit(panel.workspace.clone(), 3); panel.undo_manager.record(operation_a); panel.undo_manager.record(operation_b); panel.undo_manager.record(operation_c); panel.undo_manager.record(operation_d); assert_eq!(panel.undo_manager.stack.len(), 3); }); }}
use anyhow::anyhow;
use gpui::{AppContext, SharedString, Task, WeakEntity};
use project::ProjectPath;
use std::collections::VecDeque;
use ui::{App, IntoElement, Label, ParentElement, Styled, v_flex};
use workspace::{
Workspace,
notifications::{NotificationId, simple_message_notification::MessageNotification},
};
const MAX_UNDO_OPERATIONS: usize = 10_000;
#[derive(Clone)]
pub enum ProjectPanelOperation {
Batch(Vec<ProjectPanelOperation>),
Create {
project_path: ProjectPath,
},
Rename {
old_path: ProjectPath,
new_path: ProjectPath,
},
}
pub struct UndoManager {
workspace: WeakEntity<Workspace>,
stack: VecDeque<ProjectPanelOperation>,
/// Maximum number of operations to keep on the undo stack.
limit: usize,
}
impl UndoManager {
pub fn new(workspace: WeakEntity<Workspace>) -> Self {
Self::new_with_limit(workspace, MAX_UNDO_OPERATIONS)
}
pub fn new_with_limit(workspace: WeakEntity<Workspace>, limit: usize) -> Self {
Self {
workspace,
limit,
stack: VecDeque::new(),
}
}
pub fn can_undo(&self) -> bool {
!self.stack.is_empty()
}
pub fn undo(&mut self, cx: &mut App) {
if let Some(operation) = self.stack.pop_back() {
let task = self.revert_operation(operation, cx);
let workspace = self.workspace.clone();
cx.spawn(async move |cx| {
let errors = task.await;
if !errors.is_empty() {
cx.update(|cx| {
let messages = errors
.iter()
.map(|err| SharedString::from(err.to_string()))
.collect();
Self::show_errors(workspace, messages, cx)
})
}
})
.detach();
}
}
pub fn record(&mut self, operation: ProjectPanelOperation) {
if self.stack.len() >= self.limit {
self.stack.pop_front();
}
self.stack.push_back(operation);
}
pub fn record_batch(&mut self, operations: impl IntoIterator<Item = ProjectPanelOperation>) {
let mut operations = operations.into_iter().collect::<Vec<_>>();
let operation = match operations.len() {
0 => return,
1 => operations.pop().unwrap(),
_ => ProjectPanelOperation::Batch(operations),
};
self.record(operation);
}
/// Attempts to revert the provided `operation`, returning a vector of errors
/// in case there was any failure while reverting the operation.
///
/// For all operations other than [`crate::undo::ProjectPanelOperation::Batch`], a maximum
/// of one error is returned.
fn revert_operation(
&self,
operation: ProjectPanelOperation,
cx: &mut App,
) -> Task<Vec<anyhow::Error>> {
match operation {
ProjectPanelOperation::Create { project_path } => {
let Some(workspace) = self.workspace.upgrade() else {
return Task::ready(vec![anyhow!("Failed to obtain workspace.")]);
};
let result = workspace.update(cx, |workspace, cx| {
workspace.project().update(cx, |project, cx| {
let entry_id = project
.entry_for_path(&project_path, cx)
.map(|entry| entry.id)
.ok_or_else(|| anyhow!("No entry for path."))?;
project
.delete_entry(entry_id, true, cx)
.ok_or_else(|| anyhow!("Failed to trash entry."))
})
});
let task = match result {
Ok(task) => task,
Err(err) => return Task::ready(vec![err]),
};
cx.spawn(async move |_| match task.await {
Ok(_) => vec![],
Err(err) => vec![err],
})
}
ProjectPanelOperation::Rename { old_path, new_path } => {
let Some(workspace) = self.workspace.upgrade() else {
return Task::ready(vec![anyhow!("Failed to obtain workspace.")]);
};
let result = workspace.update(cx, |workspace, cx| {
workspace.project().update(cx, |project, cx| {
let entry_id = project
.entry_for_path(&new_path, cx)
.map(|entry| entry.id)
.ok_or_else(|| anyhow!("No entry for path."))?;
Ok(project.rename_entry(entry_id, old_path.clone(), cx))
})
});
let task = match result {
Ok(task) => task,
Err(err) => return Task::ready(vec![err]),
};
cx.spawn(async move |_| match task.await {
Ok(_) => vec![],
Err(err) => vec![err],
})
}
ProjectPanelOperation::Batch(operations) => {
// When reverting operations in a batch, we reverse the order of
// operations to handle dependencies between them. For example,
// if a batch contains the following order of operations:
//
// 1. Create `src/`
// 2. Create `src/main.rs`
//
// If we first try to revert the directory creation, it would
// fail because there's still files inside the directory.
// Operations are also reverted sequentially in order to avoid
// this same problem.
let tasks: Vec<_> = operations
.into_iter()
.rev()
.map(|operation| self.revert_operation(operation, cx))
.collect();
cx.spawn(async move |_| {
let mut errors = Vec::new();
for task in tasks {
errors.extend(task.await);
}
errors
})
}
}
}
/// Displays a notification with the list of provided errors ensuring that,
/// when more than one error is provided, which can be the case when dealing
/// with undoing a [`crate::undo::ProjectPanelOperation::Batch`], a list is
/// displayed with each of the errors, instead of a single message.
fn show_errors(workspace: WeakEntity<Workspace>, messages: Vec<SharedString>, cx: &mut App) {
workspace
.update(cx, move |workspace, cx| {
let notification_id =
NotificationId::Named(SharedString::new_static("project_panel_undo"));
workspace.show_notification(notification_id, cx, move |cx| {
cx.new(|cx| {
if let [err] = messages.as_slice() {
MessageNotification::new(err.to_string(), cx)
.with_title("Failed to undo Project Panel Operation")
} else {
MessageNotification::new_from_builder(cx, move |_, _| {
v_flex()
.gap_1()
.children(
messages
.iter()
.map(|message| Label::new(format!("- {message}"))),
)
.into_any_element()
})
.with_title("Failed to undo Project Panel Operations")
}
})
})
})
.ok();
}
}
#[cfg(test)]
mod test {
use crate::{
ProjectPanel, project_panel_tests,
undo::{ProjectPanelOperation, UndoManager},
};
use gpui::{Entity, TestAppContext, VisualTestContext};
use project::{FakeFs, Project, ProjectPath};
use std::sync::Arc;
use util::rel_path::rel_path;
use workspace::MultiWorkspace;
struct TestContext {
project: Entity<Project>,
panel: Entity<ProjectPanel>,
}
async fn init_test(cx: &mut TestAppContext) -> TestContext {
project_panel_tests::init_test(cx);
let fs = FakeFs::new(cx.executor());
let project = Project::test(fs.clone(), ["/root".as_ref()], cx).await;
let window =
cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
let workspace = window
.read_with(cx, |mw, _| mw.workspace().clone())
.unwrap();
let cx = &mut VisualTestContext::from_window(window.into(), cx);
let panel = workspace.update_in(cx, ProjectPanel::new);
cx.run_until_parked();
TestContext { project, panel }
}
#[gpui::test]
async fn test_limit(cx: &mut TestAppContext) {
let test_context = init_test(cx).await;
let worktree_id = test_context.project.update(cx, |project, cx| {
project.visible_worktrees(cx).next().unwrap().read(cx).id()
});
let build_create_operation = |file_name: &str| ProjectPanelOperation::Create {
project_path: ProjectPath {
path: Arc::from(rel_path(file_name)),
worktree_id,
},
};
// Since we're updating the `ProjectPanel`'s undo manager with one whose
// limit is 3 operations, we only need to create 4 operations which
// we'll record, in order to confirm that the oldest operation is
// evicted.
let operation_a = build_create_operation("file_a.txt");
let operation_b = build_create_operation("file_b.txt");
let operation_c = build_create_operation("file_c.txt");
let operation_d = build_create_operation("file_d.txt");
test_context.panel.update(cx, move |panel, _cx| {
panel.undo_manager = UndoManager::new_with_limit(panel.workspace.clone(), 3);
panel.undo_manager.record(operation_a);
panel.undo_manager.record(operation_b);
panel.undo_manager.record(operation_c);
panel.undo_manager.record(operation_d);
assert_eq!(panel.undo_manager.stack.len(), 3);
});
}
}