Come gestire lo sviluppo in concomitanza con Mercurial?

StackOverflow https://stackoverflow.com/questions/3719019

Domanda

Questa è una domanda migliore prassi, e mi aspetto la risposta di essere "dipende". Spero solo di imparare scenari del mondo più reale e flussi di lavoro.

Prima di tutto, sto parlando di diverse modifiche per lo stesso progetto, in modo che nessun subrepo favore.

diciamo Let avete la vostra base di codice in un repository hg. Si inizia a lavorare su una nuova funzionalità complicato A, quindi un bug complicato B è riportato da tester di fiducia (si dispone di tester, giusto?).

E 'banale se (la correzione per) B dipende da A. È simlply CI a poi ci B.

La mia domanda è che cosa fare quando sono indipendenti (o almeno sembra ora).

mi viene in mente dei seguenti modi:

  1. Usa un clone separato per B.
  2. Usa anonima o nome rami, o segnalibri, nello stesso repository.
  3. Usa MQ (con la patch B in cima ad una).
  4. Usa ramificata MQ (spiegherò più avanti).
  5. Usa MQ multipla (dal 1,6)

1 e 2 sono coperti da una eccellente blog da @Steve Losh collegate a quella domanda un po 'correlato .

L'unico grande vantaggio di 1 rispetto alle altre scelte è che non richiede alcuna ricostruzione quando si passa da lavorare su una cosa all'altra, perché i file sono fisicamente separate e indipendenti. Quindi è davvero l'unica scelta se, per esempio, A e / o B tocca un file di intestazione che definisce un valore booleano tre stati ed è incluso da migliaia di file C (non mi dire che non hanno visto un tale codice legacy base).

3 è probabilmente il più facile (in termini di messa a punto e spese generali), e si può capovolgere l'ordine di A e B se B è un piccolo e / o urgenti correzione. Tuttavia si può ottenere difficile se A e B tocca lo stesso file (s). E 'facile da grossi pezzi di patch correzione che non ha applicato, se A e B sono ortogonali cambiamenti all'interno dello stesso file (s), ma concettualmente è ancora un po' rischioso.

4 può dare le vertigini, ma è il modo più potente e flessibile e scalabile. Ho predefinita hg qinit con -c perché voglio patch mark work-in-progress e spingere / tirare, ma ci vuole un salto concettuale per rendersi conto che si può diramarsi in MQ Repo troppo. Ecco i passaggi (mq = hg --mq):

  1. hg qnew bugA; apportare modifiche per A; hg qref
  2. mq branch branchA; hg qci
  3. hg qpop; mq up -rtip^
  4. hg qnew bugB; apportare modifiche per B; hg qref
  5. mq branch branchB; hg qci
  6. di lavorare su un nuovo: hg qpop; mq up branchA; hg qpush

Sembra pazzesco di prendere tanti passi, e ogni volta che è necessario lavorare interruttore è necessario hg qci; hg qpop; mq up <branch>; hg qpush. Ma considerare questo: avete diversi rami di rilascio di nome nello stesso repository, e avete bisogno di lavorare su diversi progetti e correzioni di bug, allo stesso tempo per tutti loro (è meglio avere bonus per questo tipo di lavoro garantiti). Faresti perde molto presto con gli altri approcci.

Ora i miei compagni di amanti HG, ci sono altre alternative / migliori?

(UPDATE) qqueue fa quasi # 4 obsoleti. Descrizione elegante di vedere Steve Losh qui .

È stato utile?

Soluzione 2

Sembra che non ci sono scelte più o migliori di quelle che ho elencato nella questione. Quindi sono qui di nuovo.

  1. Usa un clone per progetto.
    • Pro:. Separazione totale, quindi non ricostruire quando si passa progetti
    • Contro:. Esigenze toolchain per passare tra due cloni
  2. Usa anonima o rami con nome, o segnalibri, nello stesso repository.
    • Pro: hg standard (o qualsiasi DVCS) pratica; pulito e chiaro.
    • Contro:. Deve impegnarsi prima di passare e ricostruire dopo
  3. Usa MQ con una patch (o più patch consecutivi) per progetto.
    • Pro:. Semplice e facile
    • Contro: must qrefresh prima commutazione e ricostruire dopo; difficile e rischioso, se i progetti non sono ortogonali.
  4. Usa un ramo MQ (o qqueue in 1.6 +) per progetto.
    • Pro: ultra flessibile e scalabile (per il numero di progetti simultanei)
    • Contro: mosto qrefresh e qcommit prima commutazione e ricostruire dopo; si sente complicato.

Come sempre, non c'è pallottola d'argento, in modo da scegliere e scegliere quella giusta per il lavoro.

