Est-il possible d'obtenir le git répertoire racine en une seule commande?

La man page pour git-config (sous Alias) dit:

Si l'expansion d'alias est précédé d'un point d'exclamation, il sera traité comme un shell
commande. [...] Il est à noter que shell
les commandes seront exécutées à partir du répertoire de niveau supérieur d'un référentiel, qui ne peut
nécessairement le répertoire courant.

Donc, sous UNIX, vous pouvez le faire:

git config --global --add alias.root '!pwd'

Comment à propos de "git rev-parse --git-dir" ?

F:\prog\git\test\copyMerge\dirWithConflicts>git rev-parse --git-dir
F:/prog/git/test/copyMerge/.git

La --git-dir option semble fonctionner.

De git rev-parse la page de manuel:

--git-dir

    Show $GIT_DIR if defined else show the path to the .git directory.

Vous pouvez le voir en action dans cette git d'installation-sh script.

Si vous êtes dans un sous-module dossier, avec Git >=2.13, l'utilisation:

git rev-parse --show-superproject-working-tree

Si vous utilisez git rev-parse --show-toplevel, assurez-vous qu'il est avec Git 2.25+ (T1 2020).

Si vous êtes déjà dans le premier niveau, ou pas dans un dépôt git cd $(git rev-parse --show-cdup) va vous ramener à la maison (juste le cd). cd ./$(git rev-parse --show-cdup) est un moyen de fixation de la.

Pour calculer le chemin absolu de l'actuel git répertoire racine, disons pour une utilisation dans un script shell, utilisez cette combinaison de readlink et git rev-parse:

gitroot=$(readlink -f ./$(git rev-parse --show-cdup))

git-rev-parse --show-cdup vous donne le bon nombre de ".."s
à la racine de votre cwd, ou la chaîne vide si vous êtes à la racine.
Puis ajouter le préfixe "./" pour faire face à la chaîne vide en cas et à l'utilisation
readlink -f à traduire à un chemin d'accès complet.

Vous pouvez également créer un git-root commande dans votre CHEMIN, comme un script shell pour appliquer cette technique:

cat > ~/bin/git-root << EOF
#!/bin/sh -e
cdup=$(git rev-parse --show-cdup)
exec readlink -f ./$cdup
EOF
chmod 755 ~/bin/git-root

(Ci-dessus peut être collé dans un terminal pour créer git-utilisateur root et exécuter bits; le script est dans les lignes 2, 3 et 4.)

Et alors vous seriez en mesure d'exécuter git root d'obtenir la racine de votre arborescence actuelle.
Notez que dans le script shell, utilisez l'option "-e" à cause de la coquille à la sortie si les rev-parse échoue, de sorte que vous pouvez bien obtenir le statut de sortie et le message d'erreur si vous n'êtes pas dans un répertoire git.

Court de solutions qui fonctionnent avec des submodules, des crochets, et à l'intérieur de la .git répertoire

Voici la réponse courte que la plupart se veulent:

r=$(git rev-parse --git-dir) && r=$(cd "$r" && pwd)/&& echo "${r%%/.git/*}"

Cela fonctionne n'importe où dans un git arbre de travail (y compris à l'intérieur de la .git répertoire), mais suppose que le répertoire de dépôt(s) sont appelés .git (qui est la valeur par défaut). Avec submodules, il ira à la racine de la ultrapériphériques contenant référentiel.

Si vous voulez obtenir à la racine de l'actuel sous-module utilisation:

echo $(r=$(git rev-parse --show-toplevel) && ([[ -n $r ]] && echo "$r" || (cd $(git rev-parse --git-dir)/.. && pwd) ))

Facilement exécuter une commande dans votre sous-module racine, en vertu de [alias] dans votre .gitconfig, ajouter:

sh = "!f() { root=$(pwd)/&& cd ${root%%/.git/*} && git rev-parse && exec \"$@\"; }; f"

Ceci vous permet de facilement faire des choses comme git sh ag <string>

Solution robuste qui prend en charge différemment nommé ou externe .git ou $GIT_DIR répertoires.

Noter que $GIT_DIR peut pointer quelque part externe (et non .git), d'où la nécessité de poursuivre la vérification.

Mettre ceci dans votre .bashrc:

