Comment supprimer un sous-module?

Comment supprimer un sous-module Git?

Au fait, y a-t-il une raison pour laquelle je ne peux pas simplement faire

git submodule rm whatever 

?

Depuis git1.8.3 (22 avril 2013) :

Il n’y avait pas de moyen de porcelaine de dire “je ne suis plus intéressé par ce sous-module”, une fois que vous exprimez votre intérêt pour un sous-module avec ” submodule init “.
submodule deinit ” est le moyen de le faire.

Le processus de suppression utilise également git rm (depuis git1.8.5 octobre 2013).

Résumé

Le processus de suppression en 3 étapes serait alors:

 0. mv a/submodule a/submodule_tmp 1. git submodule deinit -f -- a/submodule 2. rm -rf .git/modules/a/submodule 3. git rm -fa/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 

Explication

rm -rf : Ceci est mentionné dans la réponse de Daniel Schroeder , et résumé par Eonil dans les commentaires :

Cela laisse .git/modules// inchangé.
Donc, si vous supprimez une fois un sous-module avec cette méthode et que vous les rajoutez à nouveau, cela ne sera pas possible car le référentiel a déjà été corrompu.


git rm : Voir commit 95c16418 :

Actuellement, l’utilisation de ” git rm ” sur un sous-module supprime l’arborescence du sous-module de celle du superprojet et du gitlink de l’index.
Mais la section du sous-module dans .gitmodules est .gitmodules , ce qui est un rest du sous-module maintenant supprimé et peut irriter les utilisateurs (contrairement au paramètre dans .git/config , cela doit restr un rappel que l’utilisateur a montré de l’intérêt pour ce sous-module) il sera donc repeuplé plus tard quand un ancien commit sera extrait).

Laissez ” git rm ” aider l’utilisateur en retirant non seulement le sous-module de l’arborescence, mais aussi en supprimant la section ” submodule. ” du fichier .gitmodules et .gitmodules les deux en scène.


git submodule deinit : Il provient de ce patch :

Avec ” git submodule init “, l’utilisateur peut indiquer à git s’il se soucie d’un ou de plusieurs sous-modules et souhaite qu’il soit renseigné lors du prochain appel à ” git submodule update “.
Mais actuellement, il n’existe pas de moyen simple pour dire à git qu’ils ne se soucient plus d’un sous-module et veulent se débarrasser de l’arbre de travail local (à moins que l’utilisateur en sache beaucoup sur les sous-modules et supprime le submodule.$name.url ) réglage de .git/config avec l’arbre de travail lui-même).

Aidez ces utilisateurs en fournissant une commande ‘ deinit ‘.
Cela supprime l’intégralité de la section submodule. de .git/config pour les sous-modules donnés (ou pour tous ceux qui ont été initialisés si ‘ . ‘ Est donné).
Échec si l’arborescence de travail en cours contient des modifications, sauf si elle est forcée.
Se plaindre quand, pour un sous-module donné sur la ligne de commande, le paramètre url ne peut pas être trouvé dans .git/config , mais néanmoins ne pas échouer.

Cela prend soin si les étapes (de) initialisation ( .git/config et .git/modules/xxx )

Depuis git1.8.5, le git rm prend également en charge:

  • Etape ‘ add ‘ qui enregistre l’URL d’un sous-module dans le fichier .gitmodules : il faut la supprimer pour vous.
  • l’ entrée spéciale du sous-module (comme illustré par cette question ): le git rm le supprime de l’index:
    git rm --cached path_to_submodule (pas de barre oblique)
    Cela supprimera ce répertoire stocké dans l’index avec un mode spécial “160000”, le marquant comme un répertoire racine de sous-module.

Si vous oubliez cette dernière étape et que vous essayez d’append un sous-module en tant que répertoire normal, vous obtiendrez un message d’erreur tel que:

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

Note: depuis Git 2.17 (Q2 2018), git submodule deinit n’est plus un script shell.
C’est un appel à une fonction C.

