un-submodule a git submodule

Bagaimana cara un-submodule a git submodule (membawa semua kode kembali ke inti)?

Seperti bagaimana "seharusnya" saya, seperti dalam "Prosedur terbaik" ...

Jika yang Anda inginkan adalah memasukkan kode submodule Anda ke repositori utama, Anda hanya perlu menghapus submodule dan menambahkan kembali file ke repo utama:

git rm --cached submodule_path # delete reference to submodule HEAD (no trailing slash)
git rm .gitmodules             # if you have more than one submodules,
                               # you need to edit this file instead of deleting!
rm -rf submodule_path/.git     # make sure you have backup!!
git add submodule_path         # will add files instead of commit reference
git commit -m "remove submodule"

Jika Anda juga ingin mempertahankan sejarah submodule, Anda dapat melakukan trik kecil: "gabungkan" submodule ke dalam repositori utama sehingga hasilnya akan sama seperti sebelumnya, kecuali bahwa file submodule sekarang ada di repositori utama.

Pada modul utama Anda perlu melakukan hal berikut:

# Fetch the submodule commits into the main repository
git remote add submodule_origin git://url/to/submodule/origin
git fetch submodule_origin

# Start a fake merge (won't change any files, won't commit anything)
git merge -s ours --no-commit submodule_origin/master

# Do the same as in the first solution
git rm --cached submodule_path # delete reference to submodule HEAD
git rm .gitmodules             # if you have more than one submodules,
                               # you need to edit this file instead of deleting!
rm -rf submodule_path/.git     # make sure you have backup!!
git add submodule_path         # will add files instead of commit reference

# Commit and cleanup
git commit -m "removed submodule"
git remote rm submodule_origin

Repositori yang dihasilkan akan terlihat sedikit aneh: akan ada lebih dari satu komit awal. Tapi itu tidak akan menyebabkan masalah bagi git.

Dalam solusi kedua ini Anda akan memiliki keuntungan besar bahwa Anda masih dapat menjalankan git menyalahkan atau git log pada file yang semula dalam submodul. Sebenarnya apa yang Anda lakukan di sini adalah mengubah nama banyak file di dalam satu repositori, dan git harus secara otomatis mendeteksi ini. Jika Anda masih memiliki masalah dengan git log, coba beberapa opsi (--follow, -M, -C) yang melakukan lebih baik ganti nama / deteksi salinan.

Sejak git 1.8.5 (Nov 2013 ) ( tanpa menyimpan riwayat submodule ):

mv yoursubmodule yoursubmodule_tmp
git submodule deinit yourSubmodule
git rm yourSubmodule
mv yoursubmodule_tmp yoursubmodule
git add yoursubmodule

Itu akan:

• batalkan pendaftaran dan bongkar (mis. hapus konten ) submodule ( deinit, karenanya yang mv pertama ),
• bersihkan .gitmodulesuntukmu (rm ),
• dan menghapus entri khusus yang mewakili submodule SHA1 dalam indeks induk repo ( rm).

Setelah penghapusan submodule selesai ( deinitdan git rm), Anda dapat mengganti nama folder kembali ke nama aslinya dan menambahkannya ke repo git sebagai folder biasa.

Catatan: jika submodule dibuat oleh Git lama (<1.8), Anda mungkin perlu menghapus .gitfolder bersarang di dalam submodule itu sendiri, seperti dikomentari oleh Simon East

Jika Anda perlu menjaga sejarah submodule, lihat jsears 's jawaban , yang menggunakan git filter-branch.

Saya telah membuat skrip yang akan menerjemahkan submodule ke direktori sederhana, sambil mempertahankan semua riwayat file. Itu tidak menderita dari git log --follow <file>masalah yang solusi lain menderita. Ini juga merupakan doa satu-baris yang sangat mudah yang melakukan semua pekerjaan untuk Anda. Ayo.

Itu dibangun di atas karya luar biasa oleh Lucas Jenß, yang dijelaskan dalam posting blognya " Mengintegrasikan submodule ke dalam repositori induk ", tetapi mengotomatiskan seluruh proses dan membersihkan beberapa kasing sudut lainnya.

Kode terbaru akan dipertahankan dengan perbaikan bug di github di https://github.com/jeremysears/scripts/blob/master/bin/git-submodule-rewrite , tetapi demi protokol jawaban stackoverflow yang tepat, saya telah menyertakan solusi secara keseluruhan di bawah ini.

Pemakaian:

$ git-submodule-rewrite <submodule-name>

git-submodule-rewrite:

#!/usr/bin/env bash

# This script builds on the excellent work by Lucas Jenß, described in his blog
# post "Integrating a submodule into the parent repository", but automates the
# entire process and cleans up a few other corner cases.
# https://x3ro.de/2013/09/01/Integrating-a-submodule-into-the-parent-repository.html

