pretty - git ver archivos modificados

Cómo invertir `git log--grep=<patrón>` o cómo mostrar registros de git que no coinciden con un patrón

Question

Quiero usar git log para mostrar todas las confirmaciones que no coinciden con un patrón dado. Sé que puedo usar lo siguiente para mostrar todas las confirmaciones que coinciden con un patrón:

git log --grep=<pattern>

¿Cómo invierto el sentido de coincidencia?

Estoy tratando de ignorar los commits que han "topado con la versión ..." en el mensaje.

EDITAR: Quiero que mi resultado final sea bastante detallado. por ejemplo, git log --pretty --stat . Por lo tanto, la salida de git log --format=oneline no funcionará para mí.

Answer 1

Al igual que con la respuesta de labriguy, grep también tiene una opción -z para permitir que funcione con cadenas terminadas nulas en lugar de líneas. Esto sería tan simple como invertir el partido:

git log -z --color | grep -vz "bumped to version"

Por seguridad, es posible que desee coincidir solo con el mensaje de confirmación. Para hacer esto con grep, necesita usar expresiones perladas para unir las nuevas líneas dentro de las cadenas terminadas nulas. Para saltear el encabezado:

git log -z | grep -Pvz ''^commit.*/nAuthor:.*/nDate:.*/n[/S/s]*bumped to version''

O con color:

git log -z --color | /
grep -Pvz ''^.....commit.*/nAuthor:.*/nDate:.*/n[/S/s]*bumped to version''

Finalmente, si usa --stat, también puede hacer coincidir el comienzo de esta salida para evitar la coincidencia de los nombres de archivo que contienen la cadena de confirmación. Entonces una respuesta completa a la pregunta sería como:

log -z --color --pretty --stat | /
grep -Pvz ''^.....commit.*/nAuthor:.*/nDate:.*/n[/S/s]*?bumped to version[/S/s]*?/n [^ ]''

Tenga en cuenta que grep -P se describe como ''altamente experimental'' en mi página man. Puede ser mejor utilizar pcregrep que usa libpcre, ver ¿Cómo se da un patrón para una nueva línea en grep? . Aunque grep -P funciona bien para mí y no tengo idea si pcregrep tiene una opción -z o equivalente.

Answer 2

Como lo mencionó VonC, la mejor opción es si puede actualizar a Git 2.4.0 (que se encuentra actualmente en RC2). Pero incluso si no puede hacer eso, no hay razón para elaborar scripts. A (gnu) awk one-liner debería hacerlo. git log tiene la opción -z útil para separar commits por un carácter NUL que hace que sea fácil analizarlos:

git log -z --pretty --stat | awk ''BEGIN{ RS="/0"; FS="/n/n" } !match($2, /<pattern>/)''

Si no tiene gnu awk, probablemente debería al menos instalarlo. O transfiera este script a su versión específica de awk, que dejo como ejercicio para el lector ;-).

Answer 3

Esto será posible con github.com/git/git/blob/… : vea commit 22dfa8a por Christoph Junghans ( junghans ) :

log : teach --invert-grep opción

" git log --grep=<string> " muestra solo commits con mensajes que coinciden con la cadena dada, pero a veces es útil poder mostrar solo commits que no tienen ciertos mensajes (por ejemplo, "muéstrame los que no son FIXUP") se compromete ").

Originalmente, teníamos el indicador invert-grep en grep_opt , pero porque " git grep --invert-grep " no tiene sentido, excepto en conjunción con " --files-with-matches ", que ya está cubierto por " --files-without-matches ", se movió a la estructura de revisiones.
Tener la bandera allí expresa mejor la función de la función.

Cuando se ejecutan las dos pruebas recientemente insertadas, el historial se confirma con los mensajes " initial ", " second ", " third ", " fourth ", " fifth ", " sixth " y " Second ", cometidos en este orden.
La confirmación que no concuerda con " th " o " Sec " es " second " e " initial ". Para el caso insensible a mayúsculas solo coincide " initial ".

--invert-grep

Limite la salida de confirmaciones a aquellas con un mensaje de registro que no coincida con el patrón especificado con --grep=<pattern> .

Ejemplo:

Primero grep el mensaje con "secuenciador" en ellos:

vonc@voncm C:/Users/vonc/prog/git/git
> git log -2 --pretty="tformat:%s" --grep=sequencer
Merge branch ''js/sequencer-wo-die''
sequencer: ensure to release the lock when we could not read the index

Si quiero mensajes sin secuenciador:

