Fusionando código no git con código basado en git (la base de código inicial es la misma)

Tengo un sitio de cliente que tiene una base de código singular. En mis cambios recientes, tomé la copy en vivo del website y lo envié en un nuevo repository GIT y comencé a hacer nuevas actualizaciones. Ahora hay otro desarrollador que ha realizado cambios en el sitio en vivo, por lo que me gustaría hacer algo que me permita tratar sus cambios como otra twig o algo así y combinar las diferencias sin problemas. ¿Cuál sería un enfoque adecuado para hacer esto? He considerado añadir el código a una nueva twig, y ​​también crear un parche diff y aplicarlo al código GIT también.

Supongo que hiciste algo como lo siguiente:

git init project cd project <copy existing code to this directory> git add -Af . git commit -m "Import code" <edited some files> git commit -a -m "Made changes" 

El mejor enfoque es crear una ramificación fuera de la confirmación de import original y hacer otra instantánea del sitio en vivo en esa twig. Supongamos que la confirmación de import original tiene una identificación de f00ba4 de f00ba4 (puede usar el git log para averiguar la identificación de SHA1 real). Para incorporar los cambios del otro desarrollador, puede hacer lo siguiente:

  1. Crea una nueva twig llamada en live apuntando para confirmar f00ba4, luego compruébalo:

     git checkout -b live f00ba4 
  2. Asegúrate de que no haya files sin seguir por ahí:

     git clean -dxf 
  3. Copie el último código del sitio en vivo

  4. Confirma el último código:

     git add -Af . git commit -m "take another snapshot of the live site" 
  5. Regrese a su sucursal:

     git checkout master 
  6. Incorpore los cambios del otro desarrollador con sus cambios:

     git merge live 

Cada vez que el otro desarrollador modifique los files en el sitio en vivo, puede actualizar su repository de la siguiente manera:

  1. Actualice la sucursal en live con el código más reciente:

     git checkout live git clean -dxf <copy the files from the live site> git add -Af . git commit -m "another snapshot of the live site" 
  2. Combina los cambios para live en el master :

     git checkout master git merge live 

Cuando esté listo para implementar sus cambios:

  1. Asegúrese de que la twig live esté actualizada:

     git checkout live git clean -dxf <copy the files from the live site> git add -Af . git commit -m "another snapshot of the live site" 
  2. Combina tus cambios en live :

     git merge master 
  3. Implementar los files en el sitio en vivo

Hacer una nueva twig y luego enviar sus cambios sería una buena manera de hacerlo.

Un mejor método sería conseguir que el otro desarrollador tenga su propia sucursal Git y luego simplemente integrarse entre sí.

La ramificación es el enfoque normal en Git. Eso significa: bifurque de su código actual, realice la fusión allí y, cuando lo logre, vuelva a fusionarlo en la twig principal.

La ramificación no se desvía de lo ordinario (como en SVN), sino que es parte del flujo de trabajo normal en Git. No es necesario que la edición de ese desarrollador interfiera con su trabajo: solo combine por separado y luego vuelva a fusionarse en la twig principal.