Posso obter uma saída compatível com patches do git-diff?

Estou fazendo algo muito simples errado. Estou tentando preparar um arquivo de patch comum, para poder aplicar novamente algumas alterações:

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

Com o something_here espaço em branco , quase funciona, mas os nomes dos arquivos não estão corretos. Acho que estou perdendo alguma opção.

Na vida real, vou fazer uma mesclagem após o checkout, para que o patch possa falhar por lá, mas você vê no que estou entrando.

Edite Minha falha aqui por fazer a pergunta errada. A questão real é: eu quero salvar minhas alterações, fazer uma mesclagem e reaplicar as alterações, se possível? Perguntei da maneira errada, porque estou acostumado a usar o patch para resolver esse tipo de problema e git diffparecia que era isso que eu queria que eu fizesse.

Comentário de Charles Bailey teve a resposta certa. Para mim, o git-apply é a coisa certa a fazer (o git-stash parece mais pesado do que eu preciso, o rebasing e os pacotes estão definitivamente além do meu nível de habilidade atual.) Vou aceitar a resposta que Charles deu (porque você não pode aceitar um comentário). Obrigado por todas as sugestões.

Editar, 6 anos depois Como qualquer pessoa familiarizada com o assunto sabe, eu superestimei a dificuldade de git stash. Quase todos os dias, usarei a seguinte sequência:

$ git stash
$ git merge
$ git stash pop

Se você quiser usar o patch, precisará remover os a/ b/prefixos que o git usa por padrão. Você pode fazer isso com a --no-prefixopção (você também pode fazer isso com a -popção do patch ):

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

Geralmente, porém, é mais fácil usar o straight git diffe depois usar a saída para alimentar git apply.

Na maioria das vezes, tento evitar o uso de patches de texto. Geralmente, uma ou mais confirmações temporárias combinadas com rebase git stashe pacotes são mais fáceis de gerenciar.

Para o seu caso de uso, acho que stashé o mais apropriado.

# 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

Basta usar -p1: você precisará usar -p0o --no-prefixcaso de qualquer maneira, para que você possa deixar de fora o --no-prefixe usar -p1:

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

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

As diferenças do git têm um segmento de caminho extra anexado aos caminhos do arquivo. Você pode remover esta entrada no caminho especificando -p1 com patch, assim:

patch -p1 < save.patch

1. Eu salvo o diff do diretório atual (incluindo arquivos não confirmados) no HEAD atual.
2. Em seguida, você pode transportar o save.patcharquivo para qualquer lugar (incluindo arquivos binários).
3. Na máquina de destino, aplique o patch usando git apply <file>

Nota: também são os arquivos faseados no momento.

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

Um truque útil para evitar a criação de arquivos de patch temporários:

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