dvs/

paths.rs

use std::ffi::OsStr;
use std::fmt;
use std::fmt::Formatter;
use std::path::{Component, Path, PathBuf};

use anyhow::Result;
use fs_err as fs;
use globset::GlobMatcher;
use serde::{Deserialize, Deserializer, Serialize};
use walkdir::WalkDir;

use crate::config::Config;

pub const CONFIG_FILE_NAME: &str = "dvs.toml";
pub const DEFAULT_FOLDER_NAME: &str = ".dvs";

/// Result of validating a file path for `add`.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum AddPathStatus {
    /// File exists and is inside the project
    Valid,
    /// File does not exist on disk
    NotFound,
    /// Path is a directory, not a file
    IsDirectory,
    /// Path resolves to outside the project root
    OutsideProject,
}

impl AddPathStatus {
    pub fn reason(&self) -> Option<&str> {
        match self {
            AddPathStatus::Valid => None,
            AddPathStatus::NotFound => Some("file not found"),
            AddPathStatus::OutsideProject => Some("path is outside project"),
            AddPathStatus::IsDirectory => Some("path is a directory"),
        }
    }
}

/// Result of validating a file path for `get`.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum GetPathStatus {
    /// Metadata exists: file is tracked
    Tracked,
    /// No metadata and no file on disk
    NotFound,
    /// File exists on disk but is not tracked by DVS
    NotTracked,
}

impl GetPathStatus {
    pub fn reason(&self) -> Option<&str> {
        match self {
            GetPathStatus::Tracked => None,
            GetPathStatus::NotFound => Some("file not found"),
            GetPathStatus::NotTracked => Some("not tracked by DVS"),
        }
    }
}

/// Finds the root of a project by walking up from the given directory
/// until a `dvs.toml` is found
///
/// Returns the `start_dir` if no `dvs.toml` has been found.
pub fn find_repo_root(start_dir: impl AsRef<Path>) -> PathBuf {
    let mut dir = start_dir.as_ref();
    log::debug!("Searching for repo root starting from {}", dir.display());

    loop {
        if dir.join(CONFIG_FILE_NAME).exists() {
            log::debug!("Found repo root at {}", dir.display());
            return dir.to_path_buf();
        }

        if let Some(parent) = dir.parent() {
            dir = parent;
        } else {
            break;
        }
    }

    start_dir.as_ref().to_path_buf()
}

/// Normalize a path by resolving `.` and `..` components lexically (no
/// canonicalization — the path may not exist and we want it relative to the
/// directory, with no symlink resolution). Returns `None` if `..` escapes the
/// base (pops past the root). Shared by `globbing` and `status` path filtering.
pub(crate) fn normalize_path(p: PathBuf) -> Option<PathBuf> {
    let mut out = PathBuf::new();
    for c in p.components() {
        match c {
            Component::CurDir => {}
            Component::ParentDir => {
                if !out.pop() {
                    return None;
                }
            }
            _ => out.push(c),
        }
    }
    Some(out)
}

/// We always need to figure out where the user is in a project,
/// where the root is etc.
/// This struct handles all of it so the rest of the code doesn't have to
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DvsPaths {
    /// Canonicalized path of where the user currently is
    cwd: PathBuf,
    /// Canonicalized path where our `dvs.toml` is
    repo_root: PathBuf,
    /// Folder name for metadata, defined in the config
    metadata_folder_name: String,
}

impl DvsPaths {
    /// Create with explicit paths (for testing or R package)
    pub fn new(
        cwd: PathBuf,
        repo_root: PathBuf,
        metadata_folder_name: impl Into<String>,
    ) -> Result<Self> {
        Ok(Self {
            cwd,
            repo_root: fs::canonicalize(&repo_root)?,
            metadata_folder_name: metadata_folder_name.into(),
        })
    }

    pub fn from_cwd(config: &Config) -> Result<Self> {
        let cwd = fs::canonicalize(std::env::current_dir()?)?;
        let repo_root = fs::canonicalize(find_repo_root(&cwd))?;

        log::debug!(
            "Resolved paths: cwd={}, repo_root={}",
            cwd.display(),
            repo_root.display()
        );
        Ok(Self {
            cwd,
            repo_root,
            metadata_folder_name: config.metadata_folder_name().to_owned(),
        })
    }

