grit_lib/

git_path.rs

//! Git-compatible path normalization (`normalize_path_copy`, `longest_ancestor_length`,
//! `relative_path`) plus display and comparison helpers for repository paths.

use std::borrow::Cow;
use std::ffi::OsString;
use std::fs;
use std::path::{Component, Path, PathBuf};

use crate::path_icase::worktree_path_for_index_entry;
use crate::pathspec::has_glob_chars;
use crate::unicode_normalization::resolve_worktree_path_for_staging;

/// Errors returned by Git-compatible path helper routines.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum GitPathError {
    /// Normalization would escape above the root.
    EscapesRoot,
    /// A relative URL cannot be resolved against the provided remote URL.
    InvalidRelativeUrl,
}

#[inline]
fn is_dir_sep(c: u8) -> bool {
    c == b'/'
}

/// Purely textual path normalization matching Git's `normalize_path_copy`.
/// Returns [`GitPathError::EscapesRoot`] when `..` would escape above the root
/// (Git returns -1).
pub fn normalize_path_copy(src: &str) -> Result<String, GitPathError> {
    let is_abs = src.starts_with('/');
    let raw_ends_dir = {
        let stripped = src.trim_end_matches('/');
        stripped.ends_with("/.")
            || stripped.ends_with("/..")
            || src.ends_with('/')
            || src == "."
            || src == ".."
    };
    let trailing_slash = raw_ends_dir && !src.is_empty();
    let mut stack: Vec<String> = Vec::new();
    let bytes = src.as_bytes();
    let mut i = 0usize;
    if is_abs {
        i = 1;
    }
    while i < bytes.len() {
        while i < bytes.len() && bytes[i] == b'/' {
            i += 1;
        }
        if i >= bytes.len() {
            break;
        }
        let start = i;
        while i < bytes.len() && bytes[i] != b'/' {
            i += 1;
        }
        let part = &src[start..i];
        if part == "." {
            continue;
        }
        if part == ".." {
            if stack.pop().is_none() {
                return Err(GitPathError::EscapesRoot);
            }
        } else {
            stack.push(part.to_string());
        }
    }

    let mut out = if is_abs {
        if stack.is_empty() {
            "/".to_string()
        } else {
            "/".to_string() + &stack.join("/")
        }
    } else if stack.is_empty() {
        String::new()
    } else {
        stack.join("/")
    };
    if trailing_slash && !out.is_empty() && !out.ends_with('/') {
        out.push('/');
    }
    Ok(out)
}

/// Git's `longest_ancestor_length` - normalizes `path` and each colon-separated prefix.
pub fn longest_ancestor_length(path: &str, prefixes_colon_sep: &str) -> Result<i32, GitPathError> {
    let path = normalize_path_copy(path)?;
    if path == "/" {
        return Ok(-1);
    }
    let mut max_len: i64 = -1;
    for ceil_raw in prefixes_colon_sep.split(':') {
        if ceil_raw.is_empty() {
            continue;
        }
        let ceil = normalize_path_copy(ceil_raw)?;
        let mut len = ceil.len();
        if len > 0 && ceil.as_bytes()[len - 1] == b'/' {
            len -= 1;
        }
        let p = path.as_bytes();
        let c = ceil.as_bytes();
        if len > p.len() || len > c.len() || p[..len] != c[..len] {
            continue;
        }
        // Match git/path.c: need a '/' after the ceiling and another path component (not exact path).
        if len == p.len() || p[len] != b'/' || p.get(len + 1).is_none() {
            continue;
        }
        if len as i64 > max_len {
            max_len = len as i64;
        }
    }
    Ok(max_len as i32)
}

fn have_same_root(path1: &str, path2: &str) -> bool {
    let abs1 = path1.starts_with('/');
    let abs2 = path2.starts_with('/');
    (abs1 && abs2) || (!abs1 && !abs2)
}

/// Git's `relative_path` from `path.c` (POSIX subset).
pub fn relative_path<'a>(in_path: &'a str, prefix: &'a str, sb: &'a mut String) -> Option<&'a str> {
    let in_len = in_path.len();
    let prefix_len = prefix.len();
    let mut in_off = 0usize;
    let mut prefix_off = 0usize;
    let mut i = 0usize;
    let mut j = 0usize;

    if in_len == 0 {
        return Some("./");
    }
    if prefix_len == 0 {
        return Some(in_path);
    }

    if !have_same_root(in_path, prefix) {
        return Some(in_path);
    }

    let in_b = in_path.as_bytes();
    let pre_b = prefix.as_bytes();

    while i < prefix_len && j < in_len && pre_b[i] == in_b[j] {
        if is_dir_sep(pre_b[i]) {
            while i < prefix_len && is_dir_sep(pre_b[i]) {
                i += 1;
            }
            while j < in_len && is_dir_sep(in_b[j]) {
                j += 1;
            }
            prefix_off = i;
            in_off = j;
        } else {
            i += 1;
            j += 1;
        }
    }

    if i >= prefix_len && prefix_off < prefix_len {
        if j >= in_len {
            in_off = in_len;
        } else if is_dir_sep(in_b[j]) {
            while j < in_len && is_dir_sep(in_b[j]) {
                j += 1;
            }
            in_off = j;
        } else {
            i = prefix_off;
        }
    } else if j >= in_len && in_off < in_len && is_dir_sep(pre_b[i]) {
        while i < prefix_len && is_dir_sep(pre_b[i]) {
            i += 1;
        }
        in_off = in_len;
    }

    let in_suffix = &in_path[in_off..];
    let in_suffix_len = in_suffix.len();

    if i >= prefix_len {
        if in_suffix_len == 0 {
            return Some("./");
        }
        return Some(in_suffix);
    }

    sb.clear();
    sb.reserve(in_suffix_len.saturating_add(prefix_len * 3));

    while i < prefix_len {
        if is_dir_sep(pre_b[i]) {
            sb.push_str("../");
            while i < prefix_len && is_dir_sep(pre_b[i]) {
                i += 1;
            }
            continue;
        }
        i += 1;
    }
    if prefix_len > 0 && !is_dir_sep(pre_b[prefix_len - 1]) {
        sb.push_str("../");
    }
    sb.push_str(in_suffix);

    Some(sb.as_str())
}

