¿Cómo se aplastan los compromisos en un solo parche con git format-patch?

StackOverflow https://stackoverflow.com/questions/616556

  •  03-07-2019
  •  | 
  •  

Pregunta

Tengo ocho confirmaciones en una rama que me gustaría enviar por correo electrónico a algunas personas que todavía no están iluminadas. Hasta ahora, todo lo que hago me da 8 archivos de parches, o comienza a darme archivos de parches para cada confirmación en el historial de la sucursal, desde el principio de los tiempos. Utilicé git rebase --interactivo para aplastar las confirmaciones, pero ahora todo lo que intento me da un montón de parches desde el principio de los tiempos. ¿Qué estoy haciendo mal? 

git format-patch master HEAD # yields zillions of patches, even though there's 
                             # only one commit since master
¿Fue útil?

Solución

Recomiendo hacer esto en una rama desechable de la siguiente manera. Si tus confirmaciones están en las " nuevas líneas " bifurca y has vuelto a tu " maestro " rama ya, esto debería hacer el truco: 

[adam@mbp2600 example (master)]$ git checkout -b tmpsquash
Switched to a new branch "tmpsquash"

[adam@mbp2600 example (tmpsquash)]$ git merge --squash newlines
Updating 4d2de39..b6768b2
Fast forward
Squash commit -- not updating HEAD
 test.txt |    2 ++
 1 files changed, 2 insertions(+), 0 deletions(-)

[adam@mbp2600 example (tmpsquash)]$ git commit -a -m "My squashed commits"
[tmpsquash]: created 75b0a89: "My squashed commits"
 1 files changed, 2 insertions(+), 0 deletions(-)

[adam@mbp2600 example (tmpsquash)]$ git format-patch master
0001-My-squashed-commits.patch

Espero que esto ayude!

Otros consejos

Solo para agregar una solución más a la olla: Si usas esto en su lugar: 

git format-patch master --stdout > my_new_patch.diff

Entonces aún serán 8 parches ... pero todos estarán en un solo archivo de parche y se aplicarán como uno con: 

git am < my_new_patch.diff

Siempre uso git diff, así que en tu ejemplo, algo como 

git diff master > patch.txt

Esta es una adaptación de la respuesta de Adam Alexander, en caso de que sus cambios estén en la rama maestra. Esto hace lo siguiente:

  • Crea una nueva rama desechable " tmpsquash " desde el punto que queramos (busque la clave SHA en ejecución " git --log " o con gitg. Seleccione la confirmación que desea que sea tmpsquash head, las confirmaciones que están después de eso en master serán las confirmaciones aplastadas).
  • Fusiona los cambios de maestro a tmpsquash.
  • Confirma los cambios aplastados en tmpsquash.
  • Crea el parche con las confirmaciones aplastadas.
  • Vuelve a la rama maestra 
laura@rune:~/example (master)$ git branch tmpsquash ba3c498878054e25afc5e22e207d62eb40ff1f38
laura@rune:~/example (master)$ git checkout tmpsquash
Switched to branch 'tmpsquash'
laura@rune:~/example (tmpsquash)$ git merge --squash master
Updating ba3c498..40386b8
Fast-forward
Squash commit -- not updating HEAD

[snip, changed files]

11 files changed, 212 insertions(+), 59 deletions(-)
laura@rune:~/example  (tmpsquash)$ git commit -a -m "My squashed commits"
[test2 6127e5c] My squashed commits
11 files changed, 212 insertions(+), 59 deletions(-)
laura@rune:~/example  (tmpsquash)$ git format-patch master
0001-My-squashed-commits.patch
laura@rune:~/example  (tmpsquash)$ git checkout master
Switched to branch 'master'
laura@rune:~/example  (master)$

Como ya sabes, un git format-patch -8 HEAD te dará ocho parches.

Si desea que sus 8 confirmaciones aparezcan como una sola y no le importa volver a escribir el historial de su sucursal ( o-o-X-A-B-C-D-E-F-G-H ), podría: 

git rebase -i
// squash A, B, C, D, E ,F, G into H

o, y sería una mejor solución, vuelva a reproducir todos sus 8 confirmaciones de X (la confirmación antes de sus 8 confirmaciones) en una nueva rama 

git branch delivery X
git checkout delivery
git merge --squash master
git format-patch HEAD

De esa manera, solo tiene un compromiso en la " entrega " rama, y ??representa a todos sus últimos 8 compromisos

Formato-parche entre dos etiquetas: 

git checkout <source-tag>
git checkout -b <tmpsquash>
git merge --squash <target-tag>
git commit -a -m "<message>"
git format-patch <source-tag>

La forma más sencilla es usar git diff y agregar git log si desea el mensaje de confirmación combinado que generaría el método de squash. Por ejemplo, para crear el parche entre commit abcd y 1234 : 

git diff abcd..1234 > patch.diff
git log abcd..1234 > patchmsg.txt

Luego al aplicar el parche: 

git apply patch.diff
git add -A
git reset patch.diff patchmsg.txt
git commit -F patchmsg.txt

No olvide el argumento --binary para git diff cuando trate con archivos que no son de texto, por ejemplo. Imágenes o videos.

Basado en la respuesta de Adam Alexander: 

git checkout newlines
## must be rebased to master
git checkout -b temporary
# squash the commits
git rebase -i master
git format-patch master
Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top