    pub fn metadata_folder(&self) -> PathBuf {
        self.repo_root.join(&self.metadata_folder_name)
    }

    pub fn cache_folder(&self) -> PathBuf {
        self.metadata_folder().join(".cache")
    }

    pub fn metadata_path(&self, relative: &Path) -> PathBuf {
        let dvs_path = self.metadata_folder().join(relative);
        let mut s = dvs_path.into_os_string();
        s.push(".dvs");
        PathBuf::from(s)
    }

    /// Repo-root-relative paths of every tracked file: one per `.dvs` entry in
    /// the metadata folder, with the `.dvs` extension stripped.
    /// Shared by `get` and `status`
    pub(crate) fn tracked_paths(&self) -> Vec<PathBuf> {
        let metadata_root = self.metadata_folder();
        WalkDir::new(&metadata_root)
            .into_iter()
            .filter_map(|e| e.ok())
            .filter_map(|entry| {
                let entry_path = entry.path();
                if !entry_path.is_file() || entry_path.extension() != Some(OsStr::new("dvs")) {
                    return None;
                }
                entry_path
                    .strip_prefix(&metadata_root)
                    .ok()
                    .map(|rel| rel.with_extension(""))
            })
            .collect()
    }

    pub fn repo_root(&self) -> &Path {
        &self.repo_root
    }

    pub fn cwd(&self) -> &Path {
        &self.cwd
    }

    /// Get the path relative from repo root to cwd, or None if at repo root
    pub fn cwd_relative_to_root(&self) -> Option<&Path> {
        self.cwd
            .strip_prefix(&self.repo_root)
            .ok()
            .filter(|p| !p.as_os_str().is_empty())
    }

    /// Construct the full file path from a repo-relative path
    pub fn file_path(&self, relative: &Path) -> PathBuf {
        self.repo_root.join(relative)
    }

    pub fn validate_for_add(&self, paths: &[PathBuf]) -> Vec<(PathBuf, AddPathStatus)> {
        let mut found = Vec::new();
        for path in paths {
            let file_path = self.file_path(path);
            let status = match file_path.canonicalize() {
                Ok(canonical) => {
                    if !canonical.starts_with(&self.repo_root) {
                        AddPathStatus::OutsideProject
                    } else if canonical.is_dir() {
                        AddPathStatus::IsDirectory
                    } else if canonical.is_file() {
                        AddPathStatus::Valid
                    } else {
                        AddPathStatus::NotFound
                    }
                }
                Err(_) => AddPathStatus::NotFound,
            };
            found.push((path.clone(), status));
        }
        found
    }

    pub fn validate_for_get(&self, paths: &[PathBuf]) -> Vec<(PathBuf, GetPathStatus)> {
        let mut found = Vec::new();
        for path in paths {
            let metadata_path = self.metadata_path(path);
            let validation = if metadata_path.is_file() {
                GetPathStatus::Tracked
            } else if self.file_path(path).is_file() {
                GetPathStatus::NotTracked
            } else {
                GetPathStatus::NotFound
            };
            found.push((path.clone(), validation));
        }
        found
    }
}

/// Which paths to get use for status/get
/// eg you can pass dir1/ dir2/ and it will expand to dir1/* dir2/*
/// If `recursive` is `true`, then it will expand to dir1/**/* dir2/**/*
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct PathFilter {
    pub(crate) paths: Vec<PathBuf>,
    pub(crate) recursive: bool,
}

impl PathFilter {
    /// Normalized project-relative selections, after rejecting paths outside the root.
    pub fn paths(&self) -> &[PathBuf] {
        &self.paths
    }

    /// When a user doesn't provide a path, we default to the cwd relative to the root
    pub fn cwd_scoped(recursive: bool, dvs_paths: &DvsPaths) -> Self {
        let cwd = dvs_paths
            .cwd_relative_to_root()
            .map(Path::to_path_buf)
            .unwrap_or_default(); // "" when at repo root
        Self {
            paths: vec![cwd],
            recursive,
        }
    }