function usage(){
  echo "Merge a submodule into a repo, retaining file history."
  echo "Usage: $0 <submodule-name>"
  echo ""
  echo "options:"
  echo "  -h, --help                Print this message"
  echo "  -v, --verbose             Display verbose output"
}

function abort {
    echo "$(tput setaf 1)$1$(tput sgr0)"
    exit 1
}

function request_confirmation {
    read -p "$(tput setaf 4)$1 (y/n) $(tput sgr0)"
    [ "$REPLY" == "y" ] || abort "Aborted!"
}

function warn() {
  cat << EOF
    This script will convert your "${sub}" git submodule into
    a simple subdirectory in the parent repository while retaining all
    contents and file history.

    The script will:
      * delete the ${sub} submodule configuration from .gitmodules and
        .git/config and commit it.
      * rewrite the entire history of the ${sub} submodule so that all
        paths are prefixed by ${path}.
        This ensures that git log will correctly follow the original file
        history.
      * merge the submodule into its parent repository and commit it.

    NOTE: This script might completely garble your repository, so PLEASE apply
    this only to a fresh clone of the repository where it does not matter if
    the repo is destroyed.  It would be wise to keep a backup clone of your
    repository, so that you can reconstitute it if need be.  You have been
    warned.  Use at your own risk.

EOF

  request_confirmation "Do you want to proceed?"
}

function git_version_lte() {
  OP_VERSION=$(printf "%03d%03d%03d%03d" $(echo "$1" | tr '.' '\n' | head -n 4))
  GIT_VERSION=$(git version)
  GIT_VERSION=$(printf "%03d%03d%03d%03d" $(echo "${GIT_VERSION#git version}" | tr '.' '\n' | head -n 4))
  echo -e "${GIT_VERSION}\n${OP_VERSION}" | sort | head -n1
  [ ${OP_VERSION} -le ${GIT_VERSION} ]
}

function main() {

  warn

  if [ "${verbose}" == "true" ]; then
    set -x
  fi

  # Remove submodule and commit
  git config -f .gitmodules --remove-section "submodule.${sub}"
  if git config -f .git/config --get "submodule.${sub}.url"; then
    git config -f .git/config --remove-section "submodule.${sub}"
  fi
  rm -rf "${path}"
  git add -A .
  git commit -m "Remove submodule ${sub}"
  rm -rf ".git/modules/${sub}"

  # Rewrite submodule history
  local tmpdir="$(mktemp -d -t submodule-rewrite-XXXXXX)"
  git clone "${url}" "${tmpdir}"
  pushd "${tmpdir}"
  local tab="$(printf '\t')"
  local filter="git ls-files -s | sed \"s/${tab}/${tab}${path}\//\" | GIT_INDEX_FILE=\${GIT_INDEX_FILE}.new git update-index --index-info && mv \${GIT_INDEX_FILE}.new \${GIT_INDEX_FILE}"
  git filter-branch --index-filter "${filter}" HEAD
  popd

  # Merge in rewritten submodule history
  git remote add "${sub}" "${tmpdir}"
  git fetch "${sub}"

  if git_version_lte 2.8.4
  then
    # Previous to git 2.9.0 the parameter would yield an error
    ALLOW_UNRELATED_HISTORIES=""
  else
    # From git 2.9.0 this parameter is required
    ALLOW_UNRELATED_HISTORIES="--allow-unrelated-histories"
  fi

  git merge -s ours --no-commit ${ALLOW_UNRELATED_HISTORIES} "${sub}/master"
  rm -rf tmpdir

  # Add submodule content
  git clone "${url}" "${path}"
  rm -rf "${path}/.git"
  git add "${path}"
  git commit -m "Merge submodule contents for ${sub}"
  git config -f .git/config --remove-section "remote.${sub}"

  set +x
  echo "$(tput setaf 2)Submodule merge complete. Push changes after review.$(tput sgr0)"
}

set -euo pipefail