Voir commettre 2e61273 , commettre 1342476 (14 janvier 2018) par Prathamesh Chavan ( pratham-pc ) .
(Fusionné par Junio ​​C Hamano – gitster – dans commit ead8dbe , 13 février 2018)

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

Via la page Git Submodule Tutorial :

Pour supprimer un sous-module, vous devez:

  1. Supprimez la section pertinente du fichier .gitmodules .
  2. .gitmodules scène les modifications de .gitmodules git add .gitmodules
  3. Supprimez la section correspondante de .git/config .
  4. Exécutez git rm --cached path_to_submodule (pas de barre oblique).
  5. Exécuter rm -rf .git/modules/path_to_submodule
  6. Commit git commit -m "Removed submodule "
  7. Supprimer les fichiers de sous-modules désormais non suivis
    rm -rf path_to_submodule

Voir aussi : autres étapes ci-dessous .

Juste une note. Depuis git 1.8.5.2, deux commandes vont faire:

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

Comme la réponse de @Mark Cheverton l’a correctement fait remarquer, si la deuxième ligne n’est pas utilisée, même si vous avez supprimé le sous-module pour l’instant, le rest du dossier .git / modules / the_submodule empêchera le retour ou le remplacement du même sous-module. . De plus, comme le mentionne @VonC, git rm fera le gros 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 se trouve dans un sous-répertoire du sous-répertoire.

Comme indiqué correctement dans les commentaires et autres réponses , les deux commandes (bien que fonctionnellement suffisantes pour supprimer un sous-module), laissent une trace dans la section [submodule "the_submodule"] de .git/config (juillet 2017). 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 obsolètes, incomplètes ou inutilement complexes.

Un sous-module cloné en utilisant git 1.7.8 ou plus récent laissera au plus quatre traces de lui-même dans votre repo local. Le processus de suppression de 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 le répertoire de l’index:
    git rm --cached $submodulepath
  3. Commettre
  4. Supprimer les fichiers inutilisés:
    rm -rf $submodulepath
    rm -rf .git/modules/$submodulename

Remarque: $submodulepath ne contient pas de barres obliques.

Contexte

Quand vous git submodule add , il ne l’ajoute qu’aux .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 capable de le restaurer rapidement, procédez comme suit:

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

C’est une bonne idée de faire git rebase HEAD premier et git commit à la fin, si vous le mettez dans un script.

Jetez également un oeil à une réponse à Puis-je dépeupler un sous-module Git? .

En plus des recommandations, je devais aussi rm -Rf .git/modules/path/to/submodule pour pouvoir append un nouveau sous-module avec le même nom (dans mon cas, je remplaçais une fourchette par l’original)

Vous devez supprimer l’entrée dans .gitmodules et .git/config et supprimer le répertoire du module de l’historique:

 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 

Courir:

 git rm lib/blah 

C’est tout.

Pour les anciennes versions de git (environ ~ 1.8.5), utilisez:

 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 \"$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" 

Mettez cela dans votre configuration git, et ensuite vous pouvez faire: git rms path/to/submodule

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

  1. Définissez path_to_submodule var (pas de barre oblique de fin):

    path_to_submodule=path/to/submodule

  2. Supprimez la ligne appropriée du fichier .gitmodules:

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

  3. Supprimer la section correspondante de .git / config

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

  4. Démonter et supprimer $ path_to_submodule uniquement de l’index (pour éviter de perdre des informations)

    git rm --cached $path_to_submodule

  5. Suivre les modifications apscopes aux modules .git

    git add .gitmodules

  6. Engager le superprojet

    git commit -m "Remove submodule submodule_name"

  7. Supprimer les fichiers de sous-modules désormais non suivis

    rm -rf $path_to_submodule

    rm -rf .git/modules/$path_to_submodule

Si le sous-module a été ajouté accidentellement parce que vous avez ajouté, validé et poussé un dossier qui était déjà un référentiel Git (contenu .git ), vous n’aurez aucun fichier .gitmodules à modifier ou quelque chose 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 également supprimé le dossier .git avant de faire le git add .

Après avoir expérimenté toutes les différentes réponses sur ce site, je me suis retrouvé avec cette solution:

 #!/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 

