Skąd mam wiedzieć, czy gałąź została już scalona w master?

Mam repozytorium git z wieloma gałęziami.

Skąd mam wiedzieć, które gałęzie są już połączone w gałąź główną?

git branch --merged masterwyświetla gałęzie scalone w master

git branch --mergedwyświetla gałęzie połączone w HEAD (tj. wierzchołek bieżącego oddziału)

git branch --no-merged wyświetla gałęzie, które nie zostały scalone

Domyślnie dotyczy to tylko lokalnych oddziałów. -aFlag pokaże zarówno lokalnych i zdalnych oddziałów, a -rpokazy flag tylko zdalnych oddziałów.

Za pomocą tego git merge-basepolecenia można znaleźć najnowsze wspólne zatwierdzanie między dwoma gałęziami. Jeśli to zatwierdzenie jest takie samo jak szef gałęzi, gałąź została całkowicie scalona.

Zauważ, że git branch -drobi to już teraz, ponieważ odmówi usunięcia gałęzi, która nie została jeszcze całkowicie scalona.

Istnieje również rozwiązanie interfejsu graficznego. Po prostu wpisz

gitk --all

W nowym oknie aplikacji zostanie wyświetlona graficzna reprezentacja całego repozytorium, przy czym bardzo łatwo jest stwierdzić, czy gałąź została już scalona, ​​czy nie

Korzystam z następującej funkcji bash, takiej jak: git-is-merged develop feature/new-feature

git-is-merged () {
  merge_destination_branch=$1
  merge_source_branch=$2

  merge_base=$(git merge-base $merge_destination_branch $merge_source_branch)
  merge_source_current_commit=$(git rev-parse $merge_source_branch)
  if [[ $merge_base = $merge_source_current_commit ]]
  then
    echo $merge_source_branch is merged into $merge_destination_branch
    return 0
  else
    echo $merge_source_branch is not merged into $merge_destination_branch
    return 1
  fi
}

Zastosowanie git merge-base <commit> <commit>.

To polecenie wyszukuje najlepszych wspólnych przodków między dwoma zatwierdzeniami. A jeśli wspólny przodek jest identyczny z ostatnim zatwierdzeniem „gałęzi”, to możemy spokojnie założyć, że „gałąź” została już scalona z masterem.

Oto kroki

1. Znajdź hash ostatniego zatwierdzenia w gałęzi master
2. Znajdź hash ostatniego zatwierdzenia w „oddziale”
3. Uruchom polecenie git merge-base <commit-hash-step1> <commit-hash-step2>.
4. Jeśli dane wyjściowe z kroku 3 są takie same jak dane wyjściowe z kroku 2, to „gałąź” została już scalona w master.

Więcej informacji na temat git merge-base https://git-scm.com/docs/git-merge-base .

Na temat czyszczenia zdalnych gałęzi

git branch -r | xargs -t -n 1 git branch -r --contains

Zawiera listę każdej zdalnej gałęzi, a po niej zdalne gałęzie, w których znajdują się ich najnowsze SHA.

Jest to przydatne do rozpoznania, które zdalne gałęzie zostały scalone, ale nie usunięte, a które nie zostały scalone, a zatem ulegają rozkładowi.

Jeśli używasz „tig” (jest jak gitk, ale oparty na terminalach), możesz

tig origin/feature/someones-decaying-feature

aby zobaczyć historię zatwierdzania oddziału bez konieczności pobierania kasy

Aby sprawdzić, które gałęzie są połączone w master, należy użyć następujących poleceń:

• git branch <flag[-r/-a/none]> --merged master lista wszystkich gałęzi scalonych w master.
• git branch <flag[-r/-a/none]> --merged master | wc -l policz liczbę wszystkich oddziałów scalonych w master.

Flagi są:

• -aflag - (wszystkie) pokazujące oddziały zdalne i lokalne
• -rflag - (zdalny) pokazuje tylko zdalne gałęzie
• <emptyFlag>- pokazywanie tylko lokalnych oddziałów

na przykład: git branch -r --merged master pokaże wszystkie zdalne repozytoria połączone w master.

Oto moje techniki, kiedy muszę dowiedzieć się, czy gałąź została scalona, ​​nawet jeśli można ją było zmienić, aby była aktualna z naszą główną gałęzią, co jest częstym scenariuszem dla gałęzi funkcji.

Żadne z tych podejść nie jest głupie, ale wielokrotnie uważałem je za przydatne.

1 Pokaż dziennik dla wszystkich oddziałów

