Controlla se la directory corrente è un repository Git

Sto scrivendo una serie di script per la gestione di Git in zsh.

Come posso verificare se la directory corrente è un repository Git? (Quando non sono in un repository Git, non voglio eseguire un gruppo di comandi e ottenere un sacco di fatal: Not a git repositoryrisposte).

Copiato dal file di completamento bash, il seguente è un modo ingenuo per farlo

# Copyright (C) 2006,2007 Shawn O. Pearce <spearce@spearce.org>
# Conceptually based on gitcompletion (http://gitweb.hawaga.org.uk/).
# Distributed under the GNU General Public License, version 2.0.

if [ -d .git ]; then
  echo .git;
else
  git rev-parse --git-dir 2> /dev/null;
fi;

Puoi racchiuderlo in una funzione o utilizzarlo in uno script.

Condensato in una condizione di una riga adatta per bash e zsh

[ -d .git ] && echo .git || git rev-parse --git-dir > /dev/null 2>&1

Puoi usare:

git rev-parse --is-inside-work-tree

Che stamperà 'vero' se ci si trova in un albero di lavoro di repository git.

Si noti che restituisce comunque l'output a STDERR se si è al di fuori di un repository git (e non si stampa 'false').

Tratto da questa risposta: https://stackoverflow.com/a/2044714/12983

Usa git rev-parse --git-dir

se git rev-parse --git-dir> / dev / null 2> & 1; poi
  : # Questo è un repository git valido (ma l'attuale funziona
    # directory potrebbe non essere il livello principale.
    # Controlla l'output del comando git rev-parse se ti interessa)
altro
  : # questo non è un repository git
fi

Oppure potresti farlo:

inside_git_repo="$(git rev-parse --is-inside-work-tree 2>/dev/null)"

if [ "$inside_git_repo" ]; then
  echo "inside git repo"
else
  echo "not in git repo"
fi

Non sono sicuro che ci sia un modo pubblicamente accessibile / documentato per farlo (ci sono alcune funzioni git interne che puoi usare / abusare nella fonte git stessa)

Potresti fare qualcosa del genere;

if ! git ls-files >& /dev/null; then
  echo "not in git"
fi

Basato sulla risposta di @Alex Cory :

[ "$(git rev-parse --is-inside-work-tree 2>/dev/null)" == "true" ]

non contiene operazioni ridondanti e funziona in -emodalità.

• Come notato da @ go2null , questo non funzionerà in un repository nudo. Se vuoi lavorare con un repository nudo per qualsiasi motivo, puoi semplicemente verificare la git rev-parseriuscita, ignorandone l'output.
  • Non lo considero uno svantaggio perché la riga sopra è destinata allo scripting e praticamente tutti i gitcomandi sono validi solo all'interno di un worktree. Quindi, ai fini dello scripting, molto probabilmente sei interessato a non essere solo all'interno di un "repository git" ma all'interno di un campo di lavoro.

Un'altra soluzione è verificare il codice di uscita del comando.

git rev-parse 2> /dev/null; [ $? == 0 ] && echo 1

Questo stamperà 1 se ti trovi in ​​una cartella del repository git.

Questa risposta fornisce una funzione shell POSIX di esempio e un esempio di utilizzo per integrare la risposta di @ jabbie .

is_inside_git_repo() {
    git rev-parse --is-inside-work-tree >/dev/null 2>&1
}

gitrestituisce errorlevel 0se si trova all'interno di un repository git, altrimenti restituisce errorlevel 128. (Restituisce anche trueo falsese si trova all'interno di un repository git.)

Esempio di utilizzo

for repo in *; do
    # skip files
    [ -d "$repo" ] || continue
    # run commands in subshell so each loop starts in the current dir
    (
        cd "$repo"
        # skip plain directories
        is_inside_git_repo || continue
        printf '== %s ==\n' "$repo"
        git remote update --prune 'origin' # example command
        # other commands here
    )
done

questo funziona per me. Ricevi ancora errori ma sono abbastanza facili da eliminare. funziona anche all'interno delle sottocartelle!

git status> / dev / null 2> & 1 && echo Ciao mondo!

Puoi inserirlo in un'istruzione if then se devi fare condizionalmente di più.

Perché non usare i codici di uscita? Se un repository git esiste nella directory corrente, quindi git branche git tagcomandi di ritorno codice di uscita 0; in caso contrario, verrà restituito un codice di uscita diverso da zero. In questo modo, puoi determinare se esiste o no un repository git. Semplicemente, puoi eseguire:

git tag > /dev/null 2>&1 && [ $? -eq 0 ]

Vantaggio : Flexibe. Funziona sia per i repository nudi che per quelli non nudi, e in sh, zsh e bash.

Spiegazione

1. git tag: Ottenere tag del repository per determinare se esiste o no.
2. > /dev/null 2>&1: Impedisce di stampare qualsiasi cosa, inclusi output normali ed errori.
3. [ $? -eq 0 ]: Controlla se il comando precedente ha restituito o meno il codice di uscita 0. Come forse saprai, ogni uscita diversa da zero significa che è successo qualcosa di brutto. $?ottiene il codice di uscita del comando precedente, e [, -eqe ]eseguire il confronto.

Ad esempio, è possibile creare un file denominato check-git-repocon i seguenti contenuti, renderlo eseguibile ed eseguirlo:

#!/bin/sh

if git tag > /dev/null 2>&1 && [ $? -eq 0 ]; then
    echo "Repository exists!";
else
    echo "No repository here.";
fi

# controlla se git repo

if [ $(git rev-parse --is-inside-work-tree) = true ]; then
    echo "yes, is a git repo"
    git pull
else
    echo "no, is not a git repo"
    git clone url --depth 1
fi

if ! [[ $(pwd) = *.git/* || $(pwd) = *.git ]]; then 
  if type -P git >/dev/null; then
    ! git rev-parse --is-inside-work-tree >/dev/null 2>&1 || {
     printf '\n%s\n\n' "GIT repository detected." && git status
    }
  fi
fi

Grazie ivan_pozdeev , ora ho un test se all'interno della directory .git il codice non verrà eseguito, quindi nessun errore stampato o stato di uscita falso.

" ! [[$ (Pwd) = .git / || $ (pwd) = * .git]] " verifica se non sei all'interno di un repository .git, quindi eseguirà il comando git. Il comando di tipo incorporato viene utilizzato per verificare se git è installato o è all'interno del PERCORSO. vedi tipo di aiuto

A proposito di questo:

if git status -s 2>/dev/null;then
    echo "this is a git repo"
else
    echo "this is NOT a git repo"
fi

Puoi aggiungere o sostituire $ PS1 in zshrc con uno o l' altro strumento git-prompt. In questo modo puoi essere facilmente informato se sei in un repository git e lo stato del repository è dentro.

! git rev-parse --is-inside-work-tree >/dev/null 2>&1 || { 
  printf '%s\n\n' "GIT repository detected." && git status
}

Il ! nega quindi anche se lo esegui in una directory che non è un repository git non ti darà alcuni errori fatali

Il > / dev / null 2> & 1 invia i messaggi a / dev / null visto che sei appena dopo lo stato di uscita. Il {} sono per gruppi di comando in modo che tutti i comandi dopo il || verrà eseguito se git rev-parse è riuscito poiché usiamo un! che ha negato lo stato di uscita di git rev-parse. Il printf è solo per stampare qualche messaggio e git stato per stampare lo stato del pronti contro termine.

Avvolgilo in una funzione o mettilo in uno script. Spero che questo ti aiuti