Git'te bir proje oluşturmak kolaydır ve bu nedenle küçük komut dosyası için bile ayrı depom olabilir. Şimdi sorun onları nasıl yöneteceğimizdir.

Bu depolarla birden çok yerde çalışıyorum. Bazı depoda değişiklikler yaptığımda, depoları başka yerlerde güncelleyebilmek istiyorum.

Bu yüzden içinde birçok depoya sahip bir dizinim var.

1. Hepsini nasıl getirebilirim?
2. Herhangi birinin taahhüt edilmemiş değişiklikleri olup olmadığını nasıl kontrol edebilirim?
3. Bunlardan herhangi birinde birleştirilecek değişiklik olup olmadığını nasıl kontrol edebilirim?

Ve bunları tek bir komutla yapabilmek güzel olurdu.

Çıktı, yapılacak şeyleri gerçekten fark edecek kadar sessiz olmalıdır.

Çoklu depo aracını şiddetle tavsiye ederim mr . Bir süredir başkaları tarafından önerildiği gibi özel bir kabuk komut dosyası kullanıyordum, ancak mr kullanmanın benim için şu faydaları var:

• Genel: Sadece git (örneğin Mercurial, SVN, vb.) Değil, çeşitli sürüm kontrol sistemlerinin bir birleşimi de kullanılabilir.
• Hızlıdır: mr, birden fazla işi paralel olarak yürütebilir. Bir dizi git / mercurial deposu kullanıyorum ve bunları günde birkaç kez senkronize ediyorum. Bay bu süreci muazzam bir şekilde hızlandırıyor.
• Depo kontrolleri listesini yönetmek kolay ve hızlıdır. Özel betiğinizdeki proje listesini değiştirmek yerine 'mr register' kullanın.

Sessiz çıktı hakkındaki sorunuzla ilgili olarak: Ayrıntı düzeyi, -q komut satırı anahtarı kullanılarak değiştirilebilir. Çıktıyı kısa ve net bir özet halinde güzel bir şekilde birleştiren varsayılan çıktıyı tercih ederim.

Mr komutunun her zaman $ HOME'da depolanan varsayılan proje listemi almasını ve 5 paralel iş parçacığı kullanmasını sağlamak için aşağıdaki takma adı kullanıyorum:

alias mr='mr -d ~/ -j 5 '

Şu anda kabul edilen cevapla başladığımı söylemeliyim (sadece depolar üzerinde yinelenen bir grup yardımcı komut dosyası), ama sonuçta benim için eksik bir deneyim oldu.

Yani, mr, repo ve git-alt modüllerini denedikten sonra, her birinin eksikliğini farklı buldum, bu yüzden kendi varyantımı yaptım: http://fabioz.github.io/mu-repo olgun aracı olan bu nokta - şunları yapmanızı sağlayan iş akışlarına sahiptir:

• birden çok depoyu klonla
• Birden çok depoda fark (ve düzenleme) mevcut değişiklikleri
• gelen değişiklikleri önizleyin
• komutları birden çok depoda paralel olarak çalıştır
• depo grupları oluştur
• Git ile ilgili olmayan komutları birden çok depo üzerinde çalıştır
• vb ( daha fazla bilgi için ana sayfaya bakın ).

Python'un çalıştığı tüm işletim sistemlerini desteklediğini unutmayın;)

gr (git-run), mr'ın işlevselliğini artırır (yalnızca içingit). Etiket sistemini kullanarak birden çok git deposunu düzenlemeyi daha kolay buluyorum. İçin kodgriyi korunmamış. Bash kullanıyorsanız-t tag,#tagformyerineile kullandığınızdan emin olun.

Sen kullanarak deneyebilirsiniz repo özel ile manifest.xmlsizin depoları nerede belirtmek için dosyanın. Bunun nasıl yapılacağına dair bazı belgeler var.

Alternatif olarak kullanabilirsiniz git-submodule(1) .

" RepoZ " adlı bir araç yazdım " bu da git depolarını klonladığınız veya bir şubeyi değiştirmek gibi herhangi bir şeyi değiştirdiğiniz anda otomatik olarak keşfediyor.

