Status quo
Vamos a suponer que tenemos un repositorio llamada repo-oldque contiene un sub directorio sub que nos gustaría convertir en un sub módulo con su propio repo repo-sub.
Además, se pretende que el repositorio original repo-oldse convierta en un repositorio modificado repo-newdonde todas las confirmaciones que toquen el subdirectorio existente previamente apuntarán suba las confirmaciones correspondientes de nuestro repositorio de submódulos extraído repo-sub.
Cambiemos
Es posible lograr esto con la ayuda de git filter-branchun proceso de dos pasos:
- Extracción de subdirectorio de
repo-olda repo-sub(ya mencionado en la respuesta aceptada )
- Reemplazo de subdirectorio de
repo-olda repo-new(con el mapeo de compromiso adecuado)
Observación : Sé que esta pregunta es antigua y ya se ha mencionado que git filter-branchestá en desuso y podría ser peligrosa. Pero, por otro lado, podría ayudar a otros con repositorios personales que son fáciles de validar después de la conversión. ¡Así que ten cuidado ! ¡Y avíseme si hay alguna otra herramienta que haga lo mismo sin ser obsoleta y que sea segura de usar!
Explicaré cómo me di cuenta de ambos pasos en Linux con la versión 2.26.2 de git a continuación. Las versiones anteriores pueden funcionar hasta cierto punto, pero eso debe probarse.
En aras de la simplicidad, me limitaré al caso en el que solo hay una masterrama y un origincontrol remoto en el repositorio original repo-old. También tenga en cuenta que confío en las etiquetas git temporales con el prefijo temp_que se eliminarán en el proceso. Entonces, si ya hay etiquetas con nombres similares, es posible que desee ajustar el prefijo a continuación. Y, por último, tenga en cuenta que no he probado esto de forma exhaustiva y puede haber casos en los que la receta falle. ¡Así que haga una copia de seguridad de todo antes de continuar !
Los siguientes fragmentos de bash se pueden concatenar en un gran script que luego se debe ejecutar en la misma carpeta donde repo-orgreside el repositorio . ¡No se recomienda copiar y pegar todo directamente en una ventana de comando (aunque lo he probado con éxito)!
0. Preparación
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 filtro
# 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. Extracción de subdirectorios
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. Reemplazo de subdirectorio
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"
Observación: si el repositorio recién creado se repo-newcuelga durante git submodule update --init, intente volver a clonar el repositorio de forma recursiva una vez en su lugar:
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"