Dovrei unire dallo stesso ramo o da un'unione?

Come prefazione, I consiglia strongmente di leggere Strategie avanzate di ramificazione SCM di Stephen Vance. Gran parte di questa risposta si basa sul modello impostato in quel documento.

Una funzione chiave per ramificare e unire correttamente in un sistema di controllo di versione è mantenere i ruoli dei rami coerenti e separati. Non lasciare che la tua manutenzione si fonda con la tua linea principale, né il tuo flusso di funzionalità nella manutenzione.

I ruoli fondamentali delle filiali sono la linea principale, lo sviluppo, la manutenzione, l'accumulazione e l'imballaggio. Mentre a volte questi possono essere combinati (ad esempio, il semplice 'tutto in una configurazione di uno sviluppatore di trunk'), quando si lavora in gruppi e in ambienti più complessi, è spesso necessaria una netta separazione dei ruoli.

Hai due rami funzione ... A e B. Ogni ramo dovrebbe essere ramificato dalla linea principale. Allo stesso modo, ogni correzione di bug dovrebbe essere derivata dalla linea principale.

The main programming (reason for the branch) isn't done, but a bug fix needs to be copied across multiple branches and trunk

In questo caso, il ramo di funzionalità A anche contiene una correzione di bug e parte del ramo A deve essere unito al sistema.

La migliore pratica sarebbe stata quella di diramarti dalla linea principale, eseguire la manutenzione (correzione dei bug) e unirli alla linea principale, e quindi raccogliere le modifiche dalla linea principale nei vari rami che ne hanno bisogno, se necessario.

Assumo che la linea principale sia una politica di "solo codice funzionante". Non si dovrebbe rompere la build dalla linea principale. Allo stesso modo, il codice non funzionante nella linea principale significa che tutte le diramazioni da quel punto sono state interrotte.

Per risolvere il caso qui, l'approccio migliore sarebbe quello di creare un altro ramo - un ramo di accumulazione. Ciò mantiene eventuali ramificazioni eseguite dalla linea principale mentre la verifica della correzione del bug nel ramo di accumulo non viene risolta. Per fare ciò:

1. linea principale filiale in un ramo di accumulo
2. Unisci la correzione di bug dal ramo A al ramo di accumulo
3. unisci il ramo di accumulo al principale
4. propagare le correzioni nella riga principale agli altri rami

La chiave per un ramo separato è in effetti creare un ramo di manutenzione che contiene solo la correzione di bug e andare da lì. Questo ti permette di assicurarti che il ramo sia fatto correttamente senza rompere la linea principale e apportare ulteriori modifiche per assicurarti che la correzione del bug non infranga qualcos'altro.

Penso che tutto dipenda da come sono strutturati i rami.

1. Il ramo A e il ramo B sono indipendenti

branch A      +---------+-------------
             /           \ merge 1
trunk ------+--+----------+--+--------
                \             \ merge 2
branch B         +-------------+------

Come puoi vedere qui, vorrei unire dal ramo A al tronco, quindi unire da tronco a ramo B.

2. Il ramo A è un ramo del ramo B

trunk ------+------------------+-----
             \                / merge 2
branch B      +--+--------+--+-------
                  \      / merge 1
branch A           +----+------------

In questo caso, mi unirei dal ramo A al ramo B, quindi unire il ramo B al tronco.

3. Il ramo B è un ramo del ramo A

trunk ------+------------------+-----
             \                / merge 2
branch A      +--+--------+--+-------
                  \        \ merge 1
branch B           +--------+--------

In questo caso finale, mi unirei dal ramo A al ramo B, quindi unire il ramo A al tronco. Nota: l'ordine non ha importanza per questo caso, un'unione dal ramo A al tronco, quindi il ramo A al ramo B avrebbe lo stesso effetto.

Credo che la chiave del mio pensiero sia sempre unire il genitore o fondersi in un figlio ed evitare di unire rami ancestrali / discendenti non collegati o indiretti.