void_core/repo/

mod.rs

//! Repository analysis utilities.
//!
//! This module provides tools for analyzing repository contents,
//! including parallel file statistics collection.

use std::fs::{self, File};
use std::io::Read;
use std::path::{Path, PathBuf};

use ignore::WalkBuilder;
use memmap2::Mmap;
use rayon::prelude::*;

use crate::support::{configure_walker, count_lines};
use crate::Result;

/// Options for collecting file statistics.
pub struct FileStatsOptions {
    /// Root directory to scan.
    pub root: PathBuf,
    /// Name of the void directory to skip (e.g., ".void").
    pub void_dir_name: String,
    /// Whether to include hidden files (dotfiles).
    pub include_hidden: bool,
    /// Files larger than this threshold are memory-mapped.
    /// Set to 0 to disable mmap (always read into Vec).
    pub mmap_threshold: u64,
}

impl Default for FileStatsOptions {
    fn default() -> Self {
        Self {
            root: PathBuf::from("."),
            void_dir_name: ".void".to_string(),
            include_hidden: false,
            mmap_threshold: 64 * 1024, // 64KB
        }
    }
}

/// Statistics for a single file.
#[derive(Clone)]
pub struct FileStatEntry {
    /// Relative path from root (normalized, forward slashes).
    pub path: String,
    /// Lowercase file extension, or "(no ext)" if none.
    pub extension: String,
    /// File size in bytes.
    pub size: u64,
    /// Number of lines in the file.
    pub lines: u32,
}

/// Internal job for passing file paths to workers.
struct PathJob {
    /// Absolute path on filesystem.
    abs_path: PathBuf,
    /// Relative path from root (normalized).
    rel_path: String,
}

/// Collect file statistics from a directory in parallel.
///
/// Walks the directory tree, skipping the void directory and optionally hidden files.
/// Uses rayon parallel iterators to read files and count lines in parallel.
pub fn collect_file_stats(opts: FileStatsOptions) -> Result<Vec<FileStatEntry>> {
    let root = &opts.root;
    let void_dir_name = opts.void_dir_name.clone();

    // Phase 1: Collect all file paths (walk is fast, single-threaded)
    let mut builder = WalkBuilder::new(root);
    let jobs: Vec<PathJob> = configure_walker(&mut builder)
        .hidden(!opts.include_hidden)
        .filter_entry(move |entry| {
            let name = entry.file_name().to_string_lossy();
            name != void_dir_name
                && name != "node_modules"
                && name != ".git"
                && name != ".DS_Store"
                && name != "target"
        })
        .build()
        .flatten()
        .filter(|entry| entry.file_type().is_some_and(|t| t.is_file()))
        .filter_map(|entry| {
            let abs_path = entry.path().to_path_buf();
            let rel_path = abs_path
                .strip_prefix(root)
                .ok()?
                .to_string_lossy()
                .replace('\\', "/");
            Some(PathJob { abs_path, rel_path })
        })
        .collect();

    // Phase 2: Process files in parallel (heavy I/O)
    let mmap_threshold = opts.mmap_threshold;
    let stats: Vec<FileStatEntry> = jobs
        .into_par_iter()
        .filter_map(|job| process_file(&job.abs_path, &job.rel_path, mmap_threshold))
        .collect();

    Ok(stats)
}

/// Process a single file and return its statistics.
fn process_file(abs_path: &Path, rel_path: &str, mmap_threshold: u64) -> Option<FileStatEntry> {
    let metadata = fs::metadata(abs_path).ok()?;
    let size = metadata.len();

    // Read file content
    let content = load_file_content(abs_path, size, mmap_threshold)?;

    // Count lines
    let lines = count_lines(content.as_ref());

    // Extract extension
    let extension = abs_path
        .extension()
        .and_then(|ext| ext.to_str())
        .map(|ext| ext.to_lowercase())
        .unwrap_or_else(|| "(no ext)".to_string());

    Some(FileStatEntry {
        path: rel_path.to_string(),
        extension,
        size,
        lines,
    })
}

/// File content storage (either mmap or in-memory).
enum FileContentRef {
    Mmap(Mmap),
    Bytes(Vec<u8>),
}

impl AsRef<[u8]> for FileContentRef {
    fn as_ref(&self) -> &[u8] {
        match self {
            FileContentRef::Mmap(mmap) => mmap.as_ref(),
            FileContentRef::Bytes(bytes) => bytes.as_slice(),
        }
    }
}

