un-submodule git submodule


378

Jak mogę cofnąć podmoduł git (przywrócić cały kod z powrotem do rdzenia)?

Jak w „jak” powinienem, tak jak w „Najlepszej procedurze” ...


5
Uwaga: z git1.8.3 możesz teraz spróbować git submodule deinit, patrz moja odpowiedź poniżej
VonC

6
Mogę źle zrozumieć, ale wydaje się, że git submodule deinit usuwa kod.
Joe Germuska

2
Od gita 1.8.5 (listopad 2013) git submodule deinit asubmodule ; git rm asubmodulewystarczy prosty , jak pokazano w mojej odpowiedzi poniżej
VonC

rozważ użycie poddrzewa
HiB

Odpowiedzi:


527

Jeśli wszystko, czego chcesz, to umieścić kod submodułu w głównym repozytorium, wystarczy usunąć submoduł i ponownie dodać pliki do głównego repozytorium:

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"

Jeśli chcesz również zachować historię podmodułu, możesz zrobić małą sztuczkę: „scal” podmoduł z głównym repozytorium, aby wynik był taki sam jak wcześniej, z tym że pliki podmodułów znajdują się teraz w główne repozytorium.

W głównym module musisz wykonać następujące czynności:

# 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

Powstałe repozytorium będzie wyglądać nieco dziwnie: będzie więcej niż jedno wstępne zatwierdzenie. Ale to nie spowoduje żadnych problemów dla git.

W tym drugim rozwiązaniu będziesz miał dużą zaletę, że nadal możesz uruchamiać git blame lub git log na plikach, które pierwotnie były w submodułach. W rzeczywistości zmieniłeś nazwę wielu plików w jednym repozytorium i git powinien to automatycznie wykryć. Jeśli nadal masz problemy z git logiem, wypróbuj kilka opcji (--follow, -M, -C), które lepiej wykrywają zmianę nazwy / kopiowanie.


3
Myślę, że muszę wykonać twoją drugą metodę (zachowanie historii) na niektórych repozytoriach git, które mam. Czy możesz wyjaśnić, która część powyższych poleceń powoduje, że pliki z podmodułu kończą się w podkatalogu? Czy to ty, kiedy robisz scalanie, git wprowadza plik do katalogu najwyższego poziomu (z jego historią), ale kiedy robisz git, dodajesz ścieżkę_dodułową, implikacja robi git mv dla każdego pliku?
Bowie Owens,

5
Zasadniczo tak. Sztuka polega na tym, że git nie przechowuje operacji zmiany nazwy: zamiast tego wykrywa je, sprawdzając zatwierdzenia nadrzędne. Jeśli istnieje zawartość pliku, która była obecna w poprzednim zatwierdzeniu, ale ma inną nazwę pliku, jest to uważane za zmianę nazwy (lub kopii). W powyższych krokach git mergezapewnia, że ​​dla każdego pliku będzie „poprzednie zatwierdzenie” (po jednej z dwóch „stron” scalenia).
gyim

6
Dzięki gyim, rozpocząłem projekt, w którym uznałem za sensowne podzielenie rzeczy na kilka repozytoriów i połączenie ich z powrotem z podmodułami. Ale teraz wygląda na to, że jest przeprojektowany i chcę połączyć je z powrotem bez utraty historii.
Bowie Owens,

4
@theduke Miałem również ten problem. Można to naprawić, przed wykonaniem tych kroków, przenosząc wszystkie pliki z repozytorium podmodułów do struktury katalogów o tej samej ścieżce, co repozytorium, w którym zamierzasz się połączyć: tj. jeśli twój submoduł w głównym repozytorium znajduje się w foo /, w submodule wykonaj mkdir foo && git mv !(foo) foo && git commit.
Chris Down

35
Musiałem dodać, --allow-unrelated-historiesaby wymusić scalanie podczas fałszywego scalania, gdy się dostawałem fatal: refusing to merge unrelated histories, więcej tutaj: github.com/git/git/blob/master/Documentation/RelNotes/…
vaskort

72

Od wersji git 1.8.5 (listopad 2013 ) ( bez przechowywania historii submodułu ):

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

To będzie:

  • wyrejestruj i rozładuj (tj. usuń zawartość ) submoduł ( deinitstąd mv pierwszy ),
  • posprzątaj .gitmodulesdla ciebie ( rm),
  • i usuń specjalny wpis reprezentujący ten podmoduł SHA1 w indeksie nadrzędnej repo ( rm).

Po zakończeniu usuwania submodułu ( deiniti git rm) możesz zmienić nazwę folderu z powrotem na jego pierwotną nazwę i dodać go do repozytorium git jako zwykłego folderu.

