¿Cómo puedo dejar de lado un montón de cambios no comprometidos mientras trabajo en otra cosa?

Question

Si tengo un montón de cambios no comprometidos y quiero dejarlos de lado mientras trabajo en otra cosa, y luego (después de varios días) vuelvo a eso y sigue trabajando. ¿Cuál sería el flujo de trabajo más fácil para lograr esto? (Hasta ahora solo tengo experiencia con la funcionalidad básica de Mercurial). Mi método habitual era crear una nueva rama usando clon, pero podría haber mejores formas.

Answer 1

usted tiene un puñado de opciones:

1. Shelve los artículos. Esto guarda los cambios y los elimina del directorio de trabajo para que la rama pueda continuar. No crea un conjunto de cambios.

   hg shelve --all --name "UnfinishedChanges" 
   
   hg unshelve --name "UnfinishedChanges" 
   

   actualización/Editar: Las nuevas versiones de mercurio pueden necesitar utilizar

   hg shelve -n "UnfinishedChanges" 
   hg unshelve "UnfinishedChanges" 
   

   Puede seguir utilizando --name como una alternativa a -n, pero Mercurial no parece que les gusta --name más. Además, el --all ya no es necesario y mercurial enloquecerá.

2. Patch queue los elementos que usan mq. Esto no es muy diferente a dejar de lado en algunos aspectos, pero se comporta de manera diferente. El resultado final es el mismo, los cambios se eliminan y opcionalmente se pueden volver a aplicar más adelante. Cuando se presionan, los parches son conjuntos de cambios lógicos, cuando aparecen, se guardan en otro lugar y no forman parte del historial del conjunto de cambios.

   hg qnew "UnfinishedWork" 
   hg qrefresh 
   hg qpop 
   
   hg qpush "UnfinishedWork" 
   

3. cometerlos localmente, actualizar al cambio-set anterior y seguir trabajando y hacer uso de las ramas anónimos (o múltiples cabezas). Si luego quieres los cambios, puedes combinar jefes. Si no desea los cambios, puede strip el conjunto de cambios.

   hg commit -m"Commiting unfinished work in-line." 
   hg update -r<previous revision> 
   
   hg strip -r<revision of temporary commit> 
   

4. Commitas a una sucursal con nombre. El flujo de trabajo se convierte en el mismo que en la opción 3: fusionar o pelar cuando esté listo.

   hg branch "NewBranch" 
   hg commit -m"Commiting unfinished work to temporary named branch." 
   hg update <previous branch name> 
   

Personalmente utilizo la opción 3 o 4 como que no me importa despojar cambio en sets o el check-in de código parcial (siempre y cuando eso no finalmente conseguir presionado). Esto se puede usar junto con las nuevas cosas Phase para ocultar sus conjuntos de cambios locales de otros usuarios si es necesario.

También uso el comando rebase para mover conjuntos de cambios para evitar fusiones donde una fusión no agrega nada al historial del código. Fusiones Tiendo a ahorrar para la actividad entre ramas importantes (como ramas de publicación) o actividad de una rama de características de mayor duración. También está el comando histedit que uso para comprimir conjuntos de cambios donde el "chattiness" de ellos reduce el valor.

Las colas de parche también son un mecanismo común para hacer esto, pero tienen una semántica de pila. Usted empuja y hace estallar parches, pero un parche que está "debajo" de otro parche en la pila requiere que también se empuje el que se encuentra encima.

Advertencia, al igual que con todas estas opciones, si los archivos tienen más cambios desde los cambios temporales que usted ha archivado/cola/ramificado, habrá fusionar resolución requerida cuando un-estantería/empujar/fusión.

Answer 2

Puede clonar su repositorio varias veces. Tiendo a tener un clon de raíz, luego múltiples hijos a partir de ahí. Ejemplo:

• MyProject.Root
• MyProject.BugFix1
• MyProject.BugFix2
• MyProject.FeatureChange1
• MyProject.FeatureChange2

Los 4 childs están todos clonó a partir de la raíz y empujar/tirar hacia/desde la raíz. La raíz luego push/pulls del repositorio maestro en la red/internet en algún lugar. La raíz actúa como tu tipo de área de preparación personal.

Por lo tanto, en su caso, simplemente clonaría un nuevo repositorio y comenzaría a trabajar. Deje su trabajo 'archivado' solo en el otro repositorio. Es así de simple.

El único inconveniente es el uso de espacio en disco, pero si eso fuera una preocupación, no usaría DVCS de todos modos;) Ah, y de alguna manera contamina su lista de "proyectos recientes" de Visual Studio, pero ¿qué pasa? .

[Editar siguientes comentarios]: -

Para concluir entonces ... lo que está haciendo es completamente bien y normal. Yo diría que es la mejor manera de trabajar cuando los siguientes son verdaderos: 1) es de corta duración 2) no es necesario que colabores con otros desarrolladores 3) los cambios no tienen que salir de tu PC hasta que se comprometan/tiempo de empuje.

Answer 3

Personalmente, no me gusta ninguna de las respuestas publicadas hasta ahora:

1. no me gusta clon de ramificación porque me gustaría que cada proyecto tiene solamente una directorio. Trabajar en diferentes directorios al mismo tiempo arruina completamente el historial de los archivos recientes de mis editores. Siempre termino cambiando el archivo incorrecto. Entonces ya no hago eso.
2. Uso shelve para soluciones rápidas (solo para mover mis cambios sin compromiso a otra rama, si me doy cuenta de que estoy equivocado). Estás hablando de días, de ninguna manera dejaría algo durante días.
3. creo mq es demasiado complicado para un sittuation tales ordinaria

Creo que la mejor forma de hacerlo es simplemente confirmar los cambios, lo que vuelve al conjunto de cambios antes de iniciar estos cambios y trabajar desde allí. Hay algunos problemas menores, déjenme ilustrar:

Digamos que usted tiene el conjunto de cambios A. Luego de comenzar los cambios. En este punto, desea dejarlo de lado por un tiempo. En primer lugar, comprometer su trabajo:

hg ci -m "Working on new stuff" 

Si lo desea, puede agregar un marcador para que sea más fácil para volver más tarde. Siempre creo marcadores en mis ramas anónimas.

hg bookmark new-stuff 

Vuelve al conjunto de cambios antes de que estas modificaciones

hg update A 

Desde aquí, trabajar y generar el conjunto de cambios C. Ahora usted tiene 2 cabezas (B y C), se le avisará cuando intentas empujar Usted puede empujar una sola rama, especificando la cabeza de esa rama:

hg push -r C 

O puede cambiar la fase de la rama new-stuff a secreto. Los conjuntos de cambios secretos no serán empujados.

hg phase -r new-stuff --secret --force 

Answer 4

Para mantener los cambios uncommited locales, forma más fácil para mí es sólo para guardarlos como un archivo de revisión.

hg diff > /tmp/`hg id -i`.patch 

y cuando se necesita para volver al estado anterior:

hg up <REV_WHERE_SAVED> 
hg patch --no-commit /tmp/<REV_WHERE_SAVED>.patch