sous-module un sous-module git

378

Comment annuler le sous-module d'un sous-module git (ramener tout le code dans le noyau)?

Comme dans la façon dont «dois-je», comme dans «Meilleure procédure» ...

Quickredfox
la source
5
Remarque: avec git1.8.3, vous pouvez maintenant essayer un git submodule deinit, voir ma réponse ci
VonC
6
Je peux mal comprendre, mais git subminule deinit semble supprimer le code.
Joe Germuska
2
Depuis git 1.8.5 (novembre 2013), un simple git submodule deinit asubmodule ; git rm asubmodulesuffit, comme illustré dans ma réponse ci
VonC
envisager d'utiliser git subtree
HiB

Réponses:

527

Si tout ce que vous voulez est de mettre votre code de sous-module dans le référentiel principal, il vous suffit de supprimer le sous-module et de rajouter les fichiers dans le référentiel principal:

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"

Si vous souhaitez également conserver l'historique du sous-module, vous pouvez faire une petite astuce: "fusionner" le sous-module dans le référentiel principal afin que le résultat soit le même qu'avant, sauf que les fichiers du sous-module sont maintenant dans le référentiel principal.

Dans le module principal, vous devrez effectuer les opérations suivantes:

# 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

Le dépôt résultant aura l'air un peu bizarre: il y aura plus d'un commit initial. Mais cela ne causera aucun problème pour git.

Dans cette deuxième solution, vous aurez le gros avantage que vous pouvez toujours exécuter git blame ou git log sur les fichiers qui étaient à l'origine dans les sous-modules. En fait, ce que vous avez fait ici, c'est de renommer de nombreux fichiers dans un même référentiel, et git devrait le détecter automatiquement. Si vous rencontrez toujours des problèmes avec git log, essayez certaines options (--follow, -M, -C) qui permettent de mieux renommer / copier la détection.

gyim
la source
3
Je pense que je dois faire votre deuxième méthode (préservation de l'historique) sur certains git repos que j'ai. Pourriez-vous expliquer quelle partie des commandes ci-dessus provoque la fin des fichiers du sous-module dans le sous-répertoire? Est-ce que vous lorsque vous faites la fusion git apporte le fichier dans le répertoire de niveau supérieur (avec son historique) mais quand vous faites le git add submodule_path, il implicite fait un git mv pour chaque fichier?
Bowie Owens
5
Fondamentalement, oui. L'astuce est que git ne stocke pas les opérations de renommage: au lieu de cela, il les détecte en regardant les commits parents. S'il y a un contenu de fichier qui était présent dans la validation précédente, mais avec un nom de fichier différent, il est considéré comme un renommage (ou une copie). Dans les étapes ci-dessus, git mergegarantit qu'il y aura un "commit précédent" pour chaque fichier (sur l'un des deux "côtés" de la fusion).
gyim
6
Merci gyim, j'ai commencé un projet où je pensais qu'il était logique de diviser les choses en deux référentiels et de les relier avec des sous-modules. Mais maintenant, il semble trop conçu et je veux les combiner sans perdre mon histoire.
Bowie Owens
4
@theduke J'ai également eu ce problème. Il peut être corrigé en, avant de suivre ces étapes, en déplaçant tous les fichiers de votre référentiel de sous-modules dans une structure de répertoires avec le même chemin d' accès que le référentiel dans lequel vous êtes sur le point de fusionner: ie. si votre sous-module dans le référentiel principal est dans foo /, dans le sous-module, exécutez mkdir foo && git mv !(foo) foo && git commit.
Chris Down
35
Nécessaire à ajouter --allow-unrelated-historiespour forcer la fusion lors de la fausse fusion pendant que j'obtenais fatal: refusing to merge unrelated histories, plus ici: github.com/git/git/blob/master/Documentation/RelNotes/…
vaskort
72

