'git stash apply' with Interactive Mode

What I often do (in git bash) is

git stash show -p 'stash@{0}' >tmp.patch

Then I edit the file and remove the parts I don't want. Finally I say

<tmp.patch git apply

or

<tmp.patch patch -p1

It doesn't work for binary files, though, but neither does the accepted answer (using checkout -p) for them.

One possible way is to reset the index and then use interactive add

# 0. ensure there are no uncommitted changes
git status

# 1. apply a changeset as is
git stash apply stash@{n}
# ... fix or discard conflicts if any

# 2. reset the index 
git reset

# 3. interactively add the required chunks (except new files)
git add -p

# 4. stash all other changes
git stash save --keep-index "comment"
# 4. or just discards all other changes in the working tree
git checkout-index -f -a

# 5. commit
git commit -m "comment"

Another way is to use interactive reset in place of interactive add.

# 0. ensure the working tree does not have unstaged changes
git status

# 1. apply a changeset as is
git stash apply stash@{n}
# ... fix or discard conflicts if any

# 2. interactively exclude the unneeded chunks from the index 
git reset -p

# 3. stash all other changes
git stash save --keep-index "comment"
# 3. or just discards all other changes in the working tree
git checkout-index -f -a

# 4. commit
git commit -m "comment"

Is it possible?

Yes it is!

git checkout -p stash@{0}

Where you can replace the 0 in stash@{0} with the index of the stash you want to apply.

Use git stash list and git show -p stash@{n} if unsure which n is the stash you want to apply.

Don't forget to git stash drop stash@{n} when you know you won't need that stash anymore, since git checkout obviously will not drop the stash for you.

Why does it work?

The key is to realize that stashes are, in essence, references to commits just like tags and branches.

Indeed, they're stored in .git/refs/stash, one line per stash hash.

Caveats

As @mgadda mentioned in the comments below, git checkout -p tries to apply the whole difference between a commit and the current workspace.

In the case of a git stash, if the stash you're trying to apply was done against a different commit, then git checkout -p stash@{n} will try to apply interactively all the differences between the commit stash@{n} and the commit of the current workspace, including all their parent commits that are different.

For example, if you're trying to apply a stash that was saved "many commits ago" into the current workspace, git checkout -p stash@{n} will try to apply not only the changes in the stash proper, but will also try to revert all changes that happened between the commit on which the stash is based and the current commit.

Conversely, if you're trying to apply a stash "from the future", i.e. into a branch that is a number of commits from before the commit on which the stash is based, then git checkout -p stash@{n} will try to also apply all the other changes that happened between the current commit and the commit from the future, besides the changes from the stash itself.

(In case you're wondering, git checkout -p stash@{n} a stash from a parallel branch will try to revert all changes between the current commit and the original branching point and also apply all changes between the branching point and the other branch, besides the change in the stash).

Workarounds

There are a few workarounds, none of them are perfect for every situation:

• 1. Be really careful with the patches you accept when you do git checkout -p stash@{n}
• 2. Do a git stash pop, then git stash again before doing git checkout -p .... But if you wanted to do a partial apply of your stash to avoid conflicts, this won't really help. In that case, see solution 4 below.
• 3. If you have a graphical diff tool supported by git (like meld), you can use git difftool and "apply left" only the changes you're interested in:

  • git difftool -d stash@{n} to compare a whole stash and all its files

  • git difftool stash@{n} -- path/to/file to compare a single file

• 4. (Based on @andrew's answer) On a detached head, go back to the "parent" commit of the stash you're interested in, apply the stash, re-stash interactively only the parts you're interested in, go back and reapply the smaller stash.

Step by step:

git checkout stash@{n}^  # notice the "^". 

# Now you're in a detached head in the parent commit of the stash.
# It can be applied cleanly:
git stash apply stash@{n}

# Now save only the diffs you're interested in:
git stash -p

# remove the rest of the old stash
git checkout -- .  # be careful or you could remove unrelated changes

# go back to the branch where you want to apply the smaller stash
git checkout <my previous branch>

# apply the smaller stash
git stash pop