kardo_core/scanner/

cache.rs

//! Content-hash caching for incremental scanning.
//!
//! Before processing a file, check if its SHA-256 hash matches the stored hash.
//! If unchanged, skip processing.

use sha2::{Digest, Sha256};
use std::collections::HashMap;
use std::time::Instant;

/// Result of an incremental scan.
#[derive(Debug, Clone)]
pub struct ScanResult {
    pub files_scanned: usize,
    pub files_skipped: usize,
    pub duration_ms: u64,
    pub score: Option<f64>,
}

/// Cache of content hashes for incremental processing.
pub struct ContentCache {
    hashes: HashMap<String, String>,
}

impl ContentCache {
    pub fn new() -> Self {
        Self {
            hashes: HashMap::new(),
        }
    }

    /// Load cache from a list of (path, hash) pairs (e.g., from DB).
    pub fn from_entries(entries: Vec<(String, String)>) -> Self {
        Self {
            hashes: entries.into_iter().collect(),
        }
    }

    /// Compute SHA-256 hash of file content.
    pub fn compute_hash(content: &[u8]) -> String {
        let mut hasher = Sha256::new();
        hasher.update(content);
        format!("{:x}", hasher.finalize())
    }

    /// Check if a file has changed since last scan.
    /// Returns true if the file is new or changed (needs processing).
    pub fn needs_processing(&self, relative_path: &str, content: &[u8]) -> bool {
        let new_hash = Self::compute_hash(content);
        match self.hashes.get(relative_path) {
            Some(stored) => stored != &new_hash,
            None => true, // New file
        }
    }

    /// Update the stored hash for a file.
    pub fn update(&mut self, relative_path: String, content: &[u8]) {
        let hash = Self::compute_hash(content);
        self.hashes.insert(relative_path, hash);
    }

    /// Get all current cache entries (for persisting to DB).
    pub fn entries(&self) -> Vec<(&str, &str)> {
        self.hashes
            .iter()
            .map(|(k, v)| (k.as_str(), v.as_str()))
            .collect()
    }

    /// Process a batch of files, skipping unchanged ones.
    ///
    /// `files`: (relative_path, content) pairs
    /// `processor`: function to call for each file that needs processing
    ///
    /// Returns ScanResult with counts and timing.
    pub fn process_batch<F>(
        &mut self,
        files: &[(String, Vec<u8>)],
        mut processor: F,
    ) -> ScanResult
    where
        F: FnMut(&str, &[u8]),
    {
        let start = Instant::now();
        let mut scanned = 0;
        let mut skipped = 0;

        for (path, content) in files {
            if self.needs_processing(path, content) {
                processor(path, content);
                self.update(path.clone(), content);
                scanned += 1;
            } else {
                skipped += 1;
            }
        }

        ScanResult {
            files_scanned: scanned,
            files_skipped: skipped,
            duration_ms: start.elapsed().as_millis() as u64,
            score: None,
        }
    }
}

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

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

    #[test]
    fn test_compute_hash() {
        let hash = ContentCache::compute_hash(b"hello world");
        assert!(!hash.is_empty());
        // SHA-256 of "hello world" is known
        assert_eq!(
            hash,
            "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"
        );
    }

    #[test]
    fn test_needs_processing_new_file() {
        let cache = ContentCache::new();
        assert!(cache.needs_processing("new.md", b"content"));
    }

    #[test]
    fn test_needs_processing_unchanged() {
        let mut cache = ContentCache::new();
        cache.update("file.md".to_string(), b"content");
        assert!(!cache.needs_processing("file.md", b"content"));
    }

    #[test]
    fn test_needs_processing_changed() {
        let mut cache = ContentCache::new();
        cache.update("file.md".to_string(), b"old content");
        assert!(cache.needs_processing("file.md", b"new content"));
    }

    #[test]
    fn test_process_batch_skips_unchanged() {
        let mut cache = ContentCache::new();
        cache.update("unchanged.md".to_string(), b"same");

        let files = vec![
            ("unchanged.md".to_string(), b"same".to_vec()),
            ("new.md".to_string(), b"new content".to_vec()),
        ];

        let mut processed = Vec::new();
        let result = cache.process_batch(&files, |path, _content| {
            processed.push(path.to_string());
        });

        assert_eq!(result.files_scanned, 1);
        assert_eq!(result.files_skipped, 1);
        assert_eq!(processed, vec!["new.md"]);
    }

    #[test]
    fn test_process_batch_all_new() {
        let mut cache = ContentCache::new();
        let files = vec![
            ("a.md".to_string(), b"aaa".to_vec()),
            ("b.md".to_string(), b"bbb".to_vec()),
        ];

        let result = cache.process_batch(&files, |_path, _content| {});
        assert_eq!(result.files_scanned, 2);
        assert_eq!(result.files_skipped, 0);
    }

    #[test]
    fn test_from_entries() {
        let hash = ContentCache::compute_hash(b"content");
        let cache = ContentCache::from_entries(vec![("file.md".to_string(), hash)]);
        assert!(!cache.needs_processing("file.md", b"content"));
    }

    #[test]
    fn test_entries_roundtrip() {
        let mut cache = ContentCache::new();
        cache.update("a.md".to_string(), b"aaa");
        cache.update("b.md".to_string(), b"bbb");

        let entries = cache.entries();
        assert_eq!(entries.len(), 2);
    }
}