Wie entferne ich ein Git-Submodul?

Gibt es übrigens einen Grund, den ich nicht einfach tun kann git submodule rm whatever?

Seit git1.8.3 (22. April 2013) :

Es gab keine Möglichkeit, mit Porzellan zu sagen "Ich interessiere mich nicht mehr für dieses Submodul", wenn Sie Ihr Interesse an einem Submodul mit " submodule init" zum Ausdruck gebracht haben .
" submodule deinit" ist der Weg dazu.

Der Löschvorgang wird ebenfalls verwendet git rm(seit git1.8.5 Oktober 2013).

Zusammenfassung

Der 3-stufige Entfernungsprozess wäre dann:

0. mv a/submodule a/submodule_tmp

1. git submodule deinit -f -- a/submodule    
2. rm -rf .git/modules/a/submodule
3. git rm -f a/submodule
# Note: a/submodule (no trailing slash)

# or, if you want to leave it in your working tree and have done step 0
3.   git rm --cached a/submodule
3bis mv a/submodule_tmp a/submodule

Erläuterung

rm -rf: Die in Rede ist Daniel Schroeder ‚s Antwort , und durch zusammengefasst Eonil in den Kommentaren :

Dies bleibt .git/modules/<path-to-submodule>/unverändert.
Wenn Sie also einmal ein Submodul mit dieser Methode löschen und erneut hinzufügen, ist dies nicht möglich, da das Repository bereits beschädigt ist.

git rm: Siehe Commit 95c16418 :

git rmWenn Sie derzeit " " für ein Submodul verwenden, werden der Arbeitsbaum des Submoduls aus dem des Superprojekts und der Gitlink aus dem Index entfernt.
Der Abschnitt des Submoduls in .gitmodulesbleibt jedoch unberührt. Dies ist ein Überbleibsel des jetzt entfernten Submoduls und kann Benutzer irritieren (im Gegensatz zum Einstellen .git/configmuss dies als Erinnerung bleiben, dass der Benutzer Interesse an diesem Submodul gezeigt hat, damit es später wieder aufgefüllt wird wenn ein älteres Commit ausgecheckt ist).

Lassen Sie " git rm" dem Benutzer helfen, indem Sie nicht nur das Submodul aus dem Arbeitsbaum entfernen, sondern auch den submodule.<submodule name>Abschnitt " " aus der .gitmodulesDatei entfernen und beides bereitstellen.

git submodule deinit: Es stammt aus diesem Patch :

Mit " git submodule init" kann der Benutzer git mitteilen, dass er sich für ein oder mehrere Submodule interessiert, und möchte, dass es beim nächsten Aufruf von " git submodule update" aufgefüllt wird.
Derzeit gibt es jedoch keine einfache Möglichkeit, Git zu sagen, dass sie sich nicht mehr für ein Submodul interessieren und den lokalen Arbeitsbaum entfernen möchten (es sei denn, der Benutzer weiß viel über Interna des Submoduls und entfernt die submodule.$name.urlEinstellung " " .git/configzusammen mit der Arbeit Baum selbst).

Helfen Sie diesen Benutzern, indem Sie einen deinitBefehl ' ' eingeben.
Dies entfernt den gesamten submodule.<name>Abschnitt .git/configentweder für die angegebenen Submodule ( oder für alle, die initialisiert wurden, wenn ' .' angegeben ist).
Fehler, wenn der aktuelle Arbeitsbaum Änderungen enthält, sofern dies nicht erzwungen wird.
Beschweren Sie sich, wenn für ein in der Befehlszeile angegebenes Submodul die URL-Einstellung nicht gefunden werden kann .git/config, aber dennoch nicht fehlschlägt.

Dies ist wichtig, wenn die (De-) Initialisierungsschritte ( .git/configund .git/modules/xxx)

Seit git1.8.5 git rmkümmert sich das auch um:

• ' add' Schritt, der die URL eines Submoduls in der .gitmodulesDatei aufzeichnet : Es muss für Sie entfernt werden.
• Der spezielle Submoduleintrag (wie in dieser Frage dargestellt ): Der Git rm entfernt ihn aus dem Index:
  git rm --cached path_to_submodule(kein abschließender Schrägstrich)
  Dadurch wird das im Index gespeicherte Verzeichnis mit einem speziellen Modus "160000" entfernt und als Submodul-Stammverzeichnis markiert .

Wenn Sie diesen letzten Schritt vergessen und versuchen, ein Submodul als reguläres Verzeichnis hinzuzufügen, wird folgende Fehlermeldung angezeigt:

git add mysubmodule/file.txt 
Path 'mysubmodule/file.txt' is in submodule 'mysubmodule'

Hinweis: Seit Git 2.17 (Q2 2018) ist das Git-Submodul deinit kein Shell-Skript mehr.
Es ist ein Aufruf einer C-Funktion.

