nations unies-un sous-module sous-module git

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

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 aussi vous voulez préserver l'histoire de la sous-module, vous pouvez faire un petit truc: "fusionner" le sous-module dans le référentiel principal pour que le résultat sera le même qu'avant, sauf que le sous-module fichiers sont maintenant dans le référentiel principal.

Dans le module principal, vous aurez besoin de faire ce qui suit:

# 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

L'résultant référentiel aura l'air un peu bizarre: il n'y aura plus qu'une première validation. Mais il ne causera pas de problèmes pour git.

Dans cette deuxième solution, vous aurez le grand avantage que vous pouvez toujours exécuter git le blâme ou la commande git log sur les fichiers qui ont été à l'origine dans les submodules. En fait, ce que vous avez fait ici est de renommer de nombreux fichiers à l'intérieur d'un référentiel, et git doit détection automatique de la ce. Si vous avez toujours des problèmes avec la commande git log, essayer quelques options (--suivre, -M, -C), que faire de mieux renommer/copier détection.

J'ai créé un script qui va traduire un sous-module d'un simple répertoire, tout en conservant l'historique des fichiers. Il ne souffre pas de la git log --follow <file> questions que les autres solutions souffrent. Il est également très facile d'une seule ligne d'invocation qui fait tout le travail pour vous. G'luck.

Il s'appuie sur l'excellent travail de Lucas Jenß, décrit dans son blog "L'intégration d'un sous-module dans le dépôt parent", mais automatise l'ensemble du processus et nettoie les quelques autres cas de coin.

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

Utilisation:

$ git-submodule-rewrite <submodule-name>

git-sous-module-réécriture:

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

Beaucoup de réponses ici, mais tous semblent être excessivement complexe et probablement ne pas faire ce que vous voulez. Je suis sûr que la plupart des gens veulent garder leur histoire.

Pour cet exemple, les principaux repo sera [email protected]:main/main.git et le sous-module repo sera [email protected]:main/child.git. Cela suppose que le sous-module est situé dans le répertoire racine de la mère des pensions. Ajuster les instructions nécessaires.

Commencer par clonage de la mère repo et le retrait de 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"

Maintenant, nous allons ajouter le repos de l'enfant, en amont du principal repo.

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 voulez déplacer les fichiers sur la fusion de préparation de la branche dans le même emplacement que le sous-module a été ci-dessus bien que vous pouvez facilement changer l'emplacement en changeant le chemin d'accès au fichier.

mkdir child

déplacer tous les dossiers et fichiers à l'exception de l' .git dossier dans le dossier enfant.

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

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

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

Regardez autour de vous et assurez-vous tout semble bon avant d'exécuter git push

La seule chose que vous devez retenir, c'est maintenant que la commande git log n'est pas, par défaut, suivez les fichiers déplacés cependant, en cours d'exécution git log --follow filename vous pouvez voir l'historique complet de vos fichiers.

La meilleure réponse à ce que j'ai trouvé est ici:

http://x3ro.de/2013/09/01/Integrating-a-submodule-into-the-parent-repository.html

Cet article explique la procédure très bien.

Ici est un peu une version améliorée (à mon humble avis) de l'actuel haut de réponse:

Dans un autre répertoire (de faire des erreurs plus facile à nettoyer et essayer de nouveau) découvrez le haut de repo et de la subrepo.

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

D'abord modifier le subrepo pour déplacer tous les fichiers dans le répertoire désiré

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"

Faire une note de la TÊTE

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

Maintenant supprimer le subrepo de la principale repo

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
git merge $SUBREPO_HEAD

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

Je l'ai trouvé plus pratique (aussi?) extraction de validation des données de la sous-module, parce que sinon, je lâche eux. (Pas pu les pousser comme je n'ai pas accès à cette distance). J'ai donc ajouté des sous-module/.git comme remote_origin2, elle est extraite s'engage et fusionné à partir de cette branche.
Vous ne savez pas si j'ai encore besoin de le sous-module à distance de l'origine, puisque je ne suis pas assez familier avec git encore.