Bagaimana menemukan orang tua terdekat dari cabang Git?

Katakanlah saya memiliki repositori lokal berikut dengan pohon komit seperti ini:

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

masteradalah saya ini terbaru kode rilis stabil , developadalah saya ini adalah 'berikutnya' kode rilis , dan featuremerupakan fitur baru yang disiapkan untukdevelop .

Apa yang saya ingin dapat lakukan pada repo jarak jauh saya menggunakan kait, adalah untuk mendorong untuk featureditolak kecuali komit fadalah keturunan langsung developKEPALA. yaitu pohon komit terlihat seperti ini karena fitur telah git rebaseaktif d.

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

Jadi apakah mungkin untuk:

• Identifikasi cabang induk dari feature?
• Identifikasi komit di cabang induk yang fmerupakan turunan dari?

Dari sana saya akan memeriksa apa KEPALA cabang induk, dan melihat apakah fpendahulu cocok dengan cabang orangtua KEPALA, untuk menentukan apakah fitur perlu diubah kembali.

Dengan asumsi bahwa repositori jarak jauh memiliki salinan cabang pengembangan (deskripsi awal Anda menjelaskannya dalam repositori lokal, tetapi kedengarannya seperti itu juga ada di remote), Anda harus dapat mencapai apa yang saya pikir Anda inginkan, tetapi pendekatannya sedikit berbeda dari apa yang Anda bayangkan.

Sejarah Git didasarkan pada DAG komitmen. Cabang (dan "ref" secara umum) hanyalah label sementara yang menunjukkan komitmen spesifik dalam DAG commit yang terus berkembang. Dengan demikian, hubungan antar cabang dapat bervariasi dari waktu ke waktu, tetapi hubungan antara komitmen tidak.

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

Sepertinya bazdidasarkan pada (versi lama) bar? Tetapi bagaimana jika kita menghapus bar?

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

Sekarang sepertinya bazdidasarkan pada foo. Tetapi nenek moyang baztidak berubah, kami hanya menghapus label (dan hasilnya menjuntai komit). Dan bagaimana jika kita menambahkan label baru di 4?

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

Sekarang sepertinya bazdidasarkan pada quux. Meski begitu, nenek moyang tidak berubah, hanya label yang berubah.

Namun, jika kita bertanya "apakah melakukan 6turunan dari komitmen 3?" (dengan asumsi 3dan nama 6lengkap SHA-1 komit), maka jawabannya adalah "ya", apakah label bardan quuxada atau tidak.

Jadi, Anda dapat mengajukan pertanyaan seperti "apakah komit yang didorong adalah turunan dari ujung cabang pengembangan saat ini ?", Tetapi Anda tidak dapat dengan andal bertanya "apa cabang induk dari komit yang didorong?".

Sebagian besar pertanyaan yang andal yang tampaknya mendekati apa yang Anda inginkan adalah:

Untuk semua leluhur komit terdorong (tidak termasuk ujung kembang saat ini dan leluhurnya), yang memiliki kembang ujung saat ini sebagai induk:

• apakah setidaknya ada satu komit seperti itu ada?
• apakah semua komitmen seperti itu dilakukan oleh orang tua tunggal?

Yang dapat diimplementasikan sebagai:

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

Ini akan mencakup sebagian dari apa yang Anda inginkan dibatasi, tetapi mungkin tidak semuanya.

Untuk referensi, berikut adalah sejarah contoh yang diperluas:

    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

Kode di atas dapat digunakan untuk menolak Hdan Ssaat menerima H', J, K, atau N, tetapi akan juga menerima Ldan P(mereka melibatkan gabungan, tetapi mereka tidak menggabungkan ujung berkembang ).

Untuk juga menolak Ldan P, Anda dapat mengubah pertanyaan dan bertanya

Untuk semua leluhur komit yang terdorong (tidak termasuk tip perkembangan saat ini dan leluhurnya):

• apakah ada komitmen dengan dua orang tua?
• jika tidak, apakah setidaknya satu komit tersebut memiliki tip mengembangkan (hanya) induknya?

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

Sebuah rephrasal

Cara lain untuk mengutarakan pertanyaannya adalah "Apa komit terdekat yang berada di cabang selain cabang saat ini, dan cabang mana yang itu?"

Sebuah solusi

Anda dapat menemukannya dengan sedikit sihir baris perintah

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

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

Begini cara kerjanya:

1. Menampilkan riwayat tekstual semua komit, termasuk cabang jarak jauh.
2. Leluhur dari komit saat ini ditunjukkan oleh bintang. Saring semua yang lainnya.
3. Abaikan semua komitmen di cabang saat ini.
4. Hasil pertama adalah cabang leluhur terdekat. Abaikan hasil lainnya.
5. Nama cabang ditampilkan [dalam kurung]. Abaikan segala sesuatu di luar tanda kurung, dan tanda kurung.
6. Terkadang nama cabang akan menyertakan ~ # atau ^ # untuk menunjukkan berapa banyak komit antara komit yang direferensikan dan tip cabang. Kami tidak peduli. Abaikan mereka.

Dan Hasilnya

Menjalankan kode di atas

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

Akan memberi Anda developjika Anda menjalankannya dari H dan masterjika Anda menjalankannya dari I.

Kode tersedia sebagai intisari

Anda juga dapat mencoba:

git log --graph --decorate

orangtua git

Anda bisa menjalankan perintah

git parent

untuk menemukan induk cabang, jika Anda menambahkan jawaban @ Jo Chrysler sebagai alias git . Ini akan menyederhanakan penggunaan.

Buka file gitconfig yang terletak di "~/.gitconfig"menggunakan editor teks apa pun. (Untuk linux). Dan untuk Windows jalur ".gitconfig" umumnya terletak dic:\users\your-user\.gitconfig

vim  ~/.gitconfig

Tambahkan perintah alias berikut dalam file:

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

Simpan dan keluar dari editor.

Jalankan perintah git parent

Itu dia!

Saya punya solusi untuk masalah Anda secara keseluruhan (tentukan jika featurediturunkan dari ujung develop), tetapi tidak berfungsi menggunakan metode yang Anda uraikan.

Anda dapat menggunakan git branch --containsdaftar semua cabang turun dari ujung develop, kemudian gunakan grepuntuk memastikan featureada di antara mereka.

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

Jika ada di antara mereka, itu akan dicetak " feature" ke output standar dan memiliki kode pengembalian 0. Jika tidak, tidak akan mencetak apa pun dan memiliki kode pengembalian 1.

Ini bekerja dengan baik untuk saya.

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

Jawaban sopan dari: @droidbot dan @Jistanidiot

Karena tidak ada jawaban di atas yang berfungsi pada repositori kami, saya ingin berbagi dengan cara saya sendiri, menggunakan gabungan terbaru di git log:

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

Masukkan ke dalam skrip bernama git-last-merges, yang juga menerima nama cabang sebagai argumen (bukan cabang saat ini) serta yang laingit log argumen

Dari output, kita dapat secara manual mendeteksi cabang induk berdasarkan esensi cabang sendiri dan jumlah penggabungan dari masing-masing cabang.

EDIT: Jika Anda sering menggunakan git rebasecabang anak (dan penggabungan sering diteruskan sehingga tidak ada terlalu banyak gabungan yang dilakukan), jawaban ini tidak akan berfungsi dengan baik, jadi saya menulis skrip untuk menghitung komit di depan (normal dan gabungan) , dan di belakang komit (seharusnya tidak ada penggabungan di belakang di cabang induk) pada semua cabang dibandingkan dengan cabang saat ini. Jalankan saja skrip ini dan beri tahu saya apakah ini cocok untuk Anda atau tidak

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

Sebuah solusi

Solusi berdasarkangit show-branch tidak cukup bekerja untuk saya (lihat di bawah), jadi saya telah menggabungkannya dengan yang didasarkan padagit log dan berakhir dengan ini:

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

Keterbatasan dan Peringatan

• KEPALA dapat dilepas (banyak alat CI melakukannya untuk memastikan mereka membangun komit yang benar di cabang tertentu), tetapi cabang asal dan cabang lokal harus sama atau "di atas" KEPALA saat ini.
• Tidak boleh ada tag di jalan (saya kira; saya belum menguji skrip saat melakukan dengan tag antara cabang child dan parent)
• skrip mengandalkan fakta "KEPALA" selalu terdaftar sebagai dekorasi pertama oleh logperintah
• menjalankan script pada masterdandevelop hasil (kebanyakan) di<SHA> Initial commit

Hasil

 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

Meskipun keberadaan cabang lokal (mis. Hanya origin/topicada sejak komit Odiperiksa langsung oleh SHA-nya), skrip harus dicetak sebagai berikut:

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

* - atau masterjika developkomitmen berada di atas KEPALA master (~ master akan maju cepat untuk berkembang)

Mengapa tidak menunjukkan cabang bekerja untuk saya

Solusi berdasarkangit show-branch terbukti tidak dapat diandalkan untuk saya dalam situasi berikut:

