Git invert staging area

Question

I have got changes in my staging area, and others not staged yet (some files have changes both in and out the staging area). I would like to invert the content of the staging area and the changes which are not staged. Does a shortcut exist in order to do that, without doing more complex actions like local side-branch commits, or diffs, or stashes [etc.]? Thanks.

Answer 1

Here’s how I do it:

1. Commit the index to a temporary commit
2. Commit the remainder to a secondary temporary commit
3. Switch the order of the commits with interactive rebase
4. Mixed reset
5. Soft reset

It can be typed out manually pretty fast, especially if you use Vim for commit messages:

git commit -m tmp1
git add . # optionally with `git add -u` if there are deletions
git commit -m tmp2
git rebase -i HEAD~2 # swap the order of the commits; `ddp:wq` in vi
git reset HEAD~1
git reset HEAD~1 --soft

Answer 2

Based on gtd's answer and the ability to script inverting the commits this is what I'm using now:

[alias]                                                                                                                                                                                                              
    swaplast = !git tag _invert && git reset --hard HEAD~2 && git cherry-pick _invert _invert~1 && git tag -d _invert                                                                                            
    invertindex = !git commit -m tmp1 && git add -A && git commit -m tmp2 && git swaplast && git reset HEAD~1 && git reset HEAD~1 --soft

Posted on my blog here: http://blog.ericwoodruff.me/2013/12/inverting-git-index.html

Answer 3

There’s probably more than one way to do this, but I think I would take this approach – there’s currently no pre-built shortcut to this, but you could pretty easily write your own script to follow this process:

1. Generate a patch for the stuff that is currently in your working directory but not in your index yet (things you haven’t done git add for)

   git diff-files -p > /tmp/unstaged.patch
   

2. Generate a patch for what you’ve already added to the index against your current HEAD

   git diff-index --cached -p HEAD > /tmp/staged.patch
   

3. Reset your index and working directory to your HEAD

   git reset --hard HEAD
   

4. Apply your unstaged patch to both your working directory and your index, resulting in those changes being staged

   git apply --index /tmp/unstaged.patch
   

5. Apply your staged patch against only your working directory

   git apply /tmp/staged.patch
   

Depending on the exact nature of your changes, steps 4 and/or 5 may result in some merge conflicts that you need to resolve by hand, but I’m not sure there’s a clean way to completely avoid that possibility.

You could probably use git stash to accomplish steps 1 and 4 instead of the above commands, but I’m not sure that would really gain you anything…

Also, you may want to review the man pages for the git diff-* and git apply commands first to see if there are other options that might make sense for you to use.

Answer 4

This is what I use to solve this issue.

First git reset which will remove all the files from 'staging' to 'files not staged for commit'. The files that are in both 'staging' and 'files not staged for commit' will keep your most recent changes that are currently in your 'files not staged for commit'

then

git add /path/to/file the specific files you need to add to staging

Not exactly a short-cut, but it gets the job done

Inversely, After you git reset, you could git checkout /path/to/file for the files that are currently 'not staged for commit' which you don't want to add to staging. This will remove specific files from 'not staged to commit'

then run git add . which will add all files in 'not staged for commit' to 'staging' - whichever is easier for your situation