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

98

Si tengo un montón de cambios no confirmados y quiero dejarlos de lado mientras trabajo en otra cosa, y luego (después de varios días) volver a ellos y seguir trabajando. ¿Cuál sería el flujo de trabajo más sencillo 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.

Erik
fuente

Respuestas:

133

Tienes varias opciones:

  1. Guarde 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"
    

    Actualizar / Editar : Es posible que sea necesario usar versiones más nuevas de mercurial

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

    Todavía puede usarlo --namecomo una alternativa -n, pero Mercurial ya no parece gustarle --name. Además, --allya no es necesario y Mercurial se asustará con él.

  2. Ponga en cola los elementos usando mq. Esto no es muy diferente para archivarlo 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 tarde. Cuando se presionan, los parches son conjuntos de cambios lógicos, cuando se abren, se guardan en otro lugar y no forman parte del historial de conjuntos de cambios.

    hg qnew "UnfinishedWork"
    hg qrefresh
    hg qpop
    
    hg qpush "UnfinishedWork"
    
  3. Confírmelos localmente, actualice al conjunto de cambios anterior y continúe trabajando y haga uso de ramas anónimas (o múltiples cabezas). Si luego desea los cambios, puede fusionar cabezas. Si no desea los cambios, puede eliminar 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. Confíelos a una rama con nombre. El flujo de trabajo pasa a ser el mismo que en la opción 3: fusionar o eliminar cuando esté listo.

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

Personalmente, uso la opción 3 o 4, ya que no me importa eliminar los conjuntos de cambios o registrar el código parcial (siempre que eso no se presione finalmente). Esto se puede utilizar junto con la nueva fase material de para ocultar sus conjuntos de cambios locales de otros usuarios si es necesario.

También utilizo el rebasecomando para mover conjuntos de cambios para evitar fusiones donde una fusión no agregaría nada al historial del código. Fusiones Tiendo a ahorrar para la actividad entre ramas importantes (como las ramas de lanzamiento) o la actividad de una rama de características de mayor duración. También está el histeditcomando que uso para comprimir conjuntos de cambios donde la "charla" de ellos reduce el valor.

Las colas de parches también son un mecanismo común para hacer esto, pero tienen semántica de pila. Usted empuja y abre parches, pero un parche que está "debajo" de otro parche en la pila requiere que el que está en la parte superior también se inserte.

Advertencia , al igual que con todas estas opciones, si los archivos tienen más cambios desde los cambios temporales que ha dejado en la estantería / en la cola / ramificado, se requerirá una resolución de fusión al deshacer la estantería / empujar / fusionar.

Adam Houldsworth
fuente
Gracias por la gran respuesta y los útiles ejemplos. ¿Sabe si el uso de marcadores hg también es una opción?
Erik
@Erik Posiblemente, pero no tengo experiencia usándolo.
Adam Houldsworth
2
Los marcadores se pueden usar para ayudar con la opción 3: puede usar uno para etiquetar la revisión que creó para guardar el cambio. No pueden hacer la tarea por sí mismos.
Steve Kaye
--allno se reconoce la opción . es un comportamiento predeterminado archivar todos los cambios de todos modos.
naXa
@naXa Hola amigo, si uno de mis comandos está un poco mal (tal vez porque la versión ha cambiado), no dude en editar la respuesta y la aprobaré si es necesario :-)
Adam Houldsworth
23

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

  1. No me gusta la ramificación de clones porque me gusta que cada proyecto tenga solo un directorio. Trabajar en diferentes directorios al mismo tiempo arruina completamente el historial de archivos recientes de mis editores. Siempre termino cambiando el archivo incorrecto. Así que ya no hago eso.
  2. Lo uso shelvepara arreglos rápidos (solo para mover mis cambios no comprometidos a otra rama, si me doy cuenta de que estoy en la incorrecta). Estás hablando de días, de ninguna manera dejaría algo por días.
  3. Creo que mqes demasiado complicado para una situación tan ordinaria.

Creo que la mejor manera es simplemente confirmar los cambios, luego volver al conjunto de cambios antes de comenzar estos cambios y trabajar desde allí. Hay algunos problemas menores, permítanme ilustrar:

