Comment puis-je supprimer un sous-module?

Via la page tutoriel de sous-module Git :

pour supprimer un sous-module, vous devez:

1. supprimer la section pertinente du fichier .gitmodules .
"1519190920 de la" Scène .gitmodules modifications git add .gitmodules
2. supprimer la section pertinente de .git/config .
3. Exécuter git rm --cached path_to_submodule (pas de slash.)
4. Exécuter rm -rf .git/modules/path_to_submodule
5. Commit git commit -m "Removed submodule <name>"
6. supprimer les fichiers submodules Non tracés
   
   rm -rf path_to_submodule

Voir aussi : autres étapes au-dessous de .

juste une note. Depuis git 1.8.5.2, deux commandes feront:

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

comme @Mark Cheverton L'a souligné à juste titre, si la deuxième ligne n'est pas utilisée, même si vous avez enlevé le sous-module pour l'instant, le reste .git / modules / le dossier_submodule empêchera le même sous-module d'être ajouté ou remplacé à l'avenir. En outre, comme @VonC l'a mentionné, git rm fera la plupart du travail sur un sous-module.

--mise à jour (07/05/2017)--

juste pour clarifier, the_submodule est le chemin relatif du sous-module à l'intérieur du projet. Par exemple, c'est subdir/my_submodule si le sous-module est à l'intérieur d'un sous-répertoire subdir .

comme indiqué correctement dans les commentaires et autres réponses , les deux commandes (bien que fonctionnellement suffisantes pour supprimer un sous-module), ne laisser une trace dans la section [submodule "the_submodule"] de .git/config (à partir de juillet 2017), qui peut être supprimé en utilisant une troisième commande:

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

la majorité des réponses à cette question sont périmées, incomplètes ou inutilement complexes.

un sous-module cloné à l'aide de git 1.7.8 ou plus récent laissera au plus quatre traces de lui-même dans votre repo local. Le processus pour enlever ces quatre traces est donné par les trois commandes ci-dessous:

# 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

étapes Simples

1. supprimer les entrées de configuration:
   
   git config -f .git/config --remove-section submodule.$submodulename

git config -f .gitmodules --remove-section submodule.$submodulename
2. Supprimer répertoire de l'index:
   
   git rm --cached $submodulepath
3. Commit
4. supprimer les fichiers non utilisés:
   
   rm -rf $submodulepath

rm -rf .git/modules/$submodulename

s'il vous Plaît note: $submodulepath ne contient pas de leader ou de barres obliques.

arrière-plan

Quand vous faites git submodule add , il ajoute que .gitmodules , mais une fois que vous avez fait git submodule init , il a ajouté à .git/config .

Donc, si vous souhaitez supprimer les modules, mais être en mesure de restaurer rapidement, alors, faites ceci:

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

It est une bonne idée de faire git rebase HEAD d'abord et git commit à la fin, si vous le mettez dans un script.

aussi jeter un oeil à une réponse à est-ce que je peux désopuler un sous-module Git? .

en plus des recommandations, j'ai aussi eu à rm -Rf .git/modules/path/to/submodule pour pouvoir ajouter un nouveau sous-module avec le même nom (dans mon cas je remplaçais une fourchette avec l'original)

vous devez supprimer l'entrée dans .gitmodules et .git/config , et supprimer le répertoire du module de l'histoire:

git rm --cached path/to/submodule

si vous écrivez sur la liste de diffusion de git probablement quelqu'un fera un script shell pour vous.

pour supprimer un sous-module ajouté en utilisant:

git submodule add blah@blah.com:repos/blah.git lib/blah

Run:

git rm lib/blah

C'est ça.

Pour les anciennes versions de git (vers ~1.8.5):

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

vous pouvez utiliser un alias pour automatiser les solutions fournies par d'autres:

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

mettez ça dans votre git config, et ensuite vous pouvez faire: git rms path/to/submodule

pour résumer, voici ce que vous devez faire:

1. Set path_to_submodule var (no trailing slash):

   path_to_submodule=path/to/submodule

2. supprimer la ligne correspondante du .gitmodules fichier:

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

3. supprimer la section pertinente .git / config

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

4. Unstage et supprimer $path_to_submodule seulement à partir de l'index (pour éviter de perdre de l'information)

   git rm --cached $path_to_submodule

5. Suivi des modifications apportées .gitmodules

   git add .gitmodules

6. Commettre le superproject

   git commit -m "Remove submodule submodule_name"

7. Supprimer les fichiers submodules Non tracés

   rm -rf $path_to_submodule

   rm -rf .git/modules/$path_to_submodule

si le sous-module était accidentellement ajouté parce que vous avez ajouté, engagé et poussé un dossier qui était déjà un dépôt Git (contenu .git ), vous n'aurez pas de fichier .gitmodules à éditer, ou quoi que ce soit dans .git/config . dans ce cas, tout ce dont vous avez besoin est:

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