Depolar bulunduktan sonra "izlenir". Bu, onları posh-git'ten esinlenen yoğun bir durum bilgisi içeren yerel depoların bir listesinde gösterecektir . Bu, geçerli dalı ve dosya düzenlemeleri ve gelen veya giden taahhütlerin sayısı gibi diğer şeyleri içerir.

Bu, yerel depolarınızı ve taahhüt etmek veya zorlamak için bitmemiş işlerinizi takip etmenize yardımcı olur. Ek olarak, arşiv listesini bir depodan diğerine geçmek için gezinme olarak kullanabilirsiniz.

"Hepsini nasıl getirebilirim?"

Windows sürümü, bir depoyu almak veya çekmek için bir bağlam menüsü sunar. Çoklu seçim ile eylemleri aynı anda birden fazla havuzda çalıştırabilirsiniz.

Ancak, başka bir özelliği çok yararlı bulabilirsin:

Otomatik getirme ile RepoZ'a git depolarınızın tümünün uzaktan kumandalarını arka planda periyodik olarak getirmesini söyleyebilirsiniz. Bu getirmeler elbette yerel taahhütlerinizle çakışmaz. İle olduğu gibi yerel birleştirme girişimi yoktur git pull.

Gitslave , süper ve arasında bir süper proje / alt proje ilişkisi oluşturarak birçok depo üzerinde aynı komutu çalıştırabilen bir araçtır. Bu (varsayılan olarak) çıktı özetleme sağlar, böylece benzersiz çıktı sağlayan depolara konsantre olabilirsiniz (git durumu için kullanışlıdır, git ls dosyaları için pek kullanışlı değildir).

Bu, genellikle birkaç depoyu bir araya getirmeniz ve aynı anda veya her neyse aynı dalda veya etikette tutmanız gereken projeler için kullanılır. (Çıplak) depolarım için sadece küçük bir makefile var, bu da keyfi git komutlarını çalıştırmama izin veriyor, gördüğünüz gibi öncelikle fsck ve gc için kullanıyorum:

full: fsck-full gc-aggressive
        @:

fsck-full:
        for f in */.; do (cd $$f; echo $$f; git fsck --full || echo $$f FAILED); done

gc-aggressive:
        for f in */.; do (cd $$f; echo $$f; git gc --aggressive || echo $$f FAILED); done

%:
        for f in */.; do (cd $$f; git $@ || echo $$f FAILED); done

Bir dizinde bulunan tüm depolarda (özyinelemeli) herhangi bir git komutunu çalıştırmak için bir takma ad ve işlev yaptım. Burada bulabilirsiniz: https://github.com/jaguililla/dotfiles/git

Kod bu:

#!/bin/sh
# To use it: source git_aliases

# Example: rgita remote \;
alias rgita='find . -type d -name .git -execdir git'

# Example: rgit remote -vv
rgit() {
  rgita "$@" \;
}

Umarım yardımcı olur :)

git-status-allCevheri bunun için kullanabilirsiniz : https://github.com/reednj/git-status-all

# install the gem    
gem install git-status-all

# use the status-all subcommand to scan the directory
git status-all

Ayrıca, durumu görüntülemeden önce tüm depolar için başlangıç ​​noktasından getirecek bir getirme seçeneği de vardır:

git status-all --fetch

Bu betiği, tüm depolarımda git komutlarını kolayca yürütmek için kullanıyorum.

#!/bin/sh
if [ ! "$1" = "" ] ; then

   if [ "$GITREPO" = "" -a -d "$HOME/cm/src" ] ; then
      GITREPO="$HOME/cm/src"
   fi

   if [ "$GITREPO" != "" ] ; then

      echo "Git repositories found in $GITREPO"
      echo "-=-=-=-=-=-=-=-=-=-=-=-=-=-"

      DIRS="`/bin/ls -1 $GITREPO`"

      for dir in $DIRS ; do

         if [ -d $GITREPO/$dir/.git ] ; then
            echo "$dir -> git $1"
            cd $GITREPO/$dir ; git $@
            echo
         fi

      done
   else

      echo "Git repositories not found."

   fi
fi

