Mit Git nach einem schmutzigen Index oder nicht verfolgten Dateien suchen

Wie kann ich überprüfen, ob ich nicht festgeschriebene Änderungen in meinem Git-Repository habe:

1. Dem Index hinzugefügte, aber nicht festgeschriebene Änderungen
2. Nicht verfolgte Dateien

aus einem Skript?

git-status scheint mit git Version 1.6.4.2 immer Null zurückzugeben.

Großartiges Timing! Ich habe vor ein paar Tagen einen Blog-Beitrag darüber geschrieben, als ich herausfand, wie ich meiner Eingabeaufforderung Informationen zum Git-Status hinzufügen kann.

Folgendes mache ich:

1. Für schmutzigen Status:

   # Returns "*" if the current git branch is dirty.
   function evil_git_dirty {
     [[ $(git diff --shortstat 2> /dev/null | tail -n1) != "" ]] && echo "*"
   }

2. Für nicht verfolgte Dateien (Beachten Sie das --porcelainFlag, mit git statusdem Sie eine schöne analysierbare Ausgabe erhalten):

   # Returns the number of untracked files
   
   function evil_git_num_untracked_files {
     expr `git status --porcelain 2>/dev/null| grep "^??" | wc -l` 
   }

Obwohl dies git diff --shortstatbequemer ist, können Sie auch git status --porcelainschmutzige Dateien abrufen:

# Get number of files added to the index (but uncommitted)
expr $(git status --porcelain 2>/dev/null| grep "^M" | wc -l)

# Get number of files that are uncommitted and not added
expr $(git status --porcelain 2>/dev/null| grep "^ M" | wc -l)

# Get number of total uncommited files
expr $(git status --porcelain 2>/dev/null| egrep "^(M| M)" | wc -l)

Hinweis: 2>/dev/nullHiermit werden die Fehlermeldungen herausgefiltert, sodass Sie diese Befehle für Nicht-Git-Verzeichnisse verwenden können. (Sie werden einfach 0für die Anzahl der Dateien zurückkehren.)

Bearbeiten :

Hier sind die Beiträge:

Hinzufügen von Git-Statusinformationen zu Ihrer Terminal-Eingabeaufforderung

Verbesserte Git-fähige Shell-Eingabeaufforderung

Der Schlüssel zum zuverlässigen "Scripting" von Git liegt in der Verwendung der "Plumbing" -Befehle.

Die Entwickler achten beim Ändern der Installationsbefehle darauf, dass sie sehr stabile Schnittstellen bereitstellen (dh eine bestimmte Kombination aus Repository-Status, Standard, Befehlszeilenoptionen, Argumenten usw. erzeugt in allen Git-Versionen dieselbe Ausgabe, in denen der Befehl / Option existiert). Neue Ausgabevarianten in Installationsbefehlen können über neue Optionen eingeführt werden, dies kann jedoch keine Probleme für Programme mit sich bringen, die bereits für ältere Versionen geschrieben wurden (sie würden die neuen Optionen nicht verwenden, da sie nicht vorhanden waren (oder zumindest waren) nicht verwendet) zum Zeitpunkt der Erstellung des Skripts).

Leider sind die "alltäglichen" Git-Befehle die "Porzellan" -Befehle, so dass die meisten Git-Benutzer möglicherweise nicht mit den Installationsbefehlen vertraut sind. Die Unterscheidung zwischen Porzellan und Sanitärbefehl wird in der Haupt- Git-Manpage vorgenommen (siehe Unterabschnitte mit dem Titel Befehle auf hoher Ebene (Porzellan) und Befehle auf niedriger Ebene (Sanitär) .

Um sich über nicht genehmigte Änderungen zu informieren, müssen Sie wahrscheinlich git diff-index(Index (und möglicherweise verfolgte Teile des Arbeitsbaums) mit einem anderen Baum vergleichen (z. B. HEAD)), möglicherweise git diff-files(Arbeitsbaum mit Index vergleichen) und möglicherweise git ls-files( Listendateien ; z. B. Liste nicht verfolgt) , nicht signierte Dateien).