Cela restaure exactement le même état qu’avant l’ajout du sous-module. Vous pouvez tout de suite append à nouveau le sous-module, 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 modifications à valider.

Cela a été testé avec:

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

Ce que je fais actuellement en décembre 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é que deinit fonctionne bien pour moi:

 git submodule deinit  git rm  

De git docs :

deinit

Désinscrivez les sous-modules donnés, c’est-à-dire supprimez l’intégralité du submodule.$name Section du fichier .git / config avec leur arbre de travail.

J’ai récemment découvert un projet git qui inclut 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 du sous-module sera supprimé de votre repo et existera toujours dans votre système de fichiers. Vous pouvez ensuite valider le changement comme git commit -am "Remove the submodule" : git commit -am "Remove the submodule" .

Voici ce que j’ai fait :

1.) Supprimez la section correspondante du fichier .gitmodules. Vous pouvez utiliser la commande ci-dessous:

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

2.) .gitmodules scène les modifications de .gitmodules

 git add .gitmodules 

3.) Supprimez la section correspondante de .git/config . Vous pouvez utiliser la commande ci-dessous:

 git submodule deinit -f "submodule_name" 

4.) Supprimez le gitlink (pas de barre oblique de fin):

 git rm --cached path_to_submodule 

5.) .git/modules :

 rm -rf .git/modules/path_to_submodule 

6.) Commit:

 git commit -m "Removed submodule " 

7.) Supprimer les fichiers de sous-modules maintenant non suivis

 rm -rf path_to_submodule 

Je devais aller plus loin avec les étapes de John Douthat et cd dans le répertoire du sous-module, puis supprimer le repository Git:

 cd submodule rm -fr .git 

Ensuite, je pourrais valider les fichiers en tant que partie du référentiel 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 fichier caché .submodule (nom exact oublié), il contient une liste … vous pouvez les effacer individuellement. Je viens d’en avoir un, alors je l’ai supprimé. Simple, mais ça pourrait gâcher Git, puisque je ne sais pas si quelque chose est attaché au sous-module. Cela semble aller pour l’instant, mis à part le problème de mise à niveau habituel de libetpan, mais sans espoir.

Remarqué que personne n’a posté d’effacement manuel, donc ajouté

Voici les 4 étapes que j’ai trouvées nécessaires ou utiles (les premières importantes):

 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 à l’ étape 1 devrait en prendre soin. Si tout va bien, la deuxième partie de la question OP peut recevoir une réponse positive un jour (que cela peut être fait en une seule commande).

Mais en juillet 2017, l’ étape 2 est nécessaire pour supprimer des données dans .git/modules/ , sinon vous ne pourrez pas, par exemple, rappend le sous-module à l’avenir.

Vous pouvez probablement vous en sortir avec les deux étapes ci-dessus pour git 1.8.5+, comme l’a noté la réponse de tinlyx , car toutes les commandes du git submodule semblent fonctionner.

L’étape 3 supprime la section du sous- the_submodule dans le fichier .git/config . Cela devrait être fait pour être complet. (L’entrée peut causer des problèmes avec les anciennes versions de git, mais je n’en ai pas à tester).

Pour cela, la plupart des réponses suggèrent d’utiliser le git submodule deinit . Je trouve plus explicite et moins déroutant d’utiliser git config -f .git/config --remove-section . Selon la documentation de git deinit , git deinit :

Annuler l’inscription des sous-modules donnés … Si vous voulez vraiment supprimer un sous-module du référentiel et le valider, utilisez plutôt git-rm [1].

Last but not least, si vous ne git commit pas de git commit , vous obtiendrez une erreur lors de la git submodule summary (à partir de git 2.7):

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

Ceci est indépendamment du fait que vous fassiez les étapes 2 ou 3.

Si vous venez d’append le sous-module et, par exemple, que vous avez simplement ajouté le mauvais sous-module ou que vous l’avez ajouté au mauvais endroit, il vous suffit de git stash puis de supprimer le dossier. Cela suppose que l’ajout du sous-module est la seule chose que vous ayez faite dans le récent repository.