Varsayılan olarak betik ~ / cm / src içinde git depolarını arar, ancak GITREPO ortam değişkenini istediğiniz gibi ayarlayarak bunu geçersiz kılabilirsiniz.

Bu komut dosyası bu komut dosyasına dayanmaktadır .

Birden çok depoyu yönetmek için gita adında bir komut satırı aracı yazdım . Kayıtlı depoların durumunu yan yana gösterir, örneğin

Ayrıca herhangi bir çalışma dizininden git komutlarını / takma adlarını delege edebilir.

Şimdi bu aracı kullanarak sorularınızı yanıtlamak için:

Hepsini nasıl getirebilirim?

gita fetch

Herhangi birinin taahhüt edilmemiş değişiklikleri olup olmadığını nasıl kontrol edebilirim?

gita lsKomut gösterileri 3 olası semboller gösterir şube adı, yanındaki

• +: aşamalı değişiklikler
• *: aşamalı olmayan değişiklikler
• _: izlenmeyen dosyalar / klasörler

Bunlardan herhangi birinde birleştirilecek değişiklik olup olmadığını nasıl kontrol edebilirim?

Şube isimleri 5 şekilde renklendirilmiştir

• beyaz: yerel şubenin uzak şubesi yok
• yeşil: yerel şube uzak şube ile aynı
• kırmızı: yerel şube uzak şubeden ayrıldı
• mor: yerel şube uzak şubenin önünde (itme için iyi)
• sarı: yerel şube uzak şubenin arkasında (birleştirme için iyi)

Kurmak için basitçe çalıştırın

pip3 install -U gita

Hala bu konuya bakan biri varsa, lütfen gitme adlı kabuk betiğime bakın

yerel git depolarınızı manuel olarak girmeniz gerekecek, ancak bu aracı birden çok bilgisayarda birden fazla git projesinde işbirliği yapmak için her gün kullanıyorum.

koşabilirsin git clone https://github.com/robbenz/gitme.git

ayrıca komut dosyası aşağıda yayınlanmıştır

#!/bin/bash -e

REPOS=( 
/Users/you/gitrepo1
/Users/you/gitrepo2
/Users/you/gitrepo3
/Users/you/gitrepo4
)

MOVE="Moving to next REPO... \n" 

tput setaf 2;echo "What ya wanna do? You can say push, pull, commit, ftp push, or status"; tput sgr0

read input

if [ $input =  "commit" ]
then
    tput setaf 2;echo "Do you want a unique commit message? [y/n]";tput sgr0
    read ans
    if [ $ans = "y" ]
    then 
        for i in "${REPOS[@]}"
        do
            cd "$i"
            tput setaf 6;pwd;tput sgr0 
            git add . -A
            read -p "Commit description: " desc  
            git commit -m "$desc"
            tput setaf 2;echo  $MOVE;tput sgr0 
            sleep 1
        done 
    else 
        for i in "${REPOS[@]}"
        do
            cd "$i"
            tput setaf 6;pwd;tput sgr0 
            git add . -A
            git commit -m "autocommit backup point"
            tput setaf 2;echo  $MOVE;tput sgr0 
            sleep 1
        done
    fi 
elif [ $input = "push" ] || [ $input = "pull" ] || [ $input = "ftp push" ] || [ $input = "status" ]
    then
        for i in "${REPOS[@]}"
do
    cd "$i"
    tput setaf 6;pwd;tput sgr0 
    git $input 
    tput setaf 2;echo  $MOVE;tput sgr0 
    sleep 1
    done 
else tput setaf 1;echo "You have zero friends";tput sgr0 
fi

~ / .Bash_profile dosyamda bir takma ad kurdum alias gitme='sh /path/to/gitme.sh'

Bir dizin ağacındaki tüm depolarda git komutlarını özyinelemeli olarak çalıştıran CPAN üzerinde rgit'i kontrol etmelisiniz .

Dokümanlardan:

Bu yardımcı program, tüm git depoları için bir kök dizini (geçerli çalışma dizini veya - ayarlanmışsa - GIT_DIR ortam değişkeni tarafından verilen dizin olabilir) özyinelemeli olarak arar, bu listeyi depo yoluna göre sıralayın, chdir her birine onları ve belirtilen git komutunu çalıştırır.

