void_core/

stash.rs

//! Stash module - save and restore working tree changes
//!
//! Stash allows saving the current working tree state (both staged and unstaged changes)
//! to a special commit, then restoring it later. The stash stack is stored as:
//! - `.void/stash/meta.bin` - Encrypted metadata (messages, timestamps, etc.)
//! - `.void/refs/stash/<index>` - Commit CIDs for each stash entry

use std::fs;
use std::path::Path;
use std::time::{SystemTime, UNIX_EPOCH};

use serde::{Deserialize, Serialize};

use void_crypto::{CommitCid, EncryptedStash};

use crate::crypto;
use crate::{cid, Result};

const STASH_DIR: &str = "stash";
const STASH_META_FILE: &str = "meta.bin";
const REFS_STASH_DIR: &str = "refs/stash";

/// A single stash entry
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct StashEntry {
    /// Index in the stash stack (0 = most recent)
    pub index: u32,
    /// CID of the stash commit
    pub commit_cid: CommitCid,
    /// CID of HEAD when stash was created
    pub original_head: CommitCid,
    /// Optional message describing the stash
    pub message: Option<String>,
    /// Unix timestamp when stash was created
    pub timestamp: u64,
}

/// The stash stack containing all stash entries
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct StashStack {
    /// Schema version for forward compatibility
    pub version: u32,
    /// Stash entries, ordered by index (0 = most recent)
    pub entries: Vec<StashEntry>,
}

impl StashStack {
    pub const VERSION: u32 = 1;

    /// Create a new empty stash stack
    pub fn new() -> Self {
        Self {
            version: Self::VERSION,
            entries: Vec::new(),
        }
    }

    /// Get the number of stash entries
    pub fn len(&self) -> usize {
        self.entries.len()
    }

    /// Check if the stash stack is empty
    pub fn is_empty(&self) -> bool {
        self.entries.is_empty()
    }

    /// Get a stash entry by index
    pub fn get(&self, index: u32) -> Option<&StashEntry> {
        self.entries.iter().find(|e| e.index == index)
    }

    /// Push a new entry onto the stack
    ///
    /// This shifts all existing indices up by 1.
    pub fn push(&mut self, commit_cid: CommitCid, original_head: CommitCid, message: Option<String>) {
        // Shift all existing indices up
        for entry in &mut self.entries {
            entry.index += 1;
        }

        let timestamp = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .map(|d| d.as_secs())
            .unwrap_or(0);

        self.entries.insert(
            0,
            StashEntry {
                index: 0,
                commit_cid,
                original_head,
                message,
                timestamp,
            },
        );
    }

    /// Remove and return an entry by index
    ///
    /// Entries with higher indices are shifted down.
    pub fn remove(&mut self, index: u32) -> Option<StashEntry> {
        let pos = self.entries.iter().position(|e| e.index == index)?;
        let entry = self.entries.remove(pos);

        // Shift indices down for entries that were after the removed one
        for e in &mut self.entries {
            if e.index > index {
                e.index -= 1;
            }
        }

        Some(entry)
    }

    /// Drop an entry without returning it
    pub fn drop(&mut self, index: u32) -> bool {
        self.remove(index).is_some()
    }
}

impl Default for StashStack {
    fn default() -> Self {
        Self::new()
    }
}

// ============================================================================
// File I/O for stash stack
// ============================================================================

fn stash_meta_path(void_dir: impl AsRef<Path>) -> std::path::PathBuf {
    void_dir.as_ref().join(STASH_DIR).join(STASH_META_FILE)
}

fn stash_ref_path(void_dir: impl AsRef<Path>, index: u32) -> std::path::PathBuf {
    void_dir.as_ref().join(REFS_STASH_DIR).join(index.to_string())
}

/// Read the stash stack from disk
///
/// Returns an empty stack if the stash file doesn't exist.
pub fn read_stash_stack(void_dir: impl AsRef<Path>, key: &crypto::SecretKey) -> Result<StashStack> {
    let void_dir = void_dir.as_ref();
    let path = stash_meta_path(void_dir);
    if !path.exists() {
        return Ok(StashStack::new());
    }

    let raw = fs::read(&path)?;
    let blob = EncryptedStash::from_bytes(raw);
    Ok(blob.decrypt_and_parse(key.as_bytes())?)
}

/// Write the stash stack to disk
pub fn write_stash_stack(void_dir: impl AsRef<Path>, key: &crypto::SecretKey, stack: &StashStack) -> Result<()> {
    let void_dir = void_dir.as_ref();
    let stash_dir = void_dir.join(STASH_DIR);
    fs::create_dir_all(&stash_dir)?;

    let bytes = crate::support::cbor_to_vec(stack)?;
    let blob = EncryptedStash::encrypt(key.as_bytes(), &bytes)?;

    let path = stash_meta_path(void_dir);
    let temp_path = path.with_extension("tmp");
    fs::write(&temp_path, blob.as_bytes())?;
    fs::rename(&temp_path, &path)?;

    // Also write ref files for each entry
    let refs_dir = void_dir.join(REFS_STASH_DIR);
    fs::create_dir_all(&refs_dir)?;

    // Clean up old ref files
    if refs_dir.exists() {
        for entry in fs::read_dir(&refs_dir)? {
            let entry = entry?;
            fs::remove_file(entry.path())?;
        }
    }

    // Write current ref files
    for entry in &stack.entries {
        let ref_path = stash_ref_path(void_dir, entry.index);
        let cid_obj = cid::from_bytes(entry.commit_cid.as_bytes())?;
        fs::write(&ref_path, format!("{}\n", cid_obj))?;
    }

    Ok(())
}

