Merge branch 'jk/test-lint-forbid-when-finished-in-subshell' into maint
[git/git.git] / contrib / subtree / git-subtree.sh
1 #!/bin/sh
2 #
3 # git-subtree.sh: split/join git repositories in subdirectories of this one
4 #
5 # Copyright (C) 2009 Avery Pennarun <apenwarr@gmail.com>
6 #
7 if [ $# -eq 0 ]; then
8 set -- -h
9 fi
10 OPTS_SPEC="\
11 git subtree add --prefix=<prefix> <commit>
12 git subtree add --prefix=<prefix> <repository> <ref>
13 git subtree merge --prefix=<prefix> <commit>
14 git subtree pull --prefix=<prefix> <repository> <ref>
15 git subtree push --prefix=<prefix> <repository> <ref>
16 git subtree split --prefix=<prefix> <commit...>
17 --
18 h,help show the help
19 q quiet
20 d show debug messages
21 P,prefix= the name of the subdir to split out
22 m,message= use the given message as the commit message for the merge commit
23 options for 'split'
24 annotate= add a prefix to commit message of new commits
25 b,branch= create a new branch from the split subtree
26 ignore-joins ignore prior --rejoin commits
27 onto= try connecting new tree to an existing one
28 rejoin merge the new branch back into HEAD
29 options for 'add', 'merge', and 'pull'
30 squash merge subtree changes as a single commit
31 "
32 eval "$(echo "$OPTS_SPEC" | git rev-parse --parseopt -- "$@" || echo exit $?)"
33
34 PATH=$PATH:$(git --exec-path)
35 . git-sh-setup
36
37 require_work_tree
38
39 quiet=
40 branch=
41 debug=
42 command=
43 onto=
44 rejoin=
45 ignore_joins=
46 annotate=
47 squash=
48 message=
49 prefix=
50
51 debug()
52 {
53 if [ -n "$debug" ]; then
54 printf "%s\n" "$*" >&2
55 fi
56 }
57
58 say()
59 {
60 if [ -z "$quiet" ]; then
61 printf "%s\n" "$*" >&2
62 fi
63 }
64
65 progress()
66 {
67 if [ -z "$quiet" ]; then
68 printf "%s\r" "$*" >&2
69 fi
70 }
71
72 assert()
73 {
74 if "$@"; then
75 :
76 else
77 die "assertion failed: " "$@"
78 fi
79 }
80
81
82 #echo "Options: $*"
83
84 while [ $# -gt 0 ]; do
85 opt="$1"
86 shift
87 case "$opt" in
88 -q) quiet=1 ;;
89 -d) debug=1 ;;
90 --annotate) annotate="$1"; shift ;;
91 --no-annotate) annotate= ;;
92 -b) branch="$1"; shift ;;
93 -P) prefix="$1"; shift ;;
94 -m) message="$1"; shift ;;
95 --no-prefix) prefix= ;;
96 --onto) onto="$1"; shift ;;
97 --no-onto) onto= ;;
98 --rejoin) rejoin=1 ;;
99 --no-rejoin) rejoin= ;;
100 --ignore-joins) ignore_joins=1 ;;
101 --no-ignore-joins) ignore_joins= ;;
102 --squash) squash=1 ;;
103 --no-squash) squash= ;;
104 --) break ;;
105 *) die "Unexpected option: $opt" ;;
106 esac
107 done
108
109 command="$1"
110 shift
111 case "$command" in
112 add|merge|pull) default= ;;
113 split|push) default="--default HEAD" ;;
114 *) die "Unknown command '$command'" ;;
115 esac
116
117 if [ -z "$prefix" ]; then
118 die "You must provide the --prefix option."
119 fi
120
121 case "$command" in
122 add) [ -e "$prefix" ] &&
123 die "prefix '$prefix' already exists." ;;
124 *) [ -e "$prefix" ] ||
125 die "'$prefix' does not exist; use 'git subtree add'" ;;
126 esac
127
128 dir="$(dirname "$prefix/.")"
129
130 if [ "$command" != "pull" -a "$command" != "add" -a "$command" != "push" ]; then
131 revs=$(git rev-parse $default --revs-only "$@") || exit $?
132 dirs="$(git rev-parse --no-revs --no-flags "$@")" || exit $?
133 if [ -n "$dirs" ]; then
134 die "Error: Use --prefix instead of bare filenames."
135 fi
136 fi
137
138 debug "command: {$command}"
139 debug "quiet: {$quiet}"
140 debug "revs: {$revs}"
141 debug "dir: {$dir}"
142 debug "opts: {$*}"
143 debug
144
145 cache_setup()
146 {
147 cachedir="$GIT_DIR/subtree-cache/$$"
148 rm -rf "$cachedir" || die "Can't delete old cachedir: $cachedir"
149 mkdir -p "$cachedir" || die "Can't create new cachedir: $cachedir"
150 mkdir -p "$cachedir/notree" || die "Can't create new cachedir: $cachedir/notree"
151 debug "Using cachedir: $cachedir" >&2
152 }
153
154 cache_get()
155 {
156 for oldrev in $*; do
157 if [ -r "$cachedir/$oldrev" ]; then
158 read newrev <"$cachedir/$oldrev"
159 echo $newrev
160 fi
161 done
162 }
163
164 cache_miss()
165 {
166 for oldrev in $*; do
167 if [ ! -r "$cachedir/$oldrev" ]; then
168 echo $oldrev
169 fi
170 done
171 }
172
173 check_parents()
174 {
175 missed=$(cache_miss $*)
176 for miss in $missed; do
177 if [ ! -r "$cachedir/notree/$miss" ]; then
178 debug " incorrect order: $miss"
179 fi
180 done
181 }
182
183 set_notree()
184 {
185 echo "1" > "$cachedir/notree/$1"
186 }
187
188 cache_set()
189 {
190 oldrev="$1"
191 newrev="$2"
192 if [ "$oldrev" != "latest_old" \
193 -a "$oldrev" != "latest_new" \
194 -a -e "$cachedir/$oldrev" ]; then
195 die "cache for $oldrev already exists!"
196 fi
197 echo "$newrev" >"$cachedir/$oldrev"
198 }
199
200 rev_exists()
201 {
202 if git rev-parse "$1" >/dev/null 2>&1; then
203 return 0
204 else
205 return 1
206 fi
207 }
208
209 rev_is_descendant_of_branch()
210 {
211 newrev="$1"
212 branch="$2"
213 branch_hash=$(git rev-parse $branch)
214 match=$(git rev-list -1 $branch_hash ^$newrev)
215
216 if [ -z "$match" ]; then
217 return 0
218 else
219 return 1
220 fi
221 }
222
223 # if a commit doesn't have a parent, this might not work. But we only want
224 # to remove the parent from the rev-list, and since it doesn't exist, it won't
225 # be there anyway, so do nothing in that case.
226 try_remove_previous()
227 {
228 if rev_exists "$1^"; then
229 echo "^$1^"
230 fi
231 }
232
233 find_latest_squash()
234 {
235 debug "Looking for latest squash ($dir)..."
236 dir="$1"
237 sq=
238 main=
239 sub=
240 git log --grep="^git-subtree-dir: $dir/*\$" \
241 --pretty=format:'START %H%n%s%n%n%b%nEND%n' HEAD |
242 while read a b junk; do
243 debug "$a $b $junk"
244 debug "{{$sq/$main/$sub}}"
245 case "$a" in
246 START) sq="$b" ;;
247 git-subtree-mainline:) main="$b" ;;
248 git-subtree-split:) sub="$b" ;;
249 END)
250 if [ -n "$sub" ]; then
251 if [ -n "$main" ]; then
252 # a rejoin commit?
253 # Pretend its sub was a squash.
254 sq="$sub"
255 fi
256 debug "Squash found: $sq $sub"
257 echo "$sq" "$sub"
258 break
259 fi
260 sq=
261 main=
262 sub=
263 ;;
264 esac
265 done
266 }
267
268 find_existing_splits()
269 {
270 debug "Looking for prior splits..."
271 dir="$1"
272 revs="$2"
273 main=
274 sub=
275 git log --grep="^git-subtree-dir: $dir/*\$" \
276 --pretty=format:'START %H%n%s%n%n%b%nEND%n' $revs |
277 while read a b junk; do
278 case "$a" in
279 START) sq="$b" ;;
280 git-subtree-mainline:) main="$b" ;;
281 git-subtree-split:) sub="$b" ;;
282 END)
283 debug " Main is: '$main'"
284 if [ -z "$main" -a -n "$sub" ]; then
285 # squash commits refer to a subtree
286 debug " Squash: $sq from $sub"
287 cache_set "$sq" "$sub"
288 fi
289 if [ -n "$main" -a -n "$sub" ]; then
290 debug " Prior: $main -> $sub"
291 cache_set $main $sub
292 cache_set $sub $sub
293 try_remove_previous "$main"
294 try_remove_previous "$sub"
295 fi
296 main=
297 sub=
298 ;;
299 esac
300 done
301 }
302
303 copy_commit()
304 {
305 # We're going to set some environment vars here, so
306 # do it in a subshell to get rid of them safely later
307 debug copy_commit "{$1}" "{$2}" "{$3}"
308 git log -1 --pretty=format:'%an%n%ae%n%aD%n%cn%n%ce%n%cD%n%B' "$1" |
309 (
310 read GIT_AUTHOR_NAME
311 read GIT_AUTHOR_EMAIL
312 read GIT_AUTHOR_DATE
313 read GIT_COMMITTER_NAME
314 read GIT_COMMITTER_EMAIL
315 read GIT_COMMITTER_DATE
316 export GIT_AUTHOR_NAME \
317 GIT_AUTHOR_EMAIL \
318 GIT_AUTHOR_DATE \
319 GIT_COMMITTER_NAME \
320 GIT_COMMITTER_EMAIL \
321 GIT_COMMITTER_DATE
322 (printf "%s" "$annotate"; cat ) |
323 git commit-tree "$2" $3 # reads the rest of stdin
324 ) || die "Can't copy commit $1"
325 }
326
327 add_msg()
328 {
329 dir="$1"
330 latest_old="$2"
331 latest_new="$3"
332 if [ -n "$message" ]; then
333 commit_message="$message"
334 else
335 commit_message="Add '$dir/' from commit '$latest_new'"
336 fi
337 cat <<-EOF
338 $commit_message
339
340 git-subtree-dir: $dir
341 git-subtree-mainline: $latest_old
342 git-subtree-split: $latest_new
343 EOF
344 }
345
346 add_squashed_msg()
347 {
348 if [ -n "$message" ]; then
349 echo "$message"
350 else
351 echo "Merge commit '$1' as '$2'"
352 fi
353 }
354
355 rejoin_msg()
356 {
357 dir="$1"
358 latest_old="$2"
359 latest_new="$3"
360 if [ -n "$message" ]; then
361 commit_message="$message"
362 else
363 commit_message="Split '$dir/' into commit '$latest_new'"
364 fi
365 cat <<-EOF
366 $commit_message
367
368 git-subtree-dir: $dir
369 git-subtree-mainline: $latest_old
370 git-subtree-split: $latest_new
371 EOF
372 }
373
374 squash_msg()
375 {
376 dir="$1"
377 oldsub="$2"
378 newsub="$3"
379 newsub_short=$(git rev-parse --short "$newsub")
380
381 if [ -n "$oldsub" ]; then
382 oldsub_short=$(git rev-parse --short "$oldsub")
383 echo "Squashed '$dir/' changes from $oldsub_short..$newsub_short"
384 echo
385 git log --pretty=tformat:'%h %s' "$oldsub..$newsub"
386 git log --pretty=tformat:'REVERT: %h %s' "$newsub..$oldsub"
387 else
388 echo "Squashed '$dir/' content from commit $newsub_short"
389 fi
390
391 echo
392 echo "git-subtree-dir: $dir"
393 echo "git-subtree-split: $newsub"
394 }
395
396 toptree_for_commit()
397 {
398 commit="$1"
399 git log -1 --pretty=format:'%T' "$commit" -- || exit $?
400 }
401
402 subtree_for_commit()
403 {
404 commit="$1"
405 dir="$2"
406 git ls-tree "$commit" -- "$dir" |
407 while read mode type tree name; do
408 assert [ "$name" = "$dir" ]
409 assert [ "$type" = "tree" -o "$type" = "commit" ]
410 [ "$type" = "commit" ] && continue # ignore submodules
411 echo $tree
412 break
413 done
414 }
415
416 tree_changed()
417 {
418 tree=$1
419 shift
420 if [ $# -ne 1 ]; then
421 return 0 # weird parents, consider it changed
422 else
423 ptree=$(toptree_for_commit $1)
424 if [ "$ptree" != "$tree" ]; then
425 return 0 # changed
426 else
427 return 1 # not changed
428 fi
429 fi
430 }
431
432 new_squash_commit()
433 {
434 old="$1"
435 oldsub="$2"
436 newsub="$3"
437 tree=$(toptree_for_commit $newsub) || exit $?
438 if [ -n "$old" ]; then
439 squash_msg "$dir" "$oldsub" "$newsub" |
440 git commit-tree "$tree" -p "$old" || exit $?
441 else
442 squash_msg "$dir" "" "$newsub" |
443 git commit-tree "$tree" || exit $?
444 fi
445 }
446
447 copy_or_skip()
448 {
449 rev="$1"
450 tree="$2"
451 newparents="$3"
452 assert [ -n "$tree" ]
453
454 identical=
455 nonidentical=
456 p=
457 gotparents=
458 for parent in $newparents; do
459 ptree=$(toptree_for_commit $parent) || exit $?
460 [ -z "$ptree" ] && continue
461 if [ "$ptree" = "$tree" ]; then
462 # an identical parent could be used in place of this rev.
463 identical="$parent"
464 else
465 nonidentical="$parent"
466 fi
467
468 # sometimes both old parents map to the same newparent;
469 # eliminate duplicates
470 is_new=1
471 for gp in $gotparents; do
472 if [ "$gp" = "$parent" ]; then
473 is_new=
474 break
475 fi
476 done
477 if [ -n "$is_new" ]; then
478 gotparents="$gotparents $parent"
479 p="$p -p $parent"
480 fi
481 done
482
483 if [ -n "$identical" ]; then
484 echo $identical
485 else
486 copy_commit $rev $tree "$p" || exit $?
487 fi
488 }
489
490 ensure_clean()
491 {
492 if ! git diff-index HEAD --exit-code --quiet 2>&1; then
493 die "Working tree has modifications. Cannot add."
494 fi
495 if ! git diff-index --cached HEAD --exit-code --quiet 2>&1; then
496 die "Index has modifications. Cannot add."
497 fi
498 }
499
500 ensure_valid_ref_format()
501 {
502 git check-ref-format "refs/heads/$1" ||
503 die "'$1' does not look like a ref"
504 }
505
506 cmd_add()
507 {
508 if [ -e "$dir" ]; then
509 die "'$dir' already exists. Cannot add."
510 fi
511
512 ensure_clean
513
514 if [ $# -eq 1 ]; then
515 git rev-parse -q --verify "$1^{commit}" >/dev/null ||
516 die "'$1' does not refer to a commit"
517
518 "cmd_add_commit" "$@"
519 elif [ $# -eq 2 ]; then
520 # Technically we could accept a refspec here but we're
521 # just going to turn around and add FETCH_HEAD under the
522 # specified directory. Allowing a refspec might be
523 # misleading because we won't do anything with any other
524 # branches fetched via the refspec.
525 ensure_valid_ref_format "$2"
526
527 "cmd_add_repository" "$@"
528 else
529 say "error: parameters were '$@'"
530 die "Provide either a commit or a repository and commit."
531 fi
532 }
533
534 cmd_add_repository()
535 {
536 echo "git fetch" "$@"
537 repository=$1
538 refspec=$2
539 git fetch "$@" || exit $?
540 revs=FETCH_HEAD
541 set -- $revs
542 cmd_add_commit "$@"
543 }
544
545 cmd_add_commit()
546 {
547 revs=$(git rev-parse $default --revs-only "$@") || exit $?
548 set -- $revs
549 rev="$1"
550
551 debug "Adding $dir as '$rev'..."
552 git read-tree --prefix="$dir" $rev || exit $?
553 git checkout -- "$dir" || exit $?
554 tree=$(git write-tree) || exit $?
555
556 headrev=$(git rev-parse HEAD) || exit $?
557 if [ -n "$headrev" -a "$headrev" != "$rev" ]; then
558 headp="-p $headrev"
559 else
560 headp=
561 fi
562
563 if [ -n "$squash" ]; then
564 rev=$(new_squash_commit "" "" "$rev") || exit $?
565 commit=$(add_squashed_msg "$rev" "$dir" |
566 git commit-tree $tree $headp -p "$rev") || exit $?
567 else
568 revp=$(peel_committish "$rev") &&
569 commit=$(add_msg "$dir" "$headrev" "$rev" |
570 git commit-tree $tree $headp -p "$revp") || exit $?
571 fi
572 git reset "$commit" || exit $?
573
574 say "Added dir '$dir'"
575 }
576
577 cmd_split()
578 {
579 debug "Splitting $dir..."
580 cache_setup || exit $?
581
582 if [ -n "$onto" ]; then
583 debug "Reading history for --onto=$onto..."
584 git rev-list $onto |
585 while read rev; do
586 # the 'onto' history is already just the subdir, so
587 # any parent we find there can be used verbatim
588 debug " cache: $rev"
589 cache_set $rev $rev
590 done
591 fi
592
593 if [ -n "$ignore_joins" ]; then
594 unrevs=
595 else
596 unrevs="$(find_existing_splits "$dir" "$revs")"
597 fi
598
599 # We can't restrict rev-list to only $dir here, because some of our
600 # parents have the $dir contents the root, and those won't match.
601 # (and rev-list --follow doesn't seem to solve this)
602 grl='git rev-list --topo-order --reverse --parents $revs $unrevs'
603 revmax=$(eval "$grl" | wc -l)
604 revcount=0
605 createcount=0
606 eval "$grl" |
607 while read rev parents; do
608 revcount=$(($revcount + 1))
609 progress "$revcount/$revmax ($createcount)"
610 debug "Processing commit: $rev"
611 exists=$(cache_get $rev)
612 if [ -n "$exists" ]; then
613 debug " prior: $exists"
614 continue
615 fi
616 createcount=$(($createcount + 1))
617 debug " parents: $parents"
618 newparents=$(cache_get $parents)
619 debug " newparents: $newparents"
620
621 tree=$(subtree_for_commit $rev "$dir")
622 debug " tree is: $tree"
623
624 check_parents $parents
625
626 # ugly. is there no better way to tell if this is a subtree
627 # vs. a mainline commit? Does it matter?
628 if [ -z $tree ]; then
629 set_notree $rev
630 if [ -n "$newparents" ]; then
631 cache_set $rev $rev
632 fi
633 continue
634 fi
635
636 newrev=$(copy_or_skip "$rev" "$tree" "$newparents") || exit $?
637 debug " newrev is: $newrev"
638 cache_set $rev $newrev
639 cache_set latest_new $newrev
640 cache_set latest_old $rev
641 done || exit $?
642 latest_new=$(cache_get latest_new)
643 if [ -z "$latest_new" ]; then
644 die "No new revisions were found"
645 fi
646
647 if [ -n "$rejoin" ]; then
648 debug "Merging split branch into HEAD..."
649 latest_old=$(cache_get latest_old)
650 git merge -s ours \
651 -m "$(rejoin_msg $dir $latest_old $latest_new)" \
652 $latest_new >&2 || exit $?
653 fi
654 if [ -n "$branch" ]; then
655 if rev_exists "refs/heads/$branch"; then
656 if ! rev_is_descendant_of_branch $latest_new $branch; then
657 die "Branch '$branch' is not an ancestor of commit '$latest_new'."
658 fi
659 action='Updated'
660 else
661 action='Created'
662 fi
663 git update-ref -m 'subtree split' "refs/heads/$branch" $latest_new || exit $?
664 say "$action branch '$branch'"
665 fi
666 echo $latest_new
667 exit 0
668 }
669
670 cmd_merge()
671 {
672 revs=$(git rev-parse $default --revs-only "$@") || exit $?
673 ensure_clean
674
675 set -- $revs
676 if [ $# -ne 1 ]; then
677 die "You must provide exactly one revision. Got: '$revs'"
678 fi
679 rev="$1"
680
681 if [ -n "$squash" ]; then
682 first_split="$(find_latest_squash "$dir")"
683 if [ -z "$first_split" ]; then
684 die "Can't squash-merge: '$dir' was never added."
685 fi
686 set $first_split
687 old=$1
688 sub=$2
689 if [ "$sub" = "$rev" ]; then
690 say "Subtree is already at commit $rev."
691 exit 0
692 fi
693 new=$(new_squash_commit "$old" "$sub" "$rev") || exit $?
694 debug "New squash commit: $new"
695 rev="$new"
696 fi
697
698 version=$(git version)
699 if [ "$version" \< "git version 1.7" ]; then
700 if [ -n "$message" ]; then
701 git merge -s subtree --message="$message" $rev
702 else
703 git merge -s subtree $rev
704 fi
705 else
706 if [ -n "$message" ]; then
707 git merge -Xsubtree="$prefix" --message="$message" $rev
708 else
709 git merge -Xsubtree="$prefix" $rev
710 fi
711 fi
712 }
713
714 cmd_pull()
715 {
716 if [ $# -ne 2 ]; then
717 die "You must provide <repository> <ref>"
718 fi
719 ensure_clean
720 ensure_valid_ref_format "$2"
721 git fetch "$@" || exit $?
722 revs=FETCH_HEAD
723 set -- $revs
724 cmd_merge "$@"
725 }
726
727 cmd_push()
728 {
729 if [ $# -ne 2 ]; then
730 die "You must provide <repository> <ref>"
731 fi
732 ensure_valid_ref_format "$2"
733 if [ -e "$dir" ]; then
734 repository=$1
735 refspec=$2
736 echo "git push using: " $repository $refspec
737 localrev=$(git subtree split --prefix="$prefix") || die
738 git push $repository $localrev:refs/heads/$refspec
739 else
740 die "'$dir' must already exist. Try 'git subtree add'."
741 fi
742 }
743
744 "cmd_$command" "$@"