(UPDATE) Per chi è innamorato di MQ, utilizzando MQ in cima rami regolari (# 2 + # 3) è probabilmente il più comune e la pratica preferibile.

Se si dispone di due progetti concorrenti con riferimento sulla due rami (ad esempio il prossimo rilascio e versione attuale), è banale per hop tra loro in questo modo: 

hg qnew; {coding}; hg qrefresh; {repeat}
hg qfinish -a
hg update -r <branch/bookmark/rev>
hg qimport -r <rev>; {repeat}

Per l'ultimo passo, qimport dovrebbe aggiungere un'opzione -a di importare una linea di changeset in una sola volta. Spero Meister Geisler accorge questo:)

Altri suggerimenti

avrei sempre usare rami con nome, perché questo permette Mercurial fare il suo lavoro: per mantenere la storia del progetto, e per ricordare il motivo per cui hai fatto che cambia in quale ordine al codice sorgente. Se avere un clone o due seduti sul vostro disco è generalmente facile, dato il mio stile di lavoro, almeno:

  1. Il vostro progetto manca un processo di generazione, in modo da poter testare ed eseguire le cose a posto dal codice sorgente? Poi sarò tentati di avere solo un clone, e ritorno hg up e indietro quando ho bisogno di lavorare su un altro ramo.

  2. Ma se si dispone di un buildout, virtualenv, o altra struttura che viene costruito, e che potrebbero discostarsi tra i due rami, poi facendo un hg up poi in attesa del processo di generazione di ri-run può essere un dolore grande , soprattutto se le cose come la creazione di un database di esempio sono coinvolti. In quel caso avrei sicuramente usare due cloni, uno seduto sulla punta del tronco, e uno seduto sulla punta del ramo funzione di emergenza.

Quindi la domanda è, nel momento in cui vi viene detto di smettere di lavorare in funzione di A, e cominciare indipendenti caratteristica B, quali opzioni alternative ci sono, per:? Come gestire lo sviluppo in concomitanza con Mercurial

Guardiamo il problema con la concorrenza rimosso, allo stesso modo in cui si scrive filettato code-definiscono un semplice flusso di lavoro per risolvere qualsiasi problema dato a voi, e applicarlo ad ogni problema. Mercurial si unirà al lavoro, una volta che è fatto. Quindi, il programmatore Un lavorerà sulla funzione A. programmatore B lavorerà sulla funzione B. Entrambi appena capita di essere voi. (Se solo avessimo cervelli multi-core:)

  

avrei sempre usare rami con nome, perché questo permette Mercurial fare il suo lavoro: per mantenere la storia del progetto, e per ricordare il motivo per cui hai fatto che cambia in quale ordine al codice sorgente.

Sono d'accordo con il sentimento di Brandon, ma mi chiedo se ha trascurato questa caratteristica A non è stato testato? Nel caso peggiore, essa compila codice e passa unit test, ma alcuni metodi implementano i requisiti precedenti, e alcuni metodi implementano quelli nuovi. A diff contro il precedente check-in è lo strumento che utilizzerebbe per aiutarmi a tornare in pista con la caratteristica a.

è il codice per la funzione A a un punto in cui si sarebbe normalmente il check in? Il passaggio da funzione A a lavorare su funzionalità di B non è un motivo per commettere il codice per la testa o ad un ramo . Solo il check-in codice che compila e passa i test. La mia ragione è, se i bisogni programmatore C per iniziare caratteristica C, un checkout fresco di questo ramo non è più il posto migliore per iniziare. Come mantenere il teste ramo sano, significa che è possibile rispondere rapidamente, con più affidabile correzioni di bug.

L'obiettivo è di avere il vostro codice (testato e verificato) in esecuzione, così si vuole tutto il codice per finire fusa nella testa (del vostro sviluppo e legacy rami). Il mio punto sembra essere, ho visto ramificazione usato in modo inefficiente: codice diventa stantio e poi non utilizzati, l'unione diventa più duro del problema originale.

Solo l'opzione 1 ha senso per me. In generale:

  1. Si dovrebbe pensare tue opere di codice, prima che qualcun altro lo vede.
  2. Favorire la testa sopra un ramo.
  3. Branch e check-in se qualcun altro sta prendendo il problema.
  4. Branch se il vostro sistema o tester automatizzato bisogno solo di codice.
  5. Branch se si fa parte di una squadra, lavorando su un problema. Consideratelo la testa, vedere 1-4.

Con l'eccezione dei file di configurazione, i processi di build dovrebbe essere una cassa e un singolo comando build. Non dovrebbe essere più difficile da passare tra i cloni, che per un nuovo programmatore aderire al progetto. (Devo ammettere che il mio progetto ha bisogno di qualche lavoro qui.)

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top