/// Load file content, using mmap for files above threshold.
fn load_file_content(path: &Path, size: u64, mmap_threshold: u64) -> Option<FileContentRef> {
    let use_mmap = mmap_threshold > 0 && size >= mmap_threshold;

    if use_mmap {
        if let Ok(file) = File::open(path) {
            if let Ok(mmap) = unsafe { Mmap::map(&file) } {
                return Some(FileContentRef::Mmap(mmap));
            }
        }
    }

    // Fall back to reading into memory
    let mut file = File::open(path).ok()?;
    let mut bytes = Vec::with_capacity(size as usize);
    file.read_to_end(&mut bytes).ok()?;
    Some(FileContentRef::Bytes(bytes))
}

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

    #[test]
    fn collect_basic() {
        let temp = TempDir::new().unwrap();
        fs::write(temp.path().join("file1.txt"), "hello\nworld").unwrap();
        fs::write(temp.path().join("file2.rs"), "fn main() {}").unwrap();
        fs::create_dir(temp.path().join("subdir")).unwrap();
        fs::write(temp.path().join("subdir/nested.txt"), "line1\nline2\nline3").unwrap();

        let opts = FileStatsOptions {
            root: temp.path().to_path_buf(),
            void_dir_name: ".void".to_string(),
            include_hidden: false,
            mmap_threshold: 0,
        };

        let stats = collect_file_stats(opts).unwrap();
        assert_eq!(stats.len(), 3);

        // Check that we got the expected files (order may vary due to parallelism)
        let paths: Vec<_> = stats.iter().map(|s| s.path.as_str()).collect();
        assert!(paths.contains(&"file1.txt"));
        assert!(paths.contains(&"file2.rs"));
        assert!(paths.contains(&"subdir/nested.txt"));
    }

    #[test]
    fn collect_skips_void_dir() {
        let temp = TempDir::new().unwrap();
        fs::write(temp.path().join("file.txt"), "hello").unwrap();
        fs::create_dir(temp.path().join(".void")).unwrap();
        fs::write(temp.path().join(".void/secret"), "should be skipped").unwrap();

        let opts = FileStatsOptions {
            root: temp.path().to_path_buf(),
            void_dir_name: ".void".to_string(),
            include_hidden: false,
            mmap_threshold: 0,
        };

        let stats = collect_file_stats(opts).unwrap();
        assert_eq!(stats.len(), 1);
        assert_eq!(stats[0].path, "file.txt");
    }

    #[test]
    fn collect_respects_hidden_option() {
        let temp = TempDir::new().unwrap();
        fs::write(temp.path().join("visible.txt"), "visible").unwrap();
        fs::write(temp.path().join(".hidden"), "hidden").unwrap();

        // Without hidden files
        let opts = FileStatsOptions {
            root: temp.path().to_path_buf(),
            void_dir_name: ".void".to_string(),
            include_hidden: false,
            mmap_threshold: 0,
        };
        let stats = collect_file_stats(opts).unwrap();
        assert_eq!(stats.len(), 1);
        assert_eq!(stats[0].path, "visible.txt");

        // With hidden files
        let opts = FileStatsOptions {
            root: temp.path().to_path_buf(),
            void_dir_name: ".void".to_string(),
            include_hidden: true,
            mmap_threshold: 0,
        };
        let stats = collect_file_stats(opts).unwrap();
        assert_eq!(stats.len(), 2);
    }

    #[test]
    fn extract_extension() {
        let temp = TempDir::new().unwrap();
        fs::write(temp.path().join("file.TXT"), "text").unwrap();
        fs::write(temp.path().join("noext"), "no extension").unwrap();

        let opts = FileStatsOptions {
            root: temp.path().to_path_buf(),
            void_dir_name: ".void".to_string(),
            include_hidden: false,
            mmap_threshold: 0,
        };

        let stats = collect_file_stats(opts).unwrap();

        let txt_file = stats.iter().find(|s| s.path == "file.TXT").unwrap();
        assert_eq!(txt_file.extension, "txt"); // lowercase

        let noext_file = stats.iter().find(|s| s.path == "noext").unwrap();
        assert_eq!(noext_file.extension, "(no ext)");
    }
}