Jak znaleźć najbliższego rodzica gałęzi Git?

A rephrasal

Innym sposobem wyrażenia tego pytania jest "jaki jest najbliższy commit, który znajduje się na gałęzi innej niż bieżąca i która to gałąź?"

A solution

Możesz go znaleźć za pomocą odrobiny magii linii poleceń

git show-branch \
| sed "s/].*//" \
| grep "\*" \
| grep -v "$(git rev-parse --abbrev-ref HEAD)" \
| head -n1 \
| sed "s/^.*\[//" 

Z awk :

git show-branch -a \
| grep '\*' \
| grep -v `git rev-parse --abbrev-ref HEAD` \
| head -n1 \
| sed 's/[^\[]*//' \
| awk 'match($0, /\[[a-zA-Z0-9\/-]+\]/) { print substr( $0, RSTART+1, RLENGTH-2 )}'

Oto Jak to działa:

1. Wyświetla historię tekstową wszystkich commitów, łącznie ze zdalnymi gałęziami.
2. przodkowie aktualnego commita są wskazywani przez star. Odfiltruj Wszystko inne.
3. ignoruje wszystkie commity w bieżącej gałęzi.
4. pierwszy wynik będzie najbliższą gałęzią przodka. Zignoruj Pozostałe wyniki.
5. nazwy gałęzi są wyświetlane [w nawiasach]. Ignoruj wszystko poza nawiasami i nawiasami.
6. czasami nazwa gałęzi będzie zawierać ~ # lub ^#, aby wskazać, ile commitów znajduje się pomiędzy odwołanym commitem a końcówką gałęzi. Nie obchodzi nas to. Zignoruj ich.

I Wynik

Uruchamianie powyższego kodu na

 A---B---D <-master
      \
       \
        C---E---I <-develop
             \
              \
               F---G---H <-topic

Da ci develop jeśli uruchomisz go z H I master jeśli uruchomisz go z I.

Kod jest dostępny jako gist

Możesz również spróbować:

git log --graph --decorate

Git parent

Możesz po prostu uruchomić polecenie

git parent

Aby znaleźć rodzica gałęzi, dodaj odpowiedź @Joe Chrysler jako alias git . Uprości to Korzystanie.

Otwórz plik gitconfig znajdujący się w "~/.gitconfig" używając dowolnego edytora tekstu. (Dla Linuksa). I dla okien ".gitconfig " ścieżka znajduje się zazwyczaj w c:\users\your-user\.gitconfig

vim  ~/.gitconfig

Dodaj do pliku następujące polecenie alias:

[alias]
            parent = "!git show-branch | grep '*' | grep -v \"$(git rev-parse --abbrev-ref HEAD)\" | head -n1 | sed 's/.*\\[\\(.*\\)\\].*/\\1/' | sed 's/[\\^~].*//' #"

Zapisz i wyjdź z redaktor.

Uruchom polecenie git parent

Mam rozwiązanie twojego ogólnego problemu( określ, czy {[1] } pochodzi od końcówki develop), ale nie działa przy użyciu metody, którą opisałeś.

Możesz użyć git branch --contains, aby wyświetlić listę wszystkich gałęzi pochodzących z końcówki develop, a następnie użyć grep, aby upewnić się, że feature jest wśród nich.

git branch --contains develop | grep "^ *feature$"

Jeśli jest wśród nich, wyświetli " feature" na standardowe wyjście i będzie miał kod powrotu równy 0. W przeciwnym razie nic nie wydrukuje i będzie miał kod zwrotny równy 1.

To działa dobrze dla mnie.

git show-branch | grep '*' | grep -v "$(git rev-parse --abbrev-ref HEAD)" | head -n1 | sed 's/.*\[\(.*\)\].*/\1/' | sed 's/[\^~].*//'

Ponieważ żadna z powyższych odpowiedzi nie działa na naszym repozytorium, chcę podzielić się swoją własną drogą, używając najnowszych mergów w git log:

#!/bin/bash
git log --oneline --merges "$@" | grep into | sed 's/.* into //g' | uniq --count | head -n 10

