git.oblomov.eu Git - git/blob - git-submodule.sh

   1 #!/bin/sh
   2 #
   3 # git-submodules.sh: add, init, update or list git submodules
   4 #
   5 # Copyright (c) 2007 Lars Hjemli
   6
   7 USAGE='[--quiet] [--cached] [add <repo> [-b branch]|status|init|update] [--] [<path>...]'
   8 OPTIONS_SPEC=
   9 . git-sh-setup
  10 require_work_tree
  11
  12 command=
  13 branch=
  14 quiet=
  15 cached=
  16
  17 #
  18 # print stuff on stdout unless -q was specified
  19 #
  20 say()
  21 {
  22         if test -z "$quiet"
  23         then
  24                 echo "$@"
  25         fi
  26 }
  27
  28 # NEEDSWORK: identical function exists in get_repo_base in clone.sh
  29 get_repo_base() {
  30         (
  31                 cd "`/bin/pwd`" &&
  32                 cd "$1" || cd "$1.git" &&
  33                 {
  34                         cd .git
  35                         pwd
  36                 }
  37         ) 2>/dev/null
  38 }
  39
  40 # Resolve relative url by appending to parent's url
  41 resolve_relative_url ()
  42 {
  43         branch="$(git symbolic-ref HEAD 2>/dev/null)"
  44         remote="$(git config branch.${branch#refs/heads/}.remote)"
  45         remote="${remote:-origin}"
  46         remoteurl="$(git config remote.$remote.url)" ||
  47                 die "remote ($remote) does not have a url in .git/config"
  48         url="$1"
  49         while test -n "$url"
  50         do
  51                 case "$url" in
  52                 ../*)
  53                         url="${url#../}"
  54                         remoteurl="${remoteurl%/*}"
  55                         ;;
  56                 ./*)
  57                         url="${url#./}"
  58                         ;;
  59                 *)
  60                         break;;
  61                 esac
  62         done
  63         echo "$remoteurl/$url"
  64 }
  65
  66 #
  67 # Map submodule path to submodule name
  68 #
  69 # $1 = path
  70 #
  71 module_name()
  72 {
  73         # Do we have "submodule.<something>.path = $1" defined in .gitmodules file?
  74         re=$(printf '%s' "$1" | sed -e 's/[].[^$\\*]/\\&/g')
  75         name=$( GIT_CONFIG=.gitmodules \
  76                 git config --get-regexp '^submodule\..*\.path$' |
  77                 sed -n -e 's|^submodule\.\(.*\)\.path '"$re"'$|\1|p' )
  78        test -z "$name" &&
  79        die "No submodule mapping found in .gitmodules for path '$path'"
  80        echo "$name"
  81 }
  82
  83 #
  84 # Clone a submodule
  85 #
  86 # Prior to calling, cmd_update checks that a possibly existing
  87 # path is not a git repository.
  88 # Likewise, cmd_add checks that path does not exist at all,
  89 # since it is the location of a new submodule.
  90 #
  91 module_clone()
  92 {
  93         path=$1
  94         url=$2
  95
  96         # If there already is a directory at the submodule path,
  97         # expect it to be empty (since that is the default checkout
  98         # action) and try to remove it.
  99         # Note: if $path is a symlink to a directory the test will
 100         # succeed but the rmdir will fail. We might want to fix this.
 101         if test -d "$path"
 102         then
 103                 rmdir "$path" 2>/dev/null ||
 104                 die "Directory '$path' exist, but is neither empty nor a git repository"
 105         fi
 106
 107         test -e "$path" &&
 108         die "A file already exist at path '$path'"
 109
 110         git-clone -n "$url" "$path" ||
 111         die "Clone of '$url' into submodule path '$path' failed"
 112 }
 113
 114 #
 115 # Add a new submodule to the working tree, .gitmodules and the index
 116 #
 117 # $@ = repo [path]
 118 #
 119 # optional branch is stored in global branch variable
 120 #
 121 cmd_add()
 122 {
 123         # parse $args after "submodule ... add".
 124         while test $# -ne 0
 125         do
 126                 case "$1" in
 127                 -b | --branch)
 128                         case "$2" in '') usage ;; esac
 129                         branch=$2
 130                         shift
 131                         ;;
 132                 -q|--quiet)
 133                         quiet=1
 134                         ;;
 135                 --)
 136                         shift
 137                         break
 138                         ;;
 139                 -*)
 140                         usage
 141                         ;;
 142                 *)
 143                         break
 144                         ;;
 145                 esac
 146                 shift
 147         done
 148
 149         repo=$1
 150         path=$2
 151
 152         if test -z "$repo"; then
 153                 usage
 154         fi
 155
 156         # Guess path from repo if not specified or strip trailing slashes
 157         if test -z "$path"; then
 158                 path=$(echo "$repo" | sed -e 's|/*$||' -e 's|:*/*\.git$||' -e 's|.*[/:]||g')
 159         else
 160                 path=$(echo "$path" | sed -e 's|/*$||')
 161         fi
 162
 163         git ls-files --error-unmatch "$path" > /dev/null 2>&1 &&
 164         die "'$path' already exists in the index"
 165
 166         # perhaps the path exists and is already a git repo, else clone it
 167         if test -e "$path"
 168         then
 169                 if test -d "$path/.git" &&
 170                 test "$(unset GIT_DIR; cd $path; git rev-parse --git-dir)" = ".git"
 171                 then
 172                         echo "Adding existing repo at '$path' to the index"
 173                 else
 174                         die "'$path' already exists and is not a valid git repo"
 175                 fi
 176         else
 177                 case "$repo" in
 178                 ./*|../*)
 179                         # dereference source url relative to parent's url
 180                         realrepo="$(resolve_relative_url $repo)" ;;
 181                 *)
 182                         # Turn the source into an absolute path if
 183                         # it is local
 184                         if base=$(get_repo_base "$repo"); then
 185                                 repo="$base"
 186                         fi
 187                         realrepo=$repo
 188                         ;;
 189                 esac
 190
 191                 module_clone "$path" "$realrepo" || exit
 192                 (unset GIT_DIR; cd "$path" && git checkout -q ${branch:+-b "$branch" "origin/$branch"}) ||
 193                 die "Unable to checkout submodule '$path'"
 194         fi
 195
 196         git add "$path" ||
 197         die "Failed to add submodule '$path'"
 198
 199         GIT_CONFIG=.gitmodules git config submodule."$path".path "$path" &&
 200         GIT_CONFIG=.gitmodules git config submodule."$path".url "$repo" &&
 201         git add .gitmodules ||
 202         die "Failed to register submodule '$path'"
 203 }
 204
 205 #
 206 # Register submodules in .git/config
 207 #
 208 # $@ = requested paths (default to all)
 209 #
 210 cmd_init()
 211 {
 212         # parse $args after "submodule ... init".
 213         while test $# -ne 0
 214         do
 215                 case "$1" in
 216                 -q|--quiet)
 217                         quiet=1
 218                         ;;
 219                 --)
 220                         shift
 221                         break
 222                         ;;
 223                 -*)
 224                         usage
 225                         ;;
 226                 *)
 227                         break
 228                         ;;
 229                 esac
 230                 shift
 231         done
 232
 233         git ls-files --stage -- "$@" | grep -e '^160000 ' |
 234         while read mode sha1 stage path
 235         do
 236                 # Skip already registered paths
 237                 name=$(module_name "$path") || exit
 238                 url=$(git config submodule."$name".url)
 239                 test -z "$url" || continue
 240
 241                 url=$(GIT_CONFIG=.gitmodules git config submodule."$name".url)
 242                 test -z "$url" &&
 243                 die "No url found for submodule path '$path' in .gitmodules"
 244
 245                 # Possibly a url relative to parent
 246                 case "$url" in
 247                 ./*|../*)
 248                         url="$(resolve_relative_url "$url")"
 249                         ;;
 250                 esac
 251
 252                 git config submodule."$name".url "$url" ||
 253                 die "Failed to register url for submodule path '$path'"
 254
 255                 say "Submodule '$name' ($url) registered for path '$path'"
 256         done
 257 }
 258
 259 #
 260 # Update each submodule path to correct revision, using clone and checkout as needed
 261 #
 262 # $@ = requested paths (default to all)
 263 #
 264 cmd_update()
 265 {
 266         # parse $args after "submodule ... update".
 267         while test $# -ne 0
 268         do
 269                 case "$1" in
 270                 -q|--quiet)
 271                         quiet=1
 272                         ;;
 273                 --)
 274                         shift
 275                         break
 276                         ;;
 277                 -*)
 278                         usage
 279                         ;;
 280                 *)
 281                         break
 282                         ;;
 283                 esac
 284                 shift
 285         done
 286
 287         git ls-files --stage -- "$@" | grep -e '^160000 ' |
 288         while read mode sha1 stage path
 289         do
 290                 name=$(module_name "$path") || exit
 291                 url=$(git config submodule."$name".url)
 292                 if test -z "$url"
 293                 then
 294                         # Only mention uninitialized submodules when its
 295                         # path have been specified
 296                         test "$#" != "0" &&
 297                         say "Submodule path '$path' not initialized"
 298                         continue
 299                 fi
 300
 301                 if ! test -d "$path"/.git
 302                 then
 303                         module_clone "$path" "$url" || exit
 304                         subsha1=
 305                 else
 306                         subsha1=$(unset GIT_DIR; cd "$path" &&
 307                                 git rev-parse --verify HEAD) ||
 308                         die "Unable to find current revision in submodule path '$path'"
 309                 fi
 310
 311                 if test "$subsha1" != "$sha1"
 312                 then
 313                         (unset GIT_DIR; cd "$path" && git-fetch &&
 314                                 git-checkout -q "$sha1") ||
 315                         die "Unable to checkout '$sha1' in submodule path '$path'"
 316
 317                         say "Submodule path '$path': checked out '$sha1'"
 318                 fi
 319         done
 320 }
 321
 322 set_name_rev () {
 323         revname=$( (
 324                 unset GIT_DIR
 325                 cd "$1" && {
 326                         git describe "$2" 2>/dev/null ||
 327                         git describe --tags "$2" 2>/dev/null ||
 328                         git describe --contains --tags "$2"
 329                 }
 330         ) )
 331         test -z "$revname" || revname=" ($revname)"
 332 }
 333
 334 #
 335 # List all submodules, prefixed with:
 336 #  - submodule not initialized
 337 #  + different revision checked out
 338 #
 339 # If --cached was specified the revision in the index will be printed
 340 # instead of the currently checked out revision.
 341 #
 342 # $@ = requested paths (default to all)
 343 #
 344 cmd_status()
 345 {
 346         # parse $args after "submodule ... status".
 347         while test $# -ne 0
 348         do
 349                 case "$1" in
 350                 -q|--quiet)
 351                         quiet=1
 352                         ;;
 353                 --cached)
 354                         cached=1
 355                         ;;
 356                 --)
 357                         shift
 358                         break
 359                         ;;
 360                 -*)
 361                         usage
 362                         ;;
 363                 *)
 364                         break
 365                         ;;
 366                 esac
 367                 shift
 368         done
 369
 370         git ls-files --stage -- "$@" | grep -e '^160000 ' |
 371         while read mode sha1 stage path
 372         do
 373                 name=$(module_name "$path") || exit
 374                 url=$(git config submodule."$name".url)
 375                 if test -z "$url" || ! test -d "$path"/.git
 376                 then
 377                         say "-$sha1 $path"
 378                         continue;
 379                 fi
 380                 set_name_rev "$path" "$sha1"
 381                 if git diff-files --quiet -- "$path"
 382                 then
 383                         say " $sha1 $path$revname"
 384                 else
 385                         if test -z "$cached"
 386                         then
 387                                 sha1=$(unset GIT_DIR; cd "$path" && git rev-parse --verify HEAD)
 388                                 set_name_rev "$path" "$sha1"
 389                         fi
 390                         say "+$sha1 $path$revname"
 391                 fi
 392         done
 393 }
 394
 395 # This loop parses the command line arguments to find the
 396 # subcommand name to dispatch.  Parsing of the subcommand specific
 397 # options are primarily done by the subcommand implementations.
 398 # Subcommand specific options such as --branch and --cached are
 399 # parsed here as well, for backward compatibility.
 400
 401 while test $# != 0 && test -z "$command"
 402 do
 403         case "$1" in
 404         add | init | update | status)
 405                 command=$1
 406                 ;;
 407         -q|--quiet)
 408                 quiet=1
 409                 ;;
 410         -b|--branch)
 411                 case "$2" in
 412                 '')
 413                         usage
 414                         ;;
 415                 esac
 416                 branch="$2"; shift
 417                 ;;
 418         --cached)
 419                 cached=1
 420                 ;;
 421         --)
 422                 break
 423                 ;;
 424         -*)
 425                 usage
 426                 ;;
 427         *)
 428                 break
 429                 ;;
 430         esac
 431         shift
 432 done
 433
 434 # No command word defaults to "status"
 435 test -n "$command" || command=status
 436
 437 # "-b branch" is accepted only by "add"
 438 if test -n "$branch" && test "$command" != add
 439 then
 440         usage
 441 fi
 442
 443 # "--cached" is accepted only by "status"
 444 if test -n "$cached" && test "$command" != status
 445 then
 446         usage
 447 fi
 448
 449 "cmd_$command" "$@"