Documentation: git-commit in 1.2.X series defaults to --include.
[gitweb.git] / git-fetch.sh
index 673a1841793ff5cd5b3422471dfaebf049b5b63e..b4325d9d98589bf7823174318b431197d6b896c6 100755 (executable)
@@ -1,27 +1,59 @@
 #!/bin/sh
 #
-. git-sh-setup || die "Not a git archive"
+
+USAGE='<fetch-options> <repository> <refspec>...'
+. git-sh-setup
 . git-parse-remote
 _x40='[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]'
 _x40="$_x40$_x40$_x40$_x40$_x40$_x40$_x40$_x40"
 
+LF='
+'
+IFS="$LF"
+
+no_tags=
+tags=
 append=
 force=
+verbose=
 update_head_ok=
+exec=
+upload_pack=
 while case "$#" in 0) break ;; esac
 do
        case "$1" in
        -a|--a|--ap|--app|--appe|--appen|--append)
                append=t
                ;;
+       --upl|--uplo|--uploa|--upload|--upload-|--upload-p|\
+       --upload-pa|--upload-pac|--upload-pack)
+               shift
+               exec="--exec=$1" 
+               upload_pack="-u $1"
+               ;;
        -f|--f|--fo|--for|--forc|--force)
                force=t
                ;;
+       -t|--t|--ta|--tag|--tags)
+               tags=t
+               ;;
+       -n|--n|--no|--no-|--no-t|--no-ta|--no-tag|--no-tags)
+               no_tags=t
+               ;;
        -u|--u|--up|--upd|--upda|--updat|--update|--update-|--update-h|\
        --update-he|--update-hea|--update-head|--update-head-|\
        --update-head-o|--update-head-ok)
                update_head_ok=t
                ;;
+       -v|--verbose)
+               verbose=Yes
+               ;;
+       -k|--k|--ke|--kee|--keep)
+               keep=--keep
+               ;;
+       -*)
+               usage
+               ;;
        *)
                break
                ;;
@@ -45,7 +77,7 @@ rsync_slurped_objects=
 
 if test "" = "$append"
 then
-       : >$GIT_DIR/FETCH_HEAD
+       : >"$GIT_DIR/FETCH_HEAD"
 fi
 
 append_fetch_head () {
@@ -54,6 +86,10 @@ append_fetch_head () {
     remote_name_="$3"
     remote_nick_="$4"
     local_name_="$5"
+    case "$6" in
+    t) not_for_merge_='not-for-merge' ;;
+    '') not_for_merge_= ;;
+    esac
 
     # remote-nick is the URL given on the command line (or a shorthand)
     # remote-name is the $GIT_DIR relative refs/ path we computed