    /// Create a filter from user-provided paths (relative to cwd) and a recursive flag.
    /// Translates cwd-relative paths to repo-root-relative using `dvs_paths.cwd_relative_to_root()`.
    pub fn from_user_paths(
        user_paths: Vec<PathBuf>,
        recursive: bool,
        dvs_paths: &DvsPaths,
    ) -> Self {
        let cwd_prefix = dvs_paths.cwd_relative_to_root();
        let repo_root = dvs_paths.repo_root();
        let paths = user_paths
            .into_iter()
            .filter_map(|p| {
                if p.is_absolute() {
                    p.strip_prefix(repo_root)
                        .ok()
                        .map(|r| r.to_path_buf())
                        .and_then(normalize_path)
                } else {
                    let joined = if let Some(prefix) = cwd_prefix {
                        prefix.join(&p)
                    } else {
                        p
                    };
                    normalize_path(joined)
                }
            })
            .collect();
        Self { paths, recursive }
    }

    pub(crate) fn matches(&self, tracked_path: &Path, glob: Option<&GlobMatcher>) -> bool {
        self.paths.iter().any(|filter_path| {
            if tracked_path == filter_path {
                return true;
            }
            // it needs to be a parent
            let Ok(rel) = tracked_path.strip_prefix(filter_path) else {
                return false;
            };
            match glob {
                Some(g) => g.is_match(rel),
                None => {
                    // Recursive: any descendant or non-recursive: direct child
                    self.recursive || tracked_path.parent() == Some(filter_path.as_path())
                }
            }
        })
    }
}

#[derive(Debug, PartialEq, Eq)]
pub enum ProjectPathError {
    Empty,
    NotRelative,
    NotUtf8,
    Backslash,
}

impl fmt::Display for ProjectPathError {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            ProjectPathError::Empty => f.write_str("Path is empty or has an empty component"),
            ProjectPathError::NotRelative => {
                f.write_str("Path needs to be relative, without a leading `/`, `.` or `..`")
            }
            ProjectPathError::NotUtf8 => f.write_str("Path is not UTF-8"),
            ProjectPathError::Backslash => f.write_str("Part of the path contains `\\`"),
        }
    }
}

/// We want a path to be the same on all OSes: we need to be able to push on Windows and
/// pull on Linux.
#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize)]
#[serde(transparent)]
pub struct ProjectPath(String);

impl ProjectPath {
    pub fn from_path(path: &Path) -> Result<Self, ProjectPathError> {
        let mut out = String::new();
        for component in path.components() {
            let Component::Normal(c) = component else {
                return Err(ProjectPathError::NotRelative);
            };
            let part = c.to_str().ok_or(ProjectPathError::NotUtf8)?;
            if part.contains('\\') {
                return Err(ProjectPathError::Backslash);
            }
            if !out.is_empty() {
                out.push('/');
            }
            out.push_str(part);
        }
        if out.is_empty() {
            return Err(ProjectPathError::Empty);
        }
        Ok(Self(out))
    }

    /// This is like from_path but from a canonical dvs path, eg using / even on Windows
    pub fn from_canonical(path: &str) -> Result<Self, ProjectPathError> {
        if path.starts_with('/') {
            return Err(ProjectPathError::NotRelative);
        }
        let mut out = String::with_capacity(path.len());
        for part in path.split('/') {
            match part {
                "" => return Err(ProjectPathError::Empty),
                "." | ".." => return Err(ProjectPathError::NotRelative),
                _ => {
                    if part.contains('\\') {
                        return Err(ProjectPathError::Backslash);
                    }
                    if !out.is_empty() {
                        out.push('/');
                    }
                    out.push_str(part);
                }
            }
        }

        if out.is_empty() {
            return Err(ProjectPathError::Empty);
        }

        Ok(Self(out))
    }

    pub fn as_str(&self) -> &str {
        &self.0
    }

    pub fn to_native(&self) -> PathBuf {
        self.0.split('/').collect()
    }
}

