Bagaimana cara mengimpor repositori Git yang ada ke yang lain?

Saya memiliki repositori Git dalam folder bernama XXX , dan saya memiliki repositori Git kedua yang disebut YYY .

Saya ingin mengimpor repositori XXX ke dalam repositori YYY sebagai subdirektori bernama ZZZ dan menambahkan semua riwayat perubahan XXX ke YYY .

Struktur folder sebelumnya:

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

Struktur folder setelah:

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

Apakah ini bisa dilakukan, atau haruskah saya menggunakan sub-modul?

Mungkin cara paling sederhana adalah dengan menarik barang XXX ke cabang di YYY dan kemudian menggabungkannya menjadi master:

Di 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

Saya sebenarnya hanya mencoba ini dengan beberapa repo saya dan itu berhasil. Tidak seperti jawaban Jorg, itu tidak akan membiarkan Anda terus menggunakan repo yang lain, tapi saya rasa Anda tidak menentukannya.

Catatan: Karena ini awalnya ditulis pada tahun 2009, git telah menambahkan gabungan subtree yang disebutkan dalam jawaban di bawah ini. Saya mungkin akan menggunakan metode itu hari ini, walaupun tentu saja metode ini masih berfungsi.

Jika Anda ingin mempertahankan histori komit yang tepat dari repositori kedua dan karena itu juga mempertahankan kemampuan untuk dengan mudah menggabungkan perubahan hulu di masa depan maka inilah metode yang Anda inginkan. Ini menghasilkan riwayat subtree yang tidak dimodifikasi yang diimpor ke dalam repo Anda ditambah satu komitmen gabungan untuk memindahkan repositori yang digabungkan ke subdirektori.

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."

Anda dapat melacak perubahan hulu seperti:

git pull -s subtree XXX_remote master

Git mencari tahu sendiri di mana root sebelum melakukan penggabungan, jadi Anda tidak perlu menentukan awalan pada penggabungan berikutnya.

The downside adalah bahwa dalam sejarah gabungan file tidak diperbaiki (tidak dalam subdirektori). Akibatnya git log ZZZ/aakan menampilkan semua perubahan (jika ada) kecuali yang ada dalam riwayat gabungan. Anda dapat melakukan:

git log --follow -- a

tapi itu tidak akan menampilkan perubahan selain dari itu di riwayat gabungan.

Dengan kata lain, jika Anda tidak mengubah ZZZfile dalam repositori XXX, maka Anda perlu menentukan --followdan jalur yang tidak diperbaiki. Jika Anda mengubahnya di kedua repositori, maka Anda memiliki 2 perintah, tidak ada yang menunjukkan semua perubahan.

Versi Git sebelum 2.9 : Anda tidak perlu meneruskan --allow-unrelated-historiesopsi ke git merge.

Metode di jawaban lain yang menggunakan read-treedan melewatkan merge -s ourslangkah secara efektif tidak berbeda dari menyalin file dengan cp dan melakukan hasilnya.

Sumber asli berasal dari artikel bantuan "Subtree Merge" github . Dan tautan lain yang bermanfaat .

git-subtreeadalah skrip yang dirancang untuk kasus penggunaan yang tepat untuk menggabungkan beberapa repositori ke dalam satu sembari mempertahankan sejarah (dan / atau memisah riwayat subtree, meskipun tampaknya tidak relevan dengan pertanyaan ini). Ini didistribusikan sebagai bagian dari pohon git sejak rilis 1.7.11 .

Untuk menggabungkan repositori <repo>pada revisi <rev>sebagai subdirektori <prefix>, gunakan git subtree addsebagai berikut:

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

git-subtree mengimplementasikan strategi gabungan subtree dengan cara yang lebih ramah pengguna.

Untuk kasus Anda, di dalam repositori YYY, Anda akan menjalankan:

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

The downside adalah bahwa dalam sejarah gabungan file tidak diperbaiki (tidak dalam subdirektori). Akibatnya git log ZZZ/aakan menampilkan semua perubahan (jika ada) kecuali yang ada dalam riwayat gabungan. Anda dapat melakukan:

git log --follow -- a

tapi itu tidak akan menampilkan perubahan selain dari itu di riwayat gabungan.

Dengan kata lain, jika Anda tidak mengubah ZZZfile dalam repositori XXX, maka Anda perlu menentukan --followdan jalur yang tidak diperbaiki. Jika Anda mengubahnya di kedua repositori, maka Anda memiliki 2 perintah, tidak ada yang menunjukkan semua perubahan.

Lebih lanjut di sini .