(Beachten Sie, dass in den folgenden Befehlen HEAD --anstelle von verwendet wird, HEADda sonst der Befehl fehlschlägt, wenn eine Datei mit dem Namen vorhanden ist HEAD.)

Verwenden Sie Folgendes, um zu überprüfen, ob ein Repository Änderungen vorgenommen hat (noch nicht festgeschrieben):

git diff-index --quiet --cached HEAD --

• Wenn es mit beendet 0wird, gab es keine Unterschiede ( 1bedeutet, dass es Unterschiede gab).

So überprüfen Sie, ob ein Arbeitsbaum Änderungen enthält, die bereitgestellt werden könnten:

git diff-files --quiet

• Der Exit-Code ist der gleiche wie für git diff-index( 0== keine Unterschiede; 1== Unterschiede).

So überprüfen Sie, ob sich die Kombination aus Index und nachverfolgten Dateien im Arbeitsbaum in Bezug auf Folgendes geändert hat HEAD:

git diff-index --quiet HEAD --

• Dies ist wie eine Kombination der beiden vorherigen. Ein Hauptunterschied besteht darin, dass immer noch "keine Unterschiede" gemeldet werden, wenn Sie eine abgestufte Änderung haben, die Sie im Arbeitsbaum "rückgängig gemacht" haben (zurück zu den Inhalten, die sich in befinden HEAD). In derselben Situation würden die beiden separaten Befehle Berichte über "vorhandene Unterschiede" zurückgeben.

Sie haben auch nicht verfolgte Dateien erwähnt. Sie meinen möglicherweise "nicht verfolgt und nicht signiert", oder Sie meinen einfach "nicht verfolgt" (einschließlich ignorierter Dateien). In jedem Fall git ls-filesist das Werkzeug für den Job:

Für "nicht verfolgt" (enthält ignorierte Dateien, falls vorhanden):

git ls-files --others

Für "nicht verfolgt und nicht signiert":

git ls-files --exclude-standard --others

Mein erster Gedanke ist, nur zu überprüfen, ob diese Befehle ausgegeben wurden:

test -z "$(git ls-files --others)"

• Wenn es mit beendet 0wird, gibt es keine nicht verfolgten Dateien. Wenn es mit beendet 1wird, gibt es nicht verfolgte Dateien.

Es besteht eine geringe Wahrscheinlichkeit, dass dadurch abnormale Exits git ls-filesin Berichte "Keine nicht verfolgten Dateien" übersetzt werden (beide führen zu Exits ungleich Null des obigen Befehls). Eine etwas robustere Version könnte folgendermaßen aussehen:

u="$(git ls-files --others)" && test -z "$u"

• Die Idee ist dieselbe wie beim vorherigen Befehl, ermöglicht jedoch die git ls-filesAusbreitung unerwarteter Fehler . In diesem Fall kann ein Exit ungleich Null bedeuten, dass nicht verfolgte Dateien vorhanden sind, oder dass ein Fehler aufgetreten ist. Wenn Sie stattdessen die Ergebnisse "Fehler" mit dem Ergebnis "Keine nicht verfolgten Dateien" kombinieren möchten, verwenden Sie test -n "$u"(wobei exit von 0"einige nicht verfolgte Dateien" bedeutet und ungleich Null Fehler oder "keine nicht verfolgten Dateien" bedeutet).

Eine andere Idee besteht darin --error-unmatch, einen Exit ungleich Null zu verursachen, wenn keine nicht verfolgten Dateien vorhanden sind. Dies birgt auch das Risiko, dass "keine nicht verfolgten Dateien" (Beenden 1) mit "Ein Fehler ist aufgetreten" (Beenden ungleich Null, aber wahrscheinlich 128) zusammengeführt werden. Die Überprüfung auf Exit-Codes von 0vs. 1vs. ungleich Null ist jedoch wahrscheinlich ziemlich robust:

git ls-files --others --error-unmatch . >/dev/null 2>&1; ec=$?
if test "$ec" = 0; then
    echo some untracked files
elif test "$ec" = 1; then
    echo no untracked files
else
    echo error from ls-files
fi

Jedes der oben genannten git ls-filesBeispiele kann verwendet werden, --exclude-standardwenn Sie nur nicht verfolgte und nicht signierte Dateien berücksichtigen möchten.

