Skip to content

Instantly share code, notes, and snippets.

@pahanix

pahanix/bashrc.sh

Forked from natikgadzhi/bashrc.sh
Created August 18, 2009 18:15
Download ZIP

Revisions

  1. railsmaniac revised this gist Jul 29, 2009. 2 changed files with 0 additions and 0 deletions.
    0 bashrc → bashrc.sh
    View file
    File renamed without changes.
    0 git-autocompletion → git-autocompletion.sh
    View file
    File renamed without changes.
  2. railsmaniac created this gist Jul 29, 2009.
    74 changes: 74 additions & 0 deletions bashrc
    View file
    Original file line number Diff line number Diff line change
    @@ -0,0 +1,74 @@
    #...
    # Nav
    alias l='ls -CF'

    ## Dev
    # Rails
    alias ss='script/server --debugger'
    alias sc='script/console --debugger'
    alias sg='script/generate'
    alias sd='script/destroy'
    export AUTOFEATURE=true
    alias at='autospec'
    alias rf='rake features'
    alias rs='rake spec'
    function rff {
    rake features FEATURE=features/"$1".feature
    }

    # Git shortcuts
    alias gs='git status; git submodule status'
    alias ga='git add'
    # alias gc='git commit -m' (See function below)
    alias gp='git pull $* && git push $*'
    alias gull='git pull'
    alias gush='git push'
    alias gsh='git show'
    alias gl='git log'
    alias gb='git branch'
    alias gco='git checkout'
    alias gd='git diff'
    alias gd1='echo "git diff HEAD"; git diff HEAD'
    alias gd2='echo "git diff HEAD^"; git diff HEAD^'
    alias grmall="git status | grep 'deleted:' | awk '{print \$3}' | xargs git rm -f"

    # on my macbook pro only 'h', 'l', 'w', 'x' are reserved
    alias s='gs'
    alias a='ga'
    alias c='gc'
    alias u='gull'
    alias p='gush'
    alias g='gl'
    alias b='gb'
    alias o='gco'
    alias d='gd'
    alias d1='gd1'
    alias d2='gd2'

    # Git submodule shortcuts

    alias gsa='git submodule add'
    alias gsu='git submodule update --init'

    # Git svn shortcuts
    alias gf='git svn fetch'
    alias gfr='git svn fetch && git svn rebase'
    alias gdc='git svn dcommit'
    alias gnc='git svn fetch && git svn rebase && git svn dcommit'
    alias gcn='git svn fetch && git svn rebase && git svn dcommit'

    # Usage:
    # gc 'bug is fixed' # non-interactive mode
    # gc # interactive mode
    # Commit message: bug is fixed
    #
    function gc {
    local commitmessage
    if [ "" = "$1" ]; then
    echo -n 'Commit message: '
    commitmessage="$(ruby -e "puts gets")"
    git commit -m "$commitmessage"
    else
    git commit -m "$1"
    fi
    }
    1,295 changes: 1,295 additions & 0 deletions git-autocompletion
    View file
    Original file line number Diff line number Diff line change
    @@ -0,0 +1,1295 @@
    #
    # bash completion support for core Git.
    #
    # Copyright (C) 2006,2007 Shawn O. Pearce <[email protected]>
    # Conceptually based on gitcompletion (http://gitweb.hawaga.org.uk/).
    # Distributed under the GNU General Public License, version 2.0.
    #
    # The contained completion routines provide support for completing:
    #
    # *) local and remote branch names
    # *) local and remote tag names
    # *) .git/remotes file names
    # *) git 'subcommands'
    # *) tree paths within 'ref:path/to/file' expressions
    # *) common --long-options
    #
    # To use these routines:
    #
    # 1) Copy this file to somewhere (e.g. ~/.git-completion.sh).
    # 2) Added the following line to your .bashrc:
    # source ~/.git-completion.sh
    #
    # 3) You may want to make sure the git executable is available
    # in your PATH before this script is sourced, as some caching
    # is performed while the script loads. If git isn't found
    # at source time then all lookups will be done on demand,
    # which may be slightly slower.
    #
    # 4) Consider changing your PS1 to also show the current branch:
    # PS1='[\u@\h \W$(__git_ps1 " (%s)")]\$ '
    #
    # The argument to __git_ps1 will be displayed only if you
    # are currently in a git repository. The %s token will be
    # the name of the current branch.
    #
    # To submit patches:
    #
    # *) Read Documentation/SubmittingPatches
    # *) Send all patches to the current maintainer:
    #
    # "Shawn O. Pearce" <[email protected]>
    #
    # *) Always CC the Git mailing list:
    #
    # [email protected]
    #

    __gitdir ()
    {
    if [ -z "$1" ]; then
    if [ -n "$__git_dir" ]; then
    echo "$__git_dir"
    elif [ -d .git ]; then
    echo .git
    else
    git rev-parse --git-dir 2>/dev/null
    fi
    elif [ -d "$1/.git" ]; then
    echo "$1/.git"
    else
    echo "$1"
    fi
    }

    __git_ps1 ()
    {
    local g="$(git rev-parse --git-dir 2>/dev/null)"
    if [ -n "$g" ]; then
    local r
    local b
    if [ -d "$g/../.dotest" ]
    then
    r="|AM/REBASE"
    b="$(git symbolic-ref HEAD 2>/dev/null)"
    elif [ -f "$g/.dotest-merge/interactive" ]
    then
    r="|REBASE-i"
    b="$(cat $g/.dotest-merge/head-name)"
    elif [ -d "$g/.dotest-merge" ]
    then
    r="|REBASE-m"
    b="$(cat $g/.dotest-merge/head-name)"
    elif [ -f "$g/MERGE_HEAD" ]
    then
    r="|MERGING"
    b="$(git symbolic-ref HEAD 2>/dev/null)"
    else
    if [ -f $g/BISECT_LOG ]
    then
    r="|BISECTING"
    fi
    if ! b="$(git symbolic-ref HEAD 2>/dev/null)"
    then
    b="$(cut -c1-7 $g/HEAD)..."
    fi
    fi

    if [ -n "$1" ]; then
    printf "$1" "${b##refs/heads/}$r"
    else
    printf " (%s)" "${b##refs/heads/}$r"
    fi
    fi
    }

    __gitcomp ()
    {
    local all c s=$'\n' IFS=' '$'\t'$'\n'
    local cur="${COMP_WORDS[COMP_CWORD]}"
    if [ $# -gt 2 ]; then
    cur="$3"
    fi
    for c in $1; do
    case "$c$4" in
    --*=*) all="$all$c$4$s" ;;
    *.) all="$all$c$4$s" ;;
    *) all="$all$c$4 $s" ;;
    esac
    done
    IFS=$s
    COMPREPLY=($(compgen -P "$2" -W "$all" -- "$cur"))
    return
    }

    __git_heads ()
    {
    local cmd i is_hash=y dir="$(__gitdir "$1")"
    if [ -d "$dir" ]; then
    for i in $(git --git-dir="$dir" \
    for-each-ref --format='%(refname)' \
    refs/heads ); do
    echo "${i#refs/heads/}"
    done
    return
    fi
    for i in $(git-ls-remote "$1" 2>/dev/null); do
    case "$is_hash,$i" in
    y,*) is_hash=n ;;
    n,*^{}) is_hash=y ;;
    n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
    n,*) is_hash=y; echo "$i" ;;
    esac
    done
    }

    __git_tags ()
    {
    local cmd i is_hash=y dir="$(__gitdir "$1")"
    if [ -d "$dir" ]; then
    for i in $(git --git-dir="$dir" \
    for-each-ref --format='%(refname)' \
    refs/tags ); do
    echo "${i#refs/tags/}"
    done
    return
    fi
    for i in $(git-ls-remote "$1" 2>/dev/null); do
    case "$is_hash,$i" in
    y,*) is_hash=n ;;
    n,*^{}) is_hash=y ;;
    n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
    n,*) is_hash=y; echo "$i" ;;
    esac
    done
    }

    __git_refs ()
    {
    local cmd i is_hash=y dir="$(__gitdir "$1")"
    if [ -d "$dir" ]; then
    if [ -e "$dir/HEAD" ]; then echo HEAD; fi
    for i in $(git --git-dir="$dir" \
    for-each-ref --format='%(refname)' \
    refs/tags refs/heads refs/remotes); do
    case "$i" in
    refs/tags/*) echo "${i#refs/tags/}" ;;
    refs/heads/*) echo "${i#refs/heads/}" ;;
    refs/remotes/*) echo "${i#refs/remotes/}" ;;
    *) echo "$i" ;;
    esac
    done
    return
    fi
    for i in $(git-ls-remote "$dir" 2>/dev/null); do
    case "$is_hash,$i" in
    y,*) is_hash=n ;;
    n,*^{}) is_hash=y ;;
    n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
    n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
    n,refs/remotes/*) is_hash=y; echo "${i#refs/remotes/}" ;;
    n,*) is_hash=y; echo "$i" ;;
    esac
    done
    }

    __git_refs2 ()
    {
    local i
    for i in $(__git_refs "$1"); do
    echo "$i:$i"
    done
    }

    __git_refs_remotes ()
    {
    local cmd i is_hash=y
    for i in $(git-ls-remote "$1" 2>/dev/null); do
    case "$is_hash,$i" in
    n,refs/heads/*)
    is_hash=y
    echo "$i:refs/remotes/$1/${i#refs/heads/}"
    ;;
    y,*) is_hash=n ;;
    n,*^{}) is_hash=y ;;
    n,refs/tags/*) is_hash=y;;
    n,*) is_hash=y; ;;
    esac
    done
    }

    __git_remotes ()
    {
    local i ngoff IFS=$'\n' d="$(__gitdir)"
    shopt -q nullglob || ngoff=1
    shopt -s nullglob
    for i in "$d/remotes"/*; do
    echo ${i#$d/remotes/}
    done
    [ "$ngoff" ] && shopt -u nullglob
    for i in $(git --git-dir="$d" config --list); do
    case "$i" in
    remote.*.url=*)
    i="${i#remote.}"
    echo "${i/.url=*/}"
    ;;
    esac
    done
    }

    __git_merge_strategies ()
    {
    if [ -n "$__git_merge_strategylist" ]; then
    echo "$__git_merge_strategylist"
    return
    fi
    sed -n "/^all_strategies='/{
    s/^all_strategies='//
    s/'//
    p
    q
    }" "$(git --exec-path)/git-merge"
    }
    __git_merge_strategylist=
    __git_merge_strategylist="$(__git_merge_strategies 2>/dev/null)"

    __git_complete_file ()
    {
    local pfx ls ref cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    ?*:*)
    ref="${cur%%:*}"
    cur="${cur#*:}"
    case "$cur" in
    ?*/*)
    pfx="${cur%/*}"
    cur="${cur##*/}"
    ls="$ref:$pfx"
    pfx="$pfx/"
    ;;
    *)
    ls="$ref"
    ;;
    esac
    COMPREPLY=($(compgen -P "$pfx" \
    -W "$(git --git-dir="$(__gitdir)" ls-tree "$ls" \
    | sed '/^100... blob /s,^.* ,,
    /^040000 tree /{
    s,^.* ,,
    s,$,/,
    }
    s/^.* //')" \
    -- "$cur"))
    ;;
    *)
    __gitcomp "$(__git_refs)"
    ;;
    esac
    }

    __git_complete_revlist ()
    {
    local pfx cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    *...*)
    pfx="${cur%...*}..."
    cur="${cur#*...}"
    __gitcomp "$(__git_refs)" "$pfx" "$cur"
    ;;
    *..*)
    pfx="${cur%..*}.."
    cur="${cur#*..}"
    __gitcomp "$(__git_refs)" "$pfx" "$cur"
    ;;
    *.)
    __gitcomp "$cur."
    ;;
    *)
    __gitcomp "$(__git_refs)"
    ;;
    esac
    }

    __git_commands ()
    {
    if [ -n "$__git_commandlist" ]; then
    echo "$__git_commandlist"
    return
    fi
    local i IFS=" "$'\n'
    for i in $(git help -a|egrep '^ ')
    do
    case $i in
    *--*) : helper pattern;;
    applymbox) : ask gittus;;
    applypatch) : ask gittus;;
    archimport) : import;;
    cat-file) : plumbing;;
    check-attr) : plumbing;;
    check-ref-format) : plumbing;;
    commit-tree) : plumbing;;
    cvsexportcommit) : export;;
    cvsimport) : import;;
    cvsserver) : daemon;;
    daemon) : daemon;;
    diff-files) : plumbing;;
    diff-index) : plumbing;;
    diff-tree) : plumbing;;
    fast-import) : import;;
    fsck-objects) : plumbing;;
    fetch-pack) : plumbing;;
    fmt-merge-msg) : plumbing;;
    for-each-ref) : plumbing;;
    hash-object) : plumbing;;
    http-*) : transport;;
    index-pack) : plumbing;;
    init-db) : deprecated;;
    local-fetch) : plumbing;;
    mailinfo) : plumbing;;
    mailsplit) : plumbing;;
    merge-*) : plumbing;;
    mktree) : plumbing;;
    mktag) : plumbing;;
    pack-objects) : plumbing;;
    pack-redundant) : plumbing;;
    pack-refs) : plumbing;;
    parse-remote) : plumbing;;
    patch-id) : plumbing;;
    peek-remote) : plumbing;;
    prune) : plumbing;;
    prune-packed) : plumbing;;
    quiltimport) : import;;
    read-tree) : plumbing;;
    receive-pack) : plumbing;;
    reflog) : plumbing;;
    repo-config) : deprecated;;
    rerere) : plumbing;;
    rev-list) : plumbing;;
    rev-parse) : plumbing;;
    runstatus) : plumbing;;
    sh-setup) : internal;;
    shell) : daemon;;
    send-pack) : plumbing;;
    show-index) : plumbing;;
    ssh-*) : transport;;
    stripspace) : plumbing;;
    svn) : import export;;
    symbolic-ref) : plumbing;;
    tar-tree) : deprecated;;
    unpack-file) : plumbing;;
    unpack-objects) : plumbing;;
    update-index) : plumbing;;
    update-ref) : plumbing;;
    update-server-info) : daemon;;
    upload-archive) : plumbing;;
    upload-pack) : plumbing;;
    write-tree) : plumbing;;
    verify-tag) : plumbing;;
    *) echo $i;;
    esac
    done
    }
    __git_commandlist=
    __git_commandlist="$(__git_commands 2>/dev/null)"

    __git_aliases ()
    {
    local i IFS=$'\n'
    for i in $(git --git-dir="$(__gitdir)" config --list); do
    case "$i" in
    alias.*)
    i="${i#alias.}"
    echo "${i/=*/}"
    ;;
    esac
    done
    }

    __git_aliased_command ()
    {
    local word cmdline=$(git --git-dir="$(__gitdir)" \
    config --get "alias.$1")
    for word in $cmdline; do
    if [ "${word##-*}" ]; then
    echo $word
    return
    fi
    done
    }

    __git_whitespacelist="nowarn warn error error-all strip"

    _git_am ()
    {
    local cur="${COMP_WORDS[COMP_CWORD]}"
    if [ -d .dotest ]; then
    __gitcomp "--skip --resolved"
    return
    fi
    case "$cur" in
    --whitespace=*)
    __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
    return
    ;;
    --*)
    __gitcomp "
    --signoff --utf8 --binary --3way --interactive
    --whitespace=
    "
    return
    esac
    COMPREPLY=()
    }

    _git_apply ()
    {
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --whitespace=*)
    __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
    return
    ;;
    --*)
    __gitcomp "
    --stat --numstat --summary --check --index
    --cached --index-info --reverse --reject --unidiff-zero
    --apply --no-add --exclude=
    --whitespace= --inaccurate-eof --verbose
    "
    return
    esac
    COMPREPLY=()
    }

    _git_add ()
    {
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --*)
    __gitcomp "--interactive --refresh"
    return
    esac
    COMPREPLY=()
    }

    _git_bisect ()
    {
    local i c=1 command
    while [ $c -lt $COMP_CWORD ]; do
    i="${COMP_WORDS[c]}"
    case "$i" in
    start|bad|good|reset|visualize|replay|log)
    command="$i"
    break
    ;;
    esac
    c=$((++c))
    done

    if [ $c -eq $COMP_CWORD -a -z "$command" ]; then
    __gitcomp "start bad good reset visualize replay log"
    return
    fi

    case "$command" in
    bad|good|reset)
    __gitcomp "$(__git_refs)"
    ;;
    *)
    COMPREPLY=()
    ;;
    esac
    }

    _git_branch ()
    {
    __gitcomp "$(__git_refs)"
    }

    _git_bundle ()
    {
    local mycword="$COMP_CWORD"
    case "${COMP_WORDS[0]}" in
    git)
    local cmd="${COMP_WORDS[2]}"
    mycword="$((mycword-1))"
    ;;
    git-bundle*)
    local cmd="${COMP_WORDS[1]}"
    ;;
    esac
    case "$mycword" in
    1)
    __gitcomp "create list-heads verify unbundle"
    ;;
    2)
    # looking for a file
    ;;
    *)
    case "$cmd" in
    create)
    __git_complete_revlist
    ;;
    esac
    ;;
    esac
    }

    _git_checkout ()
    {
    __gitcomp "$(__git_refs)"
    }

    _git_cherry ()
    {
    __gitcomp "$(__git_refs)"
    }

    _git_cherry_pick ()
    {
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --*)
    __gitcomp "--edit --no-commit"
    ;;
    *)
    __gitcomp "$(__git_refs)"
    ;;
    esac
    }

    _git_commit ()
    {
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --*)
    __gitcomp "
    --all --author= --signoff --verify --no-verify
    --edit --amend --include --only
    "
    return
    esac
    COMPREPLY=()
    }

    _git_describe ()
    {
    __gitcomp "$(__git_refs)"
    }

    _git_diff ()
    {
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --*)
    __gitcomp "--cached --stat --numstat --shortstat --summary
    --patch-with-stat --name-only --name-status --color
    --no-color --color-words --no-renames --check
    --full-index --binary --abbrev --diff-filter
    --find-copies-harder --pickaxe-all --pickaxe-regex
    --text --ignore-space-at-eol --ignore-space-change
    --ignore-all-space --exit-code --quiet --ext-diff
    --no-ext-diff"
    return
    ;;
    esac
    __git_complete_file
    }

    _git_diff_tree ()
    {
    __gitcomp "$(__git_refs)"
    }

    _git_fetch ()
    {
    local cur="${COMP_WORDS[COMP_CWORD]}"

    case "${COMP_WORDS[0]},$COMP_CWORD" in
    git-fetch*,1)
    __gitcomp "$(__git_remotes)"
    ;;
    git,2)
    __gitcomp "$(__git_remotes)"
    ;;
    *)
    case "$cur" in
    *:*)
    __gitcomp "$(__git_refs)" "" "${cur#*:}"
    ;;
    *)
    local remote
    case "${COMP_WORDS[0]}" in
    git-fetch) remote="${COMP_WORDS[1]}" ;;
    git) remote="${COMP_WORDS[2]}" ;;
    esac
    __gitcomp "$(__git_refs2 "$remote")"
    ;;
    esac
    ;;
    esac
    }

    _git_format_patch ()
    {
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --*)
    __gitcomp "
    --stdout --attach --thread
    --output-directory
    --numbered --start-number
    --numbered-files
    --keep-subject
    --signoff
    --in-reply-to=
    --full-index --binary
    --not --all
    "
    return
    ;;
    esac
    __git_complete_revlist
    }

    _git_gc ()
    {
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --*)
    __gitcomp "--prune --aggressive"
    return
    ;;
    esac
    COMPREPLY=()
    }

    _git_ls_remote ()
    {
    __gitcomp "$(__git_remotes)"
    }

    _git_ls_tree ()
    {
    __git_complete_file
    }

    _git_log ()
    {
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --pretty=*)
    __gitcomp "
    oneline short medium full fuller email raw
    " "" "${cur##--pretty=}"
    return
    ;;
    --date=*)
    __gitcomp "
    relative iso8601 rfc2822 short local default
    " "" "${cur##--date=}"
    return
    ;;
    --*)
    __gitcomp "
    --max-count= --max-age= --since= --after=
    --min-age= --before= --until=
    --root --topo-order --date-order --reverse
    --no-merges --follow
    --abbrev-commit --abbrev=
    --relative-date --date=
    --author= --committer= --grep=
    --all-match
    --pretty= --name-status --name-only --raw
    --not --all
    --left-right --cherry-pick
    "
    return
    ;;
    esac
    __git_complete_revlist
    }

    _git_merge ()
    {
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "${COMP_WORDS[COMP_CWORD-1]}" in
    -s|--strategy)
    __gitcomp "$(__git_merge_strategies)"
    return
    esac
    case "$cur" in
    --strategy=*)
    __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
    return
    ;;
    --*)
    __gitcomp "
    --no-commit --no-summary --squash --strategy
    "
    return
    esac
    __gitcomp "$(__git_refs)"
    }

    _git_merge_base ()
    {
    __gitcomp "$(__git_refs)"
    }

    _git_name_rev ()
    {
    __gitcomp "--tags --all --stdin"
    }

    _git_pull ()
    {
    local cur="${COMP_WORDS[COMP_CWORD]}"

    case "${COMP_WORDS[0]},$COMP_CWORD" in
    git-pull*,1)
    __gitcomp "$(__git_remotes)"
    ;;
    git,2)
    __gitcomp "$(__git_remotes)"
    ;;
    *)
    local remote
    case "${COMP_WORDS[0]}" in
    git-pull) remote="${COMP_WORDS[1]}" ;;
    git) remote="${COMP_WORDS[2]}" ;;
    esac
    __gitcomp "$(__git_refs "$remote")"
    ;;
    esac
    }

    _git_push ()
    {
    local cur="${COMP_WORDS[COMP_CWORD]}"

    case "${COMP_WORDS[0]},$COMP_CWORD" in
    git-push*,1)
    __gitcomp "$(__git_remotes)"
    ;;
    git,2)
    __gitcomp "$(__git_remotes)"
    ;;
    *)
    case "$cur" in
    *:*)
    local remote
    case "${COMP_WORDS[0]}" in
    git-push) remote="${COMP_WORDS[1]}" ;;
    git) remote="${COMP_WORDS[2]}" ;;
    esac
    __gitcomp "$(__git_refs "$remote")" "" "${cur#*:}"
    ;;
    +*)
    __gitcomp "$(__git_refs)" + "${cur#+}"
    ;;
    *)
    __gitcomp "$(__git_refs)"
    ;;
    esac
    ;;
    esac
    }

    _git_rebase ()
    {
    local cur="${COMP_WORDS[COMP_CWORD]}"
    if [ -d .dotest ] || [ -d .git/.dotest-merge ]; then
    __gitcomp "--continue --skip --abort"
    return
    fi
    case "${COMP_WORDS[COMP_CWORD-1]}" in
    -s|--strategy)
    __gitcomp "$(__git_merge_strategies)"
    return
    esac
    case "$cur" in
    --strategy=*)
    __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
    return
    ;;
    --*)
    __gitcomp "--onto --merge --strategy"
    return
    esac
    __gitcomp "$(__git_refs)"
    }

    _git_config ()
    {
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prv="${COMP_WORDS[COMP_CWORD-1]}"
    case "$prv" in
    branch.*.remote)
    __gitcomp "$(__git_remotes)"
    return
    ;;
    branch.*.merge)
    __gitcomp "$(__git_refs)"
    return
    ;;
    remote.*.fetch)
    local remote="${prv#remote.}"
    remote="${remote%.fetch}"
    __gitcomp "$(__git_refs_remotes "$remote")"
    return
    ;;
    remote.*.push)
    local remote="${prv#remote.}"
    remote="${remote%.push}"
    __gitcomp "$(git --git-dir="$(__gitdir)" \
    for-each-ref --format='%(refname):%(refname)' \
    refs/heads)"
    return
    ;;
    pull.twohead|pull.octopus)
    __gitcomp "$(__git_merge_strategies)"
    return
    ;;
    color.branch|color.diff|color.status)
    __gitcomp "always never auto"
    return
    ;;
    color.*.*)
    __gitcomp "
    black red green yellow blue magenta cyan white
    bold dim ul blink reverse
    "
    return
    ;;
    *.*)
    COMPREPLY=()
    return
    ;;
    esac
    case "$cur" in
    --*)
    __gitcomp "
    --global --system --file=
    --list --replace-all
    --get --get-all --get-regexp
    --add --unset --unset-all
    --remove-section --rename-section
    "
    return
    ;;
    branch.*.*)
    local pfx="${cur%.*}."
    cur="${cur##*.}"
    __gitcomp "remote merge" "$pfx" "$cur"
    return
    ;;
    branch.*)
    local pfx="${cur%.*}."
    cur="${cur#*.}"
    __gitcomp "$(__git_heads)" "$pfx" "$cur" "."
    return
    ;;
    remote.*.*)
    local pfx="${cur%.*}."
    cur="${cur##*.}"
    __gitcomp "
    url fetch push skipDefaultUpdate
    receivepack uploadpack tagopt
    " "$pfx" "$cur"
    return
    ;;
    remote.*)
    local pfx="${cur%.*}."
    cur="${cur#*.}"
    __gitcomp "$(__git_remotes)" "$pfx" "$cur" "."
    return
    ;;
    esac
    __gitcomp "
    apply.whitespace
    core.fileMode
    core.gitProxy
    core.ignoreStat
    core.preferSymlinkRefs
    core.logAllRefUpdates
    core.loosecompression
    core.repositoryFormatVersion
    core.sharedRepository
    core.warnAmbiguousRefs
    core.compression
    core.legacyHeaders
    core.packedGitWindowSize
    core.packedGitLimit
    clean.requireForce
    color.branch
    color.branch.current
    color.branch.local
    color.branch.remote
    color.branch.plain
    color.diff
    color.diff.plain
    color.diff.meta
    color.diff.frag
    color.diff.old
    color.diff.new
    color.diff.commit
    color.diff.whitespace
    color.pager
    color.status
    color.status.header
    color.status.added
    color.status.changed
    color.status.untracked
    diff.renameLimit
    diff.renames
    fetch.unpackLimit
    format.headers
    format.subjectprefix
    gitcvs.enabled
    gitcvs.logfile
    gitcvs.allbinary
    gitcvs.dbname gitcvs.dbdriver gitcvs.dbuser gitcvs.dvpass
    gc.packrefs
    gc.reflogexpire
    gc.reflogexpireunreachable
    gc.rerereresolved
    gc.rerereunresolved
    http.sslVerify
    http.sslCert
    http.sslKey
    http.sslCAInfo
    http.sslCAPath
    http.maxRequests
    http.lowSpeedLimit
    http.lowSpeedTime
    http.noEPSV
    i18n.commitEncoding
    i18n.logOutputEncoding
    log.showroot
    merge.tool
    merge.summary
    merge.verbosity
    pack.window
    pack.depth
    pack.windowMemory
    pack.compression
    pack.deltaCacheSize
    pack.deltaCacheLimit
    pull.octopus
    pull.twohead
    repack.useDeltaBaseOffset
    show.difftree
    showbranch.default
    tar.umask
    transfer.unpackLimit
    receive.unpackLimit
    receive.denyNonFastForwards
    user.name
    user.email
    user.signingkey
    whatchanged.difftree
    branch. remote.
    "
    }

    _git_remote ()
    {
    local i c=1 command
    while [ $c -lt $COMP_CWORD ]; do
    i="${COMP_WORDS[c]}"
    case "$i" in
    add|rm|show|prune|update) command="$i"; break ;;
    esac
    c=$((++c))
    done

    if [ $c -eq $COMP_CWORD -a -z "$command" ]; then
    __gitcomp "add rm show prune update"
    return
    fi

    case "$command" in
    rm|show|prune)
    __gitcomp "$(__git_remotes)"
    ;;
    update)
    local i c='' IFS=$'\n'
    for i in $(git --git-dir="$(__gitdir)" config --list); do
    case "$i" in
    remotes.*)
    i="${i#remotes.}"
    c="$c ${i/=*/}"
    ;;
    esac
    done
    __gitcomp "$c"
    ;;
    *)
    COMPREPLY=()
    ;;
    esac
    }

    _git_reset ()
    {
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --*)
    __gitcomp "--mixed --hard --soft"
    return
    ;;
    esac
    __gitcomp "$(__git_refs)"
    }

    _git_shortlog ()
    {
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --*)
    __gitcomp "
    --max-count= --max-age= --since= --after=
    --min-age= --before= --until=
    --no-merges
    --author= --committer= --grep=
    --all-match
    --not --all
    --numbered --summary
    "
    return
    ;;
    esac
    __git_complete_revlist
    }

    _git_show ()
    {
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --pretty=*)
    __gitcomp "
    oneline short medium full fuller email raw
    " "" "${cur##--pretty=}"
    return
    ;;
    --*)
    __gitcomp "--pretty="
    return
    ;;
    esac
    __git_complete_file
    }

    _git_stash ()
    {
    __gitcomp 'list show apply clear'
    }

    _git_submodule ()
    {
    local i c=1 command
    while [ $c -lt $COMP_CWORD ]; do
    i="${COMP_WORDS[c]}"
    case "$i" in
    add|status|init|update) command="$i"; break ;;
    esac
    c=$((++c))
    done

    if [ $c -eq $COMP_CWORD -a -z "$command" ]; then
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --*)
    __gitcomp "--quiet --cached"
    ;;
    *)
    __gitcomp "add status init update"
    ;;
    esac
    return
    fi
    }

    _git_tag ()
    {
    local i c=1 f=0
    while [ $c -lt $COMP_CWORD ]; do
    i="${COMP_WORDS[c]}"
    case "$i" in
    -d|-v)
    __gitcomp "$(__git_tags)"
    return
    ;;
    -f)
    f=1
    ;;
    esac
    c=$((++c))
    done

    case "${COMP_WORDS[COMP_CWORD-1]}" in
    -m|-F)
    COMPREPLY=()
    ;;
    -*|tag|git-tag)
    if [ $f = 1 ]; then
    __gitcomp "$(__git_tags)"
    else
    COMPREPLY=()
    fi
    ;;
    *)
    __gitcomp "$(__git_refs)"
    ;;
    esac
    }

    _git ()
    {
    local i c=1 command __git_dir

    while [ $c -lt $COMP_CWORD ]; do
    i="${COMP_WORDS[c]}"
    case "$i" in
    --git-dir=*) __git_dir="${i#--git-dir=}" ;;
    --bare) __git_dir="." ;;
    --version|--help|-p|--paginate) ;;
    *) command="$i"; break ;;
    esac
    c=$((++c))
    done

    if [ $c -eq $COMP_CWORD -a -z "$command" ]; then
    case "${COMP_WORDS[COMP_CWORD]}" in
    --*=*) COMPREPLY=() ;;
    --*) __gitcomp "
    --no-pager
    --git-dir=
    --bare
    --version
    --exec-path
    "
    ;;
    *) __gitcomp "$(__git_commands) $(__git_aliases)" ;;
    esac
    return
    fi

    local expansion=$(__git_aliased_command "$command")
    [ "$expansion" ] && command="$expansion"

    case "$command" in
    am) _git_am ;;
    add) _git_add ;;
    apply) _git_apply ;;
    bisect) _git_bisect ;;
    bundle) _git_bundle ;;
    branch) _git_branch ;;
    checkout) _git_checkout ;;
    cherry) _git_cherry ;;
    cherry-pick) _git_cherry_pick ;;
    commit) _git_commit ;;
    config) _git_config ;;
    describe) _git_describe ;;
    diff) _git_diff ;;
    fetch) _git_fetch ;;
    format-patch) _git_format_patch ;;
    gc) _git_gc ;;
    log) _git_log ;;
    ls-remote) _git_ls_remote ;;
    ls-tree) _git_ls_tree ;;
    merge) _git_merge;;
    merge-base) _git_merge_base ;;
    name-rev) _git_name_rev ;;
    pull) _git_pull ;;
    push) _git_push ;;
    rebase) _git_rebase ;;
    remote) _git_remote ;;
    reset) _git_reset ;;
    shortlog) _git_shortlog ;;
    show) _git_show ;;
    show-branch) _git_log ;;
    stash) _git_stash ;;
    submodule) _git_submodule ;;
    tag) _git_tag ;;
    whatchanged) _git_log ;;
    *) COMPREPLY=() ;;
    esac
    }

    _gitk ()
    {
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --*)
    __gitcomp "--not --all"
    return
    ;;
    esac
    __git_complete_revlist
    }

    complete -o default -o nospace -F _git git
    complete -o default -o nospace -F _gitk gitk
    complete -o default -o nospace -F _git_am git-am
    complete -o default -o nospace -F _git_apply git-apply
    complete -o default -o nospace -F _git_bisect git-bisect
    complete -o default -o nospace -F _git_branch git-branch
    complete -o default -o nospace -F _git_bundle git-bundle
    complete -o default -o nospace -F _git_checkout git-checkout
    complete -o default -o nospace -F _git_cherry git-cherry
    complete -o default -o nospace -F _git_cherry_pick git-cherry-pick
    complete -o default -o nospace -F _git_commit git-commit
    complete -o default -o nospace -F _git_describe git-describe
    complete -o default -o nospace -F _git_diff git-diff
    complete -o default -o nospace -F _git_fetch git-fetch
    complete -o default -o nospace -F _git_format_patch git-format-patch
    complete -o default -o nospace -F _git_gc git-gc
    complete -o default -o nospace -F _git_log git-log
    complete -o default -o nospace -F _git_ls_remote git-ls-remote
    complete -o default -o nospace -F _git_ls_tree git-ls-tree
    complete -o default -o nospace -F _git_merge git-merge
    complete -o default -o nospace -F _git_merge_base git-merge-base
    complete -o default -o nospace -F _git_name_rev git-name-rev
    complete -o default -o nospace -F _git_pull git-pull
    complete -o default -o nospace -F _git_push git-push
    complete -o default -o nospace -F _git_rebase git-rebase
    complete -o default -o nospace -F _git_config git-config
    complete -o default -o nospace -F _git_remote git-remote
    complete -o default -o nospace -F _git_reset git-reset
    complete -o default -o nospace -F _git_shortlog git-shortlog
    complete -o default -o nospace -F _git_show git-show
    complete -o default -o nospace -F _git_stash git-stash
    complete -o default -o nospace -F _git_submodule git-submodule
    complete -o default -o nospace -F _git_log git-show-branch
    complete -o default -o nospace -F _git_tag git-tag
    complete -o default -o nospace -F _git_log git-whatchanged

    # The following are necessary only for Cygwin, and only are needed
    # when the user has tab-completed the executable name and consequently
    # included the '.exe' suffix.
    #
    if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
    complete -o default -o nospace -F _git_add git-add.exe
    complete -o default -o nospace -F _git_apply git-apply.exe
    complete -o default -o nospace -F _git git.exe
    complete -o default -o nospace -F _git_branch git-branch.exe
    complete -o default -o nospace -F _git_bundle git-bundle.exe
    complete -o default -o nospace -F _git_cherry git-cherry.exe
    complete -o default -o nospace -F _git_describe git-describe.exe
    complete -o default -o nospace -F _git_diff git-diff.exe
    complete -o default -o nospace -F _git_format_patch git-format-patch.exe
    complete -o default -o nospace -F _git_log git-log.exe
    complete -o default -o nospace -F _git_ls_tree git-ls-tree.exe
    complete -o default -o nospace -F _git_merge_base git-merge-base.exe
    complete -o default -o nospace -F _git_name_rev git-name-rev.exe
    complete -o default -o nospace -F _git_push git-push.exe
    complete -o default -o nospace -F _git_config git-config
    complete -o default -o nospace -F _git_shortlog git-shortlog.exe
    complete -o default -o nospace -F _git_show git-show.exe
    complete -o default -o nospace -F _git_log git-show-branch.exe
    complete -o default -o nospace -F _git_tag git-tag.exe
    complete -o default -o nospace -F _git_log git-whatchanged.exe
    fi