Git: rebasing e mantenimento della corrente in un ramo remoto - pratiche accettate?

6

Quando si sviluppa su un ramo di lunga data (qui definito come vivere più a lungo di una versione), qual è la pratica più accettata per mantenere il ramo corrente con la sua origine mantenendo la cronologia relativamente pulita prima di fondersi?

Ad esempio, considera il ramo di origine ( m ) e un ramo (argomento) ( t ) con il seguente grafico cronologico:

 A[1]--------F[2]--H[3]--J[4] (m)
  \           \     \
   B----C-D-E--G-----I-----K (t)

[1] - Release 1.0
[2] - Release 2.0
[3] - Hotfix 2.1
[4] - Hotfix 2.2

Nel ramo t Mi sono unito periodicamente dal master ( m ) per mantenere aggiornato il mio topic topic, ma ci sono molti piccoli commit tra B e K che mi piacerebbe schiacciare con un rebase.

Sono preoccupato se schiaccio quei commit che cambierò l'hash dei commit uniti dal master e creerò problemi per gli altri quando unirò il mio branch in master per la Release 3.0.

Se I rebase -i il ramo dell'argomento, mi aspetto che il grafico assomigli a questo:

 A---------F---H---J (m)
  \
   B-----------------K (t)

dove K contiene tutti i commit schiacciati tra B e K incluse le modifiche unite dal master ( F e H ). Se poi unisco t di nuovo al master m Mi chiedo se ci siano probabilmente conflitti da F e H . Il grafico dovrebbe apparire così:

 A---------F---H---J---L (m)
  \                   /
   B-----------------K   (t)

t ora può essere eliminato perché non è più utilizzato. Mi piacerebbe mantenere la cronologia di dove t è stato derivato, quindi basare B su J perderebbe quell'informazione e probabilmente risolverebbe il mio problema ma il grafico sarebbe simile a:

 A---------F---H---J---K' (m)

Questa è una preoccupazione valida? Qual è la pratica comunemente accettata per mantenere la propria diramazione caratteristica con la sua origine mantenendo una cronologia relativamente pulita?

Nota: l'esempio qui è semplificato, ci sono in realtà centinaia di commit dal punto di diramazione a HEAD sul ramo dell'argomento - oltre 300 - molti dei quali potrebbero essere schiacciati dall'esistenza

    
posta BrionS 08.04.2013 - 15:42
fonte

3 risposte

2

La migliore pratica è di mantenere una cronologia accurata e basta fare una fusione diretta. In questo modo, se introduci un bug in C , qualcuno che sta indagando può dire "Oh, questo ha senso perché è stato fatto prima di mettere la funzione F in origin , ma non unita fino ad oggi". Ha anche il vantaggio di non cambiare nessun hash. Ci sono dei flag che puoi usare per nascondere la cronologia del ramo dell'argomento quando non ti interessa.

Se devi schiacciare i tuoi commit, ad esempio se origin è controllato da un'altra organizzazione, allora dipende da quante persone usano il ramo dell'argomento e quanti ne devono fare le une dal tuo origin . Non riuscirai a farlo senza disturbare qualcuno . Alcune squadre lavorano solo con la storia originale e una persona si occupa di tutte le unioni. Alcuni team ricominciano con un nuovo ramo di argomenti ogni volta che vengono uniti in origin . Alcuni team rebase continuamente il loro branch di argomento a origin , e rendono semplicemente pratica comune fare sempre un pull force. Dovrai capire cosa funziona per il tuo team.

    
risposta data 08.04.2013 - 17:10
fonte
0

Hai un paio di opzioni a seconda del ramo t.

Se il ramo t è anche un ramo remoto con più sviluppatori che lavorano su di esso. Penso che il modo migliore stia facendo le fusioni che stai suggerendo. Rifondare e fare una spinta forzata sembra un modo rischioso di fare le cose. Cerco di evitare di modificare una cronologia spinta.

Se il ramo è locale, allora puoi fare un git rebase origin/master questo porterà tutte le modifiche che si sono verificate nel master e poi aggiungerà le tue commit dopo l'ultimo commit. Il vantaggio di questo è che puoi facilmente trovare tutti i tuoi impegni per lo schiacciamento. Ciò mantiene anche tutte le modifiche relative al progetto nei tuoi commit piuttosto che unire la risoluzione dei conflitti in un commit di unione e mantiene pulito il ramo quando lo si unisce in master.

    
risposta data 08.04.2013 - 17:23
fonte
0

Dopo diversi esperimenti su un clone del repository e data la vastità dei commit da schiacciare, ho deciso che sarebbe piuttosto poco pratico schiacciarli mantenendo il commit del ramo originale solo per una tracciabilità.

La soluzione più pulita / più semplice sembra essere quella che ha suggerito @Karl: basta unire il ramo in master e averne a che fare. Mentre introduce molti messaggi di commit non necessari e talvolta spuri nella cronologia, è chiaro dove è stato creato il ramo, aggiornato dal master e infine reinserito.

Alla fine, la tracciabilità vince su una cronologia pristine.

Il grafico finale ha il seguente aspetto (utilizzando --no-ff sull'unione):

A[1]--------F[2]--H[3]--J[4]--L (m)
 \           \     \         /
  B----C-D-E--G-----I-------K   (t)

[1] - Release 1.0
[2] - Release 2.0
[3] - Hotfix 2.1
[4] - Hotfix 2.2

E da un punto di vista di git log assomiglia a:

commit L (HEAD, m, origin/master)
  merge parents K, J
commit K (t)
commit J
commit I
  merge parents H, G
commit H
commit G
  merge parents F, E
commit F
commit E
commit D
commit C
commit B
commit A
    
risposta data 08.04.2013 - 21:01
fonte

Leggi altre domande sui tag