declare verbose=false
while [ $# -gt 0 ]; do
    case "$1" in
        (-h|--help)
            usage
            exit 0
            ;;
        (-v|--verbose)
            verbose=true
            ;;
        (*)
            break
            ;;
    esac
    shift
done

declare sub="${1:-}"

if [ -z "${sub}" ]; then
  >&2 echo "Error: No submodule specified"
  usage
  exit 1
fi

shift

if [ -n "${1:-}" ]; then
  >&2 echo "Error: Unknown option: ${1:-}"
  usage
  exit 1
fi

if ! [ -d ".git" ]; then
  >&2 echo "Error: No git repository found.  Must be run from the root of a git repository"
  usage
  exit 1
fi

declare path="$(git config -f .gitmodules --get "submodule.${sub}.path")"
declare url="$(git config -f .gitmodules --get "submodule.${sub}.url")"

if [ -z "${path}" ]; then
  >&2 echo "Error: Submodule not found: ${sub}"
  usage
  exit 1
fi

if ! [ -d "${path}" ]; then
  >&2 echo "Error: Submodule path not found: ${path}"
  usage
  exit 1
fi

main

1. git rm --cached the_submodule_path
2. hapus bagian submodule dari .gitmodulesfile, atau jika itu hanya submodule, hapus file tersebut.
3. lakukan komit "hapus submodule xyz"
4. git add the_submodule_path
5. komit lain "menambahkan basis kode xyz"

Saya belum menemukan cara yang lebih mudah. Anda dapat memampatkan 3-5 menjadi satu langkah melalui git commit -a- masalah selera.

Banyak jawaban di sini tetapi semuanya tampaknya terlalu rumit dan kemungkinan tidak melakukan apa yang Anda inginkan. Saya yakin kebanyakan orang ingin menyimpan sejarah mereka.

Untuk contoh ini repo utama akan menjadi [email protected]:main/main.gitdan repo submodule akan [email protected]:main/child.git. Ini mengasumsikan bahwa submodule terletak di direktori root dari repo induk. Sesuaikan instruksi sesuai kebutuhan.

Mulailah dengan mengkloning repo induk dan menghapus submodule lama.

git clone [email protected]:main/main.git
git submodule deinit child
git rm child
git add --all
git commit -m "remove child submodule"

Sekarang kita akan menambahkan repo anak hulu ke repo utama.

git remote add upstream [email protected]:main/child.git
git fetch upstream
git checkout -b merge-prep upstream/master

Langkah selanjutnya mengasumsikan bahwa Anda ingin memindahkan file pada cabang gabungan-persiapan ke lokasi yang sama dengan submodule di atas meskipun Anda dapat dengan mudah mengubah lokasi dengan mengubah path file.

mkdir child

pindahkan semua folder dan file kecuali folder .git ke folder anak.

git add --all
git commit -m "merge prep"

Sekarang Anda cukup menggabungkan file Anda kembali ke cabang master.

git checkout master
git merge merge-prep # --allow-unrelated-histories merge-prep flag may be required 

Lihatlah ke sekeliling dan pastikan semuanya terlihat baik sebelum berjalan git push

Satu hal yang harus Anda ingat sekarang adalah bahwa git log secara default tidak mengikuti file yang dipindahkan namun dengan menjalankannya git log --follow filenameAnda dapat melihat riwayat lengkap file Anda.

Itu terjadi pada kami bahwa kami membuat 2 repositori untuk 2 proyek yang sangat digabungkan sehingga tidak masuk akal untuk memisahkannya, jadi kami menggabungkannya.

Saya akan menunjukkan cara menggabungkan cabang-cabang master di masing-masing pertama dan kemudian saya akan menjelaskan bagaimana Anda dapat memperluas ini ke setiap cabang yang Anda dapatkan, semoga ini membantu Anda.

Jika submodule Anda berfungsi, dan Anda ingin mengubahnya menjadi direktori yang dapat Anda lakukan:

git clone project_uri project_name

Di sini kami melakukan klon bersih untuk bekerja. Untuk proses ini, Anda tidak perlu menginisialisasi atau memperbarui submodul, jadi abaikan saja.

cd project_name
vim .gitmodules

Edit .gitmodulesdengan editor favorit Anda (atau Vim) untuk menghapus submodule yang akan Anda ganti. Baris yang perlu Anda hapus akan terlihat seperti ini:

[submodule "lib/asi-http-request"]
    path = lib/asi-http-request
    url = https://github.com/pokeb/asi-http-request.git

Setelah menyimpan file,

git rm --cached directory_of_submodule
git commit -am "Removed submodule_name as submodule"
rm -rf directory_of_submodule

Di sini kita menghapus hubungan submodule sepenuhnya sehingga kita dapat membuat membawa repo lain ke proyek di tempat.

git remote add -f submodule_origin submodule_uri
git fetch submodel_origin/master

Di sini kita mengambil repositori submodule untuk digabung.

git merge -s ours --no-commit submodule_origin/master

Di sini kita memulai operasi gabungan dari 2 repositori, tetapi berhenti sebelum melakukan.

git read-tree --prefix=directory_of_submodule/ -u submodule_origin/master

Di sini kami mengirim konten master dalam submodule ke direktori di mana ia sebelum awalan nama direktori

git commit -am "submodule_name is now part of main project"

Di sini kita menyelesaikan prosedur melakukan komit dari perubahan dalam penggabungan.

Setelah menyelesaikan ini, Anda bisa mendorong, dan mulai lagi dengan cabang lain untuk menggabungkan, cukup checkout cabang di repositori Anda yang akan menerima perubahan dan mengubah cabang yang Anda bawa operasi gabungan dan baca-pohon.

Jawaban terbaik untuk ini saya temukan di sini:

http://x3ro.de/2013/09/01/Integrating-a-submodule-into-the-parent-repository.html

Artikel ini menjelaskan prosedur dengan sangat baik.

Inilah versi yang sedikit lebih baik (IMHO) dari jawaban @ gyim. Dia melakukan banyak perubahan berbahaya di copy pekerjaan utama, di mana saya pikir itu jauh lebih mudah untuk beroperasi pada klon yang terpisah dan kemudian menggabungkannya bersama di akhir.

Dalam direktori terpisah (untuk membuat kesalahan lebih mudah dibersihkan dan coba lagi) periksa repo atas dan subrepo.

git clone ../main_repo main.tmp
git clone ../main_repo/sub_repo sub.tmp

Pertama-tama edit subrepo untuk memindahkan semua file ke subdirektori yang diinginkan

cd sub.tmp
mkdir sub_repo_path
git mv `ls | grep -v sub_repo_path` sub_repo_path/
git commit -m "Moved entire subrepo into sub_repo_path"

Catat KEPALA

SUBREPO_HEAD=`git reflog | awk '{ print $1; exit; }'`

Sekarang hapus subrepo dari repo utama

cd ../main.tmp
rmdir sub_repo_path
vi .gitmodules  # remove config for submodule
git add -A
git commit -m "Removed submodule sub_repo_path in preparation for merge"

Dan akhirnya, gabungkan saja

git fetch ../sub.tmp
# remove --allow-unrelated-histories if using git older than 2.9.0
git merge --allow-unrelated-histories $SUBREPO_HEAD

Dan dilakukan! Dengan aman dan tanpa sihir apa pun.

Untuk kapan

git rm [-r] --cached submodule_path

kembali

fatal: pathspec 'emr/normalizers/' did not match any files

Konteks: Saya melakukannya rm -r .git*di folder submodule saya sebelum menyadari bahwa mereka perlu di-submoduled di proyek utama yang baru saja saya tambahkan. Saya mendapat kesalahan di atas ketika de-submoduling beberapa, tetapi tidak semuanya. Bagaimanapun, saya memperbaikinya dengan menjalankan, (setelah, tentu saja, rm -r .git*)

mv submodule_path submodule_path.temp
git add -A .
git commit -m "De-submodulization phase 1/2"
mv submodule_path.temp submodule_path
git add -A .
git commit -m "De-submodulization phase 2/2"

Perhatikan bahwa ini tidak menyimpan sejarah.

Berdasarkan jawaban VonC , saya telah membuat skrip bash sederhana yang melakukan ini. Pada addakhirnya harus menggunakan wildcard jika tidak akan membatalkan sebelumnya rmuntuk submodule itu sendiri. Sangat penting untuk menambahkan isi direktori submodule, dan tidak menamai direktori itu sendiri diadd perintah.

Dalam sebuah file bernama git-integrate-submodule:

#!/usr/bin/env bash
mv "$1" "${1}_"
git submodule deinit "$1"
git rm "$1"
mv "${1}_" "$1"
git add "$1/**"

Saya merasa lebih nyaman untuk (juga?) Mengambil data komit lokal dari submodule, karena kalau tidak saya akan kehilangan mereka. (Tidak dapat mendorong mereka karena saya tidak memiliki akses ke remote itu). Jadi saya menambahkan submodule / .git sebagai remote_origin2, mengambilnya melakukan dan bergabung dari cabang itu. Tidak yakin apakah saya masih memerlukan submodule remote sebagai asal, karena saya belum cukup akrab dengan git.

Inilah yang saya temukan terbaik & paling sederhana.

Dalam repo submodule, dari HEAD Anda ingin bergabung ke repo utama:

• git checkout -b "mergeMe"
• mkdir "foo/bar/myLib/" (jalur identik dengan tempat Anda ingin file pada repo utama)
• git mv * "foo/bar/myLib/" (pindahkan semua ke jalur)
• git commit -m "ready to merge into main"

Kembali ke repo utama setelah menghapus submodule dan membersihkan jalur "foo / bar / myLib":

• git merge --allow-unrelated-histories SubmoduleOriginRemote/mergeMe

booming dilakukan

sejarah terpelihara

jangan khawatir

Perhatikan ini hampir identik dengan beberapa jawaban lain. Tapi ini mengasumsikan Anda memiliki repo submodule. Juga ini membuatnya mudah untuk mendapatkan perubahan hulu untuk submodule di masa depan.