/// Git's `cleanup_path` from `path.c`: strip a single leading `./` and any
/// directory separators immediately following it. Internal consecutive slashes
/// (e.g. `info//sparse-checkout`) are deliberately preserved so the result
/// matches `git rev-parse --git-path` byte-for-byte.
#[must_use]
pub fn cleanup_path(path: &str) -> &str {
    if let Some(rest) = path.strip_prefix("./") {
        rest.trim_start_matches('/')
    } else {
        path
    }
}

/// The relative portion of a `--git-path` argument, mirroring how Git builds the
/// buffer in `repo_git_pathv`: the caller-supplied `fmt` string is appended to
/// `<git_dir>/` verbatim and only [`cleanup_path`] runs over the whole buffer.
/// In practice that means a single leading `/` (and a leading `./`) is dropped
/// from the user-supplied component while internal `//` runs are kept intact.
#[must_use]
pub fn git_path_relative_component(path: &str) -> &str {
    // Drop one leading slash (Git appends fmt right after "<git_dir>/", so a
    // user "/foo" would otherwise become "<git_dir>//foo"); keep the rest as-is.
    let trimmed = path.strip_prefix('/').unwrap_or(path);
    cleanup_path(trimmed)
}

/// One entry in Git's `common_list` (`git/path.c`).
struct CommonDir {
    is_dir: bool,
    is_common: bool,
    path: &'static str,
}

/// Git's `common_list` table from `git/path.c`. Each entry classifies a path
/// (or directory prefix) under the git dir as belonging to the common dir or to
/// the per-worktree git dir. The order is irrelevant for classification because
/// `trie_find` always selects the longest `/`-terminated matching prefix.
const COMMON_LIST: &[CommonDir] = &[
    CommonDir {
        is_dir: true,
        is_common: true,
        path: "branches",
    },
    CommonDir {
        is_dir: true,
        is_common: true,
        path: "common",
    },
    CommonDir {
        is_dir: true,
        is_common: true,
        path: "hooks",
    },
    CommonDir {
        is_dir: true,
        is_common: true,
        path: "info",
    },
    CommonDir {
        is_dir: false,
        is_common: false,
        path: "info/sparse-checkout",
    },
    CommonDir {
        is_dir: true,
        is_common: true,
        path: "logs",
    },
    CommonDir {
        is_dir: false,
        is_common: false,
        path: "logs/HEAD",
    },
    CommonDir {
        is_dir: true,
        is_common: false,
        path: crate::refs::store::paths::LOGS_REFS_BISECT,
    },
    CommonDir {
        is_dir: true,
        is_common: false,
        path: crate::refs::store::paths::LOGS_REFS_REWRITTEN,
    },
    CommonDir {
        is_dir: true,
        is_common: false,
        path: crate::refs::store::paths::LOGS_REFS_WORKTREE,
    },
    CommonDir {
        is_dir: true,
        is_common: true,
        path: "lost-found",
    },
    CommonDir {
        is_dir: true,
        is_common: true,
        path: "objects",
    },
    CommonDir {
        is_dir: true,
        is_common: true,
        path: "refs",
    },
    CommonDir {
        is_dir: true,
        is_common: false,
        path: "refs/bisect",
    },
    CommonDir {
        is_dir: true,
        is_common: false,
        path: "refs/rewritten",
    },
    CommonDir {
        is_dir: true,
        is_common: false,
        path: "refs/worktree",
    },
    CommonDir {
        is_dir: true,
        is_common: true,
        path: "remotes",
    },
    CommonDir {
        is_dir: true,
        is_common: true,
        path: "worktrees",
    },
    CommonDir {
        is_dir: true,
        is_common: true,
        path: "rr-cache",
    },
    CommonDir {
        is_dir: true,
        is_common: true,
        path: "svn",
    },
    CommonDir {
        is_dir: false,
        is_common: true,
        path: "config",
    },
    CommonDir {
        is_dir: false,
        is_common: true,
        path: "gc.pid",
    },
    CommonDir {
        is_dir: false,
        is_common: true,
        path: crate::refs::store::paths::packed_refs_rel(),
    },
    CommonDir {
        is_dir: false,
        is_common: true,
        path: "shallow",
    },
];

/// Git's `check_common` (`git/path.c`): decide, for the matched `common_list`
/// entry and the unmatched remainder of the key, whether the path is common.
fn check_common(entry: &CommonDir, unmatched: &[u8]) -> Option<bool> {
    let first = unmatched.first().copied();
    if entry.is_dir && (first.is_none() || first == Some(b'/')) {
        return Some(entry.is_common);
    }
    if !entry.is_dir && first.is_none() {
        return Some(entry.is_common);
    }
    None
}

/// Compressed-trie lookup with the same behavior as Git's `trie_find`, specialized to
/// `common_list` + `check_common`. Returns the longest `/`-or-`\0`-terminated
/// `common_list` prefix's classification for `key`, or `None` if no prefix
/// matches (treated as "not common" by callers).
///
/// Mirrors the C trie semantics including: partial normalization (consecutive
/// slashes are skipped) and the fallback to a shorter `/`-terminated prefix when
/// a longer node yields no verdict.
fn trie_find_common(key: &[u8]) -> Option<bool> {
    // The trie distinguishes nodes by their full path; longest match wins, but
    // when the deepest matching node declines (`check_common` -> None) and we are
    // at a `/` boundary, control falls back to the next-shorter prefix that has a
    // value. We emulate this by scanning candidate prefixes from longest to
    // shortest. A candidate is a `common_list` path P that is a prefix of the
    // normalized key, terminated in the key by `\0` or `/`.
    let norm = normalize_double_slashes(key);
    // Collect matching entries, longest path first.
    let mut matches: Vec<&CommonDir> = COMMON_LIST
        .iter()
        .filter(|e| key_has_prefix_node(&norm, e.path.as_bytes()))
        .collect();
    matches.sort_by_key(|a| std::cmp::Reverse(a.path.len()));
    for entry in matches {
        let plen = entry.path.len();
        let unmatched = &norm[plen..];
        if let Some(verdict) = check_common(entry, unmatched) {
            return Some(verdict);
        }
        // No verdict at this node. The C trie only falls back to a shorter
        // prefix; continue to the next (shorter) candidate.
    }
    None
}

