Briser une précédente livraison en plusieurs commits

git rebase -i va le faire.

Tout d'abord, commencez avec un répertoire de travail est propre: git status ne doivent présenter ni dans l'attente des modifications, des suppressions ou des ajouts.

Maintenant, vous devez décider qui commit(s) que vous voulez diviser.

A) le Fractionnement de la plus récente s'engager

À se séparer de votre plus récente s'engager, d'abord:

$ git reset HEAD~

Maintenant commettre les pièces individuellement de la manière habituelle, la production comme de nombreux engage que vous en avez besoin.

B) Fractionnement d'un commit plus loin en arrière

Cela nécessite rebasage, qui est, la réécriture de l'histoire. Pour trouver la bonne engager, vous avez plusieurs choix:

• Si c'était à trois s'engage en retour, puis

  $ git rebase -i HEAD~3
  

  où 3 est combien s'engage en retour c'est.

• Si elle a été plus loin en arrière dans l'arbre que vous souhaitez compter, puis

  $ git rebase -i 123abcd~
  

  où 123abcd est le SHA1 de la validation que vous souhaitez diviser.

• Si vous êtes sur une autre branche (par exemple, une branche) que vous avez l'intention de fusionner en master:

  $ git rebase -i master
  

Lorsque vous obtenez le rebase écran de modification, de trouver le commit que vous voulez rompre. Au début de cette ligne, remplacer pick avec edit (e pour faire court). Économiser de la mémoire tampon et de sortie. Cela va maintenant s'arrêter juste après le commit que vous voulez modifier. Alors:

$ git reset HEAD~

Commettre les pièces individuellement de la manière habituelle, la production comme de nombreux engage que vous en avez besoin, puis

$ git rebase --continue

Utilisation git rebase --interactive afin de le modifier plus tôt s'engager, exécutez git reset HEAD~, puis git add -p pour en ajouter, puis faire un commit, puis ajouter un peu plus et de faire un autre commit, autant de fois que vous le souhaitez. Lorsque vous avez terminé, exécutez git rebase --continue, et vous aurez tout le split s'engage plus tôt dans votre pile.

Important: Notez que vous pouvez jouer et de faire tous les changements que vous voulez, et ne pas avoir à vous soucier de perdre des vieux changements, parce que vous pouvez toujours exécuter le git reflog pour trouver le point dans votre projet qui contient les modifications que vous souhaitez, (appelons-la a8c4ab), puis git reset a8c4ab.

Voici une série de commandes pour montrer comment cela fonctionne:

mkdir git-test; cd git-test; git init

maintenant ajouter un fichier A

vi A

ajouter cette ligne:

one

git commit -am one

puis ajoutez cette ligne à Un:

two

git commit -am two

puis ajoutez cette ligne à Un:

three

git commit -am three

maintenant le fichier ressemble à ceci:

one
two
three

