Mercuriali modifiche prelievo ciliegia per impegnarsi

Question

Di ', ho fatto molti cambiamenti al mio codice e solo bisogno di commettere alcuni di questi cambiamenti. C'è un modo per farlo in mercuriale? So che darcs ha una caratteristica come questo.

Lo so hg transplant può fare questo tra i rami, ma ho bisogno di qualcosa di simile per commettere il codice nel presente ramo e non quando l'aggiunta di insiemi di modifiche da un altro ramo.

Answer 1

MQ come Chad citati sono a senso unico. C'è anche soluzioni più leggere:

• estensione Record che funziona più o meno allo stesso modo di darcs record. E 'distribuito con Mercurial.
• Ripiano estensione , che consente di "accantonare" alcune modifiche, che consente di impegnarsi solo un sottoinsieme delle modifiche (quelli che non sono accantonato)

Answer 2

Se si utilizza TortoiseHg 1.x per Windows, questa funzionalità è implementata in modo bello destra, fuori dalla scatola (nessun estensioni richieste).

1. Eseguire il TortoiseHg commit Tool.
2. Scegliere un file per il quale solamente vuole commettere un sottoinsieme del suo i cambiamenti.
3. Fare clic sul Hunk scheda Selezione nel riquadro di anteprima.
4. Fare doppio clic o utilizzare la barra spaziatrice per commutazione che cambiano hunks dovrebbero essere incluso nel commettere.

---

TortoiseHg 2.x , la scheda Hunk Selection è ormai andato. Al suo posto, è il Shelve strumento . Ha un paio di più funzioni rispetto al vecchio selezione fusto. Queste nuove caratteristiche sono disponibili al costo di una certa complessità.

Si noti che non v'è alcuna necessità di abilitare esplicitamente l'estensione Mercurial Ripiano quando si utilizza questa funzione. Secondo Steve Borho (piombo TortoiseHg sviluppatore) in a una diversa domanda TortoiseHg : "Abbiamo una copia locale del prolungamento ripiano e chiamare in esso direttamente."

---

TortoiseHg 2.7 + , questa funzionalità è stata migliorata e reintrodotto. Ora è costruito direttamente nello strumento Commit:

Avviso nell'elenco dei file sul che il file in alto a sinistra viene controllato per indicare che sarà incluso, il secondo file non è selezionata, perché non sarà incluso, e il terzo file, Sample.txt, viene riempito (il Null indicatore casella di controllo), perché selezionare solo le modifiche da quel file sarà incluso nel commettere.

La modifica Sample.txt che sarà incluso viene controllato nella porzione selezione variazione inferiore destro dell'immagine. La modifica che verrà esclusa non è selezionata e la vista diff è in grigio. Si noti inoltre che l'icona per lo strumento ripiano è ancora facilmente reperibili.

Answer 3

Il tutorial Mercurial Queues è terribile per questo caso d'uso. Tutti gli esempi che ho visto suppone che si abbia ancora fare un commit e vi sono l'aggiornamento di una singola patch. La maggior parte delle volte questo non è il caso, e si dispone di 2 o 3 commit che si desidera schiacciare insieme o cambiare in qualche altro modo.

Diciamo che avere questo tipo di storia:

---O---O---A---B---C

Il primo esempio è quello di schiacciare commette A, B, e C. Prima init mq:

$ hg qinit

Ora abbiamo bisogno di "importare" i commit A, B e C nella coda patch. Assumiamo sono gli ultimi 3 commit. Possiamo usare la sintassi di revisione "-N" per importarli in questo modo:

$ hg qimport -r -3:-1

Ciò significa che l'importazione come cerotti da 3 patch di nuovo fino all'ultimo commit. È possibile controllare lo stato di queste patch con hg qseries. Esso dovrebbe mostrare qualcosa del genere:

$ hg qseries
101.diff
102.diff
103.diff

Se i numeri 101, 102 e 103 corrispondono ai numeri di revisione locali dei commit A, B e C. Ora queste patch sono applicare , che significa i cambiamenti che essi descrivono sono già in copia di lavoro. È possibile liberarsi dei cambiamenti della copia di lavoro e rimuoverli dalla storia di commit, salvandoli in unica forma di patch, utilizzando hg qpop. Si può dire che sia hg qpop; hg qpop al pop cambia C e B dallo stack, o specificare una patch per "pop a". In questo caso, sarebbe qualcosa di simile:

$ hg qpop 101.diff
now at: 101.diff

Ora avete le patch per impegna B e C in coda patch, ma non vengono applicate (le modifiche sono state "perse" - esistono solo nella zona di coda di patch). Ora si può piegare queste patch in ultimo, cioè creiamo un nuovo impegno che è l'equivalente della somma delle variazioni A + B + C.

$ hg qfold -e 102.diff 103.diff

