Crear parches de Git para dos files en varios renombrados

Quiero mover dos files de un repository a otro. Los files se agregaron originalmente como:

  1. /src/init/Price.cs
  2. /tests/init/PriceTests.cs

Los dos files fueron renombrados más tarde a:

  1. /src/init/PriceValue.cs
  2. /tests/init/PriceValueTests.cs

Y luego movido a:

  1. /src/moved/PriceValue.cs
  2. /tests/moved/PriceValueTests.cs

Intenté seguir esta descripción para crear un set de parches para estos files, pero no estoy seguro de cómo pasar las seis routes diferentes en las que han estado los files.

PriceValue.cs encontrar todas las identificaciones de compromiso que afectan a PriceValue.cs (a través de renombrados y movimientos), pero pasar esos ID a Git falla con el siguiente post de error:

 $ git format-patch -o /tmp/pricevaluepatches $(git log --all dfeeb 6966b 9f882 …) -bash: /usr/local/bin/git: Argument list too long 

Entonces, ¿cómo creo un set de parches para esto que solo contiene los cambios en los files mencionados, pero los contiene a través de un cambio de nombre y un movimiento de cada file?

Puede get los parches de algunos files específicos, pero no antes de cometer sha1 usando

 git format-patch sha1 -- file1 file2 ... 

Cualquiera de los files puede ser un file antiguo (antes de un cambio de nombre) o un file existente.

Si quieres todos los commits hasta commit sha1 , puedes usar

 git format-patch --root sha1 -- file1 file2 ... 

Entonces, en tu caso, todos los commits hasta ahora ( HEAD ) de tus seis files:

 git format-patch --root HEAD -- /src/init/Price.cs /src/init/PriceValue.cs /src/moved/PriceValue.cs /src/init/PriceTests.cs /src/init/PriceValueTests.cs /src/moved/PriceValueTests.cs 

Hmm … Suponiendo que quiero mantener los files de parche como están, lo que haría es get el file de parche aplicado en una twig para que pueda recogerlo en la twig derecha.

Entonces, supongamos que tengo en mi twig principal un file llamado /tests/moved/PriceValueTests.cs y quiero aplicarle un parche que tenga el nombre /tests/init/PriceTests.cs en su lugar. Asumiendo que no quiero hackear el file de parche, lo que haría es:

  • crear una twig temporal de mi maestro
  • sucursal temp de pago
  • cambie el nombre del file a la misma ruta que el file parche (y confirme, por supuesto)
  • aplicar el file de parche en la bifurcación temporal (debería funcionar ahora que la ruta del file tiene un file correspondiente)
  • cometer en una twig temporal
  • maestro de pago
  • escoge la última revisión desde la twig temporal

Esto es para que git pueda rastrear el cambio de nombre y poder aplicarlo con éxito. Lo he hecho varias veces y el algorithm de cambio de nombre de git tiende a hacerlo bien.

Para lograr el objective de la pregunta a través de una combinación (en lugar de un parche individual que se mueve a través del parche de formatting) se pueden eliminar todos los demás files en un nuevo compromiso y luego combinar ese compromiso entre repositorys en el repository de destino (adaptado de https : //stackoverflow.com/a/10548919/7496656 ):

 cd path/to/project-a git checkout -b for-b master # or whichever branch you want to merge from git rm -r . git checkout HEAD -- src/moved/PriceValue.cs tests/moved/PriceValueTests.cs git commit cd path/to/project-b git remote add project-a path/to/project-a git fetch project-a git merge --allow-unrelated-histories project-a/for-b git remote remove project-a cd path/to/project-a git branch -D for-b 

Esto tiene la ventaja de que todo el historial está allí, los ID de confirmación permanecen iguales y no hay necesidad de hacer malabares con las confirmaciones individuales ni de encontrarlas. Esto puede tener la desventaja de que una vista linealizada (como el git log ) en oposition a la vista de gráfico (como gitk ) probablemente se vuelva más confusa a medida que el número de compromisos no relacionados se hace mayor.

También se podría filtrar el project-a repository project-a antes de la fusión, para ocultar los files no relacionados o confirmaciones. Sin embargo, la desventaja de esto es: si haces esto en una combinación de repository más de una vez, posiblemente también en la otra dirección, hace que el historial sea less limpio ya que el historial común solo ocurre varias veces (una para cada combinación). Esto también haría que esta solución sea más difícil que la inicialmente probada. Esto también tendría la desventaja de que los ID de confirmación no permanecen iguales y, por lo tanto, no sería tan fácil encontrar cuál fue la misma confirmación en todos los repositorys.

Intereting Posts