aboutsummaryrefslogtreecommitdiff
path: root/src/persist/restore.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/persist/restore.rs')
-rw-r--r--src/persist/restore.rs353
1 files changed, 353 insertions, 0 deletions
diff --git a/src/persist/restore.rs b/src/persist/restore.rs
new file mode 100644
index 00000000..eeef0af1
--- /dev/null
+++ b/src/persist/restore.rs
@@ -0,0 +1,353 @@
+use std::collections::{HashMap, HashSet};
+use std::path::PathBuf;
+use std::sync::atomic::AtomicBool;
+use std::sync::Arc;
+
+use ratatui::layout::Direction;
+use tokio::sync::{mpsc, Notify};
+use tracing::{error, warn};
+
+use crate::events::AppEvent;
+use crate::layout::{Node, PaneId, TileLayout};
+use crate::pane::{PaneRuntime, PaneState};
+use crate::workspace::Workspace;
+
+use super::{DirectionSnapshot, LayoutSnapshot, SessionSnapshot, TabSnapshot, WorkspaceSnapshot};
+
+/// Restore workspaces from a snapshot. Each pane gets a fresh shell in its saved cwd.
+pub fn restore(
+ snapshot: &SessionSnapshot,
+ rows: u16,
+ cols: u16,
+ scrollback_limit_bytes: usize,
+ events: mpsc::Sender<AppEvent>,
+ render_notify: Arc<Notify>,
+ render_dirty: Arc<AtomicBool>,
+) -> Vec<Workspace> {
+ snapshot
+ .workspaces
+ .iter()
+ .filter_map(|ws_snap| {
+ restore_workspace(
+ ws_snap,
+ rows,
+ cols,
+ scrollback_limit_bytes,
+ events.clone(),
+ render_notify.clone(),
+ render_dirty.clone(),
+ )
+ })
+ .collect()
+}
+
+fn restore_workspace(
+ snap: &WorkspaceSnapshot,
+ rows: u16,
+ cols: u16,
+ scrollback_limit_bytes: usize,
+ events: mpsc::Sender<AppEvent>,
+ render_notify: Arc<Notify>,
+ render_dirty: Arc<AtomicBool>,
+) -> Option<Workspace> {
+ let mut tabs = Vec::new();
+ let mut public_pane_numbers = HashMap::new();
+ let mut next_public_pane_number = 1;
+
+ for (idx, tab_snap) in snap.tabs.iter().enumerate() {
+ let tab = restore_tab(
+ tab_snap,
+ idx + 1,
+ rows,
+ cols,
+ scrollback_limit_bytes,
+ events.clone(),
+ render_notify.clone(),
+ render_dirty.clone(),
+ )?;
+ for pane_id in tab.layout.pane_ids() {
+ public_pane_numbers.insert(pane_id, next_public_pane_number);
+ next_public_pane_number += 1;
+ }
+ tabs.push(tab);
+ }
+
+ if tabs.is_empty() {
+ return None;
+ }
+
+ Some(Workspace {
+ id: snap
+ .id
+ .clone()
+ .unwrap_or_else(crate::workspace::generate_workspace_id),
+ custom_name: snap.custom_name.clone(),
+ identity_cwd: snap.identity_cwd.clone(),
+ cached_git_ahead_behind: None,
+ public_pane_numbers,
+ next_public_pane_number,
+ active_tab: snap.active_tab.min(tabs.len().saturating_sub(1)),
+ tabs,
+ })
+}
+
+fn restore_tab(
+ snap: &TabSnapshot,
+ number: usize,
+ rows: u16,
+ cols: u16,
+ scrollback_limit_bytes: usize,
+ events: mpsc::Sender<AppEvent>,
+ render_notify: Arc<Notify>,
+ render_dirty: Arc<AtomicBool>,
+) -> Option<crate::workspace::Tab> {
+ let (node, id_map) = restore_node_remapped(&snap.layout);
+ let reverse_id_map: HashMap<PaneId, u32> = id_map
+ .iter()
+ .map(|(&old_id, &new_id)| (new_id, old_id))
+ .collect();
+ let pane_ids = collect_pane_ids(&node);
+
+ let mut panes = HashMap::new();
+ let mut pane_cwds = HashMap::new();
+ let mut runtimes = HashMap::new();
+ for id in &pane_ids {
+ let saved_cwd = reverse_id_map
+ .get(id)
+ .and_then(|old_id| snap.panes.get(old_id))
+ .map(|p| p.cwd.clone())
+ .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| "/".into()));
+
+ let cwd = if saved_cwd.exists() {
+ saved_cwd
+ } else {
+ warn!(
+ cwd = %saved_cwd.display(),
+ "saved pane cwd does not exist, falling back to HOME"
+ );
+ let home = std::env::var("HOME")
+ .map(PathBuf::from)
+ .unwrap_or_else(|_| PathBuf::from("/"));
+ if home.exists() {
+ home
+ } else {
+ PathBuf::from("/")
+ }
+ };
+
+ match PaneRuntime::spawn(
+ *id,
+ rows,
+ cols,
+ cwd.clone(),
+ scrollback_limit_bytes,
+ crate::terminal_theme::TerminalTheme::default(),
+ events.clone(),
+ render_notify.clone(),
+ render_dirty.clone(),
+ ) {
+ Ok(runtime) => {
+ panes.insert(*id, PaneState::new());
+ pane_cwds.insert(*id, cwd.clone());
+ runtimes.insert(*id, runtime);
+ }
+ Err(e) => {
+ error!(
+ tab = ?snap.custom_name,
+ pane_id = id.raw(),
+ err = %e,
+ "failed to restore pane, skipping"
+ );
+ }
+ }
+ }
+
+ if panes.is_empty() {
+ warn!(
+ tab = ?snap.custom_name,
+ "no panes could be restored for tab, dropping it"
+ );
+ return None;
+ }
+
+ let surviving: HashSet<PaneId> = panes.keys().copied().collect();
+ let Some(node) = prune_restored_node(node, &surviving) else {
+ warn!(
+ tab = ?snap.custom_name,
+ "restored tab lost all panes after pruning missing layout nodes"
+ );
+ return None;
+ };
+ let pane_ids = collect_pane_ids(&node);
+ let focus = resolve_restored_pane(snap.focused, &id_map, &surviving, &pane_ids)?;
+ let root_pane = resolve_restored_pane(snap.root_pane, &id_map, &surviving, &pane_ids)?;
+ let layout = TileLayout::from_saved(node, focus);
+
+ Some(crate::workspace::Tab {
+ custom_name: snap.custom_name.clone(),
+ number,
+ root_pane,
+ layout,
+ panes,
+ pane_cwds,
+ runtimes,
+ zoomed: snap.zoomed,
+ events,
+ render_notify,
+ render_dirty,
+ })
+}
+
+pub(super) fn prune_restored_node(node: Node, surviving: &HashSet<PaneId>) -> Option<Node> {
+ match node {
+ Node::Pane(id) => surviving.contains(&id).then_some(Node::Pane(id)),
+ Node::Split {
+ direction,
+ ratio,
+ first,
+ second,
+ } => {
+ let first = prune_restored_node(*first, surviving);
+ let second = prune_restored_node(*second, surviving);
+ match (first, second) {
+ (Some(first), Some(second)) => Some(Node::Split {
+ direction,
+ ratio,
+ first: Box::new(first),
+ second: Box::new(second),
+ }),
+ (Some(remaining), None) | (None, Some(remaining)) => Some(remaining),
+ (None, None) => None,
+ }
+ }
+ }
+}
+
+pub(super) fn resolve_restored_pane(
+ saved_old_id: Option<u32>,
+ id_map: &HashMap<u32, PaneId>,
+ surviving: &HashSet<PaneId>,
+ pane_ids: &[PaneId],
+) -> Option<PaneId> {
+ saved_old_id
+ .and_then(|old_id| id_map.get(&old_id).copied())
+ .filter(|pane_id| surviving.contains(pane_id))
+ .or_else(|| pane_ids.first().copied())
+}
+
+/// Restore a layout tree, remapping every pane ID to a fresh globally unique one.
+/// Returns the new tree and a map of old_raw_id → new PaneId.
+pub(super) fn restore_node_remapped(snap: &LayoutSnapshot) -> (Node, HashMap<u32, PaneId>) {
+ let mut id_map = HashMap::new();
+ let node = remap_inner(snap, &mut id_map);
+ (node, id_map)
+}
+
+fn remap_inner(snap: &LayoutSnapshot, id_map: &mut HashMap<u32, PaneId>) -> Node {
+ match snap {
+ LayoutSnapshot::Pane(old_id) => {
+ let new_id = PaneId::alloc();
+ id_map.insert(*old_id, new_id);
+ Node::Pane(new_id)
+ }
+ LayoutSnapshot::Split {
+ direction,
+ ratio,
+ first,
+ second,
+ } => {
+ let first_node = remap_inner(first, id_map);
+ let second_node = remap_inner(second, id_map);
+ let dir = match direction {
+ DirectionSnapshot::Horizontal => Direction::Horizontal,
+ DirectionSnapshot::Vertical => Direction::Vertical,
+ };
+ Node::Split {
+ direction: dir,
+ ratio: *ratio,
+ first: Box::new(first_node),
+ second: Box::new(second_node),
+ }
+ }
+ }
+}
+
+pub(super) fn collect_pane_ids(node: &Node) -> Vec<PaneId> {
+ let mut ids = Vec::new();
+ collect_ids_inner(node, &mut ids);
+ ids
+}
+
+fn collect_ids_inner(node: &Node, ids: &mut Vec<PaneId>) {
+ match node {
+ Node::Pane(id) => ids.push(*id),
+ Node::Split { first, second, .. } => {
+ collect_ids_inner(first, ids);
+ collect_ids_inner(second, ids);
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn capture_and_restore_node_round_trip() {
+ let node = Node::Split {
+ direction: Direction::Horizontal,
+ ratio: 0.5,
+ first: Box::new(Node::Pane(PaneId::from_raw(0))),
+ second: Box::new(Node::Split {
+ direction: Direction::Vertical,
+ ratio: 0.3,
+ first: Box::new(Node::Pane(PaneId::from_raw(1))),
+ second: Box::new(Node::Pane(PaneId::from_raw(2))),
+ }),
+ };
+
+ let snap = super::super::snapshot::capture_node(&node);
+ let (restored, id_map) = restore_node_remapped(&snap);
+
+ assert_eq!(id_map.len(), 3);
+ let ids = collect_pane_ids(&restored);
+ assert_eq!(ids.len(), 3);
+ let unique: std::collections::HashSet<u32> = ids.iter().map(|id| id.raw()).collect();
+ assert_eq!(unique.len(), 3);
+ }
+
+ #[test]
+ fn prune_restored_node_collapses_missing_branch() {
+ let keep = PaneId::from_raw(11);
+ let missing = PaneId::from_raw(12);
+ let node = Node::Split {
+ direction: Direction::Horizontal,
+ ratio: 0.5,
+ first: Box::new(Node::Pane(keep)),
+ second: Box::new(Node::Pane(missing)),
+ };
+ let surviving = std::collections::HashSet::from([keep]);
+
+ let pruned = prune_restored_node(node, &surviving).expect("remaining pane should survive");
+
+ assert!(matches!(pruned, Node::Pane(id) if id == keep));
+ }
+
+ #[test]
+ fn resolve_restored_pane_prefers_surviving_saved_id_and_falls_back_to_first_remaining() {
+ let first = PaneId::from_raw(21);
+ let second = PaneId::from_raw(22);
+ let id_map = HashMap::from([(0_u32, first), (1_u32, second)]);
+ let surviving = std::collections::HashSet::from([first]);
+ let pane_ids = vec![first];
+
+ assert_eq!(
+ resolve_restored_pane(Some(0), &id_map, &surviving, &pane_ids),
+ Some(first)
+ );
+ assert_eq!(
+ resolve_restored_pane(Some(1), &id_map, &surviving, &pane_ids),
+ Some(first)
+ );
+ }
+}