use crate::{DOT_GIT_DIR, MODULES};use std::ffi::OsStr;use std::path::Path;use std::{io::Read, path::PathBuf}; /// The kind of repository by looking exclusively at its `git_dir`.#[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]pub enum RepositoryKind {    /// The repository resides in `.git/modules/`.    Submodule,    /// The repository resides in `.git/worktrees/`.    LinkedWorktree,    /// The repository is in a `.git` directory.    Common,} ///pub mod from_gitdir_file {    /// The error returned by [`from_gitdir_file()`][crate::path::from_gitdir_file()].    #[derive(Debug, thiserror::Error)]    #[expect(missing_docs)]    pub enum Error {        #[error(transparent)]        Io(#[from] std::io::Error),        #[error(transparent)]        Parse(#[from] crate::parse::gitdir::Error),    }} fn read_regular_file_content_with_size_limit(path: &std::path::Path) -> std::io::Result<Vec<u8>> {    let mut file = std::fs::File::open(path)?;    let max_file_size = 1024 * 64; // NOTE: git allows 1MB here    let file_size = file.metadata()?.len();    if file_size > max_file_size {        return Err(std::io::Error::other(format!(            "Refusing to open files larger than {} bytes, '{}' was {} bytes large",            max_file_size,            path.display(),            file_size        )));    }    let mut buf = Vec::with_capacity(512);    file.read_to_end(&mut buf)?;    Ok(buf)} /// Read a plain path file, returning `None` if the file is missing.////// Linked-worktree `gitdir` files are plain path files in Git, not `gitdir:`/// files. Match Git's `get_linked_worktree()` behavior by trimming trailing/// whitespace before interpreting the content. Empty or whitespace-only path/// files are invalid.fn read_plain_file_content(path: &std::path::Path) -> Option<std::io::Result<Vec<u8>>> {    use bstr::ByteSlice;    let mut buf = match read_regular_file_content_with_size_limit(path) {        Ok(buf) => buf,        Err(err) if err.kind() == std::io::ErrorKind::NotFound => return None,        Err(err) => return Some(Err(err)),    };    let trimmed_len = buf.trim_end().len();    buf.truncate(trimmed_len);    if buf.is_empty() {        return Some(Err(std::io::Error::new(            std::io::ErrorKind::InvalidData,            format!("Refusing to read an empty path from '{}'", path.display()),        )));    }    Some(Ok(buf))} /// Guess the kind of repository by looking at its `git_dir` path and return it./// Return `None` if `git_dir` isn't called `.git` or isn't within `.git/worktrees` or `.git/modules`, or if it's/// a `.git` suffix like in `foo.git`./// The check for markers is case-sensitive under the assumption that nobody meddles with standard directories.////// As this considers only the path, it cannot recognize linked worktrees of repositories whose Git directory isn't/// named `.git`, such as natively bare repositories. Inspect the worktree's `commondir` file to identify those.pub fn repository_kind(git_dir: &Path) -> Option<RepositoryKind> {    if git_dir.file_name() == Some(OsStr::new(DOT_GIT_DIR)) {        return Some(RepositoryKind::Common);    }     let mut last_comp = None;    git_dir.components().rev().skip(1).any(|c| {        if c.as_os_str() == OsStr::new(DOT_GIT_DIR) {            true        } else {            last_comp = Some(c.as_os_str());            false        }    });    let last_comp = last_comp?;    if last_comp == OsStr::new(MODULES) {        RepositoryKind::Submodule.into()    } else if last_comp == OsStr::new("worktrees") {        RepositoryKind::LinkedWorktree.into()    } else {        None    }} /// Reads a plain path from a file that contains it as its only content, with trailing whitespace trimmed.////// Empty or whitespace-only path files are invalid.pub fn from_plain_file(path: &std::path::Path) -> Option<std::io::Result<PathBuf>> {    read_plain_file_content(path).map(|res| res.map(gix_path::from_bstring))} /// Reads a plain path from a file like [`from_plain_file()`], resolving relative paths against/// the file's containing directory as needed.////// The `path` argument is expected to name the path file itself, which is always supposed to be/// a file path.pub fn from_plain_file_relative_to_file(path: &std::path::Path) -> Option<std::io::Result<PathBuf>> {    read_plain_file_content(path).map(|res| {        res.and_then(|buf| {            let plain_path = gix_path::from_bstring(buf);            if !plain_path.is_relative() {                return Ok(plain_path);            }            match path.parent() {                Some(parent) => Ok(parent.join(plain_path)),                _ => Err(std::io::Error::other(format!(                    "'{path}' has no parent, but '{plain_path}' is relative. It's impossible",                    path = path.display(),                    plain_path = plain_path.display()                ))),            }        })    })} /// Reads typical `gitdir: ` files from disk as used by worktrees and submodules.pub fn from_gitdir_file(path: &std::path::Path) -> Result<PathBuf, from_gitdir_file::Error> {    let buf = read_regular_file_content_with_size_limit(path)?;    let mut gitdir = crate::parse::gitdir(&buf)?;    if let Some(parent) = path.parent() {        gitdir = parent.join(gitdir);    }    Ok(gitdir)} /// Conditionally pop a trailing `.git` dir if present.pub fn without_dot_git_dir(mut path: PathBuf) -> PathBuf {    if path.file_name().and_then(std::ffi::OsStr::to_str) == Some(DOT_GIT_DIR) {        path.pop();    }    path}