Як знайти найближчого батька філії Git?

Скажімо, у мене є таке локальне сховище з таким файлом:

master --> a
            \
             \
      develop c --> d
               \
                \
         feature f --> g --> h

masterце мій, це останній стабільний код випуску , developце мій це наступний код випуску , і featureце нова функція, яка готується доdevelop .

Те, що я хочу мати можливість робити на своєму віддаленому репо, використовуючи гачки, - featureце відхилення натискань, якщо вчинення fне є прямим нащадком developHEAD. тобто дерево фіксації виглядає так, тому що функція була git rebaseвключена d.

master --> a
            \
             \
      develop c --> d
                     \
                      \
               feature f --> g --> h

Так чи можливо:

• Визначте материнську гілку feature?
• Визначте команду у батьківській гілці, яка fє нащадком?

Звідти я би перевірив, що таке HEAD материнської гілки, і побачив, чи відповідає fпопередник батьківській гілці HEAD, щоб визначити, чи потрібно функцію повторно оцінювати.

Якщо припустити, що у віддаленому сховищі є копія гілки розробки (ваш початковий опис описує її в локальному сховищі, але це здається, що він існує і у віддаленому сховищі), ви повинні мати можливість досягти того, що я думаю, що ви хочете, але підхід трохи відрізняється від того, що ви передбачили.

Історія Git заснована на DAG -комітетах. Відділення (та "загальнодоступні" взагалі) - це лише тимчасові мітки, які вказують на конкретні комісії в постійно зростаючій комісії DAG. Таким чином, відносини між гілками можуть змінюватися з часом, але взаємозв'язок між комісіями не має.

    ---o---1                foo
            \
             2---3---o      bar
                  \
                   4
                    \
                     5---6  baz

Схоже baz, заснована на (старій версії) bar? Але що робити, якщо ми видалимо bar?

    ---o---1                foo
            \
             2---3
                  \
                   4
                    \
                     5---6  baz

Тепер, схоже baz, заснована на foo. Але походження bazне змінилося, ми просто зняли мітку (і випливає в результаті звисання). А що, якщо ми додамо новий ярлик на 4?

    ---o---1                foo
            \
             2---3
                  \
                   4        quux
                    \
                     5---6  baz

Тепер, схоже baz, заснована на quux. Все-таки родовід не змінився, змінилися лише мітки.

Однак, якщо ми запитували, "чи чинить 6нащадок вчинення 3?" (Припускаючи , що 3і 6повний SHA-1 здійснюють імена), то відповідь буде «так», то чи barй quuxмітки присутні чи ні.

Отже, ви можете задати питання на кшталт "чи натиснута фіксація є нащадком поточного кінця гілки розвитку ?", Але ви не можете надійно запитати "що таке батьківська гілка висунутої фіксації?".

В основному надійне питання, яке, здається, наближається до того, що ви хочете, це:

Для всіх предків, що підштовхуються, (за винятком поточної версії розвитку та її предків), які мають поточну верхівку розвитку як батьків:

• чи існує хоча б одна така комісія?
• чи всі такі вчинки, що здійснюються неповнолітніми?

Що може бути реалізовано як:

pushedrev=...
basename=develop
if ! baserev="$(git rev-parse --verify refs/heads/"$basename" 2>/dev/null)"; then
    echo "'$basename' is missing, call for help!"
    exit 1
fi
parents_of_children_of_base="$(
  git rev-list --pretty=tformat:%P "$pushedrev" --not "$baserev" |
  grep -F "$baserev"
)"
case ",$parents_of_children_of_base" in
    ,)     echo "must descend from tip of '$basename'"
           exit 1 ;;
    ,*\ *) echo "must not merge tip of '$basename' (rebase instead)"
           exit 1 ;;
    ,*)    exit 0 ;;
esac

Це охопить частину того, що ви хочете обмежити, але, можливо, не все.

Для довідки, ось розширена приклад історії:

    A                                   master
     \
      \                    o-----J
       \                  /       \
        \                | o---K---L
         \               |/
          C--------------D              develop
           \             |\
            F---G---H    | F'--G'--H'
                    |    |\
                    |    | o---o---o---N
                     \   \      \       \
                      \   \      o---o---P
                       \   \   
                        R---S

