feat: add DOT_GIT_DIR constant, containing the name ".git". (#331)

Author: Byron

git-discover/src/is.rs

@@ -1,23 +1,25 @@
+use crate::DOT_GIT_DIR;
 use std::{borrow::Cow, ffi::OsStr, path::Path};
 
 /// Returns true if the given `git_dir` seems to be a bare repository.
 ///
 /// Please note that repositories without an index generally _look_ bare, even though they might also be uninitialized.
 pub fn bare(git_dir_candidate: impl AsRef<Path>) -> bool {
     let git_dir = git_dir_candidate.as_ref();
-    !(git_dir.join("index").exists() || (git_dir.file_name() == Some(OsStr::new(".git")) && git_dir.is_file()))
+    !(git_dir.join("index").exists() || (git_dir.file_name() == Some(OsStr::new(DOT_GIT_DIR)) && git_dir.is_file()))
 }
 
 /// What constitutes a valid git repository, returning the guessed repository kind
 /// purely based on the presence of files. Note that the git-config ultimately decides what's bare.
 ///
-/// Returns the Kind of git directory that was passed, possibly alongside the supporting private worktree git dir
+/// Returns the `Kind` of git directory that was passed, possibly alongside the supporting private worktree git dir.
 ///
-/// Note that `.git` files are followed to a valid git directory, which then requires
+/// Note that `.git` files are followed to a valid git directory, which then requires…
+///
+///   * …a valid head
+///   * …an objects directory
+///   * …a refs directory
 ///
-/// * a valid head
-/// * an objects directory
-/// * a refs directory
 pub fn git(git_dir: impl AsRef<Path>) -> Result<crate::repository::Kind, crate::is_git::Error> {
     #[derive(Eq, PartialEq)]
     enum Kind {
@@ -52,13 +54,15 @@ pub fn git(git_dir: impl AsRef<Path>) -> Result<crate::repository::Kind, crate::
         }
         Err(crate::path::from_gitdir_file::Error::Io(err)) if is_directory(&err) => {
             let common_dir = git_dir.join("commondir");
-            match crate::path::from_plain_file(common_dir)
-                .and_then(Result::ok)
-                .and_then(|cd| {
-                    crate::path::from_plain_file(git_dir.join("gitdir"))
-                        .and_then(Result::ok)
-                        .map(|worktree_gitfile| (crate::path::without_dot_git_dir(worktree_gitfile), cd))
-                }) {
+            let worktree_and_common_dir =
+                crate::path::from_plain_file(common_dir)
+                    .and_then(Result::ok)
+                    .and_then(|cd| {
+                        crate::path::from_plain_file(git_dir.join("gitdir"))
+                            .and_then(Result::ok)
+                            .map(|worktree_gitfile| (crate::path::without_dot_git_dir(worktree_gitfile), cd))
+                    });
+            match worktree_and_common_dir {
                 Some((work_dir, common_dir)) => {
                     let common_dir = git_dir.join(common_dir);
                     (

git-discover/src/lib.rs

@@ -4,6 +4,9 @@
 #![forbid(unsafe_code, rust_2018_idioms)]
 #![deny(missing_docs)]
 
+/// The name of the `.git` directory.
+pub const DOT_GIT_DIR: &str = ".git";
+
 ///
 pub mod repository;
 

git-discover/src/path.rs

@@ -1,3 +1,4 @@
+use crate::DOT_GIT_DIR;
 use std::{io::Read, path::PathBuf};
 
 ///
@@ -60,7 +61,7 @@ pub fn from_gitdir_file(path: impl AsRef<std::path::Path>) -> Result<PathBuf, fr
 
 /// Conditionally pop a trailing `.git` dir if present.
 pub fn without_dot_git_dir(mut path: PathBuf) -> PathBuf {
-    if path.file_name().and_then(|n| n.to_str()) == Some(".git") {
+    if path.file_name().and_then(|n| n.to_str()) == Some(DOT_GIT_DIR) {
         path.pop();
     }
     path

git-discover/src/repository.rs

@@ -24,6 +24,7 @@ mod path {
     use crate::{
         path::without_dot_git_dir,
         repository::{Kind, Path},
+        DOT_GIT_DIR,
     };
 
     impl AsRef<std::path::Path> for Path {
@@ -84,7 +85,7 @@ mod path {
         pub fn into_repository_and_work_tree_directories(self) -> (PathBuf, Option<PathBuf>) {
             match self {
                 Path::LinkedWorkTree { work_dir, git_dir } => (git_dir, Some(work_dir)),
-                Path::WorkTree(working_tree) => (working_tree.join(".git"), Some(working_tree)),
+                Path::WorkTree(working_tree) => (working_tree.join(DOT_GIT_DIR), Some(working_tree)),
                 Path::Repository(repository) => (repository, None),
             }
         }

git-discover/src/upwards.rs

@@ -155,7 +155,7 @@ pub(crate) mod function {
     use git_sec::Trust;
 
     use super::{Error, Options};
-    use crate::is_git;
+    use crate::{is_git, DOT_GIT_DIR};
 
     /// Find the location of the git repository directly in `directory` or in any of its parent directories and provide
     /// an associated Trust level by looking at the git directory's ownership, and control discovery using `options`.
@@ -241,7 +241,7 @@ pub(crate) mod function {
 
             for append_dot_git in &[false, true] {
                 if *append_dot_git {
-                    cursor.push(".git");
+                    cursor.push(DOT_GIT_DIR);
                 }
                 if let Ok(kind) = is_git(&cursor) {
                     match filter_by_trust(&cursor)? {
@@ -302,7 +302,7 @@ pub(crate) mod function {
         }
 
         if let Some(cwd) = cwd {
-            debug_assert_eq!(cursor.file_name().and_then(|f| f.to_str()), Some(".git"));
+            debug_assert_eq!(cursor.file_name().and_then(|f| f.to_str()), Some(DOT_GIT_DIR));
             let parent = cursor.parent().expect(".git appended");
             cwd.strip_prefix(parent)
                 .ok()
@@ -312,7 +312,7 @@ pub(crate) mod function {
                     (relative_path_components * "..".len() < current_component_len).then(|| {
                         std::iter::repeat("..")
                             .take(relative_path_components)
-                            .chain(Some(".git"))
+                            .chain(Some(DOT_GIT_DIR))
                             .collect()
                     })
                 })