void_core/diff/

working.rs

//! Working tree diff operations.
//!
//! Computes differences between commits/index and the working tree.

use std::collections::HashMap;
use std::fs;
use std::path::Path;

use rayon::prelude::*;

use super::collect::{collect_commit_files, load_commit_and_reader, FileEntry};
use super::rename::apply_rename_detection;
use super::types::{DiffKind, FileDiff, TreeDiff};
use crate::cid::VoidCid;
use crate::crypto::KeyVault;
use crate::index::WorkspaceIndex;
use crate::store::ObjectStoreExt;
use crate::support::configure_walker;
use crate::{ContentHash, Result, VoidError};

/// Walks a workspace directory and collects file entries with their hashes.
///
/// Uses rayon for parallel hashing.
fn collect_workspace_files(workspace: &Path) -> Result<Vec<FileEntry>> {
    // Use ignore crate to respect repo ignore rules (match staging behavior)
    let mut builder = ignore::WalkBuilder::new(workspace);
    let walker = configure_walker(&mut builder)
        .filter_entry(|entry| {
            let name = entry.file_name().to_string_lossy();
            name != ".void" && name != ".git" && name != "node_modules" && name != ".DS_Store"
        })
        .build();

    let paths: Vec<_> = walker
        .filter_map(|e| e.ok())
        .filter(|e| e.file_type().map(|ft| ft.is_file()).unwrap_or(false))
        .filter_map(|e| {
            let path = e.path();
            path.strip_prefix(workspace)
                .ok()
                .map(|rel| rel.to_path_buf())
        })
        .collect();

    // Parallel hash computation
    let entries: Result<Vec<FileEntry>> = paths
        .par_iter()
        .map(|rel_path| {
            let full_path = workspace.join(rel_path);
            let content = fs::read(&full_path)?;
            let hash = ContentHash::digest(&content);

            let path_str = rel_path.to_str().ok_or_else(|| {
                VoidError::Io(std::io::Error::new(
                    std::io::ErrorKind::InvalidData,
                    "path not valid UTF-8",
                ))
            })?;

            // Normalize path separators to forward slashes
            let normalized = path_str.replace('\\', "/");

            Ok(FileEntry {
                path: normalized,
                content_hash: hash,
            })
        })
        .collect();

    entries
}

/// Computes the diff between a commit and the working tree.
///
/// # Arguments
/// * `store` - Object store for fetching encrypted objects
/// * `vault` - Key vault for decryption
/// * `commit` - CID of the commit to compare against
/// * `workspace` - Path to the workspace directory
///
/// # Returns
/// A `TreeDiff` showing changes in the working tree relative to the commit.
pub fn diff_working<S: ObjectStoreExt>(
    store: &S,
    vault: &KeyVault,
    commit: &VoidCid,
    workspace: &Path,
) -> Result<TreeDiff> {
    // Load commit files via manifest
    let (commit_obj, reader) = load_commit_and_reader(store, vault, commit)?;
    let commit_files = collect_commit_files(store, &commit_obj, &reader)?;

    // Build map of commit files: path -> hash
    let commit_map: HashMap<&str, ContentHash> = commit_files
        .iter()
        .map(|e| (e.path.as_str(), e.content_hash))
        .collect();

    // Collect workspace files with parallel hashing
    let workspace_files = collect_workspace_files(workspace)?;

    // Build map of workspace files: path -> hash
    let workspace_map: HashMap<&str, ContentHash> = workspace_files
        .iter()
        .map(|e| (e.path.as_str(), e.content_hash))
        .collect();

    let mut diffs = Vec::new();

    // Find deleted and modified files
    for entry in &commit_files {
        match workspace_map.get(entry.path.as_str()) {
            None => {
                // Deleted from workspace
                diffs.push(FileDiff {
                    path: entry.path.clone(),
                    kind: DiffKind::Deleted,
                    old_hash: Some(entry.content_hash),
                    new_hash: None,
                });
            }
            Some(&ws_hash) => {
                if ws_hash != entry.content_hash {
                    // Modified in workspace
                    diffs.push(FileDiff {
                        path: entry.path.clone(),
                        kind: DiffKind::Modified,
                        old_hash: Some(entry.content_hash),
                        new_hash: Some(ws_hash),
                    });
                }
            }
        }
    }

    // Find added files
    for entry in &workspace_files {
        if !commit_map.contains_key(entry.path.as_str()) {
            diffs.push(FileDiff {
                path: entry.path.clone(),
                kind: DiffKind::Added,
                old_hash: None,
                new_hash: Some(entry.content_hash),
            });
        }
    }

    let files = apply_rename_detection(diffs);

    Ok(TreeDiff { files })
}