Наведений вище код може бути використаний для відхилення Hі Sпри прийомі H', J, Kабо N, але він також буде приймати Lі P(вони включають злиття, але вони не зливаються кінчиком розробки ).

Щоб також відхилити Lі P, ви можете змінити питання і задати його

Для всіх предків, що підштовхуються, (за винятком поточної версії розвитку та її предків):

• чи є якісь зобов’язання з двома батьками?
• якщо ні, чи має принаймні одна така комісія поточна порада розвивати свою (єдину) батьківщину?

pushedrev=...
basename=develop
if ! baserev="$(git rev-parse --verify refs/heads/"$basename" 2>/dev/null)"; then
    echo "'$basename' is missing, call for help!"
    exit 1
fi
parents_of_commits_beyond_base="$(
  git rev-list --pretty=tformat:%P "$pushedrev" --not "$baserev" |
  grep -v '^commit '
)"
case "$parents_of_commits_beyond_base" in
    *\ *)          echo "must not push merge commits (rebase instead)"
                   exit 1 ;;
    *"$baserev"*)  exit 0 ;;
    *)             echo "must descend from tip of '$basename'"
                   exit 1 ;;
esac

Рефраза

Ще один спосіб сформулювати питання: "Який найближчий комітет, який знаходиться на гілці, відмінній від поточної гілки, і яка це гілка?"

Вирішення

Ви можете знайти його за допомогою трохи магії командного рядка

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

З 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 )}'

Ось як це працює:

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

І Результат

Запуск вищевказаного коду на

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

Дасть вам, developякщо ви запустите його з H і masterякщо ви запустите його з I.

Код доступний у вигляді суті

Ви також можете спробувати:

git log --graph --decorate

git батьків

Можна просто запустити команду

git parent

знайти батьківського відділення, якщо ви додасте відповідь @Joe Chrysler як псевдонім git . Це спростить використання.

Відкрийте файл gitconfig, розташований у "~/.gitconfig", використовуючи будь-який текстовий редактор. (Для Linux). А для Windows шлях ".gitconfig" зазвичай знаходиться наc:\users\your-user\.gitconfig

vim  ~/.gitconfig

Додайте таку команду псевдоніму у файл:

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

Збережіть та вийдіть із редактора.

Виконайте команду git parent

Це воно!

