g

   1 #!/usr/bin/env bash
   2 #
   3 # Wrapper for git to handle more subdirs at the same time
   4 #
   5
   6 if [ -n "$g_debug" ] ; then
   7     set -x
   8 fi
   9
  10 SUBMODULES_ALL="dictionaries helpcontent2 translations"
  11
  12 pushd $(dirname $0) > /dev/null
  13 if [ -f ${BUILDDIR}/config_host.mk ] ; then
  14     # we are in the SRCDIR
  15     SRC_ROOT=$(< ${BUILDDIR}/config_host.mk grep -a SRC_ROOT | sed -e "s/.*=//")
  16 else
  17     SRC_ROOT=$(pwd)
  18 fi
  19 popd > /dev/null
  20
  21 COREDIR="$SRC_ROOT"
  22
  23 usage()
  24 {
  25     git
  26     echo
  27     echo "Usage: g [options] [git (checkout|clone|fetch|gc|grep|pull|push|reset) [git options/args..]]"
  28     echo ""
  29     echo " -z restore the git hooks and do other sanity checks"
  30 }
  31
  32 refresh_submodule_hooks()
  33 {
  34     local repo=$1
  35     local hook
  36     local hook_name
  37
  38     if [ -d "${repo?}"/.git ] ; then
  39         # use core's hook by default
  40         for hook_name in "${COREDIR?}/.git-hooks"/* ; do
  41             if [ ! -e "${hook_name}" ] ; then
  42                 continue
  43             fi
  44             hook="${repo?}/.git/hooks/${hook_name##*/}"
  45             if [ ! -e "${hook?}" ] || [ -L "${hook?}" ] ; then
  46                 rm -f "${hook?}"
  47                 ln -sf "${hook_name}" "${hook?}"
  48             fi
  49         done
  50         # override if need be by the submodules' own hooks
  51         for hook_name in "${COREDIR?}/${repo?}/.git-hooks"/* ; do
  52             if [ ! -e "${hook_name}" ] ; then
  53                 continue
  54             fi
  55             hook="${repo?}/.git/hooks/${hook_name##*/}"
  56             if [ ! -e "${hook?}" ] || [ -L "${hook?}" ] ; then
  57                 rm -f "${hook?}"
  58                 ln -sf "${hook_name}" "${hook?}"
  59             fi
  60         done
  61     elif [ -d .git/modules/"${repo}"/hooks ] ; then
  62         for hook_name in "${COREDIR?}/.git-hooks"/* ; do
  63             if [ ! -e "${hook_name}" ] ; then
  64                 continue
  65             fi
  66             hook=".git/modules/${repo?}/hooks/${hook_name##*/}"
  67             if [ ! -e "${hook?}" ] || [ -L "${hook?}" ] ; then
  68                 rm -f "${hook?}"
  69                 ln -sf "${hook_name}" "${hook?}"
  70             fi
  71         done
  72         # override if need be by the submodules' own hooks
  73         for hook_name in "${COREDIR?}/${repo?}/.git-hooks"/* ; do
  74             if [ ! -e "${hook_name}" ] ; then
  75                 continue
  76             fi
  77             hook=".git/modules/${repo?}/hooks/${hook_name##*/}"
  78             if [ ! -e "${hook?}" ] || [ -L "${hook?}" ] ; then
  79                 rm -f "${hook?}"
  80                 ln -sf "${hook_name}" "${hook?}"
  81             fi
  82         done
  83     fi
  84
  85 }
  86
  87 refresh_all_hooks()
  88 {
  89     local repo
  90     local hook_name
  91     local hook
  92
  93     pushd "${COREDIR?}" > /dev/null
  94     # There's no ".git" e.g. in a secondary worktree
  95     if [ -d ".git" ]; then
  96         for hook_name in "${COREDIR?}/.git-hooks"/* ; do
  97             hook=".git/hooks/${hook_name##*/}"
  98             if [ ! -e "${hook?}" ] || [ -L "${hook?}" ] ; then
  99                 rm -f "${hook?}"
 100                 ln -sf "${hook_name}" "${hook?}"
 101             fi
 102         done
 103     fi
 104
 105     for repo in ${SUBMODULES_ALL?} ; do
 106         refresh_submodule_hooks "$repo"
 107     done
 108     popd > /dev/null
 109
 110 }
 111
 112 set_push_url()
 113 {
 114     local repo
 115
 116     repo="$1"
 117     if [ -n "$repo" ] ; then
 118         pushd "${COREDIR?}/${repo?}" > /dev/null
 119     else
 120         pushd "${COREDIR?}" > /dev/null
 121         repo="core"
 122     fi
 123     echo "setting up push url for ${repo?}"
 124     if [ "${repo?}" = "helpcontent2" ] ; then
 125         git config remote.origin.pushurl "ssh://${PUSH_USER}logerrit/help"
 126     else
 127         git config remote.origin.pushurl "ssh://${PUSH_USER}logerrit/${repo?}"
 128     fi
 129     popd > /dev/null
 130 }
 131
 132 set_push_urls()
 133 {
 134     PUSH_USER="$1"
 135     set_push_url
 136     for repo in ${SUBMODULES_ACTIVE?} ; do
 137         set_push_url "${repo?}"
 138     done
 139 }
 140
 141 get_active_submodules()
 142 {
 143     SUBMODULES_ACTIVE=""
 144     local repo
 145
 146     for repo in ${SUBMODULES_ALL?} ; do
 147         if [ -d "${repo?}"/.git ] || [ -f "${repo?}"/.git ] ; then
 148             SUBMODULES_ACTIVE="${repo?} ${SUBMODULES_ACTIVE?}"
 149         fi
 150     done
 151 }
 152
 153 get_configured_submodules()
 154 {
 155     SUBMODULES_CONFIGURED=""
 156     if [ -f ${BUILDDIR}/config_host.mk ] ; then
 157         SUBMODULES_CONFIGURED=$(< ${BUILDDIR}/config_host.mk grep -a GIT_NEEDED_SUBMODULES | sed -e "s/.*=//")
 158     else
 159         # if we need the configured submodule before the configuration is done. we assumed you want them all
 160         SUBMODULES_CONFIGURED=${SUBMODULES_ALL?}
 161     fi
 162 }
 163
 164 get_git_reference()
 165 {
 166     REFERENCED_GIT=""
 167     if [ -f ${BUILDDIR}/config_host.mk ]; then
 168         REFERENCED_GIT=$(< ${BUILDDIR}/config_host.mk grep -a GIT_REFERENCE_SRC | sed -e "s/.*=//")
 169     fi
 170     LINKED_GIT=""
 171     if [ -f ${BUILDDIR}/config_host.mk ]; then
 172         LINKED_GIT=$(< ${BUILDDIR}/config_host.mk grep -a GIT_LINK_SRC | sed -e "s/.*=//")
 173     fi
 174 }
 175
 176 do_shortcut_update()
 177 {
 178     local module
 179     local repo
 180
 181     for module in $SUBMODULES_CONFIGURED ; do
 182         if [ ! -d "${module?}"/.git ] ; then
 183             case "${module?}" in
 184                 helpcontent2)
 185                     if [ -d clone/help/.git ] ; then
 186                         repo="clone/help/.git"
 187                     fi
 188                     ;;
 189                 *)
 190                     if [ -d clone/"${module?}"/.git ] ; then
 191                         repo="clone/${module?}/.git"
 192                     fi
 193                     ;;
 194             esac
 195             if [ -n "$repo" ] ; then
 196                 cp -r "${repo?}" "${module?}/."
 197             fi
 198         fi
 199     done
 200 }
 201
 202 do_git_cmd()
 203 {
 204     echo "cmd:$*"
 205     git "$@"
 206     git submodule foreach git "$@" $KEEP_GOING
 207 }
 208
 209 do_checkout()
 210 {
 211     local cmd
 212     local create_branch="0"
 213     local branch
 214     local module
 215
 216     git checkout "$@" || return $?
 217     for cmd in "$@" ; do
 218         if [ "$cmd" = "-f" ]; then
 219             continue
 220         elif [ "$cmd" = "-b" ] ; then
 221             create_branch=1
 222         elif [ "$create_branch" = "1" ] ; then
 223             branch="$cmd"
 224             create_branch=0
 225         fi
 226     done
 227     if [ -f .gitmodules ] ; then
 228         git submodule update --progress
 229         if [ -n "$branch" ] ; then
 230             git submodule foreach git checkout -b "${branch}" HEAD || return $?
 231         fi
 232     else
 233         # now that is the nasty case we moved prior to submodules
 234         # delete the submodules left over if any
 235         for module in $SUBMODULES_ALL ; do
 236             echo "clean-up submodule $module"
 237             rm -fr "${module}"
 238         done
 239         # make sure we have the needed repo in clone
 240         ./g clone && ./g -f checkout "$@" || return $?
 241     fi
 242     return $?
 243 }
 244
 245 do_reset()
 246 {
 247     git reset "$@" || return $?
 248     if [ -f .gitmodules ] ; then
 249         git submodule update --progress || return $?
 250     else
 251         # now that is the nasty case we moved prior to submodules
 252         # delete the submodules left over if any
 253         for module in $SUBMODULES_ALL ; do
 254             echo "clean-up submodule $module"
 255             rm -fr "${module}"
 256         done
 257         # make sure we have the needed repo in clone
 258         ./g clone && ./g -f reset "$@"
 259     fi
 260     return $?;
 261 }
 262
 263 do_init_modules()
 264 {
 265     local module
 266     local configured
 267
 268     do_shortcut_update
 269
 270     for module in $SUBMODULES_CONFIGURED ; do
 271         if [ -n "$LINKED_GIT" ] ; then
 272             if ! [ -d ".git/modules/${module}" ]; then
 273                 ./bin/git-new-module-workdir "${LINKED_GIT}/${module}" "${module}"
 274             fi
 275         fi
 276         configured=$(git config --local --get submodule."${module}".url)
 277         if [ -z "$configured" ] ; then
 278             git submodule init "$module" || return $?
 279         fi
 280     done
 281     for module in $SUBMODULES_CONFIGURED ; do
 282         if [ -n "$REFERENCED_GIT" ] ; then
 283             git submodule update --reference "$REFERENCED_GIT/.git/modules/$module" --progress "$module" || return $?
 284         else
 285             git submodule update --progress "$module" || return $?
 286         fi
 287     done
 288     return 0
 289 }
 290
 291
 292 # no params, no action
 293 if [ "$#" -eq "0" ] ; then
 294     usage
 295 fi
 296
 297 if [ ! "$(type -p git)" ]; then
 298     echo "Cannot find the git binary! Is git installed and is in PATH?"
 299     exit 1
 300 fi
 301
 302
 303 get_active_submodules
 304 get_configured_submodules
 305 get_git_reference
 306
 307
 308
 309
 310 # extra params for some commands, like log
 311 EXTRA=
 312 COMMAND="$1"
 313 PAGER=
 314 RELATIVIZE=1
 315 PUSH_ALL=
 316 PUSH_USER=
 317 PUSH_NOTES=
 318 LAST_WORKING=
 319 SET_LAST_WORKING=
 320 ALLOW_EMPTY=
 321 KEEP_GOING=
 322 REPORT_REPOS=1
 323 REPORT_COMMANDS=0
 324 REPORT_COMPACT=0
 325 DO_HOOK_REFRESH=false
 326
 327 while [ "${COMMAND:0:1}" = "-" ] ; do
 328     case "$COMMAND" in
 329         -f )KEEP_GOING="||:"
 330             ;;
 331         -z)
 332             refresh_all_hooks
 333             exit 0;
 334             ;;
 335         --set-push-urls)
 336             shift
 337             PUSH_USER="$1"
 338             if [ -n "${PUSH_USER}" ] ; then
 339                 PUSH_USER="${PUSH_USER}@"
 340             fi
 341             set_push_urls "$PUSH_USER"
 342             exit 0;
 343             ;;
 344         -*)
 345             echo "option: $COMMAND not supported" 1>&2
 346             exit 1
 347     esac
 348     shift
 349     COMMAND="$1"
 350 done
 351
 352 shift
 353
 354 case "$COMMAND" in
 355     branch)
 356         do_git_cmd "${COMMAND}" "$@"
 357         ;;
 358     checkout)
 359         do_checkout "$@"
 360         ;;
 361     clone)
 362         do_init_modules && refresh_all_hooks
 363         ;;
 364     fetch)
 365         (git fetch "$@" && git submodule foreach git fetch "$@" ) && git submodule update --progress
 366
 367         ;;
 368     gc)
 369          (git gc "$@" && git submodule foreach git gc "$@" )
 370         ;;
 371     grep)
 372         KEEP_GOING="||:"
 373         do_git_cmd "${COMMAND}" "$@"
 374         ;;
 375     pull)
 376         git pull "$@" && git submodule update --progress && refresh_all_hooks
 377         ;;
 378     push)
 379         git submodule foreach git push "$@"
 380         if [ "$?" = "0" ] ; then
 381             git push "$@"
 382         fi
 383         ;;
 384     reset)
 385         do_reset
 386         ;;
 387     tag)
 388         do_git_cmd "${COMMAND}" "$@"
 389         ;;
 390     "")
 391         ;;
 392     *)
 393         echo "./g does not support command: $COMMAND" 1>&2
 394         exit 1;
 395         ;;
 396 esac
 397
 398 exit $?
 399
 400 # vi:set shiftwidth=4 expandtab: