Найти материнская ветка в Git

перефразирование

другой способ сформулировать вопрос: "Какова ближайшая фиксация, которая находится на ветке, отличной от текущей ветви, и какая ветвь это?"

решение

вы можете найти его с немного магии командной строки

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

вот как это работает:

1. отображение текстовой истории всех коммитов, включая удаленные ветви.
2. указаны предки текущего коммита по звезде. Отфильтровать все остальное.
3. игнорировать все коммиты в текущей ветке.
4. первым результатом будет ближайшая ветвь предка. Игнорируйте другие результаты.
5. названия ветвей отображаются [в скобках]. Игнорируйте все, что находится за скобками, и скобки.
6. иногда имя ветви будет включать ~# или^#, чтобы указать, сколько коммитов находится между указанным коммитом и наконечником ветви. Нам все равно. Игнорировать их.

и в результате

запуск вышеуказанного кода на

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

даст вам develop Если вы запустите его из H и master Если вы запустите его и.

код доступен в виде gist

вы также можете попробовать:

git log --graph --decorate

у меня есть решение вашей общей проблемы (определить, если feature происходит от кончика develop), но он не работает с использованием метода, который вы изложили.

можно использовать git branch --contains чтобы перечислить все ветви, сошедшие с кончика develop, а затем использовать grep чтобы убедиться feature среди них.

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

если он среди них, он будет печатать " feature" к стандартному выходу и имеют код возврата 0. В противном случае он ничего не напечатает и будет иметь код возврата часть 1.

это работает нормально для меня.

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

вежливые ответы от: @droidbot и @Jistanidiot

поскольку ни один из ответов выше не работал в нашем репозитории, я хочу поделиться своим собственным способом, используя последние слияния в git log:

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

положите его в скрипт с именем git-last-merges, который также принимает имя ветви в качестве аргумента (вместо текущей ветви), а также другие git log аргументы

на выходе мы можем вручную определить родительскую ветвь(ы) на основе собственных соглашений о ветвлении и количества слияний из каждой ветви.

EDIT: Если вы используете git rebase на дочерних ветвях часто (и слияния часто переадресовываются, поэтому не слишком много коммитов слияния), этот ответ не будет работать хорошо, поэтому я написал сценарий для подсчета коммитов вперед (normal и merge), а за коммитами (не должно быть никакого за слиянием в родительской ветви) на всех ветвях по сравнению с текущей ветвью. Просто запустите этот скрипт и дайте мне знать, если у вас работает или нет

#!/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

помните это, как описано в "Git: поиск того, из какой ветви пришел коммит", вы не можете легко определить ветвь, где была сделана эта фиксация (ветви могут быть переименованы, перемещены, удалены...), даже если git branch --contains <commit> - это старт.

• вы можете вернуться от фиксации к фиксации до git branch --contains <commit> Не список feature филиала и филиала,
• сравнить, что совершить SHA1, чтобы /refs/heads/develop

если два коммита id матч, вы хорошо идти (это будет означать feature ветвь имеет свое происхождение во главе develop).

git parent

вы можете просто выполнить команду

git parent

чтобы найти родителя ветви, если вы добавите @Joe Chrysler ответ как git alias. Это упростит использование.

откройте файл gitconfig, расположенный по адресу"~/.gitconfig " с помощью любого текстового редактора.

vim  ~/.gitconfig

добавьте в файл следующую команду alias:

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

сохранить и закрыть редактор.

выполнить команду git parent

вот именно!

магия командной строки JoeChrysler может быть упрощена. Вот логика, как написано:

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

мы можем сделать то же самое, что все пять из этих команд фильтры в относительно простой :

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

вот так ломается:

-F'[]^~[]' 

разделить строку на поля в ],^,~ и [ символы.

/\*/                      

найти строки, содержащие звездочка

&& !/'"$current_branch"'/

...но не текущее название ветки

{ print ;               

когда вы найдете такую строку, выведите ее второе поле (то есть часть между первым и вторым вхождениями наших символов разделителя полей). Для простых имен ветвей это будет только то, что находится между скобками; для ссылок с относительными скачками это будет просто имя без модификатора. Таким образом, наш набор разделителей полей обрабатывает намерение обоих sed команды.

  exit }

затем немедленно выйти. Это означает, что он только когда-либо обрабатывает первую совпадающую строку, поэтому нам не нужно передавать вывод через head -n 1.

@Mark Reed: вы должны добавить, что строка фиксации должна содержать не только звездочку, но и начинаться со звездочки! В противном случае сообщения фиксации, содержащие звездочку, также включаются в соответствующие строки. Так и должно быть:

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

или длинная версия:

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/.*\[\(.*\)\].*//' | # really, just the part of the line between []
  sed 's/[\^~].*//'            # and with any relative refs (^, ~n) removed`

кросс-платформенная реализация с 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=""/>
                <replaceregex pattern="[\^~].*" replace=""/>
            </tokenfilter>
          </filterchain>
    </loadresource>

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

вот реализация PowerShell решения Марка Рида:

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

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/.*\[\(.*\)\].*//' | sed 's/[\^~].*//'

достигает тех же целей, что и ответ Марка Рида, но использует гораздо более безопасный подход, который не ведет себя плохо в ряде сценариев:

1. последняя фиксация родительской ветви-это слияние, что делает столбец show - не *
2. сообщение содержит название
3. сообщение содержит *

любой, кто хочет сделать это в эти дни - приложение SourceTree Atlassian показывает вам отличное визуальное представление о том, как ваши ветви связаны друг с другом, т. е. где они начинались и где они в настоящее время сидят в порядке фиксации (например, голова или 4 фиксации позади и т. д.).

Если вы используете исходное дерево, посмотрите на свои данные фиксации > родители >, тогда вы увидите подчеркнутые номера фиксации (ссылки)

Я не говорю, что это хороший способ решить эту проблему, однако это, кажется, работает для меня.

git branch --contains $(cat .git/ORIG_HEAD) Проблема в том, что cat'ING файл заглядывает во внутреннюю работу git, поэтому это не обязательно совместимо вперед (или обратно совместимо).