origin - ¿Cómo convertir un repositorio de GIT a un submódulo, que está anidado en otro repositorio de GIT(padre)?

git push

Question

Tengo un repositorio GIT que tiene subcarpetas como sub-supositorios GIT.

+ main (local GIT repo)
  + subdirectory1
     + plugin1 (created as local GIT repo)
     + plugin2 (created as local GIT repo)
  + subdirectory2
    + subdirectory2a
      + plugin3 (created as local GIT repo)
  + subdirectory3

El plugin1, plugin2, plugin3 son subcarpetas (subrepos) del repositorio principal de GIT. También plugin1, plugin2, plugin3 se iniciaron como repositorios GIT locales y se agregó contenido e historial.

Me gustaría convertir plugin1, plugin2, plugin3 GIT subrepos en submódulos o repositorio GIT principal.

Me gustaría hacer el desarrollo por separado en los complementos de repositorios GIT, pero aún mantener como subcarpetas, también aparecen como un enlace en el repositorio GIT principal. Yo uso GIT Extensions como GUI de control de versiones de desarrollo.

Answer 1

Cambie al directorio principal , revise la rama principal y realice el siguiente comando Git para crear un nuevo submódulo para plugin1:

git submodule add (url_to_plugin1_repository) subdirectory1/plugin1sm

Aquí el "url_to_plugin1_repository" apunta a su repositorio de Git actual para plugin1 . Se creará un nuevo directorio llamado subdirectorio1 / plugin1sm , que rastreará su repositorio remoto. Le he dado un nombre diferente para distinguirlo del directorio plugin1 que no es un submódulo. Tenga en cuenta que Git clonará los datos para el directorio plugin1sm de la url remota, en lugar de simplemente copiar de su local. Dicho esto, si tiene cambios sin compromiso en su repositorio de plugin1 local, debe confirmarlos y presionarlos antes de realizar el paso anterior.

En este punto, hacer un estado de git desde el directorio principal debería mostrar algo similar a lo siguiente:

$ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD ..." to unstage)
#
#   new file:   .gitmodules
#   new file:   subdirectory1/plugin1sm

Como se encuentra en el directorio principal , el nuevo submódulo aparece como un "archivo" en el conjunto de cambios. Puede confirmar este cambio con los siguientes comandos:

$ git add subdirectory1/plugin1sm
$ git commit -m "Created submodule for plugin1"
$ git push origin master

La siguiente pregunta que probablemente te surja es cómo usar el nuevo submódulo junto con tu repositorio principal de Git. Comencemos investigando qué sucede cuando trabajas en archivos dentro del directorio plugin1sm . Cuando trabajas dentro del directorio plugin1sm , Git hará un seguimiento de los cambios y se comportará como si no supiera nada fuera de ese directorio. Cuando llegue el momento de comprometerse e impulsar sus cambios, use los siguientes comandos esperados:

$ cd subdirectory1/plugin1sm
$ git add <yourfile>
$ git commit -m "modified my file"
$ git push

Pero, ¿qué pasa con el repositorio principal? Aquí es donde las cosas se ponen un poco interesantes. Como modificó su submódulo plugin1sm , se mostrará como un "archivo" modificado en el conjunto de cambios del repositorio principal. Para continuar, puede agregar el submódulo y presionarlo con los siguientes comandos:

$ cd ../../
$ git add subdirectory1/plugin1sm
$ git commit -m "updated my submodule"
$ git push origin master</code>

Para resumir, su flujo de trabajo básico de Git dentro de un submódulo seguirá su curso habitual, y dentro de su repositorio principal , deberá tener en cuenta que todo el submódulo aparecerá como un archivo. Las cosas se vuelven más complejas que el caso de uso simple que consideramos aquí, pero espero que esto te coloque en el camino correcto.

Puede repetir este procedimiento para los directorios plugin2 y plugin3 . Y cuando haya terminado de crear los submódulos, debería poder eliminar los directorios de plugin originales.

Answer 2

Hice un truco feo para resolver mi problema de submódulo en Git Extensions.
Tal vez no sea realmente válido, pero actualmente funciona.

cd main/subdirectory1/plugin2
git init
git status
git add .
git commit -m "Initial commit of Submodule."
git checkout -b dev     # create branch dev

git submodule add ./subdirectory1/plugin2 subdirectory1/plugin2

Add the following config text to w:/path/to/main/.git/config:
[submodule "subdirectory1/plugin2"]
    url = w:/path/to/main/subdirectory1/plugin2

Add the following config text to w:/path/to/main/.gitmodules (supporting Git Extensions to see submodule):
[submodule "subdirectory1/plugin2"]
    path = subdirectory1/plugin2
    url = w:/path/to/main/subdirectory1/plugin2
    branch = dev

Answer 3

Esta es la solución que finalmente parece funcionar bien para mí (en Windows, usando las extensiones de Git como interfaz de usuario):