Umieść go w skrypcie o nazwie git-last-merges, który również przyjmuje nazwę gałęzi jako argument (zamiast bieżącej gałęzi), a także inne argumenty git log

Z wyjścia możemy ręcznie wykryć gałąź (- y) nadrzędną (- e) na podstawie własnych konwencji rozgałęzień i liczby scaleń z każdej gałęzi.

EDIT: Jeśli często używasz git rebase na gałęziach potomnych (a merge sÄ ... czÄ ™ sto przekazywane szybko, wiÄ ™ c nie ma zbyt wielu zmian scalajÄ ... cych), ta odpowiedĹş nie bÄ ™ dzie dziaĹ ' aĹ 'a dobrze, wiÄ ™ c napisaĹ' em skrypt, ktĂłry liczyĺ ' przed commitami (normal i merge), a za commitami (nie powinno byÄ ‡ Ĺźadnych za merge w branĹźy macierzystej) na wszystkich branĺźach w porăłwnaniu do obecnej branĹźy. Po prostu uruchom ten skrypt i daj mi znać, czy działa dla Ciebie, czy nie

#!/bin/bash
HEAD="`git rev-parse --abbrev-ref HEAD`"
echo "Comparing to $HEAD"
printf "%12s  %12s   %10s     %s\n" "Behind" "BehindMerge" "Ahead" "Branch"
git branch | grep -v '^*' | sed 's/^\* //g' | while read branch ; do
    ahead_merge_count=`git log --oneline --merges $branch ^$HEAD | wc -l`
    if [[ $ahead_merge_count != 0 ]] ; then
        continue
    fi
    ahead_count=`git log --oneline --no-merges $branch ^$HEAD | wc -l`
    behind_count=`git log --oneline --no-merges ^$branch $HEAD | wc -l`
    behind_merge_count=`git log --oneline --merges ^$branch $HEAD | wc -l`
    behind="-$behind_count"
    behind_merge="-M$behind_merge_count"
    ahead="+$ahead_count"
    printf "%12s  %12s   %10s     %s\n" "$behind" "$behind_merge" "$ahead" "$branch"
done | sort -n

Rozwiązanie

Rozwiązanie oparte na git show-branch nie do końca działa dla mnie (patrz niżej), więc połączyłem go z jednym na podstawie git log i skończyło się na tym:

git log --decorate --simplify-by-decoration --oneline \ # selects only commits with a branch or tag
      | grep -v "(HEAD" \                               # removes current head (and branch)
      | head -n1 \                                      # selects only the closest decoration
      | sed 's/.* (\(.*\)) .*/\1/' \                    # filters out everything but decorations
      | sed 's/\(.*\), .*/\1/' \                        # picks only the first decoration
      | sed 's/origin\///'                              # strips "origin/" from the decoration

Ograniczenia i zastrzeżenia

• HEAD może być odłączony (wiele narzędzi CI robi to, aby mieć pewność, że zbudują poprawny commit w danej gałęzi), ale origin branch I local branch muszą być zarówno w par lub "powyżej" bieżącej gałęzi.
• musi być brak znaczników w sposób (zakładam, że nie testowałem skryptu na commitach z tagiem między potomkiem a gałęzią nadrzędną)
• skrypt opiera się na fakcie "HEAD" jest zawsze wymienione jako pierwsza Dekoracja przez log
• uruchamianie skryptu na master i develop wyniki (głównie) w <SHA> Initial commit

Wyniki

 A---B---D---E---F <-origin/master, master
      \      \
       \      \
        \      G---H---I <- origin/hotfix, hotfix
         \
          \
           J---K---L <-origin/develop, develop
                \
                 \
                  M---N---O <-origin/feature/a, feature/a
                       \   \
                        \   \
                         \   P---Q---R <-origin/feature/b, feature/b
                          \
                           \
                            S---T---U <-origin/feature/c, feature/c

Pomimo istnienia lokalnej gałęzi (np. tylko origin/topic jest obecny od commit O w 1996 roku, po raz pierwszy w historii, w 1997 roku, w Polsce, w 1998 roku, w Polsce, w 1999 roku, w Polsce i na świecie.]}

