Empujando el código viejo al repository de git

Soy nuevo en git. Tengo un repository remoto de git en mi server que contiene el maestro, que es la versión actual de mi código. En mi computadora local tengo versiones antiguas (alnetworkingedor de 10) de este código almacenadas en otro lugar desde antes de usar el control de versiones (solo files sin formatting).

Aunque probablemente nunca vuelva a necesitar las versiones antiguas, me gustaría agregarlas al repository, así que si alguna vez quisiera verificar una versión anterior, podría hacerlo.

Entonces, ¿cómo hago esto? ¿Los agrego como twigs o tags y cómo debo agregarlos al repository remoto?

En este momento hago esto: simplemente elimine TODO el código de la versión actual (ya confirmado y enviado al server), copie y pegue los files de código anterior (digamos la versión 0.2) y cree una nueva twig (versión0.2), comprométala y luego presione al server. Ahora tengo 2 twigs, master y version0.2. ¿Debería ser esta la forma correcta?

Su sistema está bien, sin embargo, si el código antiguo realmente conduce a donde está el maestro, recomiendo unir todo en una sola twig una vez que todo el código esté en el repository. Estoy asumiendo que este es un repository privado y jugar con el maestro no va a afectar a nadie más (reescribir el historial en un repository público no es agradable).

Dicho esto, también supongo que tienes un montón de sucursales similares a las siguientes sucursales:

  1. v0.1
  2. v0.2
  3. v0.3
  4. dominar

En este caso, v0.1 es el más antiguo, v0.2 basado en v0.1, y así sucesivamente. Para hacer que master represente esto, sugiero rebasar las twigs en order para que al final el maestro contenga el código de todas las twigs. Los pasos para hacer esto son:

  1. git checkout v0.2
  2. git checkout -b REBASE_v0.2
    • Al crear una nueva twig, llamada REBASE, aquí no aplicamos la twig v0.2 original. Si algo sale mal, siempre podemos volver a la twig anterior.
  3. git rebase v0.1
  4. Resuelve cualquier conflicto
  5. Si eliminó cualquier file entre v0.1 y v0.2 git rm FILE cada file.
  6. git checkout v0.3
  7. git checkout -b REBASE_v0.3
  8. git rebase REBASE_v0.2
  9. Resuelve cualquier conflicto
  10. Si eliminó cualquier file entre v0.2 y v0.3 git rm FILE cada file.
  11. Enjuague y repita los pasos 6-10 para cualquier otra versión de las twigs que haya importado.
  12. git checkout master
  13. git checkout -b REBASE_master
  14. git rebase REBASE_v0.3
  15. Resuelve cualquier conflicto
  16. git diff master
    • Suponiendo que todos los conflictos se resolvieron correctamente, esto no debería mostrar diferencias.
  17. git checkout master
  18. git branch master_old
  19. git reset --hard REBASE_master
  20. git branch -D REBASE_v0.2 REBASE_v0.3 REBASE_master
    • Deshacerse de las twigs de rebase

Una vez que esté seguro de que todo está bien, puede continuar y deshacerse de las twigs originales: git branch -D v0.1 v0.2 v0.3 master_old

En este punto, debería tener una twig principal con su progresión de código real.

Lo que puedes hacer:

  1. Encuentre todas sus versiones anteriores y ordénelas por edad
  2. Crear un repository en el más antiguo y comprometer
  3. Reemplaza todos los files con la segunda versión más antigua y confirma
  4. Repite hasta que hayas confirmado todas las versiones
  5. Desde un clon de su repository remoto, extraiga este nuevo repository
  6. Resuelva el conflicto de combinación manteniendo la versión más nueva y confirme

O bien, si usted es el único usuario de su repository remoto, es aún más sencillo aplicar las confirmaciones más recientes del repository remoto sobre las versiones anteriores y replace el repository remoto.