Existe uma maneira de obter o diretório raiz do git em um comando?

O Mercurial tem uma maneira de imprimir o diretório raiz (que contém .hg) via

hg root

Existe algo equivalente no git para obter o diretório que contém o diretório .git?

Sim:

git rev-parse --show-toplevel

Se você deseja replicar o comando Git mais diretamente, é possível criar um alias :

git config --global alias.root 'rev-parse --show-toplevel'

e agora git rootfuncionará exatamente comohg root .

Nota : Em um submódulo, isso exibirá o diretório raiz do submódulo e não o repositório pai. Se você estiver usando Git> = 2.13 ou superior, existe uma maneira de os submódulos mostrarem o diretório raiz do superprojeto. Se o seu git for mais antigo que isso, veja esta outra resposta.

A manpágina para git-config(em Alias ) diz:

Se a expansão do alias for prefixada com um ponto de exclamação, será tratada como um comando shell. [...] Observe que os comandos do shell serão executados no diretório de nível superior de um repositório, que pode não ser necessariamente o diretório atual.

Portanto, no UNIX, você pode:

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

Foi --show-topleveladicionado recentemente git rev-parseou por que ninguém menciona isso?

Na git rev-parsepágina do manual:

   --show-toplevel
       Show the absolute path of the top-level directory.

Que tal " git rev-parse --git-dir"?

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

o --git-dir opção parece funcionar.

Na página de manual do git rev-parse :

--git-dir

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

Você pode vê-lo em ação neste git setup-shscript .

Se você estiver em uma pasta de submódulo, com Git> = 2.13 , use :

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

Se você estiver usando git rev-parse --show-toplevel, verifique se está com o Git 2.25+ (primeiro trimestre de 2020) .

Para escrever uma resposta simples aqui, para que possamos usar

git root

para fazer o trabalho, basta configurar seu git usando

git config --global alias.root "rev-parse --show-toplevel"

e você pode adicionar o seguinte ao seu ~/.bashrc:

alias cdroot='cd $(git root)'

para que você possa usar apenas cdrootpara ir para o topo do seu repo.

Se você já está no nível superior ou não em um repositório git cd $(git rev-parse --show-cdup), você será levado para casa (apenas cd). cd ./$(git rev-parse --show-cdup)é uma maneira de consertar isso.

Para calcular o caminho absoluto do diretório raiz atual do git, digamos para uso em um script de shell, use esta combinação de readlink e git rev-parse:

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

git-rev-parse --show-cdupfornece o número certo de ".." s para obter a raiz do seu cwd ou a string vazia, se você estiver na raiz. Em seguida, acrescente "./" para lidar com a caixa de cordas vazia e use readlink -f para traduzir para um caminho completo.

Você também pode criar um git-rootcomando no seu PATH como um script de shell para aplicar esta técnica:

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

(O acima pode ser colado em um terminal para criar git-root e definir bits de execução; o script real está nas linhas 2, 3 e 4.)

E então você poderá executar git rootpara obter a raiz da sua árvore atual. Observe que, no script do shell, use "-e" para fazer com que o shell seja encerrado se a análise de revisão falhar, para que você possa obter corretamente o status de saída e a mensagem de erro se não estiver em um diretório git.

Como outros observaram, o núcleo da solução é usar git rev-parse --show-cdup. No entanto, existem alguns casos extremos a serem abordados:

1. Quando o cwd já é a raiz da árvore de trabalho, o comando gera uma sequência vazia.
   _{Na verdade, ele produz uma linha vazia, mas a substituição de comando retira a quebra de linha à direita. O resultado final é uma sequência vazia.}

   A maioria das respostas sugere anexar a saída de ./forma que uma saída vazia se torne "./"antes de ser alimentada cd.

2. Quando GIT_WORK_TREE é definido como um local que não é o pai do cwd, a saída pode ser um nome de caminho absoluto.

   Anexar ./está errado nessa situação. Se a ./é anexado a um caminho absoluto, ele se torna um caminho relativo (e eles se referem apenas ao mesmo local se o cwd for o diretório raiz do sistema).

3. A saída pode conter espaço em branco.

   Isso realmente se aplica apenas no segundo caso, mas tem uma solução fácil: use aspas duplas em torno da substituição do comando (e qualquer uso subsequente do valor).

Como outras respostas observaram, podemos fazê-lo cd "./$(git rev-parse --show-cdup)", mas isso ocorre no segundo caso de aresta (e no terceiro caso de aresta se deixarmos de aspas duplas).

Muitos shells são tratados cd ""como não-op, portanto, para aqueles shells que poderíamos fazer cd "$(git rev-parse --show-cdup)"(as aspas duplas protegem a string vazia como argumento no primeiro caso de aresta e preservam espaço em branco no terceiro caso de aresta). POSIX diz que o resultado decd "" não é especificado, portanto, é melhor evitar fazer essa suposição.

Uma solução que funcione em todos os casos acima requer algum tipo de teste. Feito explicitamente, pode ser assim:

cdup="$(git rev-parse --show-cdup)" && test -n "$cdup" && cd "$cdup"

Não cdé feito o primeiro caso de borda.