• dla commitów G, H, I (oddział hotfix) → master
• dla commitów M, N, O (oddział feature/a) → develop
• dla commitów S, T, U (oddział feature/c) → develop
• dla commitów P, Q, R (oddział feature/b) → feature/a
• dla commitów J, K, L (oddział develop) → <sha> Initial commit*
• dla commitów B, D, E, F (Oddział master) → <sha> Initial commit

Dlaczego nie pokazałeś-branch działa dla mnie

Rozwiązanie oparte na git show-branch okazało się zawodne dla mnie w następujących sytuacjach:

• Głowa wolnostojąca - w tym Głowa wolnostojąca case oznacza zamianę grep '\*' \ na 'grep'!'\- a to dopiero początek wszystkich kłopotów
• uruchamianie skryptu na master i develop wyniki w develop i ` odpowiednio
• gałęzie na master branch (hotfix/ Branch) kończy się develop jako rodzic, ponieważ ich najbliższy rodzic master został oznaczony ! zamiast * nie bez powodu.

Pamiętaj, że jak opisano w "Git: Finding what branch a commit came from" , nie możesz łatwo wskazać gałęzi, z której został utworzony commit (gałęzie mogą być zmieniane, przenoszone, usuwane...), choć git branch --contains <commit> to początek.

• Możesz wrócić z commit do commit, dopóki git branch --contains <commit> nie wyświetli gałęzi feature oraz listy gałęzi develop,
• porównaj ten commit SHA1 do /refs/heads/develop

Jeśli dwa commity id pasują, możesz iść (oznaczałoby to feature oddział ma swój początek na czele develop).

Oto implementacja PowerShell rozwiązania Marka Reeda:

git show-branch -a | where-object { $_.Contains('*') -eq $true} | Where-object {$_.Contains($branchName) -ne $true } | select -first 1 | % {$_ -replace('.*\[(.*)\].*','$1')} | % { $_ -replace('[\^~].*','') }

Magia wiersza poleceń Joechryslera może być uproszczona. Oto logika Joego - dla zwięzłości wprowadziłem parametr o nazwie cur_branch w miejsce zastąpienia polecenia `git rev-parse --abbrev-ref HEAD` w obu wersjach; można go zainicjować w następujący sposób:

cur_branch=$(git rev-parse --abbrev-ref HEAD)

Oto rurociąg Joe:

git show-branch -a           |
  grep '\*'                  | # we want only lines that contain an asterisk
  grep -v "$cur_branch"      | # but also don't contain the current branch
  head -n1                   | # and only the first such line
  sed 's/.*\[\(.*\)\].*/\1/' | # really, just the part of the line between []
  sed 's/[\^~].*//'            # and with any relative refs (^, ~n) removed

Możemy wykonać to samo, co wszystkie pięć tych pojedynczych filtrów poleceń w stosunkowo prostym poleceniu awk:

git show-branch -a |
  awk -F'[]^~[]' '/\*/ && !/'"$cur_branch"'/ {print $2;exit}'  

To rozkłada się tak:

-F'[]^~[]' 

Split the linia do pól w ], ^, ~, i [ znaków.

/\*/                      

Znajdź linie zawierające gwiazdkę

&& !/'"$cur_branch"'/

...ale nie obecna nazwa gałęzi

{ print $2;               

Gdy znajdziesz taką linię, wydrukuj jej drugie pole(to znaczy część pomiędzy pierwszym i drugim wystąpieniem naszych znaków separatora pól). Dla prostych nazw gałęzi, będzie to tylko to, co znajduje się między nawiasami; dla refów ze skokami względnymi, będzie to tylko nazwa bez modyfikatora. Więc nasz zestaw separatorów pól obsługuje intencje obu komend sed.

  exit }

Następnie NATYCHMIAST WYJDŹ. Oznacza to, że przetwarza tylko pierwszą pasującą linię, więc nie musimy przepuszczać wyjścia przez head -n 1.

Nie mówię, że to dobry sposób na rozwiązanie tego problemu, jednak wydaje się, że to działa na mnie.

git branch --contains $(cat .git/ORIG_HEAD) Problem polega na tym, że cat'ing pliku zagląda do wewnętrznego działania Gita, więc niekoniecznie jest to kompatybilne do przodu (lub wstecznie).

Implementacja wieloplatformowa z Ant

    <exec executable="git" outputproperty="currentBranch">
        <arg value="rev-parse" />  
        <arg value="--abbrev-ref" />  
        <arg value="HEAD" />  
    </exec>

    <exec executable="git" outputproperty="showBranchOutput">
        <arg value="show-branch" />  
        <arg value="-a" />  
    </exec>

    <loadresource property="baseBranch">
      <propertyresource name="showBranchOutput"/>
          <filterchain>
            <linecontains>
              <contains value="*"/>
            </linecontains>
            <linecontains negate="true">
              <contains value="${currentBranch}"/>
            </linecontains>
            <headfilter lines="1"/>
            <tokenfilter>
                <replaceregex pattern=".*\[(.*)\].*" replace="\1"/>
                <replaceregex pattern="[\^~].*" replace=""/>
            </tokenfilter>
          </filterchain>
    </loadresource>

    <echo message="${currentBranch} ${baseBranch}" />

@Mark Reed: powinieneś dodać, że linia zatwierdzania nie powinna zawierać tylko gwiazdkę, ale powinna zaczynać się od gwiazdki! W przeciwnym razie komunikaty zatwierdzające zawierające gwiazdkę są również dołączane do dopasowanych linii. Tak powinno być:

git show-branch -a | awk -F'[]^~[]' '/^\*/ && !/'"$current_branch"'/ {print $2;exit}'

Lub wersja długa:

git show-branch -a           |
  awk '^\*'                  | # we want only lines that contain an asterisk
  awk -v "$current_branch"   | # but also don't contain the current branch
  head -n1                   | # and only the first such line
  sed 's/.*\[\(.*\)\].*/\1/' | # really, just the part of the line between []
  sed 's/[\^~].*//'            # and with any relative refs (^, ~n) removed`

