Merge branch 'rs/more-buffered-io'
[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" "$@"