Siehe Commit 2e61273 , Commit 1342476 (14. Januar 2018) von Prathamesh Chavan ( pratham-pc) .
^{(Zusammengeführt von Junio ​​C Hamano - gitster- in Commit ead8dbe , 13. Februar 2018)}

git ${wt_prefix:+-C "$wt_prefix"} submodule--helper deinit \
  ${GIT_QUIET:+--quiet} \
  ${prefix:+--prefix "$prefix"} \
  ${force:+--force} \
  ${deinit_all:+--all} "$@"

Über die Seite Git Submodule Tutorial :

Um ein Submodul zu entfernen, müssen Sie:

1. Löschen Sie den entsprechenden Abschnitt aus der .gitmodulesDatei.
2. Stellen Sie die .gitmodulesÄnderungen in Szene:
   git add .gitmodules
3. Löschen Sie den entsprechenden Abschnitt aus .git/config.
4. Entfernen Sie die Submodul-Dateien aus dem Arbeitsbaum und dem Index:
   git rm --cached path_to_submodule(kein abschließender Schrägstrich).
5. Entfernen Sie das .gitVerzeichnis des Submoduls :
   rm -rf .git/modules/path_to_submodule
6. Übernehmen Sie die Änderungen:
   git commit -m "Removed submodule <name>"
7. Löschen Sie die jetzt nicht verfolgten Submodul-Dateien:
   rm -rf path_to_submodule

Siehe auch : alternative Schritte unten .

Nur eine Notiz. Seit Git 1.8.5.2 reichen zwei Befehle aus:

git rm the_submodule
rm -rf .git/modules/the_submodule

Wie die Antwort von @Mark Cheverton richtig gezeigt hat, verhindert der verbleibende Ordner .git / modules / the_submodule, dass dasselbe Submodul in Zukunft wieder hinzugefügt oder ersetzt wird, wenn die zweite Zeile nicht verwendet wird, selbst wenn Sie das Submodul vorerst entfernt haben . Wie @VonC bereits erwähnt, erledigt er den git rmgrößten Teil der Arbeit auf einem Submodul.

--Update (07/05/2017) -

Zur Verdeutlichung the_submoduleist der relative Pfad des Submoduls innerhalb des Projekts. Zum Beispiel, subdir/my_submodulewenn sich das Submodul in einem Unterverzeichnis befindet subdir.

Wie in den Kommentaren und anderen Antworten richtig ausgeführt , hinterlassen die beiden Befehle (obwohl sie funktional ausreichen, um ein Submodul zu entfernen) im [submodule "the_submodule"]Abschnitt von .git/config(Stand Juli 2017) eine Spur , die mit einem dritten Befehl entfernt werden kann:

git config -f .git/config --remove-section submodule.the_submodule 2> /dev/null

Die meisten Antworten auf diese Frage sind veraltet, unvollständig oder unnötig komplex.

Ein mit git 1.7.8 oder neuer geklontes Submodul hinterlässt höchstens vier Spuren von sich selbst in Ihrem lokalen Repo. Der Vorgang zum Entfernen dieser vier Spuren wird durch die folgenden drei Befehle angegeben:

# Remove the submodule entry from .git/config
git submodule deinit -f path/to/submodule

# Remove the submodule directory from the superproject's .git/modules directory
rm -rf .git/modules/path/to/submodule

# Remove the entry in .gitmodules and remove the submodule directory located at path/to/submodule
git rm -f path/to/submodule

Einfache Schritte

1. Konfigurationseinträge entfernen:
   git config -f .git/config --remove-section submodule.$submodulename
git config -f .gitmodules --remove-section submodule.$submodulename
2. Verzeichnis aus dem Index entfernen:
   git rm --cached $submodulepath
3. Verpflichten
4. Nicht verwendete Dateien löschen:
   rm -rf $submodulepath
rm -rf .git/modules/$submodulename

Bitte beachten Sie: $submodulepath Enthält keine führenden oder nachfolgenden Schrägstriche.

Hintergrund

Wenn Sie dies tun git submodule add, wird es nur hinzugefügt .gitmodules, aber sobald Sie dies getan haben git submodule init, wird es hinzugefügt.git/config .

Wenn Sie also die Module entfernen möchten, diese aber schnell wiederherstellen können, gehen Sie wie folgt vor:

git rm --cached $submodulepath
git config -f .git/config --remove-section submodule.$submodulepath

Es ist eine gute Idee, git rebase HEADzuerst und zu tungit commit am Ende , wenn Sie dies in ein Skript einfügen.

Schauen Sie sich auch eine Antwort auf Kann ich ein Git-Submodul entvölkern? .

Zusätzlich zu den Empfehlungen musste ich rm -Rf .git/modules/path/to/submodulein der Lage sein, ein neues Submodul mit demselben Namen hinzuzufügen (in meinem Fall ersetzte ich eine Gabel durch das Original).

So entfernen Sie ein hinzugefügtes Submodul mit:

git submodule add [email protected]:repos/blah.git lib/blah

Lauf:

