Github kann nicht merge branch, keine Konflikte, es manuell auto-merges

Habe ich einen pull-request, dass Github sagt, es kann nicht automatisch Zusammenführen. Diese änderung ist hinter dem master einige commits, aber ohne Konflikte.

Manuell Zusammenfügen, ich bekomme keine Konflikte, und bekomme ich diese Ausgabe:

(on master)
$git merge otherbranch
[vim pops up for commit message, :wq]
Auto-merging <file>
Merge made by the 'recursive' strategy.
<file> | 1 +
1 file changed, 1 insertion(+)

Ist, warum Github nicht automatisch Zusammenführen? Es automatisch zusammengeführt, von der Befehlszeile aus sowieso. Ist dieses nicht automatisch genug für Github?

InformationsquelleAutor jpimentel | 2013-10-17

12

Der Grund ist, dass git merge verwendet eine Strategie namens "rekursiven" mergen standardmäßig. Es ist in der Lage zu führen Sie die 3-Wege-Zusammenführung: der patch von einer Seite, und die Anwendung des Patches auf der anderen Seite, erzeugt eine neue Datei. Es tut dies auch rekursiv, in komplizierteren Situationen, in denen eine Menge von Verzweigungen und Zusammenführungen geschehen und es gibt mehreren merge-Basen für die beiden commits zusammengeführt.

Ich vor kurzem begegnet die gleiche situation:
```
$ git merge-base --all 90d64557 05b3dd8f
711d1ad9772e42d64e5ecd592bee95fd63590b86
f303c59666877696feef62844cfbb7960d464fc1
$
```
Mit 2 merge-Grundlagen, ein 3-Wege-merge ist nicht möglich. Der 'recursive' Strategie ist es daher, dieses Problem gelöst, indem zuerst recursing in einem Zusammenführen dieser beiden verpflichtet:
```
$ git merge-base 711d1ad9 f303c596
3f5db59435ffa4a453e5e82348f478547440e7eb
$
```
OK, nur eine merge-base, also die 3-Wege-Zusammenführung beginnen kann. was die änderungen auf beiden Seiten?
```
$ git diff --stat 3f5db594 711d1ad9
 normalize/coll.py      | 116 ++++++++++++++++++++++++++++++++++++++-----------
 normalize/visitor.py   |  49 ++++++++++-----------
 tests/test_property.py |  10 +++--
 3 files changed, 120 insertions(+), 55 deletions(-)
$ git diff --stat 3f5db594 f303c596
 normalize/identity.py  | 38 +++++++++++++++++++++++++++++++-------
 tests/test_property.py |  2 ++
 2 files changed, 33 insertions(+), 7 deletions(-)
$ 
```
Diese beiden diffs sowohl änderungen an der gleichen Datei, so dass Sie nicht gelöst werden kann mit einer einfachen Strategie, einfach nur die neuere version von jeder Datei von jeder Seite (eine index merge). Stattdessen git nimmt die neue Datei von einer Seite, und versucht, den patch von der anderen Seite. Das Ergebnis ist eine kombinierte verpflichten, die simuliert werden können, wie diese:
```
$ git checkout -b tmp
Switched to a new branch 'tmp'
$ git reset --hard f303c59666877696feef62844cfbb7960d464fc1
HEAD is now at f303c59 record_id: throw a more helpful error if record identity is not hashable
$ git merge 711d1ad9772e42d64e5ecd592bee95fd63590b86
Auto-merging tests/test_property.py
Merge made by the 'recursive' strategy.
 normalize/coll.py      | 116 ++++++++++++++++++++++++++++++++++++++-----------
 normalize/visitor.py   |  49 ++++++++++-----------
 tests/test_property.py |  10 +++--
 3 files changed, 120 insertions(+), 55 deletions(-)
$ git diff --stat 3f5db594 HEAD tests/test_property.py
 tests/test_property.py | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)
$
```
Es dann zurück in die ursprüngliche 3-Weg-Zusammenführung, mit diesem Ergebnis verschmelzen als Ausgangspunkt; und dies betrifft auch änderungen an der selben Datei:
```
$ git diff --stat HEAD 90d64557| grep selector
 normalize/selector.py          |  17 +--
 tests/test_selector.py         |  19 ++--
$ git diff --stat HEAD 05b3dd8f| grep selector
 normalize/selector.py  | 29 +++++++++++++++++------------
 tests/test_selector.py |  9 +++++++++
$
```
Aber wieder die änderungen sind zu verschiedenen Abschnitten der Datei, und so unter dem diff und Anwendung auf der anderen Seite erfolgreich ist.

So, C git in der Lage war, diese zu lösen Zusammenführen, indem Sie zuerst tun, eine 3-Wege-merge auf die beiden Seriendruck-Grundlagen der zwei Ausgangspunkte, und dann ein weiteres 3-Wege-merge auf die beiden ursprünglichen begeht zusammengeführt und das Zwischenergebnis der ersten Zusammenführung.

Github ist die automatische Auflösung nicht tun. Es ist nicht unbedingt unfähig, und ich bin mir nicht sicher, wie viel von der rekursive Strategie, die es gilt umzusetzen, aber es ist irrenden auf der Seite der Vorsicht, das ist genau das, was Sie erwarten, eine große grüne Taste, wie das zu tun :-).

Schöne Ergänzung auf dem rekursiven merge-Strategie. +1 Gute Ergänzung zu meiner eigenen Antwort.

InformationsquelleAutor samv
5

Nein, es ist nicht über das Zusammenführen. Es wird über Rebase.

Sollten Sie versuchen, Stellungswechsel, in Ihrem lokalen repo (geklont von deine Gabel), otherbranch oben master.

Erste, sicherstellen, dass der master ist der jüngste von der ursprünglichen upstream-repo:
```
cd /your/local/repo
git remote add upstream /url/original/repo
git fetch upstream

# Make sure you don't have any local commmit on your master
git branch -f master upstream/master # reset your master branch 
                                     # to the one from upstream repo
git checkout otherbranch
git rebase master
```
Dass rebase generiert Konflikte, die Sie lösen sollen, git add, und dann git rebase --continue.

Schließlich einfach push --force Ihren Zweig zu deiner Gabel: , aktualisieren Sie Ihre pull-request automatisch (sonst nichts zu tun).
```
git push -u -f otherbranch origin
```
(wenn es schon schob einmal eine git push allein sollte genug sein)

Sehen weitere Tipps über pull-requests hier.

OK, ich denke, es macht Sinn. Danke!

InformationsquelleAutor VonC
0

Standardmäßig Git nicht weiß, ob er kann auto-merge Ihre Niederlassung haben oder nicht, vor der Bestätigung die commit-Nachricht für den merge-commit.

Wenn Sie wissen, Sie haben keine Konflikte, Sie können diesen Prozess automatisieren, rekursiver auto-Verschmelzung durch ändern GIT_EDITOR zu nicht-interaktiven Tools, zum Beispiel durch hinzufügen cat oder true:
```
GIT_EDITOR=true git merge otherbranch
```
^{Das gleiche für pull. Sie können auch angeben, merging-Strategie wie -X theirs oder -X ours.}

oder eine andere Methode ist, um Stellungswechsel (hinzufügen -r zu Ihrem pull Befehl).

InformationsquelleAutor kenorb

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.