et notre git log se présente comme suit (eh bien, j'utilise git log --pretty=oneline --pretty="%h %cn %cr ---- %s"

bfb8e46 Rose Perrone 4 seconds ago ---- three
2b613bc Rose Perrone 14 seconds ago ---- two
9aac58f Rose Perrone 24 seconds ago ---- one

Disons que nous voulons diviser le deuxième s'engager, two.

git rebase --interactive HEAD~2

Cela apporte un message qui ressemble à ceci:

pick 2b613bc two
pick bfb8e46 three

Modifier le premier pick à un e l'édition de commettre.

git reset HEAD~

git diff nous montre que nous venons de unstaged la validation nous avons fait pour la deuxième commit:

diff --git a/A b/A
index 5626abf..814f4a4 100644
--- a/A
+++ b/A
@@ -1 +1,2 @@
 one
+two

Laisser la scène de ce changement, et d'ajouter "et un troisième" cette ligne dans le fichier A.

git add .

C'est généralement le moment au cours d'un rebase interactif où nous git rebase --continue, parce qu'en général nous voulons juste revenir dans notre pile de s'engage à modifier plus tôt s'engager. Mais cette fois, nous voulons créer un nouveau commit. Donc, nous allons exécuter git commit -am 'two and a third'. Maintenant, nous allons éditer le fichier de A et ajoutez la ligne two and two thirds.

git add .
git commit -am 'two and two thirds'
git rebase --continue

Nous avons un conflit avec notre engagement, three, donc, nous allons le résoudre:

Nous allons changer

one
<<<<<<< HEAD
two and a third
two and two thirds
=======
two
three
>>>>>>> bfb8e46... three

à

one
two and a third
two and two thirds
three

git add .; git rebase --continue

Maintenant notre git log -p ressemble à ceci:

commit e59ca35bae8360439823d66d459238779e5b4892
Author: Rose Perrone <[email protected]>
Date:   Sun Jul 7 13:57:00 2013 -0700

    three

diff --git a/A b/A
index 5aef867..dd8fb63 100644
--- a/A
+++ b/A
@@ -1,3 +1,4 @@
 one
 two and a third
 two and two thirds
+three

commit 4a283ba9bf83ef664541b467acdd0bb4d770ab8e
Author: Rose Perrone <[email protected]>
Date:   Sun Jul 7 14:07:07 2013 -0700

    two and two thirds

diff --git a/A b/A
index 575010a..5aef867 100644
--- a/A
+++ b/A
@@ -1,2 +1,3 @@
 one
 two and a third
+two and two thirds

commit 704d323ca1bc7c45ed8b1714d924adcdc83dfa44
Author: Rose Perrone <[email protected]>
Date:   Sun Jul 7 14:06:40 2013 -0700

    two and a third

diff --git a/A b/A
index 5626abf..575010a 100644
--- a/A
+++ b/A
@@ -1 +1,2 @@
 one
+two and a third

commit 9aac58f3893488ec643fecab3c85f5a2f481586f
Author: Rose Perrone <[email protected]>
Date:   Sun Jul 7 13:56:40 2013 -0700

    one

diff --git a/A b/A
new file mode 100644
index 0000000..5626abf
--- /dev/null
+++ b/A
@@ -0,0 +1 @@
+one

git rebase --interactive peuvent être utilisés pour diviser une livraison dans les plus petits s'engage. Le Git docs sur rebase ont une forme concise, la procédure pas à pas du processus de Fractionnement s'Engage:

En mode interactif, vous pouvez la marque s'engage avec l'action "modifier". Toutefois, cela ne signifie pas nécessairement que git rebase attend le résultat de ce montage pour être exactement un commit. En effet, vous pouvez annuler la livraison, ou vous pouvez ajouter d'autres validations. Cela peut être utilisé pour diviser un commit en deux:

• Commencer un rebase interactif avec git rebase -i <commit>^, où <commit> est le commit que vous voulez diviser. En fait, tout s'engager gamme va faire, en tant qu'il contient qui s'engagent.

• Marque le commit que vous voulez diviser avec l'action "modifier".

• Quand il s'agit de l'édition qui s'engagent, exécuter git reset HEAD^. L'effet est que la TÊTE est remonté par un, et de l'indice de suit en. Cependant, l'arbre de travail reste la même.

• Maintenant ajouter les modifications apportées à l'index que vous voulez avoir dans le premier commit. Vous pouvez utiliser git add (éventuellement de manière interactive) ou git gui (ou les deux) pour le faire.

• Commettre l'indice actuel avec ce message de commit est approprié maintenant.

• Répétez les deux dernières étapes jusqu'à ce que votre arbre de travail est propre.

• De continuer le rebase avec git rebase --continue.

Si vous n'êtes pas absolument sûr que les révisions intermédiaires sont compatibles (ils compiler, de passer de la suite de tests, etc.) vous devez utiliser git stash de ranger le pas-encore-commis changements après chaque validation, de test et de modifier l'engager si des corrections sont nécessaires.

Maintenant dans la dernière TortoiseGit sur Windows, vous pouvez le faire très facilement.

Ouvrir le rebase dialogue, configurer, et de suivre les étapes suivantes.

• Cliquez-droit sur le commit que vous voulez diviser et sélectionnez "Edit" (parmi les choisir, squash, suppression,...).
• Cliquez sur "Start" pour démarrer la conversion.
• Une fois qu'il arrive à le commettre à split, cochez la case "Edit/Split" bouton et
  cliquez sur "Amend" directement. La boîte de dialogue de validation s'ouvre.
  
  
• Désélectionner les fichiers que vous voulez mettre sur un autre commit.
• Modifier le message de commit, puis cliquez sur "commit".
• Jusqu'à ce qu'il y a des fichiers à valider, la boîte de dialogue de validation s'ouvre à nouveau et de nouveau. Quand il n'y a plus de fichier à commettre, il sera toujours vous demander si vous voulez ajouter un plus commettre.

Très utile, merci TortoiseGit !

Chose la plus facile à faire sans un rebase interactif est (probablement) pour créer une nouvelle branche de départ à la validation avant celui que vous voulez diviser, cherry-pick -n de la validation, de réinitialisation, de cachette, de commettre le déplacement de fichiers, réappliquer la cachette et de valider les modifications, puis fusion avec l'ancienne direction générale ou de choisir les commits qui ont suivi. (Puis passer l'ancien nom de la branche de l'actuel chef.) (C'est probablement mieux de suivre Mbo conseils et faire un rebase interactif.)

Si vous avez ceci:

A - B <- mybranch

Où vous avez commis une teneur en commettre B:

/modules/a/file1
/modules/a/file2
/modules/b/file3
/modules/b/file4

Mais vous voulez diviser B en C - D, et d'obtenir ce résultat:

A - C - D <-mybranch

Vous pouvez diviser le contenu comme ceci par exemple (contenu à partir de différents répertoires dans les différents commits)...

Réinitialiser la branche de retour à la validation avant de l'un à split:

git checkout mybranch
git reset --hard A

De créer un premier commit (C):

git checkout B /modules/a
git add -u
git commit -m "content of /modules/a"

Créer de la deuxième commit (D):

git checkout B /modules/b
git add -u
git commit -m "content of /modules/b"

Ici est de savoir comment diviser un commit dans IntelliJ IDEA, PyCharm, PhpStorm etc

1. Dans le Contrôle de Version du journal de la fenêtre, sélectionnez la validation que vous souhaitez
   split, droit de la souris et sélectionnez la Interactively Rebase from
Here

2. marque de celui que vous souhaitez diviser comme edit, cliquez sur Start
Rebasing

3. Vous devriez voir une étiquette jaune est placé ce sens que la TÊTE
   à qui s'engagent. Clic-droit sur le commettre, sélectionnez Undo Commit

4. Maintenant ces commits sont de retour à la zone de mise en attente, vous pouvez ensuite valider
   séparément. Après tout, le changement a été commise, l'ancien commit
   devient inactif.