Uwaga: jeśli modułem został stworzony przez starego Git (<1,8), może być konieczne, aby usunąć zagnieżdżony .gitfolder, w samym modułem, jak skomentował przez Simona Wschodzie


Jeśli trzeba zachować historię modułem, patrz jsears „s odpowiedź , który korzysta git filter-branch.


5
To faktycznie usuwa go z działającego drzewa w 1.8.4 (cały katalog podmodułu został wyczyszczony).
Chris Down

@ChrisDown masz na myśli, że deinitsam wyczyściłeś działające drzewo ze swojego podmodułu?
VonC

Tak, usuwa całą zawartość katalogu podmodułów.
Chris Down

2
@ mschuett nie, niczego nie brakuje. W podmodule nie ma .git. Jeśli tak było w twoim przypadku, było to zagnieżdżone repozytorium, a nie submoduł. To wyjaśnia, dlaczego powyższa odpowiedź nie miałaby zastosowania w twoim przypadku. Różnica między nimi znajduje się na stronie stackoverflow.com/a/34410102/6309 .
VCC

1
@VonC Aktualnie korzystam z wersji 2.9.0.windows.1, jednak submoduły mogły zostać utworzone kilka lat temu na znacznie wcześniejszej wersji git, nie jestem pewien. Wydaje mi się, że kroki wydają się działać, dopóki usuwam ten plik przed wykonaniem końcowego polecenia add + commit.
Simon East

67

Stworzyłem skrypt, który przetłumaczy submoduł do prostego katalogu, zachowując całą historię plików. Nie ma git log --follow <file>problemów z innymi rozwiązaniami. Jest to również bardzo łatwe wywołanie jednowierszowe, które wykonuje całą pracę za Ciebie. Chodź.

Opiera się na doskonałej pracy Lucasa Jenßa, opisanej w jego blogu „ Integracja submodułu w repozytorium nadrzędnym ”, ale automatyzuje cały proces i oczyszcza kilka innych przypadków narożnych.

Najnowszy kod będzie utrzymywany z poprawkami błędów w github na https://github.com/jeremysears/scripts/blob/master/bin/git-submodule-rewrite , ale ze względu na odpowiedni protokół odpowiedzi stackoverflow, zawarłem rozwiązanie w całości poniżej.

Stosowanie:

$ 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

Nie działa na Ubuntu 16.04. Wysłałem żądanie ściągnięcia do repozytorium Github.
qznc

1
Dobry połów, @qznc. Zostało to przetestowane na OSX. Z przyjemnością scalę to, gdy przejdzie na obu platformach.
jsears

Wsparcie @qznc Ubuntu 16.04 zostało scalone i odpowiedź została zaktualizowana.
jsears

2
To najlepsza odpowiedź, zachowuje całą historię. Bardzo dobrze!
CharlesB

1
Wszystkie prace działają bez błędów w Git Bash 2.20.1.1 na Windows 10 z najnowszą wersją github: curl https://raw.githubusercontent.com/jeremysears/scripts/master/bin/git-submodule-rewrite > git-submodule-rewrite.shi./git-submodule-rewrite.sh <submodule-name>
Alexey

32
  1. git rm --cached the_submodule_path
  2. usuń sekcję submodułu z .gitmodulespliku lub, jeśli jest to jedyny submoduł, usuń plik.
  3. wykonaj zatwierdzenie „usunięto submoduł xyz”
  4. git add the_submodule_path
  5. kolejna zmiana „dodana baza kodu xyz”

Nie znalazłem jeszcze łatwiejszego sposobu. Możesz skompresować 3-5 w jeden krok git commit -a- kwestia smaku.


6
Nie powinno być .gitmoduleszamiast .submodules?
imz - Ivan Zakharyaschev

1
Powinno być .gitmodulesnie.submodules
MKEY

1
Musiałem usunąć .gitkatalog submodułu, zanim zacznę git addpracować z folderem submodułu
Carson Evans

16

Wiele odpowiedzi tutaj, ale wszystkie wydają się zbyt skomplikowane i prawdopodobnie nie robią tego, co chcesz. Jestem pewien, że większość ludzi chce zachować swoją historię.

W tym przykładzie będzie to repozytorium główne git@site.com:main/main.giti repozytorium submodułu git@site.com:main/child.git. Zakłada się, że podmoduł znajduje się w katalogu głównym repozytorium nadrzędnego. Dostosuj instrukcje w razie potrzeby.

Zacznij od klonowania repozytorium nadrzędnego i usunięcia starego podmodułu.

git clone git@site.com:main/main.git
git submodule deinit child
git rm child
git add --all
git commit -m "remove child submodule"

Teraz dodamy repozytorium potomne w górę do repozytorium głównego.