Az önce istediğinizi yapan bir araç yarattım!

1. Hepsini nasıl getirebilirim? gmaster fetch
2. Herhangi birinin taahhüt edilmemiş değişiklikleri olup olmadığını nasıl kontrol edebilirim? gmaster status
3. Bunlardan herhangi birinde birleştirilecek değişiklik olup olmadığını nasıl kontrol edebilirim? gmaster status

Gitmaster denir: https://github.com/francoiscabrol/gitmaster

Bu basit bash işlevini .bash_profile dosyama, git, maven, gradle veya diğer bash komutlarını yalnızca tüm git depolarında çalıştırabilmek için yazdım:

# usefull function to work with multiple git repositories
all() {
    failed=0
    printf '>>> START RUNNING: "%s" >>>' "$*"
    for d in */; do
        pushd "$d" > /dev/null
        if [ -d ".git" ]
        then
            printf '\n--------------------------------------------\n\n'
            pwd
            eval $@
            if [ $? -ne 0 ]
            then
                failed=1
                break;
            fi
        fi
        popd > /dev/null
    done
    if [ $failed -eq 0 ]
    then
        printf '\n--------------------------------------------\n'
        printf '<<< RAN "%s" WITH SUCCESS!!! <<<' "$*"
    else
        printf '\n<<< FAILED!!! <<<'
    fi
}

Bu bu şekilde kullanılabilir

all git st
all git pull
all ./gradlew clean test
etc.

Sorumluluk reddi: Bu araç üzerinde www.repoflow.com adresinde çalışıyorum

Hepsini nasıl getirebilirim?
Bunlardan herhangi birinde birleştirilecek değişiklik olup olmadığını nasıl kontrol edebilirim?

• İlgili tüm depoları getirebilir (veya bunları itebilir / çekebilir / işleyebilirsiniz), getirme işleminden sonra kullanıcı arayüzü yeni depo durumu ile güncellenir, depo ayrılırsa çakışmaların türlerini görebilir ve bunları birleştirmeye başlayabilirsiniz.

Herhangi birinin taahhüt edilmemiş değişiklikleri olup olmadığını nasıl kontrol edebilirim?

• Kullanıcı arayüzünde, her havuz için dosyaların durumunu görebilirsiniz (Bunları tek tek veya toplu olarak ekleyebilir / kaldırabilirsiniz).

Bunun üzerinde çalışıyorum, ancak bu aynı zamanda OP sorularını çözüyor ve genel olarak birden fazla depoyu yönetmeye yardımcı oluyor, kendi komut dosyalarınızı oluşturmak için kullanıcı arayüzünü veya temeldeki GraphQL API'yi kullanabilirsiniz, lütfen bunu başka bir seçenek olarak düşünün.

Birden fazla depoyu almak için kullanışlı bir araç var. git-pull-alleşzamansız olarak birden çok git deposunda çalıştırılan bir komut satırı aracıdır.

Kurulum

npm install -g git-pull-all

Kullanım

Şu dosya ve dizinlere sahip olduğunuzu varsayın:

~/Projects/
  cool-examples/
    .git/
  funny-movies/
  my-todos.txt
  super-express/
    .git/

git-pull-allKomutu ~/Projectsdizinde çalıştırdığınızda , çocuk git depolarını bulmalı (yukarıdaki durumda harika örnekler ve süper ifade ) ve ardından git pullbunların her birinde çalıştırılmalıdır .

$ cd ~/Projects
$ git-pull-all
funny-movies/
Not a git repository
cool-examples/
Already up-to-date.
super-express/
Already up-to-date.
Done!

git-pull-all ~/Projects

GitHub bağlantısı: https://github.com/tatsuyaoiw/git-pull-all

Visual Studio kodunu kullanıyorum. Kod tabanımızda hepsi ayrı Git depoları olan yaklaşık 20 kitaplığımız var ve Visual Studio Code'daki kaynak kontrol sekmesi, yerel depoların ne kadar geride veya ileride olduğunun "bir bakışta" görünümünü görmek için oldukça iyi. Ayrıca, bu bilgileri güncel tutmak için periyodik olarak getirme ayarları ve bir yenileme düğmesi vardır.

