diff options
Diffstat (limited to 'contrib')
| -rw-r--r-- | contrib/coccinelle/README | 2 | ||||
| -rw-r--r-- | contrib/coccinelle/object_id.cocci | 95 | ||||
| -rw-r--r-- | contrib/completion/git-completion.bash | 126 | ||||
| -rw-r--r-- | contrib/git-jump/README | 6 | ||||
| -rwxr-xr-x | contrib/git-jump/git-jump | 8 | ||||
| -rw-r--r-- | contrib/persistent-https/Makefile | 6 | ||||
| -rwxr-xr-x | contrib/subtree/git-subtree.sh | 678 | ||||
| -rwxr-xr-x | contrib/subtree/t/t7900-subtree.sh | 32 |
8 files changed, 653 insertions, 300 deletions
diff --git a/contrib/coccinelle/README b/contrib/coccinelle/README new file mode 100644 index 0000000..9c2f887 --- /dev/null +++ b/contrib/coccinelle/README @@ -0,0 +1,2 @@ +This directory provides examples of Coccinelle (http://coccinelle.lip6.fr/) +semantic patches that might be useful to developers. diff --git a/contrib/coccinelle/object_id.cocci b/contrib/coccinelle/object_id.cocci new file mode 100644 index 0000000..8ccdbb5 --- /dev/null +++ b/contrib/coccinelle/object_id.cocci @@ -0,0 +1,95 @@ +@@ +expression E1; +@@ +- is_null_sha1(E1.hash) ++ is_null_oid(&E1) + +@@ +expression E1; +@@ +- is_null_sha1(E1->hash) ++ is_null_oid(E1) + +@@ +expression E1; +@@ +- sha1_to_hex(E1.hash) ++ oid_to_hex(&E1) + +@@ +expression E1; +@@ +- sha1_to_hex(E1->hash) ++ oid_to_hex(E1) + +@@ +expression E1; +@@ +- sha1_to_hex_r(E1.hash) ++ oid_to_hex_r(&E1) + +@@ +expression E1; +@@ +- sha1_to_hex_r(E1->hash) ++ oid_to_hex_r(E1) + +@@ +expression E1; +@@ +- hashclr(E1.hash) ++ oidclr(&E1) + +@@ +expression E1; +@@ +- hashclr(E1->hash) ++ oidclr(E1) + +@@ +expression E1, E2; +@@ +- hashcmp(E1.hash, E2.hash) ++ oidcmp(&E1, &E2) + +@@ +expression E1, E2; +@@ +- hashcmp(E1->hash, E2->hash) ++ oidcmp(E1, E2) + +@@ +expression E1, E2; +@@ +- hashcmp(E1->hash, E2.hash) ++ oidcmp(E1, &E2) + +@@ +expression E1, E2; +@@ +- hashcmp(E1.hash, E2->hash) ++ oidcmp(&E1, E2) + +@@ +expression E1, E2; +@@ +- hashcpy(E1.hash, E2.hash) ++ oidcpy(&E1, &E2) + +@@ +expression E1, E2; +@@ +- hashcpy(E1->hash, E2->hash) ++ oidcpy(E1, E2) + +@@ +expression E1, E2; +@@ +- hashcpy(E1->hash, E2.hash) ++ oidcpy(E1, &E2) + +@@ +expression E1, E2; +@@ +- hashcpy(E1.hash, E2->hash) ++ oidcpy(&E1, E2) diff --git a/contrib/completion/git-completion.bash b/contrib/completion/git-completion.bash index 8f700de..c1b2135 100644 --- a/contrib/completion/git-completion.bash +++ b/contrib/completion/git-completion.bash @@ -803,6 +803,50 @@ __git_find_on_cmdline () done } +# Echo the value of an option set on the command line or config +# +# $1: short option name +# $2: long option name including = +# $3: list of possible values +# $4: config string (optional) +# +# example: +# result="$(__git_get_option_value "-d" "--do-something=" \ +# "yes no" "core.doSomething")" +# +# result is then either empty (no option set) or "yes" or "no" +# +# __git_get_option_value requires 3 arguments +__git_get_option_value () +{ + local c short_opt long_opt val + local result= values config_key word + + short_opt="$1" + long_opt="$2" + values="$3" + config_key="$4" + + ((c = $cword - 1)) + while [ $c -ge 0 ]; do + word="${words[c]}" + for val in $values; do + if [ "$short_opt$val" = "$word" ] || + [ "$long_opt$val" = "$word" ]; then + result="$val" + break 2 + fi + done + ((c--)) + done + + if [ -n "$config_key" ] && [ -z "$result" ]; then + result="$(git --git-dir="$(__gitdir)" config "$config_key")" + fi + + echo "$result" +} + __git_has_doubledash () { local c=1 @@ -1092,12 +1136,15 @@ _git_clone () --depth --single-branch --branch + --recurse-submodules " return ;; esac } +__git_untracked_file_modes="all no normal" + _git_commit () { case "$prev" in @@ -1119,7 +1166,7 @@ _git_commit () return ;; --untracked-files=*) - __gitcomp "all no normal" "" "${cur##--untracked-files=}" + __gitcomp "$__git_untracked_file_modes" "" "${cur##--untracked-files=}" return ;; --*) @@ -1795,6 +1842,56 @@ _git_stage () _git_add } +_git_status () +{ + local complete_opt + local untracked_state + + case "$cur" in + --ignore-submodules=*) + __gitcomp "none untracked dirty all" "" "${cur##--ignore-submodules=}" + return + ;; + --untracked-files=*) + __gitcomp "$__git_untracked_file_modes" "" "${cur##--untracked-files=}" + return + ;; + --column=*) + __gitcomp " + always never auto column row plain dense nodense + " "" "${cur##--column=}" + return + ;; + --*) + __gitcomp " + --short --branch --porcelain --long --verbose + --untracked-files= --ignore-submodules= --ignored + --column= --no-column + " + return + ;; + esac + + untracked_state="$(__git_get_option_value "-u" "--untracked-files=" \ + "$__git_untracked_file_modes" "status.showUntrackedFiles")" + + case "$untracked_state" in + no) + # --ignored option does not matter + complete_opt= + ;; + all|normal|*) + complete_opt="--cached --directory --no-empty-directory --others" + + if [ -n "$(__git_find_on_cmdline "--ignored")" ]; then + complete_opt="$complete_opt --ignored --exclude=*" + fi + ;; + esac + + __git_complete_index_file "$complete_opt" +} + __git_config_get_set_variables () { local prevword word config_file= c=$cword @@ -2100,6 +2197,7 @@ _git_config () format.attach format.cc format.coverLetter + format.from format.headers format.numbered format.pretty @@ -2614,6 +2712,32 @@ _git_whatchanged () _git_log } +_git_worktree () +{ + local subcommands="add list lock prune unlock" + local subcommand="$(__git_find_on_cmdline "$subcommands")" + if [ -z "$subcommand" ]; then + __gitcomp "$subcommands" + else + case "$subcommand,$cur" in + add,--*) + __gitcomp "--detach" + ;; + list,--*) + __gitcomp "--porcelain" + ;; + lock,--*) + __gitcomp "--reason" + ;; + prune,--*) + __gitcomp "--dry-run --expire --verbose" + ;; + *) + ;; + esac + fi +} + __git_main () { local i c=1 command __git_dir diff --git a/contrib/git-jump/README b/contrib/git-jump/README index 1cebc32..225e3f0 100644 --- a/contrib/git-jump/README +++ b/contrib/git-jump/README @@ -29,7 +29,7 @@ Obviously this trivial case isn't that interesting; you could just open `foo.c` yourself. But when you have many changes scattered across a project, you can use the editor's support to "jump" from point to point. -Git-jump can generate three types of interesting lists: +Git-jump can generate four types of interesting lists: 1. The beginning of any diff hunks. @@ -37,6 +37,8 @@ Git-jump can generate three types of interesting lists: 3. Any grep matches. + 4. Any whitespace errors detected by `git diff --check`. + Using git-jump -------------- @@ -83,7 +85,7 @@ complete list of files and line numbers for each match. Limitations ----------- -This scripts was written and tested with vim. Given that the quickfix +This script was written and tested with vim. Given that the quickfix format is the same as what gcc produces, I expect emacs users have a similar feature for iterating through the list, but I know nothing about how to activate it. diff --git a/contrib/git-jump/git-jump b/contrib/git-jump/git-jump index dc90cd6..427f206 100755 --- a/contrib/git-jump/git-jump +++ b/contrib/git-jump/git-jump @@ -12,6 +12,8 @@ diff: elements are diff hunks. Arguments are given to diff. merge: elements are merge conflicts. Arguments are ignored. grep: elements are grep hits. Arguments are given to grep. + +ws: elements are whitespace errors. Arguments are given to diff --check. EOF } @@ -25,7 +27,7 @@ mode_diff() { perl -ne ' if (m{^\+\+\+ (.*)}) { $file = $1; next } defined($file) or next; - if (m/^@@ .*\+(\d+)/) { $line = $1; next } + if (m/^@@ .*?\+(\d+)/) { $line = $1; next } defined($line) or next; if (/^ /) { $line++; next } if (/^[-+]\s*(.*)/) { @@ -55,6 +57,10 @@ mode_grep() { ' } +mode_ws() { + git diff --check "$@" +} + if test $# -lt 1; then usage >&2 exit 1 diff --git a/contrib/persistent-https/Makefile b/contrib/persistent-https/Makefile index 92baa3b..52b84ba 100644 --- a/contrib/persistent-https/Makefile +++ b/contrib/persistent-https/Makefile @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -BUILD_LABEL=$(shell date +"%s") +BUILD_LABEL=$(shell cut -d" " -f3 ../../GIT-VERSION-FILE) TAR_OUT=$(shell go env GOOS)_$(shell go env GOARCH).tar.gz all: git-remote-persistent-https git-remote-persistent-https--proxy \ @@ -25,8 +25,10 @@ git-remote-persistent-http: git-remote-persistent-https ln -f -s git-remote-persistent-https git-remote-persistent-http git-remote-persistent-https: + case $$(go version) in \ + "go version go"1.[0-5].*) EQ=" " ;; *) EQ="=" ;; esac && \ go build -o git-remote-persistent-https \ - -ldflags "-X main._BUILD_EMBED_LABEL $(BUILD_LABEL)" + -ldflags "-X main._BUILD_EMBED_LABEL$${EQ}$(BUILD_LABEL)" clean: rm -f git-remote-persistent-http* *.tar.gz diff --git a/contrib/subtree/git-subtree.sh b/contrib/subtree/git-subtree.sh index 7a39b30..dec085a 100755 --- a/contrib/subtree/git-subtree.sh +++ b/contrib/subtree/git-subtree.sh @@ -4,8 +4,9 @@ # # Copyright (C) 2009 Avery Pennarun <apenwarr@gmail.com> # -if [ $# -eq 0 ]; then - set -- -h +if test $# -eq 0 +then + set -- -h fi OPTS_SPEC="\ git subtree add --prefix=<prefix> <commit> @@ -48,89 +49,144 @@ squash= message= prefix= -debug() -{ - if [ -n "$debug" ]; then +debug () { + if test -n "$debug" + then printf "%s\n" "$*" >&2 fi } -say() -{ - if [ -z "$quiet" ]; then +say () { + if test -z "$quiet" + then printf "%s\n" "$*" >&2 fi } -progress() -{ - if [ -z "$quiet" ]; then +progress () { + if test -z "$quiet" + then printf "%s\r" "$*" >&2 fi } -assert() -{ - if "$@"; then - : - else +assert () { + if ! "$@" + then die "assertion failed: " "$@" fi } -#echo "Options: $*" - -while [ $# -gt 0 ]; do +while test $# -gt 0 +do opt="$1" shift + case "$opt" in - -q) quiet=1 ;; - -d) debug=1 ;; - --annotate) annotate="$1"; shift ;; - --no-annotate) annotate= ;; - -b) branch="$1"; shift ;; - -P) prefix="${1%/}"; shift ;; - -m) message="$1"; shift ;; - --no-prefix) prefix= ;; - --onto) onto="$1"; shift ;; - --no-onto) onto= ;; - --rejoin) rejoin=1 ;; - --no-rejoin) rejoin= ;; - --ignore-joins) ignore_joins=1 ;; - --no-ignore-joins) ignore_joins= ;; - --squash) squash=1 ;; - --no-squash) squash= ;; - --) break ;; - *) die "Unexpected option: $opt" ;; + -q) + quiet=1 + ;; + -d) + debug=1 + ;; + --annotate) + annotate="$1" + shift + ;; + --no-annotate) + annotate= + ;; + -b) + branch="$1" + shift + ;; + -P) + prefix="${1%/}" + shift + ;; + -m) + message="$1" + shift + ;; + --no-prefix) + prefix= + ;; + --onto) + onto="$1" + shift + ;; + --no-onto) + onto= + ;; + --rejoin) + rejoin=1 + ;; + --no-rejoin) + rejoin= + ;; + --ignore-joins) + ignore_joins=1 + ;; + --no-ignore-joins) + ignore_joins= + ;; + --squash) + squash=1 + ;; + --no-squash) + squash= + ;; + --) + break + ;; + *) + die "Unexpected option: $opt" + ;; esac done command="$1" shift + case "$command" in - add|merge|pull) default= ;; - split|push) default="--default HEAD" ;; - *) die "Unknown command '$command'" ;; +add|merge|pull) + default= + ;; +split|push) + default="--default HEAD" + ;; +*) + die "Unknown command '$command'" + ;; esac -if [ -z "$prefix" ]; then +if test -z "$prefix" +then die "You must provide the --prefix option." fi case "$command" in - add) [ -e "$prefix" ] && - die "prefix '$prefix' already exists." ;; - *) [ -e "$prefix" ] || - die "'$prefix' does not exist; use 'git subtree add'" ;; +add) + test -e "$prefix" && + die "prefix '$prefix' already exists." + ;; +*) + test -e "$prefix" || + die "'$prefix' does not exist; use 'git subtree add'" + ;; esac dir="$(dirname "$prefix/.")" -if [ "$command" != "pull" -a "$command" != "add" -a "$command" != "push" ]; then +if test "$command" != "pull" && + test "$command" != "add" && + test "$command" != "push" +then revs=$(git rev-parse $default --revs-only "$@") || exit $? - dirs="$(git rev-parse --no-revs --no-flags "$@")" || exit $? - if [ -n "$dirs" ]; then + dirs=$(git rev-parse --no-revs --no-flags "$@") || exit $? + if test -n "$dirs" + then die "Error: Use --prefix instead of bare filenames." fi fi @@ -142,78 +198,82 @@ debug "dir: {$dir}" debug "opts: {$*}" debug -cache_setup() -{ +cache_setup () { cachedir="$GIT_DIR/subtree-cache/$$" - rm -rf "$cachedir" || die "Can't delete old cachedir: $cachedir" - mkdir -p "$cachedir" || die "Can't create new cachedir: $cachedir" - mkdir -p "$cachedir/notree" || die "Can't create new cachedir: $cachedir/notree" + rm -rf "$cachedir" || + die "Can't delete old cachedir: $cachedir" + mkdir -p "$cachedir" || + die "Can't create new cachedir: $cachedir" + mkdir -p "$cachedir/notree" || + die "Can't create new cachedir: $cachedir/notree" debug "Using cachedir: $cachedir" >&2 } -cache_get() -{ - for oldrev in $*; do - if [ -r "$cachedir/$oldrev" ]; then +cache_get () { + for oldrev in "$@" + do + if test -r "$cachedir/$oldrev" + then read newrev <"$cachedir/$oldrev" echo $newrev fi done } -cache_miss() -{ - for oldrev in $*; do - if [ ! -r "$cachedir/$oldrev" ]; then +cache_miss () { + for oldrev in "$@" + do + if ! test -r "$cachedir/$oldrev" + then echo $oldrev fi done } -check_parents() -{ - missed=$(cache_miss $*) - for miss in $missed; do - if [ ! -r "$cachedir/notree/$miss" ]; then +check_parents () { + missed=$(cache_miss "$@") + for miss in $missed + do + if ! test -r "$cachedir/notree/$miss" + then debug " incorrect order: $miss" fi done } -set_notree() -{ +set_notree () { echo "1" > "$cachedir/notree/$1" } -cache_set() -{ +cache_set () { oldrev="$1" newrev="$2" - if [ "$oldrev" != "latest_old" \ - -a "$oldrev" != "latest_new" \ - -a -e "$cachedir/$oldrev" ]; then + if test "$oldrev" != "latest_old" && + test "$oldrev" != "latest_new" && + test -e "$cachedir/$oldrev" + then die "cache for $oldrev already exists!" fi echo "$newrev" >"$cachedir/$oldrev" } -rev_exists() -{ - if git rev-parse "$1" >/dev/null 2>&1; then +rev_exists () { + if git rev-parse "$1" >/dev/null 2>&1 + then return 0 else return 1 fi } -rev_is_descendant_of_branch() -{ +rev_is_descendant_of_branch () { newrev="$1" branch="$2" - branch_hash=$(git rev-parse $branch) - match=$(git rev-list -1 $branch_hash ^$newrev) + branch_hash=$(git rev-parse "$branch") + match=$(git rev-list -1 "$branch_hash" "^$newrev") - if [ -z "$match" ]; then + if test -z "$match" + then return 0 else return 1 @@ -223,15 +283,14 @@ rev_is_descendant_of_branch() # 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() -{ - if rev_exists "$1^"; then +try_remove_previous () { + if rev_exists "$1^" + then echo "^$1^" fi } -find_latest_squash() -{ +find_latest_squash () { debug "Looking for latest squash ($dir)..." dir="$1" sq= @@ -239,37 +298,43 @@ find_latest_squash() sub= git log --grep="^git-subtree-dir: $dir/*\$" \ --pretty=format:'START %H%n%s%n%n%b%nEND%n' HEAD | - while read a b junk; do + 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:) - sub="$(git rev-parse "$b^0")" || - die "could not rev-parse split hash $b from commit $sq" - ;; - END) - if [ -n "$sub" ]; then - if [ -n "$main" ]; then - # a rejoin commit? - # Pretend its sub was a squash. - sq="$sub" - fi - debug "Squash found: $sq $sub" - echo "$sq" "$sub" - break + START) + sq="$b" + ;; + git-subtree-mainline:) + main="$b" + ;; + git-subtree-split:) + sub="$(git rev-parse "$b^0")" || + die "could not rev-parse split hash $b from commit $sq" + ;; + END) + if test -n "$sub" + then + if test -n "$main" + then + # a rejoin commit? + # Pretend its sub was a squash. + sq="$sub" fi - sq= - main= - sub= - ;; + debug "Squash found: $sq $sub" + echo "$sq" "$sub" + break + fi + sq= + main= + sub= + ;; esac done } -find_existing_splits() -{ +find_existing_splits () { debug "Looking for prior splits..." dir="$1" revs="$2" @@ -277,37 +342,43 @@ find_existing_splits() sub= git log --grep="^git-subtree-dir: $dir/*\$" \ --pretty=format:'START %H%n%s%n%n%b%nEND%n' $revs | - while read a b junk; do + while read a b junk + do case "$a" in - START) sq="$b" ;; - git-subtree-mainline:) main="$b" ;; - git-subtree-split:) - sub="$(git rev-parse "$b^0")" || - die "could not rev-parse split hash $b from commit $sq" - ;; - END) - debug " Main is: '$main'" - if [ -z "$main" -a -n "$sub" ]; then - # squash commits refer to a subtree - debug " Squash: $sq from $sub" - cache_set "$sq" "$sub" - fi - if [ -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= - ;; + START) + sq="$b" + ;; + git-subtree-mainline:) + main="$b" + ;; + git-subtree-split:) + sub="$(git rev-parse "$b^0")" || + die "could not rev-parse split hash $b from commit $sq" + ;; + 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 } -copy_commit() -{ +copy_commit () { # 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}" @@ -325,66 +396,69 @@ copy_commit() GIT_COMMITTER_NAME \ GIT_COMMITTER_EMAIL \ GIT_COMMITTER_DATE - (printf "%s" "$annotate"; cat ) | + ( + printf "%s" "$annotate" + cat + ) | git commit-tree "$2" $3 # reads the rest of stdin ) || die "Can't copy commit $1" } -add_msg() -{ +add_msg () { dir="$1" latest_old="$2" latest_new="$3" - if [ -n "$message" ]; then + if test -n "$message" + then commit_message="$message" else commit_message="Add '$dir/' from commit '$latest_new'" fi cat <<-EOF $commit_message - + git-subtree-dir: $dir git-subtree-mainline: $latest_old git-subtree-split: $latest_new EOF } -add_squashed_msg() -{ - if [ -n "$message" ]; then +add_squashed_msg () { + if test -n "$message" + then echo "$message" else echo "Merge commit '$1' as '$2'" fi } -rejoin_msg() -{ +rejoin_msg () { dir="$1" latest_old="$2" latest_new="$3" - if [ -n "$message" ]; then + if test -n "$message" + then commit_message="$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 } -squash_msg() -{ +squash_msg () { dir="$1" oldsub="$2" newsub="$3" newsub_short=$(git rev-parse --short "$newsub") - - if [ -n "$oldsub" ]; then + + if test -n "$oldsub" + then oldsub_short=$(git rev-parse --short "$oldsub") echo "Squashed '$dir/' changes from $oldsub_short..$newsub_short" echo @@ -393,41 +467,41 @@ squash_msg() else echo "Squashed '$dir/' content from commit $newsub_short" fi - + echo echo "git-subtree-dir: $dir" echo "git-subtree-split: $newsub" } -toptree_for_commit() -{ +toptree_for_commit () { commit="$1" git log -1 --pretty=format:'%T' "$commit" -- || exit $? } -subtree_for_commit() -{ +subtree_for_commit () { commit="$1" dir="$2" git ls-tree "$commit" -- "$dir" | - while read mode type tree name; do - assert [ "$name" = "$dir" ] - assert [ "$type" = "tree" -o "$type" = "commit" ] - [ "$type" = "commit" ] && continue # ignore submodules + 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 } -tree_changed() -{ +tree_changed () { tree=$1 shift - if [ $# -ne 1 ]; then + if test $# -ne 1 + then return 0 # weird parents, consider it changed else ptree=$(toptree_for_commit $1) - if [ "$ptree" != "$tree" ]; then + if test "$ptree" != "$tree" + then return 0 # changed else return 1 # not changed @@ -435,118 +509,127 @@ tree_changed() fi } -new_squash_commit() -{ +new_squash_commit () { old="$1" oldsub="$2" newsub="$3" tree=$(toptree_for_commit $newsub) || exit $? - if [ -n "$old" ]; then - squash_msg "$dir" "$oldsub" "$newsub" | - git commit-tree "$tree" -p "$old" || 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 $? + git commit-tree "$tree" || exit $? fi } -copy_or_skip() -{ +copy_or_skip () { rev="$1" tree="$2" newparents="$3" - assert [ -n "$tree" ] + assert test -n "$tree" identical= nonidentical= p= gotparents= - for parent in $newparents; do + for parent in $newparents + do ptree=$(toptree_for_commit $parent) || exit $? - [ -z "$ptree" ] && continue - if [ "$ptree" = "$tree" ]; then + test -z "$ptree" && continue + if test "$ptree" = "$tree" + then # an identical parent could be used in place of this rev. identical="$parent" else nonidentical="$parent" fi - + # sometimes both old parents map to the same newparent; # eliminate duplicates is_new=1 - for gp in $gotparents; do - if [ "$gp" = "$parent" ]; then + for gp in $gotparents + do + if test "$gp" = "$parent" + then is_new= break fi done - if [ -n "$is_new" ]; then + if test -n "$is_new" + then gotparents="$gotparents $parent" p="$p -p $parent" fi done copycommit= - if [ -n "$identical" ] && [ -n "$nonidentical" ]; then + if test -n "$identical" && test -n "$nonidentical" + then extras=$(git rev-list --count $identical..$nonidentical) - if [ "$extras" -ne 0 ]; then + if test "$extras" -ne 0 + then # we need to preserve history along the other branch copycommit=1 fi fi - if [ -n "$identical" ] && [ -z "$copycommit" ]; then + if test -n "$identical" && test -z "$copycommit" + then echo $identical else - copy_commit $rev $tree "$p" || exit $? + copy_commit "$rev" "$tree" "$p" || exit $? fi } -ensure_clean() -{ - if ! git diff-index HEAD --exit-code --quiet 2>&1; then +ensure_clean () { + if ! git diff-index HEAD --exit-code --quiet 2>&1 + then die "Working tree has modifications. Cannot add." fi - if ! git diff-index --cached HEAD --exit-code --quiet 2>&1; then + if ! git diff-index --cached HEAD --exit-code --quiet 2>&1 + then die "Index has modifications. Cannot add." fi } -ensure_valid_ref_format() -{ +ensure_valid_ref_format () { git check-ref-format "refs/heads/$1" || - die "'$1' does not look like a ref" + die "'$1' does not look like a ref" } -cmd_add() -{ - if [ -e "$dir" ]; then +cmd_add () { + if test -e "$dir" + then die "'$dir' already exists. Cannot add." fi ensure_clean - - if [ $# -eq 1 ]; then - git rev-parse -q --verify "$1^{commit}" >/dev/null || - die "'$1' does not refer to a commit" - - "cmd_add_commit" "$@" - elif [ $# -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" "$@" + + if test $# -eq 1 + then + git rev-parse -q --verify "$1^{commit}" >/dev/null || + die "'$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 "error: parameters were '$@'" - die "Provide either a commit or a repository and commit." + say "error: parameters were '$@'" + die "Provide either a commit or a repository and commit." fi } -cmd_add_repository() -{ +cmd_add_repository () { echo "git fetch" "$@" repository=$1 refspec=$2 @@ -556,60 +639,63 @@ cmd_add_repository() cmd_add_commit "$@" } -cmd_add_commit() -{ +cmd_add_commit () { revs=$(git rev-parse $default --revs-only "$@") || exit $? set -- $revs rev="$1" - + debug "Adding $dir as '$rev'..." git read-tree --prefix="$dir" $rev || exit $? git checkout -- "$dir" || exit $? tree=$(git write-tree) || exit $? - + headrev=$(git rev-parse HEAD) || exit $? - if [ -n "$headrev" -a "$headrev" != "$rev" ]; then + if test -n "$headrev" && test "$headrev" != "$rev" + then headp="-p $headrev" else headp= fi - - if [ -n "$squash" ]; then + + if test -n "$squash" + then rev=$(new_squash_commit "" "" "$rev") || exit $? commit=$(add_squashed_msg "$rev" "$dir" | - git commit-tree $tree $headp -p "$rev") || exit $? + git commit-tree "$tree" $headp -p "$rev") || exit $? else revp=$(peel_committish "$rev") && - commit=$(add_msg "$dir" "$headrev" "$rev" | - git commit-tree $tree $headp -p "$revp") || exit $? + commit=$(add_msg "$dir" $headrev "$rev" | + git commit-tree "$tree" $headp -p "$revp") || exit $? fi git reset "$commit" || exit $? - + say "Added dir '$dir'" } -cmd_split() -{ +cmd_split () { debug "Splitting $dir..." cache_setup || exit $? - - if [ -n "$onto" ]; then + + if test -n "$onto" + then debug "Reading history for --onto=$onto..." git rev-list $onto | - while read rev; do + 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 + cache_set "$rev" "$rev" done fi - - if [ -n "$ignore_joins" ]; then + + if test -n "$ignore_joins" + then unrevs= else unrevs="$(find_existing_splits "$dir" "$revs")" fi - + # 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) @@ -618,12 +704,14 @@ cmd_split() revcount=0 createcount=0 eval "$grl" | - while read rev parents; do + while read rev parents + do revcount=$(($revcount + 1)) progress "$revcount/$revmax ($createcount)" debug "Processing commit: $rev" - exists=$(cache_get $rev) - if [ -n "$exists" ]; then + exists=$(cache_get "$rev") + if test -n "$exists" + then debug " prior: $exists" continue fi @@ -631,76 +719,89 @@ cmd_split() debug " parents: $parents" newparents=$(cache_get $parents) debug " newparents: $newparents" - - tree=$(subtree_for_commit $rev "$dir") + + tree=$(subtree_for_commit "$rev" "$dir") debug " tree is: $tree" check_parents $parents - + # ugly. is there no better way to tell if this is a subtree # vs. a mainline commit? Does it matter? - if [ -z $tree ]; then - set_notree $rev - if [ -n "$newparents" ]; then - cache_set $rev $rev + if test -z "$tree" + then + set_notree "$rev" + if test -n "$newparents" + then + cache_set "$rev" "$rev" fi continue 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 + cache_set "$rev" "$newrev" + cache_set latest_new "$newrev" + cache_set latest_old "$rev" done || exit $? + latest_new=$(cache_get latest_new) - if [ -z "$latest_new" ]; then + if test -z "$latest_new" + then die "No new revisions were found" fi - - if [ -n "$rejoin" ]; then + + if test -n "$rejoin" + then debug "Merging split branch into HEAD..." latest_old=$(cache_get latest_old) git merge -s ours \ - -m "$(rejoin_msg "$dir" $latest_old $latest_new)" \ - $latest_new >&2 || exit $? - fi - if [ -n "$branch" ]; then - if rev_exists "refs/heads/$branch"; then - if ! rev_is_descendant_of_branch $latest_new $branch; then + --allow-unrelated-histories \ + -m "$(rejoin_msg "$dir" "$latest_old" "$latest_new")" \ + "$latest_new" >&2 || exit $? + fi + if test -n "$branch" + then + if rev_exists "refs/heads/$branch" + then + if ! rev_is_descendant_of_branch "$latest_new" "$branch" + then die "Branch '$branch' is not an ancestor of commit '$latest_new'." fi action='Updated' else action='Created' fi - git update-ref -m 'subtree split' "refs/heads/$branch" $latest_new || exit $? + git update-ref -m 'subtree split' \ + "refs/heads/$branch" "$latest_new" || exit $? say "$action branch '$branch'" fi - echo $latest_new + echo "$latest_new" exit 0 } -cmd_merge() -{ +cmd_merge () { revs=$(git rev-parse $default --revs-only "$@") || exit $? ensure_clean - + set -- $revs - if [ $# -ne 1 ]; then + if test $# -ne 1 + then die "You must provide exactly one revision. Got: '$revs'" fi rev="$1" - - if [ -n "$squash" ]; then + + if test -n "$squash" + then first_split="$(find_latest_squash "$dir")" - if [ -z "$first_split" ]; then + if test -z "$first_split" + then die "Can't squash-merge: '$dir' was never added." fi set $first_split old=$1 sub=$2 - if [ "$sub" = "$rev" ]; then + if test "$sub" = "$rev" + then say "Subtree is already at commit $rev." exit 0 fi @@ -710,25 +811,29 @@ cmd_merge() fi version=$(git version) - if [ "$version" \< "git version 1.7" ]; then - if [ -n "$message" ]; then - git merge -s subtree --message="$message" $rev + if test "$version" \< "git version 1.7" + then + if test -n "$message" + then + git merge -s subtree --message="$message" "$rev" else - git merge -s subtree $rev + git merge -s subtree "$rev" fi else - if [ -n "$message" ]; then - git merge -Xsubtree="$prefix" --message="$message" $rev + if test -n "$message" + then + git merge -Xsubtree="$prefix" \ + --message="$message" "$rev" else git merge -Xsubtree="$prefix" $rev fi fi } -cmd_pull() -{ - if [ $# -ne 2 ]; then - die "You must provide <repository> <ref>" +cmd_pull () { + if test $# -ne 2 + then + die "You must provide <repository> <ref>" fi ensure_clean ensure_valid_ref_format "$2" @@ -738,20 +843,21 @@ cmd_pull() cmd_merge "$@" } -cmd_push() -{ - if [ $# -ne 2 ]; then - die "You must provide <repository> <ref>" +cmd_push () { + if test $# -ne 2 + then + die "You must provide <repository> <ref>" fi ensure_valid_ref_format "$2" - if [ -e "$dir" ]; then - repository=$1 - refspec=$2 - echo "git push using: " $repository $refspec - localrev=$(git subtree split --prefix="$prefix") || die - git push "$repository" $localrev:refs/heads/$refspec + if test -e "$dir" + then + repository=$1 + refspec=$2 + echo "git push using: " "$repository" "$refspec" + localrev=$(git subtree split --prefix="$prefix") || die + git push "$repository" "$localrev":"refs/heads/$refspec" else - die "'$dir' must already exist. Try 'git subtree add'." + die "'$dir' must already exist. Try 'git subtree add'." fi } diff --git a/contrib/subtree/t/t7900-subtree.sh b/contrib/subtree/t/t7900-subtree.sh index 3bf96a9..9751cfe 100755 --- a/contrib/subtree/t/t7900-subtree.sh +++ b/contrib/subtree/t/t7900-subtree.sh @@ -16,16 +16,16 @@ export TEST_DIRECTORY subtree_test_create_repo() { - test_create_repo "$1" + test_create_repo "$1" && ( - cd $1 + cd "$1" && git config log.date relative ) } create() { - echo "$1" >"$1" + echo "$1" >"$1" && git add "$1" } @@ -71,12 +71,12 @@ join_commits() } test_create_commit() ( - repo=$1 - commit=$2 - cd "$repo" - mkdir -p $(dirname "$commit") \ + repo=$1 && + commit=$2 && + cd "$repo" && + mkdir -p "$(dirname "$commit")" \ || error "Could not create directory for commit" - echo "$commit" >"$commit" + echo "$commit" >"$commit" && git add "$commit" || error "Could not add commit" git commit -m "$commit" || error "Could not commit" ) @@ -347,6 +347,22 @@ test_expect_success 'split sub dir/ with --rejoin' ' ' next_test +test_expect_success 'split sub dir/ with --rejoin from scratch' ' + subtree_test_create_repo "$subtree_test_count" && + test_create_commit "$subtree_test_count" main1 && + ( + cd "$subtree_test_count" && + mkdir "sub dir" && + echo file >"sub dir"/file && + git add "sub dir/file" && + git commit -m"sub dir file" && + split_hash=$(git subtree split --prefix="sub dir" --rejoin) && + git subtree split --prefix="sub dir" --rejoin && + check_equal "$(last_commit_message)" "Split '\''sub dir/'\'' into commit '\''$split_hash'\''" + ) + ' + +next_test test_expect_success 'split sub dir/ with --rejoin and --message' ' subtree_test_create_repo "$subtree_test_count" && subtree_test_create_repo "$subtree_test_count/sub proj" && |