FWIW , j'ai aussi enlevé le dossier .git avant de faire le dossier git add .

après avoir expérimenté avec toutes les réponses différentes sur ce site, j'ai fini avec cette solution:

#!/bin/sh
path=""
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

cela rétablit le même état qu'avant l'ajout du sous-module. Vous pouvez ajouter les sous-module de nouveau, ce qui n'était pas possible avec la plupart des réponses ici.

git submodule add $giturl test
aboveScript test

cela vous laisse avec une caisse propre sans aucun changement à commettre.

ceci a été testé avec:

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

Ce que je fais actuellement Déc 2012 (combine la plupart de ces réponses):

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

j'ai trouvé deinit fonctionne bien pour moi:

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

à Partir de git docs :

deinit

ne pas enregistrer les sous-Règles données, c.-à-d. supprimer le tout submodule.$name la section de .git / config avec leur arbre de travail.

j'ai récemment découvert un projet git qui comprend de nombreuses commandes utiles liées à git: https://github.com/visionmedia/git-extras

installez-le et tapez:

git-delete-submodule submodule

alors les choses sont faites. Le répertoire submodule sera supprimé de votre repo et existera toujours dans votre système de fichiers. Vous pouvez alors effectuer le changement comme: git commit -am "Remove the submodule" .

voici ce que j'ai fait:

1.) Supprimer la section pertinente du .fichier gitmodules. Vous pouvez utiliser la commande suivante:

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

2.) Étape .gitmodules changements

git add .gitmodules

3.) Supprimer la section pertinente de .git/config . Vous pouvez utiliser la commande suivante:

git submodule deinit -f "submodule_name"

4.) Retirez le gitlink (pas de slash):

git rm --cached path_to_submodule

5.) Nettoyage le .git/modules :

rm -rf .git/modules/path_to_submodule

6. S'engagent:

git commit -m "Removed submodule <name>"

7.) Supprimer le maintenant sans traces sous-module fichiers

rm -rf path_to_submodule

J'ai dû prendre les pas de John Douthat un peu plus loin et cd dans le répertoire du sous-module, puis supprimer le dépôt Git:

cd submodule
rm -fr .git

alors je pourrais propager les fichiers en tant que partie du dépôt git parent sans l'ancienne référence à un sous-module.

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

je viens de trouver le .submodule (nom exact oublié) fichier caché, il a une liste... vous pouvez les effacer individuellement de cette façon. Je viens d'en prendre un, alors je l'ai effacé. C'est Simple, mais ça pourrait faire foirer Git, puisque je ne sais pas si quelque chose est attaché au sous-module. Semble ok jusqu'à présent, en dehors de la question de mise à niveau habituelle de libetpan, mais c'est (espérons-le) sans rapport.

N'a remarqué aucune effacement manuel, donc ajouté

Voici les 4 étapes que j'ai trouvé nécessaires ou utiles (importantes d'abord):

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

En théorie , git rm dans étape 1 doit prendre soin d'elle. Espérons que la deuxième partie de L'OP question pourra un jour recevoir une réponse positive (que cela puisse être fait en une seule commande).

mais à partir de juillet 2017, étape 2 est nécessaire pour supprimer les données dans .git/modules/ dans le cas contraire, vous ne pouvez pas par exemple ajouter le sous-module à l'avenir.

vous pouvez probablement vous en tirer avec les deux étapes ci-dessus pour git 1.8.5+ comme réponse de tinlyx noté, comme toutes les commandes git submodule semblent fonctionner.

L'Étape 3 supprime la section pour the_submodule dans le fichier .git/config . Cela devrait être fait pour l'exhaustivité. (L'entrée peut causer des problèmes pour les versions plus anciennes de git, mais je n'en ai pas un à tester).

pour cela, la plupart des réponses suggèrent d'utiliser git submodule deinit . Je trouve qu'il est plus explicite et moins déroutant d'utiliser git config -f .git/config --remove-section . Selon la documentation git-submodule , git deinit :

désinscrire Les sous-Règles données ... Si vous voulez vraiment supprimer un submodule du dépôt et commit qui utilisent git-rm[1] au lieu de .

Last mais surtout, si vous ne faites pas git commit , vous obtiendrez / pouvez obtenir une erreur en faisant git submodule summary (à partir de git 2.7):

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

peu importe que vous fassiez les étapes 2 ou 3.

si vous venez d'ajouter le sous-module, et par exemple, vous avez simplement ajouté le mauvais sous-module ou vous l'avez ajouté au mauvais endroit, faites simplement git stash puis supprimez le dossier. Cela suppose que l'ajout du sous-module est la seule chose que vous avez fait dans le récent repo.