Wie können Sie sich mit Git-Formatpatch in einen Patch in einen Patch auskürzen?

StackOverflow https://stackoverflow.com/questions/616556

  •  03-07-2019
  •  | 
  •  

Frage

Ich habe acht Commits in einer Filiale, die ich gerne an einige Leute senden möchte, die noch nicht erleuchtet sind. Bisher gibt mir alles, was ich mache, entweder 8 Patch -Dateien oder gibt mir Patch -Dateien für jeden Commit in der Geschichte der Filiale seit Beginn der Zeit. Ich habe Git Rebase verwendet -interaktiv, um die Commits zu zerquetschen, aber jetzt gibt mir alles, was ich probiere, von Anfang an Ziillionen von Patches. Was mache ich falsch?

git format-patch master HEAD # yields zillions of patches, even though there's 
                             # only one commit since master
War es hilfreich?

Lösung

Ich würde dies wie folgt in einem Wegwerfzweig empfehlen. Wenn sich Ihre Commits in der "Newlines" -Ast befinden und Sie bereits zu Ihrem "Master" -Ast zurückgekehrt sind, sollte dies den Trick machen:

[adam@mbp2600 example (master)]$ git checkout -b tmpsquash
Switched to a new branch "tmpsquash"

[adam@mbp2600 example (tmpsquash)]$ git merge --squash newlines
Updating 4d2de39..b6768b2
Fast forward
Squash commit -- not updating HEAD
 test.txt |    2 ++
 1 files changed, 2 insertions(+), 0 deletions(-)

[adam@mbp2600 example (tmpsquash)]$ git commit -a -m "My squashed commits"
[tmpsquash]: created 75b0a89: "My squashed commits"
 1 files changed, 2 insertions(+), 0 deletions(-)

[adam@mbp2600 example (tmpsquash)]$ git format-patch master
0001-My-squashed-commits.patch

Hoffe das hilft!

Andere Tipps

Nur um dem Topf noch eine Lösung hinzuzufügen: Wenn Sie dies stattdessen verwenden:

git format-patch master --stdout > my_new_patch.diff

Dann werden es immer noch 8 Patches sein ... aber sie werden alle in einer einzelnen Patchfile sein und werden als einer mit:

git am < my_new_patch.diff

Ich verwende immer Git Diff in Ihrem Beispiel so etwas wie

git diff master > patch.txt

Dies ist eine Anpassung von Adam Alexander Antwort, falls Ihre Änderungen in Master Branch sind. Dies macht Folgendes:

  • Erstellt einen neuen Wegwerfzweig "tmpsquash" von dem Punkt, an dem wir gewünscht werden (suchen Sie nach dem SHA -Schlüssel, der "Git -Log" oder mit Gitg. Der zerquetschte Commits).
  • Fügt die Änderungen von Master zu tmpsquash zusammen.
  • Verpflichtet sich die verteilten Änderungen an TMPSQuash.
  • Erstellt den Patch mit den zerquetschten Commits.
  • Geht zurück zum Master Branch
laura@rune:~/example (master)$ git branch tmpsquash ba3c498878054e25afc5e22e207d62eb40ff1f38
laura@rune:~/example (master)$ git checkout tmpsquash
Switched to branch 'tmpsquash'
laura@rune:~/example (tmpsquash)$ git merge --squash master
Updating ba3c498..40386b8
Fast-forward
Squash commit -- not updating HEAD

[snip, changed files]

11 files changed, 212 insertions(+), 59 deletions(-)
laura@rune:~/example  (tmpsquash)$ git commit -a -m "My squashed commits"
[test2 6127e5c] My squashed commits
11 files changed, 212 insertions(+), 59 deletions(-)
laura@rune:~/example  (tmpsquash)$ git format-patch master
0001-My-squashed-commits.patch
laura@rune:~/example  (tmpsquash)$ git checkout master
Switched to branch 'master'
laura@rune:~/example  (master)$

Wie Sie bereits wissen, a git format-patch -8 HEAD Gib dir acht Patches.

Wenn Sie möchten, dass Ihre 8 Commits als eins erscheinen, und nichts dagegen, die Geschichte Ihrer Niederlassung neu zu schreiben ((o-o-X-A-B-C-D-E-F-G-H), Sie könnten :

git rebase -i
// squash A, B, C, D, E ,F, G into H

oder, und es wäre eine bessere Lösung, Wiederholen Sie alle Ihre 8 Commits von X (Der Commit vor Ihren 8 Commits) in einer neuen Filiale

git branch delivery X
git checkout delivery
git merge --squash master
git format-patch HEAD

Auf diese Weise haben Sie nur einen Commit

Formatpatch zwischen zwei Tags:

git checkout <source-tag>
git checkout -b <tmpsquash>
git merge --squash <target-tag>
git commit -a -m "<message>"
git format-patch <source-tag>

Der einfachste Weg ist zu verwenden git diff, und hinzufügen git log Wenn Sie die kombinierte Commit -Nachricht wünschen, dass die Kürbismethode ausgeben würde. Zum Beispiel, um den Patch zwischen dem Commit zu erstellen abcd und 1234:

git diff abcd..1234 > patch.diff
git log abcd..1234 > patchmsg.txt

Dann beim Anwenden des Patches:

git apply patch.diff
git add -A
git reset patch.diff patchmsg.txt
git commit -F patchmsg.txt

Vergiss nicht das --binary Argument an git diff Beim Umgang mit Nicht-Text-Dateien, zB Bildern oder Videos.

Basierend auf Adam Alexanders Antwort:

git checkout newlines
## must be rebased to master
git checkout -b temporary
# squash the commits
git rebase -i master
git format-patch master
Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top