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