Cómo grep (buscar) código comprometido en el historial de Git

He eliminado un archivo o algún código en un archivo en algún momento del pasado. ¿Puedo grep en el contenido (no en los mensajes de confirmación)?

Una solución muy pobre es grep el registro:

git log -p | grep <pattern>

Sin embargo, esto no devuelve el hash de confirmación de inmediato. He jugado un poco con git grepvano.

Para buscar contenido de confirmación (es decir, líneas de origen reales, en lugar de mensajes de confirmación y similares), debe hacer lo siguiente:

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

git rev-list --all | xargs git grep <expression> funcionará si te encuentras con un error "Lista de argumentos demasiado larga".

Si desea limitar la búsqueda a algún subárbol (por ejemplo, "lib / util"), deberá pasar eso al rev-listsubcomando y greptambién:

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

Esto buscará en todo su texto de confirmación regexp.

La razón para pasar la ruta en ambos comandos es porque rev-listdevolverá la lista de revisiones donde lib/utilocurrieron todos los cambios , pero también debe pasar para grepque solo busque lib/util.

Solo imagine el siguiente escenario: greppodría encontrar lo mismo <regexp>en otros archivos que están contenidos en la misma revisión devuelta por rev-list(incluso si no hubo cambios en ese archivo en esa revisión).

Aquí hay otras formas útiles de buscar su fuente:

Busque en el árbol de trabajo el texto que coincida con la expresión regular regexp:

git grep <regexp>

Busque en el árbol de trabajo líneas de texto que coincidan con la expresión regular regexp1 o regexp2:

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

Busque en el árbol de trabajo líneas de texto que coincidan con la expresión regular regexp1 y regexp2, informando solo las rutas de los archivos:

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

Busque en el árbol de trabajo archivos que tengan líneas de texto que coincidan con la expresión regular regexp1 y líneas de texto que coincidan con la expresión regular regexp2:

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

Busque en el árbol de trabajo líneas modificadas de patrones de coincidencia de texto

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

Busque en todas las revisiones el texto que coincida con la expresión regular regexp:

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

Busque en todas las revisiones entre rev1 y rev2 el texto que coincida con la expresión regular regexp:

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

Debe usar la opción pickaxe ( -S) de git log.

Para buscar Foo:

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

Vea el historial de Git: encuentre la línea perdida por palabra clave para obtener más información.

Como Jakub Narębski comentó:

• esto busca diferencias que introducen o eliminan una instancia de<string> . Por lo general, significa "revisiones donde agregó o eliminó la línea con 'Foo'".

• la --pickaxe-regexopción le permite usar expresiones regulares POSIX extendidas en lugar de buscar una cadena. Ejemplo (de git log):git log -S"frotz\(nitfol" --pickaxe-regex

Como comentó Rob , esta búsqueda distingue entre mayúsculas y minúsculas: abrió una pregunta de seguimiento sobre cómo buscar entre mayúsculas y minúsculas.

Mi forma favorita de hacerlo es con git logla -Gopción (agregada en la versión 1.7.4).

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

Hay una sutil diferencia entre la forma en que las opciones -Gy -Sdeterminan si una confirmación coincide:

• La -Sopción esencialmente cuenta el número de veces que su búsqueda coincide en un archivo antes y después de una confirmación. La confirmación se muestra en el registro si los conteos antes y después son diferentes. Esto, por ejemplo, no mostrará confirmaciones donde se movió una línea que coincide con su búsqueda.
• Con el -G opción, la confirmación se muestra en el registro si su búsqueda coincide con cualquier línea que se agregó, eliminó o modificó.

Tome este compromiso como un ejemplo:

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

Debido a que el número de veces que aparece "hola" en el archivo es el mismo antes y después de esta confirmación, no coincidirá con el uso -Shello. Sin embargo, dado que hubo un cambio en una coincidencia de línea hello, la confirmación se mostrará usando -Ghello.

Si desea examinar los cambios en el código (vea lo que realmente se ha cambiado con la palabra dada en todo el historial) vaya al patchmodo: encontré una combinación muy útil de hacer:

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 puede ser una forma más efectiva de buscar texto en todas las ramas, especialmente si hay muchas coincidencias y desea ver primero los cambios más recientes (relevantes).

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