vbc=$(git rev-parse --abbrev-ref HEAD)
vbc_col=$(( $(git show-branch | grep '^[^\[]*\*' | head -1 | cut -d* -f1 | wc -c) - 1 )) 
swimming_lane_start_row=$(( $(git show-branch | grep -n "^[\-]*$" | cut -d: -f1) + 1 )) 
git show-branch | tail -n +$swimming_lane_start_row | grep -v "^[^\[]*\[$vbc" | grep "^.\{$vbc_col\}[^ ]" | head -n1 | sed 's/.*\[\(.*\)\].*/\1/' | sed 's/[\^~].*//'

Osiąga te same cele, Co odpowiedź Marka Reeda, ale używa znacznie bezpieczniejszego podejścia, które nie źle się zachowuje w wielu scenariuszach:

1. Ostatni commit gałęzi nadrzędnej jest scaleniem, co sprawia, że kolumna pokazuje - nie *
2. Commit zawiera nazwę gałęzi
3. Commit message contains *

Oto moja wersja Powershell:

function Get-GHAParentBranch {
    [CmdletBinding()]
    param(
        $Name = (git branch --show-current)
    )
    git show-branch | 
      Select-String '^[^\[]*\*' | 
      Select-String -NotMatch -Pattern "\[$([Regex]::Escape($Name)).*?\]" |
      Select-Object -First 1 |
      Foreach-Object {$PSItem -replace '^.+?\[(.+)\].+$','$1'}
}

Rozwiązania oparte na git show-branch -a plus niektóre filtry mają jeden minus: git może rozważyć nazwę gałęzi o krótkim czasie życia.

Z określonego podzbioru wszystkich gałęzi, który jest najbliższym rodzicem gałęzi git?

Aby uprościć, rozważę "gałąź git", aby odnosić się do HEAD (tj. obecny oddział).

HEAD
important/a
important/b
spam/a
spam/b

Rozwiązania bazujące na filtrach git show-branch -a + mogą dawać, że najbliższym rodzicem HEAD jest spam/a, ale nam to nie zależy.

Jeśli chcemy wiedzieć, który z important/a i important/b jest najbliższym rodzicem HEAD, możemy uruchomić następujące polecenie:

