contrib/tig-completion.bash

   1 ##
   2 # bash completion support for tig
   3 #
   4 # Copyright (C) 2007-2010 Jonas fonseca
   5 # Copyright (C) 2006,2007 Shawn Pearce
   6 #
   7 # Based git's git-completion.sh: http://repo.or.cz/w/git/fastimport.git
   8 #
   9 # The contained completion routines provide support for completing:
  10 #
  11 #    *) local and remote branch names
  12 #    *) local and remote tag names
  13 #    *) tig 'subcommands'
  14 #    *) tree paths within 'ref:path/to/file' expressions
  15 #
  16 # To use these routines:
  17 #
  18 #    1) Copy this file to somewhere (e.g. ~/.tig-completion.sh).
  19 #    2) Added the following line to your .bashrc:
  20 #        source ~/.tig-completion.sh
  21 #
  22 #    3) You may want to make sure the git executable is available
  23 #       in your PATH before this script is sourced, as some caching
  24 #       is performed while the script loads.  If git isn't found
  25 #       at source time then all lookups will be done on demand,
  26 #       which may be slightly slower.
  27 #
  28
  29 __tigdir ()
  30 {
  31         if [ -z "$1" ]; then
  32                 if [ -n "$__git_dir" ]; then
  33                         echo "$__git_dir"
  34                 elif [ -d .git ]; then
  35                         echo .git
  36                 else
  37                         git rev-parse --git-dir 2>/dev/null
  38                 fi
  39         elif [ -d "$1/.git" ]; then
  40                 echo "$1/.git"
  41         else
  42                 echo "$1"
  43         fi
  44 }
  45
  46 _tigcomp ()
  47 {
  48         local all c s=$'\n' IFS=' '$'\t'$'\n'
  49         local cur="${COMP_WORDS[COMP_CWORD]}"
  50         if [ $# -gt 2 ]; then
  51                 cur="$3"
  52         fi
  53         for c in $1; do
  54                 case "$c$4" in
  55                 --*=*) all="$all$c$4$s" ;;
  56                 *.)    all="$all$c$4$s" ;;
  57                 *)     all="$all$c$4 $s" ;;
  58                 esac
  59         done
  60         IFS=$s
  61         COMPREPLY=($(compgen -P "$2" -W "$all" -- "$cur"))
  62         return
  63 }
  64
  65 __tig_refs ()
  66 {
  67         local cmd i is_hash=y dir="$(__tigdir "$1")"
  68         if [ -d "$dir" ]; then
  69                 for i in HEAD FETCH_HEAD ORIG_HEAD MERGE_HEAD; do
  70                         if [ -e "$dir/$i" ]; then echo $i; fi
  71                 done
  72                 for i in $(git --git-dir="$dir" \
  73                         for-each-ref --format='%(refname)' \
  74                         refs/tags refs/heads refs/remotes); do
  75                         case "$i" in
  76                                 refs/tags/*)    echo "${i#refs/tags/}" ;;
  77                                 refs/heads/*)   echo "${i#refs/heads/}" ;;
  78                                 refs/remotes/*) echo "${i#refs/remotes/}" ;;
  79                                 *)              echo "$i" ;;
  80                         esac
  81                 done
  82                 return
  83         fi
  84         for i in $(git-ls-remote "$dir" 2>/dev/null); do
  85                 case "$is_hash,$i" in
  86                 y,*) is_hash=n ;;
  87                 n,*^{}) is_hash=y ;;
  88                 n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
  89                 n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
  90                 n,refs/remotes/*) is_hash=y; echo "${i#refs/remotes/}" ;;
  91                 n,*) is_hash=y; echo "$i" ;;
  92                 esac
  93         done
  94 }
  95
  96 __tig_complete_file ()
  97 {
  98         local pfx ls ref cur="${COMP_WORDS[COMP_CWORD]}"
  99         case "$cur" in
 100         ?*:*)
 101                 ref="${cur%%:*}"
 102                 cur="${cur#*:}"
 103                 case "$cur" in
 104                 ?*/*)
 105                         pfx="${cur%/*}"
 106                         cur="${cur##*/}"
 107                         ls="$ref:$pfx"
 108                         pfx="$pfx/"
 109                         ;;
 110                 *)
 111                         ls="$ref"
 112                         ;;
 113             esac
 114                 COMPREPLY=($(compgen -P "$pfx" \
 115                         -W "$(git --git-dir="$(__tigdir)" ls-tree "$ls" \
 116                                 | sed '/^100... blob /s,^.*     ,,
 117                                        /^040000 tree /{
 118                                            s,^.*        ,,
 119                                            s,$,/,
 120                                        }
 121                                        s/^.*    //')" \
 122                         -- "$cur"))
 123                 ;;
 124         *)
 125                 _tigcomp "$(__tig_refs)"
 126                 ;;
 127         esac
 128 }
 129
 130 __tig_complete_revlist ()
 131 {
 132         local pfx cur="${COMP_WORDS[COMP_CWORD]}"
 133         case "$cur" in
 134         *...*)
 135                 pfx="${cur%...*}..."
 136                 cur="${cur#*...}"
 137                 _tigcomp "$(__tig_refs)" "$pfx" "$cur"
 138                 ;;
 139         *..*)
 140                 pfx="${cur%..*}.."
 141                 cur="${cur#*..}"
 142                 _tigcomp "$(__tig_refs)" "$pfx" "$cur"
 143                 ;;
 144         *.)
 145                 _tigcomp "$cur."
 146                 ;;
 147         *)
 148                 _tigcomp "$(__tig_refs)"
 149                 ;;
 150         esac
 151 }
 152
 153 _tig_options ()
 154 {
 155         local cur="${COMP_WORDS[COMP_CWORD]}"
 156         case "$cur" in
 157         --pretty=*)
 158                 _tigcomp "
 159                         oneline short medium full fuller email raw
 160                         " "" "${cur##--pretty=}"
 161                 return
 162                 ;;
 163         --*)
 164                 _tigcomp "
 165                         --max-count= --max-age= --since= --after=
 166                         --min-age= --before= --until=
 167                         --root --not --topo-order --date-order
 168                         --no-merges
 169                         --abbrev-commit --abbrev=
 170                         --relative-date
 171                         --author= --committer= --grep=
 172                         --all-match
 173                         --pretty= --name-status --name-only
 174                         --not --all
 175                         --help --version
 176                         "
 177                 return
 178                 ;;
 179         -*)
 180                 _tigcomp "-v -h"
 181                 return
 182                 ;;
 183         esac
 184         __tig_complete_revlist
 185 }
 186
 187 _tig_blame ()
 188 {
 189         local reply="" ref=HEAD cur="${COMP_WORDS[COMP_CWORD]}"
 190
 191         if test "$COMP_CWORD" -lt 3; then
 192                 reply="$(__tig_refs)"
 193         else
 194                 ref="${COMP_WORDS[2]}"
 195         fi
 196
 197         reply="$reply $(git --git-dir="$(__tigdir)" ls-tree "$ref" \
 198                         | sed '/^100... blob /s,^.*     ,,
 199                                /^040000 tree /{
 200                                    s,^.*        ,,
 201                                    s,$,/,
 202                                }
 203                                s/^.*    //')"
 204         _tigcomp "$reply"
 205 }
 206
 207 _tig_show ()
 208 {
 209         local cur="${COMP_WORDS[COMP_CWORD]}"
 210         case "$cur" in
 211         --pretty=*)
 212                 _tigcomp "
 213                         oneline short medium full fuller email raw
 214                         " "" "${cur##--pretty=}"
 215                 return
 216                 ;;
 217         --*)
 218                 _tigcomp "--pretty="
 219                 return
 220                 ;;
 221         esac
 222         __tig_complete_file
 223 }
 224
 225 _tig ()
 226 {
 227         local i c=1 command __tig_dir
 228
 229         while [ $c -lt $COMP_CWORD ]; do
 230                 i="${COMP_WORDS[c]}"
 231                 case "$i" in
 232                 --) command="log"; break;;
 233                 -*) ;;
 234                 *) command="$i"; break ;;
 235                 esac
 236                 c=$((++c))
 237         done
 238
 239         if [ $c -eq $COMP_CWORD -a -z "$command" ]; then
 240                 case "${COMP_WORDS[COMP_CWORD]}" in
 241                 --*=*) COMPREPLY=() ;;
 242                 -*)   _tig_options ;;
 243                 *)    _tigcomp "blame status show log stash grep $(__tig_refs)" ;;
 244                 esac
 245                 return
 246         fi
 247
 248         case "$command" in
 249         blame)  _tig_blame ;;
 250         show)   _tig_show ;;
 251         status) ;;
 252         *)      _tigcomp "
 253                         $(__tig_complete_file)
 254                         $(__tig_refs)
 255                 " ;;
 256         esac
 257 }
 258
 259 # Detect if current shell is ZSH, and if so, load this file in bash
 260 # compatibility mode.
 261 if [ -n "$ZSH_VERSION" ]; then
 262         autoload bashcompinit
 263         bashcompinit
 264 fi
 265
 266 complete -o default -o nospace -F _tig tig
 267
 268 # The following are necessary only for Cygwin, and only are needed
 269 # when the user has tab-completed the executable name and consequently
 270 # included the '.exe' suffix.
 271 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
 272 complete -o default -o nospace -F _tig tig.exe
 273 fi