> git log -2 --pretty="tformat:%s" --grep=sequencer --invert-grep
Second batch for 2.11
Merge branch ''js/git-gui-commit-gpgsign''

Answer 4

Genere una lista de todas las confirmaciones, reste aquellas cuyos mensajes de registro contienen el patrón ofensivo y envíe el resultado al git log con sus opciones deseadas. En la etapa final, un par de opciones para git log son útiles:

--stdin
Además del compromiso enumerado en la línea de comando, léelos de la entrada estándar.

--no-walk
Solo muestre las revoluciones dadas, pero no atraviese sus antepasados.

Puede hacerlo con una sola tubería y sustitución de proceso.

#! /bin/bash
if (( $# < 1 )); then
echo >&2 "Usage: $0 pattern [<since>..<until>]"
exit 1
fi
pattern=$1
shift
git log --format=%H $@ |
grep -v -f <(git log --format=%H "--grep=$pattern" $@) |
git log --pretty --stat --stdin --no-walk

Si no quieres usar bash, puedes hacerlo con Perl.

#! /usr/bin/env perl
use strict;
use warnings;
no warnings "exec";
sub usage { "Usage: $0 pattern/n" }
sub commits_to_omit {
my($pattern) = @_;
open my $fh, "-|", "git", "log", "--grep=$pattern", "--format=%H", @ARGV
or die "$0: exec: $!";
my %omit = map +($_ => 1), <$fh>;
%omit;
}
die usage unless @ARGV >= 1;
my $pattern = shift;
my %omit = commits_to_omit $pattern;
open my $all, "-|", "git", "log", "--format=%H", @ARGV
or die "$0: exec: $!";
open my $out, "|-", "git", "log", "--pretty", "--stat", "--stdin", "--no-walk"
or die "$0: exec: $!";
while (<$all>) {
print $out $_ unless $omit{$_};
}

Asumiendo que uno de los anteriores está en tu RUTA como git-log-vgrep y con un historial de la forma

$ git lola * b0f2a28 (tmp, feature1) D * 68f87b0 C * d311c65 B * a092126 A | * 83052e6 (HEAD, origin/master, master) Z | * 90c3d28 Y | * 4165a42 X | * 37844cb W |/ * f8ba9ea V

podríamos decir

$ git log-vgrep X

para obtener Z, Y, W y V.

También puede registrar otras ramas, por lo

$ git log-vgrep A tmp

da D, C, B y V; y

$ git log-vgrep C tmp~2..tmp

cede solo D.

Una limitación de las implementaciones anteriores es si usa un patrón que coincida con todas las confirmaciones, por ejemplo,. o ^ , entonces obtendrás HEAD. Así es como funciona el git log :

$ git log --stdin --no-walk --pretty=oneline </dev/null 83052e62f0dc1c6ddfc1aff3463504a4bf23e3c4 Z

Answer 5

Hasta donde puedo decir, esto no es posible hacerlo directamente con una sola línea de comando; tendrías que hacer algo como sugiere Justin Lilly y luego ejecutar ''git log'' en la lista resultante de hash, por ejemplo,

git log --format="%h" | grep -v `git log -1 --grep="bumped to version" --format="%h"` > good-hashes
for h in `cat good-hashes`; do
PAGER=cat git log -1 --pretty --stat $h
done

debería hacer el truco.

Answer 6

Un método relativamente simple con mucha flexibilidad es usar git log con la opción -z canalizada a awk. La opción -z agrega nulos entre los registros de confirmación, por lo que facilita el análisis con awk:

git log --color=always -z | awk -v RS=//0

(color = siempre es necesario para mantener el color cuando la salida es una tubería). Entonces, es simple agregar cualquier expresión booleana que quiera que funcione en cada campo. Por ejemplo, esto imprimirá todas las entradas donde el correo electrónico del autor no es de fugly.com, y el día de la confirmación fue el domingo:

git log --color=always -z | awk -v RS=//0 ''!/Author:.*fugly.com>/ && /Date:.* Sun /''

Otra cosa agradable es que puedes agregar cualquier opción de formato o rango de revisión al registro de git, y aún funciona.

Una última cosa, si quieres paginarlo, usa "menos -r" para mantener los colores.

EDITAR: cambió para usar -v en awk para hacerlo un poco más simple.

Answer 7

obtener una lista de todas las confirmaciones que contengan su resultado, luego filtrar sus valores hash.

git log --format=oneline | grep -v `git log --grep="bumped to version" --format="%h"`

Answer 8

git log --pretty --stat | grep -v "bumped to version"