Używając wizualnego narzędzia, takiego jak gitk lub TortoiseGit, lub po prostu git log z opcją --all, przejrzyj historię, aby zobaczyć wszystkie połączenia do głównej gałęzi. Powinieneś być w stanie stwierdzić, czy ta konkretna gałąź funkcji została scalona, ​​czy nie.

2 Zawsze usuwaj zdalną gałąź podczas łączenia w gałąź funkcji

Jeśli masz dobry nawyk usuwania zarówno gałęzi lokalnej, jak i zdalnej podczas scalania w gałęzi funkcji, możesz po prostu zaktualizować i przyciąć piloty na drugim komputerze, a gałęzie funkcji znikną.

Aby to zapamiętać, używam już rozszerzeń git flow (edycja AVH) do lokalnego tworzenia i scalania moich gałęzi funkcji, dlatego dodałem następujący haczyk git flow z pytaniem, czy chcę również automatycznie usunąć gałąź zdalną.

Przykład tworzenia / zakończenia gałęzi funkcji

554 Andreas:MyRepo(develop)$ git flow start tmp
Switched to a new branch 'feature/tmp'

Summary of actions:
- A new branch 'feature/tmp' was created, based on 'develop'
- You are now on branch 'feature/tmp'

Now, start committing on your feature. When done, use:

     git flow feature finish tmp

555 Andreas:MyRepo(feature/tmp)$ git flow finish
Switched to branch 'develop'
Your branch is up-to-date with 'if/develop'.
Already up-to-date.

[post-flow-feature-finish] Delete remote branch? (Y/n)
Deleting remote branch: origin/feature/tmp.

Deleted branch feature/tmp (was 02a3356).

Summary of actions:
- The feature branch 'feature/tmp' was merged into 'develop'
- Feature branch 'feature/tmp' has been locally deleted
- You are now on branch 'develop'

556 Andreas:ScDesktop (develop)$

.git / hooks / post-flow-feature-finish

NAME=$1
ORIGIN=$2
BRANCH=$3

# Delete remote branch
# Allows us to read user input below, assigns stdin to keyboard
exec < /dev/tty

while true; do
  read -p "[post-flow-feature-finish] Delete remote branch? (Y/n) " yn
  if [ "$yn" = "" ]; then
    yn='Y'    
  fi
  case $yn in
      [Yy] ) 
        echo -e "\e[31mDeleting remote branch: $2/$3.\e[0m" || exit "$?"
        git push $2 :$3; 
        break;;
      [Nn] ) 
        echo -e "\e[32mKeeping remote branch.\e[0m" || exit "$?"
        break;;
      * ) echo "Please answer y or n for yes or no.";;
  esac
done

# Stop reading user input (close STDIN)
exec <&-
exit 0

3 Wyszukaj według komunikatu zatwierdzenia

Jeśli nie zawsze usuwasz zdalną gałąź, nadal możesz wyszukać podobne zatwierdzenia, aby ustalić, czy gałąź została scalona, ​​czy nie. Pułapka polega na tym, że gałąź zdalna została przeniesiona do nierozpoznawalnego, takiego jak zgniecenie zatwierdzeń lub zmiana komunikatów zatwierdzania.

• Pobierz i przycinaj wszystkie piloty
• Znajdź wiadomość o ostatnim zatwierdzeniu w gałęzi funkcji
• Sprawdź, czy zatwierdzenie z tym samym komunikatem można znaleźć w gałęzi master

Przykładowe polecenia w gałęzi master:

gru                   
gls origin/feature/foo
glf "my message"

W moim bashu .profile config

alias gru='git remote update -p'
alias glf=findCommitByMessage

findCommitByMessage() {
    git log -i --grep="$1"
}

Oto mały linijka, która poinformuje cię, czy twoja gałąź zawiera lub nie zawiera danych ze zdalnego źródła / gałęzi master:

$ git fetch && git branch -r --merged | grep -q origin/master && echo Incorporates origin/master || echo Out of date from origin/master

Natknąłem się na to pytanie podczas pracy nad gałęzią funkcji i często chciałem się upewnić, że najnowsze prace zostały włączone do mojej osobnej gałęzi.

Aby uogólnić ten test, dodałem następujący alias do mojego ~ / .gitconfig:

[alias]
   current = !git branch -r --merged | grep -q $1 && echo Incorporates $1 || echo Out of date from $1 && :

Następnie mogę zadzwonić:

$ git current origin/master

sprawdzić, czy jestem obecny.