Con Mercurial, come posso "comprimere" una serie di changeset in uno prima di eseguire il push?

Diciamo che ho un repository Mercurial locale e uno remoto. Ora inizio a lavorare su una funzionalità. Ci lavoro e quando penso che sia finito, metto in commit il changeset. Testandolo un po 'di più, trovo che potrei migliorare ulteriormente questa funzionalità modificando qualcosa nel codice. Faccio il cambiamento e mi impegno. 20 minuti dopo, trovo che ci sia un bug in questa nuova funzionalità, quindi lo risolvo e lo impegno anche io.

Ora ho 3 changeset che vorrei davvero inviare al repository remoto come un changeset con il messaggio "Implementing feature X", per esempio.

Come posso farlo senza troppi problemi? Credo di poterlo fare con le patch, ma mi sembra un sacco di lavoro.

Che ne dici dell'estensione Collapse ?

L' estensione histedit è esattamente quello che stai cercando.

hg histedit -o

o

hg histedit --outgoing

farà apparire un elenco dei changeset in uscita. Dalla lista puoi

• Piega 2 o più changeset creando un unico changeset
• Elimina i changeset rimuovendoli dalla cronologia
• Riordina i changeset come preferisci.

histedit ti chiederà il nuovo messaggio di commit dei gruppi di modifiche piegati che di default sono i due messaggi con "\ n *** \ n" che li separa.

Puoi anche ottenere risultati simili usando l'estensione mq, ma è molto più difficile.

Puoi anche utilizzare l'estensione di compressione per eseguire semplicemente la piegatura, ma non fornisce un'interfaccia utente così piacevole e non fornisce un modo per modificare il messaggio di commit risultante. La modifica del messaggio di commit risultante consente anche di ripulire il messaggio finale, che è qualcosa che finisco sempre per utilizzare.

Sì, puoi farlo con le patch: supponiamo che il tuo lavoro sia nei changeset da 100 a 110 inclusi

1. Crea una patch:

   % hg export -o mypatch 100:110 --git

2. Aggiorna a 99:

   % hg update 99

3. Applica la patch con --no-commit (altrimenti recupererai tutti i tuoi changeset):

   % hg import --no-commit mypatch

4. Salva tutte le modifiche in una volta:

   % hg commit

5. Ora hai due testine (110 e 111) che dovrebbero essere equivalenti in termini di file che producono nella tua directory di lavoro - magari diffonderli per sanità mentale prima di rimuovere quelli vecchi:

   % hg strip 100

OK, ora che ho spiegato tutto, sembra lungo, ma avendolo fatto un sacco di volte io stesso, non trovo che sia troppo un compito ingrato ...

Se stai usando TortoiseHg, puoi solo selezionare due revisioni (usa CTRL per selezionare quelle non successive), fare clic con il tasto destro e selezionare "Comprimi cronologia" .

Dopodiché otterrai un nuovo elenco di modifiche nella nuova intestazione a partire dalla prima modifica selezionata in precedenza, conterrà tutti gli elenchi di modifiche discendenti tra quelli selezionati.

Puoi semplicemente eliminare i vecchi elenchi di modifiche se non ne hai più bisogno: usa le estensioni MQ per questo. Di nuovo, in TortoiseHg: fai clic con il pulsante destro del mouse sulla prima lista di modifiche che deve essere spogliata con tutti i suoi discendenti, "Modifica cronologia -> Rimuovi" .

Il mio metodo preferito per utilizzare mq per questa piegatura è utilizzare TortoiseHg come descritto qui . Tuttavia, può essere facilmente eseguito dalla riga di comando in questo modo:

hg qimport -r <first>:<last> 
    -- where <first> and <last> are the first and last changesets 
    -- in the range of revisions you want to collapse

hg qpop <first>.diff
    -- remove all except for the first patch from the queue
    -- note: mq names patches <#>.diff when it imports them, so we're using that here

hg qfold <next>.diff
    -- where <next> is <first>+1, then <first>+2, until you've reached <last>

hg qfinish -a
    -- apply the folded changeset back into the repository

(Potrebbe esserci un modo migliore per eseguire il passaggio qfold, ma non ne sono a conoscenza, poiché di solito uso TortoiseHg per quell'operazione.)

All'inizio sembra un po 'complicato, ma una volta che hai iniziato a usare mq, è abbastanza semplice e naturale - inoltre puoi fare ogni genere di altre cose con mq che possono essere molto utili!

hg collapsee hg histeditsono i modi migliori. O, piuttosto, sarebbero i modi migliori, se funzionassero in modo affidabile ... Sono riuscito histedita bloccarmi con uno stack dump entro tre minuti. Collapsenon è molto meglio.

Ho pensato di poter condividere altri due BKM:

1. hg rebase --collapse

   Questa estensione è distribuita con Mercurial. Non ho ancora avuto problemi con esso. Potrebbe essere necessario giocare ad alcuni giochi per aggirare le hg rebaselimitazioni: in pratica, non gli piace ribasare a un antenato sullo stesso ramo, denominato o predefinito, sebbene lo consenta se si ribasano tra rami (denominati).

2. Spostare il repository ( foo/.hg) nella directory di lavoro ( bar) e nei suoi file. Non il contrario.

Alcune persone hanno parlato della creazione di due alberi clone e della copia dei file tra di loro. O rattoppare tra di loro. Invece, è più facile spostare le .hgdirectory.

hg clone project work
... lots of edits
... hg pull, merge, resolve
hg clone project, clean
mv work/.hg .hg.work
mv clean/.hg work/.hg
cd work
... if necessary, pull, nerge, reconcile - but that would only happen because of a race
hg push

Questo funziona fintanto che i veri repository, gli .hgalberi, sono indipendenti dalla directory di lavoro e dai suoi file.

Se non sono indipendenti ...

Non ho mai usato Mercurial, ma suona molto simile a ciò di cui parlava Martin Fowler sul suo blog non molto tempo fa:

http://martinfowler.com/bliki/MercurialSquashCommit.html

Perché non solo hg strip --keepcomando?

Quindi puoi eseguire il commit di tutte le modifiche come un unico commit.

HistEdit farà quello che vuoi, ma probabilmente è eccessivo. Se l'unica cosa di cui hai bisogno è piegare insieme alcuni changeset, l' estensione Collapse farà il lavoro.

Supponiamo di avere due commit inediti THISe THATin Mercurial e che si vogliano unire in un unico commit al THISpunto ::

... --> THIS --> ... --> THAT --> ... --> LAST

Verifica che i tuoi commit non siano pubblicati:

$ hg glog -r "draft() & ($THIS | $THAT)"

Aggiorna per LASTeseguire il commit:

$ hg up

e importa commit fino a THISMQ:

$ hg qimport $THIS::.

Annulla l'applicazione di tutte le patch e applica solo prima THIS:

$ hg qpop -a
$ hg qpush
$ hg qapplied
... THIS ...

Unisciti a THAT:

$ hg qfold $THATNAME

NOTA Per trovare il nome THATNAMEutilizzare:

$ hg qseries

Applica tutte le patch e spostale nella cronologia del repository:

$ hg qpush -a
$ hg qfinish -a

Il mio post sul blog sull'argomento è Unire due commit in Mercurial .

Sì, strip --keepfunziona per la domanda dell'autore. Ma era leggermente diverso dagli altri, ad esempio, se hai la versione da 1 a 30 ma vuoi solo comprimere la versione 12-15. Altre soluzioni funzionano ma non strip --keep.