?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tg: avoid "not a valid object name" messages
[topgit/pro.git] / tg.sh
blob1bc8e4248071e7bece9c4f7097bf23faeb89b280
1 #!/bin/sh
2 # TopGit - A different patch queue manager
3 # Copyright (C) Petr Baudis <pasky@suse.cz> 2008
4 # Copyright (C) Kyle J. McKay <mackyle@gmail.com> 2014,2015,2016
5 # All rights reserved.
6 # GPLv2
7
8 TG_VERSION=0.19.7
9
10 # Update in Makefile if you add any code that requires a newer version of git
11 GIT_MINIMUM_VERSION="@mingitver@"
12
13 ## SHA-1 pattern
14
15 octet='[0-9a-f][0-9a-f]'
16 octet4="$octet$octet$octet$octet"
17 octet19="$octet4$octet4$octet4$octet4$octet$octet$octet"
18 octet20="$octet4$octet4$octet4$octet4$octet4"
19 nullsha="0000000000000000000000000000000000000000"
20 tab=' '
21 lf='
22 '
23
24 ## Auxiliary functions
25
26 # Preserves current $? value while triggering a non-zero set -e exit if active
27 # This works even for shells that sometimes fail to correctly trigger a -e exit
28 check_exit_code()
29 {
30 return $?
31 }
32
33 # This is the POSIX equivalent of which
34 cmd_path()
35 (
36 { "unset" -f command unset unalias "$1"; } >/dev/null 2>&1 || :
37 { "unalias" -a; } >/dev/null 2>&1 || :
38 command -v "$1"
39 )
40
41 # Output arguments without any possible interpretation
42 # (Avoid misinterpretation of '\' characters or leading "-n", "-E" or "-e")
43 echol()
44 {
45 printf '%s\n' "$*"
46 }
47
48 info()
49 {
50 echol "${TG_RECURSIVE}${tgname:-tg}: $*"
51 }
52
53 warn()
54 {
55 info "warning: $*" >&2
56 }
57
58 err()
59 {
60 info "error: $*" >&2
61 }
62
63 die()
64 {
65 info "fatal: $*" >&2
66 exit 1
67 }
68
69 # shift off first arg then return "$*" properly quoted in single-quotes
70 # if $1 was '' output goes to stdout otherwise it's assigned to $1
71 # the final \n, if any, is omitted from the result but any others are included
72 v_quotearg()
73 {
74 _quotearg_v="$1"
75 shift
76 set -- "$_quotearg_v" \
77 "sed \"s/'/'\\\\\\''/g;1s/^/'/;\\\$s/\\\$/'/;s/'''/'/g;1s/^''\\(.\\)/\\1/\"" "$*"
78 unset _quotearg_v
79 if [ -z "$3" ]; then
80 if [ -z "$1" ]; then
81 echo "''"
82 else
83 eval "$1=\"''\""
84 fi
85 else
86 if [ -z "$1" ]; then
87 printf "%s$4" "$3" | eval "$2"
88 else
89 eval "$1="'"$(printf "%s$4" "$3" | eval "$2")"'
90 fi
91 fi
92 }
93
94 # same as v_quotearg except there's no extra $1 so output always goes to stdout
95 quotearg()
96 {
97 v_quotearg '' "$@"
98 }
99
100 vcmp()
101 {
102 # Compare $1 to $3 each of which must match ^[^0-9]*\d*(\.\d*)*.*$
103 # where only the "\d*" parts in the regex participate in the comparison
104 # Since EVERY string matches that regex this function is easy to use
105 # An empty string ('') for $1 or $3 or any "\d*" part is treated as 0
106 # $2 is a compare op '<', '<=', '=', '==', '!=', '>=', '>'
107 # Return code is 0 for true, 1 for false (or unknown compare op)
108 # There is NO difference in behavior between '=' and '=='
109 # Note that "vcmp 1.8 == 1.8.0.0.0.0" correctly returns 0
110 set -- "$1" "$2" "$3" "${1%%[0-9]*}" "${3%%[0-9]*}"
111 set -- "${1#"$4"}" "$2" "${3#"$5"}"
112 set -- "${1%%[!0-9.]*}" "$2" "${3%%[!0-9.]*}"
113 while
114 vcmp_a_="${1%%.*}"
115 vcmp_b_="${3%%.*}"
116 [ "z$vcmp_a_" != "z" -o "z$vcmp_b_" != "z" ]
117 do
118 if [ "${vcmp_a_:-0}" -lt "${vcmp_b_:-0}" ]; then
119 unset vcmp_a_ vcmp_b_
120 case "$2" in "<"|"<="|"!=") return 0; esac
121 return 1
122 elif [ "${vcmp_a_:-0}" -gt "${vcmp_b_:-0}" ]; then
123 unset vcmp_a_ vcmp_b_
124 case "$2" in ">"|">="|"!=") return 0; esac
125 return 1;
126 fi
127 vcmp_a_="${1#$vcmp_a_}"
128 vcmp_b_="${3#$vcmp_b_}"
129 set -- "${vcmp_a_#.}" "$2" "${vcmp_b_#.}"
130 done
131 unset vcmp_a_ vcmp_b_
132 case "$2" in "="|"=="|"<="|">=") return 0; esac
133 return 1
134 }
135
136 precheck() {
137 if ! git_version="$(git version)"; then
138 die "'git version' failed"
139 fi
140 case "$git_version" in [Gg]"it version "*);;*)
141 die "'git version' output does not start with 'git version '"
142 esac
143
144 vcmp "$git_version" '>=' "$GIT_MINIMUM_VERSION" ||
145 die "git version >= $GIT_MINIMUM_VERSION required but found $git_version instead"
146 }
147
148 case "$1" in version|--version|-V)
149 echo "TopGit version $TG_VERSION"
150 exit 0
151 esac
152
153 precheck
154 [ "$1" = "precheck" ] && exit 0
155
156
157 cat_depsmsg_internal()
158 {
159 _rev="$(ref_exists_rev "refs/heads/$1")" || return 0
160 if [ -s "$tg_cache_dir/$1/.$2" ]; then
161 if read _rev_match && [ "$_rev" = "$_rev_match" ]; then
162 _line=
163 while IFS= read -r _line || [ -n "$_line" ]; do
164 printf '%s\n' "$_line"
165 done
166 return 0
167 fi <"$tg_cache_dir/$1/.$2"
168 fi
169 [ -d "$tg_cache_dir/$1" ] || mkdir -p "$tg_cache_dir/$1" 2>/dev/null || :
170 if [ -d "$tg_cache_dir/$1" ]; then
171 printf '%s\n' "$_rev" >"$tg_cache_dir/$1/.$2"
172 _line=
173 git cat-file blob "$_rev:.$2" 2>/dev/null |
174 while IFS= read -r _line || [ -n "$_line" ]; do
175 printf '%s\n' "$_line" >&3
176 printf '%s\n' "$_line"
177 done 3>>"$tg_cache_dir/$1/.$2"
178 else
179 git cat-file blob "$_rev:.$2" 2>/dev/null
180 fi
181 }
182
183 # cat_deps BRANCHNAME
184 # Caches result
185 cat_deps()
186 {
187 cat_depsmsg_internal "$1" topdeps
188 }
189
190 # cat_msg BRANCHNAME
191 # Caches result
192 cat_msg()
193 {
194 cat_depsmsg_internal "$1" topmsg
195 }
196
197 # cat_file TOPIC:PATH [FROM]
198 # cat the file PATH from branch TOPIC when FROM is empty.
199 # FROM can be -i or -w, than the file will be from the index or worktree,
200 # respectively. The caller should than ensure that HEAD is TOPIC, to make sense.
201 cat_file()
202 {
203 path="$1"
204 case "$2" in
205 -w)
206 cat "$root_dir/${path#*:}"
207 ;;
208 -i)
209 # ':file' means cat from index
210 git cat-file blob ":${path#*:}" 2>/dev/null
211 ;;
212 '')
213 case "$path" in
214 refs/heads/*:.topdeps)
215 _temp="${path%:.topdeps}"
216 cat_deps "${_temp#refs/heads/}"
217 ;;
218 refs/heads/*:.topmsg)
219 _temp="${path%:.topmsg}"
220 cat_msg "${_temp#refs/heads/}"
221 ;;
222 *)
223 git cat-file blob "$path" 2>/dev/null
224 ;;
225 esac
226 ;;
227 *)
228 die "Wrong argument to cat_file: '$2'"
229 ;;
230 esac
231 }
232
233 # if use_alt_temp_odb and tg_use_alt_odb are true try to write the object(s)
234 # into the temporary alt odb area instead of the usual location
235 git_temp_alt_odb_cmd()
236 {
237 if [ -n "$use_alt_temp_odb" ] && [ -n "$tg_use_alt_odb" ] &&
238 [ -n "$TG_OBJECT_DIRECTORY" ] &&
239 [ -f "$TG_OBJECT_DIRECTORY/info/alternates" ]; then
240 (
241 GIT_ALTERNATE_OBJECT_DIRECTORIES="$TG_PRESERVED_ALTERNATES"
242 GIT_OBJECT_DIRECTORY="$TG_OBJECT_DIRECTORY"
243 unset TG_OBJECT_DIRECTORY TG_PRESERVED_ALTERNATES
244 export GIT_ALTERNATE_OBJECT_DIRECTORIES GIT_OBJECT_DIRECTORY
245 git "$@"
246 )
247 else
248 git "$@"
249 fi
250 }
251
252 git_write_tree() { git_temp_alt_odb_cmd write-tree "$@"; }
253 git_mktree() { git_temp_alt_odb_cmd mktree "$@"; }
254
255 # get tree for the committed topic
256 get_tree_()
257 {
258 echo "refs/heads/$1"
259 }
260
261 # get tree for the base
262 get_tree_b()
263 {
264 echo "refs/$topbases/$1"
265 }
266
267 # get tree for the index
268 get_tree_i()
269 {
270 git_write_tree
271 }
272
273 # get tree for the worktree
274 get_tree_w()
275 {
276 i_tree=$(git_write_tree)
277 (
278 # the file for --index-output needs to sit next to the
279 # current index file
280 cd "$root_dir"
281 : ${GIT_INDEX_FILE:="$git_dir/index"}
282 TMP_INDEX="$(mktemp "${GIT_INDEX_FILE}-tg.XXXXXX")"
283 git read-tree -m $i_tree --index-output="$TMP_INDEX" &&
284 GIT_INDEX_FILE="$TMP_INDEX" &&
285 export GIT_INDEX_FILE &&
286 git diff --name-only -z HEAD |
287 git update-index -z --add --remove --stdin &&
288 git_write_tree &&
289 rm -f "$TMP_INDEX"
290 )
291 }
292
293 # strip_ref "$(git symbolic-ref HEAD)"
294 # Output will have a leading refs/heads/ or refs/$topbases/ stripped if present
295 strip_ref()
296 {
297 case "$1" in
298 refs/"$topbases"/*)
299 echol "${1#refs/$topbases/}"
300 ;;
301 refs/heads/*)
302 echol "${1#refs/heads/}"
303 ;;
304 *)
305 echol "$1"
306 esac
307 }
308
309 # pretty_tree [-t] NAME [-b | -i | -w]
310 # Output tree ID of a cleaned-up tree without tg's artifacts.
311 # NAME will be ignored for -i and -w, but needs to be present
312 # If -t is used the tree is written into the alternate temporary objects area
313 pretty_tree()
314 {
315 use_alt_temp_odb=
316 [ "$1" != "-t" ] || { shift; use_alt_temp_odb=1; }
317 name="$1"
318 source="${2#?}"
319 git ls-tree --full-tree "$(get_tree_$source "$name")" |
320 LC_ALL=C sed -ne '/ \.top.*$/!p' |
321 git_mktree
322 }
323
324 # return an empty-tree root commit -- date is either passed in or current
325 # If passed in "$*" must be epochsecs followed by optional hhmm offset (+0000 default)
326 # An invalid secs causes the current date to be used, an invalid zone offset
327 # causes +0000 to be used
328 make_empty_commit()
329 (
330 # the empty tree is guaranteed to always be there even in a repo with
331 # zero objects, but for completeness we force it to exist as a real object
332 SECS=
333 read -r SECS ZONE JUNK <<-EOT || :
334 $*
335 EOT
336 case "$SECS" in *[!0-9]*) SECS=; esac
337 if [ -z "$SECS" ]; then
338 MTDATE="$(date '+%s %z')"
339 else
340 case "$ZONE" in
341 -[01][0-9][0-5][0-9]|+[01][0-9][0-5][0-9])
342 ;;
343 [01][0-9][0-5][0-9])
344 ZONE="+$ZONE"
345 ;;
346 *)
347 ZONE="+0000"
348 esac
349 MTDATE="$SECS $ZONE"
350 fi
351 EMPTYID="- <-> $MTDATE"
352 EMPTYTREE="$(git hash-object -t tree -w --stdin < /dev/null)"
353 printf '%s\n' "tree $EMPTYTREE" "author $EMPTYID" "committer $EMPTYID" '' |
354 git hash-object -t commit -w --stdin
355 )
356
357 # setup_hook NAME
358 setup_hook()
359 {
360 tgname="${0##*/}"
361 hook_call="\"\$(\"$tgname\" --hooks-path)\"/$1 \"\$@\""
362 if [ -f "$git_hooks_dir/$1" ] && LC_ALL=C grep -Fq "$hook_call" "$git_hooks_dir/$1"; then
363 # Another job well done!
364 return
365 fi
366 # Prepare incantation
367 hook_chain=
368 if [ -s "$git_hooks_dir/$1" -a -x "$git_hooks_dir/$1" ]; then
369 hook_call="$hook_call"' || exit $?'
370 if [ -L "$git_hooks_dir/$1" ] || ! LC_ALL=C sed -n 1p <"$git_hooks_dir/$1" | LC_ALL=C grep -Fqx "#!@SHELL_PATH@"; then
371 chain_num=
372 while [ -e "$git_hooks_dir/$1-chain$chain_num" ]; do
373 chain_num=$(( $chain_num + 1 ))
374 done
375 mv -f "$git_hooks_dir/$1" "$git_hooks_dir/$1-chain$chain_num"
376 hook_chain=1
377 fi
378 else
379 hook_call="exec $hook_call"
380 [ -d "$git_hooks_dir" ] || mkdir -p "$git_hooks_dir" || :
381 fi
382 # Don't call hook if tg is not installed
383 hook_call="if command -v \"$tgname\" >/dev/null 2>&1; then $hook_call; fi"
384 # Insert call into the hook
385 {
386 echol "#!@SHELL_PATH@"
387 echol "$hook_call"
388 if [ -n "$hook_chain" ]; then
389 echol "exec \"\$0-chain$chain_num\" \"\$@\""
390 else
391 [ ! -s "$git_hooks_dir/$1" ] || cat "$git_hooks_dir/$1"
392 fi
393 } >"$git_hooks_dir/$1+"
394 chmod a+x "$git_hooks_dir/$1+"
395 mv "$git_hooks_dir/$1+" "$git_hooks_dir/$1"
396 }
397
398 # setup_ours (no arguments)
399 setup_ours()
400 {
401 if [ ! -s "$git_common_dir/info/attributes" ] || ! grep -q topmsg "$git_common_dir/info/attributes"; then
402 [ -d "$git_common_dir/info" ] || mkdir "$git_common_dir/info"
403 {
404 echo ".topmsg merge=ours"
405 echo ".topdeps merge=ours"
406 } >>"$git_common_dir/info/attributes"
407 fi
408 if ! git config merge.ours.driver >/dev/null; then
409 git config merge.ours.name '"always keep ours" merge driver'
410 git config merge.ours.driver 'touch %A'
411 fi
412 }
413
414 # measure_branch NAME [BASE] [EXTRAHEAD...]
415 measure_branch()
416 {
417 _bname="$1"; _base="$2"
418 shift; shift
419 [ -n "$_base" ] || _base="refs/$topbases/$(strip_ref "$_bname")"
420 # The caller should've verified $name is valid
421 _commits="$(git rev-list --count "$_bname" "$@" ^"$_base" --)"
422 _nmcommits="$(git rev-list --count --no-merges "$_bname" "$@" ^"$_base" --)"
423 if [ $_commits -ne 1 ]; then
424 _suffix="commits"
425 else
426 _suffix="commit"
427 fi
428 echo "$_commits/$_nmcommits $_suffix"
429 }
430
431 # branch_contains B1 B2
432 # Whether B1 is a superset of B2.
433 branch_contains()
434 {
435 _revb1="$(ref_exists_rev "$1")" || return 0
436 _revb2="$(ref_exists_rev "$2")" || return 0
437 if [ -s "$tg_cache_dir/$1/.bc/$2/.d" ]; then
438 if read _result _rev_matchb1 _rev_matchb2 &&
439 [ "$_revb1" = "$_rev_matchb1" -a "$_revb2" = "$_rev_matchb2" ]; then
440 return $_result
441 fi <"$tg_cache_dir/$1/.bc/$2/.d"
442 fi
443 [ -d "$tg_cache_dir/$1/.bc/$2" ] || mkdir -p "$tg_cache_dir/$1/.bc/$2" 2>/dev/null || :
444 _result=0
445 [ "$(git rev-list --count --max-count=1 "$_revb2" --not "$_revb1" --)" = "0" ] || _result=1
446 if [ -d "$tg_cache_dir/$1/.bc/$2" ]; then
447 echo "$_result" "$_revb1" "$_revb2" >"$tg_cache_dir/$1/.bc/$2/.d"
448 fi
449 return $_result
450 }
451
452 create_ref_dirs()
453 {
454 [ ! -s "$tg_tmp_dir/tg~ref-dirs-created" -a -s "$tg_ref_cache" ] || return 0
455 LC_ALL=C awk -v p="$tg_tmp_dir/cached/" '{print p $1}' <"$tg_ref_cache" | LC_ALL=C tr '\n' '\0' | xargs -0 mkdir -p
456 echo 1 >"$tg_tmp_dir/tg~ref-dirs-created"
457 }
458
459 # If the first argument is non-empty, stores "1" there if this call created the cache
460 v_create_ref_cache()
461 {
462 [ -n "$tg_ref_cache" -a ! -s "$tg_ref_cache" ] || return 0
463 _remotespec=
464 [ -z "$base_remote" ] || _remotespec="refs/remotes/$base_remote"
465 [ -z "$1" ] || eval "$1=1"
466 git for-each-ref --format='%(refname) %(objectname)' \
467 refs/heads "refs/$topbases" $_remotespec >"$tg_ref_cache"
468 create_ref_dirs
469 }
470
471 remove_ref_cache()
472 {
473 [ -n "$tg_ref_cache" -a -s "$tg_ref_cache" ] || return 0
474 >"$tg_ref_cache"
475 }
476
477 # setting tg_ref_cache_only to non-empty will force non-$tg_ref_cache lookups to fail
478 rev_parse()
479 {
480 if [ -n "$tg_ref_cache" -a -s "$tg_ref_cache" ]; then
481 LC_ALL=C awk -v r="$1" 'BEGIN {e=1}; $1 == r {print $2; e=0; exit}; END {exit e}' <"$tg_ref_cache"
482 else
483 [ -z "$tg_ref_cache_only" ] || return 1
484 git rev-parse --quiet --verify "$1^0" -- 2>/dev/null
485 fi
486 }
487
488 # ref_exists_rev REF
489 # Whether REF is a valid ref name
490 # REF must be fully qualified and start with refs/heads/, refs/$topbases/
491 # or, if $base_remote is set, refs/remotes/$base_remote/
492 # Caches result if $tg_read_only and outputs HASH on success
493 ref_exists_rev()
494 {
495 case "$1" in
496 refs/*)
497 ;;
498 $octet20)
499 printf '%s' "$1"
500 return;;
501 *)
502 die "ref_exists_rev requires fully-qualified ref name"
503 esac
504 [ -n "$tg_read_only" ] || { git rev-parse --quiet --verify "$1^0" -- 2>/dev/null; return; }
505 _result=
506 _result_rev=
507 { read -r _result _result_rev <"$tg_tmp_dir/cached/$1/.ref"; } 2>/dev/null || :
508 [ -z "$_result" ] || { printf '%s' "$_result_rev"; return $_result; }
509 _result_rev="$(rev_parse "$1")"
510 _result=$?
511 [ -d "$tg_tmp_dir/cached/$1" ] || mkdir -p "$tg_tmp_dir/cached/$1" 2>/dev/null
512 [ ! -d "$tg_tmp_dir/cached/$1" ] ||
513 echo $_result $_result_rev >"$tg_tmp_dir/cached/$1/.ref" 2>/dev/null || :
514 printf '%s' "$_result_rev"
515 return $_result
516 }
517
518 # Same as ref_exists_rev but output is abbreviated hash
519 # Optional second argument defaults to --short but may be any --short=.../--no-short option
520 ref_exists_rev_short()
521 {
522 case "$1" in
523 refs/*)
524 ;;
525 $octet20)
526 ;;
527 *)
528 die "ref_exists_rev_short requires fully-qualified ref name"
529 esac
530 [ -n "$tg_read_only" ] || { git rev-parse --quiet --verify ${2:---short} "$1^0" -- 2>/dev/null; return; }
531 _result=
532 _result_rev=
533 { read -r _result _result_rev <"$tg_tmp_dir/cached/$1/.rfs"; } 2>/dev/null || :
534 [ -z "$_result" ] || { printf '%s' "$_result_rev"; return $_result; }
535 _result_rev="$(rev_parse "$1")"
536 _result=$?
537 if [ $_result -eq 0 ]; then
538 _result_rev="$(git rev-parse --verify ${2:---short} --quiet "$_result_rev" --)"
539 _result=$?
540 fi
541 [ -d "$tg_tmp_dir/cached/$1" ] || mkdir -p "$tg_tmp_dir/cached/$1" 2>/dev/null
542 [ ! -d "$tg_tmp_dir/cached/$1" ] ||
543 echo $_result $_result_rev >"$tg_tmp_dir/cached/$1/.rfs" 2>/dev/null || :
544 printf '%s' "$_result_rev"
545 return $_result
546 }
547
548 # ref_exists REF
549 # Whether REF is a valid ref name
550 # REF must be fully qualified and start with refs/heads/, refs/$topbases/
551 # or, if $base_remote is set, refs/remotes/$base_remote/
552 # Caches result
553 ref_exists()
554 {
555 ref_exists_rev "$1" >/dev/null
556 }
557
558 # rev_parse_tree REF
559 # Runs git rev-parse REF^{tree}
560 # Caches result if $tg_read_only
561 rev_parse_tree()
562 {
563 [ -n "$tg_read_only" ] || { git rev-parse --verify "$1^{tree}" -- 2>/dev/null; return; }
564 if [ -f "$tg_tmp_dir/cached/$1/.rpt" ]; then
565 if IFS= read -r _result <"$tg_tmp_dir/cached/$1/.rpt"; then
566 printf '%s\n' "$_result"
567 return 0
568 fi
569 return 1
570 fi
571 [ -d "$tg_tmp_dir/cached/$1" ] || mkdir -p "$tg_tmp_dir/cached/$1" 2>/dev/null || :
572 if [ -d "$tg_tmp_dir/cached/$1" ]; then
573 git rev-parse --verify "$1^{tree}" -- >"$tg_tmp_dir/cached/$1/.rpt" 2>/dev/null || :
574 if IFS= read -r _result <"$tg_tmp_dir/cached/$1/.rpt"; then
575 printf '%s\n' "$_result"
576 return 0
577 fi
578 return 1
579 fi
580 git rev-parse --verify "$1^{tree}" -- 2>/dev/null
581 }
582
583 # has_remote BRANCH
584 # Whether BRANCH has a remote equivalent (accepts ${topbases#heads/}/ too)
585 has_remote()
586 {
587 [ -n "$base_remote" ] && ref_exists "refs/remotes/$base_remote/$1"
588 }
589
590 # Return the verified TopGit branch name for "$2" in "$1" or die with an error.
591 # If -z "$1" still set return code but do not return result
592 # As a convenience, if HEAD or @ is given and HEAD is a symbolic ref to
593 # refs/heads/... then ... will be verified instead.
594 # if "$3" = "-f" (for fail) then return an error rather than dying.
595 v_verify_topgit_branch()
596 {
597 if [ "$2" = "HEAD" ] || [ "$2" = "@" ]; then
598 _verifyname="$(git symbolic-ref HEAD 2>/dev/null)" || :
599 [ -n "$_verifyname" -o "$3" = "-f" ] || die "HEAD is not a symbolic ref"
600 case "$_verifyname" in refs/"$topbases"/*|refs/heads/*);;*)
601 [ "$3" != "-f" ] || return 1
602 die "HEAD is not a symbolic ref to the refs/heads namespace"
603 esac
604 set -- "$1" "$_verifyname" "$3"
605 fi
606 case "$2" in
607 refs/"$topbases"/*)
608 _verifyname="${2#refs/$topbases/}"
609 ;;
610 refs/heads/*)
611 _verifyname="${2#refs/heads/}"
612 ;;
613 *)
614 _verifyname="$2"
615 ;;
616 esac
617 if ! ref_exists "refs/heads/$_verifyname"; then
618 [ "$3" != "-f" ] || return 1
619 die "no such branch: $_verifyname"
620 fi
621 if ! ref_exists "refs/$topbases/$_verifyname"; then
622 [ "$3" != "-f" ] || return 1
623 die "not a TopGit-controlled branch: $_verifyname"
624 fi
625 [ -z "$1" ] || eval "$1="'"$_verifyname"'
626 }
627
628 # Return the verified TopGit branch name or die with an error.
629 # As a convenience, if HEAD or @ is given and HEAD is a symbolic ref to
630 # refs/heads/... then ... will be verified instead.
631 # if "$2" = "-f" (for fail) then return an error rather than dying.
632 verify_topgit_branch()
633 {
634 v_verify_topgit_branch _verifyname "$@" || return
635 printf '%s' "$_verifyname"
636 }
637
638 # Caches result
639 # $1 = branch name (i.e. "t/foo/bar")
640 # $2 = optional result of rev-parse "refs/heads/$1"
641 # $3 = optional result of rev-parse "refs/$topbases/$1"
642 branch_annihilated()
643 {
644 _branch_name="$1"
645 _rev="${2:-$(ref_exists_rev "refs/heads/$_branch_name")}"
646 _rev_base="${3:-$(ref_exists_rev "refs/$topbases/$_branch_name")}"
647
648 _result=
649 _result_rev=
650 _result_rev_base=
651 { read -r _result _result_rev _result_rev_base <"$tg_cache_dir/$_branch_name/.ann"; } 2>/dev/null || :
652 [ -z "$_result" -o "$_result_rev" != "$_rev" -o "$_result_rev_base" != "$_rev_base" ] || return $_result
653
654 # use the merge base in case the base is ahead.
655 mb="$(git merge-base "$_rev_base" "$_rev" 2>/dev/null)"
656
657 test -z "$mb" || test "$(rev_parse_tree "$mb")" = "$(rev_parse_tree "$_rev")"
658 _result=$?
659 [ -d "$tg_cache_dir/$_branch_name" ] || mkdir -p "$tg_cache_dir/$_branch_name" 2>/dev/null
660 [ ! -d "$tg_cache_dir/$_branch_name" ] ||
661 echo $_result $_rev $_rev_base >"$tg_cache_dir/$_branch_name/.ann" 2>/dev/null || :
662 return $_result
663 }
664
665 non_annihilated_branches()
666 {
667 [ $# -gt 0 ] || set -- "refs/$topbases"
668 git for-each-ref --format='%(objectname) %(refname)' "$@" |
669 while read rev ref; do
670 name="${ref#refs/$topbases/}"
671 if branch_annihilated "$name" "" "$rev"; then
672 continue
673 fi
674 echol "$name"
675 done
676 }
677
678 # Make sure our tree is clean
679 # if optional "$1" given also verify that a checkout to "$1" would succeed
680 ensure_clean_tree()
681 {
682 check_status
683 [ -z "$tg_state$git_state" ] || { do_status; exit 1; }
684 git update-index --ignore-submodules --refresh ||
685 die "the working directory has uncommitted changes (see above) - first commit or reset them"
686 [ -z "$(git diff-index --cached --name-status -r --ignore-submodules HEAD --)" ] ||
687 die "the index has uncommited changes"
688 [ -z "$1" ] || git read-tree -n -u -m "$1" ||
689 die "git checkout \"$1\" would fail"
690 }
691
692 # is_sha1 REF
693 # Whether REF is a SHA1 (compared to a symbolic name).
694 is_sha1()
695 {
696 case "$1" in $octet20) return 0;; esac
697 return 1
698 }
699
700 # recurse_deps_internal NAME [BRANCHPATH...]
701 # get recursive list of dependencies with leading 0 if branch exists 1 if missing
702 # followed by a 1 if the branch is "tgish" (2 if it also has a remote); 0 if not
703 # followed by a 0 for a non-leaf, 1 for a leaf or 2 for annihilated tgish
704 # but missing and remotes are always "0"
705 # then the branch name followed by its depedency chain (which might be empty)
706 # An output line might look like this:
707 # 0 1 1 t/foo/leaf t/foo/int t/stage
708 # If no_remotes is non-empty, exclude remotes
709 # If recurse_preorder is non-empty, do a preorder rather than postorder traversal
710 # but the leaf info will always be 0 or 2 in that case
711 # If with_top_level is non-empty, include the top-level that's normally omitted
712 # any branch names in the space-separated recurse_deps_exclude variable
713 # are skipped (along with their dependencies)
714 recurse_deps_internal()
715 {
716 case " $recurse_deps_exclude " in *" $1 "*) return 0; esac
717 _ref_hash=
718 if ! _ref_hash="$(ref_exists_rev "refs/heads/$1")"; then
719 [ -z "$2" ] || echo "1 0 0 $*"
720 return 0
721 fi
722
723 _is_tgish=0
724 _ref_hash_base=
725 _is_leaf=0
726 ! _ref_hash_base="$(ref_exists_rev "refs/$topbases/$1")" || _is_tgish=1
727 [ "$_is_tgish" = "0" ] || [ -n "$no_remotes" ] || ! has_remote "${topbases#heads/}/$1" || _is_tgish=2
728 [ "$_is_tgish" = "0" ] || ! branch_annihilated "$1" "$_ref_hash" "$_ref_hash_base" || _is_leaf=2
729 [ -z "$recurse_preorder" -o -z "${2:-$with_top_level}" ] || echo "0 $_is_tgish $_is_leaf $*"
730
731 # If no_remotes is unset also check our base against remote base.
732 # Checking our head against remote head has to be done in the helper.
733 if [ "$_is_tgish" = "2" ]; then
734 echo "0 0 0 refs/remotes/$base_remote/${topbases#heads/}/$1 $*"
735 fi
736
737 # if the branch was annihilated, it is considered to have no dependencies
738 [ "$_is_leaf" = "2" ] || _is_leaf=1
739 if [ "$_is_tgish" != "0" ] && [ "$_is_leaf" = "1" ]; then
740 #TODO: handle nonexisting .topdeps?
741 while read _dname && [ -n "$_dname" ]; do
742 # Avoid depedency loops
743 case " $* " in *" $_dname "*)
744 warn "dependency loop detected in branch $_dname"
745 _is_leaf=0
746 continue
747 esac
748 # Shoo shoo, leave our environment alone!
749 _dep_is_leaf=0
750 (recurse_deps_internal "$_dname" "$@") || _dep_is_leaf=$?
751 [ "$_dep_is_leaf" = "2" ] || _is_leaf=0
752 done <<-EOT
753 $(cat_deps "$1")
754 EOT
755 fi
756
757 [ -n "$recurse_preorder" -o -z "${2:-$with_top_level}" ] || echo "0 $_is_tgish $_is_leaf $*"
758 return ${_is_leaf:-0}
759 }
760
761 # do_eval CMD
762 # helper for recurse_deps so that a return statement executed inside CMD
763 # does not return from recurse_deps. This shouldn't be necessary, but it
764 # seems that it actually is.
765 do_eval()
766 {
767 eval "$@"
768 }
769
770 # becomes read-only for caching purposes
771 # assigns new value to tg_read_only
772 # become_cacheable/undo_become_cacheable calls may be nested
773 become_cacheable()
774 {
775 _old_tg_read_only="$tg_read_only"
776 if [ -z "$tg_read_only" ]; then
777 ! [ -e "$tg_tmp_dir/cached" ] && ! [ -e "$tg_tmp_dir/tg~ref-dirs-created" ] ||
778 rm -rf "$tg_tmp_dir/cached" "$tg_tmp_dir/tg~ref-dirs-created"
779 tg_read_only=1
780 fi
781 _my_ref_cache=
782 v_create_ref_cache _my_ref_cache
783 _my_ref_cache="${_my_ref_cache:+1}"
784 tg_read_only="undo${_my_ref_cache:-0}-$_old_tg_read_only"
785 }
786
787 # restores tg_read_only and ref_cache to state before become_cacheable call
788 # become_cacheable/undo_bocome_cacheable calls may be nested
789 undo_become_cacheable()
790 {
791 case "$tg_read_only" in
792 "undo"[01]"-"*)
793 _suffix="${tg_read_only#undo?-}"
794 [ "${tg_read_only%$_suffix}" = "undo0-" ] || remove_ref_cache
795 tg_read_only="$_suffix"
796 esac
797 }
798
799 # just call this, no undo, sets tg_read_only= and removes ref cache and cached results
800 become_non_cacheable()
801 {
802 remove_ref_cache
803 tg_read_only=
804 ! [ -e "$tg_tmp_dir/cached" ] && ! [ -e "$tg_tmp_dir/tg~ref-dirs-created" ] ||
805 rm -rf "$tg_tmp_dir/cached" "$tg_tmp_dir/tg~ref-dirs-created"
806 }
807
808 # call this to make sure Git will not complain about a missing user/email
809 # result is cached in TG_IDENT_CHECKED and a non-empty value suppresses the check
810 ensure_ident_available()
811 {
812 [ -z "$TG_IDENT_CHECKED" ] || return 0
813 git var GIT_AUTHOR_IDENT >/dev/null &&
814 git var GIT_COMMITTER_IDENT >/dev/null || exit
815 TG_IDENT_CHECKED=1
816 export TG_IDENT_CHECKED
817 return 0
818 }
819
820 # recurse_deps CMD NAME [BRANCHPATH...]
821 # Recursively eval CMD on all dependencies of NAME.
822 # Dependencies are visited in topological order.
823 # CMD can refer to the following variables:
824 #
825 # _ret starts as 0; CMD can change; will be final return result
826 # _dep bare branch name or "refs/remotes/..." for a remote base
827 # _name has $_dep in its .topdeps ("" for top and $with_top_level)
828 # _depchain 0+ space-separated branch names forming a path to top
829 # _dep_missing boolean "1" if no such $_dep ref; "" if ref present
830 # _dep_is_leaf boolean "1" if leaf; "" if not
831 # _dep_is_tgish boolean "1" if tgish; "" if not (which implies no remote)
832 # _dep_has_remote boolean "1" if $_dep has_remote; "" if not
833 # _dep_annihilated boolean "1" if $_dep annihilated; "" if not
834 #
835 # CMD may use a "return" statement without issue; its return value is ignored,
836 # but if CMD sets _ret to a negative value, e.g. "-0" or "-1" the enumeration
837 # will stop immediately and the value with the leading "-" stripped off will
838 # be the final result code
839 #
840 # CMD can refer to $_name for queried branch name,
841 # $_dep for dependency name,
842 # $_depchain for space-seperated branch backtrace,
843 # $_dep_missing boolean to check whether $_dep is present
844 # and the $_dep_is_tgish and $_dep_annihilated booleans.
845 # If recurse_preorder is NOT set then the $_dep_is_leaf boolean is also valid.
846 # It can modify $_ret to affect the return value
847 # of the whole function.
848 # If recurse_deps() hits missing dependencies, it will append
849 # them to space-separated $missing_deps list and skip them
850 # after calling CMD with _dep_missing set.
851 # remote dependencies are processed if no_remotes is unset.
852 # any branch names in the space-separated recurse_deps_exclude variable
853 # are skipped (along with their dependencies)
854 recurse_deps()
855 {
856 _cmd="$1"; shift
857
858 become_cacheable
859 _depsfile="$(get_temp tg-depsfile)"
860 recurse_deps_internal "$@" >>"$_depsfile" || :
861 undo_become_cacheable
862
863 _ret=0
864 while read _ismissing _istgish _isleaf _dep _name _deppath; do
865 _depchain="$_name${_deppath:+ $_deppath}"
866 _dep_is_tgish=
867 [ "$_istgish" = "0" ] || _dep_is_tgish=1
868 _dep_has_remote=
869 [ "$_istgish" != "2" ] || _dep_has_remote=1
870 _dep_missing=
871 if [ "$_ismissing" != "0" ]; then
872 _dep_missing=1
873 case " $missing_deps " in *" $_dep "*);;*)
874 missing_deps="${missing_deps:+$missing_deps }$_dep"
875 esac
876 fi
877 _dep_annihilated=
878 _dep_is_leaf=
879 if [ "$_isleaf" = "1" ]; then
880 _dep_is_leaf=1
881 elif [ "$_isleaf" = "2" ]; then
882 _dep_annihilated=1
883 fi
884 do_eval "$_cmd" || :
885 if [ "${_ret#-}" != "$_ret" ]; then
886 _ret="${_ret#-}"
887 break
888 fi
889 done <"$_depsfile"
890 rm -f "$_depsfile"
891 return ${_ret:-0}
892 }
893
894 find_leaves_internal()
895 {
896 if [ -n "$_dep_is_leaf" ] && [ -z "$_dep_annihilated" ] && [ -z "$_dep_missing" ]; then
897 if [ -n "$_dep_is_tgish" ]; then
898 fulldep="refs/$topbases/$_dep"
899 else
900 fulldep="refs/heads/$_dep"
901 fi
902 case " $seen_leaf_refs " in *" $fulldep "*);;*)
903 seen_leaf_refs="${seen_leaf_refs:+$seen_leaf_refs }$fulldep"
904 if fullrev="$(ref_exists_rev "$fulldep")"; then
905 case " $seen_leaf_revs " in *" $fullrev "*);;*)
906 seen_leaf_revs="${seen_leaf_revs:+$seen_leaf_revs }$fullrev"
907 # See if Git knows it by another name
908 if tagname="$(git describe --exact-match "$fullrev" 2>/dev/null)" && [ -n "$tagname" ]; then
909 echo "refs/tags/$tagname"
910 else
911 echo "$fulldep"
912 fi
913 esac
914 fi
915 esac
916 fi
917 }
918
919 # find_leaves NAME
920 # output (one per line) the unique leaves of NAME
921 # a leaf is either
922 # 1) a non-tgish dependency
923 # 2) the base of a tgish dependency with no non-annihilated dependencies
924 # duplicates are suppressed (by commit rev) and remotes are always ignored
925 # if a leaf has an exact tag match that will be output
926 # note that recurse_deps_exclude IS honored for this operation
927 find_leaves()
928 {
929 no_remotes=1
930 with_top_level=1
931 recurse_preorder=
932 seen_leaf_refs=
933 seen_leaf_revs=
934 recurse_deps find_leaves_internal "$1"
935 with_top_level=
936 }
937
938 # branch_needs_update
939 # This is a helper function for determining whether given branch
940 # is up-to-date wrt. its dependencies. It expects input as if it
941 # is called as a recurse_deps() helper.
942 # In case the branch does need update, it will echo it together
943 # with the branch backtrace on the output (see needs_update()
944 # description for details) and set $_ret to non-zero.
945 branch_needs_update()
946 {
947 if [ -n "$_dep_missing" ]; then
948 echo "! $_dep $_depchain"
949 return 0
950 fi
951
952 if [ -n "$_dep_is_tgish" ]; then
953 branch_annihilated "$_dep" && return 0
954
955 if has_remote "$_dep"; then
956 branch_contains "refs/heads/$_dep" "refs/remotes/$base_remote/$_dep" ||
957 echo "refs/remotes/$base_remote/$_dep $_dep $_depchain"
958 fi
959 # We want to sync with our base first and should output this before
960 # the remote branch, but the order does not actually matter to tg-update
961 # as it just recurses regardless, but it does matter for tg-info (which
962 # treats out-of-date bases as though they were already merged in) so
963 # we output the remote before the base.
964 branch_contains "refs/heads/$_dep" "refs/$topbases/$_dep" || {
965 echo ": $_dep $_depchain"
966 _ret=1
967 return
968 }
969 fi
970
971 if [ -n "$_name" ]; then
972 case "$_dep" in refs/*) _fulldep="$_dep";; *) _fulldep="refs/heads/$_dep";; esac
973 if ! branch_contains "refs/$topbases/$_name" "$_fulldep"; then
974 # Some new commits in _dep
975 echo "$_dep $_depchain"
976 _ret=1
977 fi
978 fi
979 }
980
981 # needs_update NAME
982 # This function is recursive; it outputs reverse path from NAME
983 # to the branch (e.g. B_DIRTY B1 B2 NAME), one path per line,
984 # inner paths first. Innermost name can be refs/remotes/<remote>/<name>
985 # if the head is not in sync with the <remote> branch <name>, ':' if
986 # the head is not in sync with the base (in this order of priority)
987 # or '!' if dependency is missing. Note that the remote branch, base
988 # order is reversed from the order they will actually be updated in
989 # order to accomodate tg info which treats out-of-date items that are
990 # only in the base as already being in the head for status purposes.
991 # It will also return non-zero status if NAME needs update.
992 # If needs_update() hits missing dependencies, it will append
993 # them to space-separated $missing_deps list and skip them.
994 needs_update()
995 {
996 recurse_deps branch_needs_update "$1"
997 }
998
999 # branch_empty NAME [-i | -w]
1000 branch_empty()
1001 {
1002 if [ -z "$2" ]; then
1003 _rev="$(ref_exists_rev "refs/heads/$1")" || return 0
1004 _result=
1005 _result_rev=
1006 { read -r _result _result_rev <"$tg_cache_dir/$1/.mt"; } 2>/dev/null || :
1007 [ -z "$_result" -o "$_result_rev" != "$_rev" ] || return $_result
1008 _result=0
1009 [ "$(pretty_tree -t "$1" -b)" = "$(pretty_tree -t "$1" $2)" ] || _result=$?
1010 [ -d "$tg_cache_dir/$1" ] || mkdir -p "$tg_cache_dir/$1" 2>/dev/null
1011 [ ! -d "$tg_cache_dir/$1" ] || echo $_result $_rev >"$tg_cache_dir/$1/.mt"
1012 return $_result
1013 else
1014 [ "$(pretty_tree -t "$1" -b)" = "$(pretty_tree -t "$1" $2)" ]
1015 fi
1016 }
1017
1018 # list_deps [-i | -w] [BRANCH]
1019 # -i/-w apply only to HEAD
1020 list_deps()
1021 {
1022 head_from=
1023 [ "$1" != "-i" -a "$1" != "-w" ] || { head_from="$1"; shift; }
1024 head="$(git symbolic-ref -q HEAD)" ||
1025 head="..detached.."
1026
1027 git for-each-ref --format='%(objectname) %(refname)' "refs/$topbases${1:+/$1}" |
1028 while read rev ref; do
1029 name="${ref#refs/$topbases/}"
1030 if branch_annihilated "$name" "" "$rev"; then
1031 continue
1032 fi
1033
1034 from=$head_from
1035 [ "refs/heads/$name" = "$head" ] ||
1036 from=
1037 cat_file "refs/heads/$name:.topdeps" $from | while read dep; do
1038 dep_is_tgish=true
1039 ref_exists "refs/$topbases/$dep" ||
1040 dep_is_tgish=false
1041 if ! "$dep_is_tgish" || ! branch_annihilated $dep; then
1042 echo "$name $dep"
1043 fi
1044 done
1045 done
1046 }
1047
1048 # checkout_symref_full [-f] FULLREF [SEED]
1049 # Just like git checkout $iowopt -b FULLREF [SEED] except that FULLREF MUST start with
1050 # refs/ and HEAD is ALWAYS set to a symref to it and [SEED] (default is FULLREF)
1051 # MUST be a committish which if present will be used instead of current FULLREF
1052 # (and FULLREF will be updated to it as well in that case)
1053 # With -f it's like git checkout $iowopt -f -b FULLREF (uses read-tree --reset instead of -m)
1054 # As an extension, FULLREF may also be a full hash to create a detached HEAD instead
1055 checkout_symref_full()
1056 {
1057 _mode=-m
1058 if [ "$1" = "-f" ]; then
1059 mode="--reset"
1060 shift
1061 fi
1062 _ishash=
1063 case "$1" in
1064 refs/?*)
1065 ;;
1066 $octet20)
1067 _ishash=1
1068 [ -z "$2" ] || [ "$1" = "$2" ] ||
1069 die "programmer error: invalid checkout_symref_full \"$1\" \"$2\""
1070 set -- HEAD "$1"
1071 ;;
1072 *)
1073 die "programmer error: invalid checkout_symref_full \"$1\""
1074 ;;
1075 esac
1076 _seedrev="$(git rev-parse --quiet --verify "${2:-$1}^0" --)" ||
1077 die "invalid committish: \"${2:-$1}\""
1078 # We have to do all the hard work ourselves :/
1079 # This is like git checkout -b "$1" "$2"
1080 # (or just git checkout "$1"),
1081 # but never creates a detached HEAD (unless $1 is a hash)
1082 git read-tree -u $_mode HEAD "$_seedrev" &&
1083 {
1084 [ -z "$2" ] && [ "$(git cat-file -t "$1")" = "commit" ] ||
1085 git update-ref "$1" "$_seedrev"
1086 } && {
1087 [ -n "$_ishash" ] || git symbolic-ref HEAD "$1"
1088 }
1089 }
1090
1091 # switch_to_base NAME [SEED]
1092 switch_to_base()
1093 {
1094 checkout_symref_full "refs/$topbases/$1" "$2"
1095 }
1096
1097 # run editor with arguments
1098 # the editor setting will be cached in $tg_editor (which is eval'd)
1099 # result non-zero if editor fails or GIT_EDITOR cannot be determined
1100 run_editor()
1101 {
1102 tg_editor="$GIT_EDITOR"
1103 [ -n "$tg_editor" ] || tg_editor="$(git var GIT_EDITOR)" || return $?
1104 eval "$tg_editor" '"$@"'
1105 }
1106
1107 # Show the help messages.
1108 do_help()
1109 {
1110 _www=
1111 if [ "$1" = "-w" ]; then
1112 _www=1
1113 shift
1114 fi
1115 if [ -z "$1" ] ; then
1116 # This is currently invoked in all kinds of circumstances,
1117 # including when the user made a usage error. Should we end up
1118 # providing more than a short help message, then we should
1119 # differentiate.
1120 # Petr's comment: http://marc.info/?l=git&m=122718711327376&w=2
1121
1122 ## Build available commands list for help output
1123
1124 cmds=
1125 sep=
1126 for cmd in "$TG_INST_CMDDIR"/tg-[!-]*; do
1127 ! [ -r "$cmd" ] && continue
1128 # strip directory part and "tg-" prefix
1129 cmd="${cmd##*/}"
1130 cmd="${cmd#tg-}"
1131 [ "$cmd" != "migrate-bases" ] || continue
1132 [ "$cmd" != "summary" ] || cmd="st[atus]|$cmd"
1133 cmds="$cmds$sep$cmd"
1134 sep="|"
1135 done
1136
1137 echo "TopGit version $TG_VERSION - A different patch queue manager"
1138 echo "Usage: $tgname [-C <dir>] [-r <remote> | -u] [-c <name>=<val>] ($cmds) ..."
1139 echo " Or: $tgname help [-w] [<command>]"
1140 echo "Use \"$tgdisplaydir$tgname help tg\" for overview of TopGit"
1141 elif [ -r "$TG_INST_CMDDIR"/tg-$1 -o -r "$TG_INST_SHAREDIR/tg-$1.txt" ] ; then
1142 if [ -n "$_www" ]; then
1143 nohtml=
1144 if ! [ -r "$TG_INST_SHAREDIR/topgit.html" ]; then
1145 echo "${0##*/}: missing html help file:" \
1146 "$TG_INST_SHAREDIR/topgit.html" 1>&2
1147 nohtml=1
1148 fi
1149 if ! [ -r "$TG_INST_SHAREDIR/tg-$1.html" ]; then
1150 echo "${0##*/}: missing html help file:" \
1151 "$TG_INST_SHAREDIR/tg-$1.html" 1>&2
1152 nohtml=1
1153 fi
1154 if [ -n "$nohtml" ]; then
1155 echo "${0##*/}: use" \
1156 "\"${0##*/} help $1\" instead" 1>&2
1157 exit 1
1158 fi
1159 git web--browse -c help.browser "$TG_INST_SHAREDIR/tg-$1.html"
1160 exit
1161 fi
1162 output()
1163 {
1164 if [ -r "$TG_INST_CMDDIR"/tg-$1 ] ; then
1165 "$TG_INST_CMDDIR"/tg-$1 -h 2>&1 || :
1166 echo
1167 elif [ "$1" = "help" ]; then
1168 echo "Usage: ${tgname:-tg} help [-w] [<command>]"
1169 echo
1170 elif [ "$1" = "status" ] || [ "$1" = "st" ]; then
1171 echo "Usage: ${tgname:-tg} @tgsthelpusage@"
1172 echo
1173 fi
1174 if [ -r "$TG_INST_SHAREDIR/tg-$1.txt" ] ; then
1175 cat "$TG_INST_SHAREDIR/tg-$1.txt"
1176 fi
1177 }
1178 page output "$1"
1179 else
1180 echo "${0##*/}: no help for $1" 1>&2
1181 do_help
1182 exit 1
1183 fi
1184 }
1185
1186 check_status()
1187 {
1188 git_state=
1189 git_remove=
1190 if [ -e "$git_dir/MERGE_HEAD" ]; then
1191 git_state="merge"
1192 elif [ -e "$git_dir/rebase-apply/applying" ]; then
1193 git_state="am"
1194 git_remove="$git_dir/rebase-apply"
1195 elif [ -e "$git_dir/rebase-apply" ]; then
1196 git_state="rebase"
1197 git_remove="$git_dir/rebase-apply"
1198 elif [ -e "$git_dir/rebase-merge" ]; then
1199 git_state="rebase"
1200 git_remove="$git_dir/rebase-merge"
1201 elif [ -e "$git_dir/CHERRY_PICK_HEAD" ]; then
1202 git_state="cherry-pick"
1203 elif [ -e "$git_dir/BISECT_LOG" ]; then
1204 git_state="bisect"
1205 elif [ -e "$git_dir/REVERT_HEAD" ]; then
1206 git_state="revert"
1207 fi
1208 git_remove="${git_remove#./}"
1209
1210 tg_state=
1211 tg_remove=
1212 if [ -e "$git_dir/tg-update" ]; then
1213 tg_state="update"
1214 tg_remove="$git_dir/tg-update"
1215 fi
1216 tg_remove="${tg_remove#./}"
1217 }
1218
1219 # Show status information
1220 do_status()
1221 {
1222 do_status_result=0
1223 do_status_verbose=
1224 do_status_help=
1225 abbrev=refs
1226 pfx=
1227 while [ $# -gt 0 ] && case "$1" in
1228 --help|-h)
1229 do_status_help=1
1230 break;;
1231 -vv)
1232 # kludge in this common bundling option
1233 abbrev=
1234 do_status_verbose=1
1235 pfx="## "
1236 ;;
1237 --verbose|-v)
1238 [ -z "$do_status_verbose" ] || abbrev=
1239 do_status_verbose=1
1240 pfx="## "
1241 ;;
1242 --exit-code)
1243 do_status_result=2
1244 ;;
1245 *)
1246 die "unknown status argument: $1"
1247 ;;
1248 esac; do shift; done
1249 if [ -n "$do_status_help" ]; then
1250 echo "Usage: ${tgname:-tg} @tgsthelpusage@"
1251 return
1252 fi
1253 check_status
1254 symref="$(git symbolic-ref --quiet HEAD)" || :
1255 headrv="$(git rev-parse --quiet --verify ${abbrev:+--short} HEAD --)" || :
1256 if [ -n "$symref" ]; then
1257 uprefpart=
1258 if [ -n "$headrv" ]; then
1259 upref="$(git rev-parse --symbolic-full-name @{upstream} 2>/dev/null)" || :
1260 if [ -n "$upref" ]; then
1261 uprefpart=" ... ${upref#$abbrev/remotes/}"
1262 mbase="$(git merge-base HEAD "$upref")" || :
1263 ahead="$(git rev-list --count HEAD ${mbase:+--not $mbase})" || ahead=0
1264 behind="$(git rev-list --count "$upref" ${mbase:+--not $mbase})" || behind=0
1265 [ "$ahead$behind" = "00" ] || uprefpart="$uprefpart ["
1266 [ "$ahead" = "0" ] || uprefpart="${uprefpart}ahead $ahead"
1267 [ "$ahead" = "0" ] || [ "$behind" = "0" ] || uprefpart="$uprefpart, "
1268 [ "$behind" = "0" ] || uprefpart="${uprefpart}behind $behind"
1269 [ "$ahead$behind" = "00" ] || uprefpart="$uprefpart]"
1270 fi
1271 fi
1272 echol "${pfx}HEAD -> ${symref#$abbrev/heads/} [${headrv:-unborn}]$uprefpart"
1273 else
1274 echol "${pfx}HEAD -> ${headrv:-?}"
1275 fi
1276 if [ -n "$tg_state" ]; then
1277 extra=
1278 if [ "$tg_state" = "update" ]; then
1279 IFS= read -r uname <"$git_dir/tg-update/name" || :
1280 [ -z "$uname" ] ||
1281 extra="; currently updating branch '$uname'"
1282 fi
1283 echol "${pfx}tg $tg_state in progress$extra"
1284 if [ -s "$git_dir/tg-update/fullcmd" ] && [ -s "$git_dir/tg-update/names" ]; then
1285 printf "${pfx}You are currently updating as a result of:\n${pfx} "
1286 cat "$git_dir/tg-update/fullcmd"
1287 bcnt="$(( $(wc -w < "$git_dir/tg-update/names") ))"
1288 if [ $bcnt -gt 1 ]; then
1289 pcnt=0
1290 ! [ -s "$git_dir/tg-update/processed" ] ||
1291 pcnt="$(( $(wc -w < "$git_dir/tg-update/processed") ))"
1292 echo "${pfx}$pcnt of $bcnt branches updated so far"
1293 fi
1294 fi
1295 if [ "$tg_state" = "update" ]; then
1296 echol "${pfx}"' (use "tg update --continue" to continue)'
1297 echol "${pfx}"' (use "tg update --skip" to skip this branch and continue)'
1298 echol "${pfx}"' (use "tg update --stop" to stop and retain updates so far)'
1299 echol "${pfx}"' (use "tg update --abort" to restore pre-update state)'
1300 fi
1301 fi
1302 [ -z "$git_state" ] || echo "${pfx}git $git_state in progress"
1303 if [ "$git_state" = "merge" ]; then
1304 ucnt="$(( $(git ls-files --unmerged --full-name --abbrev :/ | wc -l) ))"
1305 if [ $ucnt -gt 0 ]; then
1306 echo "${pfx}"'fix conflicts and then "git commit" the result'
1307 else
1308 echo "${pfx}"'all conflicts fixed; run "git commit" to record result'
1309 fi
1310 fi
1311 if [ -z "$git_state" ]; then
1312 gsp="$(git status --porcelain 2>/dev/null)" || return 0 # bare repository
1313 gspcnt=0
1314 [ -z "$gsp" ] ||
1315 gspcnt="$(( $(printf '%s\n' "$gsp" | LC_ALL=C sed -n '/^??/!p' | wc -l) ))"
1316 untr=
1317 if [ "$gspcnt" -eq 0 ]; then
1318 [ -z "$gsp" ] || untr="; non-ignored, untracked files present"
1319 echo "${pfx}working directory is clean$untr"
1320 [ -n "$tg_state" ] || do_status_result=0
1321 else
1322 echo "${pfx}working directory is DIRTY"
1323 [ -z "$do_status_verbose" ] || git status --short --untracked-files=no
1324 fi
1325 fi
1326 }
1327
1328 ## Pager stuff
1329
1330 # isatty FD
1331 isatty()
1332 {
1333 test -t $1
1334 }
1335
1336 # pass "diff" to get pager.diff
1337 # if pager.$1 is a boolean false returns cat
1338 # if set to true or unset fails
1339 # otherwise succeeds and returns the value
1340 get_pager()
1341 {
1342 if _x="$(git config --bool "pager.$1" 2>/dev/null)"; then
1343 [ "$_x" != "true" ] || return 1
1344 echo "cat"
1345 return 0
1346 fi
1347 if _x="$(git config "pager.$1" 2>/dev/null)"; then
1348 echol "$_x"
1349 return 0
1350 fi
1351 return 1
1352 }
1353
1354 # setup_pager
1355 # Set TG_PAGER to a valid executable
1356 # After calling, code to be paged should be surrounded with {...} | eval "$TG_PAGER"
1357 # See also the following "page" function for ease of use
1358 # emptypager will be set to 1 (otherwise empty) if TG_PAGER was set to "cat" to not be empty
1359 # Preference is (same as Git):
1360 # 1. GIT_PAGER
1361 # 2. pager.$USE_PAGER_TYPE (but only if USE_PAGER_TYPE is set and so is pager.$USE_PAGER_TYPE)
1362 # 3. core.pager (only if set)
1363 # 4. PAGER
1364 # 5. git var GIT_PAGER
1365 # 6. less
1366 setup_pager()
1367 {
1368 isatty 1 || { emptypager=1; TG_PAGER=cat; return 0; }
1369
1370 emptypager=
1371 if [ -z "$TG_PAGER_IN_USE" ]; then
1372 # TG_PAGER = GIT_PAGER | PAGER | less
1373 # NOTE: GIT_PAGER='' is significant
1374 if [ -n "${GIT_PAGER+set}" ]; then
1375 TG_PAGER="$GIT_PAGER"
1376 elif [ -n "$USE_PAGER_TYPE" ] && _dp="$(get_pager "$USE_PAGER_TYPE")"; then
1377 TG_PAGER="$_dp"
1378 elif _cp="$(git config core.pager 2>/dev/null)"; then
1379 TG_PAGER="$_cp"
1380 elif [ -n "${PAGER+set}" ]; then
1381 TG_PAGER="$PAGER"
1382 else
1383 _gp="$(git var GIT_PAGER 2>/dev/null)" || :
1384 [ "$_gp" != ":" ] || _gp=
1385 TG_PAGER="${_gp:-less}"
1386 fi
1387 if [ -z "$TG_PAGER" ]; then
1388 emptypager=1
1389 TG_PAGER=cat
1390 fi
1391 else
1392 emptypager=1
1393 TG_PAGER=cat
1394 fi
1395
1396 # Set pager default environment variables
1397 # see pager.c:setup_pager
1398 if [ -z "${LESS+set}" ]; then
1399 LESS="-FRX"
1400 export LESS
1401 fi
1402 if [ -z "${LV+set}" ]; then
1403 LV="-c"
1404 export LV
1405 fi
1406
1407 # this is needed so e.g. $(git diff) will still colorize it's output if
1408 # requested in ~/.gitconfig with color.diff=auto
1409 GIT_PAGER_IN_USE=1
1410 export GIT_PAGER_IN_USE
1411
1412 # this is needed so we don't get nested pagers
1413 TG_PAGER_IN_USE=1
1414 export TG_PAGER_IN_USE
1415 }
1416
1417 # page eval_arg [arg ...]
1418 #
1419 # Calls setup_pager then evals the first argument passing it all the rest
1420 # where the output is piped through eval "$TG_PAGER" unless emptypager is set
1421 # by setup_pager (in which case the output is left as-is).
1422 #
1423 # To handle arbitrary paging duties, collect lines to be paged into a
1424 # function and then call page with the function name or perhaps func_name "$@".
1425 #
1426 # If no arguments at all are passed in do nothing (return with success).
1427 page()
1428 {
1429 [ $# -gt 0 ] || return 0
1430 setup_pager
1431 _evalarg="$1"; shift
1432 if [ -n "$emptypager" ]; then
1433 eval "$_evalarg" '"$@"'
1434 else
1435 eval "$_evalarg" '"$@"' | eval "$TG_PAGER"
1436 fi
1437 }
1438
1439 # get_temp NAME [-d]
1440 # creates a new temporary file (or directory with -d) in the global
1441 # temporary directory $tg_tmp_dir with pattern prefix NAME
1442 get_temp()
1443 {
1444 mktemp $2 "$tg_tmp_dir/$1.XXXXXX"
1445 }
1446
1447 # automatically called by strftime
1448 # does nothing if already setup
1449 # may be called explicitly if the first call would otherwise be in a subshell
1450 # so that the setup is only done once before subshells start being spawned
1451 setup_strftime()
1452 {
1453 [ -z "$strftime_is_setup" ] || return 0
1454
1455 # date option to format raw epoch seconds values
1456 daterawopt=
1457 _testes='951807788'
1458 _testdt='2000-02-29 07:03:08 UTC'
1459 _testfm='%Y-%m-%d %H:%M:%S %Z'
1460 if [ "$(TZ=UTC date "-d@$_testes" "+$_testfm" 2>/dev/null)" = "$_testdt" ]; then
1461 daterawopt='-d@'
1462 elif [ "$(TZ=UTC date "-r$_testes" "+$_testfm" 2>/dev/null)" = "$_testdt" ]; then
1463 daterawopt='-r'
1464 fi
1465 strftime_is_setup=1
1466 }
1467
1468 # $1 => strftime format string to use
1469 # $2 => raw timestamp as seconds since epoch
1470 # $3 => optional time zone string (empty/absent for local time zone)
1471 strftime()
1472 {
1473 setup_strftime
1474 if [ -n "$daterawopt" ]; then
1475 if [ -n "$3" ]; then
1476 TZ="$3" date "$daterawopt$2" "+$1"
1477 else
1478 date "$daterawopt$2" "+$1"
1479 fi
1480 else
1481 if [ -n "$3" ]; then
1482 TZ="$3" perl -MPOSIX=strftime -le 'print strftime($ARGV[0],localtime($ARGV[1]))' "$1" "$2"
1483 else
1484 perl -MPOSIX=strftime -le 'print strftime($ARGV[0],localtime($ARGV[1]))' "$1" "$2"
1485 fi
1486 fi
1487 }
1488
1489 setup_git_dirs()
1490 {
1491 [ -n "$git_dir" ] || git_dir="$(git rev-parse --git-dir)"
1492 if [ -n "$git_dir" ] && [ -d "$git_dir" ]; then
1493 git_dir="$(cd "$git_dir" && pwd)"
1494 fi
1495 if [ -z "$git_common_dir" ]; then
1496 if vcmp "$git_version" '>=' "2.5"; then
1497 # rev-parse --git-common-dir is broken and may give
1498 # an incorrect result unless the current directory is
1499 # already set to the top level directory
1500 git_common_dir="$(cd "./$(git rev-parse --show-cdup)" && cd "$(git rev-parse --git-common-dir)" && pwd)"
1501 else
1502 git_common_dir="$git_dir"
1503 fi
1504 fi
1505 [ -n "$git_dir" ] && [ -n "$git_common_dir" ] &&
1506 [ -d "$git_dir" ] && [ -d "$git_common_dir" ] || die "Not a git repository"
1507 git_hooks_dir="$git_common_dir/hooks"
1508 if vcmp "$git_version" '>=' "2.9" && gchp="$(git config --path --get core.hooksPath 2>/dev/null)" && [ -n "$gchp" ]; then
1509 case "$gchp" in
1510 /[!/]*)
1511 git_hooks_dir="$gchp"
1512 ;;
1513 *)
1514 [ -n "$1" ] || warn "ignoring non-absolute core.hooksPath: $gchp"
1515 ;;
1516 esac
1517 unset gchp
1518 fi
1519 }
1520
1521 basic_setup()
1522 {
1523 setup_git_dirs $1
1524 [ -n "$base_remote" ] || base_remote="$(git config topgit.remote 2>/dev/null)" || :
1525 tgsequester="$(git config --bool topgit.sequester 2>/dev/null)" || :
1526 tgnosequester=
1527 [ "$tgsequester" != "false" ] || tgnosequester=1
1528 unset tgsequester
1529
1530 # catch errors if topbases is used without being set
1531 unset tg_topbases_set
1532 topbases="programmer*:error"
1533 topbasesrx="programmer*:error}"
1534 oldbases="$topbases"
1535 }
1536
1537 ## Initial setup
1538 initial_setup()
1539 {
1540 # suppress the merge log editor feature since git 1.7.10
1541
1542 GIT_MERGE_AUTOEDIT=no
1543 export GIT_MERGE_AUTOEDIT
1544
1545 basic_setup $1
1546 iowopt=
1547 ! vcmp "$git_version" '>=' "2.5" || iowopt="--ignore-other-worktrees"
1548 auhopt=
1549 ! vcmp "$git_version" '>=' "2.9" || auhopt="--allow-unrelated-histories"
1550 root_dir="$(git rev-parse --show-cdup)"; root_dir="${root_dir:-.}"
1551 logrefupdates="$(git config --bool core.logallrefupdates 2>/dev/null)" || :
1552 [ "$logrefupdates" = "true" ] || logrefupdates=
1553
1554 # make sure root_dir doesn't end with a trailing slash.
1555
1556 root_dir="${root_dir%/}"
1557
1558 # create global temporary directories, inside GIT_DIR
1559
1560 tg_tmp_dir=
1561 trap 'rm -rf "$tg_tmp_dir"' EXIT
1562 trap 'exit 129' HUP
1563 trap 'exit 130' INT
1564 trap 'exit 131' QUIT
1565 trap 'exit 134' ABRT
1566 trap 'exit 143' TERM
1567 tg_tmp_dir="$(mktemp -d "$git_dir/tg-tmp.XXXXXX" 2>/dev/null)" || tg_tmp_dir=
1568 [ -n "$tg_tmp_dir" ] || tg_tmp_dir="$(mktemp -d "${TMPDIR:-/tmp}/tg-tmp.XXXXXX" 2>/dev/null)" || tg_tmp_dir=
1569 [ -n "$tg_tmp_dir" ] || [ -z "$TMPDIR" ] || tg_tmp_dir="$(mktemp -d "/tmp/tg-tmp.XXXXXX" 2>/dev/null)" || tg_tmp_dir=
1570 tg_ref_cache="$tg_tmp_dir/tg~ref-cache"
1571 [ -n "$tg_tmp_dir" ] && [ -w "$tg_tmp_dir" ] && { >"$tg_ref_cache"; } >/dev/null 2>&1 ||
1572 die "could not create a writable temporary directory"
1573
1574 # make sure global cache directory exists inside GIT_DIR or $tg_tmp_dir
1575
1576 user_id_no="$(id -u)" || :
1577 : "${user_id_no:=_99_}"
1578 tg_cache_dir="$git_common_dir/tg-cache"
1579 [ -d "$tg_cache_dir" ] || mkdir "$tg_cache_dir" >/dev/null 2>&1 || tg_cache_dir=
1580 [ -z "$tg_cache_dir" ] || tg_cache_dir="$tg_cache_dir/$user_id_no"
1581 [ -z "$tg_cache_dir" ] || [ -d "$tg_cache_dir" ] || mkdir "$tg_cache_dir" >/dev/null 2>&1 || tg_cache_dir=
1582 [ -z "$tg_cache_dir" ] || { >"$tg_cache_dir/.tgcache"; } >/dev/null 2>&1 || tg_cache_dir=
1583 if [ -z "$tg_cache_dir" ]; then
1584 tg_cache_dir="$tg_tmp_dir/tg-cache"
1585 [ -d "$tg_cache_dir" ] || mkdir "$tg_cache_dir" >/dev/null 2>&1 || tg_cache_dir=
1586 [ -z "$tg_cache_dir" ] || { >"$tg_cache_dir/.tgcache"; } >/dev/null 2>&1 || tg_cache_dir=
1587 fi
1588 [ -n "$tg_cache_dir" ] ||
1589 die "could not create a writable tg-cache directory (even a temporary one)"
1590
1591 # GIT_ALTERNATE_OBJECT_DIRECTORIES can contain double-quoted entries
1592 # since Git v2.11.1; however, it's only necessary for : (or perhaps ;)
1593 # so we avoid it if possible and require v2.11.1 to do it at all
1594 # otherwise just don't make an alternates temporary store in that case;
1595 # it's okay to not have one; everything will still work; the nicety of
1596 # making the temporary tree objects vanish when tg exits just won't
1597 # happen in that case but nothing will break also be sure to reuse
1598 # the parent's if we've been recursively invoked and it's for the
1599 # same repository we were invoked on
1600
1601 tg_use_alt_odb=1
1602 _odbdir="${GIT_OBJECT_DIRECTORY:-$git_common_dir/objects}"
1603 [ -n "$_odbdir" ] && [ -d "$_odbdir" ] || tg_use_alt_odb=
1604 _fulltmpdir=
1605 [ -z "$tg_use_alt_odb" ] || _fulltmpdir="$(cd "$tg_tmp_dir" && pwd -P)"
1606 case "$_fulltmpdir" in *[";:"]*) vcmp "$git_version" '>=' "2.11.1" || tg_use_alt_odb=; esac
1607 _fullodbdir=
1608 [ -z "$tg_use_alt_odb" ] || _fullodbdir="$(cd "$_odbdir" && pwd -P)"
1609 if [ -n "$tg_use_alt_odb" ] && [ -n "$TG_OBJECT_DIRECTORY" ] && [ -d "$TG_OBJECT_DIRECTORY/info" ] &&
1610 [ -f "$TG_OBJECT_DIRECTORY/info/alternates" ] && [ -r "$TG_OBJECT_DIRECTORY/info/alternates" ]; then
1611 if IFS= read -r _otherodbdir <"$TG_OBJECT_DIRECTORY/info/alternates" &&
1612 [ -n "$_otherodbdir" ] && [ "$_otherodbdir" = "$_fullodbdir" ]; then
1613 tg_use_alt_odb=2
1614 fi
1615 fi
1616 if [ "$tg_use_alt_odb" = "1" ]; then
1617 # create an alternate objects database to keep the ephemeral objects in
1618 mkdir -p "$tg_tmp_dir/objects/info"
1619 echol "$_fullodbdir" >"$tg_tmp_dir/objects/info/alternates"
1620 TG_OBJECT_DIRECTORY="$_fulltmpdir/objects"
1621 case "$TG_OBJECT_DIRECTORY" in
1622 *[";:"]*)
1623 # surround in "..." and backslash-escape internal '"' and '\\'
1624 _altodbdq="\"$(printf '%s\n' "$TG_OBJECT_DIRECTORY" |
1625 LC_ALL=C sed 's/\([""\\]\)/\\\1/g')\""
1626 ;;
1627 *)
1628 _altodbdq="$TG_OBJECT_DIRECTORY"
1629 ;;
1630 esac
1631 TG_PRESERVED_ALTERNATES="$GIT_ALTERNATE_OBJECT_DIRECTORIES"
1632 if [ -n "$GIT_ALTERNATE_OBJECT_DIRECTORIES" ]; then
1633 GIT_ALTERNATE_OBJECT_DIRECTORIES="$_altodbdq:$GIT_ALTERNATE_OBJECT_DIRECTORIES"
1634 else
1635 GIT_ALTERNATE_OBJECT_DIRECTORIES="$_altodbdq"
1636 fi
1637 export TG_PRESERVED_ALTERNATES TG_OBJECT_DIRECTORY GIT_ALTERNATE_OBJECT_DIRECTORIES GIT_OBJECT_DIRECTORY
1638 fi
1639 }
1640
1641 set_topbases()
1642 {
1643 # refer to "top-bases" in a refname with $topbases
1644
1645 [ -z "$tg_topbases_set" ] || return 0
1646
1647 topbases_implicit_default=1
1648 # See if topgit.top-bases is set to heads or refs
1649 tgtb="$(git config "topgit.top-bases" 2>/dev/null)" || :
1650 if [ -n "$tgtb" ] && [ "$tgtb" != "heads" ] && [ "$tgtb" != "refs" ]; then
1651 if [ -n "$1" ]; then
1652 # never die on the hook script
1653 unset tgtb
1654 else
1655 die "invalid \"topgit.top-bases\" setting (must be \"heads\" or \"refs\")"
1656 fi
1657 fi
1658 if [ -n "$tgtb" ]; then
1659 case "$tgtb" in
1660 heads)
1661 topbases="heads/{top-bases}"
1662 topbasesrx="heads/[{]top-bases[}]"
1663 oldbases="top-bases";;
1664 refs)
1665 topbases="top-bases"
1666 topbasesrx="top-bases"
1667 oldbases="heads/{top-bases}";;
1668 esac
1669 # MUST NOT be exported
1670 unset tgtb tg_topbases_set topbases_implicit_default
1671 tg_topbases_set=1
1672 return 0
1673 fi
1674 unset tgtb
1675
1676 # check heads and top-bases and see what state the current
1677 # repository is in. remotes are ignored.
1678
1679 hblist=" "
1680 topbases=
1681 both=
1682 newtb="heads/{top-bases}"
1683 while read -r rn && [ -n "$rn" ]; do case "$rn" in
1684 "refs/heads/{top-bases}"/*)
1685 case "$hblist" in *" ${rn#refs/$newtb/} "*)
1686 if [ "$topbases" != "heads/{top-bases}" ] && [ -n "$topbases" ]; then
1687 both=1
1688 break;
1689 else
1690 topbases="heads/{top-bases}"
1691 topbasesrx="heads/[{]top-bases[}]"
1692 oldbases="top-bases"
1693 fi
1694 esac;;
1695 "refs/top-bases"/*)
1696 case "$hblist" in *" ${rn#refs/top-bases/} "*)
1697 if [ "$topbases" != "top-bases" ] && [ -n "$topbases" ]; then
1698 both=1
1699 break;
1700 else
1701 topbases="top-bases"
1702 topbasesrx="top-bases"
1703 oldbases="heads/{top-bases}"
1704 fi
1705 esac;;
1706 "refs/heads"/*)
1707 hblist="$hblist${rn#refs/heads/} ";;
1708 esac; done <<-EOT
1709 $(git for-each-ref --format='%(refname)' "refs/heads" "refs/top-bases" 2>/dev/null)
1710 EOT
1711 if [ -n "$both" ]; then
1712 if [ -n "$1" ]; then
1713 # hook script always prefers newer without complaint
1714 topbases="heads/{top-bases}"
1715 topbasesrx="heads/[{]top-bases[}]"
1716 oldbases="top-bases"
1717 else
1718 # Complain and die
1719 err "repository contains existing TopGit branches"
1720 err "but some use refs/top-bases/... for the base"
1721 err "and some use refs/heads/{top-bases}/... for the base"
1722 err "with the latter being the new, preferred location"
1723 err "set \"topgit.top-bases\" to either \"heads\" to use"
1724 err "the new heads/{top-bases} location or \"refs\" to use"
1725 err "the old top-bases location."
1726 err "(the tg migrate-bases command can also resolve this issue)"
1727 die "schizophrenic repository requires topgit.top-bases setting"
1728 fi
1729 elif [ -n "$topbases" ]; then
1730 unset topbases_implicit_default
1731 fi
1732
1733 [ -n "$topbases" ] || {
1734 # default is still top-bases for now
1735 topbases="top-bases"
1736 topbasesrx="top-bases"
1737 oldbases="heads/{top-bases}"
1738 }
1739 # MUST NOT be exported
1740 unset hblist both newtb rn tg_topases_set
1741 tg_topbases_set=1
1742 return 0
1743 }
1744
1745 # init_reflog "ref"
1746 # if "$logrefupdates" is set and ref is not under refs/heads/ then force
1747 # an empty log file to exist so that ref changes will be logged
1748 # "$1" must be a fully-qualified refname (i.e. start with "refs/")
1749 # However, if "$1" is "refs/tgstash" then always make the reflog
1750 # The only ref not under refs/ that Git will write a reflog for is HEAD;
1751 # no matter what, it will NOT update a reflog for any other bare refs so
1752 # just quietly succeed when passed TG_STASH without doing anything.
1753 init_reflog()
1754 {
1755 [ -n "$1" ] && [ "$1" != "TG_STASH" ] || return 0
1756 [ -n "$logrefupdates" ] || [ "$1" = "refs/tgstash" ] || return 0
1757 case "$1" in refs/heads/*|HEAD) return 0;; refs/*[!/]);; *) return 1; esac
1758 mkdir -p "$git_common_dir/logs/${1%/*}" 2>/dev/null || :
1759 { >>"$git_common_dir/logs/$1" || :; } 2>/dev/null
1760 }
1761
1762 # store the "realpath" for "$2" in "$1" except the leaf is not resolved if it's
1763 # a symbolic link. The directory part must exist, but the basename need not.
1764 v_get_abs_path()
1765 {
1766 [ -n "$1" ] && [ -n "$2" ] || return 1
1767 set -- "$1" "$2" "${2%/}"
1768 case "$3" in
1769 */*) set -- "$1" "$2" "${3%/*}";;
1770 * ) set -- "$1" "$2" ".";;
1771 esac
1772 [ -d "$3" ] || return 1
1773 eval "$1="'"$(cd "$3" && pwd -P)/${2##*/}"'
1774 }
1775
1776 ## Startup
1777
1778 : "${TG_INST_CMDDIR:=@cmddir@}"
1779 : "${TG_INST_SHAREDIR:=@sharedir@}"
1780 : "${TG_INST_HOOKSDIR:=@hooksdir@}"
1781
1782 [ -d "$TG_INST_CMDDIR" ] ||
1783 die "No command directory: '$TG_INST_CMDDIR'"
1784
1785 if [ -n "$tg__include" ]; then
1786
1787 # We were sourced from another script for our utility functions;
1788 # this is set by hooks. Skip the rest of the file. A simple return doesn't
1789 # work as expected in every shell. See http://bugs.debian.org/516188
1790
1791 # ensure setup happens
1792
1793 initial_setup 1
1794 set_topbases 1
1795
1796 else
1797
1798 set -e
1799
1800 tg="$0"
1801 tgdir="${tg%/}"
1802 case "$tgdir" in */*);;*) tgdir="./$tgdir"; esac
1803 tgdir="${tgdir%/*}/"
1804 tgname="${tg##*/}"
1805 [ "$0" != "$tgname" ] || tgdir=""
1806
1807 # If tg contains a '/' but does not start with one then replace it with an absolute path
1808
1809 case "$0" in /*) ;; */*)
1810 tgdir="$(cd "${0%/*}" && pwd -P)/"
1811 tg="$tgdir$tgname"
1812 esac
1813
1814 # If the tg in the PATH is the same as "$tg" just display the basename
1815 # tgdisplay will include any explicit -C <dir> option whereas tg will not
1816
1817 tgdisplaydir="$tgdir"
1818 tgdisplay="$tg"
1819 if
1820 v_get_abs_path _tgabs "$tg" &&
1821 v_get_abs_path _tgnameabs "$(cmd_path "$tgname")" &&
1822 [ "$_tgabs" = "$_tgnameabs" ]
1823 then
1824 tgdisplaydir=""
1825 tgdisplay="$tgname"
1826 fi
1827 unset _tgabs _tgnameabs
1828
1829 explicit_remote=
1830 explicit_dir=
1831 gitcdopt=
1832 noremote=
1833
1834 cmd=
1835 while :; do case "$1" in
1836
1837 help|--help|-h)
1838 cmd=help
1839 shift
1840 break;;
1841
1842 status|--status)
1843 cmd=status
1844 shift
1845 break;;
1846
1847 --hooks-path)
1848 cmd=hooks-path
1849 shift
1850 break;;
1851
1852 --top-bases)
1853 cmd=top-bases
1854 shift
1855 break;;
1856
1857 -r)
1858 shift
1859 if [ -z "$1" ]; then
1860 echo "Option -r requires an argument." >&2
1861 do_help
1862 exit 1
1863 fi
1864 unset noremote
1865 base_remote="$1"
1866 explicit_remote="$base_remote"
1867 tg="$tgdir$tgname -r $explicit_remote"
1868 tgdisplay="$tgdisplaydir$tgname"
1869 [ -z "$explicit_dir" ] || tgdisplay="$tgdisplay -C \"$explicit_dir\""
1870 tgdisplay="$tgdisplay -r $explicit_remote"
1871 shift;;
1872
1873 -u)
1874 unset base_remote explicit_remote
1875 noremote=1
1876 tg="$tgdir$tgname -u"
1877 tgdisplay="$tgdisplaydir$tgname"
1878 [ -z "$explicit_dir" ] || tgdisplay="$tgdisplay -C \"$explicit_dir\""
1879 tgdisplay="$tgdisplay -u"
1880 shift;;
1881
1882 -C)
1883 shift
1884 if [ -z "$1" ]; then
1885 echo "Option -C requires an argument." >&2
1886 do_help
1887 exit 1
1888 fi
1889 cd "$1"
1890 unset GIT_DIR GIT_COMMON_DIR
1891 explicit_dir="$1"
1892 gitcdopt=" -C \"$explicit_dir\""
1893 tg="$tgdir$tgname"
1894 tgdisplay="$tgdisplaydir$tgname -C \"$explicit_dir\""
1895 [ -z "$explicit_remote" ] || tg="$tg -r $explicit_remote"
1896 [ -z "$explicit_remote" ] || tgdisplay="$tgdisplay -r $explicit_remote"
1897 [ -z "$noremote" ] || tg="$tg -u"
1898 [ -z "$noremote" ] || tg="$tgdisplay -u"
1899 shift;;
1900
1901 -c)
1902 shift
1903 if [ -z "$1" ]; then
1904 echo "Option -c requires an argument." >&2
1905 do_help
1906 exit 1
1907 fi
1908 param="'$(printf '%s\n' "$1" | sed "s/[']/'\\\\''/g")'"
1909 GIT_CONFIG_PARAMETERS="${GIT_CONFIG_PARAMETERS:+$GIT_CONFIG_PARAMETERS }$param"
1910 export GIT_CONFIG_PARAMETERS
1911 shift;;
1912
1913 --)
1914 shift
1915 break;;
1916
1917 -*)
1918 echo "Invalid option $1 (subcommand options must appear AFTER the subcommand)." >&2
1919 do_help
1920 exit 1;;
1921
1922 *)
1923 break;;
1924
1925 esac; done
1926
1927 [ -n "$cmd" -o $# -lt 1 ] || { cmd="$1"; shift; }
1928
1929 ## Dispatch
1930
1931 [ -n "$cmd" ] || { do_help; exit 1; }
1932
1933 case "$cmd" in
1934
1935 help)
1936 do_help "$@"
1937 exit 0;;
1938
1939 status|st)
1940 unset base_remote
1941 basic_setup
1942 set_topbases
1943 do_status "$@"
1944 exit ${do_status_result:-0};;
1945
1946 hooks-path)
1947 # Internal command
1948 echol "$TG_INST_HOOKSDIR";;
1949
1950 top-bases)
1951 # Maintenance command
1952 ! git rev-parse --git-dir >/dev/null 2>&1 || setup_git_dirs
1953 set_topbases
1954 echol "refs/$topbases";;
1955
1956 *)
1957 isutil=
1958 case "$cmd" in index-merge-one-file)
1959 isutil="-"
1960 esac
1961 [ -r "$TG_INST_CMDDIR"/tg-$isutil$cmd ] || {
1962 looplevel="$TG_ALIAS_DEPTH"
1963 [ "${looplevel#[1-9]}" != "$looplevel" ] &&
1964 [ "${looplevel%%[!0-9]*}" = "$looplevel" ] ||
1965 looplevel=0
1966 tgalias="$(git config "topgit.alias.$cmd" 2>/dev/null)" || :
1967 [ -n "$tgalias" ] || {
1968 echo "Unknown subcommand: $cmd" >&2
1969 do_help
1970 exit 1
1971 }
1972 looplevel=$(( $looplevel + 1 ))
1973 [ $looplevel -le 10 ] || die "topgit.alias nesting level 10 exceeded"
1974 TG_ALIAS_DEPTH="$looplevel"
1975 export TG_ALIAS_DEPTH
1976 if [ "!${tgalias#?}" = "$tgalias" ]; then
1977 unset GIT_PREFIX
1978 if pfx="$(git rev-parse --show-prefix 2>/dev/null)"; then
1979 GIT_PREFIX="$pfx"
1980 export GIT_PREFIX
1981 fi
1982 cd "./$(git rev-parse --show-cdup 2>/dev/null)"
1983 exec @SHELL_PATH@ -c "${tgalias#?} \"\$@\"" @SHELL_PATH@ "$@"
1984 else
1985 eval 'exec "$tgbin"' "$tgalias" '"$@"'
1986 fi
1987 die "alias execution failed for: $tgalias"
1988 }
1989 unset TG_ALIAS_DEPTH
1990
1991 showing_help=
1992 if [ "$*" = "-h" ] || [ "$*" = "--help" ]; then
1993 showing_help=1
1994 fi
1995
1996 [ -n "$showing_help" ] || initial_setup
1997 [ -z "$noremote" ] || unset base_remote
1998
1999 nomergesetup="$showing_help"
2000 case "$cmd" in base|contains|info|log|rebase|revert|summary|tag)
2001 # avoid merge setup where not necessary
2002
2003 nomergesetup=1
2004 esac
2005
2006 if [ -z "$nomergesetup" ]; then
2007 # make sure merging the .top* files will always behave sanely
2008
2009 setup_ours
2010 setup_hook "pre-commit"
2011 fi
2012
2013 # everything but rebase needs topbases set
2014 carefully="$showing_help"
2015 [ "$cmd" != "migrate-bases" ] || carefully=1
2016 [ "$cmd" = "rebase" ] || set_topbases $carefully
2017
2018 _use_ref_cache=
2019 tg_read_only=1
2020 case "$cmd$showing_help" in
2021 contains|export|info|summary|tag)
2022 _use_ref_cache=1;;
2023 annihilate|create|delete|depend|import|update)
2024 tg_use_alt_odb=
2025 tg_read_only=;;
2026 esac
2027 [ -z "$_use_ref_cache" ] || v_create_ref_cache
2028
2029 fullcmd="${tgname:-tg} $cmd $*"
2030 . "$TG_INST_CMDDIR"/tg-$isutil$cmd;;
2031 esac
2032
2033 fi
TopGit - A different patch queue manager