diff options
Diffstat (limited to 'git-submodule.sh')
| -rwxr-xr-x | git-submodule.sh | 1060 |
1 files changed, 915 insertions, 145 deletions
diff --git a/git-submodule.sh b/git-submodule.sh index 3320998c76..5629d875e6 100755 --- a/git-submodule.sh +++ b/git-submodule.sh @@ -1,42 +1,132 @@ #!/bin/sh # -# git-submodules.sh: add, init, update or list git submodules +# git-submodule.sh: add, init, update or list git submodules # # Copyright (c) 2007 Lars Hjemli -USAGE='[--quiet] [--cached] [add <repo> [-b branch]|status|init|update] [--] [<path>...]' +dashless=$(basename "$0" | sed -e 's/-/ /') +USAGE="[--quiet] add [-b branch] [-f|--force] [--reference <repository>] [--] <repository> [<path>] + or: $dashless [--quiet] status [--cached] [--recursive] [--] [<path>...] + or: $dashless [--quiet] init [--] [<path>...] + or: $dashless [--quiet] update [--init] [-N|--no-fetch] [-f|--force] [--rebase] [--reference <repository>] [--merge] [--recursive] [--] [<path>...] + or: $dashless [--quiet] summary [--cached|--files] [--summary-limit <n>] [commit] [--] [<path>...] + or: $dashless [--quiet] foreach [--recursive] <command> + or: $dashless [--quiet] sync [--] [<path>...]" +OPTIONS_SPEC= . git-sh-setup +. git-sh-i18n +. git-parse-remote require_work_tree -add= +command= branch= +force= +reference= +cached= +recursive= init= +files= +nofetch= update= -status= -quiet= -cached= +prefix= +# The function takes at most 2 arguments. The first argument is the +# URL that navigates to the submodule origin repo. When relative, this URL +# is relative to the superproject origin URL repo. The second up_path +# argument, if specified, is the relative path that navigates +# from the submodule working tree to the superproject working tree. +# +# The output of the function is the origin URL of the submodule. # -# print stuff on stdout unless -q was specified +# The output will either be an absolute URL or filesystem path (if the +# superproject origin URL is an absolute URL or filesystem path, +# respectively) or a relative file system path (if the superproject +# origin URL is a relative file system path). # -say() +# When the output is a relative file system path, the path is either +# relative to the submodule working tree, if up_path is specified, or to +# the superproject working tree otherwise. +resolve_relative_url () { - if test -z "$quiet" - then - echo "$@" - fi + remote=$(get_default_remote) + remoteurl=$(git config "remote.$remote.url") || + remoteurl=$(pwd) # the repository is its own authoritative upstream + url="$1" + remoteurl=${remoteurl%/} + sep=/ + up_path="$2" + + case "$remoteurl" in + *:*|/*) + is_relative= + ;; + ./*|../*) + is_relative=t + ;; + *) + is_relative=t + remoteurl="./$remoteurl" + ;; + esac + + while test -n "$url" + do + case "$url" in + ../*) + url="${url#../}" + case "$remoteurl" in + */*) + remoteurl="${remoteurl%/*}" + ;; + *:*) + remoteurl="${remoteurl%:*}" + sep=: + ;; + *) + if test -z "$is_relative" || test "." = "$remoteurl" + then + die "$(eval_gettext "cannot strip one component off url '\$remoteurl'")" + else + remoteurl=. + fi + ;; + esac + ;; + ./*) + url="${url#./}" + ;; + *) + break;; + esac + done + remoteurl="$remoteurl$sep${url%/}" + echo "${is_relative:+${up_path}}${remoteurl#./}" } -# NEEDSWORK: identical function exists in get_repo_base in clone.sh -get_repo_base() { - ( - cd "`/bin/pwd`" && - cd "$1" || cd "$1.git" && - { - cd .git - pwd +# +# Get submodule info for registered submodules +# $@ = path to limit submodule list +# +module_list() +{ + git ls-files --error-unmatch --stage -- "$@" | + perl -e ' + my %unmerged = (); + my ($null_sha1) = ("0" x 40); + while (<STDIN>) { + chomp; + my ($mode, $sha1, $stage, $path) = + /^([0-7]+) ([0-9a-f]{40}) ([0-3])\t(.*)$/; + next unless $mode eq "160000"; + if ($stage ne "0") { + if (!$unmerged{$path}++) { + print "$mode $null_sha1 U\t$path\n"; + } + next; } - ) 2>/dev/null + print "$_\n"; + } + ' } # @@ -47,91 +137,268 @@ get_repo_base() { module_name() { # Do we have "submodule.<something>.path = $1" defined in .gitmodules file? - re=$(printf '%s' "$1" | sed -e 's/\([^a-zA-Z0-9_]\)/\\\1/g') - name=$( GIT_CONFIG=.gitmodules \ - git config --get-regexp '^submodule\..*\.path$' | + sm_path="$1" + re=$(printf '%s\n' "$1" | sed -e 's/[].[^$\\*]/\\&/g') + name=$( git config -f .gitmodules --get-regexp '^submodule\..*\.path$' | sed -n -e 's|^submodule\.\(.*\)\.path '"$re"'$|\1|p' ) - test -z "$name" && - die "No submodule mapping found in .gitmodules for path '$path'" - echo "$name" + test -z "$name" && + die "$(eval_gettext "No submodule mapping found in .gitmodules for path '\$sm_path'")" + echo "$name" } # # Clone a submodule # -# Prior to calling, modules_update checks that a possibly existing +# Prior to calling, cmd_update checks that a possibly existing # path is not a git repository. -# Likewise, module_add checks that path does not exist at all, +# Likewise, cmd_add checks that path does not exist at all, # since it is the location of a new submodule. # module_clone() { - path=$1 + sm_path=$1 url=$2 + reference="$3" + quiet= + if test -n "$GIT_QUIET" + then + quiet=-q + fi + + gitdir= + gitdir_base= + name=$(module_name "$sm_path" 2>/dev/null) + test -n "$name" || name="$sm_path" + base_name=$(dirname "$name") - # If there already is a directory at the submodule path, - # expect it to be empty (since that is the default checkout - # action) and try to remove it. - # Note: if $path is a symlink to a directory the test will - # succeed but the rmdir will fail. We might want to fix this. - if test -d "$path" + gitdir=$(git rev-parse --git-dir) + gitdir_base="$gitdir/modules/$base_name" + gitdir="$gitdir/modules/$name" + + if test -d "$gitdir" then - rmdir "$path" 2>/dev/null || - die "Directory '$path' exist, but is neither empty nor a git repository" + mkdir -p "$sm_path" + rm -f "$gitdir/index" + else + mkdir -p "$gitdir_base" + git clone $quiet -n ${reference:+"$reference"} \ + --separate-git-dir "$gitdir" "$url" "$sm_path" || + die "$(eval_gettext "Clone of '\$url' into submodule path '\$sm_path' failed")" fi - test -e "$path" && - die "A file already exist at path '$path'" + a=$(cd "$gitdir" && pwd)/ + b=$(cd "$sm_path" && pwd)/ + # normalize Windows-style absolute paths to POSIX-style absolute paths + case $a in [a-zA-Z]:/*) a=/${a%%:*}${a#*:} ;; esac + case $b in [a-zA-Z]:/*) b=/${b%%:*}${b#*:} ;; esac + # Remove all common leading directories after a sanity check + if test "${a#$b}" != "$a" || test "${b#$a}" != "$b"; then + die "$(eval_gettext "Gitdir '\$a' is part of the submodule path '\$b' or vice versa")" + fi + while test "${a%%/*}" = "${b%%/*}" + do + a=${a#*/} + b=${b#*/} + done + # Now chop off the trailing '/'s that were added in the beginning + a=${a%/} + b=${b%/} + + # Turn each leading "*/" component into "../" + rel=$(echo $b | sed -e 's|[^/][^/]*|..|g') + echo "gitdir: $rel/$a" >"$sm_path/.git" - git-clone -n "$url" "$path" || - die "Clone of '$url' into submodule path '$path' failed" + rel=$(echo $a | sed -e 's|[^/][^/]*|..|g') + (clear_local_git_env; cd "$sm_path" && GIT_WORK_TREE=. git config core.worktree "$rel/$b") } # # Add a new submodule to the working tree, .gitmodules and the index # -# $@ = repo [path] +# $@ = repo path # # optional branch is stored in global branch variable # -module_add() +cmd_add() { + # parse $args after "submodule ... add". + while test $# -ne 0 + do + case "$1" in + -b | --branch) + case "$2" in '') usage ;; esac + branch=$2 + shift + ;; + -f | --force) + force=$1 + ;; + -q|--quiet) + GIT_QUIET=1 + ;; + --reference) + case "$2" in '') usage ;; esac + reference="--reference=$2" + shift + ;; + --reference=*) + reference="$1" + shift + ;; + --) + shift + break + ;; + -*) + usage + ;; + *) + break + ;; + esac + shift + done + repo=$1 - path=$2 + sm_path=$2 + + if test -z "$sm_path"; then + sm_path=$(echo "$repo" | + sed -e 's|/$||' -e 's|:*/*\.git$||' -e 's|.*[/:]||g') + fi - if test -z "$repo"; then + if test -z "$repo" -o -z "$sm_path"; then usage fi - # Turn the source into an absolute path if - # it is local - if base=$(get_repo_base "$repo"); then - repo="$base" + # assure repo is absolute or relative to parent + case "$repo" in + ./*|../*) + # dereference source url relative to parent's url + realrepo=$(resolve_relative_url "$repo") || exit + ;; + *:*|/*) + # absolute url + realrepo=$repo + ;; + *) + die "$(eval_gettext "repo URL: '\$repo' must be absolute or begin with ./|../")" + ;; + esac + + # normalize path: + # multiple //; leading ./; /./; /../; trailing / + sm_path=$(printf '%s/\n' "$sm_path" | + sed -e ' + s|//*|/|g + s|^\(\./\)*|| + s|/\./|/|g + :start + s|\([^/]*\)/\.\./|| + tstart + s|/*$|| + ') + git ls-files --error-unmatch "$sm_path" > /dev/null 2>&1 && + die "$(eval_gettext "'\$sm_path' already exists in the index")" + + if test -z "$force" && ! git add --dry-run --ignore-missing "$sm_path" > /dev/null 2>&1 + then + eval_gettextln "The following path is ignored by one of your .gitignore files: +\$sm_path +Use -f if you really want to add it." >&2 + exit 1 fi - # Guess path from repo if not specified or strip trailing slashes - if test -z "$path"; then - path=$(echo "$repo" | sed -e 's|/*$||' -e 's|:*/*\.git$||' -e 's|.*[/:]||g') + # perhaps the path exists and is already a git repo, else clone it + if test -e "$sm_path" + then + if test -d "$sm_path"/.git -o -f "$sm_path"/.git + then + eval_gettextln "Adding existing repo at '\$sm_path' to the index" + else + die "$(eval_gettext "'\$sm_path' already exists and is not a valid git repo")" + fi + else - path=$(echo "$path" | sed -e 's|/*$||') + + module_clone "$sm_path" "$realrepo" "$reference" || exit + ( + clear_local_git_env + cd "$sm_path" && + # ash fails to wordsplit ${branch:+-b "$branch"...} + case "$branch" in + '') git checkout -f -q ;; + ?*) git checkout -f -q -B "$branch" "origin/$branch" ;; + esac + ) || die "$(eval_gettext "Unable to checkout submodule '\$sm_path'")" fi + git config submodule."$sm_path".url "$realrepo" - test -e "$path" && - die "'$path' already exists" + git add $force "$sm_path" || + die "$(eval_gettext "Failed to add submodule '\$sm_path'")" - git ls-files --error-unmatch "$path" > /dev/null 2>&1 && - die "'$path' already exists in the index" + git config -f .gitmodules submodule."$sm_path".path "$sm_path" && + git config -f .gitmodules submodule."$sm_path".url "$repo" && + git add --force .gitmodules || + die "$(eval_gettext "Failed to register submodule '\$sm_path'")" +} - module_clone "$path" "$repo" || exit - (unset GIT_DIR && cd "$path" && git checkout -q ${branch:+-b "$branch" "origin/$branch"}) || - die "Unable to checkout submodule '$path'" - git add "$path" || - die "Failed to add submodule '$path'" +# +# Execute an arbitrary command sequence in each checked out +# submodule +# +# $@ = command to execute +# +cmd_foreach() +{ + # parse $args after "submodule ... foreach". + while test $# -ne 0 + do + case "$1" in + -q|--quiet) + GIT_QUIET=1 + ;; + --recursive) + recursive=1 + ;; + -*) + usage + ;; + *) + break + ;; + esac + shift + done + + toplevel=$(pwd) + + # dup stdin so that it can be restored when running the external + # command in the subshell (and a recursive call to this function) + exec 3<&0 - GIT_CONFIG=.gitmodules git config submodule."$path".path "$path" && - GIT_CONFIG=.gitmodules git config submodule."$path".url "$repo" && - git add .gitmodules || - die "Failed to register submodule '$path'" + module_list | + while read mode sha1 stage sm_path + do + if test -e "$sm_path"/.git + then + say "$(eval_gettext "Entering '\$prefix\$sm_path'")" + name=$(module_name "$sm_path") + ( + prefix="$prefix$sm_path/" + clear_local_git_env + # we make $path available to scripts ... + path=$sm_path + cd "$sm_path" && + eval "$@" && + if test -n "$recursive" + then + cmd_foreach "--recursive" "$@" + fi + ) <&3 3<&- || + die "$(eval_gettext "Stopping at '\$sm_path'; script returned non-zero status.")" + fi + done } # @@ -139,24 +406,59 @@ module_add() # # $@ = requested paths (default to all) # -modules_init() +cmd_init() { - git ls-files --stage -- "$@" | grep -e '^160000 ' | - while read mode sha1 stage path + # parse $args after "submodule ... init". + while test $# -ne 0 do - # Skip already registered paths - name=$(module_name "$path") || exit - url=$(git config submodule."$name".url) - test -z "$url" || continue + case "$1" in + -q|--quiet) + GIT_QUIET=1 + ;; + --) + shift + break + ;; + -*) + usage + ;; + *) + break + ;; + esac + shift + done + + module_list "$@" | + while read mode sha1 stage sm_path + do + name=$(module_name "$sm_path") || exit + + # Copy url setting when it is not set yet + if test -z "$(git config "submodule.$name.url")" + then + url=$(git config -f .gitmodules submodule."$name".url) + test -z "$url" && + die "$(eval_gettext "No url found for submodule path '\$sm_path' in .gitmodules")" - url=$(GIT_CONFIG=.gitmodules git config submodule."$name".url) - test -z "$url" && - die "No url found for submodule path '$path' in .gitmodules" + # Possibly a url relative to parent + case "$url" in + ./*|../*) + url=$(resolve_relative_url "$url") || exit + ;; + esac + git config submodule."$name".url "$url" || + die "$(eval_gettext "Failed to register url for submodule path '\$sm_path'")" - git config submodule."$name".url "$url" || - die "Failed to register url for submodule path '$path'" + say "$(eval_gettext "Submodule '\$name' (\$url) registered for path '\$sm_path'")" + fi - say "Submodule '$name' ($url) registered for path '$path'" + # Copy "update" setting when it is not set yet + upd="$(git config -f .gitmodules submodule."$name".update)" + test -z "$upd" || + test -n "$(git config submodule."$name".update)" || + git config submodule."$name".update "$upd" || + die "$(eval_gettext "Failed to register update mode for submodule path '\$sm_path'")" done } @@ -165,55 +467,422 @@ modules_init() # # $@ = requested paths (default to all) # -modules_update() +cmd_update() { - git ls-files --stage -- "$@" | grep -e '^160000 ' | - while read mode sha1 stage path + # parse $args after "submodule ... update". + orig_flags= + while test $# -ne 0 + do + case "$1" in + -q|--quiet) + GIT_QUIET=1 + ;; + -i|--init) + init=1 + ;; + -N|--no-fetch) + nofetch=1 + ;; + -f|--force) + force=$1 + ;; + -r|--rebase) + update="rebase" + ;; + --reference) + case "$2" in '') usage ;; esac + reference="--reference=$2" + orig_flags="$orig_flags $(git rev-parse --sq-quote "$1")" + shift + ;; + --reference=*) + reference="$1" + ;; + -m|--merge) + update="merge" + ;; + --recursive) + recursive=1 + ;; + --checkout) + update="checkout" + ;; + --) + shift + break + ;; + -*) + usage + ;; + *) + break + ;; + esac + orig_flags="$orig_flags $(git rev-parse --sq-quote "$1")" + shift + done + + if test -n "$init" + then + cmd_init "--" "$@" || return + fi + + cloned_modules= + module_list "$@" | { + err= + while read mode sha1 stage sm_path do - name=$(module_name "$path") || exit + if test "$stage" = U + then + echo >&2 "Skipping unmerged submodule $sm_path" + continue + fi + name=$(module_name "$sm_path") || exit url=$(git config submodule."$name".url) + if ! test -z "$update" + then + update_module=$update + else + update_module=$(git config submodule."$name".update) + fi + + if test "$update_module" = "none" + then + echo "Skipping submodule '$sm_path'" + continue + fi + if test -z "$url" then # Only mention uninitialized submodules when its # path have been specified test "$#" != "0" && - say "Submodule path '$path' not initialized" + say "$(eval_gettext "Submodule path '\$sm_path' not initialized +Maybe you want to use 'update --init'?")" continue fi - if ! test -d "$path"/.git + if ! test -d "$sm_path"/.git -o -f "$sm_path"/.git then - module_clone "$path" "$url" || exit + module_clone "$sm_path" "$url" "$reference"|| exit + cloned_modules="$cloned_modules;$name" subsha1= else - subsha1=$(unset GIT_DIR && cd "$path" && + subsha1=$(clear_local_git_env; cd "$sm_path" && git rev-parse --verify HEAD) || - die "Unable to find current revision in submodule path '$path'" + die "$(eval_gettext "Unable to find current revision in submodule path '\$sm_path'")" fi if test "$subsha1" != "$sha1" then - (unset GIT_DIR && cd "$path" && git-fetch && - git-checkout -q "$sha1") || - die "Unable to checkout '$sha1' in submodule path '$path'" + subforce=$force + # If we don't already have a -f flag and the submodule has never been checked out + if test -z "$subsha1" -a -z "$force" + then + subforce="-f" + fi + + if test -z "$nofetch" + then + # Run fetch only if $sha1 isn't present or it + # is not reachable from a ref. + (clear_local_git_env; cd "$sm_path" && + ( (rev=$(git rev-list -n 1 $sha1 --not --all 2>/dev/null) && + test -z "$rev") || git-fetch)) || + die "$(eval_gettext "Unable to fetch in submodule path '\$sm_path'")" + fi + + # Is this something we just cloned? + case ";$cloned_modules;" in + *";$name;"*) + # then there is no local change to integrate + update_module= ;; + esac + + must_die_on_failure= + case "$update_module" in + rebase) + command="git rebase" + die_msg="$(eval_gettext "Unable to rebase '\$sha1' in submodule path '\$sm_path'")" + say_msg="$(eval_gettext "Submodule path '\$sm_path': rebased into '\$sha1'")" + must_die_on_failure=yes + ;; + merge) + command="git merge" + die_msg="$(eval_gettext "Unable to merge '\$sha1' in submodule path '\$sm_path'")" + say_msg="$(eval_gettext "Submodule path '\$sm_path': merged in '\$sha1'")" + must_die_on_failure=yes + ;; + *) + command="git checkout $subforce -q" + die_msg="$(eval_gettext "Unable to checkout '\$sha1' in submodule path '\$sm_path'")" + say_msg="$(eval_gettext "Submodule path '\$sm_path': checked out '\$sha1'")" + ;; + esac - say "Submodule path '$path': checked out '$sha1'" + if (clear_local_git_env; cd "$sm_path" && $command "$sha1") + then + say "$say_msg" + elif test -n "$must_die_on_failure" + then + die_with_status 2 "$die_msg" + else + err="${err};$die_msg" + continue + fi + fi + + if test -n "$recursive" + then + (clear_local_git_env; cd "$sm_path" && eval cmd_update "$orig_flags") + res=$? + if test $res -gt 0 + then + die_msg="$(eval_gettext "Failed to recurse into submodule path '\$sm_path'")" + if test $res -eq 1 + then + err="${err};$die_msg" + continue + else + die_with_status $res "$die_msg" + fi + fi fi done + + if test -n "$err" + then + OIFS=$IFS + IFS=';' + for e in $err + do + if test -n "$e" + then + echo >&2 "$e" + fi + done + IFS=$OIFS + exit 1 + fi + } } set_name_rev () { revname=$( ( - unset GIT_DIR && + clear_local_git_env cd "$1" && { git describe "$2" 2>/dev/null || git describe --tags "$2" 2>/dev/null || - git describe --contains --tags "$2" + git describe --contains "$2" 2>/dev/null || + git describe --all --always "$2" } ) ) test -z "$revname" || revname=" ($revname)" } +# +# Show commit summary for submodules in index or working tree +# +# If '--cached' is given, show summary between index and given commit, +# or between working tree and given commit +# +# $@ = [commit (default 'HEAD'),] requested paths (default all) +# +cmd_summary() { + summary_limit=-1 + for_status= + diff_cmd=diff-index + + # parse $args after "submodule ... summary". + while test $# -ne 0 + do + case "$1" in + --cached) + cached="$1" + ;; + --files) + files="$1" + ;; + --for-status) + for_status="$1" + ;; + -n|--summary-limit) + if summary_limit=$(($2 + 0)) 2>/dev/null && test "$summary_limit" = "$2" + then + : + else + usage + fi + shift + ;; + --) + shift + break + ;; + -*) + usage + ;; + *) + break + ;; + esac + shift + done + + test $summary_limit = 0 && return + if rev=$(git rev-parse -q --verify --default HEAD ${1+"$1"}) + then + head=$rev + test $# = 0 || shift + elif test -z "$1" -o "$1" = "HEAD" + then + # before the first commit: compare with an empty tree + head=$(git hash-object -w -t tree --stdin </dev/null) + test -z "$1" || shift + else + head="HEAD" + fi + + if [ -n "$files" ] + then + test -n "$cached" && + die "$(gettext -- "--cached cannot be used with --files")" + diff_cmd=diff-files + head= + fi + + cd_to_toplevel + # Get modified modules cared by user + modules=$(git $diff_cmd $cached --ignore-submodules=dirty --raw $head -- "$@" | + sane_egrep '^:([0-7]* )?160000' | + while read mod_src mod_dst sha1_src sha1_dst status name + do + # Always show modules deleted or type-changed (blob<->module) + test $status = D -o $status = T && echo "$name" && continue + # Also show added or modified modules which are checked out + GIT_DIR="$name/.git" git-rev-parse --git-dir >/dev/null 2>&1 && + echo "$name" + done + ) + + test -z "$modules" && return + + git $diff_cmd $cached --ignore-submodules=dirty --raw $head -- $modules | + sane_egrep '^:([0-7]* )?160000' | + cut -c2- | + while read mod_src mod_dst sha1_src sha1_dst status name + do + if test -z "$cached" && + test $sha1_dst = 0000000000000000000000000000000000000000 + then + case "$mod_dst" in + 160000) + sha1_dst=$(GIT_DIR="$name/.git" git rev-parse HEAD) + ;; + 100644 | 100755 | 120000) + sha1_dst=$(git hash-object $name) + ;; + 000000) + ;; # removed + *) + # unexpected type + eval_gettextln "unexpected mode \$mod_dst" >&2 + continue ;; + esac + fi + missing_src= + missing_dst= + + test $mod_src = 160000 && + ! GIT_DIR="$name/.git" git-rev-parse -q --verify $sha1_src^0 >/dev/null && + missing_src=t + + test $mod_dst = 160000 && + ! GIT_DIR="$name/.git" git-rev-parse -q --verify $sha1_dst^0 >/dev/null && + missing_dst=t + + total_commits= + case "$missing_src,$missing_dst" in + t,) + errmsg="$(eval_gettext " Warn: \$name doesn't contain commit \$sha1_src")" + ;; + ,t) + errmsg="$(eval_gettext " Warn: \$name doesn't contain commit \$sha1_dst")" + ;; + t,t) + errmsg="$(eval_gettext " Warn: \$name doesn't contain commits \$sha1_src and \$sha1_dst")" + ;; + *) + errmsg= + total_commits=$( + if test $mod_src = 160000 -a $mod_dst = 160000 + then + range="$sha1_src...$sha1_dst" + elif test $mod_src = 160000 + then + range=$sha1_src + else + range=$sha1_dst + fi + GIT_DIR="$name/.git" \ + git rev-list --first-parent $range -- | wc -l + ) + total_commits=" ($(($total_commits + 0)))" + ;; + esac + + sha1_abbr_src=$(echo $sha1_src | cut -c1-7) + sha1_abbr_dst=$(echo $sha1_dst | cut -c1-7) + if test $status = T + then + blob="$(gettext "blob")" + submodule="$(gettext "submodule")" + if test $mod_dst = 160000 + then + echo "* $name $sha1_abbr_src($blob)->$sha1_abbr_dst($submodule)$total_commits:" + else + echo "* $name $sha1_abbr_src($submodule)->$sha1_abbr_dst($blob)$total_commits:" + fi + else + echo "* $name $sha1_abbr_src...$sha1_abbr_dst$total_commits:" + fi + if test -n "$errmsg" + then + # Don't give error msg for modification whose dst is not submodule + # i.e. deleted or changed to blob + test $mod_dst = 160000 && echo "$errmsg" + else + if test $mod_src = 160000 -a $mod_dst = 160000 + then + limit= + test $summary_limit -gt 0 && limit="-$summary_limit" + GIT_DIR="$name/.git" \ + git log $limit --pretty='format: %m %s' \ + --first-parent $sha1_src...$sha1_dst + elif test $mod_dst = 160000 + then + GIT_DIR="$name/.git" \ + git log --pretty='format: > %s' -1 $sha1_dst + else + GIT_DIR="$name/.git" \ + git log --pretty='format: < %s' -1 $sha1_src + fi + echo + fi + echo + done | + if test -n "$for_status"; then + if [ -n "$files" ]; then + gettextln "# Submodules changed but not updated:" + else + gettextln "# Submodule changes to be committed:" + fi + echo "#" + sed -e 's|^|# |' -e 's|^# $|#|' + else + cat + fi +} # # List all submodules, prefixed with: # - submodule not initialized @@ -224,50 +893,162 @@ set_name_rev () { # # $@ = requested paths (default to all) # -modules_list() +cmd_status() { - git ls-files --stage -- "$@" | grep -e '^160000 ' | - while read mode sha1 stage path + # parse $args after "submodule ... status". + orig_flags= + while test $# -ne 0 + do + case "$1" in + -q|--quiet) + GIT_QUIET=1 + ;; + --cached) + cached=1 + ;; + --recursive) + recursive=1 + ;; + --) + shift + break + ;; + -*) + usage + ;; + *) + break + ;; + esac + orig_flags="$orig_flags $(git rev-parse --sq-quote "$1")" + shift + done + + module_list "$@" | + while read mode sha1 stage sm_path do - name=$(module_name "$path") || exit + name=$(module_name "$sm_path") || exit url=$(git config submodule."$name".url) - if test -z "url" || ! test -d "$path"/.git + displaypath="$prefix$sm_path" + if test "$stage" = U then - say "-$sha1 $path" + say "U$sha1 $displaypath" + continue + fi + if test -z "$url" || ! test -d "$sm_path"/.git -o -f "$sm_path"/.git + then + say "-$sha1 $displaypath" continue; fi - set_name_rev "$path" "$sha1" - if git diff-files --quiet -- "$path" + set_name_rev "$sm_path" "$sha1" + if git diff-files --ignore-submodules=dirty --quiet -- "$sm_path" then - say " $sha1 $path$revname" + say " $sha1 $displaypath$revname" else if test -z "$cached" then - sha1=$(unset GIT_DIR && cd "$path" && git rev-parse --verify HEAD) - set_name_rev "$path" "$sha1" + sha1=$(clear_local_git_env; cd "$sm_path" && git rev-parse --verify HEAD) + set_name_rev "$sm_path" "$sha1" + fi + say "+$sha1 $displaypath$revname" + fi + + if test -n "$recursive" + then + ( + prefix="$displaypath/" + clear_local_git_env + cd "$sm_path" && + eval cmd_status "$orig_args" + ) || + die "$(eval_gettext "Failed to recurse into submodule path '\$sm_path'")" + fi + done +} +# +# Sync remote urls for submodules +# This makes the value for remote.$remote.url match the value +# specified in .gitmodules. +# +cmd_sync() +{ + while test $# -ne 0 + do + case "$1" in + -q|--quiet) + GIT_QUIET=1 + shift + ;; + --) + shift + break + ;; + -*) + usage + ;; + *) + break + ;; + esac + done + cd_to_toplevel + module_list "$@" | + while read mode sha1 stage sm_path + do + name=$(module_name "$sm_path") + url=$(git config -f .gitmodules --get submodule."$name".url) + + # Possibly a url relative to parent + case "$url" in + ./*|../*) + # rewrite foo/bar as ../.. to find path from + # submodule work tree to superproject work tree + up_path="$(echo "$sm_path" | sed "s/[^/][^/]*/../g")" && + # guarantee a trailing / + up_path=${up_path%/}/ && + # path from submodule work tree to submodule origin repo + sub_origin_url=$(resolve_relative_url "$url" "$up_path") && + # path from superproject work tree to submodule origin repo + super_config_url=$(resolve_relative_url "$url") || exit + ;; + *) + sub_origin_url="$url" + super_config_url="$url" + ;; + esac + + if git config "submodule.$name.url" >/dev/null 2>/dev/null + then + say "$(eval_gettext "Synchronizing submodule url for '\$name'")" + git config submodule."$name".url "$super_config_url" + + if test -e "$sm_path"/.git + then + ( + clear_local_git_env + cd "$sm_path" + remote=$(get_default_remote) + git config remote."$remote".url "$sub_origin_url" + ) fi - say "+$sha1 $path$revname" fi done } -while case "$#" in 0) break ;; esac +# This loop parses the command line arguments to find the +# subcommand name to dispatch. Parsing of the subcommand specific +# options are primarily done by the subcommand implementations. +# Subcommand specific options such as --branch and --cached are +# parsed here as well, for backward compatibility. + +while test $# != 0 && test -z "$command" do case "$1" in - add) - add=1 - ;; - init) - init=1 - ;; - update) - update=1 - ;; - status) - status=1 + add | foreach | init | update | status | summary | sync) + command=$1 ;; -q|--quiet) - quiet=1 + GIT_QUIET=1 ;; -b|--branch) case "$2" in @@ -278,7 +1059,7 @@ do branch="$2"; shift ;; --cached) - cached=1 + cached="$1" ;; --) break @@ -293,30 +1074,19 @@ do shift done -case "$add,$branch" in -1,*) - ;; -,) - ;; -,*) +# No command word defaults to "status" +test -n "$command" || command=status + +# "-b branch" is accepted only by "add" +if test -n "$branch" && test "$command" != add +then usage - ;; -esac +fi -case "$add,$init,$update,$status,$cached" in -1,,,,) - module_add "$@" - ;; -,1,,,) - modules_init "$@" - ;; -,,1,,) - modules_update "$@" - ;; -,,,*,*) - modules_list "$@" - ;; -*) +# "--cached" is accepted only by "status" and "summary" +if test -n "$cached" && test "$command" != status -a "$command" != summary +then usage - ;; -esac +fi + +"cmd_$command" "$@" |