Mevcut Git deposunu bir başkasına nasıl aktarabilirim?

XXX adlı bir klasörde Git depom var ve YYY adlı ikinci Git depom var .

Ben almak istediğiniz XXX içine depo YYY bir alt dizin adında olarak depo ZZZ ve tüm eklemek XXX için 'ın değişiklik geçmişini YYY .

Önce klasör yapısı:

├── XXX
│   ├── .git
│   └── (project files)
└── YYY
    ├── .git
    └── (project files)

Sonra klasör yapısı:

YYY
├── .git  <-- This now contains the change history from XXX
├──  ZZZ  <-- This was originally XXX
│    └── (project files)
└──  (project files)

Bu yapılabilir mi, yoksa alt modülleri kullanmaya mı başvurmalıyım?

Muhtemelen en basit yol, XXX şeyleri YYY'de bir şubeye çekmek ve daha sonra master ile birleştirmek olacaktır:

In YYY :

git remote add other /path/to/XXX
git fetch other
git checkout -b ZZZ other/master
mkdir ZZZ
git mv stuff ZZZ/stuff                      # repeat as necessary for each file/dir
git commit -m "Moved stuff to ZZZ"
git checkout master                
git merge ZZZ --allow-unrelated-histories   # should add ZZZ/ to master
git commit
git remote rm other
git branch -d ZZZ                           # to get rid of the extra branch before pushing
git push                                    # if you have a remote, that is

Aslında bunu sadece birkaç depo ile denedim ve işe yarıyor. Jörg'in cevabından farklı olarak , diğer repoyu kullanmaya devam etmenize izin vermiyor, ama yine de belirttiğinizi sanmıyorum.

Not: Bu ilk olarak 2009'da yazıldığından, git aşağıdaki cevapta belirtilen alt ağaç birleştirmesini ekledi. Muhtemelen bugün bu yöntemi kullanacağım, ancak elbette bu yöntem hala çalışıyor.

İkinci deponun kesin taahhüt geçmişini korumak ve bu nedenle gelecekte yukarı akış değişikliklerini kolayca birleştirme yeteneğini korumak istiyorsanız, işte istediğiniz yöntem budur. Alt ağacın değiştirilmemiş geçmişinin deponuza aktarılmasıyla ve birleştirilmiş deponun alt dizine taşınması için bir birleştirme taahhüdü ile sonuçlanır.

git remote add XXX_remote <path-or-url-to-XXX-repo>
git fetch XXX_remote
git merge -s ours --no-commit --allow-unrelated-histories XXX_remote/master
git read-tree --prefix=ZZZ/ -u XXX_remote/master
git commit -m "Imported XXX as a subtree."

Yukarı akış değişikliklerini aşağıdaki gibi izleyebilirsiniz:

git pull -s subtree XXX_remote master

Git, birleştirmeden önce köklerin nerede olduğunu kendi başına bulur, bu nedenle sonraki birleşmelerde öneki belirtmenize gerek yoktur.

olumsuz birleştirilmiş tarihinin dosyaları (bir alt dizininde) öneksiz olmasıdır. Sonuç olarak git log ZZZ/a, birleştirilmiş geçmişte olanlar dışındaki tüm değişiklikleri (varsa) gösterir. Yapabilirsin:

git log --follow -- a

ancak bu, birleştirilmiş geçmişten sonraki değişiklikleri göstermez.

Başka bir deyişle, ZZZdepodaki dosyalarını değiştirmezsenizXXX , belirtilmemiş --followve önceden düzeltilmemiş bir yol belirtmeniz gerekir . Her iki havuzda da değiştirirseniz, hiçbiri tüm değişiklikleri göstermeyen 2 komutunuz olur.

2.9'dan önceki Git sürümleri :--allow-unrelated-histories Seçeneğigit merge .

Diğer cevapta kullanılan yöntem read-treemerge -s oursAdımı ve atlayan cp ile dosyaları kopyalamaktan ve sonucu işlemekten farklı değildir.

Orijinal kaynak github'un "Subtree Merge" yardım makalesinden alınmıştır . Ve bir başka faydalı bağlantı .

git-subtreetam olarak bu kullanım durumu için, geçmişi korurken birden çok havuzu bir araya getirme (ve / veya alt ağaçların geçmişini bölme, ancak bu soru ile ilgisi yok gibi görünüyor) için tasarlanmış bir komut dosyasıdır. 1.7.11 sürümünden beri git ağacının bir parçası olarak dağıtılmaktadır .

