`55a7075`

feat: implement workspace state persistence

- Add serializable state structs (WorkspaceState, TabState, PaneState, etc.)
- Implement Workspace::save() to persist open tabs, cursor positions,
viewport scroll, and pane bounds to .fackr/workspace.json
- Implement Workspace::load() to restore workspace state on startup,
handling missing files gracefully
- Add Cursors::from_cursor() constructor for state restoration
- Call workspace.save() on editor exit
- Replace empty default tab when opening explicit file to avoid
spurious [new] tab appearing as tab 1

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 4 months ago

SHA: 55a707540de6c85d7e0da16285972fbfa6cd5af8
Parents: 2e01399
Tree: c7bece2

3 changed files

Status	File	+	-
M	`src/editor/cursor.rs`	8	0
M	`src/editor/state.rs`	5	0
M	`src/workspace/state.rs`	256	10

src/editor/cursor.rsmodified

+         }
+     }
 +    /// Create a Cursors container from a single cursor
 +    pub fn from_cursor(cursor: Cursor) -> Self {
 +        Self {
 +            cursors: vec![cursor],
 +            primary: 0,
 +        }
 +    }
++
      /// Get the primary cursor
      pub fn primary(&self) -> &Cursor {
          &self.cursors[self.primary]

src/editor/state.rsmodified


             }
         }
 
+        // Save workspace state before exiting
+        if let Err(e) = self.workspace.save() {
+            eprintln!("Warning: Failed to save workspace state: {}", e);
+        }
+
         self.screen.leave_raw_mode()?;
         Ok(())
     }

src/workspace/state.rsmodified

  #![allow(dead_code)]
  use anyhow::Result;
 +use serde::{Deserialize, Serialize};
  use std::path::{Path, PathBuf};
  use crate::buffer::Buffer;
 -use crate::editor::{Cursors, History};
 +use crate::editor::{Cursor, Cursors, History};
  use crate::fuss::FussMode;
  use crate::lsp::LspClient;
  use crate::syntax::Highlighter;
 +// ============================================================================
 +// Serializable state structures for workspace persistence
 +// ============================================================================
++
 +/// Serializable workspace state for persistence
 +#[derive(Debug, Serialize, Deserialize)]
 +struct WorkspaceState {
 +    active_tab: usize,
 +    tabs: Vec<TabState>,
 +}
++
 +/// Serializable tab state
 +#[derive(Debug, Serialize, Deserialize)]
 +struct TabState {
 +    /// Files open in this tab (by path)
 +    files: Vec<FileState>,
 +    /// Active pane index
 +    active_pane: usize,
 +    /// Pane configurations
 +    panes: Vec<PaneState>,
 +}
++
 +/// Serializable file reference
 +#[derive(Debug, Serialize, Deserialize)]
 +struct FileState {
 +    /// Path to file (None for unsaved)
 +    path: Option<PathBuf>,
 +    /// Whether file is outside workspace
 +    is_orphan: bool,
 +}
++
 +/// Serializable pane state
 +#[derive(Debug, Serialize, Deserialize)]
 +struct PaneState {
 +    /// Index into tab's files
 +    buffer_idx: usize,
 +    /// Primary cursor position
 +    cursor_line: usize,
 +    cursor_col: usize,
 +    /// Viewport scroll position
 +    viewport_line: usize,
 +    viewport_col: usize,
 +    /// Pane bounds (normalized 0.0-1.0)
 +    bounds: BoundsState,
 +}
++
 +/// Serializable pane bounds
 +#[derive(Debug, Serialize, Deserialize)]
 +struct BoundsState {
 +    x_start: f32,
 +    y_start: f32,
 +    x_end: f32,
 +    y_end: f32,
 +}
++
  /// Normalized pane bounds (0.0 to 1.0)
  /// Converted to screen coordinates at render time
  #[derive(Debug, Clone)]
              return Ok(());
+         }
 -        // TODO: Implement JSON deserialization
 -        // For now, just return Ok - we'll add full persistence later
 +        // Read and parse JSON
 +        let json = std::fs::read_to_string(&state_path)?;
 +        let state: WorkspaceState = match serde_json::from_str(&json) {
 +            Ok(s) => s,
 +            Err(e) => {
 +                // If JSON is corrupted, log and continue with empty workspace
 +                eprintln!("Warning: Failed to parse workspace.json: {}", e);
 +                return Ok(());
 +            }
 +        };
