Come usare git merge --squash?

Ho un server Git remoto, ecco lo scenario che voglio eseguire:

• Per ogni bug / funzione creo un ramo Git diverso

• Continuo a impegnare il mio codice in quel ramo Git con messaggi Git non ufficiali

• Nel repository superiore dobbiamo eseguire un commit per un bug con il messaggio Git ufficiale

Quindi, come posso unire il mio ramo al ramo remoto in modo che ottengano un solo commit per tutti i miei check-in (voglio anche fornire un messaggio di commit per questo)?

Supponiamo che venga chiamato il ramo per la correzione di bug bugfixe si desidera unirlo in master:

git checkout master
git merge --squash bugfix
git commit

Questo prenderà tutti i commit dal bugfixramo, li schiaccerà in 1 commit e li fonderà con il tuo masterramo.

Spiegazione :

git checkout master

Passa al tuo masterramo.

git merge --squash bugfix

Prende tutti i commit dal bugfixramo e li unisce al ramo corrente.

git commit

Crea un unico commit dalle modifiche unite.

Se si omette il -mparametro, è possibile modificare una bozza del messaggio di commit contenente tutti i messaggi dei commit compressi prima di finalizzare il commit.

Ciò che alla fine mi ha chiarito questo è stato un commento che mostra che:

git checkout main
git merge --squash feature

è l'equivalente di fare:

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

Quando voglio unire un ramo di funzionalità con 105 (!!) commit e averli tutti compressi in uno, non voglio git rebase -i origin/masterperché devo risolvere separatamente i conflitti di unione per ciascuno dei commit intermedi (o almeno quelli che git non riesce a capire se stesso). L'utilizzo git merge --squashmi dà il risultato che desidero, di un unico commit per l'unione di un intero ramo di caratteristiche. E ho solo bisogno di fare al massimo una risoluzione manuale dei conflitti.

Vuoi unirti con l'opzione squash. Questo se vuoi farlo un ramo alla volta.

git merge --squash feature1

Se vuoi unire tutti i rami contemporaneamente ai singoli commit, prima fai un rebase interattivo e schiaccia ogni caratteristica, quindi unisci il polpo:

git checkout feature1
git rebase -i master

Squash in un commit, quindi ripetere per le altre funzionalità.

git checkout master
git merge feature1 feature2 feature3 ...

Quest'ultima fusione è una "fusione di polpo" perché sta unendo molti rami contemporaneamente.

Spero che sia di aiuto

Se hai già git merge bugfixattivato main, puoi eliminare il commit di merge in uno con:

git reset --soft HEAD^1
git commit

Unisci il newFeatureramo in mastercon un commit personalizzato:

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

Se invece lo fai

git merge --squash newFeature && git commit

riceverai un messaggio di commit che includerà tutti i file newFeature commit ramo, che puoi personalizzare.

Lo spiego a fondo qui: https://youtu.be/FQNAIacelT4

So che questa domanda non riguarda specificamente Github, ma poiché Github è così ampiamente usato e questa è la risposta che stavo cercando, la condividerò qui.

Github ha la capacità di eseguire fusioni di squash, a seconda delle opzioni di unione abilitate per il repository.

Se le fusioni di squash sono abilitate, l'opzione "Squash and merge" dovrebbe apparire nel menu a discesa sotto il pulsante "Unisci".

Supponiamo di aver lavorato in feature / task1 con più commit.

1. Vai al ramo del tuo progetto (project / my_project)

   git checkout project/my_project
   

2. Crea un nuovo ramo (feature / task1_bugfix)

   git checkout -b feature/task1_bugfix
   

3. Marge con l' --squashopzione

   git merge --squash feature/task1
   

4. Crea un unico commit

   git commit -am "add single comments"
   

5. Spingi il tuo ramo

   git push --set-upstream origin feature/task1_bugfix
   

Per Git

Crea una nuova funzionalità

tramite terminale / shell:

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

Questo non lo commette, ti permette di rivederlo prima.

Quindi esegui il commit e termina la funzione da questo nuovo ramo ed elimina / ignora quello vecchio (quello su cui hai sviluppato).

in caso di errore: il commit non è possibile perché sono presenti file non uniti.

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

corretti tutti i file di conflitto

git add . 

potresti anche usare

git add [filename]

Per schiacciare il tuo ramo locale prima di spingerlo:

1. controlla la filiale in questione su cui lavorare se non è già stata estratta.

2. Trova lo sha del commit più vecchio che desideri mantenere.

3. Crea / checkout un nuovo ramo (tmp1) da quel commit.

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

4. Unisci il ramo originale nel nuovo schiacciandolo.

   git merge --squash <original branch>

5. Conferma le modifiche che sono state create dall'unione, con un messaggio di riepilogo di commit.

   git commit -m <msg>

6. Dai un'occhiata al ramo originale che vuoi schiacciare.

   git checkout <branch>

7. Ripristina lo sha di commit originale che desideri conservare.

   git reset --soft <sha1>

8. Rebase questo ramo in base al nuovo ramo tmp1.

   git rebase tmp1

9. Ecco fatto: ora cancella il ramo temporaneo tmp1 quando sei sicuro che tutto sia a posto.

Puoi usare lo strumento che ho creato per semplificare questo processo: git-squash . Ad esempio per schiacciare tutti i commit sul ramo della funzione che è stato ramificato dal ramo principale, scrivere:

git squash master
git push --force