<repo>Revizyondaki bir havuzu <rev>alt dizin olarak birleştirmek için aşağıdaki gibi <prefix>kullanın git subtree add:

git subtree add -P <prefix> <repo> <rev>

git-subtree alt ağaç birleştirme stratejisini uygular daha kullanıcı dostu bir şekilde .

Sizin durumunuz için, YYY deposu içinde şunu çalıştırırsınız:

git subtree add -P ZZZ /path/to/XXX.git master

Olumsuz birleştirilmiş tarihinin dosyaları (bir alt dizininde) öneksiz olmasıdır. Sonuç olarak git log ZZZ/a, birleştirilmiş geçmişte olanlar dışındaki tüm değişiklikleri (varsa) gösterir. Yapabilirsin:

git log --follow -- a

ancak bu, birleştirilmiş geçmişten sonraki değişiklikleri göstermez.

Başka bir deyişle, ZZZdepodaki dosyalarını değiştirmezsenizXXX , belirtilmemiş --followve önceden düzeltilmemiş bir yol belirtmeniz gerekir . Her iki havuzda da değiştirirseniz, hiçbiri tüm değişiklikleri göstermeyen 2 komutunuz olur.

Burada daha fazlası .

Git havuzunda, Git topluluğunda topluca " şimdiye kadarki en havalı birleştirme " olarak bilinen iyi bilinen bir örneği var (bunu açıklayan Git posta listesine e-postada kullanılan konu satırı Linus Torvalds'ın ardından birleştirmek). Bu durumda, gitkartık Git'in uygun bir parçası olan Git GUI aslında ayrı bir projeydi. Linus bu havuzu Git havuzuna birleştirmeyi başardı.

• Git deposunda her zaman Git'in bir parçası olarak geliştirilmiş gibi görünür,
• tüm tarih korunur ve
• hala eski deposunda bağımsız olarak geliştirilebilir, değişiklikler basitçe git pulldüzenlenir.

E-posta yeniden üretmek için gerekli adımları içeriyor, ancak kalbin zayıflığı için değil: ilk olarak Linus Git'i yazdı , bu yüzden muhtemelen sizden veya benden biraz daha fazla şey biliyor ve ikincisi, bu neredeyse 5 yıl önceydi ve Git o zamandan beri önemli ölçüde iyileşti , bu yüzden şimdi çok daha kolay.

Özellikle, sanırım bugünlerde bu özel durumda, gitk alt modülünü kullanacağım.

Bunu yapmanın basit yolu git format-patch kullanmaktır.

2 git deposu foo ve barımız olduğunu varsayın .

foo şunları içerir:

• fan.txt
• .git

çubuk içeriği:

• bar.txt
• .git

ve bar geçmişini ve şu dosyaları içeren foo ile bitirmek istiyoruz :

• fan.txt
• .git
• filanca / bar.txt

Bunu yapmak için:

 1. create a temporary directory eg PATH_YOU_WANT/patch-bar
 2. go in bar directory
 3. git format-patch --root HEAD --no-stat -o PATH_YOU_WANT/patch-bar --src-prefix=a/foobar/ --dst-prefix=b/foobar/
 4. go in foo directory
 5. git am PATH_YOU_WANT/patch-bar/*

Ve çubuktan tüm mesaj taahhütlerini yeniden yazmak istiyorsak, örneğin Linux'ta yapabiliriz:

git filter-branch --msg-filter 'sed "1s/^/\[bar\] /"' COMMIT_SHA1_OF_THE_PARENT_OF_THE_FIRST_BAR_COMMIT..HEAD

Bu, her taahhüt mesajının başına "[bar]" ekleyecektir.

Bu işlev uzaktan repoyu yerel repo dizinine klonlayacak, birleştirildikten sonra tüm taahhütler kaydedilecek, git logorijinal taahhütleri ve uygun yolları gösterecektir:

function git-add-repo
{
    repo="$1"
    dir="$(echo "$2" | sed 's/\/$//')"
    path="$(pwd)"

    tmp="$(mktemp -d)"
    remote="$(echo "$tmp" | sed 's/\///g'| sed 's/\./_/g')"

    git clone "$repo" "$tmp"
    cd "$tmp"

    git filter-branch --index-filter '
        git ls-files -s |
        sed "s,\t,&'"$dir"'/," |
        GIT_INDEX_FILE="$GIT_INDEX_FILE.new" git update-index --index-info &&
        mv "$GIT_INDEX_FILE.new" "$GIT_INDEX_FILE"
    ' HEAD

    cd "$path"
    git remote add -f "$remote" "file://$tmp/.git"
    git pull "$remote/master"
    git merge --allow-unrelated-histories -m "Merge repo $repo into master" --edit "$remote/master"
    git remote remove "$remote"
    rm -rf "$tmp"
}

Nasıl kullanılır:

cd current/package
git-add-repo https://github.com/example/example dir/to/save

Küçük değişiklikler yaparsanız, birleştirilmiş repo dosyalarını / dizinlerini farklı yollara taşıyabilirsiniz, örneğin:

repo="https://github.com/example/example"
path="$(pwd)"

tmp="$(mktemp -d)"
remote="$(echo "$tmp" | sed 's/\///g' | sed 's/\./_/g')"

git clone "$repo" "$tmp"
cd "$tmp"

GIT_ADD_STORED=""

function git-mv-store
{
    from="$(echo "$1" | sed 's/\./\\./')"
    to="$(echo "$2" | sed 's/\./\\./')"

    GIT_ADD_STORED+='s,\t'"$from"',\t'"$to"',;'
}

# NOTICE! This paths used for example! Use yours instead!
git-mv-store 'public/index.php' 'public/admin.php'
git-mv-store 'public/data' 'public/x/_data'
git-mv-store 'public/.htaccess' '.htaccess'
git-mv-store 'core/config' 'config/config'
git-mv-store 'core/defines.php' 'defines/defines.php'
git-mv-store 'README.md' 'doc/README.md'
git-mv-store '.gitignore' 'unneeded/.gitignore'

git filter-branch --index-filter '
    git ls-files -s |
    sed "'"$GIT_ADD_STORED"'" |
    GIT_INDEX_FILE="$GIT_INDEX_FILE.new" git update-index --index-info &&
    mv "$GIT_INDEX_FILE.new" "$GIT_INDEX_FILE"
' HEAD

GIT_ADD_STORED=""

cd "$path"
git remote add -f "$remote" "file://$tmp/.git"
git pull "$remote/master"
git merge --allow-unrelated-histories -m "Merge repo $repo into master" --edit "$remote/master"
git remote remove "$remote"
rm -rf "$tmp"

Uyarılar
Yolların yerine geçer sed, bu nedenle birleştirildikten sonra doğru yollarda hareket ettiğinden emin olun. Parametre sadece Git> = 2.9 beri var.
--allow-unrelated-histories

Bu makaleye dayanarak benim için işe yarayan alt ağaç kullanmak sadece uygulanabilir tarih aktarıldı. Herkesin adımlara ihtiyacı olması durumunda buraya gönderme (yer tutucuları sizin için geçerli olan değerlerle değiştirdiğinizden emin olun):

kaynak havuzunuzdaki alt klasörü yeni bir şubeye ayırın

git subtree split --prefix=<source-path-to-merge> -b subtree-split-result

hedef deponuzda bölünmüş sonuç dalında birleştirme

git remote add merge-source-repo <path-to-your-source-repository>
git fetch merge-source-repo
git merge -s ours --no-commit merge-source-repo/subtree-split-result
git read-tree --prefix=<destination-path-to-merge-into> -u merge-source-repo/subtree-split-result

değişikliklerinizi doğrulayın ve taahhüt edin

git status
git commit

Unutma

subtree-split-resultŞubeyi silerek temizleyin

git branch -D subtree-split-result

Verileri kaynak deposundan almak için eklediğiniz uzaktan kumandayı kaldırın

git remote rm merge-source-repo

Sanırım başka bir cevap eklemek biraz daha basit. Repo_to_import içine repo_dest öğesi çekilir ve ardından bir push - set-upstream url: repo_dest master yapılır.

Bu yöntem benim için birkaç küçük depoyu daha büyük bir depoya aktarmamda işe yaradı.

Nasıl içe aktarılır: repo1_to_import to repo_dest

# checkout your repo1_to_import if you don't have it already 
git clone url:repo1_to_import repo1_to_import
cd repo1_to_import

# now. pull all of repo_dest
git pull url:repo_dest
ls 
git status # shows Your branch is ahead of 'origin/master' by xx commits.
# now push to repo_dest
git push --set-upstream url:repo_dest master

# repeat for other repositories you want to import

İçe aktarma işlemini gerçekleştirmeden önce dosyaları ve dizinleri orijinal depoda istediğiniz konuma yeniden adlandırın veya taşıyın. Örneğin

cd repo1_to_import
mkdir topDir
git add topDir
git mv this that and the other topDir/
git commit -m"move things into topDir in preparation for exporting into new repo"
# now do the pull and push to import

Aşağıdaki bağlantıda açıklanan yöntem bu cevaba ilham verdi. Daha basit göründüğü için beğendim. Ama dikkat et! Ejderhalar var! https://help.github.com/articles/importing-an-external-git-repository git push --mirror url:repo_dest yerel repo geçmişinizi ve durumunuzu uzaktan kumanda eder (url: repo_dest). AMA uzaktan kumandanın eski tarihini ve durumunu siler. Eğlenceli devam ediyor! : -E

Benim durumumda sadece diğer depodaki (XXX) bazı dosyaları içe aktarmak istedim. Alt ağaç benim için çok karmaşıktı ve diğer çözümler işe yaramadı. Ben de öyle yaptım:

ALL_COMMITS=$(git log --reverse --pretty=format:%H -- ZZZ | tr '\n' ' ')

Bu, içe aktarmak istediğim dosyaları (ZZZ) ters sırada sırayla etkileyen tüm taahhütlerin alanla ayrılmış bir listesini verir (yeniden adlandırmaları yakalamak için --follow eklemeniz gerekebilir). Daha sonra hedef depoya (YYY) girdim, diğer havuzu (XXX) uzaktan ekledim, ondan bir getirme yaptım ve son olarak:

git cherry-pick $ALL_COMMITS

bu da tüm taahhütleri şubenize ekler, böylece geçmişlerine sahip tüm dosyalara sahip olursunuz ve onlarla ne istersen onu her zaman bu depodaymış gibi yapabilirsin.

Bkz Temel örneğini de bu makalede ve depoları üzerinde böyle eşleme göz önünde bulundurun:

• A <-> YYY ,
• B <-> XXX

Bu bölümde açıklanan tüm etkinliklerden sonra (birleştirme işleminden sonra), dalı kaldırın B-master:

$ git branch -d B-master

Ardından, değişiklikleri itin.

Benim için çalışıyor.

Aradığım bir durumdaydım -s theirsama elbette bu strateji mevcut değil. Geçmişim GitHub'da bir proje çatallamış olduğumdu ve şimdi bir nedenden dolayı masteryerelim ile birleştirilemediupstream/master bu şubede yerel bir değişiklik . (Gerçekten orada ne olduğunu bilmiyorum - sanırım yukarı akış sahnelerin arkasında bazı pis itişler yapmış olabilir, belki?)

Sonunda yaptığım şey

# as per https://help.github.com/articles/syncing-a-fork/
git fetch upstream
git checkout master
git merge upstream/master
....
# Lots of conflicts, ended up just abandonging this approach
git reset --hard   # Ditch failed merge
git checkout upstream/master
# Now in detached state
git branch -d master # !
git checkout -b master   # create new master from upstream/master

Şimdi benim masterile tekrar senkronize upstream/master(ve benzer şekilde senkronize etmek istediğiniz herhangi bir şube için yukarıdaki tekrarlayabilirsiniz).

Sorununuz için başka bir çözüm önerebilirim ( git-submodules'e alternatif ) - gil (git links) aracı

Karmaşık git depo bağımlılıklarının tanımlanmasını ve yönetilmesini sağlar.

Ayrıca git özyinelemeli alt modüllere bağımlılık sorununa bir çözüm sağlar .

Aşağıdaki proje bağımlılıklarına sahip olduğunuzu düşünün: sample git repository bağımlılık grafiği

Daha sonra .gitlinks, depolarla ilişki açıklaması içeren bir dosya tanımlayabilirsiniz:

# Projects
CppBenchmark CppBenchmark https://github.com/chronoxor/CppBenchmark.git master
CppCommon CppCommon https://github.com/chronoxor/CppCommon.git master
CppLogging CppLogging https://github.com/chronoxor/CppLogging.git master

# Modules
Catch2 modules/Catch2 https://github.com/catchorg/Catch2.git master
cpp-optparse modules/cpp-optparse https://github.com/weisslj/cpp-optparse.git master
fmt modules/fmt https://github.com/fmtlib/fmt.git master
HdrHistogram modules/HdrHistogram https://github.com/HdrHistogram/HdrHistogram_c.git master
zlib modules/zlib https://github.com/madler/zlib.git master

# Scripts
build scripts/build https://github.com/chronoxor/CppBuildScripts.git master
cmake scripts/cmake https://github.com/chronoxor/CppCMakeScripts.git master

Her satır git bağlantısını aşağıdaki biçimde tanımlar:

1. Deponun benzersiz adı
2. Deponun göreli yolu (.gitlinks dosyasının yolundan başlar)
3. Git klon komutunda kullanılacak Git deposu Ödeme için depo dalı
4. Boş satır veya # ile başlayan satır ayrıştırılmaz (yorum olarak değerlendirilir).

Son olarak kök örnek deponuzu güncellemeniz gerekir:

# Clone and link all git links dependencies from .gitlinks file
gil clone
gil link

# The same result with a single command
gil update

Sonuç olarak, gerekli tüm projeleri klonlayacak ve bunları uygun bir şekilde birbirine bağlayacaksınız.

Bazı depodaki tüm değişiklikleri, alt bağlantılı depolardaki tüm değişikliklerle işlemek istiyorsanız, bunu tek bir komutla yapabilirsiniz:

gil commit -a -m "Some big update"

Çekme, itme komutları benzer şekilde çalışır:

gil pull
gil push

Gil (git links) aracı aşağıdaki komutları destekler:

usage: gil command arguments
Supported commands:
    help - show this help
    context - command will show the current git link context of the current directory
    clone - clone all repositories that are missed in the current context
    link - link all repositories that are missed in the current context
    update - clone and link in a single operation
    pull - pull all repositories in the current directory
    push - push all repositories in the current directory
    commit - commit all repositories in the current directory

Git özyinelemeli alt modüller bağımlılık sorunu hakkında daha fazla bilgi .

Bana isimlerini kullanalım a(yerine XXXve ZZZ) ve byerine (YYY o biraz daha kolay okumak için açıklama yapar, çünkü).

Eğer depo birleştirmek istediğiniz Say aiçine b(Ben birbirlerine yanında yer konum varsayarak):

cd a
git filter-repo --to-subdirectory-filter a
cd ..
cd b
git remote add a ../a
git fetch a
git merge --allow-unrelated-histories a/master
git remote remove a

Eğer gerek Bunun için git-filter-repoyüklü ( filter-branchedilmektedir cesaretini ).

Bunlardan birini bir alt dizine koyarak 2 büyük havuzu birleştirme örneği: https://gist.github.com/x-yuri/9890ab1079cf4357d6f269d073fd9731

Burada daha fazlası .

Bunu yapmanın kolay bir yolunu bilmiyorum. Bunu YAPABİLİRSİNİZ:

1. XXX deposuna bir ZZZ süper dizini eklemek için git filter-branch kullanın
2. Yeni şubeyi YYY deposuna aktarın
3. İtilen dalı YYY'nin bagajıyla birleştirin.

Bu kulağa çekici geliyorsa ayrıntıları ile düzenleyebilirim.

Sanırım bunu 'git mv' ve 'git pull' kullanarak yapabilirsiniz.

Ben adil git noob - ben ana depo ile dikkatli olun - ama ben sadece bir temp dir denedim ve işe yarıyor gibi görünüyor.

İlk olarak, XXX yapısını YYY içindeyken görünmesini istediğiniz şekilde eşleştirin:

cd XXX
mkdir tmp
git mv ZZZ tmp/ZZZ
git mv tmp ZZZ

Şimdi XXX şöyle görünüyor:

XXX
 |- ZZZ
     |- ZZZ

Şimdi değişiklikleri almak için 'git pull' kullanın:

cd ../YYY
git pull ../XXX

Şimdi YYY şöyle görünüyor:

YYY
 |- ZZZ
     |- ZZZ
 |- (other folders that already were in YYY)