208

I am doing something very simple wrong. I'm trying to prepare an ordinary patch file, so I can reapply some changes:

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

With something_here blank it almost works, but the file names aren't right. I think I'm just I'm missing some option.

In real life, I am going to do a merge after the checkout, so the patch might fail there, but you see what I'm getting at.

Edit My fault here for asking the wrong question. The actual question is, I want to save my changes away, do a merge, then re-apply the changes, if possible? I asked it the wrong way because I am used to using patch to solve these sorts of problems and git diff looked like that's what it wanted me to do.

Charles Bailey's comment had the right answer. For me, git-apply is the right thing to do (git-stash looks more heavy-weight than I need and rebasing and bundles is definitely beyond my current skill level.) I'm going to accept the answer Charles gave (because you can't accept a comment). Thanks for all the suggestions.

Edit, 6 years later As anyone familiar with the subject knows, I over-estimated the difficulty of git stash. Pretty much every day or so, I will use the following sequence:

$ git stash $ git merge $ git stash pop

Edit, 5 years further down the road I have largely abandoned git apply and don’t even use git stash much. git rebase FTW.

Improve this question
8
  • 9
    Is there any reason you specifically want to use patch rather than git apply ? Commented Jan 6, 2011 at 0:41
  • 3
    And even then, do you really need patches rather than something like git stash or other git tools? Commented Jan 6, 2011 at 0:43
  • 3
    Post-edit, I think that git stash is the easiest solution for what you are trying to do, but there are lots of approaches that work. Commented Jan 6, 2011 at 1:26
  • 1
    @Malvolio: Indeed it is, you don't even have to think of a temporary file name to store your patch in. Commented Jan 6, 2011 at 12:15
  • 6
    @Charlse, sometimes you need to send a patch to someone without the entire git repository. For example if using git-svn. Commented Mar 29, 2011 at 8:27

5 Answers 5

Reset to default
272

Just use -p1: you will need to use -p0 in the --no-prefix case anyway, so you can just leave out the --no-prefix and use -p1:

$ git diff > save.patch $ patch -p1 < save.patch $ git diff --no-prefix > save.patch $ patch -p0 < save.patch
Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

If you're wondering why, the man docs sums it up nicely - source.
This won't work with renames; git diff outputs a line which patch ignores. git apply is the way to go.
158

If you want to use patch you need to remove the a/ b/ prefixes that git uses by default. You can do this with the --no-prefix option (you can also do this with patch's -p option):

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

Usually though, it is easier to use straight git diff and then use the output to feed to git apply.

Most of the time I try to avoid using textual patches. Usually one or more of temporary commits combined with rebase, git stash and bundles are easier to manage.

For your use case I think that stash is most appropriate.

# 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
Improve this answer

5 Comments

git diff --no-prefix master > diff.patch and then git checkout master patch -p0 < diff.patch
@Natim For ultimate safety I would recommend using patch --dry-run < diff.patch before issuing the last command.
@ᴠɪɴᴄᴇɴᴛ what would be the benefit of doing that? Since we are using git we are unlikely to loose anything isn't it?
@Natim As I said, just for ultimate safety, no need to undo anything in case of error. I was also thinking about people who read this and want to use patch outside of git (maybe using a patch file generated by diff) in a more general use case.
In order to include new files in your patch you need to also include "git diff --no-prefix --cached" in the patch. Maybe there's a better way?
16

The git diffs have an extra path segment prepended to the file paths. You can strip the this entry in the path by specifying -p1 with patch, like so:

patch -p1 < save.patch
Improve this answer

Comments

12
  1. I save the diff of the current directory (including uncommitted files) against the current HEAD.
  2. Then you can transport the save.patch file to wherever (including binary files).
  3. On your target machine, apply the patch using git apply <file>

Note: it diff's the currently staged files too.

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

3 Comments

Hahaha. That's funny. I asked this question almost four years ago and the way I have been doing this has evolved but if you had asked me yesterday how to do it, I would have given your answer and said I got it from answers to this question. (Actually I would probably use a bare git diff > save.patch and git checkout . instead of a reset, but yeah...
Oh didn't notice its 4 yrs old :P. Btw, the reset is just to demonstrate it works.. I also don't see anyone using git apply or making the diff relevant to your state and the pointer to the last commit available. Doing just git diff hasn't done anything at all
Yeah, now I wonder how I found out about git apply. The thing with git diff is (I think) from using git reset -- the relationships among the repo, the index, and the working area are the issue.
9

A useful trick to avoid creating temporary patch files:

git diff | patch -p1 -d [dst-dir]
Improve this answer

1 Comment

Exactly what I wanted. Also works perfectly with stashes! git stash show -p stash@{3} | patch -p1 -d [dst-dir]

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.