Angenommen, Sie sind auf Git 1.7.0 oder höher ...

Nachdem ich alle Antworten auf dieser Seite gelesen und einige Experimente durchgeführt habe, denke ich, dass die Methode, die die richtige Kombination aus Korrektheit und Kürze trifft, folgende ist:

test -n "$(git status --porcelain)"

Während Git eine Menge Nuancen zwischen dem zulässt, was verfolgt, ignoriert, nicht verfolgt, aber nicht signiert usw. ist, glaube ich, dass der typische Anwendungsfall für die Automatisierung von Build-Skripten besteht, bei denen Sie alles stoppen möchten, wenn Ihre Kaufabwicklung nicht sauber ist.

In diesem Fall ist es sinnvoll zu simulieren, was der Programmierer tun würde: git statusGeben Sie die Ausgabe ein und sehen Sie sie sich an. Wir möchten uns jedoch nicht darauf verlassen, dass bestimmte Wörter --porcelainangezeigt werden. Daher verwenden wir den in 1.7.0 eingeführten Modus. Wenn diese Option aktiviert ist, führt ein sauberes Verzeichnis zu keiner Ausgabe.

Dann prüfen wir test -n, ob eine Ausgabe vorhanden war oder nicht.

Dieser Befehl gibt 1 zurück, wenn das Arbeitsverzeichnis sauber ist, und 0, wenn Änderungen festgeschrieben werden müssen. Sie können das -nin a ändern , -zwenn Sie das Gegenteil wollen. Dies ist nützlich, um dies mit einem Befehl in einem Skript zu verketten. Beispielsweise:

test -z "$(git status --porcelain)" || red-alert "UNCLEAN UNCLEAN"

Dies besagt effektiv: "Entweder müssen keine Änderungen vorgenommen werden oder es wird ein Alarm ausgelöst." Je nach dem Skript, das Sie schreiben, ist dieser Einzeiler möglicherweise einer if-Anweisung vorzuziehen.

Eine Implementierung aus VonCs Antwort:

if [[ -n $(git status --porcelain) ]]; then echo "repo is dirty"; fi

Ich habe ein paar dieser Antworten durchgesehen ... (und hatte verschiedene Probleme mit * nix und Windows, was eine Anforderung war, die ich hatte) ... fand, dass das Folgende gut funktioniert hat ...

git diff --no-ext-diff --quiet --exit-code

So überprüfen Sie den Exit-Code in * nix

echo $?   
#returns 1 if the repo has changes (0 if clean)

So überprüfen Sie den Exit-Code im Fenster $

echo %errorlevel% 
#returns 1 if the repos has changes (0 if clean) 

Der von https://github.com/sindresorhus/pure/issues/115 Dank @paulirish an diesem Beitrag für die gemeinsame Nutzung

Warum nicht git statusmit einem Skript einkapseln, das:

• analysiert die Ausgabe dieses Befehls
• gibt den entsprechenden Fehlercode basierend auf Ihren Anforderungen zurück

Auf diese Weise können Sie diesen erweiterten Status in Ihrem Skript verwenden.

Wie 0xfe in seiner hervorragenden Antwort erwähnt , git status --porcelainist es für jede skriptbasierte Lösung von entscheidender Bedeutung

--porcelain

Geben Sie die Ausgabe in einem stabilen, einfach zu analysierenden Format für Skripte an.
Derzeit ist dies identisch mit --short output, wird sich aber in Zukunft garantiert nicht ändern, sodass es für Skripte sicher ist.

Eine DIY-Möglichkeit, die aktualisiert wurde, um dem Vorschlag von 0xfe zu folgen

#!/bin/sh
exit $(git status --porcelain | wc -l) 

Wie von Chris Johnsen bemerkt , funktioniert dies nur auf Git 1.7.0 oder neuer.

Ich brauchte ziemlich oft einen einfachen Weg, um einen Build fehlzuschlagen, wenn am Ende der Ausführung modifizierte oder nicht verfolgte Dateien vorhanden sind, die nicht ignoriert werden.

Dies ist sehr wichtig, um zu vermeiden, dass Builds Reste produzieren.