Estos comandos de registro enumeran confirmaciones que agregan o eliminan la cadena de búsqueda / expresión regular dada (generalmente) más reciente primero. los-p opción hace que la diferencia relevante se muestre donde se agregó o eliminó el patrón, por lo que puede verlo en contexto.

Después de encontrar una confirmación relevante que agregue el texto que estaba buscando (por ejemplo, 8beeff00d), busque las ramas que contienen la confirmación:

git branch -a --contains 8beeff00d

Tomé la respuesta de Jeet y la adapté a Windows (gracias a esta respuesta ):

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

Tenga en cuenta que para mí, por alguna razón, la confirmación real que eliminó esta expresión regular no apareció en la salida del comando, sino que una confirmación anterior.

Buscar en cualquier revisión, cualquier archivo :

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

Buscar solo en algunos archivos, por ejemplo, archivos XML:

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

Las líneas de resultado deberían verse así: 6988bec26b1503d45eb0b2e8a4364afb87dde7af: bla.xml: texto de la línea que encontró ...

Luego puede obtener más información como autor, fecha y diferencia usando git show:

git show 6988bec26b1503d45eb0b2e8a4364afb87dde7af

Para simplificar, sugeriría usar GUI: gitk : el navegador de repositorios Git . Es bastante flexible

1. Para buscar el código:
   
   
2. Para buscar archivos:
   
   
3. Por supuesto, también admite expresiones regulares:
   
   

Y puede navegar por los resultados con las flechas arriba / abajo.

Para cualquier otra persona que intente hacer esto en Sourcetree , no hay un comando directo en la interfaz de usuario (a partir de la versión 1.6.21.0). Sin embargo, puede usar los comandos especificados en la respuesta aceptada abriendo Terminal ventana (botón disponible en la barra de herramientas principal) y copiándolos / pegándolos allí.

Nota: La vista de búsqueda de Sourcetree puede hacer búsquedas de texto en parte. Presione Ctrl+ 3para ir a la vista de Búsqueda (o haga clic en la pestaña Buscar disponible en la parte inferior). Desde el extremo derecho, configure el tipo de búsqueda en Cambios de archivo y luego escriba la cadena que desea buscar. Este método tiene las siguientes limitaciones en comparación con el comando anterior:

1. Sourcetree solo muestra los commits que contienen la palabra de búsqueda en uno de los archivos modificados. Encontrar el archivo exacto que contiene el texto de búsqueda es nuevamente una tarea manual.
2. RegEx no es compatible.

Cada vez que me encuentro en su lugar, uso la siguiente línea de comando:

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

Explicación:

1. git log- Necesito escribir más aquí; Muestra los registros en orden cronológico.
2. -S "<words/phrases i am trying to find>" - Muestra todas las confirmaciones de Git donde cualquier archivo (agregado / modificado / eliminado) tiene las palabras / frases que estoy tratando de encontrar sin los símbolos '<>'.
3. --all - Hacer cumplir y buscar en todas las ramas.
4. --oneline - Comprime el registro de Git en una línea.
5. --graph - Crea el gráfico de confirmaciones ordenadas cronológicamente.

La respuesta de Jeet funciona en PowerShell.

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

A continuación se muestran todos los archivos, en cualquier confirmación, que contengan a password.

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

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

Entonces, ¿estás tratando de buscar versiones anteriores del código para ver dónde existe algo por última vez?

Si estuviera haciendo esto, probablemente usaría git bisect . Con bisect, puede especificar una versión buena conocida, una versión mala conocida y un script simple que verifica si la versión es buena o mala (en este caso, un grep para ver si el código que está buscando está presente) ) Al ejecutar esto, se encontrará cuando se eliminó el código.

Escenario: realizó una gran limpieza de su código utilizando su IDE. Problema: el IDE limpió más de lo debido y ahora el código no se compila (faltan recursos, etc.)

Solución:

git grep --cached "text_to_find"

Encontrará el archivo donde se modificó "text_to_find".

Ahora puede deshacer este cambio y compilar su código.

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

es un ajuste a la solución de Jeet , por lo que muestra resultados mientras busca y no solo al final (lo que puede llevar mucho tiempo en un repositorio grande).

En mi caso, necesitaba buscar un commit corto y, por desgracia, las soluciones enumeradas no funcionaban.

Logré hacerlo con (reemplazar el 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