++
 +        // Restore tabs from state
 +        let mut restored_tabs = Vec::new();
 +        for tab_state in state.tabs {
 +            // Try to open each file in the tab
 +            let mut buffers = Vec::new();
 +            let mut valid_buffer_map: Vec<Option<usize>> = Vec::new(); // Maps old index to new index
++
 +            for file_state in &tab_state.files {
 +                if let Some(ref path) = file_state.path {
 +                    // Resolve path (relative or absolute based on orphan status)
 +                    let full_path = if file_state.is_orphan {
 +                        path.clone()
 +                    } else {
 +                        self.root.join(path)
 +                    };
++
 +                    // Only restore if file still exists
 +                    if full_path.exists() {
 +                        match BufferEntry::from_file(&full_path, &self.root) {
 +                            Ok(entry) => {
 +                                valid_buffer_map.push(Some(buffers.len()));
 +                                buffers.push(entry);
 +                            }
 +                            Err(_) => {
 +                                valid_buffer_map.push(None);
 +                            }
 +                        }
 +                    } else {
 +                        valid_buffer_map.push(None);
 +                    }
 +                } else {
 +                    // Unsaved file - skip it (can't restore without content)
 +                    valid_buffer_map.push(None);
 +                }
 +            }
++
 +            // Skip tab if no files could be restored
 +            if buffers.is_empty() {
 +                continue;
 +            }
++
 +            // Restore panes, mapping buffer indices
 +            let mut panes = Vec::new();
 +            for pane_state in &tab_state.panes {
 +                // Check if this pane's buffer was successfully loaded
 +                if let Some(Some(new_idx)) = valid_buffer_map.get(pane_state.buffer_idx) {
 +                    let mut pane = Pane::with_buffer_idx(*new_idx);
++
 +                    // Restore cursor position (clamped to buffer bounds)
 +                    let buffer = &buffers[*new_idx].buffer;
 +                    let line = pane_state.cursor_line.min(buffer.line_count().saturating_sub(1));
 +                    let col = if line < buffer.line_count() {
 +                        pane_state.cursor_col.min(buffer.line_len(line))
 +                    } else {
 +                        0
 +                    };
 +                    pane.cursors = Cursors::from_cursor(Cursor {
 +                        line,
 +                        col,
 +                        desired_col: col,
 +                        anchor_line: line,
 +                        anchor_col: col,
 +                        selecting: false,
 +                    });
++
 +                    // Restore viewport
 +                    pane.viewport_line = pane_state.viewport_line.min(buffer.line_count().saturating_sub(1));
 +                    pane.viewport_col = pane_state.viewport_col;
++
 +                    // Restore bounds
 +                    pane.bounds = PaneBounds {
 +                        x_start: pane_state.bounds.x_start,
 +                        y_start: pane_state.bounds.y_start,
 +                        x_end: pane_state.bounds.x_end,
 +                        y_end: pane_state.bounds.y_end,
 +                    };
++
 +                    panes.push(pane);
 +                }
 +            }
++
 +            // Ensure at least one pane exists
 +            if panes.is_empty() {
 +                panes.push(Pane::default());
 +            }
++
 +            // Clamp active_pane to valid range
 +            let active_pane = tab_state.active_pane.min(panes.len().saturating_sub(1));
++
 +            restored_tabs.push(Tab {
 +                buffers,
 +                panes,
 +                active_pane,
 +            });
 +        }
++
 +        // Only replace tabs if we successfully restored at least one
 +        if !restored_tabs.is_empty() {
 +            self.tabs = restored_tabs;
 +            self.active_tab = state.active_tab.min(self.tabs.len().saturating_sub(1));
 +        }
++
          Ok(())
