Jak korzystać z Git Merge - Quash?

Mam zdalny serwer Git, oto scenariusz, który chcę wykonać:

• Dla każdego błędu / funkcji tworzę inną gałąź Git

• Nadal zatwierdzam swój kod w tym oddziale Git z nieoficjalnymi wiadomościami Git

• W górnym repozytorium musimy wykonać jedno zatwierdzenie dla jednego błędu z oficjalną wiadomością Git

Jak więc połączyć moją gałąź z gałęzią zdalną, aby otrzymali tylko jedno zatwierdzenie dla wszystkich moich meldowań (nawet chcę podać w tym celu komunikat zatwierdzenia)?

Powiedzmy, że twoja gałąź naprawiania błędów jest wywoływana bugfixi chcesz połączyć ją w master:

git checkout master
git merge --squash bugfix
git commit

Spowoduje to pobranie wszystkich zatwierdzeń z bugfixgałęzi, zgniecenie ich w 1 zatwierdzenie i scalenie go z mastergałęzią.

Objaśnienie :

git checkout master

Przełączniki do masteroddziału.

git merge --squash bugfix

Pobiera wszystkie zatwierdzenia z bugfixoddziału i łączy je z bieżącym oddziałem.

git commit

Tworzy pojedyncze zatwierdzenie na podstawie scalonych zmian.

Pominięcie -mparametru pozwala zmodyfikować wersję roboczą wiadomości zatwierdzenia zawierającą każdą wiadomość z twoich zgniecionych zatwierdzeń przed sfinalizowaniem twojego zatwierdzenia.

To, co ostatecznie mnie wyjaśniło, to komentarz pokazujący, że:

git checkout main
git merge --squash feature

jest odpowiednikiem robienia:

git checkout feature
git diff main > feature.patch
git checkout main
patch -p1 < feature.patch
git add .

Kiedy chcę scalić gałąź funkcji ze 105 zatwierdzeniami (!!) i zmiażdżyć je wszystkie w jednym, nie chcę, git rebase -i origin/masterponieważ muszę osobno rozwiązywać konflikty scalania dla każdego z pośrednich zatwierdzeń (lub przynajmniej tych, które git nie może się zorientować). Użycie git merge --squashdaje mi wynik, jaki chcę, z jednego zatwierdzenia do scalenia całej gałęzi funkcji. Potrzebuję tylko jednego ręcznego rozwiązania konfliktu.

Chcesz połączyć z opcją squash. Dzieje się tak, jeśli chcesz to zrobić pojedynczo.

git merge --squash feature1

Jeśli chcesz scalić wszystkie gałęzie w tym samym czasie, co pojedyncze zatwierdzenia, najpierw najpierw wykonaj interaktywny podział i wyciśnij każdą funkcję, a następnie scal ośmiornicę:

git checkout feature1
git rebase -i master

Squash w jednym zatwierdzeniu, a następnie powtórz dla pozostałych funkcji.

git checkout master
git merge feature1 feature2 feature3 ...

To ostatnie scalenie jest „scaleniem ośmiornicy”, ponieważ łączy wiele gałęzi jednocześnie.

Mam nadzieję że to pomoże

Jeśli masz już git merge bugfixwłączony main, możesz zmiksować zatwierdzenie scalania w jeden z:

git reset --soft HEAD^1
git commit

Scal newFeaturegałąź masterz niestandardowym zatwierdzeniem:

git merge --squash newFeature && git commit -m 'Your custom commit message';

Jeśli zamiast tego zrobisz

git merge --squash newFeature && git commit

otrzymasz komunikat zatwierdzenia, który będzie zawierał wszystkie zatwierdzenia newFeatureoddziału, które możesz dostosować.

Dokładnie to wyjaśniam tutaj: https://youtu.be/FQNAIacelT4

Wiem, że to pytanie nie dotyczy konkretnie Github, ale ponieważ Github jest tak szeroko stosowane i to jest odpowiedź, której szukałem, podzielę się nią tutaj.

Github ma możliwość wykonywania połączeń squash, w zależności od opcji scalania włączonych dla repozytorium.

Jeśli scalenia squasha są włączone, opcja „Squash and merge” powinna pojawić się w menu pod przyciskiem „Scal”.

Załóżmy, że pracowałeś w funkcji / zadaniu 1 z wieloma zatwierdzeniami.

1. Przejdź do gałęzi projektu (project / my_project)

   git checkout project/my_project
   

2. Utwórz nowy oddział (feature / task1_bugfix)

   git checkout -b feature/task1_bugfix
   

3. Połącz z --squashopcją

   git merge --squash feature/task1
   

4. Utwórz pojedynczy zatwierdzenie

   git commit -am "add single comments"
   

5. Pchnij swój oddział

   git push --set-upstream origin feature/task1_bugfix
   

Dla Gita

Utwórz nową funkcję

przez Terminal / Shell:

git checkout origin/feature/<featurename>
git merge --squash origin/feature/<featurename>

Nie zatwierdza go, pozwala najpierw go przejrzeć.

Następnie zatwierdź i zakończ funkcję z tej nowej gałęzi, a następnie usuń / zignoruj ​​starą (tę, którą stworzyłeś).

jeśli pojawi się błąd: zatwierdzenie nie jest możliwe, ponieważ masz nie scalone pliki.

git checkout master
git merge --squash bugfix
git add .
git commit -m "Message"

naprawiono wszystkie pliki konfliktu

git add . 

możesz również użyć

git add [filename]

Aby zgnieść lokalny oddział przed wypchnięciem go:

1. sprawdź gałąź, o której mowa, aby pracować, jeśli nie jest jeszcze wyewidencjonowana.

2. Znajdź sha najstarszego zatwierdzenia, które chcesz zachować.

3. Utwórz / sprawdź nową gałąź (tmp1) z tego zatwierdzenia.

   git checkout -b tmp1 <sha1-of-commit>

4. Scal oryginalną gałąź w nową zgniatanie.

   git merge --squash <original branch>

5. Zatwierdź zmiany, które zostały utworzone przez scalenie, z komunikatem o zatwierdzeniu podsumowania.

   git commit -m <msg>

6. Do kasy oryginalnej gałęzi, którą chcesz zgnieść.

   git checkout <branch>

7. Zresetuj do pierwotnego zatwierdzenia, które chcesz zachować.

   git reset --soft <sha1>

8. Ponownie uruchom tę gałąź w oparciu o nową gałąź tmp1.

   git rebase tmp1

9. To wszystko - teraz usuń tymczasową gałąź tmp1, gdy masz pewność, że wszystko jest w porządku.

Możesz użyć narzędzia, które stworzyłem, aby ułatwić ten proces: git-squash . Na przykład, aby zgnieść wszystkie zatwierdzenia w gałęzi funkcji, która została rozgałęziona z gałęzi głównej, napisz:

git squash master
git push --force