files - git merge theirs

¿Cómo puedo resumir una combinación para detectar un `git merge-s ours` erróneo?

Question

Varias veces en el pasado, hemos tenido un problema en el que los desarrolladores (ya sea explícitamente o de manera efectiva) hicieron una git merge -s ours cuando no deberían, los compromisos se han perdido y solo hemos detectado esto mucho más tarde cuando se realiza la limpieza. Mucho más complejo y lento. Las pruebas no fallaron porque las mismas confirmaciones que agregaron las pruebas se revertieron silenciosamente junto con el código que estaban probando.

Lo que me gustaría hacer es encontrar o crear una herramienta que resuma una combinación, produciendo una salida similar a la siguiente con una combinación normal:

Lines              Left(2b3c4d) Right(3c4d5e)
Common with base   970          930
Unique wrt base    20            50
Unique wrt other   15            45
Unique wrt merge   15            45
Common with merge  995          985

Pero en el caso en el que se realizó una fusión incorrectamente, revertiendo muchos cambios, o donde se realizó una git merge -s ours , podría resultar en un informe algo como:

Lines              Left(2b3c4d) Right(3c4d5e)
Common with base   970          930
Unique wrt base    20            50
Unique wrt other   15            45
Unique wrt merge   15             0 !!
Common with merge  990          935
Warning: 100% of changes from 3c4d5e are missing from merge commit!

Si se ejecutara este informe para cada confirmación, podríamos marcar hacia arriba (a través de un trabajo de Jenkins) siempre que una fusión fuera un poco mal .

Hasta ahora he jugado con git diff --stat , git diff --name-status y git diff --summary pero hasta ahora ninguno me ha dado lo que quiero.

Lo mejor que puedo hacer hasta ahora resultaría en algo como lo siguiente para una fusión normal:

              base..left   base..right  left..merge  right..merge
              f67c4..a9eb4 f67c4..5b592 a9eb4..cb209 5b592..cb209
 a    |                    1 +          1 +          
 b    |       1 +                                    1 +
 base |       1 +          1 +          1 +          1 +
changed       2            2            2            2
insertions(+) 2            2            2            2
deletions(-)  0            0            0            0

y para una fusión ours :

              base..left   base..right  left..merge  right..merge
              f67c4..a9eb4 f67c4..5b592 a9eb4..95637 5b592..95637
 a    |                    1 +                       1 -
 b    |       1 +                                    1 +
 base |       1 +          1 +                       2 +-
changed       2            2            0            3
insertions(+) 2            2            0            2
deletions(-)  0            0            0            2

Tenga en cuenta que no solo quiero detectar una combinación -s ours , sino que también quiero detectar la situación en la que algunos cambios, pero no todos, se encuentran en la combinación resultante. Este es un caso más general de detección de fusiones erróneas que solo la comprobación de una causa específica de pérdida de cambios.

Además, esto solo parece ocurrir cuando hay conflictos en la combinación, por lo que cualquier método que requiera ejecutar la combinación de nuevo automáticamente también deberá resolver esos conflictos automáticamente.

Finalmente, me gustaría poder ejecutar esta utilidad de resumen en un repositorio sucio, sin guardar todos mis cambios primero, de ahí mis experimentos actuales con git diff .

Se agradecería cualquier sugerencia sobre cómo puedo obtener este tipo de información de manera más directa que un script con mucho análisis y reformateo.

^{Las preguntas más cercanas que puedo encontrar a este respecto son: Detectar una fusión hecha por ''-s ours'' (pero la única respuesta no ayuda) y "git merge -s ours" y cómo mostrar la diferencia (pero no hay respuestas a todos allí).}

Answer 1

Tuve este problema exacto, y terminé escribiendo una herramienta para detectar este tipo de fusiones. Si bien no puedo compartir el código real (técnicamente es propiedad de mi empleador), el algoritmo es muy simple: sea S1 el conjunto de todos los archivos que tienen cambios entre la combinación y el segundo padre de la combinación. Sea S2 el conjunto de todos los archivos que tienen cambios entre la combinación y la base de combinación. Reste S2 de S1 y quedará con el conjunto de archivos que probablemente hayan perdido cambios debido a la combinación.

Esto no solo detectará las combinaciones hechas con -s ours , sino que también detectará combinaciones fallidas donde algunos , pero no todos, de los cambios en el segundo padre se convirtieron en la combinación.