Las siguientes acciones se realizan en línea de comando:

cd c:/!GIT/main     # main
git branch
git checkout dev-main

mkdir subdirectory1/plugin1
cd subdirectory1/plugin1
git init        # init git
git status      # show status
git add .       # stage
git commit -m "Initial commit"      # initial commit
git checkout -b "dev"       # create dev branch
git remote add origin ./subdirectory1/plugin1    # add remote path

# create submodule in main
cd ../..
git submodule add ./subdirectory1/plugin1 subdirectory1/plugin1  # create submodule
git submodule   # show submodules
git status
git add .       # stage submodule
git status
git commit -m "Submodule subdirectory1/plugin1"
git status
git config submodule.subdirectory1/plugin1.url ./subdirectory1/plugin1   # add relative path to config
git submodule   # show submodules

Answer 4

Mi respuesta tiene dos partes, Condiciones y Solución.

Parte I: Condiciones

Tenía el mismo problema, pero ya tenía un repositorio similar con la misma estructura, por ejemplo

Project1 (not a repo)
   |___ Repo1
   |___ Repo2

y:

Project2 (a repo)
   |___ Submodule1 (same repo as Repo1)
   |___ Submodule2 (same repo as Repo2)

Y quería convertir Repo1 y Repo2 en un submódulo de Project1 que básicamente es lo mismo que Project2. Para decir claramente, la clonación de Project2 no sería el truco porque había muchos más archivos en Project1 y Project2 que no eran lo mismo, pero para mantener las cosas simples ...

Así que mi .git/config Project1 se veía así

[core]
repositoryformatversion = 0
filemode = false
bare = false
logallrefupdates = true
symlinks = false
ignorecase = true

Y mi .git/config Project2 me gusta esto:

[core]
    repositoryformatversion = 0
    filemode = false
    bare = false
    logallrefupdates = true
    symlinks = false
    ignorecase = true
[submodule]
    active = .
[remote "origin"]
    url = ######
    fetch = +refs/heads/*:refs/remotes/origin/*
[branch "master"]
    remote = origin
    merge = refs/heads/master
[submodule "Submodule2"]
    url = ######
[submodule "Subodule2"]
    url = ######

y en Project2, había un archivo llamado .gitmodules:

Tenía el mismo problema, pero ya tenía un repositorio similar con la misma estructura, por ejemplo

Project1 (not a repo)
   |___ Repo1
   |___ Repo2

y:

Project2 (a repo)
   |___ Submodule1 (same repo as Repo1)
   |___ Submodule2 (same repo as Repo2)

Y quería convertir Repo1 y Repo2 en un submódulo de Project1 que básicamente es lo mismo que Project2. Para decir claramente, la clonación de Project2 no sería el truco porque había muchos más archivos en Project1 y Project2 que no eran lo mismo, pero para mantener las cosas simples ...

Así que mi .git/config Project1 se veía así:

[core]
    repositoryformatversion = 0
    filemode = false
    bare = false
    logallrefupdates = true
    symlinks = false
    ignorecase = true

Y mi .git/config Project2 me gusta esto:

[core]
    repositoryformatversion = 0
    filemode = false
    bare = false
    logallrefupdates = true
    symlinks = false
    ignorecase = true
[submodule]
    active = .
[remote "origin"]
    url = URL/TO/Project2
    fetch = +refs/heads/*:refs/remotes/origin/*
[branch "master"]
    remote = origin
    merge = refs/heads/master
[submodule "Path/To/Submodule2"]
    url = ######
[submodule "Path/To/Subodule2"]
    url = ######

y en Project2, había un archivo llamado .gitmodules:

[submodule "Path/To/Submodule1"]
    path = Path/To/Submodule1
    url = ######
    branch = master
[submodule "Path/To/Submodule2"]
    path = Path/To/Submodule2
    url = ######
    branch = master

Entonces lo que hay que hacer:

Parte II: Solución

1. Asegúrese de que los submódulos tengan el mismo nombre de carpeta

Project1 (not a repo) |___ Submodule1 |___ Submodule2

2. Luego copia Project2/.gitmodules en Project1/

3. Luego copie la parte del submódulo de contenido de .git/conif de .git/conif a .git/config Project1, que básicamente se vea como Project2, pero no anule [origen de "remoto"]:

Y mi .git/config Project1 así:

[core]
    repositoryformatversion = 0
    filemode = false
    bare = false
    logallrefupdates = true
    symlinks = false
    ignorecase = true
[submodule]
    active = .
[remote "origin"]
    *url = URL/TO/Project1*
    fetch = +refs/heads/*:refs/remotes/origin/*
[branch "master"]
    remote = origin
    merge = refs/heads/master
[submodule "Path/To/Submodule2"]
    url = ######
[submodule "Path/To/Subodule2"]
    url = ######