dotfiles

_hub (5187B)

---

 #compdef hub
 
 # Zsh will source this file when attempting to autoload the "_hub" function,
 # typically on the first attempt to complete the hub command.  We define two new
 # setup helper routines (one for the zsh-distributed version, one for the
 # git-distributed, bash-based version).  Then we redefine the "_hub" function to
 # call "_git" after some other interception.
 #
 # This is pretty fragile, if you think about it.  Any number of implementation
 # changes in the "_git" scripts could cause problems down the road.  It would be
 # better if the stock git completions were just a bit more permissive about how
 # it allowed third-party commands to be added.
 
 (( $+functions[__hub_setup_zsh_fns] )) ||
 __hub_setup_zsh_fns () {
   (( $+functions[_git-alias] )) ||
   _git-alias () {
     _arguments \
       '-s[output shell script suitable for eval]' \
       '1::shell:(zsh bash csh)'
   }
 
   (( $+functions[_git-browse] )) ||
   _git-browse () {
     _arguments \
       '-u[output the URL]' \
       '2::subpage:(wiki commits issues)'
   }
 
   (( $+functions[_git-compare] )) ||
   _git-compare () {
     _arguments \
       '-u[output the URL]' \
       ':[start...]end range:'
   }
 
   (( $+functions[_git-create] )) ||
   _git-create () {
     _arguments \
       '::name (REPOSITORY or ORGANIZATION/REPOSITORY):' \
       '-p[make repository private]' \
       '-d[description]:description' \
       '-h[home page]:repository home page URL:_urls'
   }
 
   (( $+functions[_git-fork] )) ||
   _git-fork () {
     _arguments \
       '--no-remote[do not add a remote for the new fork]'
   }
 
   (( $+functions[_git-pull-request] )) ||
   _git-pull-request () {
     _arguments \
       '-f[force (skip check for local commits)]' \
       '-b[base]:base ("branch", "owner\:branch", "owner/repo\:branch"):' \
       '-h[head]:head ("branch", "owner\:branch", "owner/repo\:branch"):' \
       - set1 \
         '-m[message]' \
         '-F[file]' \
       - set2 \
         '-i[issue]:issue number:' \
       - set3 \
         '::issue-url:_urls'
   }
 
   # stash the "real" command for later
   functions[_hub_orig_git_commands]=$functions[_git_commands]
 
   # Replace it with our own wrapper.
   declare -f _git_commands >& /dev/null && unfunction _git_commands
   _git_commands () {
     local ret=1
     # call the original routine
     _call_function ret _hub_orig_git_commands
 
     # Effectively "append" our hub commands to the behavior of the original
     # _git_commands function.  Using this wrapper function approach ensures
     # that we only offer the user the hub subcommands when the user is
     # actually trying to complete subcommands.
     hub_commands=(
       alias:'show shell instructions for wrapping git'
       pull-request:'open a pull request on GitHub'
       fork:'fork origin repo on GitHub'
       create:'create new repo on GitHub for the current project'
       browse:'browse the project on GitHub'
       compare:'open GitHub compare view'
       ci-status:'lookup commit in GitHub Status API'
     )
     _describe -t hub-commands 'hub command' hub_commands && ret=0
 
     return ret
   }
 }
 
 (( $+functions[__hub_setup_bash_fns] )) ||
 __hub_setup_bash_fns () {
   # TODO more bash-style fns needed here to complete subcommand args.  They take
   # the form "_git_CMD" where "CMD" is something like "pull-request".
 
   # Duplicate and rename the 'list_all_commands' function
   eval "$(declare -f __git_list_all_commands | \
         sed 's/__git_list_all_commands/__git_list_all_commands_without_hub/')"
 
   # Wrap the 'list_all_commands' function with extra hub commands
   __git_list_all_commands() {
     cat <<-EOF
 alias
 pull-request
 fork
 create
 browse
 compare
 ci-status
 EOF
     __git_list_all_commands_without_hub
   }
 
   # Ensure cached commands are cleared
   __git_all_commands=""
 }
 
 # redefine _hub to a much smaller function in the steady state
 _hub () {
   # only attempt to intercept the normal "_git" helper functions once
   (( $+__hub_func_replacement_done )) ||
     () {
       # At this stage in the shell's execution the "_git" function has not yet
       # been autoloaded, so the "_git_commands" or "__git_list_all_commands"
       # functions will not be defined.  Call it now (with a bogus no-op service
       # to prevent premature completion) so that we can wrap them.
       if declare -f _git >& /dev/null ; then
         _hub_noop () { __hub_zsh_provided=1 }       # zsh-provided will call this one
         __hub_noop_main () { __hub_git_provided=1 } # git-provided will call this one
         local service=hub_noop
         _git
         unfunction _hub_noop
         unfunction __hub_noop_main
         service=git
       fi
 
       if (( $__hub_zsh_provided )) ; then
         __hub_setup_zsh_fns
       elif (( $__hub_git_provided )) ; then
         __hub_setup_bash_fns
       fi
 
       __hub_func_replacement_done=1
     }
 
   # Now perform the actual completion, allowing the "_git" function to call our
   # replacement "_git_commands" function as needed.  Both versions expect
   # service=git or they will call nonexistent routines or end up in an infinite
   # loop.
   service=git
   declare -f _git >& /dev/null && _git
 }
 
 # make sure we actually attempt to complete on the first "tab" from the user
 _hub