@@ -78,12 +114,13 @@ append_fetch_head () {
     if git-cat-file commit "$head_" >/dev/null 2>&1
     then
        headc_=$(git-rev-parse --verify "$head_^0") || exit
-       echo "$headc_   $note_" >>$GIT_DIR/FETCH_HEAD
-       echo >&2 "* committish: $head_"
-       echo >&2 "  $note_"
+       echo "$headc_   $not_for_merge_ $note_" >>"$GIT_DIR/FETCH_HEAD"
+       [ "$verbose" ] && echo >&2 "* committish: $head_"
+       [ "$verbose" ] && echo >&2 "  $note_"
     else
-       echo >&2 "* non-commit: $head_"
-       echo >&2 "  $note_"
+       echo "$head_    not-for-merge   $note_" >>"$GIT_DIR/FETCH_HEAD"
+       [ "$verbose" ] && echo >&2 "* non-commit: $head_"
+       [ "$verbose" ] && echo >&2 "  $note_"
     fi
     if test "$local_name_" != ""
     then
@@ -101,18 +138,25 @@ fast_forward_local () {
        # is no way to guarantee "fast-forward" anyway.
        if test -f "$GIT_DIR/$1"
        then
-               echo >&2 "* $1: updating with $3"
+               if now_=$(cat "$GIT_DIR/$1") && test "$now_" = "$2"
+               then
+                       [ "$verbose" ] && echo >&2 "* $1: same as $3"
+               else
+                       echo >&2 "* $1: updating with $3"
+               fi
        else
                echo >&2 "* $1: storing $3"
        fi
-       echo "$2" >"$GIT_DIR/$1" ;;
+       git-update-ref "$1" "$2" 
+       ;;
 
     refs/heads/*)
-       # NEEDSWORK: use the same cmpxchg protocol here.
-       echo "$2" >"$GIT_DIR/$1.lock"
-       if test -f "$GIT_DIR/$1"
+       # $1 is the ref being updated.
+       # $2 is the new value for the ref.
+       local=$(git-rev-parse --verify "$1^0" 2>/dev/null)
+       if test "$local"
        then
-           local=$(git-rev-parse --verify "$1^0") &&
+           # Require fast-forward.
            mb=$(git-merge-base "$local" "$2") &&
            case "$2,$mb" in
            $local,*)
@@ -120,113 +164,229 @@ fast_forward_local () {
                ;;
            *,$local)
                echo >&2 "* $1: fast forward to $3"
+               git-update-ref "$1" "$2" "$local"
                ;;
            *)
                false
                ;;
            esac || {
                echo >&2 "* $1: does not fast forward to $3;"
-               case "$force,$single_force" in
-               t,* | *,t)
+               case ",$force,$single_force," in
+               *,t,*)
                        echo >&2 "  forcing update."
+                       git-update-ref "$1" "$2" "$local"
                        ;;
                *)
-                       mv "$GIT_DIR/$1.lock" "$GIT_DIR/$1.remote"
-                       echo >&2 "  leaving it in '$1.remote'"
+                       echo >&2 "  not updating."
                        ;;
                esac
            }
        else
-               echo >&2 "* $1: storing $3"
+           echo >&2 "* $1: storing $3"
+           git-update-ref "$1" "$2"
        fi
-       test -f "$GIT_DIR/$1.lock" &&
-           mv "$GIT_DIR/$1.lock" "$GIT_DIR/$1"
        ;;
     esac
 }
 
 case "$update_head_ok" in
 '')
-       orig_head=$(cat "$GIT_DIR/HEAD" 2>/dev/null)
+       orig_head=$(git-rev-parse --verify HEAD 2>/dev/null)
        ;;
 esac
 
-for ref in $(get_remote_refs_for_fetch "$@")
-do
-    refs="$refs $ref"
+# If --tags (and later --heads or --all) is specified, then we are
+# not talking about defaults stored in Pull: line of remotes or
+# branches file, and just fetch those and refspecs explicitly given.
+# Otherwise we do what we always did.
 
-    # These are relative path from $GIT_DIR, typically starting at refs/
-    # but may be HEAD
-    if expr "$ref" : '\+' >/dev/null
-    then
-       single_force=t
-       ref=$(expr "$ref" : '\+\(.*\)')
-    else
-       single_force=
-    fi
-    remote_name=$(expr "$ref" : '\([^:]*\):')
-    local_name=$(expr "$ref" : '[^:]*:\(.*\)')
+reflist=$(get_remote_refs_for_fetch "$@")
+if test "$tags"
+then
+       taglist=$(IFS=" " &&
+                 git-ls-remote $upload_pack --tags "$remote" |
+                 while read sha1 name
+                 do
+                       case "$name" in
+                       (*^*) continue ;;
+                       esac
+                       if git-check-ref-format "$name"
+                       then
+                           echo ".${name}:${name}"
+                       else
+                           echo >&2 "warning: tag ${name} ignored"
+                       fi
+                 done)
+       if test "$#" -gt 1
+       then
+               # remote URL plus explicit refspecs; we need to merge them.
+               reflist="$reflist$LF$taglist"
+       else
+               # No explicit refspecs; fetch tags only.
+               reflist=$taglist
+       fi
+fi
 
-    rref="$rref $remote_name"
+fetch_main () {
+  reflist="$1"
+  refs=
 
-    # There are transports that can fetch only one head at a time...
-    case "$remote" in
-    http://* | https://*)
-       if [ -n "$GIT_SSL_NO_VERIFY" ]; then
-           curl_extra_args="-k"
-       fi
-       head=$(curl -nsf $curl_extra_args "$remote/$remote_name") &&
-       expr "$head" : "$_x40\$" >/dev/null ||
-               die "Failed to fetch $remote_name from $remote"
-       echo Fetching "$remote_name from $remote" using http
-       git-http-fetch -v -a "$head" "$remote/" || exit
-       ;;
-    rsync://*)
-       TMP_HEAD="$GIT_DIR/TMP_HEAD"
-       rsync -L "$remote/$remote_name" "$TMP_HEAD" || exit 1
-       head=$(git-rev-parse TMP_HEAD)
-       rm -f "$TMP_HEAD"
-       test "$rsync_slurped_objects" || {
-           rsync -avz --ignore-existing "$remote/objects/" \
-               "$GIT_OBJECT_DIRECTORY/" || exit
-           rsync_slurped_objects=t
-       }
-       ;;
-    *)
-       # We will do git native transport with just one call later.
-       continue ;;
-    esac
+  for ref in $reflist
+  do
+      refs="$refs$LF$ref"
 
-    append_fetch_head "$head" "$remote" "$remote_name" "$remote_nick" "$local_name"
+      # These are relative path from $GIT_DIR, typically starting at refs/
+      # but may be HEAD
+      if expr "$ref" : '\.' >/dev/null
+      then
+         not_for_merge=t
+         ref=$(expr "$ref" : '\.\(.*\)')
+      else
+         not_for_merge=
+      fi
+      if expr "$ref" : '\+' >/dev/null
+      then
+         single_force=t
+         ref=$(expr "$ref" : '\+\(.*\)')
+      else
+         single_force=
+      fi
+      remote_name=$(expr "$ref" : '\([^:]*\):')
+      local_name=$(expr "$ref" : '[^:]*:\(.*\)')
 
-done
+      rref="$rref$LF$remote_name"
 
-case "$remote" in
-http://* | https://* | rsync://* )
-    ;; # we are already done.
-*)
-    git-fetch-pack "$remote" $rref |
-    while read sha1 remote_name
-    do
-       found=
-       single_force=
-       for ref in $refs
+      # There are transports that can fetch only one head at a time...
+      case "$remote" in
+      http://* | https://*)
+         if [ -n "$GIT_SSL_NO_VERIFY" ]; then
+             curl_extra_args="-k"
+         fi
+         remote_name_quoted=$(perl -e '
+             my $u = $ARGV[0];
+             $u =~ s{([^-a-zA-Z0-9/.])}{sprintf"%%%02x",ord($1)}eg;
+             print "$u";
+         ' "$remote_name")
+         head=$(curl -nsfL $curl_extra_args "$remote/$remote_name_quoted") &&
+         expr "$head" : "$_x40\$" >/dev/null ||
+                 die "Failed to fetch $remote_name from $remote"
+         echo >&2 Fetching "$remote_name from $remote" using http
+         git-http-fetch -v -a "$head" "$remote/" || exit
+         ;;
+      rsync://*)
+         TMP_HEAD="$GIT_DIR/TMP_HEAD"
+         rsync -L -q "$remote/$remote_name" "$TMP_HEAD" || exit 1
+         head=$(git-rev-parse --verify TMP_HEAD)
+         rm -f "$TMP_HEAD"
+         test "$rsync_slurped_objects" || {
+             rsync -av --ignore-existing --exclude info \
+                 "$remote/objects/" "$GIT_OBJECT_DIRECTORY/" || exit
+
+             # Look at objects/info/alternates for rsync -- http will
+             # support it natively and git native ones will do it on
+             # the remote end.  Not having that file is not a crime.
+             rsync -q "$remote/objects/info/alternates" \
+                 "$GIT_DIR/TMP_ALT" 2>/dev/null ||
+                 rm -f "$GIT_DIR/TMP_ALT"
+             if test -f "$GIT_DIR/TMP_ALT"
+             then
+                 resolve_alternates "$remote" <"$GIT_DIR/TMP_ALT" |
+                 while read alt
+                 do
+                     case "$alt" in 'bad alternate: '*) die "$alt";; esac
+                     echo >&2 "Getting alternate: $alt"
+                     rsync -av --ignore-existing --exclude info \
+                     "$alt" "$GIT_OBJECT_DIRECTORY/" || exit
+                 done
+                 rm -f "$GIT_DIR/TMP_ALT"
+             fi
+             rsync_slurped_objects=t
+         }
+         ;;
+      *)
+         # We will do git native transport with just one call later.
+         continue ;;
+      esac
+
+      append_fetch_head "$head" "$remote" \
+         "$remote_name" "$remote_nick" "$local_name" "$not_for_merge"
+
+  done
+
+  case "$remote" in
+  http://* | https://* | rsync://* )
+      ;; # we are already done.
+  *)
+    ( : subshell because we muck with IFS
+      IFS="    $LF"
+      (
+         git-fetch-pack $exec $keep "$remote" $rref || echo failed "$remote"
+      ) |
+      while read sha1 remote_name
+      do
+         case "$sha1" in
+         failed)
+                 echo >&2 "Fetch failure: $remote"
+                 exit 1 ;;
+         esac
+         found=
+         single_force=
+         for ref in $refs
+         do
+             case "$ref" in
+             +$remote_name:*)
+                 single_force=t
+                 not_for_merge=
+                 found="$ref"
+                 break ;;
+             .+$remote_name:*)
+                 single_force=t
+                 not_for_merge=t
+                 found="$ref"
+                 break ;;
+             .$remote_name:*)
+                 not_for_merge=t
+                 found="$ref"
+                 break ;;
+             $remote_name:*)
+                 not_for_merge=
+                 found="$ref"
+                 break ;;
+             esac
+         done
+         local_name=$(expr "$found" : '[^:]*:\(.*\)')
+         append_fetch_head "$sha1" "$remote" \
+                 "$remote_name" "$remote_nick" "$local_name" "$not_for_merge"
+      done
+    ) || exit ;;
+  esac
+
+}
+
+fetch_main "$reflist"
+
+# automated tag following
+case "$no_tags$tags" in
+'')
+       taglist=$(IFS=" " &&
+       git-ls-remote $upload_pack --tags "$remote" |
+       sed -ne 's|^\([0-9a-f]*\)[      ]\(refs/tags/.*\)^{}$|\1 \2|p' |
+       while read sha1 name
        do
-           case "$ref" in
-           +$remote_name:*)
-               single_force=t
-               found="$ref"
-               break ;;
-           $remote_name:*)
-               found="$ref"
-               break ;;
-           esac
-       done
-
-       local_name=$(expr "$found" : '[^:]*:\(.*\)')
-       append_fetch_head "$sha1" "$remote" "$remote_name" "$remote_nick" "$local_name"
-    done
-    ;;
+               test -f "$GIT_DIR/$name" && continue
+               git-check-ref-format "$name" || {
+                       echo >&2 "warning: tag ${name} ignored"
+                       continue
+               }
+               git-cat-file -t "$sha1" >/dev/null 2>&1 || continue
+               echo >&2 "Auto-following $name"
+               echo ".${name}:${name}"
+       done)
+       case "$taglist" in
+       '') ;;
+       ?*)
+               fetch_main "$taglist" ;;
+       esac
 esac
 
 # If the original head was empty (i.e. no "master" yet), or
@@ -235,10 +395,10 @@ case ",$update_head_ok,$orig_head," in
 *,, | t,* )
        ;;
 *)
-       curr_head=$(cat "$GIT_DIR/HEAD" 2>/dev/null)
+       curr_head=$(git-rev-parse --verify HEAD 2>/dev/null)
        if test "$curr_head" != "$orig_head"
        then
-               echo "$orig_head" >$GIT_DIR/HEAD
+               git-update-ref HEAD "$orig_head"
                die "Cannot fetch into the current branch."
        fi
        ;;