¿Cómo usar git merge --squash?

Tengo un servidor Git remoto, este es el escenario que quiero realizar:

• Para cada error / característica creo una rama Git diferente

• Sigo confirmando mi código en esa rama de Git con mensajes Git no oficiales

• En el repositorio superior, tenemos que hacer un commit para un error con el mensaje oficial de Git

Entonces, ¿cómo puedo fusionar mi sucursal con la sucursal remota para que obtengan solo una confirmación para todos mis registros (incluso quiero proporcionar un mensaje de confirmación para esto)?

Supongamos que se llama a su rama de corrección de errores bugfixy desea fusionarla en master:

git checkout master
git merge --squash bugfix
git commit

Esto tomará todos los commits de la bugfixrama, los aplastará en 1 commit y los combinará con su masterbranch.

Explicacion :

git checkout master

Cambia a su masterrama.

git merge --squash bugfix

Toma todas las confirmaciones de la bugfixrama y las fusiona con su rama actual.

git commit

Crea una única confirmación a partir de los cambios combinados.

Omitir el -mparámetro le permite modificar un borrador de mensaje de confirmación que contiene cada mensaje de sus confirmaciones aplastadas antes de finalizar su confirmación.

Lo que finalmente me aclaró esto fue un comentario que muestra que:

git checkout main
git merge --squash feature

es el equivalente a hacer:

git checkout feature
git diff main > feature.patch
git checkout main
patch -p1 < feature.patch
git add .

Cuando quiero fusionar una rama de características con 105 (!!) confirmaciones y hacer que todas se agrupen en una sola, no quiero hacerlo git rebase -i origin/masterporque necesito resolver por separado los conflictos de fusión para cada una de las confirmaciones intermedias (o al menos las que Git no puede darse cuenta de sí mismo). El uso git merge --squashme da el resultado que quiero, de una sola confirmación para fusionar una rama de características completa. Y, solo necesito hacer como máximo una resolución manual de conflictos.

Desea fusionarse con la opción de squash. Eso si quieres hacerlo una rama a la vez.

git merge --squash feature1

Si desea fusionar todas las ramas al mismo tiempo que las confirmaciones individuales, primero vuelva a redactar de forma interactiva y elimine cada característica y luego combine pulpo:

git checkout feature1
git rebase -i master

Aplaste en una confirmación y luego repita para las otras características.

git checkout master
git merge feature1 feature2 feature3 ...

Esa última fusión es una "fusión de pulpo" porque está fusionando muchas ramas a la vez.

Espero que esto ayude

Si ya tiene git merge bugfixen main, puede aplastar la combinación de cometer en uno con:

git reset --soft HEAD^1
git commit

Fusionar newFeaturerama mastercon una confirmación personalizada:

git merge --squash newFeature && git commit -m 'Your custom commit message';

Si en cambio, lo haces

git merge --squash newFeature && git commit

recibirá un mensaje de confirmación que incluirá todas las newFeatureconfirmaciones de rama, que puede personalizar.

Lo explico a fondo aquí: https://youtu.be/FQNAIacelT4

Sé que esta pregunta no se trata específicamente de Github, pero dado que Github es muy utilizado y esta es la respuesta que estaba buscando, la compartiré aquí.

Github tiene la capacidad de realizar fusiones de squash, dependiendo de las opciones de fusión habilitadas para el repositorio.

Si las fusiones de squash están habilitadas, la opción "Squash and merge" debería aparecer en el menú desplegable debajo del botón "Merge".

Suponga que trabajó en feature / task1 con múltiples commits.

1. Vaya a la rama de su proyecto (project / my_project)

   git checkout project/my_project
   

2. Crear una nueva sucursal (feature / task1_bugfix)

   git checkout -b feature/task1_bugfix
   

3. Marge con la --squashopción

   git merge --squash feature/task1
   

4. Crear una sola confirmación

   git commit -am "add single comments"
   

5. Empuja tu rama

   git push --set-upstream origin feature/task1_bugfix
   

Para Git

Crea una nueva característica

a través de Terminal / Shell:

git checkout origin/feature/<featurename>
git merge --squash origin/feature/<featurename>

Esto no lo compromete, le permite revisarlo primero.

Luego, confirme y termine la función de esta nueva rama, y ​​elimine / ignore la anterior (la que realizó).

si obtiene un error: la confirmación no es posible porque tiene archivos no fusionados.

git checkout master
git merge --squash bugfix
git add .
git commit -m "Message"

reparó todos los archivos de conflicto

git add . 

también podrías usar

git add [filename]

Para aplastar su rama local antes de empujarla:

1. revise la rama en cuestión para trabajar si aún no está desprotegida.

2. Encuentra el sha del compromiso más antiguo que deseas mantener.

3. Crear / pagar una nueva rama (tmp1) a partir de esa confirmación.

   git checkout -b tmp1 <sha1-of-commit>

4. Fusiona la rama original con la nueva aplastando.

   git merge --squash <original branch>

5. Confirme los cambios creados por la fusión, con un mensaje de confirmación de resumen.

   git commit -m <msg>

6. Verifique la rama original que desea aplastar.

   git checkout <branch>

7. Restablezca el commit original que desea mantener.

   git reset --soft <sha1>

8. Rebase esta rama basada en la nueva rama tmp1.

   git rebase tmp1

9. Eso es todo, ahora elimine la rama temporal tmp1 una vez que esté seguro de que todo está bien.

Puede usar la herramienta que he creado para facilitar este proceso: git-squash . Por ejemplo, para aplastar todas las confirmaciones en la rama de características que se ha ramificado desde la rama maestra, escriba:

git squash master
git push --force