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