git remote add upstream git@site.com:main/child.git
git fetch upstream
git checkout -b merge-prep upstream/master

W następnym kroku założono, że chcesz przenieść pliki z gałęzi scalania do tej samej lokalizacji, co podmoduł powyżej, chociaż możesz łatwo zmienić lokalizację, zmieniając ścieżkę pliku.

mkdir child

przenieś wszystkie foldery i pliki oprócz folderu .git do folderu podrzędnego.

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

Teraz możesz po prostu scalić swoje pliki z powrotem w gałęzi master.

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

Rozejrzyj się i upewnij się, że wszystko wygląda dobrze przed uruchomieniem git push

Jedyną rzeczą, którą musisz teraz zapamiętać, jest to, że git log domyślnie nie śledzi przeniesionych plików, jednak po uruchomieniu git log --follow filenamemożesz zobaczyć pełną historię swoich plików.


2
Dotarłem do finału git merge merge-prepi otrzymałem błąd fatal: refusing to merge unrelated histories. Obejście to: git merge --allow-unrelated-histories merge-prep.
humblehacker

@humblehacker dzięki, dodałem mały komentarz na wypadek, gdyby inni też na to wpadli.
mschuett

1
Najlepsza odpowiedź, aby zachować historię submodułu. Dziękuję @mschuett
Anton Temchenko

W tym przykładzie, czy istnieje jakiś sposób, aby pobrać pliki upstream do childkatalogu, więc nie musisz ich przenosić później? Mam takie same nazwy plików w podmodule i głównym repozytorium ... więc dostaję konflikt scalania, ponieważ próbuje połączyć dwa pliki razem.
Skitterm

Być może, ale nie wiem o tym od razu. Osobiście po prostu dokonałbym zatwierdzenia, przenosząc pliki w repozytorium, w którym próbujesz się przenieść, aby znajdowały się w katalogu, który chcesz przed
pobraniem

12

Zdarzyło się nam, że stworzyliśmy 2 repozytoria dla 2 projektów, które były tak połączone, że rozdzielenie ich nie miało sensu, więc połączyliśmy je.

Pokażę, jak połączyć główne gałęzie w każdej z nich, a następnie wyjaśnię, jak możesz to rozszerzyć na każdą otrzymaną gałąź, mam nadzieję, że to ci pomoże.

Jeśli podmoduł działa i chcesz przekonwertować go na katalog w miejscu, możesz:

git clone project_uri project_name

Tutaj robimy czysty klon do pracy. W tym procesie nie musisz inicjować ani aktualizować submodułów, więc po prostu go pomiń.

cd project_name
vim .gitmodules

Edytuj za .gitmodulespomocą swojego ulubionego edytora (lub Vima), aby usunąć submoduł, który planujesz zastąpić. Linie, które musisz usunąć, powinny wyglądać mniej więcej tak:

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

Po zapisaniu pliku

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

Tutaj całkowicie usuwamy relację podmodułu, abyśmy mogli stworzyć drugą repozytorium w projekcie.

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

Tutaj pobieramy repozytorium submodułu do scalenia.

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

Tutaj rozpoczynamy operację scalania 2 repozytoriów, ale zatrzymujemy się przed zatwierdzeniem.

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

Tutaj wysyłamy zawartość wzorca w podmodule do katalogu, w którym była przed prefiksem nazwy katalogu

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

Tutaj kończymy procedurę zatwierdzając zmiany w scalaniu.

Po zakończeniu możesz pchać i zaczynać od innej gałęzi w celu scalenia, po prostu sprawdź gałąź w swoim repozytorium, która otrzyma zmiany i zmieni gałąź, którą wprowadzasz w operacjach scalania i odczytu.


wydaje się, że nie zachowało to historii plików submodułów, po prostu widzę pojedyncze zatwierdzenie w dzienniku git dla plików dodanych poniżejdirectory_of_submodule
Anentropic

@Anentropic Przepraszamy za opóźnienie w odpowiedzi. Właśnie wykonałem całą procedurę ponownie (z niewielką poprawką). Procedura zachowuje całą historię, ale ma punkt scalenia, może dlatego jej nie znajdziesz. Jeśli chcesz zobaczyć historię submodułu, po prostu zrób „dziennik git”, poszukaj zatwierdzenia scalania (w tym przykładzie jest ten z komunikatem „nazwa_modułu jest teraz częścią głównego projektu”). Będzie miał 2 zatwierdzenia nadrzędne (Scal: sdasda asdasd), git zaloguj drugi zatwierdzenie i masz tam całą historię swojego modułu podrzędnego / głównego.
dvicino

