contrib/tg-completion.bash

   1 #
   2 # bash completion support for TopGit.
   3 #
   4 # Copyright (C) 2008 Jonas Fonseca <fonseca@diku.dk>
   5 # Copyright (C) 2006,2007 Shawn O. Pearce <spearce@spearce.org>
   6 # Based git's git-completion.sh: http://repo.or.cz/w/git/fastimport.git
   7 # Conceptually based on gitcompletion (http://gitweb.hawaga.org.uk/).
   8 # Distributed under the GNU General Public License, version 2.0.
   9 #
  10 # To use these routines:
  11 #
  12 #    1) Copy this file to somewhere (e.g. ~/.tg-completion.sh).
  13 #    2) Source it from your ~/.bashrc.
  14 #
  15 # Note: Make sure the tg script is in your PATH before you source this
  16 # script, so it can properly setup cached values.
  17
  18 case "$COMP_WORDBREAKS" in
  19 *:*) : great ;;
  20 *)   COMP_WORDBREAKS="$COMP_WORDBREAKS:"
  21 esac
  22
  23 ### {{{ Utilities
  24
  25 __tgdir ()
  26 {
  27         if [ -z "$1" ]; then
  28                 if [ -n "$__tg_dir" ]; then
  29                         echo "$__tg_dir"
  30                 elif [ -d .git ]; then
  31                         echo .git
  32                 else
  33                         git rev-parse --git-dir 2>/dev/null
  34                 fi
  35         elif [ -d "$1/.git" ]; then
  36                 echo "$1/.git"
  37         else
  38                 echo "$1"
  39         fi
  40 }
  41
  42 __tgcomp_1 ()
  43 {
  44         local c IFS=' '$'\t'$'\n'
  45         for c in $1; do
  46                 case "$c$2" in
  47                 --*=*) printf %s$'\n' "$c$2" ;;
  48                 *.)    printf %s$'\n' "$c$2" ;;
  49                 *)     printf %s$'\n' "$c$2 " ;;
  50                 esac
  51         done
  52 }
  53
  54 __tgcomp ()
  55 {
  56         local cur="${COMP_WORDS[COMP_CWORD]}"
  57         if [ $# -gt 2 ]; then
  58                 cur="$3"
  59         fi
  60         case "$cur" in
  61         --*=)
  62                 COMPREPLY=()
  63                 ;;
  64         *)
  65                 local IFS=$'\n'
  66                 COMPREPLY=($(compgen -P "$2" \
  67                         -W "$(__tgcomp_1 "$1" "$4")" \
  68                         -- "$cur"))
  69                 ;;
  70         esac
  71 }
  72
  73 __tg_heads ()
  74 {
  75         local cmd i is_hash=y dir="$(__tgdir "$1")"
  76         if [ -d "$dir" ]; then
  77                 git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
  78                         refs/heads
  79                 return
  80         fi
  81         for i in $(git ls-remote "$1" 2>/dev/null); do
  82                 case "$is_hash,$i" in
  83                 y,*) is_hash=n ;;
  84                 n,*^{}) is_hash=y ;;
  85                 n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
  86                 n,*) is_hash=y; echo "$i" ;;
  87                 esac
  88         done
  89 }
  90
  91 __tg_refs ()
  92 {
  93         local cmd i is_hash=y dir="$(__tgdir "$1")"
  94         if [ -d "$dir" ]; then
  95                 if [ -e "$dir/HEAD" ]; then echo HEAD; fi
  96                 git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
  97                         refs/tags refs/heads refs/remotes
  98                 return
  99         fi
 100         for i in $(git ls-remote "$dir" 2>/dev/null); do
 101                 case "$is_hash,$i" in
 102                 y,*) is_hash=n ;;
 103                 n,*^{}) is_hash=y ;;
 104                 n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
 105                 n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
 106                 n,refs/remotes/*) is_hash=y; echo "${i#refs/remotes/}" ;;
 107                 n,*) is_hash=y; echo "$i" ;;
 108                 esac
 109         done
 110 }
 111
 112 __tg_refs2 ()
 113 {
 114         local i
 115         for i in $(__tg_refs "$1"); do
 116                 echo "$i:$i"
 117         done
 118 }
 119
 120 __tg_refs_remotes ()
 121 {
 122         local cmd i is_hash=y
 123         for i in $(git ls-remote "$1" 2>/dev/null); do
 124                 case "$is_hash,$i" in
 125                 n,refs/heads/*)
 126                         is_hash=y
 127                         echo "$i:refs/remotes/$1/${i#refs/heads/}"
 128                         ;;
 129                 y,*) is_hash=n ;;
 130                 n,*^{}) is_hash=y ;;
 131                 n,refs/tags/*) is_hash=y;;
 132                 n,*) is_hash=y; ;;
 133                 esac
 134         done
 135 }
 136
 137 __tg_remotes ()
 138 {
 139         local i ngoff IFS=$'\n' d="$(__tgdir)"
 140         shopt -q nullglob || ngoff=1
 141         shopt -s nullglob
 142         for i in "$d/remotes"/*; do
 143                 echo ${i#$d/remotes/}
 144         done
 145         [ "$ngoff" ] && shopt -u nullglob
 146         for i in $(git --git-dir="$d" config --list); do
 147                 case "$i" in
 148                 remote.*.url=*)
 149                         i="${i#remote.}"
 150                         echo "${i/.url=*/}"
 151                         ;;
 152                 esac
 153         done
 154 }
 155
 156 __tg_find_subcommand ()
 157 {
 158         local word subcommand c=1
 159
 160         while [ $c -lt $COMP_CWORD ]; do
 161                 word="${COMP_WORDS[c]}"
 162                 for subcommand in $1; do
 163                         if [ "$subcommand" = "$word" ]; then
 164                                 echo "$subcommand"
 165                                 return
 166                         fi
 167                 done
 168                 c=$((++c))
 169         done
 170 }
 171
 172 __tg_complete_revlist ()
 173 {
 174         local pfx cur="${COMP_WORDS[COMP_CWORD]}"
 175         case "$cur" in
 176         *...*)
 177                 pfx="${cur%...*}..."
 178                 cur="${cur#*...}"
 179                 __tgcomp "$(__tg_refs)" "$pfx" "$cur"
 180                 ;;
 181         *..*)
 182                 pfx="${cur%..*}.."
 183                 cur="${cur#*..}"
 184                 __tgcomp "$(__tg_refs)" "$pfx" "$cur"
 185                 ;;
 186         *)
 187                 __tgcomp "$(__tg_refs)"
 188                 ;;
 189         esac
 190 }
 191
 192 __tg_topics ()
 193 {
 194         tg summary -t
 195 }
 196
 197 __tg_commands ()
 198 {
 199         if [ -n "$__tg_all_commandlist" ]; then
 200                 echo "$__tg_all_commandlist"
 201                 return
 202         fi
 203         local i IFS=" "$'\n'
 204         for i in $(tg help | sed -n 's/^Usage:.*(\([^)]*\)).*/\1/p' | tr '|' ' ')
 205         do
 206                 case $i in
 207                 *--*)             : helper pattern;;
 208                 *) echo $i;;
 209                 esac
 210         done
 211         echo help
 212 }
 213 __tg_all_commandlist=
 214 __tg_all_commandlist="$(__tg_commands 2>/dev/null)"
 215
 216 __tg_complete_arg ()
 217 {
 218         if [ $COMP_CWORD -gt 2 ] && [ "${COMP_WORDS[$COMP_CWORD - 1]}" = "$1" ]; then
 219                 return 0
 220         fi
 221         return 1
 222 }
 223
 224 ### }}}
 225 ### {{{ Commands
 226
 227 _tg_create ()
 228 {
 229         local cmd="$1"
 230         local cur="${COMP_WORDS[COMP_CWORD]}"
 231
 232         # Name must be the first arg after the create command
 233         if [ $((cmd + 1)) = $COMP_CWORD ]; then
 234                 __tgcomp "$(__tg_topics)"
 235                 return
 236         fi
 237
 238         __tg_complete_arg "-r" && {
 239                 __tgcomp "$(__tg_remotes)"
 240                 return
 241         }
 242
 243         case "$cur" in
 244         -*)
 245                 __tgcomp "
 246                         -r
 247                 "
 248                 ;;
 249         *)
 250                 __tgcomp "$(__tg_refs)"
 251         esac
 252 }
 253
 254 _tg_delete ()
 255 {
 256         local cur="${COMP_WORDS[COMP_CWORD]}"
 257
 258         case "$cur" in
 259         -*)
 260                 __tgcomp "
 261                         -f
 262                 "
 263                 ;;
 264         *)
 265                 __tgcomp "$(__tg_topics)"
 266         esac
 267 }
 268
 269 _tg_depend ()
 270 {
 271         local subcommands="add"
 272         local subcommand="$(__git_find_subcommand "$subcommands" 2>/dev/null || __git_find_on_cmdline "$subcommands" 2>/dev/null)"
 273         if [ -z "$subcommand" ]; then
 274                 __tgcomp "$subcommands"
 275                 return
 276         fi
 277
 278         case "$subcommand" in
 279         add)
 280                 __tgcomp "$(__tg_refs)"
 281         esac
 282 }
 283
 284 _tg_export ()
 285 {
 286         local cur="${COMP_WORDS[COMP_CWORD]}"
 287
 288         __tg_complete_arg "--collapse" && {
 289                 __tgcomp "$(__tg_heads)"
 290                 return
 291         }
 292
 293         __tg_complete_arg "--quilt" && {
 294                 return
 295         }
 296
 297         case "$cur" in
 298         *)
 299                 __tgcomp "
 300                         --collapse
 301                         --quilt
 302                 "
 303         esac
 304 }
 305
 306 _tg_help ()
 307 {
 308         local cur="${COMP_WORDS[COMP_CWORD]}"
 309         case "$cur" in
 310         -*)
 311                 COMPREPLY=()
 312                 return
 313                 ;;
 314         esac
 315         __tgcomp "$(__tg_commands)"
 316 }
 317
 318 _tg_import ()
 319 {
 320         local cur="${COMP_WORDS[COMP_CWORD]}"
 321
 322         __tg_complete_arg "-p" && {
 323                 COMPREPLY=()
 324                 return
 325         }
 326
 327         case "$cur" in
 328         -*)
 329                 __tgcomp "
 330                         -p
 331                 "
 332                 ;;
 333         *)
 334                 __tg_complete_revlist
 335         esac
 336 }
 337
 338 _tg_info ()
 339 {
 340         local cur="${COMP_WORDS[COMP_CWORD]}"
 341
 342         case "$cur" in
 343         *)
 344                 __tgcomp "$(__tg_topics)"
 345         esac
 346 }
 347
 348 _tg_log ()
 349 {
 350         local cur="${COMP_WORDS[COMP_CWORD]}"
 351
 352         case "$cur" in
 353         *)
 354                 __tgcomp "$(__tg_topics)"
 355         esac
 356 }
 357
 358 _tg_mail ()
 359 {
 360         local cur="${COMP_WORDS[COMP_CWORD]}"
 361
 362         case "$cur" in
 363         -*)
 364                 __tgcomp "
 365                         -i
 366                         -w
 367                         -s
 368                         -r
 369                 "
 370                 ;;
 371         *)
 372                 __tgcomp "$(__tg_topics)"
 373         esac
 374 }
 375
 376 _tg_patch ()
 377 {
 378         local cur="${COMP_WORDS[COMP_CWORD]}"
 379
 380         case "$cur" in
 381         -*)
 382                 __tgcomp "
 383                         -i
 384                         -w
 385                 "
 386                 ;;
 387         *)
 388                 __tgcomp "$(__tg_topics)"
 389         esac
 390 }
 391
 392 _tg_push ()
 393 {
 394         local cur="${COMP_WORDS[COMP_CWORD]}"
 395
 396         __tg_complete_arg "-r" && {
 397                 __tgcomp "$(__tg_remotes)"
 398                 return
 399         }
 400
 401         case "$cur" in
 402         -*)
 403                 __tgcomp "
 404                         --no-deps
 405                         --dry-run
 406                         --tgish-only
 407                         -r
 408                 "
 409                 ;;
 410         *)
 411                 __tgcomp "$(__tg_topics)"
 412         esac
 413 }
 414
 415 _tg_remote ()
 416 {
 417         local cur="${COMP_WORDS[COMP_CWORD]}"
 418
 419         case "$cur" in
 420         -*)
 421                 __tgcomp "
 422                         --populate
 423                 "
 424                 ;;
 425         *)
 426                 __tgcomp "$(__tg_remotes)"
 427         esac
 428 }
 429
 430 _tg_summary ()
 431 {
 432         local cur="${COMP_WORDS[COMP_CWORD]}"
 433
 434         case "$cur" in
 435         *)
 436                 __tgcomp "
 437                         --graphviz
 438                         --sort
 439                         --deps
 440                         -t
 441                         -i
 442                         -w
 443                 "
 444         esac
 445 }
 446
 447 _tg_update ()
 448 {
 449         local cur="${COMP_WORDS[COMP_CWORD]}"
 450
 451         case "$cur" in
 452         *)
 453                 __tgcomp "$(__tg_topics)"
 454         esac
 455 }
 456
 457 _tg_next ()
 458 {
 459         local cur="${COMP_WORDS[COMP_CWORD]}"
 460
 461         case "$cur" in
 462         -*)
 463                 __tgcomp "
 464                         -i
 465                         -w
 466                 "
 467                 ;;
 468         *)
 469                 __tgcomp "$(__tg_heads)"
 470         esac
 471 }
 472
 473 _tg_prev ()
 474 {
 475         local cur="${COMP_WORDS[COMP_CWORD]}"
 476
 477         case "$cur" in
 478         -*)
 479                 __tgcomp "
 480                         -i
 481                         -w
 482                 "
 483                 ;;
 484         *)
 485                 __tgcomp "$(__tg_topics)"
 486         esac
 487 }
 488
 489 ### }}}
 490 ### {{{ tg completion
 491
 492 _tg ()
 493 {
 494         local i c=1 command __tg_dir
 495
 496         while [ $c -lt $COMP_CWORD ]; do
 497                 i="${COMP_WORDS[c]}"
 498                 case "$i" in
 499                 -r)
 500                         c=$((++c))
 501                         if [ $c -lt $COMP_CWORD ]; then
 502                                 __tgcomp "$(__tg_remotes)"
 503                                 return
 504                         fi
 505                         ;;
 506                 -h|--help) command="help"; break ;;
 507                 *) command="$i"; break ;;
 508                 esac
 509                 c=$((++c))
 510         done
 511
 512         if [ -z "$command" ]; then
 513                 case "${COMP_WORDS[COMP_CWORD]}" in
 514                 -*)     __tgcomp "
 515                                 -r
 516                                 -h
 517                                 --help
 518                         "
 519                         ;;
 520                 *)     __tgcomp "$(__tg_commands)" ;;
 521                 esac
 522                 return
 523         fi
 524
 525         case "$command" in
 526         create)      _tg_create "$c" ;;
 527         delete)      _tg_delete ;;
 528         depend)      _tg_depend ;;
 529         export)      _tg_export ;;
 530         files)       _tg_patch ;;
 531         help)        _tg_help ;;
 532         import)      _tg_import ;;
 533         info)        _tg_info ;;
 534         log)         _tg_log ;;
 535         mail)        _tg_mail ;;
 536         next)        _tg_next ;;
 537         patch)       _tg_patch ;;
 538         prev)        _tg_prev ;;
 539         push)        _tg_push ;;
 540         remote)      _tg_remote ;;
 541         summary)     _tg_summary ;;
 542         update)      _tg_update ;;
 543         *)           COMPREPLY=() ;;
 544         esac
 545 }
 546
 547 ### }}}
 548
 549 complete -o default -o nospace -F _tg tg
 550
 551 # The following are necessary only for Cygwin, and only are needed
 552 # when the user has tab-completed the executable name and consequently
 553 # included the '.exe' suffix.
 554 #
 555 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
 556 complete -o default -o nospace -F _tg tg.exe
 557 fi