/// Clear all stash entries
pub fn clear_stash(void_dir: impl AsRef<Path>, key: &crypto::SecretKey) -> Result<()> {
    write_stash_stack(void_dir, key, &StashStack::new())
}

#[cfg(test)]
mod tests {
    use super::*;
    use tempfile::TempDir;

    fn setup() -> (TempDir, std::path::PathBuf, crypto::SecretKey) {
        let temp = TempDir::new().unwrap();
        let void_dir = temp.path().join(".void");
        fs::create_dir_all(&void_dir).unwrap();
        let key = crypto::SecretKey::new(crypto::generate_key());
        (temp, void_dir, key)
    }

    fn make_cid(data: &[u8]) -> CommitCid {
        let cid_obj = cid::create(data);
        CommitCid::from_bytes(cid::to_bytes(&cid_obj))
    }

    #[test]
    fn test_stash_stack_new() {
        let stack = StashStack::new();
        assert!(stack.is_empty());
        assert_eq!(stack.len(), 0);
        assert_eq!(stack.version, StashStack::VERSION);
    }

    #[test]
    fn test_stash_stack_push() {
        let mut stack = StashStack::new();

        let cid1 = make_cid(b"commit1");
        let head1 = make_cid(b"head1");
        stack.push(cid1.clone(), head1.clone(), Some("first".to_string()));

        assert_eq!(stack.len(), 1);
        let entry = stack.get(0).unwrap();
        assert_eq!(entry.commit_cid, cid1);
        assert_eq!(entry.original_head, head1);
        assert_eq!(entry.message, Some("first".to_string()));

        // Push another
        let cid2 = make_cid(b"commit2");
        let head2 = make_cid(b"head2");
        stack.push(cid2.clone(), head2.clone(), None);

        assert_eq!(stack.len(), 2);

        // Index 0 should be the newest
        let newest = stack.get(0).unwrap();
        assert_eq!(newest.commit_cid, cid2);

        // Index 1 should be the oldest
        let oldest = stack.get(1).unwrap();
        assert_eq!(oldest.commit_cid, cid1);
    }

    #[test]
    fn test_stash_stack_remove() {
        let mut stack = StashStack::new();

        stack.push(make_cid(b"c1"), make_cid(b"h1"), Some("first".to_string()));
        stack.push(make_cid(b"c2"), make_cid(b"h2"), Some("second".to_string()));
        stack.push(make_cid(b"c3"), make_cid(b"h3"), Some("third".to_string()));

        // Remove middle entry (index 1)
        let removed = stack.remove(1).unwrap();
        assert_eq!(removed.message, Some("second".to_string()));

        assert_eq!(stack.len(), 2);

        // Index 0 should still be the newest
        assert_eq!(stack.get(0).unwrap().message, Some("third".to_string()));

        // What was index 2 should now be index 1
        assert_eq!(stack.get(1).unwrap().message, Some("first".to_string()));
    }

    #[test]
    fn test_stash_stack_drop() {
        let mut stack = StashStack::new();
        let cid1 = make_cid(b"c1");
        let cid2 = make_cid(b"c2");
        stack.push(cid1.clone(), make_cid(b"h1"), None);
        stack.push(cid2.clone(), make_cid(b"h2"), None);

        assert!(stack.drop(0));
        assert_eq!(stack.len(), 1);
        assert_eq!(stack.get(0).unwrap().commit_cid, cid1);

        assert!(!stack.drop(5)); // Non-existent
    }

    #[test]
    fn test_stash_roundtrip() {
        let (_temp, void_dir, key) = setup();

        let cid1 = make_cid(b"commit1");
        let cid2 = make_cid(b"commit2");

        let mut stack = StashStack::new();
        stack.push(
            cid1.clone(),
            make_cid(b"head1"),
            Some("test stash".to_string()),
        );
        stack.push(cid2.clone(), make_cid(b"head2"), None);

        write_stash_stack(&void_dir, &key, &stack).unwrap();
        let loaded = read_stash_stack(&void_dir, &key).unwrap();

        assert_eq!(loaded.len(), 2);
        assert_eq!(loaded.get(0).unwrap().commit_cid, cid2);
        assert_eq!(
            loaded.get(1).unwrap().message,
            Some("test stash".to_string())
        );
    }

    #[test]
    fn test_read_empty_stash() {
        let (_temp, void_dir, key) = setup();

        let stack = read_stash_stack(&void_dir, &key).unwrap();
        assert!(stack.is_empty());
    }

    #[test]
    fn test_clear_stash() {
        let (_temp, void_dir, key) = setup();

        let mut stack = StashStack::new();
        stack.push(make_cid(b"c1"), make_cid(b"h1"), None);
        write_stash_stack(&void_dir, &key, &stack).unwrap();

        clear_stash(&void_dir, &key).unwrap();

        let loaded = read_stash_stack(&void_dir, &key).unwrap();
        assert!(loaded.is_empty());
    }
}