Merge git://git2.kernel.org/pub/scm/gitk/gitk into maint
[git] / git-checkout.sh
1 #!/bin/sh
2
3 USAGE='[-q] [-f] [-b <new_branch>] [-m] [<branch>] [<paths>...]'
4 SUBDIRECTORY_OK=Sometimes
5 . git-sh-setup
6 require_work_tree
7
8 old_name=HEAD
9 old=$(git-rev-parse --verify $old_name 2>/dev/null)
10 oldbranch=$(git-symbolic-ref $old_name 2>/dev/null)
11 new=
12 new_name=
13 force=
14 branch=
15 track=
16 newbranch=
17 newbranch_log=
18 merge=
19 quiet=
20 LF='
21 '
22 while [ "$#" != "0" ]; do
23     arg="$1"
24     shift
25     case "$arg" in
26         "-b")
27                 newbranch="$1"
28                 shift
29                 [ -z "$newbranch" ] &&
30                         die "git checkout: -b needs a branch name"
31                 git-show-ref --verify --quiet -- "refs/heads/$newbranch" &&
32                         die "git checkout: branch $newbranch already exists"
33                 git-check-ref-format "heads/$newbranch" ||
34                         die "git checkout: we do not like '$newbranch' as a branch name."
35                 ;;
36         "-l")
37                 newbranch_log=-l
38                 ;;
39         "--track"|"--no-track")
40                 track="$arg"
41                 ;;
42         "-f")
43                 force=1
44                 ;;
45         -m)
46                 merge=1
47                 ;;
48         "-q")
49                 quiet=1
50                 ;;
51         --)
52                 break
53                 ;;
54         -*)
55                 usage
56                 ;;
57         *)
58                 if rev=$(git-rev-parse --verify "$arg^0" 2>/dev/null)
59                 then
60                         if [ -z "$rev" ]; then
61                                 echo "unknown flag $arg"
62                                 exit 1
63                         fi
64                         new="$rev"
65                         new_name="$arg"
66                         if git-show-ref --verify --quiet -- "refs/heads/$arg"
67                         then
68                                 branch="$arg"
69                         fi
70                 elif rev=$(git-rev-parse --verify "$arg^{tree}" 2>/dev/null)
71                 then
72                         # checking out selected paths from a tree-ish.
73                         new="$rev"
74                         new_name="$arg^{tree}"
75                         branch=
76                 else
77                         new=
78                         new_name=
79                         branch=
80                         set x "$arg" "$@"
81                         shift
82                 fi
83                 case "$1" in
84                 --)
85                         shift ;;
86                 esac
87                 break
88                 ;;
89     esac
90 done
91
92 case "$newbranch,$track" in
93 ,--*)
94         die "git checkout: --track and --no-track require -b"
95 esac
96
97 case "$force$merge" in
98 11)
99         die "git checkout: -f and -m are incompatible"
100 esac
101
102 # The behaviour of the command with and without explicit path
103 # parameters is quite different.
104 #
105 # Without paths, we are checking out everything in the work tree,
106 # possibly switching branches.  This is the traditional behaviour.
107 #
108 # With paths, we are _never_ switching branch, but checking out
109 # the named paths from either index (when no rev is given),
110 # or the named tree-ish (when rev is given).
111
112 if test "$#" -ge 1
113 then
114         hint=
115         if test "$#" -eq 1
116         then
117                 hint="
118 Did you intend to checkout '$@' which can not be resolved as commit?"
119         fi
120         if test '' != "$newbranch$force$merge"
121         then
122                 die "git checkout: updating paths is incompatible with switching branches/forcing$hint"
123         fi
124         if test '' != "$new"
125         then
126                 # from a specific tree-ish; note that this is for
127                 # rescuing paths and is never meant to remove what
128                 # is not in the named tree-ish.
129                 git-ls-tree --full-name -r "$new" "$@" |
130                 git-update-index --index-info || exit $?
131         fi
132
133         # Make sure the request is about existing paths.
134         git-ls-files --error-unmatch -- "$@" >/dev/null || exit
135         git-ls-files -- "$@" |
136         git-checkout-index -f -u --stdin
137         exit $?
138 else
139         # Make sure we did not fall back on $arg^{tree} codepath
140         # since we are not checking out from an arbitrary tree-ish,
141         # but switching branches.
142         if test '' != "$new"
143         then
144                 git-rev-parse --verify "$new^{commit}" >/dev/null 2>&1 ||
145                 die "Cannot switch branch to a non-commit."
146         fi
147 fi
148
149 # We are switching branches and checking out trees, so
150 # we *NEED* to be at the toplevel.
151 cd_to_toplevel
152
153 [ -z "$new" ] && new=$old && new_name="$old_name"
154
155 # If we don't have an existing branch that we're switching to,
156 # and we don't have a new branch name for the target we
157 # are switching to, then we are detaching our HEAD from any
158 # branch.  However, if "git checkout HEAD" detaches the HEAD
159 # from the current branch, even though that may be logically
160 # correct, it feels somewhat funny.  More importantly, we do not
161 # want "git checkout" nor "git checkout -f" to detach HEAD.
162
163 detached=
164 detach_warn=
165
166 describe_detached_head () {
167         test -n "$quiet" || {
168                 printf >&2 "$1 "
169                 GIT_PAGER= git log >&2 -1 --pretty=oneline --abbrev-commit "$2"
170         }
171 }
172
173 if test -z "$branch$newbranch" && test "$new" != "$old"
174 then
175         detached="$new"
176         if test -n "$oldbranch" && test -z "$quiet"
177         then
178                 detach_warn="Note: moving to \"$new_name\" which isn't a local branch
179 If you want to create a new branch from this checkout, you may do so
180 (now or later) by using -b with the checkout command again. Example:
181   git checkout -b <new_branch_name>"
182         fi
183 elif test -z "$oldbranch"
184 then
185         describe_detached_head 'Previous HEAD position was' "$old"
186 fi
187
188 if [ "X$old" = X ]
189 then
190         if test -z "$quiet"
191         then
192                 echo >&2 "warning: You appear to be on a branch yet to be born."
193                 echo >&2 "warning: Forcing checkout of $new_name."
194         fi
195         force=1
196 fi
197
198 if [ "$force" ]
199 then
200     git-read-tree --reset -u $new
201 else
202     git-update-index --refresh >/dev/null
203     merge_error=$(git-read-tree -m -u --exclude-per-directory=.gitignore $old $new 2>&1) || (
204         case "$merge" in
205         '')
206                 echo >&2 "$merge_error"
207                 exit 1 ;;
208         esac
209
210         # Match the index to the working tree, and do a three-way.
211         git diff-files --name-only | git update-index --remove --stdin &&
212         work=`git write-tree` &&
213         git read-tree --reset -u $new || exit
214
215         eval GITHEAD_$new='${new_name:-${branch:-$new}}' &&
216         eval GITHEAD_$work=local &&
217         export GITHEAD_$new GITHEAD_$work &&
218         git merge-recursive $old -- $new $work
219
220         # Do not register the cleanly merged paths in the index yet.
221         # this is not a real merge before committing, but just carrying
222         # the working tree changes along.
223         unmerged=`git ls-files -u`
224         git read-tree --reset $new
225         case "$unmerged" in
226         '')     ;;
227         *)
228                 (
229                         z40=0000000000000000000000000000000000000000
230                         echo "$unmerged" |
231                         sed -e 's/^[0-7]* [0-9a-f]* /'"0 $z40 /"
232                         echo "$unmerged"
233                 ) | git update-index --index-info
234                 ;;
235         esac
236         exit 0
237     )
238     saved_err=$?
239     if test "$saved_err" = 0 && test -z "$quiet"
240     then
241         git diff-index --name-status "$new"
242     fi
243     (exit $saved_err)
244 fi
245
246
247 # Switch the HEAD pointer to the new branch if we
248 # checked out a branch head, and remove any potential
249 # old MERGE_HEAD's (subsequent commits will clearly not
250 # be based on them, since we re-set the index)
251 #
252 if [ "$?" -eq 0 ]; then
253         if [ "$newbranch" ]; then
254                 git-branch $track $newbranch_log "$newbranch" "$new_name" || exit
255                 branch="$newbranch"
256         fi
257         if test -n "$branch"
258         then
259                 GIT_DIR="$GIT_DIR" git-symbolic-ref -m "checkout: moving to $branch" HEAD "refs/heads/$branch"
260                 if test -n "$quiet"
261                 then
262                         true    # nothing
263                 elif test "refs/heads/$branch" = "$oldbranch"
264                 then
265                         echo >&2 "Already on branch \"$branch\""
266                 else
267                         echo >&2 "Switched to${newbranch:+ a new} branch \"$branch\""
268                 fi
269         elif test -n "$detached"
270         then
271                 # NEEDSWORK: we would want a command to detach the HEAD
272                 # atomically, instead of this handcrafted command sequence.
273                 # Perhaps:
274                 #       git update-ref --detach HEAD $new
275                 # or something like that...
276                 #
277                 git-rev-parse HEAD >"$GIT_DIR/HEAD.new" &&
278                 mv "$GIT_DIR/HEAD.new" "$GIT_DIR/HEAD" &&
279                 git-update-ref -m "checkout: moving to $arg" HEAD "$detached" ||
280                         die "Cannot detach HEAD"
281                 if test -n "$detach_warn"
282                 then
283                         echo >&2 "$detach_warn"
284                 fi
285                 describe_detached_head 'HEAD is now at' HEAD
286         fi
287         rm -f "$GIT_DIR/MERGE_HEAD"
288 else
289         exit 1
290 fi