Ho trovato una buona spiegazione per Come ripristinare l'unione da questo link e copio incollato la spiegazione di seguito e sarebbe utile nel caso in cui il link di seguito non funzioni.
Come ripristinare una fusione errata
Alan (alan@clueserver.org) ha detto:
Ho un ramo principale. Abbiamo una branca di ciò su cui alcuni sviluppatori stanno lavorando. Dicono che è pronto. Lo uniamo nel ramo principale. Si rompe qualcosa in modo da ripristinare l'unione. Apportano modifiche al codice. arrivano a un punto in cui dicono che va bene e ci uniamo di nuovo. Quando esaminato, troviamo che le modifiche al codice effettuate prima del ripristino non si trovano nel ramo principale, ma le modifiche al codice successive si trovano nel ramo principale. e ha chiesto aiuto per riprendersi da questa situazione.
La storia immediatamente dopo il "ripristino della fusione" sarebbe simile a questa:
---o---o---o---M---x---x---W
/
---A---B
dove A e B sono sullo sviluppo laterale che non era così buono, M è la fusione che porta questi cambiamenti prematuri nella linea principale, x sono cambiamenti non correlati a ciò che il ramo laterale ha fatto e già fatto sulla linea principale, e W è il " ripristina l'unione M "(W non guarda M sottosopra?). IOW, "diff W ^ .. W" è simile a "diff -RM ^ .. M".
Tale "ripristino" di una fusione può essere effettuato con:
$ git revert -m 1 M
Dopo che gli sviluppatori del ramo laterale hanno corretto i loro errori, la storia potrebbe apparire così:
---o---o---o---M---x---x---W---x
/
---A---B-------------------C---D
dove C e D stanno riparando ciò che è stato rotto in A e B, e potresti avere già alcune altre modifiche sulla linea principale dopo W.
Se unisci il ramo laterale aggiornato (con D in punta), nessuna delle modifiche apportate in A o B sarà nel risultato, perché sono state ripristinate da W. Questo è ciò che Alan ha visto.
Linus spiega la situazione:
Il ripristino di un commit regolare annulla in modo efficace ciò che ha fatto il commit ed è abbastanza semplice. Ma il ripristino di un commit di unione annulla anche i dati modificati dal commit, ma non fa assolutamente nulla agli effetti sulla cronologia che ha avuto la fusione. Quindi la fusione continuerà a esistere, e sarà comunque vista come unire i due rami insieme, e le future fusioni vedranno quella fusione come l'ultimo stato condiviso - e il ripristino che ha ripristinato la fusione introdotto non avrà alcun effetto. Quindi un "ripristino" annulla le modifiche ai dati, ma non è cosìun "annullamento", nel senso che non annulla gli effetti di un commit sulla cronologia del repository. Quindi, se pensi di "ripristinare" come "annulla", allora ti perderai sempre questa parte dei ripristini. Sì, annulla i dati, ma no, non annulla la cronologia. In una situazione del genere, si vorrebbe innanzitutto ripristinare il ripristino precedente, il che renderebbe la cronologia simile a questa:
---o---o---o---M---x---x---W---x---Y
/
---A---B-------------------C---D
dove Y è il ripristino di W. Tale "ripristino del ripristino" può essere fatto con:
$ git ripristina W
Questa storia (ignorando i possibili conflitti tra ciò che W e W..Y sono cambiati) equivarrebbe a non avere W o Y nella storia:
---o---o---o---M---x---x-------x----
/
---A---B-------------------C---D
e la fusione del ramo laterale non avrà conflitti derivanti da un precedente ripristino e ripristino del ripristino.
---o---o---o---M---x---x-------x-------*
/ /
---A---B-------------------C---D
Naturalmente le modifiche apportate in C e D possono ancora essere in conflitto con ciò che è stato fatto da una qualsiasi delle x, ma questo è solo un normale conflitto di unione.