Depuis git 1.8.5 (novembre 2013 ) ( sans conserver l'historique du sous-module ):

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

Cela va:

  • désenregistrer et décharger (c.-à-d. supprimer le contenu de ) le sous-module ( deinit, d'où lemv premier ),
  • nettoyer le .gitmodules pour vous ( rm),
  • et supprimez l' entrée spéciale représentant ce sous-module SHA1 dans l'index du référentiel parent (rm ).

Une fois le retrait du sous-module terminé (deinit et git rm), vous pouvez renommer le dossier en son nom d'origine et l'ajouter au dépôt git en tant que dossier normal.

Note: si le sous - module a été créé par un ancien Git (<1,8), vous devrez peut - être supprimer le imbriquée .gitdossier dans le sous - module lui - même, comme commenté par Simon Est


Si vous devez conserver l'historique du sous-module, voir la réponse de jsears , qui utilise .git filter-branch

VonC
la source
5
Cela le supprime réellement de l'arborescence de travail en 1.8.4 (mon répertoire de sous-module entier a été effacé).
Chris Down
@ChrisDown vous voulez dire, le deinitseul a nettoyé l'arbre de travail de votre sous-module?
VonC
Oui, il supprime tout le contenu du répertoire du sous-module.
Chris Down
2
@mschuett non, vous ne manquez rien: un sous-module ne contient pas de .git en premier lieu. Si c'était le cas pour vous, c'était un dépôt imbriqué, pas un sous-module. Cela explique pourquoi cette réponse ci-dessus ne s'appliquerait pas dans votre cas. Pour la différence entre les deux, voir stackoverflow.com/a/34410102/6309 .
VonC
1
@VonC Je suis actuellement sur 2.9.0.windows.1, mais les sous-modules peuvent avoir été créés il y a plusieurs années sur une version beaucoup plus ancienne de git, je ne suis pas sûr. Je pense que les étapes semblent fonctionner tant que je supprime ce fichier avant de faire l'ajout + validation final.
Simon East
67

J'ai créé un script qui traduira un sous-module dans un répertoire simple, tout en conservant tout l'historique des fichiers. Il ne souffre pas des git log --follow <file>problèmes dont souffrent les autres solutions. C'est aussi une invocation d'une ligne très simple qui fait tout le travail pour vous. Bonne chance.

Il s'appuie sur l'excellent travail de Lucas Jenß, décrit dans son article de blog " Intégrer un sous-module dans le référentiel parent ", mais automatise l'ensemble du processus et nettoie quelques autres cas d'angle.

Le dernier code sera maintenu avec des corrections de bugs sur github à https://github.com/jeremysears/scripts/blob/master/bin/git-submodule-rewrite , mais pour le bien du protocole de réponse stackoverflow, j'ai inclus le solution dans son intégralité ci-dessous.

Usage:

$ 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
jsears
la source
Ne fonctionne pas sur Ubuntu 16.04. J'ai envoyé une demande de retrait au dépôt Github.
qznc
1
Bonne prise, @qznc. Cela a été testé sur OSX. Je fusionnerai volontiers cela quand il passera sur les deux plates-formes.
jsears
@qznc Ubuntu 16.04 support fusionné et réponse mise à jour.
jsears
2
Ceci est la meilleure réponse, conserve toute l'histoire. Très agréable!
CharlesB
1
Travaillez tous sans erreurs dans Git Bash 2.20.1.1 sur Windows 10 avec la dernière version de github: curl https://raw.githubusercontent.com/jeremysears/scripts/master/bin/git-submodule-rewrite > git-submodule-rewrite.shet./git-submodule-rewrite.sh <submodule-name>
Alexey
32
  1. git rm --cached the_submodule_path
  2. retirer la section de sous-module de la .gitmodules fichier ou, s'il s'agit du seul sous-module, supprimez le fichier.
  3. faire un commit "sous-module supprimé xyz"
  4. git add the_submodule_path
  5. un autre commit "a ajouté la base de code de xyz"

Je n'ai pas encore trouvé de moyen plus simple. Vous pouvez compresser 3-5 en une seule étape via git commit -a- question de goût.

Marcel Jackwerth
la source
6
Devrait - il pas au .gitmoduleslieu de .submodules?
imz - Ivan Zakharyaschev
1
Ce ne devrait .gitmodulespas être le cas.submodules
Mkey
1
J'ai dû supprimer le .gitrépertoire du sous-module avant de git addtravailler sur le dossier du sous-module
Carson Evans
16

Beaucoup de réponses ici, mais toutes semblent trop complexes et ne font probablement pas ce que vous voulez. Je suis sûr que la plupart des gens veulent garder leur histoire.

Pour cet exemple, le dépôt principal sera [email protected]:main/main.gitet le dépôt de sous-module sera [email protected]:main/child.git. Cela suppose que le sous-module se trouve dans le répertoire racine du référentiel parent. Ajustez les instructions selon vos besoins.

Commencez par cloner le référentiel parent et supprimer l'ancien sous-module.

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

Nous allons maintenant ajouter les dépôts enfants en amont au référentiel principal.

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

L'étape suivante suppose que vous souhaitez déplacer les fichiers de la branche merge-prep dans le même emplacement que le sous-module était au-dessus, bien que vous puissiez facilement changer l'emplacement en changeant le chemin du fichier.

mkdir child

déplacer tous les dossiers et fichiers sauf le dossier .git dans le dossier enfant.

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

Maintenant, vous pouvez simplement fusionner vos fichiers dans la branche principale.

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

Regardez autour de vous et assurez-vous que tout a l'air bien avant de courir git push

La seule chose que vous devez vous rappeler maintenant est que git log ne suit pas par défaut les fichiers déplacés, mais en exécutant, git log --follow filenamevous pouvez voir l'historique complet de vos fichiers.

mschuett
la source
2
Je suis arrivé jusqu'à la finale git merge merge-prepet j'ai reçu l'erreur fatal: refusing to merge unrelated histories. Solution est la suivante: git merge --allow-unrelated-histories merge-prep.
humblehacker
@humblehacker merci j'ai ajouté un petit commentaire au cas où d'autres s'y retrouveraient également.
mschuett
1
La meilleure réponse pour garder l'historique du sous-module. Merci @mschuett
Anton Temchenko
Dans l'exemple ici, existe-t-il un moyen de récupérer les fichiers en amont dans le childrépertoire, vous n'avez donc pas à les déplacer plus tard? J'ai les mêmes noms de fichiers dans un sous-module et le référentiel principal ... donc je reçois juste un conflit de fusion car il essaie de fusionner les deux fichiers ensemble.
Skitterm
Peut-être, mais je ne le sais pas tout de suite.
Personnellement,
12

Il nous est arrivé que nous avons créé 2 référentiels pour 2 projets qui étaient tellement couplés qu'il n'était pas logique de les séparer, alors nous les avons fusionnés.

Je vais montrer comment fusionner les branches principales dans chaque première, puis je vais expliquer comment vous pouvez l'étendre à toutes les branches que vous avez, j'espère que cela vous aidera.

Si vous avez fait fonctionner le sous-module et que vous souhaitez le convertir en un répertoire en place, vous pouvez faire:

git clone project_uri project_name

Ici, nous faisons un clone propre pour travailler. Pour ce processus, vous n'avez pas besoin d'initialiser ou de mettre à jour les sous-modules, alors sautez-le simplement.

cd project_name
vim .gitmodules

Modifiez .gitmodulesavec votre éditeur préféré (ou Vim) pour supprimer le sous-module que vous prévoyez de remplacer. Les lignes que vous devez supprimer devraient ressembler à ceci:

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

Après avoir enregistré le fichier,

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

Ici, nous supprimons complètement la relation de sous-module afin que nous puissions créer mettre en place l'autre référentiel dans le projet.

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

Ici, nous récupérons le référentiel de sous-modules à fusionner.

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

Ici, nous commençons une opération de fusion des 2 référentiels, mais nous arrêtons avant de valider.

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

Ici, nous envoyons le contenu de master dans le sous-module au répertoire où il était avant de préfixer un nom de répertoire

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

Ici, nous terminons la procédure en validant les modifications de la fusion.

Après avoir terminé cela, vous pouvez pousser et recommencer avec n'importe quelle autre branche à fusionner, il suffit de retirer la branche dans votre référentiel qui recevra les modifications et de changer la branche que vous apportez dans les opérations de fusion et de lecture.

dvicino
la source
cela ne semble pas avoir conservé l'historique des fichiers du sous-module, je ne vois qu'un seul commit dans le journal git pour les fichiers ajoutés sousdirectory_of_submodule
Anentropic
@Anentropic Désolé pour le délai de réponse. Je viens de refaire la procédure complète (avec une petite correction). La procédure conserve l'historique complet, mais elle a un point de fusion, c'est peut-être pourquoi vous ne le trouvez pas. Si vous voulez voir l'historique du sous-module, faites simplement un "journal git", recherchez le commit de fusion (dans l'exemple est celui avec le message "nom-sous-module fait maintenant partie du projet principal"). Il aura 2 validations parentales (Fusion: sdasda asdasd), git log le deuxième commit et vous aurez tout votre historique de sous-module / maître là-bas.
dvicino
ma mémoire est floue maintenant mais je pense que j'ai pu obtenir l'historique des fichiers de sous-module fusionnés en faisant git log original_path_of_file_in_submoduleie le chemin enregistré dans le dépôt git pour le fichier (qui n'existe plus sur le système de fichiers) même si le fichier de sous-module vit maintenant àsubmodule_path/new_path_of_file
Anentropic le
Cela ne préserve pas très bien l'histoire, et aussi les chemins sont faux. Je pense que quelque chose comme un arbre-filtre est nécessaire mais je suis hors de ma profondeur ... essayant ce que j'ai trouvé ici: x3ro.de/2013/09/01/…
Luke H
Cette réponse est obsolète, stackoverflow.com/a/16162228/11343 (réponse VonC) fait la même chose mais en mieux
CharlesB
6

Voici une version légèrement améliorée (IMHO) de la réponse de @ gyim. Il fait un tas de changements dangereux dans la copie de travail principale, où je pense qu'il est beaucoup plus facile d'opérer sur des clones séparés et de les fusionner à la fin.

Dans un répertoire séparé (pour faciliter le nettoyage des erreurs et réessayer), consultez à la fois le référentiel supérieur et le sous-référentiel.

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

Modifiez d'abord le sous-référentiel pour déplacer tous les fichiers dans le sous-répertoire souhaité

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"

Prenez note de la TÊTE

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

Maintenant, supprimez le subrepo du référentiel principal

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"

Et enfin, juste les fusionner

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

Et.. Voila! En toute sécurité et sans aucune magie.

sans données
la source
... quelle réponse est-ce? Pourrait vouloir référencer le nom d'utilisateur ainsi que la première réponse peut changer au fil du temps.
Contango
@Contango réponse mise à jour. mais la meilleure réponse est toujours la meilleure réponse avec une avance de 400 points ;-)
données
Est-ce que cela fonctionne si le subrepo contient déjà un répertoire nommé subrepoavec des trucs dedans?
detly
Dans la dernière étape, j'obtiens l'erreur suivante: git merge $SUBREPO_HEAD fatal: refusing to merge unrelated historiesDois-je utiliser git merge $SUBREPO_HEAD --allow-unrelated-historiesdans ce cas? Ou devrait-il fonctionner sans et j'ai fait une erreur?
Ti-m
1
@ Ti-m Oui, c'est exactement le cas de la fusion de deux historiques qui ne partagent aucun commit. La garde contre les histoires indépendantes semble être nouvelle dans git depuis que j'ai écrit ceci; Je mettrai à jour ma réponse.
données le
3

Lorsque

git rm [-r] --cached submodule_path

Retour

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

Contexte: je l'ai fait rm -r .git*dans mes dossiers de sous-module avant de réaliser qu'ils devaient être dé-sous-modulés dans le projet principal auquel je venais de les ajouter. J'ai eu l'erreur ci-dessus lors du dé-sous-module de certains, mais pas tous. Quoi qu'il en soit, je les ai réparés en exécutant, (après, bien sûr, le 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"

Notez que cela ne préserve pas l'histoire.

brandones
la source
3

Sur la base de la réponse de VonC , j'ai créé un simple script bash qui fait cela. À addla fin, il doit utiliser des caractères génériques, sinon il annulera le précédent rmpour le sous-module lui-même. Il est important d'ajouter le contenu du répertoire du sous-module et de ne pas nommer le répertoire lui-même dans la addcommande.

Dans un fichier appelé git-integrate-submodule:

#!/usr/bin/env bash
mv "$1" "${1}_"
git submodule deinit "$1"
git rm "$1"
mv "${1}_" "$1"
git add "$1/**"
void.pointer
la source
0

J'ai trouvé plus pratique de récupérer (également?) Les données de validation locales du sous-module, car sinon je les perdrais. (Impossible de les pousser car je n'ai pas accès à cette télécommande). J'ai donc ajouté le sous-module / .git en tant que remote_origin2, récupéré les validations et fusionné à partir de cette branche. Je ne sais pas si j'ai toujours besoin de la télécommande du sous-module comme origine, car je ne suis pas encore assez familier avec git.

Rian Wouters
la source
0

Voici ce que j'ai trouvé le meilleur et le plus simple.

Dans le référentiel de sous-module, à partir de HEAD, vous souhaitez fusionner dans le référentiel principal:

  • git checkout -b "mergeMe"
  • mkdir "foo/bar/myLib/" (chemin identique à celui où vous voulez les fichiers sur le référentiel principal)
  • git mv * "foo/bar/myLib/" (déplacez tout dans le chemin)
  • git commit -m "ready to merge into main"

Retour au dépôt principal après avoir retiré le sous-module et effacé le chemin "foo / bar / myLib":

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

boom fait

histoires préservées

pas de soucis


Notez cela presque identique à certaines autres réponses. Mais cela suppose que vous possédez un dépôt de sous-module. Cela permet également d'obtenir facilement les futures modifications en amont du sous-module.

CommaToast
la source