Czy istnieje opcja Git-merge --dry-run?

Musiałem zaimplementować metodę, która automatycznie wykrywa konflikty między repozytorium a jego zdalnym. To rozwiązanie wykonuje scalanie w pamięci, więc nie dotknie indeksu ani drzewa roboczego. Myślę, że to najbezpieczniejszy sposób na rozwiązanie tego problemu. Oto jak to działa:

1. Pobierz pilota do repozytorium. Na przykład: git fetch origin master
2. Uruchom git merge-base: git merge-base FETCH_HEAD master
3. Uruchom git merge-tree: git merge-tree mergebase master FETCH_HEAD (mergebase jest szesnastkowym identyfikatorem, który merge-base wydrukowane w poprzednim kroku)

Teraz Załóżmy, że chcesz połączyć zdalny master z lokalnym master, ale możesz użyć dowolnych gałęzi. git merge-tree wykona scalenie w pamięci i wydrukuje wynik na standardowe wyjście. Grep dla wzoru << lub >>. Możesz też wydrukować dane wyjściowe do pliku i to sprawdzić. Jeśli znajdziesz linię zaczynającą się od 'changed in both', najprawdopodobniej dojdzie do konfliktu.

Moje proste rozwiązanie brute-force to:

1: Utwórz gałąź Pre-master (Z master of course)
2: Połącz wszystkie rzeczy, które chcesz zrobić z tym pre-mistrzem
wtedy możesz zobaczyć, jak doszło do scalenia bez dotykania mistrza.
3a: Scal pre-master Do master lub
3b: połącz wszystkie gałęzie wydane przez wannabe w master

W każdym razie posłuchałbym rady @ orange80.

Cofnięcie połączenia z Gitem jest tak proste, że nie powinieneś się martwić o suchą rundę:

$ git pull $REMOTE $BRANCH
# uh oh, that wasn't right
$ git reset --hard ORIG_HEAD
# all is right with the world

EDIT: jak zaznaczono w komentarzach poniżej, jeśli masz zmiany w katalogu roboczym lub staging area, prawdopodobnie będziesz chciał je ukryć przed wykonaniem powyższego (w przeciwnym razie znikną po git reset powyżej)

Zrobiłem pseudonim do robienia tego i działa jak urok, robię to:

 git config --global alias.mergetest '!f(){ git merge --no-commit --no-ff "$1"; git merge --abort; echo "Merge aborted"; };f '

Now I just call

git mergetest <branchname>

Aby dowiedzieć się, czy są jakieś konflikty.

Po prostu odróżnij bieżącą gałąź od zdalnej, to powie Ci, co się zmieni, gdy wykonasz pull/merge.

#see diff between current master and remote branch
git diff master origin/master

Używam do tego polecenia request-pull git. Pozwala zobaczyć każdą zmianę, która nastąpiłaby podczas scalania, , ale bez robienia czegokolwiek na lokalnych lub zdalnych repozytoriach.

Na przykład, wyobraź sobie, że chcesz scalić gałąź o nazwie "feature-x" do gałęzi master

git request-pull master origin feature-x

Pokaże Ci podsumowanie tego, co się stanie (bez robienia czegokolwiek):

The following changes since commit fc01dde318:
    Layout updates (2015-06-25 11:00:47 +0200)
are available in the git repository at:
    http://fakeurl.com/myrepo.git/ feature-x
for you to fetch changes up to 841d3b41ad:
----------------------------------------------------------------
john (2):
    Adding some layout
    Refactoring
ioserver.js            |   8 +++---
package.json           |   7 +++++-
server.js              |   4 +--
layout/ldkdsd.js       | 277 +++++++++++++++++++++++++++++++++++++
4 files changed, 289 insertions(+), 7 deletions(-)
create mode 100644 layout/ldkdsd.js

Jeśli dodasz parametr -p, otrzymasz również pełny tekst łaty, dokładnie tak, jak gdyby robiłaś git diff na każdym zmienionym pliku.

Dziwię się, że nikt jeszcze nie zasugerował używania łatek.

Powiedz, że chcesz przetestować połączenie z your_branch do master (zakładam, że maszmaster sprawdzone):

$ git diff master your_branch > your_branch.patch
$ git apply --check your_branch.patch
$ rm your_branch.patch

Jeśli pojawią się błędy typu

error: patch failed: test.txt:1
error: test.txt: patch does not apply

Oznacza to, że łatka nie powiodła się i połączenie wywołałoby konflikty. Brak wyjścia oznacza, że patch jest czysty i będziesz mógł łatwo połączyć gałąź

Zauważ, że to nie zmieni się w rzeczywistości Twoje działające drzewo (oczywiście oprócz tworzenia pliku łatki, ale możesz to bezpiecznie usunąć później). Z dokumentacji git-apply:

--check
    Instead of applying the patch, see if the patch is applicable to the
    current working tree and/or the index file and detects errors. Turns
    off "apply".

uwaga dla każdego, kto jest mądrzejszy/bardziej doświadczony z Gitem niż ja: proszę dać mi znać, jeśli się mylę i ta metoda pokazuje inne zachowanie niż zwykłe scalanie. Wydaje się dziwne, że w ciągu ponad 8 lat istnienia tego pytania nikt nie sugerowałby tego pozornie oczywistego rozwiązania.

To może być interesujące: z dokumentacji:

Jeśli próbowałeś połączenia, które spowodowało złożone konflikty i chcesz zacznij od nowa, możesz odzyskać za pomocą git merge --abort .

Ale można też zrobić to naiwnie (ale wolno):

rm -Rf /tmp/repository
cp -r repository /tmp/
cd /tmp/repository
git merge ...
...if successful, do the real merge. :)

(uwaga: nie zadziała tylko klonowanie do /tmp, potrzebujesz kopii, aby mieć pewność, że niezatwierdzone zmiany nie będą ze sobą kolidować).

Zdaję sobie sprawę, że jest to stare pytanie, ale jest to pierwsze, które pojawia się w wyszukiwarce Google.

Git wprowadził opcję --FF-only podczas scalania.

From: http://git-scm.com/docs/git-merge

---

--FF-only

Odmowa scalenia i zakończenia ze statusem niezerowym, chyba że bieżąca głowica jest już aktualna lub połączenie może zostać rozwiązane jako przewijanie do przodu.

Zrobienie tego spowoduje próbę połączenia i przewijanie do przodu, a jeśli nie może, przerywa i podpowiada, że przewijanie do przodu nie może być wykonane, ale pozostawia działającą gałąź nietkniętą. Jeśli może przewijać do przodu, to wykona scalenie na działającej gałęzi. Ta opcja jest również dostępna na git pull. W ten sposób można wykonać następujące czynności:

git pull --ff-only origin branchA #See if you can pull down and merge branchA

git merge --ff-only branchA branchB #See if you can merge branchA into branchB

Używam git log aby zobaczyć co się zmieniło na gałęzi feature z gałęzi master

git log does_this_branch..contain_this_branch_changes

Np.-aby zobaczyć jakie commity znajdują się w gałęzi feature, która nie została/nie została scalona do master:

git log master..feature_branch

Jeśli chcesz przewijać z B do A, musisz upewnić się, że Git log B..A nie pokazuje nic, tzn. A nie ma nic, czego B nie ma. Ale nawet jeśli B..A ma coś, możesz nadal być w stanie połączyć się bez konfliktów, więc powyższe pokazuje dwie rzeczy: że będzie przewijanie do przodu, a tym samym nie dostaniesz konfliktu.

Utwórz tymczasową kopię swojej kopii roboczej, następnie połącz ją z nią i różnicuj obie.