Wie quetscht man Commits in einen Patch mit Git-Format-Patch?

Ich habe acht Commits in einem Zweig, die ich per E-Mail an einige Leute senden möchte, die noch nicht aufgeklärt sind. Bisher gibt mir alles, was ich mache, entweder 8 Patch-Dateien oder seit Beginn der Zeit Patch-Dateien für jedes Commit in der Geschichte des Zweigs. Ich habe git rebase --interactive verwendet, um die Commits zu quetschen, aber jetzt gibt mir alles, was ich versuche, von Anfang an zig Millionen Patches. Was mache ich falsch?

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

Ich würde empfehlen, dies auf einem Wegwerfzweig wie folgt zu tun. Wenn sich Ihre Commits im Zweig "Newlines" befinden und Sie bereits zu Ihrem Zweig "Master" zurückgekehrt sind, sollte dies den Trick tun:

[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!

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

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

Dann sind es immer noch 8 Patches ... aber alle befinden sich in einer einzigen Patchdatei und gelten als eine mit:

git am < my_new_patch.diff

Ich benutze immer Git Diff, also in deinem Beispiel so etwas wie

git diff master > patch.txt

Dies ist eine Anpassung der Antwort von Adam Alexander, falls sich Ihre Änderungen im Hauptzweig befinden. Dies tun die folgenden:

• Erstellt einen neuen Wegwerfzweig "tmpsquash" ab dem gewünschten Punkt (suchen Sie nach dem SHA-Schlüssel, auf dem "git --log" oder mit gitg ausgeführt wird. Wählen Sie das Commit aus, das Sie als tmpsquash head verwenden möchten. Die Commits, die danach im Master ausgeführt werden, sind die gequetschten Commits).
• Führt die Änderungen von Master zu tmpsquash zusammen.
• Übernimmt die gequetschten Änderungen in tmpsquash.
• Erstellt den Patch mit den gequetschten Commits.
• Geht zurück zum Hauptzweig

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, erhalten git format-patch -8 HEADSie mit a acht Patches.

Wenn Sie möchten, dass Ihre 8 Commits als eins angezeigt werden und es Ihnen nichts ausmacht, den Verlauf Ihres Zweigs ( o-o-X-A-B-C-D-E-F-G-H) neu zu schreiben , können Sie:

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

oder, und es wäre eine bessere Lösung, alle 8 Commits von X(das Commit vor Ihren 8 Commits) in einem neuen Zweig wiederzugeben

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

Auf diese Weise haben Sie nur ein Commit im Zweig "Zustellung" und es repräsentiert alle Ihre letzten 8 Commits

Format-Patch 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>

Am einfachsten ist es git diff, git logdie kombinierte Festschreibungsnachricht zu verwenden und hinzuzufügen , die die Squash-Methode ausgeben würde. So erstellen Sie beispielsweise den Patch zwischen Commit abcdund 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

Vergessen Sie nicht das --binaryArgument, git diffwenn Sie mit Nicht-Textdateien, z. B. Bildern oder Videos, arbeiten.

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