JezK
Edit File: git-subtree
#!/bin/sh # # git-subtree.sh: split/join git repositories in subdirectories of this one # # Copyright (C) 2009 Avery Pennarun <apenwarr@gmail.com> # if test -z "$GIT_EXEC_PATH" || ! test -f "$GIT_EXEC_PATH/git-sh-setup" || { test "${PATH#"${GIT_EXEC_PATH}:"}" = "$PATH" && test ! "$GIT_EXEC_PATH" -ef "${PATH%%:*}" 2>/dev/null } then basename=${0##*[/\\]} echo >&2 'It looks like either your git installation or your' echo >&2 'git-subtree installation is broken.' echo >&2 echo >&2 "Tips:" echo >&2 " - If \`git --exec-path\` does not print the correct path to" echo >&2 " your git install directory, then set the GIT_EXEC_PATH" echo >&2 " environment variable to the correct directory." echo >&2 " - Make sure that your \`$basename\` file is either in your" echo >&2 " PATH or in your git exec path (\`$(git --exec-path)\`)." echo >&2 " - You should run git-subtree as \`git ${basename#git-}\`," echo >&2 " not as \`$basename\`." >&2 exit 126 fi OPTS_SPEC="\ git subtree add --prefix=<prefix> <commit> git subtree add --prefix=<prefix> <repository> <ref> git subtree merge --prefix=<prefix> <commit> git subtree split --prefix=<prefix> [<commit>] git subtree pull --prefix=<prefix> <repository> <ref> git subtree push --prefix=<prefix> <repository> <refspec> -- h,help show the help q quiet d show debug messages P,prefix= the name of the subdir to split out options for 'split' (also: 'push') annotate= add a prefix to commit message of new commits b,branch= create a new branch from the split subtree ignore-joins ignore prior --rejoin commits onto= try connecting new tree to an existing one rejoin merge the new branch back into HEAD options for 'add' and 'merge' (also: 'pull', 'split --rejoin', and 'push --rejoin') squash merge subtree changes as a single commit m,message= use the given message as the commit message for the merge commit " indent=0 # Usage: say [MSG...] say () { if test -z "$arg_quiet" then printf '%s\n' "$*" fi } # Usage: debug [MSG...] debug () { if test -n "$arg_debug" then printf "%$(($indent * 2))s%s\n" '' "$*" >&2 fi } # Usage: progress [MSG...] progress () { if test -z "$arg_quiet" then if test -z "$arg_debug" then # Debug mode is off. # # Print one progress line that we keep updating (use # "\r" to return to the beginning of the line, rather # than "\n" to start a new line). This only really # works when stderr is a terminal. printf "%s\r" "$*" >&2 else # Debug mode is on. The `debug` function is regularly # printing to stderr. # # Don't do the one-line-with-"\r" thing, because on a # terminal the debug output would overwrite and hide the # progress output. Add a "progress:" prefix to make the # progress output and the debug output easy to # distinguish. This ensures maximum readability whether # stderr is a terminal or a file. printf "progress: %s\n" "$*" >&2 fi fi } # Usage: assert CMD... assert () { if ! "$@" then die "fatal: assertion failed: $*" fi } # Usage: die_incompatible_opt OPTION COMMAND die_incompatible_opt () { assert test "$#" = 2 opt="$1" arg_command="$2" die "fatal: the '$opt' flag does not make sense with 'git subtree $arg_command'." } main () { if test $# -eq 0 then set -- -h fi set_args="$(echo "$OPTS_SPEC" | git rev-parse --parseopt -- "$@" || echo exit $?)" eval "$set_args" . git-sh-setup require_work_tree # First figure out the command and whether we use --rejoin, so # that we can provide more helpful validation when we do the # "real" flag parsing. arg_split_rejoin= allow_split= allow_addmerge= while test $# -gt 0 do opt="$1" shift case "$opt" in --annotate|-b|-P|-m|--onto) shift ;; --rejoin) arg_split_rejoin=1 ;; --no-rejoin) arg_split_rejoin= ;; --) break ;; esac done arg_command=$1 case "$arg_command" in add|merge|pull) allow_addmerge=1 ;; split|push) allow_split=1 allow_addmerge=$arg_split_rejoin ;; *) die "fatal: unknown command '$arg_command'" ;; esac # Reset the arguments array for "real" flag parsing. eval "$set_args" # Begin "real" flag parsing. arg_quiet= arg_debug= arg_prefix= arg_split_branch= arg_split_onto= arg_split_ignore_joins= arg_split_annotate= arg_addmerge_squash= arg_addmerge_message= while test $# -gt 0 do opt="$1" shift case "$opt" in -q) arg_quiet=1 ;; -d) arg_debug=1 ;; --annotate) test -n "$allow_split" || die_incompatible_opt "$opt" "$arg_command" arg_split_annotate="$1" shift ;; --no-annotate) test -n "$allow_split" || die_incompatible_opt "$opt" "$arg_command" arg_split_annotate= ;; -b) test -n "$allow_split" || die_incompatible_opt "$opt" "$arg_command" arg_split_branch="$1" shift ;; -P) arg_prefix="${1%/}" shift ;; -m) test -n "$allow_addmerge" || die_incompatible_opt "$opt" "$arg_command" arg_addmerge_message="$1" shift ;; --no-prefix) arg_prefix= ;; --onto) test -n "$allow_split" || die_incompatible_opt "$opt" "$arg_command" arg_split_onto="$1" shift ;; --no-onto) test -n "$allow_split" || die_incompatible_opt "$opt" "$arg_command" arg_split_onto= ;; --rejoin) test -n "$allow_split" || die_incompatible_opt "$opt" "$arg_command" ;; --no-rejoin) test -n "$allow_split" || die_incompatible_opt "$opt" "$arg_command" ;; --ignore-joins) test -n "$allow_split" || die_incompatible_opt "$opt" "$arg_command" arg_split_ignore_joins=1 ;; --no-ignore-joins) test -n "$allow_split" || die_incompatible_opt "$opt" "$arg_command" arg_split_ignore_joins= ;; --squash) test -n "$allow_addmerge" || die_incompatible_opt "$opt" "$arg_command" arg_addmerge_squash=1 ;; --no-squash) test -n "$allow_addmerge" || die_incompatible_opt "$opt" "$arg_command" arg_addmerge_squash= ;; --) break ;; *) die "fatal: unexpected option: $opt" ;; esac done shift if test -z "$arg_prefix" then die "fatal: you must provide the --prefix option." fi case "$arg_command" in add) test -e "$arg_prefix" && die "fatal: prefix '$arg_prefix' already exists." ;; *) test -e "$arg_prefix" || die "fatal: '$arg_prefix' does not exist; use 'git subtree add'" ;; esac dir="$(dirname "$arg_prefix/.")" debug "command: {$arg_command}" debug "quiet: {$arg_quiet}" debug "dir: {$dir}" debug "opts: {$*}" debug "cmd_$arg_command" "$@" } # Usage: cache_setup cache_setup () { assert test $# = 0 cachedir="$GIT_DIR/subtree-cache/$$" rm -rf "$cachedir" || die "fatal: can't delete old cachedir: $cachedir" mkdir -p "$cachedir" || die "fatal: can't create new cachedir: $cachedir" mkdir -p "$cachedir/notree" || die "fatal: can't create new cachedir: $cachedir/notree" debug "Using cachedir: $cachedir" >&2 } # Usage: cache_get [REVS...] cache_get () { for oldrev in "$@" do if test -r "$cachedir/$oldrev" then read newrev <"$cachedir/$oldrev" echo $newrev fi done } # Usage: cache_miss [REVS...] cache_miss () { for oldrev in "$@" do if ! test -r "$cachedir/$oldrev" then echo $oldrev fi done } # Usage: check_parents [REVS...] check_parents () { missed=$(cache_miss "$@") || exit $? local indent=$(($indent + 1)) for miss in $missed do if ! test -r "$cachedir/notree/$miss" then debug "incorrect order: $miss" process_split_commit "$miss" "" fi done } # Usage: set_notree REV set_notree () { assert test $# = 1 echo "1" > "$cachedir/notree/$1" } # Usage: cache_set OLDREV NEWREV cache_set () { assert test $# = 2 oldrev="$1" newrev="$2" if test "$oldrev" != "latest_old" && test "$oldrev" != "latest_new" && test -e "$cachedir/$oldrev" then die "fatal: cache for $oldrev already exists!" fi echo "$newrev" >"$cachedir/$oldrev" } # Usage: rev_exists REV rev_exists () { assert test $# = 1 if git rev-parse "$1" >/dev/null 2>&1 then return 0 else return 1 fi } # Usage: try_remove_previous REV # # If a commit doesn't have a parent, this might not work. But we only want # to remove the parent from the rev-list, and since it doesn't exist, it won't # be there anyway, so do nothing in that case. try_remove_previous () { assert test $# = 1 if rev_exists "$1^" then echo "^$1^" fi } # Usage: process_subtree_split_trailer SPLIT_HASH MAIN_HASH [REPOSITORY] process_subtree_split_trailer () { assert test $# = 2 -o $# = 3 b="$1" sq="$2" repository="" if test "$#" = 3 then repository="$3" fi fail_msg="fatal: could not rev-parse split hash $b from commit $sq" if ! sub="$(git rev-parse --verify --quiet "$b^{commit}")" then # if 'repository' was given, try to fetch the 'git-subtree-split' hash # before 'rev-parse'-ing it again, as it might be a tag that we do not have locally if test -n "${repository}" then git fetch "$repository" "$b" sub="$(git rev-parse --verify --quiet "$b^{commit}")" || die "$fail_msg" else hint1=$(printf "hint: hash might be a tag, try fetching it from the subtree repository:") hint2=$(printf "hint: git fetch <subtree-repository> $b") fail_msg=$(printf "$fail_msg\n$hint1\n$hint2") die "$fail_msg" fi fi } # Usage: find_latest_squash DIR [REPOSITORY] find_latest_squash () { assert test $# = 1 -o $# = 2 dir="$1" repository="" if test "$#" = 2 then repository="$2" fi debug "Looking for latest squash (dir=$dir, repository=$repository)..." local indent=$(($indent + 1)) sq= main= sub= git log --grep="^git-subtree-dir: $dir/*\$" \ --no-show-signature --pretty=format:'START %H%n%s%n%n%b%nEND%n' HEAD | while read a b junk do debug "$a $b $junk" debug "{{$sq/$main/$sub}}" case "$a" in START) sq="$b" ;; git-subtree-mainline:) main="$b" ;; git-subtree-split:) process_subtree_split_trailer "$b" "$sq" "$repository" ;; END) if test -n "$sub" then if test -n "$main" then # a rejoin commit? # Pretend its sub was a squash. sq=$(git rev-parse --verify "$sq^2") || die fi debug "Squash found: $sq $sub" echo "$sq" "$sub" break fi sq= main= sub= ;; esac done || exit $? } # Usage: find_existing_splits DIR REV [REPOSITORY] find_existing_splits () { assert test $# = 2 -o $# = 3 debug "Looking for prior splits..." local indent=$(($indent + 1)) dir="$1" rev="$2" repository="" if test "$#" = 3 then repository="$3" fi main= sub= local grep_format="^git-subtree-dir: $dir/*\$" if test -n "$arg_split_ignore_joins" then grep_format="^Add '$dir/' from commit '" fi git log --grep="$grep_format" \ --no-show-signature --pretty=format:'START %H%n%s%n%n%b%nEND%n' "$rev" | while read a b junk do case "$a" in START) sq="$b" ;; git-subtree-mainline:) main="$b" ;; git-subtree-split:) process_subtree_split_trailer "$b" "$sq" "$repository" ;; END) debug "Main is: '$main'" if test -z "$main" -a -n "$sub" then # squash commits refer to a subtree debug " Squash: $sq from $sub" cache_set "$sq" "$sub" fi if test -n "$main" -a -n "$sub" then debug " Prior: $main -> $sub" cache_set $main $sub cache_set $sub $sub try_remove_previous "$main" try_remove_previous "$sub" fi main= sub= ;; esac done || exit $? } # Usage: copy_commit REV TREE FLAGS_STR copy_commit () { assert test $# = 3 # We're going to set some environment vars here, so # do it in a subshell to get rid of them safely later debug copy_commit "{$1}" "{$2}" "{$3}" git log -1 --no-show-signature --pretty=format:'%an%n%ae%n%aD%n%cn%n%ce%n%cD%n%B' "$1" | ( read GIT_AUTHOR_NAME read GIT_AUTHOR_EMAIL read GIT_AUTHOR_DATE read GIT_COMMITTER_NAME read GIT_COMMITTER_EMAIL read GIT_COMMITTER_DATE export GIT_AUTHOR_NAME \ GIT_AUTHOR_EMAIL \ GIT_AUTHOR_DATE \ GIT_COMMITTER_NAME \ GIT_COMMITTER_EMAIL \ GIT_COMMITTER_DATE ( printf "%s" "$arg_split_annotate" cat ) | git commit-tree "$2" $3 # reads the rest of stdin ) || die "fatal: can't copy commit $1" } # Usage: add_msg DIR LATEST_OLD LATEST_NEW add_msg () { assert test $# = 3 dir="$1" latest_old="$2" latest_new="$3" if test -n "$arg_addmerge_message" then commit_message="$arg_addmerge_message" else commit_message="Add '$dir/' from commit '$latest_new'" fi if test -n "$arg_split_rejoin" then # If this is from a --rejoin, then rejoin_msg has # already inserted the `git-subtree-xxx:` tags echo "$commit_message" return fi cat <<-EOF $commit_message git-subtree-dir: $dir git-subtree-mainline: $latest_old git-subtree-split: $latest_new EOF } # Usage: add_squashed_msg REV DIR add_squashed_msg () { assert test $# = 2 if test -n "$arg_addmerge_message" then echo "$arg_addmerge_message" else echo "Merge commit '$1' as '$2'" fi } # Usage: rejoin_msg DIR LATEST_OLD LATEST_NEW rejoin_msg () { assert test $# = 3 dir="$1" latest_old="$2" latest_new="$3" if test -n "$arg_addmerge_message" then commit_message="$arg_addmerge_message" else commit_message="Split '$dir/' into commit '$latest_new'" fi cat <<-EOF $commit_message git-subtree-dir: $dir git-subtree-mainline: $latest_old git-subtree-split: $latest_new EOF } # Usage: squash_msg DIR OLD_SUBTREE_COMMIT NEW_SUBTREE_COMMIT squash_msg () { assert test $# = 3 dir="$1" oldsub="$2" newsub="$3" newsub_short=$(git rev-parse --short "$newsub") if test -n "$oldsub" then oldsub_short=$(git rev-parse --short "$oldsub") echo "Squashed '$dir/' changes from $oldsub_short..$newsub_short" echo git log --no-show-signature --pretty=tformat:'%h %s' "$oldsub..$newsub" git log --no-show-signature --pretty=tformat:'REVERT: %h %s' "$newsub..$oldsub" else echo "Squashed '$dir/' content from commit $newsub_short" fi echo echo "git-subtree-dir: $dir" echo "git-subtree-split: $newsub" } # Usage: toptree_for_commit COMMIT toptree_for_commit () { assert test $# = 1 commit="$1" git rev-parse --verify "$commit^{tree}" || exit $? } # Usage: subtree_for_commit COMMIT DIR subtree_for_commit () { assert test $# = 2 commit="$1" dir="$2" git ls-tree "$commit" -- "$dir" | while read mode type tree name do assert test "$name" = "$dir" assert test "$type" = "tree" -o "$type" = "commit" test "$type" = "commit" && continue # ignore submodules echo $tree break done || exit $? } # Usage: tree_changed TREE [PARENTS...] tree_changed () { assert test $# -gt 0 tree=$1 shift if test $# -ne 1 then return 0 # weird parents, consider it changed else ptree=$(toptree_for_commit $1) || exit $? if test "$ptree" != "$tree" then return 0 # changed else return 1 # not changed fi fi } # Usage: new_squash_commit OLD_SQUASHED_COMMIT OLD_NONSQUASHED_COMMIT NEW_NONSQUASHED_COMMIT new_squash_commit () { assert test $# = 3 old="$1" oldsub="$2" newsub="$3" tree=$(toptree_for_commit $newsub) || exit $? if test -n "$old" then squash_msg "$dir" "$oldsub" "$newsub" | git commit-tree "$tree" -p "$old" || exit $? else squash_msg "$dir" "" "$newsub" | git commit-tree "$tree" || exit $? fi } # Usage: copy_or_skip REV TREE NEWPARENTS copy_or_skip () { assert test $# = 3 rev="$1" tree="$2" newparents="$3" assert test -n "$tree" identical= nonidentical= p= gotparents= copycommit= for parent in $newparents do ptree=$(toptree_for_commit $parent) || exit $? test -z "$ptree" && continue if test "$ptree" = "$tree" then # an identical parent could be used in place of this rev. if test -n "$identical" then # if a previous identical parent was found, check whether # one is already an ancestor of the other mergebase=$(git merge-base $identical $parent) if test "$identical" = "$mergebase" then # current identical commit is an ancestor of parent identical="$parent" elif test "$parent" != "$mergebase" then # no common history; commit must be copied copycommit=1 fi else # first identical parent detected identical="$parent" fi else nonidentical="$parent" fi # sometimes both old parents map to the same newparent; # eliminate duplicates is_new=1 for gp in $gotparents do if test "$gp" = "$parent" then is_new= break fi done if test -n "$is_new" then gotparents="$gotparents $parent" p="$p -p $parent" fi done if test -n "$identical" && test -n "$nonidentical" then extras=$(git rev-list --count $identical..$nonidentical) if test "$extras" -ne 0 then # we need to preserve history along the other branch copycommit=1 fi fi if test -n "$identical" && test -z "$copycommit" then echo $identical else copy_commit "$rev" "$tree" "$p" || exit $? fi } # Usage: ensure_clean ensure_clean () { assert test $# = 0 if ! git diff-index HEAD --exit-code --quiet 2>&1 then die "fatal: working tree has modifications. Cannot add." fi if ! git diff-index --cached HEAD --exit-code --quiet 2>&1 then die "fatal: index has modifications. Cannot add." fi } # Usage: ensure_valid_ref_format REF ensure_valid_ref_format () { assert test $# = 1 git check-ref-format "refs/heads/$1" || die "fatal: '$1' does not look like a ref" } # Usage: process_split_commit REV PARENTS process_split_commit () { assert test $# = 2 local rev="$1" local parents="$2" if test $indent -eq 0 then revcount=$(($revcount + 1)) else # processing commit without normal parent information; # fetch from repo parents=$(git rev-parse "$rev^@") extracount=$(($extracount + 1)) fi progress "$revcount/$revmax ($createcount) [$extracount]" debug "Processing commit: $rev" local indent=$(($indent + 1)) exists=$(cache_get "$rev") || exit $? if test -n "$exists" then debug "prior: $exists" return fi createcount=$(($createcount + 1)) debug "parents: $parents" check_parents $parents newparents=$(cache_get $parents) || exit $? debug "newparents: $newparents" tree=$(subtree_for_commit "$rev" "$dir") || exit $? debug "tree is: $tree" # ugly. is there no better way to tell if this is a subtree # vs. a mainline commit? Does it matter? if test -z "$tree" then set_notree "$rev" if test -n "$newparents" then cache_set "$rev" "$rev" fi return fi newrev=$(copy_or_skip "$rev" "$tree" "$newparents") || exit $? debug "newrev is: $newrev" cache_set "$rev" "$newrev" cache_set latest_new "$newrev" cache_set latest_old "$rev" } # Usage: cmd_add REV # Or: cmd_add REPOSITORY REF cmd_add () { ensure_clean if test $# -eq 1 then git rev-parse -q --verify "$1^{commit}" >/dev/null || die "fatal: '$1' does not refer to a commit" cmd_add_commit "$@" elif test $# -eq 2 then # Technically we could accept a refspec here but we're # just going to turn around and add FETCH_HEAD under the # specified directory. Allowing a refspec might be # misleading because we won't do anything with any other # branches fetched via the refspec. ensure_valid_ref_format "$2" cmd_add_repository "$@" else say >&2 "fatal: parameters were '$*'" die "Provide either a commit or a repository and commit." fi } # Usage: cmd_add_repository REPOSITORY REFSPEC cmd_add_repository () { assert test $# = 2 echo "git fetch" "$@" repository=$1 refspec=$2 git fetch "$@" || exit $? cmd_add_commit FETCH_HEAD } # Usage: cmd_add_commit REV cmd_add_commit () { # The rev has already been validated by cmd_add(), we just # need to normalize it. assert test $# = 1 rev=$(git rev-parse --verify "$1^{commit}") || exit $? debug "Adding $dir as '$rev'..." if test -z "$arg_split_rejoin" then # Only bother doing this if this is a genuine 'add', # not a synthetic 'add' from '--rejoin'. git read-tree --prefix="$dir" $rev || exit $? fi git checkout -- "$dir" || exit $? tree=$(git write-tree) || exit $? headrev=$(git rev-parse --verify HEAD) || exit $? if test -n "$headrev" && test "$headrev" != "$rev" then headp="-p $headrev" else headp= fi if test -n "$arg_addmerge_squash" then rev=$(new_squash_commit "" "" "$rev") || exit $? commit=$(add_squashed_msg "$rev" "$dir" | git commit-tree "$tree" $headp -p "$rev") || exit $? else revp=$(peel_committish "$rev") || exit $? commit=$(add_msg "$dir" $headrev "$rev" | git commit-tree "$tree" $headp -p "$revp") || exit $? fi git reset "$commit" || exit $? say >&2 "Added dir '$dir'" } # Usage: cmd_split [REV] [REPOSITORY] cmd_split () { if test $# -eq 0 then rev=$(git rev-parse HEAD) elif test $# -eq 1 -o $# -eq 2 then rev=$(git rev-parse -q --verify "$1^{commit}") || die "fatal: '$1' does not refer to a commit" else die "fatal: you must provide exactly one revision, and optionnally a repository. Got: '$*'" fi repository="" if test "$#" = 2 then repository="$2" fi if test -n "$arg_split_rejoin" then ensure_clean fi debug "Splitting $dir..." cache_setup || exit $? if test -n "$arg_split_onto" then debug "Reading history for --onto=$arg_split_onto..." git rev-list $arg_split_onto | while read rev do # the 'onto' history is already just the subdir, so # any parent we find there can be used verbatim debug "cache: $rev" cache_set "$rev" "$rev" done || exit $? fi unrevs="$(find_existing_splits "$dir" "$rev" "$repository")" || exit $? # We can't restrict rev-list to only $dir here, because some of our # parents have the $dir contents the root, and those won't match. # (and rev-list --follow doesn't seem to solve this) grl='git rev-list --topo-order --reverse --parents $rev $unrevs' revmax=$(eval "$grl" | wc -l) revcount=0 createcount=0 extracount=0 eval "$grl" | while read rev parents do process_split_commit "$rev" "$parents" done || exit $? latest_new=$(cache_get latest_new) || exit $? if test -z "$latest_new" then die "fatal: no new revisions were found" fi if test -n "$arg_split_rejoin" then debug "Merging split branch into HEAD..." latest_old=$(cache_get latest_old) || exit $? arg_addmerge_message="$(rejoin_msg "$dir" "$latest_old" "$latest_new")" || exit $? if test -z "$(find_latest_squash "$dir")" then cmd_add "$latest_new" >&2 || exit $? else cmd_merge "$latest_new" >&2 || exit $? fi fi if test -n "$arg_split_branch" then if rev_exists "refs/heads/$arg_split_branch" then if ! git merge-base --is-ancestor "$arg_split_branch" "$latest_new" then die "fatal: branch '$arg_split_branch' is not an ancestor of commit '$latest_new'." fi action='Updated' else action='Created' fi git update-ref -m 'subtree split' \ "refs/heads/$arg_split_branch" "$latest_new" || exit $? say >&2 "$action branch '$arg_split_branch'" fi echo "$latest_new" exit 0 } # Usage: cmd_merge REV [REPOSITORY] cmd_merge () { test $# -eq 1 -o $# -eq 2 || die "fatal: you must provide exactly one revision, and optionally a repository. Got: '$*'" rev=$(git rev-parse -q --verify "$1^{commit}") || die "fatal: '$1' does not refer to a commit" repository="" if test "$#" = 2 then repository="$2" fi ensure_clean if test -n "$arg_addmerge_squash" then first_split="$(find_latest_squash "$dir" "$repository")" || exit $? if test -z "$first_split" then die "fatal: can't squash-merge: '$dir' was never added." fi set $first_split old=$1 sub=$2 if test "$sub" = "$rev" then say >&2 "Subtree is already at commit $rev." exit 0 fi new=$(new_squash_commit "$old" "$sub" "$rev") || exit $? debug "New squash commit: $new" rev="$new" fi if test -n "$arg_addmerge_message" then git merge --no-ff -Xsubtree="$arg_prefix" \ --message="$arg_addmerge_message" "$rev" else git merge --no-ff -Xsubtree="$arg_prefix" $rev fi } # Usage: cmd_pull REPOSITORY REMOTEREF cmd_pull () { if test $# -ne 2 then die "fatal: you must provide <repository> <ref>" fi repository="$1" ref="$2" ensure_clean ensure_valid_ref_format "$ref" git fetch "$repository" "$ref" || exit $? cmd_merge FETCH_HEAD "$repository" } # Usage: cmd_push REPOSITORY [+][LOCALREV:]REMOTEREF cmd_push () { if test $# -ne 2 then die "fatal: you must provide <repository> <refspec>" fi if test -e "$dir" then repository=$1 refspec=${2#+} remoteref=${refspec#*:} if test "$remoteref" = "$refspec" then localrevname_presplit=HEAD else localrevname_presplit=${refspec%%:*} fi ensure_valid_ref_format "$remoteref" localrev_presplit=$(git rev-parse -q --verify "$localrevname_presplit^{commit}") || die "fatal: '$localrevname_presplit' does not refer to a commit" echo "git push using: " "$repository" "$refspec" localrev=$(cmd_split "$localrev_presplit" "$repository") || die git push "$repository" "$localrev":"refs/heads/$remoteref" else die "fatal: '$dir' must already exist. Try 'git subtree add'." fi } main "$@"