¿Puedo obtener una salida compatible con parches de git-diff?

Estoy haciendo algo muy simple mal. Estoy tratando de preparar un archivo de revisión normal, para poder volver a aplicar algunos cambios:

$ git diff > before
$ git diff something_here > save.patch
$ git checkout . 
$ patch < save.patch
$ git diff > after
$ diff before after
$

Con el something_here espacio en blanco casi funciona, pero los nombres de los archivos no son correctos. Creo que solo me falta alguna opción.

En la vida real, voy a hacer una fusión después del pago, por lo que el parche puede fallar allí, pero ya ves a lo que me refiero.

Edite Mi culpa aquí por hacer la pregunta incorrecta. La pregunta real es, ¿quiero guardar mis cambios, hacer una fusión y luego volver a aplicar los cambios, si es posible? Lo pregunté de manera incorrecta porque estoy acostumbrado a usar parches para resolver este tipo de problemas y git diffparecía que eso era lo que quería que hiciera.

El comentario de Charles Bailey tuvo la respuesta correcta. Para mí, git-apply es lo correcto (git-stash parece más pesado de lo que necesito y el rebase y los paquetes definitivamente están más allá de mi nivel de habilidad actual). Voy a aceptar la respuesta que Charles dio (porque usted No puedo aceptar un comentario). Gracias por todas las sugerencias.

Editar, 6 años después Como sabe cualquier persona familiarizada con el tema, sobreestimé la dificultad de git stash. Casi todos los días más o menos, usaré la siguiente secuencia:

$ git stash
$ git merge
$ git stash pop

Si desea usar el parche, debe eliminar los a/ b/prefijos que usa git de forma predeterminada. Puede hacerlo con la --no-prefixopción (también puede hacerlo con la -popción de parche ):

git diff --no-prefix [<other git-diff arguments>]

Por lo general, sin embargo, es más fácil usarlo directamente git diffy luego usar la salida para alimentarlo git apply.

La mayoría de las veces trato de evitar el uso de parches textuales. Por lo general, una o más confirmaciones temporales combinadas con rebase git stashy paquetes son más fáciles de administrar.

Para su caso de uso, creo que stashes lo más apropiado.

# save uncommitted changes
git stash

# do a merge or some other operation
git merge some-branch

# re-apply changes, removing stash if successful
# (you may be asked to resolve conflicts).
git stash pop

Solo use -p1: de todos modos, deberá usar -p0el --no-prefixestuche, por lo que puede omitir --no-prefixy usar -p1:

$ git diff > save.patch
$ patch -p1 < save.patch

$ git diff --no-prefix > save.patch
$ patch -p0 < save.patch

Los git diffs tienen un segmento de ruta adicional antepuesto a las rutas de archivo. Puede quitar esta entrada en la ruta especificando -p1 con parche, así:

patch -p1 < save.patch

1. Guardo el diff del directorio actual (incluidos los archivos no confirmados) contra el HEAD actual.
2. Luego puede transportar el save.patcharchivo a cualquier lugar (incluidos los archivos binarios).
3. En su máquina de destino, aplique el parche usando git apply <file>

Nota: también son los archivos almacenados actualmente.

$ git diff --binary --staged HEAD > save.patch
$ git reset --hard
$ <transport it>
$ git apply save.patch

Un truco útil para evitar crear archivos de parches temporales:

git diff | patch -p1 -d [dst-dir]