Comment puis-je squash deux non consécutifs s'engage?

Je suis un peu nouveau pour l'ensemble de l'année de référence dans git. Disons que j'ai fait la suite s'engage à:

A -> B -> C -> D

Par la suite, je me rends compte que D contient un correctif qui dépend d'un nouveau code ajouté dans A, et que ces révisions vont de pair. Comment puis-je squash A & D ensemble et laisser B & C seul?

InformationsquelleAutor Nik Reiman | 2010-10-13

git git-rebase

218

Vous pouvez exécuter git rebase --interactive et réorganiser D avant B et les courges D en A.

Git va ouvrir un éditeur, et vous voyez un fichier comme ceci:
```
pick aaaaaaa Commit A
pick bbbbbbb Commit B
pick ccccccc Commit C
pick ddddddd Commit D

# Rebase aaaaaaa..ddddddd onto 1234567 (4 command(s))
#
# Commands:
# p, pick = use commit
# r, reword = use commit, but edit the commit message
# e, edit = use commit, but stop for amending
# s, squash = use commit, but meld into previous commit
# f, fixup = like "squash", but discard this commit's log message
# x, exec = run command (the rest of the line) using shell
#
# These lines can be re-ordered; they are executed from top to bottom.
#
# If you remove a line here THAT COMMIT WILL BE LOST.
#
# However, if you remove everything, the rebase will be aborted.
#
# Note that empty commits are commented out
```
Maintenant vous modifiez le fichier qu'il ressemble à ceci:
```
pick aaaaaaa Commit A
squash ddddddd Commit D
pick bbbbbbb Commit B
pick ccccccc Commit C
```
Et git maintenant fusionner les modifications de A et D, ainsi que dans un commit, et de mettre B et C par la suite. Lorsque vous ne souhaitez pas conserver le message de validation de D, vous pouvez également utiliser la fonction "correction" mot-clé.
- Au départ, je l'ai lu comme "rebase D sur Un, squash D en Un, puis rebase B sur DA". Il n'est pas clair à partir de la réponse que ce qui peut être fait par la réorganisation des lignes dans un éditeur de texte.
- Si votre branche est local, vous obtiendrez There is no tracking information for the current branch erreur lors de l'année de référence. Dans ce cas, vous devez spécifier le nombre de commits que vous voulez travailler avec, comme ceci: git rebase -i HEAD~4. Voir cette réponse.
- J'utilise le mode interactif(git rebase -i) pendant des années, je viens de réaliser qu'il peut être réorganisées. Grâce
InformationsquelleAutor Rudi
41

Remarque: Vous devez pas changer les commits qui ont été poussés à un autre repo en quelque sorte sauf si vous connaissez la les conséquences.

git log --oneline -4
```
D commit_message_for_D
C commit_message_for_C
B commit_message_for_B
A commit_message_for_A
```
git rebase --interactive
```
pick D commit_message_for_D
pick C commit_message_for_C
pick B commit_message_for_B
pick A commit_message_for_A
```
Type i (Mis VIM en mode insertion)

Modifier la liste ressemble à ceci (Vous n'avez pas à supprimer ou d'inclure le message de commit). Ne pas écorcher squash!:
```
pick C commit_message_for_C
pick B commit_message_for_B
pick A commit_message_for_A
squash D
```
Type Esc alors ZZ (Enregistrer et quitter VIM)
```
# This is a combination of 2 commits.
# The first commit's message is:

commit_message_for_D

# This is the 2nd commit message:

commit_message_for_A
```
Type i

Modifier le texte de ce que vous voulez que le nouveau message de commit ressembler. Je recommande ce être une description des changements en commettre A et D:
```
new_commit_message_for_A_and_D
```
Type Esc alors ZZ

git log --oneline -4
```
E new_commit_message_for_A_and_D
C commit_message_for_C
B commit_message_for_B
```
git show E
```
(You should see a diff showing a combination of changes from A and D)
```
Vous avez maintenant créé un nouveau commit E. S'engage A et D n'êtes plus dans votre histoire, mais qui ne sont pas partis. Vous pouvez toujours les récupérer à ce moment et pour un temps par git rebase --hard D (git rebase --hard va détruire tous les changements locaux!).

InformationsquelleAutor Nate
3

Pour ceux qui utilisent SourceTree:

Assurez-vous que vous ne l'avez pas déjà poussé la commet.
1. Référentiel > Rebase Interactif...
2. Glisser D (la plus récente s'engager) pour être directement au-dessus de (l'ancien commit)
3. Assurez-vous commettre D est mis en évidence
4. Cliquez sur Squash with previous
InformationsquelleAutor Adam Johns
1

Rebase interactif fonctionne bien jusqu'à ce que vous avez de grandes branche avec 20-30 s'engage et/ou d'un couple de fusions de maître ou/et de la fixation des conflits alors que vous, a été la validation de votre branche. Même avec la conclusion de ma s'engage à travers l'histoire et le remplacement de pick avec squash n'a pas travaillé ici. Alors que je cherchais une autre façon et a trouvé ce l'article.
J'ai fait mes modifications à ce travail sur la branche distincte:
```
git checkout master
git fetch
git pull
git merge branch-name
git reset origin/master
git branch -D branch-name
git checkout -b branch-name
git add --all
#Do some commit
git push -f --set-upstream origin branch-name
```
Avant cela, j'ai obtenu mon pull request avec environ 30 s'engage avec 2-3 fusionne de maître + fixation de conflits. Et après cela, je me suis clair PR avec un commit.

P. S. voici bash script pour ce faire des mesures en mode auto.
- La première solution, à savoir que l'article est vraiment sympa, merci pour le lien
InformationsquelleAutor Oleksiy Guzenko
-1

$ git checkout master

$ git log --oneline
```
D
C
B
A
```
$ git rebase --sur la TÊTE^^^ la TÊTE^

$ git log --oneline
```
D
A
```
- Je pense que tu veux dire --oneline? Et il semble que vous avez abandonné C et B, ce qui n'est pas ce que l'OP a été l'intention.
- Ne fonctionne pas pour moi. Il a déménagé à la fois de ma TÊTE et de maîtriser le bas pour Un, mais n'a pas de fusion et D en Un (git show A) et D, C et B ont été perdu dans ma ref-journal. Dû git rebase D pour revenir.
InformationsquelleAutor Cotton

Vous devez vous connecter pour publier un commentaire.