Ada contoh yang terkenal dari hal ini di repositori Git itu sendiri, yang secara kolektif dikenal di komunitas Git sebagai " penggabungan paling keren yang pernah ada " (setelah baris subjek Linus Torvalds digunakan dalam email ke mailinglist Git yang menggambarkan ini menggabungkan). Dalam hal ini, gitkGUI GUI yang sekarang merupakan bagian dari Git yang tepat, sebenarnya merupakan proyek yang terpisah. Linus berhasil menggabungkan repositori itu ke dalam repositori Git dengan cara itu

• muncul di repositori Git seolah-olah itu selalu dikembangkan sebagai bagian dari Git,
• semua sejarah disimpan dan
• masih dapat dikembangkan secara independen di repositori tuanya, dengan perubahan yang sedang git pulldiedit.

E-mail berisi langkah-langkah yang diperlukan untuk mereproduksi, tetapi itu bukan untuk orang yang lemah hati: pertama, Linus menulis Git, jadi dia mungkin tahu sedikit lebih banyak tentang hal itu daripada Anda atau saya, dan kedua, ini hampir 5 tahun yang lalu dan Git telah meningkat pesat sejak saat itu, jadi mungkin sekarang jauh lebih mudah.

Secara khusus, saya kira saat ini orang akan menggunakan submodule gitk, dalam kasus tertentu.

Cara mudah untuk melakukannya adalah dengan menggunakan git format-patch.

Asumsikan kita memiliki 2 repositori git foo and bar .

foo berisi:

• foo.txt
• .git

bilah berisi:

• bar.txt
• .git

dan kami ingin mengakhiri dengan foo yang berisi riwayat bilah dan file-file ini:

• foo.txt
• .git
• foobar / bar.txt

