¿Cómo aplastas los commits en un parche con git format-patch?

Tengo ocho confirmaciones en una rama que me gustaría enviar por correo electrónico a algunas personas que aún no están iluminadas. Hasta ahora, todo lo que hago me da 8 archivos de parche o comienza a darme archivos de parche para cada confirmación en la historia de la rama, desde el principio de los tiempos. Usé git rebase --interactive para aplastar los commits, pero ahora todo lo que intento me da millones 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

Recomiendo hacer esto en una rama desechable de la siguiente manera. Si sus confirmaciones están en la rama "líneas nuevas" y ya ha cambiado a su rama "maestra", esto debería ser 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!

Solo para agregar una solución más al bote: si usa esto en su lugar:

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

Entonces todavía habrá 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 (busca la clave SHA que ejecuta "git --log" o con gitg. Selecciona el commit que quieres que sea tmpsquash head, los commits que están después de eso en master serán el aplastado comete).
• Fusiona los cambios de maestro a tmpsquash.
• Comete los cambios aplastados en tmpsquash.
• Crea el parche con los commits aplastados.
• Regresa 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 sabe, un git format-patch -8 HEADle dará ocho parches.

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

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

o, y sería una mejor solución, reproducir todos tus 8 commits desde X(el commit antes de tus 8 commits) en una nueva rama

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

De esa manera, solo tiene una confirmación en la rama de "entrega", y representa todas sus últimas 8 confirmaciones

Parche de formato 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 fácil es usar git diffy agregar git logsi desea el mensaje de confirmación combinado que generaría el método de squash. Por ejemplo, para crear el parche entre commit abcdy 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 --binaryargumento de git diffcuando se trata de 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