Bisher sieht der beste Befehl, den ich letztendlich verwendet habe, so aus:

 test -z "$(git status --porcelain | tee /dev/fd/2)" || \
     {{ echo "ERROR: git unclean at the end, failing build." && return 1 }}

Es mag etwas komplex aussehen und ich würde mich freuen, wenn jemand eine kurzgeschlossene Variante findet, die das gewünschte Verhalten beibehält:

• Keine Ausgabe und erfolgreicher Exit-Code, wenn alles in Ordnung ist
• Beenden Sie Code 1, wenn dies fehlschlägt
• Fehlermeldung auf stderr, die erklärt, warum es fehlschlägt
• Liste der Dateien anzeigen, die den Fehler verursacht haben, stderr erneut.

@ eduard-wirch Antwort war ziemlich vollständig, aber da ich beide gleichzeitig überprüfen wollte, ist hier meine endgültige Variante.

        set -eu

        u="$(git ls-files --others)"
        if ! git diff-index --name-only --quiet HEAD -- || [ -z "${u:-}" ]; then
            dirty="-dirty"
        fi

Wenn die Ausführung nicht mit set -e oder einem gleichwertigen Element ausgeführt wird, können wir stattdessen eine ausführen u="$(git ls-files --others)" || exit 1(oder zurückkehren, wenn dies für eine verwendete Funktion funktioniert).

Untracked_files wird also nur gesetzt, wenn der Befehl ordnungsgemäß erfolgreich ist.

Danach können wir nach beiden Eigenschaften suchen und eine Variable (oder was auch immer) festlegen.

Dies ist eine Shell-freundlichere Variante, um herauszufinden, ob nicht verfolgte Dateien im Repository vorhanden sind:

# Works in bash and zsh
if [[ "$(git status --porcelain 2>/dev/null)" = *\?\?* ]]; then
  echo untracked files
fi

Dies führt nicht zu einem zweiten Prozess grepund erfordert keine Überprüfung, ob Sie sich in einem Git-Repository befinden oder nicht. Das ist praktisch für Shell-Eingabeaufforderungen usw.

Sie können auch tun

git describe --dirty

. Am Ende wird das Wort "-dirty" angehängt, wenn ein schmutziger Arbeitsbaum erkannt wird. Nach git-describe(1):

   --dirty[=<mark>]
       Describe the working tree. It means describe HEAD and appends <mark> (-dirty by default) if
       the working tree is dirty.

. Vorsichtsmaßnahme: Nicht verfolgte Dateien gelten nicht als "schmutzig", da sie sich, wie in der Manpage angegeben, nur um den Arbeitsbaum kümmern.

Es kann eine bessere Kombination von Antworten aus diesem Thread sein .. aber das funktioniert für mich ... für .gitconfig‚s [alias]Abschnitt ...

          # git untracked && echo "There are untracked files!"
untracked = ! git status --porcelain 2>/dev/null | grep -q "^??"
          # git unclean && echo "There are uncommited changes!"
  unclean = ! ! git diff --quiet --ignore-submodules HEAD > /dev/null 2>&1
          # git dirty && echo "There are uncommitted changes OR untracked files!"
    dirty = ! git untracked || git unclean

Der einfachste automatische Test, den ich verwende, um einen verschmutzten Zustand zu erkennen = alle Änderungen, einschließlich nicht verfolgter Dateien :

git add --all
git diff-index --exit-code HEAD

HINWEIS:

• Ohne add --all diff-index bemerkt nicht verfolgte Dateien nicht.
• Normalerweise laufe ich git resetnach dem Testen des Fehlercodes, um alles wieder zu entfernen.

Hier ist der beste und sauberste Weg. Die ausgewählte Antwort hat aus irgendeinem Grund bei mir nicht funktioniert. Sie hat keine Änderungen erfasst, bei denen es sich um neue Dateien handelt, die nicht festgeschrieben wurden.

function git_dirty {
    text=$(git status)
    changed_text="Changes to be committed"
    untracked_files="Untracked files"

    dirty=false

    if [[ ${text} = *"$changed_text"* ]];then
        dirty=true
    fi

    if [[ ${text} = *"$untracked_files"* ]];then
        dirty=true
    fi

    echo $dirty
}