Comment maintenir des changements non engagés dans un référentiel mercuriel local, tout en poussant / tirant?

Question

Si je travaille sur des fichiers que je ne veux pas commettre, je les sauve. J'ai ensuite d'autres fichiers que je souhaite pousser vers le serveur, mais si quelqu'un d'autre a apporté des modifications au référentiel, et je les retire vers le bas, il me demande de fusionner ou de réprimander. Mais l'une ou l'autre de ces options me fera perdre mes changements locaux que je n'ai pas commis.

Que font les autres pour contourner cela? Je trouve difficile la documentation de l'extension des étagères pour comprendre.

Remarque: j'utilise Mercurial Eclipse pour pousser et extraire des fichiers vers / depuis le serveur.

Toute explication de cela serait grandement appréciée! Merci!

---

Exemple:

Je travaille sur mon site Web dans Mercurial Eclipse. J'ai un nouveau dossier et de nouveaux fichiers que je ne veux pas encore m'engager sur le serveur. J'ai également modifié certains fichiers existants et je ne veux pas encore dire ces modifications en direct.

Ensuite, quelque chose sur mon site Web se casse et je dois le réparer, il ne me laissera pas le réparer sans reprendre ou fusionner avec le pointeur le plus récent du référentiel et cela me fera perdre tous mes changements non engagés.

Que dois-je faire avec mon nouveau dossier et mes fichiers que j'ai édité si je ne veux pas le perdre? Le refonte semble fastidieux. La copie des fichiers dans un nouveau dossier semble également fastidieuse. Je suis sûr que les étagères ou MQ feront ce que je veux, je ne sais pas encore comment y aller.

Answer 1

Je suis sûr que quelqu'un vous aidera à trouver une mauvaise solution de contournement, mais le meilleur itinéraire est de changer vos objectifs - vous engagez. Le code qui n'a pas été commis n'a pas été écrit. Si vous ne pouvez pas demeurer positivement d'avoir des engins fréquents dans votre histoire, utilisez des files d'attente mercuriel avec un référentiel de file d'attente et commettez-le. Vous pouvez ensuite faire éclater les ensembles de changes, pousser / pull / fusionner, et les repousser, et tout ce dont vous êtes un travail précieux sera commis dans la file d'attente du patch.

Answer 2

En ce qui concerne votre exemple, voici ce que je ferais (suivant la stratégie de Ry4an pour simplement commettre les choses sur lesquelles vous travaillez actuellement, mais je ne veux pas déjà publier):

Supposés que vous commencez à travailler dans un référentiel comme celui-ci:

$ hg status -A
C f1
C f2
$ hg glog
@  changeset:   1:7f3c6c86a92f
|  tag:         tip
|  summary:     add f2
|
o  changeset:   0:03ca1e6d5b86
   summary:     initial

C'est-à-dire qu'il y a 2 fichiers et 2 engagements / ensembles de change. Vous faites du travail, disons ajouter une nouvelle fonctionnalité, puis votre copie de travail pourrait ressembler à ceci:

$ hg status
M f2
? f3
? f4

Il y a 2 nouveaux et 1 fichier modifié. Vous devez maintenant corriger un bogue pour lequel vous avez également besoin de nouvelles modifications dans un référentiel distant. Instantané de votre travail actuel en le commettant et en tirant les modifications à distance (dans laquelle vous faites l'ordre qui n'a pas d'importance, une traction par défaut ne touche pas l'état de votre copie de travail):

$ hg commit -A -m "snapshot feature work"
$ hg pull

Cela peut entraîner une histoire comme celle-ci:

o  changeset:   3:2284ba62de07            <-- just pulled in
|  tag:         tip
|  parent:      1:7f3c6c86a92f
|  summary:     edit f1
|
| @  changeset:   2:4a19d371a04f          <-- your interrupted work
|/   summary:     snapshot feature work
|
o  changeset:   1:7f3c6c86a92f
|  summary:     add f2
|
o  changeset:   0:03ca1e6d5b86
   summary:     initial

Vous pouvez maintenant mettre à jour la révision 3 de la révision 3 et commencer à corriger les bogues:

$ hg update 3
.. fix the bug ..
$ hg commit -m "fix a bug"
$ hg glog --limit 3
@  changeset:   4:5d3d947fb4af
|  tag:         tip
|  summary:     fix a bug
|
o  changeset:   3:2284ba62de07
|  parent:      1:7f3c6c86a92f
|  summary:     edit f1
|
| o  changeset:   2:4a19d371a04f
|/   summary:     snapshot feature work
:

Ça a l'air bien, poussons votre solution, c'est-à-dire le rendre en direct, tout en ne publiant pas votre travail intermédiaire:

$ hg push -r 4

Cela pousse tous les changements menant à la révision 4, votre bugfix, mais pas d'autres branches de votre référentiel local. Vous pouvez également utiliser -r ., qui fait référence à la révision des parents de votre copie de travail, c'est-à-dire la révision que vous venez de commander.

Enfin, vous pouvez revenir à votre fonctionnement et continuer votre travail:

$ hg update 2
.. work, commit, work, commit ..
.. finally merge with the other branch, e.g. revision 4

Ces étapes sont sur la ligne de commande, mais je pense qu'il n'est pas difficile d'adapter le concept général aux clics correspondants dans le plugin mercurial Eclipse.

Quelques notes supplémentaires:

• Vous voudrez peut-être signet Votre instantané vous engage, vous n'avez donc pas besoin de travailler avec des identifiants ou des chiffres de révision.
• Si vous souhaitez publier votre fonctionnalité dans un seul engagement plus tard, utilisez le effondrement Extension une fois que vous avez terminé.