Supongamos que tiene el conjunto de cambios A. Luego comienza los cambios. En este punto, debe dejarlo a un lado por un tiempo. Primero que nada, compromete tu trabajo:

hg ci -m "Working on new stuff"

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

hg bookmark new-stuff

Regrese al conjunto de cambios antes de estas modificaciones

hg update A

Desde aquí, trabaja y genera el conjunto de cambios C. Ahora tiene 2 cabezas (B y C), se le advertirá cuando intente presionar. Puede enviar solo una rama especificando el encabezado de esa rama:

hg push -r C

O puede cambiar la fase de la new-stufframa a secreta. No se enviarán conjuntos de cambios secretos.

hg phase -r new-stuff --secret --force
Rafael Piccolo
fuente
¡Gracias por la respuesta detallada! Realmente me gusta leer los flujos de trabajo de las personas para esos problemas (¿ordinarios?).
Erik
Creo que mqes un poco complicado solo para esta situación, pero tiene una amplia gama de usos, incluido este, que vale la pena invertir el tiempo para dominarlo.
Norman Gray
12

Para mantener los cambios locales no comprometidos, la forma más fácil para mí es guardarlos como un archivo de parche.

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

y cuando necesite volver al estado anterior:

hg up <REV_WHERE_SAVED>
hg patch --no-commit /tmp/<REV_WHERE_SAVED>.patch
mapcuk
fuente
Me desnudaría /tmpy hg id -itambién funcionará en Windoze.
anatoly techtonik
Y hg upno se necesita allí.
anatoly techtonik
1
@techtonik ¿Qué pasaría si aplico el parche en otra revisión? Especialmente si se modifican los archivos parcheados.
mapcuk
Mercurial intentará fusionarlo y tendrás que lidiar con el conflicto de todos modos.
anatoly techtonik
6

Puede clonar su repositorio varias veces. Tiendo a tener un clon raíz, luego varios hijos de allí. Ejemplo:

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

Los 4 hijos son todos clonados desde la raíz y empujan / tiran hacia / desde la raíz. La raíz luego empuja / extrae del repositorio maestro en la red / Internet en algún lugar. La raíz actúa como una especie de área de preparación personal.

Entonces, 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 estaría usando DVCS en absoluto de todos modos;) Ah, y contamina la lista de "proyectos recientes" de Visual Studio, pero qué diablos.

[Editar los siguientes comentarios]: -

Para concluir entonces ... lo que estás haciendo está completamente bien y es normal. Yo diría que es la mejor manera posible de trabajar cuando se cumplen las siguientes condiciones: 1) es de corta duración 2) no es necesario colaborar con otros desarrolladores 3) los cambios no necesitan salir de su PC hasta que se confirmen / empujar el tiempo.

nbevans
fuente
¿Alguna razón para no utilizar sucursales? Para esto son y son considerablemente más rápidos que la clonación de repositorios.
Adam Houldsworth
En mi pregunta dije lo siguiente: Mi método habitual era crear una nueva rama usando clon, pero podría haber mejores formas.
Erik
1
@AdamHouldsworth, técnicamente estas son ramas ... solo de corta duración. Hacer una rama con nombre para un trabajo de corta duración es completamente estúpido. Abusa del propósito denominado ramas que son para historias de trabajo de larga duración.
nbevans
@NathanE Si cree que las ramas con nombre para trabajos de corta duración son "completamente estúpidas", entonces también hay ramificaciones anónimas, estanterías o la cola de parches como otras opciones ligeras. Volver a clonar, en mi opinión, es igualmente estúpido frente a otras opciones: un beneficio potencial es tener dos conjuntos de código abiertos en dos instancias de VS, pero rara vez tengo que hacer esto, por lo que usar clones como una cuestión de rutina no lo hace. me sirvas. Solo para aclarar, no fui el votante negativo.
Adam Houldsworth
@NathanE Tampoco son exclusivos de las "historias de trabajo de larga duración", eso es algo en lo que son buenos si sigues la integración continua. Directamente de los documentos : "Las ramas ocurren si las líneas de desarrollo divergen", si está archivando un elemento de trabajo para trabajar en otra cosa, esto me suena a divergencia, independientemente de la duración que tenga.
Adam Houldsworth