632d4fbb0c70f96dd2d72c54e45a60fe165d28cc
   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' list [<options>]
  12'git stash' show [<stash>]
  13'git stash' drop [-q|--quiet] [<stash>]
  14'git stash' ( pop | apply ) [--index] [-q|--quiet] [<stash>]
  15'git stash' branch <branchname> [<stash>]
  16'git stash' [save [-p|--patch] [-k|--[no-]keep-index] [-q|--quiet]
  17             [-u|--include-untracked] [-a|--all] [<message>]]
  18'git stash' clear
  19'git stash' create [<message>]
  20
  21DESCRIPTION
  22-----------
  23
  24Use `git stash` when you want to record the current state of the
  25working directory and the index, but want to go back to a clean
  26working directory.  The command saves your local modifications away
  27and reverts the working directory to match the `HEAD` commit.
  28
  29The modifications stashed away by this command can be listed with
  30`git stash list`, inspected with `git stash show`, and restored
  31(potentially on top of a different commit) with `git stash apply`.
  32Calling `git stash` without any arguments is equivalent to `git stash save`.
  33A stash is by default listed as "WIP on 'branchname' ...", but
  34you can give a more descriptive message on the command line when
  35you create one.
  36
  37The latest stash you created is stored in `refs/stash`; older
  38stashes are found in the reflog of this reference and can be named using
  39the usual reflog syntax (e.g. `stash@{0}` is the most recently
  40created stash, `stash@{1}` is the one before it, `stash@{2.hours.ago}`
  41is also possible).
  42
  43OPTIONS
  44-------
  45
  46save [-p|--patch] [--[no-]keep-index] [-u|--include-untracked] [-a|--all] [-q|--quiet] [<message>]::
  47
  48        Save your local modifications to a new 'stash', and run `git reset
  49        --hard` to revert them.  The <message> part is optional and gives
  50        the description along with the stashed state.  For quickly making
  51        a snapshot, you can omit _both_ "save" and <message>, but giving
  52        only <message> does not trigger this action to prevent a misspelled
  53        subcommand from making an unwanted stash.
  54+
  55If the `--keep-index` option is used, all changes already added to the
  56index are left intact.
  57+
  58If the `--include-untracked` option is used, all untracked files are also
  59stashed and then cleaned up with `git clean`, leaving the working directory
  60in a very clean state. If the `--all` option is used instead then the
  61ignored files are stashed and cleaned in addition to the untracked files.
  62+
  63With `--patch`, you can interactively select hunks from the diff
  64between HEAD and the working tree to be stashed.  The stash entry is
  65constructed such that its index state is the same as the index state
  66of your repository, and its worktree contains only the changes you
  67selected interactively.  The selected changes are then rolled back
  68from your worktree. See the ``Interactive Mode'' section of
  69linkgit:git-add[1] to learn how to operate the `--patch` mode.
  70+
  71The `--patch` option implies `--keep-index`.  You can use
  72`--no-keep-index` to override this.
  73
  74list [<options>]::
  75
  76        List the stashes that you currently have.  Each 'stash' is listed
  77        with its name (e.g. `stash@{0}` is the latest stash, `stash@{1}` is
  78        the one before, etc.), the name of the branch that was current when the
  79        stash was made, and a short description of the commit the stash was
  80        based on.
  81+
  82----------------------------------------------------------------
  83stash@{0}: WIP on submit: 6ebd0e2... Update git-stash documentation
  84stash@{1}: On master: 9cc0589... Add git-stash
  85----------------------------------------------------------------
  86+
  87The command takes options applicable to the 'git log'
  88command to control what is shown and how. See linkgit:git-log[1].
  89
  90show [<stash>]::
  91
  92        Show the changes recorded in the stash as a diff between the
  93        stashed state and its original parent. When no `<stash>` is given,
  94        shows the latest one. By default, the command shows the diffstat, but
  95        it will accept any format known to 'git diff' (e.g., `git stash show
  96        -p stash@{1}` to view the second most recent stash in patch form).
  97
  98pop [--index] [-q|--quiet] [<stash>]::
  99
 100        Remove a single stashed state from the stash list and apply it
 101        on top of the current working tree state, i.e., do the inverse
 102        operation of `git stash save`. The working directory must
 103        match the index.
 104+
 105Applying the state can fail with conflicts; in this case, it is not
 106removed from the stash list. You need to resolve the conflicts by hand
 107and call `git stash drop` manually afterwards.
 108+
 109If the `--index` option is used, then tries to reinstate not only the working
 110tree's changes, but also the index's ones. However, this can fail, when you
 111have conflicts (which are stored in the index, where you therefore can no
 112longer apply the changes as they were originally).
 113+
 114When no `<stash>` is given, `stash@{0}` is assumed, otherwise `<stash>` must
 115be a reference of the form `stash@{<revision>}`.
 116
 117apply [--index] [-q|--quiet] [<stash>]::
 118
 119        Like `pop`, but do not remove the state from the stash list. Unlike `pop`,
 120        `<stash>` may be any commit that looks like a commit created by
 121        `stash save` or `stash create`.
 122
 123branch <branchname> [<stash>]::
 124
 125        Creates and checks out a new branch named `<branchname>` starting from
 126        the commit at which the `<stash>` was originally created, applies the
 127        changes recorded in `<stash>` to the new working tree and index.
 128        If that succeeds, and `<stash>` is a reference of the form
 129        `stash@{<revision>}`, it then drops the `<stash>`. When no `<stash>`
 130        is given, applies the latest one.
 131+
 132This is useful if the branch on which you ran `git stash save` has
 133changed enough that `git stash apply` fails due to conflicts. Since
 134the stash is applied on top of the commit that was HEAD at the time
 135`git stash` was run, it restores the originally stashed state with
 136no conflicts.
 137
 138clear::
 139        Remove all the stashed states. Note that those states will then
 140        be subject to pruning, and may be impossible to recover (see
 141        'Examples' below for a possible strategy).
 142
 143drop [-q|--quiet] [<stash>]::
 144
 145        Remove a single stashed state from the stash list. When no `<stash>`
 146        is given, it removes the latest one. i.e. `stash@{0}`, otherwise
 147        `<stash>` must be a valid stash log reference of the form
 148        `stash@{<revision>}`.
 149
 150create::
 151
 152        Create a stash (which is a regular commit object) and return its
 153        object name, without storing it anywhere in the ref namespace.
 154        This is intended to be useful for scripts.  It is probably not
 155        the command you want to use; see "save" above.
 156
 157
 158DISCUSSION
 159----------
 160
 161A stash is represented as a commit whose tree records the state of the
 162working directory, and its first parent is the commit at `HEAD` when
 163the stash was created.  The tree of the second parent records the
 164state of the index when the stash is made, and it is made a child of
 165the `HEAD` commit.  The ancestry graph looks like this:
 166
 167            .----W
 168           /    /
 169     -----H----I
 170
 171where `H` is the `HEAD` commit, `I` is a commit that records the state
 172of the index, and `W` is a commit that records the state of the working
 173tree.
 174
 175
 176EXAMPLES
 177--------
 178
 179Pulling into a dirty tree::
 180
 181When you are in the middle of something, you learn that there are
 182upstream changes that are possibly relevant to what you are
 183doing.  When your local changes do not conflict with the changes in
 184the upstream, a simple `git pull` will let you move forward.
 185+
 186However, there are cases in which your local changes do conflict with
 187the upstream changes, and `git pull` refuses to overwrite your
 188changes.  In such a case, you can stash your changes away,
 189perform a pull, and then unstash, like this:
 190+
 191----------------------------------------------------------------
 192$ git pull
 193 ...
 194file foobar not up to date, cannot merge.
 195$ git stash
 196$ git pull
 197$ git stash pop
 198----------------------------------------------------------------
 199
 200Interrupted workflow::
 201
 202When you are in the middle of something, your boss comes in and
 203demands that you fix something immediately.  Traditionally, you would
 204make a commit to a temporary branch to store your changes away, and
 205return to your original branch to make the emergency fix, like this:
 206+
 207----------------------------------------------------------------
 208# ... hack hack hack ...
 209$ git checkout -b my_wip
 210$ git commit -a -m "WIP"
 211$ git checkout master
 212$ edit emergency fix
 213$ git commit -a -m "Fix in a hurry"
 214$ git checkout my_wip
 215$ git reset --soft HEAD^
 216# ... continue hacking ...
 217----------------------------------------------------------------
 218+
 219You can use 'git stash' to simplify the above, like this:
 220+
 221----------------------------------------------------------------
 222# ... hack hack hack ...
 223$ git stash
 224$ edit emergency fix
 225$ git commit -a -m "Fix in a hurry"
 226$ git stash pop
 227# ... continue hacking ...
 228----------------------------------------------------------------
 229
 230Testing partial commits::
 231
 232You can use `git stash save --keep-index` when you want to make two or
 233more commits out of the changes in the work tree, and you want to test
 234each change before committing:
 235+
 236----------------------------------------------------------------
 237# ... hack hack hack ...
 238$ git add --patch foo            # add just first part to the index
 239$ git stash save --keep-index    # save all other changes to the stash
 240$ edit/build/test first part
 241$ git commit -m 'First part'     # commit fully tested change
 242$ git stash pop                  # prepare to work on all other changes
 243# ... repeat above five steps until one commit remains ...
 244$ edit/build/test remaining parts
 245$ git commit foo -m 'Remaining parts'
 246----------------------------------------------------------------
 247
 248Recovering stashes that were cleared/dropped erroneously::
 249
 250If you mistakenly drop or clear stashes, they cannot be recovered
 251through the normal safety mechanisms.  However, you can try the
 252following incantation to get a list of stashes that are still in your
 253repository, but not reachable any more:
 254+
 255----------------------------------------------------------------
 256git fsck --unreachable |
 257grep commit | cut -d\  -f3 |
 258xargs git log --merges --no-walk --grep=WIP
 259----------------------------------------------------------------
 260
 261
 262SEE ALSO
 263--------
 264linkgit:git-checkout[1],
 265linkgit:git-commit[1],
 266linkgit:git-reflog[1],
 267linkgit:git-reset[1]
 268
 269GIT
 270---
 271Part of the linkgit:git[1] suite