ephemeris_files/

walk.rs

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

use git2::{ErrorCode, Repository as GitRepository};

use crate::FilesError;
use crate::error::IoResultExt as _;
use crate::path::{RepositoryPath, RepositoryRoot};
use crate::repository::Repository;

/// List the regular files Git tracks or would track below `root`.
///
/// Inside a Git repository the result matches
/// `git ls-files --cached --others --exclude-standard` without symbolic
/// links. Every Git ignore source applies to untracked files.
///
/// When no Git repository holds `root`, the result is every regular file
/// below it, without symbolic links and without `.git` entries. A source
/// tree without `.git` is already an export of Git's view.
///
/// # Errors
/// Returns an error when `root` lies inside a repository without being its
/// root, when Git cannot be read or when the filesystem cannot be listed.
pub fn walk(root: &RepositoryRoot) -> Result<BTreeSet<RepositoryPath>, FilesError> {
    match GitRepository::discover(root.as_path()) {
        Err(error) if error.code() == ErrorCode::NotFound => files_below(root),
        _ => Repository::open(root.as_path())?.visible_files(),
    }
}

pub(crate) fn files_below(root: &RepositoryRoot) -> Result<BTreeSet<RepositoryPath>, FilesError> {
    let mut files = BTreeSet::new();
    collect(root, root.as_path(), &mut files)?;
    Ok(files)
}

fn collect(
    root: &RepositoryRoot,
    directory: &Path,
    files: &mut BTreeSet<RepositoryPath>,
) -> Result<(), FilesError> {
    for item in fs::read_dir(directory).at_path(directory)? {
        let item = item.at_path(directory)?;
        if item.file_name() == ".git" {
            continue;
        }
        let path = item.path();
        let metadata = item.metadata().at_path(&path)?;
        if metadata.is_dir() {
            collect(root, &path, files)?;
        } else if metadata.is_file() {
            files.insert(root.relative(&path)?);
        }
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use std::fs;
    use std::os::unix::fs::{PermissionsExt as _, symlink};
    use std::os::unix::net::UnixListener;
    use std::path::Path;

    use git2::Repository as GitRepository;

    use super::walk;
    use crate::RepositoryRoot;

    fn repo() -> tempfile::TempDir {
        let dir = tempfile::tempdir().expect("tempdir");
        GitRepository::init(dir.path()).expect("init repository");
        dir
    }

    fn add(root: &Path, paths: &[&str]) {
        let repository = GitRepository::open(root).expect("open repository");
        let mut index = repository.index().expect("repository index");
        for path in paths {
            index.add_path(Path::new(path)).expect("stage path");
        }
        index.write().expect("write index");
    }

    fn write(root: &Path, path: &str, content: &str) {
        let full = root.join(path);
        fs::create_dir_all(full.parent().unwrap()).unwrap();
        fs::write(full, content).unwrap();
    }

    fn walked(root: &Path) -> Vec<String> {
        walk(&RepositoryRoot::new(root).unwrap())
            .unwrap()
            .iter()
            .map(ToString::to_string)
            .collect()
    }

    #[test]
    fn tracked_and_untracked_files_are_listed() {
        let dir = repo();
        write(dir.path(), "tracked.md", "");
        write(dir.path(), "docs/new.md", "");
        add(dir.path(), &["tracked.md"]);
        assert_eq!(walked(dir.path()), ["docs/new.md", "tracked.md"]);
    }

    #[test]
    fn a_gitignored_file_is_not_listed() {
        let dir = repo();
        write(dir.path(), ".gitignore", "*.log\n");
        write(dir.path(), "a.log", "");
        write(dir.path(), "a.md", "");
        assert_eq!(walked(dir.path()), [".gitignore", "a.md"]);
    }

    #[test]
    fn a_file_in_the_info_exclude_is_not_listed() {
        let dir = repo();
        write(dir.path(), ".git/info/exclude", "secret.md\n");
        write(dir.path(), "secret.md", "");
        write(dir.path(), "a.md", "");
        assert_eq!(walked(dir.path()), ["a.md"]);
    }

    #[test]
    fn a_file_in_the_global_excludes_is_not_listed() {
        let dir = repo();
        let global = tempfile::NamedTempFile::new().unwrap();
        fs::write(global.path(), "global.md\n").unwrap();
        GitRepository::open(dir.path())
            .unwrap()
            .config()
            .unwrap()
            .set_str("core.excludesFile", global.path().to_str().unwrap())
            .unwrap();
        write(dir.path(), "global.md", "");
        write(dir.path(), "a.md", "");
        assert_eq!(walked(dir.path()), ["a.md"]);
    }

    #[test]
    fn symbolic_links_are_not_listed() {
        let dir = repo();
        write(dir.path(), "a.md", "");
        symlink("a.md", dir.path().join("tracked-link")).unwrap();
        symlink("a.md", dir.path().join("untracked-link")).unwrap();
        add(dir.path(), &["tracked-link"]);
        assert_eq!(walked(dir.path()), ["a.md"]);
    }

    #[test]
    fn a_tracked_file_matched_by_a_gitignore_is_still_listed() {
        let dir = repo();
        write(dir.path(), ".gitignore", "*.log\n");
        write(dir.path(), "kept.log", "");
        add(dir.path(), &["kept.log"]);
        assert_eq!(walked(dir.path()), [".gitignore", "kept.log"]);
    }

    #[test]
    fn without_a_repository_every_regular_file_is_listed() {
        let dir = tempfile::tempdir().unwrap();
        write(dir.path(), "a.md", "");
        write(dir.path(), "docs/b.md", "");
        write(dir.path(), "docs/.git/config", "");
        write(dir.path(), "sub/.git", "gitdir: elsewhere");
        write(dir.path(), "sub/c.md", "");
        symlink("a.md", dir.path().join("link")).unwrap();
        assert_eq!(walked(dir.path()), ["a.md", "docs/b.md", "sub/c.md"]);
    }

    #[test]
    fn without_a_repository_sockets_are_not_listed() {
        let dir = tempfile::tempdir().unwrap();
        write(dir.path(), "a.md", "");
        let _socket = UnixListener::bind(dir.path().join("sock")).unwrap();
        assert_eq!(walked(dir.path()), ["a.md"]);
    }

    #[test]
    fn an_ignored_directory_is_not_entered() {
        let dir = repo();
        write(dir.path(), ".gitignore", "target/\n");
        write(dir.path(), "target/artifact", "");
        write(dir.path(), "a.md", "");
        let target = dir.path().join("target");
        fs::set_permissions(&target, fs::Permissions::from_mode(0o000)).unwrap();
        let result = walk(&RepositoryRoot::new(dir.path()).unwrap());
        fs::set_permissions(&target, fs::Permissions::from_mode(0o755)).unwrap();
        assert_eq!(
            result
                .unwrap()
                .iter()
                .map(ToString::to_string)
                .collect::<Vec<_>>(),
            [".gitignore", "a.md"]
        );
    }

    #[test]
    fn a_root_inside_a_repository_is_rejected() {
        let dir = repo();
        write(dir.path(), "docs/a.md", "");
        let root = RepositoryRoot::new(&dir.path().join("docs")).unwrap();
        assert!(walk(&root).is_err());
    }
}