git rm lib/blah

Das ist es.

Für alte Versionen von git (ca. 1.8.5) verwenden Sie:

git submodule deinit lib/blah
git rm lib/blah
git config -f .gitmodules --remove-section submodule.lib/blah

Sie müssen den Eintrag in .gitmodulesund .git/configentfernen und das Verzeichnis des Moduls aus dem Verlauf entfernen:

git rm --cached path/to/submodule

Wenn Sie auf die Mailingliste von git schreiben, wird wahrscheinlich jemand ein Shell-Skript für Sie erstellen.

Sie können einen Alias ​​verwenden, um die von anderen bereitgestellten Lösungen zu automatisieren:

[alias]
  rms = "!f(){ git rm --cached \"$1\";rm -r \"$1\";git config -f .gitmodules --remove-section \"submodule.$1\";git config -f .git/config --remove-section \"submodule.$1\";git add .gitmodules; }; f"

Fügen Sie das in Ihre Git-Konfiguration ein, und dann können Sie Folgendes tun: git rms path/to/submodule

Zusammenfassend sollten Sie Folgendes tun:

1. Setze path_to_submodulevar (kein abschließender Schrägstrich):

   path_to_submodule=path/to/submodule

2. Löschen Sie die entsprechende Zeile aus der .gitmodules-Datei:

   git config -f .gitmodules --remove-section submodule.$path_to_submodule

3. Löschen Sie den entsprechenden Abschnitt aus .git / config

   git config -f .git/config --remove-section submodule.$path_to_submodule

4. Heben Sie die Bühne auf und entfernen Sie $ path_to_submodule nur aus dem Index (um den Verlust von Informationen zu vermeiden).

   git rm --cached $path_to_submodule

5. Verfolgen Sie Änderungen an .gitmodules

   git add .gitmodules

6. Übernehmen Sie das Superprojekt

   git commit -m "Remove submodule submodule_name"

7. Löschen Sie die jetzt nicht verfolgten Submodul-Dateien

   rm -rf $path_to_submodule

   rm -rf .git/modules/$path_to_submodule

Wenn das Submodul versehentlich hinzugefügt wurde, weil Sie einen Ordner hinzugefügt, festgeschrieben und verschoben haben, der bereits ein Git-Repository (enthalten .git) war, müssen Sie keine .gitmodulesDatei bearbeiten oder irgendetwas darin .git/config. In diesem Fall brauchen Sie nur:

git rm --cached subfolder
git add subfolder
git commit -m "Enter message here"
git push

FWIW , ich habe auch den .gitOrdner entfernt, bevor ich das gemacht habe git add.

Ich fand deinitWerke gut für mich:

git submodule deinit <submodule-name>    
git rm <submodule-name>

Aus Git-Dokumenten :

deinit

Heben Sie die Registrierung der angegebenen Submodule auf, dh entfernen Sie den gesamten submodule.$name Abschnitt zusammen mit ihrem Arbeitsbaum aus .git / config.

Nachdem ich mit all den verschiedenen Antworten auf dieser Site experimentiert hatte, kam ich zu folgender Lösung:

#!/bin/sh
path="$1"
if [ ! -f "$path/.git" ]; then
  echo "$path is no valid git submodule"
  exit 1
fi
git submodule deinit -f $path &&
git rm --cached $path &&
rm -rf .git/modules/$path &&
rm -rf $path &&
git reset HEAD .gitmodules &&
git config -f .gitmodules --remove-section submodule.$path

Dadurch wird der exakt gleiche Status wie vor dem Hinzufügen des Submoduls wiederhergestellt. Sie können das Submodul sofort wieder hinzufügen, was bei den meisten Antworten hier nicht möglich war.

git submodule add $giturl test
aboveScript test

Dadurch haben Sie eine saubere Kaufabwicklung, ohne dass Änderungen vorgenommen werden müssen.

Dies wurde getestet mit:

$ git --version
git version 1.9.3 (Apple Git-50)

Was ich gerade im Dezember 2012 mache (kombiniert die meisten dieser Antworten):

oldPath="vendor/example"
git config -f .git/config --remove-section "submodule.${oldPath}"
git config -f .gitmodules --remove-section "submodule.${oldPath}"
git rm --cached "${oldPath}"
rm -rf "${oldPath}"              ## remove src (optional)
rm -rf ".git/modules/${oldPath}" ## cleanup gitdir (optional housekeeping)
git add .gitmodules
git commit -m "Removed ${oldPath}"

Folgendes habe ich getan:

1.) Löschen Sie den entsprechenden Abschnitt aus der .gitmodules-Datei. Sie können den folgenden Befehl verwenden:

git config -f .gitmodules --remove-section "submodule.submodule_name"

2.) Führen Sie die .gitmodulesÄnderungen durch

git add .gitmodules

3.) Löschen Sie den entsprechenden Abschnitt aus .git/config. Sie können den folgenden Befehl verwenden:

git submodule deinit -f "submodule_name"