• HEAD terlepas - termasuk kasing kepala terpisah berarti mengganti grep '\*' \untuk `grep '! \ - dan itu hanyalah awal dari semua masalah
• menjalankan script pada masterdandevelop hasil dalam developdan `` masing-masing
• cabang padamaster cabang ( hotfix/cabang) berakhir dengan developsebagai induk karena masterinduk cabang terdekat mereka ditandai dengan !alih - alih *karena suatu alasan.

Ingat bahwa, seperti yang dijelaskan dalam "Git: Menemukan darimana asal sebuah komit berasal" , Anda tidak dapat dengan mudah menentukan cabang tempat komit tersebut dibuat (cabang dapat diubah namanya, dipindahkan, dihapus ...), meskipun itu git branch --contains <commit>adalah permulaan.

• Anda dapat kembali dari komit ke komit hingga git branch --contains <commit>tidak mencantumkan featurecabang dan daftar developcabang,
• bandingkan komit SHA1 ke /refs/heads/develop

Jika kedua melakukan id cocok, Anda baik untuk pergi (itu berarti featurecabang memiliki asal di KEPALA develop).

Sihir baris perintah JoeChrysler dapat disederhanakan. Inilah logika Joe - untuk singkatnya saya telah memperkenalkan parameter bernama cur_branchpengganti substitusi perintah `git rev-parse --abbrev-ref HEAD`ke dalam kedua versi; yang dapat diinisialisasi seperti:

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

Lalu, inilah pipa 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

Kita dapat mencapai hal yang sama seperti kelima perintah individu itu menyaring dalam perintah yang relatif sederhana awk:

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

Itu rusak seperti ini:

-F'[]^~[]' 

membagi garis menjadi bidang di ], ^, ~, dan [karakter.

/\*/                      

Temukan garis yang mengandung tanda bintang

&& !/'"$cur_branch"'/

... tetapi bukan nama cabang saat ini

{ print $2;               

Ketika Anda menemukan garis seperti itu, cetak bidang keduanya (yaitu, bagian antara kemunculan pertama dan kedua dari karakter pemisah bidang kami). Untuk nama-nama cabang yang sederhana, itu adalah apa yang ada di antara kurung; untuk referensi dengan lompatan relatif, itu hanya nama tanpa pengubah. Jadi, set pemisah bidang kami menangani maksud kedua sedperintah.

  exit }

Kemudian segera keluar. Ini berarti hanya memproses baris pencocokan pertama, jadi kami tidak perlu menyalurkan output head -n 1.

Berikut ini adalah implementasi PowerShell dari solusi Mark Reed:

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

Saya tidak mengatakan ini adalah cara yang baik untuk menyelesaikan masalah ini, namun ini sepertinya bekerja untuk saya.

git branch --contains $(cat .git/ORIG_HEAD) Masalahnya adalah bahwa menjalankan file sedang mengintip ke dalam git, jadi ini belum tentu kompatibel ke depan (atau kompatibel ke belakang).

Implementasi lintas platform dengan 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: Anda harus menambahkan bahwa garis komit seharusnya tidak hanya mengandung tanda bintang, tetapi mulai dengan tanda bintang! Kalau tidak, komit pesan yang mengandung tanda bintang juga termasuk dalam baris yang cocok. Jadi seharusnya:

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

atau versi panjang:

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

Mencapai tujuan yang sama dengan jawaban Mark Reed, tetapi menggunakan pendekatan yang jauh lebih aman yang tidak nakal dalam sejumlah skenario:

1. Komit terakhir cabang induk adalah penggabungan, membuat kolom ditampilkan - tidak*
2. Pesan komit berisi nama cabang
3. Pesan komit berisi *

Siapa pun yang ingin melakukan ini akhir-akhir ini - aplikasi SourceTree dari Atlassian menunjukkan kepada Anda representasi visual yang hebat tentang bagaimana cabang Anda berhubungan satu sama lain, yaitu Di mana mereka memulai dan di mana mereka saat ini duduk dalam urutan komit (mis. HEAD atau 4 komit di belakang, dll.) .

Jika Anda menggunakan Source Tree lihat detail komit Anda> Parents> maka Anda akan melihat angka komit digarisbawahi (tautan)

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

Dapatkan komit terakhir yang merupakan cabang saya dan master(atau cabang apa pun yang ingin Anda tentukan)

Ini tidak bekerja untuk saya ketika saya telah melakukan sesuatu seperti develop > release-v1.0.0 > feature-foo, itu akan berjalan jauh ke belakang untuk berkembang, perhatikan ada rebase yang terlibat, tidak yakin apakah itu memperparah masalah saya ...

Berikut ini memang memberikan hash komit yang benar untuk saya

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