/// Computes the diff between the index and the working tree.
///
/// # Arguments
/// * `index` - The workspace index (staged files)
/// * `workspace` - Path to the workspace directory
///
/// # Returns
/// A `TreeDiff` showing unstaged changes (working tree vs index).
pub fn diff_index(index: &WorkspaceIndex, workspace: &Path) -> Result<TreeDiff> {
    // Build map of index entries: path -> hash
    let index_map: HashMap<&str, ContentHash> = index
        .iter()
        .map(|e| (e.path.as_str(), e.content_hash))
        .collect();

    // Collect workspace files with parallel hashing
    let workspace_files = collect_workspace_files(workspace)?;

    // Build map of workspace files: path -> hash
    let workspace_map: HashMap<&str, ContentHash> = workspace_files
        .iter()
        .map(|e| (e.path.as_str(), e.content_hash))
        .collect();

    let mut diffs = Vec::new();

    // Find deleted and modified files (relative to index)
    for entry in index.iter() {
        match workspace_map.get(entry.path.as_str()) {
            None => {
                // Deleted from workspace
                diffs.push(FileDiff {
                    path: entry.path.clone(),
                    kind: DiffKind::Deleted,
                    old_hash: Some(entry.content_hash),
                    new_hash: None,
                });
            }
            Some(&ws_hash) => {
                if ws_hash != entry.content_hash {
                    // Modified in workspace
                    diffs.push(FileDiff {
                        path: entry.path.clone(),
                        kind: DiffKind::Modified,
                        old_hash: Some(entry.content_hash),
                        new_hash: Some(ws_hash),
                    });
                }
            }
        }
    }

    // Find untracked files (in workspace but not in index)
    for entry in &workspace_files {
        if !index_map.contains_key(entry.path.as_str()) {
            diffs.push(FileDiff {
                path: entry.path.clone(),
                kind: DiffKind::Added,
                old_hash: None,
                new_hash: Some(entry.content_hash),
            });
        }
    }

    let files = apply_rename_detection(diffs);

    Ok(TreeDiff { files })
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::sync::Arc;
    use crate::cid::ToVoidCid;
    use crate::crypto::{self, KeyVault};
    use crate::index::IndexEntry;
    use crate::metadata::ShardMap;
    use crate::pipeline::{commit_workspace, CommitOptions, SealOptions};
    use crate::VoidContext;
    use camino::Utf8PathBuf;
    use tempfile::TempDir;

    fn setup_test_workspace() -> (
        TempDir,
        std::path::PathBuf,
        std::path::PathBuf,
        [u8; 32],
        [u8; 32],
    ) {
        let dir = TempDir::new().unwrap();
        let root = dir.path().to_path_buf();
        let void_dir = root.join(".void");
        fs::create_dir_all(void_dir.join("objects")).unwrap();

        let key = crypto::generate_key();
        let repo_secret = crypto::generate_key();

        (dir, root, void_dir, key, repo_secret)
    }

    fn make_test_entry(path: &str, hash_byte: u8) -> IndexEntry {
        IndexEntry {
            path: path.to_string(),
            content_hash: ContentHash([hash_byte; 32]),
            mtime_secs: 1700000000,
            mtime_nanos: 123456789,
            size: 100,
            materialized: true,
        }
    }

    #[test]
    fn diff_empty_index_with_workspace() {
        let temp = TempDir::new().unwrap();
        let workspace = temp.path();

        // Create some files in workspace
        fs::write(workspace.join("file1.txt"), "hello").unwrap();
        fs::write(workspace.join("file2.txt"), "world").unwrap();

        let index = WorkspaceIndex::empty();
        let diff = diff_index(&index, workspace).unwrap();

        // Both files should be Added
        assert_eq!(diff.len(), 2);
        assert!(diff.files.iter().all(|f| matches!(f.kind, DiffKind::Added)));

        let paths: Vec<_> = diff.files.iter().map(|f| f.path.as_str()).collect();
        assert!(paths.contains(&"file1.txt"));
        assert!(paths.contains(&"file2.txt"));
    }

    #[test]
    fn diff_index_with_modified_file() {
        let temp = TempDir::new().unwrap();
        let workspace = temp.path();

        // Create file
        fs::write(workspace.join("file.txt"), "original").unwrap();

        // Create index with different hash
        let mut index = WorkspaceIndex::empty();
        index.entries.push(make_test_entry("file.txt", 0xAA));

        let diff = diff_index(&index, workspace).unwrap();

        assert_eq!(diff.len(), 1);
        assert_eq!(diff.files[0].path, "file.txt");
        assert!(matches!(diff.files[0].kind, DiffKind::Modified));
    }

    #[test]
    fn diff_index_with_deleted_file() {
        let temp = TempDir::new().unwrap();
        let workspace = temp.path();

        // Create index with a file that doesn't exist in workspace
        let mut index = WorkspaceIndex::empty();
        index.entries.push(make_test_entry("deleted.txt", 0xBB));

        let diff = diff_index(&index, workspace).unwrap();

        assert_eq!(diff.len(), 1);
        assert_eq!(diff.files[0].path, "deleted.txt");
        assert!(matches!(diff.files[0].kind, DiffKind::Deleted));
    }

    #[test]
    fn diff_index_detects_rename() {
        let temp = TempDir::new().unwrap();
        let workspace = temp.path();

        let content = b"same content";
        fs::write(workspace.join("new.txt"), content).unwrap();
        let hash = ContentHash::digest(content);

        let mut index = WorkspaceIndex::empty();
        index.entries.push(IndexEntry {
            path: "old.txt".to_string(),
            content_hash: hash,
            mtime_secs: 1700000000,
            mtime_nanos: 0,
            size: content.len() as u64,
            materialized: true,
        });

        let diff = diff_index(&index, workspace).unwrap();

        assert_eq!(diff.len(), 1);
        assert_eq!(diff.files[0].path, "new.txt");
        match &diff.files[0].kind {
            DiffKind::Renamed { from, similarity } => {
                assert_eq!(from, "old.txt");
                assert_eq!(*similarity, 100);
            }
            other => panic!("expected renamed diff, got {other:?}"),
        }
    }

    #[test]
    fn diff_index_with_no_changes() {
        let temp = TempDir::new().unwrap();
        let workspace = temp.path();

        // Create file
        let content = b"hello world";
        fs::write(workspace.join("file.txt"), content).unwrap();

        // Create index with matching hash
        let hash = ContentHash::digest(content);
        let mut index = WorkspaceIndex::empty();
        index.entries.push(IndexEntry {
            path: "file.txt".to_string(),
            content_hash: hash,
            mtime_secs: 1700000000,
            mtime_nanos: 0,
            size: content.len() as u64,
            materialized: true,
        });

        let diff = diff_index(&index, workspace).unwrap();

        assert!(diff.is_empty());
    }

    #[test]
    fn diff_working_detects_changes() {
        let (_dir, root, void_dir, key, repo_secret) = setup_test_workspace();
        let vault = KeyVault::new(key).expect("key derivation should not fail");

        // Create initial files
        fs::write(root.join("file1.txt"), "original").unwrap();
        fs::write(root.join("file2.txt"), "unchanged").unwrap();

        // Commit
        let vault = Arc::new(KeyVault::new(key).unwrap());
        let mut ctx = VoidContext::headless(&void_dir, Arc::clone(&vault), 0).unwrap();
        ctx.paths.root = Utf8PathBuf::try_from(root.clone()).unwrap();
        ctx.repo.secret = void_crypto::RepoSecret::new(repo_secret);

        let seal_opts = SealOptions {
            ctx,
            shard_map: ShardMap::new(64),
            ..Default::default()
        };

        let result = commit_workspace(CommitOptions {
            seal: seal_opts,
            message: "initial".into(),
            parent_cid: None,
            allow_data_loss: false,
            foreign_parent: false,
        })
        .unwrap();

        // Modify workspace
        fs::write(root.join("file1.txt"), "modified").unwrap();
        fs::write(root.join("new.txt"), "new file").unwrap();

        // Diff working tree against commit
        let objects_dir = Utf8PathBuf::try_from(void_dir.join("objects")).unwrap();
        let store = crate::store::FsStore::new(objects_dir).unwrap();

        let commit_cid = result.commit_cid.to_void_cid().unwrap();
        let diff = diff_working(&store, &vault, &commit_cid, &root).unwrap();

        // Should have: 1 added (new.txt), 1 modified (file1.txt)
        let stats = diff.stats();
        assert_eq!(stats.added, 1);
        assert_eq!(stats.modified, 1);
        assert_eq!(stats.deleted, 0);
    }
}