4.) Entfernen Sie den Gitlink (kein abschließender Schrägstrich):

git rm --cached path_to_submodule

5.) Bereinigen Sie die .git/modules:

rm -rf .git/modules/path_to_submodule

6.) Festschreiben:

git commit -m "Removed submodule <name>"

7.) Löschen Sie die jetzt nicht verfolgten Submodul-Dateien

rm -rf path_to_submodule

Ich habe kürzlich ein Git-Projekt herausgefunden, das viele nützliche git-bezogene Befehle enthält: https://github.com/visionmedia/git-extras

Installieren Sie es und geben Sie Folgendes ein:

git-delete-submodule submodule

Dann sind die Dinge erledigt. Das Submodulverzeichnis wird aus Ihrem Repo entfernt und ist weiterhin in Ihrem Dateisystem vorhanden. Sie können die Änderung dann wie folgt festschreiben : git commit -am "Remove the submodule".

Ich musste John Douthats Schritte einen Schritt weiter und cdin das Verzeichnis des Submoduls gehen und dann das Git-Repository entfernen:

cd submodule
rm -fr .git

Dann könnte ich die Dateien als Teil des übergeordneten Git-Repositorys ohne den alten Verweis auf ein Submodul festschreiben.

Hier sind die 4 Schritte, die ich für notwendig oder nützlich hielt (wichtige zuerst):

git rm -f the_submodule
rm -rf .git/modules/the_submodule
git config -f .git/config --remove-section submodule.the_submodule
git commit -m "..."

In der Theorie , git rmin Schritt 1 sollte sich darum kümmern. Hoffentlich kann der zweite Teil der OP-Frage eines Tages positiv beantwortet werden (dies kann in einem Befehl erfolgen).

Ab Juli 2017 ist jedoch Schritt 2 erforderlich, um Daten zu entfernen. .git/modules/Andernfalls können Sie das Submodul in Zukunft nicht mehr hinzufügen.

Sie können wahrscheinlich mit den obigen zwei Schritten für Git 1.8.5+ durchkommen, wie Tinlyx 'Antwort vermerkt hat, wie allegit submodule Befehle zu funktionieren scheinen.

Schritt 3 entfernt den Abschnitt für the_submodulein der Datei.git/config . Dies sollte der Vollständigkeit halber erfolgen. (Der Eintrag kann Probleme für ältere Git-Versionen verursachen, aber ich habe keine zum Testen).

Aus diesem Grund schlagen die meisten Antworten die Verwendung vor git submodule deinit. Ich finde es expliziter und weniger verwirrend zu benutzen git config -f .git/config --remove-section. Nach der git-Submodul Dokumentation , git deinit:

Heben Sie die Registrierung der angegebenen Submodule auf ... Wenn Sie wirklich ein Submodul aus dem Repository entfernen und festschreiben möchten, verwenden Sie stattdessen git-rm [1] .

Last but not least, wenn Sie dies nicht tun git commit, werden / können Sie dabei einen Fehler erhalten git submodule summary(ab Git 2.7):

fatal: Not a git repository: 'the_submodule/.git'
* the_submodule 73f0d1d...0000000:

Dies ist unabhängig davon, ob Sie die Schritte 2 oder 3 ausführen.

project dir:     ~/foo_project/
submodule:       ~/foo_project/lib/asubmodule
- - - - - - - - - - - - - - - - - - - - - - - - -
run:
  1.   cd ~/foo_project
  2.   git rm lib/asubmodule && 
          rm .git/modules/lib/asubmodule && 
            git submodule lib/asubmodule deinit --recursive --force

Ich habe gerade die versteckte Datei .submodule (vergessenen genauen Namen) gefunden, sie enthält eine Liste ... Sie können sie auf diese Weise einzeln löschen. Ich hatte gerade eine, also habe ich sie gelöscht. Einfach, aber es könnte Git durcheinander bringen, da ich nicht weiß, ob irgendetwas mit dem Submodul verbunden ist. Scheint bis jetzt in Ordnung zu sein, abgesehen von Libetpans üblichem Upgrade-Problem, aber das hat (hoffentlich) nichts damit zu tun.

Es wurde bemerkt, dass niemand ein manuelles Löschen gepostet hat, also hinzugefügt

Mit Git 2.17 und höher ist es nur:

git submodule deinit -f {module_name}
git add {module_name}
git commit

Wenn Sie gerade das Submodul hinzugefügt haben und beispielsweise einfach das falsche Submodul hinzugefügt haben oder es an der falschen Stelle hinzugefügt haben, git stashlöschen Sie einfach den Ordner. Dies setzt voraus, dass das Hinzufügen des Submoduls das einzige ist, was Sie im letzten Repo getan haben.

Zum Nutzen des Lesers wird hier versucht, dies zusammenzufassen und eine schrittweise Anleitung zu geben, wie dies zu tun ist, wenn die Dinge nicht wie erwartet funktionieren. Im Folgenden finden Sie die getestete und sichere Methode für gitVersionen 2.17und höher , um ein Submodul zu entfernen :