# Print the name of the git working tree's root directory
function git_root() {
  local root first_commit
  # git displays its own error if not in a repository
  root=$(git rev-parse --show-toplevel) || return
  if [[ -n $root ]]; then
    echo $root
    return
  elif [[ $(git rev-parse --is-inside-git-dir) = true ]]; then
    # We're inside the .git directory
    # Store the commit id of the first commit to compare later
    # It's possible that $GIT_DIR points somewhere not inside the repo
    first_commit=$(git rev-list --parents HEAD | tail -1) ||
      echo "$0: Can't get initial commit" 2>&1 && false && return
    root=$(git rev-parse --git-dir)/.. &&
      # subshell so we don't change the user's working directory
    ( cd "$root" &&
      if [[ $(git rev-list --parents HEAD | tail -1) = $first_commit ]]; then
        pwd
      else
        echo "$FUNCNAME: git directory is not inside its repository" 2>&1
        false
      fi
    )
  else
    echo "$FUNCNAME: Can't determine repository root" 2>&1
    false
  fi
}

# Change working directory to git repository root
function cd_git_root() {
  local root
  root=$(git_root) || return 1  # git_root will print any errors
  cd "$root"
}

L'exécuter en tapant git_root (après le redémarrage de votre shell: exec bash)

Si vous êtes à la recherche d'un bon alias pour ce faire, en plus de ne pas sauter cd si vous n'êtes pas dans un git dir:

alias ..g='git rev-parse && cd "$(git rev-parse --show-cdup)"'

Cette coque alias fonctionne si vous êtes dans un git subdir, ou au niveau supérieur:

alias gr='[ ! -z `git rev-parse --show-toplevel` ] && cd `git rev-parse --show-toplevel || pwd`'

mis à jour pour utiliser la syntaxe moderne au lieu de backticks:

alias gr='[ ! -z $(git rev-parse --show-toplevel) ] && cd $(git rev-parse --show-toplevel || pwd)'

Voici un script que j'ai écrit qui gère les deux cas: 1) un référentiel avec un espace de travail, 2) dépôt nu.

https://gist.github.com/jdsumsion/6282953

git-root (fichier exécutable dans votre chemin d'accès):

#!/bin/bash
GIT_DIR=`git rev-parse --git-dir` &&
(
  if [ `basename $GIT_DIR` = ".git" ]; then
    # handle normal git repos (with a .git dir)
    cd $GIT_DIR/..
  else
    # handle bare git repos (the repo IS a xxx.git dir)
    cd $GIT_DIR
  fi
  pwd
)

J'espère que cela est utile.

Depuis Git 2.13.0, il soutient une nouvelle option permettant d'afficher le chemin de la racine du projet, qui fonctionne même quand être utilisé à partir de l'intérieur d'un sous-module:

git rev-parse --show-superproject-working-tree

Je voulais étendre sur Daniel Brockman est excellent commentaire.

Définition git config --global alias.exec '!exec ' vous permet de faire des choses comme git exec make parce que, comme man git-config états:

Si l'expansion d'alias est précédé d'un point d'exclamation, elle sera traitée comme une commande shell. [...] À noter que les commandes shell sera exécuté dans le répertoire de niveau supérieur d'un référentiel, qui n'est pas nécessairement le répertoire courant.

Il est également utile de savoir que $GIT_PREFIX sera le chemin vers le répertoire par rapport au répertoire de niveau supérieur d'un référentiel. Mais, sachant qu'il est seulement la moitié de la bataille™. Shell extension variable qui rend un peu difficile à utiliser. Donc, je vous suggère d'utiliser bash -c comme suit:

git exec bash -c 'ls -l $GIT_PREFIX'

autres commandes comprennent:

git exec pwd
git exec make

Eu à résoudre moi-même aujourd'hui. Résolu en C# que j'en avais besoin pour un programme, mais je pense que ça peut être esily réécrit. Considérer ce Domaine Public.

public static string GetGitRoot (string file_path) {

    file_path = System.IO.Path.GetDirectoryName (file_path);

    while (file_path != null) {

        if (Directory.Exists (System.IO.Path.Combine (file_path, ".git")))
            return file_path;

        file_path = Directory.GetParent (file_path).FullName;

    }

    return null;

}