Ri-fare un merge ritornato in Git

Question

ho incontrato un po 'di un problema qui: ho avuto un ramo specifico problemi 28s in Git, che ho fuso nel ramo generale develop. Venuto fuori che avevo fatto troppo in fretta, quindi ho usato git-revert per annullare l'unione. Ora, però, è giunto il momento di unire <=> in <=>, ma il comando git-merge vede l'unione originale, e felicemente annuncia che tutto va bene e rami sono stati già fuse. Cosa faccio ora? Creare un '28s Ripristina 'Ripristina '-> sviluppare''' commettere? Non sembra essere un buon modo per farlo, ma non riesco a immaginare un altro al momento.

Ciò che la struttura ad albero appare come:

Answer 1

È necessario "ripristinare la Revert". Dipende da come lo si ripristina che, potrebbe non essere così facile come sembra. Guardate il documento ufficiale su questo argomento .

---o---o---o---M---x---x---W---x---Y
              /
      ---A---B-------------------C---D

per consentire:

---o---o---o---M---x---x-------x-------*
              /                       /
      ---A---B-------------------C---D

  

Ma fa tutto il lavoro? Certo lo fa. È possibile ripristinare una fusione, e da una   vista meramente tecnico, git lo ha fatto in modo molto naturale e non aveva alcun reale   guai.
  E 'solo ritenuto un cambiamento da "stato prima di merge" per   "Stato dopo l'unione", e che è stato.
  Niente di complicato, nulla di strano,   nulla di veramente pericoloso. Git lo farà senza nemmeno pensarci.

     

Quindi, da un punto di vista tecnico, non c'è niente di sbagliato con un ritorno di una stampa,   ma da un angolo del flusso di lavoro è qualcosa che in genere dovrebbe cercare di   evitare .

     

Se possibile, ad esempio, se si trova un problema che ha ottenuto fuse   nell'albero principale, piuttosto che tornare l'unione, provare a davvero difficile :

     

  
• tagliare in due il problema in ramo che dalla fusione, e solo risolvere il problema,
  
• o provare a ripristinare l'individuo commettere che lo ha causato.
  

     

Sì, è più complesso, e no, non è sempre andare a lavorare (a volte   la risposta è: "oops, io davvero non avrei dovuto fusa, perché non è stato   ancora pronto, e ho davvero bisogno di annullare tutti del merge "). Così dunque voi   in realtà dovrebbe tornare l'unione, ma quando si vuole rifare l'unione, si   ora bisogno di farlo ripristinando il ripristino.

Answer 2

Supponiamo di avere tale storia

---o---o---o---M---W---x-------x-------*
              /                      
      ---A---B

Dove A, B fallita commit e W - è tornare di M

Quindi, prima di iniziare a fissare trovato problemi io cherry-pick di W impegno a mio ramo

git cherry-pick -x W

Poi ho Ripristina W commettere il mio ramo

git revert W 

Dopo posso continuare fissaggio.

La storia finale potrebbe assomigliare a:

---o---o---o---M---W---x-------x-------*
              /                       /     
      ---A---B---W---W`----------C---D

Quando mando un PR lo farà mostra chiaramente che PR è undo revert e aggiunge alcune nuove commit.

Answer 3

Per ripristinare il revert senza rovinare il flusso di lavoro troppo:

• Creare una copia locale dei rifiuti sviluppare
• Ripristina la Revert commettere sulla copia locale di sviluppo
• Unisci che copia nel vostro ramo della funzione, e spingere il vostro ramo di caratteristica al server Git.

Il ramo di caratteristica dovrebbe ora essere in grado di essere uniti come normale quando sei pronto per questo. L'unico svantaggio è che avrete un avere un paio di fusione extra / ripristinare impegna nella vostra storia.

Answer 4

Per ripristinare un Revert in GIT:

git revert <commit-hash-of-previous-revert>

Answer 5

Invece di usare git-revert si potrebbe avere usato questo comando nel devel ramo per buttare via (undo) l'unione sbagliata commit (invece di un ritorno esso).

git checkout devel
git reset --hard COMMIT_BEFORE_WRONG_MERGE

Questo sarà anche regolare il contenuto della directory di lavoro di conseguenza. Fare attenzione :

• Salva le modifiche nel ramo sviluppo (dal l'unione sbagliata) perché Anche verranno cancellati dal git-reset. Tutti i commit dopo quello specificato come il git reset argomento sarà andato!
• Inoltre, non farlo se le modifiche erano già tirati da altri repository perché il reset riscrivere la storia.

Vi consiglio di studiare il 28s man-page con attenzione prima di provare questo.

Ora, dopo il reset è possibile ri-applicare le modifiche in <=> e poi fare

git checkout devel
git merge 28s

Questa sarà una vera e propria unione da <=> in <=> come quello iniziale (che ora è cancellati dalla storia di git).

Answer 6

Ho appena trovato questo post di fronte lo stesso problema. Trovo sopra wayyy per paura di fare dure di reset ecc finirò cancellando qualcosa che non voglio, e non sarà in grado di tornare indietro.

Invece ho verificato il commit volevo che il ramo di tornare a esempio git checkout 123466t7632723. Poi convertito in un git checkout my-new-branch ramo. Allora ho cancellato il tralcio non volevo più. Naturalmente questo funziona solo se si è in grado di buttare via il ramo incasinato.

Answer 7

Vorrei suggerire di seguire i passaggi qui sotto per riportare un revert, dire SHA1.

git checkout develop #go to develop branch
git pull             #get the latest from remote/develop branch
git branch users/yourname/revertOfSHA1 #having HEAD referring to develop
git checkout users/yourname/revertOfSHA1 #checkout the newly created branch
git log --oneline --graph --decorate #find the SHA of the revert in the history, say SHA1
git revert SHA1
git push --set-upstream origin users/yourname/revertOfSHA1 #push the changes to remote

Ora creare PR per il ramo users/yourname/revertOfSHA1

Answer 8

1. creare nuova filiale a impegnarsi prima della fusione originale - lo chiamano lo 'sviluppo-base'
2. eseguire rebase interattivo di 'sviluppo' in cima 'sviluppare-base' (anche se è già in alto). Durante rebase interattivo, avrete la possibilità di rimuovere sia l'unione commit, e il commit che ha invertito l'unione, vale a dire rimuovere entrambi gli eventi della storia git

A questo punto avrete un pulito 'sviluppare' ramo a cui è possibile unire la vostra caratteristica Brach, come si fa regolarmente.