submodule="path/to/sub"              # no trailing slash!
git submodule deinit -- "$submodule"
git rm -- "$submodule"

• Wenn dies bei Ihnen nicht funktioniert, siehe unten.
• Keine Optionen. Nichts gefährliches. Und denken Sie nicht einmal daran, mehr zu tun!
• Getestet mit Debian Buster 2.20.1und Ubuntu 18.042.17.1 .
• "$submodule" ist nur zu betonen, wo der Name zu setzen ist, und dass Sie mit Leerzeichen und dergleichen vorsichtig sein müssen
• Wenn unter Windows, ignorieren Sie die erste Zeile und ersetzen Sie "$submodule"einen ordnungsgemäß angegebenen Pfad zum Submodul durch die Windows-Methode. (Ich bin nicht Windows)

Warnung!

Berühren Sie niemals die Innenseiten des .gitVerzeichnisses selbst! Innen bearbeiten.git betritt die dunkle Seite. Bleib um jeden Preis weg!

Und ja, Sie können dafür verantwortlich machen git, da viele nützliche Dinge fehltengit in der Vergangenheit . Wie ein richtiger Weg, um Submodule wieder zu entfernen.

Ich denke, es gibt einen sehr gefährlichen Teil in der Dokumentation von git submodule. Es wird empfohlen, sich zu entfernen $GIT_DIR/modules/<name>/. Nach meinem Verständnis ist dies nicht nur einfach falsch, es ist äußerst gefährlich und verursacht in Zukunft große Kopfschmerzen! Siehe unten.

Beachten Sie, dass

git module deinit

ist die direkte Umkehrung zu

git module init

aber

git submodule deinit -- module
git rm -- module

ist auch ganz umgekehrt

git submodule add -- URL module
git submodule update --init --recursive -- module

weil einige Befehle im Grunde mehr als nur eine einzige Sache tun müssen:

• git submodule deinit -- module
  • (1) Aktualisierungen .git/config
• git rm
  • (2) entfernt die Dateien des Moduls
  • (3) entfernt dadurch rekursiv die Submodule des Submoduls
  • (4) Aktualisierungen .gitmodules
• git submodule add
  • zieht die Daten ein .git/modules/NAME/
  • (1) tut git submodule init, also Updates.git/config
  • (2) git submodule updatecheckt das Modul also nicht rekursiv aus
  • (4) Aktualisierungen .gitmodules
• git submodule update --init --recursive -- module
  • zieht bei Bedarf weitere Daten ein
  • (3) prüft die Submodule des Submoduls rekursiv

Dies kann nicht vollständig symmetrisch sein, da es wenig sinnvoll ist, es streng symmetrisch zu halten. Es sind einfach nicht mehr als zwei Befehle erforderlich. Auch das "Abrufen der Daten" ist implizit, da Sie es benötigen. Das Entfernen der zwischengespeicherten Informationen wird jedoch nicht durchgeführt, da dies überhaupt nicht erforderlich ist und möglicherweise wertvolle Daten löscht.

Für Neulinge ist das wirklich rätselhaft, aber im Grunde ist es eine gute Sache: macht giteinfach das Offensichtliche und macht das richtig und versucht nicht einmal mehr zu tun. gitist ein Werkzeug, das einen zuverlässigen Job machen muss, anstatt nur eine andere "Eierlegende Wollmilchsau" zu sein ("Eierlegende Wollmilchsau" bedeutet für mich "eine böse Version eines Schweizer Taschenmessers").

Ich verstehe also Beschwerden von Menschen und sage: "Warum tut das nicht gitdas Offensichtliche für mich?" Dies liegt daran, dass "offensichtlich" hier vom Standpunkt abhängt. Zuverlässigkeit in jeder Situation ist weitaus wichtiger. Daher ist das, was für Sie oft offensichtlich ist, nicht in allen möglichen technischen Situationen das Richtige. Bitte denken Sie daran: AFAICSgit folgt dem technischen Weg, nicht dem sozialen. (Daher der kluge Name: git)

Wenn dies fehlschlägt

Die obigen Befehle können aus folgenden Gründen fehlschlagen:

• Dein gitist zu alt. Dann verwenden Sie eine neuere git. (Siehe unten, wie es geht.)
• Sie haben nicht festgeschriebene Daten und können Daten verlieren. Dann legen Sie sie besser zuerst fest.
• Ihr Submodul ist in gewissem git cleanSinne nicht sauber . Reinigen Sie dann zuerst Ihr Submodul mit diesem Befehl. (Siehe unten.)
• Sie haben in der Vergangenheit etwas getan, das von nicht unterstützt wird git. Dann bist du auf der dunklen Seite und die Dinge werden hässlich und kompliziert. (Möglicherweise wird das Problem durch die Verwendung eines anderen Computers behoben.)
• Vielleicht gibt es noch mehr Möglichkeiten zum Scheitern, die mir nicht bekannt sind (ich bin nur ein gitPower-User).

