?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tg-info.sh: with --series=<name> HEAD may be detached
[topgit/pro.git] / tg-update.sh
blob81fab693119d26bd7d90885130ff716deec303a2
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> 2015,2016,2017
5 # All rights reserved.
6 # GPLv2
7
8 names= # Branch(es) to update
9 name1= # first name
10 name2= # second name
11 namecnt=0 # how many names were seen
12 all= # Update all branches
13 pattern= # Branch selection filter for -a
14 current= # Branch we are currently on
15 skipms= # skip missing dependencies
16 stash= # tgstash refs before changes
17 quiet= # be quieter
18 basemode= # true if --base active
19 editmode= # 0, 1 or empty to force none, force edit or default
20 basemsg= # message for --base merge commit
21 basefile= # message file for --base merge commit
22 basenc= # --no-commit on merge
23 basefrc= # --force non-ff update
24 setautoupdate=1 # temporarily set rerere.autoUpdate to true
25
26 if [ "$(git config --get --bool topgit.autostash 2>/dev/null)" != "false" ]; then
27 # topgit.autostash is true (or unset)
28 stash=1
29 fi
30
31 ## Parse options
32
33 USAGE="\
34 Usage: ${tgname:-tg} [...] update [--[no-]stash] [--skip-missing] ([<name>...] | -a [<pattern>...])
35 Or: ${tgname:-tg} [...] update --base [-F <file> | -m <msg>] [--[no-]edit] [-f] <base-branch> <ref>
36 Or: ${tgname:-tg} [...] update --continue | -skip | --stop | --abort"
37
38 usage()
39 {
40 if [ "${1:-0}" != 0 ]; then
41 printf '%s\n' "$USAGE" >&2
42 else
43 printf '%s\n' "$USAGE"
44 fi
45 exit ${1:-0}
46 }
47
48 # --base mode comes here with $1 set to <base-branch> and $2 set to <ref>
49 # and all options already parsed and validated into above-listed flags
50 # this function should exit after returning to "$current"
51 do_base_mode()
52 {
53 v_verify_topgit_branch tgbranch "$1"
54 depcnt="$(( $(git cat-file blob "refs/heads/$tgbranch:.topdeps" 2>/dev/null | wc -l) ))"
55 if [ $depcnt -gt 0 ]; then
56 grammar="dependency"
57 [ $depcnt -eq 1 ] || grammar="dependencies"
58 die "'$tgbranch' is not a TopGit [BASE] branch (it has $depcnt $grammar)"
59 fi
60 newrev="$(git rev-parse --verify "$2^0" --)" && [ -n "$newrev" ] ||
61 die "not a valid commit-ish: $2"
62 baserev="$(ref_exists_rev "refs/$topbases/$tgbranch")" && [ -n "$baserev" ] ||
63 die "unable to get current base commit for branch '$tgbranch'"
64 if [ "$baserev" = "$newrev" ]; then
65 [ -n "$quiet" ] || echo "No change"
66 exit 0
67 fi
68 alreadymerged=
69 ! contained_by "$newrev" "refs/heads/$tgbranch" || alreadymerged=1
70 if [ -z "$basefrc" ] && ! contained_by "$baserev" "$newrev"; then
71 die "Refusing non-fast-forward update of base without --force"
72 fi
73
74 # check that we can checkout the branch
75
76 [ -n "$alreadymerged" ] || git read-tree -n -u -m "refs/heads/$tgbranch" ||
77 die "git checkout \"$branch\" would fail"
78
79 # and make sure everything's clean and we know who we are
80
81 [ -n "$alreadymerged" ] || ensure_clean_tree
82 ensure_ident_available
83
84 # always auto stash even if it's just to the anonymous stash TG_STASH
85
86 stashmsg="tgupdate: autostash before --base $tgbranch update"
87 if [ -n "$stash" ]; then
88 tg tag -q -q -m "$stashmsg" --stash "$tgbranch" &&
89 stashhash="$(git rev-parse --quiet --verify refs/tgstash --)" &&
90 [ -n "$stashhash" ] &&
91 [ "$(git cat-file -t "$stashhash" -- 2>/dev/null)" = "tag" ] ||
92 die "requested --stash failed"
93 else
94 tg tag --anonymous "$tgbranch" &&
95 stashhash="$(git rev-parse --quiet --verify TG_STASH --)" &&
96 [ -n "$stashhash" ] &&
97 [ "$(git cat-file -t "$stashhash" -- 2>/dev/null)" = "tag" ] ||
98 die "anonymous --stash failed"
99 fi
100
101 # proceed with the update
102
103 git update-ref -m "tg update --base $tgbranch $2" "refs/$topbases/$tgbranch" "$newrev" "$baserev" ||
104 die "Unable to update base ref"
105 if [ -n "$alreadymerged" ]; then
106 [ -n "$quiet" ] || echo "Already contained in branch (base updated)"
107 exit 0
108 fi
109 git checkout -q $iowopt "$tgbranch" || die "git checkout failed"
110 msgopt=
111 [ -z "$basemsg" ] || msgopt='-m "$basemsg"'
112 fileopt=
113 [ -z "$basefile" ] || fileopt='-F "$basefile"'
114 if [ -n "$editmode" ]; then
115 if [ "$editmode" = "0" ]; then
116 editopt="--no-edit"
117 else
118 editopt="--edit"
119 fi
120 else
121 if [ -z "$basemsg$basefile" ]; then
122 editopt="--edit"
123 basemsg="tg update --base $tgbranch $2"
124 msgopt='-m "$basemsg"'
125 else
126 editopt="--no-edit"
127 fi
128 fi
129 ncopt=
130 [ -z "$basenc" ] || ncopt="--no-commit"
131 eval git merge --no-ff --no-log --no-stat $auhopt $ncopt $editopt "$msgopt" "$fileopt" "refs/$topbases/$tgbranch" -- || exit
132 [ -n "$basenc" ] || checkout_symref_full "$current"
133 exit
134 }
135
136 state_dir="$git_dir/tg-update"
137 mergeours=
138 mergetheirs=
139 mergeresult=
140 stashhash=
141 next_no_auto=
142 merging_topfiles=
143
144 is_active() {
145 [ -d "$state_dir" ] || return 1
146 [ -s "$state_dir/fullcmd" ] || return 1
147 [ -f "$state_dir/remote" ] || return 1
148 [ -f "$state_dir/skipms" ] || return 1
149 [ -f "$state_dir/all" ] || return 1
150 [ -s "$state_dir/current" ] || return 1
151 [ -s "$state_dir/stashhash" ] || return 1
152 [ -s "$state_dir/name" ] || return 1
153 [ -s "$state_dir/names" ] || return 1
154 [ -f "$state_dir/processed" ] || return 1
155 [ -f "$state_dir/no_auto" ] || return 1
156 [ -f "$state_dir/setautoupdate" ] || return 1
157 [ -f "$state_dir/merging_topfiles" ] || return 1
158 [ -f "$state_dir/mergeours" ] || return 1
159 [ -f "$state_dir/mergeours" ] || return 1
160 if [ -s "$state_dir/mergeours" ]; then
161 [ -s "$state_dir/mergetheirs" ] || return 1
162 else
163 ! [ -s "$state_dir/mergetheirs" ] || return 1
164 fi
165 }
166
167 restore_state() {
168 is_active || die "programmer error"
169 IFS= read -r fullcmd <"$state_dir/fullcmd" && [ -n "$fullcmd" ]
170 IFS= read -r base_remote <"$state_dir/remote" || :
171 IFS= read -r skipms <"$state_dir/skipms" || :
172 IFS= read -r all <"$state_dir/all" || :
173 IFS= read -r current <"$state_dir/current" && [ -n "$current" ]
174 IFS= read -r stashhash <"$state_dir/stashhash" && [ -n "$stashhash" ]
175 IFS= read -r name <"$state_dir/name" && [ -n "$name" ]
176 IFS= read -r names <"$state_dir/names" && [ -n "$names" ]
177 IFS= read -r processed <"$state_dir/processed" || :
178 IFS= read -r next_no_auto <"$state_dir/no_auto" || :
179 IFS= read -r setautoupdate <"$state_dir/setautoupdate" || :
180 # merging_topfiles is for outside info but not to be restored
181 IFS= read -r mergeours <"$state_dir/mergeours" || :
182 IFS= read -r mergetheirs <"$state_dir/mergetheirs" || :
183 if [ -n "$mergeours" ] && [ -n "$mergetheirs" ]; then
184 headhash="$(git rev-parse --quiet --verify HEAD --)" || :
185 if [ -n "$headhash" ]; then
186 parents="$(git --no-pager log -n 1 --format='format:%P' "$headhash" -- 2>/dev/null)" || :
187 if [ "$parents" = "$mergeours $mergetheirs" ]; then
188 mergeresult="$headhash"
189 fi
190 fi
191 if [ -z "$mergeresult" ]; then
192 mergeours=
193 mergetheirs=
194 fi
195 fi
196 restored=1
197 }
198
199 clear_state() {
200 ! [ -e "$state_dir" ] || rm -rf "$state_dir" >/dev/null 2>&1 || :
201 }
202
203 restarted=
204 isactive=
205 ! is_active || isactive=1
206 isactiveopt=
207 if [ -z "$isactive" ] && [ $# -eq 1 ]; then
208 case "$1" in --abort|--stop|--continue|--skip) isactiveopt=1; esac
209 fi
210 if [ -n "$isactive" ] || [ -n "$isactiveopt" ]; then
211 [ $# -eq 1 ] && [ x"$1" != x"--status" ] || { do_status; exit 0; }
212 if [ -z "$isactive" ]; then
213 clear_state
214 info "No update is currently active"
215 exit 0
216 fi
217 case "$1" in
218 --abort)
219 current=
220 stashhash=
221 IFS= read -r current <"$state_dir/current" || :
222 IFS= read -r stashhash <"$state_dir/stashhash" || :
223 clear_state
224 if [ -n "$stashhash" ]; then
225 tg revert -f -q -q --no-stash "$stashhash" >/dev/null 2>&1 || :
226 fi
227 if [ -n "$current" ]; then
228 info "Ok, update aborted, returning to ${current#refs/heads/}"
229 checkout_symref_full -f "$current"
230 else
231 info "Ok, update aborted. Now, you just need to"
232 info "switch back to some sane branch using \`git$gitcdopt checkout\`."
233 fi
234 ! [ -f "$git_dir/TGMERGE_MSG" ] || [ -e "$git_dir/MERGE_MSG" ] ||
235 mv -f "$git_dir/TGMERGE_MSG" "$git_dir/MERGE_MSG" || :
236 exit 0
237 ;;
238 --stop)
239 clear_state
240 info "Ok, update stopped. Now, you just need to"
241 info "switch back to some sane branch using \`git$gitcdopt checkout\`."
242 ! [ -f "$git_dir/TGMERGE_MSG" ] || [ -e "$git_dir/MERGE_MSG" ] ||
243 mv -f "$git_dir/TGMERGE_MSG" "$git_dir/MERGE_MSG" || :
244 exit 0
245 ;;
246 --continue|--skip)
247 restore_state
248 if [ "$1" = "--skip" ]; then
249 info "Ok, I will try to continue without updating this branch."
250 git reset --hard -q
251 case " $processed " in *" $name "*);;*)
252 processed="${processed:+$processed }$name"
253 esac
254 fi
255 # assume user fixed it
256 # we could be left on a detached HEAD if we were resolving
257 # a conflict while merging a base in, fix it with a checkout
258 git checkout -q $iowopt "$(strip_ref "$name")"
259 ;;
260 *)
261 do_status
262 exit 1
263 esac
264 fi
265 clear_state
266
267 if [ -z "$restored" ]; then
268 setautoupdate=1
269 [ "$(git config --get --bool topgit.setAutoUpdate 2>/dev/null)" != "false" ] ||
270 setautoupdate=
271
272 while [ -n "$1" ]; do
273 arg="$1"; shift
274 case "$arg" in
275 -h)
276 usage;;
277 -a|--all)
278 [ -z "$names$pattern" ] || usage 1
279 all=1;;
280 --skip-missing)
281 skipms=1;;
282 --stash)
283 stash=1;;
284 --no-stash)
285 stash=;;
286 --auto|--auto-update|--set-auto|--set-auto-update)
287 setautoupdate=1;;
288 --no-auto|--no-auto-update|--no-set-auto|--no-set-auto-update)
289 setautoupdate=;;
290 --quiet|-q)
291 quiet=1;;
292 --base)
293 basemode=1;;
294 --edit|-e)
295 editmode=1;;
296 --no-edit)
297 editmode=0;;
298 --no-commit)
299 basenc=1;;
300 --force|-f)
301 basefrc=1;;
302 -m)
303 [ $# -gt 0 ] && [ -n "$1" ] || die "option -m requires an argument"
304 basemsg="$1"
305 shift;;
306 -m?*)
307 basemsg="${1#-m}";;
308 --message=*)
309 basemsg="${1#--message=}";;
310 -F)
311 [ $# -gt 0 ] && [ -n "$1" ] || die "option -F requires an argument"
312 basefile="$1"
313 shift;;
314 -F?*)
315 basefile="${1#-F}";;
316 --file=*)
317 basefile="${1#--file=}"
318 [ -n "$basefile" ] || die "option --file= requires an argument"
319 ;;
320 -?*)
321 usage 1;;
322 --)
323 break;;
324 "")
325 ;;
326 *)
327 if [ -z "$all" ]; then
328 namecnt=$(( $namecnt + 1 ))
329 [ "$namecnt" != "1" ] || name1="$arg"
330 [ "$namecnt" != "2" ] || name2="$arg"
331 names="${names:+$names }$arg"
332 else
333 pattern="${pattern:+$pattern }refs/$topbases/$(strip_ref "$arg")"
334 fi
335 ;;
336 esac
337 done
338 while [ $# -gt 0 ]; do
339 if [ -z "$all" ]; then
340 namecnt=$(( $namecnt + 1 ))
341 [ "$namecnt" != "1" ] || name1="$1"
342 [ "$namecnt" != "2" ] || name2="$1"
343 names="${names:+$names }$*"
344 else
345 pattern="${pattern:+$pattern }refs/$topbases/$(strip_ref "$1")"
346 fi
347 shift
348 done
349 [ -n "$basemode" ] || [ -z "$editmode$basemsg$basefile$basenc$basefrc" ] || usage 1
350 [ -z "$basemode" ] || [ -z "$all$skipms" ] || usage 1
351 [ -z "$basemode" ] || [ -z "$basemsg" ] || [ -z "$basefile" ] || usage 1
352 [ -z "$basemode" ] || [ "$namecnt" -eq 2 ] || usage 1
353
354 current="$(git symbolic-ref -q HEAD)" || :
355 if [ -n "$current" ]; then
356 [ -n "$(git rev-parse --verify --quiet HEAD --)" ] ||
357 die "cannot return to unborn branch; switch to another branch"
358 else
359 current="$(git rev-parse --verify --quiet HEAD)" ||
360 die "cannot return to invalid HEAD; switch to another branch"
361 fi
362
363 [ -z "$basemode" ] || do_base_mode "$name1" "$name2"
364
365 origpattern="$pattern"
366 [ -z "$pattern" ] && pattern="refs/$topbases"
367
368 processed=
369 [ -n "$all$names" ] || names="HEAD"
370 if [ -z "$all" ]; then
371 clean_names() {
372 names=
373 while [ $# -gt 0 ]; do
374 name="$(verify_topgit_branch "$1")"
375 case " $names " in *" $name "*);;*)
376 names="${names:+$names }$name"
377 esac
378 shift
379 done
380 }
381 clean_names $names
382 fi
383 ensure_clean_tree
384 fi
385
386 save_state() {
387 mkdir -p "$state_dir"
388 printf '%s\n' "$fullcmd" >"$state_dir/fullcmd"
389 printf '%s\n' "$base_remote" >"$state_dir/remote"
390 printf '%s\n' "$skipms" >"$state_dir/skipms"
391 printf '%s\n' "$all" >"$state_dir/all"
392 printf '%s\n' "$current" >"$state_dir/current"
393 printf '%s\n' "$stashhash" >"$state_dir/stashhash"
394 printf '%s\n' "$name" >"$state_dir/name"
395 printf '%s\n' "$names" >"$state_dir/names"
396 printf '%s\n' "$processed" >"$state_dir/processed"
397 printf '%s\n' "$no_auto" >"$state_dir/no_auto"
398 printf '%s\n' "$setautoupdate" >"$state_dir/setautoupdate"
399 # this one is an external flag and needs to be zero length for false
400 printf '%s' "$merging_topfiles" >"$state_dir/merging_topfiles"
401 printf '%s\n' "$1" >"$state_dir/mergeours"
402 printf '%s\n' "$2" >"$state_dir/mergetheirs"
403 }
404
405 stash_now_if_requested() {
406 [ -z "$TG_RECURSIVE" ] || return 0
407 [ -z "$stashhash" ] || return 0
408 ensure_ident_available
409 msg="tgupdate: autostash before update"
410 if [ -n "$all" ]; then
411 msg="$msg --all${origpattern:+ $origpattern}"
412 else
413 msg="$msg $names"
414 fi
415 set -- $names
416 if [ -n "$stash" ]; then
417 tg tag -q -q -m "$msg" --stash "$@" &&
418 stashhash="$(git rev-parse --quiet --verify refs/tgstash --)" &&
419 [ -n "$stashhash" ] &&
420 [ "$(git cat-file -t "$stashhash" -- 2>/dev/null)" = "tag" ] ||
421 die "requested --stash failed"
422 else
423 tg tag --anonymous "$@" &&
424 stashhash="$(git rev-parse --quiet --verify TG_STASH --)" &&
425 [ -n "$stashhash" ] &&
426 [ "$(git cat-file -t "$stashhash" -- 2>/dev/null)" = "tag" ] ||
427 die "anonymous --stash failed"
428 fi
429 [ -z "$next_no_auto" ] || no_auto="$next_no_auto"
430 next_no_auto=
431 }
432
433 recursive_update() {
434 _ret=0
435 on_base=
436 (
437 if [ -n "$TG_RECURSIVE" ]; then
438 TG_RECURSIVE="==> [$1]${TG_RECURSIVE#==>}"
439 else
440 TG_RECURSIVE="==> [$1]$lf"
441 fi
442 update_branch "$1"
443 ) || _ret=$?
444 [ $_ret -eq 3 ] && exit 3
445 return $_ret
446 }
447
448 # If HEAD is a symref to "$1" detach it at its current value
449 detach_symref_head_on_branch() {
450 _hsr="$(git symbolic-ref -q HEAD --)" && [ -n "$_hsr" ] || return 0
451 _hrv="$(git rev-parse --quiet --verify HEAD --)" && [ -n "$_hrv" ] ||
452 die "cannot detach_symref_head_on_branch from unborn branch $_hsr"
453 git update-ref --no-deref -m "detaching HEAD from $_hsr to safely update it" HEAD "$_hrv"
454 }
455
456 # git_topmerge will need this even on success and since it might otherwise
457 # be called many times do it just the once here and now
458 repotoplvl="$(git rev-parse --show-toplevel)" && [ -n "$repotoplvl" ] && [ -d "$repotoplvl" ] ||
459 die "git rev-parse --show-toplevel failed"
460
461 # Run an in-tree recursive merge but make sure we get the desired version of
462 # any .topdeps and .topmsg files. The $auhopt and --no-stat options are
463 # always implicitly in effect. If successful, a new commit is performed on HEAD.
464 #
465 # The "git merge-recursive" tool (and others) must be run to get the desired
466 # result. And --no-ff is always implicitly in effect as well.
467 #
468 # NOTE: [optional] arguments MUST appear in the order shown
469 # [optional] '-v' varname => optional variable to return original HEAD hash in
470 # [optional] '--merge', '--theirs' or '--remove' to alter .topfile handling
471 # [optional] '--name' <name-for-ours [--name <name-for-theirs>]
472 # $1 => '-m' MUST be '-m'
473 # $2 => commit message
474 # $3 => commit-ish to merge as "theirs"
475 git_topmerge()
476 {
477 _ovar=
478 [ "$1" != "-v" ] || [ $# -lt 2 ] || [ -z "$2" ] || { _ovar="$2"; shift 2; }
479 _mmode=
480 case "$1" in --theirs|--remove|--merge) _mmode="${1#--}"; shift; esac
481 _nameours=
482 _nametheirs=
483 if [ "$1" = "--name" ] && [ $# -ge 2 ]; then
484 _nameours="$2"
485 shift 2
486 if [ "$1" = "--name" ] && [ $# -ge 2 ]; then
487 _nametheirs="$2"
488 shift 2
489 fi
490 fi
491 : "${_nameours:=HEAD}"
492 [ "$#" -eq 3 ] && [ "$1" = "-m" ] && [ -n "$2" ] && [ -n "$3" ] ||
493 die "programmer error: invalid arguments to git_topmerge: $*"
494 _ours="$(git rev-parse --verify HEAD^0)" || die "git rev-parse failed"
495 _theirs="$(git rev-parse --verify "$3^0")" || die "git rev-parse failed"
496 [ -z "$_ovar" ] || eval "$_ovar="'"$_ours"'
497 eval "GITHEAD_$_ours="'"$_nameours"' && eval export "GITHEAD_$_ours"
498 if [ -n "$_nametheirs" ]; then
499 eval "GITHEAD_$_theirs="'"$_nametheirs"' && eval export "GITHEAD_$_theirs"
500 fi
501 _mdriver='touch %A'
502 if [ "$_mmode" = "merge" ]; then
503 TG_L1="$_nameours" && export TG_L1
504 TG_L2="merged common ancestors" && export TG_L2
505 TG_L3="${_nametheirs:-$3}" && export TG_L3
506 _mdriver='git merge-file -L "$TG_L1" -L "$TG_L2" -L "$TG_L3" --marker-size=%L %A %O %B'
507 fi
508 _msg="$2"
509 _mt=
510 _mb="$(git merge-base --all "$_ours" "$_theirs")" && [ -n "$_mb" ] ||
511 { _mt=1; _mb="$(git hash-object -w -t tree --stdin < /dev/null)"; }
512 # any .topdeps or .topmsg output needs to be stripped from stdout
513 tmpstdout="$tg_tmp_dir/stdout.$$"
514 _ret=0
515 git -c "merge.ours.driver=$_mdriver" merge-recursive \
516 $_mb -- "$_ours" "$_theirs" >"$tmpstdout" || _ret=$?
517 # success or failure is not relevant until after fixing up the
518 # .topdeps and .topmsg files and running rerere unless _ret >= 126
519 [ $_ret -lt 126 ] || return $_ret
520 if [ "$_mmode" = "merge" ]; then
521 cat "$tmpstdout"
522 else
523 case "$_mmode" in
524 theirs) _source="$_theirs";;
525 remove) _source="";;
526 *) _source="$_ours";;
527 esac
528 _newinfo=
529 [ -z "$_source" ] ||
530 _newinfo="$(git cat-file --batch-check="%(objecttype) %(objectname)$tab%(rest)" <<-EOT |
531 $_source:.topdeps .topdeps
532 $_source:.topmsg .topmsg
533 EOT
534 sed -n 's/^blob /100644 /p'
535 )"
536 [ -z "$_newinfo" ] || _newinfo="$lf$_newinfo"
537 git update-index --index-info <<-EOT ||
538 0 $nullsha$tab.topdeps
539 0 $nullsha$tab.topmsg$_newinfo
540 EOT
541 die "git update-index failed"
542 if [ "$_mmode" = "remove" ] &&
543 { [ -e "$repotoplvl/.topdeps" ] || [ -e "$repotoplvl/.topmsg" ]; }
544 then
545 rm -r -f "$repotoplvl/.topdeps" "$repotoplvl/.topmsg" >/dev/null 2>&1 || :
546 else
547 for zapbad in "$repotoplvl/.topdeps" "$repotoplvl/.topmsg"; do
548 if [ -e "$zapbad" ] && { [ -L "$zapbad" ] || [ ! -f "$zapbad" ]; }; then
549 rm -r -f "$zapbad"
550 fi
551 done
552 (cd "$repotoplvl" && git checkout-index -q -f -u -- .topdeps .topmsg) ||
553 die "git checkout-index failed"
554 fi
555 # dump output without any .topdeps or .topmsg messages
556 sed -e '/ \.topdeps/d' -e '/ \.topmsg/d' <"$tmpstdout"
557 fi
558 # rerere will be a nop unless rerere.enabled is true, but might complete the merge!
559 eval git "${setautoupdate:+-c rerere.autoupdate=1}" rerere || :
560 git ls-files --unmerged --full-name --abbrev :/ >"$tmpstdout" 2>&1 ||
561 die "git ls-files failed"
562 if [ -s "$tmpstdout" ]; then
563 [ "$_ret" != "0" ] || _ret=1
564 else
565 _ret=0
566 fi
567 if [ $_ret -ne 0 ]; then
568 # merge failed, spit out message, enter "merge" mode and return
569 {
570 printf '%s\n\n# Conflicts:\n' "$_msg"
571 sed -n "/$tab/s/^[^$tab]*/#/p" <"$tmpstdout" | sort -u
572 } >"$git_dir/MERGE_MSG"
573 git update-ref MERGE_HEAD "$_theirs" || :
574 echo 'Automatic merge failed; fix conflicts and then commit the result.'
575 rm -f "$tmpstdout"
576 return $_ret
577 fi
578 # commit time at last!
579 thetree="$(git write-tree)" || die "git write-tree failed"
580 # avoid an extra "already up-to-date" commit (can't happen if _mt though)
581 origtree=
582 [ -n "$_mt" ] || origtree="$(git rev-parse --quiet --verify "$_ours^{tree}" --)" &&
583 [ -n "$origtree" ] || die "git rev-parse failed"
584 if [ "$origtree" != "$thetree" ] || ! contained_by "$_theirs" "$_ours"; then
585 thecommit="$(git commit-tree -p "$_ours" -p "$_theirs" -m "$_msg" "$thetree")" &&
586 [ -n "$thecommit" ] || die "git commit-tree failed"
587 git update-ref -m "$_msg" HEAD "$thecommit" || die "git update-ref failed"
588 fi
589 # mention how the merge was made
590 echo "Merge made by the 'recursive' strategy."
591 rm -f "$tmpstdout"
592 return 0
593 }
594
595 # run git_topmerge with the passed in arguments (it always does --no-stat)
596 # then return the exit status of git_topmerge
597 # if the returned exit status is no error show a shortstat before
598 # returning assuming the merge was done into the previous HEAD but exclude
599 # .topdeps and .topmsg info from the stat unless doing a --merge
600 # if the first argument is --merge or --theirs or --remove handle .topmsg/.topdeps
601 # as follows:
602 # (default) .topmsg and .topdeps always keep ours
603 # --merge a normal merge takes place
604 # --theirs .topmsg and .topdeps always keep theirs
605 # --remove .topmsg and .topdeps are removed from the result and working tree
606 # note this function should only be called after attempt_index_merge fails as
607 # it implicity always does --no-ff (except for --merge which will --ff)
608 git_merge() {
609 _ret=0
610 git_topmerge -v _oldhead "$@" || _ret=$?
611 _exclusions=
612 [ "$1" = "--merge" ] || _exclusions=":/ :!/.topdeps :!/.topmsg"
613 [ "$_ret" != "0" ] || git --no-pager diff-tree --shortstat "$_oldhead" HEAD^0 -- $_exclusions
614 return $_ret
615 }
616
617 # similar to git_merge but operates exclusively using a separate index and temp dir
618 # only trivial aggressive automatic (i.e. simple) merges are supported
619 #
620 # [optional] '--no-auto' to suppress "automatic" merging, merge fails instead
621 # [optional] '--merge', '--theirs' or '--remove' to alter .topfile handling
622 # $1 => '' to discard result, 'refs/?*' to update the specified ref or a varname
623 # $2 => '-m' MUST be '-m'
624 # $3 => commit message AND, if $1 matches refs/?* the update-ref message
625 # $4 => commit-ish to merge as "ours"
626 # $5 => commit-ish to merge as "theirs"
627 # [$6...] => more commit-ishes to merge as "theirs" in octopus
628 #
629 # all merging is done in a separate index (or temporary files for simple merges)
630 # if successful the ref or var is updated with the result
631 # otherwise everything is left unchanged and a silent failure occurs
632 # if successful and $1 matches refs/?* it WILL BE UPDATED to a new commit using the
633 # message and appropriate parents AND HEAD WILL BE DETACHED first if it's a symref
634 # to the same ref
635 # otherwise if $1 does not match refs/?* and is not empty the named variable will
636 # be set to contain the resulting commit from the merge
637 # the working tree and index ARE LEFT COMPLETELY UNTOUCHED no matter what
638 v_attempt_index_merge() {
639 _noauto=
640 if [ "$1" = "--no-auto" ]; then
641 _noauto=1
642 shift
643 fi
644 _exclusions=
645 [ "$1" = "--merge" ] || _exclusions=":/ :!/.topdeps :!/.topmsg"
646 _mstyle=
647 if [ "$1" = "--merge" ] || [ "$1" = "--theirs" ] || [ "$1" = "--remove" ]; then
648 _mmode="${1#--}"
649 shift
650 if [ "$_mmode" = "merge" ] || [ "$_mmode" = "theirs" ]; then
651 _mstyle="-top$_mmode"
652 fi
653 fi
654 [ "$#" -ge 5 ] && [ "$2" = "-m" ] && [ -n "$3" ] && [ -n "$4" ] && [ -n "$5" ] ||
655 die "programmer error: invalid arguments to v_attempt_index_merge: $*"
656 _var="$1"
657 _msg="$3"
658 _head="$4"
659 shift 4
660 rh="$(git rev-parse --quiet --verify "$_head^0" --)" && [ -n "$rh" ] || return 1
661 orh="$rh"
662 oth=
663 _mmsg=
664 newc=
665 _nodt=
666 _same=
667 _mt=
668 _octo=
669 if [ $# -gt 1 ]; then
670 if [ "$_mmode" = "merge" ] || [ "$_mmode" = "theirs" ]; then
671 die "programmer error: invalid octopus .topfile strategy to v_attempt_index_merge: --$_mode"
672 fi
673 ihl="$(git merge-base --independent "$@")" || return 1
674 set -- $ihl
675 [ $# -ge 1 ] && [ -n "$1" ] || return 1
676 fi
677 [ $# -eq 1 ] || _octo=1
678 mb="$(git merge-base ${_octo:+--octopus} "$rh" "$@")" && [ -n "$mb" ] || {
679 mb="$(git hash-object -w -t tree --stdin < /dev/null)"
680 _mt=1
681 }
682 if [ -z "$_mt" ]; then
683 if [ -n "$_octo" ]; then
684 while [ $# -gt 1 ] && mbh="$(git merge-base "$rh" "$1")" && [ -n "$mbh" ]; do
685 if [ "$rh" = "$mbh" ]; then
686 _mmsg="Fast-forward (no commit created)"
687 rh="$1"
688 shift
689 elif [ "$1" = "$mbh" ]; then
690 shift
691 else
692 break;
693 fi
694 done
695 if [ $# -eq 1 ]; then
696 _octo=
697 mb="$(git merge-base "$rh" "$1")" && [ -n "$mb" ] || return 1
698 fi
699 fi
700 if [ -z "$_octo" ]; then
701 r1="$(git rev-parse --quiet --verify "$1^0" --)" && [ -n "$r1" ] || return 1
702 oth="$r1"
703 set -- "$r1"
704 if [ "$rh" = "$mb" ]; then
705 _mmsg="Fast-forward (no commit created)"
706 newc="$r1"
707 _nodt=1
708 _mstyle=
709 elif [ "$r1" = "$mb" ]; then
710 [ -n "$_mmsg" ] || _mmsg="Already up-to-date!"
711 newc="$rh"
712 _nodt=1
713 _same=1
714 _mstyle=
715 fi
716 fi
717 fi
718 if [ -z "$newc" ]; then
719 if [ "$_mmode" = "theirs" ] && [ -z "$oth" ]; then
720 oth="$(git rev-parse --quiet --verify "$1^0" --)" && [ -n "$oth" ] || return 1
721 set -- "$oth"
722 fi
723 inew="$tg_tmp_dir/index.$$"
724 ! [ -e "$inew" ] || rm -f "$inew"
725 itmp="$tg_tmp_dir/output.$$"
726 imrg="$tg_tmp_dir/auto.$$"
727 [ -z "$_octo" ] || >"$imrg"
728 _auto=
729 _parents=
730 _newrh="$rh"
731 while :; do
732 if [ -n "$_parents" ]; then
733 if contained_by "$1" "$_newrh"; then
734 shift
735 continue
736 fi
737 fi
738 GIT_INDEX_FILE="$inew" git read-tree -m --aggressive -i "$mb" "$rh" "$1" || { rm -f "$inew" "$imrg"; return 1; }
739 GIT_INDEX_FILE="$inew" git ls-files --unmerged --full-name --abbrev :/ >"$itmp" 2>&1 || { rm -f "$inew" "$itmp" "$imrg"; return 1; }
740 ! [ -s "$itmp" ] || {
741 if ! GIT_INDEX_FILE="$inew" TG_TMP_DIR="$tg_tmp_dir" git merge-index -q "$TG_INST_CMDDIR/tg--index-merge-one-file$_mstyle" -a >"$itmp" 2>&1; then
742 rm -f "$inew" "$itmp" "$imrg"
743 return 1
744 fi
745 if [ -s "$itmp" ]; then
746 if [ -n "$_noauto" ]; then
747 rm -f "$inew" "$itmp" "$imrg"
748 return 1
749 fi
750 if [ -n "$_octo" ]; then
751 cat "$itmp" >>"$imrg"
752 else
753 cat "$itmp"
754 fi
755 _auto=" automatic"
756 fi
757 }
758 _mstyle=
759 rm -f "$itmp"
760 _parents="${_parents:+$_parents }-p $1"
761 if [ $# -gt 1 ]; then
762 newt="$(GIT_INDEX_FILE="$inew" git write-tree)" && [ -n "$newt" ] || { rm -f "$inew" "$imrg"; return 1; }
763 rh="$newt"
764 shift
765 continue
766 fi
767 break;
768 done
769 if [ "$_mmode" != "merge" ]; then
770 case "$_mmode" in
771 theirs) _source="$oth";;
772 remove) _source="";;
773 *) _source="$orh";;
774 esac
775 _newinfo=
776 [ -z "$_source" ] ||
777 _newinfo="$(git cat-file --batch-check="%(objecttype) %(objectname)$tab%(rest)" <<-EOT |
778 $_source:.topdeps .topdeps
779 $_source:.topmsg .topmsg
780 EOT
781 sed -n 's/^blob /100644 /p'
782 )"
783 [ -z "$_newinfo" ] || _newinfo="$lf$_newinfo"
784 GIT_INDEX_FILE="$inew" git update-index --index-info <<-EOT || { rm -f "$inew" "$imrg"; return 1; }
785 0 $nullsha$tab.topdeps
786 0 $nullsha$tab.topmsg$_newinfo
787 EOT
788 fi
789 newt="$(GIT_INDEX_FILE="$inew" git write-tree)" && [ -n "$newt" ] || { rm -f "$inew" "$imrg"; return 1; }
790 [ -z "$_octo" ] || sort -u <"$imrg"
791 rm -f "$inew" "$imrg"
792 newc="$(git commit-tree -p "$orh" $_parents -m "$_msg" "$newt")" && [ -n "$newc" ] || return 1
793 _mmsg="Merge made by the 'trivial aggressive$_auto${_octo:+ octopus}' strategy."
794 fi
795 case "$_var" in
796 refs/?*)
797 if [ -n "$_same" ]; then
798 _same=
799 if rv="$(git rev-parse --quiet --verify "$_var" --)" && [ "$rv" = "$newc" ]; then
800 _same=1
801 fi
802 fi
803 if [ -z "$_same" ]; then
804 detach_symref_head_on_branch "$_var" || return 1
805 # git update-ref returns 0 even on failure :(
806 git update-ref -m "$_msg" "$_var" "$newc" || return 1
807 fi
808 ;;
809 ?*)
810 eval "$_var="'"$newc"'
811 ;;
812 esac
813 echo "$_mmsg"
814 [ -n "$_nodt" ] || git --no-pager diff-tree --shortstat "$orh" "$newc" -- $_exclusions
815 return 0
816 }
817
818 # shortcut that passes $3 as a preceding argument (which must match refs/?*)
819 attempt_index_merge() {
820 _noauto=
821 _mmode=
822 if [ "$1" = "--no-auto" ]; then
823 _noauto="$1"
824 shift
825 fi
826 if [ "$1" = "--merge" ] || [ "$1" = "--theirs" ] || [ "$1" = "--remove" ]; then
827 _mmode="$1"
828 shift
829 fi
830 case "$3" in refs/?*);;*)
831 die "programmer error: invalid arguments to attempt_index_merge: $*"
832 esac
833 v_attempt_index_merge $_noauto $_mmode "$3" "$@"
834 }
835
836 on_base=
837 do_base_switch() {
838 [ -n "$1" ] || return 0
839 if
840 [ "$1" != "$on_base" ] ||
841 [ "$(git symbolic-ref -q HEAD)" != "refs/$topbases/$1" ]
842 then
843 switch_to_base "$1"
844 on_base="$1"
845 fi
846 }
847
848 update_branch_internal() {
849 # We are cacheable until the first change
850 become_cacheable
851
852 _update_name="$1"
853 ## First, take care of our base
854
855 _depcheck="$(get_temp tg-depcheck)"
856 missing_deps=
857 needs_update "$_update_name" >"$_depcheck" || :
858 if [ -n "$missing_deps" ]; then
859 msg="Some dependencies are missing: $missing_deps"
860 if [ -n "$skipms" ]; then
861 info "$msg; skipping"
862 elif [ -z "$all" ]; then
863 die "$msg"
864 else
865 info "$msg; skipping branch $_update_name"
866 return 0
867 fi
868 fi
869 # allow automatic simple merges by default until a failure occurs
870 no_auto=
871 if [ -s "$_depcheck" ]; then
872 <"$_depcheck" \
873 sed 's/ [^ ]* *$//' | # last is $_update_name
874 sed 's/.* \([^ ]*\)$/+\1/' | # only immediate dependencies
875 sed 's/^\([^+]\)/-\1/' | # now each line is +branch or -branch (+ == recurse)
876 >"$_depcheck.ideps" \
877 uniq -s 1 # fold branch lines; + always comes before - and thus wins within uniq
878
879 stash_now_if_requested
880
881 while read -r depline; do
882 dep="${depline#?}"
883 action="${depline%$dep}"
884
885 # We do not distinguish between dependencies out-of-date
886 # and base/remote out-of-date cases for $dep here,
887 # but thanks to needs_update returning : or refs/remotes/<remote>/<name>
888 # for the latter, we do correctly recurse here
889 # in both cases.
890
891 if [ x"$action" = x+ ]; then
892 case " $missing_deps " in *" $dep "*)
893 info "Skipping recursing to missing dependency: $dep"
894 continue
895 esac
896 info "Recursing to $dep..."
897 recursive_update "$dep" || exit 3
898 fi
899 done <"$_depcheck.ideps"
900
901 # Create a list of all the fully qualified ref names that need
902 # to be merged into $_update_name's base. This will be done
903 # as an octopus merge if there are no conflicts.
904 deplist=
905 deplines=
906 set --
907 while read -r dep; do
908 dep="${dep#?}"
909 case "$dep" in
910 "refs"/*)
911 set -- "$@" "$dep"
912 case "$dep" in
913 "refs/heads"/*)
914 d="${dep#refs/heads/}"
915 deplist="${deplist:+$deplist }$d"
916 deplines="$deplines$d$lf"
917 ;;
918 *)
919 d="${dep#refs/}"
920 deplist="${deplist:+$deplist }$d"
921 deplines="$deplines$d$lf"
922 ;;
923 esac
924 ;;
925 *)
926 set -- "$@" "refs/heads/$dep"
927 deplist="${deplist:+$deplist }$dep"
928 deplines="$deplines$dep$lf"
929 ;;
930 esac
931 done <"$_depcheck.ideps"
932
933 # Make sure we end up on the correct base branch
934 on_base=
935 if [ $# -ge 2 ]; then
936 info "Updating $_update_name base with deps: $deplist"
937 become_non_cacheable
938 msg="tgupdate: octopus merge $# deps into $topbases/$_update_name$lf$lf$deplines"
939 if attempt_index_merge --remove -m "$msg" "refs/$topbases/$_update_name" "$@"; then
940 set --
941 else
942 info "Octopus merge failed; falling back to multiple 3-way merges"
943 no_auto="--no-auto"
944 fi
945 fi
946
947 for fulldep in "$@"; do
948 # This will be either a proper topic branch
949 # or a remote base. (branch_needs_update() is called
950 # only on the _dependencies_, not our branch itself!)
951
952 case "$fulldep" in
953 "refs/heads"/*)
954 dep="${fulldep#refs/heads/}";;
955 "refs"/*)
956 dep="${fulldep#refs/}";;
957 *)
958 dep="$fulldep";; # this should be a programmer error
959 esac
960
961 info "Updating $_update_name base with $dep changes..."
962 become_non_cacheable
963 msg="tgupdate: merge $dep into $topbases/$_update_name"
964 if
965 ! attempt_index_merge $no_auto --remove -m "$msg" "refs/$topbases/$_update_name" "$fulldep^0" &&
966 ! {
967 # We need to switch to the base branch
968 # ...but only if we aren't there yet (from failed previous merge)
969 do_base_switch "$_update_name" || die "do_base_switch failed" &&
970 git_merge --remove --name "$_update_name base" --name "$dep" -m "$msg" "$fulldep^0"
971 }
972 then
973 rm "$_depcheck"
974 save_state
975 unset TG_RECURSIVE
976 info "Please commit merge resolution and call \`$tgdisplayac update --continue\`"
977 info "(use \`$tgdisplayac status\` to see more options)"
978 exit 3
979 fi
980 done
981 else
982 info "The base is up-to-date."
983 fi
984
985
986 ## Second, update our head with the remote branch
987
988 plusextra=
989 merge_with="refs/$topbases/$_update_name"
990 brmmode=
991 if has_remote "$_update_name"; then
992 _rname="refs/remotes/$base_remote/$_update_name"
993 if branch_contains "refs/heads/$_update_name" "$_rname"; then
994 info "The $_update_name head is up-to-date wrt. its remote branch."
995 else
996 stash_now_if_requested
997 info "Reconciling $_update_name base with remote branch updates..."
998 become_non_cacheable
999 msg="tgupdate: merge ${_rname#refs/} onto $topbases/$_update_name"
1000 checkours=
1001 checktheirs=
1002 got_merge_with=
1003 brmmode="--merge"
1004 if [ -n "$mergeresult" ]; then
1005 checkours="$(git rev-parse --verify --quiet "refs/$topbases/$_update_name^0" --)" || :
1006 checktheirs="$(git rev-parse --verify --quiet "$_rname^0" --)" || :
1007 if [ "$mergeours" = "$checkours" ] && [ "$mergetheirs" = "$checktheirs" ]; then
1008 got_merge_with="$mergeresult"
1009 fi
1010 fi
1011 if
1012 [ -z "$got_merge_with" ] &&
1013 ! v_attempt_index_merge $no_auto --theirs "merge_with" -m "$msg" "refs/$topbases/$_update_name" "$_rname^0" &&
1014 ! {
1015 # *DETACH* our HEAD now!
1016 no_auto="--no-auto"
1017 git checkout -q --detach $iowopt "refs/$topbases/$_update_name" || die "git checkout failed" &&
1018 git_merge --theirs --name "$_update_name base content" --name "${_rname#refs/}" -m "$msg" "$_rname^0" &&
1019 merge_with="$(git rev-parse --verify HEAD --)"
1020 }
1021 then
1022 save_state \
1023 "$(git rev-parse --verify --quiet "refs/$topbases/$_update_name^0" --)" \
1024 "$(git rev-parse --verify --quiet "$_rname^0" --)"
1025 unset TG_RECURSIVE
1026 info "Please commit merge resolution and call \`$tgdisplayac update --continue\`"
1027 info "(use \`$tgdisplayac status\` to see more options)"
1028 exit 3
1029 fi
1030 # Go back but remember we want to merge with this, not base
1031 [ -z "$got_merge_with" ] || merge_with="$got_merge_with"
1032 plusextra="${_rname#refs/} + "
1033 fi
1034 fi
1035
1036
1037 ## Third, update our head with the base
1038
1039 if branch_contains "refs/heads/$_update_name" "$merge_with"; then
1040 info "The $_update_name head is up-to-date wrt. the base."
1041 return 0
1042 fi
1043 stash_now_if_requested
1044 info "Updating $_update_name against ${plusextra}new base..."
1045 become_non_cacheable
1046 msg="tgupdate: merge ${plusextra}$topbases/$_update_name into $_update_name"
1047 b4deps=
1048 if [ -n "$brmmode" ] && [ "$base_remote" ]; then
1049 b4deps="$(git rev-parse --verify --quiet "refs/heads/$_update_name:.topdeps" --)" && [ -n "$b4deps" ] ||
1050 b4deps="$(git hash-object -t blob -w --stdin </dev/null)"
1051 fi
1052 if
1053 ! attempt_index_merge $no_auto $brmmode -m "$msg" "refs/heads/$_update_name" "$merge_with^0" &&
1054 ! {
1055 # Home, sweet home...
1056 # (We want to always switch back, in case we were
1057 # on the base from failed previous merge.)
1058 git checkout -q $iowopt "$_update_name" || die "git checkout failed" &&
1059 git_merge $brmmode --name "$_update_name" --name "${plusextra}$topbases/$_update_name" -m "$msg" "$merge_with^0"
1060 }
1061 then
1062 no_auto=
1063 merging_topfiles="${brmmode:+1}"
1064 save_state
1065 unset TG_RECURSIVE
1066 info "Please commit merge resolution and call \`$tgdisplayac update --continue\`"
1067 info "(use \`$tgdisplayac status\` to see more options)"
1068 exit 3
1069 fi
1070
1071 # Fourth, auto create locally any newly depended on branches we got from the remote
1072
1073 _result=0
1074 if [ -n "$b4deps" ] &&
1075 l8rdeps="$(git rev-parse --verify --quiet "refs/heads/$_update_name:.topdeps" --)" &&
1076 [ -n "$l8rdeps" ] && [ "$b4deps" != "$l8rdeps" ]
1077 then
1078 _olddeps=
1079 while read -r newdep; do
1080 if [ -n "$newdep" ]; then
1081 if auto_create_local_remote "$newdep"; then
1082 _result=75
1083 else
1084 if ref_exists "refs/heads/$newdep"; then
1085 # maybe the line just moved around
1086 [ -n "$_olddeps" ] && [ -f "$_olddeps" ] || {
1087 _olddeps="$(get_temp b4deps)" &&
1088 git cat-file blob "$b4deps" >"$_olddeps"
1089 }
1090 if awk -v "newdep=$newdep" '$0 == newdep {exit 1}' <"$_olddeps"; then
1091 # nope, it's a new head already existing locally
1092 _result=75
1093 fi
1094 else
1095 # helpfully check to see if there's such a remote branch
1096 _rntgb=
1097 ! ref_exists "refs/remotes/$base_remote/$newdep" || _rntgb=1
1098 # maybe a locking local orphan base too
1099 _blocked=
1100 if [ -n "$_rntgb" ] &&
1101 ref_exists "refs/remotes/$base_remote/${topbases#heads/}$newdep" &&
1102 ref_exists "refs/$topbases/$newdep"
1103 then
1104 _blocked=1
1105 fi
1106 # spew the flexibly adjustable warning
1107 warn "-------------------------------------"
1108 warn "MISSING DEPENDENCY MERGED FROM REMOTE"
1109 warn "-------------------------------------"
1110 warn "Local Branch: $_update_name"
1111 warn " Remote Name: $base_remote"
1112 warn " Dependency: $newdep"
1113 if [ -n "$_blocked" ]; then
1114 warn "Blocking Ref: refs/$topbases/$newdep"
1115 elif [ -n "$_rntgb" ]; then
1116 warn "Existing Ref: refs/remotes/$base_remote/$newdep"
1117 fi
1118 warn ""
1119 if [ -n "$_blocked" ]; then
1120 warn "There is no local branch by that name, but"
1121 warn "there IS a remote TopGit branch available by"
1122 warn "that name, but creation of a local version has"
1123 warn "been blocked by existence of the ref shown above."
1124 elif [ -n "$_rntgb" ]; then
1125 warn "There is no local branch or remote TopGit"
1126 warn "branch available by that name, but there is an"
1127 warn "existing non-TopGit remote branch ref shown above."
1128 warn "Non-TopGit branches are not set up automatically"
1129 warn "by TopGit and must be maintained manually."
1130 else
1131 warn "There is no local branch or remote branch"
1132 warn "(TopGit or otherwise) available by that name."
1133 fi
1134 warn "-------------------------------------"
1135 fi
1136 fi
1137 fi
1138 done <<-EOT
1139 $(git diff "$b4deps" "$l8rdeps" -- | diff_added_lines)
1140 EOT
1141 fi
1142 return $_result
1143 }
1144
1145 update_branch() {
1146 _ubicode=0
1147 _maxdeploop=3
1148 update_branch_internal "$@" || _ubicode=$?
1149 while [ "$_maxdeploop" -gt 0 ] && [ "$_ubicode" = "75" ]; do
1150 _maxdeploop="$(( $maxdeploop - 1 ))"
1151 info "Updating $1 again with newly added dependencies..."
1152 _ubicode=0
1153 update_branch_internal "$@" || _ubicode=$?
1154 done
1155 return $_ubicode
1156 }
1157
1158 # We are "read-only" and cacheable until the first change
1159 tg_read_only=1
1160 v_create_ref_cache
1161
1162 do_non_annihilated_branches_patterns() {
1163 while read -r _pat && [ -n "$_pat" ]; do
1164 set -- "$@" "$_pat"
1165 done
1166 non_annihilated_branches "$@"
1167 }
1168
1169 do_non_annihilated_branches() {
1170 if [ -z "$pattern" ]; then
1171 non_annihilated_branches
1172 else
1173 do_non_annihilated_branches_patterns <<-EOT
1174 $(sed 'y/ /\n/' <<-LIST
1175 $pattern
1176 LIST
1177 )
1178 EOT
1179 fi
1180 }
1181
1182 if [ -n "$all" ] && [ -z "$restored" ]; then
1183 names=
1184 while read name && [ -n "$name" ]; do
1185 case " $names " in *" $name "*);;*)
1186 names="${names:+$names }$name"
1187 esac
1188 done <<-EOT
1189 $(do_non_annihilated_branches)
1190 EOT
1191 fi
1192
1193 for name in $names; do
1194 case " $processed " in *" $name "*) continue; esac
1195 [ -z "$all" ] && case "$names" in *" "*) ! :; esac || info "Proccessing $name..."
1196 update_branch "$name" || exit
1197 processed="${processed:+$processed }$name"
1198 done
1199
1200 [ -z "$all" ] && case "$names" in *" "*) ! :; esac ||
1201 info "Returning to ${current#refs/heads/}..."
1202 checkout_symref_full "$current"
1203 ! [ -f "$git_dir/TGMERGE_MSG" ] || [ -e "$git_dir/MERGE_MSG" ] ||
1204 mv -f "$git_dir/TGMERGE_MSG" "$git_dir/MERGE_MSG" || :
TopGit - A different patch queue manager