Hg: Comment faire un rebase comme git du rebase

Dans Git, je peux le faire:

1. Commencer à travailler sur une nouvelle fonctionnalité: 
$ git co -b newfeature-123 # (un local de développement de la branche) 
faire quelques commits (M, N, O) 

maître A---B---C 
\ 
newfeature-123 M---N---O 

2. Tirez sur les nouveaux changements de l'amont maître: 
$ git pull 
(master mis à jour avec ff-commits) 

maître A---B---C---D---E---F 
\ 
newfeature-123 M---N---O 

3. Rebase de master ainsi que ma nouvelle fonctionnalité 
peut être mis au point contre les derniers changements en amont: 
(à partir de newfeature-123) 
$ git rebase maître 

maître A---B---C---D---E---F 
\ 
newfeature-123 M---N---O

Je veux savoir comment faire la même chose dans Mercurial, et j'ai écumé le web pour une réponse, mais le meilleur que j'ai pu trouver était: git rebase - peut hg faire

Ce lien donne 2 exemples:

1. Je vais vous avouer que cela: (en remplacement de la révision à partir de l'exemple avec ceux de mon propre exemple)

hg jusqu'-C F 
hg branche -f newfeature-123 
hg greffe -a-b newfeature-123

est pas trop mal, sauf qu'il laisse derrière lui le pré-rebase M-Pas comme un dissociées de la tête et crée 3 nouveaux commits M',N',O' qui les représentent embranchement à partir de la mise à jour de la ligne principale.

Fondamentalement, le problème est que je me retrouve avec ceci:

maître A---B---C---D---E---F 
\ \ 
newfeature-123 \ M'---N---O' 
\ 
newfeature-123 M---N---O

ce n'est pas bon parce qu'il laisse derrière local, indésirables s'engage à ce que devrait être abandonnée.

L'autre option à partir du même lien est

hg qimport -r M:O 
hg qpop -un 
hg jusqu'F 
hg branche newfeature-123 
hg qpush -un 
hg qdel -r qbase:qtip

et cela a pour conséquence le graphique souhaité:

maître A---B---C---D---E---F 
\ 
newfeature-123 M---N---O

mais ces commandes (tous les 6 d'entre eux!) l'air beaucoup plus compliqué que

$ git rebase maître

Je veux savoir si c'est le seul équivalent en Hg ou si il y a une autre manière qui est simple comme Git.

"ce n'est pas bon parce qu'il laisse derrière local, indésirables s'engage à ce que devrait être abandonnée." - en fait, git fait la même chose. Il ne permet pas de modifier ou de supprimer les commits dans l'origine de la branche, il est tout à fait nouvelles qui s'appliquent de la même série de changements sur le dessus de maître. Vous pouvez toujours accéder à l'ancienne à l'aide de git reflog et ils ne sont pas totalement disparu jusqu'à ce qu'ils obtiennent des ordures collectées. Si vous souhaitez les conserver dans une branche nommée, de sorte que vous n'avez pas à utiliser le reflog, il suffit de faire git branch feature-123_original avant le changement d'année de base.
Question au hasard: avez-vous ascii-dessiner les ensembles de modifications/branches vous-même ou est-il un outil qui le fait?
Juste fait moi-même avec TextWrangler mis à "écraser."

InformationsquelleAutor jpswain | 2010-04-20

233

VonC a la réponse que vous cherchez, le Rebase Extension. Il est, cependant, la peine de dépenser une seconde ou deux de réflexion sur le pourquoi ni mq ni rebase sont activés par défaut dans mercurial: comme mercurial est tout au sujet indélébile révisions. Quand je travaille de la manière que vous décrivez, ce qui est presque tous les jours, voici le modèle que j'ai à prendre:
```
1. Start working on a new feature:
$ hg clone mainline-repo newfeature-123
do a few commits (M, N, O)

master A---B---C
                \
newfeature-123   M---N---O

2. Pull new changes from upstream mainline:
$ hg pull

master A---B---C---D---E---F
                \
newfeature-123   M---N---O

3. merge master into my clone so that my new feature 
can be developed against the latest upstream changes:
(from newfeature-123)
$ hg merge F

master A---B---C---D---E---F
                \           \
newfeature-123   M---N---O---P
```
et c'est vraiment tout ce qui est nécessaire. Je me retrouve avec un newfeature-123 clone, je peux facilement pousser vers le réseau principal quand je suis heureux avec elle. Plus important encore, cependant, je n'a jamais changé l'histoire. Quelqu'un peut regarder mon csets et voir ce qu'ils ont été à l'origine codage et de la façon dont j'ai réagi à des changements dans la canalisation principale tout au long de mon travail. Tout le monde ne pense qu'a de la valeur, mais je suis un croyant ferme que c'est le travail de contrôle de source pour nous montrer pas ce que nous voulions était arrivé, mais ce qui s'est réellement passé, chaque cul-de-sac et de tous les refactoriser doit laisser une trace indélébile, et la relocalisation et d'autres de l'histoire des techniques de montage cacher.

Maintenant aller chercher VonC de réponse alors que j'ai mis ma boîte à savon loin. 🙂
- Remarque: bien sûr, Git n'est pas exactement vous permettent de réécrire l'histoire, seulement pour créer un facilement (utcc.utoronto.ca/~cks/espace/blog/tech/GitNewHistory). En ajoutant le RebaseExtension, Mercurial fournit exactement la même façon commode de remplacer une vieille histoire par un nouveau. Pourquoi? Parce qu'une fusion n'est pas toujours la bonne réponse, surtout quand votre révision doit être considérée comme évolutions sur le dessus de F, et non l'inverse (P fusionné sur le dessus de O)
- VonC, je suis d'accord, une fusion n'est pas toujours le bon choix, mais je pense que la différence est ce que l'on veut un VCS de l'histoire, pour être en mesure de le leur dire. Je pense que l'histoire doit toujours être en mesure de répondre à des questions comme "Quel était ce moyen, j'ai essayé de l'intégrer au début, cela n'a pas fonctionné, et j'ai pensé était inutile à l'heure". Les scientifiques gardez journaux de bord à la plume avec des pages numérotées, et AFAIC les ingénieurs en logiciel doit enregistrer chaque octet ai jamais tapé. Réécriture de l'histoire, même cset la filiation, mais certainement CollapseExtension, HistEdit, etc. en violent. C'est totalement une question de choix personnel.
- +1 pour le choix personnel. Avec Git-je utiliser par conséquent rebase pour trivial diverge et de fusion pour les non-trivial. Cela me permet de les préserver de fusion de l'histoire où je me sens est important, mais gardez le journal propre et linéaire, la plupart du temps.
- Aussi, je fais des tonnes de interactive rebases parce que j'ai tendance à d'abord faire beaucoup de petits engage, pour ensuite se rejoindre, l'étiquette et les nettoyer, puis les fusionner avec (ou rebase sur le dessus de) la branche principale. J'aime le codage et la gestion des changements à séparer les étapes.
- Si la fusion s'engage jamais de nuage de ma vision, je viens d'utiliser le --no-merges option disponible sur la plupart des cset liste des commandes, mais comme nous sommes tous en disant que c'est entièrement une question de préférence personnelle dans les deux git et Mercurial.
- Le "enregistrer chaque octet le long de la trajectoire de développement de" la philosophie n'est pas vraiment approprié pour les grands projets open-source, où les contributeurs proposent un ensemble de correctifs, puis retravailler en fonction de la rétroaction des responsables. Puis finalement le principal projet de référentiel a juste la bonne version de tous les changements, avec tous les changements liés à un seul commit. git rebase interactif est vraiment bon pour le nettoyage de travail se transforme en une séquence de commits qui ne laissent pas de l'arbre cassé, et avec des messages de commit reflet de ce que vous décidez à-dire après que vous avez terminé de travailler sur l'ensemble de la chose.
- Sachant que vous avez fait une erreur à un moment n'aide personne dans deux semaines. Indélébile, les révisions ne sont pas utiles.
InformationsquelleAutor Ry4an Brase
102

Vous pourriez être à la recherche pour Rebase Extension. (mis en œuvre dans le cadre de la SummerOfCode 2008)

Dans ces cas, il peut être utile de "détacher" les changements locaux, de synchroniser le référentiel général puis ajouter le privé changements sur le dessus de la nouvelle télécommande changements. Cette opération est appelée rebase.

L'obtention de:

à:

Comme commenté ci-dessous par steprobe:

Dans le cas où vous n'êtes pas en tirant les changements, et vous avez les deux branches dans votre pension, vous pouvez le faire (à l'aide de keepbranches):
```
hg up newfeature-123 
hg rebase -d master --keepbranches
```
(--keepbranches: Hériter de l'original du nom de la branche.)

Mojca mentionne:

J'aime utiliser hg rebase --source {L1's-sha} --dest {R2's-sha}, mais je ne sais pas je pourrais ajouter --keepbranches à la fin.

Comme illustré ci-dessous par Jonathan Blackburn:
```
 hg rebase -d default --keepbranches
```
- J'ai regardé le Rebase Extension, mais il n'est toujours pas clair pour moi. Pourriez-vous expliquer les étapes à faire ce que j'ai décrit ci-dessus?
- Dans le cas où vous n'êtes pas en tirant les changements, et vous avez les deux branches dans votre pension, vous pouvez le faire: hg up newfeature-123 suivie par hg rebase -d master --keepbranches
- Je crois qu'elle n'est pas cela, c'est juste une question de choix. Le problème est que cela devient abusé et je suis avec @Ry4an sur ce n'est pas de réécrire l'histoire afin que vous puissiez savoir ce qui se passe et quand.
- merci pour l'astuce pour l'utilisation de --keepbranches. J'aime utiliser hg rebase --source {L1's-sha} --dest {R2's-sha}, mais je ne sais pas je pourrais ajouter --keepbranches à la fin. C'est mentionné dans d'autres de moindre rang des réponses, mais il serait bien d'écrire explicitement à cette réponse ainsi.
- Pas de problème. J'ai édité la réponse en conséquence.
InformationsquelleAutor VonC
44

En supposant que vous avez un moderne Hg installation, vous pouvez simplement ajouter:
```
[extensions]
rebase = 
```
à ~/.hgrc.

Ensuite, vous pouvez utiliser les commandes hg rebase, hg pull --rebase, ou hg help rebase.
- Juste pour ajouter à cela, dans les termes de la commande, alors vous devez exécuter serait: hg rebase -s o -d f
InformationsquelleAutor sblom
21

Je ne pense pas que les réponses ci-dessus parvenir à l'OP de l'objectif, qui est de maintenir sa tâche de direction, juste relocalisée à l'encontre d'un moment plus tard, sur le parent de la branche.

Disons que je commence avec ce graphique (généré à l'aide de la graphlog extension. Sérieux geek amour pour graphlog).
```
@  9a4c0eb66429 Feature 3 commit 2 tip feature3
|
| o  af630ccb4a80 default againagainagain  
| |
o |  98bdde5d2185 Feature 3 branch commit 1  feature3
|/
o  e9f850ac41da foo   
```
Si je suis sur le feature3 branche et souhaitez rebase hors de l'againagainagain s'engager, je comprends que je courrais hg rebase -d default. Cela a le résultat suivant:
```
@  89dada24591e Feature 3 commit 2 tip 
|
o  77dcce88786d Feature 3 branch commit 1  
|
o  af630ccb4a80 default againagainagain  
|
o  e9f850ac41da foo  
```
Mission accomplie? Je ne le pense pas. Le problème est que lorsque l'engage sur le feature3 branche ont été relocalisée sur againagainagain, la feature3 branche a été supprimé. Mes commits ont été déplacés à la branche par défaut, ce qui était ce que j'essayais d'éviter en premier lieu.

Dans Git, le résultat devrait ressembler à ceci:
```
@  9a4c0eb66429 Feature 3 commit 2 tip
|
o  98bdde5d2185 Feature 3 branch commit 1 **feature3**
|
o  af630ccb4a80 default againagainagain
|
o  e9f850ac41da foo
```
Avis que le feature3 branche existe encore, les deux commits sont toujours sur le feature3 branche, et n'est pas visible par défaut. Sans la préservation de la tâche de direction, je ne vois pas comment ce est fonctionnellement différentes à partir d'une fusion.

Mise à JOUR: j'ai découvert le --keepbranches drapeau pris en charge par hg rebase, et je suis heureux de signaler tout est okey-dokey. À l'aide de hg rebase -d default --keepbranches, j'ai exactement reproduire le Git comportement je désirais. Un couple de alias plus tard et je suis rebasage comme personne.
- Viens de découvrir le --keepbranches drapeau sur rebase. Le problème est résolu. Étaient-ce mon code je ferais que la valeur par défaut, mais c'est juste moi.
- Je pense qu'il pourrait être utile si vous avez ajouté que peu d'informations à votre réponse ci - dessus m'a fallu un certain temps pour le trouver.
InformationsquelleAutor Jonathan Blackburn
3

Étant donné que certaines personnes ont de renchérir en disant qu'ils pensent qu'il est bon de garder à chaque itération de tout, je vais souligner que pour les plus gros projets open-source, de l'acceptation des changements plein de fusions et de développement de l'itération ferait pour un désordre de la canalisation principale de la révision de l'histoire, et de faire la révision de l'histoire pour le moins utile de voir comment la version actuelle est arrivé là.

Cela fonctionne bien lorsqu'il est soumis modifications sont examinées par les gens qui n'ont pas les écrire, avant ils sont acceptés, de sorte que les modifications qui vont dans le réseau principal sont généralement de débogage et de travail. Ensuite, lorsque vous revenez à l'origine d'une ligne, à vous de voir tous les changements qui vont avec, et non point dans le milieu de développement de la changer c'est une partie de.

La x265 contributeurs page explique comment re-commettre un ensemble de modifications que vous travaillez sur, à se préparer pour la présentation pour le x265 projet. (Y compris l'utilisation de TortoiseHG de commettre certaines mais pas toutes les modifications dans un fichier individuel, comme git gui de la scène/unstage diff beau mec pour valider).

Le processus est d'obtenir hg mis à jour à la pointe amont, et puis obtenir toutes vos modifications non validées dans le répertoire de travail. Laisser de côté tout qui ne font pas partie de ce que vous voulez envoyer, puis casser le reste dans un grand nombre de commits sont appropriées, avec de beaux messages de commit.

Je crois que vous pourriez copier/coller et ensuite modifier les messages de commit par rapport aux versions précédentes d'un nouveau jeu de patches que vous êtes à la révision. Ou peut-être vous pourriez greffe de votre ancien s'engage (cherry-pick dans git langue), puis de les modifier un par un, pour obtenir votre ancien des messages de commit comme point de départ pour la modification.

InformationsquelleAutor Peter Cordes

Vous devez vous connecter pour publier un commentaire.