impl<'de> Deserialize<'de> for ProjectPath {
    fn deserialize<D: Deserializer<'de>>(de: D) -> Result<Self, D::Error> {
        let s = String::deserialize(de)?;
        ProjectPath::from_canonical(&s).map_err(serde::de::Error::custom)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::testutil::{create_temp_git_repo, init_dvs_repo};

    #[test]
    fn metadata_path_returns_dvs_file_path() {
        let (_tmp, root) = create_temp_git_repo();
        let paths = DvsPaths::new(root.clone(), root.clone(), ".meta").unwrap();

        let result = paths.metadata_path(Path::new("sub/file.txt"));
        assert_eq!(result, root.join(".meta/sub/file.txt.dvs"));
    }

    #[test]
    fn validate_for_add() {
        let (_tmp, root) = create_temp_git_repo();
        let paths = DvsPaths::new(root.clone(), root.clone(), ".dvs").unwrap();

        // Valid: existing file inside repo
        fs_err::write(root.join("test.txt"), b"content").unwrap();

        // OutsideProject: a sibling of the repo, outside its root.
        fs_err::write(root.parent().unwrap().join("outside.txt"), b"outside").unwrap();
        let outside_relative = PathBuf::from("..").join("outside.txt");

        // IsDirectory: a subdirectory inside the repo
        fs_err::create_dir(root.join("subdir")).unwrap();

        let result = paths.validate_for_add(&[
            PathBuf::from("test.txt"),
            PathBuf::from("nonexistent.txt"),
            outside_relative,
            PathBuf::from("subdir"),
        ]);

        assert_eq!(result[0].1, AddPathStatus::Valid);
        assert_eq!(result[1].1, AddPathStatus::NotFound);
        assert_eq!(result[2].1, AddPathStatus::OutsideProject);
        assert_eq!(result[3].1, AddPathStatus::IsDirectory);
    }

    #[test]
    fn can_handle_project_paths() {
        assert_eq!(
            ProjectPath::from_path(Path::new("data/file.csv"))
                .unwrap()
                .as_str(),
            "data/file.csv"
        );
        #[cfg(unix)]
        assert_eq!(
            ProjectPath::from_path(Path::new("data\\file.csv")),
            Err(ProjectPathError::Backslash)
        );
        #[cfg(windows)]
        assert_eq!(
            ProjectPath::from_path(Path::new("data\\file.csv"))
                .unwrap()
                .as_str(),
            "data/file.csv"
        );

        let paths = vec!["../file.csv", "./file.csv"];
        for p in paths {
            assert!(ProjectPath::from_path(Path::new(p)).is_err());
        }
    }

    #[test]
    fn canonical_project_path_errors() {
        for (input, expected) in [
            ("/abs/file.csv", ProjectPathError::NotRelative),
            ("../file.csv", ProjectPathError::NotRelative),
            ("./file.csv", ProjectPathError::NotRelative),
            ("data\\file.csv", ProjectPathError::Backslash),
            ("data//file.csv", ProjectPathError::Empty),
            ("data/", ProjectPathError::Empty),
            ("", ProjectPathError::Empty),
        ] {
            assert_eq!(ProjectPath::from_canonical(input), Err(expected),);
        }
    }

    #[test]
    fn canonical_project_path_round_trip() {
        let path = ProjectPath::from_canonical("data/sub/file.csv").unwrap();
        assert_eq!(path.as_str(), "data/sub/file.csv");
        assert_eq!(ProjectPath::from_path(&path.to_native()), Ok(path));
    }

    fn run_filter_cases(cases: Vec<(&[&str], &str, bool)>, recursive: bool) {
        for (filter_paths, test_path, expected) in cases {
            let filter = PathFilter {
                paths: filter_paths
                    .iter()
                    .filter_map(|p| normalize_path(PathBuf::from(p)))
                    .collect(),
                recursive,
            };
            assert_eq!(
                filter.matches(Path::new(test_path), None),
                expected,
                "filter={filter_paths:?} recursive={recursive} path={test_path:?}"
            );
        }
    }