Questo mostrerà il vostro editor in modo da poter modificare il messaggio di commit. Per impostazione predefinita, il messaggio sarà la concatenazione dei messaggi di commit per i cambiamenti A, B e C, separati da un asterisco. La cosa bella è che si hg qfold scheda-completare le patch se si utilizza bash e hanno lo script hg-completamento di provenienza. Questo lascia la storia come questa, dove A + B + C è un singolo commit che è la combinazione dei 3 patch che ci interessano:

---O---O---A+B+C

Un altro caso d'uso è se abbiamo lo stesso tipo di storia come prima, ma ci vuole far cadere cerotto B e unire A + C. Questo è abbastanza simile al precedente in realtà. Quando si arriva alla fase qfold, si sarebbe semplicemente volte negli ultimi commit piuttosto che le ultime 2 commit:

$ hg qfold -e 103.diff

Questo lascia la variazione per B nella coda patch, ma non si applica alla copia di lavoro e il suo impegno non è nella storia. Si può vedere questo eseguendo:

$ hg qunapplied
102.diff

La storia ora assomiglia a questo, dove A + C è un singolo commit che combina le modifiche A e C:

---O---O---A+C

Un caso d'uso finale potrebbe essere che è necessario applicare solo impegnarsi C. Faresti questo eseguendo il qimport come sopra, e si dovrebbe pop off tutte le patch non volevi:

$ hg qpop -a

I mezzi -a bandiera pop off tutte le patch. Ora è possibile applicare solo quello che si vuole:

$ hg qpush 103.diff

Questo ti lascia con questa storia:

---O---O---C

Una volta che hai finito con tutto questo, è necessario per finire il giocherellare coda. Questo può essere fatto con:

$ hg qfinish -a

Così ci siamo. È ora possibile eseguire hg push e impegnarsi solo esattamente quello che vuoi, o hg email una patch coerente alla mailing list.

Answer 4

Mi sento come se mi manca qualcosa perché nessuno ha suggerito questo già.

Il normale "hg commit" comando può essere usato per scegliere in modo selettivo quali a commettere (non c'è bisogno di impegnare tutte le modifiche in sospeso nella directory di lavoro locale).

Se si dispone di un insieme di modifiche in questo modo:

M ext-web/docroot/WEB-INF/liferay-display.xml
M ext-web/docroot/WEB-INF/liferay-portlet-ext.xml
M ext-web/docroot/WEB-INF/portlet-ext.xml

È possibile impegnarsi solo due di questi cambiamenti con ...

hg commit -m "partial commit of working dir changes" ext-web/docroot/WEB-INF/liferay-display.xml ext-web/docroot/WEB-INF/liferay-portlet-ext.xml

Non super conveniente dalla riga di comando perché avete a portata di mano, digitare i file di impegnarsi in modo selettivo (vs un processo di check-box GUI come tartaruga), ma si tratta di così semplice come si arriva e non richiede le estensioni. E file globbing probabilmente può aiutare a ridurre la digitazione (come sarebbe in precedenza, entrambi i file impegnati condividono in modo univoco "Liferay" nei loro percorsi.

Answer 5

È possibile utilizzare il record di estensione , che viene distribuito con Mercurial.

È necessario abilitare nel vostro ~/.hgrc primo file, aggiungendolo alla sezione [extensions]:

[extensions]
record=

Poi, basta digitare hg record invece di hg commit, e sarete in grado di selezionare le modifiche da quali file si desidera impegnarsi.

È inoltre possibile utilizzare il crecord estensione che fornisce un'interfaccia più gradevole per esaminare e selezionare i cambiamenti. (Non è distribuito con Mercurial, però, e ho visto che di tanto in tanto rovinare un commit, quindi non è del tutto privo di bug.)

Answer 6

È passato del tempo. Sembra l'opzione migliore oggi è hg commit --interactive

Answer 7

Mercurial Queues riempie questo ruolo per Mercurial. C'è una bella buon tutorial lì legato.

Answer 8

Prova QCT (Qt commit Tool). Ha una caratteristica "selezionare le modifiche" che si avvia uno strumento di unione a 3 vie per di annullare le singole modifiche. Dopo che si impegnano, tali modifiche si "slacciò" tornano.

Answer 9

commettere-patch . E 'uno script che permette di modificare il diff prima di commettere. E 'davvero bello, con Emacs di diff-mode e VC-mode.

In passato ho usato crecord, ma ha bug relativi alla unicode (in realtà l'estensione record ha gli insetti, che crecord dipende).

Answer 10

Per prima cosa dovete dimenticare tutto ciò che finora abbiamo avuto GUI e tornare alla riga di comando. Avanti da linea di comando fare questo:

hg stat> filelist.txt

Questa tubi tutti i file modificati in un file di testo chiamato filelist.txt

Avanti modificare il filelist per includere solo i file che si desidera impegnarsi.

Infine commettere utilizzando lo sytnax set di file:

hg commit "set: 'listfile: test.txt'"