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