+     }
      pub fn save(&self) -> Result<()> {
          self.init()?; // Ensure .fackr/ exists
 -        let _state_path = self.root.join(".fackr").join("workspace.json");
 +        let state_path = self.root.join(".fackr").join("workspace.json");
++
 +        // Build serializable state
 +        let mut tabs = Vec::new();
 +        for tab in &self.tabs {
 +            // Collect file states
 +            let files: Vec<FileState> = tab.buffers.iter().map(|b| {
 +                FileState {
 +                    path: b.path.clone(),
 +                    is_orphan: b.is_orphan,
 +                }
 +            }).collect();
++
 +            // Only save tabs that have at least one saved file
 +            if files.iter().all(|f| f.path.is_none()) {
 +                continue;
 +            }
++
 +            // Collect pane states
 +            let panes: Vec<PaneState> = tab.panes.iter().map(|p| {
 +                let cursor = p.cursors.primary();
 +                PaneState {
 +                    buffer_idx: p.buffer_idx,
 +                    cursor_line: cursor.line,
 +                    cursor_col: cursor.col,
 +                    viewport_line: p.viewport_line,
 +                    viewport_col: p.viewport_col,
 +                    bounds: BoundsState {
 +                        x_start: p.bounds.x_start,
 +                        y_start: p.bounds.y_start,
 +                        x_end: p.bounds.x_end,
 +                        y_end: p.bounds.y_end,
 +                    },
 +                }
 +            }).collect();
++
 +            tabs.push(TabState {
 +                files,
 +                active_pane: tab.active_pane,
 +                panes,
 +            });
 +        }
++
 +        // Don't save if there's nothing meaningful to save
 +        if tabs.is_empty() {
 +            // Remove old state file if it exists
 +            if state_path.exists() {
 +                let _ = std::fs::remove_file(&state_path);
 +            }
 +            return Ok(());
 +        }
++
 +        let state = WorkspaceState {
 +            active_tab: self.active_tab.min(tabs.len().saturating_sub(1)),
 +            tabs,
 +        };
++
 +        // Serialize and write
 +        let json = serde_json::to_string_pretty(&state)?;
 +        std::fs::write(&state_path, json)?;
 -        // TODO: Implement JSON serialization
 -        // For now, just return Ok - we'll add full persistence later
          Ok(())
+     }
          &mut self.tabs[self.active_tab]
+     }
 +    /// Check if a tab is an empty default tab (no path, not modified, empty content)
 +    fn is_empty_default_tab(tab: &mut Tab) -> bool {
 +        if tab.buffers.len() != 1 || tab.panes.len() != 1 {
 +            return false;
 +        }
 +        let buf = &mut tab.buffers[0];
 +        buf.path.is_none() && !buf.is_modified() && buf.buffer.len_chars() == 0
 +    }
++
      /// Open a file in a new tab
      pub fn open_file(&mut self, path: &Path) -> Result<()> {
          // Check if file is already open in any tab's primary buffer
              let _ = self.lsp.open_document(&path_str, &content);
+         }
 -        self.tabs.push(tab);
 -        self.active_tab = self.tabs.len() - 1;
 +        // If we have exactly one empty default tab, replace it instead of adding
 +        if self.tabs.len() == 1 && Self::is_empty_default_tab(&mut self.tabs[0]) {
 +            self.tabs[0] = tab;
 +            self.active_tab = 0;
 +        } else {
 +            self.tabs.push(tab);
 +            self.active_tab = self.tabs.len() - 1;
 +        }
          Ok(())
+     }
      /// Open a new file (doesn't exist yet) in a new tab
      pub fn open_new_file(&mut self, path: &Path) -> Result<()> {
          let tab = Tab::new_file(path, &self.root);
 -        self.tabs.push(tab);
 -        self.active_tab = self.tabs.len() - 1;
++
 +        // If we have exactly one empty default tab, replace it instead of adding
 +        if self.tabs.len() == 1 && Self::is_empty_default_tab(&mut self.tabs[0]) {
 +            self.tabs[0] = tab;
 +            self.active_tab = 0;
 +        } else {
 +            self.tabs.push(tab);
 +            self.active_tab = self.tabs.len() - 1;
 +        }
          Ok(())
+     }

`@@ -832,6 +832,11 @@` impl Editor {
832	832	}
833	833	}
834	834
	835	+ // Save workspace state before exiting
	836	+ if let Err(e) = self.workspace.save() {
	837	+ eprintln!("Warning: Failed to save workspace state: {}", e);
	838	+ }
	839	+
835	840	self.screen.leave_raw_mode()?;
836	841	Ok(())
837	842	}