Merge branch 'js/init-db-update-for-mingw'
[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 "$1")
235 local indent=$(($2 + 1))
236 for miss in $missed
237 do
238 if ! test -r "$cachedir/notree/$miss"
239 then
240 debug " incorrect order: $miss"
241 process_split_commit "$miss" "" "$indent"
242 fi
243 done
244 }
245
246 set_notree () {
247 echo "1" > "$cachedir/notree/$1"
248 }
249
250 cache_set () {
251 oldrev="$1"
252 newrev="$2"
253 if test "$oldrev" != "latest_old" &&
254 test "$oldrev" != "latest_new" &&
255 test -e "$cachedir/$oldrev"
256 then
257 die "cache for $oldrev already exists!"
258 fi
259 echo "$newrev" >"$cachedir/$oldrev"
260 }
261
262 rev_exists () {
263 if git rev-parse "$1" >/dev/null 2>&1
264 then
265 return 0
266 else
267 return 1
268 fi
269 }
270
271 rev_is_descendant_of_branch () {
272 newrev="$1"
273 branch="$2"
274 branch_hash=$(git rev-parse "$branch")
275 match=$(git rev-list -1 "$branch_hash" "^$newrev")
276
277 if test -z "$match"
278 then
279 return 0
280 else
281 return 1
282 fi
283 }
284
285 # if a commit doesn't have a parent, this might not work. But we only want
286 # to remove the parent from the rev-list, and since it doesn't exist, it won't
287 # be there anyway, so do nothing in that case.
288 try_remove_previous () {
289 if rev_exists "$1^"
290 then
291 echo "^$1^"
292 fi
293 }
294
295 find_latest_squash () {
296 debug "Looking for latest squash ($dir)..."
297 dir="$1"
298 sq=
299 main=
300 sub=
301 git log --grep="^git-subtree-dir: $dir/*\$" \
302 --no-show-signature --pretty=format:'START %H%n%s%n%n%b%nEND%n' HEAD |
303 while read a b junk
304 do
305 debug "$a $b $junk"
306 debug "{{$sq/$main/$sub}}"
307 case "$a" in
308 START)
309 sq="$b"
310 ;;
311 git-subtree-mainline:)
312 main="$b"
313 ;;
314 git-subtree-split:)
315 sub="$(git rev-parse "$b^0")" ||
316 die "could not rev-parse split hash $b from commit $sq"
317 ;;
318 END)
319 if test -n "$sub"
320 then
321 if test -n "$main"
322 then
323 # a rejoin commit?
324 # Pretend its sub was a squash.
325 sq="$sub"
326 fi
327 debug "Squash found: $sq $sub"
328 echo "$sq" "$sub"
329 break
330 fi
331 sq=
332 main=
333 sub=
334 ;;
335 esac
336 done
337 }
338
339 find_existing_splits () {
340 debug "Looking for prior splits..."
341 dir="$1"
342 revs="$2"
343 main=
344 sub=
345 local grep_format="^git-subtree-dir: $dir/*\$"
346 if test -n "$ignore_joins"
347 then
348 grep_format="^Add '$dir/' from commit '"
349 fi
350 git log --grep="$grep_format" \
351 --no-show-signature --pretty=format:'START %H%n%s%n%n%b%nEND%n' $revs |
352 while read a b junk
353 do
354 case "$a" in
355 START)
356 sq="$b"
357 ;;
358 git-subtree-mainline:)
359 main="$b"
360 ;;
361 git-subtree-split:)
362 sub="$(git rev-parse "$b^0")" ||
363 die "could not rev-parse split hash $b from commit $sq"
364 ;;
365 END)
366 debug " Main is: '$main'"
367 if test -z "$main" -a -n "$sub"
368 then
369 # squash commits refer to a subtree
370 debug " Squash: $sq from $sub"
371 cache_set "$sq" "$sub"
372 fi
373 if test -n "$main" -a -n "$sub"
374 then
375 debug " Prior: $main -> $sub"
376 cache_set $main $sub
377 cache_set $sub $sub
378 try_remove_previous "$main"
379 try_remove_previous "$sub"
380 fi
381 main=
382 sub=
383 ;;
384 esac
385 done
386 }
387
388 copy_commit () {
389 # We're going to set some environment vars here, so
390 # do it in a subshell to get rid of them safely later
391 debug copy_commit "{$1}" "{$2}" "{$3}"
392 git log -1 --no-show-signature --pretty=format:'%an%n%ae%n%aD%n%cn%n%ce%n%cD%n%B' "$1" |
393 (
394 read GIT_AUTHOR_NAME
395 read GIT_AUTHOR_EMAIL
396 read GIT_AUTHOR_DATE
397 read GIT_COMMITTER_NAME
398 read GIT_COMMITTER_EMAIL
399 read GIT_COMMITTER_DATE
400 export GIT_AUTHOR_NAME \
401 GIT_AUTHOR_EMAIL \
402 GIT_AUTHOR_DATE \
403 GIT_COMMITTER_NAME \
404 GIT_COMMITTER_EMAIL \
405 GIT_COMMITTER_DATE
406 (
407 printf "%s" "$annotate"
408 cat
409 ) |
410 git commit-tree "$2" $3 # reads the rest of stdin
411 ) || die "Can't copy commit $1"
412 }
413
414 add_msg () {
415 dir="$1"
416 latest_old="$2"
417 latest_new="$3"
418 if test -n "$message"
419 then
420 commit_message="$message"
421 else
422 commit_message="Add '$dir/' from commit '$latest_new'"
423 fi
424 cat <<-EOF
425 $commit_message
426
427 git-subtree-dir: $dir
428 git-subtree-mainline: $latest_old
429 git-subtree-split: $latest_new
430 EOF
431 }
432
433 add_squashed_msg () {
434 if test -n "$message"
435 then
436 echo "$message"
437 else
438 echo "Merge commit '$1' as '$2'"
439 fi
440 }
441
442 rejoin_msg () {
443 dir="$1"
444 latest_old="$2"
445 latest_new="$3"
446 if test -n "$message"
447 then
448 commit_message="$message"
449 else
450 commit_message="Split '$dir/' into commit '$latest_new'"
451 fi
452 cat <<-EOF
453 $commit_message
454
455 git-subtree-dir: $dir
456 git-subtree-mainline: $latest_old
457 git-subtree-split: $latest_new
458 EOF
459 }
460
461 squash_msg () {
462 dir="$1"
463 oldsub="$2"
464 newsub="$3"
465 newsub_short=$(git rev-parse --short "$newsub")
466
467 if test -n "$oldsub"
468 then
469 oldsub_short=$(git rev-parse --short "$oldsub")
470 echo "Squashed '$dir/' changes from $oldsub_short..$newsub_short"
471 echo
472 git log --no-show-signature --pretty=tformat:'%h %s' "$oldsub..$newsub"
473 git log --no-show-signature --pretty=tformat:'REVERT: %h %s' "$newsub..$oldsub"
474 else
475 echo "Squashed '$dir/' content from commit $newsub_short"
476 fi
477
478 echo
479 echo "git-subtree-dir: $dir"
480 echo "git-subtree-split: $newsub"
481 }
482
483 toptree_for_commit () {
484 commit="$1"
485 git rev-parse --verify "$commit^{tree}" || exit $?
486 }
487
488 subtree_for_commit () {
489 commit="$1"
490 dir="$2"
491 git ls-tree "$commit" -- "$dir" |
492 while read mode type tree name
493 do
494 assert test "$name" = "$dir"
495 assert test "$type" = "tree" -o "$type" = "commit"
496 test "$type" = "commit" && continue # ignore submodules
497 echo $tree
498 break
499 done
500 }
501
502 tree_changed () {
503 tree=$1
504 shift
505 if test $# -ne 1
506 then
507 return 0 # weird parents, consider it changed
508 else
509 ptree=$(toptree_for_commit $1)
510 if test "$ptree" != "$tree"
511 then
512 return 0 # changed
513 else
514 return 1 # not changed
515 fi
516 fi
517 }
518
519 new_squash_commit () {
520 old="$1"
521 oldsub="$2"
522 newsub="$3"
523 tree=$(toptree_for_commit $newsub) || exit $?
524 if test -n "$old"
525 then
526 squash_msg "$dir" "$oldsub" "$newsub" |
527 git commit-tree "$tree" -p "$old" || exit $?
528 else
529 squash_msg "$dir" "" "$newsub" |
530 git commit-tree "$tree" || exit $?
531 fi
532 }
533
534 copy_or_skip () {
535 rev="$1"
536 tree="$2"
537 newparents="$3"
538 assert test -n "$tree"
539
540 identical=
541 nonidentical=
542 p=
543 gotparents=
544 copycommit=
545 for parent in $newparents
546 do
547 ptree=$(toptree_for_commit $parent) || exit $?
548 test -z "$ptree" && continue
549 if test "$ptree" = "$tree"
550 then
551 # an identical parent could be used in place of this rev.
552 if test -n "$identical"
553 then
554 # if a previous identical parent was found, check whether
555 # one is already an ancestor of the other
556 mergebase=$(git merge-base $identical $parent)
557 if test "$identical" = "$mergebase"
558 then
559 # current identical commit is an ancestor of parent
560 identical="$parent"
561 elif test "$parent" != "$mergebase"
562 then
563 # no common history; commit must be copied
564 copycommit=1
565 fi
566 else
567 # first identical parent detected
568 identical="$parent"
569 fi
570 else
571 nonidentical="$parent"
572 fi
573
574 # sometimes both old parents map to the same newparent;
575 # eliminate duplicates
576 is_new=1
577 for gp in $gotparents
578 do
579 if test "$gp" = "$parent"
580 then
581 is_new=
582 break
583 fi
584 done
585 if test -n "$is_new"
586 then
587 gotparents="$gotparents $parent"
588 p="$p -p $parent"
589 fi
590 done
591
592 if test -n "$identical" && test -n "$nonidentical"
593 then
594 extras=$(git rev-list --count $identical..$nonidentical)
595 if test "$extras" -ne 0
596 then
597 # we need to preserve history along the other branch
598 copycommit=1
599 fi
600 fi
601 if test -n "$identical" && test -z "$copycommit"
602 then
603 echo $identical
604 else
605 copy_commit "$rev" "$tree" "$p" || exit $?
606 fi
607 }
608
609 ensure_clean () {
610 if ! git diff-index HEAD --exit-code --quiet 2>&1
611 then
612 die "Working tree has modifications. Cannot add."
613 fi
614 if ! git diff-index --cached HEAD --exit-code --quiet 2>&1
615 then
616 die "Index has modifications. Cannot add."
617 fi
618 }
619
620 ensure_valid_ref_format () {
621 git check-ref-format "refs/heads/$1" ||
622 die "'$1' does not look like a ref"
623 }
624
625 process_split_commit () {
626 local rev="$1"
627 local parents="$2"
628 local indent=$3
629
630 if test $indent -eq 0
631 then
632 revcount=$(($revcount + 1))
633 else
634 # processing commit without normal parent information;
635 # fetch from repo
636 parents=$(git rev-parse "$rev^@")
637 extracount=$(($extracount + 1))
638 fi
639
640 progress "$revcount/$revmax ($createcount) [$extracount]"
641
642 debug "Processing commit: $rev"
643 exists=$(cache_get "$rev")
644 if test -n "$exists"
645 then
646 debug " prior: $exists"
647 return
648 fi
649 createcount=$(($createcount + 1))
650 debug " parents: $parents"
651 check_parents "$parents" "$indent"
652 newparents=$(cache_get $parents)
653 debug " newparents: $newparents"
654
655 tree=$(subtree_for_commit "$rev" "$dir")
656 debug " tree is: $tree"
657
658 # ugly. is there no better way to tell if this is a subtree
659 # vs. a mainline commit? Does it matter?
660 if test -z "$tree"
661 then
662 set_notree "$rev"
663 if test -n "$newparents"
664 then
665 cache_set "$rev" "$rev"
666 fi
667 return
668 fi
669
670 newrev=$(copy_or_skip "$rev" "$tree" "$newparents") || exit $?
671 debug " newrev is: $newrev"
672 cache_set "$rev" "$newrev"
673 cache_set latest_new "$newrev"
674 cache_set latest_old "$rev"
675 }
676
677 cmd_add () {
678 if test -e "$dir"
679 then
680 die "'$dir' already exists. Cannot add."
681 fi
682
683 ensure_clean
684
685 if test $# -eq 1
686 then
687 git rev-parse -q --verify "$1^{commit}" >/dev/null ||
688 die "'$1' does not refer to a commit"
689
690 cmd_add_commit "$@"
691
692 elif test $# -eq 2
693 then
694 # Technically we could accept a refspec here but we're
695 # just going to turn around and add FETCH_HEAD under the
696 # specified directory. Allowing a refspec might be
697 # misleading because we won't do anything with any other
698 # branches fetched via the refspec.
699 ensure_valid_ref_format "$2"
700
701 cmd_add_repository "$@"
702 else
703 say "error: parameters were '$@'"
704 die "Provide either a commit or a repository and commit."
705 fi
706 }
707
708 cmd_add_repository () {
709 echo "git fetch" "$@"
710 repository=$1
711 refspec=$2
712 git fetch "$@" || exit $?
713 revs=FETCH_HEAD
714 set -- $revs
715 cmd_add_commit "$@"
716 }
717
718 cmd_add_commit () {
719 revs=$(git rev-parse $default --revs-only "$@") || exit $?
720 set -- $revs
721 rev="$1"
722
723 debug "Adding $dir as '$rev'..."
724 git read-tree --prefix="$dir" $rev || exit $?
725 git checkout -- "$dir" || exit $?
726 tree=$(git write-tree) || exit $?
727
728 headrev=$(git rev-parse HEAD) || exit $?
729 if test -n "$headrev" && test "$headrev" != "$rev"
730 then
731 headp="-p $headrev"
732 else
733 headp=
734 fi
735
736 if test -n "$squash"
737 then
738 rev=$(new_squash_commit "" "" "$rev") || exit $?
739 commit=$(add_squashed_msg "$rev" "$dir" |
740 git commit-tree "$tree" $headp -p "$rev") || exit $?
741 else
742 revp=$(peel_committish "$rev") &&
743 commit=$(add_msg "$dir" $headrev "$rev" |
744 git commit-tree "$tree" $headp -p "$revp") || exit $?
745 fi
746 git reset "$commit" || exit $?
747
748 say "Added dir '$dir'"
749 }
750
751 cmd_split () {
752 debug "Splitting $dir..."
753 cache_setup || exit $?
754
755 if test -n "$onto"
756 then
757 debug "Reading history for --onto=$onto..."
758 git rev-list $onto |
759 while read rev
760 do
761 # the 'onto' history is already just the subdir, so
762 # any parent we find there can be used verbatim
763 debug " cache: $rev"
764 cache_set "$rev" "$rev"
765 done
766 fi
767
768 unrevs="$(find_existing_splits "$dir" "$revs")"
769
770 # We can't restrict rev-list to only $dir here, because some of our
771 # parents have the $dir contents the root, and those won't match.
772 # (and rev-list --follow doesn't seem to solve this)
773 grl='git rev-list --topo-order --reverse --parents $revs $unrevs'
774 revmax=$(eval "$grl" | wc -l)
775 revcount=0
776 createcount=0
777 extracount=0
778 eval "$grl" |
779 while read rev parents
780 do
781 process_split_commit "$rev" "$parents" 0
782 done || exit $?
783
784 latest_new=$(cache_get latest_new)
785 if test -z "$latest_new"
786 then
787 die "No new revisions were found"
788 fi
789
790 if test -n "$rejoin"
791 then
792 debug "Merging split branch into HEAD..."
793 latest_old=$(cache_get latest_old)
794 git merge -s ours \
795 --allow-unrelated-histories \
796 -m "$(rejoin_msg "$dir" "$latest_old" "$latest_new")" \
797 "$latest_new" >&2 || exit $?
798 fi
799 if test -n "$branch"
800 then
801 if rev_exists "refs/heads/$branch"
802 then
803 if ! rev_is_descendant_of_branch "$latest_new" "$branch"
804 then
805 die "Branch '$branch' is not an ancestor of commit '$latest_new'."
806 fi
807 action='Updated'
808 else
809 action='Created'
810 fi
811 git update-ref -m 'subtree split' \
812 "refs/heads/$branch" "$latest_new" || exit $?
813 say "$action branch '$branch'"
814 fi
815 echo "$latest_new"
816 exit 0
817 }
818
819 cmd_merge () {
820 revs=$(git rev-parse $default --revs-only "$@") || exit $?
821 ensure_clean
822
823 set -- $revs
824 if test $# -ne 1
825 then
826 die "You must provide exactly one revision. Got: '$revs'"
827 fi
828 rev="$1"
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" "$@"