Combinar varias confirmaciones antes de enviar en Git [duplicar]

Si tienes montones de confirmaciones y solo quieres aplastar las últimas X confirmaciones, busca el ID de confirmación de la confirmación desde la que quieres empezar a aplastar y haz

git rebase -i <that_commit_id>

Luego proceda como se describe en la respuesta de leopd, cambiando todas las pick s a squash es excepto la primera.

Hay bastantes respuestas de trabajo aquí, pero me pareció que esta es la más fácil. Este comando abrirá un editor, donde solo puede reemplazar pick con squash para eliminarlos / fusionarlos en uno

git rebase -i HEAD~4

Donde, 4 es el número de confirmaciones que desea squash en uno. Esto se explica aquí también.

Puede hacer esto con git rebase -i, pasando la revisión que desea usar como 'root':

git rebase -i origin/master

Abrirá una ventana del editor que muestra todas las confirmaciones que ha realizado después de la última confirmación en origin/master. Puedes rechazar commits, aplastar commits en un solo commit, o editar commits anteriores.

Hay algunos recursos que probablemente pueden explicar esto de una mejor manera, y mostrar algunos otros ejemplos:

Http://book.git-scm.com/4_interactive_rebasing.html

Y

Http://gitready.com/advanced/2009/02/10/squashing-commits-with-rebase.html

Son las dos primeras buenas páginas que pude encontrar.

Se me ocurrió

#!/bin/sh

message=`git log --format=%B origin..HEAD | sort | uniq | grep -v '^$'`
git reset --soft origin
git commit -m "$message"

Combina, ordena, unifica y elimina las líneas vacías del mensaje de confirmación. Uso esto para cambios locales en un wiki de github (usando gollum)

Y mi forma de squashing múltiples push es (tal vez empujaste a tu propia rama muchos commits y ahora deseas hacer una pull request y no quieres saturarlos con muchos commits que ya has empujado). La forma en que lo hago (no hay otra opción más simple que yo pueda decir es).

1. Cree una nueva rama por el bien de squash (rama desde la rama original a la que desea extraer la solicitud).
2. Empuje la rama recién creada.
3. Fusionar rama con commits (ya empujado) a la nueva rama.
4. Rebase nueva rama y squash.
5. Empuje nueva rama.
6. Crea una nueva pull request para una nueva rama que ahora tiene un solo commit.

Ejemplo:

git checkout from_branch_you_wish_to_pull_request_to
git checkout -b new_branch_will_have_single_squashed_commit
git push -u new_branch_will_have_single_squashed_commit
git merge older_branch_with_all_those_multiple_commits
git rebase -i (here you squash)
git push origin new_branch_will_have_single_squashed_commit

Ahora puede extraer la solicitud en from_branch_you_wish_to_pull_request_to

Puedes aplastar (unir) confirmaciones con un Rebase interactivo. Hay un bonito video de YouTube que muestra cómo hacer esto en la línea de comandos o con SmartGit :

• https://www.youtube.com/watch?v=qi_QAFrmHJM

Si ya eres un usuario de SmartGit entonces puedes seleccionar todas tus commits salientes (manteniendo presionada la tecla Ctrl) y abrir el menú contextual (clic derecho) para aplastar tus commits.

Es muy cómodo:

También hay un tutorial muy bonito de Atlassian que muestra cómo funciona:

• https://www.atlassian.com/git/tutorials/rewriting-history/git-rebase-i

Probablemente quieras usar Rebase interactivo, que se describe en detalle en ese enlace.

Puedes encontrar otros buenos recursos si buscas "git rebase interactive".