Come inserire un commit tra alcuni due commit arbitrari in passato?

Supponiamo di avere la seguente cronologia di commit sul mio ramo solo locale:

A -- B -- C

Come inserisco un nuovo commit tra Ae B?

È ancora più facile che nella risposta di OP.

1. git rebase -i <any earlier commit>. Questo visualizza un elenco di commit nell'editor di testo configurato.
2. Trova il commit che vuoi inserire dopo (supponiamo che sia a1b2c3d). Nel tuo editor, per quella riga, cambia pickin edit.
3. Inizia il rebase chiudendo il tuo editor di testo (salva le modifiche). Questo ti lascia al prompt dei comandi con il commit che hai scelto in precedenza ( a1b2c3d) come se fosse stato appena eseguito il commit .
4. Apporta le tue modifiche e git commit( NON modificare, a differenza della maggior parte dei messaggi edit). Questo crea un nuovo commit dopo quello che hai scelto.
5. git rebase --continue. Questo riproduce i commit successivi, lasciando il tuo nuovo commit inserito nella posizione corretta.

Fai attenzione che questo riscriverà la storia e distruggerà chiunque cerchi di tirare.

Risulta essere abbastanza semplice, la risposta la trovate qui . Supponi di essere su un ramo branch. Eseguire questi passaggi:

• creare un ramo temporaneo dal commit dopo aver inserito il nuovo commit (in questo caso commit A):

  git checkout -b temp A
  

• eseguire le modifiche e eseguirne il commit, creando un commit, chiamiamolo N:

  git commit -a -m "Message"
  

  (o git addseguito da git commit)

• rebase i commit che vuoi avere dopo il nuovo commit (in questo caso commit Be C) sul nuovo commit:

  git rebase temp branch
  

^{(forse è necessario utilizzare -pper preservare le unioni, se ce ne fossero, grazie a un commento non più esistente di ciekawy )}

• eliminare il ramo temporaneo:

  git branch -d temp
  

Dopo questo, la cronologia appare come segue:

A -- N -- B -- C

È ovviamente possibile che durante il rebasing compaiano alcuni conflitti.

Nel caso in cui il tuo ramo non sia solo locale, questo introdurrà la riscrittura della cronologia, quindi potrebbe causare seri problemi.

Soluzione ancora più semplice:

1. Crea il tuo nuovo commit alla fine, D.Ora hai:

   A -- B -- C -- D
   

2. Quindi esegui:

   $ git rebase -i hash-of-A
   

3. Git aprirà il tuo editor e sarà simile a questo:

   pick 8668d21 B
   pick 650f1fc C
   pick 74096b9 D
   

4. Sposta semplicemente D in alto in questo modo, quindi salva ed esci

   pick 74096b9 D
   pick 8668d21 B
   pick 650f1fc C
   

5. Ora avrai:

   A -- D -- B -- C
   

Supponendo che la cronologia del commit sia preA -- A -- B -- C, se si desidera inserire un commit tra Ae B, i passaggi sono i seguenti:

1. git rebase -i hash-of-preA

2. Git aprirà il tuo editor. Il contenuto potrebbe essere questo:

   pick 8668d21 A
   pick 650f1fc B
   pick 74096b9 C
   

   Cambia il primo pickin edit:

   edit 8668d21 A
   pick 650f1fc B
   pick 74096b9 C
   

   Salva ed esci.

3. Modifica il tuo codice e poi git add . && git commit -m "I"

4. git rebase --continue

Ora la cronologia dei commit di Git è preA -- A -- I -- B -- C

Se incontri un conflitto, Git si fermerà a questo commit. È possibile utilizzare git diffper individuare i marcatori di conflitto e risolverli. Dopo aver risolto tutti i conflitti, devi usare git add <filename>per dire a Git che il conflitto è stato risolto e quindi rieseguire git rebase --continue.

Se vuoi annullare il rebase, usa git rebase --abort.

Ecco una strategia che evita di fare un "edit hack" durante il rebase visto nelle altre risposte che ho letto.

Usando git rebase -isi ottiene un elenco di commit da quel commit. Basta aggiungere una "interruzione" all'inizio del file, questo farà sì che il rebase si interrompa a quel punto.

break
pick <B's hash> <B's commit message>
pick <C's hash> <C's commit message>

Una volta lanciato, git rebaseora si fermerà al punto di "rottura". Ora puoi modificare i tuoi file e creare normalmente il tuo commit. È quindi possibile continuare il rebase con git rebase --continue. Ciò potrebbe causare conflitti che dovrai risolvere. Se ti perdi, non dimenticare che puoi sempre interromperne l'uso git rebase --abort.

Questa strategia può essere generalizzata per inserire un commit ovunque, basta mettere il "break" nel punto in cui si desidera inserire un commit.

Dopo aver riscritto la storia, non dimenticare di farlo git push -f. Si applicano i soliti avvertimenti su altre persone che recuperano il tuo ramo.

Molte buone risposte già qui. Volevo solo aggiungere una soluzione "no rebase", in 4 semplici passaggi.

Sommario

git checkout A
git commit -am "Message for commit D"
git cherry-pick A..C
git branch -f master HEAD

Spiegazione

(Nota: un vantaggio di questa soluzione è che non tocchi il tuo ramo fino al passaggio finale, quando sei sicuro al 100% di essere OK con il risultato finale, quindi hai un passaggio di "pre-conferma" molto pratico consentendo il test AB .)

Stato iniziale (ho ipotizzato masterper il nome del tuo ramo)

A -- B -- C <<< master <<< HEAD

1) Inizia puntando la TESTA nel punto giusto

git checkout A

     B -- C <<< master
    /
   A  <<< detached HEAD

(Facoltativamente qui, invece di scollegare HEAD, avremmo potuto creare un ramo temporaneo con git checkout -b temp A , che avremmo dovuto eliminare alla fine del processo. Entrambe le varianti funzionano, fai come preferisci poiché tutto il resto rimane lo stesso)

2) Creare il nuovo commit D da inserire

# at this point, make the changes you wanted to insert between A and B, then

git commit -am "Message for commit D"

     B -- C <<< master
    /
   A -- D <<< detached HEAD (or <<< temp <<< HEAD)

3) Quindi porta le copie degli ultimi commit mancanti B e C (sarebbe la stessa riga se ci fossero più commit)

git cherry-pick A..C

# (if any, resolve any potential conflicts between D and these last commits)

     B -- C <<< master
    /
   A -- D -- B' -- C' <<< detached HEAD (or <<< temp <<< HEAD)

(comodo AB Testing qui se necessario)

Ora è il momento di ispezionare il tuo codice, testare tutto ciò che deve essere testato e puoi anche diff / confrontare / ispezionare ciò che avevi e ciò che avresti ottenuto dopo le operazioni.

4) A seconda dei tuoi test tra Ce C', o è OK o è KO.

(ENTRAMBI) 4-OK) Infine, sposta il riferimento dimaster

git branch -f master HEAD

     B -- C <<< (B and C are candidates for garbage collection)
    /
   A -- D -- B' -- C' <<< master

(OR) 4-KO) Vattene e bastamaster invariato

Se hai creato un ramo temporaneo, eliminalo semplicemente con git branch -d <name>, ma se hai scelto la rotta HEAD scollegata, nessuna azione necessaria a questo punto, i nuovi commit saranno idonei per la raccolta dei rifiuti subito dopo che ti sarai ricollegatoHEAD con ungit checkout master

In entrambi i casi (OK o KO), a questo punto basta fare di masternuovo il checkout per ricollegarlo HEAD.