    #[test]
    fn status_filter_matches_non_recursive() {
        // (filter_paths, test_path, expected)
        let cases: Vec<(&[&str], &str, bool)> = vec![
            // direct child matches
            (&["dir1"], "dir1/b.txt", true),
            // nested child does NOT match
            (&["dir1"], "dir1/sub/c.txt", false),
            // exact file match
            (&["dir2/d.txt"], "dir2/d.txt", true),
            // exact file: different file does NOT match
            (&["dir2/d.txt"], "dir2/e.txt", false),
            // "." matches root-level files
            (&["."], "a.txt", true),
            // "." does NOT match nested files
            (&["."], "dir1/b.txt", false),
            // "../foo" escapes root → dropped, matches nothing
            (&["../foo"], "foo", false),
            // "dir1/../dir2" normalizes to "dir2", matches direct child
            (&["dir1/../dir2"], "dir2/d.txt", true),
            // "dir1/.." normalizes to root, matches root-level files
            (&["dir1/.."], "a.txt", true),
        ];
        run_filter_cases(cases, false);
    }

    #[test]
    fn status_filter_matches_recursive() {
        // (filter_paths, test_path, expected)
        let cases: Vec<(&[&str], &str, bool)> = vec![
            // direct child matches
            (&["dir1"], "dir1/b.txt", true),
            // nested child matches
            (&["dir1"], "dir1/sub/c.txt", true),
            // unrelated dir does NOT match
            (&["dir1"], "dir2/d.txt", false),
            // "." matches everything recursively
            (&["."], "a.txt", true),
            (&["."], "dir1/b.txt", true),
            (&["."], "dir1/sub/c.txt", true),
            // "../foo" escapes root → dropped
            (&["../foo"], "foo", false),
            // "a/../../x" escapes root → dropped
            (&["a/../../x"], "x", false),
            // "dir1/../dir2" normalizes to "dir2", matches descendants
            (&["dir1/../dir2"], "dir2/d.txt", true),
        ];
        run_filter_cases(cases, true);
    }

    #[test]
    fn from_user_paths_with_subdirectory_cwd() {
        let (_tmp, root) = create_temp_git_repo();
        let (_config, _dvs_dir) = init_dvs_repo(&root);

        // Create subdirectories so canonicalize works in DvsPaths::new
        fs::create_dir_all(root.join("subdir/deep")).unwrap();
        fs::create_dir_all(root.join("dir2")).unwrap();

        // From subdir/: ../foo → resolves to "foo" (valid)
        let paths = DvsPaths::new(
            fs::canonicalize(root.join("subdir")).unwrap(),
            root.to_path_buf(),
            ".dvs",
        )
        .unwrap();
        let filter = PathFilter::from_user_paths(vec![PathBuf::from("../foo")], false, &paths);
        assert_eq!(filter.paths, vec![PathBuf::from("foo")]);

        // From subdir/: ../../foo → escapes root → dropped (empty)
        let filter = PathFilter::from_user_paths(vec![PathBuf::from("../../foo")], false, &paths);
        assert!(
            filter.paths.is_empty(),
            "../../foo should escape root and be dropped"
        );

        // From subdir/deep/: ../../foo → resolves to "foo" (valid, 2 levels up = root)
        let paths_deep = DvsPaths::new(
            fs::canonicalize(root.join("subdir/deep")).unwrap(),
            root.to_path_buf(),
            ".dvs",
        )
        .unwrap();
        let filter =
            PathFilter::from_user_paths(vec![PathBuf::from("../../foo")], false, &paths_deep);
        assert_eq!(filter.paths, vec![PathBuf::from("foo")]);

        // From subdir/: ../dir2/file.txt → resolves to "dir2/file.txt"
        let filter =
            PathFilter::from_user_paths(vec![PathBuf::from("../dir2/file.txt")], false, &paths);
        assert_eq!(filter.paths, vec![PathBuf::from("dir2/file.txt")]);

        // From subdir/: absolute path with .. like <root>/subdir/../a.txt → normalizes to "a.txt"
        let abs_with_dotdot = root.join("subdir/../a.txt");
        let filter = PathFilter::from_user_paths(vec![abs_with_dotdot], false, &paths);
        assert_eq!(filter.paths, vec![PathBuf::from("a.txt")]);
    }
}