Jadi untuk melakukan itu:

 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/*

Dan jika kita ingin menulis ulang semua komit pesan dari bar dapat kita lakukan, misalnya di Linux:

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

Ini akan menambahkan "[bilah]" di awal setiap pesan komit.

Fungsi ini akan mengkloning repo jarak jauh ke dir repo lokal, setelah menggabungkan semua komit akan disimpan, git logakan ditampilkan komit asli dan jalur yang benar:

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"
}

Cara Penggunaan:

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

Jika membuat sedikit perubahan, Anda bahkan dapat memindahkan file / dir repo yang digabungkan ke jalur yang berbeda, misalnya:

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"

Jalur Pemberitahuan menggantikan via sed, jadi pastikan jalur tersebut dipindahkan di jalur yang benar setelah penggabungan.
The --allow-unrelated-historiesparameter hanya ada sejak git> = 2,9.

Berdasarkan artikel ini , menggunakan subtree adalah yang berhasil untuk saya dan hanya riwayat yang berlaku yang ditransfer. Posting di sini kalau-kalau ada yang membutuhkan langkah-langkah (pastikan untuk mengganti penampung dengan nilai yang berlaku untuk Anda):

di repositori sumber Anda, pisahkan subfolder ke cabang baru

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

di repo tujuan Anda bergabung di cabang hasil split

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

verifikasi perubahan Anda dan komit

git status
git commit

Jangan lupa

Bersihkan dengan menghapus subtree-split-resultcabang

git branch -D subtree-split-result

Hapus remote yang Anda tambahkan untuk mengambil data dari repo sumber

git remote rm merge-source-repo

Menambahkan jawaban lain karena saya pikir ini sedikit lebih sederhana. Tarik repo_dest dilakukan ke repo_to_import dan kemudian push --set-upstream url: master repo_dest dilakukan.

Metode ini berhasil bagi saya mengimpor beberapa repo yang lebih kecil ke yang lebih besar.

Cara mengimpor: repo1_to_import ke 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

Ganti nama atau pindahkan file dan dir ke posisi yang diinginkan dalam repo asli sebelum Anda melakukan impor. misalnya

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

Metode yang dijelaskan pada tautan berikut menginspirasi jawaban ini. Saya menyukainya karena sepertinya lebih sederhana. TAPI Waspadalah! Ada naga! https://help.github.com/articles/importing-an-external-git-repository git push --mirror url:repo_dest mendorong riwayat repo lokal Anda dan menyatakan ke remote (url: repo_dest). TAPI menghapus sejarah lama dan keadaan remote. Menyenangkan kemudian terjadi! : -E

Saya ingin mengimpor hanya beberapa file dari repositori lain (XXX) dalam kasus saya. Subtree terlalu rumit untuk saya dan solusi lainnya tidak berhasil. Inilah yang saya lakukan:

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

Ini memberi Anda daftar yang dipisahkan oleh ruang dari semua komit yang memengaruhi file yang ingin saya impor (ZZZ) dalam urutan terbalik (Anda mungkin harus menambahkan - ikuti untuk mengambil nama juga). Saya kemudian pergi ke repositori target (YYY), menambahkan repositori lain (XXX) sebagai remote, melakukan pengambilan dari itu dan akhirnya:

git cherry-pick $ALL_COMMITS

yang menambahkan semua komit ke cabang Anda, dengan demikian Anda akan memiliki semua file dengan sejarahnya dan dapat melakukan apa pun yang Anda inginkan dengannya seolah-olah mereka selalu berada di repositori ini.

Lihat contoh dasar dalam artikel ini dan pertimbangkan pemetaan seperti pada repositori:

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

Setelah semua aktivitas yang dijelaskan dalam bab ini (setelah penggabungan), hapus cabang B-master:

$ git branch -d B-master

Lalu, dorong perubahan.

Ini bekerja untuk saya.

Saya berada dalam situasi di mana saya mencari -s theirstetapi tentu saja, strategi ini tidak ada. Sejarah saya adalah bahwa saya telah melakukan proyek pada GitHub, dan sekarang karena alasan tertentu, lokal saya mastertidak dapat digabung denganupstream/master walaupun saya tidak membuat perubahan lokal pada cabang ini. (Benar-benar tidak tahu apa yang terjadi di sana - saya kira hulu telah melakukan beberapa dorongan kotor di belakang layar, mungkin?)

Apa yang akhirnya saya lakukan adalah

# 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

Jadi sekarang saya masterlagi sinkron dengan upstream/master(dan Anda bisa mengulangi di atas untuk cabang lain yang juga ingin Anda sinkronkan).

Saya dapat menyarankan solusi lain (alternatif untuk git-submodules ) untuk masalah Anda - gil (git links) alat

Hal ini memungkinkan untuk menggambarkan dan mengelola dependensi repositori git yang kompleks.

Juga memberikan solusi untuk masalah ketergantungan submodules git rekursif .

Pertimbangkan Anda memiliki dependensi proyek berikut: grafik dependensi repositori sampel git

Kemudian Anda dapat mendefinisikan .gitlinksfile dengan deskripsi relasi repositori:

# 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

Setiap baris menggambarkan tautan git dalam format berikut:

1. Nama unik repositori
2. Jalur relatif repositori (dimulai dari jalur file .gitlinks)
3. Repositori git yang akan digunakan dalam perintah git clone Cabang repositori untuk checkout
4. Baris kosong atau baris yang dimulai dengan # tidak diuraikan (diperlakukan sebagai komentar).

Akhirnya Anda harus memperbarui repositori sampel root Anda:

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

# The same result with a single command
gil update

Sebagai hasilnya, Anda akan mengkloning semua proyek yang diperlukan dan menghubungkannya satu sama lain dengan cara yang benar.

Jika Anda ingin mengkomit semua perubahan dalam beberapa repositori dengan semua perubahan dalam repositori terkait anak Anda dapat melakukannya dengan satu perintah:

gil commit -a -m "Some big update"

Perintah tarik, tekan bekerja dengan cara yang sama:

gil pull
gil push

Alat Gil (git links) mendukung perintah berikut:

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

Lebih lanjut tentang masalah ketergantungan submodul git rekursif .

Biarkan saya menggunakan nama a(di tempat XXXdan ZZZ) dan b(di tempatYYY ), karena itu membuat deskripsi sedikit lebih mudah dibaca.

Katakanlah Anda ingin menggabungkan repositori ake b(Saya berasumsi mereka berada di satu sama lain):

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

Untuk ini, Anda perlu git-filter-repomenginstal ( filter-branchtidak disarankan ).

Contoh menggabungkan 2 repositori besar, menempatkan salah satunya ke dalam subdirektori: https://gist.github.com/x-yuri/9890ab1079cf4357d6f269d073fd9731

Lebih lanjut di sini .

Saya tidak tahu cara mudah untuk melakukan itu. Anda BISA melakukan ini:

1. Gunakan cabang-filter git untuk menambahkan direktori super ZZZ di repositori XXX
2. Dorong cabang baru ke repositori YYY
3. Gabungkan cabang yang didorong dengan belalai YYY.

Saya dapat mengedit dengan detail jika itu terdengar menarik.

Saya pikir Anda bisa melakukan ini menggunakan 'git mv' dan 'git pull'.

Saya seorang git noob yang adil - jadi berhati-hatilah dengan repositori utama Anda - tetapi saya baru saja mencoba ini dalam direktori temp dan sepertinya berhasil.

Pertama - ganti nama struktur XXX agar sesuai dengan yang Anda inginkan ketika berada dalam YYY:

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

Sekarang XXX terlihat seperti ini:

XXX
 |- ZZZ
     |- ZZZ

Sekarang gunakan 'git pull' untuk mengambil perubahan:

cd ../YYY
git pull ../XXX

Sekarang YYY terlihat seperti ini:

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