У мене є рішення вашої загальної проблеми (визначте, чи 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/.*\[\(.*\)\].*/\1/' | 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часто використовуєте на дочірніх гілках (і злиття часто передаються вперед, щоб не було занадто багато комірок злиття), ця відповідь не спрацює добре, тому я написав сценарій для підрахунку попереду комітів (нормальних і злиття) , а за комітами (не повинно бути жодних за злиттям у материнській гілці) для всіх гілок порівняно з поточною гілкою. Просто запустіть цей сценарій і дайте мені знати, працює він для вас чи ні

#!/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 show-branch рішення не дуже спрацювало для мене (див. Нижче), тому я поєднав його з рішенням на основіgit log та закінчив це:

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

Обмеження та застереження

• HEAD може бути від'єднаний (багато інструментів CI роблять це для того, щоб вони створили правильну фіксацію в даній гілці), але початкова гілка та локальна гілка повинні бути як на рівні, так і «вище» поточної HEAD.
• У способі не повинно бути тегів (я припускаю; я не перевіряв сценарій на комітах з тегом між дочірньою та батьківською гілкою)
• сценарій заснований на тому факті «ГОЛОВИ» завжди вказана в якості першого прикраси по logкоманді
• працює скрипт на masterіdevelop результати ( в основному) в<SHA> Initial commit

Результати

 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

Незважаючи на існування місцевої філії (наприклад, існує лише origin/topicз моменту, коли комісія Oбула перевірена безпосередньо його SHA), сценарій повинен надрукувати наступним чином:

• Для фіксацій G, H,I (філія hotfix) →master
• Для фіксацій M, N,O (філія feature/a) →develop
• Для фіксацій S, T,U (філія feature/c) →develop
• Для фіксацій P, Q,R (філія feature/b) →feature/a
• Для фіксацій J, K, L(філія develop) → <sha> Initial commit*
• Для фіксацій B, D, E, F(філія master) →<sha> Initial commit

* - або masterякщо developдоручення були на вершині Master's HEAD (~ майстер буде швидко розвинутий)

Чому не показали для мене філії роботи

Рішення, засноване наgit show-branch мені, виявилося ненадійним у наступних ситуаціях:

• відокремлена голова - включаючи відокремлений чохол grep '\*' \для голови означає заміну на "grep"! " \ - і це лише початок усіх неприємностей
• працює скрипт на masterіdevelop призводить developі `` відповідно
• гілки наmaster гілці ( hotfix/гілках) закінчуються developяк батьків, оскільки їх найближчий masterбатько гілки позначений !замість *причини.

Пам’ятайте, що, як описано у "Git: Пошук того, з якої гілки взяли комісію" , ви не можете легко визначити гілку, з якої зроблено цей комітет (гілки можна перейменовувати, перемістити, видалити ...), хоча git branch --contains <commit>це і є початком.

• Ви можете повернутися з комісії на фіксацію до тих пір, git branch --contains <commit>поки не з'явиться featureфілія та список developгілок,
• порівняйте цю комісію SHA1 з /refs/heads/develop

Якщо два учасники поспілкуються, ви добре піти (це означатиме, що featureфілія має своє походження в HEAD of develop).

Магія командного рядка JoeChrysler може бути спрощена. Ось логіка Джо - для стислості я ввів параметр, названий cur_branchзамість підстановки команди, `git rev-parse --abbrev-ref HEAD`в обидві версії; які можна ініціалізувати так:

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

Тоді ось труба Джо:

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

Ми можемо виконати те саме, що і всі п'ять цих окремих фільтрів команд у відносно простій awkкоманді:

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

Це руйнується так:

-F'[]^~[]' 

розділити рядок на поля в ], ^, ~та [персонажах.

/\*/                      

Знайдіть рядки, які містять зірочку

&& !/'"$cur_branch"'/

... але не поточна назва філії

{ print $2;               

Знайшовши такий рядок, надрукуйте його друге поле (тобто частину між першим та другим входженнями символів нашого розділювача поля). Для простих імен гілок це буде саме те, що між дужками; для refs з відносними стрибками, це буде лише назва без модифікатора. Таким чином, наш набір розділювачів полів обробляє наміри обох sedкоманд.

  exit }

Потім негайно вийдіть. Це означає, що він лише коли-небудь обробляє перший збіг рядка, тому нам не потрібно передавати вихід head -n 1.

Ось реалізація рішення Mark Reed PowerShell:

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

Я не кажу, що це хороший спосіб вирішити цю проблему, однак це, здається, працює для мене.

git branch --contains $(cat .git/ORIG_HEAD) Проблема полягає в тому, що котирування файлу заглядає до внутрішньої роботи git, тому це не обов'язково для сумісного вперед (або сумісного назад).

Межплатформна реалізація з 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: Вам слід додати, що рядок фіксації повинен містити не лише зірочку, а починати зірочку! В іншому випадку повідомлення фіксації, які містять зірочку, також включаються в відповідні рядки. Так має бути:

git show-branch -a | awk -F'[]^~[]' '/^\*/ && !/'"$current_branch"'/ {print $2;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/.*\[\(.*\)\].*/\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/[\^~].*//'

Досягає тих самих цілей, що і у відповіді Марка Ріда, але використовується набагато безпечніший підхід, який не поводиться в багатьох сценаріях:

1. Остання фіксація батьківської гілки - це злиття, показуючи стовпець - не*
2. Повідомлення фіксації містить назву філії
3. Повідомлення про фіксацію містить *

Кожен, хто хоче це зробити сьогодні - додаток Atlassian SourceTree показує вам чудове візуальне уявлення про те, як ваші гілки ставляться одна до одної, тобто де вони почалися та де вони зараз сидять у порядку виконання (наприклад, HEAD або 4 комірки позаду тощо). .

Якщо ви використовуєте Джерело дерева, подивіться деталі зобов'язань> Батьки>, тоді ви побачите підкреслені номери комісій (посилання)

Альтернатива: git rev-list master | grep "$(git rev-list HEAD)" | head -1

Отримайте останнє зобов’язання, що це і моя філія, і master(або будь-яка галузь, яку ви хочете вказати)

Це не спрацювало для мене, коли я зробив щось подібне develop > release-v1.0.0 > feature-foo , він би пройшов весь шлях назад, щоб розвиватись, зауважте, що там була включена база даних, не впевнений, чи це ускладнює мою проблему ...

Нижче подано правильний хеш для мене

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