Come grep (ricerca) codice commesso nella cronologia di Git

Ho eliminato un file o un codice in un file qualche volta in passato. Posso grep nel contenuto (non nei messaggi di commit)?

Una soluzione molto scadente è grep il registro:

git log -p | grep <pattern>

Tuttavia, ciò non restituisce immediatamente l'hash di commit. Ho giocato con git grepinutilmente.

Per cercare contenuti di commit (ovvero, righe di origine effettive, anziché messaggi di commit e simili), devi fare:

git grep <regexp> $(git rev-list --all)

git rev-list --all | xargs git grep <expression> funzionerà se si verifica un errore "Elenco argomenti troppo lungo".

Se si desidera limitare la ricerca a qualche sottostruttura (ad esempio "lib / util"), sarà necessario passarla al rev-listsottocomando e grepanche:

git grep <regexp> $(git rev-list --all -- lib/util) -- lib/util

Questo verrà visualizzato in modo rapido attraverso tutto il testo di commit per regexp.

Il motivo del passaggio del percorso in entrambi i comandi è perché rev-listrestituirà l'elenco delle revisioni in cui sono lib/utilavvenute tutte le modifiche , ma è anche necessario passare in grepmodo che esegua solo la ricerca lib/util.

Immagina solo il seguente scenario: greppotrebbe trovare lo stesso <regexp>su altri file contenuti nella stessa revisione restituiti da rev-list(anche se su quella revisione non sono state apportate modifiche a quel file).

Ecco alcuni altri modi utili per cercare la tua fonte:

Cerca albero di lavoro per il testo corrispondente all'espressione regolare regexp:

git grep <regexp>

Cerca nella struttura di lavoro le righe di testo corrispondenti all'espressione regolare regexp1 o regexp2:

git grep -e <regexp1> [--or] -e <regexp2>

Cerca nella struttura di lavoro le righe di testo corrispondenti all'espressione regolare regexp1 e regexp2, riportando solo i percorsi dei file:

git grep -l -e <regexp1> --and -e <regexp2>

Cerca l'albero di lavoro per i file che hanno righe di testo corrispondenti all'espressione regolare regexp1 e righe di testo corrispondenti all'espressione regolare regexp2:

git grep -l --all-match -e <regexp1> -e <regexp2>

Cerca l'albero di lavoro per le righe modificate del modello di corrispondenza del testo:

git diff --unified=0 | grep <pattern>

Cerca in tutte le revisioni il testo corrispondente all'espressione regolare regexp:

git grep <regexp> $(git rev-list --all)

Cerca in tutte le revisioni tra rev1 e rev2 il testo corrispondente all'espressione regolare regexp:

git grep <regexp> $(git rev-list <rev1>..<rev2>)

Dovresti usare l' opzione piccone ( -S) di git log.

Per cercare Foo:

git log -SFoo -- path_containing_change
git log -SFoo --since=2009.1.1 --until=2010.1.1 -- path_containing_change

Vedi la cronologia di Git - trova la linea persa per parola chiave per ulteriori informazioni.

Come ha commentato Jakub Narębski :

• questo cerca le differenze che introducono o rimuovono un'istanza di<string> . Di solito significa "revisioni in cui hai aggiunto o rimosso la riga con 'Foo'".

• l' --pickaxe-regexopzione consente di utilizzare regex POSIX esteso invece di cercare una stringa. Esempio (da git log):git log -S"frotz\(nitfol" --pickaxe-regex

Come ha commentato Rob , questa ricerca fa distinzione tra maiuscole e minuscole: ha aperto una domanda di follow-up su come cercare senza distinzione tra maiuscole e minuscole.

Il mio modo preferito per farlo è con l git log' -Gopzione (aggiunta nella versione 1.7.4).

-G<regex>
       Look for differences whose added or removed line matches the given <regex>.

C'è una sottile differenza tra il modo in cui le opzioni -Ge -Sdeterminano se un commit corrisponde:

• L' -Sopzione conta essenzialmente il numero di volte in cui la ricerca corrisponde a un file prima e dopo un commit. Il commit viene visualizzato nel registro se i conteggi prima e dopo sono diversi. Ad esempio, questo non mostrerà i commit in cui è stata spostata una linea corrispondente alla tua ricerca.
• Con l' -Gopzione, il commit viene visualizzato nel registro se la ricerca corrisponde a una riga aggiunta, rimossa o modificata.

Prendi questo commit come esempio:

diff --git a/test b/test
index dddc242..60a8ba6 100644
--- a/test
+++ b/test
@@ -1 +1 @@
-hello hello
+hello goodbye hello

Poiché il numero di volte in cui "ciao" appare nel file è lo stesso prima e dopo questo commit, non corrisponderà all'utilizzo -Shello. Tuttavia, poiché è stata apportata una modifica a una corrispondenza di riga hello, il commit verrà mostrato utilizzando -Ghello.