Se for aceitável executar cd .para o primeiro caso de borda, o condicional poderá ser feito na expansão do parâmetro:

cdup="$(git rev-parse --show-cdup)" && cd "${cdup:-.}"

Caso você esteja alimentando esse caminho para o próprio Git, use :/

# this adds the whole working tree from any directory in the repo
git add :/

# and is equal to
git add $(git rev-parse --show-toplevel)

Soluções curtas que funcionam com submódulos, em ganchos e dentro do .git diretório

Aqui está a resposta curta que a maioria deseja:

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

Isso funcionará em qualquer lugar da árvore de trabalho do git (inclusive dentro do .gitdiretório), mas pressupõe que os diretórios do repositório sejam chamados .git(que é o padrão). Com os submódulos, isso irá para a raiz do repositório externo.

Se você deseja chegar à raiz do submódulo atual, use:

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

Para executar facilmente um comando em sua raiz do submódulo, [alias]em sua .gitconfig, adicione:

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

Isso permite que você faça facilmente coisas como git sh ag <string>

Solução robusta que suporta diretórios .gitou nomes diferentes ou externos $GIT_DIR.

Observe que $GIT_DIRpode apontar para algum lugar externo (e não ser chamado .git), daí a necessidade de uma verificação adicional.

Coloque isso no seu .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"
}

Executá-lo digitando git_root(depois de reiniciar o shell: exec bash)

Para alterar a resposta "git config" um pouco:

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

e limpe o caminho. Muito agradável.

Se você está procurando um bom alias para fazer isso e não exploda cdse não estiver em um dir git:

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

git-extras

adiciona $ git root
consulte https://github.com/tj/git-extras/blob/master/Commands.md#git-root

$ pwd
.../very-deep-from-root-directory
$ cd `git root`
$ git add . && git commit

Disponibilidade de git-extras

• homebrew (osx) / linuxbrew (linux) $ brew install git-extras
• repositórios debian / ubuntu ( https://packages.debian.org/sid/git-extras )$ apt-get install git-extras

Esse alias do shell funciona se você estiver em um subdiretório git ou no nível superior:

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

atualizado para usar a sintaxe moderna em vez de backticks:

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

alias git-root='cd \`git rev-parse --git-dir\`; cd ..'

Todo o resto falha em algum momento, quer ir para o diretório inicial ou apenas falhar miseravelmente. Esta é a maneira mais rápida e mais curta de voltar ao GIT_DIR.

Aqui está um script que eu escrevi que lida com os dois casos: 1) repositório com uma área de trabalho, 2) repositório vazio.

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

git-root (arquivo executável no seu caminho):

#!/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
)

Espero que isso seja útil.

$ git config alias.root '!pwd'
# then you have:
$ git root

Desde o Git 2.13.0 , ele suporta uma nova opção para mostrar o caminho do projeto raiz, que funciona mesmo quando usado dentro de um submódulo:

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

Aliases de shell pré-configurados em estruturas de shell

Se você usar uma estrutura de shell, talvez já exista um alias de shell disponível:

• $ grtem oh-my-zsh (68k) ( cd $(git rev-parse --show-toplevel || echo "."))
• $ git-rootno prezto (8,8k) (exibe o caminho para a raiz da árvore de trabalho)
• $ g.. zimfw (1k) (altera o diretório atual para o nível superior da árvore de trabalho.)

Eu queria expandir o excelente comentário de Daniel Brockman.

A definição git config --global alias.exec '!exec 'permite fazer coisas como git exec makeporque, como man git-configafirma:

Se a expansão do alias for prefixada com um ponto de exclamação, será tratada como um comando shell. [...] Observe que os comandos do shell serão executados no diretório de nível superior de um repositório, que pode não ser necessariamente o diretório atual.

Também é útil saber que esse $GIT_PREFIXserá o caminho para o diretório atual em relação ao diretório de nível superior de um repositório. Mas, sabendo que é apenas metade da batalha ™. A expansão de variáveis ​​do Shell torna bastante difícil de usar. Então, eu sugiro usar bash -cassim:

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

outros comandos incluem:

git exec pwd
git exec make

Caso alguém precise de uma maneira compatível com POSIX, sem a necessidade de gitexecutável:

git-root:

#$1: Path to child directory
git_root_recurse_parent() {
    # Check if cwd is a git root directory
    if [ -d .git/objects -a -d .git/refs -a -f .git/HEAD ] ; then
        pwd
        return 0
    fi

    # Check if recursion should end (typically if cwd is /)
    if [ "${1}" = "$(pwd)" ] ; then
        return 1
    fi

    # Check parent directory in the same way
    local cwd=$(pwd)
    cd ..
    git_root_recurse_parent "${cwd}"
}

git_root_recurse_parent

Se você deseja apenas a funcionalidade como parte de um script, remova o shebang e substitua a última git_root_recurse_parentlinha por:

git_root() {
    (git_root_recurse_parent)
}

Hoje tive que resolver isso sozinho. Resolvi em C # conforme eu precisava para um programa, mas acho que ele pode ser reescrito. Considere este domínio público.

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;

}