/// Collapse runs of consecutive `/` to a single `/` (Git's partial path
/// normalization inside `trie_find`). A trailing slash is preserved as a single
/// slash so directory-prefix matching still sees the boundary.
fn normalize_double_slashes(key: &[u8]) -> Vec<u8> {
    let mut out = Vec::with_capacity(key.len());
    let mut prev_slash = false;
    for &b in key {
        if b == b'/' {
            if !prev_slash {
                out.push(b);
            }
            prev_slash = true;
        } else {
            out.push(b);
            prev_slash = false;
        }
    }
    out
}

/// True when `node` is a prefix of `key` terminated by end-of-string or `/`.
fn key_has_prefix_node(key: &[u8], node: &[u8]) -> bool {
    if key.len() < node.len() || &key[..node.len()] != node {
        return false;
    }
    matches!(key.get(node.len()), None | Some(b'/'))
}

/// True when the relative git-dir path `rel` belongs to the common (shared)
/// directory, mirroring Git's `update_common_dir` decision (`git/path.c`).
///
/// `rel` is the component after the git dir (for example the reflog prefix from
/// [`crate::refs::store::paths::logs_refs_rel`], `config`, or `HEAD`). Any trailing `.lock` suffix is ignored for the decision, exactly as
/// `update_common_dir` strips `LOCK_SUFFIX` before consulting the trie.
#[must_use]
pub fn is_common_git_path(rel: &str) -> bool {
    let stripped = rel.strip_suffix(".lock").unwrap_or(rel);
    matches!(trie_find_common(stripped.as_bytes()), Some(true))
}

/// Git `setup.c` `abspath_part_inside_repo` (POSIX).
///
/// Strips the work tree from an absolute, normalized path, preserving symlink path
/// components when they are still under the work tree as a string prefix.
pub fn abspath_part_inside_repo(path: &str, work_tree: &Path) -> Option<String> {
    let normalized = normalize_path_copy(path).ok()?;
    if !normalized.starts_with('/') {
        return None;
    }
    let wt_display = work_tree.to_string_lossy();
    let wt_trim: &str = if wt_display == "/" {
        "/"
    } else {
        wt_display.trim_end_matches('/')
    };
    let wt_len = wt_trim.len();
    let p = normalized.as_str();
    let len = p.len();

    if wt_len <= len && p.starts_with(wt_trim) {
        if len > wt_len && p.as_bytes()[wt_len] == b'/' {
            return Some(p[wt_len + 1..].to_string());
        }
        if len == wt_len {
            return Some(String::new());
        }
        if wt_len > 0 && wt_trim.as_bytes()[wt_len - 1] == b'/' {
            return Some(p[wt_len..].trim_start_matches('/').to_string());
        }
    }

    let wt_canon = path_for_disk_compare(work_tree);
    let mut cum = String::new();
    for seg in p.split('/').filter(|s| !s.is_empty()) {
        cum.push('/');
        cum.push_str(seg);
        let rp = path_for_disk_compare(Path::new(&cum));
        if rp == wt_canon {
            if p.len() == cum.len() {
                return Some(String::new());
            }
            if p.as_bytes().get(cum.len()) == Some(&b'/') {
                return Some(p[cum.len() + 1..].to_string());
            }
        }
    }
    let full = path_for_disk_compare(Path::new(p));
    if full == wt_canon {
        return Some(String::new());
    }
    None
}

/// Git path variables copied into hook/filter subprocess environments.
pub(crate) const SUBPROCESS_GIT_PATH_VARS: [&str; 5] = [
    "GIT_DIR",
    "GIT_COMMON_DIR",
    "GIT_WORK_TREE",
    "GIT_INDEX_FILE",
    "GIT_OBJECT_DIRECTORY",
];

/// Strip Windows `\\?\` prefixes from path-valued `GIT_*` entries in a subprocess env block.
pub(crate) fn strip_verbatim_prefix_from_subprocess_path_vars(set: &mut [(OsString, OsString)]) {
    for (key, value) in set.iter_mut() {
        if !SUBPROCESS_GIT_PATH_VARS.iter().any(|var| key == *var) {
            continue;
        }
        let Some(s) = value.to_str() else {
            continue;
        };
        let stripped = strip_verbatim_path_prefix_str(s);
        if stripped.len() != s.len() {
            *value = OsString::from(stripped.into_owned());
        }
    }
}

/// Strip Windows extended-length `\\?\` / `\\?\UNC\` prefixes for comparison and display.
#[must_use]
pub fn strip_verbatim_path_prefix_str(path: &str) -> Cow<'_, str> {
    if let Some(rest) = path.strip_prefix(r"\\?\UNC\") {
        Cow::Owned(format!(r"\\{rest}"))
    } else if let Some(rest) = path.strip_prefix(r"\\?\") {
        Cow::Borrowed(rest)
    } else {
        Cow::Borrowed(path)
    }
}

/// `path` without a Windows `\\?\` / `\\?\UNC\` prefix, for paths handed to child processes.
///
/// [`Path::canonicalize`] returns verbatim paths on Windows, and MSYS tools such as Git for
/// Windows' `sh` cannot open them. Other platforms return `path` unchanged.
#[must_use]
pub(crate) fn path_without_verbatim_prefix(path: &Path) -> Cow<'_, Path> {
    #[cfg(windows)]
    if let Some(s) = path.to_str() {
        let stripped = strip_verbatim_path_prefix_str(s);
        if stripped.len() != s.len() {
            return Cow::Owned(PathBuf::from(stripped.into_owned()));
        }
    }
    Cow::Borrowed(path)
}

/// Longest path, in UTF-16 units, that Win32 file APIs accept without the `\\?\` prefix
/// (`MAX_PATH` less the terminating NUL).
#[cfg(any(windows, test))]
const WIN32_MAX_PATH_UNITS: usize = 259;