Se vuoi sfogliare le modifiche al codice (vedi cosa è stato effettivamente cambiato con la parola data nell'intera cronologia) vai in patchmodalità - Ho trovato una combinazione molto utile di fare:

git log -p
# Hit '/' for search mode.
# Type in the word you are searching.
# If the first search is not relevant, hit 'n' for next (like in Vim ;) )

git log può essere un modo più efficace di cercare testo tra tutti i rami, specialmente se ci sono molte corrispondenze e si desidera prima vedere le modifiche (rilevanti) più recenti.

git log -p --all -S 'search string'
git log -p --all -G 'match regular expression'

L'elenco di questi comandi di log consente di aggiungere o rimuovere la stringa / regex di ricerca specificata, (generalmente) prima più recente. L' -popzione fa sì che il diff rilevante sia mostrato dove il pattern è stato aggiunto o rimosso, in modo da poterlo vedere nel contesto.

Dopo aver trovato un commit pertinente che aggiunge il testo che stavi cercando (ad esempio 8beeff00d), trova i rami che contengono il commit:

git branch -a --contains 8beeff00d

Ho preso la risposta di Jeet e l'ho adattata a Windows (grazie a questa risposta ):

FOR /F %x IN ('"git rev-list --all"') DO @git grep <regex> %x > out.txt

Si noti che per me, per qualche motivo, il commit effettivo che ha eliminato questa regex non è apparso nell'output del comando, ma piuttosto un commit prima di esso.

Cerca in qualsiasi revisione, qualsiasi file :

git rev-list --all | xargs git grep <regexp>

Cerca solo in alcuni file, ad esempio file XML:

git rev-list --all | xargs -I{} git grep <regexp> {} -- "*.xml"

Le righe dei risultati dovrebbero apparire così: 6988bec26b1503d45eb0b2e8a4364afb87dde7af: bla.xml: testo della riga trovata ...

È quindi possibile ottenere ulteriori informazioni come autore, data e diff utilizzando git show:

git show 6988bec26b1503d45eb0b2e8a4364afb87dde7af

Per semplicità, suggerirei di usare la GUI: gitk - Il browser del repository Git . È abbastanza flessibile

1. Per cercare il codice:
   
   
2. Per cercare i file:
   
   
3. Naturalmente, supporta anche le espressioni regolari:
   
   

E puoi navigare attraverso i risultati usando le frecce su / giù.

Per chiunque cerchi di farlo in Sourcetree , non esiste alcun comando diretto nell'interfaccia utente (a partire dalla versione 1.6.21.0). Tuttavia, è possibile utilizzare i comandi specificati nella risposta accettata aprendo la finestra Terminale (pulsante disponibile nella barra degli strumenti principale) e copiandoli / incollandoli.

Nota: la vista Ricerca di Sourcetree può eseguire parzialmente la ricerca di testo per te. Premi Ctrl+ 3per accedere alla vista Cerca (o fai clic sulla scheda Cerca disponibile in basso). Dall'estrema destra, imposta Tipo di ricerca su Modifiche file, quindi digita la stringa che desideri cercare. Questo metodo presenta le seguenti limitazioni rispetto al comando precedente:

1. Sourcetree mostra solo i commit che contengono la parola di ricerca in uno dei file modificati. Trovare il file esatto che contiene il testo di ricerca è di nuovo un'attività manuale.
2. RegEx non è supportato.

Ogni volta che mi trovo al tuo posto, utilizzo la seguente riga di comando:

git log -S "<words/phrases i am trying to find>" --all --oneline  --graph

Spiegazione:

1. git log- Devo scrivere di più qui; mostra i registri in ordine cronologico.
2. -S "<words/phrases i am trying to find>" - Mostra tutti quei commit Git in cui qualsiasi file (aggiunto / modificato / cancellato) ha le parole / frasi che sto cercando di trovare senza i simboli '<>'.
3. --all - Per imporre e cercare in tutti i rami.
4. --oneline - Comprime il registro Git in una riga.
5. --graph - Crea il grafico dei commit ordinati cronologicamente.

La risposta di Jeet funziona in PowerShell.

git grep -n <regex> $(git rev-list --all)

Di seguito vengono visualizzati tutti i file, in qualsiasi commit, che contengono un password.

# Store intermediate result
$result = git grep -n "password" $(git rev-list --all)

# Display unique file names
$result | select -unique { $_ -replace "(^.*?:)|(:.*)", "" }

Quindi stai provando a sfogliare le versioni precedenti del codice cercando di vedere dove esiste l'ultima cosa?

Se lo facessi, probabilmente userei git bisect . Usando bisect, puoi specificare una versione valida conosciuta, una versione non nota nota e un semplice script che controlla se la versione è buona o cattiva (in questo caso un grep per vedere se il codice che stai cercando è presente ). L'esecuzione di questo troverà quando il codice è stato rimosso.

Scenario: hai eseguito una ripulitura del codice utilizzando il tuo IDE. Problema: l'IDE ha ripulito più di quanto dovrebbe e ora il codice non viene compilato (risorse mancanti, ecc.)

Soluzione:

git grep --cached "text_to_find"

Troverà il file in cui è stato modificato "text_to_find".

Ora puoi annullare questa modifica e compilare il tuo codice.

git rev-list --all | xargs -n 5 git grep EXPRESSION

è una modifica della soluzione di Jeet , quindi mostra i risultati mentre cerca e non solo alla fine (che può richiedere molto tempo in un grande repository).

Nel mio caso avevo bisogno di cercare un breve commit e, purtroppo, le soluzioni elencate non funzionavano.

Sono riuscito a farlo con (sostituire il token REGEX ):

for commit in $(git rev-list --all --abbrev-commit)
do
    if [[ $commit =~ __REGEX__ ]]; then 
        git --no-pager show -s --format='%h %an - %s' $commit
    fi
done