Documentation / git-stash.txton commit Document git-stash (09ccdb6)
   1git-stash(1)
   2============
   3
   4NAME
   5----
   6git-stash - Stash the changes in a dirty working directory away
   7
   8SYNOPSIS
   9--------
  10[verse]
  11'git-stash'
  12'git-stash' [list | show [<stash>] | apply [<stash>] | clear]
  13
  14DESCRIPTION
  15-----------
  16
  17Use 'git-stash' when you want to record the current state of the
  18working directory and the index, but want to go back to a clean
  19working directory.  The command saves your local modifications away
  20and reverts the working directory to match the `HEAD` commit.
  21
  22The modifications stashed away by this command can be listed with
  23`git-stash list`, inspected with `git-stash show`, and restored
  24(potentially on top of a different commit) with `git-stash apply`
  25commands.  The default operation when called without options is to
  26save the changes away.
  27
  28The latest stash you created is stored in `$GIT_DIR/refs/stash`; older
  29stashes are found in the reflog of this refererence and can be named using
  30the usual reflog syntax (e.g. `stash@{1}` is the stash one previously made,
  31`stash@{2}` is the one before it, `stash@{2.hours.ago}` is also possible).
  32
  33OPTIONS
  34-------
  35
  36(no subcommand)::
  37
  38        Save your local modifications to a new 'stash', and run `git-reset
  39        --hard` to revert them.
  40
  41list::
  42
  43        List the stashes that you currently have.  Each 'stash' is listed
  44        with its name (e.g. `stash@{0}` is the latest stash, `stash@{1} is
  45        the one before), the name of the branch that was current when the
  46        stash was made, and a short description of the commit the stash was
  47        based on.
  48+
  49----------------------------------------------------------------
  50stash@{0}: submit: 6ebd0e2... Add git-stash
  51stash@{1}: master: 9cc0589... Merge branch 'master' of gfi
  52----------------------------------------------------------------
  53
  54show [<stash>]::
  55
  56        Show the changes recorded in the stash.  When no `<stash>` is given,
  57        shows the latest one.  By default, the command shows diffstat, but
  58        you can add `-p` option (i.e. `git stash show -p stash@{2}`) to view
  59        it in patch form.
  60
  61apply [<stash>]::
  62
  63        Restores the changes recorded in the stash on top of the current
  64        working tree state.  When no `<stash>` is given, applies the latest
  65        one.  The working directory must match the index.  When the changes
  66        conflict, you need to resolve them by hand and mark the result with
  67        `git add` as usual.  When the changes are cleanly merged, your
  68        earlier local changes stored in the stash becomes the differences
  69        between the index and the working tree (i.e. `git diff`), except
  70        that newly created files are registered in the index (i.e. `git diff
  71        --cached` is necessary to review the newly added files).
  72
  73clear::
  74        Removes all the stashed states.
  75
  76
  77DISCUSSION
  78----------
  79
  80A stash is represented as a commit whose tree records the state of the
  81working directory, and its first parent is the commit at `HEAD` when
  82the stash was created.  The tree of the second parent records the
  83state of the index when the stash is made, and it is made a child of
  84the `HEAD` commit.  The ancestry graph looks like this:
  85
  86            .----W
  87           /    /
  88     ...--H----I
  89
  90where `H` is the `HEAD` commit, `I` is a commit that records the state
  91of the index, and `W` is a commit that records the state of the working
  92tree.
  93
  94
  95EXAMPLES
  96--------
  97
  98Pulling into a dirty tree::
  99
 100When you are in the middle of something, you learn that there are
 101changes that possibly are relevant to what you are doing in the
 102upstream.  When your local changes do not conflict with the changes in
 103the upstream, a simple `git pull` will let you move forward.
 104+
 105However, there are cases in which your local changes do conflict with
 106the upstream changes, and `git pull` refuses to overwrite your
 107changes.  In such a case, you can first stash your changes away,
 108perform a pull, and then unstash, like this:
 109+
 110----------------------------------------------------------------
 111$ git pull
 112...
 113file foobar not up to date, cannot merge.
 114$ git stash
 115$ git pull
 116$ git stash apply
 117----------------------------------------------------------------
 118
 119Interrupted workflow::
 120
 121When you are in the middle of something, your boss comes in and
 122demands you to fix something immediately.  Traditionally, you would
 123make a commit to a temporary branch to store your changes away, and
 124come back to make the emergency fix, like this:
 125+
 126----------------------------------------------------------------
 127... hack hack hack ...
 128$ git checkout -b my_wip
 129$ git commit -a -m "WIP"
 130$ git checkout master
 131$ edit emergency fix
 132$ git commit -a -m "Fix in a hurry"
 133$ git checkout my_wip
 134$ git reset --soft HEAD^
 135... continue hacking ...
 136----------------------------------------------------------------
 137+
 138You can use `git-stash` to simplify the above, like this:
 139+
 140----------------------------------------------------------------
 141... hack hack hack ...
 142$ git stash
 143$ edit emergency fix
 144$ git commit -a -m "Fix in a hurry"
 145$ git stash apply
 146... continue hacking ...
 147----------------------------------------------------------------
 148
 149SEE ALSO
 150--------
 151gitlink:git-checkout[1],
 152gitlink:git-commit[1],
 153gitlink:git-reflog[1],
 154gitlink:git-reset[1]
 155
 156AUTHOR
 157------
 158Written by Nanako Shiraishi <nanako3@bluebottle.com>
 159
 160GIT
 161---
 162Part of the gitlink:git[7] suite