/// Win32 spelling of a verbatim drive (`\\?\C:\…`) or UNC (`\\?\UNC\server\share\…`) path.
///
/// Returns `None` when `path` is not one of those forms, or when dropping the prefix would
/// change which file the path names or push it past `MAX_PATH`: components Win32 rewrites or
/// rejects (empty, `.`, `..`, a trailing `.` or space, `/`, `:`, wildcards, control
/// characters), reserved device names such as `NUL` or `COM1.txt`, and over-long paths all keep
/// the prefix. Volume GUID (`\\?\Volume{…}`) and device (`\\.\`) paths are never rewritten.
#[cfg(any(windows, test))]
fn simplify_verbatim_str(path: &str) -> Option<String> {
    let (simple, components) = if let Some(rest) = path.strip_prefix(r"\\?\UNC\") {
        let mut parts = rest.splitn(3, '\\');
        let (server, share) = (parts.next()?, parts.next()?);
        if server.is_empty() || share.is_empty() {
            return None;
        }
        (format!(r"\\{rest}"), rest)
    } else {
        let rest = path.strip_prefix(r"\\?\")?;
        let drive = rest.as_bytes();
        if drive.len() < 3 || !drive[0].is_ascii_alphabetic() || drive[1..3] != *b":\\" {
            return None;
        }
        (rest.to_owned(), &rest[3..])
    };
    let round_trips =
        components.is_empty() || components.split('\\').all(win32_component_round_trips);
    (round_trips && simple.encode_utf16().count() <= WIN32_MAX_PATH_UNITS).then_some(simple)
}

/// Whether Win32 path parsing leaves `component` unchanged and names a regular file.
#[cfg(any(windows, test))]
pub(crate) fn win32_component_round_trips(component: &str) -> bool {
    const RESERVED: [&str; 6] = ["CON", "PRN", "AUX", "NUL", "CONIN$", "CONOUT$"];
    if component.is_empty()
        || component.ends_with(['.', ' '])
        || component.contains(['/', ':', '<', '>', '"', '|', '?', '*'])
        || component.chars().any(char::is_control)
    {
        return false;
    }
    let stem = component
        .split('.')
        .next()
        .unwrap_or(component)
        .trim_end_matches(' ');
    if RESERVED.iter().any(|name| stem.eq_ignore_ascii_case(name)) {
        return false;
    }
    let numbered_device = ["COM", "LPT"].iter().any(|device| {
        stem.get(..3)
            .is_some_and(|head| head.eq_ignore_ascii_case(device))
            && matches!(
                &stem[3..],
                "1" | "2"
                    | "3"
                    | "4"
                    | "5"
                    | "6"
                    | "7"
                    | "8"
                    | "9"
                    | "\u{b9}"
                    | "\u{b2}"
                    | "\u{b3}"
            )
    });
    !numbered_device
}

/// Whether every `/`-separated component of a Git storage path is safe as a Win32 file name.
#[cfg(any(windows, test))]
pub(crate) fn win32_storage_path_components_round_trip(path: &str) -> bool {
    path.split('/').all(win32_component_round_trips)
}

/// `path` in its plain Win32 spelling when it is a verbatim (`\\?\`) path that names the same
/// file without the prefix; every other path, and every path off Windows, is returned unchanged.
///
/// [`std::fs::canonicalize`] always returns verbatim paths on Windows. Paths stored on a
/// [`crate::repo::Repository`] go through this so they compare equal to, and display like, the
/// paths callers passed in. Over-long and otherwise unrepresentable paths keep the prefix so
/// they still open.
#[must_use]
pub(crate) fn simplify_verbatim_path(path: PathBuf) -> PathBuf {
    #[cfg(windows)]
    if let Some(simple) = path.to_str().and_then(simplify_verbatim_str) {
        return PathBuf::from(simple);
    }
    path
}

/// [`Path::canonicalize`] followed by [`simplify_verbatim_path`].
///
/// Use this instead of [`Path::canonicalize`] everywhere in the crate, so canonical paths
/// stored on a repository handle and canonical paths computed later compare equal.
pub(crate) trait CanonicalizeExt {
    /// Canonical absolute form of `self`, without a needless Windows `\\?\` prefix.
    ///
    /// # Errors
    ///
    /// Returns the [`std::io::Error`] from [`std::fs::canonicalize`] (for example when the
    /// path does not exist).
    fn canonicalize_simplified(&self) -> std::io::Result<PathBuf>;
}

impl CanonicalizeExt for Path {
    #[allow(clippy::disallowed_methods)]
    fn canonicalize_simplified(&self) -> std::io::Result<PathBuf> {
        fs::canonicalize(self).map(simplify_verbatim_path)
    }
}

/// User-facing path: forward slashes, no verbatim prefix (Git-style init/status paths).
#[must_use]
pub fn user_display_path(path: &Path) -> String {
    strip_verbatim_path_prefix_str(&path.display().to_string()).replace('\\', "/")
}

/// User-facing path for error messages (alias of [`user_display_path`]).
#[must_use]
pub fn path_for_error_message(path: &Path) -> String {
    user_display_path(path)
}

/// Absolute path for Git worktree gitfiles (linked `.git` `gitdir:` lines and `gitdir` files).
///
/// Resolves symlinks via [`std::fs::canonicalize`] when possible, strips Windows `\\?\`
/// extended-length prefixes, and uses forward slashes so system Git can open linked worktrees.
#[must_use]
pub fn absolute_path_for_gitfile_stored_path(path: &Path) -> String {
    let canon = path
        .canonicalize_simplified()
        .unwrap_or_else(|_| path.to_path_buf());
    user_display_path(&canon)
}

/// Lexical absolute path for comparison (does not follow symlinks).
///
/// Strips Windows verbatim prefixes when present. Used for repository entry paths so
/// symlinks keep their repository spelling in status and pathspec resolution.
#[must_use]
pub fn path_lexical_for_disk_compare(path: &Path) -> PathBuf {
    let abs = std::path::absolute(path).unwrap_or_else(|_| path.to_path_buf());
    let normalized = lexical_normalize_path_buf(abs);
    #[cfg(windows)]
    let normalized = PathBuf::from(
        strip_verbatim_path_prefix_str(&normalized.display().to_string()).into_owned(),
    );
    normalized
}

fn lexical_normalize_path_buf(path: PathBuf) -> PathBuf {
    let mut out = PathBuf::new();
    for c in path.components() {
        match c {
            Component::Prefix(prefix) => out.push(prefix.as_os_str()),
            Component::RootDir => out.push(c),
            Component::CurDir => {}
            Component::ParentDir => {
                out.pop();
            }
            Component::Normal(_) => out.push(c),
        }
    }
    out
}

/// Repository-relative path with forward slashes when `path` lies under `work_tree`.
#[must_use]
pub fn strip_worktree_prefix(path: &Path, work_tree: &Path) -> Option<String> {
    let path_key = apply_macos_private_alias_for_compare(path_lexical_for_disk_compare(path));
    let wt_key = path_for_disk_compare(work_tree);
    let rel = path_key.strip_prefix(&wt_key).ok()?;
    Some(path_to_git_slash(rel))
}

/// Convert a filesystem path to Git's slash-separated repo-relative form.
#[must_use]
pub fn path_to_git_slash(path: &Path) -> String {
    path.components()
        .filter_map(|c| match c {
            Component::Normal(s) => Some(s.to_string_lossy().into_owned()),
            _ => None,
        })
        .collect::<Vec<_>>()
        .join("/")
}

/// Path of `to` relative to `from`, for display (forward slashes).
///
/// Uses normalized paths (including Windows verbatim-prefix stripping) and walks up from
/// the common ancestor with `..` when the target is not under `from`.
#[must_use]
pub fn relative_path_for_display(from: &Path, to: &Path) -> Option<String> {
    let from_cmp = path_for_disk_compare(from);
    let to_cmp = apply_macos_private_alias_for_compare(path_lexical_for_disk_compare(to));
    if from_cmp == to_cmp {
        return Some(".".to_owned());
    }

    let from_parts: Vec<_> = from_cmp.components().collect();
    let to_parts: Vec<_> = to_cmp.components().collect();
    let common = from_parts
        .iter()
        .zip(to_parts.iter())
        .take_while(|(a, b)| a == b)
        .count();

    let mut segments: Vec<String> = Vec::new();
    for part in &from_parts[common..] {
        if matches!(part, Component::Normal(_)) {
            segments.push("..".to_owned());
        }
    }
    for part in &to_parts[common..] {
        match part {
            Component::Normal(name) => segments.push(name.to_string_lossy().into_owned()),
            Component::ParentDir => {
                segments.pop();
            }
            Component::CurDir | Component::RootDir | Component::Prefix(_) => {}
        }
    }

    if segments.is_empty() {
        Some(".".to_owned())
    } else {
        Some(segments.join("/"))
    }
}

/// Normalize macOS `/private` spellings for path comparison keys.
///
/// `/tmp` and `/private/tmp` refer to the same directory; use the spelling without
/// `/private` when that path exists, or when an ancestor exists at the public spelling
/// (so not-yet-created paths still match a canonical work tree).
#[must_use]
fn apply_macos_private_alias_for_compare(path: PathBuf) -> PathBuf {
    #[cfg(target_os = "macos")]
    {
        if let Ok(stripped) = path.strip_prefix("/private") {
            let without_private = PathBuf::from("/").join(stripped);
            if without_private.exists() {
                return without_private;
            }
            let mut probe = without_private.as_path();
            while let Some(parent) = probe.parent() {
                if parent == Path::new("") {
                    break;
                }
                if parent.exists() {
                    return without_private;
                }
                probe = parent;
            }
        }
    }
    path
}

/// Canonicalize a path for on-disk comparison (macOS `/private` aliasing).
///
/// On macOS, `/tmp` and `/private/tmp` refer to the same directory; Git stores and
/// accepts both spellings when matching paths against `core.worktree`.
///
/// On Windows, `canonicalize` may return `\\?\`-prefixed paths; those are stripped so
/// comparisons match non-verbatim spellings (`C:\…`).
#[must_use]
pub fn path_for_disk_compare(path: &Path) -> PathBuf {
    let canon = path
        .canonicalize_simplified()
        .unwrap_or_else(|_| path.to_path_buf());
    #[cfg(windows)]
    let canon =
        PathBuf::from(strip_verbatim_path_prefix_str(&canon.display().to_string()).into_owned());
    apply_macos_private_alias_for_compare(canon)
}

/// Returns whether `rel_path` has a symlink among its directory components.
///
/// Git rejects pathspecs that traverse through a symlinked directory (for example
/// `dl/f` when `dl` is a symlink). Staging the symlink blob at `dl` itself is allowed.
#[must_use]
pub(crate) fn pathspec_traverses_symlink_dir(
    work_tree: &Path,
    rel_path: &str,
    precompose_unicode: bool,
    ignorecase: bool,
) -> bool {
    if rel_path.is_empty()
        || has_glob_chars(rel_path)
        || rel_path.starts_with(":(")
        || rel_path.starts_with(':')
    {
        return false;
    }
    let directory_pathspec = rel_path.ends_with('/');
    let components: Vec<&str> = rel_path.split('/').filter(|c| !c.is_empty()).collect();
    if components.is_empty() {
        return false;
    }
    let check_through = if directory_pathspec {
        components.len()
    } else if components.len() <= 1 {
        return false;
    } else {
        components.len() - 1
    };
    let mut prefix = String::new();
    for component in &components[..check_through] {
        if !prefix.is_empty() {
            prefix.push('/');
        }
        prefix.push_str(component);
        let abs = if precompose_unicode {
            resolve_worktree_path_for_staging(work_tree, &prefix, true).abs
        } else {
            worktree_path_for_index_entry(work_tree, &prefix, ignorecase)
        };
        let Ok(meta) = fs::symlink_metadata(&abs) else {
            continue;
        };
        if meta.file_type().is_symlink() {
            return true;
        }
    }
    false
}

/// Git `setup.c` `prefix_path_gently` (POSIX).
pub fn prefix_path_gently(prefix: &str, path: &str, work_tree: &Path) -> Option<String> {
    if path.starts_with('/') {
        let n = normalize_path_copy(path).ok()?;
        abspath_part_inside_repo(&n, work_tree)
    } else {
        let concat = format!("{prefix}{path}");
        normalize_path_copy(&concat).ok()
    }
}

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

    #[test]
    #[cfg(unix)]
    fn pathspec_traverses_symlink_dir_detects_intermediate_symlink() {
        use std::os::unix::fs::symlink;

        let tmp = tempfile::TempDir::new().expect("tempdir");
        let root = tmp.path();
        std::fs::create_dir_all(root.join("real")).expect("mkdir");
        std::fs::write(root.join("real/f"), b"x").expect("write");
        symlink("real", root.join("dl")).expect("symlink");
        assert!(pathspec_traverses_symlink_dir(root, "dl/f", false, false));
        assert!(!pathspec_traverses_symlink_dir(root, "dl", false, false));
        assert!(!pathspec_traverses_symlink_dir(
            root, "real/f", false, false
        ));
        assert!(pathspec_traverses_symlink_dir(root, "dl/", false, false));
        assert!(pathspec_traverses_symlink_dir(root, "dl/f/", false, false));
    }

    #[test]
    fn cleanup_path_strips_leading_dot_slash() {
        assert_eq!(cleanup_path("./foo"), "foo");
        assert_eq!(cleanup_path(".//foo"), "foo");
        assert_eq!(cleanup_path("foo"), "foo");
    }

    #[test]
    fn cleanup_path_keeps_internal_double_slashes() {
        // Git's cleanup_path never collapses interior consecutive slashes.
        assert_eq!(
            cleanup_path("info//sparse-checkout"),
            "info//sparse-checkout"
        );
        assert_eq!(cleanup_path("./info//grafts"), "info//grafts");
    }

    #[test]
    fn git_path_component_drops_one_leading_slash_keeps_interior() {
        assert_eq!(
            git_path_relative_component("info//sparse-checkout"),
            "info//sparse-checkout"
        );
        assert_eq!(git_path_relative_component("/info//grafts"), "info//grafts");
        assert_eq!(git_path_relative_component("HEAD"), "HEAD");
    }

    #[test]
    fn is_common_git_path_matches_git_common_list() {
        use crate::refs::store::paths;
        let common_cases = [
            paths::logs_refs_rel().to_owned(),
            format!("{}/", paths::logs_refs_rel()),
            paths::logs_refs_child("bisec/foo"),
            paths::logs_refs_child("bisec"),
            paths::logs_refs_child("bisectfoo"),
            "objects".to_owned(),
            "objects/bar".to_owned(),
            "info/exclude".to_owned(),
            "info/grafts".to_owned(),
            "remotes/bar".to_owned(),
            "branches/bar".to_owned(),
            paths::LOGS_REFS_HEADS_MAIN.to_owned(),
            "refs/heads/main".to_owned(),
            "hooks/me".to_owned(),
            "config".to_owned(),
            paths::packed_refs_rel().to_owned(),
            "shallow".to_owned(),
            "common".to_owned(),
            "common/file".to_owned(),
        ];
        // Common (resolved against the common dir) — t0060 cases.
        for p in &common_cases {
            assert!(is_common_git_path(p), "{p} should be common");
        }
        let worktree_cases = [
            "index".to_owned(),
            "index.lock".to_owned(),
            "HEAD".to_owned(),
            "logs/HEAD".to_owned(),
            "logs/HEAD.lock".to_owned(),
            paths::logs_refs_child("bisect/foo"),
            "info/sparse-checkout".to_owned(),
            "refs/bisect/foo".to_owned(),
        ];
        // Per-worktree (resolved against the git dir) — t0060 cases.
        for p in &worktree_cases {
            assert!(!is_common_git_path(p), "{p} should be worktree-local");
        }
    }

    #[test]
    fn strip_verbatim_extended_path_prefix() {
        assert_eq!(strip_verbatim_path_prefix_str(r"\\?\C:\tmp\p"), r"C:\tmp\p");
        assert_eq!(
            strip_verbatim_path_prefix_str(r"\\?\UNC\server\share\dir"),
            r"\\server\share\dir"
        );
        assert_eq!(strip_verbatim_path_prefix_str(r"C:\tmp\p"), r"C:\tmp\p");
    }

    #[test]
    fn simplify_verbatim_str_rewrites_only_round_tripping_paths() {
        let long_tail = "d".repeat(WIN32_MAX_PATH_UNITS - r"C:\".len());
        let too_long_tail = format!("{long_tail}x");
        let long_drive = format!(r"\\?\C:\{long_tail}");
        let too_long_drive = format!(r"\\?\C:\{too_long_tail}");
        let cases: &[(&str, Option<&str>)] = &[
            (r"\\?\C:\Users\me\proj", Some(r"C:\Users\me\proj")),
            (r"\\?\c:\proj\.git", Some(r"c:\proj\.git")),
            (r"\\?\C:\", Some(r"C:\")),
            (r"\\?\C:\a b\file.txt", Some(r"C:\a b\file.txt")),
            ("\\\\?\\C:\\caf\u{e9}\\x", Some("C:\\caf\u{e9}\\x")),
            (r"\\?\C:\console\nulled", Some(r"C:\console\nulled")),
            (r"\\?\C:\COM10\LPT0", Some(r"C:\COM10\LPT0")),
            (r"\\?\UNC\server\share\dir", Some(r"\\server\share\dir")),
            (r"\\?\UNC\server\share", Some(r"\\server\share")),
            (long_drive.as_str(), Some(&long_drive[4..])),
            (too_long_drive.as_str(), None),
            (r"\\?\C:\proj\dir.", None),
            (r"\\?\C:\proj\dir ", None),
            (r"\\?\C:\proj\.\x", None),
            (r"\\?\C:\proj\..\x", None),
            (r"\\?\C:\proj\\x", None),
            (r"\\?\C:\proj\a/b", None),
            (r"\\?\C:\proj\a:b", None),
            (r"\\?\C:\proj\a*b", None),
            (r"\\?\C:\proj\NUL", None),
            (r"\\?\C:\proj\nul.txt", None),
            (r"\\?\C:\proj\Com1", None),
            (r"\\?\C:\proj\lpt9.log", None),
            ("\\\\?\\C:\\proj\\COM\u{b9}", None),
            (r"\\?\C:\proj\CONOUT$", None),
            (r"\\?\C:", None),
            (r"\\?\C:proj", None),
            (r"\\?\1:\proj", None),
            (r"\\?\UNC\server", None),
            (r"\\?\UNC\\share", None),
            (r"\\?\UNC\server\share\x.", None),
            (
                r"\\?\Volume{0a1b2c3d-0000-0000-0000-100000000000}\dir",
                None,
            ),
            (r"\\.\C:\proj", None),
            (r"\\.\PhysicalDrive0", None),
            (r"\??\C:\proj", None),
            (r"C:\proj", None),
            (r"\\server\share", None),
            ("/home/me/proj", None),
        ];
        for (input, expected) in cases {
            assert_eq!(
                simplify_verbatim_str(input).as_deref(),
                *expected,
                "simplify {input:?}"
            );
        }
    }

    #[test]
    fn simplify_verbatim_path_keeps_non_windows_paths() {
        let unix = PathBuf::from("/home/me/proj");
        assert_eq!(simplify_verbatim_path(unix.clone()), unix);
        let verbatim = PathBuf::from(r"\\?\C:\proj");
        let expected = if cfg!(windows) {
            PathBuf::from(r"C:\proj")
        } else {
            verbatim.clone()
        };
        assert_eq!(simplify_verbatim_path(verbatim), expected);
    }

    #[test]
    fn canonicalize_simplified_matches_canonicalize_without_prefix() {
        let tmp = tempfile::tempdir().expect("tempdir");
        let dir = tmp.path().join("a").join("..").join("b");
        std::fs::create_dir_all(tmp.path().join("a")).expect("mkdir a");
        std::fs::create_dir_all(tmp.path().join("b")).expect("mkdir b");
        let simplified = dir.canonicalize_simplified().expect("canonicalize");
        let raw = std::fs::canonicalize(&dir).expect("canonicalize");
        assert_eq!(simplified, simplify_verbatim_path(raw));
        assert!(!simplified.to_string_lossy().starts_with(r"\\?\"));
        assert!(simplified.is_dir());
        assert!(Path::new("does-not-exist-here")
            .canonicalize_simplified()
            .is_err());
    }

    #[test]
    fn repository_paths_are_simplified_canonical_paths() {
        use crate::config::environment::RepositoryOptions;
        use crate::ref_storage::RefStorageFormat;
        use crate::repo::{init_repository, Repository};

        let tmp = tempfile::tempdir().expect("tempdir");
        let work = tmp.path().join("hw");
        init_repository(&work, false, "main", None, RefStorageFormat::Files).expect("init");
        std::fs::create_dir_all(work.join("sub")).expect("mkdir sub");
        let expected = work.canonicalize_simplified().expect("canonicalize");

        for start in [work.clone(), work.join("sub"), work.join("sub").join("..")] {
            let repo = Repository::discover(Some(start.as_path()), &RepositoryOptions::empty())
                .expect("discover");
            let wt = repo.work_tree().expect("work tree");
            assert!(!wt.to_string_lossy().starts_with(r"\\?\"), "{wt:?}");
            assert_eq!(wt, expected.as_path());
            assert_eq!(repo.git_dir(), expected.join(".git"));
            assert_eq!(repo.common_git_dir(), repo.git_dir());
            assert!(repo.git_dir().join("config").is_file());
            repo.config().expect("config through stored git dir");
        }

        let opened = Repository::open(
            &work.join(".git"),
            &RepositoryOptions::empty().with_work_tree(&work),
        )
        .expect("open");
        assert_eq!(opened.work_tree(), Some(expected.as_path()));
        assert_eq!(opened.git_dir(), expected.join(".git"));
    }

    #[test]
    fn separate_git_dir_gitfile_is_plain_absolute_path() {
        use crate::objects::HashAlgo;
        use crate::ref_storage::RefStorageFormat;
        use crate::repo::init_repository_separate_git_dir;

        let tmp = tempfile::tempdir().expect("tempdir");
        let work = tmp.path().join("wt");
        let git_dir = tmp.path().join("store.git");
        let repo = init_repository_separate_git_dir(
            &work,
            &git_dir,
            "main",
            None,
            RefStorageFormat::Files,
            HashAlgo::Sha1,
            &crate::environment::Environment::empty(),
        )
        .expect("init separate git dir");
        let gitfile = std::fs::read_to_string(work.join(".git")).expect("read gitfile");
        let stored = gitfile
            .strip_prefix("gitdir: ")
            .and_then(|rest| rest.strip_suffix('\n'))
            .expect("gitdir line");
        assert!(!stored.contains("?"), "{stored}");
        assert_eq!(stored, absolute_path_for_gitfile_stored_path(&git_dir));
        assert_eq!(
            repo.git_dir(),
            git_dir.canonicalize_simplified().expect("canonicalize")
        );

        let out = std::process::Command::new("git")
            .args(["rev-parse", "--absolute-git-dir"])
            .current_dir(&work)
            .env("GIT_CEILING_DIRECTORIES", tmp.path())
            .output();
        let Ok(out) = out else {
            return;
        };
        assert!(out.status.success(), "git rev-parse failed: {out:?}");
        let git_view = PathBuf::from(String::from_utf8_lossy(&out.stdout).trim());
        assert_eq!(
            git_view
                .canonicalize_simplified()
                .expect("canonicalize git view"),
            repo.git_dir()
        );
    }

    #[test]
    fn user_display_path_uses_forward_slashes() {
        assert_eq!(
            user_display_path(Path::new(r"\\?\C:\tmp\p\.git")),
            "C:/tmp/p/.git"
        );
    }

    #[test]
    fn path_for_error_message_strips_verbatim_prefix() {
        let msg = path_for_error_message(Path::new(r"\\?\C:\Users\tmp\r"));
        assert!(!msg.contains(r"\\?\"));
        assert_eq!(msg, "C:/Users/tmp/r");
    }

    #[test]
    fn absolute_path_for_gitfile_stored_path_strips_verbatim() {
        let tmp = tempfile::tempdir().expect("tempdir");
        let dir = tmp.path().join("linked");
        std::fs::create_dir_all(&dir).expect("mkdir");
        let stored = absolute_path_for_gitfile_stored_path(&dir);
        assert!(!stored.contains(r"\\?\"));
        assert!(!stored.contains("//?/"));
        #[cfg(windows)]
        {
            assert!(stored.contains('/'));
            assert_eq!(
                absolute_path_for_gitfile_stored_path(Path::new(r"\\?\C:\tmp\t\src\.git")),
                "C:/tmp/t/src/.git"
            );
        }
    }

    #[test]
    fn relative_path_for_display_above_and_below_cwd() {
        let tmp = tempfile::tempdir().expect("tempdir");
        let repo = tmp.path().join("repo");
        let deep = repo.join("d");
        std::fs::create_dir_all(&deep).expect("mkdir");
        std::fs::write(repo.join("a.txt"), b"root").expect("write");
        std::fs::write(deep.join("a.txt"), b"nested").expect("write");

        let cwd = deep.canonicalize_simplified().expect("canonicalize cwd");
        let above = repo
            .join("a.txt")
            .canonicalize_simplified()
            .expect("canonicalize above");
        let below = deep
            .join("a.txt")
            .canonicalize_simplified()
            .expect("canonicalize below");

        assert_eq!(
            relative_path_for_display(&cwd, &above).as_deref(),
            Some("../a.txt")
        );
        assert_eq!(
            relative_path_for_display(&cwd, &below).as_deref(),
            Some("a.txt")
        );
    }

    #[cfg(unix)]
    #[test]
    fn strip_worktree_prefix_preserves_symlink_spelling() {
        use std::os::unix::fs::symlink;

        let tmp = tempfile::tempdir().expect("tempdir");
        let repo = tmp.path().join("repo");
        std::fs::create_dir_all(repo.join("d")).expect("mkdir");
        let outside = tmp.path().join("outside");
        std::fs::create_dir_all(&outside).expect("mkdir outside");
        symlink(&outside, repo.join("d/link")).expect("symlink");
        assert_eq!(
            strip_worktree_prefix(&repo.join("d/link"), &repo).as_deref(),
            Some("d/link")
        );
    }

    #[test]
    fn strip_worktree_prefix_for_nested_file() {
        let tmp = tempfile::tempdir().expect("tempdir");
        let repo = tmp.path().join("repo");
        std::fs::create_dir_all(repo.join("d")).expect("mkdir");
        let file = repo.join("d/a.txt");
        std::fs::write(&file, b"x").expect("write");
        assert_eq!(
            strip_worktree_prefix(&file, &repo).as_deref(),
            Some("d/a.txt")
        );
    }

    #[cfg(target_os = "macos")]
    #[test]
    fn strip_worktree_prefix_macos_private_tmp_alias() {
        let tmp = tempfile::tempdir().expect("tempdir");
        let canon = tmp
            .path()
            .canonicalize_simplified()
            .expect("canonicalize tempdir");
        let public = if let Ok(stripped) = canon.strip_prefix("/private") {
            std::path::PathBuf::from("/").join(stripped)
        } else {
            canon.clone()
        };
        if public == canon {
            return;
        }
        std::fs::create_dir_all(public.join("nested")).expect("mkdir");
        let file_public = public.join("nested/file.txt");
        std::fs::write(&file_public, b"x").expect("write");
        assert_eq!(
            strip_worktree_prefix(&file_public, &canon).as_deref(),
            Some("nested/file.txt")
        );

        let missing_private = canon.join("nested/not-yet.txt");
        assert_eq!(
            strip_worktree_prefix(&missing_private, &canon).as_deref(),
            Some("nested/not-yet.txt")
        );
    }

    #[cfg(target_os = "macos")]
    #[test]
    fn relative_path_for_display_macos_private_tmp_alias() {
        let tmp = tempfile::tempdir().expect("tempdir");
        let repo_canon = tmp
            .path()
            .canonicalize_simplified()
            .expect("canonicalize tempdir");
        let repo_public = if let Ok(stripped) = repo_canon.strip_prefix("/private") {
            std::path::PathBuf::from("/").join(stripped)
        } else {
            repo_canon.clone()
        };
        if repo_public == repo_canon {
            return;
        }
        let sub = repo_public.join("sub");
        std::fs::create_dir_all(&sub).expect("mkdir sub");
        let file = sub.join("f.txt");
        std::fs::write(&file, b"x").expect("write");

        // cwd at public /tmp/.../sub, target under repo (private spelling in path buffer).
        let cwd = sub.clone();
        let target = repo_canon.join("sub/f.txt");
        assert_eq!(
            relative_path_for_display(&cwd, &target).as_deref(),
            Some("f.txt")
        );

        // Physical cwd after cd -P (private spelling).
        let cwd_private = sub.canonicalize_simplified().expect("canonicalize sub");
        assert_eq!(
            relative_path_for_display(&cwd_private, &target).as_deref(),
            Some("f.txt")
        );
    }

    #[test]
    fn relative_path_preserves_interior_double_slash_suffix() {
        // Mirrors `git rev-parse --git-path info//sparse-checkout`: the suffix
        // below the shared prefix is copied verbatim, double slash intact.
        let mut sb = String::new();
        let rel = relative_path("/repo/.git/info//sparse-checkout", "/repo", &mut sb);
        assert_eq!(rel, Some(".git/info//sparse-checkout"));
    }

    #[test]
    fn win32_storage_path_components_round_trip_ref_names() {
        let ok = win32_storage_path_components_round_trip;
        assert!(!ok("refs/heads/aux"));
        assert!(!ok("refs/heads/AUX"));
        assert!(!ok("refs/heads/com1"));
        assert!(!ok("refs/heads/COM1.txt"));
        assert!(!ok("refs/heads/foo/aux/bar"));
        assert!(!ok("refs/heads/foo./bar"));
        assert!(!ok("refs/heads/conin$"));
        assert!(ok("refs/heads/auxiliary"));
        assert!(ok("refs/heads/commit"));
        assert!(ok("HEAD"));
    }
}