Mögliche Korrekturen folgen.

Verwenden Sie eine neuere git

Wenn Ihre Maschine zu alt ist, ist keine submodule deinitin Ihrer git. Wenn Sie Ihre nicht aktualisieren möchten (oder können), verwenden Sie giteinfach eine andere Maschine mit einer neueren git! gitsoll vollständig verteilt sein, sodass Sie einen anderen verwenden können git, um die Arbeit zu erledigen:

• workhorse:~/path/to/worktree$ git status --porcelain darf nichts ausgeben! Wenn ja, bereinigen Sie zuerst die Dinge!
• workhorse:~/path/to/worktree$ ssh account@othermachine
• othermachine:~$ git clone --recursive me@workhorse path/to/worktree/.git TMPWORK && cd TMPWORK
• Jetzt mach das Submodul-Zeug
• othermachine:~/TMPWORK$ git commit . -m . && exit
• workhorse:~/path/to/worktree$ git fetch account@othermachine:TMPWORK/.git
• workhorse:~/path/to/worktree$ git merge --ff-only FETCH_HEAD. Wenn dies nicht funktioniert, verwenden Siegit reset --soft FETCH_HEAD
• Jetzt bereinige Dinge, bis git statuses wieder sauber ist. Sie können dies tun, weil Sie es dank des ersten Schritts schon einmal sauber hatten.

Dies othermachinekann eine VM oder eine Ubuntu-WSL unter Windows sein. Sogar a chroot(aber ich gehe davon aus, dass Sie kein Root sind, denn wenn Sie es sind root, sollte es einfacher sein, auf das neuere zu aktualisieren git).

Beachten Sie ssh, dass es zahlreiche Möglichkeiten zum Transport von gitRepositorys gibt , wenn Sie nicht einsteigen können . Sie können Ihren Arbeitsbaum auf einen USB-Stick (einschließlich des .gitVerzeichnisses) kopieren und vom Stick klonen. Klonen Sie die Kopie, um die Dinge wieder sauber zu machen. Dies kann eine PITA sein, falls Ihre Submodule nicht direkt von einer anderen Maschine aus zugänglich sind. Aber auch dafür gibt es eine Lösung:

git config --add url.NEWURLPREFIX.insteadOf ORIGINALURLPREFIX

Sie können diese Multiplikation verwenden, und diese wird in gespeichert $HOME/.gitconfig . Etwas wie

git config --add 'url./mnt/usb/repo/.insteadof' https://github.com/

schreibt URLs wie neu

https://github.com/XXX/YYY.git

in

/mnt/usb/repo/XXX/YYY.git

Es ist einfach, wenn Sie sich an leistungsstarke gitFunktionen wie diese gewöhnen .

Bereinigen Sie die Dinge zuerst

Die manuelle Reinigung ist gut, da Sie auf diese Weise möglicherweise einige Dinge erkennen, die Sie vergessen haben.

• Wenn sich git über nicht gespeicherte Sachen beschwert, legen Sie sie fest und schieben Sie sie an einen sicheren Ort.
• Wenn git sich über einige Reste beschwert, git statusundgit clean -ixfd dein Freund ist
• Versuchen Sie eine der Optionen zu verzichten rmund deinitso lange wie möglich. Optionen (wie -f) für gitsind gut, wenn Sie ein Profi sind. Aber als Sie hierher kamen, sind Sie wahrscheinlich nicht so erfahren in der submoduleGegend. Also besser auf Nummer sicher gehen.

Beispiel:

$ git status --porcelain
 M two
$ git submodule deinit two
error: the following file has local modifications:
    two
(use --cached to keep the file, or -f to force removal)
fatal: Submodule work tree 'two' contains local modifications; use '-f' to discard them
$ cd two
$ git submodule deinit --all
error: the following file has local modifications:
    md5chk
(use --cached to keep the file, or -f to force removal)
fatal: Submodule work tree 'md5chk' contains local modifications; use '-f' to discard them
$ cd md5chk
$ git submodule deinit --all
error: the following file has local modifications:
    tino
(use --cached to keep the file, or -f to force removal)
fatal: Submodule work tree 'tino' contains local modifications; use '-f' to discard them
$ cd tino
$ git status --porcelain
?? NEW
$ git clean -i -f -d
Would remove the following item:
  NEW
*** Commands ***
    1: clean                2: filter by pattern    3: select by numbers    4: ask each
    5: quit                 6: help