moja pamięć jest teraz zamglona, ​​ale myślę, że udało mi się uzyskać historię scalonych plików submodułów, wykonując git log original_path_of_file_in_submodulenp. ścieżkę zarejestrowaną w repozytorium git dla pliku (który już nie istnieje w systemie plików), mimo że plik submodułu teraz mieszka wsubmodule_path/new_path_of_file
Anentropic

To nie zachowuje historii zbyt dobrze, a także ścieżki są złe. Wydaje
Luke H

Ta odpowiedź jest nieaktualna, stackoverflow.com/a/16162228/11343 (odpowiedź VonC) robi to samo, ale lepiej
CharlesB


6

Oto nieco ulepszona wersja (IMHO) odpowiedzi @ gyim. Dokonuje wielu niebezpiecznych zmian w głównej kopii roboczej, gdzie myślę, że o wiele łatwiej jest operować na oddzielnych klonach, a następnie scalić je na końcu.

W osobnym katalogu (aby ułatwić usuwanie błędów i spróbuj ponownie), sprawdź zarówno najlepsze repozytorium, jak i subrepo.

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

Najpierw edytuj subrepo, aby przenieść wszystkie pliki do żądanego podkatalogu

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"

Zanotuj HEAD

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

Teraz usuń subrepo z głównego repozytorium

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"

I w końcu po prostu je połącz

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

I zrobione! Bezpiecznie i bez magii.


... która to odpowiedź? Może chcesz odwoływać się do nazwy użytkownika, a najwyższa odpowiedź może się z czasem zmienić.
Contango,

Odpowiedź @Contango została zaktualizowana. ale najwyższa odpowiedź jest wciąż najwyższą odpowiedzią na 400-punktową przewagę ;-)
danych

Czy to działa, jeśli subrepo zawiera już katalog o nazwie subrepoz zawartością ?
detly

W ostatnim kroku pojawia się następujący błąd: git merge $SUBREPO_HEAD fatal: refusing to merge unrelated historiesCzy powinienem użyć git merge $SUBREPO_HEAD --allow-unrelated-historiesw tym przypadku? A może powinien działać bez i popełniłem błąd?
Ti-m

1
@ Ti-m Tak, dokładnie tak jest w przypadku połączenia dwóch historii, które nie dzielą żadnych zatwierdzeń. Ochrona przed niepowiązanymi historiami wydaje się nowa od samego początku, odkąd to napisałem; Zaktualizuję moją odpowiedź.
danych

3

Do kiedy

git rm [-r] --cached submodule_path

zwroty

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

Kontekst: Zrobiłem to rm -r .git*w folderach submodułów, zanim zdałem sobie sprawę, że trzeba je zdekodulodować w głównym projekcie, do którego właśnie je dodałem. Wystąpił powyższy błąd podczas usuwania niektórych modeli, ale nie wszystkich. W każdym razie naprawiłem je, uruchamiając (po, oczywiście 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"

Pamiętaj, że to nie zachowuje historii.


3

Na podstawie odpowiedzi VonC stworzyłem prosty skrypt bash, który to robi. Na addkońcu należy użyć symboli wieloznacznych, w przeciwnym razie cofnie poprzednie rmdla samego podmodułu. Ważne jest, aby dodać zawartość katalogu submodułu, a nie nazywać samego katalogu w addpoleceniu.

W pliku o nazwie git-integrate-submodule:

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

0

Uważam, że wygodniej jest (również?) Pobierać dane lokalnego zatwierdzenia z podmodułu, ponieważ w przeciwnym razie straciłbym je. (Nie można ich wypchnąć, ponieważ nie mam dostępu do tego pilota). Więc dodałem submodule / .git jako remote_origin2, ściągnąłem commits i połączyłem z tej gałęzi. Nie jestem pewien, czy nadal potrzebuję zdalnego modułu podrzędnego jako źródła, ponieważ nie znam jeszcze git.


0

Oto, co uważam za najlepsze i najprostsze.

W repozytorium submodułowym HEAD chcesz scalić w repozytorium główne:

  • git checkout -b "mergeMe"
  • mkdir "foo/bar/myLib/" (identyczna ścieżka jak w przypadku plików na głównym repozytorium)
  • git mv * "foo/bar/myLib/" (przenieś wszystko na ścieżkę)
  • git commit -m "ready to merge into main"

Powrót do głównego repozytorium po usunięciu podmodułu i wyczyszczeniu ścieżki „foo / bar / myLib”:

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

boom zrobiony

historie zachowane

bez obaw


Zauważ, że prawie identyczne z niektórymi innymi odpowiedziami. Ale zakłada to, że posiadasz repozytorium submodułu. Ułatwia to także uzyskanie przyszłych zmian dla podmodułu.

Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.