for b in $(git branch -a -l "important/*"); do
    d1=$(git rev-list --first-parent ^${b} HEAD |wc -l);
    d2=$(git rev-list --first-parent ^HEAD ${b} |wc -l);
    echo "${b} ${d1} ${d2}";
done \
|sort -n -k2 -k3 \
|head -n1 \
|awk '{print $1}';

Co robi:

1.) $(git branch -a -l "important/*"): wyświetla listę wszystkich gałęzi z określonym wzorem ("important/*").

2.) d=$(git rev-list --first-parent ^${b} HEAD |wc -l);: dla każdego z tych branches ($b), Oblicz odległość ($d1) w liczbie commitów, od HEAD do najbliższego commita w $b (podobnie jak podczas obliczania odległości od punktu do linii). Możesz rozważyć odległość inaczej: możesz nie chcieć używać --first-parent, lub możesz chcieć odległość od końcówki do końcówki gałęzi ("${b}"...HEAD), ...

2.2) d2=$(git rev-list --first-parent ^HEAD ${b} |wc -l);: dla każdej z tych gałęzi ($b) Oblicz odległość ($d2) w liczbie commitów od wierzchołka gałęzi do najbliższy commit w HEAD. Użyjemy tej odległości do wyboru pomiędzy dwoma gałęziami, których odległość $d1 była równa.

3.) echo "${b} ${d1} ${d2}";: wyświetla nazwę każdej z gałęzi, a następnie odległości, aby móc je później sortować (najpierw $d1, a następnie $d2).

4.) |sort -n -k2 -k3: Sortuj poprzedni wynik, więc otrzymujemy posortowaną (według odległości) listę wszystkich gałęzi, a następnie ich odległości (oba).

5.) |head -n1: pierwszym wynikiem poprzedniego kroku będzie gałąź która ma mniejszą odległość, tj. najbliższą gałąź macierzystą. Więc po prostu odrzuć wszystkie inne gałęzie.

6.) |awk '{print $1}';: zależy nam tylko na nazwie gałęzi, a nie NA odległości, więc wyodrębnij pierwsze pole, które było nazwą rodzica. Tutaj jest! :)

Każdy, kto chce to zrobić w dzisiejszych czasach-aplikacja SourceTree firmy Atlassian pokazuje świetną wizualną reprezentację tego, jak twoje gałęzie odnoszą się do siebie, tj. gdzie zaczęły się i gdzie obecnie znajdują się w kolejności commitów (np. HEAD lub 4 commity z tyłu itp.).

Jeśli używasz drzewa źródeł, spójrz na szczegóły commita > Parents > wtedy zobaczysz numery commitów podkreślone (linki)

Alternatywa: git rev-list master | grep "$(git rev-list HEAD)" | head -1

Get The last commit that it ' s both my branch and master (or whatever branch you want to specific)

To nie działa dla mnie, gdy zrobiłem coś takiego develop > release-v1.0.0 > feature-foo, to przejść całą drogę Wstecz, aby rozwinąć, zauważ, że był rebase zaangażowany, Nie wiem, czy to jest komplikować mój problem...

Poniżej podano prawidłowy hash commit dla mnie

git log --decorate \
  | grep 'commit' \
  | grep 'origin/' \
  | head -n 2 \
  | tail -n 1 \
  | awk '{ print $2 }' \
  | tr -d "\n"

git log -2 --pretty=format:'%d' --abbrev-commit | tail -n 1 | sed 's/\s(//g; s/,/\n/g';

(pochodzenie / nazwa rodzica, nazwa rodzica)

git log -2 --pretty=format:'%d' --abbrev-commit | tail -n 1 | sed 's/\s(//g; s/,/\n/g';

Pochodzenie / nazwa rodzica

git log -2 --pretty=format:'%d' --abbrev-commit | tail -n 1 | sed 's/(.*,//g; s/)//';

Nazwa rodzica

Git jest dostarczany z kilkoma klientami GUI, które pomagają ci to zwizualizować. Otwórz GitGUI i przejdź do menu Repository > Visualize All Branch History