What now> 1
Removing NEW
$ cd ../../..
$ git status --porcelain
$ git submodule deinit two
Cleared directory 'two'
Submodule 'someunusedname' (https://github.com/hilbix/src.git) unregistered for path 'two'

Sie sehen, es wird nicht -fbenötigt submodule deinit. Wenn die Dinge in gewissem git cleanSinne sauber sind . Beachten Sie auch, dass dies git clean -xnicht benötigt wird. Dies bedeutet, dass git submodule deinitnicht verfolgte Dateien, die ignoriert werden , bedingungslos entfernt werden. Dies ist normalerweise das, was Sie wollen, aber vergessen Sie es nicht. Manchmal sind ignorierte Dateien wertvoll, z. B. zwischengespeicherte Daten, deren erneute Berechnung Stunden bis Tage dauert.

Warum nie entfernen $GIT_DIR/modules/<name>/?

Wahrscheinlich möchten Benutzer das zwischengespeicherte Repository entfernen, weil sie Angst haben, später auf ein Problem zu stoßen. Dies ist wahr, aber auf dieses "Problem" zu stoßen, ist der richtige Weg, es zu lösen! Weil die Lösung einfach ist und richtig gemacht wird, können Sie glücklich leben. Dies vermeidet umständlichere Probleme als wenn Sie die Daten selbst entfernen.

Beispiel:

mkdir tmptest &&
cd tmptest &&
git init &&
git submodule add https://github.com/hilbix/empty.git two &&
git commit -m . &&
git submodule deinit two &&
git rm two &&
git commit -m . &&
git submodule add https://github.com/hilbix/src.git two

Die letzte Zeile gibt folgenden Fehler aus:

A git directory for 'two' is found locally with remote(s):
  origin    https://github.com/hilbix/empty.git
If you want to reuse this local git directory instead of cloning again from
  https://github.com/hilbix/src.git
use the '--force' option. If the local git directory is not the correct repo
or you are unsure what this means choose another name with the '--name' option.

Warum dieser Fehler? Weil .git/modules/two/zuvor von https://github.com/hilbix/empty.git ausgefüllt wurde und jetzt von etwas anderem neu ausgefüllt werden soll, nämlich https://github.com/hilbix/src.git . Sie werden dies nicht sehen, wenn Sie es erneut von https://github.com/hilbix/empty.git ausfüllen

Was nun? Nun, mach genau das, was dir gesagt wurde! Verwenden--name someunusedname

git submodule add --name someunusedname https://github.com/hilbix/src.git two

.gitmodules dann sieht es so aus

[submodule "someunusedname"]
    path = two
    url = https://github.com/hilbix/src.git

ls -1p .git/modules/ gibt

someunusedname/
two/

Auf diese Weise können Sie in Zukunft Zweige / Commit vorwärts und rückwärts wechseln und werden nie wieder in Schwierigkeiten geraten, two/da zwei verschiedene (und möglicherweise inkompatible) Upstream-Repositorys vorhanden sind. Und das Beste ist: Sie behalten beide auch lokal zwischengespeichert.

• Dies gilt nicht nur für Sie. Dies gilt auch für alle anderen Benutzer Ihres Repositorys.
• Und Sie verlieren nicht die Geschichte. Falls Sie vergessen haben, die neueste Version des alten Submoduls zu pushen, können Sie die lokale Kopie eingeben und dies später tun. Beachten Sie, dass es häufig vorkommt, dass jemand vergisst, einige Submodule zu pushen (da dies eine PITA für Neulinge ist, bis sie sich daran gewöhnt haben git).

Wenn Sie jedoch das zwischengespeicherte Verzeichnis entfernt haben, stoßen beide unterschiedlichen Kassen aufeinander, da Sie die --nameOptionen nicht verwenden , oder? Jedes Mal, wenn Sie zur Kasse gehen, müssen Sie das .git/modules/<module>/Verzeichnis möglicherweise immer wieder entfernen . Dies ist äußerst umständlich und macht es schwierig, so etwas zu verwenden git bisect.

Es gibt also einen sehr technischen Grund, dieses Modulverzeichnis als Platzhalter beizubehalten. Leute, die empfehlen, etwas unten zu entfernen, .git/modules/wissen es entweder nicht besser oder vergessen zu sagen, dass dies leistungsstarke Funktionen wie git bisectnahezu unmöglich macht, wenn dies eine solche Inkompatibilität mit Submodulen überschreitet.

Ein weiterer Grund ist oben gezeigt. Schau dir das an ls. Was siehst du dort?

Nun, die 2. Variante des Moduls two/ist nicht unter .git/modules/two/, es ist unter .git/modules/someunusedname/! Also sind Dinge wie git rm $module; rm -f .git/module/$modulevöllig falsch! Sie müssen entweder konsultieren module/.gitoder .gitmodulesdas Richtige zum Entfernen finden!

So fallen nicht nur die meisten anderen Antworten in diese gefährliche Falle, auch sehr beliebte gitErweiterungen hatten diesen Fehler ( er ist jetzt dort behoben )! Behalten Sie also besser das .git/Verzeichnis in der Hand, wenn Sie nicht genau wissen, was Sie tun!

Und aus philosophischer Sicht ist das Löschen der Geschichte immer falsch! Abgesehen von der Quantenmechanik , wie üblich, aber das ist etwas völlig anderes.

Zu Ihrer Information, Sie haben es wahrscheinlich erraten: hilbix ist mein GitHub-Account.

Zusammenfassend sollten Sie Folgendes tun:

Setze path_to_submodule var (kein abschließender Schrägstrich):

path_to_submodule=path/to/submodule

Löschen Sie die entsprechende Zeile aus der .gitmodules-Datei:

git config -f .gitmodules --remove-section submodule.$path_to_submodule

Löschen Sie den entsprechenden Abschnitt aus .git / config

git config -f .git/config --remove-section submodule.$path_to_submodule

Heben Sie die Bühne auf und entfernen Sie $ path_to_submodule nur aus dem Index (um zu verhindern, dass Informationen verloren gehen).

git rm --cached $path_to_submodule

Verfolgen Sie Änderungen an .gitmodules

git add .gitmodules

Übernehmen Sie das Superprojekt

git commit -m "Remove submodule submodule_name"

Löschen Sie die jetzt nicht verfolgten Submodul-Dateien

rm -rf $path_to_submodule

rm -rf .git/modules/$path_to_submodule

Siehe auch: Alternative Richtlinien

Das ist einfach:

1. Entfernen Sie den Abschnitt von .gitmodules
2. Anruf: git add .gitmodules
3. Anruf: git submodule deinit <path to submodule>
4. Anruf: git rm <path to submodule>
5. Commit und Push

Sie müssen die Moduldateien in Ihrem Projekt manuell löschen.

Ich habe ein Bash-Skript erstellt, um den Entfernungsprozess zu vereinfachen. Es wird auch geprüft, ob Änderungen im Repo nicht gespeichert wurden, und um Bestätigung gebeten. Es os xwäre interessant zu wissen, ob es auch unter gängigen Linux-Distributionen funktioniert:

https://gist.github.com/fabifrank/cdc7e67fd194333760b060835ac0172f

In der neuesten Version von Git sind nur 4 Operationen erforderlich, um das Git-Submodul zu entfernen.

• Entfernen Sie den entsprechenden Eintrag in .gitmodules
• Bühnenwechsel git add .gitmodules
• Entfernen Sie das Submodulverzeichnis git rm --cached <path_to_submodule>
• Verpflichte es git commit -m "Removed submodule xxx"

Falls Sie dies in einem einzeiligen Befehl mit dem Bash-Skript wie folgt tun müssen :

$ cd /path/to/your/repo && /bin/bash $HOME/remove_submodule.sh /path/to/the/submodule

Erstellen Sie eine Bash-Skriptdatei im $HOMEVerzeichnis mit dem Namen remove_submodule.sh:

#!/bin/bash

git config -f .gitmodules --remove-section submodule.$1
git config -f .git/config --remove-section submodule.$1
git rm --cached $1
git add .gitmodules
git commit -m "Remove submodule in $1"
rm -rf $1
rm -rf .git/modules/$1
git push origin $(git rev-parse --abbrev-ref HEAD) --force --quiet

• Ein Submodul kann durch Ausführen gelöscht werden git rm <submodule path> && git commit. Dies kann mit rückgängig gemacht werden git revert.
  • Durch das Löschen werden die Tracking-Daten des Superprojekts entfernt, die sowohl der Gitlink-Eintrag als auch der Abschnitt in der .gitmodulesDatei sind.
  • Das Arbeitsverzeichnis des Submoduls wird aus dem Dateisystem entfernt, das Git-Verzeichnis wird jedoch beibehalten, um das Auschecken früherer Commits zu ermöglichen, ohne dass ein Abruf aus einem anderen Repository erforderlich ist.
• Um ein Submodul vollständig zu entfernen, löschen Sie es zusätzlich manuell$GIT_DIR/modules/<name>/ .

Quelle: git help submodules

Git-Submodul entfernen

Um ein gitSubmodul zu entfernen, sind weniger als 4 Schritte erforderlich.

1. Entfernen Sie den entsprechenden Eintrag in der .gitmodulesDatei. Der Eintrag könnte wie unten erwähnt sein

[submodule "path_to_submodule"]
    path = path_to_submodule
    url = url_path_to_submodule

2. Bühnenwechsel git add .gitmodules
3. Entfernen Sie das Submodulverzeichnis git rm --cached <path_to_submodule>.
4. Übernehmen Sie es git commit -m "Removed submodule xxx"und drücken Sie.

Weitere 2 Schritte, die unten erwähnt werden, sind erforderlich, um das Submodul in einer lokal geklonten Kopie vollständig zu reinigen.

5. Entfernen Sie den entsprechenden Eintrag in der .git/configDatei. Der Eintrag könnte wie unten erwähnt sein

[submodule "path_to_submodule"]
    url = url_path_to_submodule

6. Tun rm -rf .git/modules/path_to_submodule

Diese 5. und 6. Schritte erzeugen keine Änderungen, die festgeschrieben werden müssen.