Bir komut dosyası kadar kullanışlı değil, ancak kaynak kontrolü söz konusu olduğunda benim için değişiklik yapan kişi olmayı seviyorum. Değişikliklerin, vb. Üzerine yazılmaması için çok iyi yazılmış bir komut dosyası gerekir. VS Code yaklaşımı ile, kendinize göre hareket edebileceğiniz iyi miktarda bilgiyi hızlı bir şekilde alırsınız.

İşte neye benzediğinin bir ekran görüntüsü:

Her deponun teslim alınmış farklı bir dalı olsa bile, bir .git klasörü olan tüm alt dizinlerden mevcut şubeden çekmek için harika bir çözüm buldum. Komut tek satırlıktır, farklı git komutlarını değiştirmeye yetecek kadar esnektir ve takma ad verilebilir.

Aşağıdakileri kopyalayıp yapıştırmanız yeterlidir:

find . -type d -maxdepth 2 -name .git -exec sh -c 'cd $0 && cd .. && git pull origin $(git rev-parse --abbrev-ref HEAD)' {} \;

Parçalamak:

find . -type d -maxdepth 2 -name .git 

Geçerli dizinde (bul.) ".Git" (-name .git) adını taşıyan tüm dizinleri (-tipi) bulun, en fazla iki dizin derinliğine (1 yerine 2, çünkü aradığımız git repo klasöründeki git klasörü).

-exec sh -c 

Aşağıdaki kabuk komutunu çalıştırın (exec sh -c)

'cd $0 && cd .. && git pull origin $(git rev-parse --abbrev-ref HEAD)'

Dizini ilk bağımsız değişkenle değiştirin (cd $ 0), ardından .git klasöründen (cd ..) ayrılmak için dizini bir düzey değiştirin, ardından git rev-parse ... çalıştırarak geçerli dalın HEAD commit.

{} \;

"{}", İlk bul komutundan aldığımız sonuç göreceli yoldur . ; komutu bitirmek için kullanılır.

Zsh üzerinde MacOS 10.14.6'da test edilmiştir. Olduğu gibi, yalnızca uzak ve yerel şubeler AFAIK olarak adlandırıldığında çalışır.

Durum almak için bunu değiştirebilirsiniz. Bunu daha esnek hale getirmek için argümanlar ekleyebileceğinizi umuyorum, ancak henüz denemedim.

Toplu iş / kabuk komut dosyası oluşturmak ve tek seferde çalıştırmak için kod düzenleyicimin (VS kodu) çoklu imleç seçme / çok satırlı düzenleme özelliğini kullanıyorum. Bu basit aptal çözümle ne yaptığımı ve bu komutların uygulanmasından ne bekleyebileceğimi biliyorum. Tahmin yok, öğrenmek yok, özelleştirmeye gerek yok. Diğer bir neden de, her seferinde ortak bir ana dizinde bulunan farklı depo kümelerinde komut çalıştırmak istediğimde.

https://github.com/wwjamieson3/envisionTools , bunu ve daha fazlasını yapan gitstat adında bir bash betiğine sahiptir. GNU ve mac uyumludur. İstenirse uzaktan kumandalardan getirme yapabilir. İzlenmemiş, değiştirilmiş, eklenen, silinmiş ve hazırlanmış dosyaları gösterir. Uzaktan kumandalarda birleştirilmemiş kayıtları ve çalıştırılmamış yerel taahhütleri göstererek uzaktan kumandalarla farklılık gösterir. Ayrıca renk kodlu sonuçları özet veya ayrıntılı modda ve hatta HTML'de görüntüleyebilir. Sonsuz derecede daha hızlı olduğundan ve çok eskiyse konum bulma veritabanınızı güncellemenizi isteyeceği için find yerine locate kullanır.

Görünüşe göre bir senaryo yazmak oldukça kolay. Esasen depolarda yineleme yapması ve ardından git ls-files, git diff ve git log gibi komutları kullanması gerekir.