Status Quo
Supposons que nous ayons un référentiel appelé repo-oldqui contient un sous- répertoire sub que nous aimerions convertir en un sous- module avec son propre dépôt repo-sub.
Il est en outre prévu que le dépôt d'origine repo-oldsoit converti en un dépôt modifié repo-newoù tous les commits touchant le sous sub- répertoire existant précédemment pointeront maintenant vers les commits correspondants de notre repo de sous-module extrait repo-sub.
Changeons
Il est possible d'y parvenir à l'aide d' git filter-branchun processus en deux étapes:
- Extraction de sous-répertoire de
repo-oldvers repo-sub(déjà mentionné dans la réponse acceptée )
- Remplacement du sous-répertoire de
repo-oldà repo-new(avec un mappage de validation approprié)
Remarque : je sais que cette question est ancienne et qu'il a déjà été mentionné qu'elle git filter-branchest un peu obsolète et pourrait être dangereuse. Mais d'un autre côté, cela pourrait aider les autres avec des référentiels personnels faciles à valider après la conversion. Alors soyez prévenu ! Et s'il vous plaît laissez-moi savoir s'il existe un autre outil qui fait la même chose sans être obsolète et est sûr à utiliser!
Je vais vous expliquer comment j'ai réalisé les deux étapes sous linux avec la version 2.26.2 de git ci-dessous. Les versions plus anciennes peuvent fonctionner dans une certaine mesure, mais cela doit être testé.
Par souci de simplicité, je me limiterai au cas où il y a juste une masterbranche et une origintélécommande dans le repo d'origine repo-old. Sachez également que je compte sur des balises git temporaires avec le préfixe temp_qui seront supprimées dans le processus. Donc, s'il y a déjà des balises nommées de manière similaire, vous voudrez peut-être ajuster le préfixe ci-dessous. Et enfin, sachez que je n'ai pas testé cela de manière approfondie et qu'il peut y avoir des cas secondaires où la recette échoue. Veuillez donc tout sauvegarder avant de continuer !
Les extraits de code bash suivants peuvent être concaténés en un seul gros script qui doit ensuite être exécuté dans le même dossier où se trouve le dépôt repo-org. Il n'est pas recommandé de tout copier et coller directement dans une fenêtre de commande (même si j'ai testé cela avec succès)!
0. Préparation
Variables
# Root directory where repo-org lives
# and a temporary location for git filter-branch
root="$PWD"
temp='/dev/shm/tmp'
# The old repository and the subdirectory we'd like to extract
repo_old="$root/repo-old"
repo_old_directory='sub'
# The new submodule repository, its url
# and a hash map folder which will be populated
# and later used in the filter script below
repo_sub="$root/repo-sub"
repo_sub_url='https://github.com/somewhere/repo-sub.git'
repo_sub_hashmap="$root/repo-sub.map"
# The new modified repository, its url
# and a filter script which is created as heredoc below
repo_new="$root/repo-new"
repo_new_url='https://github.com/somewhere/repo-new.git'
repo_new_filter="$root/repo-new.sh"
Script de filtrage
# The index filter script which converts our subdirectory into a submodule
cat << EOF > "$repo_new_filter"
#!/bin/bash
# Submodule hash map function
sub ()
{
local old_commit=\$(git rev-list -1 \$1 -- '$repo_old_directory')
if [ ! -z "\$old_commit" ]
then
echo \$(cat "$repo_sub_hashmap/\$old_commit")
fi
}
# Submodule config
SUB_COMMIT=\$(sub \$GIT_COMMIT)
SUB_DIR='$repo_old_directory'
SUB_URL='$repo_sub_url'
# Submodule replacement
if [ ! -z "\$SUB_COMMIT" ]
then
touch '.gitmodules'
git config --file='.gitmodules' "submodule.\$SUB_DIR.path" "\$SUB_DIR"
git config --file='.gitmodules' "submodule.\$SUB_DIR.url" "\$SUB_URL"
git config --file='.gitmodules' "submodule.\$SUB_DIR.branch" 'master'
git add '.gitmodules'
git rm --cached -qrf "\$SUB_DIR"
git update-index --add --cacheinfo 160000 \$SUB_COMMIT "\$SUB_DIR"
fi
EOF
chmod +x "$repo_new_filter"
1. Extraction de sous-répertoires
cd "$root"
# Create a new clone for our new submodule repo
git clone "$repo_old" "$repo_sub"
# Enter the new submodule repo
cd "$repo_sub"
# Remove the old origin remote
git remote remove origin
# Loop over all commits and create temporary tags
for commit in $(git rev-list --all)
do
git tag "temp_$commit" $commit
done
# Extract the subdirectory and slice commits
mkdir -p "$temp"
git filter-branch --subdirectory-filter "$repo_old_directory" \
--tag-name-filter 'cat' \
--prune-empty --force -d "$temp" -- --all
# Populate hash map folder from our previously created tag names
mkdir -p "$repo_sub_hashmap"
for tag in $(git tag | grep "^temp_")
do
old_commit=${tag#'temp_'}
sub_commit=$(git rev-list -1 $tag)
echo $sub_commit > "$repo_sub_hashmap/$old_commit"
done
git tag | grep "^temp_" | xargs -d '\n' git tag -d 2>&1 > /dev/null
# Add the new url for this repository (and e.g. push)
git remote add origin "$repo_sub_url"
# git push -u origin master
2. Remplacement de sous-répertoire
cd "$root"
# Create a clone for our modified repo
git clone "$repo_old" "$repo_new"
# Enter the new modified repo
cd "$repo_new"
# Remove the old origin remote
git remote remove origin
# Replace the subdirectory and map all sliced submodule commits using
# the filter script from above
mkdir -p "$temp"
git filter-branch --index-filter "$repo_new_filter" \
--tag-name-filter 'cat' --force -d "$temp" -- --all
# Add the new url for this repository (and e.g. push)
git remote add origin "$repo_new_url"
# git push -u origin master
# Cleanup (commented for safety reasons)
# rm -rf "$repo_sub_hashmap"
# rm -f "$repo_new_filter"
Remarque: si le référentiel nouvellement créé se repo-newbloque pendant, git submodule update --initessayez de re-cloner le référentiel de manière récursive une fois à la place:
cd "$root"
# Clone the new modified repo recursively
git clone --recursive "$repo_new" "$repo_new-tmp"
# Now use the newly cloned one
mv "$repo_new" "$repo_new-bak"
mv "$repo_new-tmp" "$repo_new"
# Cleanup (commented for safety reasons)
# rm -rf "$repo_new-bak"